Class math
A static class to contain various math functions and constants.
Inherited Members
Namespace: Unity.Mathematics
Assembly: solution.dll
Syntax
public static class mathFields
| Name | Description |
|---|---|
| DBL_MIN_NORMAL | The smallest positive normal number representable in a double. This is a f64/double precision constant. |
| E | The mathematical constant e also known as Euler's number. Approximately 2.72. |
| EPSILON | The difference between 1.0f and the next representable f32/single precision number. Beware: This value is different from System.Single.Epsilon, which is the smallest, positive, denormalized f32/single. |
| EPSILON_DBL | The difference between 1.0 and the next representable f64/double precision number. Beware: This value is different from System.Double.Epsilon, which is the smallest, positive, denormalized f64/double. |
| E_DBL | The mathematical constant e also known as Euler's number. Approximately 2.72. This is a f64/double precision constant. |
| FLT_MIN_NORMAL | The smallest positive normal number representable in a float. |
| INFINITY | Single precision constant for positive infinity. |
| INFINITY_DBL | Double precision constant for positive infinity. |
| LN10 | The natural logarithm of 10. Approximately 2.30. |
| LN10_DBL | The natural logarithm of 10. Approximately 2.30. This is a f64/double precision constant. |
| LN2 | The natural logarithm of 2. Approximately 0.69. |
| LN2_DBL | The natural logarithm of 2. Approximately 0.69. This is a f64/double precision constant. |
| LOG10E | The base 10 logarithm of e. Approximately 0.43. |
| LOG10E_DBL | The base 10 logarithm of e. Approximately 0.43. This is a f64/double precision constant. |
| LOG2E | The base 2 logarithm of e. Approximately 1.44. |
| LOG2E_DBL | The base 2 logarithm of e. Approximately 1.44. This is a f64/double precision constant. |
| NAN | Single precision constant for Not a Number. NAN is considered unordered, which means all comparisons involving it are false except for not equal (operator !=). As a consequence, NAN == NAN is false but NAN != NAN is true. Additionally, there are multiple bit representations for Not a Number, so if you must test if your value is NAN, use isnan(). |
| NAN_DBL | Double precision constant for Not a Number. NAN_DBL is considered unordered, which means all comparisons involving it are false except for not equal (operator !=). As a consequence, NAN_DBL == NAN_DBL is false but NAN_DBL != NAN_DBL is true. Additionally, there are multiple bit representations for Not a Number, so if you must test if your value is NAN_DBL, use isnan(). |
| PI | The mathematical constant pi. Approximately 3.14. |
| PI2 | The mathematical constant (2 * pi). Approximately 6.28. Also known as TAU. |
| PI2_DBL | The mathematical constant (2 * pi). Approximately 6.28. This is a f64/double precision constant. Also known as TAU_DBL. |
| PIHALF | The mathematical constant (pi / 2). Approximately 1.57. |
| PIHALF_DBL | The mathematical constant (pi / 2). Approximately 1.57. This is a f64/double precision constant. |
| PI_DBL | The mathematical constant pi. Approximately 3.14. This is a f64/double precision constant. |
| SQRT2 | The square root 2. Approximately 1.41. |
| SQRT2_DBL | The square root 2. Approximately 1.41. This is a f64/double precision constant. |
| TAU | The mathematical constant tau. Approximately 6.28. Also known as PI2. |
| TAU_DBL | The mathematical constant tau. Approximately 6.28. This is a f64/double precision constant. Also known as PI2_DBL. |
| TODEGREES | The conversion constant used to convert radians to degrees. Multiply the radian value by this constant to get degrees. |
| TODEGREES_DBL | The conversion constant used to convert radians to degrees. Multiply the radian value by this constant to get degrees. |
| TORADIANS | The conversion constant used to convert degrees to radians. Multiply the degree value by this constant to get radians. |
| TORADIANS_DBL | The conversion constant used to convert degrees to radians. Multiply the degree value by this constant to get radians. |
Methods
| Name | Description |
|---|---|
| AffineTransform(RigidTransform) | Returns an AffineTransform constructed from a RigidTransform. |
| AffineTransform(float3, float3x3) | Returns an AffineTransform constructed from a translation represented by float3 vector and a float3x3 matrix representing both rotation and scale. |
| AffineTransform(float3, quaternion) | Returns an AffineTransform constructed from a translation represented by a float3 vector and rotation represented by a unit quaternion. |
| AffineTransform(float3, quaternion, float3) | Returns an AffineTransform constructed from a translation represented by a float3 vector, rotation represented by a unit quaternion and scale represented by a float3 vector. |
| AffineTransform(float3x3) | Returns an AffineTransform constructed from a float3x3 matrix representing both rotation and scale. |
| AffineTransform(float3x4) | Returns an AffineTransform constructed from a float3x4 matrix. |
| AffineTransform(float4x4) | Returns an AffineTransform constructed from a float4x4 matrix. |
| Euler(quaternion, RotationOrder) | 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(quaternion) | 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(quaternion) | 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(quaternion) | 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(quaternion) | 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(quaternion) | 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(quaternion) | 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. |
| RigidTransform(float3x3, float3) | Returns a RigidTransform constructed from a rotation represented by a float3x3 rotation matrix and a translation represented by a float3 vector. |
| RigidTransform(float4x4) | Returns a RigidTransform constructed from a rotation represented by a float3x3 matrix and a translation represented by a float3 vector. |
| RigidTransform(quaternion, float3) | Returns a RigidTransform constructed from a rotation represented by a unit quaternion and a translation represented by a float3 vector. |
| abs(double) | Returns the absolute value of a double value. |
| abs(int) | Returns the absolute value of a int value. |
| abs(long) | Returns the absolute value of a long value. |
| abs(float) | Returns the absolute value of a float value. |
| abs(double2) | Returns the componentwise absolute value of a double2 vector. |
| abs(double3) | Returns the componentwise absolute value of a double3 vector. |
| abs(double4) | Returns the componentwise absolute value of a double4 vector. |
| abs(float2) | Returns the componentwise absolute value of a float2 vector. |
| abs(float3) | Returns the componentwise absolute value of a float3 vector. |
| abs(float4) | Returns the componentwise absolute value of a float4 vector. |
| abs(int2) | Returns the componentwise absolute value of a int2 vector. |
| abs(int3) | Returns the componentwise absolute value of a int3 vector. |
| abs(int4) | Returns the componentwise absolute value of a int4 vector. |
| acos(double) | Returns the arccosine of a double value. |
| acos(float) | Returns the arccosine of a float value. |
| acos(double2) | Returns the componentwise arccosine of a double2 vector. |
| acos(double3) | Returns the componentwise arccosine of a double3 vector. |
| acos(double4) | Returns the componentwise arccosine of a double4 vector. |
| acos(float2) | Returns the componentwise arccosine of a float2 vector. |
| acos(float3) | Returns the componentwise arccosine of a float3 vector. |
| acos(float4) | Returns the componentwise arccosine of a float4 vector. |
| all(bool2) | Returns true if all components of the input bool2 vector are true, false otherwise. |
| all(bool3) | Returns true if all components of the input bool3 vector are true, false otherwise. |
| all(bool4) | Returns true if all components of the input bool4 vector are true, false otherwise. |
| all(double2) | Returns true if all components of the input double2 vector are non-zero, false otherwise. |
| all(double3) | Returns true if all components of the input double3 vector are non-zero, false otherwise. |
| all(double4) | Returns true if all components of the input double4 vector are non-zero, false otherwise. |
| all(float2) | Returns true if all components of the input float2 vector are non-zero, false otherwise. |
| all(float3) | Returns true if all components of the input float3 vector are non-zero, false otherwise. |
| all(float4) | Returns true if all components of the input float4 vector are non-zero, false otherwise. |
| all(int2) | Returns true if all components of the input int2 vector are non-zero, false otherwise. |
| all(int3) | Returns true if all components of the input int3 vector are non-zero, false otherwise. |
| all(int4) | Returns true if all components of the input int4 vector are non-zero, false otherwise. |
| all(uint2) | Returns true if all components of the input uint2 vector are non-zero, false otherwise. |
| all(uint3) | Returns true if all components of the input uint3 vector are non-zero, false otherwise. |
| all(uint4) | Returns true if all components of the input uint4 vector are non-zero, false otherwise. |
| angle(quaternion, quaternion) | Returns the angle in radians between two unit quaternions. |
| any(bool2) | Returns true if any component of the input bool2 vector is true, false otherwise. |
| any(bool3) | Returns true if any component of the input bool3 vector is true, false otherwise. |
| any(bool4) | Returns true if any components of the input bool4 vector is true, false otherwise. |
| any(double2) | Returns true if any component of the input double2 vector is non-zero, false otherwise. |
| any(double3) | Returns true if any component of the input double3 vector is non-zero, false otherwise. |
| any(double4) | Returns true if any component of the input double4 vector is non-zero, false otherwise. |
| any(float2) | Returns true if any component of the input float2 vector is non-zero, false otherwise. |
| any(float3) | Returns true if any component of the input float3 vector is non-zero, false otherwise. |
| any(float4) | Returns true if any component of the input float4 vector is non-zero, false otherwise. |
| any(int2) | Returns true if any component of the input int2 vector is non-zero, false otherwise. |
| any(int3) | Returns true if any component of the input int3 vector is non-zero, false otherwise. |
| any(int4) | Returns true if any components of the input int4 vector is non-zero, false otherwise. |
| any(uint2) | Returns true if any component of the input uint2 vector is non-zero, false otherwise. |
| any(uint3) | Returns true if any component of the input uint3 vector is non-zero, false otherwise. |
| any(uint4) | Returns true if any components of the input uint4 vector is non-zero, false otherwise. |
| asdouble(long) | Returns the bit pattern of a long as a double. |
| asdouble(ulong) | Returns the bit pattern of a ulong as a double. |
| asfloat(int) | Returns the bit pattern of an int as a float. |
| asfloat(uint) | Returns the bit pattern of a uint as a float. |
| asfloat(int2) | Returns the bit pattern of an int2 as a float2. |
| asfloat(int3) | Returns the bit pattern of an int3 as a float3. |
| asfloat(int4) | Returns the bit pattern of an int4 as a float4. |
| asfloat(uint2) | Returns the bit pattern of a uint2 as a float2. |
| asfloat(uint3) | Returns the bit pattern of a uint3 as a float3. |
| asfloat(uint4) | Returns the bit pattern of a uint4 as a float4. |
| asin(double) | Returns the arcsine of a double value. |
| asin(float) | Returns the arcsine of a float value. |
| asin(double2) | Returns the componentwise arcsine of a double2 vector. |
| asin(double3) | Returns the componentwise arcsine of a double3 vector. |
| asin(double4) | Returns the componentwise arcsine of a double4 vector. |
| asin(float2) | Returns the componentwise arcsine of a float2 vector. |
| asin(float3) | Returns the componentwise arcsine of a float3 vector. |
| asin(float4) | Returns the componentwise arcsine of a float4 vector. |
| asint(float) | Returns the bit pattern of a float as an int. |
| asint(uint) | Returns the bit pattern of a uint as an int. |
| asint(float2) | Returns the bit pattern of a float2 as an int2. |
| asint(float3) | Returns the bit pattern of a float3 as an int3. |
| asint(float4) | Returns the bit pattern of a float4 as an int4. |
| asint(uint2) | Returns the bit pattern of a uint2 as an int2. |
| asint(uint3) | Returns the bit pattern of a uint3 as an int3. |
| asint(uint4) | Returns the bit pattern of a uint4 as an int4. |
| aslong(double) | Returns the bit pattern of a double as a long. |
| aslong(ulong) | Returns the bit pattern of a ulong as a long. |
| asuint(int) | Returns the bit pattern of an int as a uint. |
| asuint(float) | Returns the bit pattern of a float as a uint. |
| asuint(float2) | Returns the bit pattern of a float2 as a uint2. |
| asuint(float3) | Returns the bit pattern of a float3 as a uint3. |
| asuint(float4) | Returns the bit pattern of a float4 as a uint4. |
| asuint(int2) | Returns the bit pattern of an int2 as a uint2. |
| asuint(int3) | Returns the bit pattern of an int3 as a uint3. |
| asuint(int4) | Returns the bit pattern of an int4 as a uint4. |
| asulong(double) | Returns the bit pattern of a double as a ulong. |
| asulong(long) | Returns the bit pattern of a long as a ulong. |
| atan(double) | Returns the arctangent of a double value. |
| atan(float) | Returns the arctangent of a float value. |
| atan(double2) | Returns the componentwise arctangent of a double2 vector. |
| atan(double3) | Returns the componentwise arctangent of a double3 vector. |
| atan(double4) | Returns the componentwise arctangent of a double4 vector. |
| atan(float2) | Returns the componentwise arctangent of a float2 vector. |
| atan(float3) | Returns the componentwise arctangent of a float3 vector. |
| atan(float4) | Returns the componentwise arctangent of a float4 vector. |
| atan2(double, double) | Returns the 2-argument arctangent of a pair of double values. |
| atan2(float, float) | Returns the 2-argument arctangent of a pair of float values. |
| atan2(double2, double2) | Returns the 2-argument arctangent of a pair of double2 vectors. |
| atan2(double3, double3) | Returns the 2-argument arctangent of a pair of double3 vectors. |
| atan2(double4, double4) | Returns the 2-argument arctangent of a pair of double4 vectors. |
| atan2(float2, float2) | Returns the componentwise 2-argument arctangent of a pair of floats2 vectors. |
| atan2(float3, float3) | Returns the componentwise 2-argument arctangent of a pair of floats3 vectors. |
| atan2(float4, float4) | Returns the componentwise 2-argument arctangent of a pair of floats4 vectors. |
| back() | Unity's back axis (0, 0, -1). |
| bitmask(bool4) | 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(bool) | Returns a bool2 vector constructed from a single bool value by assigning it to every component. |
| bool2(bool, bool) | Returns a bool2 vector constructed from two bool values. |
| bool2(bool2) | Returns a bool2 vector constructed from a bool2 vector. |
| bool2x2(bool) | Returns a bool2x2 matrix constructed from a single bool value by assigning it to every component. |
| bool2x2(bool, bool, bool, bool) | Returns a bool2x2 matrix constructed from from 4 bool values given in row-major order. |
| bool2x2(bool2, bool2) | Returns a bool2x2 matrix constructed from two bool2 vectors. |
| bool2x3(bool) | Returns a bool2x3 matrix constructed from a single bool value by assigning it to every component. |
| bool2x3(bool, bool, bool, bool, bool, bool) | Returns a bool2x3 matrix constructed from from 6 bool values given in row-major order. |
| bool2x3(bool2, bool2, bool2) | Returns a bool2x3 matrix constructed from three bool2 vectors. |
| bool2x4(bool) | Returns a bool2x4 matrix constructed from a single bool value by assigning it to every component. |
| bool2x4(bool, bool, bool, bool, bool, bool, bool, bool) | Returns a bool2x4 matrix constructed from from 8 bool values given in row-major order. |
| bool2x4(bool2, bool2, bool2, bool2) | Returns a bool2x4 matrix constructed from four bool2 vectors. |
| bool3(bool) | Returns a bool3 vector constructed from a single bool value by assigning it to every component. |
| bool3(bool, bool, bool) | Returns a bool3 vector constructed from three bool values. |
| bool3(bool, bool2) | Returns a bool3 vector constructed from a bool value and a bool2 vector. |
| bool3(bool2, bool) | Returns a bool3 vector constructed from a bool2 vector and a bool value. |
| bool3(bool3) | Returns a bool3 vector constructed from a bool3 vector. |
| bool3x2(bool) | Returns a bool3x2 matrix constructed from a single bool value by assigning it to every component. |
| bool3x2(bool, bool, bool, bool, bool, bool) | Returns a bool3x2 matrix constructed from from 6 bool values given in row-major order. |
| bool3x2(bool3, bool3) | Returns a bool3x2 matrix constructed from two bool3 vectors. |
| bool3x3(bool) | Returns a bool3x3 matrix constructed from a single bool value by assigning it to every component. |
| bool3x3(bool, bool, bool, bool, bool, bool, bool, bool, bool) | Returns a bool3x3 matrix constructed from from 9 bool values given in row-major order. |
| bool3x3(bool3, bool3, bool3) | Returns a bool3x3 matrix constructed from three bool3 vectors. |
| bool3x4(bool) | Returns a bool3x4 matrix constructed from a single bool value by assigning it to every component. |
| bool3x4(bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool) | Returns a bool3x4 matrix constructed from from 12 bool values given in row-major order. |
| bool3x4(bool3, bool3, bool3, bool3) | Returns a bool3x4 matrix constructed from four bool3 vectors. |
| bool4(bool) | Returns a bool4 vector constructed from a single bool value by assigning it to every component. |
| bool4(bool, bool, bool, bool) | Returns a bool4 vector constructed from four bool values. |
| bool4(bool, bool, bool2) | Returns a bool4 vector constructed from two bool values and a bool2 vector. |
| bool4(bool, bool2, bool) | Returns a bool4 vector constructed from a bool value, a bool2 vector and a bool value. |
| bool4(bool, bool3) | Returns a bool4 vector constructed from a bool value and a bool3 vector. |
| bool4(bool2, bool, bool) | Returns a bool4 vector constructed from a bool2 vector and two bool values. |
| bool4(bool2, bool2) | Returns a bool4 vector constructed from two bool2 vectors. |
| bool4(bool3, bool) | Returns a bool4 vector constructed from a bool3 vector and a bool value. |
| bool4(bool4) | Returns a bool4 vector constructed from a bool4 vector. |
| bool4x2(bool) | Returns a bool4x2 matrix constructed from a single bool value by assigning it to every component. |
| bool4x2(bool, bool, bool, bool, bool, bool, bool, bool) | Returns a bool4x2 matrix constructed from from 8 bool values given in row-major order. |
| bool4x2(bool4, bool4) | Returns a bool4x2 matrix constructed from two bool4 vectors. |
| bool4x3(bool) | Returns a bool4x3 matrix constructed from a single bool value by assigning it to every component. |
| bool4x3(bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool) | Returns a bool4x3 matrix constructed from from 12 bool values given in row-major order. |
| bool4x3(bool4, bool4, bool4) | Returns a bool4x3 matrix constructed from three bool4 vectors. |
| bool4x4(bool) | Returns a bool4x4 matrix constructed from a single bool value by assigning it to every component. |
| bool4x4(bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool) | Returns a bool4x4 matrix constructed from from 16 bool values given in row-major order. |
| bool4x4(bool4, bool4, bool4, bool4) | Returns a bool4x4 matrix constructed from four bool4 vectors. |
| ceil(double) | Returns the result of rounding a double value up to the nearest greater integral value greater or equal to the original value. |
| ceil(float) | Returns the result of rounding a float value up to the nearest integral value greater or equal to the original value. |
| ceil(double2) | Returns the result of rounding each component of a double2 vector value up to the nearest integral value greater or equal to the original value. |
| ceil(double3) | Returns the result of rounding each component of a double3 vector value up to the nearest integral value greater or equal to the original value.. |
| ceil(double4) | Returns the result of rounding each component of a double4 vector value up to the nearest integral value greater or equal to the original value. |
| ceil(float2) | Returns the result of rounding each component of a float2 vector value up to the nearest value greater or equal to the original value. |
| ceil(float3) | Returns the result of rounding each component of a float3 vector value up to the nearest value greater or equal to the original value. |
| ceil(float4) | Returns the result of rounding each component of a float4 vector value up to the nearest value greater or equal to the original value. |
| ceillog2(int) | Computes the ceiling of the base-2 logarithm of x. |
| ceillog2(uint) | Computes the ceiling of the base-2 logarithm of x. |
| ceillog2(int2) | Computes the componentwise ceiling of the base-2 logarithm of x. |
| ceillog2(int3) | Computes the componentwise ceiling of the base-2 logarithm of x. |
| ceillog2(int4) | Computes the componentwise ceiling of the base-2 logarithm of x. |
| ceillog2(uint2) | Computes the componentwise ceiling of the base-2 logarithm of x. |
| ceillog2(uint3) | Computes the componentwise ceiling of the base-2 logarithm of x. |
| ceillog2(uint4) | Computes the componentwise ceiling of the base-2 logarithm of x. |
| ceilpow2(int) | Returns the smallest power of two greater than or equal to the input. |
| ceilpow2(long) | Returns the smallest power of two greater than or equal to the input. |
| ceilpow2(uint) | Returns the smallest power of two greater than or equal to the input. |
| ceilpow2(ulong) | Returns the smallest power of two greater than or equal to the input. |
| ceilpow2(int2) | Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input. |
| ceilpow2(int3) | Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input. |
| ceilpow2(int4) | Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input. |
| ceilpow2(uint2) | Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input. |
| ceilpow2(uint3) | Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input. |
| ceilpow2(uint4) | Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input. |
| chgsign(float, float) | Change the sign of x based on the most significant bit of y [msb(y) ? -x : x]. |
| chgsign(float2, float2) | Change the sign of components of x based on the most significant bit of components of y [msb(y) ? -x : x]. |
| chgsign(float3, float3) | Change the sign of components of x based on the most significant bit of components of y [msb(y) ? -x : x]. |
| chgsign(float4, float4) | Change the sign of components of x based on the most significant bit of components of y [msb(y) ? -x : x]. |
| clamp(double, double, double) | Returns the result of clamping the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are double values. |
| clamp(int, int, int) | Returns the result of clamping the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are int values. |
| clamp(long, long, long) | Returns the result of clamping the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are long values. |
| clamp(float, float, float) | Returns the result of clamping the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are float values. |
| clamp(uint, uint, uint) | Returns the result of clamping the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are uint values. |
| clamp(ulong, ulong, ulong) | Returns the result of clamping the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are ulong values. |
| clamp(double2, double2, double2) | Returns the result of a componentwise clamping of the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are double2 vectors. |
| clamp(double3, double3, double3) | Returns the result of a componentwise clamping of the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are double3 vectors. |
| clamp(double4, double4, double4) | Returns the result of a componentwise clamping of the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are double4 vectors. |
| clamp(float2, float2, float2) | Returns the result of a componentwise clamping of the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are float2 vectors. |
| clamp(float3, float3, float3) | Returns the result of a componentwise clamping of the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are float3 vectors. |
| clamp(float4, float4, float4) | Returns the result of a componentwise clamping of the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are float4 vectors. |
| clamp(int2, int2, int2) | Returns the result of a componentwise clamping of the int2 x into the interval [a, b], where a and b are int2 vectors. |
| clamp(int3, int3, int3) | Returns the result of a componentwise clamping of the int3 x into the interval [a, b], where x, a and b are int3 vectors. |
| clamp(int4, int4, int4) | Returns the result of a componentwise clamping of the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are int4 vectors. |
| clamp(uint2, uint2, uint2) | Returns the result of a componentwise clamping of the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are uint2 vectors. |
| clamp(uint3, uint3, uint3) | Returns the result of a componentwise clamping of the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are uint3 vectors. |
| clamp(uint4, uint4, uint4) | Returns the result of a componentwise clamping of the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are uint4 vectors. |
| cmax(double2) | Returns the maximum component of a double2 vector. |
| cmax(double3) | Returns the maximum component of a double3 vector. |
| cmax(double4) | Returns the maximum component of a double4 vector. |
| cmax(float2) | Returns the maximum component of a float2 vector. |
| cmax(float3) | Returns the maximum component of a float3 vector. |
| cmax(float4) | Returns the maximum component of a float4 vector. |
| cmax(int2) | Returns the maximum component of an int2 vector. |
| cmax(int3) | Returns the maximum component of an int3 vector. |
| cmax(int4) | Returns the maximum component of an int4 vector. |
| cmax(uint2) | Returns the maximum component of a uint2 vector. |
| cmax(uint3) | Returns the maximum component of a uint3 vector. |
| cmax(uint4) | Returns the maximum component of a uint4 vector. |
| cmin(double2) | Returns the minimum component of a double2 vector. |
| cmin(double3) | Returns the minimum component of a double3 vector. |
| cmin(double4) | Returns the minimum component of a double4 vector. |
| cmin(float2) | Returns the minimum component of a float2 vector. |
| cmin(float3) | Returns the minimum component of a float3 vector. |
| cmin(float4) | Returns the minimum component of a float4 vector. |
| cmin(int2) | Returns the minimum component of an int2 vector. |
| cmin(int3) | Returns the minimum component of an int3 vector. |
| cmin(int4) | Returns the minimum component of an int4 vector. |
| cmin(uint2) | Returns the minimum component of a uint2 vector. |
| cmin(uint3) | Returns the minimum component of a uint3 vector. |
| cmin(uint4) | Returns the minimum component of a uint4 vector. |
| compress(int*, int, int4, bool4) | Packs components with an enabled mask to the left. |
| compress(float*, int, float4, bool4) | Packs components with an enabled mask to the left. |
| compress(uint*, int, uint4, bool4) | Packs components with an enabled mask to the left. |
| conjugate(quaternion) | Returns the conjugate of a quaternion value. |
| cos(double) | Returns the cosine of a double value. |
| cos(float) | Returns the cosine of a float value. |
| cos(double2) | Returns the componentwise cosine of a double2 vector. |
| cos(double3) | Returns the componentwise cosine of a double3 vector. |
| cos(double4) | Returns the componentwise cosine of a double4 vector. |
| cos(float2) | Returns the componentwise cosine of a float2 vector. |
| cos(float3) | Returns the componentwise cosine of a float3 vector. |
| cos(float4) | Returns the componentwise cosine of a float4 vector. |
| cosh(double) | Returns the hyperbolic cosine of a double value. |
| cosh(float) | Returns the hyperbolic cosine of a float value. |
| cosh(double2) | Returns the componentwise hyperbolic cosine of a double2 vector. |
| cosh(double3) | Returns the componentwise hyperbolic cosine of a double3 vector. |
| cosh(double4) | Returns the componentwise hyperbolic cosine of a double4 vector. |
| cosh(float2) | Returns the componentwise hyperbolic cosine of a float2 vector. |
| cosh(float3) | Returns the componentwise hyperbolic cosine of a float3 vector. |
| cosh(float4) | Returns the componentwise hyperbolic cosine of a float4 vector. |
| countbits(int) | 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. |
| countbits(long) | Returns number of 1-bits in the binary representation of a long value. Also known as the Hamming weight, popcnt on x86, and vcnt on ARM. |
| countbits(uint) | Returns number of 1-bits in the binary representation of a uint value. Also known as the Hamming weight, popcnt on x86, and vcnt on ARM. |
| countbits(ulong) | Returns number of 1-bits in the binary representation of a ulong value. Also known as the Hamming weight, popcnt on x86, and vcnt on ARM. |
| countbits(int2) | Returns component-wise number of 1-bits in the binary representation of an int2 vector. Also known as the Hamming weight, popcnt on x86, and vcnt on ARM. |
| countbits(int3) | Returns component-wise number of 1-bits in the binary representation of an int3 vector. Also known as the Hamming weight, popcnt on x86, and vcnt on ARM. |
| countbits(int4) | Returns component-wise number of 1-bits in the binary representation of an int4 vector. Also known as the Hamming weight, popcnt on x86, and vcnt on ARM. |
| countbits(uint2) | Returns component-wise number of 1-bits in the binary representation of a uint2 vector. Also known as the Hamming weight, popcnt on x86, and vcnt on ARM. |
| countbits(uint3) | Returns component-wise number of 1-bits in the binary representation of a uint3 vector. Also known as the Hamming weight, popcnt on x86, and vcnt on ARM. |
| countbits(uint4) | Returns component-wise number of 1-bits in the binary representation of a uint4 vector. Also known as the Hamming weight, popcnt on x86, and vcnt on ARM. |
| cross(double3, double3) | Returns the cross product of two double3 vectors. |
| cross(float3, float3) | Returns the cross product of two float3 vectors. |
| csum(double2) | Returns the horizontal sum of components of a double2 vector. |
| csum(double3) | Returns the horizontal sum of components of a double3 vector. |
| csum(double4) | Returns the horizontal sum of components of a double4 vector. |
| csum(float2) | Returns the horizontal sum of components of a float2 vector. |
| csum(float3) | Returns the horizontal sum of components of a float3 vector. |
| csum(float4) | Returns the horizontal sum of components of a float4 vector. |
| csum(int2) | Returns the horizontal sum of components of an int2 vector. |
| csum(int3) | Returns the horizontal sum of components of an int3 vector. |
| csum(int4) | Returns the horizontal sum of components of an int4 vector. |
| csum(uint2) | Returns the horizontal sum of components of a uint2 vector. |
| csum(uint3) | Returns the horizontal sum of components of a uint3 vector. |
| csum(uint4) | Returns the horizontal sum of components of a uint4 vector. |
| decompose(AffineTransform, out float3, out quaternion, out float3) | Decomposes the AffineTransform in translation, rotation and scale. |
| degrees(double) | Returns the result of converting a double value from radians to degrees. |
| degrees(float) | Returns the result of converting a double value from radians to degrees. |
| degrees(double2) | Returns the result of a componentwise conversion of a double2 vector from radians to degrees. |
| degrees(double3) | Returns the result of a componentwise conversion of a double3 vector from radians to degrees. |
| degrees(double4) | Returns the result of a componentwise conversion of a double4 vector from radians to degrees. |
| degrees(float2) | Returns the result of a componentwise conversion of a double2 vector from radians to degrees. |
| degrees(float3) | Returns the result of a componentwise conversion of a double3 vector from radians to degrees. |
| degrees(float4) | Returns the result of a componentwise conversion of a double4 vector from radians to degrees. |
| determinant(double2x2) | Returns the determinant of a double2x2 matrix. |
| determinant(double3x3) | Returns the determinant of a double3x3 matrix. |
| determinant(double4x4) | Returns the determinant of a double4x4 matrix. |
| determinant(float2x2) | Returns the determinant of a float2x2 matrix. |
| determinant(float3x3) | Returns the determinant of a float3x3 matrix. |
| determinant(float4x4) | Returns the determinant of a float4x4 matrix. |
| determinant(int2x2) | Returns the determinant of a int2x2 matrix. |
| determinant(int3x3) | Returns the determinant of a int3x3 matrix. |
| determinant(int4x4) | Returns the determinant of a int4x4 matrix. |
| distance(double, double) | Returns the distance between two double values. |
| distance(float, float) | Returns the distance between two float values. |
| distance(double2, double2) | Returns the distance between two double2 vectors. |
| distance(double3, double3) | Returns the distance between two double3 vectors. |
| distance(double4, double4) | Returns the distance between two double4 vectors. |
| distance(float2, float2) | Returns the distance between two float2 vectors. |
| distance(float3, float3) | Returns the distance between two float3 vectors. |
| distance(float4, float4) | Returns the distance between two float4 vectors. |
| distancesq(double, double) | Returns the squared distance between two double values. |
| distancesq(float, float) | Returns the squared distance between two float values. |
| distancesq(double2, double2) | Returns the squared distance between two double2 vectors. |
| distancesq(double3, double3) | Returns the squared distance between two double3 vectors. |
| distancesq(double4, double4) | Returns the squared distance between two double4 vectors. |
| distancesq(float2, float2) | Returns the squared distance between two float2 vectors. |
| distancesq(float3, float3) | Returns the squared distance between two float3 vectors. |
| distancesq(float4, float4) | Returns the squared distance between two float4 vectors. |
| dot(double, double) | Returns the dot product of two double values. Equivalent to multiplication. |
| dot(int, int) | Returns the dot product of two int values. Equivalent to multiplication. |
| dot(float, float) | Returns the dot product of two float values. Equivalent to multiplication. |
| dot(uint, uint) | Returns the dot product of two uint values. Equivalent to multiplication. |
| dot(double2, double2) | Returns the dot product of two double2 vectors. |
| dot(double3, double3) | Returns the dot product of two double3 vectors. |
| dot(double4, double4) | Returns the dot product of two double4 vectors. |
| dot(float2, float2) | Returns the dot product of two float2 vectors. |
| dot(float3, float3) | Returns the dot product of two float3 vectors. |
| dot(float4, float4) | Returns the dot product of two float4 vectors. |
| dot(int2, int2) | Returns the dot product of two int2 vectors. |
| dot(int3, int3) | Returns the dot product of two int3 vectors. |
| dot(int4, int4) | Returns the dot product of two int4 vectors. |
| dot(quaternion, quaternion) | Returns the dot product of two quaternions. |
| dot(uint2, uint2) | Returns the dot product of two uint2 vectors. |
| dot(uint3, uint3) | Returns the dot product of two uint3 vectors. |
| dot(uint4, uint4) | Returns the dot product of two uint4 vectors. |
| double2(bool) | Returns a double2 vector constructed from a single bool value by converting it to double and assigning it to every component. |
| double2(double) | Returns a double2 vector constructed from a single double value by assigning it to every component. |
| double2(double, double) | Returns a double2 vector constructed from two double values. |
| double2(int) | Returns a double2 vector constructed from a single int value by converting it to double and assigning it to every component. |
| double2(float) | Returns a double2 vector constructed from a single float value by converting it to double and assigning it to every component. |
| double2(uint) | Returns a double2 vector constructed from a single uint value by converting it to double and assigning it to every component. |
| double2(bool2) | Return a double2 vector constructed from a bool2 vector by componentwise conversion. |
| double2(double2) | Returns a double2 vector constructed from a double2 vector. |
| double2(float2) | Return a double2 vector constructed from a float2 vector by componentwise conversion. |
| double2(half) | Returns a double2 vector constructed from a single half value by converting it to double and assigning it to every component. |
| double2(half2) | Return a double2 vector constructed from a half2 vector by componentwise conversion. |
| double2(int2) | Return a double2 vector constructed from a int2 vector by componentwise conversion. |
| double2(uint2) | Return a double2 vector constructed from a uint2 vector by componentwise conversion. |
| double2x2(bool) | Returns a double2x2 matrix constructed from a single bool value by converting it to double and assigning it to every component. |
| double2x2(double) | Returns a double2x2 matrix constructed from a single double value by assigning it to every component. |
| double2x2(double, double, double, double) | Returns a double2x2 matrix constructed from from 4 double values given in row-major order. |
| double2x2(int) | Returns a double2x2 matrix constructed from a single int value by converting it to double and assigning it to every component. |
| double2x2(float) | Returns a double2x2 matrix constructed from a single float value by converting it to double and assigning it to every component. |
| double2x2(uint) | Returns a double2x2 matrix constructed from a single uint value by converting it to double and assigning it to every component. |
| double2x2(bool2x2) | Return a double2x2 matrix constructed from a bool2x2 matrix by componentwise conversion. |
| double2x2(double2, double2) | Returns a double2x2 matrix constructed from two double2 vectors. |
| double2x2(float2x2) | Return a double2x2 matrix constructed from a float2x2 matrix by componentwise conversion. |
| double2x2(int2x2) | Return a double2x2 matrix constructed from a int2x2 matrix by componentwise conversion. |
| double2x2(uint2x2) | Return a double2x2 matrix constructed from a uint2x2 matrix by componentwise conversion. |
| double2x3(bool) | Returns a double2x3 matrix constructed from a single bool value by converting it to double and assigning it to every component. |
| double2x3(double) | Returns a double2x3 matrix constructed from a single double value by assigning it to every component. |
| double2x3(double, double, double, double, double, double) | Returns a double2x3 matrix constructed from from 6 double values given in row-major order. |
| double2x3(int) | Returns a double2x3 matrix constructed from a single int value by converting it to double and assigning it to every component. |
| double2x3(float) | Returns a double2x3 matrix constructed from a single float value by converting it to double and assigning it to every component. |
| double2x3(uint) | Returns a double2x3 matrix constructed from a single uint value by converting it to double and assigning it to every component. |
| double2x3(bool2x3) | Return a double2x3 matrix constructed from a bool2x3 matrix by componentwise conversion. |
| double2x3(double2, double2, double2) | Returns a double2x3 matrix constructed from three double2 vectors. |
| double2x3(float2x3) | Return a double2x3 matrix constructed from a float2x3 matrix by componentwise conversion. |
| double2x3(int2x3) | Return a double2x3 matrix constructed from a int2x3 matrix by componentwise conversion. |
| double2x3(uint2x3) | Return a double2x3 matrix constructed from a uint2x3 matrix by componentwise conversion. |
| double2x4(bool) | Returns a double2x4 matrix constructed from a single bool value by converting it to double and assigning it to every component. |
| double2x4(double) | Returns a double2x4 matrix constructed from a single double value by assigning it to every component. |
| double2x4(double, double, double, double, double, double, double, double) | Returns a double2x4 matrix constructed from from 8 double values given in row-major order. |
| double2x4(int) | Returns a double2x4 matrix constructed from a single int value by converting it to double and assigning it to every component. |
| double2x4(float) | Returns a double2x4 matrix constructed from a single float value by converting it to double and assigning it to every component. |
| double2x4(uint) | Returns a double2x4 matrix constructed from a single uint value by converting it to double and assigning it to every component. |
| double2x4(bool2x4) | Return a double2x4 matrix constructed from a bool2x4 matrix by componentwise conversion. |
| double2x4(double2, double2, double2, double2) | Returns a double2x4 matrix constructed from four double2 vectors. |
| double2x4(float2x4) | Return a double2x4 matrix constructed from a float2x4 matrix by componentwise conversion. |
| double2x4(int2x4) | Return a double2x4 matrix constructed from a int2x4 matrix by componentwise conversion. |
| double2x4(uint2x4) | Return a double2x4 matrix constructed from a uint2x4 matrix by componentwise conversion. |
| double3(bool) | Returns a double3 vector constructed from a single bool value by converting it to double and assigning it to every component. |
| double3(double) | Returns a double3 vector constructed from a single double value by assigning it to every component. |
| double3(double, double, double) | Returns a double3 vector constructed from three double values. |
| double3(double, double2) | Returns a double3 vector constructed from a double value and a double2 vector. |
| double3(int) | Returns a double3 vector constructed from a single int value by converting it to double and assigning it to every component. |
| double3(float) | Returns a double3 vector constructed from a single float value by converting it to double and assigning it to every component. |
| double3(uint) | Returns a double3 vector constructed from a single uint value by converting it to double and assigning it to every component. |
| double3(bool3) | Return a double3 vector constructed from a bool3 vector by componentwise conversion. |
| double3(double2, double) | Returns a double3 vector constructed from a double2 vector and a double value. |
| double3(double3) | Returns a double3 vector constructed from a double3 vector. |
| double3(float3) | Return a double3 vector constructed from a float3 vector by componentwise conversion. |
| double3(half) | Returns a double3 vector constructed from a single half value by converting it to double and assigning it to every component. |
| double3(half3) | Return a double3 vector constructed from a half3 vector by componentwise conversion. |
| double3(int3) | Return a double3 vector constructed from a int3 vector by componentwise conversion. |
| double3(uint3) | Return a double3 vector constructed from a uint3 vector by componentwise conversion. |
| double3x2(bool) | Returns a double3x2 matrix constructed from a single bool value by converting it to double and assigning it to every component. |
| double3x2(double) | Returns a double3x2 matrix constructed from a single double value by assigning it to every component. |
| double3x2(double, double, double, double, double, double) | Returns a double3x2 matrix constructed from from 6 double values given in row-major order. |
| double3x2(int) | Returns a double3x2 matrix constructed from a single int value by converting it to double and assigning it to every component. |
| double3x2(float) | Returns a double3x2 matrix constructed from a single float value by converting it to double and assigning it to every component. |
| double3x2(uint) | Returns a double3x2 matrix constructed from a single uint value by converting it to double and assigning it to every component. |
| double3x2(bool3x2) | Return a double3x2 matrix constructed from a bool3x2 matrix by componentwise conversion. |
| double3x2(double3, double3) | Returns a double3x2 matrix constructed from two double3 vectors. |
| double3x2(float3x2) | Return a double3x2 matrix constructed from a float3x2 matrix by componentwise conversion. |
| double3x2(int3x2) | Return a double3x2 matrix constructed from a int3x2 matrix by componentwise conversion. |
| double3x2(uint3x2) | Return a double3x2 matrix constructed from a uint3x2 matrix by componentwise conversion. |
| double3x3(bool) | Returns a double3x3 matrix constructed from a single bool value by converting it to double and assigning it to every component. |
| double3x3(double) | Returns a double3x3 matrix constructed from a single double value by assigning it to every component. |
| double3x3(double, double, double, double, double, double, double, double, double) | Returns a double3x3 matrix constructed from from 9 double values given in row-major order. |
| double3x3(int) | Returns a double3x3 matrix constructed from a single int value by converting it to double and assigning it to every component. |
| double3x3(float) | Returns a double3x3 matrix constructed from a single float value by converting it to double and assigning it to every component. |
| double3x3(uint) | Returns a double3x3 matrix constructed from a single uint value by converting it to double and assigning it to every component. |
| double3x3(bool3x3) | Return a double3x3 matrix constructed from a bool3x3 matrix by componentwise conversion. |
| double3x3(double3, double3, double3) | Returns a double3x3 matrix constructed from three double3 vectors. |
| double3x3(float3x3) | Return a double3x3 matrix constructed from a float3x3 matrix by componentwise conversion. |
| double3x3(int3x3) | Return a double3x3 matrix constructed from a int3x3 matrix by componentwise conversion. |
| double3x3(uint3x3) | Return a double3x3 matrix constructed from a uint3x3 matrix by componentwise conversion. |
| double3x4(bool) | Returns a double3x4 matrix constructed from a single bool value by converting it to double and assigning it to every component. |
| double3x4(double) | Returns a double3x4 matrix constructed from a single double value by assigning it to every component. |
| double3x4(double, double, double, double, double, double, double, double, double, double, double, double) | Returns a double3x4 matrix constructed from from 12 double values given in row-major order. |
| double3x4(int) | Returns a double3x4 matrix constructed from a single int value by converting it to double and assigning it to every component. |
| double3x4(float) | Returns a double3x4 matrix constructed from a single float value by converting it to double and assigning it to every component. |
| double3x4(uint) | Returns a double3x4 matrix constructed from a single uint value by converting it to double and assigning it to every component. |
| double3x4(bool3x4) | Return a double3x4 matrix constructed from a bool3x4 matrix by componentwise conversion. |
| double3x4(double3, double3, double3, double3) | Returns a double3x4 matrix constructed from four double3 vectors. |
| double3x4(float3x4) | Return a double3x4 matrix constructed from a float3x4 matrix by componentwise conversion. |
| double3x4(int3x4) | Return a double3x4 matrix constructed from a int3x4 matrix by componentwise conversion. |
| double3x4(uint3x4) | Return a double3x4 matrix constructed from a uint3x4 matrix by componentwise conversion. |
| double4(bool) | Returns a double4 vector constructed from a single bool value by converting it to double and assigning it to every component. |
| double4(double) | Returns a double4 vector constructed from a single double value by assigning it to every component. |
| double4(double, double, double, double) | Returns a double4 vector constructed from four double values. |
| double4(double, double, double2) | Returns a double4 vector constructed from two double values and a double2 vector. |
| double4(double, double2, double) | Returns a double4 vector constructed from a double value, a double2 vector and a double value. |
| double4(double, double3) | Returns a double4 vector constructed from a double value and a double3 vector. |
| double4(int) | Returns a double4 vector constructed from a single int value by converting it to double and assigning it to every component. |
| double4(float) | Returns a double4 vector constructed from a single float value by converting it to double and assigning it to every component. |
| double4(uint) | Returns a double4 vector constructed from a single uint value by converting it to double and assigning it to every component. |
| double4(bool4) | Return a double4 vector constructed from a bool4 vector by componentwise conversion. |
| double4(double2, double, double) | Returns a double4 vector constructed from a double2 vector and two double values. |
| double4(double2, double2) | Returns a double4 vector constructed from two double2 vectors. |
| double4(double3, double) | Returns a double4 vector constructed from a double3 vector and a double value. |
| double4(double4) | Returns a double4 vector constructed from a double4 vector. |
| double4(float4) | Return a double4 vector constructed from a float4 vector by componentwise conversion. |
| double4(half) | Returns a double4 vector constructed from a single half value by converting it to double and assigning it to every component. |
| double4(half4) | Return a double4 vector constructed from a half4 vector by componentwise conversion. |
| double4(int4) | Return a double4 vector constructed from a int4 vector by componentwise conversion. |
| double4(uint4) | Return a double4 vector constructed from a uint4 vector by componentwise conversion. |
| double4x2(bool) | Returns a double4x2 matrix constructed from a single bool value by converting it to double and assigning it to every component. |
| double4x2(double) | Returns a double4x2 matrix constructed from a single double value by assigning it to every component. |
| double4x2(double, double, double, double, double, double, double, double) | Returns a double4x2 matrix constructed from from 8 double values given in row-major order. |
| double4x2(int) | Returns a double4x2 matrix constructed from a single int value by converting it to double and assigning it to every component. |
| double4x2(float) | Returns a double4x2 matrix constructed from a single float value by converting it to double and assigning it to every component. |
| double4x2(uint) | Returns a double4x2 matrix constructed from a single uint value by converting it to double and assigning it to every component. |
| double4x2(bool4x2) | Return a double4x2 matrix constructed from a bool4x2 matrix by componentwise conversion. |
| double4x2(double4, double4) | Returns a double4x2 matrix constructed from two double4 vectors. |
| double4x2(float4x2) | Return a double4x2 matrix constructed from a float4x2 matrix by componentwise conversion. |
| double4x2(int4x2) | Return a double4x2 matrix constructed from a int4x2 matrix by componentwise conversion. |
| double4x2(uint4x2) | Return a double4x2 matrix constructed from a uint4x2 matrix by componentwise conversion. |
| double4x3(bool) | Returns a double4x3 matrix constructed from a single bool value by converting it to double and assigning it to every component. |
| double4x3(double) | Returns a double4x3 matrix constructed from a single double value by assigning it to every component. |
| double4x3(double, double, double, double, double, double, double, double, double, double, double, double) | Returns a double4x3 matrix constructed from from 12 double values given in row-major order. |
| double4x3(int) | Returns a double4x3 matrix constructed from a single int value by converting it to double and assigning it to every component. |
| double4x3(float) | Returns a double4x3 matrix constructed from a single float value by converting it to double and assigning it to every component. |
| double4x3(uint) | Returns a double4x3 matrix constructed from a single uint value by converting it to double and assigning it to every component. |
| double4x3(bool4x3) | Return a double4x3 matrix constructed from a bool4x3 matrix by componentwise conversion. |
| double4x3(double4, double4, double4) | Returns a double4x3 matrix constructed from three double4 vectors. |
| double4x3(float4x3) | Return a double4x3 matrix constructed from a float4x3 matrix by componentwise conversion. |
| double4x3(int4x3) | Return a double4x3 matrix constructed from a int4x3 matrix by componentwise conversion. |
| double4x3(uint4x3) | Return a double4x3 matrix constructed from a uint4x3 matrix by componentwise conversion. |
| double4x4(bool) | Returns a double4x4 matrix constructed from a single bool value by converting it to double and assigning it to every component. |
| double4x4(double) | Returns a double4x4 matrix constructed from a single double value by assigning it to every component. |
| double4x4(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double) | Returns a double4x4 matrix constructed from from 16 double values given in row-major order. |
| double4x4(int) | Returns a double4x4 matrix constructed from a single int value by converting it to double and assigning it to every component. |
| double4x4(float) | Returns a double4x4 matrix constructed from a single float value by converting it to double and assigning it to every component. |
| double4x4(uint) | Returns a double4x4 matrix constructed from a single uint value by converting it to double and assigning it to every component. |
| double4x4(bool4x4) | Return a double4x4 matrix constructed from a bool4x4 matrix by componentwise conversion. |
| double4x4(double4, double4, double4, double4) | Returns a double4x4 matrix constructed from four double4 vectors. |
| double4x4(float4x4) | Return a double4x4 matrix constructed from a float4x4 matrix by componentwise conversion. |
| double4x4(int4x4) | Return a double4x4 matrix constructed from a int4x4 matrix by componentwise conversion. |
| double4x4(uint4x4) | Return a double4x4 matrix constructed from a uint4x4 matrix by componentwise conversion. |
| down() | Unity's down axis (0, -1, 0). |
| exp(double) | Returns the base-e exponential of x. |
| exp(float) | Returns the base-e exponential of x. |
| exp(double2) | Returns the componentwise base-e exponential of x. |
| exp(double3) | Returns the componentwise base-e exponential of x. |
| exp(double4) | Returns the componentwise base-e exponential of x. |
| exp(float2) | Returns the componentwise base-e exponential of x. |
| exp(float3) | Returns the componentwise base-e exponential of x. |
| exp(float4) | Returns the componentwise base-e exponential of x. |
| exp(quaternion) | Returns the natural exponent of a quaternion. |
| exp10(double) | Returns the base-10 exponential of x. |
| exp10(float) | Returns the base-10 exponential of x. |
| exp10(double2) | Returns the componentwise base-10 exponential of x. |
| exp10(double3) | Returns the componentwise base-10 exponential of x. |
| exp10(double4) | Returns the componentwise base-10 exponential of x. |
| exp10(float2) | Returns the componentwise base-10 exponential of x. |
| exp10(float3) | Returns the componentwise base-10 exponential of x. |
| exp10(float4) | Returns the componentwise base-10 exponential of x. |
| exp2(double) | Returns the base-2 exponential of x. |
| exp2(float) | Returns the base-2 exponential of x. |
| exp2(double2) | Returns the componentwise base-2 exponential of x. |
| exp2(double3) | Returns the componentwise base-2 exponential of x. |
| exp2(double4) | Returns the componentwise base-2 exponential of x. |
| exp2(float2) | Returns the componentwise base-2 exponential of x. |
| exp2(float3) | Returns the componentwise base-2 exponential of x. |
| exp2(float4) | Returns the componentwise base-2 exponential of x. |
| f16tof32(uint) | Returns the floating point representation of a half-precision floating point value. |
| f16tof32(uint2) | Returns the floating point representation of a half-precision floating point vector. |
| f16tof32(uint3) | Returns the floating point representation of a half-precision floating point vector. |
| f16tof32(uint4) | Returns the floating point representation of a half-precision floating point vector. |
| f32tof16(float) | Returns the result converting a float value to its nearest half-precision floating point representation. |
| f32tof16(float2) | Returns the result of a componentwise conversion of a float2 vector to its nearest half-precision floating point representation. |
| f32tof16(float3) | Returns the result of a componentwise conversion of a float3 vector to its nearest half-precision floating point representation. |
| f32tof16(float4) | Returns the result of a componentwise conversion of a float4 vector to its nearest half-precision floating point representation. |
| faceforward(double2, double2, double2) | 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. |
| faceforward(double3, double3, double3) | 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. |
| faceforward(double4, double4, double4) | 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. |
| faceforward(float2, float2, float2) | 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. |
| faceforward(float3, float3, float3) | 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. |
| faceforward(float4, float4, float4) | 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(double3x4) | Fast matrix inverse for rigid transforms (orthonormal basis and translation) |
| fastinverse(double4x4) | Fast matrix inverse for rigid transforms (orthonormal basis and translation) |
| fastinverse(float3x4) | Fast matrix inverse for rigid transforms (orthonormal basis and translation) |
| fastinverse(float4x4) | Fast matrix inverse for rigid transforms (orthonormal basis and translation) |
| float2(bool) | Returns a float2 vector constructed from a single bool value by converting it to float and assigning it to every component. |
| float2(double) | Returns a float2 vector constructed from a single double value by converting it to float and assigning it to every component. |
| float2(int) | Returns a float2 vector constructed from a single int value by converting it to float and assigning it to every component. |
| float2(float) | Returns a float2 vector constructed from a single float value by assigning it to every component. |
| float2(float, float) | Returns a float2 vector constructed from two float values. |
| float2(uint) | Returns a float2 vector constructed from a single uint value by converting it to float and assigning it to every component. |
| float2(bool2) | Return a float2 vector constructed from a bool2 vector by componentwise conversion. |
| float2(double2) | Return a float2 vector constructed from a double2 vector by componentwise conversion. |
| float2(float2) | Returns a float2 vector constructed from a float2 vector. |
| float2(half) | Returns a float2 vector constructed from a single half value by converting it to float and assigning it to every component. |
| float2(half2) | Return a float2 vector constructed from a half2 vector by componentwise conversion. |
| float2(int2) | Return a float2 vector constructed from a int2 vector by componentwise conversion. |
| float2(uint2) | Return a float2 vector constructed from a uint2 vector by componentwise conversion. |
| float2x2(bool) | Returns a float2x2 matrix constructed from a single bool value by converting it to float and assigning it to every component. |
| float2x2(double) | Returns a float2x2 matrix constructed from a single double value by converting it to float and assigning it to every component. |
| float2x2(int) | Returns a float2x2 matrix constructed from a single int value by converting it to float and assigning it to every component. |
| float2x2(float) | Returns a float2x2 matrix constructed from a single float value by assigning it to every component. |
| float2x2(float, float, float, float) | Returns a float2x2 matrix constructed from from 4 float values given in row-major order. |
| float2x2(uint) | Returns a float2x2 matrix constructed from a single uint value by converting it to float and assigning it to every component. |
| float2x2(bool2x2) | Return a float2x2 matrix constructed from a bool2x2 matrix by componentwise conversion. |
| float2x2(double2x2) | Return a float2x2 matrix constructed from a double2x2 matrix by componentwise conversion. |
| float2x2(float2, float2) | Returns a float2x2 matrix constructed from two float2 vectors. |
| float2x2(int2x2) | Return a float2x2 matrix constructed from a int2x2 matrix by componentwise conversion. |
| float2x2(uint2x2) | Return a float2x2 matrix constructed from a uint2x2 matrix by componentwise conversion. |
| float2x3(bool) | Returns a float2x3 matrix constructed from a single bool value by converting it to float and assigning it to every component. |
| float2x3(double) | Returns a float2x3 matrix constructed from a single double value by converting it to float and assigning it to every component. |
| float2x3(int) | Returns a float2x3 matrix constructed from a single int value by converting it to float and assigning it to every component. |
| float2x3(float) | Returns a float2x3 matrix constructed from a single float value by assigning it to every component. |
| float2x3(float, float, float, float, float, float) | Returns a float2x3 matrix constructed from from 6 float values given in row-major order. |
| float2x3(uint) | Returns a float2x3 matrix constructed from a single uint value by converting it to float and assigning it to every component. |
| float2x3(bool2x3) | Return a float2x3 matrix constructed from a bool2x3 matrix by componentwise conversion. |
| float2x3(double2x3) | Return a float2x3 matrix constructed from a double2x3 matrix by componentwise conversion. |
| float2x3(float2, float2, float2) | Returns a float2x3 matrix constructed from three float2 vectors. |
| float2x3(int2x3) | Return a float2x3 matrix constructed from a int2x3 matrix by componentwise conversion. |
| float2x3(uint2x3) | Return a float2x3 matrix constructed from a uint2x3 matrix by componentwise conversion. |
| float2x4(bool) | Returns a float2x4 matrix constructed from a single bool value by converting it to float and assigning it to every component. |
| float2x4(double) | Returns a float2x4 matrix constructed from a single double value by converting it to float and assigning it to every component. |
| float2x4(int) | Returns a float2x4 matrix constructed from a single int value by converting it to float and assigning it to every component. |
| float2x4(float) | Returns a float2x4 matrix constructed from a single float value by assigning it to every component. |
| float2x4(float, float, float, float, float, float, float, float) | Returns a float2x4 matrix constructed from from 8 float values given in row-major order. |
| float2x4(uint) | Returns a float2x4 matrix constructed from a single uint value by converting it to float and assigning it to every component. |
| float2x4(bool2x4) | Return a float2x4 matrix constructed from a bool2x4 matrix by componentwise conversion. |
| float2x4(double2x4) | Return a float2x4 matrix constructed from a double2x4 matrix by componentwise conversion. |
| float2x4(float2, float2, float2, float2) | Returns a float2x4 matrix constructed from four float2 vectors. |
| float2x4(int2x4) | Return a float2x4 matrix constructed from a int2x4 matrix by componentwise conversion. |
| float2x4(uint2x4) | Return a float2x4 matrix constructed from a uint2x4 matrix by componentwise conversion. |
| float3(bool) | Returns a float3 vector constructed from a single bool value by converting it to float and assigning it to every component. |
| float3(double) | Returns a float3 vector constructed from a single double value by converting it to float and assigning it to every component. |
| float3(int) | Returns a float3 vector constructed from a single int value by converting it to float and assigning it to every component. |
| float3(float) | Returns a float3 vector constructed from a single float value by assigning it to every component. |
| float3(float, float, float) | Returns a float3 vector constructed from three float values. |
| float3(float, float2) | Returns a float3 vector constructed from a float value and a float2 vector. |
| float3(uint) | Returns a float3 vector constructed from a single uint value by converting it to float and assigning it to every component. |
| float3(bool3) | Return a float3 vector constructed from a bool3 vector by componentwise conversion. |
| float3(double3) | Return a float3 vector constructed from a double3 vector by componentwise conversion. |
| float3(float2, float) | Returns a float3 vector constructed from a float2 vector and a float value. |
| float3(float3) | Returns a float3 vector constructed from a float3 vector. |
| float3(half) | Returns a float3 vector constructed from a single half value by converting it to float and assigning it to every component. |
| float3(half3) | Return a float3 vector constructed from a half3 vector by componentwise conversion. |
| float3(int3) | Return a float3 vector constructed from a int3 vector by componentwise conversion. |
| float3(uint3) | Return a float3 vector constructed from a uint3 vector by componentwise conversion. |
| float3x2(bool) | Returns a float3x2 matrix constructed from a single bool value by converting it to float and assigning it to every component. |
| float3x2(double) | Returns a float3x2 matrix constructed from a single double value by converting it to float and assigning it to every component. |
| float3x2(int) | Returns a float3x2 matrix constructed from a single int value by converting it to float and assigning it to every component. |
| float3x2(float) | Returns a float3x2 matrix constructed from a single float value by assigning it to every component. |
| float3x2(float, float, float, float, float, float) | Returns a float3x2 matrix constructed from from 6 float values given in row-major order. |
| float3x2(uint) | Returns a float3x2 matrix constructed from a single uint value by converting it to float and assigning it to every component. |
| float3x2(bool3x2) | Return a float3x2 matrix constructed from a bool3x2 matrix by componentwise conversion. |
| float3x2(double3x2) | Return a float3x2 matrix constructed from a double3x2 matrix by componentwise conversion. |
| float3x2(float3, float3) | Returns a float3x2 matrix constructed from two float3 vectors. |
| float3x2(int3x2) | Return a float3x2 matrix constructed from a int3x2 matrix by componentwise conversion. |
| float3x2(uint3x2) | Return a float3x2 matrix constructed from a uint3x2 matrix by componentwise conversion. |
| float3x3(bool) | Returns a float3x3 matrix constructed from a single bool value by converting it to float and assigning it to every component. |
| float3x3(double) | Returns a float3x3 matrix constructed from a single double value by converting it to float and assigning it to every component. |
| float3x3(int) | Returns a float3x3 matrix constructed from a single int value by converting it to float and assigning it to every component. |
| float3x3(float) | Returns a float3x3 matrix constructed from a single float value by assigning it to every component. |
| float3x3(float, float, float, float, float, float, float, float, float) | Returns a float3x3 matrix constructed from from 9 float values given in row-major order. |
| float3x3(uint) | Returns a float3x3 matrix constructed from a single uint value by converting it to float and assigning it to every component. |
| float3x3(bool3x3) | Return a float3x3 matrix constructed from a bool3x3 matrix by componentwise conversion. |
| float3x3(double3x3) | Return a float3x3 matrix constructed from a double3x3 matrix by componentwise conversion. |
| float3x3(float3, float3, float3) | Returns a float3x3 matrix constructed from three float3 vectors. |
| float3x3(float4x4) | Extracts a float3x3 from the upper left 3x3 of a float4x4. |
| float3x3(int3x3) | Return a float3x3 matrix constructed from a int3x3 matrix by componentwise conversion. |
| float3x3(quaternion) | Returns a float3x3 matrix constructed from a quaternion. |
| float3x3(uint3x3) | Return a float3x3 matrix constructed from a uint3x3 matrix by componentwise conversion. |
| float3x4(bool) | Returns a float3x4 matrix constructed from a single bool value by converting it to float and assigning it to every component. |
| float3x4(double) | Returns a float3x4 matrix constructed from a single double value by converting it to float and assigning it to every component. |
| float3x4(int) | Returns a float3x4 matrix constructed from a single int value by converting it to float and assigning it to every component. |
| float3x4(float) | Returns a float3x4 matrix constructed from a single float value by assigning it to every component. |
| float3x4(float, float, float, float, float, float, float, float, float, float, float, float) | Returns a float3x4 matrix constructed from from 12 float values given in row-major order. |
| float3x4(uint) | Returns a float3x4 matrix constructed from a single uint value by converting it to float and assigning it to every component. |
| float3x4(AffineTransform) | Returns a float3x4 matrix constructed from an AffineTransform. |
| float3x4(bool3x4) | Return a float3x4 matrix constructed from a bool3x4 matrix by componentwise conversion. |
| float3x4(double3x4) | Return a float3x4 matrix constructed from a double3x4 matrix by componentwise conversion. |
| float3x4(float3, float3, float3, float3) | Returns a float3x4 matrix constructed from four float3 vectors. |
| float3x4(int3x4) | Return a float3x4 matrix constructed from a int3x4 matrix by componentwise conversion. |
| float3x4(uint3x4) | Return a float3x4 matrix constructed from a uint3x4 matrix by componentwise conversion. |
| float4(bool) | Returns a float4 vector constructed from a single bool value by converting it to float and assigning it to every component. |
| float4(double) | Returns a float4 vector constructed from a single double value by converting it to float and assigning it to every component. |
| float4(int) | Returns a float4 vector constructed from a single int value by converting it to float and assigning it to every component. |
| float4(float) | Returns a float4 vector constructed from a single float value by assigning it to every component. |
| float4(float, float, float, float) | Returns a float4 vector constructed from four float values. |
| float4(float, float, float2) | Returns a float4 vector constructed from two float values and a float2 vector. |
| float4(float, float2, float) | Returns a float4 vector constructed from a float value, a float2 vector and a float value. |
| float4(float, float3) | Returns a float4 vector constructed from a float value and a float3 vector. |
| float4(uint) | Returns a float4 vector constructed from a single uint value by converting it to float and assigning it to every component. |
| float4(bool4) | Return a float4 vector constructed from a bool4 vector by componentwise conversion. |
| float4(double4) | Return a float4 vector constructed from a double4 vector by componentwise conversion. |
| float4(float2, float, float) | Returns a float4 vector constructed from a float2 vector and two float values. |
| float4(float2, float2) | Returns a float4 vector constructed from two float2 vectors. |
| float4(float3, float) | Returns a float4 vector constructed from a float3 vector and a float value. |
| float4(float4) | Returns a float4 vector constructed from a float4 vector. |
| float4(half) | Returns a float4 vector constructed from a single half value by converting it to float and assigning it to every component. |
| float4(half4) | Return a float4 vector constructed from a half4 vector by componentwise conversion. |
| float4(int4) | Return a float4 vector constructed from a int4 vector by componentwise conversion. |
| float4(uint4) | Return a float4 vector constructed from a uint4 vector by componentwise conversion. |
| float4x2(bool) | Returns a float4x2 matrix constructed from a single bool value by converting it to float and assigning it to every component. |
| float4x2(double) | Returns a float4x2 matrix constructed from a single double value by converting it to float and assigning it to every component. |
| float4x2(int) | Returns a float4x2 matrix constructed from a single int value by converting it to float and assigning it to every component. |
| float4x2(float) | Returns a float4x2 matrix constructed from a single float value by assigning it to every component. |
| float4x2(float, float, float, float, float, float, float, float) | Returns a float4x2 matrix constructed from from 8 float values given in row-major order. |
| float4x2(uint) | Returns a float4x2 matrix constructed from a single uint value by converting it to float and assigning it to every component. |
| float4x2(bool4x2) | Return a float4x2 matrix constructed from a bool4x2 matrix by componentwise conversion. |
| float4x2(double4x2) | Return a float4x2 matrix constructed from a double4x2 matrix by componentwise conversion. |
| float4x2(float4, float4) | Returns a float4x2 matrix constructed from two float4 vectors. |
| float4x2(int4x2) | Return a float4x2 matrix constructed from a int4x2 matrix by componentwise conversion. |
| float4x2(uint4x2) | Return a float4x2 matrix constructed from a uint4x2 matrix by componentwise conversion. |
| float4x3(bool) | Returns a float4x3 matrix constructed from a single bool value by converting it to float and assigning it to every component. |
| float4x3(double) | Returns a float4x3 matrix constructed from a single double value by converting it to float and assigning it to every component. |
| float4x3(int) | Returns a float4x3 matrix constructed from a single int value by converting it to float and assigning it to every component. |
| float4x3(float) | Returns a float4x3 matrix constructed from a single float value by assigning it to every component. |
| float4x3(float, float, float, float, float, float, float, float, float, float, float, float) | Returns a float4x3 matrix constructed from from 12 float values given in row-major order. |
| float4x3(uint) | Returns a float4x3 matrix constructed from a single uint value by converting it to float and assigning it to every component. |
| float4x3(bool4x3) | Return a float4x3 matrix constructed from a bool4x3 matrix by componentwise conversion. |
| float4x3(double4x3) | Return a float4x3 matrix constructed from a double4x3 matrix by componentwise conversion. |
| float4x3(float4, float4, float4) | Returns a float4x3 matrix constructed from three float4 vectors. |
| float4x3(int4x3) | Return a float4x3 matrix constructed from a int4x3 matrix by componentwise conversion. |
| float4x3(uint4x3) | Return a float4x3 matrix constructed from a uint4x3 matrix by componentwise conversion. |
| float4x4(bool) | Returns a float4x4 matrix constructed from a single bool value by converting it to float and assigning it to every component. |
| float4x4(double) | Returns a float4x4 matrix constructed from a single double value by converting it to float and assigning it to every component. |
| float4x4(int) | Returns a float4x4 matrix constructed from a single int value by converting it to float and assigning it to every component. |
| float4x4(float) | Returns a float4x4 matrix constructed from a single float value by assigning it to every component. |
| float4x4(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float) | Returns a float4x4 matrix constructed from from 16 float values given in row-major order. |
| float4x4(uint) | Returns a float4x4 matrix constructed from a single uint value by converting it to float and assigning it to every component. |
| float4x4(AffineTransform) | Returns a float4x4 matrix constructed from an AffineTransform. |
| float4x4(RigidTransform) | Returns a float4x4 constructed from a RigidTransform. |
| float4x4(bool4x4) | Return a float4x4 matrix constructed from a bool4x4 matrix by componentwise conversion. |
| float4x4(double4x4) | Return a float4x4 matrix constructed from a double4x4 matrix by componentwise conversion. |
| float4x4(float3x3, float3) | Returns a float4x4 constructed from a float3x3 rotation matrix and a float3 translation vector. |
| float4x4(float4, float4, float4, float4) | Returns a float4x4 matrix constructed from four float4 vectors. |
| float4x4(int4x4) | Return a float4x4 matrix constructed from a int4x4 matrix by componentwise conversion. |
| float4x4(quaternion, float3) | Returns a float4x4 constructed from a quaternion and a float3 translation vector. |
| float4x4(uint4x4) | Return a float4x4 matrix constructed from a uint4x4 matrix by componentwise conversion. |
| floor(double) | Returns the result of rounding a double value up to the nearest integral value less or equal to the original value. |
| floor(float) | Returns the result of rounding a float value up to the nearest integral value less or equal to the original value. |
| floor(double2) | Returns the result of rounding each component of a double2 vector value down to the nearest value less or equal to the original value. |
| floor(double3) | Returns the result of rounding each component of a double3 vector value down to the nearest value less or equal to the original value. |
| floor(double4) | Returns the result of rounding each component of a double4 vector value down to the nearest value less or equal to the original value. |
| floor(float2) | Returns the result of rounding each component of a float2 vector value down to the nearest value less or equal to the original value. |
| floor(float3) | Returns the result of rounding each component of a float3 vector value down to the nearest value less or equal to the original value. |
| floor(float4) | Returns the result of rounding each component of a float4 vector value down to the nearest value less or equal to the original value. |
| floorlog2(int) | Computes the floor of the base-2 logarithm of x. |
| floorlog2(uint) | Computes the floor of the base-2 logarithm of x. |
| floorlog2(int2) | Computes the componentwise floor of the base-2 logarithm of x. |
| floorlog2(int3) | Computes the componentwise floor of the base-2 logarithm of x. |
| floorlog2(int4) | Computes the componentwise floor of the base-2 logarithm of x. |
| floorlog2(uint2) | Computes the componentwise floor of the base-2 logarithm of x. |
| floorlog2(uint3) | Computes the componentwise floor of the base-2 logarithm of x. |
| floorlog2(uint4) | Computes the componentwise floor of the base-2 logarithm of x. |
| fmod(double, double) | Returns the double precision floating point remainder of x/y. |
| fmod(float, float) | Returns the floating point remainder of x/y. |
| fmod(double2, double2) | Returns the componentwise double precision floating point remainder of x/y. |
| fmod(double3, double3) | Returns the componentwise double precision floating point remainder of x/y. |
| fmod(double4, double4) | Returns the componentwise double precision floating point remainder of x/y. |
| fmod(float2, float2) | Returns the componentwise floating point remainder of x/y. |
| fmod(float3, float3) | Returns the componentwise floating point remainder of x/y. |
| fmod(float4, float4) | Returns the componentwise floating point remainder of x/y. |
| forward() | Unity's forward axis (0, 0, 1). |
| forward(quaternion) | Transforms the forward vector by a quaternion. |
| frac(double) | Returns the fractional part of a double value. |
| frac(float) | Returns the fractional part of a float value. |
| frac(double2) | Returns the componentwise fractional parts of a double2 vector. |
| frac(double3) | Returns the componentwise fractional parts of a double3 vector. |
| frac(double4) | Returns the componentwise fractional parts of a double4 vector. |
| frac(float2) | Returns the componentwise fractional parts of a float2 vector. |
| frac(float3) | Returns the componentwise fractional parts of a float3 vector. |
| frac(float4) | Returns the componentwise fractional parts of a float4 vector. |
| half(double) | Returns a half value constructed from a double value. |
| half(float) | Returns a half value constructed from a float value. |
| half(half) | Returns a half value constructed from a half values. |
| half2(double) | Returns a half2 vector constructed from a single double value by converting it to half and assigning it to every component. |
| half2(float) | Returns a half2 vector constructed from a single float value by converting it to half and assigning it to every component. |
| half2(double2) | Return a half2 vector constructed from a double2 vector by componentwise conversion. |
| half2(float2) | Return a half2 vector constructed from a float2 vector by componentwise conversion. |
| half2(half) | Returns a half2 vector constructed from a single half value by assigning it to every component. |
| half2(half, half) | Returns a half2 vector constructed from two half values. |
| half2(half2) | Returns a half2 vector constructed from a half2 vector. |
| half3(double) | Returns a half3 vector constructed from a single double value by converting it to half and assigning it to every component. |
| half3(float) | Returns a half3 vector constructed from a single float value by converting it to half and assigning it to every component. |
| half3(double3) | Return a half3 vector constructed from a double3 vector by componentwise conversion. |
| half3(float3) | Return a half3 vector constructed from a float3 vector by componentwise conversion. |
| half3(half) | Returns a half3 vector constructed from a single half value by assigning it to every component. |
| half3(half, half, half) | Returns a half3 vector constructed from three half values. |
| half3(half, half2) | Returns a half3 vector constructed from a half value and a half2 vector. |
| half3(half2, half) | Returns a half3 vector constructed from a half2 vector and a half value. |
| half3(half3) | Returns a half3 vector constructed from a half3 vector. |
| half4(double) | Returns a half4 vector constructed from a single double value by converting it to half and assigning it to every component. |
| half4(float) | Returns a half4 vector constructed from a single float value by converting it to half and assigning it to every component. |
| half4(double4) | Return a half4 vector constructed from a double4 vector by componentwise conversion. |
| half4(float4) | Return a half4 vector constructed from a float4 vector by componentwise conversion. |
| half4(half) | Returns a half4 vector constructed from a single half value by assigning it to every component. |
| half4(half, half, half, half) | Returns a half4 vector constructed from four half values. |
| half4(half, half, half2) | Returns a half4 vector constructed from two half values and a half2 vector. |
| half4(half, half2, half) | Returns a half4 vector constructed from a half value, a half2 vector and a half value. |
| half4(half, half3) | Returns a half4 vector constructed from a half value and a half3 vector. |
| half4(half2, half, half) | Returns a half4 vector constructed from a half2 vector and two half values. |
| half4(half2, half2) | Returns a half4 vector constructed from two half2 vectors. |
| half4(half3, half) | Returns a half4 vector constructed from a half3 vector and a half value. |
| half4(half4) | Returns a half4 vector constructed from a half4 vector. |
| hash(void*, int, uint) | Returns a uint hash from a block of memory using the xxhash32 algorithm. Can only be used in an unsafe context. |
| hash(AffineTransform) | Returns a uint hash code of an AffineTransform. |
| hash(RigidTransform) | Returns a uint hash code of a RigidTransform. |
| hash(bool2) | Returns a uint hash code of a bool2 vector. |
| hash(bool2x2) | Returns a uint hash code of a bool2x2 matrix. |
| hash(bool2x3) | Returns a uint hash code of a bool2x3 matrix. |
| hash(bool2x4) | Returns a uint hash code of a bool2x4 matrix. |
| hash(bool3) | Returns a uint hash code of a bool3 vector. |
| hash(bool3x2) | Returns a uint hash code of a bool3x2 matrix. |
| hash(bool3x3) | Returns a uint hash code of a bool3x3 matrix. |
| hash(bool3x4) | Returns a uint hash code of a bool3x4 matrix. |
| hash(bool4) | Returns a uint hash code of a bool4 vector. |
| hash(bool4x2) | Returns a uint hash code of a bool4x2 matrix. |
| hash(bool4x3) | Returns a uint hash code of a bool4x3 matrix. |
| hash(bool4x4) | Returns a uint hash code of a bool4x4 matrix. |
| hash(double2) | Returns a uint hash code of a double2 vector. |
| hash(double2x2) | Returns a uint hash code of a double2x2 matrix. |
| hash(double2x3) | Returns a uint hash code of a double2x3 matrix. |
| hash(double2x4) | Returns a uint hash code of a double2x4 matrix. |
| hash(double3) | Returns a uint hash code of a double3 vector. |
| hash(double3x2) | Returns a uint hash code of a double3x2 matrix. |
| hash(double3x3) | Returns a uint hash code of a double3x3 matrix. |
| hash(double3x4) | Returns a uint hash code of a double3x4 matrix. |
| hash(double4) | Returns a uint hash code of a double4 vector. |
| hash(double4x2) | Returns a uint hash code of a double4x2 matrix. |
| hash(double4x3) | Returns a uint hash code of a double4x3 matrix. |
| hash(double4x4) | Returns a uint hash code of a double4x4 matrix. |
| hash(float2) | Returns a uint hash code of a float2 vector. |
| hash(float2x2) | Returns a uint hash code of a float2x2 matrix. |
| hash(float2x3) | Returns a uint hash code of a float2x3 matrix. |
| hash(float2x4) | Returns a uint hash code of a float2x4 matrix. |
| hash(float3) | Returns a uint hash code of a float3 vector. |
| hash(float3x2) | Returns a uint hash code of a float3x2 matrix. |
| hash(float3x3) | Returns a uint hash code of a float3x3 matrix. |
| hash(float3x4) | Returns a uint hash code of a float3x4 matrix. |
| hash(float4) | Returns a uint hash code of a float4 vector. |
| hash(float4x2) | Returns a uint hash code of a float4x2 matrix. |
| hash(float4x3) | Returns a uint hash code of a float4x3 matrix. |
| hash(float4x4) | Returns a uint hash code of a float4x4 matrix. |
| hash(half) | Returns a uint hash code of a half value. |
| hash(half2) | Returns a uint hash code of a half2 vector. |
| hash(half3) | Returns a uint hash code of a half3 vector. |
| hash(half4) | Returns a uint hash code of a half4 vector. |
| hash(int2) | Returns a uint hash code of a int2 vector. |
| hash(int2x2) | Returns a uint hash code of a int2x2 matrix. |
| hash(int2x3) | Returns a uint hash code of a int2x3 matrix. |
| hash(int2x4) | Returns a uint hash code of a int2x4 matrix. |
| hash(int3) | Returns a uint hash code of a int3 vector. |
| hash(int3x2) | Returns a uint hash code of a int3x2 matrix. |
| hash(int3x3) | Returns a uint hash code of a int3x3 matrix. |
| hash(int3x4) | Returns a uint hash code of a int3x4 matrix. |
| hash(int4) | Returns a uint hash code of a int4 vector. |
| hash(int4x2) | Returns a uint hash code of a int4x2 matrix. |
| hash(int4x3) | Returns a uint hash code of a int4x3 matrix. |
| hash(int4x4) | Returns a uint hash code of a int4x4 matrix. |
| hash(quaternion) | Returns a uint hash code of a quaternion. |
| hash(uint2) | Returns a uint hash code of a uint2 vector. |
| hash(uint2x2) | Returns a uint hash code of a uint2x2 matrix. |
| hash(uint2x3) | Returns a uint hash code of a uint2x3 matrix. |
| hash(uint2x4) | Returns a uint hash code of a uint2x4 matrix. |
| hash(uint3) | Returns a uint hash code of a uint3 vector. |
| hash(uint3x2) | Returns a uint hash code of a uint3x2 matrix. |
| hash(uint3x3) | Returns a uint hash code of a uint3x3 matrix. |
| hash(uint3x4) | Returns a uint hash code of a uint3x4 matrix. |
| hash(uint4) | Returns a uint hash code of a uint4 vector. |
| hash(uint4x2) | Returns a uint hash code of a uint4x2 matrix. |
| hash(uint4x3) | Returns a uint hash code of a uint4x3 matrix. |
| hash(uint4x4) | Returns a uint hash code of a uint4x4 matrix. |
| hashwide(AffineTransform) | 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. |
| hashwide(RigidTransform) | Returns a uint4 vector hash code of a RigidTransform. 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. |
| hashwide(bool2) | Returns a uint2 vector hash code of a bool2 vector. 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. |
| hashwide(bool2x2) | Returns a uint2 vector hash code of a bool2x2 matrix. 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. |
| hashwide(bool2x3) | Returns a uint2 vector hash code of a bool2x3 matrix. 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. |
| hashwide(bool2x4) | Returns a uint2 vector hash code of a bool2x4 matrix. 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. |
| hashwide(bool3) | Returns a uint3 vector hash code of a bool3 vector. 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. |
| hashwide(bool3x2) | Returns a uint3 vector hash code of a bool3x2 matrix. 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. |
| hashwide(bool3x3) | Returns a uint3 vector hash code of a bool3x3 matrix. 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. |
| hashwide(bool3x4) | Returns a uint3 vector hash code of a bool3x4 matrix. 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. |
| hashwide(bool4) | Returns a uint4 vector hash code of a bool4 vector. 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. |
| hashwide(bool4x2) | Returns a uint4 vector hash code of a bool4x2 matrix. 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. |
| hashwide(bool4x3) | Returns a uint4 vector hash code of a bool4x3 matrix. 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. |
| hashwide(bool4x4) | Returns a uint4 vector hash code of a bool4x4 matrix. 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. |
| hashwide(double2) | Returns a uint2 vector hash code of a double2 vector. 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. |
| hashwide(double2x2) | Returns a uint2 vector hash code of a double2x2 matrix. 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. |
| hashwide(double2x3) | Returns a uint2 vector hash code of a double2x3 matrix. 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. |
| hashwide(double2x4) | Returns a uint2 vector hash code of a double2x4 matrix. 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. |
| hashwide(double3) | Returns a uint3 vector hash code of a double3 vector. 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. |
| hashwide(double3x2) | Returns a uint3 vector hash code of a double3x2 matrix. 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. |
| hashwide(double3x3) | Returns a uint3 vector hash code of a double3x3 matrix. 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. |
| hashwide(double3x4) | Returns a uint3 vector hash code of a double3x4 matrix. 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. |
| hashwide(double4) | Returns a uint4 vector hash code of a double4 vector. 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. |
| hashwide(double4x2) | Returns a uint4 vector hash code of a double4x2 matrix. 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. |
| hashwide(double4x3) | Returns a uint4 vector hash code of a double4x3 matrix. 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. |
| hashwide(double4x4) | Returns a uint4 vector hash code of a double4x4 matrix. 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. |
| hashwide(float2) | Returns a uint2 vector hash code of a float2 vector. 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. |
| hashwide(float2x2) | Returns a uint2 vector hash code of a float2x2 matrix. 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. |
| hashwide(float2x3) | Returns a uint2 vector hash code of a float2x3 matrix. 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. |
| hashwide(float2x4) | Returns a uint2 vector hash code of a float2x4 matrix. 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. |
| hashwide(float3) | Returns a uint3 vector hash code of a float3 vector. 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. |
| hashwide(float3x2) | Returns a uint3 vector hash code of a float3x2 matrix. 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. |
| hashwide(float3x3) | Returns a uint3 vector hash code of a float3x3 matrix. 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. |
| hashwide(float3x4) | Returns a uint3 vector hash code of a float3x4 matrix. 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. |
| hashwide(float4) | Returns a uint4 vector hash code of a float4 vector. 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. |
| hashwide(float4x2) | Returns a uint4 vector hash code of a float4x2 matrix. 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. |
| hashwide(float4x3) | Returns a uint4 vector hash code of a float4x3 matrix. 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. |
| hashwide(float4x4) | Returns a uint4 vector hash code of a float4x4 matrix. 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. |
| hashwide(half2) | Returns a uint2 vector hash code of a half2 vector. 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. |
| hashwide(half3) | Returns a uint3 vector hash code of a half3 vector. 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. |
| hashwide(half4) | Returns a uint4 vector hash code of a half4 vector. 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. |
| hashwide(int2) | Returns a uint2 vector hash code of a int2 vector. 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. |
| hashwide(int2x2) | Returns a uint2 vector hash code of a int2x2 matrix. 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. |
| hashwide(int2x3) | Returns a uint2 vector hash code of a int2x3 matrix. 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. |
| hashwide(int2x4) | Returns a uint2 vector hash code of a int2x4 matrix. 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. |
| hashwide(int3) | Returns a uint3 vector hash code of a int3 vector. 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. |
| hashwide(int3x2) | Returns a uint3 vector hash code of a int3x2 matrix. 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. |
| hashwide(int3x3) | Returns a uint3 vector hash code of a int3x3 matrix. 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. |
| hashwide(int3x4) | Returns a uint3 vector hash code of a int3x4 matrix. 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. |
| hashwide(int4) | Returns a uint4 vector hash code of a int4 vector. 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. |
| hashwide(int4x2) | Returns a uint4 vector hash code of a int4x2 matrix. 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. |
| hashwide(int4x3) | Returns a uint4 vector hash code of a int4x3 matrix. 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. |
| hashwide(int4x4) | Returns a uint4 vector hash code of a int4x4 matrix. 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. |
| hashwide(quaternion) | Returns a uint4 vector hash code of a quaternion. 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. |
| hashwide(uint2) | Returns a uint2 vector hash code of a uint2 vector. 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. |
| hashwide(uint2x2) | Returns a uint2 vector hash code of a uint2x2 matrix. 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. |
| hashwide(uint2x3) | Returns a uint2 vector hash code of a uint2x3 matrix. 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. |
| hashwide(uint2x4) | Returns a uint2 vector hash code of a uint2x4 matrix. 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. |
| hashwide(uint3) | Returns a uint3 vector hash code of a uint3 vector. 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. |
| hashwide(uint3x2) | Returns a uint3 vector hash code of a uint3x2 matrix. 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. |
| hashwide(uint3x3) | Returns a uint3 vector hash code of a uint3x3 matrix. 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. |
| hashwide(uint3x4) | Returns a uint3 vector hash code of a uint3x4 matrix. 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. |
| hashwide(uint4) | Returns a uint4 vector hash code of a uint4 vector. 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. |
| hashwide(uint4x2) | Returns a uint4 vector hash code of a uint4x2 matrix. 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. |
| hashwide(uint4x3) | Returns a uint4 vector hash code of a uint4x3 matrix. 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. |
| hashwide(uint4x4) | Returns a uint4 vector hash code of a uint4x4 matrix. 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(bool) | Returns a int2 vector constructed from a single bool value by converting it to int and assigning it to every component. |
| int2(double) | Returns a int2 vector constructed from a single double value by converting it to int and assigning it to every component. |
| int2(int) | Returns a int2 vector constructed from a single int value by assigning it to every component. |
| int2(int, int) | Returns a int2 vector constructed from two int values. |
| int2(float) | Returns a int2 vector constructed from a single float value by converting it to int and assigning it to every component. |
| int2(uint) | Returns a int2 vector constructed from a single uint value by converting it to int and assigning it to every component. |
| int2(bool2) | Return a int2 vector constructed from a bool2 vector by componentwise conversion. |
| int2(double2) | Return a int2 vector constructed from a double2 vector by componentwise conversion. |
| int2(float2) | Return a int2 vector constructed from a float2 vector by componentwise conversion. |
| int2(int2) | Returns a int2 vector constructed from an int2 vector. |
| int2(uint2) | Return a int2 vector constructed from a uint2 vector by componentwise conversion. |
| int2x2(bool) | Returns a int2x2 matrix constructed from a single bool value by converting it to int and assigning it to every component. |
| int2x2(double) | Returns a int2x2 matrix constructed from a single double value by converting it to int and assigning it to every component. |
| int2x2(int) | Returns a int2x2 matrix constructed from a single int value by assigning it to every component. |
| int2x2(int, int, int, int) | Returns a int2x2 matrix constructed from from 4 int values given in row-major order. |
| int2x2(float) | Returns a int2x2 matrix constructed from a single float value by converting it to int and assigning it to every component. |
| int2x2(uint) | Returns a int2x2 matrix constructed from a single uint value by converting it to int and assigning it to every component. |
| int2x2(bool2x2) | Return a int2x2 matrix constructed from a bool2x2 matrix by componentwise conversion. |
| int2x2(double2x2) | Return a int2x2 matrix constructed from a double2x2 matrix by componentwise conversion. |
| int2x2(float2x2) | Return a int2x2 matrix constructed from a float2x2 matrix by componentwise conversion. |
| int2x2(int2, int2) | Returns a int2x2 matrix constructed from two int2 vectors. |
| int2x2(uint2x2) | Return a int2x2 matrix constructed from a uint2x2 matrix by componentwise conversion. |
| int2x3(bool) | Returns a int2x3 matrix constructed from a single bool value by converting it to int and assigning it to every component. |
| int2x3(double) | Returns a int2x3 matrix constructed from a single double value by converting it to int and assigning it to every component. |
| int2x3(int) | Returns a int2x3 matrix constructed from a single int value by assigning it to every component. |
| int2x3(int, int, int, int, int, int) | Returns a int2x3 matrix constructed from from 6 int values given in row-major order. |
| int2x3(float) | Returns a int2x3 matrix constructed from a single float value by converting it to int and assigning it to every component. |
| int2x3(uint) | Returns a int2x3 matrix constructed from a single uint value by converting it to int and assigning it to every component. |
| int2x3(bool2x3) | Return a int2x3 matrix constructed from a bool2x3 matrix by componentwise conversion. |
| int2x3(double2x3) | Return a int2x3 matrix constructed from a double2x3 matrix by componentwise conversion. |
| int2x3(float2x3) | Return a int2x3 matrix constructed from a float2x3 matrix by componentwise conversion. |
| int2x3(int2, int2, int2) | Returns a int2x3 matrix constructed from three int2 vectors. |
| int2x3(uint2x3) | Return a int2x3 matrix constructed from a uint2x3 matrix by componentwise conversion. |
| int2x4(bool) | Returns a int2x4 matrix constructed from a single bool value by converting it to int and assigning it to every component. |
| int2x4(double) | Returns a int2x4 matrix constructed from a single double value by converting it to int and assigning it to every component. |
| int2x4(int) | Returns a int2x4 matrix constructed from a single int value by assigning it to every component. |
| int2x4(int, int, int, int, int, int, int, int) | Returns a int2x4 matrix constructed from from 8 int values given in row-major order. |
| int2x4(float) | Returns a int2x4 matrix constructed from a single float value by converting it to int and assigning it to every component. |
| int2x4(uint) | Returns a int2x4 matrix constructed from a single uint value by converting it to int and assigning it to every component. |
| int2x4(bool2x4) | Return a int2x4 matrix constructed from a bool2x4 matrix by componentwise conversion. |
| int2x4(double2x4) | Return a int2x4 matrix constructed from a double2x4 matrix by componentwise conversion. |
| int2x4(float2x4) | Return a int2x4 matrix constructed from a float2x4 matrix by componentwise conversion. |
| int2x4(int2, int2, int2, int2) | Returns a int2x4 matrix constructed from four int2 vectors. |
| int2x4(uint2x4) | Return a int2x4 matrix constructed from a uint2x4 matrix by componentwise conversion. |
| int3(bool) | Returns a int3 vector constructed from a single bool value by converting it to int and assigning it to every component. |
| int3(double) | Returns a int3 vector constructed from a single double value by converting it to int and assigning it to every component. |
| int3(int) | Returns a int3 vector constructed from a single int value by assigning it to every component. |
| int3(int, int, int) | Returns a int3 vector constructed from three int values. |
| int3(int, int2) | Returns a int3 vector constructed from an int value and an int2 vector. |
| int3(float) | Returns a int3 vector constructed from a single float value by converting it to int and assigning it to every component. |
| int3(uint) | Returns a int3 vector constructed from a single uint value by converting it to int and assigning it to every component. |
| int3(bool3) | Return a int3 vector constructed from a bool3 vector by componentwise conversion. |
| int3(double3) | Return a int3 vector constructed from a double3 vector by componentwise conversion. |
| int3(float3) | Return a int3 vector constructed from a float3 vector by componentwise conversion. |
| int3(int2, int) | Returns a int3 vector constructed from an int2 vector and an int value. |
| int3(int3) | Returns a int3 vector constructed from an int3 vector. |
| int3(uint3) | Return a int3 vector constructed from a uint3 vector by componentwise conversion. |
| int3x2(bool) | Returns a int3x2 matrix constructed from a single bool value by converting it to int and assigning it to every component. |
| int3x2(double) | Returns a int3x2 matrix constructed from a single double value by converting it to int and assigning it to every component. |
| int3x2(int) | Returns a int3x2 matrix constructed from a single int value by assigning it to every component. |
| int3x2(int, int, int, int, int, int) | Returns a int3x2 matrix constructed from from 6 int values given in row-major order. |
| int3x2(float) | Returns a int3x2 matrix constructed from a single float value by converting it to int and assigning it to every component. |
| int3x2(uint) | Returns a int3x2 matrix constructed from a single uint value by converting it to int and assigning it to every component. |
| int3x2(bool3x2) | Return a int3x2 matrix constructed from a bool3x2 matrix by componentwise conversion. |
| int3x2(double3x2) | Return a int3x2 matrix constructed from a double3x2 matrix by componentwise conversion. |
| int3x2(float3x2) | Return a int3x2 matrix constructed from a float3x2 matrix by componentwise conversion. |
| int3x2(int3, int3) | Returns a int3x2 matrix constructed from two int3 vectors. |
| int3x2(uint3x2) | Return a int3x2 matrix constructed from a uint3x2 matrix by componentwise conversion. |
| int3x3(bool) | Returns a int3x3 matrix constructed from a single bool value by converting it to int and assigning it to every component. |
| int3x3(double) | Returns a int3x3 matrix constructed from a single double value by converting it to int and assigning it to every component. |
| int3x3(int) | Returns a int3x3 matrix constructed from a single int value by assigning it to every component. |
| int3x3(int, int, int, int, int, int, int, int, int) | Returns a int3x3 matrix constructed from from 9 int values given in row-major order. |
| int3x3(float) | Returns a int3x3 matrix constructed from a single float value by converting it to int and assigning it to every component. |
| int3x3(uint) | Returns a int3x3 matrix constructed from a single uint value by converting it to int and assigning it to every component. |
| int3x3(bool3x3) | Return a int3x3 matrix constructed from a bool3x3 matrix by componentwise conversion. |
| int3x3(double3x3) | Return a int3x3 matrix constructed from a double3x3 matrix by componentwise conversion. |
| int3x3(float3x3) | Return a int3x3 matrix constructed from a float3x3 matrix by componentwise conversion. |
| int3x3(int3, int3, int3) | Returns a int3x3 matrix constructed from three int3 vectors. |
| int3x3(uint3x3) | Return a int3x3 matrix constructed from a uint3x3 matrix by componentwise conversion. |
| int3x4(bool) | Returns a int3x4 matrix constructed from a single bool value by converting it to int and assigning it to every component. |
| int3x4(double) | Returns a int3x4 matrix constructed from a single double value by converting it to int and assigning it to every component. |
| int3x4(int) | Returns a int3x4 matrix constructed from a single int value by assigning it to every component. |
| int3x4(int, int, int, int, int, int, int, int, int, int, int, int) | Returns a int3x4 matrix constructed from from 12 int values given in row-major order. |
| int3x4(float) | Returns a int3x4 matrix constructed from a single float value by converting it to int and assigning it to every component. |
| int3x4(uint) | Returns a int3x4 matrix constructed from a single uint value by converting it to int and assigning it to every component. |
| int3x4(bool3x4) | Return a int3x4 matrix constructed from a bool3x4 matrix by componentwise conversion. |
| int3x4(double3x4) | Return a int3x4 matrix constructed from a double3x4 matrix by componentwise conversion. |
| int3x4(float3x4) | Return a int3x4 matrix constructed from a float3x4 matrix by componentwise conversion. |
| int3x4(int3, int3, int3, int3) | Returns a int3x4 matrix constructed from four int3 vectors. |
| int3x4(uint3x4) | Return a int3x4 matrix constructed from a uint3x4 matrix by componentwise conversion. |
| int4(bool) | Returns a int4 vector constructed from a single bool value by converting it to int and assigning it to every component. |
| int4(double) | Returns a int4 vector constructed from a single double value by converting it to int and assigning it to every component. |
| int4(int) | Returns a int4 vector constructed from a single int value by assigning it to every component. |
| int4(int, int, int, int) | Returns a int4 vector constructed from four int values. |
| int4(int, int, int2) | Returns a int4 vector constructed from two int values and an int2 vector. |
| int4(int, int2, int) | Returns a int4 vector constructed from an int value, an int2 vector and an int value. |
| int4(int, int3) | Returns a int4 vector constructed from an int value and an int3 vector. |
| int4(float) | Returns a int4 vector constructed from a single float value by converting it to int and assigning it to every component. |
| int4(uint) | Returns a int4 vector constructed from a single uint value by converting it to int and assigning it to every component. |
| int4(bool4) | Return a int4 vector constructed from a bool4 vector by componentwise conversion. |
| int4(double4) | Return a int4 vector constructed from a double4 vector by componentwise conversion. |
| int4(float4) | Return a int4 vector constructed from a float4 vector by componentwise conversion. |
| int4(int2, int, int) | Returns a int4 vector constructed from an int2 vector and two int values. |
| int4(int2, int2) | Returns a int4 vector constructed from two int2 vectors. |
| int4(int3, int) | Returns a int4 vector constructed from an int3 vector and an int value. |
| int4(int4) | Returns a int4 vector constructed from an int4 vector. |
| int4(uint4) | Return a int4 vector constructed from a uint4 vector by componentwise conversion. |
| int4x2(bool) | Returns a int4x2 matrix constructed from a single bool value by converting it to int and assigning it to every component. |
| int4x2(double) | Returns a int4x2 matrix constructed from a single double value by converting it to int and assigning it to every component. |
| int4x2(int) | Returns a int4x2 matrix constructed from a single int value by assigning it to every component. |
| int4x2(int, int, int, int, int, int, int, int) | Returns a int4x2 matrix constructed from from 8 int values given in row-major order. |
| int4x2(float) | Returns a int4x2 matrix constructed from a single float value by converting it to int and assigning it to every component. |
| int4x2(uint) | Returns a int4x2 matrix constructed from a single uint value by converting it to int and assigning it to every component. |
| int4x2(bool4x2) | Return a int4x2 matrix constructed from a bool4x2 matrix by componentwise conversion. |
| int4x2(double4x2) | Return a int4x2 matrix constructed from a double4x2 matrix by componentwise conversion. |
| int4x2(float4x2) | Return a int4x2 matrix constructed from a float4x2 matrix by componentwise conversion. |
| int4x2(int4, int4) | Returns a int4x2 matrix constructed from two int4 vectors. |
| int4x2(uint4x2) | Return a int4x2 matrix constructed from a uint4x2 matrix by componentwise conversion. |
| int4x3(bool) | Returns a int4x3 matrix constructed from a single bool value by converting it to int and assigning it to every component. |
| int4x3(double) | Returns a int4x3 matrix constructed from a single double value by converting it to int and assigning it to every component. |
| int4x3(int) | Returns a int4x3 matrix constructed from a single int value by assigning it to every component. |
| int4x3(int, int, int, int, int, int, int, int, int, int, int, int) | Returns a int4x3 matrix constructed from from 12 int values given in row-major order. |
| int4x3(float) | Returns a int4x3 matrix constructed from a single float value by converting it to int and assigning it to every component. |
| int4x3(uint) | Returns a int4x3 matrix constructed from a single uint value by converting it to int and assigning it to every component. |
| int4x3(bool4x3) | Return a int4x3 matrix constructed from a bool4x3 matrix by componentwise conversion. |
| int4x3(double4x3) | Return a int4x3 matrix constructed from a double4x3 matrix by componentwise conversion. |
| int4x3(float4x3) | Return a int4x3 matrix constructed from a float4x3 matrix by componentwise conversion. |
| int4x3(int4, int4, int4) | Returns a int4x3 matrix constructed from three int4 vectors. |
| int4x3(uint4x3) | Return a int4x3 matrix constructed from a uint4x3 matrix by componentwise conversion. |
| int4x4(bool) | Returns a int4x4 matrix constructed from a single bool value by converting it to int and assigning it to every component. |
| int4x4(double) | Returns a int4x4 matrix constructed from a single double value by converting it to int and assigning it to every component. |
| int4x4(int) | Returns a int4x4 matrix constructed from a single int value by assigning it to every component. |
| int4x4(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int) | Returns a int4x4 matrix constructed from from 16 int values given in row-major order. |
| int4x4(float) | Returns a int4x4 matrix constructed from a single float value by converting it to int and assigning it to every component. |
| int4x4(uint) | Returns a int4x4 matrix constructed from a single uint value by converting it to int and assigning it to every component. |
| int4x4(bool4x4) | Return a int4x4 matrix constructed from a bool4x4 matrix by componentwise conversion. |
| int4x4(double4x4) | Return a int4x4 matrix constructed from a double4x4 matrix by componentwise conversion. |
| int4x4(float4x4) | Return a int4x4 matrix constructed from a float4x4 matrix by componentwise conversion. |
| int4x4(int4, int4, int4, int4) | Returns a int4x4 matrix constructed from four int4 vectors. |
| int4x4(uint4x4) | Return a int4x4 matrix constructed from a uint4x4 matrix by componentwise conversion. |
| inverse(AffineTransform) | Returns the inverse of an AffineTransform. |
| inverse(RigidTransform) | Returns the inverse of a RigidTransform. |
| inverse(double2x2) | Returns the double2x2 full inverse of a double2x2 matrix. |
| inverse(double3x3) | Returns the double3x3 full inverse of a double3x3 matrix. |
| inverse(double4x4) | Returns the double4x4 full inverse of a double4x4 matrix. |
| inverse(float2x2) | Returns the float2x2 full inverse of a float2x2 matrix. |
| inverse(float3x3) | Returns the float3x3 full inverse of a float3x3 matrix. |
| inverse(float4x4) | Returns the float4x4 full inverse of a float4x4 matrix. |
| inverse(quaternion) | Returns the inverse of a quaternion value. |
| isfinite(double) | Returns true if the input double is a finite floating point value, false otherwise. |
| isfinite(float) | Returns true if the input float is a finite floating point value, false otherwise. |
| isfinite(double2) | Returns a bool2 indicating for each component of a double2 whether it is a finite floating point value. |
| isfinite(double3) | Returns a bool3 indicating for each component of a double3 whether it is a finite floating point value. |
| isfinite(double4) | Returns a bool4 indicating for each component of a double4 whether it is a finite floating point value. |
| isfinite(float2) | Returns a bool2 indicating for each component of a float2 whether it is a finite floating point value. |
| isfinite(float3) | Returns a bool3 indicating for each component of a float3 whether it is a finite floating point value. |
| isfinite(float4) | Returns a bool4 indicating for each component of a float4 whether it is a finite floating point value. |
| isinf(double) | Returns true if the input double is an infinite floating point value, false otherwise. |
| isinf(float) | Returns true if the input float is an infinite floating point value, false otherwise. |
| isinf(double2) | Returns a bool2 indicating for each component of a double2 whether it is an infinite floating point value. |
| isinf(double3) | Returns a bool3 indicating for each component of a double3 whether it is an infinite floating point value. |
| isinf(double4) | Returns a bool4 indicating for each component of a double4 whether it is an infinite floating point value. |
| isinf(float2) | Returns a bool2 indicating for each component of a float2 whether it is an infinite floating point value. |
| isinf(float3) | Returns a bool3 indicating for each component of a float3 whether it is an infinite floating point value. |
| isinf(float4) | Returns a bool4 indicating for each component of a float4 whether it is an infinite floating point value. |
| isnan(double) | Returns true if the input double is a NaN (not a number) floating point value, false otherwise. |
| isnan(float) | Returns true if the input float is a NaN (not a number) floating point value, false otherwise. |
| isnan(double2) | Returns a bool2 indicating for each component of a double2 whether it is a NaN (not a number) floating point value. |
| isnan(double3) | Returns a bool3 indicating for each component of a double3 whether it is a NaN (not a number) floating point value. |
| isnan(double4) | Returns a bool4 indicating for each component of a double4 whether it is a NaN (not a number) floating point value. |
| isnan(float2) | Returns a bool2 indicating for each component of a float2 whether it is a NaN (not a number) floating point value. |
| isnan(float3) | Returns a bool3 indicating for each component of a float3 whether it is a NaN (not a number) floating point value. |
| isnan(float4) | Returns a bool4 indicating for each component of a float4 whether it is a NaN (not a number) floating point value. |
| ispow2(int) | Checks if the input is a power of two. |
| ispow2(uint) | Checks if the input is a power of two. |
| ispow2(int2) | Checks if each component of the input is a power of two. |
| ispow2(int3) | Checks if each component of the input is a power of two. |
| ispow2(int4) | Checks if each component of the input is a power of two. |
| ispow2(uint2) | Checks if each component of the input is a power of two. |
| ispow2(uint3) | Checks if each component of the input is a power of two. |
| ispow2(uint4) | Checks if each component of the input is a power of two. |
| left() | Unity's left axis (-1, 0, 0). |
| length(double) | Returns the length of a double value. Equivalent to the absolute value. |
| length(float) | Returns the length of a float value. Equivalent to the absolute value. |
| length(double2) | Returns the length of a double2 vector. |
| length(double3) | Returns the length of a double3 vector. |
| length(double4) | Returns the length of a double4 vector. |
| length(float2) | Returns the length of a float2 vector. |
| length(float3) | Returns the length of a float3 vector. |
| length(float4) | Returns the length of a float4 vector. |
| length(quaternion) | Returns the length of a quaternion. |
| lengthsq(double) | Returns the squared length of a double value. Equivalent to squaring the value. |
| lengthsq(float) | Returns the squared length of a float value. Equivalent to squaring the value. |
| lengthsq(double2) | Returns the squared length of a double2 vector. |
| lengthsq(double3) | Returns the squared length of a double3 vector. |
| lengthsq(double4) | Returns the squared length of a double4 vector. |
| lengthsq(float2) | Returns the squared length of a float2 vector. |
| lengthsq(float3) | Returns the squared length of a float3 vector. |
| lengthsq(float4) | Returns the squared length of a float4 vector. |
| lengthsq(quaternion) | Returns the squared length of a quaternion. |
| lerp(double, double, double) | Returns the result of linearly interpolating from x to y using the interpolation parameter t. |
| lerp(float, float, float) | Returns the result of linearly interpolating from start to end using the interpolation parameter t. |
| lerp(double2, double2, double) | Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter t. |
| lerp(double2, double2, double2) | Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter t. |
| lerp(double3, double3, double) | Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter t. |
| lerp(double3, double3, double3) | Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter t. |
| lerp(double4, double4, double) | Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter t. |
| lerp(double4, double4, double4) | Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter t. |
| lerp(float2, float2, float) | Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter t. |
| lerp(float2, float2, float2) | Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter t. |
| lerp(float3, float3, float) | Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter t. |
| lerp(float3, float3, float3) | Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter t. |
| lerp(float4, float4, float) | Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter t. |
| lerp(float4, float4, float4) | Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter t. |
| log(double) | Returns the natural logarithm of a double value. |
| log(float) | Returns the natural logarithm of a float value. |
| log(double2) | Returns the componentwise natural logarithm of a double2 vector. |
| log(double3) | Returns the componentwise natural logarithm of a double3 vector. |
| log(double4) | Returns the componentwise natural logarithm of a double4 vector. |
| log(float2) | Returns the componentwise natural logarithm of a float2 vector. |
| log(float3) | Returns the componentwise natural logarithm of a float3 vector. |
| log(float4) | Returns the componentwise natural logarithm of a float4 vector. |
| log(quaternion) | Returns the natural logarithm of a quaternion. |
| log10(double) | Returns the base-10 logarithm of a double value. |
| log10(float) | Returns the base-10 logarithm of a float value. |
| log10(double2) | Returns the componentwise base-10 logarithm of a double2 vector. |
| log10(double3) | Returns the componentwise base-10 logarithm of a double3 vector. |
| log10(double4) | Returns the componentwise base-10 logarithm of a double4 vector. |
| log10(float2) | Returns the componentwise base-10 logarithm of a float2 vector. |
| log10(float3) | Returns the componentwise base-10 logarithm of a float3 vector. |
| log10(float4) | Returns the componentwise base-10 logarithm of a float4 vector. |
| log2(double) | Returns the base-2 logarithm of a double value. |
| log2(float) | Returns the base-2 logarithm of a float value. |
| log2(double2) | Returns the componentwise base-2 logarithm of a double2 vector. |
| log2(double3) | Returns the componentwise base-2 logarithm of a double3 vector. |
| log2(double4) | Returns the componentwise base-2 logarithm of a double4 vector. |
| log2(float2) | Returns the componentwise base-2 logarithm of a float2 vector. |
| log2(float3) | Returns the componentwise base-2 logarithm of a float3 vector. |
| log2(float4) | Returns the componentwise base-2 logarithm of a float4 vector. |
| lzcnt(int) | Returns the componentwise number of leading zeros in the binary representations of an int vector. |
| lzcnt(long) | Returns number of leading zeros in the binary representations of a long value. |
| lzcnt(uint) | Returns number of leading zeros in the binary representations of a uint value. |
| lzcnt(ulong) | Returns number of leading zeros in the binary representations of a ulong value. |
| lzcnt(int2) | Returns the componentwise number of leading zeros in the binary representations of an int2 vector. |
| lzcnt(int3) | Returns the componentwise number of leading zeros in the binary representations of an int3 vector. |
| lzcnt(int4) | Returns the componentwise number of leading zeros in the binary representations of an int4 vector. |
| lzcnt(uint2) | Returns the componentwise number of leading zeros in the binary representations of a uint2 vector. |
| lzcnt(uint3) | Returns the componentwise number of leading zeros in the binary representations of a uint3 vector. |
| lzcnt(uint4) | Returns the componentwise number of leading zeros in the binary representations of a uint4 vector. |
| mad(double, double, double) | Returns the result of a multiply-add operation (a * b + c) on 3 double values. |
| mad(int, int, int) | Returns the result of a multiply-add operation (a * b + c) on 3 int values. |
| mad(long, long, long) | Returns the result of a multiply-add operation (a * b + c) on 3 long values. |
| mad(float, float, float) | Returns the result of a multiply-add operation (a * b + c) on 3 float values. |
| mad(uint, uint, uint) | Returns the result of a multiply-add operation (a * b + c) on 3 uint values. |
| mad(ulong, ulong, ulong) | Returns the result of a multiply-add operation (a * b + c) on 3 ulong values. |
| mad(double2, double2, double2) | Returns the result of a componentwise multiply-add operation (a * b + c) on 3 double2 vectors. |
| mad(double3, double3, double3) | Returns the result of a componentwise multiply-add operation (a * b + c) on 3 double3 vectors. |
| mad(double4, double4, double4) | Returns the result of a componentwise multiply-add operation (a * b + c) on 3 double4 vectors. |
| mad(float2, float2, float2) | Returns the result of a componentwise multiply-add operation (a * b + c) on 3 float2 vectors. |
| mad(float3, float3, float3) | Returns the result of a componentwise multiply-add operation (a * b + c) on 3 float3 vectors. |
| mad(float4, float4, float4) | Returns the result of a componentwise multiply-add operation (a * b + c) on 3 float4 vectors. |
| mad(int2, int2, int2) | Returns the result of a componentwise multiply-add operation (a * b + c) on 3 int2 vectors. |
| mad(int3, int3, int3) | Returns the result of a componentwise multiply-add operation (a * b + c) on 3 int3 vectors. |
| mad(int4, int4, int4) | Returns the result of a componentwise multiply-add operation (a * b + c) on 3 int4 vectors. |
| mad(uint2, uint2, uint2) | Returns the result of a componentwise multiply-add operation (a * b + c) on 3 uint2 vectors. |
| mad(uint3, uint3, uint3) | Returns the result of a componentwise multiply-add operation (a * b + c) on 3 uint3 vectors. |
| mad(uint4, uint4, uint4) | Returns the result of a componentwise multiply-add operation (a * b + c) on 3 uint4 vectors. |
| max(double, double) | Returns the maximum of two double values. |
| max(int, int) | Returns the maximum of two int values. |
| max(long, long) | Returns the maximum of two long values. |
| max(float, float) | Returns the maximum of two float values. |
| max(uint, uint) | Returns the maximum of two uint values. |
| max(ulong, ulong) | Returns the maximum of two ulong values. |
| max(double2, double2) | Returns the componentwise maximum of two double2 vectors. |
| max(double3, double3) | Returns the componentwise maximum of two double3 vectors. |
| max(double4, double4) | Returns the componentwise maximum of two double4 vectors. |
| max(float2, float2) | Returns the componentwise maximum of two float2 vectors. |
| max(float3, float3) | Returns the componentwise maximum of two float3 vectors. |
| max(float4, float4) | Returns the componentwise maximum of two float4 vectors. |
| max(int2, int2) | Returns the componentwise maximum of two int2 vectors. |
| max(int3, int3) | Returns the componentwise maximum of two int3 vectors. |
| max(int4, int4) | Returns the componentwise maximum of two int4 vectors. |
| max(uint2, uint2) | Returns the componentwise maximum of two uint2 vectors. |
| max(uint3, uint3) | Returns the componentwise maximum of two uint3 vectors. |
| max(uint4, uint4) | Returns the componentwise maximum of two uint4 vectors. |
| min(double, double) | Returns the minimum of two double values. |
| min(int, int) | Returns the minimum of two int values. |
| min(long, long) | Returns the minimum of two long values. |
| min(float, float) | Returns the minimum of two float values. |
| min(uint, uint) | Returns the minimum of two uint values. |
| min(ulong, ulong) | Returns the minimum of two ulong values. |
| min(double2, double2) | Returns the componentwise minimum of two double2 vectors. |
| min(double3, double3) | Returns the componentwise minimum of two double3 vectors. |
| min(double4, double4) | Returns the componentwise minimum of two double4 vectors. |
| min(float2, float2) | Returns the componentwise minimum of two float2 vectors. |
| min(float3, float3) | Returns the componentwise minimum of two float3 vectors. |
| min(float4, float4) | Returns the componentwise minimum of two float4 vectors. |
| min(int2, int2) | Returns the componentwise minimum of two int2 vectors. |
| min(int3, int3) | Returns the componentwise minimum of two int3 vectors. |
| min(int4, int4) | Returns the componentwise minimum of two int4 vectors. |
| min(uint2, uint2) | Returns the componentwise minimum of two uint2 vectors. |
| min(uint3, uint3) | Returns the componentwise minimum of two uint3 vectors. |
| min(uint4, uint4) | Returns the componentwise minimum of two uint4 vectors. |
| modf(double, out double) | Splits a double value into an integral part i and a fractional part that gets returned. Both parts take the sign of the input. |
| modf(float, out float) | Splits a float value into an integral part i and a fractional part that gets returned. Both parts take the sign of the input. |
| modf(double2, out double2) | Performs a componentwise split of a double2 vector into an integral part i and a fractional part that gets returned. Both parts take the sign of the corresponding input component. |
| modf(double3, out double3) | Performs a componentwise split of a double3 vector into an integral part i and a fractional part that gets returned. Both parts take the sign of the corresponding input component. |
| modf(double4, out double4) | Performs a componentwise split of a double4 vector into an integral part i and a fractional part that gets returned. Both parts take the sign of the corresponding input component. |
| modf(float2, out float2) | Performs a componentwise split of a float2 vector into an integral part i and a fractional part that gets returned. Both parts take the sign of the corresponding input component. |
| modf(float3, out float3) | Performs a componentwise split of a float3 vector into an integral part i and a fractional part that gets returned. Both parts take the sign of the corresponding input component. |
| modf(float4, out float4) | Performs a componentwise split of a float4 vector into an integral part i and a fractional part that gets returned. Both parts take the sign of the corresponding input component. |
| mul(double, double) | Returns the double value result of a matrix multiplication between a double value and a double value. |
| mul(int, int) | Returns the int value result of a matrix multiplication between an int value and an int value. |
| mul(float, float) | Returns the float value result of a matrix multiplication between a float value and a float value. |
| mul(uint, uint) | Returns the uint value result of a matrix multiplication between a uint value and a uint value. |
| mul(AffineTransform, AffineTransform) | Returns the result of transforming the AffineTransform b by the AffineTransform a. |
| mul(AffineTransform, float3x3) | Returns the result of transforming the float3x3 b by an AffineTransform a. |
| mul(AffineTransform, float4) | Returns the result of transforming a float4 homogeneous coordinate by an AffineTransform. |
| mul(RigidTransform, RigidTransform) | Returns the result of transforming the RigidTransform b by the RigidTransform a. |
| mul(RigidTransform, float4) | Returns the result of transforming a float4 homogeneous coordinate by a RigidTransform. |
| mul(double2, double2) | Returns the double value result of a matrix multiplication between a double2 row vector and a double2 column vector. |
| mul(double2, double2x2) | Returns the double2 row vector result of a matrix multiplication between a double2 row vector and a double2x2 matrix. |
| mul(double2, double2x3) | Returns the double3 row vector result of a matrix multiplication between a double2 row vector and a double2x3 matrix. |
| mul(double2, double2x4) | Returns the double4 row vector result of a matrix multiplication between a double2 row vector and a double2x4 matrix. |
| mul(double2x2, double2) | Returns the double2 column vector result of a matrix multiplication between a double2x2 matrix and a double2 column vector. |
| mul(double2x2, double2x2) | Returns the double2x2 matrix result of a matrix multiplication between a double2x2 matrix and a double2x2 matrix. |
| mul(double2x2, double2x3) | Returns the double2x3 matrix result of a matrix multiplication between a double2x2 matrix and a double2x3 matrix. |
| mul(double2x2, double2x4) | Returns the double2x4 matrix result of a matrix multiplication between a double2x2 matrix and a double2x4 matrix. |
| mul(double2x3, double3) | Returns the double2 column vector result of a matrix multiplication between a double2x3 matrix and a double3 column vector. |
| mul(double2x3, double3x2) | Returns the double2x2 matrix result of a matrix multiplication between a double2x3 matrix and a double3x2 matrix. |
| mul(double2x3, double3x3) | Returns the double2x3 matrix result of a matrix multiplication between a double2x3 matrix and a double3x3 matrix. |
| mul(double2x3, double3x4) | Returns the double2x4 matrix result of a matrix multiplication between a double2x3 matrix and a double3x4 matrix. |
| mul(double2x4, double4) | Returns the double2 column vector result of a matrix multiplication between a double2x4 matrix and a double4 column vector. |
| mul(double2x4, double4x2) | Returns the double2x2 matrix result of a matrix multiplication between a double2x4 matrix and a double4x2 matrix. |
| mul(double2x4, double4x3) | Returns the double2x3 matrix result of a matrix multiplication between a double2x4 matrix and a double4x3 matrix. |
| mul(double2x4, double4x4) | Returns the double2x4 matrix result of a matrix multiplication between a double2x4 matrix and a double4x4 matrix. |
| mul(double3, double3) | Returns the double value result of a matrix multiplication between a double3 row vector and a double3 column vector. |
| mul(double3, double3x2) | Returns the double2 row vector result of a matrix multiplication between a double3 row vector and a double3x2 matrix. |
| mul(double3, double3x3) | Returns the double3 row vector result of a matrix multiplication between a double3 row vector and a double3x3 matrix. |
| mul(double3, double3x4) | Returns the double4 row vector result of a matrix multiplication between a double3 row vector and a double3x4 matrix. |
| mul(double3x2, double2) | Returns the double3 column vector result of a matrix multiplication between a double3x2 matrix and a double2 column vector. |
| mul(double3x2, double2x2) | Returns the double3x2 matrix result of a matrix multiplication between a double3x2 matrix and a double2x2 matrix. |
| mul(double3x2, double2x3) | Returns the double3x3 matrix result of a matrix multiplication between a double3x2 matrix and a double2x3 matrix. |
| mul(double3x2, double2x4) | Returns the double3x4 matrix result of a matrix multiplication between a double3x2 matrix and a double2x4 matrix. |
| mul(double3x3, double3) | Returns the double3 column vector result of a matrix multiplication between a double3x3 matrix and a double3 column vector. |
| mul(double3x3, double3x2) | Returns the double3x2 matrix result of a matrix multiplication between a double3x3 matrix and a double3x2 matrix. |
| mul(double3x3, double3x3) | Returns the double3x3 matrix result of a matrix multiplication between a double3x3 matrix and a double3x3 matrix. |
| mul(double3x3, double3x4) | Returns the double3x4 matrix result of a matrix multiplication between a double3x3 matrix and a double3x4 matrix. |
| mul(double3x4, double4) | Returns the double3 column vector result of a matrix multiplication between a double3x4 matrix and a double4 column vector. |
| mul(double3x4, double4x2) | Returns the double3x2 matrix result of a matrix multiplication between a double3x4 matrix and a double4x2 matrix. |
| mul(double3x4, double4x3) | Returns the double3x3 matrix result of a matrix multiplication between a double3x4 matrix and a double4x3 matrix. |
| mul(double3x4, double4x4) | Returns the double3x4 matrix result of a matrix multiplication between a double3x4 matrix and a double4x4 matrix. |
| mul(double4, double4) | Returns the double value result of a matrix multiplication between a double4 row vector and a double4 column vector. |
| mul(double4, double4x2) | Returns the double2 row vector result of a matrix multiplication between a double4 row vector and a double4x2 matrix. |
| mul(double4, double4x3) | Returns the double3 row vector result of a matrix multiplication between a double4 row vector and a double4x3 matrix. |
| mul(double4, double4x4) | Returns the double4 row vector result of a matrix multiplication between a double4 row vector and a double4x4 matrix. |
| mul(double4x2, double2) | Returns the double4 column vector result of a matrix multiplication between a double4x2 matrix and a double2 column vector. |
| mul(double4x2, double2x2) | Returns the double4x2 matrix result of a matrix multiplication between a double4x2 matrix and a double2x2 matrix. |
| mul(double4x2, double2x3) | Returns the double4x3 matrix result of a matrix multiplication between a double4x2 matrix and a double2x3 matrix. |
| mul(double4x2, double2x4) | Returns the double4x4 matrix result of a matrix multiplication between a double4x2 matrix and a double2x4 matrix. |
| mul(double4x3, double3) | Returns the double4 column vector result of a matrix multiplication between a double4x3 matrix and a double3 column vector. |
| mul(double4x3, double3x2) | Returns the double4x2 matrix result of a matrix multiplication between a double4x3 matrix and a double3x2 matrix. |
| mul(double4x3, double3x3) | Returns the double4x3 matrix result of a matrix multiplication between a double4x3 matrix and a double3x3 matrix. |
| mul(double4x3, double3x4) | Returns the double4x4 matrix result of a matrix multiplication between a double4x3 matrix and a double3x4 matrix. |
| mul(double4x4, double4) | Returns the double4 column vector result of a matrix multiplication between a double4x4 matrix and a double4 column vector. |
| mul(double4x4, double4x2) | Returns the double4x2 matrix result of a matrix multiplication between a double4x4 matrix and a double4x2 matrix. |
| mul(double4x4, double4x3) | Returns the double4x3 matrix result of a matrix multiplication between a double4x4 matrix and a double4x3 matrix. |
| mul(double4x4, double4x4) | Returns the double4x4 matrix result of a matrix multiplication between a double4x4 matrix and a double4x4 matrix. |
| mul(float2, float2) | Returns the float value result of a matrix multiplication between a float2 row vector and a float2 column vector. |
| mul(float2, float2x2) | Returns the float2 row vector result of a matrix multiplication between a float2 row vector and a float2x2 matrix. |
| mul(float2, float2x3) | Returns the float3 row vector result of a matrix multiplication between a float2 row vector and a float2x3 matrix. |
| mul(float2, float2x4) | Returns the float4 row vector result of a matrix multiplication between a float2 row vector and a float2x4 matrix. |
| mul(float2x2, float2) | Returns the float2 column vector result of a matrix multiplication between a float2x2 matrix and a float2 column vector. |
| mul(float2x2, float2x2) | Returns the float2x2 matrix result of a matrix multiplication between a float2x2 matrix and a float2x2 matrix. |
| mul(float2x2, float2x3) | Returns the float2x3 matrix result of a matrix multiplication between a float2x2 matrix and a float2x3 matrix. |
| mul(float2x2, float2x4) | Returns the float2x4 matrix result of a matrix multiplication between a float2x2 matrix and a float2x4 matrix. |
| mul(float2x3, float3) | Returns the float2 column vector result of a matrix multiplication between a float2x3 matrix and a float3 column vector. |
| mul(float2x3, float3x2) | Returns the float2x2 matrix result of a matrix multiplication between a float2x3 matrix and a float3x2 matrix. |
| mul(float2x3, float3x3) | Returns the float2x3 matrix result of a matrix multiplication between a float2x3 matrix and a float3x3 matrix. |
| mul(float2x3, float3x4) | Returns the float2x4 matrix result of a matrix multiplication between a float2x3 matrix and a float3x4 matrix. |
| mul(float2x4, float4) | Returns the float2 column vector result of a matrix multiplication between a float2x4 matrix and a float4 column vector. |
| mul(float2x4, float4x2) | Returns the float2x2 matrix result of a matrix multiplication between a float2x4 matrix and a float4x2 matrix. |
| mul(float2x4, float4x3) | Returns the float2x3 matrix result of a matrix multiplication between a float2x4 matrix and a float4x3 matrix. |
| mul(float2x4, float4x4) | Returns the float2x4 matrix result of a matrix multiplication between a float2x4 matrix and a float4x4 matrix. |
| mul(float3, float3) | Returns the float value result of a matrix multiplication between a float3 row vector and a float3 column vector. |
| mul(float3, float3x2) | Returns the float2 row vector result of a matrix multiplication between a float3 row vector and a float3x2 matrix. |
| mul(float3, float3x3) | Returns the float3 row vector result of a matrix multiplication between a float3 row vector and a float3x3 matrix. |
| mul(float3, float3x4) | Returns the float4 row vector result of a matrix multiplication between a float3 row vector and a float3x4 matrix. |
| mul(float3x2, float2) | Returns the float3 column vector result of a matrix multiplication between a float3x2 matrix and a float2 column vector. |
| mul(float3x2, float2x2) | Returns the float3x2 matrix result of a matrix multiplication between a float3x2 matrix and a float2x2 matrix. |
| mul(float3x2, float2x3) | Returns the float3x3 matrix result of a matrix multiplication between a float3x2 matrix and a float2x3 matrix. |
| mul(float3x2, float2x4) | Returns the float3x4 matrix result of a matrix multiplication between a float3x2 matrix and a float2x4 matrix. |
| mul(float3x3, AffineTransform) | Returns the result of transforming the AffineTransform b by a float3x3 matrix a. |
| mul(float3x3, float3) | Returns the float3 column vector result of a matrix multiplication between a float3x3 matrix and a float3 column vector. |
| mul(float3x3, float3x2) | Returns the float3x2 matrix result of a matrix multiplication between a float3x3 matrix and a float3x2 matrix. |
| mul(float3x3, float3x3) | Returns the float3x3 matrix result of a matrix multiplication between a float3x3 matrix and a float3x3 matrix. |
| mul(float3x3, float3x4) | Returns the float3x4 matrix result of a matrix multiplication between a float3x3 matrix and a float3x4 matrix. |
| mul(float3x4, float4) | Returns the float3 column vector result of a matrix multiplication between a float3x4 matrix and a float4 column vector. |
| mul(float3x4, float4x2) | Returns the float3x2 matrix result of a matrix multiplication between a float3x4 matrix and a float4x2 matrix. |
| mul(float3x4, float4x3) | Returns the float3x3 matrix result of a matrix multiplication between a float3x4 matrix and a float4x3 matrix. |
| mul(float3x4, float4x4) | Returns the float3x4 matrix result of a matrix multiplication between a float3x4 matrix and a float4x4 matrix. |
| mul(float4, float4) | Returns the float value result of a matrix multiplication between a float4 row vector and a float4 column vector. |
| mul(float4, float4x2) | Returns the float2 row vector result of a matrix multiplication between a float4 row vector and a float4x2 matrix. |
| mul(float4, float4x3) | Returns the float3 row vector result of a matrix multiplication between a float4 row vector and a float4x3 matrix. |
| mul(float4, float4x4) | Returns the float4 row vector result of a matrix multiplication between a float4 row vector and a float4x4 matrix. |
| mul(float4x2, float2) | Returns the float4 column vector result of a matrix multiplication between a float4x2 matrix and a float2 column vector. |
| mul(float4x2, float2x2) | Returns the float4x2 matrix result of a matrix multiplication between a float4x2 matrix and a float2x2 matrix. |
| mul(float4x2, float2x3) | Returns the float4x3 matrix result of a matrix multiplication between a float4x2 matrix and a float2x3 matrix. |
| mul(float4x2, float2x4) | Returns the float4x4 matrix result of a matrix multiplication between a float4x2 matrix and a float2x4 matrix. |
| mul(float4x3, float3) | Returns the float4 column vector result of a matrix multiplication between a float4x3 matrix and a float3 column vector. |
| mul(float4x3, float3x2) | Returns the float4x2 matrix result of a matrix multiplication between a float4x3 matrix and a float3x2 matrix. |
| mul(float4x3, float3x3) | Returns the float4x3 matrix result of a matrix multiplication between a float4x3 matrix and a float3x3 matrix. |
| mul(float4x3, float3x4) | Returns the float4x4 matrix result of a matrix multiplication between a float4x3 matrix and a float3x4 matrix. |
| mul(float4x4, float4) | Returns the float4 column vector result of a matrix multiplication between a float4x4 matrix and a float4 column vector. |
| mul(float4x4, float4x2) | Returns the float4x2 matrix result of a matrix multiplication between a float4x4 matrix and a float4x2 matrix. |
| mul(float4x4, float4x3) | Returns the float4x3 matrix result of a matrix multiplication between a float4x4 matrix and a float4x3 matrix. |
| mul(float4x4, float4x4) | Returns the float4x4 matrix result of a matrix multiplication between a float4x4 matrix and a float4x4 matrix. |
| mul(int2, int2) | Returns the int value result of a matrix multiplication between an int2 row vector and an int2 column vector. |
| mul(int2, int2x2) | Returns the int2 row vector result of a matrix multiplication between an int2 row vector and an int2x2 matrix. |
| mul(int2, int2x3) | Returns the int3 row vector result of a matrix multiplication between an int2 row vector and an int2x3 matrix. |
| mul(int2, int2x4) | Returns the int4 row vector result of a matrix multiplication between an int2 row vector and an int2x4 matrix. |
| mul(int2x2, int2) | Returns the int2 column vector result of a matrix multiplication between an int2x2 matrix and an int2 column vector. |
| mul(int2x2, int2x2) | Returns the int2x2 matrix result of a matrix multiplication between an int2x2 matrix and an int2x2 matrix. |
| mul(int2x2, int2x3) | Returns the int2x3 matrix result of a matrix multiplication between an int2x2 matrix and an int2x3 matrix. |
| mul(int2x2, int2x4) | Returns the int2x4 matrix result of a matrix multiplication between an int2x2 matrix and an int2x4 matrix. |
| mul(int2x3, int3) | Returns the int2 column vector result of a matrix multiplication between an int2x3 matrix and an int3 column vector. |
| mul(int2x3, int3x2) | Returns the int2x2 matrix result of a matrix multiplication between an int2x3 matrix and an int3x2 matrix. |
| mul(int2x3, int3x3) | Returns the int2x3 matrix result of a matrix multiplication between an int2x3 matrix and an int3x3 matrix. |
| mul(int2x3, int3x4) | Returns the int2x4 matrix result of a matrix multiplication between an int2x3 matrix and an int3x4 matrix. |
| mul(int2x4, int4) | Returns the int2 column vector result of a matrix multiplication between an int2x4 matrix and an int4 column vector. |
| mul(int2x4, int4x2) | Returns the int2x2 matrix result of a matrix multiplication between an int2x4 matrix and an int4x2 matrix. |
| mul(int2x4, int4x3) | Returns the int2x3 matrix result of a matrix multiplication between an int2x4 matrix and an int4x3 matrix. |
| mul(int2x4, int4x4) | Returns the int2x4 matrix result of a matrix multiplication between an int2x4 matrix and an int4x4 matrix. |
| mul(int3, int3) | Returns the int value result of a matrix multiplication between an int3 row vector and an int3 column vector. |
| mul(int3, int3x2) | Returns the int2 row vector result of a matrix multiplication between an int3 row vector and an int3x2 matrix. |
| mul(int3, int3x3) | Returns the int3 row vector result of a matrix multiplication between an int3 row vector and an int3x3 matrix. |
| mul(int3, int3x4) | Returns the int4 row vector result of a matrix multiplication between an int3 row vector and an int3x4 matrix. |
| mul(int3x2, int2) | Returns the int3 column vector result of a matrix multiplication between an int3x2 matrix and an int2 column vector. |
| mul(int3x2, int2x2) | Returns the int3x2 matrix result of a matrix multiplication between an int3x2 matrix and an int2x2 matrix. |
| mul(int3x2, int2x3) | Returns the int3x3 matrix result of a matrix multiplication between an int3x2 matrix and an int2x3 matrix. |
| mul(int3x2, int2x4) | Returns the int3x4 matrix result of a matrix multiplication between an int3x2 matrix and an int2x4 matrix. |
| mul(int3x3, int3) | Returns the int3 column vector result of a matrix multiplication between an int3x3 matrix and an int3 column vector. |
| mul(int3x3, int3x2) | Returns the int3x2 matrix result of a matrix multiplication between an int3x3 matrix and an int3x2 matrix. |
| mul(int3x3, int3x3) | Returns the int3x3 matrix result of a matrix multiplication between an int3x3 matrix and an int3x3 matrix. |
| mul(int3x3, int3x4) | Returns the int3x4 matrix result of a matrix multiplication between an int3x3 matrix and an int3x4 matrix. |
| mul(int3x4, int4) | Returns the int3 column vector result of a matrix multiplication between an int3x4 matrix and an int4 column vector. |
| mul(int3x4, int4x2) | Returns the int3x2 matrix result of a matrix multiplication between an int3x4 matrix and an int4x2 matrix. |
| mul(int3x4, int4x3) | Returns the int3x3 matrix result of a matrix multiplication between an int3x4 matrix and an int4x3 matrix. |
| mul(int3x4, int4x4) | Returns the int3x4 matrix result of a matrix multiplication between an int3x4 matrix and an int4x4 matrix. |
| mul(int4, int4) | Returns the int value result of a matrix multiplication between an int4 row vector and an int4 column vector. |
| mul(int4, int4x2) | Returns the int2 row vector result of a matrix multiplication between an int4 row vector and an int4x2 matrix. |
| mul(int4, int4x3) | Returns the int3 row vector result of a matrix multiplication between an int4 row vector and an int4x3 matrix. |
| mul(int4, int4x4) | Returns the int4 row vector result of a matrix multiplication between an int4 row vector and an int4x4 matrix. |
| mul(int4x2, int2) | Returns the int4 column vector result of a matrix multiplication between an int4x2 matrix and an int2 column vector. |
| mul(int4x2, int2x2) | Returns the int4x2 matrix result of a matrix multiplication between an int4x2 matrix and an int2x2 matrix. |
| mul(int4x2, int2x3) | Returns the int4x3 matrix result of a matrix multiplication between an int4x2 matrix and an int2x3 matrix. |
| mul(int4x2, int2x4) | Returns the int4x4 matrix result of a matrix multiplication between an int4x2 matrix and an int2x4 matrix. |
| mul(int4x3, int3) | Returns the int4 column vector result of a matrix multiplication between an int4x3 matrix and an int3 column vector. |
| mul(int4x3, int3x2) | Returns the int4x2 matrix result of a matrix multiplication between an int4x3 matrix and an int3x2 matrix. |
| mul(int4x3, int3x3) | Returns the int4x3 matrix result of a matrix multiplication between an int4x3 matrix and an int3x3 matrix. |
| mul(int4x3, int3x4) | Returns the int4x4 matrix result of a matrix multiplication between an int4x3 matrix and an int3x4 matrix. |
| mul(int4x4, int4) | Returns the int4 column vector result of a matrix multiplication between an int4x4 matrix and an int4 column vector. |
| mul(int4x4, int4x2) | Returns the int4x2 matrix result of a matrix multiplication between an int4x4 matrix and an int4x2 matrix. |
| mul(int4x4, int4x3) | Returns the int4x3 matrix result of a matrix multiplication between an int4x4 matrix and an int4x3 matrix. |
| mul(int4x4, int4x4) | Returns the int4x4 matrix result of a matrix multiplication between an int4x4 matrix and an int4x4 matrix. |
| mul(quaternion, float3) | Returns the result of transforming a vector by a quaternion. |
| mul(quaternion, quaternion) | Returns the result of transforming the quaternion b by the quaternion a. |
| mul(uint2, uint2) | Returns the uint value result of a matrix multiplication between a uint2 row vector and a uint2 column vector. |
| mul(uint2, uint2x2) | Returns the uint2 row vector result of a matrix multiplication between a uint2 row vector and a uint2x2 matrix. |
| mul(uint2, uint2x3) | Returns the uint3 row vector result of a matrix multiplication between a uint2 row vector and a uint2x3 matrix. |
| mul(uint2, uint2x4) | Returns the uint4 row vector result of a matrix multiplication between a uint2 row vector and a uint2x4 matrix. |
| mul(uint2x2, uint2) | Returns the uint2 column vector result of a matrix multiplication between a uint2x2 matrix and a uint2 column vector. |
| mul(uint2x2, uint2x2) | Returns the uint2x2 matrix result of a matrix multiplication between a uint2x2 matrix and a uint2x2 matrix. |
| mul(uint2x2, uint2x3) | Returns the uint2x3 matrix result of a matrix multiplication between a uint2x2 matrix and a uint2x3 matrix. |
| mul(uint2x2, uint2x4) | Returns the uint2x4 matrix result of a matrix multiplication between a uint2x2 matrix and a uint2x4 matrix. |
| mul(uint2x3, uint3) | Returns the uint2 column vector result of a matrix multiplication between a uint2x3 matrix and a uint3 column vector. |
| mul(uint2x3, uint3x2) | Returns the uint2x2 matrix result of a matrix multiplication between a uint2x3 matrix and a uint3x2 matrix. |
| mul(uint2x3, uint3x3) | Returns the uint2x3 matrix result of a matrix multiplication between a uint2x3 matrix and a uint3x3 matrix. |
| mul(uint2x3, uint3x4) | Returns the uint2x4 matrix result of a matrix multiplication between a uint2x3 matrix and a uint3x4 matrix. |
| mul(uint2x4, uint4) | Returns the uint2 column vector result of a matrix multiplication between a uint2x4 matrix and a uint4 column vector. |
| mul(uint2x4, uint4x2) | Returns the uint2x2 matrix result of a matrix multiplication between a uint2x4 matrix and a uint4x2 matrix. |
| mul(uint2x4, uint4x3) | Returns the uint2x3 matrix result of a matrix multiplication between a uint2x4 matrix and a uint4x3 matrix. |
| mul(uint2x4, uint4x4) | Returns the uint2x4 matrix result of a matrix multiplication between a uint2x4 matrix and a uint4x4 matrix. |
| mul(uint3, uint3) | Returns the uint value result of a matrix multiplication between a uint3 row vector and a uint3 column vector. |
| mul(uint3, uint3x2) | Returns the uint2 row vector result of a matrix multiplication between a uint3 row vector and a uint3x2 matrix. |
| mul(uint3, uint3x3) | Returns the uint3 row vector result of a matrix multiplication between a uint3 row vector and a uint3x3 matrix. |
| mul(uint3, uint3x4) | Returns the uint4 row vector result of a matrix multiplication between a uint3 row vector and a uint3x4 matrix. |
| mul(uint3x2, uint2) | Returns the uint3 column vector result of a matrix multiplication between a uint3x2 matrix and a uint2 column vector. |
| mul(uint3x2, uint2x2) | Returns the uint3x2 matrix result of a matrix multiplication between a uint3x2 matrix and a uint2x2 matrix. |
| mul(uint3x2, uint2x3) | Returns the uint3x3 matrix result of a matrix multiplication between a uint3x2 matrix and a uint2x3 matrix. |
| mul(uint3x2, uint2x4) | Returns the uint3x4 matrix result of a matrix multiplication between a uint3x2 matrix and a uint2x4 matrix. |
| mul(uint3x3, uint3) | Returns the uint3 column vector result of a matrix multiplication between a uint3x3 matrix and a uint3 column vector. |
| mul(uint3x3, uint3x2) | Returns the uint3x2 matrix result of a matrix multiplication between a uint3x3 matrix and a uint3x2 matrix. |
| mul(uint3x3, uint3x3) | Returns the uint3x3 matrix result of a matrix multiplication between a uint3x3 matrix and a uint3x3 matrix. |
| mul(uint3x3, uint3x4) | Returns the uint3x4 matrix result of a matrix multiplication between a uint3x3 matrix and a uint3x4 matrix. |
| mul(uint3x4, uint4) | Returns the uint3 column vector result of a matrix multiplication between a uint3x4 matrix and a uint4 column vector. |
| mul(uint3x4, uint4x2) | Returns the uint3x2 matrix result of a matrix multiplication between a uint3x4 matrix and a uint4x2 matrix. |
| mul(uint3x4, uint4x3) | Returns the uint3x3 matrix result of a matrix multiplication between a uint3x4 matrix and a uint4x3 matrix. |
| mul(uint3x4, uint4x4) | Returns the uint3x4 matrix result of a matrix multiplication between a uint3x4 matrix and a uint4x4 matrix. |
| mul(uint4, uint4) | Returns the uint value result of a matrix multiplication between a uint4 row vector and a uint4 column vector. |
| mul(uint4, uint4x2) | Returns the uint2 row vector result of a matrix multiplication between a uint4 row vector and a uint4x2 matrix. |
| mul(uint4, uint4x3) | Returns the uint3 row vector result of a matrix multiplication between a uint4 row vector and a uint4x3 matrix. |
| mul(uint4, uint4x4) | Returns the uint4 row vector result of a matrix multiplication between a uint4 row vector and a uint4x4 matrix. |
| mul(uint4x2, uint2) | Returns the uint4 column vector result of a matrix multiplication between a uint4x2 matrix and a uint2 column vector. |
| mul(uint4x2, uint2x2) | Returns the uint4x2 matrix result of a matrix multiplication between a uint4x2 matrix and a uint2x2 matrix. |
| mul(uint4x2, uint2x3) | Returns the uint4x3 matrix result of a matrix multiplication between a uint4x2 matrix and a uint2x3 matrix. |
| mul(uint4x2, uint2x4) | Returns the uint4x4 matrix result of a matrix multiplication between a uint4x2 matrix and a uint2x4 matrix. |
| mul(uint4x3, uint3) | Returns the uint4 column vector result of a matrix multiplication between a uint4x3 matrix and a uint3 column vector. |
| mul(uint4x3, uint3x2) | Returns the uint4x2 matrix result of a matrix multiplication between a uint4x3 matrix and a uint3x2 matrix. |
| mul(uint4x3, uint3x3) | Returns the uint4x3 matrix result of a matrix multiplication between a uint4x3 matrix and a uint3x3 matrix. |
| mul(uint4x3, uint3x4) | Returns the uint4x4 matrix result of a matrix multiplication between a uint4x3 matrix and a uint3x4 matrix. |
| mul(uint4x4, uint4) | Returns the uint4 column vector result of a matrix multiplication between a uint4x4 matrix and a uint4 column vector. |
| mul(uint4x4, uint4x2) | Returns the uint4x2 matrix result of a matrix multiplication between a uint4x4 matrix and a uint4x2 matrix. |
| mul(uint4x4, uint4x3) | Returns the uint4x3 matrix result of a matrix multiplication between a uint4x4 matrix and a uint4x3 matrix. |
| mul(uint4x4, uint4x4) | Returns the uint4x4 matrix result of a matrix multiplication between a uint4x4 matrix and a uint4x4 matrix. |
| mulScale(float3x3, float3) | 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(quaternion, quaternion, float) | Returns the result of a normalized linear interpolation between two quaternions q1 and a2 using an interpolation parameter t. |
| normalize(double2) | Returns a normalized version of the double2 vector x by scaling it by 1 / length(x). |
| normalize(double3) | Returns a normalized version of the double3 vector x by scaling it by 1 / length(x). |
| normalize(double4) | Returns a normalized version of the double4 vector x by scaling it by 1 / length(x). |
| normalize(float2) | Returns a normalized version of the float2 vector x by scaling it by 1 / length(x). |
| normalize(float3) | Returns a normalized version of the float3 vector x by scaling it by 1 / length(x). |
| normalize(float4) | Returns a normalized version of the float4 vector x by scaling it by 1 / length(x). |
| normalize(quaternion) | Returns a normalized version of a quaternion q by scaling it by 1 / length(q). |
| normalizesafe(double2, double2) | Returns a safe normalized version of the double4 vector x by scaling it by 1 / length(x). Returns the given default value when 1 / length(x) does not produce a finite number. |
| normalizesafe(double3, double3) | Returns a safe normalized version of the double4 vector x by scaling it by 1 / length(x). Returns the given default value when 1 / length(x) does not produce a finite number. |
| normalizesafe(double4, double4) | Returns a safe normalized version of the double4 vector x by scaling it by 1 / length(x). Returns the given default value when 1 / length(x) does not produce a finite number. |
| normalizesafe(float2, float2) | 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. |
| normalizesafe(float3, float3) | Returns a safe normalized version of the float3 vector x by scaling it by 1 / length(x). Returns the given default value when 1 / length(x) does not produce a finite number. |
| normalizesafe(float4, float4) | Returns a safe normalized version of the float4 vector x by scaling it by 1 / length(x). Returns the given default value when 1 / length(x) does not produce a finite number. |
| normalizesafe(quaternion) | Returns a safe normalized version of the q by scaling it by 1 / length(q). Returns the identity when 1 / length(q) does not produce a finite number. |
| normalizesafe(quaternion, quaternion) | Returns a safe normalized version of the q by scaling it by 1 / length(q). Returns the given default value when 1 / length(q) does not produce a finite number. |
| orthonormal_basis(double3, out double3, out double3) | Generate an orthonormal basis given a single unit length normal vector. |
| orthonormal_basis(float3, out float3, out float3) | Generate an orthonormal basis given a single unit length normal vector. |
| orthonormalize(float3x3) | Returns an orthonormalized version of a float3x3 matrix. |
| pow(double, double) | Returns x raised to the power y. |
| pow(float, float) | Returns x raised to the power y. |
| pow(double2, double2) | Returns the componentwise result of raising x to the power y. |
| pow(double3, double3) | Returns the componentwise result of raising x to the power y. |
| pow(double4, double4) | Returns the componentwise result of raising x to the power y. |
| pow(float2, float2) | Returns the componentwise result of raising x to the power y. |
| pow(float3, float3) | Returns the componentwise result of raising x to the power y. |
| pow(float4, float4) | Returns the componentwise result of raising x to the power y. |
| project(double2, double2) | Compute vector projection of a onto b. |
| project(double3, double3) | Compute vector projection of a onto b. |
| project(double4, double4) | Compute vector projection of a onto b. |
| project(float2, float2) | Compute vector projection of a onto b. |
| project(float3, float3) | Compute vector projection of a onto b. |
| project(float4, float4) | Compute vector projection of a onto b. |
| projectsafe(double2, double2, double2) | Compute vector projection of a onto b. If result is not finite, then return the default value instead. |
| projectsafe(double3, double3, double3) | Compute vector projection of a onto b. If result is not finite, then return the default value instead. |
| projectsafe(double4, double4, double4) | Compute vector projection of a onto b. If result is not finite, then return the default value instead. |
| projectsafe(float2, float2, float2) | Compute vector projection of a onto b. If result is not finite, then return the default value instead. |
| projectsafe(float3, float3, float3) | Compute vector projection of a onto b. If result is not finite, then return the default value instead. |
| projectsafe(float4, float4, float4) | Compute vector projection of a onto b. If result is not finite, then return the default value instead. |
| pseudoinverse(float3x3) | Computes the pseudoinverse of a matrix. |
| quaternion(float, float, float, float) | Returns a quaternion constructed from four float values. |
| quaternion(float3x3) | Returns a unit quaternion constructed from a float3x3 rotation matrix. The matrix must be orthonormal. |
| quaternion(float4) | Returns a quaternion constructed from a float4 vector. |
| quaternion(float4x4) | Returns a unit quaternion constructed from a float4x4 matrix. The matrix must be orthonormal. |
| radians(double) | Returns the result of converting a float value from degrees to radians. |
| radians(float) | Returns the result of converting a float value from degrees to radians. |
| radians(double2) | Returns the result of a componentwise conversion of a float2 vector from degrees to radians. |
| radians(double3) | Returns the result of a componentwise conversion of a float3 vector from degrees to radians. |
| radians(double4) | Returns the result of a componentwise conversion of a float4 vector from degrees to radians. |
| radians(float2) | Returns the result of a componentwise conversion of a float2 vector from degrees to radians. |
| radians(float3) | Returns the result of a componentwise conversion of a float3 vector from degrees to radians. |
| radians(float4) | Returns the result of a componentwise conversion of a float4 vector from degrees to radians. |
| rcp(double) | Returns the reciprocal a double value. |
| rcp(float) | Returns the reciprocal a float value. |
| rcp(double2) | Returns the componentwise reciprocal a double2 vector. |
| rcp(double3) | Returns the componentwise reciprocal a double3 vector. |
| rcp(double4) | Returns the componentwise reciprocal a double4 vector. |
| rcp(float2) | Returns the componentwise reciprocal a float2 vector. |
| rcp(float3) | Returns the componentwise reciprocal a float3 vector. |
| rcp(float4) | Returns the componentwise reciprocal a float4 vector. |
| reflect(double2, double2) | Given an incident vector i and a normal vector n, returns the reflection vector r = i - 2.0 * dot(i, n) * n. |
| reflect(double3, double3) | Given an incident vector i and a normal vector n, returns the reflection vector r = i - 2.0 * dot(i, n) * n. |
| reflect(double4, double4) | Given an incident vector i and a normal vector n, returns the reflection vector r = i - 2.0 * dot(i, n) * n. |
| reflect(float2, float2) | Given an incident vector i and a normal vector n, returns the reflection vector r = i - 2.0f * dot(i, n) * n. |
| reflect(float3, float3) | Given an incident vector i and a normal vector n, returns the reflection vector r = i - 2.0f * dot(i, n) * n. |
| reflect(float4, float4) | Given an incident vector i and a normal vector n, returns the reflection vector r = i - 2.0f * dot(i, n) * n. |
| refract(double2, double2, double) | Returns the refraction vector given the incident vector i, the normal vector n and the refraction index. |
| refract(double3, double3, double) | Returns the refraction vector given the incident vector i, the normal vector n and the refraction index. |
| refract(double4, double4, double) | Returns the refraction vector given the incident vector i, the normal vector n and the refraction index. |
| refract(float2, float2, float) | Returns the refraction vector given the incident vector i, the normal vector n and the refraction index. |
| refract(float3, float3, float) | Returns the refraction vector given the incident vector i, the normal vector n and the refraction index. |
| refract(float4, float4, float) | Returns the refraction vector given the incident vector i, the normal vector n and the refraction index. |
| remap(double, double, double, double, double) | Returns the result of a non-clamping linear remapping of a value x from source range [srcStart, srcEnd] to the destination range [dstStart, dstEnd]. |
| remap(float, float, float, float, float) | Returns the result of a non-clamping linear remapping of a value x from source range [srcStart, srcEnd] to the destination range [dstStart, dstEnd]. |
| remap(double2, double2, double2, double2, double2) | Returns the componentwise result of a non-clamping linear remapping of a value x from source range [srcStart, srcEnd] to the destination range [dstStart, dstEnd]. |
| remap(double3, double3, double3, double3, double3) | Returns the componentwise result of a non-clamping linear remapping of a value x from source range [srcStart, srcEnd] to the destination range [dstStart, dstEnd]. |
| remap(double4, double4, double4, double4, double4) | Returns the componentwise result of a non-clamping linear remapping of a value x from source range [srcStart, srcEnd] to the destination range [dstStart, dstEnd]. |
| remap(float2, float2, float2, float2, float2) | Returns the componentwise result of a non-clamping linear remapping of a value x from source range [srcStart, srcEnd] to the destination range [dstStart, dstEnd]. |
| remap(float3, float3, float3, float3, float3) | Returns the componentwise result of a non-clamping linear remapping of a value x from source range [srcStart, srcEnd] to the destination range [dstStart, dstEnd]. |
| remap(float4, float4, float4, float4, float4) | Returns the componentwise result of a non-clamping linear remapping of a value x from source range [srcStart, srcEnd] to the destination range [dstStart, dstEnd]. |
| reversebits(int) | Returns the result of performing a reversal of the bit pattern of an int value. |
| reversebits(long) | Returns the result of performing a reversal of the bit pattern of a long value. |
| reversebits(uint) | Returns the result of performing a reversal of the bit pattern of a uint value. |
| reversebits(ulong) | Returns the result of performing a reversal of the bit pattern of a ulong value. |
| reversebits(int2) | Returns the result of performing a componentwise reversal of the bit pattern of an int2 vector. |
| reversebits(int3) | Returns the result of performing a componentwise reversal of the bit pattern of an int3 vector. |
| reversebits(int4) | Returns the result of performing a componentwise reversal of the bit pattern of an int4 vector. |
| reversebits(uint2) | Returns the result of performing a componentwise reversal of the bit pattern of an uint2 vector. |
| reversebits(uint3) | Returns the result of performing a componentwise reversal of the bit pattern of an uint3 vector. |
| reversebits(uint4) | Returns the result of performing a componentwise reversal of the bit pattern of an uint4 vector. |
| right() | Unity's right axis (1, 0, 0). |
| rol(int, int) | Returns the result of rotating the bits of an int left by bits n. |
| rol(long, int) | Returns the result of rotating the bits of a long left by bits n. |
| rol(uint, int) | Returns the result of rotating the bits of a uint left by bits n. |
| rol(ulong, int) | Returns the result of rotating the bits of a ulong left by bits n. |
| rol(int2, int) | Returns the componentwise result of rotating the bits of an int2 left by bits n. |
| rol(int3, int) | Returns the componentwise result of rotating the bits of an int3 left by bits n. |
| rol(int4, int) | Returns the componentwise result of rotating the bits of an int4 left by bits n. |
| rol(uint2, int) | Returns the componentwise result of rotating the bits of a uint2 left by bits n. |
| rol(uint3, int) | Returns the componentwise result of rotating the bits of a uint3 left by bits n. |
| rol(uint4, int) | Returns the componentwise result of rotating the bits of a uint4 left by bits n. |
| ror(int, int) | Returns the result of rotating the bits of an int right by bits n. |
| ror(long, int) | Returns the result of rotating the bits of a long right by bits n. |
| ror(uint, int) | Returns the result of rotating the bits of a uint right by bits n. |
| ror(ulong, int) | Returns the result of rotating the bits of a ulong right by bits n. |
| ror(int2, int) | Returns the componentwise result of rotating the bits of an int2 right by bits n. |
| ror(int3, int) | Returns the componentwise result of rotating the bits of an int3 right by bits n. |
| ror(int4, int) | Returns the componentwise result of rotating the bits of an int4 right by bits n. |
| ror(uint2, int) | Returns the componentwise result of rotating the bits of a uint2 right by bits n. |
| ror(uint3, int) | Returns the componentwise result of rotating the bits of a uint3 right by bits n. |
| ror(uint4, int) | Returns the componentwise result of rotating the bits of a uint4 right by bits n. |
| rotate(AffineTransform, float3) | Returns the result of rotating a float3 vector by an AffineTransform. |
| rotate(RigidTransform, float3) | Returns the result of rotating a float3 vector by a RigidTransform. |
| rotate(double4x4, double3) | Return the result of rotating a double3 vector by a double4x4 matrix |
| rotate(float4x4, float3) | Return the result of rotating a float3 vector by a float4x4 matrix |
| rotate(quaternion, float3) | Returns the result of rotating a vector by a unit quaternion. |
| rotation(float3x3) | Extracts the rotation from a matrix. |
| round(double) | Returns the result of rounding a double value to the nearest integral value. |
| round(float) | Returns the result of rounding a float value to the nearest integral value. |
| round(double2) | Returns the result of rounding each component of a double2 vector value to the nearest integral value. |
| round(double3) | Returns the result of rounding each component of a double3 vector value to the nearest integral value. |
| round(double4) | Returns the result of rounding each component of a double4 vector value to the nearest integral value. |
| round(float2) | Returns the result of rounding each component of a float2 vector value to the nearest integral value. |
| round(float3) | Returns the result of rounding each component of a float3 vector value to the nearest integral value. |
| round(float4) | Returns the result of rounding each component of a float4 vector value to the nearest integral value. |
| rsqrt(double) | Returns the reciprocal square root of a double value. |
| rsqrt(float) | Returns the reciprocal square root of a float value. |
| rsqrt(double2) | Returns the componentwise reciprocal square root of a double2 vector. |
| rsqrt(double3) | Returns the componentwise reciprocal square root of a double3 vector. |
| rsqrt(double4) | Returns the componentwise reciprocal square root of a double4 vector. |
| rsqrt(float2) | Returns the componentwise reciprocal square root of a float2 vector. |
| rsqrt(float3) | Returns the componentwise reciprocal square root of a float3 vector. |
| rsqrt(float4) | Returns the componentwise reciprocal square root of a float4 vector |
| saturate(double) | Returns the result of clamping the double value x into the interval [0, 1]. |
| saturate(float) | Returns the result of clamping the float value x into the interval [0, 1]. |
| saturate(double2) | Returns the result of a componentwise clamping of the double2 vector x into the interval [0, 1]. |
| saturate(double3) | Returns the result of a componentwise clamping of the double3 vector x into the interval [0, 1]. |
| saturate(double4) | Returns the result of a componentwise clamping of the double4 vector x into the interval [0, 1]. |
| saturate(float2) | Returns the result of a componentwise clamping of the float2 vector x into the interval [0, 1]. |
| saturate(float3) | Returns the result of a componentwise clamping of the float3 vector x into the interval [0, 1]. |
| saturate(float4) | Returns the result of a componentwise clamping of the float4 vector x into the interval [0, 1]. |
| scaleMul(float3, float3x3) | 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(double, double, bool) | Returns trueValue if test is true, falseValue otherwise. |
| select(int, int, bool) | Returns trueValue if test is true, falseValue otherwise. |
| select(long, long, bool) | Returns trueValue if test is true, falseValue otherwise. |
| select(float, float, bool) | Returns trueValue if test is true, falseValue otherwise. |
| select(uint, uint, bool) | Returns trueValue if test is true, falseValue otherwise. |
| select(ulong, ulong, bool) | Returns trueValue if test is true, falseValue otherwise. |
| select(double2, double2, bool) | Returns trueValue if test is true, falseValue otherwise. |
| select(double2, double2, bool2) | Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test. Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected. |
| select(double3, double3, bool) | Returns trueValue if test is true, falseValue otherwise. |
| select(double3, double3, bool3) | Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test. Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected. |
| select(double4, double4, bool) | Returns trueValue if test is true, falseValue otherwise. |
| select(double4, double4, bool4) | Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test. Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected. |
| select(float2, float2, bool) | Returns trueValue if test is true, falseValue otherwise. |
| select(float2, float2, bool2) | Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test. Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected. |
| select(float3, float3, bool) | Returns trueValue if test is true, falseValue otherwise. |
| select(float3, float3, bool3) | Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test. Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected. |
| select(float4, float4, bool) | Returns trueValue if test is true, falseValue otherwise. |
| select(float4, float4, bool4) | Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test. Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected. |
| select(int2, int2, bool) | Returns trueValue if test is true, falseValue otherwise. |
| select(int2, int2, bool2) | Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test. Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected. |
| select(int3, int3, bool) | Returns trueValue if test is true, falseValue otherwise. |
| select(int3, int3, bool3) | Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test. Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected. |
| select(int4, int4, bool) | Returns trueValue if test is true, falseValue otherwise. |
| select(int4, int4, bool4) | Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test. Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected. |
| select(uint2, uint2, bool) | Returns trueValue if test is true, falseValue otherwise. |
| select(uint2, uint2, bool2) | Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test. Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected. |
| select(uint3, uint3, bool) | Returns trueValue if test is true, falseValue otherwise. |
| select(uint3, uint3, bool3) | Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test. Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected. |
| select(uint4, uint4, bool) | Returns trueValue if test is true, falseValue otherwise. |
| select(uint4, uint4, bool4) | Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test. Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected. |
| shuffle(bool2, bool2, ShuffleComponent) | Returns the result of specified shuffling of the components from two bool2 vectors into a bool value. |
| shuffle(bool2, bool2, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two bool2 vectors into a bool2 vector. |
| shuffle(bool2, bool2, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two bool2 vectors into a bool3 vector. |
| shuffle(bool2, bool2, ShuffleComponent, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two bool2 vectors into a bool4 vector. |
| shuffle(bool3, bool3, ShuffleComponent) | Returns the result of specified shuffling of the components from two bool3 vectors into a bool value. |
| shuffle(bool3, bool3, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two bool3 vectors into a bool2 vector. |
| shuffle(bool3, bool3, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two bool3 vectors into a bool3 vector. |
| shuffle(bool3, bool3, ShuffleComponent, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two bool3 vectors into a bool4 vector. |
| shuffle(bool4, bool4, ShuffleComponent) | Returns the result of specified shuffling of the components from two bool4 vectors into a bool value. |
| shuffle(bool4, bool4, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two bool4 vectors into a bool2 vector. |
| shuffle(bool4, bool4, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two bool4 vectors into a bool3 vector. |
| shuffle(bool4, bool4, ShuffleComponent, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two bool4 vectors into a bool4 vector. |
| shuffle(double2, double2, ShuffleComponent) | Returns the result of specified shuffling of the components from two double2 vectors into a double value. |
| shuffle(double2, double2, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two double2 vectors into a double2 vector. |
| shuffle(double2, double2, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two double2 vectors into a double3 vector. |
| shuffle(double2, double2, ShuffleComponent, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two double2 vectors into a double4 vector. |
| shuffle(double3, double3, ShuffleComponent) | Returns the result of specified shuffling of the components from two double3 vectors into a double value. |
| shuffle(double3, double3, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two double3 vectors into a double2 vector. |
| shuffle(double3, double3, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two double3 vectors into a double3 vector. |
| shuffle(double3, double3, ShuffleComponent, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two double3 vectors into a double4 vector. |
| shuffle(double4, double4, ShuffleComponent) | Returns the result of specified shuffling of the components from two double4 vectors into a double value. |
| shuffle(double4, double4, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two double4 vectors into a double2 vector. |
| shuffle(double4, double4, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two double4 vectors into a double3 vector. |
| shuffle(double4, double4, ShuffleComponent, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two double4 vectors into a double4 vector. |
| shuffle(float2, float2, ShuffleComponent) | Returns the result of specified shuffling of the components from two float2 vectors into a float value. |
| shuffle(float2, float2, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two float2 vectors into a float2 vector. |
| shuffle(float2, float2, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two float2 vectors into a float3 vector. |
| shuffle(float2, float2, ShuffleComponent, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two float2 vectors into a float4 vector. |
| shuffle(float3, float3, ShuffleComponent) | Returns the result of specified shuffling of the components from two float3 vectors into a float value. |
| shuffle(float3, float3, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two float3 vectors into a float2 vector. |
| shuffle(float3, float3, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two float3 vectors into a float3 vector. |
| shuffle(float3, float3, ShuffleComponent, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two float3 vectors into a float4 vector. |
| shuffle(float4, float4, ShuffleComponent) | Returns the result of specified shuffling of the components from two float4 vectors into a float value. |
| shuffle(float4, float4, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two float4 vectors into a float2 vector. |
| shuffle(float4, float4, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two float4 vectors into a float3 vector. |
| shuffle(float4, float4, ShuffleComponent, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two float4 vectors into a float4 vector. |
| shuffle(int2, int2, ShuffleComponent) | Returns the result of specified shuffling of the components from two int2 vectors into an int value. |
| shuffle(int2, int2, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two int2 vectors into an int2 vector. |
| shuffle(int2, int2, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two int2 vectors into an int3 vector. |
| shuffle(int2, int2, ShuffleComponent, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two int2 vectors into an int4 vector. |
| shuffle(int3, int3, ShuffleComponent) | Returns the result of specified shuffling of the components from two int3 vectors into an int value. |
| shuffle(int3, int3, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two int3 vectors into an int2 vector. |
| shuffle(int3, int3, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two int3 vectors into an int3 vector. |
| shuffle(int3, int3, ShuffleComponent, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two int3 vectors into an int4 vector. |
| shuffle(int4, int4, ShuffleComponent) | Returns the result of specified shuffling of the components from two int4 vectors into an int value. |
| shuffle(int4, int4, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two int4 vectors into an int2 vector. |
| shuffle(int4, int4, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two int4 vectors into an int3 vector. |
| shuffle(int4, int4, ShuffleComponent, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two int4 vectors into an int4 vector. |
| shuffle(uint2, uint2, ShuffleComponent) | Returns the result of specified shuffling of the components from two uint2 vectors into a uint value. |
| shuffle(uint2, uint2, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two uint2 vectors into a uint2 vector. |
| shuffle(uint2, uint2, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two uint2 vectors into a uint3 vector. |
| shuffle(uint2, uint2, ShuffleComponent, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two uint2 vectors into a uint4 vector. |
| shuffle(uint3, uint3, ShuffleComponent) | Returns the result of specified shuffling of the components from two uint3 vectors into a uint value. |
| shuffle(uint3, uint3, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two uint3 vectors into a uint2 vector. |
| shuffle(uint3, uint3, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two uint3 vectors into a uint3 vector. |
| shuffle(uint3, uint3, ShuffleComponent, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two uint3 vectors into a uint4 vector. |
| shuffle(uint4, uint4, ShuffleComponent) | Returns the result of specified shuffling of the components from two uint4 vectors into a uint value. |
| shuffle(uint4, uint4, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two uint4 vectors into a uint2 vector. |
| shuffle(uint4, uint4, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two uint4 vectors into a uint3 vector. |
| shuffle(uint4, uint4, ShuffleComponent, ShuffleComponent, ShuffleComponent, ShuffleComponent) | Returns the result of specified shuffling of the components from two uint4 vectors into a uint4 vector. |
| sign(double) | Returns the sign of a double value. -1.0 if it is less than zero, 0.0 if it is zero and 1.0 if it greater than zero. |
| sign(int) | 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. |
| sign(float) | Returns the sign of a float value. -1.0f if it is less than zero, 0.0f if it is zero and 1.0f if it greater than zero. |
| sign(double2) | Returns the componentwise sign of a double2 value. 1.0 for positive components, 0.0 for zero components and -1.0 for negative components. |
| sign(double3) | Returns the componentwise sign of a double3 value. 1.0 for positive components, 0.0 for zero components and -1.0 for negative components. |
| sign(double4) | Returns the componentwise sign of a double4 value. 1.0 for positive components, 0.0 for zero components and -1.0 for negative components. |
| sign(float2) | Returns the componentwise sign of a float2 value. 1.0f for positive components, 0.0f for zero components and -1.0f for negative components. |
| sign(float3) | Returns the componentwise sign of a float3 value. 1.0f for positive components, 0.0f for zero components and -1.0f for negative components. |
| sign(float4) | Returns the componentwise sign of a float4 value. 1.0f for positive components, 0.0f for zero components and -1.0f for negative components. |
| sign(int2) | Returns the componentwise sign of a int2 value. 1 for positive components, 0 for zero components and -1 for negative components. |
| sign(int3) | Returns the componentwise sign of a int3 value. 1 for positive components, 0 for zero components and -1 for negative components. |
| sign(int4) | Returns the componentwise sign of a int4 value. 1 for positive components, 0 for zero components and -1 for negative components. |
| sin(double) | Returns the sine of a double value. |
| sin(float) | Returns the sine of a float value. |
| sin(double2) | Returns the componentwise sine of a double2 vector. |
| sin(double3) | Returns the componentwise sine of a double3 vector. |
| sin(double4) | Returns the componentwise sine of a double4 vector. |
| sin(float2) | Returns the componentwise sine of a float2 vector. |
| sin(float3) | Returns the componentwise sine of a float3 vector. |
| sin(float4) | Returns the componentwise sine of a float4 vector. |
| sincos(double, out double, out double) | Returns the sine and cosine of the input double value x through the out parameters s and c. |
| sincos(float, out float, out float) | Returns the sine and cosine of the input float value x through the out parameters s and c. |
| sincos(double2, out double2, out double2) | Returns the componentwise sine and cosine of the input double2 vector x through the out parameters s and c. |
| sincos(double3, out double3, out double3) | Returns the componentwise sine and cosine of the input double3 vector x through the out parameters s and c. |
| sincos(double4, out double4, out double4) | Returns the componentwise sine and cosine of the input double4 vector x through the out parameters s and c. |
| sincos(float2, out float2, out float2) | Returns the componentwise sine and cosine of the input float2 vector x through the out parameters s and c. |
| sincos(float3, out float3, out float3) | Returns the componentwise sine and cosine of the input float3 vector x through the out parameters s and c. |
| sincos(float4, out float4, out float4) | Returns the componentwise sine and cosine of the input float4 vector x through the out parameters s and c. |
| sinh(double) | Returns the hyperbolic sine of a double value. |
| sinh(float) | Returns the hyperbolic sine of a float value. |
| sinh(double2) | Returns the componentwise hyperbolic sine of a double2 vector. |
| sinh(double3) | Returns the componentwise hyperbolic sine of a double3 vector. |
| sinh(double4) | Returns the componentwise hyperbolic sine of a double4 vector. |
| sinh(float2) | Returns the componentwise hyperbolic sine of a float2 vector. |
| sinh(float3) | Returns the componentwise hyperbolic sine of a float3 vector. |
| sinh(float4) | Returns the componentwise hyperbolic sine of a float4 vector. |
| slerp(quaternion, quaternion, float) | Returns the result of a spherical interpolation between two quaternions q1 and a2 using an interpolation parameter t. |
| smoothstep(double, double, double) | Returns a smooth Hermite interpolation between 0.0 and 1.0 when x is in the interval (inclusive) [xMin, xMax]. |
| smoothstep(float, float, float) | Returns a smooth Hermite interpolation between 0.0f and 1.0f when x is in the interval (inclusive) [xMin, xMax]. |
| smoothstep(double2, double2, double2) | Returns a componentwise smooth Hermite interpolation between 0.0 and 1.0 when x is in the interval (inclusive) [xMin, xMax]. |
| smoothstep(double3, double3, double3) | Returns a componentwise smooth Hermite interpolation between 0.0 and 1.0 when x is in the interval (inclusive) [xMin, xMax]. |
| smoothstep(double4, double4, double4) | Returns a componentwise smooth Hermite interpolation between 0.0 and 1.0 when x is in the interval (inclusive) [xMin, xMax]. |
| smoothstep(float2, float2, float2) | Returns a componentwise smooth Hermite interpolation between 0.0f and 1.0f when x is in the interval (inclusive) [xMin, xMax]. |
| smoothstep(float3, float3, float3) | Returns a componentwise smooth Hermite interpolation between 0.0f and 1.0f when x is in the interval (inclusive) [xMin, xMax]. |
| smoothstep(float4, float4, float4) | Returns a componentwise smooth Hermite interpolation between 0.0f and 1.0f when x is in the interval (inclusive) [xMin, xMax]. |
| sqrt(double) | Returns the square root of a double value. |
| sqrt(float) | Returns the square root of a float value. |
| sqrt(double2) | Returns the componentwise square root of a double2 vector. |
| sqrt(double3) | Returns the componentwise square root of a double3 vector. |
| sqrt(double4) | Returns the componentwise square root of a double4 vector. |
| sqrt(float2) | Returns the componentwise square root of a float2 vector. |
| sqrt(float3) | Returns the componentwise square root of a float3 vector. |
| sqrt(float4) | Returns the componentwise square root of a float4 vector. |
| square(double) | Computes the square (x * x) of the input argument x. |
| square(int) | Computes the square (x * x) of the input argument x. |
| square(float) | Computes the square (x * x) of the input argument x. |
| square(uint) | Computes the square (x * x) of the input argument x. |
| square(double2) | Computes the component-wise square (x * x) of the input argument x. |
| square(double3) | Computes the component-wise square (x * x) of the input argument x. |
| square(double4) | Computes the component-wise square (x * x) of the input argument x. |
| square(float2) | Computes the component-wise square (x * x) of the input argument x. |
| square(float3) | Computes the component-wise square (x * x) of the input argument x. |
| square(float4) | Computes the component-wise square (x * x) of the input argument x. |
| square(int2) | Computes the component-wise square (x * x) of the input argument x. |
| square(int3) | Computes the component-wise square (x * x) of the input argument x. |
| square(int4) | Computes the component-wise square (x * x) of the input argument x. |
| square(uint2) | Computes the component-wise square (x * x) of the input argument x. |
| square(uint3) | Computes the component-wise square (x * x) of the input argument x. |
| square(uint4) | Computes the component-wise square (x * x) of the input argument x. |
| step(double, double) | Returns the result of a step function where the result is 1.0f when x >= threshold and 0.0f otherwise. |
| step(float, float) | Returns the result of a step function where the result is 1.0f when x >= threshold and 0.0f otherwise. |
| step(double2, double2) | Returns the result of a componentwise step function where each component is 1.0f when x >= threshold and 0.0f otherwise. |
| step(double3, double3) | Returns the result of a componentwise step function where each component is 1.0f when x >= threshold and 0.0f otherwise. |
| step(double4, double4) | Returns the result of a componentwise step function where each component is 1.0f when x >= threshold and 0.0f otherwise. |
| step(float2, float2) | Returns the result of a componentwise step function where each component is 1.0f when x >= threshold and 0.0f otherwise. |
| step(float3, float3) | Returns the result of a componentwise step function where each component is 1.0f when x >= threshold and 0.0f otherwise. |
| step(float4, float4) | Returns the result of a componentwise step function where each component is 1.0f when x >= threshold and 0.0f otherwise. |
| tan(double) | Returns the tangent of a double value. |
| tan(float) | Returns the tangent of a float value. |
| tan(double2) | Returns the componentwise tangent of a double2 vector. |
| tan(double3) | Returns the componentwise tangent of a double3 vector. |
| tan(double4) | Returns the componentwise tangent of a double4 vector. |
| tan(float2) | Returns the componentwise tangent of a float2 vector. |
| tan(float3) | Returns the componentwise tangent of a float3 vector. |
| tan(float4) | Returns the componentwise tangent of a float4 vector. |
| tanh(double) | Returns the hyperbolic tangent of a double value. |
| tanh(float) | Returns the hyperbolic tangent of a float value. |
| tanh(double2) | Returns the componentwise hyperbolic tangent of a double2 vector. |
| tanh(double3) | Returns the componentwise hyperbolic tangent of a double3 vector. |
| tanh(double4) | Returns the componentwise hyperbolic tangent of a double4 vector. |
| tanh(float2) | Returns the componentwise hyperbolic tangent of a float2 vector. |
| tanh(float3) | Returns the componentwise hyperbolic tangent of a float3 vector. |
| tanh(float4) | Returns the componentwise hyperbolic tangent of a float4 vector. |
| transform(AffineTransform, float3) | Returns the result of transforming a float3 point by an AffineTransform. |
| transform(RigidTransform, float3) | Returns the result of transforming a float3 point by a RigidTransform. |
| transform(double4x4, double3) | Return the result of transforming a double3 point by a double4x4 matrix |
| transform(float4x4, float3) | Return the result of transforming a float3 point by a float4x4 matrix |
| transpose(bool2x2) | Return the bool2x2 transpose of a bool2x2 matrix. |
| transpose(bool2x3) | Return the bool3x2 transpose of a bool2x3 matrix. |
| transpose(bool2x4) | Return the bool4x2 transpose of a bool2x4 matrix. |
| transpose(bool3x2) | Return the bool2x3 transpose of a bool3x2 matrix. |
| transpose(bool3x3) | Return the bool3x3 transpose of a bool3x3 matrix. |
| transpose(bool3x4) | Return the bool4x3 transpose of a bool3x4 matrix. |
| transpose(bool4x2) | Return the bool2x4 transpose of a bool4x2 matrix. |
| transpose(bool4x3) | Return the bool3x4 transpose of a bool4x3 matrix. |
| transpose(bool4x4) | Return the bool4x4 transpose of a bool4x4 matrix. |
| transpose(double2x2) | Return the double2x2 transpose of a double2x2 matrix. |
| transpose(double2x3) | Return the double3x2 transpose of a double2x3 matrix. |
| transpose(double2x4) | Return the double4x2 transpose of a double2x4 matrix. |
| transpose(double3x2) | Return the double2x3 transpose of a double3x2 matrix. |
| transpose(double3x3) | Return the double3x3 transpose of a double3x3 matrix. |
| transpose(double3x4) | Return the double4x3 transpose of a double3x4 matrix. |
| transpose(double4x2) | Return the double2x4 transpose of a double4x2 matrix. |
| transpose(double4x3) | Return the double3x4 transpose of a double4x3 matrix. |
| transpose(double4x4) | Return the double4x4 transpose of a double4x4 matrix. |
| transpose(float2x2) | Return the float2x2 transpose of a float2x2 matrix. |
| transpose(float2x3) | Return the float3x2 transpose of a float2x3 matrix. |
| transpose(float2x4) | Return the float4x2 transpose of a float2x4 matrix. |
| transpose(float3x2) | Return the float2x3 transpose of a float3x2 matrix. |
| transpose(float3x3) | Return the float3x3 transpose of a float3x3 matrix. |
| transpose(float3x4) | Return the float4x3 transpose of a float3x4 matrix. |
| transpose(float4x2) | Return the float2x4 transpose of a float4x2 matrix. |
| transpose(float4x3) | Return the float3x4 transpose of a float4x3 matrix. |
| transpose(float4x4) | Return the float4x4 transpose of a float4x4 matrix. |
| transpose(int2x2) | Return the int2x2 transpose of a int2x2 matrix. |
| transpose(int2x3) | Return the int3x2 transpose of a int2x3 matrix. |
| transpose(int2x4) | Return the int4x2 transpose of a int2x4 matrix. |
| transpose(int3x2) | Return the int2x3 transpose of a int3x2 matrix. |
| transpose(int3x3) | Return the int3x3 transpose of a int3x3 matrix. |
| transpose(int3x4) | Return the int4x3 transpose of a int3x4 matrix. |
| transpose(int4x2) | Return the int2x4 transpose of a int4x2 matrix. |
| transpose(int4x3) | Return the int3x4 transpose of a int4x3 matrix. |
| transpose(int4x4) | Return the int4x4 transpose of a int4x4 matrix. |
| transpose(uint2x2) | Return the uint2x2 transpose of a uint2x2 matrix. |
| transpose(uint2x3) | Return the uint3x2 transpose of a uint2x3 matrix. |
| transpose(uint2x4) | Return the uint4x2 transpose of a uint2x4 matrix. |
| transpose(uint3x2) | Return the uint2x3 transpose of a uint3x2 matrix. |
| transpose(uint3x3) | Return the uint3x3 transpose of a uint3x3 matrix. |
| transpose(uint3x4) | Return the uint4x3 transpose of a uint3x4 matrix. |
| transpose(uint4x2) | Return the uint2x4 transpose of a uint4x2 matrix. |
| transpose(uint4x3) | Return the uint3x4 transpose of a uint4x3 matrix. |
| transpose(uint4x4) | Return the uint4x4 transpose of a uint4x4 matrix. |
| trunc(double) | Returns the result of truncating a double value to an integral double value. |
| trunc(float) | Returns the result of truncating a float value to an integral float value. |
| trunc(double2) | Returns the result of a componentwise truncation of a double2 value to an integral double2 value. |
| trunc(double3) | Returns the result of a componentwise truncation of a double3 value to an integral double3 value. |
| trunc(double4) | Returns the result of a componentwise truncation of a double4 value to an integral double4 value. |
| trunc(float2) | Returns the result of a componentwise truncation of a float2 value to an integral float2 value. |
| trunc(float3) | Returns the result of a componentwise truncation of a float3 value to an integral float3 value. |
| trunc(float4) | Returns the result of a componentwise truncation of a float4 value to an integral float4 value. |
| tzcnt(int) | Computes the trailing zero count in the binary representation of the input value. |
| tzcnt(long) | Computes the trailing zero count in the binary representation of the input value. |
| tzcnt(uint) | Computes the trailing zero count in the binary representation of the input value. |
| tzcnt(ulong) | Computes the trailing zero count in the binary representation of the input value. |
| tzcnt(int2) | Computes the component-wise trailing zero count in the binary representation of the input value. |
| tzcnt(int3) | Computes the component-wise trailing zero count in the binary representation of the input value. |
| tzcnt(int4) | Computes the component-wise trailing zero count in the binary representation of the input value. |
| tzcnt(uint2) | Computes the component-wise trailing zero count in the binary representation of the input value. |
| tzcnt(uint3) | Computes the component-wise trailing zero count in the binary representation of the input value. |
| tzcnt(uint4) | Computes the component-wise trailing zero count in the binary representation of the input value. |
| uint2(bool) | Returns a uint2 vector constructed from a single bool value by converting it to uint and assigning it to every component. |
| uint2(double) | Returns a uint2 vector constructed from a single double value by converting it to uint and assigning it to every component. |
| uint2(int) | Returns a uint2 vector constructed from a single int value by converting it to uint and assigning it to every component. |
| uint2(float) | Returns a uint2 vector constructed from a single float value by converting it to uint and assigning it to every component. |
| uint2(uint) | Returns a uint2 vector constructed from a single uint value by assigning it to every component. |
| uint2(uint, uint) | Returns a uint2 vector constructed from two uint values. |
| uint2(bool2) | Return a uint2 vector constructed from a bool2 vector by componentwise conversion. |
| uint2(double2) | Return a uint2 vector constructed from a double2 vector by componentwise conversion. |
| uint2(float2) | Return a uint2 vector constructed from a float2 vector by componentwise conversion. |
| uint2(int2) | Return a uint2 vector constructed from a int2 vector by componentwise conversion. |
| uint2(uint2) | Returns a uint2 vector constructed from a uint2 vector. |
| uint2x2(bool) | Returns a uint2x2 matrix constructed from a single bool value by converting it to uint and assigning it to every component. |
| uint2x2(double) | Returns a uint2x2 matrix constructed from a single double value by converting it to uint and assigning it to every component. |
| uint2x2(int) | Returns a uint2x2 matrix constructed from a single int value by converting it to uint and assigning it to every component. |
| uint2x2(float) | Returns a uint2x2 matrix constructed from a single float value by converting it to uint and assigning it to every component. |
| uint2x2(uint) | Returns a uint2x2 matrix constructed from a single uint value by assigning it to every component. |
| uint2x2(uint, uint, uint, uint) | Returns a uint2x2 matrix constructed from from 4 uint values given in row-major order. |
| uint2x2(bool2x2) | Return a uint2x2 matrix constructed from a bool2x2 matrix by componentwise conversion. |
| uint2x2(double2x2) | Return a uint2x2 matrix constructed from a double2x2 matrix by componentwise conversion. |
| uint2x2(float2x2) | Return a uint2x2 matrix constructed from a float2x2 matrix by componentwise conversion. |
| uint2x2(int2x2) | Return a uint2x2 matrix constructed from a int2x2 matrix by componentwise conversion. |
| uint2x2(uint2, uint2) | Returns a uint2x2 matrix constructed from two uint2 vectors. |
| uint2x3(bool) | Returns a uint2x3 matrix constructed from a single bool value by converting it to uint and assigning it to every component. |
| uint2x3(double) | Returns a uint2x3 matrix constructed from a single double value by converting it to uint and assigning it to every component. |
| uint2x3(int) | Returns a uint2x3 matrix constructed from a single int value by converting it to uint and assigning it to every component. |
| uint2x3(float) | Returns a uint2x3 matrix constructed from a single float value by converting it to uint and assigning it to every component. |
| uint2x3(uint) | Returns a uint2x3 matrix constructed from a single uint value by assigning it to every component. |
| uint2x3(uint, uint, uint, uint, uint, uint) | Returns a uint2x3 matrix constructed from from 6 uint values given in row-major order. |
| uint2x3(bool2x3) | Return a uint2x3 matrix constructed from a bool2x3 matrix by componentwise conversion. |
| uint2x3(double2x3) | Return a uint2x3 matrix constructed from a double2x3 matrix by componentwise conversion. |
| uint2x3(float2x3) | Return a uint2x3 matrix constructed from a float2x3 matrix by componentwise conversion. |
| uint2x3(int2x3) | Return a uint2x3 matrix constructed from a int2x3 matrix by componentwise conversion. |
| uint2x3(uint2, uint2, uint2) | Returns a uint2x3 matrix constructed from three uint2 vectors. |
| uint2x4(bool) | Returns a uint2x4 matrix constructed from a single bool value by converting it to uint and assigning it to every component. |
| uint2x4(double) | Returns a uint2x4 matrix constructed from a single double value by converting it to uint and assigning it to every component. |
| uint2x4(int) | Returns a uint2x4 matrix constructed from a single int value by converting it to uint and assigning it to every component. |
| uint2x4(float) | Returns a uint2x4 matrix constructed from a single float value by converting it to uint and assigning it to every component. |
| uint2x4(uint) | Returns a uint2x4 matrix constructed from a single uint value by assigning it to every component. |
| uint2x4(uint, uint, uint, uint, uint, uint, uint, uint) | Returns a uint2x4 matrix constructed from from 8 uint values given in row-major order. |
| uint2x4(bool2x4) | Return a uint2x4 matrix constructed from a bool2x4 matrix by componentwise conversion. |
| uint2x4(double2x4) | Return a uint2x4 matrix constructed from a double2x4 matrix by componentwise conversion. |
| uint2x4(float2x4) | Return a uint2x4 matrix constructed from a float2x4 matrix by componentwise conversion. |
| uint2x4(int2x4) | Return a uint2x4 matrix constructed from a int2x4 matrix by componentwise conversion. |
| uint2x4(uint2, uint2, uint2, uint2) | Returns a uint2x4 matrix constructed from four uint2 vectors. |
| uint3(bool) | Returns a uint3 vector constructed from a single bool value by converting it to uint and assigning it to every component. |
| uint3(double) | Returns a uint3 vector constructed from a single double value by converting it to uint and assigning it to every component. |
| uint3(int) | Returns a uint3 vector constructed from a single int value by converting it to uint and assigning it to every component. |
| uint3(float) | Returns a uint3 vector constructed from a single float value by converting it to uint and assigning it to every component. |
| uint3(uint) | Returns a uint3 vector constructed from a single uint value by assigning it to every component. |
| uint3(uint, uint, uint) | Returns a uint3 vector constructed from three uint values. |
| uint3(uint, uint2) | Returns a uint3 vector constructed from a uint value and a uint2 vector. |
| uint3(bool3) | Return a uint3 vector constructed from a bool3 vector by componentwise conversion. |
| uint3(double3) | Return a uint3 vector constructed from a double3 vector by componentwise conversion. |
| uint3(float3) | Return a uint3 vector constructed from a float3 vector by componentwise conversion. |
| uint3(int3) | Return a uint3 vector constructed from a int3 vector by componentwise conversion. |
| uint3(uint2, uint) | Returns a uint3 vector constructed from a uint2 vector and a uint value. |
| uint3(uint3) | Returns a uint3 vector constructed from a uint3 vector. |
| uint3x2(bool) | Returns a uint3x2 matrix constructed from a single bool value by converting it to uint and assigning it to every component. |
| uint3x2(double) | Returns a uint3x2 matrix constructed from a single double value by converting it to uint and assigning it to every component. |
| uint3x2(int) | Returns a uint3x2 matrix constructed from a single int value by converting it to uint and assigning it to every component. |
| uint3x2(float) | Returns a uint3x2 matrix constructed from a single float value by converting it to uint and assigning it to every component. |
| uint3x2(uint) | Returns a uint3x2 matrix constructed from a single uint value by assigning it to every component. |
| uint3x2(uint, uint, uint, uint, uint, uint) | Returns a uint3x2 matrix constructed from from 6 uint values given in row-major order. |
| uint3x2(bool3x2) | Return a uint3x2 matrix constructed from a bool3x2 matrix by componentwise conversion. |
| uint3x2(double3x2) | Return a uint3x2 matrix constructed from a double3x2 matrix by componentwise conversion. |
| uint3x2(float3x2) | Return a uint3x2 matrix constructed from a float3x2 matrix by componentwise conversion. |
| uint3x2(int3x2) | Return a uint3x2 matrix constructed from a int3x2 matrix by componentwise conversion. |
| uint3x2(uint3, uint3) | Returns a uint3x2 matrix constructed from two uint3 vectors. |
| uint3x3(bool) | Returns a uint3x3 matrix constructed from a single bool value by converting it to uint and assigning it to every component. |
| uint3x3(double) | Returns a uint3x3 matrix constructed from a single double value by converting it to uint and assigning it to every component. |
| uint3x3(int) | Returns a uint3x3 matrix constructed from a single int value by converting it to uint and assigning it to every component. |
| uint3x3(float) | Returns a uint3x3 matrix constructed from a single float value by converting it to uint and assigning it to every component. |
| uint3x3(uint) | Returns a uint3x3 matrix constructed from a single uint value by assigning it to every component. |
| uint3x3(uint, uint, uint, uint, uint, uint, uint, uint, uint) | Returns a uint3x3 matrix constructed from from 9 uint values given in row-major order. |
| uint3x3(bool3x3) | Return a uint3x3 matrix constructed from a bool3x3 matrix by componentwise conversion. |
| uint3x3(double3x3) | Return a uint3x3 matrix constructed from a double3x3 matrix by componentwise conversion. |
| uint3x3(float3x3) | Return a uint3x3 matrix constructed from a float3x3 matrix by componentwise conversion. |
| uint3x3(int3x3) | Return a uint3x3 matrix constructed from a int3x3 matrix by componentwise conversion. |
| uint3x3(uint3, uint3, uint3) | Returns a uint3x3 matrix constructed from three uint3 vectors. |
| uint3x4(bool) | Returns a uint3x4 matrix constructed from a single bool value by converting it to uint and assigning it to every component. |
| uint3x4(double) | Returns a uint3x4 matrix constructed from a single double value by converting it to uint and assigning it to every component. |
| uint3x4(int) | Returns a uint3x4 matrix constructed from a single int value by converting it to uint and assigning it to every component. |
| uint3x4(float) | Returns a uint3x4 matrix constructed from a single float value by converting it to uint and assigning it to every component. |
| uint3x4(uint) | Returns a uint3x4 matrix constructed from a single uint value by assigning it to every component. |
| uint3x4(uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint) | Returns a uint3x4 matrix constructed from from 12 uint values given in row-major order. |
| uint3x4(bool3x4) | Return a uint3x4 matrix constructed from a bool3x4 matrix by componentwise conversion. |
| uint3x4(double3x4) | Return a uint3x4 matrix constructed from a double3x4 matrix by componentwise conversion. |
| uint3x4(float3x4) | Return a uint3x4 matrix constructed from a float3x4 matrix by componentwise conversion. |
| uint3x4(int3x4) | Return a uint3x4 matrix constructed from a int3x4 matrix by componentwise conversion. |
| uint3x4(uint3, uint3, uint3, uint3) | Returns a uint3x4 matrix constructed from four uint3 vectors. |
| uint4(bool) | Returns a uint4 vector constructed from a single bool value by converting it to uint and assigning it to every component. |
| uint4(double) | Returns a uint4 vector constructed from a single double value by converting it to uint and assigning it to every component. |
| uint4(int) | Returns a uint4 vector constructed from a single int value by converting it to uint and assigning it to every component. |
| uint4(float) | Returns a uint4 vector constructed from a single float value by converting it to uint and assigning it to every component. |
| uint4(uint) | Returns a uint4 vector constructed from a single uint value by assigning it to every component. |
| uint4(uint, uint, uint, uint) | Returns a uint4 vector constructed from four uint values. |
| uint4(uint, uint, uint2) | Returns a uint4 vector constructed from two uint values and a uint2 vector. |
| uint4(uint, uint2, uint) | Returns a uint4 vector constructed from a uint value, a uint2 vector and a uint value. |
| uint4(uint, uint3) | Returns a uint4 vector constructed from a uint value and a uint3 vector. |
| uint4(bool4) | Return a uint4 vector constructed from a bool4 vector by componentwise conversion. |
| uint4(double4) | Return a uint4 vector constructed from a double4 vector by componentwise conversion. |
| uint4(float4) | Return a uint4 vector constructed from a float4 vector by componentwise conversion. |
| uint4(int4) | Return a uint4 vector constructed from a int4 vector by componentwise conversion. |
| uint4(uint2, uint, uint) | Returns a uint4 vector constructed from a uint2 vector and two uint values. |
| uint4(uint2, uint2) | Returns a uint4 vector constructed from two uint2 vectors. |
| uint4(uint3, uint) | Returns a uint4 vector constructed from a uint3 vector and a uint value. |
| uint4(uint4) | Returns a uint4 vector constructed from a uint4 vector. |
| uint4x2(bool) | Returns a uint4x2 matrix constructed from a single bool value by converting it to uint and assigning it to every component. |
| uint4x2(double) | Returns a uint4x2 matrix constructed from a single double value by converting it to uint and assigning it to every component. |
| uint4x2(int) | Returns a uint4x2 matrix constructed from a single int value by converting it to uint and assigning it to every component. |
| uint4x2(float) | Returns a uint4x2 matrix constructed from a single float value by converting it to uint and assigning it to every component. |
| uint4x2(uint) | Returns a uint4x2 matrix constructed from a single uint value by assigning it to every component. |
| uint4x2(uint, uint, uint, uint, uint, uint, uint, uint) | Returns a uint4x2 matrix constructed from from 8 uint values given in row-major order. |
| uint4x2(bool4x2) | Return a uint4x2 matrix constructed from a bool4x2 matrix by componentwise conversion. |
| uint4x2(double4x2) | Return a uint4x2 matrix constructed from a double4x2 matrix by componentwise conversion. |
| uint4x2(float4x2) | Return a uint4x2 matrix constructed from a float4x2 matrix by componentwise conversion. |
| uint4x2(int4x2) | Return a uint4x2 matrix constructed from a int4x2 matrix by componentwise conversion. |
| uint4x2(uint4, uint4) | Returns a uint4x2 matrix constructed from two uint4 vectors. |
| uint4x3(bool) | Returns a uint4x3 matrix constructed from a single bool value by converting it to uint and assigning it to every component. |
| uint4x3(double) | Returns a uint4x3 matrix constructed from a single double value by converting it to uint and assigning it to every component. |
| uint4x3(int) | Returns a uint4x3 matrix constructed from a single int value by converting it to uint and assigning it to every component. |
| uint4x3(float) | Returns a uint4x3 matrix constructed from a single float value by converting it to uint and assigning it to every component. |
| uint4x3(uint) | Returns a uint4x3 matrix constructed from a single uint value by assigning it to every component. |
| uint4x3(uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint) | Returns a uint4x3 matrix constructed from from 12 uint values given in row-major order. |
| uint4x3(bool4x3) | Return a uint4x3 matrix constructed from a bool4x3 matrix by componentwise conversion. |
| uint4x3(double4x3) | Return a uint4x3 matrix constructed from a double4x3 matrix by componentwise conversion. |
| uint4x3(float4x3) | Return a uint4x3 matrix constructed from a float4x3 matrix by componentwise conversion. |
| uint4x3(int4x3) | Return a uint4x3 matrix constructed from a int4x3 matrix by componentwise conversion. |
| uint4x3(uint4, uint4, uint4) | Returns a uint4x3 matrix constructed from three uint4 vectors. |
| uint4x4(bool) | Returns a uint4x4 matrix constructed from a single bool value by converting it to uint and assigning it to every component. |
| uint4x4(double) | Returns a uint4x4 matrix constructed from a single double value by converting it to uint and assigning it to every component. |
| uint4x4(int) | Returns a uint4x4 matrix constructed from a single int value by converting it to uint and assigning it to every component. |
| uint4x4(float) | Returns a uint4x4 matrix constructed from a single float value by converting it to uint and assigning it to every component. |
| uint4x4(uint) | Returns a uint4x4 matrix constructed from a single uint value by assigning it to every component. |
| uint4x4(uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint) | Returns a uint4x4 matrix constructed from from 16 uint values given in row-major order. |
| uint4x4(bool4x4) | Return a uint4x4 matrix constructed from a bool4x4 matrix by componentwise conversion. |
| uint4x4(double4x4) | Return a uint4x4 matrix constructed from a double4x4 matrix by componentwise conversion. |
| uint4x4(float4x4) | Return a uint4x4 matrix constructed from a float4x4 matrix by componentwise conversion. |
| uint4x4(int4x4) | Return a uint4x4 matrix constructed from a int4x4 matrix by componentwise conversion. |
| uint4x4(uint4, uint4, uint4, uint4) | Returns a uint4x4 matrix constructed from four uint4 vectors. |
| unitexp(quaternion) | Returns the natural exponent of a quaternion. Assumes w is zero. |
| unitlog(quaternion) | Returns the natural logarithm of a unit length quaternion. |
| unlerp(double, double, double) | 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). |
| unlerp(float, float, float) | 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). |
| unlerp(double2, double2, double2) | Returns the componentwise result of normalizing a floating point value x to a range [a, b]. The opposite of lerp. Equivalent to (x - a) / (b - a). |
| unlerp(double3, double3, double3) | Returns the componentwise result of normalizing a floating point value x to a range [a, b]. The opposite of lerp. Equivalent to (x - a) / (b - a). |
| unlerp(double4, double4, double4) | Returns the componentwise result of normalizing a floating point value x to a range [a, b]. The opposite of lerp. Equivalent to (x - a) / (b - a). |
| unlerp(float2, float2, float2) | Returns the componentwise result of normalizing a floating point value x to a range [a, b]. The opposite of lerp. Equivalent to (x - a) / (b - a). |
| unlerp(float3, float3, float3) | Returns the componentwise result of normalizing a floating point value x to a range [a, b]. The opposite of lerp. Equivalent to (x - a) / (b - a). |
| unlerp(float4, float4, float4) | Returns the componentwise 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). |