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

using System;
using UnityEngine.InputSystem.Utilities;
using Unity.Collections.LowLevel.Unsafe;
using UnityEngine.InputSystem.LowLevel;

////REVIEW: for vector2 visualizers of sticks, it could be useful to also visualize deadzones and raw values

namespace UnityEngine.InputSystem.Samples
{
    internal static class VisualizationHelpers
    {
        public enum Axis { X, Y, Z }

        public abstract class Visualizer
        {
            public abstract void OnDraw(Rect rect);
            public abstract void AddSample(object value, double time);
        }

        public abstract class ValueVisualizer<TValue> : Visualizer
            where TValue : struct
        {
            public RingBuffer<TValue> samples;
            public RingBuffer<GUIContent> samplesText;

            protected ValueVisualizer(int numSamples = 10)
            {
                samples = new RingBuffer<TValue>(numSamples);
                samplesText = new RingBuffer<GUIContent>(numSamples);
            }

            public override void AddSample(object value, double time)
            {
                var v = default(TValue);

                if (value != null)
                {
                    if (!(value is TValue val))
                        throw new ArgumentException(
                            $"Expecting value of type '{typeof(TValue).Name}' but value of type '{value?.GetType().Name}' instead",
                            nameof(value));
                    v = val;
                }

                samples.Append(v);
                samplesText.Append(new GUIContent(v.ToString()));
            }
        }

        // Visualizes integer and real type primitives.
        public class ScalarVisualizer<TValue> : ValueVisualizer<TValue>
            where TValue : struct
        {
            public TValue limitMin;
            public TValue limitMax;
            public TValue min;
            public TValue max;

            public ScalarVisualizer(int numSamples = 10)
                : base(numSamples)
            {
            }

            public override void OnDraw(Rect rect)
            {
                // For now, only draw the current value.
                DrawRectangle(rect, new Color(1, 1, 1, 0.1f));
                if (samples.count == 0)
                    return;
                var sample = samples[samples.count - 1];
                if (Compare(sample, default) == 0)
                    return;
                if (Compare(limitMin, default) != 0)
                {
                    // Two-way visualization with positive and negative side.
                    throw new NotImplementedException();
                }
                else
                {
                    // One-way visualization with only positive side.
                    var ratio = Divide(sample, limitMax);
                    var fillRect = rect;
                    fillRect.width = rect.width * ratio;
                    DrawRectangle(fillRect, new Color(0, 1, 0, 0.75f));

                    var valuePos = new Vector2(fillRect.xMax, fillRect.y + fillRect.height / 2);
                    DrawText(samplesText[samples.count - 1], valuePos, ValueTextStyle);
                }
            }

            public override void AddSample(object value, double time)
            {
                base.AddSample(value, time);

                if (value != null)
                {
                    var val = (TValue)value;
                    if (Compare(min, val) > 0)
                        min = val;
                    if (Compare(max, val) < 0)
                        max = val;
                }
            }

            private static unsafe int Compare(TValue left, TValue right)
            {
                var leftPtr = UnsafeUtility.AddressOf(ref left);
                var rightPtr = UnsafeUtility.AddressOf(ref right);
                if (typeof(TValue) == typeof(int))
                    return ((int*)leftPtr)->CompareTo(*(int*)rightPtr);
                if (typeof(TValue) == typeof(float))
                    return ((float*)leftPtr)->CompareTo(*(float*)rightPtr);
                throw new NotImplementedException("Scalar value type: " + typeof(TValue).Name);
            }

            private static unsafe void Subtract(ref TValue left, TValue right)
            {
                var leftPtr = UnsafeUtility.AddressOf(ref left);
                var rightPtr = UnsafeUtility.AddressOf(ref right);

                if (typeof(TValue) == typeof(int))
                    *(int*)leftPtr = *(int*)leftPtr - *(int*)rightPtr;
                if (typeof(TValue) == typeof(float))
                    *(float*)leftPtr = *(float*)leftPtr - *(float*)rightPtr;
                throw new NotImplementedException("Scalar value type: " + typeof(TValue).Name);
            }

            private static unsafe float Divide(TValue left, TValue right)
            {
                var leftPtr = UnsafeUtility.AddressOf(ref left);
                var rightPtr = UnsafeUtility.AddressOf(ref right);

                if (typeof(TValue) == typeof(int))
                    return (float)*(int*)leftPtr / *(int*)rightPtr;
                if (typeof(TValue) == typeof(float))
                    return *(float*)leftPtr / *(float*)rightPtr;
                throw new NotImplementedException("Scalar value type: " + typeof(TValue).Name);
            }
        }

        ////TODO: allow asymmetric center (i.e. center not being a midpoint of rectangle)
        ////TODO: enforce proper proportion between X and Y; it's confusing that X and Y can have different units yet have the same length
        public class Vector2Visualizer : ValueVisualizer<Vector2>
        {
            // Our value space extends radially from the center, i.e. we have
            // 360 discrete directions. Sampling at that granularity doesn't work
            // super well in visualizations so we quantize to 3 degree increments.
            public Vector2[] maximums = new Vector2[360 / 3];
            public Vector2 limits = new Vector2(1, 1);

            private GUIContent limitsXText;
            private GUIContent limitsYText;

            public Vector2Visualizer(int numSamples = 10)
                : base(numSamples)
            {
            }

            public override void AddSample(object value, double time)
            {
                base.AddSample(value, time);

                if (value != null)
                {
                    // Keep track of radial maximums.
                    var vector = (Vector2)value;
                    var angle = Vector2.SignedAngle(Vector2.right, vector);
                    if (angle < 0)
                        angle = 360 + angle;
                    var angleInt = Mathf.FloorToInt(angle) / 3;
                    if (vector.sqrMagnitude > maximums[angleInt].sqrMagnitude)
                        maximums[angleInt] = vector;

                    // Extend limits if value is out of range.
                    var limitX = Mathf.Max(Mathf.Abs(vector.x), limits.x);
                    var limitY = Mathf.Max(Mathf.Abs(vector.y), limits.y);
                    if (!Mathf.Approximately(limitX, limits.x))
                    {
                        limits.x = limitX;
                        limitsXText = null;
                    }
                    if (!Mathf.Approximately(limitY, limits.y))
                    {
                        limits.y = limitY;
                        limitsYText = null;
                    }
                }
            }

            public override void OnDraw(Rect rect)
            {
                DrawRectangle(rect, new Color(1, 1, 1, 0.1f));
                DrawAxis(Axis.X, rect, new Color(0, 1, 0, 0.75f));
                DrawAxis(Axis.Y, rect, new Color(0, 1, 0, 0.75f));

                var sampleCount = samples.count;
                if (sampleCount == 0)
                    return;

                // If limits aren't (1,1), show the actual values.
                if (limits != new Vector2(1, 1))
                {
                    if (limitsXText == null)
                        limitsXText = new GUIContent(limits.x.ToString());
                    if (limitsYText == null)
                        limitsYText = new GUIContent(limits.y.ToString());

                    var limitsXSize = ValueTextStyle.CalcSize(limitsXText);
                    var limitsXPos = new Vector2(rect.x - limitsXSize.x, rect.y - 5);
                    var limitsYPos = new Vector2(rect.xMax, rect.yMax);

                    DrawText(limitsXText, limitsXPos, ValueTextStyle);
                    DrawText(limitsYText, limitsYPos, ValueTextStyle);
                }

                // Draw maximums.
                var numMaximums = 0;
                var firstMaximumPos = default(Vector2);
                var lastMaximumPos = default(Vector2);
                for (var i = 0; i < 360 / 3; ++i)
                {
                    var value = maximums[i];
                    if (value == default)
                        continue;
                    var valuePos = PixelPosForValue(value, rect);
                    if (numMaximums > 0)
                        DrawLine(lastMaximumPos, valuePos, new Color(1, 1, 1, 0.25f));
                    else
                        firstMaximumPos = valuePos;
                    lastMaximumPos = valuePos;
                    ++numMaximums;
                }
                if (numMaximums > 1)
                    DrawLine(lastMaximumPos, firstMaximumPos, new Color(1, 1, 1, 0.25f));

                // Draw samples.
                var alphaStep = 1f / sampleCount;
                var alpha = 1f;
                for (var i = sampleCount - 1; i >= 0; --i) // Go newest to oldest.
                {
                    var value = samples[i];
                    var valueRect = RectForValue(value, rect);
                    DrawRectangle(valueRect, new Color(1, 0, 0, alpha));
                    alpha -= alphaStep;
                }

                // Print value of most recent sample. Draw last so
                // we draw over the other stuff.
                var lastSample = samples[sampleCount - 1];
                var lastSamplePos = PixelPosForValue(lastSample, rect);
                lastSamplePos.x += 3;
                lastSamplePos.y += 3;
                DrawText(samplesText[sampleCount - 1], lastSamplePos, ValueTextStyle);
            }

            private Rect RectForValue(Vector2 value, Rect rect)
            {
                var pos = PixelPosForValue(value, rect);
                return new Rect(pos.x - 1, pos.y - 1, 2, 2);
            }

            private Vector2 PixelPosForValue(Vector2 value, Rect rect)
            {
                var center = rect.center;
                var x = Mathf.Abs(value.x) / limits.x * Mathf.Sign(value.x);
                var y = Mathf.Abs(value.y) / limits.y * Mathf.Sign(value.y) * -1; // GUI Y is upside down.
                var xInPixels = x * rect.width / 2;
                var yInPixels = y * rect.height / 2;
                return new Vector2(center.x + xInPixels,
                    center.y + yInPixels);
            }
        }

        // Y axis is time, X axis can be multiple visualizations.
        public class TimelineVisualizer : Visualizer
        {
            public bool showLegend { get; set; }
            public bool showLimits { get; set; }
            public TimeUnit timeUnit { get; set; } = TimeUnit.Seconds;
            public GUIContent valueUnit { get; set; }
            ////REVIEW: should this be per timeline?
            public int timelineCount => m_Timelines != null ? m_Timelines.Length : 0;
            public int historyDepth { get; set; } = 100;

            public Vector2 limitsY
            {
                get => m_LimitsY;
                set
                {
                    m_LimitsY = value;
                    m_LimitsYMin = null;
                    m_LimitsYMax = null;
                }
            }

            public TimelineVisualizer(float totalTimeUnitsShown = 4)
            {
                m_TotalTimeUnitsShown = totalTimeUnitsShown;
            }

            public override void OnDraw(Rect rect)
            {
                var endTime = Time.realtimeSinceStartup;
                var startTime = endTime - m_TotalTimeUnitsShown;
                var endFrame = InputState.updateCount;
                var startFrame = endFrame - (int)m_TotalTimeUnitsShown;

                for (var i = 0; i < timelineCount; ++i)
                {
                    var timeline = m_Timelines[i];
                    var sampleCount = timeUnit == TimeUnit.Frames
                        ? timeline.frameSamples.count
                        : timeline.timeSamples.count;

                    // Set up clip rect so that we can do stuff like render lines to samples
                    // falling outside the render rectangle and have them get clipped.
                    GUI.BeginGroup(rect);
                    var plotType = timeline.plotType;
                    var lastPos = default(Vector2);
                    var timeUnitsPerPixel = rect.width / m_TotalTimeUnitsShown;
                    var color = m_Timelines[i].color;
                    for (var n = sampleCount - 1; n >= 0; --n)
                    {
                        var sample = timeUnit == TimeUnit.Frames
                            ? timeline.frameSamples[n].value
                            : timeline.timeSamples[n].value;

                        ////TODO: respect limitsY

                        float y;
                        if (sample.isEmpty)
                            y = 0.5f;
                        else
                            y = sample.ToSingle();

                        y /= limitsY.y;

                        var deltaTime = timeUnit == TimeUnit.Frames
                            ? timeline.frameSamples[n].frame - startFrame
                            : timeline.timeSamples[n].time - startTime;
                        var pos = new Vector2(deltaTime * timeUnitsPerPixel, rect.height - y * rect.height);

                        if (plotType == PlotType.LineGraph)
                        {
                            if (n != sampleCount - 1)
                            {
                                DrawLine(lastPos, pos, color, 2);
                                if (pos.x < 0)
                                    break;
                            }
                        }
                        else if (plotType == PlotType.BarChart)
                        {
                            ////TODO: make rectangles have a progressively stronger hue or saturation
                            var barRect = new Rect(pos.x, pos.y, timeUnitsPerPixel, y * limitsY.y * rect.height);
                            DrawRectangle(barRect, color);
                        }

                        lastPos = pos;
                    }
                    GUI.EndGroup();
                }

                if (showLegend && timelineCount > 0)
                {
                    var legendRect = rect;
                    legendRect.x += rect.width + 2;
                    legendRect.width = 400;
                    legendRect.height = ValueTextStyle.CalcHeight(m_Timelines[0].name, 400);
                    for (var i = 0; i < m_Timelines.Length; ++i)
                    {
                        var colorTagRect = legendRect;
                        colorTagRect.width = 5;
                        var labelRect = legendRect;
                        labelRect.x += 8;
                        labelRect.width -= 8;

                        DrawRectangle(colorTagRect, m_Timelines[i].color);
                        DrawText(m_Timelines[i].name, labelRect.position, ValueTextStyle);

                        legendRect.y += labelRect.height + 2;
                    }
                }

                if (showLimits)
                {
                    if (m_LimitsYMax == null)
                        m_LimitsYMax = new GUIContent(m_LimitsY.y.ToString());
                    if (m_LimitsYMin == null)
                        m_LimitsYMin = new GUIContent(m_LimitsY.x.ToString());

                    DrawText(m_LimitsYMax, new Vector2(rect.x + rect.width, rect.y), ValueTextStyle);
                    DrawText(m_LimitsYMin, new Vector2(rect.x + rect.width, rect.y + rect.height), ValueTextStyle);
                }
            }

            public override void AddSample(object value, double time)
            {
                if (timelineCount == 0)
                    throw new InvalidOperationException("Must have set up a timeline first");
                AddSample(0, PrimitiveValue.FromObject(value), (float)time);
            }

            public int AddTimeline(string name, Color color, PlotType plotType = default)
            {
                var timeline = new Timeline
                {
                    name = new GUIContent(name),
                    color = color,
                    plotType = plotType,
                };
                if (timeUnit == TimeUnit.Frames)
                    timeline.frameSamples = new RingBuffer<FrameSample>(historyDepth);
                else
                    timeline.timeSamples = new RingBuffer<TimeSample>(historyDepth);

                var index = timelineCount;
                Array.Resize(ref m_Timelines, timelineCount + 1);
                m_Timelines[index] = timeline;

                return index;
            }

            public int GetTimeline(string name)
            {
                for (var i = 0; i < timelineCount; ++i)
                    if (string.Compare(m_Timelines[i].name.text, name, StringComparison.InvariantCultureIgnoreCase) == 0)
                        return i;
                return -1;
            }

            // Add a time-based sample.
            public void AddSample(int timelineIndex, PrimitiveValue value, float time)
            {
                m_Timelines[timelineIndex].timeSamples.Append(new TimeSample
                {
                    value = value,
                    time = time
                });
            }

            // Add a frame-based sample.
            public ref PrimitiveValue GetOrCreateSample(int timelineIndex, int frame)
            {
                ref var timeline = ref m_Timelines[timelineIndex];
                ref var samples = ref timeline.frameSamples;
                var count = samples.count;
                if (count > 0)
                {
                    if (samples[count - 1].frame == frame)
                        return ref samples[count - 1].value;

                    Debug.Assert(samples[count - 1].frame < frame, "Frame numbers must be ascending");
                }

                return ref samples.Append(new FrameSample {frame = frame}).value;
            }

            private float m_TotalTimeUnitsShown;
            private Vector2 m_LimitsY = new Vector2(-1, 1);
            private GUIContent m_LimitsYMin;
            private GUIContent m_LimitsYMax;
            private Timeline[] m_Timelines;

            private struct TimeSample
            {
                public PrimitiveValue value;
                public float time;
            }

            private struct FrameSample
            {
                public PrimitiveValue value;
                public int frame;
            }

            private struct Timeline
            {
                public GUIContent name;
                public Color color;
                public RingBuffer<TimeSample> timeSamples;
                public RingBuffer<FrameSample> frameSamples;
                public PrimitiveValue minValue;
                public PrimitiveValue maxValue;
                public PlotType plotType;
            }

            public enum PlotType
            {
                LineGraph,
                BarChart,
            }

            public enum TimeUnit
            {
                Seconds,
                Frames,
            }
        }

        public static void DrawAxis(Axis axis, Rect rect, Color color = default, float width = 1)
        {
            Vector2 start, end, tickOffset;
            switch (axis)
            {
                case Axis.X:
                    start = new Vector2(rect.x, rect.y + rect.height / 2);
                    end = new Vector2(start.x + rect.width, rect.y + rect.height / 2);
                    tickOffset = new Vector2(0, 3);
                    break;

                case Axis.Y:
                    start = new Vector2(rect.x + rect.width / 2, rect.y);
                    end = new Vector2(start.x, rect.y + rect.height);
                    tickOffset = new Vector2(3, 0);
                    break;

                case Axis.Z:
                    // From bottom left corner to upper right corner.
                    start = new Vector2(rect.x, rect.yMax);
                    end = new Vector2(rect.xMax, rect.y);
                    tickOffset = new Vector2(1.5f, 1.5f);
                    break;

                default:
                    throw new NotImplementedException();
            }

            ////TODO: label limits

            DrawLine(start, end, color, width);
            DrawLine(start - tickOffset, start + tickOffset, color, width);
            DrawLine(end - tickOffset, end + tickOffset, color, width);
        }

        public static void DrawRectangle(Rect rect, Color color)
        {
            var savedColor = GUI.color;
            GUI.color = color;
            GUI.DrawTexture(rect, OnePixTex);
            GUI.color = savedColor;
        }

        public static void DrawText(string text, Vector2 pos, GUIStyle style)
        {
            var content = new GUIContent(text);
            DrawText(content, pos, style);
        }

        public static void DrawText(GUIContent text, Vector2 pos, GUIStyle style)
        {
            var content = new GUIContent(text);
            var size = style.CalcSize(content);
            var rect = new Rect(pos.x, pos.y, size.x, size.y);
            style.Draw(rect, content, false, false, false, false);
        }

        // Adapted from http://wiki.unity3d.com/index.php?title=DrawLine
        public static void DrawLine(Vector2 pointA, Vector2 pointB, Color color = default, float width = 1)
        {
            // Save the current GUI matrix, since we're going to make changes to it.
            var matrix = GUI.matrix;

            // Store current GUI color, so we can switch it back later,
            // and set the GUI color to the color parameter
            var savedColor = GUI.color;
            GUI.color = color;

            // Determine the angle of the line.
            var angle = Vector3.Angle(pointB - pointA, Vector2.right);

            // Vector3.Angle always returns a positive number.
            // If pointB is above pointA, then angle needs to be negative.
            if (pointA.y > pointB.y)
                angle = -angle;

            // Use ScaleAroundPivot to adjust the size of the line.
            // We could do this when we draw the texture, but by scaling it here we can use
            //  non-integer values for the width and length (such as sub 1 pixel widths).
            // Note that the pivot point is at +.5 from pointA.y, this is so that the width of the line
            //  is centered on the origin at pointA.
            GUIUtility.ScaleAroundPivot(new Vector2((pointB - pointA).magnitude, width), new Vector2(pointA.x, pointA.y + 0.5f));

            // Set the rotation for the line.
            //  The angle was calculated with pointA as the origin.
            GUIUtility.RotateAroundPivot(angle, pointA);

            // Finally, draw the actual line.
            // We're really only drawing a 1x1 texture from pointA.
            // The matrix operations done with ScaleAroundPivot and RotateAroundPivot will make this
            //  render with the proper width, length, and angle.
            GUI.DrawTexture(new Rect(pointA.x, pointA.y, 1, 1), OnePixTex);

            // We're done.  Restore the GUI matrix and GUI color to whatever they were before.
            GUI.matrix = matrix;
            GUI.color = savedColor;
        }

        private static Texture2D s_OnePixTex;
        private static GUIStyle s_ValueTextStyle;

        internal static GUIStyle ValueTextStyle
        {
            get
            {
                if (s_ValueTextStyle == null)
                {
                    s_ValueTextStyle = new GUIStyle();
                    s_ValueTextStyle.fontSize -= 2;
                    s_ValueTextStyle.normal.textColor = Color.white;
                }
                return s_ValueTextStyle;
            }
        }

        internal static Texture2D OnePixTex
        {
            get
            {
                if (s_OnePixTex == null)
                    s_OnePixTex = new Texture2D(1, 1);
                return s_OnePixTex;
            }
        }

        public struct RingBuffer<TValue>
        {
            public TValue[] array;
            public int head;
            public int count;

            public RingBuffer(int size)
            {
                array = new TValue[size];
                head = 0;
                count = 0;
            }

            public ref TValue Append(TValue value)
            {
                int index;
                var bufferSize = array.Length;
                if (count < bufferSize)
                {
                    Debug.Assert(head == 0, "Head can't have moved if buffer isn't full yet");
                    index = count;
                    ++count;
                }
                else
                {
                    // Buffer is full. Bump head.
                    index = (head + count) % bufferSize;
                    ++head;
                }
                array[index] = value;
                return ref array[index];
            }

            public ref TValue this[int index]
            {
                get
                {
                    if (index < 0 || index >= count)
                        throw new ArgumentOutOfRangeException(nameof(index));
                    return ref array[(head + index) % array.Length];
                }
            }
        }
    }
}