@babylonjs/core 7.24.0 → 7.25.1

package/Maths/math.scalar.functions.js.map

@@ -1 +1 @@
-{"version":3,"file":"math.scalar.functions.js","sourceRoot":"","sources":["../../../../dev/core/src/Maths/math.scalar.functions.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,KAAa;IACtC,OAAO,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,CAAC;AACzD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,CAAS,EAAE,CAAS,EAAE,UAAkB,YAAY;IAC9E,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,OAAO,CAAC;AACtC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,GAAW,EAAE,GAAW;IAChD,IAAI,GAAG,KAAK,GAAG,EAAE;QACb,OAAO,GAAG,CAAC;KACd;IACD,OAAO,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;AAC7C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,IAAI,CAAC,KAAa,EAAE,GAAW,EAAE,MAAc;IAC3D,OAAO,KAAK,GAAG,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,MAAM,CAAC;AAC1C,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,KAAK,CAAC,KAAa,EAAE,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC;IACjD,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;AAC/C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAa;IAC1C,sDAAsD;IACtD,+BAA+B;IAC/B,+CAA+C;IAE/C,wBAAwB;IACxB,wBAAwB;IACxB,GAAG;IAEH,KAAK,IAAI,IAAI,CAAC,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;IAErE,OAAO,KAAK,CAAC;AACjB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,KAAK,CAAC,CAAS;IAC3B,MAAM,GAAG,GAAG,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IAE3B,IAAI,CAAC,IAAI,EAAE,EAAE;QACT,OAAO,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC;KACpC;IAED,OAAO,GAAG,CAAC,WAAW,EAAE,CAAC;AAC7B,CAAC","sourcesContent":["/**\r\n * Extract int value\r\n * @param value number value\r\n * @returns int value\r\n */\r\nexport function ExtractAsInt(value: number) {\r\n    return parseInt(value.toString().replace(/\\W/g, \"\"));\r\n}\r\n\r\n/**\r\n * Boolean : true if the absolute difference between a and b is lower than epsilon (default = 1.401298E-45)\r\n * @param a number\r\n * @param b number\r\n * @param epsilon (default = 1.401298E-45)\r\n * @returns true if the absolute difference between a and b is lower than epsilon (default = 1.401298E-45)\r\n */\r\nexport function WithinEpsilon(a: number, b: number, epsilon: number = 1.401298e-45): boolean {\r\n    return Math.abs(a - b) <= epsilon;\r\n}\r\n\r\n/**\r\n * Returns a random float number between and min and max values\r\n * @param min min value of random\r\n * @param max max value of random\r\n * @returns random value\r\n */\r\nexport function RandomRange(min: number, max: number): number {\r\n    if (min === max) {\r\n        return min;\r\n    }\r\n    return Math.random() * (max - min) + min;\r\n}\r\n\r\n/**\r\n * Creates a new scalar with values linearly interpolated of \"amount\" between the start scalar and the end scalar.\r\n * @param start start value\r\n * @param end target value\r\n * @param amount amount to lerp between\r\n * @returns the lerped value\r\n */\r\nexport function Lerp(start: number, end: number, amount: number): number {\r\n    return start + (end - start) * amount;\r\n}\r\n\r\n/**\r\n * Returns the value itself if it's between min and max.\r\n * Returns min if the value is lower than min.\r\n * Returns max if the value is greater than max.\r\n * @param value the value to clmap\r\n * @param min the min value to clamp to (default: 0)\r\n * @param max the max value to clamp to (default: 1)\r\n * @returns the clamped value\r\n */\r\nexport function Clamp(value: number, min = 0, max = 1): number {\r\n    return Math.min(max, Math.max(min, value));\r\n}\r\n\r\n/**\r\n * Returns the angle converted to equivalent value between -Math.PI and Math.PI radians.\r\n * @param angle The angle to normalize in radian.\r\n * @returns The converted angle.\r\n */\r\nexport function NormalizeRadians(angle: number): number {\r\n    // More precise but slower version kept for reference.\r\n    // angle = angle % Tools.TwoPi;\r\n    // angle = (angle + Tools.TwoPi) % Tools.TwoPi;\r\n\r\n    //if (angle > Math.PI) {\r\n    //\tangle -= Tools.TwoPi;\r\n    //}\r\n\r\n    angle -= Math.PI * 2 * Math.floor((angle + Math.PI) / (Math.PI * 2));\r\n\r\n    return angle;\r\n}\r\n\r\n/**\r\n * Returns a string : the upper case translation of the number i to hexadecimal.\r\n * @param i number\r\n * @returns the upper case translation of the number i to hexadecimal.\r\n */\r\nexport function ToHex(i: number): string {\r\n    const str = i.toString(16);\r\n\r\n    if (i <= 15) {\r\n        return (\"0\" + str).toUpperCase();\r\n    }\r\n\r\n    return str.toUpperCase();\r\n}\r\n"]}
+{"version":3,"file":"math.scalar.functions.js","sourceRoot":"","sources":["../../../../dev/core/src/Maths/math.scalar.functions.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Extract int value\r\n * @param value number value\r\n * @returns int value\r\n */\r\nexport function ExtractAsInt(value: number) {\r\n    return parseInt(value.toString().replace(/\\W/g, \"\"));\r\n}\r\n\r\n/**\r\n * Boolean : true if the absolute difference between a and b is lower than epsilon (default = 1.401298E-45)\r\n * @param a number\r\n * @param b number\r\n * @param epsilon (default = 1.401298E-45)\r\n * @returns true if the absolute difference between a and b is lower than epsilon (default = 1.401298E-45)\r\n */\r\nexport function WithinEpsilon(a: number, b: number, epsilon: number = 1.401298e-45): boolean {\r\n    return Math.abs(a - b) <= epsilon;\r\n}\r\n\r\n/**\r\n * Returns a random float number between and min and max values\r\n * @param min min value of random\r\n * @param max max value of random\r\n * @returns random value\r\n */\r\nexport function RandomRange(min: number, max: number): number {\r\n    if (min === max) {\r\n        return min;\r\n    }\r\n    return Math.random() * (max - min) + min;\r\n}\r\n\r\n/**\r\n * Creates a new scalar with values linearly interpolated of \"amount\" between the start scalar and the end scalar.\r\n * @param start start value\r\n * @param end target value\r\n * @param amount amount to lerp between\r\n * @returns the lerped value\r\n */\r\nexport function Lerp(start: number, end: number, amount: number): number {\r\n    return start + (end - start) * amount;\r\n}\r\n\r\n/**\r\n * Same as Lerp but makes sure the values interpolate correctly when they wrap around 360 degrees.\r\n * The parameter t is clamped to the range [0, 1]. Variables a and b are assumed to be in degrees.\r\n * @param start start value\r\n * @param end target value\r\n * @param amount amount to lerp between\r\n * @returns the lerped value\r\n */\r\nexport function LerpAngle(start: number, end: number, amount: number): number {\r\n    let num: number = Repeat(end - start, 360.0);\r\n    if (num > 180.0) {\r\n        num -= 360.0;\r\n    }\r\n    return start + num * Clamp(amount);\r\n}\r\n\r\n/**\r\n * Calculates the linear parameter t that produces the interpolant value within the range [a, b].\r\n * @param a start value\r\n * @param b target value\r\n * @param value value between a and b\r\n * @returns the inverseLerp value\r\n */\r\nexport function InverseLerp(a: number, b: number, value: number): number {\r\n    let result: number = 0;\r\n    if (a != b) {\r\n        result = Clamp((value - a) / (b - a));\r\n    } else {\r\n        result = 0.0;\r\n    }\r\n    return result;\r\n}\r\n\r\n/**\r\n * Returns a new scalar located for \"amount\" (float) on the Hermite spline defined by the scalars \"value1\", \"value3\", \"tangent1\", \"tangent2\".\r\n * @see http://mathworld.wolfram.com/HermitePolynomial.html\r\n * @param value1 defines the first control point\r\n * @param tangent1 defines the first tangent\r\n * @param value2 defines the second control point\r\n * @param tangent2 defines the second tangent\r\n * @param amount defines the amount on the interpolation spline (between 0 and 1)\r\n * @returns hermite result\r\n */\r\nexport function Hermite(value1: number, tangent1: number, value2: number, tangent2: number, amount: number): number {\r\n    const squared = amount * amount;\r\n    const cubed = amount * squared;\r\n    const part1 = 2.0 * cubed - 3.0 * squared + 1.0;\r\n    const part2 = -2.0 * cubed + 3.0 * squared;\r\n    const part3 = cubed - 2.0 * squared + amount;\r\n    const part4 = cubed - squared;\r\n\r\n    return value1 * part1 + value2 * part2 + tangent1 * part3 + tangent2 * part4;\r\n}\r\n\r\n/**\r\n * Returns a new scalar which is the 1st derivative of the Hermite spline defined by the scalars \"value1\", \"value2\", \"tangent1\", \"tangent2\".\r\n * @param value1 defines the first control point\r\n * @param tangent1 defines the first tangent\r\n * @param value2 defines the second control point\r\n * @param tangent2 defines the second tangent\r\n * @param time define where the derivative must be done\r\n * @returns 1st derivative\r\n */\r\nexport function Hermite1stDerivative(value1: number, tangent1: number, value2: number, tangent2: number, time: number): number {\r\n    const t2 = time * time;\r\n    return (t2 - time) * 6 * value1 + (3 * t2 - 4 * time + 1) * tangent1 + (-t2 + time) * 6 * value2 + (3 * t2 - 2 * time) * tangent2;\r\n}\r\n\r\n/**\r\n * Returns the value itself if it's between min and max.\r\n * Returns min if the value is lower than min.\r\n * Returns max if the value is greater than max.\r\n * @param value the value to clmap\r\n * @param min the min value to clamp to (default: 0)\r\n * @param max the max value to clamp to (default: 1)\r\n * @returns the clamped value\r\n */\r\nexport function Clamp(value: number, min = 0, max = 1): number {\r\n    return Math.min(max, Math.max(min, value));\r\n}\r\n\r\n/**\r\n * Returns the angle converted to equivalent value between -Math.PI and Math.PI radians.\r\n * @param angle The angle to normalize in radian.\r\n * @returns The converted angle.\r\n */\r\nexport function NormalizeRadians(angle: number): number {\r\n    // More precise but slower version kept for reference.\r\n    // angle = angle % Tools.TwoPi;\r\n    // angle = (angle + Tools.TwoPi) % Tools.TwoPi;\r\n\r\n    //if (angle > Math.PI) {\r\n    //\tangle -= Tools.TwoPi;\r\n    //}\r\n\r\n    angle -= Math.PI * 2 * Math.floor((angle + Math.PI) / (Math.PI * 2));\r\n\r\n    return angle;\r\n}\r\n\r\n/**\r\n * Returns a string : the upper case translation of the number i to hexadecimal.\r\n * @param i number\r\n * @returns the upper case translation of the number i to hexadecimal.\r\n */\r\nexport function ToHex(i: number): string {\r\n    const str = i.toString(16);\r\n\r\n    if (i <= 15) {\r\n        return (\"0\" + str).toUpperCase();\r\n    }\r\n\r\n    return str.toUpperCase();\r\n}\r\n\r\n/**\r\n * the floor part of a log2 value.\r\n * @param value the value to compute log2 of\r\n * @returns the log2 of value.\r\n */\r\nexport function ILog2(value: number): number {\r\n    if (Math.log2) {\r\n        return Math.floor(Math.log2(value));\r\n    }\r\n\r\n    if (value < 0) {\r\n        return NaN;\r\n    } else if (value === 0) {\r\n        return -Infinity;\r\n    }\r\n\r\n    let n = 0;\r\n    if (value < 1) {\r\n        while (value < 1) {\r\n            n++;\r\n            value = value * 2;\r\n        }\r\n        n = -n;\r\n    } else if (value > 1) {\r\n        while (value > 1) {\r\n            n++;\r\n            value = Math.floor(value / 2);\r\n        }\r\n    }\r\n\r\n    return n;\r\n}\r\n\r\n/**\r\n * Loops the value, so that it is never larger than length and never smaller than 0.\r\n *\r\n * This is similar to the modulo operator but it works with floating point numbers.\r\n * For example, using 3.0 for t and 2.5 for length, the result would be 0.5.\r\n * With t = 5 and length = 2.5, the result would be 0.0.\r\n * Note, however, that the behaviour is not defined for negative numbers as it is for the modulo operator\r\n * @param value the value\r\n * @param length the length\r\n * @returns the looped value\r\n */\r\nexport function Repeat(value: number, length: number): number {\r\n    return value - Math.floor(value / length) * length;\r\n}\r\n\r\n/**\r\n * Normalize the value between 0.0 and 1.0 using min and max values\r\n * @param value value to normalize\r\n * @param min max to normalize between\r\n * @param max min to normalize between\r\n * @returns the normalized value\r\n */\r\nexport function Normalize(value: number, min: number, max: number): number {\r\n    return (value - min) / (max - min);\r\n}\r\n\r\n/**\r\n * Denormalize the value from 0.0 and 1.0 using min and max values\r\n * @param normalized value to denormalize\r\n * @param min max to denormalize between\r\n * @param max min to denormalize between\r\n * @returns the denormalized value\r\n */\r\nexport function Denormalize(normalized: number, min: number, max: number): number {\r\n    return normalized * (max - min) + min;\r\n}\r\n\r\n/**\r\n * Calculates the shortest difference between two given angles given in degrees.\r\n * @param current current angle in degrees\r\n * @param target target angle in degrees\r\n * @returns the delta\r\n */\r\nexport function DeltaAngle(current: number, target: number): number {\r\n    let num: number = Repeat(target - current, 360.0);\r\n    if (num > 180.0) {\r\n        num -= 360.0;\r\n    }\r\n    return num;\r\n}\r\n\r\n/**\r\n * PingPongs the value t, so that it is never larger than length and never smaller than 0.\r\n * @param tx value\r\n * @param length length\r\n * @returns The returned value will move back and forth between 0 and length\r\n */\r\nexport function PingPong(tx: number, length: number): number {\r\n    const t: number = Repeat(tx, length * 2.0);\r\n    return length - Math.abs(t - length);\r\n}\r\n\r\n/**\r\n * Interpolates between min and max with smoothing at the limits.\r\n *\r\n * This function interpolates between min and max in a similar way to Lerp. However, the interpolation will gradually speed up\r\n * from the start and slow down toward the end. This is useful for creating natural-looking animation, fading and other transitions.\r\n * @param from from\r\n * @param to to\r\n * @param tx value\r\n * @returns the smooth stepped value\r\n */\r\nexport function SmoothStep(from: number, to: number, tx: number): number {\r\n    let t: number = Clamp(tx);\r\n    t = -2.0 * t * t * t + 3.0 * t * t;\r\n    return to * t + from * (1.0 - t);\r\n}\r\n\r\n/**\r\n * Moves a value current towards target.\r\n *\r\n * This is essentially the same as Mathf.Lerp but instead the function will ensure that the speed never exceeds maxDelta.\r\n * Negative values of maxDelta pushes the value away from target.\r\n * @param current current value\r\n * @param target target value\r\n * @param maxDelta max distance to move\r\n * @returns resulting value\r\n */\r\nexport function MoveTowards(current: number, target: number, maxDelta: number): number {\r\n    let result: number = 0;\r\n    if (Math.abs(target - current) <= maxDelta) {\r\n        result = target;\r\n    } else {\r\n        result = current + Math.sign(target - current) * maxDelta;\r\n    }\r\n    return result;\r\n}\r\n\r\n/**\r\n * Same as MoveTowards but makes sure the values interpolate correctly when they wrap around 360 degrees.\r\n *\r\n * Variables current and target are assumed to be in degrees. For optimization reasons, negative values of maxDelta\r\n *  are not supported and may cause oscillation. To push current away from a target angle, add 180 to that angle instead.\r\n * @param current current value\r\n * @param target target value\r\n * @param maxDelta max distance to move\r\n * @returns resulting angle\r\n */\r\nexport function MoveTowardsAngle(current: number, target: number, maxDelta: number): number {\r\n    const num: number = DeltaAngle(current, target);\r\n    let result: number = 0;\r\n    if (-maxDelta < num && num < maxDelta) {\r\n        result = target;\r\n    } else {\r\n        target = current + num;\r\n        result = MoveTowards(current, target, maxDelta);\r\n    }\r\n    return result;\r\n}\r\n\r\n/**\r\n * This function returns percentage of a number in a given range.\r\n *\r\n * RangeToPercent(40,20,60) will return 0.5 (50%)\r\n * RangeToPercent(34,0,100) will return 0.34 (34%)\r\n * @param number to convert to percentage\r\n * @param min min range\r\n * @param max max range\r\n * @returns the percentage\r\n */\r\nexport function RangeToPercent(number: number, min: number, max: number): number {\r\n    return (number - min) / (max - min);\r\n}\r\n\r\n/**\r\n * This function returns number that corresponds to the percentage in a given range.\r\n *\r\n * PercentToRange(0.34,0,100) will return 34.\r\n * @param percent to convert to number\r\n * @param min min range\r\n * @param max max range\r\n * @returns the number\r\n */\r\nexport function PercentToRange(percent: number, min: number, max: number): number {\r\n    return (max - min) * percent + min;\r\n}\r\n\r\n/**\r\n * Returns the highest common factor of two integers.\r\n * @param a first parameter\r\n * @param b second parameter\r\n * @returns HCF of a and b\r\n */\r\nexport function HighestCommonFactor(a: number, b: number): number {\r\n    const r: number = a % b;\r\n    if (r === 0) {\r\n        return b;\r\n    }\r\n    return HighestCommonFactor(b, r);\r\n}\r\n"]}

package/Maths/math.scalar.js

@@ -1,323 +1,35 @@
-import { Clamp, Lerp, NormalizeRadians, RandomRange, ToHex, WithinEpsilon } from "./math.scalar.functions.js";
+import * as functions from "./math.scalar.functions.js";
+const HCF = functions.HighestCommonFactor;
 /**
  * Scalar computation library
+ * @deprecated Please use the scalar functions
  */
-export class Scalar {
+/* eslint-disable @typescript-eslint/naming-convention */
+export const Scalar = {
+    ...functions,
+    /**
+     * Two pi constants convenient for computation.
+     */
+    TwoPi: Math.PI * 2,
     /**
      * Returns -1 if value is negative and +1 is value is positive.
      * @param value the value
      * @returns the value itself if it's equal to zero.
      */
-    static Sign(value) {
-        value = +value; // convert to a number
-        if (value === 0 || isNaN(value)) {
-            return value;
-        }
-        return value > 0 ? 1 : -1;
-    }
+    Sign: Math.sign,
     /**
      * the log2 of value.
      * @param value the value to compute log2 of
      * @returns the log2 of value.
      */
-    static Log2(value) {
-        return Math.log(value) * Math.LOG2E;
-    }
-    /**
-     * the floor part of a log2 value.
-     * @param value the value to compute log2 of
-     * @returns the log2 of value.
-     */
-    static ILog2(value) {
-        if (Math.log2) {
-            return Math.floor(Math.log2(value));
-        }
-        if (value < 0) {
-            return NaN;
-        }
-        else if (value === 0) {
-            return -Infinity;
-        }
-        let n = 0;
-        if (value < 1) {
-            while (value < 1) {
-                n++;
-                value = value * 2;
-            }
-            n = -n;
-        }
-        else if (value > 1) {
-            while (value > 1) {
-                n++;
-                value = Math.floor(value / 2);
-            }
-        }
-        return n;
-    }
-    /**
-     * Loops the value, so that it is never larger than length and never smaller than 0.
-     *
-     * This is similar to the modulo operator but it works with floating point numbers.
-     * For example, using 3.0 for t and 2.5 for length, the result would be 0.5.
-     * With t = 5 and length = 2.5, the result would be 0.0.
-     * Note, however, that the behaviour is not defined for negative numbers as it is for the modulo operator
-     * @param value the value
-     * @param length the length
-     * @returns the looped value
-     */
-    static Repeat(value, length) {
-        return value - Math.floor(value / length) * length;
-    }
-    /**
-     * Normalize the value between 0.0 and 1.0 using min and max values
-     * @param value value to normalize
-     * @param min max to normalize between
-     * @param max min to normalize between
-     * @returns the normalized value
-     */
-    static Normalize(value, min, max) {
-        return (value - min) / (max - min);
-    }
-    /**
-     * Denormalize the value from 0.0 and 1.0 using min and max values
-     * @param normalized value to denormalize
-     * @param min max to denormalize between
-     * @param max min to denormalize between
-     * @returns the denormalized value
-     */
-    static Denormalize(normalized, min, max) {
-        return normalized * (max - min) + min;
-    }
-    /**
-     * Calculates the shortest difference between two given angles given in degrees.
-     * @param current current angle in degrees
-     * @param target target angle in degrees
-     * @returns the delta
-     */
-    static DeltaAngle(current, target) {
-        let num = Scalar.Repeat(target - current, 360.0);
-        if (num > 180.0) {
-            num -= 360.0;
-        }
-        return num;
-    }
-    /**
-     * PingPongs the value t, so that it is never larger than length and never smaller than 0.
-     * @param tx value
-     * @param length length
-     * @returns The returned value will move back and forth between 0 and length
-     */
-    static PingPong(tx, length) {
-        const t = Scalar.Repeat(tx, length * 2.0);
-        return length - Math.abs(t - length);
-    }
-    /**
-     * Interpolates between min and max with smoothing at the limits.
-     *
-     * This function interpolates between min and max in a similar way to Lerp. However, the interpolation will gradually speed up
-     * from the start and slow down toward the end. This is useful for creating natural-looking animation, fading and other transitions.
-     * @param from from
-     * @param to to
-     * @param tx value
-     * @returns the smooth stepped value
-     */
-    static SmoothStep(from, to, tx) {
-        let t = Scalar.Clamp(tx);
-        t = -2.0 * t * t * t + 3.0 * t * t;
-        return to * t + from * (1.0 - t);
-    }
-    /**
-     * Moves a value current towards target.
-     *
-     * This is essentially the same as Mathf.Lerp but instead the function will ensure that the speed never exceeds maxDelta.
-     * Negative values of maxDelta pushes the value away from target.
-     * @param current current value
-     * @param target target value
-     * @param maxDelta max distance to move
-     * @returns resulting value
-     */
-    static MoveTowards(current, target, maxDelta) {
-        let result = 0;
-        if (Math.abs(target - current) <= maxDelta) {
-            result = target;
-        }
-        else {
-            result = current + Scalar.Sign(target - current) * maxDelta;
-        }
-        return result;
-    }
-    /**
-     * Same as MoveTowards but makes sure the values interpolate correctly when they wrap around 360 degrees.
-     *
-     * Variables current and target are assumed to be in degrees. For optimization reasons, negative values of maxDelta
-     *  are not supported and may cause oscillation. To push current away from a target angle, add 180 to that angle instead.
-     * @param current current value
-     * @param target target value
-     * @param maxDelta max distance to move
-     * @returns resulting angle
-     */
-    static MoveTowardsAngle(current, target, maxDelta) {
-        const num = Scalar.DeltaAngle(current, target);
-        let result = 0;
-        if (-maxDelta < num && num < maxDelta) {
-            result = target;
-        }
-        else {
-            target = current + num;
-            result = Scalar.MoveTowards(current, target, maxDelta);
-        }
-        return result;
-    }
-    /**
-     * Same as Lerp but makes sure the values interpolate correctly when they wrap around 360 degrees.
-     * The parameter t is clamped to the range [0, 1]. Variables a and b are assumed to be in degrees.
-     * @param start start value
-     * @param end target value
-     * @param amount amount to lerp between
-     * @returns the lerped value
-     */
-    static LerpAngle(start, end, amount) {
-        let num = Scalar.Repeat(end - start, 360.0);
-        if (num > 180.0) {
-            num -= 360.0;
-        }
-        return start + num * Clamp(amount);
-    }
-    /**
-     * Calculates the linear parameter t that produces the interpolant value within the range [a, b].
-     * @param a start value
-     * @param b target value
-     * @param value value between a and b
-     * @returns the inverseLerp value
-     */
-    static InverseLerp(a, b, value) {
-        let result = 0;
-        if (a != b) {
-            result = Clamp((value - a) / (b - a));
-        }
-        else {
-            result = 0.0;
-        }
-        return result;
-    }
-    /**
-     * Returns a new scalar located for "amount" (float) on the Hermite spline defined by the scalars "value1", "value3", "tangent1", "tangent2".
-     * @see http://mathworld.wolfram.com/HermitePolynomial.html
-     * @param value1 defines the first control point
-     * @param tangent1 defines the first tangent
-     * @param value2 defines the second control point
-     * @param tangent2 defines the second tangent
-     * @param amount defines the amount on the interpolation spline (between 0 and 1)
-     * @returns hermite result
-     */
-    static Hermite(value1, tangent1, value2, tangent2, amount) {
-        const squared = amount * amount;
-        const cubed = amount * squared;
-        const part1 = 2.0 * cubed - 3.0 * squared + 1.0;
-        const part2 = -2.0 * cubed + 3.0 * squared;
-        const part3 = cubed - 2.0 * squared + amount;
-        const part4 = cubed - squared;
-        return value1 * part1 + value2 * part2 + tangent1 * part3 + tangent2 * part4;
-    }
-    /**
-     * Returns a new scalar which is the 1st derivative of the Hermite spline defined by the scalars "value1", "value2", "tangent1", "tangent2".
-     * @param value1 defines the first control point
-     * @param tangent1 defines the first tangent
-     * @param value2 defines the second control point
-     * @param tangent2 defines the second tangent
-     * @param time define where the derivative must be done
-     * @returns 1st derivative
-     */
-    static Hermite1stDerivative(value1, tangent1, value2, tangent2, time) {
-        const t2 = time * time;
-        return (t2 - time) * 6 * value1 + (3 * t2 - 4 * time + 1) * tangent1 + (-t2 + time) * 6 * value2 + (3 * t2 - 2 * time) * tangent2;
-    }
-    /**
-     * This function returns percentage of a number in a given range.
-     *
-     * RangeToPercent(40,20,60) will return 0.5 (50%)
-     * RangeToPercent(34,0,100) will return 0.34 (34%)
-     * @param number to convert to percentage
-     * @param min min range
-     * @param max max range
-     * @returns the percentage
-     */
-    static RangeToPercent(number, min, max) {
-        return (number - min) / (max - min);
-    }
-    /**
-     * This function returns number that corresponds to the percentage in a given range.
-     *
-     * PercentToRange(0.34,0,100) will return 34.
-     * @param percent to convert to number
-     * @param min min range
-     * @param max max range
-     * @returns the number
-     */
-    static PercentToRange(percent, min, max) {
-        return (max - min) * percent + min;
-    }
+    Log2: Math.log2,
     /**
      * Returns the highest common factor of two integers.
      * @param a first parameter
      * @param b second parameter
      * @returns HCF of a and b
      */
-    static HCF(a, b) {
-        const r = a % b;
-        if (r === 0) {
-            return b;
-        }
-        return Scalar.HCF(b, r);
-    }
-}
-/**
- * Two pi constants convenient for computation.
- */
-Scalar.TwoPi = Math.PI * 2;
-/**
- * Boolean : true if the absolute difference between a and b is lower than epsilon (default = 1.401298E-45)
- * @param a number
- * @param b number
- * @param epsilon (default = 1.401298E-45)
- * @returns true if the absolute difference between a and b is lower than epsilon (default = 1.401298E-45)
- */
-Scalar.WithinEpsilon = WithinEpsilon;
-/**
- * Returns a string : the upper case translation of the number i to hexadecimal.
- * @param i number
- * @returns the upper case translation of the number i to hexadecimal.
- */
-Scalar.ToHex = ToHex;
-/**
- * Returns the value itself if it's between min and max.
- * Returns min if the value is lower than min.
- * Returns max if the value is greater than max.
- * @param value the value to clmap
- * @param min the min value to clamp to (default: 0)
- * @param max the max value to clamp to (default: 1)
- * @returns the clamped value
- */
-Scalar.Clamp = Clamp;
-/**
- * Creates a new scalar with values linearly interpolated of "amount" between the start scalar and the end scalar.
- * @param start start value
- * @param end target value
- * @param amount amount to lerp between
- * @returns the lerped value
- */
-Scalar.Lerp = Lerp;
-/**
- * Returns a random float number between and min and max values
- * @param min min value of random
- * @param max max value of random
- * @returns random value
- */
-Scalar.RandomRange = RandomRange;
-/**
- * Returns the angle converted to equivalent value between -Math.PI and Math.PI radians.
- * @param angle The angle to normalize in radian.
- * @returns The converted angle.
- */
-Scalar.NormalizeRadians = NormalizeRadians;
+    HCF,
+};
+/* eslint-enable @typescript-eslint/naming-convention */
 //# sourceMappingURL=math.scalar.js.map

package/Maths/math.scalar.js.map

@@ -1 +1 @@
-{"version":3,"file":"math.scalar.js","sourceRoot":"","sources":["../../../../dev/core/src/Maths/math.scalar.ts"],"names":[],"mappings":"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","sourcesContent":["import { Clamp, Lerp, NormalizeRadians, RandomRange, ToHex, WithinEpsilon } from \"./math.scalar.functions\";\r\n\r\n/**\r\n * Scalar computation library\r\n */\r\nexport class Scalar {\r\n    /**\r\n     * Two pi constants convenient for computation.\r\n     */\r\n    public static TwoPi: number = Math.PI * 2;\r\n\r\n    /**\r\n     * Boolean : true if the absolute difference between a and b is lower than epsilon (default = 1.401298E-45)\r\n     * @param a number\r\n     * @param b number\r\n     * @param epsilon (default = 1.401298E-45)\r\n     * @returns true if the absolute difference between a and b is lower than epsilon (default = 1.401298E-45)\r\n     */\r\n    public static WithinEpsilon: (a: number, b: number, epsilon?: number) => boolean = WithinEpsilon;\r\n\r\n    /**\r\n     * Returns a string : the upper case translation of the number i to hexadecimal.\r\n     * @param i number\r\n     * @returns the upper case translation of the number i to hexadecimal.\r\n     */\r\n    public static ToHex: (i: number) => string = ToHex;\r\n\r\n    /**\r\n     * Returns -1 if value is negative and +1 is value is positive.\r\n     * @param value the value\r\n     * @returns the value itself if it's equal to zero.\r\n     */\r\n    public static Sign(value: number): number {\r\n        value = +value; // convert to a number\r\n\r\n        if (value === 0 || isNaN(value)) {\r\n            return value;\r\n        }\r\n\r\n        return value > 0 ? 1 : -1;\r\n    }\r\n\r\n    /**\r\n     * Returns the value itself if it's between min and max.\r\n     * Returns min if the value is lower than min.\r\n     * Returns max if the value is greater than max.\r\n     * @param value the value to clmap\r\n     * @param min the min value to clamp to (default: 0)\r\n     * @param max the max value to clamp to (default: 1)\r\n     * @returns the clamped value\r\n     */\r\n    public static Clamp: (value: number, min?: number, max?: number) => number = Clamp;\r\n\r\n    /**\r\n     * the log2 of value.\r\n     * @param value the value to compute log2 of\r\n     * @returns the log2 of value.\r\n     */\r\n    public static Log2(value: number): number {\r\n        return Math.log(value) * Math.LOG2E;\r\n    }\r\n\r\n    /**\r\n     * the floor part of a log2 value.\r\n     * @param value the value to compute log2 of\r\n     * @returns the log2 of value.\r\n     */\r\n    public static ILog2(value: number): number {\r\n        if (Math.log2) {\r\n            return Math.floor(Math.log2(value));\r\n        }\r\n\r\n        if (value < 0) {\r\n            return NaN;\r\n        } else if (value === 0) {\r\n            return -Infinity;\r\n        }\r\n\r\n        let n = 0;\r\n        if (value < 1) {\r\n            while (value < 1) {\r\n                n++;\r\n                value = value * 2;\r\n            }\r\n            n = -n;\r\n        } else if (value > 1) {\r\n            while (value > 1) {\r\n                n++;\r\n                value = Math.floor(value / 2);\r\n            }\r\n        }\r\n\r\n        return n;\r\n    }\r\n\r\n    /**\r\n     * Loops the value, so that it is never larger than length and never smaller than 0.\r\n     *\r\n     * This is similar to the modulo operator but it works with floating point numbers.\r\n     * For example, using 3.0 for t and 2.5 for length, the result would be 0.5.\r\n     * With t = 5 and length = 2.5, the result would be 0.0.\r\n     * Note, however, that the behaviour is not defined for negative numbers as it is for the modulo operator\r\n     * @param value the value\r\n     * @param length the length\r\n     * @returns the looped value\r\n     */\r\n    public static Repeat(value: number, length: number): number {\r\n        return value - Math.floor(value / length) * length;\r\n    }\r\n\r\n    /**\r\n     * Normalize the value between 0.0 and 1.0 using min and max values\r\n     * @param value value to normalize\r\n     * @param min max to normalize between\r\n     * @param max min to normalize between\r\n     * @returns the normalized value\r\n     */\r\n    public static Normalize(value: number, min: number, max: number): number {\r\n        return (value - min) / (max - min);\r\n    }\r\n\r\n    /**\r\n     * Denormalize the value from 0.0 and 1.0 using min and max values\r\n     * @param normalized value to denormalize\r\n     * @param min max to denormalize between\r\n     * @param max min to denormalize between\r\n     * @returns the denormalized value\r\n     */\r\n    public static Denormalize(normalized: number, min: number, max: number): number {\r\n        return normalized * (max - min) + min;\r\n    }\r\n\r\n    /**\r\n     * Calculates the shortest difference between two given angles given in degrees.\r\n     * @param current current angle in degrees\r\n     * @param target target angle in degrees\r\n     * @returns the delta\r\n     */\r\n    public static DeltaAngle(current: number, target: number): number {\r\n        let num: number = Scalar.Repeat(target - current, 360.0);\r\n        if (num > 180.0) {\r\n            num -= 360.0;\r\n        }\r\n        return num;\r\n    }\r\n\r\n    /**\r\n     * PingPongs the value t, so that it is never larger than length and never smaller than 0.\r\n     * @param tx value\r\n     * @param length length\r\n     * @returns The returned value will move back and forth between 0 and length\r\n     */\r\n    public static PingPong(tx: number, length: number): number {\r\n        const t: number = Scalar.Repeat(tx, length * 2.0);\r\n        return length - Math.abs(t - length);\r\n    }\r\n\r\n    /**\r\n     * Interpolates between min and max with smoothing at the limits.\r\n     *\r\n     * This function interpolates between min and max in a similar way to Lerp. However, the interpolation will gradually speed up\r\n     * from the start and slow down toward the end. This is useful for creating natural-looking animation, fading and other transitions.\r\n     * @param from from\r\n     * @param to to\r\n     * @param tx value\r\n     * @returns the smooth stepped value\r\n     */\r\n    public static SmoothStep(from: number, to: number, tx: number): number {\r\n        let t: number = Scalar.Clamp(tx);\r\n        t = -2.0 * t * t * t + 3.0 * t * t;\r\n        return to * t + from * (1.0 - t);\r\n    }\r\n\r\n    /**\r\n     * Moves a value current towards target.\r\n     *\r\n     * This is essentially the same as Mathf.Lerp but instead the function will ensure that the speed never exceeds maxDelta.\r\n     * Negative values of maxDelta pushes the value away from target.\r\n     * @param current current value\r\n     * @param target target value\r\n     * @param maxDelta max distance to move\r\n     * @returns resulting value\r\n     */\r\n    public static MoveTowards(current: number, target: number, maxDelta: number): number {\r\n        let result: number = 0;\r\n        if (Math.abs(target - current) <= maxDelta) {\r\n            result = target;\r\n        } else {\r\n            result = current + Scalar.Sign(target - current) * maxDelta;\r\n        }\r\n        return result;\r\n    }\r\n\r\n    /**\r\n     * Same as MoveTowards but makes sure the values interpolate correctly when they wrap around 360 degrees.\r\n     *\r\n     * Variables current and target are assumed to be in degrees. For optimization reasons, negative values of maxDelta\r\n     *  are not supported and may cause oscillation. To push current away from a target angle, add 180 to that angle instead.\r\n     * @param current current value\r\n     * @param target target value\r\n     * @param maxDelta max distance to move\r\n     * @returns resulting angle\r\n     */\r\n    public static MoveTowardsAngle(current: number, target: number, maxDelta: number): number {\r\n        const num: number = Scalar.DeltaAngle(current, target);\r\n        let result: number = 0;\r\n        if (-maxDelta < num && num < maxDelta) {\r\n            result = target;\r\n        } else {\r\n            target = current + num;\r\n            result = Scalar.MoveTowards(current, target, maxDelta);\r\n        }\r\n        return result;\r\n    }\r\n\r\n    /**\r\n     * Creates a new scalar with values linearly interpolated of \"amount\" between the start scalar and the end scalar.\r\n     * @param start start value\r\n     * @param end target value\r\n     * @param amount amount to lerp between\r\n     * @returns the lerped value\r\n     */\r\n    public static Lerp: (start: number, end: number, amount: number) => number = Lerp;\r\n\r\n    /**\r\n     * Same as Lerp but makes sure the values interpolate correctly when they wrap around 360 degrees.\r\n     * The parameter t is clamped to the range [0, 1]. Variables a and b are assumed to be in degrees.\r\n     * @param start start value\r\n     * @param end target value\r\n     * @param amount amount to lerp between\r\n     * @returns the lerped value\r\n     */\r\n    public static LerpAngle(start: number, end: number, amount: number): number {\r\n        let num: number = Scalar.Repeat(end - start, 360.0);\r\n        if (num > 180.0) {\r\n            num -= 360.0;\r\n        }\r\n        return start + num * Clamp(amount);\r\n    }\r\n\r\n    /**\r\n     * Calculates the linear parameter t that produces the interpolant value within the range [a, b].\r\n     * @param a start value\r\n     * @param b target value\r\n     * @param value value between a and b\r\n     * @returns the inverseLerp value\r\n     */\r\n    public static InverseLerp(a: number, b: number, value: number): number {\r\n        let result: number = 0;\r\n        if (a != b) {\r\n            result = Clamp((value - a) / (b - a));\r\n        } else {\r\n            result = 0.0;\r\n        }\r\n        return result;\r\n    }\r\n\r\n    /**\r\n     * Returns a new scalar located for \"amount\" (float) on the Hermite spline defined by the scalars \"value1\", \"value3\", \"tangent1\", \"tangent2\".\r\n     * @see http://mathworld.wolfram.com/HermitePolynomial.html\r\n     * @param value1 defines the first control point\r\n     * @param tangent1 defines the first tangent\r\n     * @param value2 defines the second control point\r\n     * @param tangent2 defines the second tangent\r\n     * @param amount defines the amount on the interpolation spline (between 0 and 1)\r\n     * @returns hermite result\r\n     */\r\n    public static Hermite(value1: number, tangent1: number, value2: number, tangent2: number, amount: number): number {\r\n        const squared = amount * amount;\r\n        const cubed = amount * squared;\r\n        const part1 = 2.0 * cubed - 3.0 * squared + 1.0;\r\n        const part2 = -2.0 * cubed + 3.0 * squared;\r\n        const part3 = cubed - 2.0 * squared + amount;\r\n        const part4 = cubed - squared;\r\n\r\n        return value1 * part1 + value2 * part2 + tangent1 * part3 + tangent2 * part4;\r\n    }\r\n\r\n    /**\r\n     * Returns a new scalar which is the 1st derivative of the Hermite spline defined by the scalars \"value1\", \"value2\", \"tangent1\", \"tangent2\".\r\n     * @param value1 defines the first control point\r\n     * @param tangent1 defines the first tangent\r\n     * @param value2 defines the second control point\r\n     * @param tangent2 defines the second tangent\r\n     * @param time define where the derivative must be done\r\n     * @returns 1st derivative\r\n     */\r\n    public static Hermite1stDerivative(value1: number, tangent1: number, value2: number, tangent2: number, time: number): number {\r\n        const t2 = time * time;\r\n        return (t2 - time) * 6 * value1 + (3 * t2 - 4 * time + 1) * tangent1 + (-t2 + time) * 6 * value2 + (3 * t2 - 2 * time) * tangent2;\r\n    }\r\n\r\n    /**\r\n     * Returns a random float number between and min and max values\r\n     * @param min min value of random\r\n     * @param max max value of random\r\n     * @returns random value\r\n     */\r\n    public static RandomRange: (min: number, max: number) => number = RandomRange;\r\n\r\n    /**\r\n     * This function returns percentage of a number in a given range.\r\n     *\r\n     * RangeToPercent(40,20,60) will return 0.5 (50%)\r\n     * RangeToPercent(34,0,100) will return 0.34 (34%)\r\n     * @param number to convert to percentage\r\n     * @param min min range\r\n     * @param max max range\r\n     * @returns the percentage\r\n     */\r\n    public static RangeToPercent(number: number, min: number, max: number): number {\r\n        return (number - min) / (max - min);\r\n    }\r\n\r\n    /**\r\n     * This function returns number that corresponds to the percentage in a given range.\r\n     *\r\n     * PercentToRange(0.34,0,100) will return 34.\r\n     * @param percent to convert to number\r\n     * @param min min range\r\n     * @param max max range\r\n     * @returns the number\r\n     */\r\n    public static PercentToRange(percent: number, min: number, max: number): number {\r\n        return (max - min) * percent + min;\r\n    }\r\n\r\n    /**\r\n     * Returns the angle converted to equivalent value between -Math.PI and Math.PI radians.\r\n     * @param angle The angle to normalize in radian.\r\n     * @returns The converted angle.\r\n     */\r\n    public static NormalizeRadians: (angle: number) => number = NormalizeRadians;\r\n\r\n    /**\r\n     * Returns the highest common factor of two integers.\r\n     * @param a first parameter\r\n     * @param b second parameter\r\n     * @returns HCF of a and b\r\n     */\r\n    public static HCF(a: number, b: number): number {\r\n        const r: number = a % b;\r\n        if (r === 0) {\r\n            return b;\r\n        }\r\n        return Scalar.HCF(b, r);\r\n    }\r\n}\r\n"]}
+{"version":3,"file":"math.scalar.js","sourceRoot":"","sources":["../../../../dev/core/src/Maths/math.scalar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,yBAAyB,CAAC;AAErD,MAAM,GAAG,GAAqC,SAAS,CAAC,mBAAmB,CAAC;AAE5E;;;GAGG;AACH,yDAAyD;AACzD,MAAM,CAAC,MAAM,MAAM,GAAG;IAClB,GAAG,SAAS;IAEZ;;OAEG;IACH,KAAK,EAAE,IAAI,CAAC,EAAE,GAAG,CAAC;IAElB;;;;OAIG;IACH,IAAI,EAAE,IAAI,CAAC,IAAI;IAEf;;;;OAIG;IACH,IAAI,EAAE,IAAI,CAAC,IAAI;IAEf;;;;;OAKG;IACH,GAAG;CACN,CAAC;AACF,wDAAwD","sourcesContent":["import * as functions from \"./math.scalar.functions\";\r\n\r\nconst HCF: (a: number, b: number) => number = functions.HighestCommonFactor;\r\n\r\n/**\r\n * Scalar computation library\r\n * @deprecated Please use the scalar functions\r\n */\r\n/* eslint-disable @typescript-eslint/naming-convention */\r\nexport const Scalar = {\r\n    ...functions,\r\n\r\n    /**\r\n     * Two pi constants convenient for computation.\r\n     */\r\n    TwoPi: Math.PI * 2,\r\n\r\n    /**\r\n     * Returns -1 if value is negative and +1 is value is positive.\r\n     * @param value the value\r\n     * @returns the value itself if it's equal to zero.\r\n     */\r\n    Sign: Math.sign,\r\n\r\n    /**\r\n     * the log2 of value.\r\n     * @param value the value to compute log2 of\r\n     * @returns the log2 of value.\r\n     */\r\n    Log2: Math.log2,\r\n\r\n    /**\r\n     * Returns the highest common factor of two integers.\r\n     * @param a first parameter\r\n     * @param b second parameter\r\n     * @returns HCF of a and b\r\n     */\r\n    HCF,\r\n};\r\n/* eslint-enable @typescript-eslint/naming-convention */\r\n"]}

package/Meshes/Builders/decalBuilder.js

@@ -1,5 +1,5 @@
 import { Vector3, Matrix, Vector2, TmpVectors } from "../../Maths/math.vector.js";
-import { Scalar } from "../../Maths/math.scalar.js";
+import { Lerp } from "../../Maths/math.scalar.functions.js";
 import { Mesh } from "../mesh.js";
 import { VertexBuffer } from "../../Buffers/buffer.js";
 import { VertexData } from "../mesh.vertexData.js";
@@ -135,7 +135,7 @@ export function CreateDecal(name, sourceMesh, options) {
                     if (v0Weights[mat0Index + i] > 0) {
                         const idx = indexOf(v1Indices, v0Indices[mat0Index + i], mat1Index, 4);
                         indices[index] = v0Indices[mat0Index + i];
-                        weights[index] = Scalar.Lerp(v0Weights[mat0Index + i], idx >= 0 ? v1Weights[idx] : 0, clipFactor);
+                        weights[index] = Lerp(v0Weights[mat0Index + i], idx >= 0 ? v1Weights[idx] : 0, clipFactor);
                         index++;
                     }
                 }
@@ -144,7 +144,7 @@ export function CreateDecal(name, sourceMesh, options) {
                     if (indexOf(v0Indices, ind, mat0Index, 4) !== -1)
                         continue;
                     indices[index] = ind;
-                    weights[index] = Scalar.Lerp(0, v1Weights[mat1Index + i], clipFactor);
+                    weights[index] = Lerp(0, v1Weights[mat1Index + i], clipFactor);
                     index++;
                 }
                 const sumw = weights[0] + weights[1] + weights[2] + weights[3];