reference

This documentation is automatically generated from the openFrameworks source code using doxygen and refers to the most recent release, version 0.12.0.

ofVectorMath.h File Reference
#include "ofVec2f.h"
#include "ofVec3f.h"
#include "ofVec4f.h"
#include "ofMatrix3x3.h"
#include "ofMatrix4x4.h"
#include "ofQuaternion.h"
#include "ofMathConstants.h"
#include "ofConstants.h"
#include "glm/vec2.hpp"
#include "glm/vec3.hpp"
#include "glm/vec4.hpp"
#include "glm/mat3x3.hpp"
#include "glm/mat4x4.hpp"
#include "glm/geometric.hpp"
#include "glm/common.hpp"
#include "glm/trigonometric.hpp"
#include "glm/exponential.hpp"
#include "glm/vector_relational.hpp"
#include "glm/gtc/constants.hpp"
#include "glm/gtc/matrix_transform.hpp"
#include "glm/gtc/matrix_inverse.hpp"
#include "glm/gtc/quaternion.hpp"
#include "glm/gtc/epsilon.hpp"
#include "glm/gtx/norm.hpp"
#include "glm/gtx/perpendicular.hpp"
#include "glm/gtx/quaternion.hpp"
#include "glm/gtx/rotate_vector.hpp"
#include "glm/gtx/spline.hpp"
#include "glm/gtx/transform.hpp"
#include "glm/gtx/vector_angle.hpp"
#include "glm/gtx/scalar_multiplication.hpp"
#include <glm/gtc/type_ptr.hpp>
#include <iomanip>

Go to the source code of this file.

Namespaces

namespace  glm
 

Functions

const ofVec2ftoOf (const glm::vec2 &v)
 
const ofVec3ftoOf (const glm::vec3 &v)
 
const ofVec4ftoOf (const glm::vec4 &v)
 
const ofMatrix4x4toOf (const glm::mat4 &v)
 
const ofMatrix3x3toOf (const glm::mat3 &v)
 
const glm::vec2 & toGlm (const ofVec2f &v)
 
const glm::vec3 & toGlm (const ofVec3f &v)
 
const glm::vec4 & toGlm (const ofVec4f &v)
 
const glm::mat4 & toGlm (const ofMatrix4x4 &v)
 
const glm::mat3 & toGlm (const ofMatrix3x3 &v)
 
const glm::vec2 & toGlm (const glm::vec2 &v)
 
const glm::vec3 & toGlm (const glm::vec3 &v)
 
const glm::vec4 & toGlm (const glm::vec4 &v)
 
const glm::quat toGlm (const ofQuaternion &q)
 
const glm::quat & toGlm (const glm::quat &q)
 
template<typename T , precision P>
std::ostream & glm::operator<< (std::ostream &os, const vec< 3, T, P > &vec)
 
template<typename T , precision P>
std::istream & glm::operator>> (std::istream &is, vec< 3, T, P > &vec)
 
template<typename T , precision P>
std::ostream & glm::operator<< (std::ostream &os, const vec< 2, T, P > &vec)
 
template<typename T , precision P>
std::istream & glm::operator>> (std::istream &is, vec< 2, T, P > &vec)
 
template<typename T , precision P>
std::ostream & glm::operator<< (std::ostream &os, const vec< 4, T, P > &vec)
 
template<typename T , precision P>
std::istream & glm::operator>> (std::istream &is, vec< 4, T, P > &vec)
 
template<typename T , precision P>
std::ostream & glm::operator<< (std::ostream &os, const mat< 3, 3, T, P > &mat)
 
template<typename T , precision P>
std::istream & glm::operator>> (std::istream &is, mat< 3, 3, T, P > &mat)
 
template<typename T , precision P>
std::ostream & glm::operator<< (std::ostream &os, const mat< 4, 4, T, P > &mat)
 
template<typename T , precision P>
std::istream & glm::operator>> (std::istream &is, mat< 4, 4, T, P > &mat)
 
template<typename T , precision P>
std::ostream & glm::operator<< (std::ostream &os, const qua< T, P > &q)
 
template<typename T , precision P>
std::istream & glm::operator>> (std::istream &is, qua< T, P > &q)
 
glm::vec3 operator+ (const glm::vec3 &v1, const ofVec3f &v2)
 
glm::vec3 operator- (const glm::vec3 &v1, const ofVec3f &v2)
 
glm::vec3 operator* (const glm::vec3 &v1, const ofVec3f &v2)
 
glm::vec3 operator/ (const glm::vec3 &v1, const ofVec3f &v2)
 
glm::vec3 & operator+= (glm::vec3 &v1, const ofVec3f &v2)
 
glm::vec3 & operator-= (glm::vec3 &v1, const ofVec3f &v2)
 
glm::vec3 & operator*= (glm::vec3 &v1, const ofVec3f &v2)
 
glm::vec3 & operator/= (glm::vec3 &v1, const ofVec3f &v2)
 
glm::vec2 operator+ (const glm::vec2 &v1, const ofVec2f &v2)
 
glm::vec2 operator- (const glm::vec2 &v1, const ofVec2f &v2)
 
glm::vec2 operator* (const glm::vec2 &v1, const ofVec2f &v2)
 
glm::vec2 operator/ (const glm::vec2 &v1, const ofVec2f &v2)
 
glm::vec2 & operator+= (glm::vec2 &v1, const ofVec2f &v2)
 
glm::vec2 & operator-= (glm::vec2 &v1, const ofVec2f &v2)
 
glm::vec2 & operator*= (glm::vec2 &v1, const ofVec2f &v2)
 
glm::vec2 & operator/= (glm::vec2 &v1, const ofVec2f &v2)
 

Function Documentation

◆ operator*() [1/2]

glm::vec2 operator* ( const glm::vec2 &  v1,
const ofVec2f v2 
)
inline

◆ operator*() [2/2]

glm::vec3 operator* ( const glm::vec3 &  v1,
const ofVec3f v2 
)
inline

◆ operator*=() [1/2]

glm::vec2 & operator*= ( glm::vec2 &  v1,
const ofVec2f v2 
)
inline

◆ operator*=() [2/2]

glm::vec3 & operator*= ( glm::vec3 &  v1,
const ofVec3f v2 
)
inline

◆ operator+() [1/2]

glm::vec2 operator+ ( const glm::vec2 &  v1,
const ofVec2f v2 
)
inline

◆ operator+() [2/2]

glm::vec3 operator+ ( const glm::vec3 &  v1,
const ofVec3f v2 
)
inline

◆ operator+=() [1/2]

glm::vec2 & operator+= ( glm::vec2 &  v1,
const ofVec2f v2 
)
inline

◆ operator+=() [2/2]

glm::vec3 & operator+= ( glm::vec3 &  v1,
const ofVec3f v2 
)
inline

◆ operator-() [1/2]

glm::vec2 operator- ( const glm::vec2 &  v1,
const ofVec2f v2 
)
inline

◆ operator-() [2/2]

glm::vec3 operator- ( const glm::vec3 &  v1,
const ofVec3f v2 
)
inline

◆ operator-=() [1/2]

glm::vec2 & operator-= ( glm::vec2 &  v1,
const ofVec2f v2 
)
inline

◆ operator-=() [2/2]

glm::vec3 & operator-= ( glm::vec3 &  v1,
const ofVec3f v2 
)
inline

◆ operator/() [1/2]

glm::vec2 operator/ ( const glm::vec2 &  v1,
const ofVec2f v2 
)
inline

◆ operator/() [2/2]

glm::vec3 operator/ ( const glm::vec3 &  v1,
const ofVec3f v2 
)
inline

◆ operator/=() [1/2]

glm::vec2 & operator/= ( glm::vec2 &  v1,
const ofVec2f v2 
)
inline

◆ operator/=() [2/2]

glm::vec3 & operator/= ( glm::vec3 &  v1,
const ofVec3f v2 
)
inline

◆ toGlm() [1/10]

const glm::quat & toGlm ( const glm::quat &  q)
inline

◆ toGlm() [2/10]

const glm::vec2 & toGlm ( const glm::vec2 &  v)
inline

◆ toGlm() [3/10]

const glm::vec3 & toGlm ( const glm::vec3 &  v)
inline

◆ toGlm() [4/10]

const glm::vec4 & toGlm ( const glm::vec4 &  v)
inline

◆ toGlm() [5/10]

const glm::mat3 & toGlm ( const ofMatrix3x3 v)
inline

◆ toGlm() [6/10]

const glm::mat4 & toGlm ( const ofMatrix4x4 v)
inline

◆ toGlm() [7/10]

const glm::quat toGlm ( const ofQuaternion q)
inline

◆ toGlm() [8/10]

const glm::vec2 & toGlm ( const ofVec2f v)
inline

◆ toGlm() [9/10]

const glm::vec3 & toGlm ( const ofVec3f v)
inline

◆ toGlm() [10/10]

const glm::vec4 & toGlm ( const ofVec4f v)
inline

◆ toOf() [1/5]

const ofMatrix3x3 & toOf ( const glm::mat3 &  v)
inline

◆ toOf() [2/5]

const ofMatrix4x4 & toOf ( const glm::mat4 &  v)
inline

◆ toOf() [3/5]

const ofVec2f & toOf ( const glm::vec2 &  v)
inline

◆ toOf() [4/5]

const ofVec3f & toOf ( const glm::vec3 &  v)
inline

◆ toOf() [5/5]

const ofVec4f & toOf ( const glm::vec4 &  v)
inline