rabidus-test/Assets/Graphy - Ultimate Stats Mon.../Runtime/GraphyManager.cs

849 lines
35 KiB
C#
Raw Permalink Normal View History

2023-09-11 15:44:17 +03:00
/* ---------------------------------------
* Author: Martin Pane (martintayx@gmail.com) (@tayx94)
* 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;
using Tayx.Graphy.Audio;
using Tayx.Graphy.Fps;
using Tayx.Graphy.Ram;
using Tayx.Graphy.Utils;
using Tayx.Graphy.Advanced;
using Tayx.Graphy.Utils.NumString;
#if GRAPHY_NEW_INPUT
using UnityEngine.InputSystem;
#endif
namespace Tayx.Graphy
{
/// <summary>
/// Main class to access the Graphy API.
/// </summary>
public class GraphyManager : G_Singleton<GraphyManager>
{
protected GraphyManager () { }
//Enums
#region Enums -> Public
public enum Mode
{
FULL = 0,
LIGHT = 1
}
public enum ModuleType
{
FPS = 0,
RAM = 1,
AUDIO = 2,
ADVANCED = 3
}
public enum ModuleState
{
FULL = 0,
TEXT = 1,
BASIC = 2,
BACKGROUND = 3,
OFF = 4
}
public enum ModulePosition
{
TOP_RIGHT = 0,
TOP_LEFT = 1,
BOTTOM_RIGHT = 2,
BOTTOM_LEFT = 3,
FREE = 4
}
public enum LookForAudioListener
{
ALWAYS,
ON_SCENE_LOAD,
NEVER
}
public enum ModulePreset
{
FPS_BASIC = 0,
FPS_TEXT = 1,
FPS_FULL = 2,
FPS_TEXT_RAM_TEXT = 3,
FPS_FULL_RAM_TEXT = 4,
FPS_FULL_RAM_FULL = 5,
FPS_TEXT_RAM_TEXT_AUDIO_TEXT = 6,
FPS_FULL_RAM_TEXT_AUDIO_TEXT = 7,
FPS_FULL_RAM_FULL_AUDIO_TEXT = 8,
FPS_FULL_RAM_FULL_AUDIO_FULL = 9,
FPS_FULL_RAM_FULL_AUDIO_FULL_ADVANCED_FULL = 10,
FPS_BASIC_ADVANCED_FULL = 11
}
#endregion
#region Variables -> Serialized Private
[SerializeField] private Mode m_graphyMode = Mode.FULL;
[SerializeField] private bool m_enableOnStartup = true;
[SerializeField] private bool m_keepAlive = true;
[SerializeField] private bool m_background = true;
[SerializeField] private Color m_backgroundColor = new Color(0, 0, 0, 0.3f);
[SerializeField] private bool m_enableHotkeys = true;
#if GRAPHY_NEW_INPUT
[SerializeField] private Key m_toggleModeKeyCode = Key.G;
#else
[SerializeField] private KeyCode m_toggleModeKeyCode = KeyCode.G;
#endif
[SerializeField] private bool m_toggleModeCtrl = true;
[SerializeField] private bool m_toggleModeAlt = false;
#if GRAPHY_NEW_INPUT
[SerializeField] private Key m_toggleActiveKeyCode = Key.H;
#else
[SerializeField] private KeyCode m_toggleActiveKeyCode = KeyCode.H;
#endif
[SerializeField] private bool m_toggleActiveCtrl = true;
[SerializeField] private bool m_toggleActiveAlt = false;
[SerializeField] private ModulePosition m_graphModulePosition = ModulePosition.TOP_RIGHT;
// Fps ---------------------------------------------------------------------------
[SerializeField] private ModuleState m_fpsModuleState = ModuleState.FULL;
[SerializeField] private Color m_goodFpsColor = new Color32(118, 212, 58, 255);
[SerializeField] private int m_goodFpsThreshold = 60;
[SerializeField] private Color m_cautionFpsColor = new Color32(243, 232, 0, 255);
[SerializeField] private int m_cautionFpsThreshold = 30;
[SerializeField] private Color m_criticalFpsColor = new Color32(220, 41, 30, 255);
[Range(10, 300)]
[SerializeField] private int m_fpsGraphResolution = 150;
[Range(1, 200)]
[SerializeField] private int m_fpsTextUpdateRate = 3; // 3 updates per sec.
// Ram ---------------------------------------------------------------------------
[SerializeField] private ModuleState m_ramModuleState = ModuleState.FULL;
[SerializeField] private Color m_allocatedRamColor = new Color32(255, 190, 60, 255);
[SerializeField] private Color m_reservedRamColor = new Color32(205, 84, 229, 255);
[SerializeField] private Color m_monoRamColor = new Color(0.3f, 0.65f, 1f, 1);
[Range(10, 300)]
[SerializeField] private int m_ramGraphResolution = 150;
[Range(1, 200)]
[SerializeField] private int m_ramTextUpdateRate = 3; // 3 updates per sec.
// Audio -------------------------------------------------------------------------
[SerializeField] private ModuleState m_audioModuleState = ModuleState.FULL;
[SerializeField] private LookForAudioListener m_findAudioListenerInCameraIfNull = LookForAudioListener.ON_SCENE_LOAD;
[SerializeField] private AudioListener m_audioListener = null;
[SerializeField] private Color m_audioGraphColor = Color.white;
[Range(10, 300)]
[SerializeField] private int m_audioGraphResolution = 81;
[Range(1, 200)]
[SerializeField] private int m_audioTextUpdateRate = 3; // 3 updates per sec.
[SerializeField] private FFTWindow m_FFTWindow = FFTWindow.Blackman;
[Tooltip("Must be a power of 2 and between 64-8192")]
[SerializeField] private int m_spectrumSize = 512;
// Advanced ----------------------------------------------------------------------
[SerializeField] private ModulePosition m_advancedModulePosition = ModulePosition.BOTTOM_LEFT;
[SerializeField] private ModuleState m_advancedModuleState = ModuleState.FULL;
#endregion
#region Variables -> Private
private bool m_initialized = false;
private bool m_active = true;
private bool m_focused = true;
private G_FpsManager m_fpsManager = null;
private G_RamManager m_ramManager = null;
private G_AudioManager m_audioManager = null;
private G_AdvancedData m_advancedData = null;
private G_FpsMonitor m_fpsMonitor = null;
private G_RamMonitor m_ramMonitor = null;
private G_AudioMonitor m_audioMonitor = null;
private ModulePreset m_modulePresetState = ModulePreset.FPS_BASIC_ADVANCED_FULL;
#endregion
//TODO: Maybe sort these into Get and GetSet sections.
#region Properties -> Public
public Mode GraphyMode { get { return m_graphyMode; }
set { m_graphyMode = value; UpdateAllParameters(); } }
public bool EnableOnStartup { get { return m_enableOnStartup; } }
public bool KeepAlive { get { return m_keepAlive; } }
public bool Background { get { return m_background; }
set { m_background = value; UpdateAllParameters(); } }
public Color BackgroundColor { get { return m_backgroundColor; }
set { m_backgroundColor = value; UpdateAllParameters(); } }
public ModulePosition GraphModulePosition
{
get { return m_graphModulePosition; }
set
{
m_graphModulePosition = value;
m_fpsManager .SetPosition(m_graphModulePosition);
m_ramManager .SetPosition(m_graphModulePosition);
m_audioManager .SetPosition(m_graphModulePosition);
}
}
// Fps ---------------------------------------------------------------------------
// Setters & Getters
public ModuleState FpsModuleState { get { return m_fpsModuleState; }
set { m_fpsModuleState = value; m_fpsManager.SetState(m_fpsModuleState); } }
public Color GoodFPSColor { get { return m_goodFpsColor; }
set { m_goodFpsColor = value; m_fpsManager.UpdateParameters(); } }
public Color CautionFPSColor { get { return m_cautionFpsColor; }
set { m_cautionFpsColor = value; m_fpsManager.UpdateParameters(); } }
public Color CriticalFPSColor { get { return m_criticalFpsColor; }
set { m_criticalFpsColor = value; m_fpsManager.UpdateParameters(); } }
public int GoodFPSThreshold { get { return m_goodFpsThreshold; }
set { m_goodFpsThreshold = value; m_fpsManager.UpdateParameters(); } }
public int CautionFPSThreshold { get { return m_cautionFpsThreshold; }
set { m_cautionFpsThreshold = value; m_fpsManager.UpdateParameters(); } }
public int FpsGraphResolution { get { return m_fpsGraphResolution; }
set { m_fpsGraphResolution = value; m_fpsManager.UpdateParameters(); } }
public int FpsTextUpdateRate { get { return m_fpsTextUpdateRate; }
set { m_fpsTextUpdateRate = value; m_fpsManager.UpdateParameters(); } }
// Getters
public float CurrentFPS { get { return m_fpsMonitor.CurrentFPS; } }
public float AverageFPS { get { return m_fpsMonitor.AverageFPS; } }
public float MinFPS { get { return m_fpsMonitor.OnePercentFPS; } }
public float MaxFPS { get { return m_fpsMonitor.Zero1PercentFps; } }
// Ram ---------------------------------------------------------------------------
// Setters & Getters
public ModuleState RamModuleState { get { return m_ramModuleState; }
set { m_ramModuleState = value; m_ramManager.SetState(m_ramModuleState); } }
public Color AllocatedRamColor { get { return m_allocatedRamColor; }
set { m_allocatedRamColor = value; m_ramManager.UpdateParameters(); } }
public Color ReservedRamColor { get { return m_reservedRamColor; }
set { m_reservedRamColor = value; m_ramManager.UpdateParameters(); } }
public Color MonoRamColor { get { return m_monoRamColor; }
set { m_monoRamColor = value; m_ramManager.UpdateParameters(); } }
public int RamGraphResolution { get { return m_ramGraphResolution; }
set { m_ramGraphResolution = value; m_ramManager.UpdateParameters(); } }
public int RamTextUpdateRate { get { return m_ramTextUpdateRate; }
set { m_ramTextUpdateRate = value; m_ramManager.UpdateParameters(); } }
// Getters
public float AllocatedRam { get { return m_ramMonitor.AllocatedRam; } }
public float ReservedRam { get { return m_ramMonitor.ReservedRam; } }
public float MonoRam { get { return m_ramMonitor.MonoRam; } }
// Audio -------------------------------------------------------------------------
// Setters & Getters
public ModuleState AudioModuleState { get { return m_audioModuleState; }
set { m_audioModuleState = value; m_audioManager.SetState(m_audioModuleState); } }
public AudioListener AudioListener { get { return m_audioListener; }
set { m_audioListener = value; m_audioManager.UpdateParameters(); } }
public LookForAudioListener
FindAudioListenerInCameraIfNull { get { return m_findAudioListenerInCameraIfNull; }
set { m_findAudioListenerInCameraIfNull = value; m_audioManager.UpdateParameters(); } }
public Color AudioGraphColor { get { return m_audioGraphColor; }
set { m_audioGraphColor = value; m_audioManager.UpdateParameters(); } }
public int AudioGraphResolution { get { return m_audioGraphResolution; }
set { m_audioGraphResolution = value; m_audioManager.UpdateParameters(); } }
public int AudioTextUpdateRate { get { return m_audioTextUpdateRate; }
set { m_audioTextUpdateRate = value; m_audioManager.UpdateParameters(); } }
public FFTWindow FftWindow { get { return m_FFTWindow; }
set { m_FFTWindow = value; m_audioManager.UpdateParameters(); } }
public int SpectrumSize { get { return m_spectrumSize; }
set { m_spectrumSize = value; m_audioManager.UpdateParameters(); } }
// Getters
/// <summary>
/// Current audio spectrum from the specified AudioListener.
/// </summary>
public float[] Spectrum { get { return m_audioMonitor.Spectrum; } }
/// <summary>
/// Maximum DB registered in the current spectrum.
/// </summary>
public float MaxDB { get { return m_audioMonitor.MaxDB; } }
// Advanced ---------------------------------------------------------------------
// Setters & Getters
public ModuleState AdvancedModuleState { get { return m_advancedModuleState; }
set { m_advancedModuleState = value; m_advancedData.SetState(m_advancedModuleState); } }
public ModulePosition AdvancedModulePosition { get { return m_advancedModulePosition; }
set { m_advancedModulePosition = value; m_advancedData.SetPosition(m_advancedModulePosition); } }
#endregion
#region Methods -> Unity Callbacks
private void Start()
{
Init();
}
private void OnDestroy()
{
G_IntString.Dispose();
G_FloatString.Dispose();
}
private void Update()
{
if (m_focused && m_enableHotkeys)
{
CheckForHotkeyPresses();
}
}
private void OnApplicationFocus(bool isFocused)
{
m_focused = isFocused;
if (m_initialized && isFocused)
{
RefreshAllParameters();
}
}
#endregion
#region Methods -> Public
public void SetModulePosition(ModuleType moduleType, ModulePosition modulePosition)
{
switch (moduleType)
{
case ModuleType.FPS:
case ModuleType.RAM:
case ModuleType.AUDIO:
m_graphModulePosition = modulePosition;
m_ramManager.SetPosition(modulePosition);
m_fpsManager.SetPosition(modulePosition);
m_audioManager.SetPosition(modulePosition);
break;
case ModuleType.ADVANCED:
m_advancedData.SetPosition(modulePosition);
break;
}
}
public void SetModuleMode(ModuleType moduleType, ModuleState moduleState)
{
switch (moduleType)
{
case ModuleType.FPS:
m_fpsManager.SetState(moduleState);
break;
case ModuleType.RAM:
m_ramManager.SetState(moduleState);
break;
case ModuleType.AUDIO:
m_audioManager.SetState(moduleState);
break;
case ModuleType.ADVANCED:
m_advancedData.SetState(moduleState);
break;
}
}
public void ToggleModes()
{
if ((int)m_modulePresetState >= Enum.GetNames(typeof(ModulePreset)).Length - 1)
{
m_modulePresetState = 0;
}
else
{
m_modulePresetState++;
}
SetPreset(m_modulePresetState);
}
public void SetPreset(ModulePreset modulePreset)
{
m_modulePresetState = modulePreset;
switch (m_modulePresetState)
{
case ModulePreset.FPS_BASIC:
m_fpsManager.SetState(ModuleState.BASIC);
m_ramManager.SetState(ModuleState.OFF);
m_audioManager.SetState(ModuleState.OFF);
m_advancedData.SetState(ModuleState.OFF);
break;
case ModulePreset.FPS_TEXT:
m_fpsManager.SetState(ModuleState.TEXT);
m_ramManager.SetState(ModuleState.OFF);
m_audioManager.SetState(ModuleState.OFF);
m_advancedData.SetState(ModuleState.OFF);
break;
case ModulePreset.FPS_FULL:
m_fpsManager.SetState(ModuleState.FULL);
m_ramManager.SetState(ModuleState.OFF);
m_audioManager.SetState(ModuleState.OFF);
m_advancedData.SetState(ModuleState.OFF);
break;
case ModulePreset.FPS_TEXT_RAM_TEXT:
m_fpsManager.SetState(ModuleState.TEXT);
m_ramManager.SetState(ModuleState.TEXT);
m_audioManager.SetState(ModuleState.OFF);
m_advancedData.SetState(ModuleState.OFF);
break;
case ModulePreset.FPS_FULL_RAM_TEXT:
m_fpsManager.SetState(ModuleState.FULL);
m_ramManager.SetState(ModuleState.TEXT);
m_audioManager.SetState(ModuleState.OFF);
m_advancedData.SetState(ModuleState.OFF);
break;
case ModulePreset.FPS_FULL_RAM_FULL:
m_fpsManager.SetState(ModuleState.FULL);
m_ramManager.SetState(ModuleState.FULL);
m_audioManager.SetState(ModuleState.OFF);
m_advancedData.SetState(ModuleState.OFF);
break;
case ModulePreset.FPS_TEXT_RAM_TEXT_AUDIO_TEXT:
m_fpsManager.SetState(ModuleState.TEXT);
m_ramManager.SetState(ModuleState.TEXT);
m_audioManager.SetState(ModuleState.TEXT);
m_advancedData.SetState(ModuleState.OFF);
break;
case ModulePreset.FPS_FULL_RAM_TEXT_AUDIO_TEXT:
m_fpsManager.SetState(ModuleState.FULL);
m_ramManager.SetState(ModuleState.TEXT);
m_audioManager.SetState(ModuleState.TEXT);
m_advancedData.SetState(ModuleState.OFF);
break;
case ModulePreset.FPS_FULL_RAM_FULL_AUDIO_TEXT:
m_fpsManager.SetState(ModuleState.FULL);
m_ramManager.SetState(ModuleState.FULL);
m_audioManager.SetState(ModuleState.TEXT);
m_advancedData.SetState(ModuleState.OFF);
break;
case ModulePreset.FPS_FULL_RAM_FULL_AUDIO_FULL:
m_fpsManager.SetState(ModuleState.FULL);
m_ramManager.SetState(ModuleState.FULL);
m_audioManager.SetState(ModuleState.FULL);
m_advancedData.SetState(ModuleState.OFF);
break;
case ModulePreset.FPS_FULL_RAM_FULL_AUDIO_FULL_ADVANCED_FULL:
m_fpsManager.SetState(ModuleState.FULL);
m_ramManager.SetState(ModuleState.FULL);
m_audioManager.SetState(ModuleState.FULL);
m_advancedData.SetState(ModuleState.FULL);
break;
case ModulePreset.FPS_BASIC_ADVANCED_FULL:
m_fpsManager.SetState(ModuleState.BASIC);
m_ramManager.SetState(ModuleState.OFF);
m_audioManager.SetState(ModuleState.OFF);
m_advancedData.SetState(ModuleState.FULL);
break;
default:
Debug.LogWarning( "[GraphyManager]::SetPreset - Tried to set a preset that is not supported." );
break;
}
}
public void ToggleActive()
{
if (!m_active)
{
Enable();
}
else
{
Disable();
}
}
public void Enable()
{
if (!m_active)
{
if (m_initialized)
{
m_fpsManager.RestorePreviousState();
m_ramManager.RestorePreviousState();
m_audioManager.RestorePreviousState();
m_advancedData.RestorePreviousState();
m_active = true;
}
else
{
Init();
}
}
}
public void Disable()
{
if (m_active)
{
m_fpsManager.SetState(ModuleState.OFF);
m_ramManager.SetState(ModuleState.OFF);
m_audioManager.SetState(ModuleState.OFF);
m_advancedData.SetState(ModuleState.OFF);
m_active = false;
}
}
#endregion
#region Methods -> Private
private void Init()
{
if (m_keepAlive)
{
DontDestroyOnLoad(transform.root.gameObject);
}
m_fpsMonitor = GetComponentInChildren(typeof(G_FpsMonitor), true) as G_FpsMonitor;
m_ramMonitor = GetComponentInChildren(typeof(G_RamMonitor), true) as G_RamMonitor;
m_audioMonitor = GetComponentInChildren(typeof(G_AudioMonitor), true) as G_AudioMonitor;
m_fpsManager = GetComponentInChildren(typeof(G_FpsManager), true) as G_FpsManager;
m_ramManager = GetComponentInChildren(typeof(G_RamManager), true) as G_RamManager;
m_audioManager = GetComponentInChildren(typeof(G_AudioManager), true) as G_AudioManager;
m_advancedData = GetComponentInChildren(typeof(G_AdvancedData), true) as G_AdvancedData;
m_fpsManager .SetPosition(m_graphModulePosition);
m_ramManager .SetPosition(m_graphModulePosition);
m_audioManager .SetPosition(m_graphModulePosition);
m_advancedData .SetPosition(m_advancedModulePosition);
m_fpsManager .SetState (m_fpsModuleState);
m_ramManager .SetState (m_ramModuleState);
m_audioManager .SetState (m_audioModuleState);
m_advancedData .SetState (m_advancedModuleState);
if (!m_enableOnStartup)
{
ToggleActive();
// We need to enable this on startup because we disable it in GraphyManagerEditor
GetComponent<Canvas>().enabled = true;
}
m_initialized = true;
}
private void CheckForHotkeyPresses()
{
#if GRAPHY_NEW_INPUT
// Toggle Mode ---------------------------------------
if (m_toggleModeCtrl && m_toggleModeAlt)
{
if (CheckFor3KeyPress(m_toggleModeKeyCode, Key.LeftCtrl, Key.LeftAlt)
|| CheckFor3KeyPress(m_toggleModeKeyCode, Key.RightCtrl, Key.LeftAlt)
|| CheckFor3KeyPress(m_toggleModeKeyCode, Key.RightCtrl, Key.RightAlt)
|| CheckFor3KeyPress(m_toggleModeKeyCode, Key.LeftCtrl, Key.RightAlt))
{
ToggleModes();
}
}
else if (m_toggleModeCtrl)
{
if (CheckFor2KeyPress(m_toggleModeKeyCode, Key.LeftCtrl)
|| CheckFor2KeyPress(m_toggleModeKeyCode, Key.RightCtrl))
{
ToggleModes();
}
}
else if (m_toggleModeAlt)
{
if (CheckFor2KeyPress(m_toggleModeKeyCode, Key.LeftAlt)
|| CheckFor2KeyPress(m_toggleModeKeyCode, Key.RightAlt))
{
ToggleModes();
}
}
else
{
if (CheckFor1KeyPress(m_toggleModeKeyCode))
{
ToggleModes();
}
}
// Toggle Active -------------------------------------
if (m_toggleActiveCtrl && m_toggleActiveAlt)
{
if (CheckFor3KeyPress(m_toggleActiveKeyCode, Key.LeftCtrl, Key.LeftAlt)
|| CheckFor3KeyPress(m_toggleActiveKeyCode, Key.RightCtrl, Key.LeftAlt)
|| CheckFor3KeyPress(m_toggleActiveKeyCode, Key.RightCtrl, Key.RightAlt)
|| CheckFor3KeyPress(m_toggleActiveKeyCode, Key.LeftCtrl, Key.RightAlt))
{
ToggleActive();
}
}
else if (m_toggleActiveCtrl)
{
if (CheckFor2KeyPress(m_toggleActiveKeyCode, Key.LeftCtrl)
|| CheckFor2KeyPress(m_toggleActiveKeyCode, Key.RightCtrl))
{
ToggleActive();
}
}
else if (m_toggleActiveAlt)
{
if (CheckFor2KeyPress(m_toggleActiveKeyCode, Key.LeftAlt)
|| CheckFor2KeyPress(m_toggleActiveKeyCode, Key.RightAlt))
{
ToggleActive();
}
}
else
{
if (CheckFor1KeyPress(m_toggleActiveKeyCode))
{
ToggleActive();
}
}
#else
// Toggle Mode ---------------------------------------
if (m_toggleModeCtrl && m_toggleModeAlt)
{
if (CheckFor3KeyPress(m_toggleModeKeyCode, KeyCode.LeftControl, KeyCode.LeftAlt)
|| CheckFor3KeyPress(m_toggleModeKeyCode, KeyCode.RightControl, KeyCode.LeftAlt)
|| CheckFor3KeyPress(m_toggleModeKeyCode, KeyCode.RightControl, KeyCode.RightAlt)
|| CheckFor3KeyPress(m_toggleModeKeyCode, KeyCode.LeftControl, KeyCode.RightAlt))
{
ToggleModes();
}
}
else if (m_toggleModeCtrl)
{
if ( CheckFor2KeyPress(m_toggleModeKeyCode, KeyCode.LeftControl)
|| CheckFor2KeyPress(m_toggleModeKeyCode, KeyCode.RightControl))
{
ToggleModes();
}
}
else if (m_toggleModeAlt)
{
if ( CheckFor2KeyPress(m_toggleModeKeyCode, KeyCode.LeftAlt)
|| CheckFor2KeyPress(m_toggleModeKeyCode, KeyCode.RightAlt))
{
ToggleModes();
}
}
else
{
if (CheckFor1KeyPress(m_toggleModeKeyCode))
{
ToggleModes();
}
}
// Toggle Active -------------------------------------
if (m_toggleActiveCtrl && m_toggleActiveAlt)
{
if ( CheckFor3KeyPress(m_toggleActiveKeyCode, KeyCode.LeftControl, KeyCode.LeftAlt)
|| CheckFor3KeyPress(m_toggleActiveKeyCode, KeyCode.RightControl, KeyCode.LeftAlt)
|| CheckFor3KeyPress(m_toggleActiveKeyCode, KeyCode.RightControl, KeyCode.RightAlt)
|| CheckFor3KeyPress(m_toggleActiveKeyCode, KeyCode.LeftControl, KeyCode.RightAlt))
{
ToggleActive();
}
}
else if (m_toggleActiveCtrl)
{
if ( CheckFor2KeyPress(m_toggleActiveKeyCode, KeyCode.LeftControl)
|| CheckFor2KeyPress(m_toggleActiveKeyCode, KeyCode.RightControl))
{
ToggleActive();
}
}
else if (m_toggleActiveAlt)
{
if ( CheckFor2KeyPress(m_toggleActiveKeyCode, KeyCode.LeftAlt)
|| CheckFor2KeyPress(m_toggleActiveKeyCode, KeyCode.RightAlt))
{
ToggleActive();
}
}
else
{
if (CheckFor1KeyPress(m_toggleActiveKeyCode))
{
ToggleActive();
}
}
#endif
}
#if GRAPHY_NEW_INPUT
private bool CheckFor1KeyPress(Key key)
{
Keyboard currentKeyboard = Keyboard.current;
if (currentKeyboard != null)
{
return Keyboard.current[key].wasPressedThisFrame;
}
return false;
}
private bool CheckFor2KeyPress(Key key1, Key key2)
{
Keyboard currentKeyboard = Keyboard.current;
if (currentKeyboard != null)
{
return Keyboard.current[key1].wasPressedThisFrame && Keyboard.current[key2].isPressed
|| Keyboard.current[key2].wasPressedThisFrame && Keyboard.current[key1].isPressed;
}
return false;
}
private bool CheckFor3KeyPress(Key key1, Key key2, Key key3)
{
Keyboard currentKeyboard = Keyboard.current;
if (currentKeyboard != null)
{
return Keyboard.current[key1].wasPressedThisFrame && Keyboard.current[key2].isPressed && Keyboard.current[key3].isPressed
|| Keyboard.current[key2].wasPressedThisFrame && Keyboard.current[key1].isPressed && Keyboard.current[key3].isPressed
|| Keyboard.current[key3].wasPressedThisFrame && Keyboard.current[key1].isPressed && Keyboard.current[key2].isPressed;
}
return false;
}
#else
private bool CheckFor1KeyPress(KeyCode key)
{
return Input.GetKeyDown(key);
}
private bool CheckFor2KeyPress(KeyCode key1, KeyCode key2)
{
return Input.GetKeyDown(key1) && Input.GetKey(key2)
|| Input.GetKeyDown(key2) && Input.GetKey(key1);
}
private bool CheckFor3KeyPress(KeyCode key1, KeyCode key2, KeyCode key3)
{
return Input.GetKeyDown(key1) && Input.GetKey(key2) && Input.GetKey(key3)
|| Input.GetKeyDown(key2) && Input.GetKey(key1) && Input.GetKey(key3)
|| Input.GetKeyDown(key3) && Input.GetKey(key1) && Input.GetKey(key2);
}
#endif
private void UpdateAllParameters()
{
m_fpsManager .UpdateParameters();
m_ramManager .UpdateParameters();
m_audioManager .UpdateParameters();
m_advancedData .UpdateParameters();
}
private void RefreshAllParameters()
{
m_fpsManager .RefreshParameters();
m_ramManager .RefreshParameters();
m_audioManager .RefreshParameters();
m_advancedData .RefreshParameters();
}
#endregion
}
}