SPEC-7531 Change Code/CryEngine to Code/Legacy (#1634)

* git mv Code\CryEngine Code\Legacy
* redirecting CMakeLists.txt
* fixing uic warning
* Some more CryEngine mentions
* validation scripts

Signed-off-by: Esteban Papp <81431996+amznestebanpapp@users.noreply.github.com>

Code/Legacy/CryCommon/CryRandomInternal.h

@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project
+ * 
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+
+#pragma once
+
+#include <algorithm>  // std::swap()
+#include <limits>  // std::numeric_limits
+#include <type_traits>  // std::make_unsigned
+#include "BaseTypes.h"  // uint32, uint64
+#include "CompileTimeAssert.h"
+#include "Cry_Vector2.h"
+#include "Cry_Vector3.h"
+#include "Cry_Vector4.h"
+
+
+namespace CryRandom_Internal
+{
+    template <class R, class T, size_t size>
+    struct BoundedRandomUint
+    {
+        COMPILE_TIME_ASSERT(std::numeric_limits<T>::is_integer);
+        COMPILE_TIME_ASSERT(!std::numeric_limits<T>::is_signed);
+        COMPILE_TIME_ASSERT(sizeof(T) == size);
+        COMPILE_TIME_ASSERT(sizeof(T) <= sizeof(uint32));
+
+        inline static T Get(R& randomGenerator, const T maxValue)
+        {
+            const uint32 r = randomGenerator.GenerateUint32();
+            // Note that the computation below is biased. An alternative computation
+            // (also biased): uint32((uint64)r * ((uint64)maxValue + 1)) >> 32)
+            return (T)((uint64)r % ((uint64)maxValue + 1));
+        }
+    };
+
+    template <class R, class T>
+    struct BoundedRandomUint<R, T, 8>
+    {
+        COMPILE_TIME_ASSERT(std::numeric_limits<T>::is_integer);
+        COMPILE_TIME_ASSERT(!std::numeric_limits<T>::is_signed);
+        COMPILE_TIME_ASSERT(sizeof(T) == sizeof(uint64));
+
+        inline static T Get(R& randomGenerator, const T maxValue)
+        {
+            const uint64 r = randomGenerator.GenerateUint64();
+            if (maxValue >= (std::numeric_limits<uint64>::max)())
+            {
+                return r;
+            }
+            // Note that the computation below is biased.
+            return (T)(r % ((uint64)maxValue + 1));
+        }
+    };
+
+    //////////////////////////////////////////////////////////////////////////
+
+    template <class R, class T, bool bInteger = std::numeric_limits<T>::is_integer>
+    struct BoundedRandom;
+
+    template <class R, class T>
+    struct BoundedRandom<R, T, true>
+    {
+        COMPILE_TIME_ASSERT(std::numeric_limits<T>::is_integer);
+        typedef typename std::make_unsigned<T>::type UT;
+        COMPILE_TIME_ASSERT(sizeof(T) == sizeof(UT));
+        COMPILE_TIME_ASSERT(std::numeric_limits<UT>::is_integer);
+        COMPILE_TIME_ASSERT(!std::numeric_limits<UT>::is_signed);
+
+        inline static T Get(R& randomGenerator, T minValue, T maxValue)
+        {
+            if (minValue > maxValue)
+            {
+                std::swap(minValue, maxValue);
+            }
+            return (T)((UT)minValue + (UT)BoundedRandomUint<R, UT, sizeof(UT)>::Get(randomGenerator, (UT)(maxValue - minValue)));
+        }
+    };
+
+    template <class R, class T>
+    struct BoundedRandom<R, T, false>
+    {
+        COMPILE_TIME_ASSERT(!std::numeric_limits<T>::is_integer);
+
+        inline static T Get(R& randomGenerator, const T minValue, const T maxValue)
+        {
+            return minValue + (maxValue - minValue) * randomGenerator.GenerateFloat();
+        }
+    };
+
+    //////////////////////////////////////////////////////////////////////////
+
+    template <class R, class VT, class T = typename VT::value_type, size_t componentCount = VT::component_count>
+    struct BoundedRandomComponentwise;
+
+    template <class R, class VT, class T>
+    struct BoundedRandomComponentwise<R, VT, T, 2>
+    {
+        inline static VT Get(R& randomGenerator, const VT& minValue, const VT& maxValue)
+        {
+            const T x = BoundedRandom<R, T>::Get(randomGenerator, minValue.x, maxValue.x);
+            const T y = BoundedRandom<R, T>::Get(randomGenerator, minValue.y, maxValue.y);
+            return VT(x, y);
+        }
+    };
+
+    template <class R, class VT, class T>
+    struct BoundedRandomComponentwise<R, VT, T, 3>
+    {
+        inline static VT Get(R& randomGenerator, const VT& minValue, const VT& maxValue)
+        {
+            const T x = BoundedRandom<R, T>::Get(randomGenerator, minValue.x, maxValue.x);
+            const T y = BoundedRandom<R, T>::Get(randomGenerator, minValue.y, maxValue.y);
+            const T z = BoundedRandom<R, T>::Get(randomGenerator, minValue.z, maxValue.z);
+            return VT(x, y, z);
+        }
+    };
+
+    template <class R, class VT, class T>
+    struct BoundedRandomComponentwise<R, VT, T, 4>
+    {
+        inline static VT Get(R& randomGenerator, const VT& minValue, const VT& maxValue)
+        {
+            const T x = BoundedRandom<R, T>::Get(randomGenerator, minValue.x, maxValue.x);
+            const T y = BoundedRandom<R, T>::Get(randomGenerator, minValue.y, maxValue.y);
+            const T z = BoundedRandom<R, T>::Get(randomGenerator, minValue.z, maxValue.z);
+            const T w = BoundedRandom<R, T>::Get(randomGenerator, minValue.w, maxValue.w);
+            return VT(x, y, z, w);
+        }
+    };
+
+    //////////////////////////////////////////////////////////////////////////
+
+    template <class R, class VT>
+    inline VT GetRandomUnitVector(R& randomGenerator)
+    {
+        typedef typename VT::value_type T;
+        COMPILE_TIME_ASSERT(!std::numeric_limits<T>::is_integer);
+
+        VT res;
+        T lenSquared;
+
+        do
+        {
+            res = BoundedRandomComponentwise<R, VT>::Get(randomGenerator, VT(-1), VT(1));
+            lenSquared = res.GetLengthSquared();
+        } while (lenSquared > 1);
+
+        if (lenSquared >= (std::numeric_limits<T>::min)())
+        {
+            return res * isqrt_tpl(lenSquared);
+        }
+
+        res = VT(ZERO);
+        res.x = 1;
+        return res;
+    }
+} // namespace CryRandom_Internal
+
+// eof