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);
}
}
// Visualizes .current device value
public class CurrentDeviceVisualizer : Visualizer
{
private InputDevice m_CurrentDevice = null;
public override void OnDraw(Rect rect)
{
// For now, only draw the current value.
DrawRectangle(rect, new Color(1, 1, 1, 0.1f));
var name = m_CurrentDevice != null ? m_CurrentDevice.name : "null";
DrawText(name, new Vector2(rect.xMin + 4, (rect.yMin + rect.yMax) / 2.0f), ValueTextStyle);
}
public override void AddSample(object value, double time)
{
var device = (InputDevice)value;
if (device is Gamepad)
m_CurrentDevice = Gamepad.current;
else if (device is Mouse)
m_CurrentDevice = Mouse.current;
else if (device is Pen)
m_CurrentDevice = Pen.current;
else if (device is Pointer) // should be last, because it's a base class for Mouse and Pen
m_CurrentDevice = Pointer.current;
else
throw new ArgumentException(
$"Expected device type that implements .current, but got '{device.name}' (deviceId: {device.deviceId}) instead ");
}
}
////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];
}
}
}
}
}