From eaba489ba28dd0aaafedf87d6d9e2d570fcea924 Mon Sep 17 00:00:00 2001
From: "W2.Wizard" <leon.delahamette@hotmail.de>
Date: Tue, 12 Jan 2021 15:08:45 +0100
Subject: [PATCH 01/13] Initial Random class

First Commit

Static class that inhabits basic and common random functions, allows it to be used in visual scripting as well.
---
 Source/Engine/Core/Math/Randomf.cs | 143 +++++++++++++++++++++++++++++
 1 file changed, 143 insertions(+)
 create mode 100644 Source/Engine/Core/Math/Randomf.cs

diff --git a/Source/Engine/Core/Math/Randomf.cs b/Source/Engine/Core/Math/Randomf.cs
new file mode 100644
index 000000000..791de2cb8
--- /dev/null
+++ b/Source/Engine/Core/Math/Randomf.cs
@@ -0,0 +1,143 @@
+// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
+
+using System;
+
+namespace FlaxEngine
+{
+    /// <summary>
+    /// A collection of common random functions which supports various types.
+    /// </summary>
+    public static class Randomf
+    {
+        // Single instance for random
+        private static Random _rand = new Random(0);
+
+        /// <summary>
+        /// Sets the seed of the random number generator.
+        /// Causes to construct a new <see cref="Random"/> instance.
+        /// </summary>
+        /// <param name="newSeed">The new seed</param>
+        public static void SetSeed(int newSeed) => _rand = new Random(newSeed);
+
+        // Bool
+
+        public static bool RandomBool()
+        {
+            return RandomInt() == 1 ? true : false;
+        }
+
+        public static bool RandomBoolWithWeight(float weight = 0)
+        {
+            return weight >= RandomInt() ? true : false;
+        }
+
+        // Byte
+
+        public static byte RandomByte(byte min = 0, byte max = 1)
+        {
+            return (byte)_rand.Next(min, max+1);
+        }
+
+        public static byte RandomUniformByte(byte value = 1)
+        {
+            int max = Math.Abs(value);
+            int min = max * -1;
+
+            return (byte)_rand.Next(min, max);
+        }
+
+        // Int
+
+        public static int RandomInt(int min = 0, int max = 1)
+        {
+            return _rand.Next(min, max+1);
+        }
+
+        public static int RandomUniformInt(int value = 1)
+        {
+            int max = Math.Abs(value);
+            int min = max * -1;
+
+            return _rand.Next(min, max);
+        }
+
+        // Float
+
+        public static float RandomFloat(float min = 0.0f, float max = 1.0f)
+        {
+            return (float)_rand.NextDouble() * (max - min) + min;
+        }
+
+        public static float RandomUniformFloat(float value = 1.0f)
+        {
+            // Ensure that in case of negative values we still return a value between + value and - value.
+            float max = Math.Abs(value);
+            float min = max * -1;
+
+            return (float)_rand.NextDouble() * (max - min) + min;
+        }
+
+        // Quaternion
+
+        public static Quaternion RandomQuaternion()
+        {
+            return Quaternion.Euler(
+                RandomUniformFloat(180),
+                RandomUniformFloat(180),
+                RandomUniformFloat(180)
+                );
+        }
+
+        // Vector
+
+        public static Vector3 RandomVector3()
+        {
+            Vector3 output;
+
+            do
+            {
+                // Create random float with a mean of 0 and deviation of ±1;
+                output.X = RandomFloat() * 2.0f - 1.0f;
+                output.Y = RandomFloat() * 2.0f - 1.0f;
+                output.Z = RandomFloat() * 2.0f - 1.0f;
+
+            } while (output.LengthSquared > 1 || output.LengthSquared < 1e-6f);
+
+            output *= (1.0f / (float)Math.Sqrt(output.LengthSquared));
+
+            return output;
+        }
+
+        public static Vector2 RandomVector2()
+        {
+            Vector2 output;
+
+            do
+            {
+                // Create random float with a mean of 0 and deviation of +-1;
+                output.X = RandomFloat() * 2.0f - 1.0f;
+                output.Y = RandomFloat() * 2.0f - 1.0f;
+
+            } while (output.LengthSquared > 1 || output.LengthSquared< 1e-6f);
+
+            output *= (1.0f / (float)Math.Sqrt(output.LengthSquared));
+
+            return output;
+        }
+
+        // Color
+
+        public static Color RandomColor(bool trueRandom, bool randomAlpha)
+        {
+            float alpha = randomAlpha ? RandomFloat() : 1f;
+
+            if (!trueRandom)
+                return Color.FromHSV(RandomFloat(0f, 360f), 1f, 1f, alpha);
+
+            return new Color(
+                RandomFloat(0f, 255f),
+                RandomFloat(0f, 255f),
+                RandomFloat(0f, 255f), alpha);
+        }
+    }
+}

From 783b9107009384e8958a6a4a2a78577b333b5eb5 Mon Sep 17 00:00:00 2001
From: "W2.Wizard" <leon.delahamette@hotmail.de>
Date: Tue, 12 Jan 2021 20:29:32 +0100
Subject: [PATCH 02/13] Added XML comments

---
 Source/Engine/Core/Math/Randomf.cs | 94 +++++++++++++++++++++---------
 1 file changed, 67 insertions(+), 27 deletions(-)

diff --git a/Source/Engine/Core/Math/Randomf.cs b/Source/Engine/Core/Math/Randomf.cs
index 791de2cb8..9e25456ab 100644
--- a/Source/Engine/Core/Math/Randomf.cs
+++ b/Source/Engine/Core/Math/Randomf.cs
@@ -12,32 +12,44 @@ namespace FlaxEngine
         // Single instance for random
         private static Random _rand = new Random(0);
 
+        //TODO: Implement some form of generic method for numerics?
+
         /// <summary>
         /// Sets the seed of the random number generator.
-        /// Causes to construct a new <see cref="Random"/> instance.
+        /// Constructs a new <see cref="Random"/> instance.
         /// </summary>
-        /// <param name="newSeed">The new seed</param>
+        /// <param name="newSeed">The new seed.</param>
         public static void SetSeed(int newSeed) => _rand = new Random(newSeed);
 
-        // Bool
+        /// <summary>
+        /// Generates a random <see cref="bool"/>.
+        /// </summary>
+        /// <returns>A <see cref="bool"/> thats either true or false.</returns>
+        public static bool RandomBool() => RandomInt() == 1;
 
-        public static bool RandomBool()
-        {
-            return RandomInt() == 1 ? true : false;
-        }
-
-        public static bool RandomBoolWithWeight(float weight = 0)
-        {
-            return weight >= RandomInt() ? true : false;
-        }
-
-        // Byte
+        /// <summary>
+        /// Generates a random <see cref="bool"/> with a weight value to adjust preference.
+        /// </summary>
+        /// <param name="weight">Normalized value that determines the chance to return true.</param>
+        /// <returns>A <see cref="bool"/> thats either true or false.</returns>
+        public static bool RandomBoolWithWeight(float weight = 0) => weight >= RandomFloat();
 
+        /// <summary>
+        /// Generates a random <see cref="byte"/> value between min and max.
+        /// </summary>
+        /// <param name="min">The lower boundary.</param>
+        /// <param name="max">The upper boundary.</param>
+        /// <returns>A <see cref="byte"/> between min and max.</returns>
         public static byte RandomByte(byte min = 0, byte max = 1)
         {
             return (byte)_rand.Next(min, max+1);
         }
 
+        /// <summary>
+        /// Generates a random <see cref="byte"/> by using a single value as both upper and lower boundary.
+        /// </summary>
+        /// <param name="value">Defines both upper and lower boundary.</param>
+        /// <returns>A that is <see cref="byte"/> between +value and -value.</returns>
         public static byte RandomUniformByte(byte value = 1)
         {
             int max = Math.Abs(value);
@@ -46,13 +58,22 @@ namespace FlaxEngine
             return (byte)_rand.Next(min, max);
         }
 
-        // Int
-
+        /// <summary>
+        /// Generates a random <see cref="int"/> value between min and max.
+        /// </summary>
+        /// <param name="min">The lower boundary.</param>
+        /// <param name="max">The upper boundary.</param>
+        /// <returns>A random <see cref="int"/> between min and max.</returns>
         public static int RandomInt(int min = 0, int max = 1)
         {
             return _rand.Next(min, max+1);
         }
 
+        /// <summary>
+        /// Generates a random <see cref="int"/> by using a single value as both upper and lower boundary.
+        /// </summary>
+        /// <param name="value">Defines both upper and lower boundary.</param>
+        /// <returns>A random <see cref="int"/> between +value and -value.</returns>
         public static int RandomUniformInt(int value = 1)
         {
             int max = Math.Abs(value);
@@ -61,13 +82,22 @@ namespace FlaxEngine
             return _rand.Next(min, max);
         }
 
-        // Float
-
+        /// <summary>
+        /// Generates a random <see cref="float"/>  value between min and max.
+        /// </summary>
+        /// <param name="min">The lower boundary.</param>
+        /// <param name="max">The upper boundary.</param>
+        /// <returns>A random <see cref="float"/> between min and max.</returns>
         public static float RandomFloat(float min = 0.0f, float max = 1.0f)
         {
             return (float)_rand.NextDouble() * (max - min) + min;
         }
 
+        /// <summary>
+        /// Generates a random <see cref="float"/>  by using a single value as both upper and lower boundary.
+        /// </summary>
+        /// <param name="value">Defines both upper and lower boundary.</param>
+        /// <returns>A random <see cref="float"/>  between +value and -value.</returns>
         public static float RandomUniformFloat(float value = 1.0f)
         {
             // Ensure that in case of negative values we still return a value between + value and - value.
@@ -77,19 +107,22 @@ namespace FlaxEngine
             return (float)_rand.NextDouble() * (max - min) + min;
         }
 
-        // Quaternion
-
+        /// <summary>
+        /// Generates a random <see cref="Quaternion"/>.
+        /// </summary>
+        /// <returns>A random <see cref="Quaternion"/>.</returns>
         public static Quaternion RandomQuaternion()
         {
             return Quaternion.Euler(
                 RandomUniformFloat(180),
                 RandomUniformFloat(180),
-                RandomUniformFloat(180)
-                );
+                RandomUniformFloat(180));
         }
 
-        // Vector
-
+        /// <summary>
+        /// Generates a uniformly distributed random unit length vector point on a unit sphere.
+        /// </summary>
+        /// <returns>A random <see cref="Vector3"/>.</returns>
         public static Vector3 RandomVector3()
         {
             Vector3 output;
@@ -108,13 +141,16 @@ namespace FlaxEngine
             return output;
         }
 
+        /// <summary>
+        /// Generates a uniformly distributed random unit length vector point on a unit sphere in 2D.
+        /// </summary>
+        /// <returns>A random <see cref="Vector2"./></returns>
         public static Vector2 RandomVector2()
         {
             Vector2 output;
 
             do
             {
-                // Create random float with a mean of 0 and deviation of +-1;
                 output.X = RandomFloat() * 2.0f - 1.0f;
                 output.Y = RandomFloat() * 2.0f - 1.0f;
 
@@ -125,8 +161,12 @@ namespace FlaxEngine
             return output;
         }
 
-        // Color
-
+        /// <summary>
+        /// Generates a random color.
+        /// </summary>
+        /// <param name="trueRandom">Should the color be generated from a single random Hue value or separate values for each channel.</param>
+        /// <param name="randomAlpha">Randomize the alpha value.</param>
+        /// <returns>A nice random color.</returns>
         public static Color RandomColor(bool trueRandom, bool randomAlpha)
         {
             float alpha = randomAlpha ? RandomFloat() : 1f;

From 604c583c36c3da255c28da2dd5d797d64c1b5202 Mon Sep 17 00:00:00 2001
From: "W2.Wizard" <leon.delahamette@hotmail.de>
Date: Wed, 13 Jan 2021 21:16:17 +0100
Subject: [PATCH 03/13] Moved all methods to Extension.cs

Moved the methods for RandomUtils.cs to Extension.cs instead.
---
 Source/Engine/Core/Math/Randomf.cs    | 183 -------------
 Source/Engine/Utilities/Extensions.cs | 355 ++++++++++++++------------
 2 files changed, 189 insertions(+), 349 deletions(-)
 delete mode 100644 Source/Engine/Core/Math/Randomf.cs

diff --git a/Source/Engine/Core/Math/Randomf.cs b/Source/Engine/Core/Math/Randomf.cs
deleted file mode 100644
index 9e25456ab..000000000
--- a/Source/Engine/Core/Math/Randomf.cs
+++ /dev/null
@@ -1,183 +0,0 @@
-// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
-
-using System;
-
-namespace FlaxEngine
-{
-    /// <summary>
-    /// A collection of common random functions which supports various types.
-    /// </summary>
-    public static class Randomf
-    {
-        // Single instance for random
-        private static Random _rand = new Random(0);
-
-        //TODO: Implement some form of generic method for numerics?
-
-        /// <summary>
-        /// Sets the seed of the random number generator.
-        /// Constructs a new <see cref="Random"/> instance.
-        /// </summary>
-        /// <param name="newSeed">The new seed.</param>
-        public static void SetSeed(int newSeed) => _rand = new Random(newSeed);
-
-        /// <summary>
-        /// Generates a random <see cref="bool"/>.
-        /// </summary>
-        /// <returns>A <see cref="bool"/> thats either true or false.</returns>
-        public static bool RandomBool() => RandomInt() == 1;
-
-        /// <summary>
-        /// Generates a random <see cref="bool"/> with a weight value to adjust preference.
-        /// </summary>
-        /// <param name="weight">Normalized value that determines the chance to return true.</param>
-        /// <returns>A <see cref="bool"/> thats either true or false.</returns>
-        public static bool RandomBoolWithWeight(float weight = 0) => weight >= RandomFloat();
-
-        /// <summary>
-        /// Generates a random <see cref="byte"/> value between min and max.
-        /// </summary>
-        /// <param name="min">The lower boundary.</param>
-        /// <param name="max">The upper boundary.</param>
-        /// <returns>A <see cref="byte"/> between min and max.</returns>
-        public static byte RandomByte(byte min = 0, byte max = 1)
-        {
-            return (byte)_rand.Next(min, max+1);
-        }
-
-        /// <summary>
-        /// Generates a random <see cref="byte"/> by using a single value as both upper and lower boundary.
-        /// </summary>
-        /// <param name="value">Defines both upper and lower boundary.</param>
-        /// <returns>A that is <see cref="byte"/> between +value and -value.</returns>
-        public static byte RandomUniformByte(byte value = 1)
-        {
-            int max = Math.Abs(value);
-            int min = max * -1;
-
-            return (byte)_rand.Next(min, max);
-        }
-
-        /// <summary>
-        /// Generates a random <see cref="int"/> value between min and max.
-        /// </summary>
-        /// <param name="min">The lower boundary.</param>
-        /// <param name="max">The upper boundary.</param>
-        /// <returns>A random <see cref="int"/> between min and max.</returns>
-        public static int RandomInt(int min = 0, int max = 1)
-        {
-            return _rand.Next(min, max+1);
-        }
-
-        /// <summary>
-        /// Generates a random <see cref="int"/> by using a single value as both upper and lower boundary.
-        /// </summary>
-        /// <param name="value">Defines both upper and lower boundary.</param>
-        /// <returns>A random <see cref="int"/> between +value and -value.</returns>
-        public static int RandomUniformInt(int value = 1)
-        {
-            int max = Math.Abs(value);
-            int min = max * -1;
-
-            return _rand.Next(min, max);
-        }
-
-        /// <summary>
-        /// Generates a random <see cref="float"/>  value between min and max.
-        /// </summary>
-        /// <param name="min">The lower boundary.</param>
-        /// <param name="max">The upper boundary.</param>
-        /// <returns>A random <see cref="float"/> between min and max.</returns>
-        public static float RandomFloat(float min = 0.0f, float max = 1.0f)
-        {
-            return (float)_rand.NextDouble() * (max - min) + min;
-        }
-
-        /// <summary>
-        /// Generates a random <see cref="float"/>  by using a single value as both upper and lower boundary.
-        /// </summary>
-        /// <param name="value">Defines both upper and lower boundary.</param>
-        /// <returns>A random <see cref="float"/>  between +value and -value.</returns>
-        public static float RandomUniformFloat(float value = 1.0f)
-        {
-            // Ensure that in case of negative values we still return a value between + value and - value.
-            float max = Math.Abs(value);
-            float min = max * -1;
-
-            return (float)_rand.NextDouble() * (max - min) + min;
-        }
-
-        /// <summary>
-        /// Generates a random <see cref="Quaternion"/>.
-        /// </summary>
-        /// <returns>A random <see cref="Quaternion"/>.</returns>
-        public static Quaternion RandomQuaternion()
-        {
-            return Quaternion.Euler(
-                RandomUniformFloat(180),
-                RandomUniformFloat(180),
-                RandomUniformFloat(180));
-        }
-
-        /// <summary>
-        /// Generates a uniformly distributed random unit length vector point on a unit sphere.
-        /// </summary>
-        /// <returns>A random <see cref="Vector3"/>.</returns>
-        public static Vector3 RandomVector3()
-        {
-            Vector3 output;
-
-            do
-            {
-                // Create random float with a mean of 0 and deviation of ±1;
-                output.X = RandomFloat() * 2.0f - 1.0f;
-                output.Y = RandomFloat() * 2.0f - 1.0f;
-                output.Z = RandomFloat() * 2.0f - 1.0f;
-
-            } while (output.LengthSquared > 1 || output.LengthSquared < 1e-6f);
-
-            output *= (1.0f / (float)Math.Sqrt(output.LengthSquared));
-
-            return output;
-        }
-
-        /// <summary>
-        /// Generates a uniformly distributed random unit length vector point on a unit sphere in 2D.
-        /// </summary>
-        /// <returns>A random <see cref="Vector2"./></returns>
-        public static Vector2 RandomVector2()
-        {
-            Vector2 output;
-
-            do
-            {
-                output.X = RandomFloat() * 2.0f - 1.0f;
-                output.Y = RandomFloat() * 2.0f - 1.0f;
-
-            } while (output.LengthSquared > 1 || output.LengthSquared< 1e-6f);
-
-            output *= (1.0f / (float)Math.Sqrt(output.LengthSquared));
-
-            return output;
-        }
-
-        /// <summary>
-        /// Generates a random color.
-        /// </summary>
-        /// <param name="trueRandom">Should the color be generated from a single random Hue value or separate values for each channel.</param>
-        /// <param name="randomAlpha">Randomize the alpha value.</param>
-        /// <returns>A nice random color.</returns>
-        public static Color RandomColor(bool trueRandom, bool randomAlpha)
-        {
-            float alpha = randomAlpha ? RandomFloat() : 1f;
-
-            if (!trueRandom)
-                return Color.FromHSV(RandomFloat(0f, 360f), 1f, 1f, alpha);
-
-            return new Color(
-                RandomFloat(0f, 255f),
-                RandomFloat(0f, 255f),
-                RandomFloat(0f, 255f), alpha);
-        }
-    }
-}
diff --git a/Source/Engine/Utilities/Extensions.cs b/Source/Engine/Utilities/Extensions.cs
index e9030af77..ff3439b77 100644
--- a/Source/Engine/Utilities/Extensions.cs
+++ b/Source/Engine/Utilities/Extensions.cs
@@ -60,172 +60,6 @@ namespace FlaxEngine.Utilities
             }, removeEmptyLines ? StringSplitOptions.RemoveEmptyEntries : StringSplitOptions.None);
         }
 
-        /// <summary>
-        /// Gets a random double.
-        /// </summary>
-        /// <param name="random">The random.</param>
-        /// <param name="maxValue">The maximum value</param>
-        /// <returns>A random double</returns>
-        public static double NextDouble(this Random random, double maxValue)
-        {
-            return random.NextDouble() * maxValue;
-        }
-
-        /// <summary>
-        /// Gets a random double.
-        /// </summary>
-        /// <param name="random">The random.</param>
-        /// <param name="minValue">The minimum value</param>
-        /// <param name="maxValue">The maximum value</param>
-        /// <returns>A random double</returns>
-        public static double NextDouble(this Random random, double minValue, double maxValue)
-        {
-            return random.NextDouble() * (maxValue - minValue) + minValue;
-        }
-
-        /// <summary>
-        /// Gets a random float.
-        /// </summary>
-        /// <param name="random">The random.</param>
-        /// <returns>A random float</returns>
-        public static float NextFloat(this Random random)
-        {
-            return (float)random.NextDouble();
-        }
-
-        /// <summary>
-        /// Gets a random float.
-        /// </summary>
-        /// <param name="random">The random.</param>
-        /// <param name="maxValue">The maximum value</param>
-        /// <returns>A random float</returns>
-        public static float NextFloat(this Random random, float maxValue)
-        {
-            return (float)random.NextDouble() * maxValue;
-        }
-
-        /// <summary>
-        /// Gets a random float.
-        /// </summary>
-        /// <param name="random">The random.</param>
-        /// <param name="minValue">The minimum value</param>
-        /// <param name="maxValue">The maximum value</param>
-        /// <returns></returns>
-        public static float NextFloat(this Random random, float minValue, float maxValue)
-        {
-            return (float)random.NextDouble() * (maxValue - minValue) + minValue;
-        }
-
-        /// <summary>
-        /// Gets a random Color.
-        /// </summary>
-        /// <param name="random">The random.</param>
-        /// <returns></returns>
-        public static Color NextColor(this Random random)
-        {
-            return new Color(NextFloat(random, 1.0f),
-                             NextFloat(random, 1.0f),
-                             NextFloat(random, 1.0f),
-                             NextFloat(random, 1.0f));
-        }
-
-        /// <summary>
-        /// Gets a random Vector2 with components in range [0;1].
-        /// </summary>
-        /// <param name="random">The random.</param>
-        /// <returns></returns>
-        public static Vector2 NextVector2(this Random random)
-        {
-            return new Vector2(NextFloat(random, 1.0f),
-                               NextFloat(random, 1.0f));
-        }
-
-        /// <summary>
-        /// Gets a random Vector3 with components in range [0;1].
-        /// </summary>
-        /// <param name="random">The random.</param>
-        /// <returns></returns>
-        public static Vector3 NextVector3(this Random random)
-        {
-            return new Vector3(NextFloat(random, 1.0f),
-                               NextFloat(random, 1.0f),
-                               NextFloat(random, 1.0f));
-        }
-
-        /// <summary>
-        /// Gets a random Vector4 with components in range [0;1].
-        /// </summary>
-        /// <param name="random">The random.</param>
-        /// <returns></returns>
-        public static Vector4 NextVector4(this Random random)
-        {
-            return new Vector4(NextFloat(random, 1.0f),
-                               NextFloat(random, 1.0f),
-                               NextFloat(random, 1.0f),
-                               NextFloat(random, 1.0f));
-        }
-
-        /// <summary>
-        /// Gets a random Quaternion.
-        /// </summary>
-        /// <param name="random">The random.</param>
-        /// <returns></returns>
-        public static Quaternion NextQuaternion(this Random random)
-        {
-            return Quaternion.Euler(NextFloat(random, -180, 180),
-                                    NextFloat(random, -180, 180),
-                                    NextFloat(random, -180, 180));
-        }
-
-        /// <summary>
-        /// Gets a random 64-bit signed integer value.
-        /// </summary>
-        /// <param name="random">The random.</param>
-        /// <returns></returns>
-        internal static long NextLong(this Random random)
-        {
-            var numArray = new byte[8];
-            random.NextBytes(numArray);
-            return (long)(BitConverter.ToUInt64(numArray, 0) & 9223372036854775807L);
-        }
-
-        /// <summary>
-        /// Generates a random normalized 2D direction vector.
-        /// </summary>
-        /// <param name="random">An instance of <see cref="Random"/>.</param>
-        /// <returns>A random normalized 2D direction vector.</returns>
-        public static Vector2 NextDirection2D(this Random random)
-        {
-            return Vector2.Normalize(new Vector2((float)random.NextDouble(), (float)random.NextDouble()));
-        }
-
-        /// <summary>
-        /// Generates a random normalized 3D direction vector.
-        /// </summary>
-        /// <param name="random">An instance of <see cref="Random"/>.</param>
-        /// <returns>A random normalized 3D direction vector.</returns>
-        public static Vector3 NextDirection3D(this Random random)
-        {
-            return Vector3.Normalize(new Vector3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble()));
-        }
-
-        /// <summary>
-        /// Generates a random point in a circle of a given radius.
-        /// </summary>
-        /// <param name="random">An instance of <see cref="Random"/>.</param>
-        /// <param name="radius">Radius of circle. Default 1.0f.</param>
-        /// <returns>A random point in a circle of a given radius.</returns>
-        public static Vector2 PointInACircle(this Random random, float radius = 1.0f)
-        {
-            var randomRadius = (float)random.NextDouble() * radius;
-
-            return new Vector2
-            {
-                X = (float)Math.Cos(random.NextDouble()) * randomRadius,
-                Y = (float)Math.Sin(random.NextDouble()) * randomRadius,
-            };
-        }
-
         /// <summary>
         /// Adds the elements of the specified collection to the end of the <see cref="ICollection{T}"/>.
         /// </summary>
@@ -404,5 +238,194 @@ namespace FlaxEngine.Utilities
                 collection[n] = value;
             }
         }
+
+        /// <summary>
+        /// Generates a random <see cref="bool"/>.
+        /// </summary>
+        /// <param name="random">An instance of <see cref="Random"/>.</param>
+        /// <returns>A <see cref="bool"/> thats either true or false.</returns>
+        public static bool NextBool(this Random random) => random.Next(2) == 1;
+
+        /// <summary>
+        /// Generates a random <see cref="bool"/> with a weight value to adjust preference.
+        /// </summary>
+        /// <param name="random">An instance of <see cref="Random"/>.</param>
+        /// <param name="weight">Normalized value that determines the chance to return true.</param>
+        /// <returns>A <see cref="bool"/> thats either true or false.</returns>
+        public static bool NextBool(this Random random, float weight = 0.5f) => weight >= NextFloat(random);
+
+        /// <summary>
+        /// Generates a random <see cref="byte"/> value between min and max.
+        /// </summary>
+        /// <param name="random">An instance of <see cref="Random"/>.</param>
+        /// <param name="min">The lower boundary.</param>
+        /// <param name="max">The upper boundary.</param>
+        /// <returns>A <see cref="byte"/> between min and max.</returns>
+        public static byte NextByte(this Random random, byte min = 0, byte max = 2)
+        {
+            return (byte)random.Next(min, max);
+        }
+
+        /// <summary>
+        /// Generates a random <see cref="float"/>  value between min and max.
+        /// </summary>
+        /// <param name="random">An instance of <see cref="Random"/>.</param>
+        /// <param name="min">The min value.</param>
+        /// <param name="max">The max value.</param>
+        /// <returns>A random <see cref="float"/> between min and max.</returns>
+        public static float NextFloat(this Random random, float min = 0.0f, float max = 2.0f)
+        {
+            return (float)random.NextDouble() * (max - min) + min;
+        }
+
+        /// <summary>
+        /// Generates a random <see cref="Quaternion"/>.
+        /// </summary>
+        /// <param name="random">An instance of <see cref="Random"/>.</param>
+        /// <param name="randomRoll">Should the roll value be randomized.</param>
+        /// <returns>A random <see cref="Quaternion"/>.</returns>
+        public static Quaternion NextQuaternion(this Random random, bool randomRoll = false)
+        {
+            return Quaternion.Euler(
+                NextFloat(random, -180, 180),
+                NextFloat(random, -180, 180),
+                randomRoll ? NextFloat(random, -180, 180) : 0);
+        }
+
+        /// <summary>
+        /// Generates a uniformly distributed random unit length vector point on a unit sphere.
+        /// </summary>
+        /// <param name="random">An instance of <see cref="Random"/>.</param>
+        /// <returns>A random <see cref="Vector3"/>.</returns>
+        public static Vector3 NextVector3(this Random random)
+        {
+            Vector3 output;
+
+            do
+            {
+                // Create random float with a mean of 0 and deviation of ±1;
+                output.X = NextFloat(random) * 2.0f - 1.0f;
+                output.Y = NextFloat(random) * 2.0f - 1.0f;
+                output.Z = NextFloat(random) * 2.0f - 1.0f;
+
+            } while (output.LengthSquared > 1 || output.LengthSquared < 1e-6f);
+
+            output *= (1.0f / (float)Math.Sqrt(output.LengthSquared));
+
+            return output;
+        }
+
+        /// <summary>
+        /// Generates a uniformly distributed random unit length vector point on a unit sphere in 2D.
+        /// </summary>
+        /// <param name="random">An instance of <see cref="Random"/>.</param>
+        /// <returns>A random <see cref="Vector2"/>.</returns>
+        public static Vector2 NextVector2(this Random random)
+        {
+            Vector2 output;
+
+            do
+            {
+                output.X = NextFloat(random) * 2.0f - 1.0f;
+                output.Y = NextFloat(random) * 2.0f - 1.0f;
+
+            } while (output.LengthSquared > 1 || output.LengthSquared < 1e-6f);
+
+            output *= (1.0f / (float)Math.Sqrt(output.LengthSquared));
+
+            return output;
+        }
+
+        /// <summary>
+        /// Generates a random <see cref="Color"/>.
+        /// </summary>
+        /// <param name="random">An instance of <see cref="Random"/>.</param>
+        /// <param name="trueRandom">Should the color be generated from a single random Hue value or separate values for each channel.</param>
+        /// <param name="randomAlpha">Randomize the alpha value.</param>
+        /// <returns>A nice random <see cref="Color"/>.</returns>
+        public static Color NextColor(this Random random, bool trueRandom, bool randomAlpha)
+        {
+            float alpha = randomAlpha ? NextFloat(random) : 1f;
+
+            if (!trueRandom)
+                return Color.FromHSV(NextFloat(random, 0f, 360f), 1f, 1f, alpha);
+
+            return new Color(
+                NextFloat(random, 0f, 255f),
+                NextFloat(random, 0f, 255f),
+                NextFloat(random, 0f, 255f), alpha);
+        }
+
+        /// <summary>
+        /// Gets a random <see cref="double"/>.
+        /// </summary>
+        /// <param name="random">An instance of <see cref="Random"/>.</param>
+        /// <param name="maxValue">The maximum value</param>
+        /// <returns>A random <see cref="double"/></returns>
+        public static double NextDouble(this Random random, double maxValue = 2.0d)
+        {
+            return random.NextDouble() * maxValue;
+        }
+
+        /// <summary>
+        /// Gets a random <see cref="double"/>.
+        /// </summary>
+        /// <param name="random">An instance of <see cref="Random"/>.</param>
+        /// <param name="minValue">The minimum value</param>
+        /// <param name="maxValue">The maximum value</param>
+        /// <returns>A random <see cref="double"/></returns>
+        public static double NextDouble(this Random random, double minValue = 0.0d, double maxValue = 2.0d)
+        {
+            return random.NextDouble() * (maxValue - minValue) + minValue;
+        }
+
+        /// <summary>
+        /// Gets a random <see cref="long"/>.
+        /// </summary>
+        /// <param name="random">An instance of <see cref="Random"/>.</param>
+        /// <returns>A random <see cref="long"/></returns>
+        internal static long NextLong(this Random random)
+        {
+            var numArray = new byte[8];
+            random.NextBytes(numArray);
+            return (long)(BitConverter.ToUInt64(numArray, 0) & 9223372036854775807L);
+        }
+
+        /// <summary>
+        /// Generates a random normalized 2D direction <see cref="Vector2"/>.
+        /// </summary>
+        /// <param name="random">An instance of <see cref="Random"/>.</param>
+        /// <returns>A random normalized 2D direction <see cref="Vector2"/>.</returns>
+        public static Vector2 NextDirection2D(this Random random)
+        {
+            return Vector2.Normalize(new Vector2((float)random.NextDouble(), (float)random.NextDouble()));
+        }
+
+        /// <summary>
+        /// Generates a random normalized 3D direction <see cref="Vector3"/>.
+        /// </summary>
+        /// <param name="random">An instance of <see cref="Random"/>.</param>
+        /// <returns>A random normalized 3D direction <see cref="Vector3"/>.</returns>
+        public static Vector3 NextDirection3D(this Random random)
+        {
+            return Vector3.Normalize(new Vector3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble()));
+        }
+
+        /// <summary>
+        /// Generates a random <see cref="Vector2"/> point in a circle of a given radius.
+        /// </summary>
+        /// <param name="random">An instance of <see cref="Random"/>.</param>
+        /// <param name="radius">Radius of circle. Default 1.0f.</param>
+        /// <returns>A random <see cref="Vector2"/> point in a circle of a given radius.</returns>
+        public static Vector2 PointInACircle(this Random random, float radius = 1.0f)
+        {
+            var randomRadius = (float)random.NextDouble() * radius;
+
+            return new Vector2
+            {
+                X = (float)Math.Cos(random.NextDouble()) * randomRadius,
+                Y = (float)Math.Sin(random.NextDouble()) * randomRadius,
+            };
+        }
     }
 }

From 6649f0d4c23dc680226cd270158ab43b1ab197a3 Mon Sep 17 00:00:00 2001
From: "W2.Wizard" <leon.delahamette@hotmail.de>
Date: Wed, 13 Jan 2021 21:58:16 +0100
Subject: [PATCH 04/13] Removed unnecessary overload

Same can be achieved by  specifiying max.
---
 Source/Engine/Utilities/Extensions.cs | 20 +++++---------------
 1 file changed, 5 insertions(+), 15 deletions(-)

diff --git a/Source/Engine/Utilities/Extensions.cs b/Source/Engine/Utilities/Extensions.cs
index ff3439b77..15238a701 100644
--- a/Source/Engine/Utilities/Extensions.cs
+++ b/Source/Engine/Utilities/Extensions.cs
@@ -286,6 +286,7 @@ namespace FlaxEngine.Utilities
         /// <returns>A random <see cref="Quaternion"/>.</returns>
         public static Quaternion NextQuaternion(this Random random, bool randomRoll = false)
         {
+
             return Quaternion.Euler(
                 NextFloat(random, -180, 180),
                 NextFloat(random, -180, 180),
@@ -360,23 +361,12 @@ namespace FlaxEngine.Utilities
         /// Gets a random <see cref="double"/>.
         /// </summary>
         /// <param name="random">An instance of <see cref="Random"/>.</param>
-        /// <param name="maxValue">The maximum value</param>
+        /// <param name="min">The minimum value</param>
+        /// <param name="max">The maximum value</param>
         /// <returns>A random <see cref="double"/></returns>
-        public static double NextDouble(this Random random, double maxValue = 2.0d)
+        public static double NextDouble(this Random random, double min = 0.0d, double max = 2.0d)
         {
-            return random.NextDouble() * maxValue;
-        }
-
-        /// <summary>
-        /// Gets a random <see cref="double"/>.
-        /// </summary>
-        /// <param name="random">An instance of <see cref="Random"/>.</param>
-        /// <param name="minValue">The minimum value</param>
-        /// <param name="maxValue">The maximum value</param>
-        /// <returns>A random <see cref="double"/></returns>
-        public static double NextDouble(this Random random, double minValue = 0.0d, double maxValue = 2.0d)
-        {
-            return random.NextDouble() * (maxValue - minValue) + minValue;
+            return random.NextDouble() * (max - min) + min;
         }
 
         /// <summary>

From 31dd5b852e1cd15dd7f67c141371adac32b2301f Mon Sep 17 00:00:00 2001
From: "W2.Wizard" <leon.delahamette@hotmail.de>
Date: Wed, 13 Jan 2021 22:04:16 +0100
Subject: [PATCH 05/13] Update Extensions.cs

---
 Source/Engine/Utilities/Extensions.cs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Source/Engine/Utilities/Extensions.cs b/Source/Engine/Utilities/Extensions.cs
index 15238a701..1e22df1c4 100644
--- a/Source/Engine/Utilities/Extensions.cs
+++ b/Source/Engine/Utilities/Extensions.cs
@@ -258,8 +258,8 @@ namespace FlaxEngine.Utilities
         /// Generates a random <see cref="byte"/> value between min and max.
         /// </summary>
         /// <param name="random">An instance of <see cref="Random"/>.</param>
-        /// <param name="min">The lower boundary.</param>
-        /// <param name="max">The upper boundary.</param>
+        /// <param name="min">The minimum value.</param>
+        /// <param name="max">The maximum value.</param>
         /// <returns>A <see cref="byte"/> between min and max.</returns>
         public static byte NextByte(this Random random, byte min = 0, byte max = 2)
         {
@@ -270,8 +270,8 @@ namespace FlaxEngine.Utilities
         /// Generates a random <see cref="float"/>  value between min and max.
         /// </summary>
         /// <param name="random">An instance of <see cref="Random"/>.</param>
-        /// <param name="min">The min value.</param>
-        /// <param name="max">The max value.</param>
+        /// <param name="min">The minimum value.</param>
+        /// <param name="max">The maximum value.</param>
         /// <returns>A random <see cref="float"/> between min and max.</returns>
         public static float NextFloat(this Random random, float min = 0.0f, float max = 2.0f)
         {

From 75c3388c00ff4d6e3ee93503b68ece30b9cce159 Mon Sep 17 00:00:00 2001
From: "W2.Wizard" <leon.delahamette@hotmail.de>
Date: Thu, 14 Jan 2021 01:12:13 +0100
Subject: [PATCH 06/13] Corrected comments

---
 Source/Engine/Utilities/Extensions.cs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/Source/Engine/Utilities/Extensions.cs b/Source/Engine/Utilities/Extensions.cs
index 1e22df1c4..a47a38ecb 100644
--- a/Source/Engine/Utilities/Extensions.cs
+++ b/Source/Engine/Utilities/Extensions.cs
@@ -304,7 +304,7 @@ namespace FlaxEngine.Utilities
 
             do
             {
-                // Create random float with a mean of 0 and deviation of ±1;
+                // Create random float with a mean of 0 and deviation of ±1
                 output.X = NextFloat(random) * 2.0f - 1.0f;
                 output.Y = NextFloat(random) * 2.0f - 1.0f;
                 output.Z = NextFloat(random) * 2.0f - 1.0f;
@@ -361,9 +361,9 @@ namespace FlaxEngine.Utilities
         /// Gets a random <see cref="double"/>.
         /// </summary>
         /// <param name="random">An instance of <see cref="Random"/>.</param>
-        /// <param name="min">The minimum value</param>
-        /// <param name="max">The maximum value</param>
-        /// <returns>A random <see cref="double"/></returns>
+        /// <param name="min">The minimum value.</param>
+        /// <param name="max">The maximum value.</param>
+        /// <returns>A random <see cref="double"/>.</returns>
         public static double NextDouble(this Random random, double min = 0.0d, double max = 2.0d)
         {
             return random.NextDouble() * (max - min) + min;
@@ -373,7 +373,7 @@ namespace FlaxEngine.Utilities
         /// Gets a random <see cref="long"/>.
         /// </summary>
         /// <param name="random">An instance of <see cref="Random"/>.</param>
-        /// <returns>A random <see cref="long"/></returns>
+        /// <returns>A random <see cref="long"/>.</returns>
         internal static long NextLong(this Random random)
         {
             var numArray = new byte[8];

From 437018e614aaf1eea97058aaaf37ced13f5b4d7b Mon Sep 17 00:00:00 2001
From: "W2.Wizard" <leon.delahamette@hotmail.de>
Date: Thu, 14 Jan 2021 11:50:03 +0100
Subject: [PATCH 07/13] Applied review changes

Applied almost all review changes.
---
 Source/Engine/Utilities/Extensions.cs | 118 ++++++++++----------------
 1 file changed, 47 insertions(+), 71 deletions(-)

diff --git a/Source/Engine/Utilities/Extensions.cs b/Source/Engine/Utilities/Extensions.cs
index a47a38ecb..f6d2be4c5 100644
--- a/Source/Engine/Utilities/Extensions.cs
+++ b/Source/Engine/Utilities/Extensions.cs
@@ -243,16 +243,9 @@ namespace FlaxEngine.Utilities
         /// Generates a random <see cref="bool"/>.
         /// </summary>
         /// <param name="random">An instance of <see cref="Random"/>.</param>
-        /// <returns>A <see cref="bool"/> thats either true or false.</returns>
-        public static bool NextBool(this Random random) => random.Next(2) == 1;
-
-        /// <summary>
-        /// Generates a random <see cref="bool"/> with a weight value to adjust preference.
-        /// </summary>
-        /// <param name="random">An instance of <see cref="Random"/>.</param>
         /// <param name="weight">Normalized value that determines the chance to return true.</param>
         /// <returns>A <see cref="bool"/> thats either true or false.</returns>
-        public static bool NextBool(this Random random, float weight = 0.5f) => weight >= NextFloat(random);
+        public static bool NextBool(this Random random, float weight = 0.5f) => random.NextDouble() < weight;
 
         /// <summary>
         /// Generates a random <see cref="byte"/> value between min and max.
@@ -260,24 +253,35 @@ namespace FlaxEngine.Utilities
         /// <param name="random">An instance of <see cref="Random"/>.</param>
         /// <param name="min">The minimum value.</param>
         /// <param name="max">The maximum value.</param>
-        /// <returns>A <see cref="byte"/> between min and max.</returns>
-        public static byte NextByte(this Random random, byte min = 0, byte max = 2)
+        /// <returns>A random <see cref="byte"/> between min and max.</returns>
+        public static byte NextByte(this Random random, byte min = 0, byte max = byte.MaxValue)
         {
             return (byte)random.Next(min, max);
         }
 
         /// <summary>
-        /// Generates a random <see cref="float"/>  value between min and max.
+        /// Generates a random <see cref="float"/> value between min and max.
         /// </summary>
         /// <param name="random">An instance of <see cref="Random"/>.</param>
         /// <param name="min">The minimum value.</param>
         /// <param name="max">The maximum value.</param>
         /// <returns>A random <see cref="float"/> between min and max.</returns>
-        public static float NextFloat(this Random random, float min = 0.0f, float max = 2.0f)
+        public static float NextFloat(this Random random, float min = 0.0f, float max = 1.0f)
         {
             return (float)random.NextDouble() * (max - min) + min;
         }
 
+        /// <summary>
+        /// Generates a random <see cref="float"/>  value between 0 and max.
+        /// </summary>
+        /// <param name="random">An instance of <see cref="Random"/>.</param>
+        /// <param name="max">The maximum value.</param>
+        /// <returns>A random <see cref="float"/> between min and max.</returns>
+        public static float NextFloat(this Random random, float max)
+        {
+            return (float)random.NextDouble() * max;
+        }
+
         /// <summary>
         /// Generates a random <see cref="Quaternion"/>.
         /// </summary>
@@ -286,7 +290,6 @@ namespace FlaxEngine.Utilities
         /// <returns>A random <see cref="Quaternion"/>.</returns>
         public static Quaternion NextQuaternion(this Random random, bool randomRoll = false)
         {
-
             return Quaternion.Euler(
                 NextFloat(random, -180, 180),
                 NextFloat(random, -180, 180),
@@ -301,6 +304,7 @@ namespace FlaxEngine.Utilities
         public static Vector3 NextVector3(this Random random)
         {
             Vector3 output;
+            float l;
 
             do
             {
@@ -309,42 +313,40 @@ namespace FlaxEngine.Utilities
                 output.Y = NextFloat(random) * 2.0f - 1.0f;
                 output.Z = NextFloat(random) * 2.0f - 1.0f;
 
-            } while (output.LengthSquared > 1 || output.LengthSquared < 1e-6f);
+                l = output.LengthSquared;
 
-            output *= (1.0f / (float)Math.Sqrt(output.LengthSquared));
+            } while (l > 1 || l < Mathf.Epsilon);
+
+            output.Normalize();
 
             return output;
         }
 
         /// <summary>
-        /// Generates a uniformly distributed random unit length vector point on a unit sphere in 2D.
+        /// Generates a random <see cref="Vector2"/> point in a circle of a given radius.
         /// </summary>
         /// <param name="random">An instance of <see cref="Random"/>.</param>
+        /// <param name="radius">Radius of circle. Default 1.0f./>.</param>
         /// <returns>A random <see cref="Vector2"/>.</returns>
-        public static Vector2 NextVector2(this Random random)
+        public static Vector2 NextVector2(this Random random, float radius = 1.0f)
         {
-            Vector2 output;
+            var randomRadius = (float)random.NextDouble() * radius;
 
-            do
+            return new Vector2
             {
-                output.X = NextFloat(random) * 2.0f - 1.0f;
-                output.Y = NextFloat(random) * 2.0f - 1.0f;
-
-            } while (output.LengthSquared > 1 || output.LengthSquared < 1e-6f);
-
-            output *= (1.0f / (float)Math.Sqrt(output.LengthSquared));
-
-            return output;
+                X = (float)Math.Cos(random.NextDouble()) * randomRadius,
+                Y = (float)Math.Sin(random.NextDouble()) * randomRadius,
+            };
         }
 
         /// <summary>
         /// Generates a random <see cref="Color"/>.
         /// </summary>
         /// <param name="random">An instance of <see cref="Random"/>.</param>
-        /// <param name="trueRandom">Should the color be generated from a single random Hue value or separate values for each channel.</param>
+        /// <param name="trueRandom">Should the color be generated from a single random hue value or separate values for each channel.</param>
         /// <param name="randomAlpha">Randomize the alpha value.</param>
         /// <returns>A nice random <see cref="Color"/>.</returns>
-        public static Color NextColor(this Random random, bool trueRandom, bool randomAlpha)
+        public static Color NextColor(this Random random, bool trueRandom = false, bool randomAlpha = false)
         {
             float alpha = randomAlpha ? NextFloat(random) : 1f;
 
@@ -352,9 +354,9 @@ namespace FlaxEngine.Utilities
                 return Color.FromHSV(NextFloat(random, 0f, 360f), 1f, 1f, alpha);
 
             return new Color(
-                NextFloat(random, 0f, 255f),
-                NextFloat(random, 0f, 255f),
-                NextFloat(random, 0f, 255f), alpha);
+                NextFloat(random),
+                NextFloat(random),
+                NextFloat(random), alpha);
         }
 
         /// <summary>
@@ -364,11 +366,22 @@ namespace FlaxEngine.Utilities
         /// <param name="min">The minimum value.</param>
         /// <param name="max">The maximum value.</param>
         /// <returns>A random <see cref="double"/>.</returns>
-        public static double NextDouble(this Random random, double min = 0.0d, double max = 2.0d)
+        public static double NextDouble(this Random random, double min = 0.0d, double max = 1.0d)
         {
             return random.NextDouble() * (max - min) + min;
         }
 
+        /// <summary>
+        /// Gets a random <see cref="double"/>.
+        /// </summary>
+        /// <param name="random">An instance of <see cref="Random"/>.</param>
+        /// <param name="max">The maximum value.</param>
+        /// <returns>A random <see cref="double"/>.</returns>
+        public static double NextDouble(this Random random, double max = 1.0d)
+        {
+            return random.NextDouble() * max;
+        }
+
         /// <summary>
         /// Gets a random <see cref="long"/>.
         /// </summary>
@@ -378,44 +391,7 @@ namespace FlaxEngine.Utilities
         {
             var numArray = new byte[8];
             random.NextBytes(numArray);
-            return (long)(BitConverter.ToUInt64(numArray, 0) & 9223372036854775807L);
-        }
-
-        /// <summary>
-        /// Generates a random normalized 2D direction <see cref="Vector2"/>.
-        /// </summary>
-        /// <param name="random">An instance of <see cref="Random"/>.</param>
-        /// <returns>A random normalized 2D direction <see cref="Vector2"/>.</returns>
-        public static Vector2 NextDirection2D(this Random random)
-        {
-            return Vector2.Normalize(new Vector2((float)random.NextDouble(), (float)random.NextDouble()));
-        }
-
-        /// <summary>
-        /// Generates a random normalized 3D direction <see cref="Vector3"/>.
-        /// </summary>
-        /// <param name="random">An instance of <see cref="Random"/>.</param>
-        /// <returns>A random normalized 3D direction <see cref="Vector3"/>.</returns>
-        public static Vector3 NextDirection3D(this Random random)
-        {
-            return Vector3.Normalize(new Vector3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble()));
-        }
-
-        /// <summary>
-        /// Generates a random <see cref="Vector2"/> point in a circle of a given radius.
-        /// </summary>
-        /// <param name="random">An instance of <see cref="Random"/>.</param>
-        /// <param name="radius">Radius of circle. Default 1.0f.</param>
-        /// <returns>A random <see cref="Vector2"/> point in a circle of a given radius.</returns>
-        public static Vector2 PointInACircle(this Random random, float radius = 1.0f)
-        {
-            var randomRadius = (float)random.NextDouble() * radius;
-
-            return new Vector2
-            {
-                X = (float)Math.Cos(random.NextDouble()) * randomRadius,
-                Y = (float)Math.Sin(random.NextDouble()) * randomRadius,
-            };
+            return (long)(BitConverter.ToUInt64(numArray, 0) & long.MaxValue);
         }
     }
 }

From 8e44e6b23cf2494959c6d278f8bf73f1cc0ea4c9 Mon Sep 17 00:00:00 2001
From: "W2.Wizard" <leon.delahamette@hotmail.de>
Date: Thu, 14 Jan 2021 12:28:51 +0100
Subject: [PATCH 08/13] Applied additional review changes

Moved out the random Color created via HSV to its own function as @stefnotch suggested.

Added + 1 to the max value in NextByte to include max as a possible value.
---
 Source/Engine/Utilities/Extensions.cs | 23 ++++++++++++++---------
 1 file changed, 14 insertions(+), 9 deletions(-)

diff --git a/Source/Engine/Utilities/Extensions.cs b/Source/Engine/Utilities/Extensions.cs
index f6d2be4c5..d7329c8bd 100644
--- a/Source/Engine/Utilities/Extensions.cs
+++ b/Source/Engine/Utilities/Extensions.cs
@@ -256,7 +256,7 @@ namespace FlaxEngine.Utilities
         /// <returns>A random <see cref="byte"/> between min and max.</returns>
         public static byte NextByte(this Random random, byte min = 0, byte max = byte.MaxValue)
         {
-            return (byte)random.Next(min, max);
+            return (byte)random.Next(min, max+1);
         }
 
         /// <summary>
@@ -343,20 +343,25 @@ namespace FlaxEngine.Utilities
         /// Generates a random <see cref="Color"/>.
         /// </summary>
         /// <param name="random">An instance of <see cref="Random"/>.</param>
-        /// <param name="trueRandom">Should the color be generated from a single random hue value or separate values for each channel.</param>
         /// <param name="randomAlpha">Randomize the alpha value.</param>
         /// <returns>A nice random <see cref="Color"/>.</returns>
-        public static Color NextColor(this Random random, bool trueRandom = false, bool randomAlpha = false)
+        public static Color NextColor(this Random random, bool randomAlpha = false)
         {
-            float alpha = randomAlpha ? NextFloat(random) : 1f;
-
-            if (!trueRandom)
-                return Color.FromHSV(NextFloat(random, 0f, 360f), 1f, 1f, alpha);
-
             return new Color(
                 NextFloat(random),
                 NextFloat(random),
-                NextFloat(random), alpha);
+                NextFloat(random), randomAlpha ? NextFloat(random) : 1f);
+        }
+
+        /// <summary>
+        /// Generates a random <see cref="ColorHSV"/> using a single random value for hue.
+        /// </summary>
+        /// <param name="random">An instance of <see cref="Random"/>.</param>
+        /// <param name="randomAlpha">Randomize the alpha value.</param>
+        /// <returns>A nice random <see cref="ColorHSV"/>.</returns>
+        public static ColorHSV NextColorHSV(this Random random, bool randomAlpha = false)
+        {
+            return new ColorHSV(NextFloat(random, 0f, 360f), 1f, 1f, randomAlpha ? NextFloat(random) : 1f);
         }
 
         /// <summary>

From 00c40e279cc7bb9c21fbde1357ac933477fe34f1 Mon Sep 17 00:00:00 2001
From: "W2.Wizard" <leon.delahamette@hotmail.de>
Date: Thu, 14 Jan 2021 13:56:10 +0100
Subject: [PATCH 09/13] Update Extensions.cs

---
 Source/Engine/Utilities/Extensions.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Source/Engine/Utilities/Extensions.cs b/Source/Engine/Utilities/Extensions.cs
index d7329c8bd..339c1c368 100644
--- a/Source/Engine/Utilities/Extensions.cs
+++ b/Source/Engine/Utilities/Extensions.cs
@@ -256,7 +256,7 @@ namespace FlaxEngine.Utilities
         /// <returns>A random <see cref="byte"/> between min and max.</returns>
         public static byte NextByte(this Random random, byte min = 0, byte max = byte.MaxValue)
         {
-            return (byte)random.Next(min, max+1);
+            return (byte)random.Next(min, max == byte.MaxValue ? byte.MaxValue + 1 : max);
         }
 
         /// <summary>
@@ -354,7 +354,7 @@ namespace FlaxEngine.Utilities
         }
 
         /// <summary>
-        /// Generates a random <see cref="ColorHSV"/> using a single random value for hue.
+        /// Generates a random <see cref="ColorHSV"/>.
         /// </summary>
         /// <param name="random">An instance of <see cref="Random"/>.</param>
         /// <param name="randomAlpha">Randomize the alpha value.</param>

From 042694f45e8c2aa3c7df6d64d0bd0d4122a687e7 Mon Sep 17 00:00:00 2001
From: "W2.Wizard" <leon.delahamette@hotmail.de>
Date: Tue, 9 Feb 2021 17:11:44 +0100
Subject: [PATCH 10/13] Added random enum

---
 Source/Engine/Utilities/Extensions.cs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/Source/Engine/Utilities/Extensions.cs b/Source/Engine/Utilities/Extensions.cs
index 339c1c368..29aa7329a 100644
--- a/Source/Engine/Utilities/Extensions.cs
+++ b/Source/Engine/Utilities/Extensions.cs
@@ -398,5 +398,17 @@ namespace FlaxEngine.Utilities
             random.NextBytes(numArray);
             return (long)(BitConverter.ToUInt64(numArray, 0) & long.MaxValue);
         }
+
+        /// <summary>
+        /// Returns a random value of the given enum.
+        /// </summary>
+        /// <typeparam name="TEnum">The enum to get the value from.</typeparam>
+        /// <param name="random">An instance of <see cref="Random"/>.</param>
+        /// <returns>A random enum value.</returns>
+        public static TEnum NextEnum<TEnum>(this Random random)
+        {
+            Array values = Enum.GetValues(typeof(TEnum));
+            return (TEnum)values.GetValue(random.Next(values.Length));
+        }
     }
 }

From 654285e57f7b5a3345480c2d2e271b04bfed3cb2 Mon Sep 17 00:00:00 2001
From: "W2.Wizard" <leon.delahamette@hotmail.de>
Date: Wed, 17 Feb 2021 00:30:24 +0100
Subject: [PATCH 11/13] Separated NextVector and NextUnitVector, refactoring

While I was at it I made some slight refactoring making it much more readable and establish consistency
---
 Source/Engine/Utilities/Extensions.cs | 94 ++++++++++++++++++++++-----
 1 file changed, 77 insertions(+), 17 deletions(-)

diff --git a/Source/Engine/Utilities/Extensions.cs b/Source/Engine/Utilities/Extensions.cs
index 29aa7329a..d5e383ab6 100644
--- a/Source/Engine/Utilities/Extensions.cs
+++ b/Source/Engine/Utilities/Extensions.cs
@@ -291,9 +291,26 @@ namespace FlaxEngine.Utilities
         public static Quaternion NextQuaternion(this Random random, bool randomRoll = false)
         {
             return Quaternion.Euler(
-                NextFloat(random, -180, 180),
-                NextFloat(random, -180, 180),
-                randomRoll ? NextFloat(random, -180, 180) : 0);
+                NextFloat(random, -180.0f, 180.0f),
+                NextFloat(random, -180.0f, 180.0f),
+                randomRoll ? NextFloat(random, -180.0f, 180.0f) : 0.0f);
+        }
+
+        /// <summary>
+        /// Generates a random <see cref="Vector2"/> point in a circle of a given radius.
+        /// </summary>
+        /// <param name="random">An instance of <see cref="Random"/>.</param>
+        /// <param name="radius">Radius of circle. Default 1.0f./>.</param>
+        /// <returns>A random <see cref="Vector2"/>.</returns>
+        public static Vector2 NextUnitVector2(this Random random, float radius = 1.0f)
+        {
+            var randomRadius = (float)random.NextDouble() * radius;
+
+            return new Vector2
+            {
+                X = (float)Math.Cos(random.NextDouble()) * randomRadius,
+                Y = (float)Math.Sin(random.NextDouble()) * randomRadius,
+            };
         }
 
         /// <summary>
@@ -301,7 +318,7 @@ namespace FlaxEngine.Utilities
         /// </summary>
         /// <param name="random">An instance of <see cref="Random"/>.</param>
         /// <returns>A random <see cref="Vector3"/>.</returns>
-        public static Vector3 NextVector3(this Random random)
+        public static Vector3 NextUnitVector3(this Random random)
         {
             Vector3 output;
             float l;
@@ -323,19 +340,53 @@ namespace FlaxEngine.Utilities
         }
 
         /// <summary>
-        /// Generates a random <see cref="Vector2"/> point in a circle of a given radius.
+        /// Gets a random <see cref="Vector2"/> with components in a given range.
         /// </summary>
         /// <param name="random">An instance of <see cref="Random"/>.</param>
-        /// <param name="radius">Radius of circle. Default 1.0f./>.</param>
+        /// <param name="min">The minimum value.</param>
+        /// <param name="max">The maximum value.</param>
         /// <returns>A random <see cref="Vector2"/>.</returns>
-        public static Vector2 NextVector2(this Random random, float radius = 1.0f)
+        public static Vector2 NextVector2(this Random random, float min = 0.0f, float max = 1.0f)
         {
-            var randomRadius = (float)random.NextDouble() * radius;
-
-            return new Vector2
+            return new Vector2 
             {
-                X = (float)Math.Cos(random.NextDouble()) * randomRadius,
-                Y = (float)Math.Sin(random.NextDouble()) * randomRadius,
+                X = NextFloat(random, min, max), 
+                Y = NextFloat(random, min, max)
+            };
+        }
+
+        /// <summary>
+        /// Gets a random <see cref="Vector3"/> with components in a given range.
+        /// </summary>
+        /// <param name="random">An instance of <see cref="Random"/>.</param>
+        /// <param name="min">The minimum value.</param>
+        /// <param name="max">The maximum value.</param>
+        /// <returns>A random <see cref="Vector3"/>.</returns>
+        public static Vector3 NextVector3(this Random random, float min = 0.0f, float max = 1.0f)
+        {
+            return new Vector3
+            {
+                X = NextFloat(random, min, max),
+                Y = NextFloat(random, min, max),
+                Z = NextFloat(random, min, max)
+            };
+        }
+
+        /// <summary>
+        /// Gets a random <see cref="Vector4"/> with components in a given range.
+        /// </summary>
+        /// <param name="random">An instance of <see cref="Random"/>.</param>
+        /// <param name="min">The minimum value.</param>
+        /// <param name="max">The maximum value.</param>
+        /// <returns>A random <see cref="Vector4"/>.</returns>
+        public static Vector4 NextVector4(this Random random, float min = 0.0f, float max = 1.0f)
+        {
+            return new Vector4
+            {
+                X = NextFloat(random, min, max),
+                Y = NextFloat(random, min, max),
+                Z = NextFloat(random, min, max),
+                W = NextFloat(random, min, max)
             };
         }
 
@@ -347,10 +398,13 @@ namespace FlaxEngine.Utilities
         /// <returns>A nice random <see cref="Color"/>.</returns>
         public static Color NextColor(this Random random, bool randomAlpha = false)
         {
-            return new Color(
-                NextFloat(random),
-                NextFloat(random),
-                NextFloat(random), randomAlpha ? NextFloat(random) : 1f);
+            return new Color
+            {
+                R = NextFloat(random),
+                G = NextFloat(random),
+                B = NextFloat(random),
+                A = randomAlpha ? NextFloat(random) : 1.0f
+            };
         }
 
         /// <summary>
@@ -361,7 +415,13 @@ namespace FlaxEngine.Utilities
         /// <returns>A nice random <see cref="ColorHSV"/>.</returns>
         public static ColorHSV NextColorHSV(this Random random, bool randomAlpha = false)
         {
-            return new ColorHSV(NextFloat(random, 0f, 360f), 1f, 1f, randomAlpha ? NextFloat(random) : 1f);
+            return new ColorHSV 
+            {
+                H = NextFloat(random, 0.0f, 360.0f),
+                S = 1.0f,
+                V = 1.0f,
+                A = randomAlpha ? NextFloat(random) : 1.0f
+            };
         }
 
         /// <summary>

From 1c1e9bb1053c994afd0a513e67b2b9b6beb6a95c Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Perrier <jeanbapt.perrier@gmail.com>
Date: Wed, 17 Feb 2021 12:44:44 +0100
Subject: [PATCH 12/13] Fix re-drawing the background when alpha > 0 .

---
 Source/Engine/UI/GUI/Tooltip.cs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/Source/Engine/UI/GUI/Tooltip.cs b/Source/Engine/UI/GUI/Tooltip.cs
index 24c0651ed..b4abfaf66 100644
--- a/Source/Engine/UI/GUI/Tooltip.cs
+++ b/Source/Engine/UI/GUI/Tooltip.cs
@@ -223,8 +223,6 @@ namespace FlaxEngine.GUI
                               TextAlignment.Center,
                               TextWrapping.WrapWords
                              );
-
-            base.Draw();
         }
 
         /// <inheritdoc />

From 4aabb81c1f05d2a6de0ebe5a4e58e677a6f9f258 Mon Sep 17 00:00:00 2001
From: Wojtek Figat <wojtek@figat.pl>
Date: Thu, 18 Feb 2021 22:43:46 +0100
Subject: [PATCH 13/13] Use constructors for random generation methods

---
 Source/Engine/Utilities/Extensions.cs | 86 +++------------------------
 1 file changed, 7 insertions(+), 79 deletions(-)

diff --git a/Source/Engine/Utilities/Extensions.cs b/Source/Engine/Utilities/Extensions.cs
index d5e383ab6..b3f6d2053 100644
--- a/Source/Engine/Utilities/Extensions.cs
+++ b/Source/Engine/Utilities/Extensions.cs
@@ -70,15 +70,9 @@ namespace FlaxEngine.Utilities
         public static void AddRange<T>(this ICollection<T> destination, IEnumerable<T> collection)
         {
             if (destination == null)
-            {
                 throw new ArgumentNullException(nameof(destination));
-            }
-
             if (collection == null)
-            {
                 throw new ArgumentNullException(nameof(collection));
-            }
-
             foreach (var item in collection)
             {
                 destination.Add(item);
@@ -95,15 +89,9 @@ namespace FlaxEngine.Utilities
         public static void EnqueueRange<T>(this Queue<T> queue, IEnumerable<T> collection)
         {
             if (queue == null)
-            {
                 throw new ArgumentNullException(nameof(queue));
-            }
-
             if (collection == null)
-            {
                 throw new ArgumentNullException(nameof(collection));
-            }
-
             foreach (var item in collection)
             {
                 queue.Enqueue(item);
@@ -120,15 +108,9 @@ namespace FlaxEngine.Utilities
         public static void PushRange<T>(this Stack<T> stack, IEnumerable<T> collection)
         {
             if (stack == null)
-            {
                 throw new ArgumentNullException(nameof(stack));
-            }
-
             if (collection == null)
-            {
                 throw new ArgumentNullException(nameof(collection));
-            }
-
             foreach (var item in collection)
             {
                 stack.Push(item);
@@ -145,15 +127,9 @@ namespace FlaxEngine.Utilities
         public static void ForEach<T>(this IEnumerable<T> source, Action<T> action)
         {
             if (source == null)
-            {
                 throw new ArgumentNullException(nameof(source));
-            }
-
             if (action == null)
-            {
                 throw new ArgumentNullException(nameof(action));
-            }
-
             foreach (var item in source)
             {
                 action(item);
@@ -172,15 +148,9 @@ namespace FlaxEngine.Utilities
         public static T Choose<T>(this Random random, IList<T> collection)
         {
             if (random == null)
-            {
                 throw new ArgumentNullException(nameof(random));
-            }
-
             if (collection == null)
-            {
                 throw new ArgumentNullException(nameof(collection));
-            }
-
             return collection[random.Next(collection.Count)];
         }
 
@@ -196,15 +166,9 @@ namespace FlaxEngine.Utilities
         public static T Choose<T>(this Random random, params T[] collection)
         {
             if (random == null)
-            {
                 throw new ArgumentNullException(nameof(random));
-            }
-
             if (collection == null)
-            {
                 throw new ArgumentNullException(nameof(collection));
-            }
-
             return collection[random.Next(collection.Length)];
         }
 
@@ -290,10 +254,7 @@ namespace FlaxEngine.Utilities
         /// <returns>A random <see cref="Quaternion"/>.</returns>
         public static Quaternion NextQuaternion(this Random random, bool randomRoll = false)
         {
-            return Quaternion.Euler(
-                NextFloat(random, -180.0f, 180.0f),
-                NextFloat(random, -180.0f, 180.0f),
-                randomRoll ? NextFloat(random, -180.0f, 180.0f) : 0.0f);
+            return Quaternion.Euler(NextFloat(random, -180.0f, 180.0f), NextFloat(random, -180.0f, 180.0f), randomRoll ? NextFloat(random, -180.0f, 180.0f) : 0.0f);
         }
 
         /// <summary>
@@ -305,12 +266,7 @@ namespace FlaxEngine.Utilities
         public static Vector2 NextUnitVector2(this Random random, float radius = 1.0f)
         {
             var randomRadius = (float)random.NextDouble() * radius;
-
-            return new Vector2
-            {
-                X = (float)Math.Cos(random.NextDouble()) * randomRadius,
-                Y = (float)Math.Sin(random.NextDouble()) * randomRadius,
-            };
+            return new Vector2((float)Math.Cos(random.NextDouble()) * randomRadius, (float)Math.Sin(random.NextDouble()) * randomRadius);
         }
 
         /// <summary>
@@ -331,7 +287,6 @@ namespace FlaxEngine.Utilities
                 output.Z = NextFloat(random) * 2.0f - 1.0f;
 
                 l = output.LengthSquared;
-
             } while (l > 1 || l < Mathf.Epsilon);
 
             output.Normalize();
@@ -348,11 +303,7 @@ namespace FlaxEngine.Utilities
         /// <returns>A random <see cref="Vector2"/>.</returns>
         public static Vector2 NextVector2(this Random random, float min = 0.0f, float max = 1.0f)
         {
-            return new Vector2 
-            {
-                X = NextFloat(random, min, max), 
-                Y = NextFloat(random, min, max)
-            };
+            return new Vector2(NextFloat(random, min, max), NextFloat(random, min, max));
         }
 
         /// <summary>
@@ -364,12 +315,7 @@ namespace FlaxEngine.Utilities
         /// <returns>A random <see cref="Vector3"/>.</returns>
         public static Vector3 NextVector3(this Random random, float min = 0.0f, float max = 1.0f)
         {
-            return new Vector3
-            {
-                X = NextFloat(random, min, max),
-                Y = NextFloat(random, min, max),
-                Z = NextFloat(random, min, max)
-            };
+            return new Vector3(NextFloat(random, min, max), NextFloat(random, min, max), NextFloat(random, min, max));
         }
 
         /// <summary>
@@ -381,13 +327,7 @@ namespace FlaxEngine.Utilities
         /// <returns>A random <see cref="Vector4"/>.</returns>
         public static Vector4 NextVector4(this Random random, float min = 0.0f, float max = 1.0f)
         {
-            return new Vector4
-            {
-                X = NextFloat(random, min, max),
-                Y = NextFloat(random, min, max),
-                Z = NextFloat(random, min, max),
-                W = NextFloat(random, min, max)
-            };
+            return new Vector4(NextFloat(random, min, max), NextFloat(random, min, max), NextFloat(random, min, max), NextFloat(random, min, max));
         }
 
         /// <summary>
@@ -398,13 +338,7 @@ namespace FlaxEngine.Utilities
         /// <returns>A nice random <see cref="Color"/>.</returns>
         public static Color NextColor(this Random random, bool randomAlpha = false)
         {
-            return new Color
-            {
-                R = NextFloat(random),
-                G = NextFloat(random),
-                B = NextFloat(random),
-                A = randomAlpha ? NextFloat(random) : 1.0f
-            };
+            return new Color(NextFloat(random), NextFloat(random), NextFloat(random), randomAlpha ? NextFloat(random) : 1.0f);
         }
 
         /// <summary>
@@ -415,13 +349,7 @@ namespace FlaxEngine.Utilities
         /// <returns>A nice random <see cref="ColorHSV"/>.</returns>
         public static ColorHSV NextColorHSV(this Random random, bool randomAlpha = false)
         {
-            return new ColorHSV 
-            {
-                H = NextFloat(random, 0.0f, 360.0f),
-                S = 1.0f,
-                V = 1.0f,
-                A = randomAlpha ? NextFloat(random) : 1.0f
-            };
+            return new ColorHSV(NextFloat(random, 0.0f, 360.0f), 1.0f, 1.0f, randomAlpha ? NextFloat(random) : 1.0f);
         }
 
         /// <summary>