Thesis-Hector-VR/Hector_v2/Library/PackageCache/com.unity.inputsystem@1.0.1/Samples~/InputRecorder/InputRecorderInspector.cs

#if UNITY_EDITOR
using UnityEditor;
using UnityEngine.Events;

////TODO: add ability to inspect contents of event traces in a separate window

namespace UnityEngine.InputSystem.Editor
{
    /// <summary>
    /// A custom inspector for <see cref="InputRecorder"/>. Adds UI elements to store captures in files, to load them from
    /// there, and to initiate replays from within the editor. It also shows information for when captures or replays are
    /// in progress.
    /// </summary>
    [CustomEditor(typeof(InputRecorder))]
    internal class InputRecorderInspector : UnityEditor.Editor
    {
        protected void OnEnable()
        {
            m_DevicePathProperty = serializedObject.FindProperty("m_DevicePath");
            m_RecordButtonPath = serializedObject.FindProperty("m_RecordButtonPath");
            m_PlayButtonPathProperty = serializedObject.FindProperty("m_PlayButtonPath");
            m_RecordFramesProperty = serializedObject.FindProperty("m_RecordFrames");
            m_RecordStateEventsOnlyProperty = serializedObject.FindProperty("m_RecordStateEventsOnly");
            m_ReplayOnNewDevicesProperty = serializedObject.FindProperty("m_ReplayOnNewDevices");
            m_SimulateTimingOnReplayProperty = serializedObject.FindProperty("m_SimulateOriginalTimingOnReplay");
            m_CaptureMemoryDefaultSizeProperty = serializedObject.FindProperty("m_CaptureMemoryDefaultSize");
            m_CaptureMemoryMaxSizeProperty = serializedObject.FindProperty("m_CaptureMemoryMaxSize");
            m_StartRecordingWhenEnabledProperty = serializedObject.FindProperty("m_StartRecordingWhenEnabled");

            m_AllInput = string.IsNullOrEmpty(m_DevicePathProperty.stringValue);

            m_PlayText = EditorGUIUtility.TrIconContent("PlayButton", "Play the current input capture.");
            m_PauseText = EditorGUIUtility.TrIconContent("PauseButton", "Pause the current input playback.");
            m_ResumeText = EditorGUIUtility.TrIconContent("PauseButton On", "Resume the current input playback.");
            m_StepForwardText = EditorGUIUtility.TrIconContent("d_StepButton", "Play the next input event.");
            m_StepBackwardText = EditorGUIUtility.TrIconContent("d_StepLeftButton", "Play the previous input event.");
            m_StopText = EditorGUIUtility.TrIconContent("PlayButton On", "Stop the current input playback.");
            m_RecordText = EditorGUIUtility.TrIconContent("Animation.Record", "Start recording input.");

            var recorder = (InputRecorder)serializedObject.targetObject;
            m_OnRecordEvent = _ => Repaint();
            recorder.changeEvent.AddListener(m_OnRecordEvent);
        }

        protected void OnDisable()
        {
            var recorder = (InputRecorder)serializedObject.targetObject;
            recorder.changeEvent.RemoveListener(m_OnRecordEvent);
        }

        public override void OnInspectorGUI()
        {
            var recorder = (InputRecorder)serializedObject.targetObject;

            using (var scope = new EditorGUI.ChangeCheckScope())
            {
                var newAllInput = EditorGUILayout.Toggle(m_AllInputText, m_AllInput);
                if (!newAllInput)
                {
                    using (new EditorGUI.IndentLevelScope())
                    {
                        EditorGUILayout.PropertyField(m_DevicePathProperty, m_DeviceText);
                    }
                }
                else if (newAllInput != m_AllInput)
                {
                    m_DevicePathProperty.stringValue = string.Empty;
                }
                m_AllInput = newAllInput;

                EditorGUILayout.PropertyField(m_RecordFramesProperty);
                EditorGUILayout.PropertyField(m_RecordStateEventsOnlyProperty);
                EditorGUILayout.PropertyField(m_ReplayOnNewDevicesProperty);
                EditorGUILayout.PropertyField(m_SimulateTimingOnReplayProperty);
                EditorGUILayout.PropertyField(m_StartRecordingWhenEnabledProperty, m_RecordWhenEnabledText);

                var defaultSizeInMB = m_CaptureMemoryDefaultSizeProperty.intValue / (1024 * 1024);
                var newDefaultSizeInMB = EditorGUILayout.IntSlider(m_DefaultSizeText, defaultSizeInMB, 1, 100);
                if (newDefaultSizeInMB != defaultSizeInMB)
                    m_CaptureMemoryDefaultSizeProperty.intValue = newDefaultSizeInMB * 1024 * 1024;

                var maxSizeInMB = m_CaptureMemoryMaxSizeProperty.intValue / (1024 * 1024);
                var newMaxSizeInMB = maxSizeInMB < newDefaultSizeInMB
                    ? newDefaultSizeInMB
                    : EditorGUILayout.IntSlider(m_MaxSizeText, maxSizeInMB, 1, 100);
                if (newMaxSizeInMB != maxSizeInMB)
                    m_CaptureMemoryMaxSizeProperty.intValue = newMaxSizeInMB * 1024 * 1024;

                EditorGUILayout.PropertyField(m_RecordButtonPath, m_RecordButtonText);
                EditorGUILayout.PropertyField(m_PlayButtonPathProperty, m_PlayButtonText);

                if (scope.changed)
                    serializedObject.ApplyModifiedProperties();
            }

            EditorGUILayout.Space();
            using (new EditorGUILayout.HorizontalScope())
            {
                ////TODO: go-to-next and go-to-previous button
                // Play and pause buttons.
                EditorGUI.BeginDisabledGroup(recorder.eventCount == 0 || recorder.captureIsRunning);
                var oldIsPlaying = recorder.replayIsRunning;
                var newIsPlaying = GUILayout.Toggle(oldIsPlaying, !oldIsPlaying ? m_PlayText : m_StopText, EditorStyles.miniButton,
                    GUILayout.Width(50));
                if (oldIsPlaying != newIsPlaying)
                {
                    if (newIsPlaying)
                        recorder.StartReplay();
                    else
                        recorder.StopReplay();
                }
                if (newIsPlaying && recorder.replay != null && GUILayout.Button(recorder.replay.paused ? m_ResumeText : m_PauseText, EditorStyles.miniButton,
                    GUILayout.Width(50)))
                {
                    if (recorder.replay.paused)
                        recorder.StartReplay();
                    else
                        recorder.PauseReplay();
                }
                EditorGUI.EndDisabledGroup();

                // Record button.
                EditorGUI.BeginDisabledGroup(recorder.replayIsRunning);
                var oldIsRecording = recorder.captureIsRunning;
                var newIsRecording = GUILayout.Toggle(oldIsRecording, m_RecordText, EditorStyles.miniButton, GUILayout.Width(50));
                if (oldIsRecording != newIsRecording)
                {
                    if (newIsRecording)
                        recorder.StartCapture();
                    else
                        recorder.StopCapture();
                }
                EditorGUI.EndDisabledGroup();

                // Load button.
                EditorGUI.BeginDisabledGroup(recorder.replayIsRunning);
                if (GUILayout.Button("Load"))
                {
                    var filePath = EditorUtility.OpenFilePanel("Choose Input Event Trace to Load", string.Empty, "inputtrace");
                    if (!string.IsNullOrEmpty(filePath))
                        recorder.LoadCaptureFromFile(filePath);
                }
                EditorGUI.EndDisabledGroup();

                // Save button.
                EditorGUI.BeginDisabledGroup(recorder.eventCount == 0 || recorder.replayIsRunning);
                if (GUILayout.Button("Save"))
                {
                    var filePath = EditorUtility.SaveFilePanel("Choose Where to Save Input Event Trace", string.Empty, $"{recorder.gameObject.name}.inputtrace", "inputtrace");
                    if (!string.IsNullOrEmpty(filePath))
                        recorder.SaveCaptureToFile(filePath);
                }

                // Clear button.
                if (GUILayout.Button("Clear"))
                {
                    recorder.ClearCapture();
                    Repaint();
                }
                EditorGUI.EndDisabledGroup();
            }

            ////TODO: allow hotscrubbing
            // Play bar.
            EditorGUILayout.IntSlider(recorder.replayPosition, 0, (int)recorder.eventCount);

            EditorGUILayout.Space();
            using (new EditorGUI.DisabledScope())
            {
                EditorGUILayout.LabelField(m_InfoText, EditorStyles.miniBoldLabel);
                using (new EditorGUI.IndentLevelScope())
                {
                    EditorGUILayout.LabelField($"{recorder.eventCount} events", EditorStyles.miniLabel);
                    EditorGUILayout.LabelField($"{recorder.totalEventSizeInBytes / 1024} kb captured", EditorStyles.miniLabel);
                    EditorGUILayout.LabelField($"{recorder.allocatedSizeInBytes / 1024} kb allocated", EditorStyles.miniLabel);

                    if (recorder.capture != null)
                    {
                        var devices = recorder.capture.deviceInfos;
                        if (devices.Count > 0)
                        {
                            EditorGUILayout.LabelField(m_DevicesText, EditorStyles.miniBoldLabel);
                            using (new EditorGUI.IndentLevelScope())
                            {
                                foreach (var device in devices)
                                {
                                    EditorGUILayout.LabelField(device.layout, EditorStyles.miniLabel);
                                }
                            }
                        }
                    }
                }
            }
        }

        private bool m_AllInput;
        private SerializedProperty m_DevicePathProperty;
        private SerializedProperty m_RecordButtonPath;
        private SerializedProperty m_PlayButtonPathProperty;
        private SerializedProperty m_RecordFramesProperty;
        private SerializedProperty m_RecordStateEventsOnlyProperty;
        private SerializedProperty m_ReplayOnNewDevicesProperty;
        private SerializedProperty m_SimulateTimingOnReplayProperty;
        private SerializedProperty m_CaptureMemoryDefaultSizeProperty;
        private SerializedProperty m_CaptureMemoryMaxSizeProperty;
        private SerializedProperty m_StartRecordingWhenEnabledProperty;
        private UnityAction<InputRecorder.Change> m_OnRecordEvent;

        private GUIContent m_RecordButtonText = new GUIContent("Record Button", "If set, this button will start and stop capture in play mode.");
        private GUIContent m_PlayButtonText = new GUIContent("Play Button", "If set, this button will start and stop replay of the current capture in play mode.");
        private GUIContent m_RecordWhenEnabledText = new GUIContent("Capture When Enabled", "If true, recording will start immediately when the component is enabled in play mode.");
        private GUIContent m_DevicesText = new GUIContent("Devices");
        private GUIContent m_AllInputText = new GUIContent("All Input", "Whether to record input from all devices or from just specific devices.");
        private GUIContent m_DeviceText = new GUIContent("Device", "Type of device to record input from.");
        private GUIContent m_InfoText = new GUIContent("Info:");
        private GUIContent m_DefaultSizeText = new GUIContent("Default Size (MB)", "Memory allocate for capture by default. Will automatically grow up to max memory.");
        private GUIContent m_MaxSizeText = new GUIContent("Max Size (MB)", "Maximum memory allocated for capture. Once a capture reaches this limit, new events will start overwriting old ones.");
        private GUIContent m_PlayText;
        private GUIContent m_PauseText;
        private GUIContent m_ResumeText;
        private GUIContent m_StepForwardText;
        private GUIContent m_StepBackwardText;
        private GUIContent m_StopText;
        private GUIContent m_RecordText;
    }
}
#endif