| Method |
Description |
| abs | Returns the absolute value of a int value. |
| acos | Returns the arccosine of a float value. |
| AffineTransform | Returns an AffineTransform constructed from a translation represented by a float3 vector and rotation represented by a unit quaternion. |
| all | Returns true if all components of the input bool2 vector are true, false otherwise. |
| angle | Returns the angle in radians between two unit quaternions. |
| any | Returns true if any component of the input bool2 vector is true, false otherwise. |
| asdouble | Returns the bit pattern of a long as a double. |
| asfloat | Returns the bit pattern of an int as a float. |
| asin | Returns the arcsine of a float value. |
| asint | Returns the bit pattern of a uint as an int. |
| aslong | Returns the bit pattern of a ulong as a long. |
| asuint | Returns the bit pattern of an int as a uint. |
| asulong | Returns the bit pattern of a long as a ulong. |
| atan | Returns the arctangent of a float value. |
| atan2 | Returns the 2-argument arctangent of a pair of float values. |
| back |
Unity's back axis (0, 0, -1).
|
| bitmask |
Returns a bitmask representation of a bool4. Storing one 1 bit per component
in LSB order, from lower to higher bits (so 4 bits in total).
The component x is stored at bit 0,
The component y is stored at bit 1,
The component z is stored at bit 2,
The component w is stored at bit 3
The bool4(x = true, y = true, z = false, w = true) would produce the value 1011 = 0xB
|
| bool2 | Returns a bool2 vector constructed from two bool values. |
| bool2x2 | Returns a bool2x2 matrix constructed from two bool2 vectors. |
| bool2x3 | Returns a bool2x3 matrix constructed from three bool2 vectors. |
| bool2x4 | Returns a bool2x4 matrix constructed from four bool2 vectors. |
| bool3 | Returns a bool3 vector constructed from three bool values. |
| bool3x2 | Returns a bool3x2 matrix constructed from two bool3 vectors. |
| bool3x3 | Returns a bool3x3 matrix constructed from three bool3 vectors. |
| bool3x4 | Returns a bool3x4 matrix constructed from four bool3 vectors. |
| bool4 | Returns a bool4 vector constructed from four bool values. |
| bool4x2 | Returns a bool4x2 matrix constructed from two bool4 vectors. |
| bool4x3 | Returns a bool4x3 matrix constructed from three bool4 vectors. |
| bool4x4 | Returns a bool4x4 matrix constructed from four bool4 vectors. |
| ceil | Returns the result of rounding a float value up to the nearest integral value greater or equal to the original value. |
| ceillog2 |
Computes the ceiling of the base-2 logarithm of x.
|
| ceilpow2 | Returns the smallest power of two greater than or equal to the input. |
| chgsign | Change the sign of x based on the most significant bit of y [msb(y) ? -x : x]. |
| clamp | Returns the result of clamping the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are int values. |
| cmax | Returns the maximum component of an int2 vector. |
| cmin | Returns the minimum component of an int2 vector. |
| compress |
Packs components with an enabled mask to the left.
|
| conjugate | Returns the conjugate of a quaternion value. |
| cos | Returns the cosine of a float value. |
| cosh | Returns the hyperbolic cosine of a float value. |
| countbits | Returns number of 1-bits in the binary representation of an int value. Also known as the Hamming weight, popcnt on x86, and vcnt on ARM. |
| cross | Returns the cross product of two float3 vectors. |
| csum | Returns the horizontal sum of components of an int2 vector. |
| decompose | Decomposes the AffineTransform in translation, rotation and scale. |
| degrees | Returns the result of converting a double value from radians to degrees. |
| determinant | Returns the determinant of a double2x2 matrix. |
| distance | Returns the distance between two float values. |
| distancesq | Returns the squared distance between two float values. |
| dot | Returns the dot product of two int values. Equivalent to multiplication. |
| double2 | Returns a double2 vector constructed from two double values. |
| double2x2 | Returns a double2x2 matrix constructed from two double2 vectors. |
| double2x3 | Returns a double2x3 matrix constructed from three double2 vectors. |
| double2x4 | Returns a double2x4 matrix constructed from four double2 vectors. |
| double3 | Returns a double3 vector constructed from three double values. |
| double3x2 | Returns a double3x2 matrix constructed from two double3 vectors. |
| double3x3 | Returns a double3x3 matrix constructed from three double3 vectors. |
| double3x4 | Returns a double3x4 matrix constructed from four double3 vectors. |
| double4 | Returns a double4 vector constructed from four double values. |
| double4x2 | Returns a double4x2 matrix constructed from two double4 vectors. |
| double4x3 | Returns a double4x3 matrix constructed from three double4 vectors. |
| double4x4 | Returns a double4x4 matrix constructed from four double4 vectors. |
| down |
Unity's down axis (0, -1, 0).
|
| Euler |
Returns the Euler angle representation of the quaternion. The returned angles depend on the specified order to apply the
three rotations around the principal axes. All rotation angles are in radians and clockwise when looking along the
rotation axis towards the origin.
When the rotation order is known at compile time, to get the best performance you should use the specific
Euler rotation constructors such as EulerZXY(...).
|
| EulerXYZ |
Returns the Euler angle representation of the quaternion following the XYZ rotation order.
All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin.
|
| EulerXZY |
Returns the Euler angle representation of the quaternion following the XZY rotation order.
All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin.
|
| EulerYXZ |
Returns the Euler angle representation of the quaternion following the YXZ rotation order.
All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin.
|
| EulerYZX |
Returns the Euler angle representation of the quaternion following the YZX rotation order.
All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin.
|
| EulerZXY |
Returns the Euler angle representation of the quaternion following the ZXY rotation order.
All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin.
|
| EulerZYX |
Returns the Euler angle representation of the quaternion following the ZYX rotation order.
All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin.
|
| exp | Returns the base-e exponential of x. |
| exp10 | Returns the base-10 exponential of x. |
| exp2 | Returns the base-2 exponential of x. |
| f16tof32 | Returns the floating point representation of a half-precision floating point value. |
| f32tof16 | Returns the result converting a float value to its nearest half-precision floating point representation. |
| faceforward | Conditionally flips a vector n if two vectors i and ng are pointing in the same direction. Returns n if dot(i, ng) < 0, -n otherwise. |
| fastinverse | Fast matrix inverse for rigid transforms (orthonormal basis and translation) |
| float2 | Returns a float2 vector constructed from two float values. |
| float2x2 | Returns a float2x2 matrix constructed from two float2 vectors. |
| float2x3 | Returns a float2x3 matrix constructed from three float2 vectors. |
| float2x4 | Returns a float2x4 matrix constructed from four float2 vectors. |
| float3 | Returns a float3 vector constructed from three float values. |
| float3x2 | Returns a float3x2 matrix constructed from two float3 vectors. |
| float3x3 | Returns a float3x3 matrix constructed from three float3 vectors. |
| float3x4 | Returns a float3x4 matrix constructed from an AffineTransform. |
| float4 | Returns a float4 vector constructed from four float values. |
| float4x2 | Returns a float4x2 matrix constructed from two float4 vectors. |
| float4x3 | Returns a float4x3 matrix constructed from three float4 vectors. |
| float4x4 | Returns a float4x4 matrix constructed from an AffineTransform. |
| floor | Returns the result of rounding a float value up to the nearest integral value less or equal to the original value. |
| floorlog2 |
Computes the floor of the base-2 logarithm of x.
|
| fmod | Returns the floating point remainder of x/y. |
| forward |
Unity's forward axis (0, 0, 1).
|
| frac | Returns the fractional part of a float value. |
| half | Returns a half value constructed from a half values. |
| half2 | Returns a half2 vector constructed from two half values. |
| half3 | Returns a half3 vector constructed from three half values. |
| half4 | Returns a half4 vector constructed from four half values. |
| hash | Returns a uint hash code of an AffineTransform. |
| hashwide |
Returns a uint4 vector hash code of an AffineTransform.
When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
that are only reduced to a narrow uint hash at the very end instead of at every step.
|
| int2 | Returns a int2 vector constructed from two int values. |
| int2x2 | Returns a int2x2 matrix constructed from two int2 vectors. |
| int2x3 | Returns a int2x3 matrix constructed from three int2 vectors. |
| int2x4 | Returns a int2x4 matrix constructed from four int2 vectors. |
| int3 | Returns a int3 vector constructed from three int values. |
| int3x2 | Returns a int3x2 matrix constructed from two int3 vectors. |
| int3x3 | Returns a int3x3 matrix constructed from three int3 vectors. |
| int3x4 | Returns a int3x4 matrix constructed from four int3 vectors. |
| int4 | Returns a int4 vector constructed from four int values. |
| int4x2 | Returns a int4x2 matrix constructed from two int4 vectors. |
| int4x3 | Returns a int4x3 matrix constructed from three int4 vectors. |
| int4x4 | Returns a int4x4 matrix constructed from four int4 vectors. |
| inverse | Returns the inverse of an AffineTransform. |
| isfinite | Returns true if the input float is a finite floating point value, false otherwise. |
| isinf | Returns true if the input float is an infinite floating point value, false otherwise. |
| isnan | Returns true if the input float is a NaN (not a number) floating point value, false otherwise. |
| ispow2 |
Checks if the input is a power of two.
|
| left |
Unity's left axis (-1, 0, 0).
|
| length | Returns the length of a float value. Equivalent to the absolute value. |
| lengthsq | Returns the squared length of a float value. Equivalent to squaring the value. |
| lerp | Returns the result of linearly interpolating from start to end using the interpolation parameter t. |
| log | Returns the natural logarithm of a float value. |
| log10 | Returns the base-10 logarithm of a float value. |
| log2 | Returns the base-2 logarithm of a float value. |
| lzcnt | Returns the componentwise number of leading zeros in the binary representations of an int vector. |
| mad | Returns the result of a multiply-add operation (a * b + c) on 3 int values. |
| max | Returns the maximum of two int values. |
| min | Returns the minimum of two int values. |
| modf | Splits a float value into an integral part i and a fractional part that gets returned. Both parts take the sign of the input. |
| mul | Returns the result of transforming the AffineTransform b by the AffineTransform a. |
| mulScale |
Matrix columns multiplied by scale components
m.c0.x " s.x | m.c1.x " s.y | m.c2.x " s.z
m.c0.y " s.x | m.c1.y " s.y | m.c2.y " s.z
m.c0.z " s.x | m.c1.z " s.y | m.c2.z * s.z
|
| nlerp | Returns the result of a normalized linear interpolation between two quaternions q1 and a2 using an interpolation parameter t. |
| normalize | Returns a normalized version of the float2 vector x by scaling it by 1 / length(x). |
| normalizesafe |
Returns a safe normalized version of the float2 vector x by scaling it by 1 / length(x).
Returns the given default value when 1 / length(x) does not produce a finite number.
|
| orthonormal_basis |
Generate an orthonormal basis given a single unit length normal vector.
|
| pow | Returns x raised to the power y. |
| project |
Compute vector projection of a onto b.
|
| projectsafe |
Compute vector projection of a onto b. If result is not finite, then return the default value instead.
|
| quaternion | Returns a quaternion constructed from four float values. |
| radians | Returns the result of converting a float value from degrees to radians. |
| rcp | Returns the reciprocal a float value. |
| reflect | Given an incident vector i and a normal vector n, returns the reflection vector r = i - 2.0f " dot(i, n) " n. |
| refract | Returns the refraction vector given the incident vector i, the normal vector n and the refraction index. |
| remap | Returns the result of a non-clamping linear remapping of a value x from source range [srcStart, srcEnd] to the destination range [dstStart, dstEnd]. |
| reversebits | Returns the result of performing a reversal of the bit pattern of an int value. |
| right |
Unity's right axis (1, 0, 0).
|
| RigidTransform | Returns a RigidTransform constructed from a rotation represented by a unit quaternion and a translation represented by a float3 vector. |
| rol | Returns the result of rotating the bits of an int left by bits n. |
| ror | Returns the result of rotating the bits of an int right by bits n. |
| rotate | Returns the result of rotating a float3 vector by an AffineTransform. |
| rotation |
Extracts the rotation from a matrix.
|
| round | Returns the result of rounding a float value to the nearest integral value. |
| rsqrt | Returns the reciprocal square root of a float value. |
| saturate | Returns the result of clamping the float value x into the interval [0, 1]. |
| scaleMul |
Matrix rows multiplied by scale components
m.c0.x " s.x | m.c1.x " s.x | m.c2.x " s.x
m.c0.y " s.y | m.c1.y " s.y | m.c2.y " s.y
m.c0.z " s.z | m.c1.z " s.z | m.c2.z * s.z
|
| select | Returns trueValue if test is true, falseValue otherwise. |
| shuffle | Returns the result of specified shuffling of the components from two bool2 vectors into a bool value. |
| sign | Returns the sign of a int value. -1 if it is less than zero, 0 if it is zero and 1 if it greater than zero. |
| sin | Returns the sine of a float value. |
| sincos | Returns the sine and cosine of the input float value x through the out parameters s and c. |
| sinh | Returns the hyperbolic sine of a float value. |
| slerp | Returns the result of a spherical interpolation between two quaternions q1 and a2 using an interpolation parameter t. |
| smoothstep | Returns a smooth Hermite interpolation between 0.0f and 1.0f when x is in the interval (inclusive) [xMin, xMax]. |
| sqrt | Returns the square root of a float value. |
| square |
Computes the square (x * x) of the input argument x.
|
| step | Returns the result of a step function where the result is 1.0f when x >= threshold and 0.0f otherwise. |
| tan | Returns the tangent of a float value. |
| tanh | Returns the hyperbolic tangent of a float value. |
| transform | Returns the result of transforming a float3 point by an AffineTransform. |
| transpose | Return the bool2x2 transpose of a bool2x2 matrix. |
| trunc | Returns the result of truncating a float value to an integral float value. |
| tzcnt |
Computes the trailing zero count in the binary representation of the input value.
|
| uint2 | Returns a uint2 vector constructed from two uint values. |
| uint2x2 | Returns a uint2x2 matrix constructed from two uint2 vectors. |
| uint2x3 | Returns a uint2x3 matrix constructed from three uint2 vectors. |
| uint2x4 | Returns a uint2x4 matrix constructed from four uint2 vectors. |
| uint3 | Returns a uint3 vector constructed from three uint values. |
| uint3x2 | Returns a uint3x2 matrix constructed from two uint3 vectors. |
| uint3x3 | Returns a uint3x3 matrix constructed from three uint3 vectors. |
| uint3x4 | Returns a uint3x4 matrix constructed from four uint3 vectors. |
| uint4 | Returns a uint4 vector constructed from four uint values. |
| uint4x2 | Returns a uint4x2 matrix constructed from two uint4 vectors. |
| uint4x3 | Returns a uint4x3 matrix constructed from three uint4 vectors. |
| uint4x4 | Returns a uint4x4 matrix constructed from four uint4 vectors. |
| unitexp | Returns the natural exponent of a quaternion. Assumes w is zero. |
| unitlog | Returns the natural logarithm of a unit length quaternion. |
| unlerp | Returns the result of normalizing a floating point value x to a range [a, b]. The opposite of lerp. Equivalent to (x - a) / (b - a). |
| up |
Unity's up axis (0, 1, 0).
|