VPP  0.8
A high-level modern C++ API for Vulkan
vppLangFunctions.hpp File Reference

Go to the source code of this file.

Namespaces

 vpp
 The VPP namespace.
 

Functions

Float vpp::Round (const Float &x)
 Computes nearest whole number to x. More...
 
Vec2 vpp::Round (const Vec2 &x)
 
Vec3 vpp::Round (const Vec3 &x)
 
Vec4 vpp::Round (const Vec4 &x)
 
Double vpp::Round (const Double &x)
 
DVec2 vpp::Round (const DVec2 &x)
 
DVec3 vpp::Round (const DVec3 &x)
 
DVec4 vpp::Round (const DVec4 &x)
 
Float vpp::RoundEven (const Float &x)
 Computes nearest whole number to x. More...
 
Vec2 vpp::RoundEven (const Vec2 &x)
 
Vec3 vpp::RoundEven (const Vec3 &x)
 
Vec4 vpp::RoundEven (const Vec4 &x)
 
Double vpp::RoundEven (const Double &x)
 
DVec2 vpp::RoundEven (const DVec2 &x)
 
DVec3 vpp::RoundEven (const DVec3 &x)
 
DVec4 vpp::RoundEven (const DVec4 &x)
 
Float vpp::Trunc (const Float &x)
 Computes nearest whole number to x whose absolute value is not larger than the absolute value of x.
 
Vec2 vpp::Trunc (const Vec2 &x)
 
Vec3 vpp::Trunc (const Vec3 &x)
 
Vec4 vpp::Trunc (const Vec4 &x)
 
Double vpp::Trunc (const Double &x)
 
DVec2 vpp::Trunc (const DVec2 &x)
 
DVec3 vpp::Trunc (const DVec3 &x)
 
DVec4 vpp::Trunc (const DVec4 &x)
 
Int vpp::Abs (const Int &x)
 Result is x if x >= 0. Otherwise result is -x.
 
IVec2 vpp::Abs (const IVec2 &x)
 
IVec3 vpp::Abs (const IVec3 &x)
 
IVec4 vpp::Abs (const IVec4 &x)
 
Float vpp::Abs (const Float &x)
 
Vec2 vpp::Abs (const Vec2 &x)
 
Vec3 vpp::Abs (const Vec3 &x)
 
Vec4 vpp::Abs (const Vec4 &x)
 
Double vpp::Abs (const Double &x)
 
DVec2 vpp::Abs (const DVec2 &x)
 
DVec3 vpp::Abs (const DVec3 &x)
 
DVec4 vpp::Abs (const DVec4 &x)
 
Int vpp::Sign (const Int &x)
 Result is 1 if x > 0, 0 if x == 0, or -1 if x < 0.
 
IVec2 vpp::Sign (const IVec2 &x)
 
IVec3 vpp::Sign (const IVec3 &x)
 
IVec4 vpp::Sign (const IVec4 &x)
 
Float vpp::Sign (const Float &x)
 
Vec2 vpp::Sign (const Vec2 &x)
 
Vec3 vpp::Sign (const Vec3 &x)
 
Vec4 vpp::Sign (const Vec4 &x)
 
Double vpp::Sign (const Double &x)
 
DVec2 vpp::Sign (const DVec2 &x)
 
DVec3 vpp::Sign (const DVec3 &x)
 
DVec4 vpp::Sign (const DVec4 &x)
 
Float vpp::Floor (const Float &x)
 Computes nearest whole number that is less than or equal to x.
 
Vec2 vpp::Floor (const Vec2 &x)
 
Vec3 vpp::Floor (const Vec3 &x)
 
Vec4 vpp::Floor (const Vec4 &x)
 
Double vpp::Floor (const Double &x)
 
DVec2 vpp::Floor (const DVec2 &x)
 
DVec3 vpp::Floor (const DVec3 &x)
 
DVec4 vpp::Floor (const DVec4 &x)
 
Float vpp::Ceil (const Float &x)
 Computes nearest whole number that is greater than or equal to x.
 
Vec2 vpp::Ceil (const Vec2 &x)
 
Vec3 vpp::Ceil (const Vec3 &x)
 
Vec4 vpp::Ceil (const Vec4 &x)
 
Double vpp::Ceil (const Double &x)
 
DVec2 vpp::Ceil (const DVec2 &x)
 
DVec3 vpp::Ceil (const DVec3 &x)
 
DVec4 vpp::Ceil (const DVec4 &x)
 
Float vpp::Fract (const Float &x)
 Computes x - Floor(x).
 
Vec2 vpp::Fract (const Vec2 &x)
 
Vec3 vpp::Fract (const Vec3 &x)
 
Vec4 vpp::Fract (const Vec4 &x)
 
Double vpp::Fract (const Double &x)
 
DVec2 vpp::Fract (const DVec2 &x)
 
DVec3 vpp::Fract (const DVec3 &x)
 
DVec4 vpp::Fract (const DVec4 &x)
 
Float vpp::Radians (const Float &x)
 Converts degrees to radians.
 
Vec2 vpp::Radians (const Vec2 &x)
 
Vec3 vpp::Radians (const Vec3 &x)
 
Vec4 vpp::Radians (const Vec4 &x)
 
Float vpp::Degrees (const Float &x)
 Converts radians to degrees.
 
Vec2 vpp::Degrees (const Vec2 &x)
 
Vec3 vpp::Degrees (const Vec3 &x)
 
Vec4 vpp::Degrees (const Vec4 &x)
 
Float vpp::Sin (const Float &x)
 The standard trigonometric sine of x radians.
 
Vec2 vpp::Sin (const Vec2 &x)
 
Vec3 vpp::Sin (const Vec3 &x)
 
Vec4 vpp::Sin (const Vec4 &x)
 
Float vpp::Cos (const Float &x)
 The standard trigonometric cosine of x radians.
 
Vec2 vpp::Cos (const Vec2 &x)
 
Vec3 vpp::Cos (const Vec3 &x)
 
Vec4 vpp::Cos (const Vec4 &x)
 
Float vpp::Tan (const Float &x)
 The standard trigonometric tangent of x radians.
 
Vec2 vpp::Tan (const Vec2 &x)
 
Vec3 vpp::Tan (const Vec3 &x)
 
Vec4 vpp::Tan (const Vec4 &x)
 
Float vpp::Asin (const Float &x)
 Arc sine. Result is an angle, in radians, whose sine is x. More...
 
Vec2 vpp::Asin (const Vec2 &x)
 
Vec3 vpp::Asin (const Vec3 &x)
 
Vec4 vpp::Asin (const Vec4 &x)
 
Float vpp::Acos (const Float &x)
 Arc cosine. Result is an angle, in radians, whose cosine is x. More...
 
Vec2 vpp::Acos (const Vec2 &x)
 
Vec3 vpp::Acos (const Vec3 &x)
 
Vec4 vpp::Acos (const Vec4 &x)
 
Float vpp::Atan (const Float &x)
 Arc tangent. Result is an angle, in radians, whose tangent is x. The range of result values is [-pi, pi].
 
Vec2 vpp::Atan (const Vec2 &x)
 
Vec3 vpp::Atan (const Vec3 &x)
 
Vec4 vpp::Atan (const Vec4 &x)
 
Float vpp::Sinh (const Float &x)
 Hyperbolic sine of x radians.
 
Vec2 vpp::Sinh (const Vec2 &x)
 
Vec3 vpp::Sinh (const Vec3 &x)
 
Vec4 vpp::Sinh (const Vec4 &x)
 
Float vpp::Cosh (const Float &x)
 Hyperbolic cosine of x radians.
 
Vec2 vpp::Cosh (const Vec2 &x)
 
Vec3 vpp::Cosh (const Vec3 &x)
 
Vec4 vpp::Cosh (const Vec4 &x)
 
Float vpp::Tanh (const Float &x)
 Hyperbolic tangent of x radians.
 
Vec2 vpp::Tanh (const Vec2 &x)
 
Vec3 vpp::Tanh (const Vec3 &x)
 
Vec4 vpp::Tanh (const Vec4 &x)
 
Float vpp::Asinh (const Float &x)
 Arc hyperbolic sine. More...
 
Vec2 vpp::Asinh (const Vec2 &x)
 
Vec3 vpp::Asinh (const Vec3 &x)
 
Vec4 vpp::Asinh (const Vec4 &x)
 
Float vpp::Acosh (const Float &x)
 Arc hyperbolic cosine. More...
 
Vec2 vpp::Acosh (const Vec2 &x)
 
Vec3 vpp::Acosh (const Vec3 &x)
 
Vec4 vpp::Acosh (const Vec4 &x)
 
Float vpp::Atanh (const Float &x)
 Arc hyperbolic tangent. More...
 
Vec2 vpp::Atanh (const Vec2 &x)
 
Vec3 vpp::Atanh (const Vec3 &x)
 
Vec4 vpp::Atanh (const Vec4 &x)
 
Float vpp::Atan2 (const Float &y, const Float &x)
 Arc tangent. More...
 
Vec2 vpp::Atan2 (const Vec2 &y, const Vec2 &x)
 
Vec3 vpp::Atan2 (const Vec3 &y, const Vec3 &x)
 
Vec4 vpp::Atan2 (const Vec4 &y, const Vec4 &x)
 
Float vpp::Pow (const Float &x, const Float &y)
 Computes x raised to the y power. More...
 
Vec2 vpp::Pow (const Vec2 &x, const Vec2 &y)
 
Vec3 vpp::Pow (const Vec3 &x, const Vec3 &y)
 
Vec4 vpp::Pow (const Vec4 &x, const Vec4 &y)
 
Float vpp::Exp (const Float &x)
 Computes the natural exponentiation of x (e^x).
 
Vec2 vpp::Exp (const Vec2 &x)
 
Vec3 vpp::Exp (const Vec3 &x)
 
Vec4 vpp::Exp (const Vec4 &x)
 
Float vpp::Log (const Float &x)
 Computes the natural logarithm of x. More...
 
Vec2 vpp::Log (const Vec2 &x)
 
Vec3 vpp::Log (const Vec3 &x)
 
Vec4 vpp::Log (const Vec4 &x)
 
Float vpp::Exp2 (const Float &x)
 Computes 2 raised to the x power (2^x).
 
Vec2 vpp::Exp2 (const Vec2 &x)
 
Vec3 vpp::Exp2 (const Vec3 &x)
 
Vec4 vpp::Exp2 (const Vec4 &x)
 
Float vpp::Log2 (const Float &x)
 Computes the base-2 logarithm of x. More...
 
Vec2 vpp::Log2 (const Vec2 &x)
 
Vec3 vpp::Log2 (const Vec3 &x)
 
Vec4 vpp::Log2 (const Vec4 &x)
 
Float vpp::Sqrt (const Float &x)
 Computes the square root of x. More...
 
Vec2 vpp::Sqrt (const Vec2 &x)
 
Vec3 vpp::Sqrt (const Vec3 &x)
 
Vec4 vpp::Sqrt (const Vec4 &x)
 
Double vpp::Sqrt (const Double &x)
 
DVec2 vpp::Sqrt (const DVec2 &x)
 
DVec3 vpp::Sqrt (const DVec3 &x)
 
DVec4 vpp::Sqrt (const DVec4 &x)
 
Float vpp::InverseSqrt (const Float &x)
 Computes the reciprocal of Sqrt(x). More...
 
Vec2 vpp::InverseSqrt (const Vec2 &x)
 
Vec3 vpp::InverseSqrt (const Vec3 &x)
 
Vec4 vpp::InverseSqrt (const Vec4 &x)
 
Double vpp::InverseSqrt (const Double &value)
 
DVec2 vpp::InverseSqrt (const DVec2 &value)
 
DVec3 vpp::InverseSqrt (const DVec3 &value)
 
DVec4 vpp::InverseSqrt (const DVec4 &value)
 
Float vpp::Determinant (const Mat2 &x)
 Computes the determinant of x.
 
Float vpp::Determinant (const Mat3 &x)
 
Float vpp::Determinant (const Mat4 &x)
 
Double vpp::Determinant (const DMat2 &x)
 
Double vpp::Determinant (const DMat3 &x)
 
Double vpp::Determinant (const DMat4 &x)
 
Mat2 vpp::MatrixInverse (const Mat2 &x)
 Computes a matrix that is the inverse of x. More...
 
Mat3 vpp::MatrixInverse (const Mat3 &x)
 
Mat4 vpp::MatrixInverse (const Mat4 &x)
 
DMat2 vpp::MatrixInverse (const DMat2 &x)
 
DMat3 vpp::MatrixInverse (const DMat3 &x)
 
DMat4 vpp::MatrixInverse (const DMat4 &x)
 
template<typename ScalarT , size_t COLS, size_t ROWS>
Matrix< ScalarT, ROWS, COLS > vpp::Transpose (const Matrix< ScalarT, COLS, ROWS > &value)
 Computes the transposition of a matrix.
 
Int vpp::Min (const Int &x, const Int &y)
 Result is y if y < x, otherwise result is x. More...
 
IVec2 vpp::Min (const IVec2 &x, const IVec2 &y)
 
IVec3 vpp::Min (const IVec3 &x, const IVec3 &y)
 
IVec4 vpp::Min (const IVec4 &x, const IVec4 &y)
 
UInt vpp::Min (const UInt &x, const UInt &y)
 
UVec2 vpp::Min (const UVec2 &x, const UVec2 &y)
 
UVec3 vpp::Min (const UVec3 &x, const UVec3 &y)
 
UVec4 vpp::Min (const UVec4 &x, const UVec4 &y)
 
Float vpp::Min (const Float &x, const Float &y)
 
Vec2 vpp::Min (const Vec2 &x, const Vec2 &y)
 
Vec3 vpp::Min (const Vec3 &x, const Vec3 &y)
 
Vec4 vpp::Min (const Vec4 &x, const Vec4 &y)
 
Double vpp::Min (const Double &x, const Double &y)
 
DVec2 vpp::Min (const DVec2 &x, const DVec2 &y)
 
DVec3 vpp::Min (const DVec3 &x, const DVec3 &y)
 
DVec4 vpp::Min (const DVec4 &x, const DVec4 &y)
 
Int vpp::Max (const Int &x, const Int &y)
 Result is y if x < y, otherwise result is x. More...
 
IVec2 vpp::Max (const IVec2 &x, const IVec2 &y)
 
IVec3 vpp::Max (const IVec3 &x, const IVec3 &y)
 
IVec4 vpp::Max (const IVec4 &x, const IVec4 &y)
 
UInt vpp::Max (const UInt &x, const UInt &y)
 
UVec2 vpp::Max (const UVec2 &x, const UVec2 &y)
 
UVec3 vpp::Max (const UVec3 &x, const UVec3 &y)
 
UVec4 vpp::Max (const UVec4 &x, const UVec4 &y)
 
Float vpp::Max (const Float &x, const Float &y)
 
Vec2 vpp::Max (const Vec2 &x, const Vec2 &y)
 
Vec3 vpp::Max (const Vec3 &x, const Vec3 &y)
 
Vec4 vpp::Max (const Vec4 &x, const Vec4 &y)
 
Double vpp::Max (const Double &x, const Double &y)
 
DVec2 vpp::Max (const DVec2 &x, const DVec2 &y)
 
DVec3 vpp::Max (const DVec3 &x, const DVec3 &y)
 
DVec4 vpp::Max (const DVec4 &x, const DVec4 &y)
 
Int vpp::Clamp (const Int &x, const Int &minVal, const Int &maxVal)
 Computes the value of Min ( Max ( x, minVal ), maxVal ). More...
 
IVec2 vpp::Clamp (const IVec2 &x, const IVec2 &minVal, const IVec2 &maxVal)
 
IVec3 vpp::Clamp (const IVec3 &x, const IVec3 &minVal, const IVec3 &maxVal)
 
IVec4 vpp::Clamp (const IVec4 &x, const IVec4 &minVal, const IVec4 &maxVal)
 
UInt vpp::Clamp (const UInt &x, const UInt &minVal, const UInt &maxVal)
 
UVec2 vpp::Clamp (const UVec2 &x, const UVec2 &minVal, const UVec2 &maxVal)
 
UVec3 vpp::Clamp (const UVec3 &x, const UVec3 &minVal, const UVec3 &maxVal)
 
UVec4 vpp::Clamp (const UVec4 &x, const UVec4 &minVal, const UVec4 &maxVal)
 
Float vpp::Clamp (const Float &x, const Float &minVal, const Float &maxVal)
 
Vec2 vpp::Clamp (const Vec2 &x, const Vec2 &minVal, const Vec2 &maxVal)
 
Vec3 vpp::Clamp (const Vec3 &x, const Vec3 &minVal, const Vec3 &maxVal)
 
Vec4 vpp::Clamp (const Vec4 &x, const Vec4 &minVal, const Vec4 &maxVal)
 
Double vpp::Clamp (const Double &x, const Double &minVal, const Double &maxVal)
 
DVec2 vpp::Clamp (const DVec2 &x, const DVec2 &minVal, const DVec2 &maxVal)
 
DVec3 vpp::Clamp (const DVec3 &x, const DVec3 &minVal, const DVec3 &maxVal)
 
DVec4 vpp::Clamp (const DVec4 &x, const DVec4 &minVal, const DVec4 &maxVal)
 
Float vpp::Mix (const Float &x, const Float &y, const Float &a)
 Computes the linear blend of x and y, i.e., x * (1 - a) + y * a.
 
Vec2 vpp::Mix (const Vec2 &x, const Vec2 &y, const Vec2 &a)
 
Vec3 vpp::Mix (const Vec3 &x, const Vec3 &y, const Vec3 &a)
 
Vec4 vpp::Mix (const Vec4 &x, const Vec4 &y, const Vec4 &a)
 
Double vpp::Mix (const Double &x, const Double &y, const Double &a)
 
DVec2 vpp::Mix (const DVec2 &x, const DVec2 &y, const DVec2 &a)
 
DVec3 vpp::Mix (const DVec3 &x, const DVec3 &y, const DVec3 &a)
 
DVec4 vpp::Mix (const DVec4 &x, const DVec4 &y, const DVec4 &a)
 
Float vpp::Step (const Float &edge, const Float &x)
 Result is 0 if x < edge. Otherwise result is 1.
 
Vec2 vpp::Step (const Vec2 &edge, const Vec2 &x)
 
Vec3 vpp::Step (const Vec3 &edge, const Vec3 &x)
 
Vec4 vpp::Step (const Vec4 &edge, const Vec4 &x)
 
Double vpp::Step (const Double &edge, const Double &x)
 
DVec2 vpp::Step (const DVec2 &edge, const DVec2 &x)
 
DVec3 vpp::Step (const DVec3 &edge, const DVec3 &x)
 
DVec4 vpp::Step (const DVec4 &edge, const DVec4 &x)
 
Float vpp::SmoothStep (const Float &edge0, const Float &edge1, const Float &x)
 Result is 0 if x <= edge0, 1 if x >= edge1, or smooth Hermite interpolation between 0 and 1 when edge0 < x < edge1. More...
 
Vec2 vpp::SmoothStep (const Vec2 &edge0, const Vec2 &edge1, const Vec2 &x)
 
Vec3 vpp::SmoothStep (const Vec3 &edge0, const Vec3 &edge1, const Vec3 &x)
 
Vec4 vpp::SmoothStep (const Vec4 &edge0, const Vec4 &edge1, const Vec4 &x)
 
Double vpp::SmoothStep (const Double &edge0, const Double &edge1, const Double &x)
 
DVec2 vpp::SmoothStep (const DVec2 &edge0, const DVec2 &edge1, const DVec2 &x)
 
DVec3 vpp::SmoothStep (const DVec3 &edge0, const DVec3 &edge1, const DVec3 &x)
 
DVec4 vpp::SmoothStep (const DVec4 &edge0, const DVec4 &edge1, const DVec4 &x)
 
Float vpp::Fma (const Float &edge0, const Float &edge1, const Float &x)
 Computes a * b + c.
 
Vec2 vpp::Fma (const Vec2 &edge0, const Vec2 &edge1, const Vec2 &x)
 
Vec3 vpp::Fma (const Vec3 &edge0, const Vec3 &edge1, const Vec3 &x)
 
Vec4 vpp::Fma (const Vec4 &edge0, const Vec4 &edge1, const Vec4 &x)
 
Double vpp::Fma (const Double &a, const Double &b, const Double &c)
 
DVec2 vpp::Fma (const DVec2 &a, const DVec2 &b, const DVec2 &c)
 
DVec3 vpp::Fma (const DVec3 &a, const DVec3 &b, const DVec3 &c)
 
DVec4 vpp::Fma (const DVec4 &a, const DVec4 &b, const DVec4 &c)
 
UInt vpp::PackSnorm4x8 (const Vec4 &v)
 Converts each component of the signed normalized floating-point value v into 8-bit integer values and packs them into the result. More...
 
UInt vpp::PackUnorm4x8 (const Vec4 &v)
 Converts each component of the positive normalized floating-point value v into 8-bit integer values and packs them into the result. More...
 
UInt vpp::PackSnorm2x16 (const Vec2 &v)
 Converts each component of the signed normalized floating-point value v into 16-bit integer values and packs them into the result. More...
 
UInt vpp::PackUnorm2x16 (const Vec2 &v)
 Converts each component of the positive normalized floating-point value v into 16-bit integer values and packs them into the result. More...
 
UInt vpp::PackHalf2x16 (const Vec2 &v)
 Converts the components of a two-component floating-point vector to the 16-bit float, then packs them into a 32-bit unsigned integer. More...
 
Double vpp::PackDouble2x32 (const UVec2 &v)
 Packs the components of v into a 64-bit value. More...
 
Vec2 vpp::UnpackSnorm2x16 (const UInt &p)
 Unpacks a single 32-bit unsigned integer p into a pair of 16-bit signed integers and converts them to normalized floating-point values. More...
 
Vec2 vpp::UnpackUnorm2x16 (const UInt &p)
 Unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers. and converts them to normalized floating-point values. More...
 
Vec2 vpp::UnpackHalf2x16 (const UInt &v)
 Unpacks a 32-bit unsigned integer into a pair of 16-bit values, interpreted as 16-bit floating-point numbers, and converts them to 32-bit floating-point values. More...
 
Vec4 vpp::UnpackSnorm4x8 (const UInt &p)
 Unpacks a single 32-bit unsigned integer p into four 8-bit signed integers and converts them to normalized floating-point values. More...
 
Vec4 vpp::UnpackUnorm4x8 (const UInt &p)
 Unpacks a single 32-bit unsigned integer p into four 8-bit unsigned integers and converts them to normalized floating-point values. More...
 
UVec2 vpp::UnpackDouble2x32 (const Double &value)
 Computes the two-component unsigned integer vector representation of v. The bit-level representation of v is preserved. More...
 
Float vpp::Dot (const Vec2 &lhs, const Vec2 &rhs)
 Computes dot product of two vectors.
 
Float vpp::Dot (const Vec3 &lhs, const Vec3 &rhs)
 
Float vpp::Dot (const Vec4 &lhs, const Vec4 &rhs)
 
Double vpp::Dot (const DVec2 &lhs, const DVec2 &rhs)
 
Double vpp::Dot (const DVec3 &lhs, const DVec3 &rhs)
 
Double vpp::Dot (const DVec4 &lhs, const DVec4 &rhs)
 
template<size_t COLS, size_t ROWS>
TRMatrix< Float, COLS, ROWS > vpp::OuterProduct (const TRVector< Float, ROWS > &lhs, const TRVector< Float, COLS > &rhs)
 Computes linear-algebraic outer product of two vectors.
 
template<size_t COLS, size_t ROWS>
TRMatrix< Double, COLS, ROWS > vpp::OuterProduct (const TRVector< Double, ROWS > &lhs, const TRVector< Double, COLS > &rhs)
 
Float vpp::Length (const Float &value)
 Computes the length of a vector.
 
Float vpp::Length (const Vec2 &value)
 
Float vpp::Length (const Vec3 &value)
 
Float vpp::Length (const Vec4 &value)
 
Double vpp::Length (const Double &value)
 
Double vpp::Length (const DVec2 &value)
 
Double vpp::Length (const DVec3 &value)
 
Double vpp::Length (const DVec4 &value)
 
Float vpp::Distance (const Float &v1, const Float &v2)
 Computes the distance between v1 and v2.
 
Float vpp::Distance (const Vec2 &v1, const Vec2 &v2)
 
Float vpp::Distance (const Vec3 &v1, const Vec3 &v2)
 
Float vpp::Distance (const Vec4 &v1, const Vec4 &v2)
 
Double vpp::Distance (const Double &v1, const Double &v2)
 
Double vpp::Distance (const DVec2 &v1, const DVec2 &v2)
 
Double vpp::Distance (const DVec3 &v1, const DVec3 &v2)
 
Double vpp::Distance (const DVec4 &v1, const DVec4 &v2)
 
Vec3 vpp::Cross (const Vec3 &x, const Vec3 &y)
 Computes the cross product of x and y.
 
DVec3 vpp::Cross (const DVec3 &x, const DVec3 &y)
 
Float vpp::Normalize (const Float &x)
 Computes the vector in the same direction as x but with a length of 1.
 
Vec2 vpp::Normalize (const Vec2 &x)
 
Vec3 vpp::Normalize (const Vec3 &x)
 
Vec4 vpp::Normalize (const Vec4 &x)
 
Double vpp::Normalize (const Double &x)
 
DVec2 vpp::Normalize (const DVec2 &x)
 
DVec3 vpp::Normalize (const DVec3 &x)
 
DVec4 vpp::Normalize (const DVec4 &x)
 
Float vpp::FaceForward (const Float &n, const Float &i, const Float &nref)
 If the dot product of nref and i is negative, the result is n, otherwise it is -n.
 
Vec2 vpp::FaceForward (const Vec2 &n, const Vec2 &i, const Vec2 &nref)
 
Vec3 vpp::FaceForward (const Vec3 &n, const Vec3 &i, const Vec3 &nref)
 
Vec4 vpp::FaceForward (const Vec4 &n, const Vec4 &i, const Vec4 &nref)
 
Double vpp::FaceForward (const Double &n, const Double &i, const Double &nref)
 
DVec2 vpp::FaceForward (const DVec2 &n, const DVec2 &i, const DVec2 &nref)
 
DVec3 vpp::FaceForward (const DVec3 &n, const DVec3 &i, const DVec3 &nref)
 
DVec4 vpp::FaceForward (const DVec4 &n, const DVec4 &i, const DVec4 &nref)
 
Float vpp::Reflect (const Float &i, const Float &n)
 Computes reflected vector to the vector i. More...
 
Vec2 vpp::Reflect (const Vec2 &i, const Vec2 &n)
 
Vec3 vpp::Reflect (const Vec3 &i, const Vec3 &n)
 
Vec4 vpp::Reflect (const Vec4 &i, const Vec4 &n)
 
Double vpp::Reflect (const Double &i, const Double &n)
 
DVec2 vpp::Reflect (const DVec2 &i, const DVec2 &n)
 
DVec3 vpp::Reflect (const DVec3 &i, const DVec3 &n)
 
DVec4 vpp::Reflect (const DVec4 &i, const DVec4 &n)
 
Float vpp::Refract (const Float &i, const Float &n, const Float &eta)
 Computes refracted vector to the vector i. More...
 
Vec2 vpp::Refract (const Vec2 &i, const Vec2 &n, const Float &eta)
 
Vec3 vpp::Refract (const Vec3 &i, const Vec3 &n, const Float &eta)
 
Vec4 vpp::Refract (const Vec4 &i, const Vec4 &n, const Float &eta)
 
Double vpp::Refract (const Double &i, const Double &n, const Float &eta)
 
DVec2 vpp::Refract (const DVec2 &i, const DVec2 &n, const Float &eta)
 
DVec3 vpp::Refract (const DVec3 &i, const DVec3 &n, const Float &eta)
 
DVec4 vpp::Refract (const DVec4 &i, const DVec4 &n, const Float &eta)
 
Int vpp::FindLsb (const Int &v)
 Computes the bit number of the least-significant 1-bit in the binary representation of v. More...
 
IVec2 vpp::FindLsb (const IVec2 &v)
 
IVec3 vpp::FindLsb (const IVec3 &v)
 
IVec4 vpp::FindLsb (const IVec4 &v)
 
UInt vpp::FindLsb (const UInt &v)
 
UVec2 vpp::FindLsb (const UVec2 &v)
 
UVec3 vpp::FindLsb (const UVec3 &v)
 
UVec4 vpp::FindLsb (const UVec4 &v)
 
Int vpp::FindMsb (const Int &value)
 Computes the bit number of the most-significant 1-bit in the binary representation of v. More...
 
IVec2 vpp::FindMsb (const IVec2 &value)
 
IVec3 vpp::FindMsb (const IVec3 &value)
 
IVec4 vpp::FindMsb (const IVec4 &value)
 
UInt vpp::FindMsb (const UInt &value)
 
UVec2 vpp::FindMsb (const UVec2 &value)
 
UVec3 vpp::FindMsb (const UVec3 &value)
 
UVec4 vpp::FindMsb (const UVec4 &value)
 
Float vpp::NMin (const Float &x, const Float &y)
 Result is y if y < x, otherwise result is x. More...
 
Vec2 vpp::NMin (const Vec2 &x, const Vec2 &y)
 
Vec3 vpp::NMin (const Vec3 &x, const Vec3 &y)
 
Vec4 vpp::NMin (const Vec4 &x, const Vec4 &y)
 
Double vpp::NMin (const Double &x, const Double &y)
 
DVec2 vpp::NMin (const DVec2 &x, const DVec2 &y)
 
DVec3 vpp::NMin (const DVec3 &x, const DVec3 &y)
 
DVec4 vpp::NMin (const DVec4 &x, const DVec4 &y)
 
Float vpp::NMax (const Float &x, const Float &y)
 Result is y if x < y, otherwise result is x. More...
 
Vec2 vpp::NMax (const Vec2 &x, const Vec2 &y)
 
Vec3 vpp::NMax (const Vec3 &x, const Vec3 &y)
 
Vec4 vpp::NMax (const Vec4 &x, const Vec4 &y)
 
Double vpp::NMax (const Double &x, const Double &y)
 
DVec2 vpp::NMax (const DVec2 &x, const DVec2 &y)
 
DVec3 vpp::NMax (const DVec3 &x, const DVec3 &y)
 
DVec4 vpp::NMax (const DVec4 &x, const DVec4 &y)
 
Float vpp::NClamp (const Float &x, const Float &minVal, const Float &maxVal)
 Result is min ( max ( x, minVal), maxVal ). More...
 
Vec2 vpp::NClamp (const Vec2 &x, const Vec2 &minVal, const Vec2 &maxVal)
 
Vec3 vpp::NClamp (const Vec3 &x, const Vec3 &minVal, const Vec3 &maxVal)
 
Vec4 vpp::NClamp (const Vec4 &x, const Vec4 &minVal, const Vec4 &maxVal)
 
Double vpp::NClamp (const Double &x, const Double &minVal, const Double &maxVal)
 
DVec2 vpp::NClamp (const DVec2 &x, const DVec2 &minVal, const DVec2 &maxVal)
 
DVec3 vpp::NClamp (const DVec3 &x, const DVec3 &minVal, const DVec3 &maxVal)
 
DVec4 vpp::NClamp (const DVec4 &x, const DVec4 &minVal, const DVec4 &maxVal)
 
Int vpp::Mod (const Int &lhs, const Int &rhs)
 Modulo operation of lhs modulo rhs. More...
 
IVec2 vpp::Mod (const IVec2 &lhs, const IVec2 &rhs)
 
IVec3 vpp::Mod (const IVec3 &lhs, const IVec3 &rhs)
 
IVec4 vpp::Mod (const IVec4 &lhs, const IVec4 &rhs)
 
IMat2 vpp::Mod (const IMat2 &lhs, const IMat2 &rhs)
 
IMat3 vpp::Mod (const IMat3 &lhs, const IMat3 &rhs)
 
IMat4 vpp::Mod (const IMat4 &lhs, const IMat4 &rhs)
 
UInt vpp::Mod (const UInt &lhs, const UInt &rhs)
 
UVec2 vpp::Mod (const UVec2 &lhs, const UVec2 &rhs)
 
UVec3 vpp::Mod (const UVec3 &lhs, const UVec3 &rhs)
 
UVec4 vpp::Mod (const UVec4 &lhs, const UVec4 &rhs)
 
UMat2 vpp::Mod (const UMat2 &lhs, const UMat2 &rhs)
 
UMat3 vpp::Mod (const UMat3 &lhs, const UMat3 &rhs)
 
UMat4 vpp::Mod (const UMat4 &lhs, const UMat4 &rhs)
 
Float vpp::Mod (const Float &lhs, const Float &rhs)
 
Vec2 vpp::Mod (const Vec2 &lhs, const Vec2 &rhs)
 
Vec3 vpp::Mod (const Vec3 &lhs, const Vec3 &rhs)
 
Vec4 vpp::Mod (const Vec4 &lhs, const Vec4 &rhs)
 
Mat2 vpp::Mod (const Mat2 &lhs, const Mat2 &rhs)
 
Mat3 vpp::Mod (const Mat3 &lhs, const Mat3 &rhs)
 
Mat4 vpp::Mod (const Mat4 &lhs, const Mat4 &rhs)
 
Double vpp::Mod (const Double &lhs, const Double &rhs)
 
DVec2 vpp::Mod (const DVec2 &lhs, const DVec2 &rhs)
 
DVec3 vpp::Mod (const DVec3 &lhs, const DVec3 &rhs)
 
DVec4 vpp::Mod (const DVec4 &lhs, const DVec4 &rhs)
 
DMat2 vpp::Mod (const DMat2 &lhs, const DMat2 &rhs)
 
DMat3 vpp::Mod (const DMat3 &lhs, const DMat3 &rhs)
 
DMat4 vpp::Mod (const DMat4 &lhs, const DMat4 &rhs)
 
std::pair< Float, Float > vpp::Modf (const Float &x)
 Computes the fractional part of x (as the first result) and the whole number part (second result). More...
 
std::pair< Vec2, Vec2 > vpp::Modf (const Vec2 &x)
 
std::pair< Vec3, Vec3 > vpp::Modf (const Vec3 &x)
 
std::pair< Vec4, Vec4 > vpp::Modf (const Vec4 &x)
 
std::pair< Double, Double > vpp::Modf (const Double &x)
 
std::pair< DVec2, DVec2 > vpp::Modf (const DVec2 &x)
 
std::pair< DVec3, DVec3 > vpp::Modf (const DVec3 &x)
 
std::pair< DVec4, DVec4 > vpp::Modf (const DVec4 &x)
 
Float vpp::Ldexp (const Float &x, const Int &exp)
 Builds a floating-point number from x and the corresponding integral exponent of two in exp. More...
 
Vec2 vpp::Ldexp (const Vec2 &x, const IVec2 &exp)
 
Vec3 vpp::Ldexp (const Vec3 &x, const IVec3 &exp)
 
Vec4 vpp::Ldexp (const Vec4 &x, const IVec4 &exp)
 
Double vpp::Ldexp (const Double &x, const Int &exp)
 
DVec2 vpp::Ldexp (const DVec2 &x, const IVec2 &exp)
 
DVec3 vpp::Ldexp (const DVec3 &x, const IVec3 &exp)
 
DVec4 vpp::Ldexp (const DVec4 &x, const IVec4 &exp)
 
std::pair< Float, Int > vpp::Frexp (const Float &x)
 Splits x into a floating-point significand in the range [0.5, 1.0) and an integral exponent of two,. More...
 
std::pair< Vec2, IVec2 > vpp::Frexp (const Vec2 &x)
 
std::pair< Vec3, IVec3 > vpp::Frexp (const Vec3 &x)
 
std::pair< Vec4, IVec4 > vpp::Frexp (const Vec4 &x)
 
std::pair< Double, Int > vpp::Frexp (const Double &x)
 
std::pair< DVec2, IVec2 > vpp::Frexp (const DVec2 &x)
 
std::pair< DVec3, IVec3 > vpp::Frexp (const DVec3 &x)
 
std::pair< DVec4, IVec4 > vpp::Frexp (const DVec4 &x)
 
Bool vpp::IsNaN (const Float &x)
 Result is true if x is an IEEE NaN, otherwise result is false.
 
BVec2 vpp::IsNaN (const Vec2 &x)
 
BVec3 vpp::IsNaN (const Vec3 &x)
 
BVec4 vpp::IsNaN (const Vec4 &x)
 
Bool vpp::IsNaN (const Double &x)
 
BVec2 vpp::IsNaN (const DVec2 &x)
 
BVec3 vpp::IsNaN (const DVec3 &x)
 
BVec4 vpp::IsNaN (const DVec4 &x)
 
Bool vpp::IsInf (const Float &value)
 Result is true if x is an IEEE Inf, otherwise result is false.
 
BVec2 vpp::IsInf (const Vec2 &value)
 
BVec3 vpp::IsInf (const Vec3 &value)
 
BVec4 vpp::IsInf (const Vec4 &value)
 
Bool vpp::IsInf (const Double &value)
 
BVec2 vpp::IsInf (const DVec2 &value)
 
BVec3 vpp::IsInf (const DVec3 &value)
 
BVec4 vpp::IsInf (const DVec4 &value)
 
Bool vpp::IsAnyComponentTrue (const BVec2 &v)
 Result is true if any component of the vector is true, otherwise false.
 
Bool vpp::IsAnyComponentTrue (const BVec3 &v)
 
Bool vpp::IsAnyComponentTrue (const BVec4 &v)
 
Bool vpp::IsAllComponentsTrue (const BVec2 &v)
 Result is true if all components of the vector are true, otherwise false.
 
Bool vpp::IsAllComponentsTrue (const BVec3 &v)
 
Bool vpp::IsAllComponentsTrue (const BVec4 &v)
 
Int vpp::BitCount (const Int &value)
 Reverses the bits in specified value. More...
 
IVec2 vpp::BitCount (const IVec2 &value)
 
IVec3 vpp::BitCount (const IVec3 &value)
 
IVec4 vpp::BitCount (const IVec4 &value)
 
Int vpp::BitCount (const UInt &value)
 
IVec2 vpp::BitCount (const UVec2 &value)
 
IVec3 vpp::BitCount (const UVec3 &value)
 
IVec4 vpp::BitCount (const UVec4 &value)
 
Int vpp::BitReverse (const Int &value)
 Counts the number of set bits in specified value. More...
 
IVec2 vpp::BitReverse (const IVec2 &value)
 
IVec3 vpp::BitReverse (const IVec3 &value)
 
IVec4 vpp::BitReverse (const IVec4 &value)
 
UInt vpp::BitReverse (const UInt &value)
 
UVec2 vpp::BitReverse (const UVec2 &value)
 
UVec3 vpp::BitReverse (const UVec3 &value)
 
UVec4 vpp::BitReverse (const UVec4 &value)
 
template<class ImageT >
void vpp::UseImage (const ImageT &img)
 Declares image binding point as used in the shader. More...
 
template<class ValueT >
void vpp::Ignore (const ValueT &value)
 Computes the expression given as argument and ignores the result. More...