# Visualization Library

A lightweight C++ OpenGL middleware for 2D/3D graphics

[Home] [Tutorials] [All Classes] [Grouped Classes]

# 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.

Visualization Library v2009.07 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Mon Aug 10 21:41:28 2009.
Permission is granted to use this page to write and publish articles regarding Visualization Library.