Added Graphy

Assets/Handlers/EnemyHandler.cs

@@ -7,8 +7,6 @@ namespace AsteroidGame.Handlers
     public class EnemyHandler : HandlerBase
     {
         [Header("Parameters")]
-        [SerializeField] [Range(0.1f, 60f)] private float _spawnRate = 60f;
-        [SerializeField] private int _objectPoolSize = 15;
 
         [Header("Configuration")]
         [SerializeField] private SoEnemyBaseList _availableEnemies;

Assets/Plugins.meta

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

Assets/Plugins/Graphy.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 2b771290a9ed1614fbc5a745ef7ba669
+folderAsset: yes
+timeCreated: 1514034907
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Editor.meta

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

Assets/Plugins/Graphy/Editor/GraphyDebuggerEditor.cs

@@ -0,0 +1,578 @@
+/* ---------------------------------------
+ * Author:          Martin Pane (martintayx@gmail.com) (@tayx94)
+ * Contributors:    https://github.com/Tayx94/graphy/graphs/contributors
+ * Project:         Graphy - Ultimate Stats Monitor
+ * Date:            02-Jan-18
+ * Studio:          Tayx
+ *
+ * Git repo:        https://github.com/Tayx94/graphy
+ *
+ * This project is released under the MIT license.
+ * Attribution is not required, but it is always welcomed!
+ * -------------------------------------*/
+
+using System;
+using UnityEngine;
+using System.Collections.Generic;
+using System.IO;
+using UnityEditor;
+
+namespace Tayx.Graphy
+{
+    [CustomEditor( typeof( GraphyDebugger ) )]
+    internal class GraphyDebuggerEditor : Editor
+    {
+        #region Variables -> Private
+
+        private GraphyDebugger m_target;
+
+        private int m_newDebugPacketListSize = 0;
+
+        private int m_previouslySelectedDebugPacketIndex = 0;
+        private int m_currentlySelectedDebugPacketIndex = 0;
+
+        private int m_selectedDebugPacketCondition = 0;
+
+        #endregion
+
+        #region Methods -> Unity Callbacks
+
+        private void OnEnable()
+        {
+            m_target = (GraphyDebugger) target;
+        }
+
+        #endregion
+
+        #region Methods -> Public Override
+
+        public override void OnInspectorGUI()
+        {
+            if( m_target == null && target == null )
+            {
+                base.OnInspectorGUI();
+
+                return;
+            }
+
+            float defaultLabelWidth = EditorGUIUtility.labelWidth;
+            float defaultFieldWidth = EditorGUIUtility.fieldWidth;
+
+            //===== CONTENT REGION ========================================================================
+
+            GUILayout.Space( 20 );
+
+            #region Section -> Logo
+
+            if( GraphyEditorStyle.DebuggerLogoTexture != null )
+            {
+                GUILayout.Label
+                (
+                    image: GraphyEditorStyle.DebuggerLogoTexture,
+                    style: new GUIStyle( GUI.skin.GetStyle( "Label" ) )
+                    {
+                        alignment = TextAnchor.UpperCenter
+                    }
+                );
+
+                GUILayout.Space( 10 );
+            }
+            else
+            {
+                EditorGUILayout.LabelField
+                (
+                    label: "[ GRAPHY - DEBUGGER ]",
+                    style: GraphyEditorStyle.HeaderStyle1
+                );
+            }
+
+            #endregion
+
+            GUILayout.Space( 5 ); //Extra pixels added when the logo is used.
+
+            #region Section -> Settings
+
+            SerializedObject serObj = serializedObject;
+
+            SerializedProperty
+                debugPacketList =
+                    serObj.FindProperty( "m_debugPackets" ); // Find the List in our script and create a refrence of it
+
+            //Update our list
+            serObj.Update();
+
+            EditorGUILayout.LabelField( "Current [Debug Packets] list size: " + debugPacketList.arraySize );
+
+            EditorGUIUtility.fieldWidth = 32;
+            EditorGUILayout.BeginHorizontal();
+
+
+            m_newDebugPacketListSize = EditorGUILayout.IntField
+            (
+                label: "Define a new list size",
+                value: m_newDebugPacketListSize
+            );
+
+            if( GUILayout.Button( "Resize List" ) )
+            {
+                if( EditorUtility.DisplayDialog
+                    (
+                        title:
+                        "Resize List",
+                        message:
+                        "Are you sure you want to resize the entire List?\n\n" +
+                        "Current List Size -> " +
+                        debugPacketList.arraySize +
+                        "\n" +
+                        "New List Size -> " +
+                        m_newDebugPacketListSize +
+                        "\n" +
+                        "This will add default entries if the value is greater than the list size, or erase the bottom values until the new size specified.",
+                        ok:
+                        "Resize",
+                        cancel:
+                        "Cancel" )
+                )
+                {
+                    m_currentlySelectedDebugPacketIndex = 0;
+
+                    if( m_newDebugPacketListSize != debugPacketList.arraySize )
+                    {
+                        while( m_newDebugPacketListSize > debugPacketList.arraySize )
+                        {
+                            debugPacketList.InsertArrayElementAtIndex( debugPacketList.arraySize );
+                            SetDefaultDebugPacketValues( debugPacketList );
+                        }
+
+                        while( m_newDebugPacketListSize < debugPacketList.arraySize )
+                        {
+                            debugPacketList.DeleteArrayElementAtIndex( debugPacketList.arraySize - 1 );
+                        }
+                    }
+                }
+            }
+
+            EditorGUILayout.EndHorizontal();
+
+            EditorGUILayout.LabelField( "NOT RECOMMENDED (Only use for first initialization)",
+                EditorStyles.centeredGreyMiniLabel );
+
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+
+            if( debugPacketList.arraySize < 1 )
+            {
+                m_previouslySelectedDebugPacketIndex = 0;
+                m_currentlySelectedDebugPacketIndex = 0;
+                m_selectedDebugPacketCondition = 0;
+
+                serializedObject.ApplyModifiedProperties();
+                return;
+            }
+
+            GraphyEditorStyle.HeaderStyle2.contentOffset = Vector2.down * 3f;
+
+            EditorGUILayout.LabelField( "Selected debug packet:" );
+
+            EditorGUILayout.BeginHorizontal();
+
+            List<string> debugPacketNames = new List<string>();
+            for( int i = 0; i < debugPacketList.arraySize; i++ )
+            {
+                SerializedProperty listItem = debugPacketList.GetArrayElementAtIndex( i );
+                // NOTE: If the Popup detects two equal strings, it just paints 1, that's why I always add the "i"
+                char checkMark = listItem.FindPropertyRelative( "Active" ).boolValue ? '\u2714' : '\u2718';
+                debugPacketNames.Add
+                (
+                    (i + 1) +
+                    " (" +
+                    checkMark +
+                    ") " +
+                    " - ID: " +
+                    listItem.FindPropertyRelative( "Id" ).intValue +
+                    " (Conditions: " +
+                    listItem.FindPropertyRelative( "DebugConditions" ).arraySize +
+                    ")"
+                );
+            }
+
+            m_currentlySelectedDebugPacketIndex =
+                EditorGUILayout.Popup( m_currentlySelectedDebugPacketIndex, debugPacketNames.ToArray() );
+
+            if( m_currentlySelectedDebugPacketIndex != m_previouslySelectedDebugPacketIndex )
+            {
+                m_selectedDebugPacketCondition = 0;
+
+                m_previouslySelectedDebugPacketIndex = m_currentlySelectedDebugPacketIndex;
+            }
+
+            Color defaultGUIColor = GUI.color;
+
+            GUI.color = new Color( 0.7f, 1f, 0.0f, 1f );
+
+            //Or add a new item to the List<> with a button
+
+            if( GUILayout.Button( "Add", GUILayout.Width( 60 ) ) )
+            {
+                debugPacketList.InsertArrayElementAtIndex( debugPacketList.arraySize );
+                SetDefaultDebugPacketValues( debugPacketList );
+            }
+
+            GUI.color = new Color( 1f, 0.7f, 0.0f, 1f );
+
+            //Remove this index from the List
+
+            if( GUILayout.Button( "Remove", GUILayout.Width( 60 ) ) )
+            {
+                debugPacketList.DeleteArrayElementAtIndex( m_currentlySelectedDebugPacketIndex );
+                if( m_currentlySelectedDebugPacketIndex > 0 )
+                {
+                    m_currentlySelectedDebugPacketIndex--;
+                }
+
+                if( debugPacketList.arraySize < 1 )
+                {
+                    serializedObject.ApplyModifiedProperties();
+                    return;
+                }
+            }
+
+            GUI.color = defaultGUIColor;
+
+            EditorGUILayout.EndHorizontal();
+
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+
+            //Display our list to the inspector window
+
+            SerializedProperty listItemSelected =
+                debugPacketList.GetArrayElementAtIndex( m_currentlySelectedDebugPacketIndex );
+
+            SerializedProperty Active = listItemSelected.FindPropertyRelative( "Active" );
+            SerializedProperty Id = listItemSelected.FindPropertyRelative( "Id" );
+            SerializedProperty ExecuteOnce = listItemSelected.FindPropertyRelative( "ExecuteOnce" );
+            SerializedProperty InitSleepTime = listItemSelected.FindPropertyRelative( "InitSleepTime" );
+            SerializedProperty ExecuteSleepTime = listItemSelected.FindPropertyRelative( "ExecuteSleepTime" );
+            SerializedProperty ConditionEvaluation = listItemSelected.FindPropertyRelative( "ConditionEvaluation" );
+            SerializedProperty DebugConditions = listItemSelected.FindPropertyRelative( "DebugConditions" );
+            SerializedProperty MessageType = listItemSelected.FindPropertyRelative( "MessageType" );
+            SerializedProperty Message = listItemSelected.FindPropertyRelative( "Message" );
+            SerializedProperty TakeScreenshot = listItemSelected.FindPropertyRelative( "TakeScreenshot" );
+            SerializedProperty ScreenshotFileName = listItemSelected.FindPropertyRelative( "ScreenshotFileName" );
+            SerializedProperty DebugBreak = listItemSelected.FindPropertyRelative( "DebugBreak" );
+            SerializedProperty UnityEvents = listItemSelected.FindPropertyRelative( "UnityEvents" );
+
+            #endregion
+
+            EditorGUILayout.LabelField
+            (
+                label:
+                "[ PACKET ] - ID: " +
+                Id.intValue +
+                " (Conditions: " +
+                DebugConditions.arraySize +
+                ")",
+                style: GraphyEditorStyle.HeaderStyle2
+            );
+
+            EditorGUIUtility.labelWidth = 150;
+            EditorGUIUtility.fieldWidth = 35;
+
+            Active.boolValue = EditorGUILayout.Toggle
+            (
+                new GUIContent
+                (
+                    text: "Active",
+                    tooltip: "If false, it will not be checked"
+                ),
+                value: Active.boolValue
+            );
+
+            Id.intValue = EditorGUILayout.IntField
+            (
+                new GUIContent
+                (
+                    text: "ID",
+                    tooltip: "Optional Id. It's used to get or remove DebugPackets in runtime"
+                ),
+                value: Id.intValue
+            );
+
+            ExecuteOnce.boolValue = EditorGUILayout.Toggle
+            (
+                new GUIContent
+                (
+                    text: "Execute once",
+                    tooltip: "If true, once the actions are executed, this DebugPacket will delete itself"
+                ),
+                value: ExecuteOnce.boolValue
+            );
+
+            InitSleepTime.floatValue = EditorGUILayout.FloatField
+            (
+                new GUIContent
+                (
+                    text: "Init sleep time",
+                    tooltip:
+                    "Time to wait before checking if conditions are met (use this to avoid low fps drops triggering the conditions when loading the game)"
+                ),
+                value: InitSleepTime.floatValue
+            );
+
+            ExecuteSleepTime.floatValue = EditorGUILayout.FloatField
+            (
+                new GUIContent
+                (
+                    text: "Sleep time after execute",
+                    tooltip:
+                    "Time to wait before checking if conditions are met again (once they have already been met and if ExecuteOnce is false)"
+                ),
+                value: ExecuteSleepTime.floatValue
+            );
+
+
+            EditorGUIUtility.labelWidth = defaultLabelWidth;
+            EditorGUIUtility.fieldWidth = defaultFieldWidth;
+
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+
+            EditorGUILayout.LabelField( "[ CONDITIONS ] (" + DebugConditions.arraySize + ")",
+                GraphyEditorStyle.HeaderStyle2 );
+
+            EditorGUILayout.PropertyField
+            (
+                ConditionEvaluation,
+                new GUIContent( "Condition evaluation" )
+            );
+
+            EditorGUILayout.Space();
+
+            if( DebugConditions.arraySize < 1 )
+            {
+                DebugConditions.InsertArrayElementAtIndex( DebugConditions.arraySize );
+                m_selectedDebugPacketCondition = 0;
+            }
+
+            EditorGUILayout.BeginHorizontal();
+
+            List<string> debugPacketConditionNames = new List<string>();
+            for( int i = 0; i < DebugConditions.arraySize; i++ )
+            {
+                SerializedProperty listItem = DebugConditions.GetArrayElementAtIndex( i );
+                // NOTE: If the Popup detects two equal strings, it just paints 1, that's why I always add the "i"
+
+                string conditionName = (i + 1).ToString() + " - ";
+                conditionName +=
+                    GetComparerStringFromDebugVariable(
+                        (GraphyDebugger.DebugVariable) listItem.FindPropertyRelative( "Variable" ).intValue ) + " ";
+                conditionName +=
+                    GetComparerStringFromDebugComparer(
+                        (GraphyDebugger.DebugComparer) listItem.FindPropertyRelative( "Comparer" ).intValue ) + " ";
+                conditionName += listItem.FindPropertyRelative( "Value" ).floatValue.ToString();
+
+                debugPacketConditionNames.Add( conditionName );
+            }
+
+            m_selectedDebugPacketCondition =
+                EditorGUILayout.Popup( m_selectedDebugPacketCondition, debugPacketConditionNames.ToArray() );
+
+            GUI.color = new Color( 0.7f, 1f, 0.0f, 1f );
+
+            if( GUILayout.Button( "Add", GUILayout.Width( 60 ) ) )
+            {
+                DebugConditions.InsertArrayElementAtIndex( DebugConditions.arraySize );
+            }
+
+            if( DebugConditions.arraySize > 1 )
+            {
+                GUI.color = new Color( 1f, 0.7f, 0.0f, 1f );
+            }
+            else
+            {
+                GUI.color = new Color( 1f, 0.7f, 0.0f, 0.5f );
+            }
+
+            //Remove this index from the List
+            if( GUILayout.Button( "Remove", GUILayout.Width( 60 ) ) )
+            {
+                if( DebugConditions.arraySize > 1 )
+                {
+                    DebugConditions.DeleteArrayElementAtIndex( m_selectedDebugPacketCondition );
+                    if( m_selectedDebugPacketCondition > 0 )
+                    {
+                        m_selectedDebugPacketCondition--;
+                    }
+                }
+            }
+
+            GUI.color = defaultGUIColor;
+
+            EditorGUILayout.EndHorizontal();
+
+            SerializedProperty conditionListItemSelected =
+                DebugConditions.GetArrayElementAtIndex( m_selectedDebugPacketCondition );
+
+            SerializedProperty Variable = conditionListItemSelected.FindPropertyRelative( "Variable" );
+            SerializedProperty Comparer = conditionListItemSelected.FindPropertyRelative( "Comparer" );
+            SerializedProperty Value = conditionListItemSelected.FindPropertyRelative( "Value" );
+
+            EditorGUILayout.PropertyField
+            (
+                Variable,
+                new GUIContent( "Variable" )
+            );
+
+            EditorGUILayout.PropertyField
+            (
+                Comparer,
+                new GUIContent( "Comparer" )
+            );
+
+            EditorGUILayout.PropertyField
+            (
+                Value,
+                new GUIContent( "Value" )
+            );
+
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+
+            EditorGUILayout.LabelField( "[ ACTIONS ]", GraphyEditorStyle.HeaderStyle2 );
+
+            EditorGUIUtility.labelWidth = 140;
+            EditorGUIUtility.fieldWidth = 35;
+
+            EditorGUILayout.PropertyField
+            (
+                MessageType,
+                new GUIContent( "Message type" )
+            );
+
+            EditorGUILayout.PropertyField( Message );
+
+            TakeScreenshot.boolValue = EditorGUILayout.Toggle
+            (
+                new GUIContent
+                (
+                    text: "Take screenshot",
+                    tooltip:
+                    "If true, it takes a screenshot and stores it. The location where the image is written to can include a directory/folder list. With no directory/folder list the image will be written into the Project folder. On mobile platforms the filename is appended to the persistent data path."
+                ),
+                value: TakeScreenshot.boolValue
+            );
+
+            if( TakeScreenshot.boolValue )
+            {
+                EditorGUILayout.PropertyField
+                (
+                    ScreenshotFileName,
+                    new GUIContent
+                    (
+                        text: "Screenshot file name",
+                        tooltip:
+                        "Avoid this characters: * . \" / \\ [ ] : ; | = , \n\nIt will have the date appended at the end to avoid overwriting."
+                    )
+                );
+            }
+
+            DebugBreak.boolValue = EditorGUILayout.Toggle
+            (
+                new GUIContent
+                (
+                    text: "Debug Break",
+                    tooltip: "If true, it pauses the editor"
+                ),
+                DebugBreak.boolValue
+            );
+
+            EditorGUILayout.PropertyField( UnityEvents );
+
+            EditorGUIUtility.labelWidth = defaultLabelWidth;
+            EditorGUIUtility.fieldWidth = defaultFieldWidth;
+
+            serializedObject.ApplyModifiedProperties();
+        }
+
+        #endregion
+
+        #region Methods -> Private
+
+        private void SetDefaultDebugPacketValues( SerializedProperty debugPacketSerializedProperty )
+        {
+            GraphyDebugger.DebugPacket debugPacket = new GraphyDebugger.DebugPacket();
+
+            debugPacketSerializedProperty.GetArrayElementAtIndex( debugPacketSerializedProperty.arraySize - 1 )
+                .FindPropertyRelative( "Active" )
+                .boolValue = debugPacket.Active;
+
+            debugPacketSerializedProperty.GetArrayElementAtIndex( debugPacketSerializedProperty.arraySize - 1 )
+                .FindPropertyRelative( "Id" )
+                .intValue = debugPacketSerializedProperty.arraySize;
+
+            debugPacketSerializedProperty.GetArrayElementAtIndex( debugPacketSerializedProperty.arraySize - 1 )
+                .FindPropertyRelative( "ExecuteOnce" )
+                .boolValue = debugPacket.ExecuteOnce;
+
+            debugPacketSerializedProperty.GetArrayElementAtIndex( debugPacketSerializedProperty.arraySize - 1 )
+                .FindPropertyRelative( "InitSleepTime" )
+                .floatValue = debugPacket.InitSleepTime;
+
+            debugPacketSerializedProperty.GetArrayElementAtIndex( debugPacketSerializedProperty.arraySize - 1 )
+                .FindPropertyRelative( "ExecuteSleepTime" )
+                .floatValue = debugPacket.ExecuteSleepTime;
+        }
+
+        private string GetComparerStringFromDebugVariable( GraphyDebugger.DebugVariable debugVariable )
+        {
+            switch( debugVariable )
+            {
+                case GraphyDebugger.DebugVariable.Fps:
+                    return "FPS Current";
+                case GraphyDebugger.DebugVariable.Fps_Min:
+                    return "FPS Min";
+                case GraphyDebugger.DebugVariable.Fps_Max:
+                    return "FPS Max";
+                case GraphyDebugger.DebugVariable.Fps_Avg:
+                    return "FPS Avg";
+
+                case GraphyDebugger.DebugVariable.Ram_Allocated:
+                    return "Ram Allocated";
+                case GraphyDebugger.DebugVariable.Ram_Reserved:
+                    return "Ram Reserved";
+                case GraphyDebugger.DebugVariable.Ram_Mono:
+                    return "Ram Mono";
+
+                case GraphyDebugger.DebugVariable.Audio_DB:
+                    return "Audio DB";
+
+                default:
+                    return null;
+            }
+        }
+
+        private string GetComparerStringFromDebugComparer( GraphyDebugger.DebugComparer debugComparer )
+        {
+            switch( debugComparer )
+            {
+                case GraphyDebugger.DebugComparer.Less_than:
+                    return "<";
+                case GraphyDebugger.DebugComparer.Equals_or_less_than:
+                    return "<=";
+                case GraphyDebugger.DebugComparer.Equals:
+                    return "==";
+                case GraphyDebugger.DebugComparer.Equals_or_greater_than:
+                    return ">=";
+                case GraphyDebugger.DebugComparer.Greater_than:
+                    return ">";
+
+                default:
+                    return null;
+            }
+        }
+
+        #endregion
+    }
+}

Assets/Plugins/Graphy/Editor/GraphyDebuggerEditor.cs.meta

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

Assets/Plugins/Graphy/Editor/GraphyEditorStyle.cs

@@ -0,0 +1,118 @@
+/* ---------------------------------------
+ * Author:          Martin Pane (martintayx@gmail.com) (@tayx94)
+ * Contributors:    https://github.com/Tayx94/graphy/graphs/contributors
+ * Project:         Graphy - Ultimate Stats Monitor
+ * Date:            02-Jan-18
+ * Studio:          Tayx
+ *
+ * Git repo:        https://github.com/Tayx94/graphy
+ *
+ * This project is released under the MIT license.
+ * Attribution is not required, but it is always welcomed!
+ * -------------------------------------*/
+
+using System;
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace Tayx.Graphy
+{
+    internal static class GraphyEditorStyle
+    {
+        #region Variables -> Private
+
+        private static Texture2D _managerLogoTexture = null;
+        private static Texture2D _debuggerLogoTexture = null;
+        private static GUISkin m_skin = null;
+        private static GUIStyle m_headerStyle1 = null;
+        private static GUIStyle m_headerStyle2 = null;
+        private static GUIStyle m_foldoutStyle = null;
+        private static string path;
+
+        #endregion
+
+        #region Properties -> Public
+
+        public static Texture2D ManagerLogoTexture => _managerLogoTexture;
+        public static Texture2D DebuggerLogoTexture => _debuggerLogoTexture;
+        public static GUISkin Skin => m_skin;
+        public static GUIStyle HeaderStyle1 => m_headerStyle1;
+        public static GUIStyle HeaderStyle2 => m_headerStyle2;
+        public static GUIStyle FoldoutStyle => m_foldoutStyle;
+
+        #endregion
+
+        #region Static Constructor
+
+        static GraphyEditorStyle()
+        {
+            string managerLogoGuid = AssetDatabase.FindAssets( $"Manager_Logo_{(EditorGUIUtility.isProSkin ? "White" : "Dark")}" )[ 0 ];
+            string debuggerLogoGuid = AssetDatabase.FindAssets( $"Debugger_Logo_{(EditorGUIUtility.isProSkin ? "White" : "Dark")}" )[ 0 ];
+            string guiSkinGuid = AssetDatabase.FindAssets( "GraphyGUISkin" )[ 0 ];
+
+            _managerLogoTexture = AssetDatabase.LoadAssetAtPath<Texture2D>
+            (
+                AssetDatabase.GUIDToAssetPath( managerLogoGuid )
+            );
+
+            _debuggerLogoTexture = AssetDatabase.LoadAssetAtPath<Texture2D>
+            (
+                AssetDatabase.GUIDToAssetPath( debuggerLogoGuid )
+            );
+
+            m_skin = AssetDatabase.LoadAssetAtPath<GUISkin>
+            (
+                AssetDatabase.GUIDToAssetPath( guiSkinGuid )
+            );
+
+            if( m_skin != null )
+            {
+                m_headerStyle1 = m_skin.GetStyle( "Header1" );
+                m_headerStyle2 = m_skin.GetStyle( "Header2" );
+
+                SetGuiStyleFontColor
+                (
+                    guiStyle: m_headerStyle2,
+                    color: EditorGUIUtility.isProSkin ? Color.white : Color.black
+                );
+            }
+            else
+            {
+                m_headerStyle1 = EditorStyles.boldLabel;
+                m_headerStyle2 = EditorStyles.boldLabel;
+            }
+
+            m_foldoutStyle = new GUIStyle( EditorStyles.foldout )
+            {
+                font = m_headerStyle2.font,
+                fontStyle = m_headerStyle2.fontStyle,
+                contentOffset = Vector2.down * 3f
+            };
+
+            SetGuiStyleFontColor
+            (
+                guiStyle: m_foldoutStyle,
+                color: EditorGUIUtility.isProSkin ? Color.white : Color.black
+            );
+        }
+
+        #endregion
+
+        #region Methods -> Private
+
+        private static void SetGuiStyleFontColor( GUIStyle guiStyle, Color color )
+        {
+            guiStyle.normal.textColor = color;
+            guiStyle.hover.textColor = color;
+            guiStyle.active.textColor = color;
+            guiStyle.focused.textColor = color;
+            guiStyle.onNormal.textColor = color;
+            guiStyle.onHover.textColor = color;
+            guiStyle.onActive.textColor = color;
+            guiStyle.onFocused.textColor = color;
+        }
+
+        #endregion
+    }
+}

Assets/Plugins/Graphy/Editor/GraphyEditorStyle.cs.meta

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

Assets/Plugins/Graphy/Editor/GraphyManagerEditor.cs

@@ -0,0 +1,872 @@
+/* ---------------------------------------
+ * Author:          Martin Pane (martintayx@gmail.com) (@tayx94)
+ * Contributors:    https://github.com/Tayx94/graphy/graphs/contributors
+ * Project:         Graphy - Ultimate Stats Monitor
+ * Date:            20-Dec-17
+ * Studio:          Tayx
+ *
+ * Git repo:        https://github.com/Tayx94/graphy
+ *
+ * This project is released under the MIT license.
+ * Attribution is not required, but it is always welcomed!
+ * -------------------------------------*/
+
+using System;
+using UnityEngine;
+using System.IO;
+using UnityEditor;
+
+namespace Tayx.Graphy
+{
+    [CustomEditor( typeof( GraphyManager ) )]
+    internal class GraphyManagerEditor : Editor
+    {
+        #region Variables -> Private
+
+        private GraphyManager m_target;
+
+        private int[] m_spectrumSizeValues =
+        {
+            128,
+            256,
+            512,
+            1024,
+            2048,
+            4096,
+            8192
+        };
+
+        #region Section -> Settings
+
+        private SerializedProperty m_graphyMode;
+
+        private SerializedProperty m_enableOnStartup;
+
+        private SerializedProperty m_keepAlive;
+
+        private SerializedProperty m_background;
+        private SerializedProperty m_backgroundColor;
+
+        private SerializedProperty m_enableHotkeys;
+
+        private SerializedProperty m_toggleModeKeyCode;
+        private SerializedProperty m_toggleModeCtrl;
+        private SerializedProperty m_toggleModeAlt;
+
+        private SerializedProperty m_toggleActiveKeyCode;
+        private SerializedProperty m_toggleActiveCtrl;
+        private SerializedProperty m_toggleActiveAlt;
+
+
+        private SerializedProperty m_graphModulePosition;
+        private SerializedProperty m_graphModuleOffset;
+
+        #endregion
+
+        #region Section -> FPS
+
+        private bool m_fpsModuleInspectorToggle = true;
+
+        private SerializedProperty m_fpsModuleState;
+
+        private SerializedProperty m_goodFpsColor;
+        private SerializedProperty m_goodFpsThreshold;
+
+        private SerializedProperty m_cautionFpsColor;
+        private SerializedProperty m_cautionFpsThreshold;
+
+        private SerializedProperty m_criticalFpsColor;
+
+        private SerializedProperty m_fpsGraphResolution;
+
+        private SerializedProperty m_fpsTextUpdateRate;
+
+        #endregion
+
+        #region Section -> RAM
+
+        private bool m_ramModuleInspectorToggle = true;
+
+        private SerializedProperty m_ramModuleState;
+
+        private SerializedProperty m_allocatedRamColor;
+        private SerializedProperty m_reservedRamColor;
+        private SerializedProperty m_monoRamColor;
+
+        private SerializedProperty m_ramGraphResolution;
+
+        private SerializedProperty m_ramTextUpdateRate;
+
+        #endregion
+
+        #region Section -> Audio
+
+        private bool m_audioModuleInspectorToggle = true;
+
+        private SerializedProperty m_findAudioListenerInCameraIfNull;
+
+        private SerializedProperty m_audioListener;
+
+        private SerializedProperty m_audioModuleState;
+
+        private SerializedProperty m_audioGraphColor;
+
+        private SerializedProperty m_audioGraphResolution;
+
+        private SerializedProperty m_audioTextUpdateRate;
+
+        private SerializedProperty m_FFTWindow;
+
+        private SerializedProperty m_spectrumSize;
+
+        #endregion
+
+        #region Section -> Advanced Settings
+
+        private bool m_advancedModuleInspectorToggle = true;
+
+        private SerializedProperty m_advancedModulePosition;
+
+        private SerializedProperty m_advancedModuleOffset;
+
+        private SerializedProperty m_advancedModuleState;
+
+        #endregion
+
+        #endregion
+
+        #region Methods -> Unity Callbacks
+
+        private void OnEnable()
+        {
+            m_target = (GraphyManager) target;
+
+            SerializedObject serObj = serializedObject;
+
+            #region Section -> Settings
+
+            m_graphyMode = serObj.FindProperty( "m_graphyMode" );
+
+            m_enableOnStartup = serObj.FindProperty( "m_enableOnStartup" );
+
+            m_keepAlive = serObj.FindProperty( "m_keepAlive" );
+
+            m_background = serObj.FindProperty( "m_background" );
+            m_backgroundColor = serObj.FindProperty( "m_backgroundColor" );
+
+            m_enableHotkeys = serObj.FindProperty( "m_enableHotkeys" );
+
+            m_toggleModeKeyCode = serObj.FindProperty( "m_toggleModeKeyCode" );
+
+            m_toggleModeCtrl = serObj.FindProperty( "m_toggleModeCtrl" );
+            m_toggleModeAlt = serObj.FindProperty( "m_toggleModeAlt" );
+
+            m_toggleActiveKeyCode = serObj.FindProperty( "m_toggleActiveKeyCode" );
+
+            m_toggleActiveCtrl = serObj.FindProperty( "m_toggleActiveCtrl" );
+            m_toggleActiveAlt = serObj.FindProperty( "m_toggleActiveAlt" );
+
+            m_graphModulePosition = serObj.FindProperty( "m_graphModulePosition" );
+
+            m_graphModuleOffset = serObj.FindProperty( "m_graphModuleOffset" );
+
+            #endregion
+
+            #region Section -> FPS
+
+            m_fpsModuleState = serObj.FindProperty( "m_fpsModuleState" );
+
+            m_goodFpsColor = serObj.FindProperty( "m_goodFpsColor" );
+            m_goodFpsThreshold = serObj.FindProperty( "m_goodFpsThreshold" );
+
+            m_cautionFpsColor = serObj.FindProperty( "m_cautionFpsColor" );
+            m_cautionFpsThreshold = serObj.FindProperty( "m_cautionFpsThreshold" );
+
+            m_criticalFpsColor = serObj.FindProperty( "m_criticalFpsColor" );
+
+            m_fpsGraphResolution = serObj.FindProperty( "m_fpsGraphResolution" );
+
+            m_fpsTextUpdateRate = serObj.FindProperty( "m_fpsTextUpdateRate" );
+
+            #endregion
+
+            #region Section -> RAM
+
+            m_ramModuleState = serObj.FindProperty( "m_ramModuleState" );
+
+            m_allocatedRamColor = serObj.FindProperty( "m_allocatedRamColor" );
+            m_reservedRamColor = serObj.FindProperty( "m_reservedRamColor" );
+            m_monoRamColor = serObj.FindProperty( "m_monoRamColor" );
+
+            m_ramGraphResolution = serObj.FindProperty( "m_ramGraphResolution" );
+
+            m_ramTextUpdateRate = serObj.FindProperty( "m_ramTextUpdateRate" );
+
+            #endregion
+
+            #region Section -> Audio
+
+            m_findAudioListenerInCameraIfNull = serObj.FindProperty( "m_findAudioListenerInCameraIfNull" );
+
+            m_audioListener = serObj.FindProperty( "m_audioListener" );
+
+            m_audioModuleState = serObj.FindProperty( "m_audioModuleState" );
+
+            m_audioGraphColor = serObj.FindProperty( "m_audioGraphColor" );
+
+            m_audioGraphResolution = serObj.FindProperty( "m_audioGraphResolution" );
+
+            m_audioTextUpdateRate = serObj.FindProperty( "m_audioTextUpdateRate" );
+
+            m_FFTWindow = serObj.FindProperty( "m_FFTWindow" );
+
+            m_spectrumSize = serObj.FindProperty( "m_spectrumSize" );
+
+            #endregion
+
+            #region Section -> Advanced Settings
+
+            m_advancedModulePosition = serObj.FindProperty( "m_advancedModulePosition" );
+
+            m_advancedModuleOffset = serObj.FindProperty( "m_advancedModuleOffset" );
+            
+            m_advancedModuleState = serObj.FindProperty( "m_advancedModuleState" );
+
+            #endregion
+        }
+
+        #endregion
+
+        #region Methods -> Public Override
+
+        public override void OnInspectorGUI()
+        {
+            if( m_target == null && target == null )
+            {
+                base.OnInspectorGUI();
+                return;
+            }
+
+            float defaultLabelWidth = EditorGUIUtility.labelWidth;
+            float defaultFieldWidth = EditorGUIUtility.fieldWidth;
+
+            //===== CONTENT REGION ========================================================================
+
+            GUILayout.Space( 20 );
+
+            #region Section -> Logo
+
+            if( GraphyEditorStyle.ManagerLogoTexture != null )
+            {
+                GUILayout.Label
+                (
+                    image: GraphyEditorStyle.ManagerLogoTexture,
+                    style: new GUIStyle( GUI.skin.GetStyle( "Label" ) )
+                    {
+                        alignment = TextAnchor.UpperCenter
+                    }
+                );
+
+                GUILayout.Space( 10 );
+            }
+            else
+            {
+                EditorGUILayout.LabelField
+                (
+                    label: "[ GRAPHY - MANAGER ]",
+                    style: GraphyEditorStyle.HeaderStyle1
+                );
+            }
+
+            #endregion
+
+            GUILayout.Space( 5 ); //Extra pixels added when the logo is used.
+
+            #region Section -> Settings
+
+            EditorGUIUtility.labelWidth = 130;
+            EditorGUIUtility.fieldWidth = 35;
+
+            EditorGUILayout.PropertyField
+            (
+                m_graphyMode,
+                new GUIContent
+                (
+                    text: "Graphy Mode",
+                    tooltip:
+                    "LIGHT mode increases compatibility with mobile and older, less powerful GPUs, but reduces the maximum graph resolutions to 128."
+                )
+            );
+
+            GUILayout.Space( 10 );
+
+            m_enableOnStartup.boolValue = EditorGUILayout.Toggle
+            (
+                new GUIContent
+                (
+                    text: "Enable On Startup",
+                    tooltip:
+                    "If ticked, Graphy will be displayed by default on startup, otherwise it will initiate and hide."
+                ),
+                value: m_enableOnStartup.boolValue
+            );
+
+            // This is a neat trick to hide Graphy in the Scene if it's going to be deactivated in play mode so that it doesn't use screen space.
+            if( !Application.isPlaying )
+            {
+                m_target.GetComponent<Canvas>().enabled = m_enableOnStartup.boolValue;
+            }
+
+            m_keepAlive.boolValue = EditorGUILayout.Toggle
+            (
+                new GUIContent
+                (
+                    text: "Keep Alive",
+                    tooltip:
+                    "If ticked, it will survive scene changes.\n\nCAREFUL, if you set Graphy as a child of another GameObject, the root GameObject will also survive scene changes. If you want to avoid that put Graphy in the root of the Scene as its own entity."
+                ),
+                value: m_keepAlive.boolValue
+            );
+
+            GUILayout.Space( 10 );
+
+            EditorGUILayout.BeginHorizontal();
+
+            m_background.boolValue = EditorGUILayout.Toggle
+            (
+                new GUIContent
+                (
+                    text: "Background",
+                    tooltip: "If ticked, it will show a background overlay to improve readability in cluttered scenes."
+                ),
+                value: m_background.boolValue
+            );
+
+            m_backgroundColor.colorValue = EditorGUILayout.ColorField( m_backgroundColor.colorValue );
+
+            EditorGUILayout.EndHorizontal();
+
+            GUILayout.Space( 10 );
+
+            m_enableHotkeys.boolValue = EditorGUILayout.Toggle
+            (
+                new GUIContent
+                (
+                    text: "Enable Hotkeys",
+                    tooltip:
+                    "If ticked, it will enable the hotkeys to be able to modify Graphy in runtime with custom keyboard shortcuts."
+                ),
+                value: m_enableHotkeys.boolValue
+            );
+
+            if( m_enableHotkeys.boolValue )
+            {
+                EditorGUILayout.BeginHorizontal();
+
+                EditorGUIUtility.labelWidth = 130;
+                EditorGUIUtility.fieldWidth = 35;
+
+                EditorGUILayout.PropertyField
+                (
+                    m_toggleModeKeyCode,
+                    new GUIContent
+                    (
+                        text: "Toggle Mode Key",
+                        tooltip: "If ticked, it will require clicking this key and the other ones you have set up."
+                    )
+                );
+
+                EditorGUIUtility.labelWidth = 30;
+                EditorGUIUtility.fieldWidth = 35;
+
+                m_toggleModeCtrl.boolValue = EditorGUILayout.Toggle
+                (
+                    new GUIContent
+                    (
+                        text: "Ctrl",
+                        tooltip: "If ticked, it will require clicking Ctrl and the other keys you have set up."
+                    ),
+                    value: m_toggleModeCtrl.boolValue
+                );
+
+                m_toggleModeAlt.boolValue = EditorGUILayout.Toggle
+                (
+                    new GUIContent
+                    (
+                        text: "Alt",
+                        tooltip: "If ticked, it will require clicking Alt and the other keys you have set up."
+                    ),
+                    value: m_toggleModeAlt.boolValue
+                );
+
+                EditorGUILayout.EndHorizontal();
+
+                EditorGUILayout.BeginHorizontal();
+
+                EditorGUIUtility.labelWidth = 130;
+                EditorGUIUtility.fieldWidth = 35;
+
+                EditorGUILayout.PropertyField
+                (
+                    m_toggleActiveKeyCode,
+                    new GUIContent
+                    (
+                        text: "Toggle Active Key",
+                        tooltip: "If ticked, it will require clicking this key and the other ones you have set up."
+                    )
+                );
+
+                EditorGUIUtility.labelWidth = 30;
+                EditorGUIUtility.fieldWidth = 35;
+
+                m_toggleActiveCtrl.boolValue = EditorGUILayout.Toggle
+                (
+                    new GUIContent
+                    (
+                        text: "Ctrl",
+                        tooltip: "If ticked, it will require clicking Ctrl and the other kesy you have set up."
+                    ),
+                    value: m_toggleActiveCtrl.boolValue
+                );
+
+                m_toggleActiveAlt.boolValue = EditorGUILayout.Toggle
+                (
+                    new GUIContent
+                    (
+                        text: "Alt",
+                        tooltip: "If ticked, it will require clicking Alt and the other keys you have set up."
+                    ),
+                    value: m_toggleActiveAlt.boolValue
+                );
+
+                EditorGUILayout.EndHorizontal();
+            }
+
+            GUILayout.Space( 15 );
+
+            EditorGUIUtility.labelWidth = 155;
+            EditorGUIUtility.fieldWidth = 35;
+
+            EditorGUILayout.PropertyField
+            (
+                m_graphModulePosition,
+                new GUIContent
+                (
+                    text: "Graph modules position",
+                    tooltip: "Defines in which corner the modules will be located."
+                )
+            );
+
+            EditorGUILayout.PropertyField
+            (
+                m_graphModuleOffset,
+                new GUIContent
+                (
+                    text: "Graph modules offset",
+                    tooltip: "Defines how far from the corner the module will be located."
+                )
+            );
+
+            #endregion
+
+            GUILayout.Space( 20 );
+
+            #region Section -> FPS
+
+            m_fpsModuleInspectorToggle = EditorGUILayout.Foldout
+            (
+                m_fpsModuleInspectorToggle,
+                content: " [ FPS ]",
+                style: GraphyEditorStyle.FoldoutStyle,
+                toggleOnLabelClick: true
+            );
+
+            GUILayout.Space( 5 );
+
+            if( m_fpsModuleInspectorToggle )
+            {
+                EditorGUILayout.PropertyField
+                (
+                    m_fpsModuleState,
+                    new GUIContent
+                    (
+                        text: "Module state",
+                        tooltip: "FULL -> Text + Graph \nTEXT -> Just text \nOFF -> Turned off"
+                    )
+                );
+
+                GUILayout.Space( 5 );
+
+                EditorGUILayout.LabelField( "Fps thresholds and colors:" );
+
+                EditorGUI.indentLevel++;
+
+                EditorGUILayout.BeginHorizontal();
+
+                m_goodFpsThreshold.intValue = EditorGUILayout.IntField
+                (
+                    new GUIContent
+                    (
+                        text: "- Good",
+                        tooltip: "When FPS rise above this value, this color will be used."
+                    ),
+                    value: m_goodFpsThreshold.intValue
+                );
+
+                m_goodFpsColor.colorValue = EditorGUILayout.ColorField( m_goodFpsColor.colorValue );
+
+                EditorGUILayout.EndHorizontal();
+
+                if( m_goodFpsThreshold.intValue <= m_cautionFpsThreshold.intValue && m_goodFpsThreshold.intValue > 1 )
+                {
+                    m_cautionFpsThreshold.intValue = m_goodFpsThreshold.intValue - 1;
+                }
+                else if( m_goodFpsThreshold.intValue <= 1 )
+                {
+                    m_goodFpsThreshold.intValue = 2;
+                }
+
+                EditorGUILayout.BeginHorizontal();
+
+                m_cautionFpsThreshold.intValue = EditorGUILayout.IntField
+                (
+                    new GUIContent
+                    (
+                        text: "- Caution",
+                        tooltip: "When FPS falls between this and the Good value, this color will be used."
+                    ),
+                    value: m_cautionFpsThreshold.intValue
+                );
+
+                m_cautionFpsColor.colorValue = EditorGUILayout.ColorField( m_cautionFpsColor.colorValue );
+
+                EditorGUILayout.EndHorizontal();
+
+                if( m_cautionFpsThreshold.intValue >= m_goodFpsThreshold.intValue )
+                {
+                    m_cautionFpsThreshold.intValue = m_goodFpsThreshold.intValue - 1;
+                }
+                else if( m_cautionFpsThreshold.intValue <= 0 )
+                {
+                    m_cautionFpsThreshold.intValue = 1;
+                }
+
+                EditorGUILayout.BeginHorizontal();
+
+                EditorGUILayout.IntField
+                (
+                    new GUIContent
+                    (
+                        text: "- Critical",
+                        tooltip:
+                        "When FPS falls below the Caution value, this color will be used. (You can't have negative FPS, so this value is just for reference, it can't be changed)."
+                    ),
+                    value: 0
+                );
+
+                m_criticalFpsColor.colorValue = EditorGUILayout.ColorField( m_criticalFpsColor.colorValue );
+
+                EditorGUILayout.EndHorizontal();
+
+                EditorGUI.indentLevel--;
+
+                if( m_fpsModuleState.intValue == 0 )
+                {
+                    m_fpsGraphResolution.intValue = EditorGUILayout.IntSlider
+                    (
+                        new GUIContent
+                        (
+                            text: "Graph resolution",
+                            tooltip: "Defines the amount of points in the graph"
+                        ),
+                        m_fpsGraphResolution.intValue,
+                        leftValue: 20,
+                        rightValue: m_graphyMode.intValue == 0 ? 300 : 128
+                    );
+                }
+
+                m_fpsTextUpdateRate.intValue = EditorGUILayout.IntSlider
+                (
+                    new GUIContent
+                    (
+                        text: "Text update rate",
+                        tooltip: "Defines the amount times the text is updated in 1 second."
+                    ),
+                    m_fpsTextUpdateRate.intValue,
+                    leftValue: 1,
+                    rightValue: 60
+                );
+            }
+
+            #endregion
+
+            GUILayout.Space( 20 );
+
+            #region Section -> RAM
+
+            m_ramModuleInspectorToggle = EditorGUILayout.Foldout
+            (
+                m_ramModuleInspectorToggle,
+                content: " [ RAM ]",
+                style: GraphyEditorStyle.FoldoutStyle,
+                toggleOnLabelClick: true
+            );
+
+            GUILayout.Space( 5 );
+
+            if( m_ramModuleInspectorToggle )
+            {
+                EditorGUILayout.PropertyField
+                (
+                    m_ramModuleState,
+                    new GUIContent
+                    (
+                        text: "Module state",
+                        tooltip: "FULL -> Text + Graph \nTEXT -> Just text \nOFF -> Turned off"
+                    )
+                );
+
+                GUILayout.Space( 5 );
+
+                EditorGUILayout.LabelField( "Graph colors:" );
+
+                EditorGUI.indentLevel++;
+
+                m_allocatedRamColor.colorValue = EditorGUILayout.ColorField
+                (
+                    label: "- Allocated",
+                    value: m_allocatedRamColor.colorValue
+                );
+
+                m_reservedRamColor.colorValue = EditorGUILayout.ColorField
+                (
+                    label: "- Reserved",
+                    value: m_reservedRamColor.colorValue
+                );
+
+                m_monoRamColor.colorValue = EditorGUILayout.ColorField
+                (
+                    label: "- Mono",
+                    value: m_monoRamColor.colorValue
+                );
+
+                EditorGUI.indentLevel--;
+
+                if( m_ramModuleState.intValue == 0 )
+                {
+                    m_ramGraphResolution.intValue = EditorGUILayout.IntSlider(
+                        new GUIContent
+                        (
+                            text: "Graph resolution",
+                            tooltip: "Defines the amount of points are in the graph"
+                        ),
+                        m_ramGraphResolution.intValue,
+                        leftValue: 20,
+                        rightValue: m_graphyMode.intValue == 0 ? 300 : 128
+                    );
+                }
+
+                m_ramTextUpdateRate.intValue = EditorGUILayout.IntSlider
+                (
+                    new GUIContent
+                    (
+                        text: "Text update rate",
+                        tooltip: "Defines the amount times the text is updated in 1 second."
+                    ),
+                    m_ramTextUpdateRate.intValue,
+                    leftValue: 1,
+                    rightValue: 60
+                );
+            }
+
+            #endregion
+
+            GUILayout.Space( 20 );
+
+            #region Section -> Audio
+
+            m_audioModuleInspectorToggle = EditorGUILayout.Foldout
+            (
+                m_audioModuleInspectorToggle,
+                content: " [ AUDIO ]",
+                style: GraphyEditorStyle.FoldoutStyle,
+                toggleOnLabelClick: true
+            );
+
+            GUILayout.Space( 5 );
+
+            if( m_audioModuleInspectorToggle )
+            {
+                EditorGUILayout.PropertyField
+                (
+                    m_audioModuleState,
+                    new GUIContent
+                    (
+                        text: "Module state",
+                        tooltip: "FULL -> Text + Graph \nTEXT -> Just text \nOFF -> Turned off"
+                    )
+                );
+
+                GUILayout.Space( 5 );
+
+                EditorGUILayout.PropertyField
+                (
+                    m_findAudioListenerInCameraIfNull,
+                    new GUIContent
+                    (
+                        text: "Find audio listener",
+                        tooltip:
+                        "Tries to find the AudioListener in the Main camera in the scene. (if AudioListener is null)"
+                    )
+                );
+
+                EditorGUILayout.PropertyField
+                (
+                    m_audioListener,
+                    new GUIContent
+                    (
+                        text: "Audio Listener",
+                        tooltip:
+                        "Graphy will take the data from this Listener. If none are specified, it will try to get it from the Main Camera in the scene."
+                    )
+                );
+
+                if( m_audioModuleState.intValue == 0 )
+                {
+                    m_audioGraphColor.colorValue = EditorGUILayout.ColorField
+                    (
+                        label: "Graph color",
+                        value: m_audioGraphColor.colorValue
+                    );
+
+                    m_audioGraphResolution.intValue = EditorGUILayout.IntSlider
+                    (
+                        new GUIContent
+                        (
+                            text: "Graph resolution",
+                            tooltip: "Defines the amount of points that are in the graph."
+                        ),
+                        m_audioGraphResolution.intValue,
+                        leftValue: 20,
+                        rightValue: m_graphyMode.intValue == 0 ? 300 : 128
+                    );
+
+                    // Forces the value to be a multiple of 3, this way the audio graph is painted correctly
+                    if( m_audioGraphResolution.intValue % 3 != 0 && m_audioGraphResolution.intValue < 300 )
+                    {
+                        m_audioGraphResolution.intValue += 3 - m_audioGraphResolution.intValue % 3;
+                    }
+                }
+
+                EditorGUILayout.PropertyField
+                (
+                    m_FFTWindow,
+                    new GUIContent
+                    (
+                        text: "FFT Window",
+                        tooltip:
+                        "Used to reduce leakage between frequency bins/bands. Note, the more complex window type, the better the quality, but reduced speed. \n\nSimplest is rectangular. Most complex is BlackmanHarris"
+                    )
+                );
+
+                m_spectrumSize.intValue = EditorGUILayout.IntSlider
+                (
+                    new GUIContent
+                    (
+                        text: "Spectrum size",
+                        tooltip:
+                        "Has to be a power of 2 between 128-8192. The higher sample rate, the less precision but also more impact on performance. Careful with mobile devices"
+                    ),
+                    m_spectrumSize.intValue,
+                    leftValue: 128,
+                    rightValue: 8192
+                );
+
+                int closestSpectrumIndex = 0;
+                int minDistanceToSpectrumValue = 100000;
+
+                for( int i = 0; i < m_spectrumSizeValues.Length; i++ )
+                {
+                    int newDistance = Mathf.Abs
+                    (
+                        value: m_spectrumSize.intValue - m_spectrumSizeValues[ i ]
+                    );
+
+                    if( newDistance < minDistanceToSpectrumValue )
+                    {
+                        minDistanceToSpectrumValue = newDistance;
+                        closestSpectrumIndex = i;
+                    }
+                }
+
+                m_spectrumSize.intValue = m_spectrumSizeValues[ closestSpectrumIndex ];
+
+                m_audioTextUpdateRate.intValue = EditorGUILayout.IntSlider
+                (
+                    new GUIContent
+                    (
+                        text: "Text update rate",
+                        tooltip: "Defines the amount times the text is updated in 1 second"
+                    ),
+                    m_audioTextUpdateRate.intValue,
+                    leftValue: 1,
+                    rightValue: 60
+                );
+            }
+
+            #endregion
+
+            GUILayout.Space( 20 );
+
+            #region Section -> Advanced Settings
+
+            m_advancedModuleInspectorToggle = EditorGUILayout.Foldout
+            (
+                m_advancedModuleInspectorToggle,
+                content: " [ ADVANCED DATA ]",
+                style: GraphyEditorStyle.FoldoutStyle,
+                toggleOnLabelClick: true
+            );
+
+            GUILayout.Space( 5 );
+
+            if( m_advancedModuleInspectorToggle )
+            {
+                EditorGUILayout.PropertyField( m_advancedModulePosition );
+
+                EditorGUILayout.PropertyField
+                (
+                    m_advancedModuleOffset,
+                    new GUIContent
+                    (
+                        text: "Advanced modules offset",
+                        tooltip: "Defines how far from the corner the module will be located."
+                    )
+                );
+                
+                EditorGUILayout.PropertyField
+                (
+                    m_advancedModuleState,
+                    new GUIContent
+                    (
+                        text: "Module state",
+                        tooltip: "FULL -> Text \nOFF -> Turned off"
+                    )
+                );
+            }
+
+            #endregion;
+
+            EditorGUIUtility.labelWidth = defaultLabelWidth;
+            EditorGUIUtility.fieldWidth = defaultFieldWidth;
+
+            serializedObject.ApplyModifiedProperties();
+        }
+
+        #endregion
+
+        #region Methods -> Private
+
+        #endregion
+    }
+}

Assets/Plugins/Graphy/Editor/GraphyManagerEditor.cs.meta

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

Assets/Plugins/Graphy/Editor/GraphyMenuItem.cs

@@ -0,0 +1,66 @@
+/* ---------------------------------------
+ * Author:          Martin Pane (martintayx@gmail.com) (@tayx94)
+ * Contributors:    https://github.com/Tayx94/graphy/graphs/contributors
+ * Project:         Graphy - Ultimate Stats Monitor
+ * Date:            20-Dec-17
+ * Studio:          Tayx
+ *
+ * Git repo:        https://github.com/Tayx94/graphy
+ *
+ * This project is released under the MIT license.
+ * Attribution is not required, but it is always welcomed!
+ * -------------------------------------*/
+
+using UnityEditor;
+using UnityEngine;
+
+namespace Tayx.Graphy
+{
+    public class GraphyMenuItem
+    {
+        [MenuItem( "Tools/Graphy/Create Prefab Variant" )]
+        static void CreatePrefabVariant()
+        {
+            // Directory checking
+            if( !AssetDatabase.IsValidFolder( "Assets/Graphy - Ultimate Stats Monitor" ) )
+            {
+                AssetDatabase.CreateFolder( "Assets", "Graphy - Ultimate Stats Monitor" );
+            }
+
+            if( !AssetDatabase.IsValidFolder( "Assets/Graphy - Ultimate Stats Monitor/Prefab Variants" ) )
+            {
+                AssetDatabase.CreateFolder( "Assets/Graphy - Ultimate Stats Monitor", "Prefab Variants" );
+            }
+
+            string graphyPrefabGuid = AssetDatabase.FindAssets( "[Graphy]" )[ 0 ];
+
+            Object originalPrefab =
+                (GameObject) AssetDatabase.LoadAssetAtPath( AssetDatabase.GUIDToAssetPath( graphyPrefabGuid ),
+                    typeof( GameObject ) );
+            GameObject objectSource = PrefabUtility.InstantiatePrefab( originalPrefab ) as GameObject;
+
+            int prefabVariantCount =
+                AssetDatabase.FindAssets( "Graphy_Variant",
+                    new[] { "Assets/Graphy - Ultimate Stats Monitor/Prefab Variants" } ).Length;
+
+            GameObject prefabVariant = PrefabUtility.SaveAsPrefabAsset( objectSource,
+                $"Assets/Graphy - Ultimate Stats Monitor/Prefab Variants/Graphy_Variant_{prefabVariantCount}.prefab" );
+
+            Object.DestroyImmediate( objectSource );
+
+            foreach( SceneView scene in SceneView.sceneViews )
+            {
+                scene.ShowNotification(
+                    new GUIContent( "Prefab Variant Created at \"Assets/Graphy - Ultimate Stats Monitor/Prefab\"!" ) );
+            }
+        }
+
+        [MenuItem( "Tools/Graphy/Import Graphy Customization Scene" )]
+        static void ImportGraphyCustomizationScene()
+        {
+            string customizationSceneGuid = AssetDatabase.FindAssets( "Graphy_CustomizationScene" )[ 0 ];
+
+            AssetDatabase.ImportPackage( AssetDatabase.GUIDToAssetPath( customizationSceneGuid ), true );
+        }
+    }
+}

Assets/Plugins/Graphy/Editor/GraphyMenuItem.cs.meta

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

Assets/Plugins/Graphy/Editor/Tayx.Graphy.Editor.asmdef

@@ -0,0 +1,23 @@
+{
+    "name": "Tayx.Graphy.Editor",
+    "references": [
+        "GUID:18e5109d897e1b244ab2dfeaf5482c7b"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [
+        {
+            "name": "com.unity.inputsystem",
+            "expression": "",
+            "define": "GRAPHY_NEW_INPUT"
+        }
+    ],
+    "noEngineReferences": false
+}

Assets/Plugins/Graphy/Editor/Tayx.Graphy.Editor.asmdef.meta

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

Assets/Plugins/Graphy/Font.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 3ac48df14c942a247a9e31f953e82768
+folderAsset: yes
+timeCreated: 1511635919
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Font/Northwest-Bold.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 2b891f35198da7642a30fd430ae0d619
+folderAsset: yes
+timeCreated: 1516718193
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Font/Northwest-Bold/ERIC-TIRADO-NORTHWEST-LICENSE.txt

@@ -0,0 +1,18 @@
+Eric Tirado - NORTHWEST - BOLD, ROUGH - BETA
+
+Version 0.6 2016
+________________________________________________________________________________________
+
+This font demo is free for personal and commercial use.
+
+DonÕt resell, donÕt rename, share it with this txt file. Easy.
+
+Sign up at tira.do/nw to get a good deal on our final release (coming soon) and be in the loop for more awesomeness!
+
+________________________________________________________________________________________
+
+fonts@erictirado.com
+
+Eric Tirado © 2016 - All Rights Reserved
+_______________________________________________________________________________________
+_______________________________________________________________________________________

Assets/Plugins/Graphy/Font/Northwest-Bold/ERIC-TIRADO-NORTHWEST-LICENSE.txt.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 67bbd8c5103323b4688fcfa3abe68927
+labels:
+- font
+timeCreated: 1516718196
+licenseType: Store
+TextScriptImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Font/Northwest-Bold/NORTHWEST-B.otf.meta

@@ -0,0 +1,22 @@
+fileFormatVersion: 2
+guid: d523cde1d178d7c4ca6bb724b9d5213e
+labels:
+- font
+timeCreated: 1516718196
+licenseType: Store
+TrueTypeFontImporter:
+  serializedVersion: 4
+  fontSize: 16
+  forceTextureCase: -2
+  characterSpacing: 0
+  characterPadding: 1
+  includeFontData: 1
+  fontNames:
+  - NORTHWEST
+  fallbackFontReferences: []
+  customCharacters: 
+  fontRenderingMode: 0
+  ascentCalculationMode: 1
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Font/Roboto.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 37f53a7f00580aa4fa7797d9308063e7
+folderAsset: yes
+timeCreated: 1515073036
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Font/Roboto/LICENSE.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

Assets/Plugins/Graphy/Font/Roboto/LICENSE.txt.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: eb908df110bf2314d94d245f8a338830
+labels:
+- font
+timeCreated: 1515073036
+licenseType: Store
+TextScriptImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Font/Roboto/Roboto-Bold.ttf.meta

@@ -0,0 +1,23 @@
+fileFormatVersion: 2
+guid: 9568ece128856a54cbc1060379ab498d
+labels:
+- font
+timeCreated: 1515090903
+licenseType: Store
+TrueTypeFontImporter:
+  serializedVersion: 4
+  fontSize: 16
+  forceTextureCase: -2
+  characterSpacing: 0
+  characterPadding: 1
+  includeFontData: 1
+  fontNames:
+  - Roboto
+  fallbackFontReferences:
+  - {fileID: 12800000, guid: 76ed11d84beb10846a746b4259e26d39, type: 3}
+  customCharacters: 
+  fontRenderingMode: 0
+  ascentCalculationMode: 1
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Font/Roboto/Roboto-Regular.ttf.meta

@@ -0,0 +1,23 @@
+fileFormatVersion: 2
+guid: 76ed11d84beb10846a746b4259e26d39
+labels:
+- font
+timeCreated: 1515073036
+licenseType: Store
+TrueTypeFontImporter:
+  serializedVersion: 4
+  fontSize: 16
+  forceTextureCase: -2
+  characterSpacing: 0
+  characterPadding: 1
+  includeFontData: 1
+  fontNames:
+  - Roboto
+  fallbackFontReferences:
+  - {fileID: 12800000, guid: 9568ece128856a54cbc1060379ab498d, type: 3}
+  customCharacters: 
+  fontRenderingMode: 0
+  ascentCalculationMode: 1
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/GUI.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 88ea372125bb21f49adbb31579e66715
+folderAsset: yes
+timeCreated: 1513980359
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/GUI/GraphyGUISkin.guiskin.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 663039f397abaa648854c3b8ef8f4256
+labels:
+- gui
+timeCreated: 1513980352
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Graphy_CustomizationScene.unitypackage.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 9df6cd2f9439dd04fb0d7a5aeb12e189
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Martín Pane
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Assets/Plugins/Graphy/LICENSE.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 7dcb986197a7fca43a1547994c1e7ad8
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Materials.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: c859b3e9d83661640842bbb8989b021a
+folderAsset: yes
+timeCreated: 1511697723
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Materials/Audio_Spectrum_Graph.mat

@@ -0,0 +1,90 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Audio_Spectrum_Graph
+  m_Shader: {fileID: 4800000, guid: bc65170c051b0724287a7f1636d87573, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 5
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 4500
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - FpsValues_Length: 120
+    - PixelSnap: 0
+    - ScrollSpeed: 0.2
+    - _AmazingThreshold: 0.72
+    - _BumpScale: 1
+    - _CautionThreshold: 0
+    - _ColorMask: 15
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _Glossiness: 0.5
+    - _GoodThreshold: 0.5
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SrcBlend: 1
+    - _Stencil: 0
+    - _StencilComp: 8
+    - _StencilOp: 0
+    - _StencilReadMask: 255
+    - _StencilWriteMask: 255
+    - _UVSec: 0
+    - _UseUIAlphaClip: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _AmazingColor: {r: 0, g: 1, b: 1, a: 1}
+    - _CautionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _CriticalColor: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _GoodColor: {r: 1, g: 1, b: 1, a: 1}

Assets/Plugins/Graphy/Materials/Audio_Spectrum_Graph.mat.meta

@@ -0,0 +1,15 @@
+fileFormatVersion: 2
+guid: 61a418be8e5d13c448865432314f8277
+labels:
+- audio
+- graph
+- material
+- shader
+- spectrometer
+- spectrum
+timeCreated: 1513179885
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Materials/Audio_Spectrum_Highest_Values_Graph.mat

@@ -0,0 +1,90 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Audio_Spectrum_Highest_Values_Graph
+  m_Shader: {fileID: 4800000, guid: bc65170c051b0724287a7f1636d87573, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 5
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 4500
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - FpsValues_Length: 120
+    - PixelSnap: 0
+    - ScrollSpeed: 0.2
+    - _AmazingThreshold: 0.72
+    - _BumpScale: 1
+    - _CautionThreshold: 0
+    - _ColorMask: 15
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _Glossiness: 0.5
+    - _GoodThreshold: 0
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SrcBlend: 1
+    - _Stencil: 0
+    - _StencilComp: 8
+    - _StencilOp: 0
+    - _StencilReadMask: 255
+    - _StencilWriteMask: 255
+    - _UVSec: 0
+    - _UseUIAlphaClip: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _AmazingColor: {r: 0, g: 1, b: 1, a: 1}
+    - _CautionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _CriticalColor: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _GoodColor: {r: 1, g: 1, b: 1, a: 1}

Assets/Plugins/Graphy/Materials/Audio_Spectrum_Highest_Values_Graph.mat.meta

@@ -0,0 +1,15 @@
+fileFormatVersion: 2
+guid: a65c67e8efa392e4faaf526ab060ac88
+labels:
+- audio
+- graph
+- material
+- shader
+- spectrometer
+- spectrum
+timeCreated: 1513179885
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Materials/FPS_Graph.mat

@@ -0,0 +1,90 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: FPS_Graph
+  m_Shader: {fileID: 4800000, guid: 96316acf0f537ae449a9a641fa00eefe, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 5
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - FpsValues_Length: 120
+    - PixelSnap: 0
+    - ScrollSpeed: 0.2
+    - _AmazingThreshold: 0.72
+    - _BumpScale: 1
+    - _CautionThreshold: 0.2
+    - _ColorMask: 15
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _Glossiness: 0.5
+    - _GoodThreshold: 0.4
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SrcBlend: 1
+    - _Stencil: 0
+    - _StencilComp: 8
+    - _StencilOp: 0
+    - _StencilReadMask: 255
+    - _StencilWriteMask: 255
+    - _UVSec: 0
+    - _UseUIAlphaClip: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _AmazingColor: {r: 0, g: 1, b: 1, a: 1}
+    - _CautionColor: {r: 0.9137255, g: 0.76862746, b: 0.41568628, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _CriticalColor: {r: 0.90588236, g: 0.43529412, b: 0.31764707, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _GoodColor: {r: 0.20825918, g: 0.6792453, b: 0.62190783, a: 1}

Assets/Plugins/Graphy/Materials/FPS_Graph.mat.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: 8a88e148dbc2d0f45a027f72e59aee4d
+labels:
+- counter
+- fps
+- graph
+- material
+- monitor
+- shader
+- stats
+timeCreated: 1511697739
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Materials/RAM_Allocated_Graph.mat

@@ -0,0 +1,90 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: RAM_Allocated_Graph
+  m_Shader: {fileID: 4800000, guid: bc65170c051b0724287a7f1636d87573, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 5
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 4500
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - FpsValues_Length: 120
+    - PixelSnap: 0
+    - ScrollSpeed: 0.2
+    - _AmazingThreshold: 0.72
+    - _BumpScale: 1
+    - _CautionThreshold: 0
+    - _ColorMask: 15
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _Glossiness: 0.5
+    - _GoodThreshold: 0.4
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SrcBlend: 1
+    - _Stencil: 0
+    - _StencilComp: 8
+    - _StencilOp: 0
+    - _StencilReadMask: 255
+    - _StencilWriteMask: 255
+    - _UVSec: 0
+    - _UseUIAlphaClip: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _AmazingColor: {r: 0, g: 1, b: 1, a: 1}
+    - _CautionColor: {r: 0.94509804, g: 0.35686275, b: 0.70980394, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _CriticalColor: {r: 0.94509804, g: 0.35686275, b: 0.70980394, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _GoodColor: {r: 0.94509804, g: 0.35686275, b: 0.70980394, a: 1}

Assets/Plugins/Graphy/Materials/RAM_Allocated_Graph.mat.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: 6b025b045db969e4988a6267cc04938d
+labels:
+- counter
+- graph
+- material
+- memory
+- monitor
+- ram
+- shader
+timeCreated: 1512500596
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Materials/RAM_Mono_Graph.mat

@@ -0,0 +1,90 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: RAM_Mono_Graph
+  m_Shader: {fileID: 4800000, guid: bc65170c051b0724287a7f1636d87573, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 5
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 4500
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - FpsValues_Length: 120
+    - PixelSnap: 0
+    - ScrollSpeed: 0.2
+    - _AmazingThreshold: 0.72
+    - _BumpScale: 1
+    - _CautionThreshold: 0
+    - _ColorMask: 15
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _Glossiness: 0.5
+    - _GoodThreshold: 0.2
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SrcBlend: 1
+    - _Stencil: 0
+    - _StencilComp: 8
+    - _StencilOp: 0
+    - _StencilReadMask: 255
+    - _StencilWriteMask: 255
+    - _UVSec: 0
+    - _UseUIAlphaClip: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _AmazingColor: {r: 0, g: 1, b: 1, a: 1}
+    - _CautionColor: {r: 0, g: 0.73333335, b: 0.9764706, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _CriticalColor: {r: 0, g: 0.73333335, b: 0.9764706, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _GoodColor: {r: 0, g: 0.73333335, b: 0.9764706, a: 1}

Assets/Plugins/Graphy/Materials/RAM_Mono_Graph.mat.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: cb5c252f19f1cd2448f88d7f9dd989e8
+labels:
+- counter
+- graph
+- material
+- memory
+- monitor
+- ram
+- shader
+timeCreated: 1513614711
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Materials/RAM_Reserved_Graph.mat

@@ -0,0 +1,90 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: RAM_Reserved_Graph
+  m_Shader: {fileID: 4800000, guid: bc65170c051b0724287a7f1636d87573, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 5
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 4500
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - FpsValues_Length: 120
+    - PixelSnap: 0
+    - ScrollSpeed: 0.2
+    - _AmazingThreshold: 0.72
+    - _BumpScale: 1
+    - _CautionThreshold: 0
+    - _ColorMask: 15
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _Glossiness: 0.5
+    - _GoodThreshold: 0.6
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SrcBlend: 1
+    - _Stencil: 0
+    - _StencilComp: 8
+    - _StencilOp: 0
+    - _StencilReadMask: 255
+    - _StencilWriteMask: 255
+    - _UVSec: 0
+    - _UseUIAlphaClip: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _AmazingColor: {r: 0, g: 1, b: 1, a: 1}
+    - _CautionColor: {r: 0.99607843, g: 0.89411765, b: 0.2509804, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _CriticalColor: {r: 0.99607843, g: 0.89411765, b: 0.2509804, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _GoodColor: {r: 0.99607843, g: 0.89411765, b: 0.2509804, a: 1}

Assets/Plugins/Graphy/Materials/RAM_Reserved_Graph.mat.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: 5ec99183bcca10249ac54cd6dcee6372
+labels:
+- counter
+- graph
+- material
+- memory
+- monitor
+- ram
+- shader
+timeCreated: 1512501386
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Prefab.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 3be1e89ca880cc644a2aa20d1854250c
+folderAsset: yes
+timeCreated: 1511555560
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Prefab/Internal.meta

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

Assets/Plugins/Graphy/Prefab/Internal/ADVANCED - Module.prefab

@@ -0,0 +1,982 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &1775469549179903898
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 4368258586773291004}
+  - component: {fileID: 7128113785356189360}
+  - component: {fileID: 7747009470150913666}
+  - component: {fileID: 5777133856306772457}
+  m_Layer: 5
+  m_Name: vr_res_text_value
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &4368258586773291004
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1775469549179903898}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 3912740604931392962}
+  m_RootOrder: 3
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0.5}
+  m_AnchorMax: {x: 1, y: 0.5}
+  m_AnchoredPosition: {x: -0.20019531, y: 49.1}
+  m_SizeDelta: {x: -24.14, y: 50}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &7128113785356189360
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1775469549179903898}
+  m_CullTransparentMesh: 0
+--- !u!114 &7747009470150913666
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1775469549179903898}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5f7201a12d95ffc409449d95f23cf332, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 0.8627451}
+  m_RaycastTarget: 0
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_FontData:
+    m_Font: {fileID: 12800000, guid: 76ed11d84beb10846a746b4259e26d39, type: 3}
+    m_FontSize: 28
+    m_FontStyle: 0
+    m_BestFit: 0
+    m_MinSize: 2
+    m_MaxSize: 40
+    m_Alignment: 0
+    m_AlignByGeometry: 0
+    m_RichText: 0
+    m_HorizontalOverflow: 0
+    m_VerticalOverflow: 0
+    m_LineSpacing: 1
+  m_Text: 'VR: [Active: ####] (####*2)x####@##Hz'
+--- !u!114 &5777133856306772457
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1775469549179903898}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: cfabb0440166ab443bba8876756fdfa9, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_EffectColor: {r: 0, g: 0, b: 0, a: 0.903}
+  m_EffectDistance: {x: 2, y: -2}
+  m_UseGraphicAlpha: 1
+--- !u!1 &3842867399166853360
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 3912740604931392962}
+  - component: {fileID: 3843565046808148296}
+  m_Layer: 5
+  m_Name: ADVANCED - Module
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &3912740604931392962
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3842867399166853360}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 3912740601112588006}
+  - {fileID: 3843565046838049136}
+  - {fileID: 3843565046838009216}
+  - {fileID: 4368258586773291004}
+  - {fileID: 3843565046838004004}
+  - {fileID: 3843565046838038372}
+  - {fileID: 3843565046838026222}
+  - {fileID: 3843565046838054370}
+  - {fileID: 3843565046838060288}
+  - {fileID: 3912740604249537256}
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 0, y: 0}
+  m_AnchoredPosition: {x: 398.02, y: 147.6}
+  m_SizeDelta: {x: 779.63, y: 277.68}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &3843565046808148296
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3842867399166853360}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5c1019d31db77fd468164577146737ad, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_backgroundImages:
+  - {fileID: 3801623490367796942}
+  m_graphicsDeviceVersionText: {fileID: 3843565046808174610}
+  m_processorTypeText: {fileID: 3843565046808132650}
+  m_operatingSystemText: {fileID: 3801623489651697784}
+  m_systemMemoryText: {fileID: 3843565046808166342}
+  m_graphicsDeviceNameText: {fileID: 3843565046807956928}
+  m_graphicsMemorySizeText: {fileID: 3843565046808154150}
+  m_screenResolutionText: {fileID: 3843565046808147406}
+  m_gameWindowResolutionText: {fileID: 3843565046808170664}
+  m_gameVRResolutionText: {fileID: 7747009470150913666}
+  m_updateRate: 5
+--- !u!1 &3842867401653705428
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 3912740604249537256}
+  - component: {fileID: 3910151276374724292}
+  - component: {fileID: 3801623489651697784}
+  - component: {fileID: 3801623454625418656}
+  m_Layer: 5
+  m_Name: operating_system_text
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &3912740604249537256
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3842867401653705428}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 3912740604931392962}
+  m_RootOrder: 9
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0.5}
+  m_AnchorMax: {x: 1, y: 0.5}
+  m_AnchoredPosition: {x: -0.20019531, y: -128.20003}
+  m_SizeDelta: {x: -23.14, y: 50}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &3910151276374724292
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3842867401653705428}
+  m_CullTransparentMesh: 0
+--- !u!114 &3801623489651697784
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3842867401653705428}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5f7201a12d95ffc409449d95f23cf332, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 0.8627451}
+  m_RaycastTarget: 0
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_FontData:
+    m_Font: {fileID: 12800000, guid: 76ed11d84beb10846a746b4259e26d39, type: 3}
+    m_FontSize: 28
+    m_FontStyle: 0
+    m_BestFit: 0
+    m_MinSize: 2
+    m_MaxSize: 40
+    m_Alignment: 0
+    m_AlignByGeometry: 0
+    m_RichText: 0
+    m_HorizontalOverflow: 0
+    m_VerticalOverflow: 0
+    m_LineSpacing: 1
+  m_Text: 'OS: OS Version [Platform]'
+--- !u!114 &3801623454625418656
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3842867401653705428}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: cfabb0440166ab443bba8876756fdfa9, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_EffectColor: {r: 0, g: 0, b: 0, a: 0.903}
+  m_EffectDistance: {x: 2, y: -2}
+  m_UseGraphicAlpha: 1
+--- !u!1 &3842867402509575672
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 3912740601112588006}
+  - component: {fileID: 3910151276525742862}
+  - component: {fileID: 3801623490367796942}
+  m_Layer: 5
+  m_Name: BG_Image
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &3912740601112588006
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3842867402509575672}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 3912740604931392962}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &3910151276525742862
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3842867402509575672}
+  m_CullTransparentMesh: 0
+--- !u!114 &3801623490367796942
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3842867402509575672}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 0, g: 0, b: 0, a: 0.33333334}
+  m_RaycastTarget: 0
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_Sprite: {fileID: 21300000, guid: c4f7f8debbcf3cf4faf280628cab55f9, type: 3}
+  m_Type: 1
+  m_PreserveAspect: 0
+  m_FillCenter: 1
+  m_FillMethod: 4
+  m_FillAmount: 1
+  m_FillClockwise: 1
+  m_FillOrigin: 0
+  m_UseSpriteMesh: 0
+  m_PixelsPerUnitMultiplier: 1
+--- !u!1 &3843565046818344340
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 3843565046838049136}
+  - component: {fileID: 3843565046838304092}
+  - component: {fileID: 3843565046808147406}
+  - component: {fileID: 3843565046808154662}
+  m_Layer: 5
+  m_Name: screen_res_value_text
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &3843565046838049136
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818344340}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 3912740604931392962}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0.5}
+  m_AnchorMax: {x: 1, y: 0.5}
+  m_AnchoredPosition: {x: -0.20019531, y: 109.39998}
+  m_SizeDelta: {x: -24.14, y: 50}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &3843565046838304092
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818344340}
+  m_CullTransparentMesh: 0
+--- !u!114 &3843565046808147406
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818344340}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5f7201a12d95ffc409449d95f23cf332, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 0.8627451}
+  m_RaycastTarget: 0
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_FontData:
+    m_Font: {fileID: 12800000, guid: 76ed11d84beb10846a746b4259e26d39, type: 3}
+    m_FontSize: 28
+    m_FontStyle: 0
+    m_BestFit: 0
+    m_MinSize: 2
+    m_MaxSize: 40
+    m_Alignment: 0
+    m_AlignByGeometry: 0
+    m_RichText: 0
+    m_HorizontalOverflow: 0
+    m_VerticalOverflow: 0
+    m_LineSpacing: 1
+  m_Text: 'Screen: ####x####@##Hz'
+--- !u!114 &3843565046808154662
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818344340}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: cfabb0440166ab443bba8876756fdfa9, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_EffectColor: {r: 0, g: 0, b: 0, a: 0.903}
+  m_EffectDistance: {x: 2, y: -2}
+  m_UseGraphicAlpha: 1
+--- !u!1 &3843565046818361608
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 3843565046838009216}
+  - component: {fileID: 3843565046838208232}
+  - component: {fileID: 3843565046808170664}
+  - component: {fileID: 3843565046808126578}
+  m_Layer: 5
+  m_Name: window_res_text_value
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &3843565046838009216
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818361608}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 3912740604931392962}
+  m_RootOrder: 2
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0.5}
+  m_AnchorMax: {x: 1, y: 0.5}
+  m_AnchoredPosition: {x: -0.20019531, y: 79.099976}
+  m_SizeDelta: {x: -24.14, y: 50}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &3843565046838208232
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818361608}
+  m_CullTransparentMesh: 0
+--- !u!114 &3843565046808170664
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818361608}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5f7201a12d95ffc409449d95f23cf332, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 0.8627451}
+  m_RaycastTarget: 0
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_FontData:
+    m_Font: {fileID: 12800000, guid: 76ed11d84beb10846a746b4259e26d39, type: 3}
+    m_FontSize: 28
+    m_FontStyle: 0
+    m_BestFit: 0
+    m_MinSize: 2
+    m_MaxSize: 40
+    m_Alignment: 0
+    m_AlignByGeometry: 0
+    m_RichText: 0
+    m_HorizontalOverflow: 0
+    m_VerticalOverflow: 0
+    m_LineSpacing: 1
+  m_Text: 'Window: ####x####@##Hz[###dpi]'
+--- !u!114 &3843565046808126578
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818361608}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: cfabb0440166ab443bba8876756fdfa9, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_EffectColor: {r: 0, g: 0, b: 0, a: 0.903}
+  m_EffectDistance: {x: 2, y: -2}
+  m_UseGraphicAlpha: 1
+--- !u!1 &3843565046818373822
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 3843565046838054370}
+  - component: {fileID: 3843565046837891680}
+  - component: {fileID: 3843565046808132650}
+  - component: {fileID: 3843565046808136672}
+  m_Layer: 5
+  m_Name: processor_type_text
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &3843565046838054370
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818373822}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 3912740604931392962}
+  m_RootOrder: 7
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0.5}
+  m_AnchorMax: {x: 1, y: 0.5}
+  m_AnchoredPosition: {x: -0.20019531, y: -67.69999}
+  m_SizeDelta: {x: -23.14, y: 50}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &3843565046837891680
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818373822}
+  m_CullTransparentMesh: 0
+--- !u!114 &3843565046808132650
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818373822}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5f7201a12d95ffc409449d95f23cf332, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 0.8627451}
+  m_RaycastTarget: 0
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_FontData:
+    m_Font: {fileID: 12800000, guid: 76ed11d84beb10846a746b4259e26d39, type: 3}
+    m_FontSize: 28
+    m_FontStyle: 0
+    m_BestFit: 0
+    m_MinSize: 2
+    m_MaxSize: 40
+    m_Alignment: 0
+    m_AlignByGeometry: 0
+    m_RichText: 0
+    m_HorizontalOverflow: 0
+    m_VerticalOverflow: 0
+    m_LineSpacing: 1
+  m_Text: 'CPU: Processor Model [# cores]'
+--- !u!114 &3843565046808136672
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818373822}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: cfabb0440166ab443bba8876756fdfa9, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_EffectColor: {r: 0, g: 0, b: 0, a: 0.903}
+  m_EffectDistance: {x: 2, y: -2}
+  m_UseGraphicAlpha: 1
+--- !u!1 &3843565046818375086
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 3843565046838026222}
+  - component: {fileID: 3843565046838222574}
+  - component: {fileID: 3843565046808154150}
+  - component: {fileID: 3843565046808169168}
+  m_Layer: 5
+  m_Name: graphics_memory_size_text
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &3843565046838026222
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818375086}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 3912740604931392962}
+  m_RootOrder: 6
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0.5}
+  m_AnchorMax: {x: 1, y: 0.5}
+  m_AnchoredPosition: {x: -0.20019531, y: -38.69999}
+  m_SizeDelta: {x: -23.14, y: 50}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &3843565046838222574
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818375086}
+  m_CullTransparentMesh: 0
+--- !u!114 &3843565046808154150
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818375086}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5f7201a12d95ffc409449d95f23cf332, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 0.8627451}
+  m_RaycastTarget: 0
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_FontData:
+    m_Font: {fileID: 12800000, guid: 76ed11d84beb10846a746b4259e26d39, type: 3}
+    m_FontSize: 28
+    m_FontStyle: 0
+    m_BestFit: 0
+    m_MinSize: 2
+    m_MaxSize: 40
+    m_Alignment: 0
+    m_AlignByGeometry: 0
+    m_RichText: 0
+    m_HorizontalOverflow: 0
+    m_VerticalOverflow: 0
+    m_LineSpacing: 1
+  m_Text: 'VRAM: ####MB. Max texture size: ####px. Shader level: ##'
+--- !u!114 &3843565046808169168
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818375086}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: cfabb0440166ab443bba8876756fdfa9, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_EffectColor: {r: 0, g: 0, b: 0, a: 0.903}
+  m_EffectDistance: {x: 2, y: -2}
+  m_UseGraphicAlpha: 1
+--- !u!1 &3843565046818382618
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 3843565046838004004}
+  - component: {fileID: 3843565046838311234}
+  - component: {fileID: 3843565046808174610}
+  - component: {fileID: 3843565046808173802}
+  m_Layer: 5
+  m_Name: graphics_device_version_text
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &3843565046838004004
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818382618}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 3912740604931392962}
+  m_RootOrder: 4
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0.5}
+  m_AnchorMax: {x: 1, y: 0.5}
+  m_AnchoredPosition: {x: -0.20019531, y: 19.300018}
+  m_SizeDelta: {x: -23.14, y: 50}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &3843565046838311234
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818382618}
+  m_CullTransparentMesh: 0
+--- !u!114 &3843565046808174610
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818382618}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5f7201a12d95ffc409449d95f23cf332, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 0.8627451}
+  m_RaycastTarget: 0
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_FontData:
+    m_Font: {fileID: 12800000, guid: 76ed11d84beb10846a746b4259e26d39, type: 3}
+    m_FontSize: 28
+    m_FontStyle: 0
+    m_BestFit: 0
+    m_MinSize: 2
+    m_MaxSize: 40
+    m_Alignment: 0
+    m_AlignByGeometry: 0
+    m_RichText: 0
+    m_HorizontalOverflow: 0
+    m_VerticalOverflow: 0
+    m_LineSpacing: 1
+  m_Text: 'Graphics API: Graphics API version [level ##]'
+--- !u!114 &3843565046808173802
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818382618}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: cfabb0440166ab443bba8876756fdfa9, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_EffectColor: {r: 0, g: 0, b: 0, a: 0.903}
+  m_EffectDistance: {x: 2, y: -2}
+  m_UseGraphicAlpha: 1
+--- !u!1 &3843565046818384376
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 3843565046838038372}
+  - component: {fileID: 3843565046838255100}
+  - component: {fileID: 3843565046807956928}
+  - component: {fileID: 3843565046808176320}
+  m_Layer: 5
+  m_Name: graphics_device_name_text
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &3843565046838038372
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818384376}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 3912740604931392962}
+  m_RootOrder: 5
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0.5}
+  m_AnchorMax: {x: 1, y: 0.5}
+  m_AnchoredPosition: {x: -0.20019531, y: -9.699982}
+  m_SizeDelta: {x: -23.14, y: 50}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &3843565046838255100
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818384376}
+  m_CullTransparentMesh: 0
+--- !u!114 &3843565046807956928
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818384376}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5f7201a12d95ffc409449d95f23cf332, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 0.8627451}
+  m_RaycastTarget: 0
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_FontData:
+    m_Font: {fileID: 12800000, guid: 76ed11d84beb10846a746b4259e26d39, type: 3}
+    m_FontSize: 28
+    m_FontStyle: 0
+    m_BestFit: 0
+    m_MinSize: 2
+    m_MaxSize: 40
+    m_Alignment: 0
+    m_AlignByGeometry: 0
+    m_RichText: 0
+    m_HorizontalOverflow: 0
+    m_VerticalOverflow: 0
+    m_LineSpacing: 1
+  m_Text: 'GPU: Graphics Card Name'
+--- !u!114 &3843565046808176320
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818384376}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: cfabb0440166ab443bba8876756fdfa9, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_EffectColor: {r: 0, g: 0, b: 0, a: 0.903}
+  m_EffectDistance: {x: 2, y: -2}
+  m_UseGraphicAlpha: 1
+--- !u!1 &3843565046818385094
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 3843565046838060288}
+  - component: {fileID: 3843565046838236824}
+  - component: {fileID: 3843565046808166342}
+  - component: {fileID: 3843565046808068368}
+  m_Layer: 5
+  m_Name: ram_text
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &3843565046838060288
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818385094}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 3912740604931392962}
+  m_RootOrder: 8
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0.5}
+  m_AnchorMax: {x: 1, y: 0.5}
+  m_AnchoredPosition: {x: -0.20019531, y: -97.19999}
+  m_SizeDelta: {x: -23.14, y: 50}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &3843565046838236824
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818385094}
+  m_CullTransparentMesh: 0
+--- !u!114 &3843565046808166342
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818385094}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5f7201a12d95ffc409449d95f23cf332, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 0.8627451}
+  m_RaycastTarget: 0
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_FontData:
+    m_Font: {fileID: 12800000, guid: 76ed11d84beb10846a746b4259e26d39, type: 3}
+    m_FontSize: 28
+    m_FontStyle: 0
+    m_BestFit: 0
+    m_MinSize: 2
+    m_MaxSize: 40
+    m_Alignment: 0
+    m_AlignByGeometry: 0
+    m_RichText: 0
+    m_HorizontalOverflow: 0
+    m_VerticalOverflow: 0
+    m_LineSpacing: 1
+  m_Text: 'RAM: #### MB'
+--- !u!114 &3843565046808068368
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 3843565046818385094}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: cfabb0440166ab443bba8876756fdfa9, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_EffectColor: {r: 0, g: 0, b: 0, a: 0.903}
+  m_EffectDistance: {x: 2, y: -2}
+  m_UseGraphicAlpha: 1

Assets/Plugins/Graphy/Prefab/Internal/ADVANCED - Module.prefab.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 8e60b58e9eec36e46ba32caf55a802f4
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Prefab/Internal/AUDIO - Module.prefab

@@ -0,0 +1,662 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &8023522192042546097
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 7800522346346212061}
+  - component: {fileID: 7804307952332944447}
+  - component: {fileID: 7984821691181171211}
+  - component: {fileID: 7984821690819282791}
+  m_Layer: 5
+  m_Name: db_value_text
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &7800522346346212061
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023522192042546097}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 8023949359419186811}
+  m_RootOrder: 3
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0.5, y: 0.5}
+  m_AnchorMax: {x: 0.5, y: 0.5}
+  m_AnchoredPosition: {x: -30.7, y: 26.300013}
+  m_SizeDelta: {x: 290.6, y: 44}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &7804307952332944447
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023522192042546097}
+  m_CullTransparentMesh: 0
+--- !u!114 &7984821691181171211
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023522192042546097}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5f7201a12d95ffc409449d95f23cf332, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 0.8627451}
+  m_RaycastTarget: 0
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_FontData:
+    m_Font: {fileID: 12800000, guid: 76ed11d84beb10846a746b4259e26d39, type: 3}
+    m_FontSize: 28
+    m_FontStyle: 0
+    m_BestFit: 0
+    m_MinSize: 2
+    m_MaxSize: 40
+    m_Alignment: 2
+    m_AlignByGeometry: 0
+    m_RichText: 0
+    m_HorizontalOverflow: 0
+    m_VerticalOverflow: 0
+    m_LineSpacing: 1
+  m_Text: -##
+--- !u!114 &7984821690819282791
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023522192042546097}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: cfabb0440166ab443bba8876756fdfa9, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_EffectColor: {r: 0, g: 0, b: 0, a: 0.903}
+  m_EffectDistance: {x: 2, y: -2}
+  m_UseGraphicAlpha: 1
+--- !u!1 &8023522193019896535
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 7800522349053869169}
+  - component: {fileID: 7804307952451012049}
+  - component: {fileID: 7984821710221682845}
+  m_Layer: 5
+  m_Name: BG_Image_TEXT
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 0
+--- !u!224 &7800522349053869169
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023522193019896535}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 8023949359419186811}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: 0.024932861, y: 31.98}
+  m_SizeDelta: {x: 0.05, y: -63.95}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &7804307952451012049
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023522193019896535}
+  m_CullTransparentMesh: 0
+--- !u!114 &7984821710221682845
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023522193019896535}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 0, g: 0, b: 0, a: 0.33333334}
+  m_RaycastTarget: 0
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_Sprite: {fileID: 21300000, guid: c4f7f8debbcf3cf4faf280628cab55f9, type: 3}
+  m_Type: 1
+  m_PreserveAspect: 0
+  m_FillCenter: 1
+  m_FillMethod: 4
+  m_FillAmount: 1
+  m_FillClockwise: 1
+  m_FillOrigin: 0
+  m_UseSpriteMesh: 0
+  m_PixelsPerUnitMultiplier: 1
+--- !u!1 &8023522193285040417
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 7800522348713255227}
+  - component: {fileID: 7804307938193033233}
+  - component: {fileID: 7984821691142389341}
+  m_Layer: 5
+  m_Name: audio_spectrum_graph
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &7800522348713255227
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023522193285040417}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 8023949359419152847}
+  - {fileID: 7800522347927017199}
+  m_Father: {fileID: 8023949359419186811}
+  m_RootOrder: 2
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 1, y: 0}
+  m_AnchoredPosition: {x: 0.23901367, y: 36.77}
+  m_SizeDelta: {x: -15.480011, y: 57.76}
+  m_Pivot: {x: 0.4999999, y: 0.50000024}
+--- !u!222 &7804307938193033233
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023522193285040417}
+  m_CullTransparentMesh: 0
+--- !u!114 &7984821691142389341
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023522193285040417}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 2100000, guid: 61a418be8e5d13c448865432314f8277, type: 2}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 0
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_Sprite: {fileID: 21300000, guid: ad4148593b05d0f47980774815c325fe, type: 3}
+  m_Type: 0
+  m_PreserveAspect: 0
+  m_FillCenter: 1
+  m_FillMethod: 4
+  m_FillAmount: 1
+  m_FillClockwise: 1
+  m_FillOrigin: 0
+  m_UseSpriteMesh: 0
+  m_PixelsPerUnitMultiplier: 1
+--- !u!1 &8023522193599714111
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 7800522347927017199}
+  - component: {fileID: 7804307952974665897}
+  - component: {fileID: 7984821691078566919}
+  m_Layer: 5
+  m_Name: audio_text_inside_graph
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &7800522347927017199
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023522193599714111}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 7800522348713255227}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 0, y: 0}
+  m_AnchoredPosition: {x: 51, y: 25.7}
+  m_SizeDelta: {x: 99.5, y: 60.700012}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &7804307952974665897
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023522193599714111}
+  m_CullTransparentMesh: 0
+--- !u!114 &7984821691078566919
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023522193599714111}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5f7201a12d95ffc409449d95f23cf332, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 0.4627451}
+  m_RaycastTarget: 0
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_FontData:
+    m_Font: {fileID: 12800000, guid: 76ed11d84beb10846a746b4259e26d39, type: 3}
+    m_FontSize: 25
+    m_FontStyle: 0
+    m_BestFit: 0
+    m_MinSize: 0
+    m_MaxSize: 40
+    m_Alignment: 6
+    m_AlignByGeometry: 0
+    m_RichText: 0
+    m_HorizontalOverflow: 0
+    m_VerticalOverflow: 0
+    m_LineSpacing: 1
+  m_Text: audio
+--- !u!1 &8023522193710420455
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 7800522347690658609}
+  - component: {fileID: 7804307938358383139}
+  - component: {fileID: 7984821689660256287}
+  m_Layer: 5
+  m_Name: BG_Image_FULL
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &7800522347690658609
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023522193710420455}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 8023949359419186811}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: 0.024963379, y: 0.0000076293945}
+  m_SizeDelta: {x: 0.049927, y: 0.0000076294}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &7804307938358383139
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023522193710420455}
+  m_CullTransparentMesh: 0
+--- !u!114 &7984821689660256287
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023522193710420455}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 0, g: 0, b: 0, a: 0.33333334}
+  m_RaycastTarget: 0
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_Sprite: {fileID: 21300000, guid: c4f7f8debbcf3cf4faf280628cab55f9, type: 3}
+  m_Type: 1
+  m_PreserveAspect: 0
+  m_FillCenter: 1
+  m_FillMethod: 4
+  m_FillAmount: 1
+  m_FillClockwise: 1
+  m_FillOrigin: 0
+  m_UseSpriteMesh: 0
+  m_PixelsPerUnitMultiplier: 1
+--- !u!1 &8023949359398923053
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 8023949359419137277}
+  - component: {fileID: 8023949359418881589}
+  - component: {fileID: 8023949359389300505}
+  - component: {fileID: 8023949359389220047}
+  m_Layer: 5
+  m_Name: db_text
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &8023949359419137277
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023949359398923053}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 8023949359419186811}
+  m_RootOrder: 4
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0.5, y: 0.5}
+  m_AnchorMax: {x: 0.5, y: 0.5}
+  m_AnchoredPosition: {x: 11.299927, y: 26.3}
+  m_SizeDelta: {x: 290.6, y: 44}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &8023949359418881589
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023949359398923053}
+  m_CullTransparentMesh: 0
+--- !u!114 &8023949359389300505
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023949359398923053}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5f7201a12d95ffc409449d95f23cf332, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 0.8627451}
+  m_RaycastTarget: 0
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_FontData:
+    m_Font: {fileID: 12800000, guid: 76ed11d84beb10846a746b4259e26d39, type: 3}
+    m_FontSize: 28
+    m_FontStyle: 0
+    m_BestFit: 0
+    m_MinSize: 2
+    m_MaxSize: 40
+    m_Alignment: 2
+    m_AlignByGeometry: 0
+    m_RichText: 0
+    m_HorizontalOverflow: 0
+    m_VerticalOverflow: 0
+    m_LineSpacing: 1
+  m_Text: dB
+--- !u!114 &8023949359389220047
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023949359398923053}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: cfabb0440166ab443bba8876756fdfa9, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_EffectColor: {r: 0, g: 0, b: 0, a: 0.903}
+  m_EffectDistance: {x: 2, y: -2}
+  m_UseGraphicAlpha: 1
+--- !u!1 &8023949359398946881
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 8023949359419152847}
+  - component: {fileID: 8023949359418881755}
+  - component: {fileID: 8023949359389187151}
+  m_Layer: 5
+  m_Name: audio_spectrum_highest_values_graph
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &8023949359419152847
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023949359398946881}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 7800522348713255227}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0.4999999, y: 0.50000024}
+--- !u!222 &8023949359418881755
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023949359398946881}
+  m_CullTransparentMesh: 0
+--- !u!114 &8023949359389187151
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023949359398946881}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 2100000, guid: a65c67e8efa392e4faaf526ab060ac88, type: 2}
+  m_Color: {r: 1, g: 1, b: 1, a: 0.5019608}
+  m_RaycastTarget: 0
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_Sprite: {fileID: 21300000, guid: ad4148593b05d0f47980774815c325fe, type: 3}
+  m_Type: 0
+  m_PreserveAspect: 0
+  m_FillCenter: 1
+  m_FillMethod: 4
+  m_FillAmount: 1
+  m_FillClockwise: 1
+  m_FillOrigin: 0
+  m_UseSpriteMesh: 0
+  m_PixelsPerUnitMultiplier: 1
+--- !u!1 &8023949359398975867
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 8023949359419186811}
+  - component: {fileID: 8023949359389265205}
+  - component: {fileID: 8023949359389242119}
+  - component: {fileID: 8023949359389228359}
+  - component: {fileID: 8023949359389258805}
+  m_Layer: 5
+  m_Name: AUDIO - Module
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &8023949359419186811
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023949359398975867}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 7800522347690658609}
+  - {fileID: 7800522349053869169}
+  - {fileID: 7800522348713255227}
+  - {fileID: 7800522346346212061}
+  - {fileID: 8023949359419137277}
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 1, y: 1}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: -176.6, y: -412}
+  m_SizeDelta: {x: 330, y: 102.5}
+  m_Pivot: {x: 0.5000003, y: 0.49999994}
+--- !u!114 &8023949359389265205
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023949359398975867}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 766a588f9a6cb55499c66ea772072e11, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_DBText: {fileID: 7984821691181171211}
+--- !u!114 &8023949359389242119
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023949359398975867}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 2216f4eff6a7a8a43b38b180fdd2fd9e, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+--- !u!114 &8023949359389228359
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023949359398975867}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: f2d6ca19dafe21b4b983441274e7f12a, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_imageGraph: {fileID: 7984821691142389341}
+  m_imageGraphHighestValues: {fileID: 8023949359389187151}
+  ShaderFull: {fileID: 4800000, guid: bc65170c051b0724287a7f1636d87573, type: 3}
+  ShaderLight: {fileID: 4800000, guid: 96316acf0f537ae449a9a641fa00eefe, type: 3}
+  m_isInitialized: 0
+--- !u!114 &8023949359389258805
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8023949359398975867}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 8c0448d8db852b54480670d291c04f1a, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_audioGraphGameObject: {fileID: 8023522193285040417}
+  m_audioDbText: {fileID: 7984821691181171211}
+  m_backgroundImages:
+  - {fileID: 7984821689660256287}
+  - {fileID: 7984821710221682845}

Assets/Plugins/Graphy/Prefab/Internal/AUDIO - Module.prefab.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 78081648e28527242bb334a6bdf7bfce
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Prefab/Internal/FPS - Module.prefab.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: fed2d45066a6d2a4191aa0c744a03147
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Prefab/Internal/RAM - Module.prefab.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 6387d68cbe02d2d4fb8912f794606585
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Prefab/[Graphy].prefab

@@ -0,0 +1,721 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &177638
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 22451668}
+  - component: {fileID: 22323726}
+  - component: {fileID: 11439282}
+  - component: {fileID: 11496292}
+  - component: {fileID: 11480938}
+  m_Layer: 5
+  m_Name: '[Graphy]'
+  m_TagString: Untagged
+  m_Icon: {fileID: 1638116407661442457, guid: 0000000000000000d000000000000000, type: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &22451668
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 177638}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 0, y: 0, z: 0}
+  m_Children:
+  - {fileID: 6658570366365034085}
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 0, y: 0}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0, y: 0}
+--- !u!223 &22323726
+Canvas:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 177638}
+  m_Enabled: 1
+  serializedVersion: 3
+  m_RenderMode: 0
+  m_Camera: {fileID: 0}
+  m_PlaneDistance: 100
+  m_PixelPerfect: 1
+  m_ReceivesEvents: 1
+  m_OverrideSorting: 0
+  m_OverridePixelPerfect: 0
+  m_SortingBucketNormalizedSize: 0
+  m_AdditionalShaderChannelsFlag: 25
+  m_SortingLayerID: 0
+  m_SortingOrder: 30000
+  m_TargetDisplay: 0
+--- !u!114 &11439282
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 177638}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 0cd44c1031e13a943bb63640046fad76, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_UiScaleMode: 1
+  m_ReferencePixelsPerUnit: 100
+  m_ScaleFactor: 0.66
+  m_ReferenceResolution: {x: 1920, y: 1080}
+  m_ScreenMatchMode: 0
+  m_MatchWidthOrHeight: 0.5
+  m_PhysicalUnit: 3
+  m_FallbackScreenDPI: 96
+  m_DefaultSpriteDPI: 96
+  m_DynamicPixelsPerUnit: 1
+--- !u!114 &11496292
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 177638}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: c80e6d63202cef44ca3ffdaccec693be, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_graphyMode: 0
+  m_enableOnStartup: 1
+  m_keepAlive: 1
+  m_background: 1
+  m_backgroundColor: {r: 0, g: 0, b: 0, a: 0.33333334}
+  m_enableHotkeys: 1
+  m_toggleModeKeyCode: 103
+  m_toggleModeCtrl: 1
+  m_toggleModeAlt: 0
+  m_toggleActiveKeyCode: 104
+  m_toggleActiveCtrl: 1
+  m_toggleActiveAlt: 0
+  m_graphModulePosition: 0
+  m_graphModuleOffset: {x: 0, y: 0}
+  m_fpsModuleState: 0
+  m_goodFpsColor: {r: 0.20825918, g: 0.6792453, b: 0.62190783, a: 1}
+  m_goodFpsThreshold: 60
+  m_cautionFpsColor: {r: 0.9137255, g: 0.76862746, b: 0.41568628, a: 1}
+  m_cautionFpsThreshold: 30
+  m_criticalFpsColor: {r: 0.90588236, g: 0.43529412, b: 0.31764707, a: 1}
+  m_fpsGraphResolution: 150
+  m_fpsTextUpdateRate: 3
+  m_ramModuleState: 0
+  m_allocatedRamColor: {r: 0.94509804, g: 0.35686275, b: 0.70980394, a: 1}
+  m_reservedRamColor: {r: 0.99607843, g: 0.89411765, b: 0.2509804, a: 1}
+  m_monoRamColor: {r: 0, g: 0.73333335, b: 0.9764706, a: 1}
+  m_ramGraphResolution: 150
+  m_ramTextUpdateRate: 3
+  m_audioModuleState: 0
+  m_findAudioListenerInCameraIfNull: 1
+  m_audioListener: {fileID: 0}
+  m_audioGraphColor: {r: 1, g: 1, b: 1, a: 1}
+  m_audioGraphResolution: 81
+  m_audioTextUpdateRate: 3
+  m_FFTWindow: 4
+  m_spectrumSize: 512
+  m_advancedModulePosition: 3
+  m_advancedModuleOffset: {x: 0, y: 0}
+  m_advancedModuleState: 0
+--- !u!114 &11480938
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 177638}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: cb8428f1f208dcc49b6c04976d44cbc9, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_debugPackets:
+  - Active: 1
+    Id: 1
+    ExecuteOnce: 1
+    InitSleepTime: 2
+    ExecuteSleepTime: 2
+    ConditionEvaluation: 0
+    DebugConditions:
+    - Variable: 0
+      Comparer: 0
+      Value: 0
+    MessageType: 0
+    Message: 
+    TakeScreenshot: 0
+    ScreenshotFileName: 
+    DebugBreak: 0
+    UnityEvents:
+      m_PersistentCalls:
+        m_Calls: []
+--- !u!1 &5196267727675805697
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 6658570366365034085}
+  - component: {fileID: 6760672456574371718}
+  m_Layer: 5
+  m_Name: SafeArea
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &6658570366365034085
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 5196267727675805697}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 22431670}
+  - {fileID: 22415034}
+  - {fileID: 22493042}
+  - {fileID: 224000010937413736}
+  m_Father: {fileID: 22451668}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &6760672456574371718
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 5196267727675805697}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 2f4bf9244f3564807b739e8f5138ce08, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_conformX: 1
+  m_conformY: 1
+--- !u!1001 &824167088398634459
+PrefabInstance:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Modification:
+    m_TransformParent: {fileID: 6658570366365034085}
+    m_Modifications:
+    - target: {fileID: 824167088385395553, guid: 6387d68cbe02d2d4fb8912f794606585,
+        type: 3}
+      propertyPath: m_Pivot.x
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 824167088385395553, guid: 6387d68cbe02d2d4fb8912f794606585,
+        type: 3}
+      propertyPath: m_Pivot.y
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 824167088385395553, guid: 6387d68cbe02d2d4fb8912f794606585,
+        type: 3}
+      propertyPath: m_RootOrder
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 824167088385395553, guid: 6387d68cbe02d2d4fb8912f794606585,
+        type: 3}
+      propertyPath: m_AnchorMax.x
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 824167088385395553, guid: 6387d68cbe02d2d4fb8912f794606585,
+        type: 3}
+      propertyPath: m_AnchorMax.y
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 824167088385395553, guid: 6387d68cbe02d2d4fb8912f794606585,
+        type: 3}
+      propertyPath: m_AnchorMin.x
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 824167088385395553, guid: 6387d68cbe02d2d4fb8912f794606585,
+        type: 3}
+      propertyPath: m_AnchorMin.y
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 824167088385395553, guid: 6387d68cbe02d2d4fb8912f794606585,
+        type: 3}
+      propertyPath: m_SizeDelta.x
+      value: 330
+      objectReference: {fileID: 0}
+    - target: {fileID: 824167088385395553, guid: 6387d68cbe02d2d4fb8912f794606585,
+        type: 3}
+      propertyPath: m_SizeDelta.y
+      value: 166.3
+      objectReference: {fileID: 0}
+    - target: {fileID: 824167088385395553, guid: 6387d68cbe02d2d4fb8912f794606585,
+        type: 3}
+      propertyPath: m_LocalPosition.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 824167088385395553, guid: 6387d68cbe02d2d4fb8912f794606585,
+        type: 3}
+      propertyPath: m_LocalPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 824167088385395553, guid: 6387d68cbe02d2d4fb8912f794606585,
+        type: 3}
+      propertyPath: m_LocalPosition.z
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 824167088385395553, guid: 6387d68cbe02d2d4fb8912f794606585,
+        type: 3}
+      propertyPath: m_LocalRotation.w
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 824167088385395553, guid: 6387d68cbe02d2d4fb8912f794606585,
+        type: 3}
+      propertyPath: m_LocalRotation.x
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 824167088385395553, guid: 6387d68cbe02d2d4fb8912f794606585,
+        type: 3}
+      propertyPath: m_LocalRotation.y
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 824167088385395553, guid: 6387d68cbe02d2d4fb8912f794606585,
+        type: 3}
+      propertyPath: m_LocalRotation.z
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 824167088385395553, guid: 6387d68cbe02d2d4fb8912f794606585,
+        type: 3}
+      propertyPath: m_AnchoredPosition.x
+      value: -10
+      objectReference: {fileID: 0}
+    - target: {fileID: 824167088385395553, guid: 6387d68cbe02d2d4fb8912f794606585,
+        type: 3}
+      propertyPath: m_AnchoredPosition.y
+      value: -188.6
+      objectReference: {fileID: 0}
+    - target: {fileID: 824167088385395553, guid: 6387d68cbe02d2d4fb8912f794606585,
+        type: 3}
+      propertyPath: m_LocalEulerAnglesHint.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 824167088385395553, guid: 6387d68cbe02d2d4fb8912f794606585,
+        type: 3}
+      propertyPath: m_LocalEulerAnglesHint.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 824167088385395553, guid: 6387d68cbe02d2d4fb8912f794606585,
+        type: 3}
+      propertyPath: m_LocalEulerAnglesHint.z
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 824167088398773255, guid: 6387d68cbe02d2d4fb8912f794606585,
+        type: 3}
+      propertyPath: m_Name
+      value: RAM - Module
+      objectReference: {fileID: 0}
+    m_RemovedComponents: []
+  m_SourcePrefab: {fileID: 100100000, guid: 6387d68cbe02d2d4fb8912f794606585, type: 3}
+--- !u!224 &22415034 stripped
+RectTransform:
+  m_CorrespondingSourceObject: {fileID: 824167088385395553, guid: 6387d68cbe02d2d4fb8912f794606585,
+    type: 3}
+  m_PrefabInstance: {fileID: 824167088398634459}
+  m_PrefabAsset: {fileID: 0}
+--- !u!1001 &3843565046818239914
+PrefabInstance:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Modification:
+    m_TransformParent: {fileID: 6658570366365034085}
+    m_Modifications:
+    - target: {fileID: 3842867399166853360, guid: 8e60b58e9eec36e46ba32caf55a802f4,
+        type: 3}
+      propertyPath: m_Name
+      value: ADVANCED - Module
+      objectReference: {fileID: 0}
+    - target: {fileID: 3912740604931392962, guid: 8e60b58e9eec36e46ba32caf55a802f4,
+        type: 3}
+      propertyPath: m_Pivot.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3912740604931392962, guid: 8e60b58e9eec36e46ba32caf55a802f4,
+        type: 3}
+      propertyPath: m_Pivot.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3912740604931392962, guid: 8e60b58e9eec36e46ba32caf55a802f4,
+        type: 3}
+      propertyPath: m_RootOrder
+      value: 3
+      objectReference: {fileID: 0}
+    - target: {fileID: 3912740604931392962, guid: 8e60b58e9eec36e46ba32caf55a802f4,
+        type: 3}
+      propertyPath: m_AnchorMax.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3912740604931392962, guid: 8e60b58e9eec36e46ba32caf55a802f4,
+        type: 3}
+      propertyPath: m_AnchorMax.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3912740604931392962, guid: 8e60b58e9eec36e46ba32caf55a802f4,
+        type: 3}
+      propertyPath: m_AnchorMin.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3912740604931392962, guid: 8e60b58e9eec36e46ba32caf55a802f4,
+        type: 3}
+      propertyPath: m_AnchorMin.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3912740604931392962, guid: 8e60b58e9eec36e46ba32caf55a802f4,
+        type: 3}
+      propertyPath: m_SizeDelta.x
+      value: 779.63
+      objectReference: {fileID: 0}
+    - target: {fileID: 3912740604931392962, guid: 8e60b58e9eec36e46ba32caf55a802f4,
+        type: 3}
+      propertyPath: m_SizeDelta.y
+      value: 277.68
+      objectReference: {fileID: 0}
+    - target: {fileID: 3912740604931392962, guid: 8e60b58e9eec36e46ba32caf55a802f4,
+        type: 3}
+      propertyPath: m_LocalPosition.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3912740604931392962, guid: 8e60b58e9eec36e46ba32caf55a802f4,
+        type: 3}
+      propertyPath: m_LocalPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3912740604931392962, guid: 8e60b58e9eec36e46ba32caf55a802f4,
+        type: 3}
+      propertyPath: m_LocalPosition.z
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3912740604931392962, guid: 8e60b58e9eec36e46ba32caf55a802f4,
+        type: 3}
+      propertyPath: m_LocalRotation.w
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 3912740604931392962, guid: 8e60b58e9eec36e46ba32caf55a802f4,
+        type: 3}
+      propertyPath: m_LocalRotation.x
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3912740604931392962, guid: 8e60b58e9eec36e46ba32caf55a802f4,
+        type: 3}
+      propertyPath: m_LocalRotation.y
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3912740604931392962, guid: 8e60b58e9eec36e46ba32caf55a802f4,
+        type: 3}
+      propertyPath: m_LocalRotation.z
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3912740604931392962, guid: 8e60b58e9eec36e46ba32caf55a802f4,
+        type: 3}
+      propertyPath: m_AnchoredPosition.x
+      value: 10
+      objectReference: {fileID: 0}
+    - target: {fileID: 3912740604931392962, guid: 8e60b58e9eec36e46ba32caf55a802f4,
+        type: 3}
+      propertyPath: m_AnchoredPosition.y
+      value: 10
+      objectReference: {fileID: 0}
+    - target: {fileID: 3912740604931392962, guid: 8e60b58e9eec36e46ba32caf55a802f4,
+        type: 3}
+      propertyPath: m_LocalEulerAnglesHint.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3912740604931392962, guid: 8e60b58e9eec36e46ba32caf55a802f4,
+        type: 3}
+      propertyPath: m_LocalEulerAnglesHint.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 3912740604931392962, guid: 8e60b58e9eec36e46ba32caf55a802f4,
+        type: 3}
+      propertyPath: m_LocalEulerAnglesHint.z
+      value: 0
+      objectReference: {fileID: 0}
+    m_RemovedComponents: []
+  m_SourcePrefab: {fileID: 100100000, guid: 8e60b58e9eec36e46ba32caf55a802f4, type: 3}
+--- !u!224 &224000010937413736 stripped
+RectTransform:
+  m_CorrespondingSourceObject: {fileID: 3912740604931392962, guid: 8e60b58e9eec36e46ba32caf55a802f4,
+    type: 3}
+  m_PrefabInstance: {fileID: 3843565046818239914}
+  m_PrefabAsset: {fileID: 0}
+--- !u!1001 &6365662255711947173
+PrefabInstance:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Modification:
+    m_TransformParent: {fileID: 6658570366365034085}
+    m_Modifications:
+    - target: {fileID: 6365662255690075667, guid: fed2d45066a6d2a4191aa0c744a03147,
+        type: 3}
+      propertyPath: m_Pivot.x
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 6365662255690075667, guid: fed2d45066a6d2a4191aa0c744a03147,
+        type: 3}
+      propertyPath: m_Pivot.y
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 6365662255690075667, guid: fed2d45066a6d2a4191aa0c744a03147,
+        type: 3}
+      propertyPath: m_RootOrder
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 6365662255690075667, guid: fed2d45066a6d2a4191aa0c744a03147,
+        type: 3}
+      propertyPath: m_AnchorMax.x
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 6365662255690075667, guid: fed2d45066a6d2a4191aa0c744a03147,
+        type: 3}
+      propertyPath: m_AnchorMax.y
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 6365662255690075667, guid: fed2d45066a6d2a4191aa0c744a03147,
+        type: 3}
+      propertyPath: m_AnchorMin.x
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 6365662255690075667, guid: fed2d45066a6d2a4191aa0c744a03147,
+        type: 3}
+      propertyPath: m_AnchorMin.y
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 6365662255690075667, guid: fed2d45066a6d2a4191aa0c744a03147,
+        type: 3}
+      propertyPath: m_SizeDelta.x
+      value: 330
+      objectReference: {fileID: 0}
+    - target: {fileID: 6365662255690075667, guid: fed2d45066a6d2a4191aa0c744a03147,
+        type: 3}
+      propertyPath: m_SizeDelta.y
+      value: 172.6
+      objectReference: {fileID: 0}
+    - target: {fileID: 6365662255690075667, guid: fed2d45066a6d2a4191aa0c744a03147,
+        type: 3}
+      propertyPath: m_LocalPosition.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 6365662255690075667, guid: fed2d45066a6d2a4191aa0c744a03147,
+        type: 3}
+      propertyPath: m_LocalPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 6365662255690075667, guid: fed2d45066a6d2a4191aa0c744a03147,
+        type: 3}
+      propertyPath: m_LocalPosition.z
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 6365662255690075667, guid: fed2d45066a6d2a4191aa0c744a03147,
+        type: 3}
+      propertyPath: m_LocalRotation.w
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 6365662255690075667, guid: fed2d45066a6d2a4191aa0c744a03147,
+        type: 3}
+      propertyPath: m_LocalRotation.x
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 6365662255690075667, guid: fed2d45066a6d2a4191aa0c744a03147,
+        type: 3}
+      propertyPath: m_LocalRotation.y
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 6365662255690075667, guid: fed2d45066a6d2a4191aa0c744a03147,
+        type: 3}
+      propertyPath: m_LocalRotation.z
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 6365662255690075667, guid: fed2d45066a6d2a4191aa0c744a03147,
+        type: 3}
+      propertyPath: m_AnchoredPosition.x
+      value: -10
+      objectReference: {fileID: 0}
+    - target: {fileID: 6365662255690075667, guid: fed2d45066a6d2a4191aa0c744a03147,
+        type: 3}
+      propertyPath: m_AnchoredPosition.y
+      value: -10
+      objectReference: {fileID: 0}
+    - target: {fileID: 6365662255690075667, guid: fed2d45066a6d2a4191aa0c744a03147,
+        type: 3}
+      propertyPath: m_LocalEulerAnglesHint.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 6365662255690075667, guid: fed2d45066a6d2a4191aa0c744a03147,
+        type: 3}
+      propertyPath: m_LocalEulerAnglesHint.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 6365662255690075667, guid: fed2d45066a6d2a4191aa0c744a03147,
+        type: 3}
+      propertyPath: m_LocalEulerAnglesHint.z
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 6365662255711835907, guid: fed2d45066a6d2a4191aa0c744a03147,
+        type: 3}
+      propertyPath: m_Name
+      value: FPS - Module
+      objectReference: {fileID: 0}
+    m_RemovedComponents: []
+  m_SourcePrefab: {fileID: 100100000, guid: fed2d45066a6d2a4191aa0c744a03147, type: 3}
+--- !u!224 &22431670 stripped
+RectTransform:
+  m_CorrespondingSourceObject: {fileID: 6365662255690075667, guid: fed2d45066a6d2a4191aa0c744a03147,
+    type: 3}
+  m_PrefabInstance: {fileID: 6365662255711947173}
+  m_PrefabAsset: {fileID: 0}
+--- !u!1001 &8023949359398807817
+PrefabInstance:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Modification:
+    m_TransformParent: {fileID: 6658570366365034085}
+    m_Modifications:
+    - target: {fileID: 8023949359398975867, guid: 78081648e28527242bb334a6bdf7bfce,
+        type: 3}
+      propertyPath: m_Name
+      value: AUDIO - Module
+      objectReference: {fileID: 0}
+    - target: {fileID: 8023949359419186811, guid: 78081648e28527242bb334a6bdf7bfce,
+        type: 3}
+      propertyPath: m_Pivot.x
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 8023949359419186811, guid: 78081648e28527242bb334a6bdf7bfce,
+        type: 3}
+      propertyPath: m_Pivot.y
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 8023949359419186811, guid: 78081648e28527242bb334a6bdf7bfce,
+        type: 3}
+      propertyPath: m_RootOrder
+      value: 2
+      objectReference: {fileID: 0}
+    - target: {fileID: 8023949359419186811, guid: 78081648e28527242bb334a6bdf7bfce,
+        type: 3}
+      propertyPath: m_AnchorMax.x
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 8023949359419186811, guid: 78081648e28527242bb334a6bdf7bfce,
+        type: 3}
+      propertyPath: m_AnchorMax.y
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 8023949359419186811, guid: 78081648e28527242bb334a6bdf7bfce,
+        type: 3}
+      propertyPath: m_AnchorMin.x
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 8023949359419186811, guid: 78081648e28527242bb334a6bdf7bfce,
+        type: 3}
+      propertyPath: m_AnchorMin.y
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 8023949359419186811, guid: 78081648e28527242bb334a6bdf7bfce,
+        type: 3}
+      propertyPath: m_SizeDelta.x
+      value: 330
+      objectReference: {fileID: 0}
+    - target: {fileID: 8023949359419186811, guid: 78081648e28527242bb334a6bdf7bfce,
+        type: 3}
+      propertyPath: m_SizeDelta.y
+      value: 102.5
+      objectReference: {fileID: 0}
+    - target: {fileID: 8023949359419186811, guid: 78081648e28527242bb334a6bdf7bfce,
+        type: 3}
+      propertyPath: m_LocalPosition.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 8023949359419186811, guid: 78081648e28527242bb334a6bdf7bfce,
+        type: 3}
+      propertyPath: m_LocalPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 8023949359419186811, guid: 78081648e28527242bb334a6bdf7bfce,
+        type: 3}
+      propertyPath: m_LocalPosition.z
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 8023949359419186811, guid: 78081648e28527242bb334a6bdf7bfce,
+        type: 3}
+      propertyPath: m_LocalRotation.w
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 8023949359419186811, guid: 78081648e28527242bb334a6bdf7bfce,
+        type: 3}
+      propertyPath: m_LocalRotation.x
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 8023949359419186811, guid: 78081648e28527242bb334a6bdf7bfce,
+        type: 3}
+      propertyPath: m_LocalRotation.y
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 8023949359419186811, guid: 78081648e28527242bb334a6bdf7bfce,
+        type: 3}
+      propertyPath: m_LocalRotation.z
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 8023949359419186811, guid: 78081648e28527242bb334a6bdf7bfce,
+        type: 3}
+      propertyPath: m_AnchoredPosition.x
+      value: -10
+      objectReference: {fileID: 0}
+    - target: {fileID: 8023949359419186811, guid: 78081648e28527242bb334a6bdf7bfce,
+        type: 3}
+      propertyPath: m_AnchoredPosition.y
+      value: -362.9
+      objectReference: {fileID: 0}
+    - target: {fileID: 8023949359419186811, guid: 78081648e28527242bb334a6bdf7bfce,
+        type: 3}
+      propertyPath: m_LocalEulerAnglesHint.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 8023949359419186811, guid: 78081648e28527242bb334a6bdf7bfce,
+        type: 3}
+      propertyPath: m_LocalEulerAnglesHint.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 8023949359419186811, guid: 78081648e28527242bb334a6bdf7bfce,
+        type: 3}
+      propertyPath: m_LocalEulerAnglesHint.z
+      value: 0
+      objectReference: {fileID: 0}
+    m_RemovedComponents: []
+  m_SourcePrefab: {fileID: 100100000, guid: 78081648e28527242bb334a6bdf7bfce, type: 3}
+--- !u!224 &22493042 stripped
+RectTransform:
+  m_CorrespondingSourceObject: {fileID: 8023949359419186811, guid: 78081648e28527242bb334a6bdf7bfce,
+    type: 3}
+  m_PrefabInstance: {fileID: 8023949359398807817}
+  m_PrefabAsset: {fileID: 0}

Assets/Plugins/Graphy/Prefab/[Graphy].prefab.meta

@@ -0,0 +1,22 @@
+fileFormatVersion: 2
+guid: 0abab5bb77339e4428787a870eb31bd3
+labels:
+- audio
+- counter
+- debugger
+- fps
+- graph
+- graphy
+- memory
+- ram
+- screenshot
+- shader
+- spectrum
+- stats
+- tayx
+timeCreated: 1513271445
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/README.md

@@ -0,0 +1,112 @@
+# Graphy - Ultimate FPS Counter - Stats Monitor & Debugger (Unity)
+
+[![openupm](https://img.shields.io/npm/v/com.tayx.graphy?label=openupm&registry_uri=https://package.openupm.com)](https://openupm.com/packages/com.tayx.graphy/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-brightgreen.svg)](https://github.com/Tayx94/graphy/blob/master/LICENSE)
+[![Unity 2019.4+](https://img.shields.io/badge/unity-2019.4%2B-blue.svg)](https://unity3d.com/get-unity/download)
+
+[![Open Issues](https://img.shields.io/github/issues-raw/tayx94/graphy)](https://github.com/Tayx94/graphy/issues)
+[![Downloads](https://img.shields.io/github/downloads/tayx94/graphy/total)](https://github.com/Tayx94/graphy/releases)
+[![Contributors](https://img.shields.io/github/contributors/tayx94/graphy)](https://github.com/Tayx94/graphy/graphs/contributors)
+[![Stars](https://img.shields.io/github/stars/Tayx94/graphy)](https://github.com/Tayx94/graphy)
+[![Forks](https://img.shields.io/github/forks/Tayx94/graphy)](https://github.com/Tayx94/graphy)
+
+[![Chat Discord](https://img.shields.io/discord/406037880314789889)](https://discord.gg/2KgNEHK?)
+
+[![Twitter](https://img.shields.io/twitter/follow/martintayx?label=Follow&style=social)](http://twitter.com/intent/user?screen_name=martinTayx)
+
+**Links:** [Discord](https://discord.gg/2KgNEHK?) | [Mail](mailto:martintayx@gmail.com) | [Twitter](http://twitter.com/intent/user?screen_name=martinTayx) | [Asset store](https://assetstore.unity.com/packages/tools/gui/graphy-ultimate-stats-monitor-debugger-105778) | [Forum post](https://forum.unity.com/threads/graphy-ultimate-stats-monitor-debugger-released.517387/) | [Donations](https://www.paypal.me/MartinPaneUK)
+
+**WINNER** of the **BEST DEVELOPMENT ASSET** in the **Unity Awards 2018**.
+
+![Graphy Image](https://image.ibb.co/dbcDu8/2018_07_15_15_10_05.gif)
+
+Graphy is the ultimate, easy to use, feature packed FPS Counter, stats monitor and debugger for your Unity project.
+
+**Main Features:**
+- Graph & Text:
+  - FPS
+  - Memory
+  - Audio
+- Advanced device information 
+- Debugging tools 
+
+With this tool you will be able to visualize and catch when your game has some unexpected hiccup or stutter, and act accordingly! 
+
+The debugger allows you to set one or more conditions, that if met will have the consequences you desire, such as taking a screenshot, pausing the editor, printing a message to the console and more! Even call a method from your own code if you want! 
+
+**Additional features:**
+- Customizable look and feel 
+- Multiple layouts 
+- Custom Inspector 
+- Hotkeys 
+- Easy to use API (accessible from code) 
+- Works on multiple platforms 
+- Background Mode 
+- Works from Unity 5.4 and up! 
+- Well documented C# and Shader code included 
+
+**Links:**
+- [Asset store](https://assetstore.unity.com/packages/tools/gui/graphy-ultimate-stats-monitor-debugger-105778)
+- [Forum post](https://forum.unity.com/threads/graphy-ultimate-stats-monitor-debugger-released.517387/)
+- [Video Teaser](https://youtu.be/2X3vXxLANk0)
+
+**Contact:**
+- [Mail](martintayx@gmail.com)
+- [Twitter](https://twitter.com/martinTayx)
+- [Discord](https://discord.gg/2KgNEHK?)
+
+## Installation
+1. The package is available on the [openupm registry](https://openupm.com). You can install it via [openupm-cli](https://github.com/openupm/openupm-cli).
+```
+openupm add com.tayx.graphy
+```
+2. You can also install via git url by adding this entry in your **manifest.json**
+```
+{
+  "dependencies": {
+    ...
+    "com.tayx.graphy": "https://github.com/Tayx94/graphy.git",
+    ...
+  }
+}
+```
+3. You can also download it from the [Asset Store](https://assetstore.unity.com/packages/tools/gui/graphy-ultimate-stats-monitor-debugger-105778)
+
+4. Click here for old version that supports Unity 5.4+: 
+[![Unity 5.4+](https://img.shields.io/badge/unity-5.4%2B-blue.svg)](https://github.com/Tayx94/graphy/releases/tag/v1.6.0-Unity5.4)
+
+## Development of Graphy
+
+Maintainer and main developer: **Martín Pane** [![Twitter](https://img.shields.io/twitter/follow/martintayx?label=Follow&style=social)](http://twitter.com/intent/user?screen_name=martinTayx)
+
+Graphy is **FREE** to use, but if it helped you and you want to contribute to its development, feel free to leave a donation! 
+
+- [Donation Link](https://www.paypal.me/MartinPaneUK)
+
+### Contributing
+
+Let's make Graphy the go-to for stats monitoring in Unity!
+
+I would really appreciate any contributions! Below you can find a roadmap for future planned features and optimisations that you might be able to help out with. If you want to make a big pull request, please do it on the "dev" branch.
+
+Create a GitHub issue if you want to start a discussion or request a feature, and please label appropriately.
+
+You can also join the [Discord](https://discord.gg/2KgNEHK?) for active discussions with other members of the community.
+
+### Roadmap
+
+**Planned features (No ETA):**
+
+  - Add GfxDriver stats to the RAM module.
+  - Scale Canvas (GetComponent<Canvas>().scaleFactor *= multiplier;) -> If it changes, set again.
+  - Make a template for a graph + text module so people can create their own easily.
+  - Allow storing FPS for a predetermined time to allow benchmarks.
+  - Dump all Graphy Data as a string to:
+  	- File.
+	- Send to server.
+	- Send mail.
+  - Add a preprocessor key #GRAPHY to avoid adding the asset in builds.
+  
+## License
+
+Graphy is released under the [MIT license](https://github.com/Tayx94/graphy/blob/master/LICENSE). Although I don't require attribution, I would love to know if you decide to use it in a project! Let me know on [Twitter](https://twitter.com/martinTayx) or by [email](martintayx@gmail.com).

Assets/Plugins/Graphy/README.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: fd1e6a9192c40084998c62404bb41ba2
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Runtime.meta

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

Assets/Plugins/Graphy/Runtime/Advanced.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 1ac38d39b5dd9f442a088b7284b58236
+folderAsset: yes
+timeCreated: 1513377123
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Runtime/Advanced/G_AdvancedData.cs

@@ -0,0 +1,397 @@
+/* ---------------------------------------
+ * Author:          Martin Pane (martintayx@gmail.com) (@martinTayx)
+ * Contributors:    https://github.com/Tayx94/graphy/graphs/contributors
+ * Project:         Graphy - Ultimate Stats Monitor
+ * Date:            05-Dec-17
+ * Studio:          Tayx
+ *
+ * Git repo:        https://github.com/Tayx94/graphy
+ *
+ * This project is released under the MIT license.
+ * Attribution is not required, but it is always welcomed!
+ * -------------------------------------*/
+
+using UnityEngine;
+using UnityEngine.UI;
+
+#if GRAPHY_XR
+using UnityEngine.XR;
+#endif
+
+using System.Collections.Generic;
+using System.Text;
+
+using Tayx.Graphy.UI;
+using Tayx.Graphy.Utils;
+using Tayx.Graphy.Utils.NumString;
+
+namespace Tayx.Graphy.Advanced
+{
+    public class G_AdvancedData : MonoBehaviour, IMovable, IModifiableState
+    {
+        #region Variables -> Serialized Private
+
+        [SerializeField] private List<Image> m_backgroundImages = new List<Image>();
+
+        [SerializeField] private Text m_graphicsDeviceVersionText = null;
+
+        [SerializeField] private Text m_processorTypeText = null;
+
+        [SerializeField] private Text m_operatingSystemText = null;
+
+        [SerializeField] private Text m_systemMemoryText = null;
+
+        [SerializeField] private Text m_graphicsDeviceNameText = null;
+        [SerializeField] private Text m_graphicsMemorySizeText = null;
+        [SerializeField] private Text m_screenResolutionText = null;
+        [SerializeField] private Text m_gameWindowResolutionText = null;
+        [SerializeField] private Text m_gameVRResolutionText = null;
+        
+#if GRAPHY_XR
+        private readonly List<XRDisplaySubsystem> m_displaySubsystems = new List<XRDisplaySubsystem>();
+#endif
+        
+        [Range( 1, 60 )] [SerializeField] private float m_updateRate = 1f; // 1 update per sec.
+
+        #endregion
+
+        #region Variables -> Private
+
+        private GraphyManager m_graphyManager = null;
+
+        private RectTransform m_rectTransform = null;
+        private Vector2 m_origPosition = Vector2.zero;
+
+        private float m_deltaTime = 0.0f;
+
+        private StringBuilder m_sb = null;
+
+        private GraphyManager.ModuleState m_previousModuleState = GraphyManager.ModuleState.FULL;
+        private GraphyManager.ModuleState m_currentModuleState = GraphyManager.ModuleState.FULL;
+
+        private readonly string[] m_windowStrings =
+        {
+            "Window: ",
+            "x",
+            "@",
+            "Hz",
+            "[",
+            "dpi]"
+        };
+        
+        private readonly string[] m_vrStrings =
+        {
+            "VR: (",
+            "*2)x",
+            "@",
+            "Hz"
+        };
+
+        #endregion
+
+        #region Methods -> Unity Callbacks
+
+        private void Awake()
+        {
+            Init();
+        }
+
+        private void Update()
+        {
+            m_deltaTime += Time.unscaledDeltaTime;
+
+            if( m_deltaTime > 1f / m_updateRate )
+            {
+                // Update screen window resolution
+                m_sb.Length = 0;
+
+                m_sb.Append( m_windowStrings[ 0 ] ).Append( Screen.width.ToStringNonAlloc() )
+                    .Append( m_windowStrings[ 1 ] ).Append( Screen.height.ToStringNonAlloc() )
+                    .Append( m_windowStrings[ 2 ] ).Append(
+#if UNITY_2022_2_OR_NEWER
+                        ((int)Screen.currentResolution.refreshRateRatio.value).ToStringNonAlloc()
+#else
+                        Screen.currentResolution.refreshRate.ToStringNonAlloc()
+#endif
+                        )
+                    .Append( m_windowStrings[ 3 ] )
+                    .Append( m_windowStrings[ 4 ] ).Append( ((int) Screen.dpi).ToStringNonAlloc() )
+                    .Append( m_windowStrings[ 5 ] );
+
+                m_gameWindowResolutionText.text = m_sb.ToString();
+
+#if GRAPHY_XR
+                // If XR enabled, update screen XR resolution
+                if( XRSettings.enabled )
+                {
+                    m_sb.Length = 0;
+
+#if UNITY_2020_2_OR_NEWER
+                    SubsystemManager.GetSubsystems( m_displaySubsystems );
+#else
+                    SubsystemManager.GetInstances( m_displaySubsystems );
+#endif
+                    float refreshRate = -1;
+
+                    if( m_displaySubsystems.Count > 0 )
+                    {
+                        m_displaySubsystems[ 0 ].TryGetDisplayRefreshRate( out refreshRate );
+                    }
+
+                    m_sb.Append( m_vrStrings[ 0 ] ).Append( XRSettings.eyeTextureWidth.ToStringNonAlloc() )
+                        .Append( m_vrStrings[ 1 ] ).Append( XRSettings.eyeTextureHeight.ToStringNonAlloc() )
+                        .Append( m_vrStrings[ 2 ] ).Append( Mathf.RoundToInt( refreshRate ).ToStringNonAlloc() )
+                        .Append( m_vrStrings[ 3 ] );
+
+                    m_gameVRResolutionText.text = m_sb.ToString();
+                }
+#endif
+                
+                // Reset variables
+                m_deltaTime = 0f;
+            }
+        }
+
+        #endregion
+
+        #region Methods -> Public
+
+        public void SetPosition( GraphyManager.ModulePosition newModulePosition, Vector2 offset )
+        {
+            if ( newModulePosition == GraphyManager.ModulePosition.FREE )
+                return;
+            
+            m_rectTransform.anchoredPosition = m_origPosition;
+
+            float xSideOffset = Mathf.Abs( m_rectTransform.anchoredPosition.x ) + offset.x;
+            float ySideOffset = Mathf.Abs( m_rectTransform.anchoredPosition.y ) + offset.y;
+
+            switch( newModulePosition )
+            {
+                case GraphyManager.ModulePosition.TOP_LEFT:
+
+                    m_rectTransform.anchorMax = Vector2.up;
+                    m_rectTransform.anchorMin = Vector2.up;
+                    m_rectTransform.anchoredPosition = new Vector2( xSideOffset, -ySideOffset );
+
+                    break;
+
+                case GraphyManager.ModulePosition.TOP_RIGHT:
+
+                    m_rectTransform.anchorMax = Vector2.one;
+                    m_rectTransform.anchorMin = Vector2.one;
+                    m_rectTransform.anchoredPosition = new Vector2( -xSideOffset, -ySideOffset );
+
+                    break;
+
+                case GraphyManager.ModulePosition.BOTTOM_LEFT:
+
+                    m_rectTransform.anchorMax = Vector2.zero;
+                    m_rectTransform.anchorMin = Vector2.zero;
+                    m_rectTransform.anchoredPosition = new Vector2( xSideOffset, ySideOffset );
+
+                    break;
+
+                case GraphyManager.ModulePosition.BOTTOM_RIGHT:
+
+                    m_rectTransform.anchorMax = Vector2.right;
+                    m_rectTransform.anchorMin = Vector2.right;
+                    m_rectTransform.anchoredPosition = new Vector2( -xSideOffset, ySideOffset );
+
+                    break;
+            }
+
+            switch( newModulePosition )
+            {
+                case GraphyManager.ModulePosition.TOP_LEFT:
+                case GraphyManager.ModulePosition.BOTTOM_LEFT:
+
+                    m_processorTypeText.alignment = TextAnchor.UpperLeft;
+                    m_systemMemoryText.alignment = TextAnchor.UpperLeft;
+                    m_graphicsDeviceNameText.alignment = TextAnchor.UpperLeft;
+                    m_graphicsDeviceVersionText.alignment = TextAnchor.UpperLeft;
+                    m_graphicsMemorySizeText.alignment = TextAnchor.UpperLeft;
+                    m_screenResolutionText.alignment = TextAnchor.UpperLeft;
+                    m_gameWindowResolutionText.alignment = TextAnchor.UpperLeft;
+                    m_gameVRResolutionText.alignment = TextAnchor.UpperLeft;
+                    m_operatingSystemText.alignment = TextAnchor.UpperLeft;
+
+                    break;
+
+                case GraphyManager.ModulePosition.TOP_RIGHT:
+                case GraphyManager.ModulePosition.BOTTOM_RIGHT:
+
+                    m_processorTypeText.alignment = TextAnchor.UpperRight;
+                    m_systemMemoryText.alignment = TextAnchor.UpperRight;
+                    m_graphicsDeviceNameText.alignment = TextAnchor.UpperRight;
+                    m_graphicsDeviceVersionText.alignment = TextAnchor.UpperRight;
+                    m_graphicsMemorySizeText.alignment = TextAnchor.UpperRight;
+                    m_screenResolutionText.alignment = TextAnchor.UpperRight;
+                    m_gameWindowResolutionText.alignment = TextAnchor.UpperRight;
+                    m_gameVRResolutionText.alignment = TextAnchor.UpperRight;
+                    m_operatingSystemText.alignment = TextAnchor.UpperRight;
+
+                    break;
+            }
+        }
+
+        public void SetState( GraphyManager.ModuleState state, bool silentUpdate = false )
+        {
+            if( !silentUpdate )
+            {
+                m_previousModuleState = m_currentModuleState;
+            }
+
+            m_currentModuleState = state;
+
+            bool active = state == GraphyManager.ModuleState.FULL
+                          || state == GraphyManager.ModuleState.TEXT
+                          || state == GraphyManager.ModuleState.BASIC;
+
+            gameObject.SetActive( active );
+
+            m_backgroundImages.SetAllActive( active && m_graphyManager.Background );
+        }
+
+        /// <summary>
+        /// Restores state to the previous one.
+        /// </summary>
+        public void RestorePreviousState()
+        {
+            SetState( m_previousModuleState );
+        }
+
+        public void UpdateParameters()
+        {
+            foreach( var image in m_backgroundImages )
+            {
+                image.color = m_graphyManager.BackgroundColor;
+            }
+
+            SetPosition( m_graphyManager.AdvancedModulePosition, Vector2.zero );
+            SetState( m_graphyManager.AdvancedModuleState );
+        }
+
+        public void RefreshParameters()
+        {
+            foreach( var image in m_backgroundImages )
+            {
+                image.color = m_graphyManager.BackgroundColor;
+            }
+
+            SetPosition( m_graphyManager.AdvancedModulePosition, Vector2.zero );
+            SetState( m_currentModuleState, true );
+        }
+
+        #endregion
+
+        #region Methods -> Private
+
+        private void Init()
+        {
+            G_IntString.Init( 0, 7680 );
+
+            m_graphyManager = transform.root.GetComponentInChildren<GraphyManager>();
+
+            m_sb = new StringBuilder();
+
+            m_rectTransform = GetComponent<RectTransform>();
+
+            m_processorTypeText.text
+                = "CPU: "
+                  + SystemInfo.processorType
+                  + " ["
+                  + SystemInfo.processorCount
+                  + " cores]";
+
+            m_systemMemoryText.text
+                = "RAM: "
+                  + SystemInfo.systemMemorySize
+                  + " MB";
+
+            m_graphicsDeviceVersionText.text
+                = "Graphics API: "
+                  + SystemInfo.graphicsDeviceVersion;
+
+            m_graphicsDeviceNameText.text
+                = "GPU: "
+                  + SystemInfo.graphicsDeviceName;
+
+            m_graphicsMemorySizeText.text
+                = "VRAM: "
+                  + SystemInfo.graphicsMemorySize
+                  + "MB. Max texture size: "
+                  + SystemInfo.maxTextureSize
+                  + "px. Shader level: "
+                  + SystemInfo.graphicsShaderLevel;
+
+            Resolution res = Screen.currentResolution;
+
+            m_screenResolutionText.text
+                = "Screen: "
+                  + res.width
+                  + "x"
+                  + res.height
+                  + "@"
+#if UNITY_2022_2_OR_NEWER
+                  + ((int)Screen.currentResolution.refreshRateRatio.value).ToStringNonAlloc()
+#else
+                  + res.refreshRate
+#endif
+                  + "Hz";
+
+            m_operatingSystemText.text
+                = "OS: "
+                  + SystemInfo.operatingSystem
+                  + " ["
+                  + SystemInfo.deviceType
+                  + "]";
+
+            m_gameVRResolutionText.text = "VR: Not active";
+            
+            float preferredWidth = 0;
+
+            // Resize the background overlay
+
+            List<Text> texts = new List<Text>()
+            {
+                m_graphicsDeviceVersionText,
+                m_processorTypeText,
+                m_systemMemoryText,
+                m_graphicsDeviceNameText,
+                m_graphicsMemorySizeText,
+                m_screenResolutionText,
+                m_gameWindowResolutionText,
+                m_gameVRResolutionText,
+                m_operatingSystemText
+            };
+
+            foreach( var text in texts )
+            {
+                if( text.preferredWidth > preferredWidth )
+                {
+                    preferredWidth = text.preferredWidth;
+                }
+            }
+            
+            m_rectTransform.SetSizeWithCurrentAnchors
+            (
+                axis: RectTransform.Axis.Horizontal,
+                size: preferredWidth + 25
+            );
+
+            m_rectTransform.anchoredPosition = new Vector2
+            (
+                x: m_rectTransform.anchoredPosition.x - m_rectTransform.rect.width / 2
+                   + m_rectTransform.rect.width / 2 * Mathf.Sign( m_rectTransform.anchoredPosition.x ),
+                y: m_rectTransform.anchoredPosition.y
+            );
+
+            m_origPosition = m_rectTransform.anchoredPosition;
+
+            UpdateParameters();
+        }
+
+        #endregion
+    }
+}

Assets/Plugins/Graphy/Runtime/Advanced/G_AdvancedData.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 5c1019d31db77fd468164577146737ad
+timeCreated: 1512484835
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Runtime/Audio.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 2523395741efc1c48822a27d9fcb57d2
+folderAsset: yes
+timeCreated: 1513377094
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Runtime/Audio/G_AudioGraph.cs

@@ -0,0 +1,294 @@
+/* ---------------------------------------
+ * Author:          Martin Pane (martintayx@gmail.com) (@martinTayx)
+ * Contributors:    https://github.com/Tayx94/graphy/graphs/contributors
+ * Project:         Graphy - Ultimate Stats Monitor
+ * Date:            15-Dec-17
+ * Studio:          Tayx
+ *
+ * Git repo:        https://github.com/Tayx94/graphy
+ *
+ * This project is released under the MIT license.
+ * Attribution is not required, but it is always welcomed!
+ * -------------------------------------*/
+
+using Tayx.Graphy.Graph;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Tayx.Graphy.Audio
+{
+    public class G_AudioGraph : G_Graph
+    {
+        #region Variables -> Serialized Private
+
+        [SerializeField] private Image m_imageGraph = null;
+        [SerializeField] private Image m_imageGraphHighestValues = null;
+
+        [SerializeField] private Shader ShaderFull = null;
+        [SerializeField] private Shader ShaderLight = null;
+
+        [SerializeField] private bool m_isInitialized = false;
+
+        #endregion
+
+        #region Variables -> Private
+
+        private GraphyManager m_graphyManager = null;
+
+        private G_AudioMonitor m_audioMonitor = null;
+
+        private int m_resolution = 40;
+
+        private G_GraphShader m_shaderGraph = null;
+        private G_GraphShader m_shaderGraphHighestValues = null;
+
+        private float[] m_graphArray;
+        private float[] m_graphArrayHighestValue;
+
+        #endregion
+
+        #region Methods -> Unity Callbacks
+
+        private void OnEnable()
+        {
+            /* ----- NOTE: ----------------------------
+             * We used to Init() here regardless of
+             * whether this module was enabled.
+             * The reason we don't Init() here
+             * anymore is that some users are on 
+             * platforms that do not support the arrays 
+             * in the Shaders.
+             *
+             * See: https://github.com/Tayx94/graphy/issues/17
+             * 
+             * Even though we don't Init() competely
+             * here anymore, we still need 
+             * m_audioMonitor for in Update()
+             * --------------------------------------*/
+            m_audioMonitor = GetComponent<G_AudioMonitor>();
+        }
+
+        private void Update()
+        {
+            if( m_audioMonitor.SpectrumDataAvailable )
+            {
+                UpdateGraph();
+            }
+        }
+
+        #endregion
+
+        #region Methods -> Public
+
+        public void UpdateParameters()
+        {
+            if( m_shaderGraph == null )
+            {
+                // While Graphy is disabled (e.g. by default via Ctrl+H) and while in Editor after a Hot-Swap,
+                // the OnApplicationFocus calls this while m_shaderGraph == null, throwing a NullReferenceException
+                return;
+            }
+
+            switch( m_graphyManager.GraphyMode )
+            {
+                case GraphyManager.Mode.FULL:
+                    m_shaderGraph.ArrayMaxSize = G_GraphShader.ArrayMaxSizeFull;
+                    m_shaderGraph.Image.material = new Material( ShaderFull );
+
+                    m_shaderGraphHighestValues.ArrayMaxSize = G_GraphShader.ArrayMaxSizeFull;
+                    m_shaderGraphHighestValues.Image.material = new Material( ShaderFull );
+                    break;
+
+                case GraphyManager.Mode.LIGHT:
+                    m_shaderGraph.ArrayMaxSize = G_GraphShader.ArrayMaxSizeLight;
+                    m_shaderGraph.Image.material = new Material( ShaderLight );
+
+                    m_shaderGraphHighestValues.ArrayMaxSize = G_GraphShader.ArrayMaxSizeLight;
+                    m_shaderGraphHighestValues.Image.material = new Material( ShaderLight );
+                    break;
+            }
+
+            m_shaderGraph.InitializeShader();
+            m_shaderGraphHighestValues.InitializeShader();
+
+            m_resolution = m_graphyManager.AudioGraphResolution;
+
+            CreatePoints();
+        }
+
+        #endregion
+
+        #region Methods -> Protected Override
+
+        protected override void UpdateGraph()
+        {
+            // Since we no longer initialize by default OnEnable(), 
+            // we need to check here, and Init() if needed
+            if( !m_isInitialized )
+            {
+                Init();
+            }
+
+            int incrementPerIteration = Mathf.FloorToInt( m_audioMonitor.Spectrum.Length / (float) m_resolution );
+
+            // Current values -------------------------
+
+            for( int i = 0; i <= m_resolution - 1; i++ )
+            {
+                float currentValue = 0;
+
+                for( int j = 0; j < incrementPerIteration; j++ )
+                {
+                    currentValue += m_audioMonitor.Spectrum[ i * incrementPerIteration + j ];
+                }
+
+                // Uses 3 values for each bar to accomplish that look
+
+                if( (i + 1) % 3 == 0 && i > 1 )
+                {
+                    float value =
+                    (
+                        m_audioMonitor.dBNormalized( m_audioMonitor.lin2dB( currentValue / incrementPerIteration ) )
+                        + m_graphArray[ i - 1 ]
+                        + m_graphArray[ i - 2 ]
+                    ) / 3;
+
+                    m_graphArray[ i ] = value;
+                    m_graphArray[ i - 1 ] = value;
+                    m_graphArray[ i - 2 ] =
+                        -1; // Always set the third one to -1 to leave gaps in the graph and improve readability
+                }
+                else
+                {
+                    m_graphArray[ i ] =
+                        m_audioMonitor.dBNormalized( m_audioMonitor.lin2dB( currentValue / incrementPerIteration ) );
+                }
+            }
+
+            for( int i = 0; i <= m_resolution - 1; i++ )
+            {
+                m_shaderGraph.ShaderArrayValues[ i ] = m_graphArray[ i ];
+            }
+
+            m_shaderGraph.UpdatePoints();
+
+
+            // Highest values -------------------------
+
+            for( int i = 0; i <= m_resolution - 1; i++ )
+            {
+                float currentValue = 0;
+
+                for( int j = 0; j < incrementPerIteration; j++ )
+                {
+                    currentValue += m_audioMonitor.SpectrumHighestValues[ i * incrementPerIteration + j ];
+                }
+
+                // Uses 3 values for each bar to accomplish that look
+
+                if( (i + 1) % 3 == 0 && i > 1 )
+                {
+                    float value =
+                    (
+                        m_audioMonitor.dBNormalized( m_audioMonitor.lin2dB( currentValue / incrementPerIteration ) )
+                        + m_graphArrayHighestValue[ i - 1 ]
+                        + m_graphArrayHighestValue[ i - 2 ]
+                    ) / 3;
+
+                    m_graphArrayHighestValue[ i ] = value;
+                    m_graphArrayHighestValue[ i - 1 ] = value;
+                    m_graphArrayHighestValue[ i - 2 ] =
+                        -1; // Always set the third one to -1 to leave gaps in the graph and improve readability
+                }
+                else
+                {
+                    m_graphArrayHighestValue[ i ] =
+                        m_audioMonitor.dBNormalized( m_audioMonitor.lin2dB( currentValue / incrementPerIteration ) );
+                }
+            }
+
+            for( int i = 0; i <= m_resolution - 1; i++ )
+            {
+                m_shaderGraphHighestValues.ShaderArrayValues[ i ] = m_graphArrayHighestValue[ i ];
+            }
+
+            m_shaderGraphHighestValues.UpdatePoints();
+        }
+
+        protected override void CreatePoints()
+        {
+            // Init Arrays
+            if( m_shaderGraph.ShaderArrayValues == null || m_shaderGraph.ShaderArrayValues.Length != m_resolution )
+            {
+                m_graphArray = new float[m_resolution];
+                m_graphArrayHighestValue = new float[m_resolution];
+                m_shaderGraph.ShaderArrayValues = new float[m_resolution];
+                m_shaderGraphHighestValues.ShaderArrayValues = new float[m_resolution];
+            }
+
+            for( int i = 0; i < m_resolution; i++ )
+            {
+                m_shaderGraph.ShaderArrayValues[ i ] = 0;
+                m_shaderGraphHighestValues.ShaderArrayValues[ i ] = 0;
+            }
+
+            // Color
+            m_shaderGraph.GoodColor = m_graphyManager.AudioGraphColor;
+            m_shaderGraph.CautionColor = m_graphyManager.AudioGraphColor;
+            m_shaderGraph.CriticalColor = m_graphyManager.AudioGraphColor;
+            m_shaderGraph.UpdateColors();
+
+            m_shaderGraphHighestValues.GoodColor = m_graphyManager.AudioGraphColor;
+            m_shaderGraphHighestValues.CautionColor = m_graphyManager.AudioGraphColor;
+            m_shaderGraphHighestValues.CriticalColor = m_graphyManager.AudioGraphColor;
+            m_shaderGraphHighestValues.UpdateColors();
+
+            // Threshold
+            m_shaderGraph.GoodThreshold = 0;
+            m_shaderGraph.CautionThreshold = 0;
+            m_shaderGraph.UpdateThresholds();
+
+            m_shaderGraphHighestValues.GoodThreshold = 0;
+            m_shaderGraphHighestValues.CautionThreshold = 0;
+            m_shaderGraphHighestValues.UpdateThresholds();
+
+            // Update Array
+            m_shaderGraph.UpdateArrayValuesLength();
+            m_shaderGraphHighestValues.UpdateArrayValuesLength();
+
+            // Average
+            m_shaderGraph.Average = 0;
+            m_shaderGraph.UpdateAverage();
+
+            m_shaderGraphHighestValues.Average = 0;
+            m_shaderGraphHighestValues.UpdateAverage();
+        }
+
+        #endregion
+
+        #region Methods -> Private
+
+        private void Init()
+        {
+            m_graphyManager = transform.root.GetComponentInChildren<GraphyManager>();
+
+            m_audioMonitor = GetComponent<G_AudioMonitor>();
+
+            m_shaderGraph = new G_GraphShader
+            {
+                Image = m_imageGraph
+            };
+
+            m_shaderGraphHighestValues = new G_GraphShader
+            {
+                Image = m_imageGraphHighestValues
+            };
+
+            UpdateParameters();
+
+            m_isInitialized = true;
+        }
+
+        #endregion
+    }
+}

Assets/Plugins/Graphy/Runtime/Audio/G_AudioGraph.cs.meta

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

Assets/Plugins/Graphy/Runtime/Audio/G_AudioManager.cs

@@ -0,0 +1,239 @@
+/* ---------------------------------------
+ * Author:          Martin Pane (martintayx@gmail.com) (@martinTayx)
+ * Contributors:    https://github.com/Tayx94/graphy/graphs/contributors
+ * Project:         Graphy - Ultimate Stats Monitor
+ * Date:            03-Jan-18
+ * Studio:          Tayx
+ *
+ * Git repo:        https://github.com/Tayx94/graphy
+ *
+ * This project is released under the MIT license.
+ * Attribution is not required, but it is always welcomed!
+ * -------------------------------------*/
+
+using UnityEngine;
+using UnityEngine.UI;
+using System.Collections.Generic;
+using Tayx.Graphy.UI;
+using Tayx.Graphy.Utils;
+
+namespace Tayx.Graphy.Audio
+{
+    public class G_AudioManager : MonoBehaviour, IMovable, IModifiableState
+    {
+        #region Variables -> Serialized Private
+
+        [SerializeField] private GameObject m_audioGraphGameObject = null;
+        [SerializeField] private Text m_audioDbText = null;
+
+        [SerializeField] private List<Image> m_backgroundImages = new List<Image>();
+
+        #endregion
+
+        #region Variables -> Private
+
+        private GraphyManager m_graphyManager = null;
+
+        private G_AudioGraph m_audioGraph = null;
+        private G_AudioMonitor m_audioMonitor = null;
+        private G_AudioText m_audioText = null;
+
+        private RectTransform m_rectTransform = null;
+        private Vector2 m_origPosition = Vector2.zero;
+
+        private List<GameObject> m_childrenGameObjects = new List<GameObject>();
+
+        private GraphyManager.ModuleState m_previousModuleState = GraphyManager.ModuleState.FULL;
+        private GraphyManager.ModuleState m_currentModuleState = GraphyManager.ModuleState.FULL;
+
+        #endregion
+
+        #region Methods -> Unity Callbacks
+
+        private void Awake()
+        {
+            Init();
+        }
+
+        private void Start()
+        {
+            UpdateParameters();
+        }
+
+        #endregion
+
+        #region Methods -> Public
+
+        public void SetPosition( GraphyManager.ModulePosition newModulePosition, Vector2 offset )
+        {
+            if ( newModulePosition == GraphyManager.ModulePosition.FREE )
+                return;
+            
+            m_rectTransform.anchoredPosition = m_origPosition;
+
+            float xSideOffset = Mathf.Abs( m_rectTransform.anchoredPosition.x ) + offset.x;
+            float ySideOffset = Mathf.Abs( m_rectTransform.anchoredPosition.y ) + offset.y;
+
+            m_audioDbText.alignment = TextAnchor.UpperRight;
+
+            switch( newModulePosition )
+            {
+                case GraphyManager.ModulePosition.TOP_LEFT:
+
+                    m_rectTransform.anchorMax = Vector2.up;
+                    m_rectTransform.anchorMin = Vector2.up;
+                    m_rectTransform.anchoredPosition = new Vector2( xSideOffset, -ySideOffset );
+
+                    break;
+
+                case GraphyManager.ModulePosition.TOP_RIGHT:
+
+                    m_rectTransform.anchorMax = Vector2.one;
+                    m_rectTransform.anchorMin = Vector2.one;
+                    m_rectTransform.anchoredPosition = new Vector2( -xSideOffset, -ySideOffset );
+
+                    break;
+
+                case GraphyManager.ModulePosition.BOTTOM_LEFT:
+
+                    m_rectTransform.anchorMax = Vector2.zero;
+                    m_rectTransform.anchorMin = Vector2.zero;
+                    m_rectTransform.anchoredPosition = new Vector2( xSideOffset, ySideOffset );
+
+                    break;
+
+                case GraphyManager.ModulePosition.BOTTOM_RIGHT:
+
+                    m_rectTransform.anchorMax = Vector2.right;
+                    m_rectTransform.anchorMin = Vector2.right;
+                    m_rectTransform.anchoredPosition = new Vector2( -xSideOffset, ySideOffset );
+
+                    break;
+            }
+        }
+
+        public void SetState( GraphyManager.ModuleState state, bool silentUpdate = false )
+        {
+            if( !silentUpdate )
+            {
+                m_previousModuleState = m_currentModuleState;
+            }
+
+            m_currentModuleState = state;
+
+            switch( state )
+            {
+                case GraphyManager.ModuleState.FULL:
+                    gameObject.SetActive( true );
+                    m_childrenGameObjects.SetAllActive( true );
+                    SetGraphActive( true );
+
+                    if( m_graphyManager.Background )
+                    {
+                        m_backgroundImages.SetOneActive( 0 );
+                    }
+                    else
+                    {
+                        m_backgroundImages.SetAllActive( false );
+                    }
+
+                    break;
+
+                case GraphyManager.ModuleState.TEXT:
+                case GraphyManager.ModuleState.BASIC:
+                    gameObject.SetActive( true );
+                    m_childrenGameObjects.SetAllActive( true );
+                    SetGraphActive( false );
+
+                    if( m_graphyManager.Background )
+                    {
+                        m_backgroundImages.SetOneActive( 1 );
+                    }
+                    else
+                    {
+                        m_backgroundImages.SetAllActive( false );
+                    }
+
+                    break;
+
+                case GraphyManager.ModuleState.BACKGROUND:
+                    gameObject.SetActive( true );
+                    SetGraphActive( false );
+                    m_childrenGameObjects.SetAllActive( false );
+
+                    m_backgroundImages.SetAllActive( false );
+
+                    break;
+
+                case GraphyManager.ModuleState.OFF:
+                    gameObject.SetActive( false );
+                    break;
+            }
+        }
+
+        public void RestorePreviousState()
+        {
+            SetState( m_previousModuleState );
+        }
+
+        public void UpdateParameters()
+        {
+            foreach( var image in m_backgroundImages )
+            {
+                image.color = m_graphyManager.BackgroundColor;
+            }
+
+            m_audioGraph.UpdateParameters();
+            m_audioMonitor.UpdateParameters();
+            m_audioText.UpdateParameters();
+
+            SetState( m_graphyManager.AudioModuleState );
+        }
+
+        public void RefreshParameters()
+        {
+            foreach( var image in m_backgroundImages )
+            {
+                image.color = m_graphyManager.BackgroundColor;
+            }
+
+            m_audioGraph.UpdateParameters();
+            m_audioMonitor.UpdateParameters();
+            m_audioText.UpdateParameters();
+
+            SetState( m_currentModuleState, true );
+        }
+
+        #endregion
+
+        #region Methods -> Private
+
+        private void Init()
+        {
+            m_graphyManager = transform.root.GetComponentInChildren<GraphyManager>();
+
+            m_rectTransform = GetComponent<RectTransform>();
+            m_origPosition = m_rectTransform.anchoredPosition;
+
+            m_audioGraph = GetComponent<G_AudioGraph>();
+            m_audioMonitor = GetComponent<G_AudioMonitor>();
+            m_audioText = GetComponent<G_AudioText>();
+
+            foreach( Transform child in transform )
+            {
+                if( child.parent == transform )
+                {
+                    m_childrenGameObjects.Add( child.gameObject );
+                }
+            }
+        }
+
+        private void SetGraphActive( bool active )
+        {
+            m_audioGraph.enabled = active;
+            m_audioGraphGameObject.SetActive( active );
+        }
+
+        #endregion
+    }
+}

Assets/Plugins/Graphy/Runtime/Audio/G_AudioManager.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 8c0448d8db852b54480670d291c04f1a
+timeCreated: 1514998347
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Runtime/Audio/G_AudioMonitor.cs

@@ -0,0 +1,211 @@
+/* ---------------------------------------
+ * Author:          Martin Pane (martintayx@gmail.com) (@martinTayx)
+ * Contributors:    https://github.com/Tayx94/graphy/graphs/contributors
+ * Project:         Graphy - Ultimate Stats Monitor
+ * Date:            15-Dec-17
+ * Studio:          Tayx
+ *
+ * Git repo:        https://github.com/Tayx94/graphy
+ *
+ * This project is released under the MIT license.
+ * Attribution is not required, but it is always welcomed!
+ * -------------------------------------*/
+
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace Tayx.Graphy.Audio
+{
+    /// <summary>
+    /// Note: this class only works with Unity's AudioListener.
+    /// If you're using a custom audio engine (like FMOD or WWise) it won't work,
+    /// although you can always adapt it.
+    /// </summary>
+    public class G_AudioMonitor : MonoBehaviour
+    {
+        #region Variables -> Private
+
+        private const float m_refValue = 1f;
+
+        private GraphyManager m_graphyManager = null;
+
+        private AudioListener m_audioListener = null;
+
+        private GraphyManager.LookForAudioListener m_findAudioListenerInCameraIfNull =
+            GraphyManager.LookForAudioListener.ON_SCENE_LOAD;
+
+        private FFTWindow m_FFTWindow = FFTWindow.Blackman;
+
+        private int m_spectrumSize = 512;
+
+        #endregion
+
+        #region Properties -> Public
+
+        /// <summary>
+        /// Current audio spectrum from the specified AudioListener.
+        /// </summary>
+        public float[] Spectrum { get; private set; }
+
+        /// <summary>
+        /// Highest audio spectrum from the specified AudioListener in the last few seconds.
+        /// </summary>
+        public float[] SpectrumHighestValues { get; private set; }
+
+        /// <summary>
+        /// Maximum DB registered in the current spectrum.
+        /// </summary>
+        public float MaxDB { get; private set; }
+
+        /// <summary>
+        /// Returns true if there is a reference to the audio listener.
+        /// </summary>
+        public bool SpectrumDataAvailable => m_audioListener != null;
+
+        #endregion
+
+        #region Methods -> Unity Callbacks
+
+        private void Awake()
+        {
+            Init();
+        }
+
+        private void Update()
+        {
+            if( m_audioListener != null )
+            {
+                // Use this data to calculate the dB value
+
+                AudioListener.GetOutputData( Spectrum, 0 );
+
+                float sum = 0;
+
+                for( int i = 0; i < Spectrum.Length; i++ )
+                {
+                    sum += Spectrum[ i ] * Spectrum[ i ]; // sum squared samples
+                }
+
+                float rmsValue = Mathf.Sqrt( sum / Spectrum.Length ); // rms = square root of average
+
+                MaxDB = 20 * Mathf.Log10( rmsValue / m_refValue ); // calculate dB
+
+                if( MaxDB < -80 ) MaxDB = -80; // clamp it to -80dB min
+
+                // Use this data to draw the spectrum in the graphs
+
+                AudioListener.GetSpectrumData( Spectrum, 0, m_FFTWindow );
+
+                for( int i = 0; i < Spectrum.Length; i++ )
+                {
+                    // Update the highest value if its lower than the current one
+                    if( Spectrum[ i ] > SpectrumHighestValues[ i ] )
+                    {
+                        SpectrumHighestValues[ i ] = Spectrum[ i ];
+                    }
+
+                    // Slowly lower the value 
+                    else
+                    {
+                        SpectrumHighestValues[ i ] = Mathf.Clamp
+                        (
+                            value: SpectrumHighestValues[ i ] - SpectrumHighestValues[ i ] * Time.deltaTime * 2,
+                            min: 0,
+                            max: 1
+                        );
+                    }
+                }
+            }
+            else if( m_audioListener == null
+                     && m_findAudioListenerInCameraIfNull == GraphyManager.LookForAudioListener.ALWAYS )
+            {
+                m_audioListener = FindAudioListener();
+            }
+        }
+
+        private void OnDestroy()
+        {
+            UnityEngine.SceneManagement.SceneManager.sceneLoaded -= OnSceneLoaded;
+        }
+
+        #endregion
+
+        #region Methods -> Public
+
+        public void UpdateParameters()
+        {
+            m_findAudioListenerInCameraIfNull = m_graphyManager.FindAudioListenerInCameraIfNull;
+
+            m_audioListener = m_graphyManager.AudioListener;
+            m_FFTWindow = m_graphyManager.FftWindow;
+            m_spectrumSize = m_graphyManager.SpectrumSize;
+
+            if( m_audioListener == null
+                && m_findAudioListenerInCameraIfNull != GraphyManager.LookForAudioListener.NEVER )
+            {
+                m_audioListener = FindAudioListener();
+            }
+
+            Spectrum = new float[m_spectrumSize];
+            SpectrumHighestValues = new float[m_spectrumSize];
+        }
+
+        /// <summary>
+        /// Converts spectrum values to decibels using logarithms.
+        /// </summary>
+        /// <param name="linear"></param>
+        /// <returns></returns>
+        public float lin2dB( float linear )
+        {
+            return Mathf.Clamp( Mathf.Log10( linear ) * 20.0f, -160.0f, 0.0f );
+        }
+
+        /// <summary>
+        /// Normalizes a value in decibels between 0-1.
+        /// </summary>
+        /// <param name="db"></param>
+        /// <returns></returns>
+        public float dBNormalized( float db )
+        {
+            return (db + 160f) / 160f;
+        }
+
+        #endregion
+
+        #region Methods -> Private
+
+        /// <summary>
+        /// Tries to find an audio listener in the main camera.
+        /// </summary>
+        private AudioListener FindAudioListener()
+        {
+            Camera mainCamera = Camera.main;
+
+            if( mainCamera != null && mainCamera.TryGetComponent( out AudioListener audioListener ) )
+            {
+                return audioListener;
+            }
+
+            return null;
+        }
+
+        private void OnSceneLoaded( Scene scene, LoadSceneMode loadSceneMode )
+        {
+            if( m_findAudioListenerInCameraIfNull == GraphyManager.LookForAudioListener.ON_SCENE_LOAD )
+            {
+                m_audioListener = FindAudioListener();
+            }
+        }
+
+        private void Init()
+        {
+            m_graphyManager = transform.root.GetComponentInChildren<GraphyManager>();
+
+            UpdateParameters();
+
+            UnityEngine.SceneManagement.SceneManager.sceneLoaded += OnSceneLoaded;
+        }
+
+        #endregion
+    }
+}

Assets/Plugins/Graphy/Runtime/Audio/G_AudioMonitor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 2216f4eff6a7a8a43b38b180fdd2fd9e
+timeCreated: 1513377074
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Runtime/Audio/G_AudioText.cs

@@ -0,0 +1,90 @@
+/* ---------------------------------------
+ * Author:          Martin Pane (martintayx@gmail.com) (@martinTayx)
+ * Contributors:    https://github.com/Tayx94/graphy/graphs/contributors
+ * Project:         Graphy - Ultimate Stats Monitor
+ * Date:            15-Dec-17
+ * Studio:          Tayx
+ *
+ * Git repo:        https://github.com/Tayx94/graphy
+ *
+ * This project is released under the MIT license.
+ * Attribution is not required, but it is always welcomed!
+ * -------------------------------------*/
+
+using UnityEngine;
+using UnityEngine.UI;
+using Tayx.Graphy.Utils.NumString;
+
+namespace Tayx.Graphy.Audio
+{
+    public class G_AudioText : MonoBehaviour
+    {
+        #region Variables -> Serialized Private
+
+        [SerializeField] private Text m_DBText = null;
+
+        #endregion
+
+        #region Variables -> Private
+
+        private GraphyManager m_graphyManager = null;
+
+        private G_AudioMonitor m_audioMonitor = null;
+
+        private int m_updateRate = 4;
+
+        private float m_deltaTimeOffset = 0;
+
+        #endregion
+
+        #region Methods -> Unity Callbacks
+
+        private void Awake()
+        {
+            Init();
+        }
+
+        private void Update()
+        {
+            if( m_audioMonitor.SpectrumDataAvailable )
+            {
+                if( m_deltaTimeOffset > 1f / m_updateRate )
+                {
+                    m_deltaTimeOffset = 0f;
+
+                    m_DBText.text = Mathf.Clamp( (int) m_audioMonitor.MaxDB, -80, 0 ).ToStringNonAlloc();
+                }
+                else
+                {
+                    m_deltaTimeOffset += Time.deltaTime;
+                }
+            }
+        }
+
+        #endregion
+
+        #region Methods -> Public
+
+        public void UpdateParameters()
+        {
+            m_updateRate = m_graphyManager.AudioTextUpdateRate;
+        }
+
+        #endregion
+
+        #region Methods -> Private
+
+        private void Init()
+        {
+            G_IntString.Init( -80, 0 ); // dB range
+
+            m_graphyManager = transform.root.GetComponentInChildren<GraphyManager>();
+
+            m_audioMonitor = GetComponent<G_AudioMonitor>();
+
+            UpdateParameters();
+        }
+
+        #endregion
+    }
+}

Assets/Plugins/Graphy/Runtime/Audio/G_AudioText.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 766a588f9a6cb55499c66ea772072e11
+timeCreated: 1513377063
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Runtime/Fps.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 3232b12a3422d1a4d8ff3eaa000c43ae
+folderAsset: yes
+timeCreated: 1513377102
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Runtime/Fps/G_FpsGraph.cs

@@ -0,0 +1,197 @@
+/* ---------------------------------------
+ * Author:          Martin Pane (martintayx@gmail.com) (@martinTayx)
+ * Contributors:    https://github.com/Tayx94/graphy/graphs/contributors
+ * Project:         Graphy - Ultimate Stats Monitor
+ * Date:            15-Dec-17
+ * Studio:          Tayx
+ *
+ * Git repo:        https://github.com/Tayx94/graphy
+ *
+ * This project is released under the MIT license.
+ * Attribution is not required, but it is always welcomed!
+ * -------------------------------------*/
+
+using Tayx.Graphy.Graph;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Tayx.Graphy.Fps
+{
+    public class G_FpsGraph : G_Graph
+    {
+        #region Variables -> Serialized Private
+
+        [SerializeField] private Image m_imageGraph = null;
+
+        [SerializeField] private Shader ShaderFull = null;
+        [SerializeField] private Shader ShaderLight = null;
+
+        // This keeps track of whether Init() has run or not
+        [SerializeField] private bool m_isInitialized = false;
+
+        #endregion
+
+        #region Variables -> Private
+
+        private GraphyManager m_graphyManager = null;
+
+        private G_FpsMonitor m_fpsMonitor = null;
+
+        private int m_resolution = 150;
+
+        private G_GraphShader m_shaderGraph = null;
+
+        private int[] m_fpsArray;
+
+        private int m_highestFps;
+
+        #endregion
+
+        #region Methods -> Unity Callbacks
+
+        private void Update()
+        {
+            UpdateGraph();
+        }
+
+        #endregion
+
+        #region Methods -> Public
+
+        public void UpdateParameters()
+        {
+            if( m_shaderGraph == null )
+            {
+                // While Graphy is disabled (e.g. by default via Ctrl+H) and while in Editor after a Hot-Swap,
+                // the OnApplicationFocus calls this while m_shaderGraph == null, throwing a NullReferenceException
+                return;
+            }
+
+            switch( m_graphyManager.GraphyMode )
+            {
+                case GraphyManager.Mode.FULL:
+                    m_shaderGraph.ArrayMaxSize = G_GraphShader.ArrayMaxSizeFull;
+                    m_shaderGraph.Image.material = new Material( ShaderFull );
+                    break;
+
+                case GraphyManager.Mode.LIGHT:
+                    m_shaderGraph.ArrayMaxSize = G_GraphShader.ArrayMaxSizeLight;
+                    m_shaderGraph.Image.material = new Material( ShaderLight );
+                    break;
+            }
+
+            m_shaderGraph.InitializeShader();
+
+            m_resolution = m_graphyManager.FpsGraphResolution;
+
+            CreatePoints();
+        }
+
+        #endregion
+
+        #region Methods -> Protected Override
+
+        protected override void UpdateGraph()
+        {
+            // Since we no longer initialize by default OnEnable(), 
+            // we need to check here, and Init() if needed
+            if( !m_isInitialized )
+            {
+                Init();
+            }
+
+            short fps = (short) (1 / Time.unscaledDeltaTime);
+
+            int currentMaxFps = 0;
+
+            for( int i = 0; i <= m_resolution - 1; i++ )
+            {
+                if( i >= m_resolution - 1 )
+                {
+                    m_fpsArray[ i ] = fps;
+                }
+                else
+                {
+                    m_fpsArray[ i ] = m_fpsArray[ i + 1 ];
+                }
+
+                // Store the highest fps to use as the highest point in the graph
+
+                if( currentMaxFps < m_fpsArray[ i ] )
+                {
+                    currentMaxFps = m_fpsArray[ i ];
+                }
+            }
+
+            m_highestFps = m_highestFps < 1 || m_highestFps <= currentMaxFps ? currentMaxFps : m_highestFps - 1;
+
+            m_highestFps = m_highestFps > 0 ? m_highestFps : 1;
+
+            if( m_shaderGraph.ShaderArrayValues == null )
+            {
+                m_fpsArray = new int[m_resolution];
+                m_shaderGraph.ShaderArrayValues = new float[m_resolution];
+            }
+
+            for( int i = 0; i <= m_resolution - 1; i++ )
+            {
+                m_shaderGraph.ShaderArrayValues[ i ] = m_fpsArray[ i ] / (float) m_highestFps;
+            }
+
+            // Update the material values
+
+            m_shaderGraph.UpdatePoints();
+
+            m_shaderGraph.Average = m_fpsMonitor.AverageFPS / m_highestFps;
+            m_shaderGraph.UpdateAverage();
+
+            m_shaderGraph.GoodThreshold = (float) m_graphyManager.GoodFPSThreshold / m_highestFps;
+            m_shaderGraph.CautionThreshold = (float) m_graphyManager.CautionFPSThreshold / m_highestFps;
+            m_shaderGraph.UpdateThresholds();
+        }
+
+        protected override void CreatePoints()
+        {
+            if( m_shaderGraph.ShaderArrayValues == null || m_fpsArray.Length != m_resolution )
+            {
+                m_fpsArray = new int[m_resolution];
+                m_shaderGraph.ShaderArrayValues = new float[m_resolution];
+            }
+
+            for( int i = 0; i < m_resolution; i++ )
+            {
+                m_shaderGraph.ShaderArrayValues[ i ] = 0;
+            }
+
+            m_shaderGraph.GoodColor = m_graphyManager.GoodFPSColor;
+            m_shaderGraph.CautionColor = m_graphyManager.CautionFPSColor;
+            m_shaderGraph.CriticalColor = m_graphyManager.CriticalFPSColor;
+
+            m_shaderGraph.UpdateColors();
+
+            m_shaderGraph.UpdateArrayValuesLength();
+        }
+
+        #endregion
+
+        #region Methods -> Private
+
+        private void Init()
+        {
+            m_graphyManager = transform.root.GetComponentInChildren<GraphyManager>();
+
+            m_fpsMonitor = GetComponent<G_FpsMonitor>();
+
+            m_shaderGraph = new G_GraphShader
+            {
+                Image = m_imageGraph
+            };
+
+            UpdateParameters();
+
+            m_isInitialized = true;
+        }
+
+        #endregion
+    }
+}

Assets/Plugins/Graphy/Runtime/Fps/G_FpsGraph.cs.meta

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

Assets/Plugins/Graphy/Runtime/Fps/G_FpsManager.cs

@@ -0,0 +1,258 @@
+/* ---------------------------------------
+ * Author:          Martin Pane (martintayx@gmail.com) (@martinTayx)
+ * Contributors:    https://github.com/Tayx94/graphy/graphs/contributors
+ * Project:         Graphy - Ultimate Stats Monitor
+ * Date:            03-Jan-18
+ * Studio:          Tayx
+ *
+ * Git repo:        https://github.com/Tayx94/graphy
+ *
+ * This project is released under the MIT license.
+ * Attribution is not required, but it is always welcomed!
+ * -------------------------------------*/
+
+using UnityEngine;
+using UnityEngine.UI;
+
+using System.Collections.Generic;
+
+using Tayx.Graphy.UI;
+using Tayx.Graphy.Utils;
+
+namespace Tayx.Graphy.Fps
+{
+    public class G_FpsManager : MonoBehaviour, IMovable, IModifiableState
+    {
+        #region Variables -> Serialized Private
+
+        [SerializeField] private GameObject m_fpsGraphGameObject = null;
+
+        [SerializeField] private List<GameObject> m_nonBasicTextGameObjects = new List<GameObject>();
+
+        [SerializeField] private List<Image> m_backgroundImages = new List<Image>();
+
+        #endregion
+
+        #region Variables -> Private
+
+        private GraphyManager m_graphyManager = null;
+
+        private G_FpsGraph m_fpsGraph = null;
+        private G_FpsMonitor m_fpsMonitor = null;
+        private G_FpsText m_fpsText = null;
+
+        private RectTransform m_rectTransform = null;
+        private Vector2 m_origPosition = Vector2.zero;
+
+        private List<GameObject> m_childrenGameObjects = new List<GameObject>();
+
+        private GraphyManager.ModuleState m_previousModuleState = GraphyManager.ModuleState.FULL;
+        private GraphyManager.ModuleState m_currentModuleState = GraphyManager.ModuleState.FULL;
+
+        #endregion
+
+        #region Methods -> Unity Callbacks
+
+        private void Awake()
+        {
+            Init();
+        }
+
+        private void Start()
+        {
+            UpdateParameters();
+        }
+
+        #endregion
+
+        #region Methods -> Public
+
+        public void SetPosition( GraphyManager.ModulePosition newModulePosition, Vector2 offset )
+        {
+            if ( newModulePosition == GraphyManager.ModulePosition.FREE )
+                return;
+            
+            m_rectTransform.anchoredPosition = m_origPosition;
+
+            float xSideOffset = Mathf.Abs( m_rectTransform.anchoredPosition.x ) + offset.x;
+            float ySideOffset = Mathf.Abs( m_rectTransform.anchoredPosition.y ) + offset.y;
+
+            switch( newModulePosition )
+            {
+                case GraphyManager.ModulePosition.TOP_LEFT:
+
+                    m_rectTransform.anchorMax = Vector2.up;
+                    m_rectTransform.anchorMin = Vector2.up;
+                    m_rectTransform.anchoredPosition = new Vector2( xSideOffset, -ySideOffset );
+
+                    break;
+
+                case GraphyManager.ModulePosition.TOP_RIGHT:
+
+                    m_rectTransform.anchorMax = Vector2.one;
+                    m_rectTransform.anchorMin = Vector2.one;
+                    m_rectTransform.anchoredPosition = new Vector2( -xSideOffset, -ySideOffset );
+
+                    break;
+
+                case GraphyManager.ModulePosition.BOTTOM_LEFT:
+
+                    m_rectTransform.anchorMax = Vector2.zero;
+                    m_rectTransform.anchorMin = Vector2.zero;
+                    m_rectTransform.anchoredPosition = new Vector2( xSideOffset, ySideOffset );
+
+                    break;
+
+                case GraphyManager.ModulePosition.BOTTOM_RIGHT:
+
+                    m_rectTransform.anchorMax = Vector2.right;
+                    m_rectTransform.anchorMin = Vector2.right;
+                    m_rectTransform.anchoredPosition = new Vector2( -xSideOffset, ySideOffset );
+
+                    break;
+
+                case GraphyManager.ModulePosition.FREE:
+                    break;
+            }
+        }
+
+        public void SetState( GraphyManager.ModuleState state, bool silentUpdate = false )
+        {
+            if( !silentUpdate )
+            {
+                m_previousModuleState = m_currentModuleState;
+            }
+
+            m_currentModuleState = state;
+
+            switch( state )
+            {
+                case GraphyManager.ModuleState.FULL:
+                    gameObject.SetActive( true );
+                    m_childrenGameObjects.SetAllActive( true );
+                    SetGraphActive( true );
+
+                    if( m_graphyManager.Background )
+                    {
+                        m_backgroundImages.SetOneActive( 0 );
+                    }
+                    else
+                    {
+                        m_backgroundImages.SetAllActive( false );
+                    }
+
+                    break;
+
+                case GraphyManager.ModuleState.TEXT:
+                    gameObject.SetActive( true );
+                    m_childrenGameObjects.SetAllActive( true );
+                    SetGraphActive( false );
+
+                    if( m_graphyManager.Background )
+                    {
+                        m_backgroundImages.SetOneActive( 1 );
+                    }
+                    else
+                    {
+                        m_backgroundImages.SetAllActive( false );
+                    }
+
+                    break;
+
+                case GraphyManager.ModuleState.BASIC:
+                    gameObject.SetActive( true );
+                    m_childrenGameObjects.SetAllActive( true );
+                    m_nonBasicTextGameObjects.SetAllActive( false );
+                    SetGraphActive( false );
+
+                    if( m_graphyManager.Background )
+                    {
+                        m_backgroundImages.SetOneActive( 2 );
+                    }
+                    else
+                    {
+                        m_backgroundImages.SetAllActive( false );
+                    }
+
+                    break;
+
+                case GraphyManager.ModuleState.BACKGROUND:
+                    gameObject.SetActive( true );
+                    m_childrenGameObjects.SetAllActive( false );
+                    SetGraphActive( false );
+
+                    m_backgroundImages.SetAllActive( false );
+                    break;
+
+                case GraphyManager.ModuleState.OFF:
+                    gameObject.SetActive( false );
+                    break;
+            }
+        }
+
+        public void RestorePreviousState()
+        {
+            SetState( m_previousModuleState );
+        }
+
+        public void UpdateParameters()
+        {
+            foreach( var image in m_backgroundImages )
+            {
+                image.color = m_graphyManager.BackgroundColor;
+            }
+
+            m_fpsGraph.UpdateParameters();
+            m_fpsMonitor.UpdateParameters();
+            m_fpsText.UpdateParameters();
+
+            SetState( m_graphyManager.FpsModuleState );
+        }
+
+        public void RefreshParameters()
+        {
+            foreach( var image in m_backgroundImages )
+            {
+                image.color = m_graphyManager.BackgroundColor;
+            }
+
+            m_fpsGraph.UpdateParameters();
+            m_fpsMonitor.UpdateParameters();
+            m_fpsText.UpdateParameters();
+
+            SetState( m_currentModuleState, true );
+        }
+
+        #endregion
+
+        #region Methods -> Private
+
+        private void Init()
+        {
+            m_graphyManager = transform.root.GetComponentInChildren<GraphyManager>();
+
+            m_rectTransform = GetComponent<RectTransform>();
+            m_origPosition = m_rectTransform.anchoredPosition;
+
+            m_fpsGraph = GetComponent<G_FpsGraph>();
+            m_fpsMonitor = GetComponent<G_FpsMonitor>();
+            m_fpsText = GetComponent<G_FpsText>();
+
+            foreach( Transform child in transform )
+            {
+                if( child.parent == transform )
+                {
+                    m_childrenGameObjects.Add( child.gameObject );
+                }
+            }
+        }
+
+        private void SetGraphActive( bool active )
+        {
+            m_fpsGraph.enabled = active;
+            m_fpsGraphGameObject.SetActive( active );
+        }
+
+        #endregion
+    }
+}

Assets/Plugins/Graphy/Runtime/Fps/G_FpsManager.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 221dc0b3655ddb749ace6bad55f0159f
+timeCreated: 1514998359
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Runtime/Fps/G_FpsMonitor.cs

@@ -0,0 +1,141 @@
+/* ---------------------------------------
+ * Author:          Martin Pane (martintayx@gmail.com) (@martinTayx)
+ * Contributors:    https://github.com/Tayx94/graphy/graphs/contributors
+ * Project:         Graphy - Ultimate Stats Monitor
+ * Date:            15-Dec-17
+ * Studio:          Tayx
+ *
+ * Git repo:        https://github.com/Tayx94/graphy
+ *
+ * This project is released under the MIT license.
+ * Attribution is not required, but it is always welcomed!
+ * -------------------------------------*/
+
+using System;
+using UnityEngine;
+
+namespace Tayx.Graphy.Fps
+{
+    public class G_FpsMonitor : MonoBehaviour
+    {
+        #region Variables -> Private
+
+        private short[] m_fpsSamples;
+        private short[] m_fpsSamplesSorted;
+        private short m_fpsSamplesCapacity = 1024;
+        private short m_onePercentSamples = 10;
+        private short m_zero1PercentSamples = 1;
+        private short m_fpsSamplesCount = 0;
+        private short m_indexSample = 0;
+
+        private float m_unscaledDeltaTime = 0f;
+
+        #endregion
+
+        #region Properties -> Public
+
+        public short CurrentFPS { get; private set; } = 0;
+        public short AverageFPS { get; private set; } = 0;
+        public short OnePercentFPS { get; private set; } = 0;
+        public short Zero1PercentFps { get; private set; } = 0;
+
+        #endregion
+
+        #region Methods -> Unity Callbacks
+
+        private void Awake()
+        {
+            Init();
+        }
+
+        private void Update()
+        {
+            m_unscaledDeltaTime = Time.unscaledDeltaTime;
+
+            // Update fps and ms
+
+            CurrentFPS = (short) (Mathf.RoundToInt( 1f / m_unscaledDeltaTime ));
+
+            // Update avg fps
+
+            uint averageAddedFps = 0;
+
+            m_indexSample++;
+
+            if( m_indexSample >= m_fpsSamplesCapacity ) m_indexSample = 0;
+
+            m_fpsSamples[ m_indexSample ] = CurrentFPS;
+
+            if( m_fpsSamplesCount < m_fpsSamplesCapacity )
+            {
+                m_fpsSamplesCount++;
+            }
+
+            for( int i = 0; i < m_fpsSamplesCount; i++ )
+            {
+                averageAddedFps += (uint) m_fpsSamples[ i ];
+            }
+
+            AverageFPS = (short) ((float) averageAddedFps / (float) m_fpsSamplesCount);
+
+            // Update percent lows
+
+            m_fpsSamples.CopyTo( m_fpsSamplesSorted, 0 );
+
+            Array.Sort( m_fpsSamplesSorted,
+                ( x, y ) => x.CompareTo( y ) ); // The lambda expression avoids garbage generation
+
+            bool zero1PercentCalculated = false;
+
+            uint totalAddedFps = 0;
+
+            short samplesToIterateThroughForOnePercent = m_fpsSamplesCount < m_onePercentSamples
+                ? m_fpsSamplesCount
+                : m_onePercentSamples;
+
+            short samplesToIterateThroughForZero1Percent = m_fpsSamplesCount < m_zero1PercentSamples
+                ? m_fpsSamplesCount
+                : m_zero1PercentSamples;
+
+            short sampleToStartIn = (short) (m_fpsSamplesCapacity - m_fpsSamplesCount);
+
+            for( short i = sampleToStartIn; i < sampleToStartIn + samplesToIterateThroughForOnePercent; i++ )
+            {
+                totalAddedFps += (ushort) m_fpsSamplesSorted[ i ];
+
+                if( !zero1PercentCalculated && i >= samplesToIterateThroughForZero1Percent - 1 )
+                {
+                    zero1PercentCalculated = true;
+
+                    Zero1PercentFps = (short) ((float) totalAddedFps / (float) m_zero1PercentSamples);
+                }
+            }
+
+            OnePercentFPS = (short) ((float) totalAddedFps / (float) m_onePercentSamples);
+        }
+
+        #endregion
+
+        #region Methods -> Public
+
+        public void UpdateParameters()
+        {
+            m_onePercentSamples = (short) (m_fpsSamplesCapacity / 100);
+            m_zero1PercentSamples = (short) (m_fpsSamplesCapacity / 1000);
+        }
+
+        #endregion
+
+        #region Methods -> Private
+
+        private void Init()
+        {
+            m_fpsSamples = new short[m_fpsSamplesCapacity];
+            m_fpsSamplesSorted = new short[m_fpsSamplesCapacity];
+
+            UpdateParameters();
+        }
+
+        #endregion
+    }
+}

Assets/Plugins/Graphy/Runtime/Fps/G_FpsMonitor.cs.meta

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

Assets/Plugins/Graphy/Runtime/Fps/G_FpsText.cs

@@ -0,0 +1,156 @@
+/* ---------------------------------------
+ * Author:          Martin Pane (martintayx@gmail.com) (@martinTayx)
+ * Contributors:    https://github.com/Tayx94/graphy/graphs/contributors
+ * Project:         Graphy - Ultimate Stats Monitor
+ * Date:            22-Nov-17
+ * Studio:          Tayx
+ *
+ * Git repo:        https://github.com/Tayx94/graphy
+ *
+ * This project is released under the MIT license.
+ * Attribution is not required, but it is always welcomed!
+ * -------------------------------------*/
+
+using UnityEngine;
+using UnityEngine.UI;
+using Tayx.Graphy.Utils.NumString;
+
+namespace Tayx.Graphy.Fps
+{
+    public class G_FpsText : MonoBehaviour
+    {
+        #region Variables -> Serialized Private
+
+        [SerializeField] private Text m_fpsText = null;
+        [SerializeField] private Text m_msText = null;
+
+        [SerializeField] private Text m_avgFpsText = null;
+        [SerializeField] private Text m_onePercentFpsText = null;
+        [SerializeField] private Text m_zero1PercentFpsText = null;
+
+        #endregion
+
+        #region Variables -> Private
+
+        private GraphyManager m_graphyManager = null;
+
+        private G_FpsMonitor m_fpsMonitor = null;
+
+        private int m_updateRate = 4; // 4 updates per sec.
+
+        private int m_frameCount = 0;
+
+        private float m_deltaTime = 0f;
+
+        private float m_fps = 0f;
+
+        private float m_ms = 0f;
+
+        private const string m_msStringFormat = "0.0";
+
+        #endregion
+
+        #region Methods -> Unity Callbacks
+
+        private void Awake()
+        {
+            Init();
+        }
+
+        private void Update()
+        {
+            m_deltaTime += Time.unscaledDeltaTime;
+
+            m_frameCount++;
+
+            // Only update texts 'm_updateRate' times per second
+
+            if( m_deltaTime > 1f / m_updateRate )
+            {
+                m_fps = m_frameCount / m_deltaTime;
+                m_ms = m_deltaTime / m_frameCount * 1000f;
+
+                // Update fps
+                m_fpsText.text = Mathf.RoundToInt( m_fps ).ToStringNonAlloc();
+                SetFpsRelatedTextColor( m_fpsText, m_fps );
+
+                // Update ms
+                m_msText.text = m_ms.ToStringNonAlloc( m_msStringFormat );
+                SetFpsRelatedTextColor( m_msText, m_fps );
+
+                // Update 1% fps
+                m_onePercentFpsText.text = ((int) (m_fpsMonitor.OnePercentFPS)).ToStringNonAlloc();
+                SetFpsRelatedTextColor( m_onePercentFpsText, m_fpsMonitor.OnePercentFPS );
+
+                // Update 0.1% fps
+                m_zero1PercentFpsText.text = ((int) (m_fpsMonitor.Zero1PercentFps)).ToStringNonAlloc();
+                SetFpsRelatedTextColor( m_zero1PercentFpsText, m_fpsMonitor.Zero1PercentFps );
+
+                // Update avg fps
+                m_avgFpsText.text = ((int) (m_fpsMonitor.AverageFPS)).ToStringNonAlloc();
+                SetFpsRelatedTextColor( m_avgFpsText, m_fpsMonitor.AverageFPS );
+
+                // Reset variables
+                m_deltaTime = 0f;
+                m_frameCount = 0;
+            }
+        }
+
+        #endregion
+
+        #region Methods -> Public
+
+        public void UpdateParameters()
+        {
+            m_updateRate = m_graphyManager.FpsTextUpdateRate;
+        }
+
+        #endregion
+
+        #region Methods -> Private
+
+        /// <summary>
+        /// Assigns color to a text according to their fps numeric value and
+        /// the colors specified in the 3 categories (Good, Caution, Critical).
+        /// </summary>
+        /// 
+        /// <param name="text">
+        /// UI Text component to change its color
+        /// </param>
+        /// 
+        /// <param name="fps">
+        /// Numeric fps value
+        /// </param>
+        private void SetFpsRelatedTextColor( Text text, float fps )
+        {
+            int roundedFps = Mathf.RoundToInt( fps );
+
+            if( roundedFps >= m_graphyManager.GoodFPSThreshold )
+            {
+                text.color = m_graphyManager.GoodFPSColor;
+            }
+            else if( roundedFps >= m_graphyManager.CautionFPSThreshold )
+            {
+                text.color = m_graphyManager.CautionFPSColor;
+            }
+            else
+            {
+                text.color = m_graphyManager.CriticalFPSColor;
+            }
+        }
+
+        private void Init()
+        {
+            G_IntString.Init( 0, 2000 ); // Max fps expected
+            G_FloatString.Init( 0, 100 ); // Max ms expected per frame
+
+            m_graphyManager = transform.root.GetComponentInChildren<GraphyManager>();
+
+            m_fpsMonitor = GetComponent<G_FpsMonitor>();
+
+            UpdateParameters();
+        }
+
+        #endregion
+    }
+}

Assets/Plugins/Graphy/Runtime/Fps/G_FpsText.cs.meta

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

Assets/Plugins/Graphy/Runtime/Graph.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: aca40e3cb2846db40ad6d970f36d4a7f
+folderAsset: yes
+timeCreated: 1516716444
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Runtime/Graph/G_Graph.cs

@@ -0,0 +1,34 @@
+/* ---------------------------------------
+ * Author:          Martin Pane (martintayx@gmail.com) (@martinTayx)
+ * Contributors:    https://github.com/Tayx94/graphy/graphs/contributors
+ * Project:         Graphy - Ultimate Stats Monitor
+ * Date:            23-Jan-18
+ * Studio:          Tayx
+ *
+ * Git repo:        https://github.com/Tayx94/graphy
+ *
+ * This project is released under the MIT license.
+ * Attribution is not required, but it is always welcomed!
+ * -------------------------------------*/
+
+using UnityEngine;
+
+namespace Tayx.Graphy.Graph
+{
+    public abstract class G_Graph : MonoBehaviour
+    {
+        #region Methods -> Protected
+
+        /// <summary>
+        /// Updates the graph/s.
+        /// </summary>
+        protected abstract void UpdateGraph();
+
+        /// <summary>
+        /// Creates the points for the graph/s.
+        /// </summary>
+        protected abstract void CreatePoints();
+
+        #endregion
+    }
+}

Assets/Plugins/Graphy/Runtime/Graph/G_Graph.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 67969a520b115cd47a7d955c9b2abfa6
+timeCreated: 1516716468
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Runtime/GraphyDebugger.cs

@@ -0,0 +1,567 @@
+/* ---------------------------------------
+ * Author:          Martin Pane (martintayx@gmail.com) (@martinTayx)
+ * Contributors:    https://github.com/Tayx94/graphy/graphs/contributors
+ * Project:         Graphy - Ultimate Stats Monitor
+ * Date:            23-Dec-17
+ * Studio:          Tayx
+ *
+ * Git repo:        https://github.com/Tayx94/graphy
+ *
+ * This project is released under the MIT license.
+ * Attribution is not required, but it is always welcomed!
+ * -------------------------------------*/
+
+using System;
+using UnityEngine;
+using UnityEngine.Events;
+using Debug = UnityEngine.Debug;
+
+using System.Collections.Generic;
+using System.Linq;
+
+using Tayx.Graphy.Audio;
+using Tayx.Graphy.Fps;
+using Tayx.Graphy.Ram;
+using Tayx.Graphy.Utils;
+
+namespace Tayx.Graphy
+{
+    /// <summary>
+    /// Main class to access the Graphy Debugger API.
+    /// </summary>
+    public class GraphyDebugger : G_Singleton<GraphyDebugger>
+    {
+        protected GraphyDebugger()
+        {
+        }
+
+        #region Enums -> Public
+
+        public enum DebugVariable
+        {
+            Fps,
+            Fps_Min,
+            Fps_Max,
+            Fps_Avg,
+            Ram_Allocated,
+            Ram_Reserved,
+            Ram_Mono,
+            Audio_DB
+        }
+
+        public enum DebugComparer
+        {
+            Less_than,
+            Equals_or_less_than,
+            Equals,
+            Equals_or_greater_than,
+            Greater_than
+        }
+
+        public enum ConditionEvaluation
+        {
+            All_conditions_must_be_met,
+            Only_one_condition_has_to_be_met,
+        }
+
+        public enum MessageType
+        {
+            Log,
+            Warning,
+            Error
+        }
+
+        #endregion
+
+        #region Structs -> Public
+
+        [System.Serializable]
+        public struct DebugCondition
+        {
+            [Tooltip( "Variable to compare against" )]
+            public DebugVariable Variable;
+
+            [Tooltip( "Comparer operator to use" )]
+            public DebugComparer Comparer;
+
+            [Tooltip( "Value to compare against the chosen variable" )]
+            public float Value;
+        }
+
+        #endregion
+
+        #region Helper Classes
+
+        [System.Serializable]
+        public class DebugPacket
+        {
+            [Tooltip( "If false, it won't be checked" )]
+            public bool Active = true;
+
+            [Tooltip( "Optional Id. It's used to get or remove DebugPackets in runtime" )]
+            public int Id;
+
+            [Tooltip( "If true, once the actions are executed, this DebugPacket will delete itself" )]
+            public bool ExecuteOnce = true;
+
+            [Tooltip( "Time to wait before checking if conditions are met (use this to avoid low fps drops triggering the conditions when loading the game)" )]
+            public float InitSleepTime = 2;
+
+            [Tooltip( "Time to wait before checking if conditions are met again (once they have already been met and if ExecuteOnce is false)" )]
+            public float ExecuteSleepTime = 2;
+
+            public ConditionEvaluation ConditionEvaluation = ConditionEvaluation.All_conditions_must_be_met;
+
+            [Tooltip( "List of conditions that will be checked each frame" )]
+            public List<DebugCondition> DebugConditions = new List<DebugCondition>();
+
+            // Actions on conditions met
+
+            public MessageType MessageType;
+            [Multiline] public string Message = string.Empty;
+            public bool TakeScreenshot = false;
+            public string ScreenshotFileName = "Graphy_Screenshot";
+
+            [Tooltip( "If true, it pauses the editor" )]
+            public bool DebugBreak = false;
+
+            public UnityEvent UnityEvents;
+            public List<System.Action> Callbacks = new List<System.Action>();
+
+
+            private bool canBeChecked = false;
+            private bool executed = false;
+
+            private float timePassed = 0;
+
+            public bool Check => canBeChecked;
+
+            public void Update()
+            {
+                if( !canBeChecked )
+                {
+                    timePassed += Time.deltaTime;
+
+                    if( (executed && timePassed >= ExecuteSleepTime)
+                        || (!executed && timePassed >= InitSleepTime) )
+                    {
+                        canBeChecked = true;
+
+                        timePassed = 0;
+                    }
+                }
+            }
+
+            public void Executed()
+            {
+                canBeChecked = false;
+                executed = true;
+            }
+        }
+
+        #endregion
+
+        #region Variables -> Serialized Private
+
+        [SerializeField] private List<DebugPacket> m_debugPackets = new List<DebugPacket>();
+
+        #endregion
+
+        #region Variables -> Private
+
+        private G_FpsMonitor m_fpsMonitor = null;
+        private G_RamMonitor m_ramMonitor = null;
+        private G_AudioMonitor m_audioMonitor = null;
+
+        #endregion
+
+        #region Methods -> Unity Callbacks
+
+        private void Start()
+        {
+            m_fpsMonitor = GetComponentInChildren<G_FpsMonitor>();
+            m_ramMonitor = GetComponentInChildren<G_RamMonitor>();
+            m_audioMonitor = GetComponentInChildren<G_AudioMonitor>();
+        }
+
+        private void Update()
+        {
+            CheckDebugPackets();
+        }
+
+        #endregion
+
+        #region Methods -> Public 
+
+        /// <summary>
+        /// Add a new DebugPacket.
+        /// </summary>
+        public void AddNewDebugPacket( DebugPacket newDebugPacket )
+        {
+            m_debugPackets?.Add( newDebugPacket );
+        }
+
+        /// <summary>
+        /// Add a new DebugPacket.
+        /// </summary>
+        public void AddNewDebugPacket
+        (
+            int newId,
+            DebugCondition newDebugCondition,
+            MessageType newMessageType,
+            string newMessage,
+            bool newDebugBreak,
+            System.Action newCallback
+        )
+        {
+            DebugPacket newDebugPacket = new DebugPacket();
+
+            newDebugPacket.Id = newId;
+            newDebugPacket.DebugConditions.Add( newDebugCondition );
+            newDebugPacket.MessageType = newMessageType;
+            newDebugPacket.Message = newMessage;
+            newDebugPacket.DebugBreak = newDebugBreak;
+            newDebugPacket.Callbacks.Add( newCallback );
+
+            AddNewDebugPacket( newDebugPacket );
+        }
+
+        /// <summary>
+        /// Add a new DebugPacket.
+        /// </summary>
+        public void AddNewDebugPacket
+        (
+            int newId,
+            List<DebugCondition> newDebugConditions,
+            MessageType newMessageType,
+            string newMessage,
+            bool newDebugBreak,
+            System.Action newCallback
+        )
+        {
+            DebugPacket newDebugPacket = new DebugPacket();
+
+            newDebugPacket.Id = newId;
+            newDebugPacket.DebugConditions = newDebugConditions;
+            newDebugPacket.MessageType = newMessageType;
+            newDebugPacket.Message = newMessage;
+            newDebugPacket.DebugBreak = newDebugBreak;
+            newDebugPacket.Callbacks.Add( newCallback );
+
+            AddNewDebugPacket( newDebugPacket );
+        }
+
+        /// <summary>
+        /// Add a new DebugPacket.
+        /// </summary>
+        public void AddNewDebugPacket
+        (
+            int newId,
+            DebugCondition newDebugCondition,
+            MessageType newMessageType,
+            string newMessage,
+            bool newDebugBreak,
+            List<System.Action> newCallbacks
+        )
+        {
+            DebugPacket newDebugPacket = new DebugPacket();
+
+            newDebugPacket.Id = newId;
+            newDebugPacket.DebugConditions.Add( newDebugCondition );
+            newDebugPacket.MessageType = newMessageType;
+            newDebugPacket.Message = newMessage;
+            newDebugPacket.DebugBreak = newDebugBreak;
+            newDebugPacket.Callbacks = newCallbacks;
+
+            AddNewDebugPacket( newDebugPacket );
+        }
+
+        /// <summary>
+        /// Add a new DebugPacket.
+        /// </summary>
+        public void AddNewDebugPacket
+        (
+            int newId,
+            List<DebugCondition> newDebugConditions,
+            MessageType newMessageType,
+            string newMessage,
+            bool newDebugBreak,
+            List<System.Action> newCallbacks
+        )
+        {
+            DebugPacket newDebugPacket = new DebugPacket();
+
+            newDebugPacket.Id = newId;
+            newDebugPacket.DebugConditions = newDebugConditions;
+            newDebugPacket.MessageType = newMessageType;
+            newDebugPacket.Message = newMessage;
+            newDebugPacket.DebugBreak = newDebugBreak;
+            newDebugPacket.Callbacks = newCallbacks;
+
+            AddNewDebugPacket( newDebugPacket );
+        }
+
+        /// <summary>
+        /// Returns the first Packet with the specified ID in the DebugPacket list.
+        /// </summary>
+        /// <param name="packetId"></param>
+        /// <returns></returns>
+        public DebugPacket GetFirstDebugPacketWithId( int packetId )
+        {
+            return m_debugPackets.First( x => x.Id == packetId );
+        }
+
+        /// <summary>
+        /// Returns a list with all the Packets with the specified ID in the DebugPacket list.
+        /// </summary>
+        /// <param name="packetId"></param>
+        /// <returns></returns>
+        public List<DebugPacket> GetAllDebugPacketsWithId( int packetId )
+        {
+            return m_debugPackets.FindAll( x => x.Id == packetId );
+        }
+
+        /// <summary>
+        /// Removes the first Packet with the specified ID in the DebugPacket list.
+        /// </summary>
+        /// <param name="packetId"></param>
+        /// <returns></returns>
+        public void RemoveFirstDebugPacketWithId( int packetId )
+        {
+            if( m_debugPackets != null && GetFirstDebugPacketWithId( packetId ) != null )
+            {
+                m_debugPackets.Remove( GetFirstDebugPacketWithId( packetId ) );
+            }
+        }
+
+        /// <summary>
+        /// Removes all the Packets with the specified ID in the DebugPacket list.
+        /// </summary>
+        /// <param name="packetId"></param>
+        /// <returns></returns>
+        public void RemoveAllDebugPacketsWithId( int packetId )
+        {
+            if( m_debugPackets != null )
+            {
+                m_debugPackets.RemoveAll( x => x.Id == packetId );
+            }
+        }
+
+        /// <summary>
+        /// Add an Action callback to the first Packet with the specified ID in the DebugPacket list.
+        /// </summary>
+        /// <param name="callback"></param>
+        /// <param name="id"></param>
+        public void AddCallbackToFirstDebugPacketWithId( System.Action callback, int id )
+        {
+            if( GetFirstDebugPacketWithId( id ) != null )
+            {
+                GetFirstDebugPacketWithId( id ).Callbacks.Add( callback );
+            }
+        }
+
+        /// <summary>
+        /// Add an Action callback to all the Packets with the specified ID in the DebugPacket list.
+        /// </summary>
+        /// <param name="callback"></param>
+        /// <param name="id"></param>
+        public void AddCallbackToAllDebugPacketWithId( System.Action callback, int id )
+        {
+            if( GetAllDebugPacketsWithId( id ) != null )
+            {
+                foreach( var debugPacket in GetAllDebugPacketsWithId( id ) )
+                {
+                    if( callback != null )
+                    {
+                        debugPacket.Callbacks.Add( callback );
+                    }
+                }
+            }
+        }
+
+        #endregion
+
+        #region Methods -> Private
+
+        /// <summary>
+        /// Checks all the Debug Packets to see if they have to be executed.
+        /// </summary>
+        private void CheckDebugPackets()
+        {
+            if( m_debugPackets == null )
+            {
+                return;
+            }
+
+            for( int i = 0; i < m_debugPackets.Count; i++ )
+            {
+                DebugPacket packet = m_debugPackets[ i ];
+
+                if( packet != null && packet.Active )
+                {
+                    packet.Update();
+
+                    if( packet.Check )
+                    {
+                        switch( packet.ConditionEvaluation )
+                        {
+                            case ConditionEvaluation.All_conditions_must_be_met:
+                                int count = 0;
+
+                                foreach( var packetDebugCondition in packet.DebugConditions )
+                                {
+                                    if( CheckIfConditionIsMet( packetDebugCondition ) )
+                                    {
+                                        count++;
+                                    }
+                                }
+
+                                if( count >= packet.DebugConditions.Count )
+                                {
+                                    ExecuteOperationsInDebugPacket( packet );
+
+                                    if( packet.ExecuteOnce )
+                                    {
+                                        m_debugPackets[ i ] = null;
+                                    }
+                                }
+
+                                break;
+
+                            case ConditionEvaluation.Only_one_condition_has_to_be_met:
+                                foreach( var packetDebugCondition in packet.DebugConditions )
+                                {
+                                    if( CheckIfConditionIsMet( packetDebugCondition ) )
+                                    {
+                                        ExecuteOperationsInDebugPacket( packet );
+
+                                        if( packet.ExecuteOnce )
+                                        {
+                                            m_debugPackets[ i ] = null;
+                                        }
+
+                                        break;
+                                    }
+                                }
+
+                                break;
+                        }
+                    }
+                }
+            }
+
+            m_debugPackets.RemoveAll( ( packet ) => packet == null );
+        }
+
+        /// <summary>
+        /// Returns true if a condition is met.
+        /// </summary>
+        /// <param name="debugCondition"></param>
+        /// <returns></returns>
+        private bool CheckIfConditionIsMet( DebugCondition debugCondition )
+        {
+            switch( debugCondition.Comparer )
+            {
+                case DebugComparer.Less_than:
+                    return GetRequestedValueFromDebugVariable( debugCondition.Variable ) < debugCondition.Value;
+                case DebugComparer.Equals_or_less_than:
+                    return GetRequestedValueFromDebugVariable( debugCondition.Variable ) <= debugCondition.Value;
+                case DebugComparer.Equals:
+                    return Mathf.Approximately( GetRequestedValueFromDebugVariable( debugCondition.Variable ),
+                        debugCondition.Value );
+                case DebugComparer.Equals_or_greater_than:
+                    return GetRequestedValueFromDebugVariable( debugCondition.Variable ) >= debugCondition.Value;
+                case DebugComparer.Greater_than:
+                    return GetRequestedValueFromDebugVariable( debugCondition.Variable ) > debugCondition.Value;
+
+                default:
+                    return false;
+            }
+        }
+
+        /// <summary>
+        /// Obtains the requested value from the specified variable.
+        /// </summary>
+        /// <param name="debugVariable"></param>
+        /// <returns></returns>
+        private float GetRequestedValueFromDebugVariable( DebugVariable debugVariable )
+        {
+            switch( debugVariable )
+            {
+                case DebugVariable.Fps:
+                    return m_fpsMonitor != null ? m_fpsMonitor.CurrentFPS : 0;
+                case DebugVariable.Fps_Min:
+                    return m_fpsMonitor != null ? m_fpsMonitor.OnePercentFPS : 0;
+                case DebugVariable.Fps_Max:
+                    return m_fpsMonitor != null ? m_fpsMonitor.Zero1PercentFps : 0;
+                case DebugVariable.Fps_Avg:
+                    return m_fpsMonitor != null ? m_fpsMonitor.AverageFPS : 0;
+
+                case DebugVariable.Ram_Allocated:
+                    return m_ramMonitor != null ? m_ramMonitor.AllocatedRam : 0;
+                case DebugVariable.Ram_Reserved:
+                    return m_ramMonitor != null ? m_ramMonitor.AllocatedRam : 0;
+                case DebugVariable.Ram_Mono:
+                    return m_ramMonitor != null ? m_ramMonitor.AllocatedRam : 0;
+
+                case DebugVariable.Audio_DB:
+                    return m_audioMonitor != null ? m_audioMonitor.MaxDB : 0;
+
+                default:
+                    return 0;
+            }
+        }
+
+        /// <summary>
+        /// Executes the operations in the DebugPacket specified.
+        /// </summary>
+        /// <param name="debugPacket"></param>
+        private void ExecuteOperationsInDebugPacket( DebugPacket debugPacket )
+        {
+            if( debugPacket != null )
+            {
+                if( debugPacket.DebugBreak )
+                {
+                    Debug.Break();
+                }
+
+                if( debugPacket.Message != "" )
+                {
+                    string message = "[Graphy] (" + System.DateTime.Now + "): " + debugPacket.Message;
+
+                    switch( debugPacket.MessageType )
+                    {
+                        case MessageType.Log:
+                            Debug.Log( message );
+                            break;
+                        case MessageType.Warning:
+                            Debug.LogWarning( message );
+                            break;
+                        case MessageType.Error:
+                            Debug.LogError( message );
+                            break;
+                    }
+                }
+
+                if( debugPacket.TakeScreenshot )
+                {
+                    string path = debugPacket.ScreenshotFileName + "_" + System.DateTime.Now + ".png";
+                    path = path.Replace( "/", "-" ).Replace( " ", "_" ).Replace( ":", "-" );
+
+                    ScreenCapture.CaptureScreenshot( path );
+                }
+
+                debugPacket.UnityEvents?.Invoke();
+
+                foreach( Action callback in debugPacket.Callbacks )
+                {
+                    callback?.Invoke();
+                }
+
+                debugPacket.Executed();
+            }
+        }
+
+        #endregion
+    }
+}

Assets/Plugins/Graphy/Runtime/GraphyDebugger.cs.meta

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

Assets/Plugins/Graphy/Runtime/GraphyManager.cs.meta

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

Assets/Plugins/Graphy/Runtime/Ram.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 839df5cf44c5c6f43b1a846e73f3e498
+folderAsset: yes
+timeCreated: 1513377097
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Runtime/Ram/G_RamGraph.cs

@@ -0,0 +1,264 @@
+/* ---------------------------------------
+ * Author:          Martin Pane (martintayx@gmail.com) (@martinTayx)
+ * Contributors:    https://github.com/Tayx94/graphy/graphs/contributors
+ * Project:         Graphy - Ultimate Stats Monitor
+ * Date:            15-Dec-17
+ * Studio:          Tayx
+ *
+ * Git repo:        https://github.com/Tayx94/graphy
+ *
+ * This project is released under the MIT license.
+ * Attribution is not required, but it is always welcomed!
+ * -------------------------------------*/
+
+using Tayx.Graphy.Graph;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Tayx.Graphy.Ram
+{
+    public class G_RamGraph : G_Graph
+    {
+        #region Variables -> Serialized Private
+
+        [SerializeField] private Image m_imageAllocated = null;
+        [SerializeField] private Image m_imageReserved = null;
+        [SerializeField] private Image m_imageMono = null;
+
+        [SerializeField] private Shader ShaderFull = null;
+        [SerializeField] private Shader ShaderLight = null;
+
+        [SerializeField] private bool m_isInitialized = false;
+
+        #endregion
+
+        #region Variables -> Private
+
+        private GraphyManager m_graphyManager = null;
+
+        private G_RamMonitor m_ramMonitor = null;
+
+        private int m_resolution = 150;
+
+        private G_GraphShader m_shaderGraphAllocated = null;
+        private G_GraphShader m_shaderGraphReserved = null;
+        private G_GraphShader m_shaderGraphMono = null;
+
+        private float[] m_allocatedArray;
+        private float[] m_reservedArray;
+        private float[] m_monoArray;
+
+        private float m_highestMemory = 0;
+
+        #endregion
+
+        #region Methods -> Unity Callbacks
+
+        private void Update()
+        {
+            UpdateGraph();
+        }
+
+        #endregion
+
+        #region Methods -> Public
+
+        public void UpdateParameters()
+        {
+            if( m_shaderGraphAllocated == null
+                || m_shaderGraphReserved == null
+                || m_shaderGraphMono == null )
+            {
+                /*
+                 * Note: this is fine, since we don't much care what granularity we use if the graph
+                 * has not been initialized, i.e. it's disabled. There is no chance that for some reason 
+                 * parameters will not stay up to date if at some point in the future the graph is enabled:
+                 * at the end of Init(), UpdateParameters() is called again.
+                 */
+                return;
+            }
+
+            switch( m_graphyManager.GraphyMode )
+            {
+                case GraphyManager.Mode.FULL:
+                    m_shaderGraphAllocated.ArrayMaxSize = G_GraphShader.ArrayMaxSizeFull;
+                    m_shaderGraphReserved.ArrayMaxSize = G_GraphShader.ArrayMaxSizeFull;
+                    m_shaderGraphMono.ArrayMaxSize = G_GraphShader.ArrayMaxSizeFull;
+
+                    m_shaderGraphAllocated.Image.material = new Material( ShaderFull );
+                    m_shaderGraphReserved.Image.material = new Material( ShaderFull );
+                    m_shaderGraphMono.Image.material = new Material( ShaderFull );
+                    break;
+
+                case GraphyManager.Mode.LIGHT:
+                    m_shaderGraphAllocated.ArrayMaxSize = G_GraphShader.ArrayMaxSizeLight;
+                    m_shaderGraphReserved.ArrayMaxSize = G_GraphShader.ArrayMaxSizeLight;
+                    m_shaderGraphMono.ArrayMaxSize = G_GraphShader.ArrayMaxSizeLight;
+
+                    m_shaderGraphAllocated.Image.material = new Material( ShaderLight );
+                    m_shaderGraphReserved.Image.material = new Material( ShaderLight );
+                    m_shaderGraphMono.Image.material = new Material( ShaderLight );
+                    break;
+            }
+
+            m_shaderGraphAllocated.InitializeShader();
+            m_shaderGraphReserved.InitializeShader();
+            m_shaderGraphMono.InitializeShader();
+
+            m_resolution = m_graphyManager.RamGraphResolution;
+
+            CreatePoints();
+        }
+
+        #endregion
+
+        #region Methods -> Protected Override
+
+        protected override void UpdateGraph()
+        {
+            // Since we no longer initialize by default OnEnable(), 
+            // we need to check here, and Init() if needed
+            if( !m_isInitialized )
+            {
+                Init();
+            }
+
+            float allocatedMemory = m_ramMonitor.AllocatedRam;
+            float reservedMemory = m_ramMonitor.ReservedRam;
+            float monoMemory = m_ramMonitor.MonoRam;
+
+            m_highestMemory = 0;
+
+            for( int i = 0; i <= m_resolution - 1; i++ )
+            {
+                if( i >= m_resolution - 1 )
+                {
+                    m_allocatedArray[ i ] = allocatedMemory;
+                    m_reservedArray[ i ] = reservedMemory;
+                    m_monoArray[ i ] = monoMemory;
+                }
+                else
+                {
+                    m_allocatedArray[ i ] = m_allocatedArray[ i + 1 ];
+                    m_reservedArray[ i ] = m_reservedArray[ i + 1 ];
+                    m_monoArray[ i ] = m_monoArray[ i + 1 ];
+                }
+
+                if( m_highestMemory < m_reservedArray[ i ] )
+                {
+                    m_highestMemory = m_reservedArray[ i ];
+                }
+            }
+
+            for( int i = 0; i <= m_resolution - 1; i++ )
+            {
+                m_shaderGraphAllocated.ShaderArrayValues[ i ] = m_allocatedArray[ i ] / m_highestMemory;
+
+                m_shaderGraphReserved.ShaderArrayValues[ i ] = m_reservedArray[ i ] / m_highestMemory;
+
+                m_shaderGraphMono.ShaderArrayValues[ i ] = m_monoArray[ i ] / m_highestMemory;
+            }
+
+            m_shaderGraphAllocated.UpdatePoints();
+            m_shaderGraphReserved.UpdatePoints();
+            m_shaderGraphMono.UpdatePoints();
+        }
+
+        protected override void CreatePoints()
+        {
+            if( m_shaderGraphAllocated.ShaderArrayValues == null ||
+                m_shaderGraphAllocated.ShaderArrayValues.Length != m_resolution )
+            {
+                m_allocatedArray = new float[m_resolution];
+                m_reservedArray = new float[m_resolution];
+                m_monoArray = new float[m_resolution];
+
+                m_shaderGraphAllocated.ShaderArrayValues = new float[m_resolution];
+                m_shaderGraphReserved.ShaderArrayValues = new float[m_resolution];
+                m_shaderGraphMono.ShaderArrayValues = new float[m_resolution];
+            }
+
+            for( int i = 0; i < m_resolution; i++ )
+            {
+                m_shaderGraphAllocated.ShaderArrayValues[ i ] = 0;
+                m_shaderGraphReserved.ShaderArrayValues[ i ] = 0;
+                m_shaderGraphMono.ShaderArrayValues[ i ] = 0;
+            }
+
+            // Initialize the material values
+
+            // Colors
+
+            m_shaderGraphAllocated.GoodColor = m_graphyManager.AllocatedRamColor;
+            m_shaderGraphAllocated.CautionColor = m_graphyManager.AllocatedRamColor;
+            m_shaderGraphAllocated.CriticalColor = m_graphyManager.AllocatedRamColor;
+
+            m_shaderGraphAllocated.UpdateColors();
+
+            m_shaderGraphReserved.GoodColor = m_graphyManager.ReservedRamColor;
+            m_shaderGraphReserved.CautionColor = m_graphyManager.ReservedRamColor;
+            m_shaderGraphReserved.CriticalColor = m_graphyManager.ReservedRamColor;
+
+            m_shaderGraphReserved.UpdateColors();
+
+            m_shaderGraphMono.GoodColor = m_graphyManager.MonoRamColor;
+            m_shaderGraphMono.CautionColor = m_graphyManager.MonoRamColor;
+            m_shaderGraphMono.CriticalColor = m_graphyManager.MonoRamColor;
+
+            m_shaderGraphMono.UpdateColors();
+
+            // Thresholds
+
+            m_shaderGraphAllocated.GoodThreshold = 0;
+            m_shaderGraphAllocated.CautionThreshold = 0;
+            m_shaderGraphAllocated.UpdateThresholds();
+
+            m_shaderGraphReserved.GoodThreshold = 0;
+            m_shaderGraphReserved.CautionThreshold = 0;
+            m_shaderGraphReserved.UpdateThresholds();
+
+            m_shaderGraphMono.GoodThreshold = 0;
+            m_shaderGraphMono.CautionThreshold = 0;
+            m_shaderGraphMono.UpdateThresholds();
+
+            m_shaderGraphAllocated.UpdateArrayValuesLength();
+            m_shaderGraphReserved.UpdateArrayValuesLength();
+            m_shaderGraphMono.UpdateArrayValuesLength();
+
+            // Average
+
+            m_shaderGraphAllocated.Average = 0;
+            m_shaderGraphReserved.Average = 0;
+            m_shaderGraphMono.Average = 0;
+
+            m_shaderGraphAllocated.UpdateAverage();
+            m_shaderGraphReserved.UpdateAverage();
+            m_shaderGraphMono.UpdateAverage();
+        }
+
+        #endregion
+
+        #region Methods -> Private
+
+        private void Init()
+        {
+            m_graphyManager = transform.root.GetComponentInChildren<GraphyManager>();
+
+            m_ramMonitor = GetComponent<G_RamMonitor>();
+
+            m_shaderGraphAllocated = new G_GraphShader();
+            m_shaderGraphReserved = new G_GraphShader();
+            m_shaderGraphMono = new G_GraphShader();
+
+            m_shaderGraphAllocated.Image = m_imageAllocated;
+            m_shaderGraphReserved.Image = m_imageReserved;
+            m_shaderGraphMono.Image = m_imageMono;
+
+            UpdateParameters();
+
+            m_isInitialized = true;
+        }
+
+        #endregion
+    }
+}

Assets/Plugins/Graphy/Runtime/Ram/G_RamGraph.cs.meta

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

Assets/Plugins/Graphy/Runtime/Ram/G_RamManager.cs

@@ -0,0 +1,232 @@
+/* ---------------------------------------
+ * Author:          Martin Pane (martintayx@gmail.com) (@martinTayx)
+ * Contributors:    https://github.com/Tayx94/graphy/graphs/contributors
+ * Project:         Graphy - Ultimate Stats Monitor
+ * Date:            03-Jan-18
+ * Studio:          Tayx
+ *
+ * Git repo:        https://github.com/Tayx94/graphy
+ *
+ * This project is released under the MIT license.
+ * Attribution is not required, but it is always welcomed!
+ * -------------------------------------*/
+
+using UnityEngine;
+using System.Collections.Generic;
+using Tayx.Graphy.UI;
+using Tayx.Graphy.Utils;
+using UnityEngine.UI;
+
+namespace Tayx.Graphy.Ram
+{
+    public class G_RamManager : MonoBehaviour, IMovable, IModifiableState
+    {
+        #region Variables -> Serialized Private
+
+        [SerializeField] private GameObject m_ramGraphGameObject = null;
+
+        [SerializeField] private List<Image> m_backgroundImages = new List<Image>();
+
+        #endregion
+
+        #region Variables -> Private
+
+        private GraphyManager m_graphyManager = null;
+
+        private G_RamGraph m_ramGraph = null;
+        private G_RamText m_ramText = null;
+
+        private RectTransform m_rectTransform = null;
+        private Vector2 m_origPosition = Vector2.zero;
+
+        private List<GameObject> m_childrenGameObjects = new List<GameObject>();
+
+        private GraphyManager.ModuleState m_previousModuleState = GraphyManager.ModuleState.FULL;
+        private GraphyManager.ModuleState m_currentModuleState = GraphyManager.ModuleState.FULL;
+
+        #endregion
+
+        #region Methods -> Unity Callbacks
+
+        private void Awake()
+        {
+            Init();
+        }
+
+        private void Start()
+        {
+            UpdateParameters();
+        }
+
+        #endregion
+
+        #region Methods -> Public
+
+        public void SetPosition( GraphyManager.ModulePosition newModulePosition, Vector2 offset )
+        {
+            if ( newModulePosition == GraphyManager.ModulePosition.FREE )
+                return;
+            
+            m_rectTransform.anchoredPosition = m_origPosition;
+
+            float xSideOffset = Mathf.Abs( m_rectTransform.anchoredPosition.x ) + offset.x;
+            float ySideOffset = Mathf.Abs( m_rectTransform.anchoredPosition.y ) + offset.y;
+
+            switch( newModulePosition )
+            {
+                case GraphyManager.ModulePosition.TOP_LEFT:
+
+                    m_rectTransform.anchorMax = Vector2.up;
+                    m_rectTransform.anchorMin = Vector2.up;
+                    m_rectTransform.anchoredPosition = new Vector2( xSideOffset, -ySideOffset );
+
+                    break;
+
+                case GraphyManager.ModulePosition.TOP_RIGHT:
+
+                    m_rectTransform.anchorMax = Vector2.one;
+                    m_rectTransform.anchorMin = Vector2.one;
+                    m_rectTransform.anchoredPosition = new Vector2( -xSideOffset, -ySideOffset );
+
+                    break;
+
+                case GraphyManager.ModulePosition.BOTTOM_LEFT:
+
+                    m_rectTransform.anchorMax = Vector2.zero;
+                    m_rectTransform.anchorMin = Vector2.zero;
+                    m_rectTransform.anchoredPosition = new Vector2( xSideOffset, ySideOffset );
+
+                    break;
+
+                case GraphyManager.ModulePosition.BOTTOM_RIGHT:
+
+                    m_rectTransform.anchorMax = Vector2.right;
+                    m_rectTransform.anchorMin = Vector2.right;
+                    m_rectTransform.anchoredPosition = new Vector2( -xSideOffset, ySideOffset );
+
+                    break;
+            }
+        }
+
+        public void SetState( GraphyManager.ModuleState state, bool silentUpdate = false )
+        {
+            if( !silentUpdate )
+            {
+                m_previousModuleState = m_currentModuleState;
+            }
+
+            m_currentModuleState = state;
+
+            switch( state )
+            {
+                case GraphyManager.ModuleState.FULL:
+                    gameObject.SetActive( true );
+                    m_childrenGameObjects.SetAllActive( true );
+                    SetGraphActive( true );
+
+                    if( m_graphyManager.Background )
+                    {
+                        m_backgroundImages.SetOneActive( 0 );
+                    }
+                    else
+                    {
+                        m_backgroundImages.SetAllActive( false );
+                    }
+
+                    break;
+
+                case GraphyManager.ModuleState.TEXT:
+                case GraphyManager.ModuleState.BASIC:
+                    gameObject.SetActive( true );
+                    m_childrenGameObjects.SetAllActive( true );
+                    SetGraphActive( false );
+
+                    if( m_graphyManager.Background )
+                    {
+                        m_backgroundImages.SetOneActive( 1 );
+                    }
+                    else
+                    {
+                        m_backgroundImages.SetAllActive( false );
+                    }
+
+                    break;
+
+                case GraphyManager.ModuleState.BACKGROUND:
+                    gameObject.SetActive( true );
+                    SetGraphActive( false );
+
+                    m_childrenGameObjects.SetAllActive( false );
+                    m_backgroundImages.SetAllActive( false );
+
+                    break;
+
+                case GraphyManager.ModuleState.OFF:
+                    gameObject.SetActive( false );
+                    break;
+            }
+        }
+
+        public void RestorePreviousState()
+        {
+            SetState( m_previousModuleState );
+        }
+
+        public void UpdateParameters()
+        {
+            foreach( var image in m_backgroundImages )
+            {
+                image.color = m_graphyManager.BackgroundColor;
+            }
+
+            m_ramGraph.UpdateParameters();
+            m_ramText.UpdateParameters();
+
+            SetState( m_graphyManager.RamModuleState );
+        }
+
+        public void RefreshParameters()
+        {
+            foreach( var image in m_backgroundImages )
+            {
+                image.color = m_graphyManager.BackgroundColor;
+            }
+
+            m_ramGraph.UpdateParameters();
+            m_ramText.UpdateParameters();
+
+            SetState( m_currentModuleState, true );
+        }
+
+        #endregion
+
+        #region Methods -> Private
+
+        private void Init()
+        {
+            m_graphyManager = transform.root.GetComponentInChildren<GraphyManager>();
+
+            m_ramGraph = GetComponent<G_RamGraph>();
+            m_ramText = GetComponent<G_RamText>();
+
+            m_rectTransform = GetComponent<RectTransform>();
+            m_origPosition = m_rectTransform.anchoredPosition;
+
+            foreach( Transform child in transform )
+            {
+                if( child.parent == transform )
+                {
+                    m_childrenGameObjects.Add( child.gameObject );
+                }
+            }
+        }
+
+        private void SetGraphActive( bool active )
+        {
+            m_ramGraph.enabled = active;
+            m_ramGraphGameObject.SetActive( active );
+        }
+
+        #endregion
+    }
+}

Assets/Plugins/Graphy/Runtime/Ram/G_RamManager.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 84f7591c01b7f1a4ab82f1a0038491da
+timeCreated: 1514998367
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Runtime/Ram/G_RamMonitor.cs

@@ -0,0 +1,40 @@
+/* ---------------------------------------
+ * Author:          Martin Pane (martintayx@gmail.com) (@martinTayx)
+ * Contributors:    https://github.com/Tayx94/graphy/graphs/contributors
+ * Project:         Graphy - Ultimate Stats Monitor
+ * Date:            15-Dec-17
+ * Studio:          Tayx
+ *
+ * Git repo:        https://github.com/Tayx94/graphy
+ *
+ * This project is released under the MIT license.
+ * Attribution is not required, but it is always welcomed!
+ * -------------------------------------*/
+
+using UnityEngine;
+using UnityEngine.Profiling;
+
+namespace Tayx.Graphy.Ram
+{
+    public class G_RamMonitor : MonoBehaviour
+    {
+        #region Properties -> Public
+
+        public float AllocatedRam { get; private set; }
+        public float ReservedRam { get; private set; }
+        public float MonoRam { get; private set; }
+
+        #endregion
+
+        #region Methods -> Unity Callbacks
+
+        private void Update()
+        {
+            AllocatedRam = Profiler.GetTotalAllocatedMemoryLong() / 1048576f;
+            ReservedRam = Profiler.GetTotalReservedMemoryLong() / 1048576f;
+            MonoRam = Profiler.GetMonoUsedSizeLong() / 1048576f;
+        }
+
+        #endregion
+    }
+}

Assets/Plugins/Graphy/Runtime/Ram/G_RamMonitor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 2494656f0dd693144be1306d5551e544
+timeCreated: 1513377000
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Runtime/Ram/G_RamText.cs

@@ -0,0 +1,96 @@
+/* ---------------------------------------
+ * Author:          Martin Pane (martintayx@gmail.com) (@martinTayx)
+ * Contributors:    https://github.com/Tayx94/graphy/graphs/contributors
+ * Project:         Graphy - Ultimate Stats Monitor
+ * Date:            05-Dec-17
+ * Studio:          Tayx
+ *
+ * Git repo:        https://github.com/Tayx94/graphy
+ *
+ * This project is released under the MIT license.
+ * Attribution is not required, but it is always welcomed!
+ * -------------------------------------*/
+
+using UnityEngine;
+using UnityEngine.UI;
+using Tayx.Graphy.Utils.NumString;
+
+namespace Tayx.Graphy.Ram
+{
+    public class G_RamText : MonoBehaviour
+    {
+        #region Variables -> Serialized Private
+
+        [SerializeField] private Text m_allocatedSystemMemorySizeText = null;
+        [SerializeField] private Text m_reservedSystemMemorySizeText = null;
+        [SerializeField] private Text m_monoSystemMemorySizeText = null;
+
+        #endregion
+
+        #region Variables -> Private
+
+        private GraphyManager m_graphyManager = null;
+
+        private G_RamMonitor m_ramMonitor = null;
+
+        private float m_updateRate = 4f; // 4 updates per sec.
+
+        private float m_deltaTime = 0.0f;
+
+        #endregion
+
+        #region Methods -> Unity Callbacks
+
+        private void Awake()
+        {
+            Init();
+        }
+
+        private void Update()
+        {
+            m_deltaTime += Time.unscaledDeltaTime;
+
+            if( m_deltaTime > 1f / m_updateRate )
+            {
+                // Update allocated, mono and reserved memory
+                m_allocatedSystemMemorySizeText.text = ((int) m_ramMonitor.AllocatedRam).ToStringNonAlloc();
+                m_reservedSystemMemorySizeText.text = ((int) m_ramMonitor.ReservedRam).ToStringNonAlloc();
+                m_monoSystemMemorySizeText.text = ((int) m_ramMonitor.MonoRam).ToStringNonAlloc();
+
+                m_deltaTime = 0f;
+            }
+        }
+
+        #endregion
+
+        #region Methods -> Public
+
+        public void UpdateParameters()
+        {
+            m_allocatedSystemMemorySizeText.color = m_graphyManager.AllocatedRamColor;
+            m_reservedSystemMemorySizeText.color = m_graphyManager.ReservedRamColor;
+            m_monoSystemMemorySizeText.color = m_graphyManager.MonoRamColor;
+
+            m_updateRate = m_graphyManager.RamTextUpdateRate;
+        }
+
+        #endregion
+
+        #region Methods -> Private
+
+        private void Init()
+        {
+            // We assume no game will consume more than 16GB of RAM.
+            // If it does, who cares about some minuscule garbage allocation lol.
+            G_IntString.Init( 0, 16386 );
+
+            m_graphyManager = transform.root.GetComponentInChildren<GraphyManager>();
+
+            m_ramMonitor = GetComponent<G_RamMonitor>();
+
+            UpdateParameters();
+        }
+
+        #endregion
+    }
+}

Assets/Plugins/Graphy/Runtime/Ram/G_RamText.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 28d32ee74b6e6d24ea89d1b477060318
+timeCreated: 1512484799
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Runtime/Shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 6d11ec87c6db49d40af874a49810f377
+folderAsset: yes
+timeCreated: 1513377085
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Graphy/Runtime/Shader/G_GraphShader.cs

@@ -0,0 +1,121 @@
+/* ---------------------------------------
+ * Author:          Martin Pane (martintayx@gmail.com) (@martinTayx)
+ * Contributors:    https://github.com/Tayx94/graphy/graphs/contributors
+ * Project:         Graphy - Ultimate Stats Monitor
+ * Date:            22-Nov-17
+ * Studio:          Tayx
+ *
+ * Git repo:        https://github.com/Tayx94/graphy
+ *
+ * This project is released under the MIT license.
+ * Attribution is not required, but it is always welcomed!
+ * -------------------------------------*/
+
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Tayx.Graphy
+{
+    /// <summary>
+    /// This class communicates directly with the shader to draw the graphs. Performance here is very important
+    /// to reduce as much overhead as possible, as we are updating hundreds of values every frame.
+    /// </summary>
+    public class G_GraphShader
+    {
+        #region Variables
+
+        public const int ArrayMaxSizeFull = 512;
+        public const int ArrayMaxSizeLight = 128;
+
+        public int ArrayMaxSize = 128;
+
+        public float[] ShaderArrayValues;
+        
+        public Image Image = null;
+
+        public float Average = 0;
+        
+        public float GoodThreshold = 0;
+        public float CautionThreshold = 0;
+
+        public Color GoodColor = Color.white;
+        public Color CautionColor = Color.white;
+        public Color CriticalColor = Color.white;
+
+        private static readonly int AveragePropertyId = Shader.PropertyToID( "Average" );
+
+        private static readonly int GoodThresholdPropertyId = Shader.PropertyToID( "_GoodThreshold" );
+        private static readonly int CautionThresholdPropertyId = Shader.PropertyToID( "_CautionThreshold" );
+        
+        private static readonly int GoodColorPropertyId = Shader.PropertyToID( "_GoodColor" );
+        private static readonly int CautionColorPropertyId = Shader.PropertyToID( "_CautionColor" );
+        private static readonly int CriticalColorPropertyId = Shader.PropertyToID( "_CriticalColor" );
+        
+        private static readonly int GraphValues = Shader.PropertyToID( "GraphValues" );
+        private static readonly int GraphValuesLength = Shader.PropertyToID( "GraphValues_Length" );
+
+        #endregion
+
+        #region Methods -> Public
+
+        /// <summary>
+        /// This is done to avoid a design problem that arrays in shaders have, 
+        /// and should be called before initializing any shader graph.
+        /// The first time that you use initialize an array, the size of the array in the shader is fixed.
+        /// This is why sometimes you will get a warning saying that the array size will be capped.
+        /// It shouldn't generate any issues, but in the worst case scenario just reset the Unity Editor
+        /// (if for some reason the shaders reload).
+        /// I also cache the Property IDs, that make access faster to modify shader parameters.
+        /// </summary>
+        public void InitializeShader()
+        {
+            Image.material.SetFloatArray( GraphValues, new float[ArrayMaxSize] );
+        }
+
+        /// <summary>
+        /// Updates the GraphValuesLength parameter in the material with the current length of the
+        /// ShaderArrayValues float[] array.
+        /// </summary>
+        public void UpdateArrayValuesLength()
+        {
+            Image.material.SetInt( GraphValuesLength, ShaderArrayValues.Length );
+        }
+
+        /// <summary>
+        /// Updates the average parameter in the material.
+        /// </summary>
+        public void UpdateAverage()
+        {
+            Image.material.SetFloat( AveragePropertyId, Average );
+        }
+
+        /// <summary>
+        /// Updates the thresholds in the material.
+        /// </summary>
+        public void UpdateThresholds()
+        {
+            Image.material.SetFloat( GoodThresholdPropertyId, GoodThreshold );
+            Image.material.SetFloat( CautionThresholdPropertyId, CautionThreshold );
+        }
+
+        /// <summary>
+        /// Updates the colors in the material.
+        /// </summary>
+        public void UpdateColors()
+        {
+            Image.material.SetColor( GoodColorPropertyId, GoodColor );
+            Image.material.SetColor( CautionColorPropertyId, CautionColor );
+            Image.material.SetColor( CriticalColorPropertyId, CriticalColor );
+        }
+
+        /// <summary>
+        /// Updates the points in the graph with the set array of values.
+        /// </summary>
+        public void UpdatePoints()
+        {
+            Image.material.SetFloatArray( GraphValues, ShaderArrayValues );
+        }
+
+        #endregion
+    }
+}