From Measuring Performance

Assets/Script/FrameRateCounter.cs

@@ -0,0 +1,66 @@
+using UnityEngine;
+using TMPro;
+
+public class FrameRateCounter : MonoBehaviour
+{
+    [SerializeField]
+    TextMeshProUGUI display = default;
+
+    public enum DisplayMode { FPS, MS };
+
+    [SerializeField]
+    DisplayMode displayMode = DisplayMode.FPS;
+
+    [SerializeField, Range(0.1f, 2.0f)]
+    float sampleDuration = 1.0f;
+
+    int frames;
+
+    float duration;
+    float bestDuration = float.MaxValue;
+    float worstDuration = 0.0f;
+
+    private void Update()
+    {
+        var frameDuration = Time.unscaledDeltaTime;
+        frames++;
+        duration += frameDuration;
+
+        if (frameDuration < bestDuration)
+        {
+            bestDuration = frameDuration;
+        }
+        if (frameDuration > worstDuration)
+        {
+            worstDuration = frameDuration;
+        }
+
+        if (duration >= sampleDuration)
+        {
+            if (displayMode == DisplayMode.FPS)
+            {
+                display.SetText(
+                    "FPS\n{0:0}\n{1:0}\n{2:0}",
+                    1.0f / bestDuration,
+                    frames / duration,
+                    1.0f / worstDuration
+                );
+            }
+            else
+            {
+                display.SetText(
+                    "FPS\n{0:1}\n{1:1}\n{2:1}",
+                    1000.0f * bestDuration,
+                    1000.0f * duration / frames,
+                    1000.0f * worstDuration
+                );
+            }
+
+            frames = 0;
+            duration = 0.0f;
+            bestDuration = float.MaxValue;
+            worstDuration = 0.0f;
+        }
+    }
+
+}

Assets/Script/FrameRateCounter.cs.meta

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

Assets/Script/FunctionLibrary.cs

@@ -0,0 +1,92 @@
+using UnityEngine;
+using static UnityEngine.Mathf;
+
+public static class FunctionLibrary
+{
+    public delegate Vector3 Function(float u, float v, float t);
+
+    public enum FunctionName { Wave, MultiWave, Ripple, Sphere, Torus }
+
+    private static Function[] functions = { Wave, MultiWave, Ripple, Sphere, Torus };
+
+    public static Function GetFunction(FunctionName name)
+    {
+        return functions[(int)name];
+    }
+
+    public static FunctionName GetNextFunctionName(FunctionName name)
+    {
+        return (int)name < functions.Length - 1 ? name + 1 : 0;
+    }
+
+    public static FunctionName GetRandomFunctionName()
+    {
+        return (FunctionName)Random.Range(0, functions.Length);
+    }
+
+    public static FunctionName GetRandomFunctionNameOtherThan(FunctionName name)
+    {
+        var choice = (FunctionName)Random.Range(1, functions.Length);
+        return choice == name ? 0 : choice;
+    }
+
+    public static Vector3 Wave(float u, float v, float t)
+    {
+        Vector3 p;
+        p.x = u;
+        p.y = Sin(PI * (u + v + t));
+        p.z = v;
+        return p;
+    }
+
+    public static Vector3 MultiWave(float u, float v, float t)
+    {
+        Vector3 p;
+        p.x = u;
+        p.y = Sin(PI * (u + 0.5f * t));
+        p.y += 0.5f * Sin(2f * PI * (v + t));
+        p.y += Sin(PI * (u + v + 0.25f * t));
+        p.y *= 1f / 2.5f;
+        p.z = v;
+        return p;
+    }
+
+    public static Vector3 Ripple(float u, float v, float t)
+    {
+        var d = Sqrt(u * u + v * v);
+        Vector3 p;
+        p.x = u;
+        p.y = Sin(PI * (4f * d - t));
+        p.y /= 1f + 10f * d;
+        p.z = v;
+        return p;
+    }
+
+    public static Vector3 Sphere(float u, float v, float t)
+    {
+        float r = 0.9f + 0.1f * Sin(PI * (6f * u + 4f * v + t));
+        float s = r * Cos(0.5f * PI * v);
+        Vector3 p;
+        p.x = s * Sin(PI * u);
+        p.y = r * Sin(0.5f * PI * v);
+        p.z = s * Cos(PI * u);
+        return p;
+    }
+
+    public static Vector3 Torus(float u, float v, float t)
+    {
+        float r1 = 0.7f + 0.1f * Sin(PI * (6f * u + 0.5f * t));
+        float r2 = 0.15f + 0.05f * Sin(PI * (8f * u + 4f * v + 2f * t));
+        float s = r1 + r2 * Cos(PI * v);
+        Vector3 p;
+        p.x = s * Sin(PI * u);
+        p.y = r2 * Sin(PI * v);
+        p.z = s * Cos(PI * u);
+        return p;
+    }
+
+    public static Vector3 Morph(float u, float v, float t, Function from, Function to, float progress)
+    {
+        return Vector3.LerpUnclamped(from(u, v, t), to(u, v, t), SmoothStep(0.0f, 1.0f, progress));
+    }
+}

Assets/Script/FunctionLibrary.cs.meta

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

Assets/Script/Graph.cs

@@ -0,0 +1,123 @@
+using UnityEngine;
+
+public class Graph : MonoBehaviour
+{
+    [SerializeField]
+    Transform pointPrefab = default;
+
+    [SerializeField, Range(10, 100)]
+    int resolution = 10;
+
+    [SerializeField]
+    FunctionLibrary.FunctionName function = default;
+
+    public enum TransitionMode { Normal, Cycle, Random }
+
+    [SerializeField]
+    TransitionMode transitionMode = TransitionMode.Normal;
+
+    [SerializeField, Min(0.0f)]
+    float functionDuration = 1.0f;
+
+    [SerializeField, Min(0.0f)]
+    float transitionDuration = 1.0f;
+
+    Transform[] points;
+
+    float duration = 0.0f;
+
+    bool transitioning;
+
+    FunctionLibrary.FunctionName transitionFunction;
+
+    private void Awake()
+    {
+        var step = 2f / resolution;
+        var scale = Vector3.one * step;
+        points = new Transform[resolution * resolution];
+        for (int i = 0; i < points.Length; i++)
+        {
+            Transform point = Instantiate(pointPrefab);
+            point.localScale = scale;
+            point.SetParent(transform, false);
+            points[i] = point;
+        }
+    }
+
+    private void Update()
+    {
+        duration += Time.deltaTime;
+        if (transitioning)
+        {
+            if (duration >= transitionDuration)
+            {
+                duration -= transitionDuration;
+                transitioning = false;
+            }
+        }
+        else if (duration >= functionDuration)
+        {
+            duration -= functionDuration;
+            transitioning = true;
+            transitionFunction = function;
+            PickNextFunction();
+        }
+        if (transitioning)
+        {
+            UpdateFunctionTransition();
+        }
+        else
+        {
+            UpdateFunction();
+        }
+    }
+
+    private void PickNextFunction()
+    {
+        if (transitionMode == TransitionMode.Normal) return;
+        function = transitionMode == TransitionMode.Cycle ?
+            FunctionLibrary.GetNextFunctionName(function) :
+            FunctionLibrary.GetRandomFunctionNameOtherThan(function);
+    }
+
+    private void UpdateFunction()
+    {
+        FunctionLibrary.Function f = FunctionLibrary.GetFunction(function);
+        var time = Time.time;
+        var step = 2.0f / resolution;
+        var v = 0.5f * step - 1f;
+        for (int i = 0, x = 0, z = 0; i < points.Length; i++, x++)
+        {
+            if (x == resolution)
+            {
+                x = 0;
+                z += 1;
+                v = (z + 0.5f) * step - 1f;
+            }
+            float u = (x + 0.5f) * step - 1f;
+            points[i].localPosition = f(u, v, time);
+        }
+    }
+
+    private void UpdateFunctionTransition()
+    {
+        FunctionLibrary.Function
+            from = FunctionLibrary.GetFunction(transitionFunction),
+            to = FunctionLibrary.GetFunction(function);
+        float progress = duration / transitionDuration;
+        float time = Time.time;
+        float step = 2f / resolution;
+        float v = 0.5f * step - 1f;
+        for (int i = 0, x = 0, z = 0; i < points.Length; i++, x++)
+        {
+            if (x == resolution)
+            {
+                x = 0;
+                z += 1;
+                v = (z + 0.5f) * step - 1f;
+            }
+            float u = (x + 0.5f) * step - 1f;
+            points[i].localPosition = FunctionLibrary.Morph(u, v, time, from, to, progress);
+        }
+    }
+}

Assets/Script/Graph.cs.meta

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