API tools faq
paste
Advertisement
candlemaster1

vmath/vec3.h

candlemaster1
Mar 26th, 2017
166
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 16.82 KB | None | 0 0
raw download clone embed print report
  1. #ifndef HVH_VMATH_VEC3_H
  2. #define HVH_VMATH_VEC3_H
  3.  
  4. #include "vmath_includes.h"
  5. #include "vec2.h"
  6.  
  7. namespace vmath
  8. {
  9.  
  10. class vec3
  11. {
  12. public:
  13.     //// Constructors
  14.     vec3() = default;
  15.     vec3(const vec3&) = default;
  16.     constexpr vec3(float x, float y, float z) : x(x), y(y), z(z) {}
  17.     constexpr vec3(vec2 xy, float z) : x(xy.data[0]), y(xy.data[1]), z(z) {}
  18.     constexpr vec3(float x, vec2 yz) : x(x), y(yz.data[0]), z(yz.data[1]) {}
  19.  
  20.     //// Swizzles
  21. private:
  22.     friend class vec4;
  23.  
  24.     template <typename T, int X, int Y, int Z>
  25.     struct SWIZZLE_READ_ONLY
  26.     {
  27.         inline operator vec3() const
  28.         {
  29.             T* self = (T*)this;
  30.             return{ self->data[X], self->data[Y], self->data[Z] };
  31.         }
  32.  
  33.         inline vec3 operator + (vec3 rhs)
  34.             { T* self = (T*)this; return{ self->data[X] + rhs.data[0], self->data[Y] + rhs.data[1], self->data[Z] + rhs.data[2] }; }
  35.         inline vec3 operator - (vec3 rhs)
  36.             { T* self = (T*)this; return{ self->data[X] - rhs.data[0], self->data[Y] - rhs.data[1], self->data[Z] - rhs.data[2] }; }
  37.         inline vec3 operator * (vec3 rhs)
  38.             { T* self = (T*)this; return{ self->data[X] * rhs.data[0], self->data[Y] * rhs.data[1], self->data[Z] * rhs.data[2] }; }
  39.         inline vec3 operator / (vec3 rhs)
  40.             { T* self = (T*)this; return{ self->data[X] / rhs.data[0], self->data[Y] / rhs.data[1], self->data[Z] / rhs.data[2] }; }
  41.  
  42.         inline vec3 operator + (float rhs)
  43.             { T* self = (T*)this; return{ self->data[X] + rhs, self->data[Y] + rhs, self->data[Z] + rhs }; }
  44.         inline vec3 operator - (float rhs)
  45.             { T* self = (T*)this; return{ self->data[X] - rhs, self->data[Y] - rhs, self->data[Z] - rhs }; }
  46.         inline vec3 operator * (float rhs)
  47.             { T* self = (T*)this; return{ self->data[X] * rhs, self->data[Y] * rhs, self->data[Z] * rhs }; }
  48.         inline vec3 operator / (float rhs)
  49.             { T* self = (T*)this; return{ self->data[X] / rhs, self->data[Y] / rhs, self->data[Z] / rhs }; }
  50.     };
  51.  
  52.     template <typename T, int X, int Y, int Z>
  53.     struct SWIZZLE_READWRITE : public SWIZZLE_READ_ONLY<T, X, Y, Z>
  54.     {
  55.         static_assert((X != Y) && (X != Z) && (Y != Z), "Read+Write swizzling cannot be defined for multiple identical elements.");
  56.  
  57.         inline T& operator = (vec3 rhs)
  58.         {
  59.             T* self = (T*)this;
  60.             self->data[X] = rhs.data[0];
  61.             self->data[Y] = rhs.data[1];
  62.             self->data[Z] = rhs.data[2];
  63.             return *self;
  64.         }
  65.        
  66.         // Any non-const, non-static member functions need to be defined here.
  67.  
  68.         inline vec3& operator += (vec3 rhs)
  69.             { T* self = (T*)this; self->data[X] += rhs.data[0]; self->data[Y] += rhs.data[1]; self->data[Z] += rhs.data[2]; return *self; }
  70.         inline vec3& operator -= (vec3 rhs)
  71.             { T* self = (T*)this; self->data[X] -= rhs.data[0]; self->data[Y] -= rhs.data[1]; self->data[Z] -= rhs.data[2]; return *self; }
  72.         inline vec3& operator *= (vec3 rhs)
  73.             { T* self = (T*)this; self->data[X] *= rhs.data[0]; self->data[Y] *= rhs.data[1]; self->data[Z] *= rhs.data[2]; return *self; }
  74.         inline vec3& operator /= (vec3 rhs)
  75.             { T* self = (T*)this; self->data[X] /= rhs.data[0]; self->data[Y] /= rhs.data[1]; self->data[Z] /= rhs.data[2]; return *self; }
  76.  
  77.         inline vec3& operator += (float rhs)
  78.             { T* self = (T*)this; self->data[X] += rhs; self->data[Y] += rhs; self->data[Z] += rhs; return *self; }
  79.         inline vec3& operator -= (float rhs)
  80.             { T* self = (T*)this; self->data[X] -= rhs; self->data[Y] -= rhs; self->data[Z] -= rhs; return *self; }
  81.         inline vec3& operator *= (float rhs)
  82.             { T* self = (T*)this; self->data[X] *= rhs; self->data[Y] *= rhs; self->data[Z] *= rhs; return *self; }
  83.         inline vec3& operator /= (float rhs)
  84.             { T* self = (T*)this; self->data[X] /= rhs; self->data[Y] /= rhs; self->data[Z] /= rhs; return *self; }
  85.        
  86.         inline void normalize()
  87.         {
  88.             T* self = (T*)this;
  89.             vec3 temp = { self->data[X], self->data[Y], self->data[Z] };
  90.             temp.normalize();
  91.             self->data[X] = temp.data[0]; self->data[Y] = temp.data[1]; self->data[Z] = temp.data[2];
  92.         }
  93.  
  94.         inline void clamp(vec3 minimum, vec3 maximum)
  95.         {
  96.             T* self = (T*)this;
  97.             vec3 temp = { self->data[X], self->data[Y], self->data[Z] };
  98.             temp.clamp(minimum, maximum);
  99.             self->data[X] = temp.data[0]; self->data[Y] = temp.data[1]; self->data[Z] = temp.data[2];
  100.         }
  101.  
  102.         inline void clamp_magnitude(float max_magnitude)
  103.         {
  104.             T* self = (T*)this;
  105.             vec3 temp = { self->data[X], self->data[Y], self->data[Z] };
  106.             temp.clamp_magnitude(max_magnitude);
  107.             self->data[X] = temp.data[0]; self->data[Y] = temp.data[1]; self->data[Z] = temp.data[2];
  108.         }
  109.  
  110.         inline void move_towards(vec3 target, float max_dist)
  111.         {
  112.             T* self = (T*)this;
  113.             vec3 temp = { self->data[X], self->data[Y], self->data[Z] };
  114.             temp.move_towards(target, max_dist);
  115.             self->data[X] = temp.data[0]; self->data[Y] = temp.data[1]; self->data[Z] = temp.data[2];
  116.         }
  117.        
  118.     };
  119.  
  120. public:
  121.     //// Data storage
  122.  
  123.     union
  124.     {
  125.         struct { float x, y, z; };
  126.         struct { float r, g, b; };
  127.         struct { float s, t, p; };
  128.         float data[3];
  129.  
  130.         //// vec3 swizzles
  131.         // xyz
  132.         SWIZZLE_READ_ONLY<vec3, 0, 0, 0> xxx;
  133.         SWIZZLE_READ_ONLY<vec3, 0, 0, 1> xxy;
  134.         SWIZZLE_READ_ONLY<vec3, 0, 0, 2> xxz;
  135.         SWIZZLE_READ_ONLY<vec3, 0, 1, 0> xyx;
  136.         SWIZZLE_READ_ONLY<vec3, 0, 1, 1> xyy;
  137.         SWIZZLE_READWRITE<vec3, 0, 1, 2> xyz;
  138.         SWIZZLE_READ_ONLY<vec3, 0, 2, 0> xzx;
  139.         SWIZZLE_READWRITE<vec3, 0, 2, 1> xzy;
  140.         SWIZZLE_READ_ONLY<vec3, 0, 2, 2> xzz;
  141.  
  142.         SWIZZLE_READ_ONLY<vec3, 1, 0, 0> yxx;
  143.         SWIZZLE_READ_ONLY<vec3, 1, 0, 1> yxy;
  144.         SWIZZLE_READWRITE<vec3, 1, 0, 2> yxz;
  145.         SWIZZLE_READ_ONLY<vec3, 1, 1, 0> yyx;
  146.         SWIZZLE_READ_ONLY<vec3, 1, 1, 1> yyy;
  147.         SWIZZLE_READ_ONLY<vec3, 1, 1, 2> yyz;
  148.         SWIZZLE_READWRITE<vec3, 1, 2, 0> yzx;
  149.         SWIZZLE_READ_ONLY<vec3, 1, 2, 1> yzy;
  150.         SWIZZLE_READ_ONLY<vec3, 1, 2, 2> yzz;
  151.  
  152.         SWIZZLE_READ_ONLY<vec3, 2, 0, 0> zxx;
  153.         SWIZZLE_READWRITE<vec3, 2, 0, 1> zxy;
  154.         SWIZZLE_READ_ONLY<vec3, 2, 0, 2> zxz;
  155.         SWIZZLE_READWRITE<vec3, 2, 1, 0> zyx;
  156.         SWIZZLE_READ_ONLY<vec3, 2, 1, 1> zyy;
  157.         SWIZZLE_READ_ONLY<vec3, 2, 1, 2> zyz;
  158.         SWIZZLE_READ_ONLY<vec3, 2, 2, 0> zzx;
  159.         SWIZZLE_READ_ONLY<vec3, 2, 2, 1> zzy;
  160.         SWIZZLE_READ_ONLY<vec3, 2, 2, 2> zzz;
  161.  
  162.         // rgb
  163.         SWIZZLE_READ_ONLY<vec3, 0, 0, 0> rrr;
  164.         SWIZZLE_READ_ONLY<vec3, 0, 0, 1> rrg;
  165.         SWIZZLE_READ_ONLY<vec3, 0, 0, 2> rrb;
  166.         SWIZZLE_READ_ONLY<vec3, 0, 1, 0> rgr;
  167.         SWIZZLE_READ_ONLY<vec3, 0, 1, 1> rgg;
  168.         SWIZZLE_READWRITE<vec3, 0, 1, 2> rgb;
  169.         SWIZZLE_READ_ONLY<vec3, 0, 2, 0> rbr;
  170.         SWIZZLE_READWRITE<vec3, 0, 2, 1> rbg;
  171.         SWIZZLE_READ_ONLY<vec3, 0, 2, 2> rbb;
  172.  
  173.         SWIZZLE_READ_ONLY<vec3, 1, 0, 0> grr;
  174.         SWIZZLE_READ_ONLY<vec3, 1, 0, 1> grg;
  175.         SWIZZLE_READWRITE<vec3, 1, 0, 2> grb;
  176.         SWIZZLE_READ_ONLY<vec3, 1, 1, 0> ggr;
  177.         SWIZZLE_READ_ONLY<vec3, 1, 1, 1> ggg;
  178.         SWIZZLE_READ_ONLY<vec3, 1, 1, 2> ggb;
  179.         SWIZZLE_READWRITE<vec3, 1, 2, 0> gbr;
  180.         SWIZZLE_READ_ONLY<vec3, 1, 2, 1> gbg;
  181.         SWIZZLE_READ_ONLY<vec3, 1, 2, 2> gbb;
  182.  
  183.         SWIZZLE_READ_ONLY<vec3, 2, 0, 0> brr;
  184.         SWIZZLE_READWRITE<vec3, 2, 0, 1> brg;
  185.         SWIZZLE_READ_ONLY<vec3, 2, 0, 2> brb;
  186.         SWIZZLE_READWRITE<vec3, 2, 1, 0> bgr;
  187.         SWIZZLE_READ_ONLY<vec3, 2, 1, 1> bgg;
  188.         SWIZZLE_READ_ONLY<vec3, 2, 1, 2> bgb;
  189.         SWIZZLE_READ_ONLY<vec3, 2, 2, 0> bbr;
  190.         SWIZZLE_READ_ONLY<vec3, 2, 2, 1> bbg;
  191.         SWIZZLE_READ_ONLY<vec3, 2, 2, 2> bbb;
  192.  
  193.         // stp
  194.         SWIZZLE_READ_ONLY<vec3, 0, 0, 0> sss;
  195.         SWIZZLE_READ_ONLY<vec3, 0, 0, 1> sst;
  196.         SWIZZLE_READ_ONLY<vec3, 0, 0, 2> ssp;
  197.         SWIZZLE_READ_ONLY<vec3, 0, 1, 0> sts;
  198.         SWIZZLE_READ_ONLY<vec3, 0, 1, 1> stt;
  199.         SWIZZLE_READWRITE<vec3, 0, 1, 2> stp;
  200.         SWIZZLE_READ_ONLY<vec3, 0, 2, 0> sps;
  201.         SWIZZLE_READWRITE<vec3, 0, 2, 1> spt;
  202.         SWIZZLE_READ_ONLY<vec3, 0, 2, 2> spp;
  203.  
  204.         SWIZZLE_READ_ONLY<vec3, 1, 0, 0> tss;
  205.         SWIZZLE_READ_ONLY<vec3, 1, 0, 1> tst;
  206.         SWIZZLE_READWRITE<vec3, 1, 0, 2> tsp;
  207.         SWIZZLE_READ_ONLY<vec3, 1, 1, 0> tts;
  208.         SWIZZLE_READ_ONLY<vec3, 1, 1, 1> ttt;
  209.         SWIZZLE_READ_ONLY<vec3, 1, 1, 2> ttp;
  210.         SWIZZLE_READWRITE<vec3, 1, 2, 0> tps;
  211.         SWIZZLE_READ_ONLY<vec3, 1, 2, 1> tpt;
  212.         SWIZZLE_READ_ONLY<vec3, 1, 2, 2> tpp;
  213.  
  214.         SWIZZLE_READ_ONLY<vec3, 2, 0, 0> pss;
  215.         SWIZZLE_READWRITE<vec3, 2, 0, 1> pst;
  216.         SWIZZLE_READ_ONLY<vec3, 2, 0, 2> psp;
  217.         SWIZZLE_READWRITE<vec3, 2, 1, 0> pts;
  218.         SWIZZLE_READ_ONLY<vec3, 2, 1, 1> ptt;
  219.         SWIZZLE_READ_ONLY<vec3, 2, 1, 2> ptp;
  220.         SWIZZLE_READ_ONLY<vec3, 2, 2, 0> pps;
  221.         SWIZZLE_READ_ONLY<vec3, 2, 2, 1> ppt;
  222.         SWIZZLE_READ_ONLY<vec3, 2, 2, 2> ppp;
  223.  
  224.         // vec2 swizzles
  225.         // xyz
  226.         vec2::SWIZZLE_READ_ONLY<vec3, 0, 0> xx;
  227.         vec2::SWIZZLE_READWRITE<vec3, 0, 1> xy;
  228.         vec2::SWIZZLE_READWRITE<vec3, 0, 2> xz;
  229.         vec2::SWIZZLE_READWRITE<vec3, 1, 0> yx;
  230.         vec2::SWIZZLE_READ_ONLY<vec3, 1, 1> yy;
  231.         vec2::SWIZZLE_READWRITE<vec3, 1, 2> yz;
  232.         vec2::SWIZZLE_READWRITE<vec3, 2, 0> zx;
  233.         vec2::SWIZZLE_READWRITE<vec3, 2, 1> zy;
  234.         vec2::SWIZZLE_READ_ONLY<vec3, 2, 2> zz;
  235.         // rgb
  236.         vec2::SWIZZLE_READ_ONLY<vec3, 0, 0> rr;
  237.         vec2::SWIZZLE_READWRITE<vec3, 0, 1> rg;
  238.         vec2::SWIZZLE_READWRITE<vec3, 0, 2> rb;
  239.         vec2::SWIZZLE_READWRITE<vec3, 1, 0> gr;
  240.         vec2::SWIZZLE_READ_ONLY<vec3, 1, 1> gg;
  241.         vec2::SWIZZLE_READWRITE<vec3, 1, 2> gb;
  242.         vec2::SWIZZLE_READWRITE<vec3, 2, 0> br;
  243.         vec2::SWIZZLE_READWRITE<vec3, 2, 1> bg;
  244.         vec2::SWIZZLE_READ_ONLY<vec3, 2, 2> bb;
  245.         // stp
  246.         vec2::SWIZZLE_READ_ONLY<vec3, 0, 0> ss;
  247.         vec2::SWIZZLE_READWRITE<vec3, 0, 1> st;
  248.         vec2::SWIZZLE_READWRITE<vec3, 0, 2> sp;
  249.         vec2::SWIZZLE_READWRITE<vec3, 1, 0> ts;
  250.         vec2::SWIZZLE_READ_ONLY<vec3, 1, 1> tt;
  251.         vec2::SWIZZLE_READWRITE<vec3, 1, 2> tp;
  252.         vec2::SWIZZLE_READWRITE<vec3, 2, 0> ps;
  253.         vec2::SWIZZLE_READWRITE<vec3, 2, 1> pt;
  254.         vec2::SWIZZLE_READ_ONLY<vec3, 2, 2> pp;
  255.     };
  256.  
  257.     //// Operator Overloads
  258.  
  259.     // Equality test operators.
  260.     inline constexpr bool operator == (vec3 rhs) const
  261.         { return ((x == rhs.x) && (y == rhs.y) && (z == rhs.z)); }
  262.     inline constexpr bool operator != (vec3 rhs) const
  263.         { return ((x != rhs.x) || (y != rhs.y) || (z != rhs.z)); }
  264.  
  265.     // Arithmetic operators (vector with vector)
  266.     inline constexpr vec3 operator + (vec3 rhs) const
  267.         { return { x+rhs.x, y+rhs.y, z+rhs.z }; }
  268.     inline constexpr vec3 operator - (vec3 rhs) const
  269.         { return { x-rhs.x, y-rhs.y, z-rhs.z }; }
  270.     inline constexpr vec3 operator * (vec3 rhs) const
  271.         { return { x*rhs.x, y*rhs.y, z*rhs.z }; }
  272.     inline constexpr vec3 operator / (vec3 rhs) const
  273.         { return { x/rhs.x, y/rhs.y, z/rhs.z }; }
  274.  
  275.     // Arithmetic operators (vector with float)
  276.     inline constexpr vec3 operator + (float rhs) const
  277.         { return { x+rhs, y+rhs, z+rhs }; }
  278.     inline constexpr vec3 operator - (float rhs) const
  279.         { return { x-rhs, y-rhs, z-rhs }; }
  280.     inline constexpr vec3 operator * (float rhs) const
  281.         { return { x*rhs, y*rhs, z*rhs }; }
  282.     inline constexpr vec3 operator / (float rhs) const
  283.         { return { x/rhs, y/rhs, z/rhs }; }
  284.  
  285.     // Arithmetic operator (float with vector)
  286.     friend inline constexpr vec3 operator + (const float lhs, const vec3 rhs)
  287.         { return { lhs+rhs.x, lhs+rhs.y, lhs+rhs.z }; }
  288.     friend inline constexpr vec3 operator - (const float lhs, const vec3 rhs)
  289.         { return { lhs-rhs.x, lhs-rhs.y, lhs-rhs.z }; }
  290.     friend inline constexpr vec3 operator * (const float lhs, const vec3 rhs)
  291.         { return { lhs*rhs.x, lhs*rhs.y, lhs*rhs.z }; }
  292.     friend inline constexpr vec3 operator / (const float lhs, const vec3 rhs)
  293.         { return { lhs/rhs.x, lhs/rhs.y, lhs/rhs.z }; }
  294.  
  295.     // Arithmetic-assignment operators (vector with vector)
  296.     inline vec3& operator += (vec3 rhs)
  297.         { return *this = *this + rhs; }
  298.     inline vec3& operator -= (vec3 rhs)
  299.         { return *this = *this - rhs; }
  300.     inline vec3& operator *= (vec3 rhs)
  301.         { return *this = *this * rhs; }
  302.     inline vec3& operator /= (vec3 rhs)
  303.         { return *this = *this / rhs; }
  304.  
  305.     // Arithmetic-assignment operators (vector with float)
  306.     inline vec3& operator += (float rhs)
  307.         { return *this = *this + rhs; }
  308.     inline vec3& operator -= (float rhs)
  309.         { return *this = *this - rhs; }
  310.     inline vec3& operator *= (float rhs)
  311.         { return *this = *this * rhs; }
  312.     inline vec3& operator /= (float rhs)
  313.         { return *this = *this / rhs; }
  314.  
  315.     // Negation operator (unary minus)
  316.     inline constexpr vec3 operator - () const
  317.         { return { -x, -y, -z }; }
  318.  
  319.     //// Member functions
  320.  
  321.     inline constexpr bool is_zero() const
  322.         { return ((x == 0.0f) && (y == 0.0f) && (z == 0.0f)); }
  323.  
  324.     inline constexpr float sum() const
  325.         { return x + y + z; }
  326.  
  327.     inline float magnitude() const
  328.         { return sqrtf((x*x) + (y*y) + (z*z)); }
  329.  
  330.     inline float mag() const
  331.         { return magnitude(); }
  332.  
  333.     inline float magnitude_squared() const
  334.         { return (x*x) + (y*y) + (z*z); }
  335.  
  336.     inline float sqrmag() const
  337.         { return magnitude_squared(); }
  338.  
  339.     inline vec3 normalized() const
  340.         { return *this / magnitude(); }
  341.  
  342.     inline void normalize()
  343.         { *this = normalized(); }
  344.  
  345.     static inline vec3 minimum(vec3 lhs, vec3 rhs)
  346.         { return { fminf(lhs.x, rhs.x), fminf(lhs.y, rhs.y), fminf(lhs.z, rhs.z) }; }
  347.  
  348.     static inline vec3 maximum(vec3 lhs, vec3 rhs)
  349.         { return { fmaxf(lhs.x, rhs.x), fmaxf(lhs.y, rhs.y), fmaxf(lhs.z, rhs.z) }; }
  350.  
  351.     inline vec3 clamped(vec3 lower, vec3 upper) const
  352.         { return minimum(upper, maximum(lower, *this)); }
  353.  
  354.     inline void clamp(vec3 lower, vec3 upper)
  355.         { *this = clamped(lower, upper); }
  356.  
  357.     inline vec3 clamped_magnitude(float max_magnitude) const
  358.     {
  359.         float mag = magnitude();
  360.         if (mag <= max_magnitude)
  361.             return *this;
  362.         else
  363.             return this->normalized() * max_magnitude;
  364.     }
  365.     inline void clamp_magnitude(float max_magnitude)
  366.         { *this = clamped_magnitude(max_magnitude); }
  367.  
  368.     static inline float distance(vec3 a, vec3 b)
  369.         { return (a-b).magnitude(); }
  370.  
  371.     static inline float distance_squared(vec3 a, vec3 b)
  372.         { return (a-b).magnitude_squared(); }
  373.  
  374.     inline vec3 moved_towards(vec3 target, float max_dist) const
  375.     {
  376.         if (distance(*this, target) <= max_dist)
  377.             return target;
  378.         else
  379.             return *this + ((target - *this).normalized() * max_dist);
  380.     }
  381.     inline void move_towards(vec3 target, float max_dist)
  382.         { *this = moved_towards(target, max_dist); }
  383.  
  384.     static inline constexpr float dot(vec3 a, vec3 b)
  385.         { return (a.x * b.x) + (a.y * b.y) + (a.z * b.z); }
  386.  
  387.     // Cross product: A x B = (a2b3 - a3b2, a3b1 - a1b3, a1b2 - a2b1)
  388.     static inline constexpr vec3 cross(vec3 a, vec3 b)
  389.         { return { (a.y*b.z) - (a.z*b.y), (a.z*b.x) - (a.x*b.z), (a.x*b.y) - (a.y*b.x) }; }
  390.  
  391.     static inline vec3 lerp(vec3 from, vec3 to, float amount)
  392.     { return (from * (1.0f - amount)) + (to * amount); }
  393.  
  394.     static inline vec3 ortho_normalize(vec3 a, vec3 b)
  395.     {
  396.         vec3 r = cross(a.normalized(), b.normalized());
  397.         return cross(r, a.normalized());
  398.     }
  399.  
  400.     static float angle(vec3 a, vec3 b)
  401.         { return acosf(clampf(dot(a, b) / (a.magnitude() * b.magnitude()), -1.0f, 1.0f)); }
  402.  
  403.     static float signed_angle(vec3 a, vec3 b)
  404.     {
  405.         float my_angle = angle(a, b);
  406.         if (cross(a, b).y < 0) my_angle = -my_angle;
  407.         return my_angle;
  408.     }
  409.  
  410.     // Transforms hue/saturation/value to red/green/blue.
  411.     static inline vec3 hsv_to_rgb(float hue, float sat, float val)
  412.     {
  413.         vec3 result;
  414.         result.r = fabsf(hue * 6.0f - 3.0f) - 1.0f;
  415.         result.g = 2 - fabsf(hue * 6.0f - 2.0f);
  416.         result.b = 2 - fabsf(hue * 6.0f - 4.0f);
  417.         result.clamp({ 0,0,0 }, { 1,1,1 });
  418.         return ((result - 1.0f) * sat + 1.0f) * val;
  419.     }
  420.  
  421.     // I got the implementation for this from Unity.  I honestly don't really know what the hell is going on here.
  422.     static inline vec3 smooth_damp(const vec3 from, const vec3 to, vec3& velocity, float smooth_time, float delta_time, float max_speed)
  423.     {
  424.         if (smooth_time <= 0.0f)
  425.             smooth_time = 0.0001f;
  426.         float num = 2 / smooth_time;
  427.         float num2 = num * delta_time;
  428.         float num3 = 1 / (1 + num2 + 0.48f * num2 * num2 + 0.235f * num2 * num2);
  429.         vec3 num4 = from - to;
  430.         vec3 num5 = to;
  431.         float max_dist = max_speed * smooth_time;
  432.         num4.clamp_magnitude(max_dist);
  433.         num5 = from - num4;
  434.         vec3 num7 = ((num4 * num) + velocity) * delta_time;
  435.         velocity = (velocity - num * num7) * num3;
  436.         vec3 num8 = to + (num4 + num7) * num3;
  437.         if (((num5 - from).magnitude() > 0) == (num8.magnitude() > num5.magnitude()))
  438.         {
  439.             num8 = num5;
  440.             velocity = (num8 - num5) / delta_time;
  441.         }
  442.  
  443.         return num8;
  444.     }
  445.  
  446.     static inline vec3 spring(vec3 current, vec3& velocity, vec3 target, float delta_time, float tightness)
  447.     {
  448.         vec3 current_to_target = target - current;
  449.         vec3 spring_force = current_to_target * tightness;
  450.         vec3 damping_force = -velocity * 2 * sqrtf(tightness);
  451.         vec3 force = spring_force + damping_force;
  452.         velocity += force * delta_time;
  453.         vec3 displacement = velocity * delta_time;
  454.         return current + displacement;
  455.     }
  456. };
  457.  
  458. constexpr vec3 VEC3_ZERO = { 0, 0, 0 };
  459. constexpr vec3 VEC3_ONE = { 1, 1, 1 };
  460. constexpr vec3 VEC3_UP = { 0, 1, 0 };
  461. constexpr vec3 VEC3_DOWN = { 0, -1, 0 };
  462. constexpr vec3 VEC3_FORWARD = { 0, 0, -1 };
  463. constexpr vec3 VEC3_BACK = { 0, 0, 1};
  464. constexpr vec3 VEC3_RIGHT = { 1, 0, 0 };
  465. constexpr vec3 VEC3_LEFT = { -1, 0, 0 };
  466.  
  467. constexpr vec3 VEC3_BLACK = { 0, 0, 0 };
  468. constexpr vec3 VEC3_WHITE = { 1, 1, 1 };
  469. constexpr vec3 VEC3_RED = { 1, 0, 0 };
  470. constexpr vec3 VEC3_GREEN = { 0, 1, 0 };
  471. constexpr vec3 VEC3_BLUE = { 0, 0, 1 };
  472. constexpr vec3 VEC3_YELLOW = { 1, 1, 0 };
  473. constexpr vec3 VEC3_CYAN = { 0, 1, 1 };
  474. constexpr vec3 VEC3_MAGENTA = { 1, 0, 1 };
  475.  
  476.  
  477. } // namespace vmath
  478. #endif
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!