utils.h

Go to the documentation of this file.

 
#pragma once
#include "mat/mat2.h"
#include "mat/mat3.h"
#include "mat/mat4.h"
#include "vec/vec2.h"
#include "vec/vec3.h"
#include "vec/vec4.h"
 
namespace Math::Utils {
 
  template<class V>
  float distance(const V& a, const V& b) {
    return (a - b).length();
  }
 
  template<class T>
  vec2<T> normalize(const vec2<T>& a) {
    return a.normalize();
  }
 
  template<class T>
  vec3<T> normalize(const vec3<T>& a) {
    return a.normalize();
  }
 
  template<class T>
  vec4<T> normalize(const vec4<T>& a) {
    return a.normalize();
  }
 
  template<class T>
  mat4<T> translate(const mat4<T>& M, const vec3<T>& V) {
    mat4<T> translation = M;
    vec3<T> res         = vec3<T>(M[0][0], M[0][1], M[0][2]) * V.x + vec3<T>(M[1][0], M[1][1], M[1][2]) * V.y
                  + vec3<T>(M[2][0], M[2][1], M[2][2]) * V.z + vec3<T>(M[3][0], M[3][1], M[3][2]);
    translation[3][0] = res.x;
    translation[3][1] = res.y;
    translation[3][2] = res.z;
    return translation;
  }
 
  template<class T>
  mat4<T> lookAt(const vec3<T>& eye, const vec3<T>& center, const vec3<T>& up) {
    vec3<T> const f(normalize(center - eye));
    vec3<T> const s(normalize(f.cross(up)));
    vec3<T> const u(s.cross(f));
 
    mat4<T> Result(1);
    Result[0][0] = s.x;
    Result[1][0] = s.y;
    Result[2][0] = s.z;
    Result[0][1] = u.x;
    Result[1][1] = u.y;
    Result[2][1] = u.z;
    Result[0][2] = -f.x;
    Result[1][2] = -f.y;
    Result[2][2] = -f.z;
    Result[3][0] = -(s * eye);
    Result[3][1] = -(u * eye);
    Result[3][2] = (f * eye);
    return Result;
  }
 
  template<class T>
  mat4<T> ortho(const float& left, const float& right, const float& bottom, const float& top) {
    mat4<T> mat(1.0f);
    mat[0][0] = static_cast<T>(2) / (right - left);
    mat[1][1] = static_cast<T>(2) / (top - bottom);
    mat[2][2] = -static_cast<T>(1);
    mat[3][0] = -(right + left) / (right - left);
    mat[3][1] = -(top + bottom) / (top - bottom);
    return mat;
  }
 
  template<class T>
  mat4<T>
  perspective(const float& FOV, const float& width, const float& height, const float& zNear, const float& zFar) {
    float halfTanFOV = tanf(FOV / static_cast<T>(2));
    float aspect     = width / height;
    return mat4<T>(
    static_cast<T>(1) / (aspect * halfTanFOV),
    0,
    0,
    0,
    0,
    static_cast<T>(1) / (halfTanFOV),
    0,
    0,
    0,
    0,
    -(zFar + zNear) / (zFar - zNear),
    -static_cast<T>(1),
    0,
    0,
    -(static_cast<T>(2) * zFar * zNear) / (zFar - zNear),
    0);
  }
 
  template<class T>
  mat4<T> angleAxis([[maybe_unused]] const float& angle, [[maybe_unused]] const vec3<T>& axis) {
    //        return mat4<T>(axis.x, axis.y, axis.z, angle);
    return mat4<T>(0);
  }
 
  template<class T>
  mat4<T> scale(const mat4<T>& mat, const float& factor) {
    return (mat4<T>::Unit() * factor) * mat;
  }
  template<class T>
  mat4<T> scale(const mat4<T>& mat, const vec3<T>& factor) {
    mat4<T> out;
    out[0][0] = mat[0][0] * factor[0];
    out[0][1] = mat[0][1] * factor[0];
    out[0][2] = mat[0][2] * factor[0];
    out[0][3] = mat[0][3] * factor[0];
    out[1][0] = mat[1][0] * factor[1];
    out[1][1] = mat[1][1] * factor[1];
    out[1][2] = mat[1][2] * factor[1];
    out[1][3] = mat[1][3] * factor[1];
    out[2][0] = mat[2][0] * factor[2];
    out[2][1] = mat[2][1] * factor[2];
    out[2][2] = mat[2][2] * factor[2];
    out[2][3] = mat[2][3] * factor[2];
    out[3][0] = mat[3][0] * static_cast<T>(1.0);
    out[3][1] = mat[3][1] * static_cast<T>(1.0);
    out[3][2] = mat[3][2] * static_cast<T>(1.0);
    out[3][3] = mat[3][3] * static_cast<T>(1.0);
    return out;
  }
 
  template<typename T, typename U>
  vec3<T> unProject(vec3<T> const& win, mat4<T> const& model, mat4<T> const& proj, vec4<U> const& viewport) {
    mat4<T> Inverse = (proj * model).Inverse();
 
    vec4<T> tmp(win, T(1));
    tmp.x = (tmp.x - T(viewport[0])) / T(viewport[2]);
    tmp.y = (tmp.y - T(viewport[1])) / T(viewport[3]);
    tmp.x = tmp.x * static_cast<T>(2) - static_cast<T>(1);
    tmp.y = tmp.y * static_cast<T>(2) - static_cast<T>(1);
 
    vec4<T> obj = Inverse * tmp;
    obj /= obj.w;
 
    return vec3<T>(obj);
  }
 
  template<class T>
  mat4<T> rotate(const mat4<T>& m, const float& angle, vec3<T> u) {
    T const cosAngle = cosf(angle);
    T const sinAngle = sinf(angle);
 
    vec3<T> axis = u.normalize();
    vec3<T> temp((T(1) - cosAngle) * axis);
 
    mat4<T> rot;
    rot[0][0] = cosAngle + temp[0] * axis[0];
    rot[0][1] = temp[0] * axis[1] + sinAngle * axis[2];
    rot[0][2] = temp[0] * axis[2] - sinAngle * axis[1];
 
    rot[1][0] = temp[1] * axis[0] - sinAngle * axis[2];
    rot[1][1] = cosAngle + temp[1] * axis[1];
    rot[1][2] = temp[1] * axis[2] + sinAngle * axis[0];
 
    rot[2][0] = temp[2] * axis[0] + sinAngle * axis[1];
    rot[2][1] = temp[2] * axis[1] - sinAngle * axis[0];
    rot[2][2] = cosAngle + temp[2] * axis[2];
 
    const vec4<T> out0 = vec4(m[0]) * rot[0][0] + vec4(m[1]) * rot[0][1] + vec4(m[2]) * rot[0][2];
    const vec4<T> out1 = vec4(m[0]) * rot[1][0] + vec4(m[1]) * rot[1][1] + vec4(m[2]) * rot[1][2];
    const vec4<T> out2 = vec4(m[0]) * rot[2][0] + vec4(m[1]) * rot[2][1] + vec4(m[2]) * rot[2][2];
    const vec4<T> out3 = vec4(m[3]);
    return mat4<T>(out0, out1, out2, out3);
  }
 
  template<class T>
  vec3<T> max(const vec3<T>& a, const vec3<T>& b) {
    return a.length() > b.length() ? a : b;
  }
 
  template<class T>
  vec3<T> lerp(const vec3<T>& p1, const vec3<T>& p2, const float& v) {
    T ax = p1[0];
    T ay = p1[1];
    T az = p1[2];
    return vec3<T>(ax + v * (p2[0] - ax), ay + v * (p2[1] - ay), az + v * (p2[2] - az));
  }
 
  template<class T>
  vec4<T> lerp(const vec4<T>& p1, const vec4<T>& p2, const float& v) {
    T ax = p1[0];
    T ay = p1[1];
    T az = p1[2];
    T aw = p1[3];
    return vec4<T>(ax + v * (p2[0] - ax), ay + v * (p2[1] - ay), az + v * (p2[2] - az), aw + v * (p2[3] - aw));
  }
} // namespace Math::Utils
 
template<class T>
void* value_ptr(vec2<T>& vec) {
  return &(vec.x);
}
 
template<class T>
void* value_ptr(vec3<T>& vec) {
  return &(vec.x);
}
 
template<class T>
void* value_ptr(vec4<T>& vec) {
  return &(vec.x);
}
template<class T>
void* value_ptr(mat2<T>& mat) {
  return &(mat[0][0]);
}
template<class T>
void* value_ptr(mat3<T>& mat) {
  return &(mat[0][0]);
}
 
template<class T>
void* value_ptr(mat4<T>& mat) {
  return &(mat[0][0]);
}
 
template<class T>
const void* value_ptr(vec2<T> const& vec) {
  return &(vec.x);
}
 
template<class T>
const void* value_ptr(vec3<T> const& vec) {
  return &(vec.x);
}
template<class T>
const void* value_ptr(vec4<T> const& vec) {
  return &(vec.x);
}
template<class T>
const void* value_ptr(mat2<T> const& mat) {
  return &(mat[0][0]);
}
template<class T>
const void* value_ptr(mat3<T> const& mat) {
  return &(mat[0][0]);
}
template<class T>
const void* value_ptr(mat4<T> const& mat) {
  return &(mat[0][0]);
}
 
template<class T>
T sign(const T& d) {
  if(d == 0.f) return 1;
  return d < 0 ? -1 : 1;
}
 
template<class T>
T abs(const T& d) {
  if(d < 0.f) return static_cast<T>(-1) * d;
  return d;
}