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