Math Common Functions
Abs ( float v ) #
Returns the absolute value of the argument.Arguments
- float v - Float value.
Return value
Absolute value.Abs ( double v ) #
Returns the absolute value of the argument.Arguments
- double v - Value.
Return value
Absolute value.int Abs ( int v ) #
Returns the absolute value of the argument.Arguments
- int v - Value.
Return value
Absolute value.long Abs ( long v ) #
Returns the absolute value of the argument.Arguments
- long v - Value.
Return value
Absolute value.float Bezier ( float [] t, float [] v, float time ) #
Calculates the value of a cubic Bezier function for t = time.
Arguments
- float [] t - Coordinates of the four points of the curve along the horizontal T (times) axis in the range [0.0f, 1.0f].
- float [] v - Coordinates of the four points of the curve along the vertical V (values) axis in the range [0.0f, 1.0f].
- float time - Time in the range [0, 1], for which the value of the Bezier function is to be calculated.
Return value
Value of the Bezier function.double Bezier ( float [] t, double [] v, float time ) #
Calculates the value of a cubic Bezier function for t = time.
Arguments
- float [] t - Coordinates of the four points of the curve along the horizontal T (times) axis in the range [0.0f, 1.0f].
- double [] v - Coordinates of the four points of the curve along the vertical V (values) axis in the range [0.0f, 1.0f].
- float time - Time in the range [0, 1], for which the value of the Bezier function is to be calculated.
Return value
Value of the Bezier function.float Ceil ( float v ) #
Ceiling function that returns the smallest integer value that is not less than the argument.Source code
float a = ceil(3.141593); // a = 4.0Arguments
- float v - Argument.
Return value
Smallest integer value not less than v.double Ceil ( double v ) #
Ceiling function that returns the smallest integer value that is not less than the argument.Source code
double a = ceil(3.141593); // a = 4.0Arguments
- double v - Argument.
Return value
Smallest integer value not less than v.double Clamp ( double v, double v0, double v1 ) #
Clamps a value within the specified min and max limits.Arguments
- double v - Value to be clamped.
- double v0 - Minimum value.
- double v1 - Maximum value.
Return value
Clamped value.float Clamp ( float v, float v0, float v1 ) #
Clamps a value within the specified min and max limits.Arguments
- float v - Value to be clamped.
- float v0 - Minimum value.
- float v1 - Maximum value.
Return value
Clamped value.int Clamp ( int v, int v0, int v1 ) #
Clamps a value within the specified min and max limits.Arguments
- int v - Value to be clamped.
- int v0 - Minimum value.
- int v1 - Maximum value.
Return value
Clamped value.long Clamp ( long v, long v0, long v1 ) #
Clamps a value within the specified min and max limits.Arguments
- long v - Value to be clamped.
- long v0 - Minimum value.
- long v1 - Maximum value.
Return value
Clamped value.dvec2 Clamp ( dvec2 v, dvec2 v0, dvec2 v1 ) #
Clamps a value within the specified min and max limits.Arguments
- dvec2 v - Value to be clamped.
- dvec2 v0 - Minimum value.
- dvec2 v1 - Maximum value.
Return value
Clamped value.ivec2 Clamp ( ivec2 v, ivec2 v0, ivec2 v1 ) #
Clamps a value within the specified min and max limits.Arguments
- ivec2 v - The value.
- ivec2 v0 - Minimum value.
- ivec2 v1 - Maximum value.
Return value
Clamped value.vec2 Clamp ( vec2 v, vec2 v0, vec2 v1 ) #
Clamps a value within the specified min and max limits.Arguments
- vec2 v - Value to be clamped.
- vec2 v0 - Minimum value.
- vec2 v1 - Maximum value.
Return value
Clamped value.dvec3 Clamp ( dvec3 v, dvec3 v0, dvec3 v1 ) #
Clamps a value within the specified min and max limits.Arguments
- dvec3 v - Value to be clamped.
- dvec3 v0 - Minimum value.
- dvec3 v1 - Maximum value.
Return value
Clamped value.ivec3 Clamp ( ivec3 v, ivec3 v0, ivec3 v1 ) #
Clamps a value within the specified min and max limits.Arguments
- ivec3 v - Value to be clamped.
- ivec3 v0 - Minimum value.
- ivec3 v1 - Maximum value.
Return value
Clamped value.vec3 Clamp ( vec3 v, vec3 v0, vec3 v1 ) #
Clamps a value within the specified min and max limits.Arguments
- vec3 v - Value to be clamped.
- vec3 v0 - Minimum value.
- vec3 v1 - Maximum value.
Return value
Clamped value.bvec4 Clamp ( bvec4 v, bvec4 v0, bvec4 v1 ) #
Clamps a value within the specified min and max limits.Arguments
- bvec4 v - Value to be clamped.
- bvec4 v0 - Minimum value.
- bvec4 v1 - Maximum value.
Return value
Clamped value.dvec4 Clamp ( dvec4 v, dvec4 v0, dvec4 v1 ) #
Clamps a value within the specified min and max limits.Arguments
- dvec4 v - Value to be clamped.
- dvec4 v0 - Minimum value.
- dvec4 v1 - Maximum value.
Return value
Clamped value.ivec4 Clamp ( ivec4 v, ivec4 v0, ivec4 v1 ) #
Clamps a value within the specified min and max limits.Arguments
- ivec4 v - Value to be clamped.
- ivec4 v0 - Minimum value.
- ivec4 v1 - Maximum value.
Return value
Clamped value.vec4 Clamp ( vec4 v, vec4 v0, vec4 v1 ) #
Clamps a value within the specified min and max limits.Arguments
- vec4 v - Value to be clamped.
- vec4 v0 - Minimum value.
- vec4 v1 - Maximum value.
Return value
Clamped value.Compare ( float v0, float v1 ) #
Compares two scalars of the float type according to the degree of precision equal to 1.0e-6f.Arguments
- float v0 - First float scalar.
- float v1 - Second float scalar.
Return value
1 if v0 is equal to v1; otherwise, 0.Compare ( double v0, double v1 ) #
Compares two scalars of the double type according to the degree of precision equal to 1.0e-6f.Arguments
- double v0 - First double scalar.
- double v1 - Second double scalar.
Return value
1 if the v0 is equal to v1; otherwise, 0.Compare ( float v0, float v1, float epsilon ) #
Compares two scalars of the float type according to the specified degree of precision.Arguments
- float v0 - First scalar.
- float v1 - Second scalar.
- float epsilon - Epsilon (degree of precision).
Return value
1 if the v0 is equal to v1; otherwise, 0.Compare ( double v0, double v1, double epsilon ) #
Compares two scalars of the double type according to the specified degree of precision.Arguments
- double v0 - First scalar.
- double v1 - Second scalar.
- double epsilon - Epsilon (degree of precision).
Return value
1 if the v0 is equal to v1; otherwise, 0.int Compare ( vec2 v0, vec2 v1 ) #
Compares two vectors according to the degree of precision equal to 1.0e-6f.Arguments
- vec2 v0 - First vector.
- vec2 v1 - Second vector.
Return value
1 if v0 is equal to v1; otherwise, 0.int Compare ( vec2 v0, vec2 v1, float epsilon ) #
Compares two vectors according to the specified degree of precision.Arguments
- vec2 v0 - First vector.
- vec2 v1 - Second vector.
- float epsilon - Epsilon (degree of precision).
Return value
1 if v0 is equal to v1; otherwise, 0.int Compare ( dvec2 v0, dvec2 v1 ) #
Compares two vectors according to the degree of precision equal to 1.0e-6f.Arguments
- dvec2 v0 - First vector.
- dvec2 v1 - Second vector.
Return value
1 if the v0 is equal to v1; otherwise, 0.int Compare ( dvec2 v0, dvec2 v1, double epsilon ) #
Compares two vectors according to the specified degree of precision.Arguments
- dvec2 v0 - First vector.
- dvec2 v1 - Second vector.
- double epsilon - Epsilon (degree of precision).
Return value
1 if the v0 is equal to v1; otherwise, 0.int Compare ( vec3 v0, vec3 v1 ) #
Compares two vectors according to the degree of precision equal to 1.0e-6f.Arguments
- vec3 v0 - First vector.
- vec3 v1 - Second vector.
Return value
1 if the v0 is equal to v1; otherwise, 0.int Compare ( vec3 v0, vec3 v1, float epsilon ) #
Compares two vectors according to the specified degree of precision.Arguments
- vec3 v0 - First vector.
- vec3 v1 - Second vector.
- float epsilon - Epsilon (degree of precision).
Return value
1 if the v0 is equal to v1; otherwise, 0.int Compare ( dvec3 v0, dvec3 v1 ) #
Compares two vectors according to the degree of precision equal to 1.0e-6f.Arguments
- dvec3 v0 - First vector.
- dvec3 v1 - Second vector.
Return value
1 if the v0 is equal to v1; otherwise, 0.int Compare ( dvec3 v0, dvec3 v1, double epsilon ) #
Compares two vectors according to the specified degree of precision.Arguments
- dvec3 v0 - First vector.
- dvec3 v1 - Second vector.
- double epsilon - Epsilon (degree of precision).
Return value
1 if the v0 is equal to v1; otherwise, 0.int Compare ( vec4 v0, vec4 v1 ) #
Compares two vectors according to the degree of precision equal to 1.0e-6f.Arguments
- vec4 v0 - First vector.
- vec4 v1 - Second vector.
Return value
1 if the v0 is equal to v1; otherwise, 0.int Compare ( vec4 v0, vec4 v1, float epsilon ) #
Compares two vectors according to the specified degree of precision.Arguments
- vec4 v0 - First vector.
- vec4 v1 - Second vector.
- float epsilon - Epsilon (degree of precision).
Return value
1 if the v0 is equal to v1; otherwise, 0.int Compare ( dvec4 v0, dvec4 v1 ) #
Compares two vectors according to the degree of precision equal to 1.0e-6f.Arguments
- dvec4 v0 - First vector.
- dvec4 v1 - Second vector.
Return value
1 if the v0 is equal to v1; otherwise, 0.int Compare ( dvec4 v0, dvec4 v1, double epsilon ) #
Compares two vectors according to the specified degree of precision.Arguments
- dvec4 v0 - First vector.
- dvec4 v1 - Second vector.
- double epsilon - Epsilon (degree of precision).
Return value
1 if the v0 is equal to v1; otherwise, 0.int Compare ( quat q0, quat q1 ) #
Compares two quaternions according to the degree of precision equal to 1.0e-6f.Arguments
- quat q0 - First quaternion.
- quat q1 - Second quaternion.
Return value
1 if the q0 is equal to q1; otherwise, 0.int Compare ( quat q0, quat q1, float epsilon ) #
Compares two quaternions according to the specified degree of precision.Arguments
- quat q0 - First quaternion.
- quat q1 - Second quaternion.
- float epsilon - Epsilon (degree of precision).
Return value
1 if the q0 is equal to q1; otherwise, 0.int Compare ( mat3 m0, mat3 m1 ) #
Compares two matrices according to the degree of precision equal to 1.0e-6f.Arguments
- mat3 m0 - First matrix.
- mat3 m1 - Second matrix.
Return value
1 if the m0 is equal to m1; otherwise, 0.int Compare ( mat3 m0, mat3 m1, float epsilon ) #
Compares two matrices according to the specified degree of precision.Arguments
- mat3 m0 - First matrix.
- mat3 m1 - Second matrix.
- float epsilon - Epsilon (degree of precision).
Return value
1 if the m0 is equal to m1; otherwise, 0.int Compare ( mat4 m0, mat4 m1 ) #
Compares two matrices according to the degree of precision equal to 1.0e-6f.Arguments
- mat4 m0 - First matrix.
- mat4 m1 - Second matrix.
Return value
1 if the m0 is equal to m1; otherwise, 0.int Compare ( mat4 m0, mat4 m1, float epsilon ) #
Compares two matrices according to the specified degree of precision.Arguments
- mat4 m0 - First matrix.
- mat4 m1 - Second matrix.
- float epsilon - Epsilon (degree of precision).
Return value
1 if the m0 is equal to m1; otherwise, 0.int Compare ( dmat4 m0, dmat4 m1 ) #
Compares two matrices according to the degree of precision equal to 1.0e-6f.Arguments
- dmat4 m0 - First matrix.
- dmat4 m1 - Second matrix.
Return value
1 if the m0 is equal to m1; otherwise, 0.int Compare ( dmat4 m0, dmat4 m1, double epsilon ) #
Compares two matrices according to the specified degree of precision.Arguments
- dmat4 m0 - First matrix.
- dmat4 m1 - Second matrix.
- double epsilon - Epsilon (degree of precision).
Return value
1 if the m0 is equal to m1; otherwise, 0.quat Conjugate ( quat q ) #
Returns the conjugate of a given quaternion.Arguments
- quat q - Quaternion.
Return value
Conjugate of a given quaternion.float Cross ( vec2 v0, vec2 v1 ) #
Cross product of vectors.Arguments
- vec2 v0 - First vector.
- vec2 v1 - Second vector.
Return value
Cross product of the two 2d vectors: v0.x * v1.y - v0.y*v1.x.ivec3 Cross ( ivec3 v0, ivec3 v1 ) #
Cross product of vectors.Arguments
- ivec3 v0 - First vector.
- ivec3 v1 - Second vector.
Return value
Resulting vector.dvec3 Cross ( dvec3 v0, dvec3 v1 ) #
Cross product of vectors.Arguments
- dvec3 v0 - First vector.
- dvec3 v1 - Second vector.
Return value
Resulting vector.vec3 Cross ( vec3 v0, vec3 v1 ) #
Cross product of vectors.Arguments
- vec3 v0 - First vector.
- vec3 v1 - Second vector.
Return value
Resulting vector.void Cross ( out ivec3 ret, ivec3 v0, ivec3 v1 ) #
Cross product of vectors.Arguments
- out ivec3 ret - Output vector, to which the resulting vector will be put.
- ivec3 v0 - First vector.
- ivec3 v1 - Second vector.
Return value
void Cross ( out vec3 ret, vec3 v0, vec3 v1 ) #
Cross product of vectors.Arguments
- out vec3 ret - Output vector, to which the resulting vector will be put.
- vec3 v0 - First vector.
- vec3 v1 - Second vector.
Return value
void Cross ( out vec4 ret, vec3 v0, vec3 v1 ) #
Cross product of vectors.Arguments
- out vec4 ret - Output vector, to which the resulting vector will be put.
- vec3 v0 - First vector.
- vec3 v1 - Second vector.
Return value
void Cross ( out dvec3 ret, dvec3 v0, dvec3 v1 ) #
Cross product of vectors.Arguments
- out dvec3 ret - Output vector, to which the resulting vector will be put.
- dvec3 v0 - First vector.
- dvec3 v1 - Second vector.
Return value
void Cross ( out vec4 ret, dvec3 v0, dvec3 v1 ) #
Cross product of vectors.Arguments
- out vec4 ret - Output vector, to which the resulting vector will be put.
- dvec3 v0 - First vector.
- dvec3 v1 - Second vector.
Return value
double Dot ( dvec2 v0, dvec2 v1 ) #
Dot product of vectors.Arguments
- dvec2 v0 - First vector.
- dvec2 v1 - Second vector.
Return value
Resulting scalar.float Dot ( vec3 v0, vec4 v1 ) #
Dot product of vectors. In this case, w component of the four-component vector is added to the dot product of first three components of vectors.Arguments
- vec3 v0 - First vector.
- vec4 v1 - Second vector.
Return value
Resulting scalar.float Dot ( vec4 v0, vec3 v1 ) #
Dot product of vectors. In this case, w component of the four-component vector is added to the dot product of first three components of vectors.Arguments
- vec4 v0 - First vector.
- vec3 v1 - Second vector.
Return value
Resulting scalar.float Dot ( vec4 v0, vec4 v1 ) #
Dot product of vectors.Arguments
- vec4 v0 - First vector.
- vec4 v1 - Second vector.
Return value
Resulting scalar.float Dot ( vec3 v0, vec3 v1 ) #
Dot product of vectors.Arguments
- vec3 v0 - First vector.
- vec3 v1 - Second vector.
Return value
Resulting scalar.float Dot ( vec2 v0, vec2 v1 ) #
Dot product of vectors.Arguments
- vec2 v0 - First vector.
- vec2 v1 - Second vector.
Return value
Resulting scalar.int Dot ( ivec3 v0, ivec3 v1 ) #
Dot product of vectors.Arguments
- ivec3 v0 - First vector.
- ivec3 v1 - Second vector.
Return value
Resulting scalar.int Dot ( ivec2 v0, ivec2 v1 ) #
Dot product of vectors.Arguments
- ivec2 v0 - First vector.
- ivec2 v1 - Second vector.
Return value
Resulting scalar.int Dot ( ivec4 v0, ivec3 v1 ) #
Dot product of vectors. In this case, w component of the four-component vector is added to the dot product of first three components of vectors.Arguments
- ivec4 v0 - First vector.
- ivec3 v1 - Second vector.
Return value
Resulting scalar.int Dot ( ivec4 v0, ivec4 v1 ) #
Dot product of vectors.Arguments
- ivec4 v0 - First vector.
- ivec4 v1 - Second vector.
Return value
Resulting scalar.double Dot ( dvec3 v0, dvec3 v1 ) #
Dot product of vectors.Arguments
- dvec3 v0 - First vector.
- dvec3 v1 - Second vector.
Return value
Resulting scalar.double Dot ( dvec3 v0, dvec4 v1 ) #
Dot product of vectors. In this case, w component of the four-component vector is added to the dot product of first three components of vectors.Arguments
- dvec3 v0 - First vector.
- dvec4 v1 - Second vector.
Return value
Resulting scalar.double Dot ( dvec4 v0, dvec3 v1 ) #
Dot product of vectors. In this case, w component of the four-component vector is added to the dot product of first three components of vectors.Arguments
- dvec4 v0 - First vector.
- dvec3 v1 - Second vector.
Return value
Resulting scalar.double Dot ( dvec4 v0, dvec4 v1 ) #
Dot product of vectors.Arguments
- dvec4 v0 - First vector.
- dvec4 v1 - Second vector.
Return value
Resulting scalar.double Dot3 ( dvec3 v0, dvec4 v1 ) #
Dot product of three components of vectors. W components of four-component vectors are ignored.Source code (C#)
float a = MathLib.Dot3(new vec3(1, 2, 3), new vec4(1, 2, 3, 4));
double b = MathLib.Dot3(new dvec4(1, 2, 3, 4), new dvec4(1, 2, 3, 4));
/*
result is:
a = 14.000000
b = 14.000000
*/Arguments
- dvec3 v0 - First vector.
- dvec4 v1 - Second vector.
Return value
Resulting scalar.double Dot3 ( dvec4 v0, dvec3 v1 ) #
Dot product of three components of vectors. W components of four-component vectors are ignored.Source code (C#)
float a = MathLib.Dot3(new vec3(1, 2, 3), new vec4(1, 2, 3, 4));
double b = MathLib.Dot3(new dvec4(1, 2, 3, 4), new dvec4(1, 2, 3, 4));
/*
result is:
a = 14.000000
b = 14.000000
*/Arguments
- dvec4 v0 - First vector.
- dvec3 v1 - Second vector.
Return value
Resulting scalar.double Dot3 ( dvec4 v0, dvec4 v1 ) #
Dot product of three components of vectors. W components of four-component vectors are ignored.Source code (C#)
float a = MathLib.Dot3(new vec3(1, 2, 3), new vec4(1, 2, 3, 4));
double b = MathLib.Dot3(new dvec4(1, 2, 3, 4), new dvec4(1, 2, 3, 4));
/*
result is:
a = 14.000000
b = 14.000000
*/Arguments
- dvec4 v0 - First vector.
- dvec4 v1 - Second vector.
Return value
Resulting scalar.float Dot3 ( vec3 v0, vec4 v1 ) #
Dot product of three components of vectors. W components of four-component vectors are ignored.Source code (C#)
float a = MathLib.Dot3(new vec3(1, 2, 3), new vec4(1, 2, 3, 4));
double b = MathLib.Dot3(new dvec4(1, 2, 3, 4), new dvec4(1, 2, 3, 4));
/*
result is:
a = 14.000000
b = 14.000000
*/Arguments
- vec3 v0 - First vector.
- vec4 v1 - Second vector.
Return value
Resulting scalar.float Dot3 ( vec4 v0, vec3 v1 ) #
Dot product of three components of vectors. W components of four-component vectors are ignored.Source code (C#)
float a = MathLib.Dot3(new vec3(1, 2, 3), new vec4(1, 2, 3, 4));
double b = MathLib.Dot3(new dvec4(1, 2, 3, 4), new dvec4(1, 2, 3, 4));
/*
result is:
a = 14.000000
b = 14.000000
*/Arguments
- vec4 v0 - First vector.
- vec3 v1 - Second vector.
Return value
Resulting scalar.float Dot3 ( vec4 v0, vec4 v1 ) #
Dot product of three components of vectors. W components of four-component vectors are ignored.Source code (C#)
float a = MathLib.Dot3(new vec3(1, 2, 3), new vec4(1, 2, 3, 4));
double b = MathLib.Dot3(new dvec4(1, 2, 3, 4), new dvec4(1, 2, 3, 4));
/*
result is:
a = 14.000000
b = 14.000000
*/Arguments
- vec4 v0 - First vector.
- vec4 v1 - Second vector.
Return value
Resulting scalar.double Floor ( double v ) #
Rounds an argument down to the nearest integer.Source code
float a = floor(2.3) // a = 2.0Arguments
- double v - Argument.
Return value
Largest integer value not greater than arg.float Floor ( float v ) #
Rounds an argument down to the nearest integer.Source code
double a = floor(2.3) // a = 2.0Arguments
- float v - Argument.
Return value
Largest integer value not greater than arg.float Frac ( float v ) #
Returns the fractional part of the argument.Source code
float a = frac(3.141593); // a = 0.141593Arguments
- float v - Argument.
Return value
Fractional part of the argument.double Frac ( double v ) #
Returns the fractional part of the argument.Source code
double a = frac(3.141593); // a = 0.141593Arguments
- double v - Argument.
Return value
Fractional part of the argument.float GetAngle ( quat q0, quat q1 ) #
Returns the angle (in degrees) between the given first and second quaternions. The angle returned is the unsigned acute angle between the two quaternions. This means the smaller of the two possible angles is used.Arguments
- quat q0 - First quaternion (from which the angular difference is measured).
- quat q1 - Second quaternion (to which the angular difference is measured).
Return value
Angle between the given quaternions, in degrees within the range [0.0; 180.0].float GetAngle ( vec3 v0, vec3 v1 ) #
Returns the angle (in degrees) between the given first and second vectors. The angle returned is the unsigned acute angle between the two vectors. This means the smaller of the two possible angles is used.Arguments
- vec3 v0 - First vector (from which the angular difference is measured).
- vec3 v1 - Second vector (to which the angular difference is measured).
Return value
Angle between the given vectors, in degrees within the range [0.0; 180.0].float GetAngle ( vec3 v0, vec3 v1, vec3 up ) #
Returns the signed angle (in degrees) between the given first and second vectors relative to the specified "up" vector.Arguments
- vec3 v0 - First vector (from which the angular difference is measured).
- vec3 v1 - Second vector (to which the angular difference is measured).
- vec3 up - Up vector, around which the other two vectors are rotated.
Return value
Angle between the given vectors, in degrees within the range [-180.0; 180.0].float Gradient4 ( float x, vec4 gradient ) #
Returns a gradient value for the specified argument using four key components. The gradient value is determined as follows:Source code
See the
smoothstep() method.smoothstep(gradient.x, gradient.y, x) - smoothstep(gradient.z, gradient.w, x);Arguments
- float x - Argument.
- vec4 gradient - Vector with four key components.
Return value
Gradient value.float Length ( vec2 v ) #
Calculates the length of a given vector.Arguments
- vec2 v - Vector.
Return value
Vector length.double Length ( dvec2 v ) #
Calculates the length of a given vector.Arguments
- dvec2 v - Vector.
Return value
Vector length.float Length ( vec3 v ) #
Calculates the length of a given vector.Arguments
- vec3 v - Vector.
Return value
Vector length.double Length ( dvec3 v ) #
Calculates the length of a given vector.Arguments
- dvec3 v - Vector.
Return value
Vector length.float Length ( vec4 v ) #
Calculates the length of a given vector.Arguments
- vec4 v - Vector.
Return value
Vector length.double Length ( dvec4 v ) #
Calculates the length of a given vector.Arguments
- dvec4 v - Vector.
Return value
Vector length.float Length2 ( vec2 v ) #
Calculates the squared length of a given vector. This method is much faster than length() - the calculation is basically the same only without the slow Sqrt call. If you are using lengths simply to compare distances, then it is faster to compare squared lengths against the squares of distances as the comparison gives the same result.Arguments
- vec2 v - Vector.
Return value
Squared length of the vector (X 2 + Y 2 + Z 2).double Length2 ( dvec2 v ) #
Calculates the squared length of a given vector. This method is much faster than length() - the calculation is basically the same only without the slow Sqrt call. If you are using lengths simply to compare distances, then it is faster to compare squared lengths against the squares of distances as the comparison gives the same result.Arguments
- dvec2 v - Vector.
Return value
Squared length of the vector (X 2 + Y 2 + Z 2).int Length2 ( ivec2 v ) #
Calculates the squared length of a given vector. If you are using lengths simply to compare distances, then it is faster to compare squared lengths against the squares of distances as the comparison gives the same result.Arguments
- ivec2 v - Vector.
Return value
Squared length of the vector (X 2 + Y 2 + Z 2).float Length2 ( vec3 v ) #
Calculates the squared length of a given vector. This method is much faster than length() - the calculation is basically the same only without the slow Sqrt call. If you are using lengths simply to compare distances, then it is faster to compare squared lengths against the squares of distances as the comparison gives the same result.Arguments
- vec3 v - Vector.
Return value
Squared length of the vector (X 2 + Y 2 + Z 2).double Length2 ( dvec3 v ) #
Calculates the squared length of a given vector. This method is much faster than length() - the calculation is basically the same only without the slow Sqrt call. If you are using lengths simply to compare distances, then it is faster to compare squared lengths against the squares of distances as the comparison gives the same result.Arguments
- dvec3 v - Vector.
Return value
Squared length of the vector (X 2 + Y 2 + Z 2).int Length2 ( ivec3 v ) #
Calculates the squared length of a given vector. If you are using lengths simply to compare distances, then it is faster to compare squared lengths against the squares of distances as the comparison gives the same result.Arguments
- ivec3 v - Vector.
Return value
Squared length of the vector (X 2 + Y 2 + Z 2).float Length2 ( vec4 v ) #
Calculates the squared length of a given vector. This method is much faster than length() - the calculation is basically the same only without the slow Sqrt call. If you are using lengths simply to compare distances, then it is faster to compare squared lengths against the squares of distances as the comparison gives the same result.Arguments
- vec4 v - Vector.
Return value
Squared length of the vector (X 2 + Y 2 + Z 2).double Length2 ( dvec4 v ) #
Calculates the squared length of a given vector. This method is much faster than length() - the calculation is basically the same only without the slow Sqrt call. If you are using lengths simply to compare distances, then it is faster to compare squared lengths against the squares of distances as the comparison gives the same result.Arguments
- dvec4 v - Vector.
Return value
Squared length of the vector (X 2 + Y 2 + Z 2).int Length2 ( ivec4 v ) #
Calculates the squared length of a given vector. If you are using lengths simply to compare distances, then it is faster to compare squared lengths against the squares of distances as the comparison gives the same result.Arguments
- ivec4 v - Vector.
Return value
Squared length of the vector (X 2 + Y 2 + Z 2).float Lerp ( float v0, float v1, float k ) #
Returns the interpolated value according to the following formula: v0 + (v 1 - v 0) * k .Arguments
- float v0 - First float value.
- float v1 - Second float value.
- float k - Interpolation coefficient.
Return value
Interpolated value.double Lerp ( double v0, double v1, double k ) #
Returns the interpolated value according to the following formula: v0 + (v 1 - v 0) * k .Arguments
- double v0 - First double value.
- double v1 - Second double value.
- double k - Interpolation coefficient.
Return value
Interpolated value.int Lerp ( int v0, int v1, int k ) #
Returns the interpolated value according to the following formula: v0 + (v 1 - v 0) * k .Arguments
- int v0 - First int value.
- int v1 - Second int value.
- int k - Interpolation coefficient.
Return value
Interpolated value.vec2 Lerp ( vec2 v0, vec2 v1, float k ) #
Returns the interpolated vector according to the following formula: v0 + (v 1 - v 0) * k .Arguments
- vec2 v0 - First vector.
- vec2 v1 - Second vector.
- float k - Interpolation coefficient.
Return value
Interpolated vector.vec3 Lerp ( vec3 v0, vec3 v1, float k ) #
Returns the interpolated vector according to the following formula: v0 + (v 1 - v 0) * k .Arguments
- vec3 v0 - First vector.
- vec3 v1 - Second vector.
- float k - Interpolation coefficient.
Return value
Interpolated vector.vec4 Lerp ( vec4 v0, vec4 v1, float k ) #
Returns the interpolated vector according to the following formula: v0 + (v 1 - v 0) * k .Arguments
- vec4 v0 - First vector.
- vec4 v1 - Second vector.
- float k - Interpolation coefficient.
Return value
Interpolated vector.dvec2 Lerp ( dvec2 v0, dvec2 v1, double k ) #
Returns the interpolated vector according to the following formula: v0 + (v 1 - v 0) * k .Arguments
- dvec2 v0 - First vector.
- dvec2 v1 - Second vector.
- double k - Interpolation coefficient.
Return value
Interpolated vector.dvec3 Lerp ( dvec3 v0, dvec3 v1, double k ) #
Returns the interpolated vector according to the following formula: v0 + (v 1 - v 0) * k .Arguments
- dvec3 v0 - First vector.
- dvec3 v1 - Second vector.
- double k - Interpolation coefficient.
Return value
Interpolated vector.dvec4 Lerp ( dvec4 v0, dvec4 v1, double k ) #
Returns the interpolated vector according to the following formula: v0 + (v 1 - v 0) * k .Arguments
- dvec4 v0 - First vector.
- dvec4 v1 - Second vector.
- double k - Interpolation coefficient.
Return value
Interpolated vector.ivec2 Lerp ( ivec2 v0, ivec2 v1, int k ) #
Returns the interpolated vector according to the following formula: v0 + (v 1 - v 0) * k .Arguments
- ivec2 v0 - First vector.
- ivec2 v1 - Second vector.
- int k - Interpolation coefficient.
Return value
Interpolated vector.ivec3 Lerp ( ivec3 v0, ivec3 v1, int k ) #
Returns the interpolated vector according to the following formula: v0 + (v 1 - v 0) * k .Arguments
- ivec3 v0 - First vector.
- ivec3 v1 - Second vector.
- int k - Interpolation coefficient.
Return value
Interpolated vector.ivec4 Lerp ( ivec4 v0, ivec4 v1, int k ) #
Returns the interpolated vector according to the following formula: v0 + (v 1 - v 0) * k .Arguments
- ivec4 v0 - First vector.
- ivec4 v1 - Second vector.
- int k - Interpolation coefficient.
Return value
Interpolated vector.Max ( float v0, float v1 ) #
Returns the maximum value.Arguments
- float v0 - First value.
- float v1 - Second value.
Return value
Maximum value.Max ( double v0, double v1 ) #
Returns the maximum value.Arguments
- double v0 - First value.
- double v1 - Second value.
Return value
Maximum value.Max ( int v0, int v1 ) #
Returns the maximum value.Arguments
- int v0 - First value.
- int v1 - Second value.
Return value
Maximum value.long Max ( long v0, long v1 ) #
Returns the maximum value.Arguments
- long v0 - First value.
- long v1 - Second value.
Return value
Maximum value.vec2 Max ( vec2 v0, vec2 v1 ) #
Returns the maximum value.Arguments
- vec2 v0 - First value.
- vec2 v1 - Second value.
Return value
Maximum value.vec3 Max ( vec3 v0, vec3 v1 ) #
Returns the maximum value.Arguments
- vec3 v0 - First value.
- vec3 v1 - Second value.
Return value
Maximum value.vec4 Max ( vec4 v0, vec4 v1 ) #
Returns the maximum value.Arguments
- vec4 v0 - First value.
- vec4 v1 - Second value.
Return value
Maximum value.dvec2 Max ( dvec2 v0, dvec2 v1 ) #
Returns the maximum value.Arguments
- dvec2 v0 - First value.
- dvec2 v1 - Second value.
Return value
Maximum value.dvec3 Max ( dvec3 v0, dvec3 v1 ) #
Returns the maximum value.Arguments
- dvec3 v0 - First value.
- dvec3 v1 - Second value.
Return value
Maximum value.dvec4 Max ( dvec4 v0, dvec4 v1 ) #
Returns the maximum value.Arguments
- dvec4 v0 - First value.
- dvec4 v1 - Second value.
Return value
Maximum value.ivec2 Max ( ivec2 v0, ivec2 v1 ) #
Returns the maximum value.Arguments
- ivec2 v0 - First value.
- ivec2 v1 - Second value.
Return value
Maximum value.ivec3 Max ( ivec3 v0, ivec3 v1 ) #
Returns the maximum value.Arguments
- ivec3 v0 - First value.
- ivec3 v1 - Second value.
Return value
Maximum value.ivec4 Max ( ivec4 v0, ivec4 v1 ) #
Returns the maximum value.Arguments
- ivec4 v0 - First value.
- ivec4 v1 - Second value.
Return value
Maximum value.bvec4 Max ( bvec4 v0, bvec4 v1 ) #
Returns the maximum value.Arguments
- bvec4 v0 - First value.
- bvec4 v1 - Second value.
Return value
Maximum value.float Min ( float v0, float v1 ) #
Returns the minimum value.Arguments
- float v0 - First value.
- float v1 - Second value.
Return value
Minimum value.double Min ( double v0, double v1 ) #
Returns the minimum value.Arguments
- double v0 - First value.
- double v1 - Second value.
Return value
Minimum value.int Min ( int v0, int v1 ) #
Returns the minimum value.Arguments
- int v0 - First value.
- int v1 - Second value.
Return value
Minimum value.long Min ( long v0, long v1 ) #
Returns the minimum value.Arguments
- long v0 - First value.
- long v1 - Second value.
Return value
Minimum value.vec2 Min ( vec2 v0, vec2 v1 ) #
Returns the minimum value.Arguments
- vec2 v0 - First value.
- vec2 v1 - Second value.
Return value
Minimum value.vec3 Min ( vec3 v0, vec3 v1 ) #
Returns the minimum value.Arguments
- vec3 v0 - First value.
- vec3 v1 - Second value.
Return value
Minimum value.vec4 Min ( vec4 v0, vec4 v1 ) #
Returns the minimum value.Arguments
- vec4 v0 - First value.
- vec4 v1 - Second value.
Return value
Minimum value.dvec2 Min ( dvec2 v0, dvec2 v1 ) #
Returns the minimum value.Arguments
- dvec2 v0 - First value.
- dvec2 v1 - Second value.
Return value
Minimum value.dvec3 Min ( dvec3 v0, dvec3 v1 ) #
Returns the minimum value.Arguments
- dvec3 v0 - First value.
- dvec3 v1 - Second value.
Return value
Minimum value.dvec4 Min ( dvec4 v0, dvec4 v1 ) #
Returns the minimum value.Arguments
- dvec4 v0 - First value.
- dvec4 v1 - Second value.
Return value
Minimum value.ivec2 Min ( ivec2 v0, ivec2 v1 ) #
Returns the minimum value.Arguments
- ivec2 v0 - First value.
- ivec2 v1 - Second value.
Return value
Minimum value.ivec3 Min ( ivec3 v0, ivec3 v1 ) #
Returns the minimum value.Arguments
- ivec3 v0 - First value.
- ivec3 v1 - Second value.
Return value
Minimum value.ivec4 Min ( ivec4 v0, ivec4 v1 ) #
Returns the minimum value.Arguments
- ivec4 v0 - First value.
- ivec4 v1 - Second value.
Return value
Minimum value.bvec4 Min ( bvec4 v0, bvec4 v1 ) #
Returns the minimum value.Arguments
- bvec4 v0 - First value.
- bvec4 v1 - Second value.
Return value
Minimum value.int Npot ( int arg ) #
Rounds up to the nearest power of two value.Arguments
- int arg - Argument.
Return value
The nearest upper power of 2 number.float Rcp ( float v ) #
Returns the reciprocal of the specified argument.Arguments
- float v - Argument.
Return value
Reciprocal of the argument.double Rcp ( double v ) #
Returns the reciprocal of the specified argument.Arguments
- double v - Argument.
Return value
Reciprocal of the argument.double Round ( double v ) #
Rounds an argument to the nearest integer value.Notice
In halfway cases, when an argument has a fractional part of exactly 0.5, the function rounds away from zero to the integer with larger magnitude.
- 3.5 -> 4
- - 3.5 -> - 4
Source code
double a = round(2.3) // a = 2.0
double b = round(5.5) // b = 6.0
double c = round(-5.5) // c = -6.0Arguments
- double v - Argument.
Return value
Nearest integer value to the argument.float Round ( float v ) #
Rounds an argument to the nearest integer value.Notice
In halfway cases, when an argument has a fractional part of exactly 0.5, the function rounds away from zero to the integer with larger magnitude.
- 3.5 -> 4
- - 3.5 -> - 4
Source code
float a = round(2.3) // a = 2.0
float b = round(5.5) // b = 6.0
float c = round(-5.5) // c = -6.0Arguments
- float v - Argument.
Return value
Nearest integer value to the argument.float Saturate ( float v ) #
Clamps the value within the range of 0.0 to 1.0.Arguments
- float v - Argument.
Return value
Argument value clamped within the range of 0.0 to 1.0.double Saturate ( double v ) #
Clamps the value within the range of 0.0 to 1.0.Arguments
- double v - Argument.
Return value
Argument value clamped within the range of 0.0 to 1.0.dvec2 Saturate ( dvec2 v ) #
Clamps the values of vector components within the range of 0.0 to 1.0.Arguments
- dvec2 v
vec2 Saturate ( vec2 v ) #
Clamps the values of vector components within the range of 0.0 to 1.0.Arguments
- vec2 v - Vector.
Return value
Vector with components clamped within the range of 0.0 to 1.0.dvec3 Saturate ( dvec3 v ) #
Clamps the values of vector components within the range of 0.0 to 1.0.Arguments
- dvec3 v - Vector.
Return value
Vector with components clamped within the range of 0.0 to 1.0.vec3 Saturate ( vec3 v ) #
Clamps the values of vector components within the range of 0.0 to 1.0.Arguments
- vec3 v - Vector.
Return value
Vector with components clamped within the range of 0.0 to 1.0.dvec4 Saturate ( dvec4 v ) #
Clamps the values of vector components within the range of 0.0 to 1.0.Arguments
- dvec4 v - Vector.
Return value
Vector with components clamped within the range of 0.0 to 1.0.vec4 Saturate ( vec4 v ) #
Clamps the values of vector components within the range of 0.0 to 1.0.Arguments
- vec4 v - Vector.
Return value
Vector with components clamped within the range of 0.0 to 1.0.float Sign ( float v ) #
Returns the sign of the argument.Arguments
- float v - Argument.
Return value
Sign of the argument. 1.0 if v >= 0.0 ; -1.0 if v < 0.0.double Sign ( double v ) #
Returns the sign of the argument.Arguments
- double v - Argument.
Return value
Sign of the argument. 1.0 if v >= 0.0 ; -1.0 if v < 0.0.int Udiv ( int x, int y ) #
Performs integer division with rounding up.Arguments
- int x - First argument.
- int y - Second argument.
Return value
The rounded up quotient of two arguments that satisfies the following condition: y * z >= x.quat Slerp ( quat q0, quat q1, float k ) #
Spherical interpolation between two given quaternions.Arguments
- quat q0 - The value of the first quaternion.
- quat q1 - The value of the second quaternion.
- float k - The current position (from 0 to 1).
Return value
Resulting quaternion.Last update:
2020-04-30
Help improve this article
Was this article helpful?
(or select a word/phrase and press Ctrl+Enter)