normal.h

Go to the documentation of this file.

 
#ifndef HERMES_GEOMETRY_NORMAL_H
#define HERMES_GEOMETRY_NORMAL_H
 
#include <iostream>
#include <hermes/geometry/vector.h>
 
namespace hermes {
 
// *********************************************************************************************************************
//                                                                                                            Normal2
// *********************************************************************************************************************
template<typename T> class Normal2 : public MathElement<T, 2u> {
  static_assert(std::is_same<T, f32>::value || std::is_same<T, f64>::value ||
                    std::is_same<T, float>::value || std::is_same<T, double>::value,
                "Normal2 must hold an float type!");
public:
  // *******************************************************************************************************************
  //                                                                                                     CONSTRUCTORS
  // *******************************************************************************************************************
  HERMES_DEVICE_CALLABLE Normal2() : x{0}, y{0} {};
  HERMES_DEVICE_CALLABLE Normal2(T _x, T _y) : x(_x), y(_y) {}
  HERMES_DEVICE_CALLABLE Normal2(const Vector2 <T> &v) : x(v.x), y(v.y) {}
  // *******************************************************************************************************************
  //                                                                                                        OPERATORS
  // *******************************************************************************************************************
  //                                                                                                          casting
  HERMES_DEVICE_CALLABLE explicit operator Vector2<T>() const {
    return Vector2<T>(x, y);
  }
  //                                                                                                       arithmetic
  HERMES_DEVICE_CALLABLE Normal2 operator-() const { return Normal2(-x, -y); }
  HERMES_DEVICE_CALLABLE Normal2 &operator*=(T f) {
    x *= f;
    y *= f;
    return *this;
  }
  HERMES_DEVICE_CALLABLE Normal2 &operator/=(T f) {
    x /= f;
    y /= f;
    return *this;
  }
  // *******************************************************************************************************************
  //                                                                                                    PUBLIC FIELDS
  // *******************************************************************************************************************
  T x{0}; 
  T y{0}; 
};
 
// *********************************************************************************************************************
//                                                                                                            Normal3
// *********************************************************************************************************************
template<typename T> class Normal3 : MathElement<T, 3u> {
  static_assert(std::is_same<T, f32>::value || std::is_same<T, f64>::value ||
                    std::is_same<T, float>::value ||
                    std::is_same<T, double>::value,
                "Normal3 must hold an float type!");
public:
  // *******************************************************************************************************************
  //                                                                                                   STATIC METHODS
  // *******************************************************************************************************************
  // *******************************************************************************************************************
  //                                                                                                     CONSTRUCTORS
  // *******************************************************************************************************************
  HERMES_DEVICE_CALLABLE Normal3() { x = y = z = 0; }
  HERMES_DEVICE_CALLABLE Normal3(T _x, T _y, T _z) : x(_x), y(_y), z(_z) {}
  HERMES_DEVICE_CALLABLE explicit Normal3(const Vector3 <T> &v) : x(v.x), y(v.y), z(v.z) {}
  // *******************************************************************************************************************
  //                                                                                                        OPERATORS
  // *******************************************************************************************************************
  //                                                                                                          casting
  HERMES_DEVICE_CALLABLE explicit operator Vector3<T>() const {
    return Vector3<T>(x, y, z);
  }
  //                                                                                                       arithmetic
  HERMES_DEVICE_CALLABLE Normal3 operator-() const { return Normal3(-x, -y, -z); }
  HERMES_DEVICE_CALLABLE Normal3 &operator+=(const Vector3<T>& v) {
    x += v.x;
    y += v.y;
    z += v.z;
    return *this;
  }
  HERMES_DEVICE_CALLABLE Normal3 &operator*=(T f) {
    x *= f;
    y *= f;
    z *= f;
    return *this;
  }
  HERMES_DEVICE_CALLABLE Normal3 &operator/=(T f) {
    x /= f;
    y /= f;
    z /= f;
    return *this;
  }
  //                                                                                                          boolean
  HERMES_DEVICE_CALLABLE bool operator!=(const Normal3 &n) const {
    return n.x != x || n.y != y || n.z != z;
  }
  // *******************************************************************************************************************
  //                                                                                                         GEOMETRY
  // *******************************************************************************************************************
  HERMES_DEVICE_CALLABLE Vector3 <T> reflect(const Vector3 <T> &v) {
    return reflect(v, *this);
  }
  HERMES_DEVICE_CALLABLE Vector3 <T> project(const Vector3 <T> &v) {
    return project(v, *this);
  }
  HERMES_DEVICE_CALLABLE void tangential(Vector3 <T> &a, Vector3 <T> &b) {
    //  hermes::tangential(Vector3<T>(x, y, z), a, b);
  }
 
  T x{0};  
  T y{0};  
  T z{0};  
};
 
// *********************************************************************************************************************
//                                                                                                          FUNCTIONS
// *********************************************************************************************************************
template<typename T>
HERMES_DEVICE_CALLABLE Vector2 <T> reflect(const Vector2 <T> &a, const Normal2<T> &n) {
  return a - 2 * dot(a, Vector2<T>(n)) * Vector2<T>(n);
}
template<typename T>
HERMES_DEVICE_CALLABLE Vector2 <T> project(const Vector2 <T> &v, const Normal2<T> &n) {
  return v - dot(v, Vector2<T>(n)) * Vector2<T>(n);
}
template<typename T>
HERMES_DEVICE_CALLABLE  Normal3<T> normalize(const Normal3<T> &normal) {
  T d = normal.x * normal.x + normal.y * normal.y + normal.z * normal.z;
  if (d == 0.f)
    return normal;
  return Normal3<T>(normal.x / d, normal.y / d, normal.z / d);
}
template<typename T>
HERMES_DEVICE_CALLABLE  Normal3<T> abs(const Normal3<T> &normal) {
  return Normal3<T>(std::abs(normal.x), std::abs(normal.y), std::abs(normal.z));
}
template<typename T>
HERMES_DEVICE_CALLABLE  Vector3 <T> reflect(const Vector3 <T> &a, const Normal3<T> &n) {
  return a - 2 * dot(a, Vector3<T>(n)) * Vector3<T>(n);
}
template<typename S>
HERMES_DEVICE_CALLABLE  Vector3 <S> project(const Vector3 <S> &v, const Normal3<S> &n) {
  return v - dot(v, Vector3<S>(n)) * Vector3<S>(n);
}
template<typename T>
HERMES_DEVICE_CALLABLE  T dot(const Normal3<T> &n, const Vector3 <T> &v) {
  return n.x * v.x + n.y * v.y + n.z * v.z;
}
template<typename T>
HERMES_DEVICE_CALLABLE  T dot(const Vector3 <T> &v, const Normal3<T> &n) {
  return n.x * v.x + n.y * v.y + n.z * v.z;
}
template<typename T>
HERMES_DEVICE_CALLABLE Vector3 <T> faceForward(const Vector3 <T> &v, const Normal3<T> &n) {
  return (dot(v, n) < 0.f) ? -v : v;
}
 
// *********************************************************************************************************************
//                                                                                                                 IO
// *********************************************************************************************************************
template<typename T>
std::ostream &operator<<(std::ostream &os, const Normal2<T> &n) {
  os << "[Normal3] " << n.x << " " << n.y << std::endl;
  return os;
}
template<typename T>
std::ostream &operator<<(std::ostream &os, const Normal3<T> &n) {
  os << "[Normal3] " << n.x << " " << n.y << " " << n.z << std::endl;
  return os;
}
 
// *********************************************************************************************************************
//                                                                                                           TYPEDEFS
// *********************************************************************************************************************
using normal2 = Normal2<real_t>;
using normal2f = Normal2<float>;
using normal2d = Normal2<double>;
using normal3 = Normal3<real_t>;
using normal3f = Normal3<float>;
using normal3d = Normal3<double>;
 
} // namespace hermes
 
#endif