\c\This file was generated using a tool\c\
\h1\func_common methods\h1\
The following methods are all part of the \b\func_common methods\b\.
It contains common GLSL functions.
\h2\Table of contents\h2\
\ul\
\-\\url #abs-function\\b\abs\b\ function\url\
\-\\url #ceil-function\\b\ceil\b\ function\url\
\-\\url #clamp-function\\b\clamp\b\ function\url\
\-\\url #floatbitstoint-function\\b\floatBitsToInt\b\ function\url\
\-\\url #floatbitstouint-function\\b\floatBitsToUint\b\ function\url\
\-\\url #floor-function\\b\floor\b\ function\url\
\-\\url #fma-function\\b\fma\b\ function\url\
\-\\url #fmax-function\\b\fmax\b\ function\url\
\-\\url #fmin-function\\b\fmin\b\ function\url\
\-\\url #fract-function\\b\fract\b\ function\url\
\-\\url #frexp-function\\b\frexp\b\ function\url\
\-\\url #intbitstofloat-function\\b\intBitsToFloat\b\ function\url\
\-\\url #isinf-function\\b\isinf\b\ function\url\
\-\\url #isnan-function\\b\isnan\b\ function\url\
\-\\url #ldexp-function\\b\ldexp\b\ function\url\
\-\\url #max-function\\b\max\b\ function\url\
\-\\url #min-function\\b\min\b\ function\url\
\-\\url #mix-function\\b\mix\b\ function\url\
\-\\url #mod-function\\b\mod\b\ function\url\
\-\\url #modf-function\\b\modf\b\ function\url\
\-\\url #round-function\\b\round\b\ function\url\
\-\\url #roundeven-function\\b\roundEven\b\ function\url\
\-\\url #sign-function\\b\sign\b\ function\url\
\-\\url #smoothstep-function\\b\smoothstep\b\ function\url\
\-\\url #step-function\\b\step\b\ function\url\
\-\\url #trunc-function\\b\trunc\b\ function\url\
\-\\url #uintbitstofloat-function\\b\uintBitsToFloat\b\ function\url\
\ul\
\h3\abs() function\h3\
\raw\#### <code>glm.<code>**abs**(**x**: *float*) -\\> *float*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\x\code\ if \code\x >= 0\code\; otherwise it returns \code\-x\code\.

\raw\#### <code>glm.<code>**abs**(**x**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\For each component \code\c\code\ of \code\x\code\,
\raw\&emsp;&emsp;\raw\Returns \code\c\code\ if \code\c >= 0\code\; otherwise it returns \code\-c\code\.

\h3\ceil() function\h3\
\raw\#### <code>glm.<code>**ceil**(**x**: *float*) -\\> *float*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns a value equal to the nearest integer that is greater than or equal to \code\x\code\.

\raw\#### <code>glm.<code>**ceil**(**x**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\For each component \code\c\code\ of \code\x\code\,
\raw\&emsp;&emsp;\raw\Returns a value equal to the nearest integer that is greater than or equal to \code\c\code\.

\h3\clamp() function\h3\
\raw\#### <code>glm.<code>**clamp**(**x**: *number*, **minVal**: *number*, **maxVal**: *number*) -\\> *number*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\min(max(x, minVal), maxVal)\code\.

\raw\#### <code>glm.<code>**clamp**(**x**: *vecN*, **minVal**: *number*, **maxVal**: *number*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\min(max(x, minVal), maxVal)\code\ for each component in \code\x\code\ using the floating-point values
\raw\&emsp;&emsp;\raw\\code\minVal\code\ and \code\maxVal\code\.

\raw\#### <code>glm.<code>**clamp**(**x**: *vecN*, **minVal**: *vecN*, **maxVal**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\min(max(x, minVal), maxVal)\code\ for each component in \code\x\code\ using the floating-point values
\raw\&emsp;&emsp;\raw\\code\minVal\code\ and \code\maxVal\code\.

\h3\floatBitsToInt() function\h3\
\raw\#### <code>glm.<code>**floatBitsToInt**(**v**: *float*) -\\> *int*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns a signed integer value representing the encoding of a floating-point value.
\raw\&emsp;&emsp;\raw\The floating-point value's bit-level representation is preserved.

\raw\#### <code>glm.<code>**floatBitsToInt**(**v**: *fvecN*) -\\> *ivecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns a signed integer value representing the encoding of a floating-point value.
\raw\&emsp;&emsp;\raw\The floating-point value's bit-level representation is preserved.

\h3\floatBitsToUint() function\h3\
\raw\#### <code>glm.<code>**floatBitsToUint**(**v**: *float*) -\\> *int*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns an unsigned integer value representing the encoding of a floating-point value.
\raw\&emsp;&emsp;\raw\The floating-point value's bit-level representation is preserved.

\raw\#### <code>glm.<code>**floatBitsToUint**(**v**: *fvecN*) -\\> *uvecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns an unsigned integer value representing the encoding of a floating-point value.
\raw\&emsp;&emsp;\raw\The floating-point value's bit-level representation is preserved.

\h3\floor() function\h3\
\raw\#### <code>glm.<code>**floor**(**x**: *float*) -\\> *float*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns a value equal to the nearest integer that is less then or equal to \code\x\code\.

\raw\#### <code>glm.<code>**floor**(**v**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\For each component \code\c\code\ of \code\v\code\:
\raw\&emsp;&emsp;\raw\Returns a value equal to the nearest integer that is less then or equal to \code\c\code\.

\h3\fma() function\h3\
\raw\#### <code>glm.<code>**fma**(**a**: *float*, **b**: *float*, **c**: *float*) -\\> *float*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Computes and returns \code\a * b + c\code\.

\h3\fmax() function\h3\
\raw\#### <code>glm.<code>**fmax**(**x**: *number*, **y**: *number*) -\\> *float*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\y\code\ if \code\x < y\code\; otherwise, it returns \code\x\code\. If one of the two arguments is \code\NaN\code\, the value
\raw\&emsp;&emsp;\raw\of the other argument is returned.

\raw\#### <code>glm.<code>**fmax**(**x**: *vecN*, **y**: *number*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\For each component \code\c\code\ of \code\x\code\:
\raw\&emsp;&emsp;\raw\Returns \code\y\code\ if \code\c < y\code\; otherwise, it returns \code\c\code\. If one of the two arguments is \code\NaN\code\, the value
\raw\&emsp;&emsp;\raw\of the other argument is returned.

\raw\#### <code>glm.<code>**fmax**(**x**: *vecN*, **y**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\For every index \code\i\code\:
\raw\&emsp;&emsp;\raw\Returns \code\y[i]\code\ if \code\x[i] < y[i]\code\; otherwise, it returns \code\x[i]\code\. If one of the two arguments is
\raw\&emsp;&emsp;\raw\\code\NaN\code\, the value of the other argument is returned.

\raw\#### <code>glm.<code>**fmax**(**a**: *vecN*, **b**: *vecN*, **c**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\fmax(fmax(a, b), c)\code\.

\raw\#### <code>glm.<code>**fmax**(**a**: *vecN*, **b**: *vecN*, **c**: *vecN*, **d**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\fmax(fmax(a, b), fmax(c, d))\code\.

\h3\fmin() function\h3\
\raw\#### <code>glm.<code>**fmin**(**x**: *number*, **y**: *number*) -\\> *float*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\y\code\ if \code\y < x\code\; otherwise, it returns \code\x\code\. If one of the two arguments is \code\NaN\code\, the value
\raw\&emsp;&emsp;\raw\of the other argument is returned.

\raw\#### <code>glm.<code>**fmin**(**x**: *vecN*, **y**: *number*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\For each component \code\c\code\ of \code\x\code\:
\raw\&emsp;&emsp;\raw\Returns \code\y\code\ if \code\y < c\code\; otherwise, it returns \code\c\code\. If one of the two arguments is \code\NaN\code\, the value
\raw\&emsp;&emsp;\raw\of the other argument is returned.

\raw\#### <code>glm.<code>**fmin**(**x**: *vecN*, **y**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\For every index \code\i\code\:
\raw\&emsp;&emsp;\raw\Returns \code\y[i]\code\ if \code\y[i] < x[i]\code\; otherwise, it returns \code\x[i]\code\. If one of the two arguments is
\raw\&emsp;&emsp;\raw\\code\NaN\code\, the value of the other argument is returned.

\raw\#### <code>glm.<code>**fmin**(**a**: *vecN*, **b**: *vecN*, **c **: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\fmin(fmin(a, b), c)\code\.

\raw\#### <code>glm.<code>**fmin**(**a**: *vecN*, **b**: *vecN*, **c **: *vecN*, **d**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\fmin(fmin(a, b), fmin(c, d))\code\.

\h3\fract() function\h3\
\raw\#### <code>glm.<code>**fract**(**x**: *float*) -\\> *float*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\x - floor(x)\code\.

\raw\#### <code>glm.<code>**fract**(**c**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\x - floor(x)\code\.

\h3\frexp() function\h3\
\raw\#### <code>glm.<code>**frexp**(**x**: *float*) -\\> *(significant: float, exponent: int)*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Splits \code\x\code\ into a floating-point significand in the range \code\[0.5, 1.0)\code\ and an integral exponent
\raw\&emsp;&emsp;\raw\of two, such that: \code\x = significand * exp(2, exponent)\code\

\raw\#### <code>glm.<code>**frexp**(**x**: *vecN*, **exp**: *ivecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Splits \code\x\code\ into a floating-point significand in the range \code\[0.5, 1.0)\code\ and an integral exponent
\raw\&emsp;&emsp;\raw\of two, such that: \code\x = significand * exp(2, exponent)\code\
\raw\&emsp;&emsp;\raw\The significand is returned by the function and the exponent is returned in the parameter
\raw\&emsp;&emsp;\raw\\code\exp\code\. For a floating-point value of zero, the significantand exponent are both zero. For a
\raw\&emsp;&emsp;\raw\floating-point value that is an infinity or is not a number, the results are undefined.

\h3\intBitsToFloat() function\h3\
\raw\#### <code>glm.<code>**intBitsToFloat**(**v**: *int*) -\\> *float*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns a floating-point value corresponding to a signed integer encoding of a floating-point
\raw\&emsp;&emsp;\raw\value. If an \code\inf\code\ or \code\NaN\code\ is passed in, it will not signal, and the resulting floating point
\raw\&emsp;&emsp;\raw\value is unspecified. Otherwise, the bit-level representation is preserved.

\raw\#### <code>glm.<code>**intBitsToFloat**(**v**: *ivecN*) -\\> *fvecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns a floating-point value corresponding to a signed integer encoding of a floating-point
\raw\&emsp;&emsp;\raw\value. If an \code\inf\code\ or \code\NaN\code\ is passed in, it will not signal, and the resulting floating point
\raw\&emsp;&emsp;\raw\value is unspecified. Otherwise, the bit-level representation is preserved.

\h3\isinf() function\h3\
\raw\#### <code>glm.<code>**isinf**(**x**: *float*) -\\> *bool*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\True\code\ if \code\x\code\ holds a positive infinity or negative infinity representation in the
\raw\&emsp;&emsp;\raw\underlying implementation's set of floating point representations.
\raw\&emsp;&emsp;\raw\Returns \code\False\code\ otherwise, including for implementations with no infinity representations.

\raw\#### <code>glm.<code>**isinf**(**x**: *vecN*) -\\> *bvecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\True\code\ if \code\x\code\ holds a positive infinity or negative infinity representation in the
\raw\&emsp;&emsp;\raw\underlying implementation's set of floating point representations.
\raw\&emsp;&emsp;\raw\Returns \code\False\code\ otherwise, including for implementations with no infinity representations.

\raw\#### <code>glm.<code>**isinf**(**x**: *quat*) -\\> *bvecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\True\code\ if \code\x\code\ holds a positive infinity or negative infinity representation in the
\raw\&emsp;&emsp;\raw\underlying implementation's set of floating point representations.
\raw\&emsp;&emsp;\raw\Returns \code\False\code\ otherwise, including for implementations with no infinity representations.

\h3\isnan() function\h3\
\raw\#### <code>glm.<code>**isnan**(**x**: *float*) -\\> *bool*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\True\code\ if \code\x\code\ holds a \code\NaN\code\ (not a number) representation in the underlying
\raw\&emsp;&emsp;\raw\implementation's set of floating point representations.
\raw\&emsp;&emsp;\raw\Returns \code\False\code\ otherwise, including for implementations with no \code\NaN\code\ representations.

\raw\#### <code>glm.<code>**isnan**(**x**: *vecN*) -\\> *bvecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\True\code\ if \code\x\code\ holds a \code\NaN\code\ (not a number) representation in the underlying
\raw\&emsp;&emsp;\raw\implementation's set of floating point representations.
\raw\&emsp;&emsp;\raw\Returns \code\False\code\ otherwise, including for implementations with no \code\NaN\code\ representations.

\raw\#### <code>glm.<code>**isnan**(**x**: *quat*) -\\> *bvecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\True\code\ if \code\x\code\ holds a \code\NaN\code\ (not a number) representation in the underlying
\raw\&emsp;&emsp;\raw\implementation's set of floating point representations.
\raw\&emsp;&emsp;\raw\Returns \code\False\code\ otherwise, including for implementations with no \code\NaN\code\ representations.

\h3\ldexp() function\h3\
\raw\#### <code>glm.<code>**ldexp**(**x**: *number*, **exp**: *int*) -\\> *float*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Builds a floating-point number from \code\x\code\ and the corresponding integral exponent of two in
\raw\&emsp;&emsp;\raw\\code\exp\code\, returning: \code\significand * exp(2, exponent)\code\. If this product is too large to be
\raw\&emsp;&emsp;\raw\represented in the floating-point type, the result is undefined.

\raw\#### <code>glm.<code>**ldexp**(**x**: *vecN*, **exp**: *ivecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Builds a floating-point number from \code\x\code\ and the corresponding integral exponent of two in
\raw\&emsp;&emsp;\raw\\code\exp\code\, returning: \code\significand * exp(2, exponent)\code\. If this product is too large to be
\raw\&emsp;&emsp;\raw\represented in the floating-point type, the result is undefined.

\h3\max() function\h3\
\raw\#### <code>glm.<code>**max**(**x**: *number*, **y**: *number*) -\\> *float*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\y\code\ if \code\x < y\code\; otherwise, it returns \code\x\code\.

\raw\#### <code>glm.<code>**max**(**x**: *vecN*, **y**: *number*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\y\code\ if \code\x < y\code\; otherwise, it returns \code\x\code\.

\raw\#### <code>glm.<code>**max**(**x**: *vecN*, **y**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\y\code\ if \code\x < y\code\; otherwise, it returns \code\x\code\.

\raw\#### <code>glm.<code>**max**(**a**: *number*, **b**: *number*, **c**: *number*) -\\> *float*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns the maximum value of 3 inputs.

\raw\#### <code>glm.<code>**max**(**a**: *vecN*, **b**: *vecN*, **c**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns the maximum component wise value of 3 inputs.

\raw\#### <code>glm.<code>**max**(**a**: *number*, **b**: *number*, **c**: *number*, **d**: *number*) -\\> *float*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns the maximum value of 4 inputs.

\raw\#### <code>glm.<code>**max**(**a**: *vecN*, **b**: *vecN*, **c**: *vecN*, **d**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns the maximum component wise value of 4 inputs.

\raw\#### <code>glm.<code>**max**(**iterable**) -\\> *any*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns the greatest number or the maximum component wise value respectively.

\h3\min() function\h3\
\raw\#### <code>glm.<code>**min**(**x**: *number*, **y**: *number*) -\\> *float*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\y\code\ if \code\y < x\code\; otherwise, it returns \code\x\code\.

\raw\#### <code>glm.<code>**min**(**x**: *vecN*, **y**: *number*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\y\code\ if \code\y < x\code\; otherwise, it returns \code\x\code\.

\raw\#### <code>glm.<code>**min**(**x**: *vecN*, **y**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\y\code\ if \code\y < x\code\; otherwise, it returns \code\x\code\.

\raw\#### <code>glm.<code>**min**(**a**: *number*, **b**: *number*, **c**: *number*) -\\> *float*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns the minimum value of 3 inputs.

\raw\#### <code>glm.<code>**min**(**a**: *vecN*, **b**: *vecN*, **c**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns the minimum component wise value of 3 inputs.

\raw\#### <code>glm.<code>**min**(**a**: *number*, **b**: *number*, **c**: *number*, **d**: *number*) -\\> *float*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns the minimum value of 4 inputs.

\raw\#### <code>glm.<code>**min**(**a**: *vecN*, **b**: *vecN*, **c**: *vecN*, **d**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns the minimum component wise value of 4 inputs.

\raw\#### <code>glm.<code>**min**(**iterable**) -\\> *any*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns the smallest number or the minimum component wise value respectively.

\h3\mix() function\h3\
\raw\#### <code>glm.<code>**mix**(**x**: *number*, **y**: *number*, **a**: *float*) -\\> *number*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\x * (1.0 - a) + y * a\code\, i.e., the linear blend of \code\x\code\ and \code\y\code\ using the floating-point
\raw\&emsp;&emsp;\raw\value \code\a\code\. The value for \code\a\code\ is not restricted to the range \code\[0, 1]\code\.

\raw\#### <code>glm.<code>**mix**(**x**: *number*, **y**: *number*, **a**: *bool*) -\\> *number*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\y\code\ if \code\a\code\ is \code\True\code\ and \code\x\code\ otherwise.

\raw\#### <code>glm.<code>**mix**(**x**: *vecN*, **y**: *vecN*, **a**: *fvecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\x * (1.0 - a) + y * a\code\, i.e., the linear blend of \code\x\code\ and \code\y\code\ using the floating-point
\raw\&emsp;&emsp;\raw\value \code\a\code\. The value for \code\a\code\ is not restricted to the range \code\[0, 1]\code\.

\raw\#### <code>glm.<code>**mix**(**x**: *vecN*, **y**: *vecN*, **a**: *bvecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\For each component index \code\i\code\:
\raw\&emsp;&emsp;\raw\Returns \code\y[i]\code\ if \code\a[i]\code\ is \code\True\code\ and \code\x[i]\code\ otherwise.

\raw\#### <code>glm.<code>**mix**(**x**: *matNxM*, **y**: *matNxM*, **a**: *fmatNxM*) -\\> *matNxM*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\x * (1.0 - a) + y * a\code\, i.e., the linear blend of \code\x\code\ and \code\y\code\ using the floating-point
\raw\&emsp;&emsp;\raw\value \code\a\code\ for each component. The value for \code\a\code\ is not restricted to the range \code\[0, 1]\code\.

\raw\#### <code>glm.<code>**mix**(**x**: *matNxM*, **y**: *matNxM*, **a**: *float*) -\\> *matNxM*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\x * (1.0 - a) + y * a\code\, i.e., the linear blend of \code\x\code\ and \code\y\code\ using the floating-point
\raw\&emsp;&emsp;\raw\value \code\a\code\ for each component. The value for \code\a\code\ is not restricted to the range \code\[0, 1]\code\.

\raw\#### <code>glm.<code>**mix**(**x**: *quat*, **y**: *quat*, **a**: *float*) -\\> *quat*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Spherical linear interpolation of two quaternions. The interpolation is oriented and the
\raw\&emsp;&emsp;\raw\rotation is performed at constant speed. For short path spherical linear interpolation, use
\raw\&emsp;&emsp;\raw\the \code\slerp\code\ function.

\h3\mod() function\h3\
\raw\#### <code>glm.<code>**mod**(**a**, **b**) -\\> *Any*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Equivalent to \code\a % b\code\.

\h3\modf() function\h3\
\raw\#### <code>glm.<code>**modf**(**x**: *float*) -\\> *(fraction, integer)*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns the fractional part of \code\x\code\ and the integer part (as a whole number floating point value).

\raw\#### <code>glm.<code>**modf**(**x**: *vecN*, **i**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns the fractional part of \code\x\code\ and sets \code\i\code\ to the integer part (as a whole number floating
\raw\&emsp;&emsp;\raw\point value).

\h3\round() function\h3\
\raw\#### <code>glm.<code>**round**(**x**: *number*) -\\> *float*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns a value equal to the nearest integer to \code\x\code\. The fraction \code\0.5\code\ will round in a
\raw\&emsp;&emsp;\raw\direction chosen by the implementation, presumably the direction that is fastest. This
\raw\&emsp;&emsp;\raw\includes the possibility that \code\round(x)\code\ returns the same value as \code\roundEven(x)\code\

\raw\#### <code>glm.<code>**round**(**x**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns a value equal to the nearest integer to \code\x\code\. The fraction \code\0.5\code\ will round in a
\raw\&emsp;&emsp;\raw\direction chosen by the implementation, presumably the direction that is fastest. This
\raw\&emsp;&emsp;\raw\includes the possibility that \code\round(x)\code\ returns the same value as \code\roundEven(x)\code\ for all
\raw\&emsp;&emsp;\raw\values of \code\x\code\.

\h3\roundEven() function\h3\
\raw\#### <code>glm.<code>**roundEven**(**x**: *number*) -\\> *float*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns a value equal to the nearest integer to \code\x\code\. A fractional part of \code\0.5\code\ will round
\raw\&emsp;&emsp;\raw\toward the nearest even integer. (Both \code\3.5\code\ and \code\4.5\code\ for \code\x\code\ will return \code\4.0\code\.)

\raw\#### <code>glm.<code>**roundEven**(**x**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns a value equal to the nearest integer to \code\x\code\. A fractional part of \code\0.5\code\ will round
\raw\&emsp;&emsp;\raw\toward the nearest even integer. (Both \code\3.5\code\ and \code\4.5\code\ for \code\x\code\ will return \code\4.0\code\.)

\h3\sign() function\h3\
\raw\#### <code>glm.<code>**sign**(**x**: *number*) -\\> *float*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\1.0\code\ if \code\x > 0\code\, \code\0.0\code\ if \code\x == 0\code\, or \code\-1.0\code\ if \code\x < 0\code\.

\raw\#### <code>glm.<code>**sign**(**x**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\For every component \code\c\code\ of \code\x\code\:
\raw\&emsp;&emsp;\raw\Returns \code\1.0\code\ if \code\x > 0\code\, \code\0.0\code\ if \code\x == 0\code\, or \code\-1.0\code\ if \code\x < 0\code\.

\h3\smoothstep() function\h3\
\raw\#### <code>glm.<code>**smoothstep**(**edge0**: *number*, **edge1**: *number*, **x**: *number*) -\\> *float*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\0.0\code\ if \code\x <= edge0\code\ and \code\1.0\code\ if \code\x >= edge1\code\ and performs smooth Hermite interpolation
\raw\&emsp;&emsp;\raw\between \code\0\code\ and \code\1\code\ when \code\edge0 < x < edge1\code\. This is useful in cases where you would want a
\raw\&emsp;&emsp;\raw\threshold function with a smooth transition. This is equivalent to :
\raw\&emsp;&emsp;\raw\\code\t = clamp((x - edge0) / (edge1 - edge0), 0, 1)\code\
\raw\&emsp;&emsp;\raw\\code\return t * t * (3 - 2 * t)\code\
\raw\&emsp;&emsp;\raw\Results are undefined if \code\edge0 >= edge1\code\.

\raw\#### <code>glm.<code>**smoothstep**(**edge0**: *number*, **edge1**: *number*, **x**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\0.0\code\ if \code\x <= edge0\code\ and \code\1.0\code\ if \code\x >= edge1\code\ and performs smooth Hermite interpolation
\raw\&emsp;&emsp;\raw\between \code\0\code\ and \code\1\code\ when \code\edge0 < x < edge1\code\. This is useful in cases where you would want a
\raw\&emsp;&emsp;\raw\threshold function with a smooth transition. This is equivalent to :
\raw\&emsp;&emsp;\raw\\code\t = clamp((x - edge0) / (edge1 - edge0), 0, 1)\code\
\raw\&emsp;&emsp;\raw\\code\return t * t * (3 - 2 * t)\code\
\raw\&emsp;&emsp;\raw\Results are undefined if \code\edge0 >= edge1\code\.

\raw\#### <code>glm.<code>**smoothstep**(**edge0**: *vecN*, **edge1**: *vecN*, **x**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\0.0\code\ if \code\x <= edge0\code\ and \code\1.0\code\ if \code\x >= edge1\code\ and performs smooth Hermite interpolation
\raw\&emsp;&emsp;\raw\between \code\0\code\ and \code\1\code\ when \code\edge0 < x < edge1\code\. This is useful in cases where you would want a
\raw\&emsp;&emsp;\raw\threshold function with a smooth transition. This is equivalent to :
\raw\&emsp;&emsp;\raw\\code\t = clamp((x - edge0) / (edge1 - edge0), 0, 1)\code\
\raw\&emsp;&emsp;\raw\\code\return t * t * (3 - 2 * t)\code\
\raw\&emsp;&emsp;\raw\Results are undefined if \code\edge0 >= edge1\code\.

\h3\step() function\h3\
\raw\#### <code>glm.<code>**step**(**edge**: *number*, **x**: *number*) -\\> *float*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns \code\0.0\code\ if \code\x < edge\code\, otherwise it returns \code\1.0\code\.

\raw\#### <code>glm.<code>**step**(**edge**: *number*, **x**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\For every component \code\c\code\ of \code\x\code\:
\raw\&emsp;&emsp;\raw\Returns \code\0.0\code\ if \code\c < edge\code\, otherwise it returns \code\1.0\code\.

\raw\#### <code>glm.<code>**step**(**edge**: *vecN*, **x**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\For every index \code\i\code\:
\raw\&emsp;&emsp;\raw\Returns \code\0.0\code\ if \code\x[i] < edge[i]\code\, otherwise it returns \code\1.0\code\.

\h3\trunc() function\h3\
\raw\#### <code>glm.<code>**trunc**(**x**: *number*) -\\> *float*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns a value equal to the nearest integer to \code\x\code\ whose absolute value is not larger than
\raw\&emsp;&emsp;\raw\the absolute value of \code\x\code\.

\raw\#### <code>glm.<code>**trunc**(**x**: *vecN*) -\\> *vecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\For every component \code\c\code\ of \code\x\code\:
\raw\&emsp;&emsp;\raw\Returns a value equal to the nearest integer to \code\c\code\ whose absolute value is not larger than
\raw\&emsp;&emsp;\raw\the absolute value of \code\c\code\.

\h3\uintBitsToFloat() function\h3\
\raw\#### <code>glm.<code>**uintBitsToFloat**(**v**: *int*) -\\> *float*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns a floating-point value corresponding to an unsigned integer encoding of a floating-point
\raw\&emsp;&emsp;\raw\value. If an \code\inf\code\ or \code\NaN\code\ is passed in, it will not signal, and the resulting floating point
\raw\&emsp;&emsp;\raw\value is unspecified. Otherwise, the bit-level representation is preserved.

\raw\#### <code>glm.<code>**uintBitsToFloat**(**v**: *ivecN*) -\\> *fvecN*</code></code>\raw\
\raw\&emsp;&emsp;\raw\Returns a floating-point value corresponding to an unsigned integer encoding of a floating-point
\raw\&emsp;&emsp;\raw\value. If an \code\inf\code\ or \code\NaN\code\ is passed in, it will not signal, and the resulting floating point
\raw\&emsp;&emsp;\raw\value is unspecified. Otherwise, the bit-level representation is preserved.

