E:/VisualizationLibrary/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vl/GLSLmath.hpp File Reference

Implements the OpenGL Shading Language convenience functions for scalar and vector operations. More...

#include <cmath>
#include <limits>
#include <vl/Vector4.hpp>
#include <vl/Matrix4.hpp>

Namespaces
namespace	vl
	Visualization Library namespace.
Functions
float	vl::asinh (float x)
double	vl::asinh (double x)
float	vl::acosh (float x)
double	vl::acosh (double x)
float	vl::atanh (float x)
double	vl::atanh (double x)
template<typename T >
bool	vl::isnan (T value)
template<typename T >
bool	vl::isinf (T value)
template<typename T >
bool	vl::isinf_pos (T value)
template<typename T >
bool	vl::isinf_neg (T value)
float	vl::modf (float a, float &intpart)
double	vl::modf (double a, double &intpart)
float	vl::radians (float degrees)
fvec2	vl::radians (const fvec2 &degrees)
fvec3	vl::radians (const fvec3 &degrees)
fvec4	vl::radians (const fvec4 &degrees)
double	vl::radians (double degrees)
float	vl::degrees (float radians)
fvec2	vl::degrees (const fvec2 &radians)
fvec3	vl::degrees (const fvec3 &radians)
fvec4	vl::degrees (const fvec4 &radians)
double	vl::degrees (double radians)
float	vl::sin (float a)
fvec2	vl::sin (const fvec2 &angle)
fvec3	vl::sin (const fvec3 &angle)
fvec4	vl::sin (const fvec4 &angle)
double	vl::sin (double a)
float	vl::cos (float a)
fvec2	vl::cos (const fvec2 &angle)
fvec3	vl::cos (const fvec3 &angle)
fvec4	vl::cos (const fvec4 &angle)
double	vl::cos (double a)
float	vl::tan (float a)
fvec2	vl::tan (const fvec2 &angle)
fvec3	vl::tan (const fvec3 &angle)
fvec4	vl::tan (const fvec4 &angle)
double	vl::tan (double a)
float	vl::asin (float a)
fvec2	vl::asin (const fvec2 &angle)
fvec3	vl::asin (const fvec3 &angle)
fvec4	vl::asin (const fvec4 &angle)
double	vl::asin (double a)
float	vl::acos (float a)
fvec2	vl::acos (const fvec2 &angle)
fvec3	vl::acos (const fvec3 &angle)
fvec4	vl::acos (const fvec4 &angle)
double	vl::acos (double a)
float	vl::atan (float a)
fvec2	vl::atan (const fvec2 &a, const fvec2 &b)
fvec3	vl::atan (const fvec3 &a, const fvec3 &b)
fvec4	vl::atan (const fvec4 &a, const fvec4 &b)
double	vl::atan (double a)
float	vl::sinh (float a)
fvec2	vl::sinh (const fvec2 &a)
fvec3	vl::sinh (const fvec3 &a)
fvec4	vl::sinh (const fvec4 &a)
double	vl::sinh (double a)
float	vl::cosh (float a)
fvec2	vl::cosh (const fvec2 &a)
fvec3	vl::cosh (const fvec3 &a)
fvec4	vl::cosh (const fvec4 &a)
double	vl::cosh (double a)
float	vl::tanh (float a)
fvec2	vl::tanh (const fvec2 &a)
fvec3	vl::tanh (const fvec3 &a)
fvec4	vl::tanh (const fvec4 &a)
double	vl::tanh (double a)
fvec2	vl::asinh (const fvec2 &a)
fvec3	vl::asinh (const fvec3 &a)
fvec4	vl::asinh (const fvec4 &a)
fvec2	vl::acosh (const fvec2 &a)
fvec3	vl::acosh (const fvec3 &a)
fvec4	vl::acosh (const fvec4 &a)
fvec2	vl::atanh (const fvec2 &a)
fvec3	vl::atanh (const fvec3 &a)
fvec4	vl::atanh (const fvec4 &a)
float	vl::pow (float a, float b)
fvec2	vl::pow (const fvec2 &a, const fvec2 &b)
fvec3	vl::pow (const fvec3 &a, const fvec3 &b)
fvec4	vl::pow (const fvec4 &a, const fvec4 &b)
double	vl::pow (double a, double b)
float	vl::exp (float a)
fvec2	vl::exp (const fvec2 &a)
fvec3	vl::exp (const fvec3 &a)
fvec4	vl::exp (const fvec4 &a)
double	vl::exp (double a)
float	vl::log (float a)
fvec2	vl::log (const fvec2 &a)
fvec3	vl::log (const fvec3 &a)
fvec4	vl::log (const fvec4 &a)
double	vl::log (double a)
float	vl::exp2 (float a)
fvec2	vl::exp2 (const fvec2 &a)
fvec3	vl::exp2 (const fvec3 &a)
fvec4	vl::exp2 (const fvec4 &a)
double	vl::exp2 (double a)
float	vl::log2 (float a)
fvec2	vl::log2 (const fvec2 &a)
fvec3	vl::log2 (const fvec3 &a)
fvec4	vl::log2 (const fvec4 &a)
double	vl::log2 (double a)
float	vl::log10 (float a)
fvec2	vl::log10 (const fvec2 &a)
fvec3	vl::log10 (const fvec3 &a)
fvec4	vl::log10 (const fvec4 &a)
double	vl::log10 (double a)
float	vl::sqrt (float a)
fvec2	vl::sqrt (const fvec2 &a)
fvec3	vl::sqrt (const fvec3 &a)
fvec4	vl::sqrt (const fvec4 &a)
double	vl::sqrt (double a)
float	vl::inversesqrt (float a)
fvec2	vl::inversesqrt (const fvec2 &a)
fvec3	vl::inversesqrt (const fvec3 &a)
fvec4	vl::inversesqrt (const fvec4 &a)
double	vl::inversesqrt (double a)
float	vl::abs (float a)
fvec2	vl::abs (const fvec2 &a)
fvec3	vl::abs (const fvec3 &a)
fvec4	vl::abs (const fvec4 &a)
double	vl::abs (double a)
int	vl::abs (int a)
float	vl::sign (float a)
fvec2	vl::sign (const fvec2 &a)
fvec3	vl::sign (const fvec3 &a)
fvec4	vl::sign (const fvec4 &a)
double	vl::sign (double a)
int	vl::sign (int a)
float	vl::floor (float a)
fvec2	vl::floor (const fvec2 &a)
fvec3	vl::floor (const fvec3 &a)
fvec4	vl::floor (const fvec4 &a)
double	vl::floor (double a)
float	vl::fract (float)
float	vl::trunc (float a)
fvec2	vl::trunc (const fvec2 &a)
fvec3	vl::trunc (const fvec3 &a)
fvec4	vl::trunc (const fvec4 &a)
double	vl::fract (double)
double	vl::trunc (double a)
float	vl::round (float x)
fvec2	vl::round (const fvec2 &a)
fvec3	vl::round (const fvec3 &a)
fvec4	vl::round (const fvec4 &a)
double	vl::round (double x)
float	vl::roundEven (float a, float epsilon=0.00001f)
fvec2	vl::roundEven (const fvec2 &a, float epsilon=0.00001f)
fvec3	vl::roundEven (const fvec3 &a, float epsilon=0.00001f)
fvec4	vl::roundEven (const fvec4 &a, float epsilon=0.00001f)
double	vl::roundEven (double a, double epsilon=0.00001)
dvec2	vl::roundEven (const dvec2 &a, double epsilon=0.00001)
dvec3	vl::roundEven (const dvec3 &a, double epsilon=0.00001)
dvec4	vl::roundEven (const dvec4 &a, double epsilon=0.00001)
float	vl::ceil (float a)
fvec2	vl::ceil (const fvec2 &a)
fvec3	vl::ceil (const fvec3 &a)
fvec4	vl::ceil (const fvec4 &a)
double	vl::ceil (double a)
fvec2	vl::fract (const fvec2 &a)
fvec3	vl::fract (const fvec3 &a)
fvec4	vl::fract (const fvec4 &a)
float	vl::mod (float a, float b)
fvec2	vl::mod (const fvec2 &a, float b)
fvec3	vl::mod (const fvec3 &a, float b)
fvec4	vl::mod (const fvec4 &a, float b)
fvec2	vl::mod (const fvec2 &a, const fvec2 &b)
fvec3	vl::mod (const fvec3 &a, const fvec3 &b)
fvec4	vl::mod (const fvec4 &a, const fvec4 &b)
double	vl::mod (double a, double b)
dvec2	vl::mod (const dvec2 &a, double b)
dvec3	vl::mod (const dvec3 &a, double b)
dvec4	vl::mod (const dvec4 &a, double b)
fvec2	vl::modf (const fvec2 &a, fvec2 &intpart)
fvec3	vl::modf (const fvec3 &a, fvec3 &intpart)
fvec4	vl::modf (const fvec4 &a, fvec4 &intpart)
float	vl::min (float a, float b)
fvec2	vl::min (const fvec2 &a, const fvec2 &b)
fvec3	vl::min (const fvec3 &a, const fvec3 &b)
fvec4	vl::min (const fvec4 &a, const fvec4 &b)
fvec2	vl::min (const fvec2 &a, float b)
fvec3	vl::min (const fvec3 &a, float b)
fvec4	vl::min (const fvec4 &a, float b)
double	vl::min (double a, double b)
dvec2	vl::min (const dvec2 &a, double b)
dvec3	vl::min (const dvec3 &a, double b)
dvec4	vl::min (const dvec4 &a, double b)
int	vl::min (int a, int b)
ivec2	vl::min (const ivec2 &a, int b)
ivec3	vl::min (const ivec3 &a, int b)
ivec4	vl::min (const ivec4 &a, int b)
unsigned int	vl::min (unsigned int a, unsigned int b)
uvec2	vl::min (const uvec2 &a, unsigned int b)
uvec3	vl::min (const uvec3 &a, unsigned int b)
uvec4	vl::min (const uvec4 &a, unsigned int b)
float	vl::max (float a, float b)
fvec2	vl::max (const fvec2 &a, const fvec2 &b)
fvec3	vl::max (const fvec3 &a, const fvec3 &b)
fvec4	vl::max (const fvec4 &a, const fvec4 &b)
fvec2	vl::max (const fvec2 &a, float b)
fvec3	vl::max (const fvec3 &a, float b)
fvec4	vl::max (const fvec4 &a, float b)
double	vl::max (double a, double b)
dvec2	vl::max (const dvec2 &a, double b)
dvec3	vl::max (const dvec3 &a, double b)
dvec4	vl::max (const dvec4 &a, double b)
int	vl::max (int a, int b)
ivec2	vl::max (const ivec2 &a, int b)
ivec3	vl::max (const ivec3 &a, int b)
ivec4	vl::max (const ivec4 &a, int b)
unsigned int	vl::max (unsigned int a, unsigned int b)
uvec2	vl::max (const uvec2 &a, unsigned int b)
uvec3	vl::max (const uvec3 &a, unsigned int b)
uvec4	vl::max (const uvec4 &a, unsigned int b)
float	vl::clamp (float x, float minval, float maxval)
fvec2	vl::clamp (const fvec2 &x, float minval, float maxval)
fvec3	vl::clamp (const fvec3 &x, float minval, float maxval)
fvec4	vl::clamp (const fvec4 &x, float minval, float maxval)
fvec2	vl::clamp (const fvec2 &x, const fvec2 &minval, const fvec2 &maxval)
fvec3	vl::clamp (const fvec3 &x, const fvec3 &minval, const fvec3 &maxval)
fvec4	vl::clamp (const fvec4 &x, const fvec4 &minval, const fvec4 &maxval)
double	vl::clamp (double x, double minval, double maxval)
dvec2	vl::clamp (const dvec2 &x, double minval, double maxval)
dvec3	vl::clamp (const dvec3 &x, double minval, double maxval)
dvec4	vl::clamp (const dvec4 &x, double minval, double maxval)
int	vl::clamp (int x, int minval, int maxval)
ivec2	vl::clamp (const ivec2 &x, int minval, int maxval)
ivec3	vl::clamp (const ivec3 &x, int minval, int maxval)
ivec4	vl::clamp (const ivec4 &x, int minval, int maxval)
unsigned int	vl::clamp (unsigned int x, unsigned int minval, unsigned int maxval)
uvec2	vl::clamp (const uvec2 &x, unsigned int minval, unsigned int maxval)
uvec3	vl::clamp (const uvec3 &x, unsigned int minval, unsigned int maxval)
uvec4	vl::clamp (const uvec4 &x, unsigned int minval, unsigned int maxval)
float	vl::mix (float a, float b, float t)
fvec2	vl::mix (const fvec2 &a, const fvec2 &b, float t)
fvec3	vl::mix (const fvec3 &a, const fvec3 &b, float t)
fvec4	vl::mix (const fvec4 &a, const fvec4 &b, float t)
fvec2	vl::mix (const fvec2 &a, const fvec2 &b, const fvec2 &t)
fvec3	vl::mix (const fvec3 &a, const fvec3 &b, const fvec3 &t)
fvec4	vl::mix (const fvec4 &a, const fvec4 &b, const fvec4 &t)
double	vl::mix (double a, double b, double t)
dvec2	vl::mix (const dvec2 &a, const dvec2 &b, double t)
dvec3	vl::mix (const dvec3 &a, const dvec3 &b, double t)
dvec4	vl::mix (const dvec4 &a, const dvec4 &b, double t)
float	vl::step (float edge, float a)
fvec2	vl::step (const fvec2 &edge, const fvec2 &a)
fvec3	vl::step (const fvec3 &edge, const fvec3 &a)
fvec4	vl::step (const fvec4 &edge, const fvec4 &a)
double	vl::step (double edge, double a)
float	vl::smoothstep (float edge0, float edge1, float a)
fvec2	vl::smoothstep (const fvec2 &edge0, const fvec2 &edge1, const fvec2 &a)
fvec3	vl::smoothstep (const fvec3 &edge0, const fvec3 &edge1, const fvec3 &a)
fvec4	vl::smoothstep (const fvec4 &edge0, const fvec4 &edge1, const fvec4 &a)
double	vl::smoothstep (double edge0, double edge1, double a)
ivec2	vl::isnan (const fvec2 &a)
ivec3	vl::isnan (const fvec3 &a)
ivec4	vl::isnan (const fvec4 &a)
ivec2	vl::isinf (const fvec2 &a)
ivec3	vl::isinf (const fvec3 &a)
ivec4	vl::isinf (const fvec4 &a)
float	vl::length (float v)
float	vl::length (const fvec2 &v)
float	vl::length (const fvec3 &v)
float	vl::length (const fvec4 &v)
double	vl::length (double v)
float	vl::length (int v)
float	vl::length (unsigned int v)
float	vl::distance (float p0, float p1)
float	vl::distance (const fvec2 &p0, const fvec2 &p1)
float	vl::distance (const fvec3 &p0, const fvec3 &p1)
float	vl::distance (const fvec4 &p0, const fvec4 &p1)
double	vl::distance (double p0, double p1)
float	vl::distance (int p0, int p1)
float	vl::distance (unsigned int p0, unsigned int p1)
float	vl::dot (float a, float b)
float	vl::dot (const fvec2 &v1, const fvec2 &v2)
float	vl::dot (const fvec3 &v1, const fvec3 &v2)
float	vl::dot (const fvec4 &v1, const fvec4 &v2)
double	vl::dot (double a, double b)
float	vl::dot (int a, int b)
float	vl::dot (unsigned int a, unsigned int b)
fvec3	vl::cross (const fvec3 &v1, const fvec3 &v2)
float	vl::normalize (float)
fvec2	vl::normalize (const fvec2 &v)
fvec3	vl::normalize (const fvec3 &v)
fvec4	vl::normalize (const fvec4 &v)
double	vl::normalize (double)
float	vl::faceforward (float N, float I, float Nref)
fvec2	vl::faceforward (const fvec2 &N, const fvec2 &I, const fvec2 &Nref)
fvec3	vl::faceforward (const fvec3 &N, const fvec3 &I, const fvec3 &Nref)
fvec4	vl::faceforward (const fvec4 &N, const fvec4 &I, const fvec4 &Nref)
double	vl::faceforward (double N, double I, double Nref)
float	vl::reflect (float I, float N)
fvec2	vl::reflect (const fvec2 &I, const fvec2 &N)
fvec3	vl::reflect (const fvec3 &I, const fvec3 &N)
fvec4	vl::reflect (const fvec4 &I, const fvec4 &N)
double	vl::reflect (double I, double N)
float	vl::refract (float I, float N, float eta)
fvec2	vl::refract (const fvec2 &I, const fvec2 &N, float eta)
fvec3	vl::refract (const fvec3 &I, const fvec3 &N, float eta)
fvec4	vl::refract (const fvec4 &I, const fvec4 &N, float eta)
double	vl::refract (double I, double N, double eta)
dvec2	vl::refract (const dvec2 &I, const dvec2 &N, double eta)
dvec3	vl::refract (const dvec3 &I, const dvec3 &N, double eta)
dvec4	vl::refract (const dvec4 &I, const dvec4 &N, double eta)
fmat2	vl::matrixCompMult (const fmat2 &a, const fmat2 &b)
fmat3	vl::matrixCompMult (const fmat3 &a, const fmat3 &b)
fmat4	vl::matrixCompMult (const fmat4 &a, const fmat4 &b)
fmat2	vl::outerProduct (const fvec2 &a, const fvec2 &b)
fmat3	vl::outerProduct (const fvec3 &a, const fvec3 &b)
fmat4	vl::outerProduct (const fvec4 &a, const fvec4 &b)
fmat2	vl::transpose (const fmat2 &a)
fmat3	vl::transpose (const fmat3 &a)
fmat4	vl::transpose (const fmat4 &a)
ivec4	vl::lessThan (const fvec4 &a, const fvec4 &b)
ivec3	vl::lessThan (const fvec3 &a, const fvec3 &b)
ivec2	vl::lessThan (const fvec2 &a, const fvec2 &b)
ivec4	vl::lessThanEqual (const fvec4 &a, const fvec4 &b)
ivec3	vl::lessThanEqual (const fvec3 &a, const fvec3 &b)
ivec2	vl::lessThanEqual (const fvec2 &a, const fvec2 &b)
ivec4	vl::greaterThan (const fvec4 &a, const fvec4 &b)
ivec3	vl::greaterThan (const fvec3 &a, const fvec3 &b)
ivec2	vl::greaterThan (const fvec2 &a, const fvec2 &b)
ivec4	vl::greaterThanEqual (const fvec4 &a, const fvec4 &b)
ivec3	vl::greaterThanEqual (const fvec3 &a, const fvec3 &b)
ivec2	vl::greaterThanEqual (const fvec2 &a, const fvec2 &b)
ivec4	vl::equal (const fvec4 &a, const fvec4 &b)
ivec3	vl::equal (const fvec3 &a, const fvec3 &b)
ivec2	vl::equal (const fvec2 &a, const fvec2 &b)
ivec4	vl::notEqual (const fvec4 &a, const fvec4 &b)
ivec3	vl::notEqual (const fvec3 &a, const fvec3 &b)
ivec2	vl::notEqual (const fvec2 &a, const fvec2 &b)
bool	vl::any (const ivec2 &a)
bool	vl::any (const ivec3 &a)
bool	vl::any (const ivec4 &a)
bool	vl::all (const ivec2 &a)
bool	vl::all (const ivec3 &a)
bool	vl::all (const ivec4 &a)

---

Detailed Description

Implements the OpenGL Shading Language convenience functions for scalar and vector operations.

This functions are particularly useful when you want to port C++ code to GLSL and vice versa, or when you want to quickly prototype in C++ an algorithm that will be ported later to GLSL.

Note that most of this functions take as arguments not only int, unsigned int, float and double variables but also their vector counterparts like fvec4, dvec4, ivec4, uvec4, fvec3, fvec2 etc. For example you can do the following:

// clamp a float value
float f = someValueFloat()
f = vl::clamp(f, 0.0f, 1.0f);

// clamp a vector value
vl::fvec4 v = someValueVec4();
v = vl::clamp(v, vl::fvec4(1,2,3,4), vl::fvec4(5,6,7,8));

// the same goes for functions like mix(), min(), max(), sin(), cos(), floor() etc!

This module also implements other convenience functions like isnan(), isinf(), isinf_pos(), isinf_neg().

The functions are divided in the following categories:

Angle and trigonometry functions

radians(), degrees(), sin(), cos(), tan(), asin(), acos(), atan()

Hyperbolic functions

sinh(), cosh(), tanh(), asinh(), acosh(), atanh()

Exponential functions

pow(), exp(), log(), exp2(), log2(), log10(), sqrt(), inversesqrt(),

Common functions

abs(), sign(), floor(), trunc(), round(), roundEven(), ceil(), fract(), mod(), modf(), min(), max(), clamp(), mix(), step(), smoothstep(), isnan(), isinf()

Geometric functions

length(), distance(), dot(), cross(), normalize(), faceforward(), reflect(), refract()

Matrix functions

matrixCompMult(), outerProduct(), transpose(),

Vector relational functions

lessThan(), lessThanEqual(), greaterThan(), greaterThanEqual(), equal(), notEqual(), any(), all(), not()

See also:

For more information please refer to the official OpenGL Shading Language manual and specifications. See also the official OpenGL & OpenGL Utility Specifications page.