From dc8479928c5aee4c6ad6fe4f59006fb604cee701 Mon Sep 17 00:00:00 2001 From: Emmanuel Gil Peyrot Date: Sun, 18 Sep 2016 09:38:01 +0900 Subject: Sources: Run clang-format on everything. --- src/common/vector_math.h | 707 +++++++++++++++++++++++++---------------------- 1 file changed, 382 insertions(+), 325 deletions(-) (limited to 'src/common/vector_math.h') diff --git a/src/common/vector_math.h b/src/common/vector_math.h index cfb9481b6..b2d630829 100644 --- a/src/common/vector_math.h +++ b/src/common/vector_math.h @@ -1,7 +1,6 @@ // Licensed under GPLv2 or any later version // Refer to the license.txt file included. - // Copyright 2014 Tony Wasserka // All rights reserved. // @@ -36,158 +35,178 @@ namespace Math { -template class Vec2; -template class Vec3; -template class Vec4; +template +class Vec2; +template +class Vec3; +template +class Vec4; -template +template static inline Vec2 MakeVec(const T& x, const T& y); -template +template static inline Vec3 MakeVec(const T& x, const T& y, const T& z); -template +template static inline Vec4 MakeVec(const T& x, const T& y, const T& z, const T& w); - -template +template class Vec2 { public: T x; T y; - T* AsArray() { return &x; } + T* AsArray() { + return &x; + } Vec2() = default; - Vec2(const T a[2]) : x(a[0]), y(a[1]) {} - Vec2(const T& _x, const T& _y) : x(_x), y(_y) {} + Vec2(const T a[2]) : x(a[0]), y(a[1]) { + } + Vec2(const T& _x, const T& _y) : x(_x), y(_y) { + } - template + template Vec2 Cast() const { return Vec2((T2)x, (T2)y); } - static Vec2 AssignToAll(const T& f) - { + static Vec2 AssignToAll(const T& f) { return Vec2(f, f); } - void Write(T a[2]) - { - a[0] = x; a[1] = y; + void Write(T a[2]) { + a[0] = x; + a[1] = y; } - Vec2 operator +(const Vec2& other) const - { - return MakeVec(x+other.x, y+other.y); + Vec2 operator+(const Vec2& other) const { + return MakeVec(x + other.x, y + other.y); } - void operator += (const Vec2 &other) - { - x+=other.x; y+=other.y; + void operator+=(const Vec2& other) { + x += other.x; + y += other.y; } - Vec2 operator -(const Vec2& other) const - { - return MakeVec(x-other.x, y-other.y); + Vec2 operator-(const Vec2& other) const { + return MakeVec(x - other.x, y - other.y); } - void operator -= (const Vec2& other) - { - x-=other.x; y-=other.y; + void operator-=(const Vec2& other) { + x -= other.x; + y -= other.y; } - template::value>::type> - Vec2 operator -() const - { - return MakeVec(-x,-y); + template ::value>::type> + Vec2 operator-() const { + return MakeVec(-x, -y); } - Vec2 operator * (const Vec2& other) const - { - return MakeVec(x*other.x, y*other.y); + Vec2 operator*(const Vec2& other) const { + return MakeVec(x * other.x, y * other.y); } - template - Vec2 operator * (const V& f) const - { - return MakeVec(x*f,y*f); + template + Vec2 operator*(const V& f) const { + return MakeVec(x * f, y * f); } - template - void operator *= (const V& f) - { - x*=f; y*=f; + template + void operator*=(const V& f) { + x *= f; + y *= f; } - template - Vec2 operator / (const V& f) const - { - return MakeVec(x/f,y/f); + template + Vec2 operator/(const V& f) const { + return MakeVec(x / f, y / f); } - template - void operator /= (const V& f) - { + template + void operator/=(const V& f) { *this = *this / f; } - T Length2() const - { - return x*x + y*y; + T Length2() const { + return x * x + y * y; } // Only implemented for T=float float Length() const; void SetLength(const float l); Vec2 WithLength(const float l) const; - float Distance2To(Vec2 &other); + float Distance2To(Vec2& other); Vec2 Normalized() const; float Normalize(); // returns the previous length, which is often useful - T& operator [] (int i) //allow vector[1] = 3 (vector.y=3) + T& operator[](int i) // allow vector[1] = 3 (vector.y=3) { return *((&x) + i); } - T operator [] (const int i) const - { + T operator[](const int i) const { return *((&x) + i); } - void SetZero() - { - x=0; y=0; + void SetZero() { + x = 0; + y = 0; } // Common aliases: UV (texel coordinates), ST (texture coordinates) - T& u() { return x; } - T& v() { return y; } - T& s() { return x; } - T& t() { return y; } + T& u() { + return x; + } + T& v() { + return y; + } + T& s() { + return x; + } + T& t() { + return y; + } - const T& u() const { return x; } - const T& v() const { return y; } - const T& s() const { return x; } - const T& t() const { return y; } + const T& u() const { + return x; + } + const T& v() const { + return y; + } + const T& s() const { + return x; + } + const T& t() const { + return y; + } // swizzlers - create a subvector of specific components - const Vec2 yx() const { return Vec2(y, x); } - const Vec2 vu() const { return Vec2(y, x); } - const Vec2 ts() const { return Vec2(y, x); } + const Vec2 yx() const { + return Vec2(y, x); + } + const Vec2 vu() const { + return Vec2(y, x); + } + const Vec2 ts() const { + return Vec2(y, x); + } }; -template -Vec2 operator * (const V& f, const Vec2& vec) -{ - return Vec2(f*vec.x,f*vec.y); +template +Vec2 operator*(const V& f, const Vec2& vec) { + return Vec2(f * vec.x, f * vec.y); } typedef Vec2 Vec2f; -template -class Vec3 -{ +template +class Vec3 { public: T x; T y; T z; - T* AsArray() { return &x; } + T* AsArray() { + return &x; + } Vec3() = default; - Vec3(const T a[3]) : x(a[0]), y(a[1]), z(a[2]) {} - Vec3(const T& _x, const T& _y, const T& _z) : x(_x), y(_y), z(_z) {} + Vec3(const T a[3]) : x(a[0]), y(a[1]), z(a[2]) { + } + Vec3(const T& _x, const T& _y, const T& _z) : x(_x), y(_y), z(_z) { + } - template + template Vec3 Cast() const { return MakeVec((T2)x, (T2)y, (T2)z); } @@ -196,126 +215,161 @@ public: static Vec3 FromRGB(unsigned int rgb); unsigned int ToRGB() const; // alpha bits set to zero - static Vec3 AssignToAll(const T& f) - { + static Vec3 AssignToAll(const T& f) { return MakeVec(f, f, f); } - void Write(T a[3]) - { - a[0] = x; a[1] = y; a[2] = z; + void Write(T a[3]) { + a[0] = x; + a[1] = y; + a[2] = z; } - Vec3 operator +(const Vec3 &other) const - { - return MakeVec(x+other.x, y+other.y, z+other.z); + Vec3 operator+(const Vec3& other) const { + return MakeVec(x + other.x, y + other.y, z + other.z); } - void operator += (const Vec3 &other) - { - x+=other.x; y+=other.y; z+=other.z; + void operator+=(const Vec3& other) { + x += other.x; + y += other.y; + z += other.z; } - Vec3 operator -(const Vec3 &other) const - { - return MakeVec(x-other.x, y-other.y, z-other.z); + Vec3 operator-(const Vec3& other) const { + return MakeVec(x - other.x, y - other.y, z - other.z); } - void operator -= (const Vec3 &other) - { - x-=other.x; y-=other.y; z-=other.z; + void operator-=(const Vec3& other) { + x -= other.x; + y -= other.y; + z -= other.z; } - template::value>::type> - Vec3 operator -() const - { - return MakeVec(-x,-y,-z); + template ::value>::type> + Vec3 operator-() const { + return MakeVec(-x, -y, -z); } - Vec3 operator * (const Vec3 &other) const - { - return MakeVec(x*other.x, y*other.y, z*other.z); + Vec3 operator*(const Vec3& other) const { + return MakeVec(x * other.x, y * other.y, z * other.z); } - template - Vec3 operator * (const V& f) const - { - return MakeVec(x*f,y*f,z*f); + template + Vec3 operator*(const V& f) const { + return MakeVec(x * f, y * f, z * f); } - template - void operator *= (const V& f) - { - x*=f; y*=f; z*=f; + template + void operator*=(const V& f) { + x *= f; + y *= f; + z *= f; } - template - Vec3 operator / (const V& f) const - { - return MakeVec(x/f,y/f,z/f); + template + Vec3 operator/(const V& f) const { + return MakeVec(x / f, y / f, z / f); } - template - void operator /= (const V& f) - { + template + void operator/=(const V& f) { *this = *this / f; } - T Length2() const - { - return x*x + y*y + z*z; + T Length2() const { + return x * x + y * y + z * z; } // Only implemented for T=float float Length() const; void SetLength(const float l); Vec3 WithLength(const float l) const; - float Distance2To(Vec3 &other); + float Distance2To(Vec3& other); Vec3 Normalized() const; float Normalize(); // returns the previous length, which is often useful - T& operator [] (int i) //allow vector[2] = 3 (vector.z=3) + T& operator[](int i) // allow vector[2] = 3 (vector.z=3) { return *((&x) + i); } - T operator [] (const int i) const - { + T operator[](const int i) const { return *((&x) + i); } - void SetZero() - { - x=0; y=0; z=0; + void SetZero() { + x = 0; + y = 0; + z = 0; } // Common aliases: UVW (texel coordinates), RGB (colors), STQ (texture coordinates) - T& u() { return x; } - T& v() { return y; } - T& w() { return z; } + T& u() { + return x; + } + T& v() { + return y; + } + T& w() { + return z; + } - T& r() { return x; } - T& g() { return y; } - T& b() { return z; } + T& r() { + return x; + } + T& g() { + return y; + } + T& b() { + return z; + } - T& s() { return x; } - T& t() { return y; } - T& q() { return z; } + T& s() { + return x; + } + T& t() { + return y; + } + T& q() { + return z; + } - const T& u() const { return x; } - const T& v() const { return y; } - const T& w() const { return z; } + const T& u() const { + return x; + } + const T& v() const { + return y; + } + const T& w() const { + return z; + } - const T& r() const { return x; } - const T& g() const { return y; } - const T& b() const { return z; } + const T& r() const { + return x; + } + const T& g() const { + return y; + } + const T& b() const { + return z; + } - const T& s() const { return x; } - const T& t() const { return y; } - const T& q() const { return z; } + const T& s() const { + return x; + } + const T& t() const { + return y; + } + const T& q() const { + return z; + } - // swizzlers - create a subvector of specific components - // e.g. Vec2 uv() { return Vec2(x,y); } - // _DEFINE_SWIZZLER2 defines a single such function, DEFINE_SWIZZLER2 defines all of them for all component names (x<->r) and permutations (xy<->yx) -#define _DEFINE_SWIZZLER2(a, b, name) const Vec2 name() const { return Vec2(a, b); } -#define DEFINE_SWIZZLER2(a, b, a2, b2, a3, b3, a4, b4) \ - _DEFINE_SWIZZLER2(a, b, a##b); \ - _DEFINE_SWIZZLER2(a, b, a2##b2); \ - _DEFINE_SWIZZLER2(a, b, a3##b3); \ - _DEFINE_SWIZZLER2(a, b, a4##b4); \ - _DEFINE_SWIZZLER2(b, a, b##a); \ - _DEFINE_SWIZZLER2(b, a, b2##a2); \ - _DEFINE_SWIZZLER2(b, a, b3##a3); \ +// swizzlers - create a subvector of specific components +// e.g. Vec2 uv() { return Vec2(x,y); } +// _DEFINE_SWIZZLER2 defines a single such function, DEFINE_SWIZZLER2 defines all of them for all +// component names (x<->r) and permutations (xy<->yx) +#define _DEFINE_SWIZZLER2(a, b, name) \ + const Vec2 name() const { \ + return Vec2(a, b); \ + } +#define DEFINE_SWIZZLER2(a, b, a2, b2, a3, b3, a4, b4) \ + _DEFINE_SWIZZLER2(a, b, a##b); \ + _DEFINE_SWIZZLER2(a, b, a2##b2); \ + _DEFINE_SWIZZLER2(a, b, a3##b3); \ + _DEFINE_SWIZZLER2(a, b, a4##b4); \ + _DEFINE_SWIZZLER2(b, a, b##a); \ + _DEFINE_SWIZZLER2(b, a, b2##a2); \ + _DEFINE_SWIZZLER2(b, a, b3##a3); \ _DEFINE_SWIZZLER2(b, a, b4##a4) DEFINE_SWIZZLER2(x, y, r, g, u, v, s, t); @@ -325,41 +379,42 @@ public: #undef _DEFINE_SWIZZLER2 }; -template -Vec3 operator * (const V& f, const Vec3& vec) -{ - return Vec3(f*vec.x,f*vec.y,f*vec.z); +template +Vec3 operator*(const V& f, const Vec3& vec) { + return Vec3(f * vec.x, f * vec.y, f * vec.z); } -template<> +template <> inline float Vec3::Length() const { return std::sqrt(x * x + y * y + z * z); } -template<> +template <> inline Vec3 Vec3::Normalized() const { return *this / Length(); } - typedef Vec3 Vec3f; -template -class Vec4 -{ +template +class Vec4 { public: T x; T y; T z; T w; - T* AsArray() { return &x; } + T* AsArray() { + return &x; + } Vec4() = default; - Vec4(const T a[4]) : x(a[0]), y(a[1]), z(a[2]), w(a[3]) {} - Vec4(const T& _x, const T& _y, const T& _z, const T& _w) : x(_x), y(_y), z(_z), w(_w) {} + Vec4(const T a[4]) : x(a[0]), y(a[1]), z(a[2]), w(a[3]) { + } + Vec4(const T& _x, const T& _y, const T& _z, const T& _w) : x(_x), y(_y), z(_z), w(_w) { + } - template + template Vec4 Cast() const { return Vec4((T2)x, (T2)y, (T2)z, (T2)w); } @@ -372,81 +427,79 @@ public: return Vec4(f, f, f, f); } - void Write(T a[4]) - { - a[0] = x; a[1] = y; a[2] = z; a[3] = w; + void Write(T a[4]) { + a[0] = x; + a[1] = y; + a[2] = z; + a[3] = w; } - Vec4 operator +(const Vec4& other) const - { - return MakeVec(x+other.x, y+other.y, z+other.z, w+other.w); + Vec4 operator+(const Vec4& other) const { + return MakeVec(x + other.x, y + other.y, z + other.z, w + other.w); } - void operator += (const Vec4& other) - { - x+=other.x; y+=other.y; z+=other.z; w+=other.w; + void operator+=(const Vec4& other) { + x += other.x; + y += other.y; + z += other.z; + w += other.w; } - Vec4 operator -(const Vec4 &other) const - { - return MakeVec(x-other.x, y-other.y, z-other.z, w-other.w); + Vec4 operator-(const Vec4& other) const { + return MakeVec(x - other.x, y - other.y, z - other.z, w - other.w); } - void operator -= (const Vec4 &other) - { - x-=other.x; y-=other.y; z-=other.z; w-=other.w; + void operator-=(const Vec4& other) { + x -= other.x; + y -= other.y; + z -= other.z; + w -= other.w; } - template::value>::type> - Vec4 operator -() const - { - return MakeVec(-x,-y,-z,-w); + template ::value>::type> + Vec4 operator-() const { + return MakeVec(-x, -y, -z, -w); } - Vec4 operator * (const Vec4 &other) const - { - return MakeVec(x*other.x, y*other.y, z*other.z, w*other.w); + Vec4 operator*(const Vec4& other) const { + return MakeVec(x * other.x, y * other.y, z * other.z, w * other.w); } - template - Vec4 operator * (const V& f) const - { - return MakeVec(x*f,y*f,z*f,w*f); + template + Vec4 operator*(const V& f) const { + return MakeVec(x * f, y * f, z * f, w * f); } - template - void operator *= (const V& f) - { - x*=f; y*=f; z*=f; w*=f; + template + void operator*=(const V& f) { + x *= f; + y *= f; + z *= f; + w *= f; } - template - Vec4 operator / (const V& f) const - { - return MakeVec(x/f,y/f,z/f,w/f); + template + Vec4 operator/(const V& f) const { + return MakeVec(x / f, y / f, z / f, w / f); } - template - void operator /= (const V& f) - { + template + void operator/=(const V& f) { *this = *this / f; } - T Length2() const - { - return x*x + y*y + z*z + w*w; + T Length2() const { + return x * x + y * y + z * z + w * w; } // Only implemented for T=float float Length() const; void SetLength(const float l); Vec4 WithLength(const float l) const; - float Distance2To(Vec4 &other); + float Distance2To(Vec4& other); Vec4 Normalized() const; float Normalize(); // returns the previous length, which is often useful - T& operator [] (int i) //allow vector[2] = 3 (vector.z=3) + T& operator[](int i) // allow vector[2] = 3 (vector.z=3) { return *((&x) + i); } - T operator [] (const int i) const - { + T operator[](const int i) const { return *((&x) + i); } - void SetZero() - { + void SetZero() { x = 0; y = 0; z = 0; @@ -454,30 +507,50 @@ public: } // Common alias: RGBA (colors) - T& r() { return x; } - T& g() { return y; } - T& b() { return z; } - T& a() { return w; } - - const T& r() const { return x; } - const T& g() const { return y; } - const T& b() const { return z; } - const T& a() const { return w; } - - // Swizzlers - Create a subvector of specific components - // e.g. Vec2 uv() { return Vec2(x,y); } - - // _DEFINE_SWIZZLER2 defines a single such function - // DEFINE_SWIZZLER2_COMP1 defines one-component functions for all component names (x<->r) - // DEFINE_SWIZZLER2_COMP2 defines two component functions for all component names (x<->r) and permutations (xy<->yx) -#define _DEFINE_SWIZZLER2(a, b, name) const Vec2 name() const { return Vec2(a, b); } -#define DEFINE_SWIZZLER2_COMP1(a, a2) \ - _DEFINE_SWIZZLER2(a, a, a##a); \ + T& r() { + return x; + } + T& g() { + return y; + } + T& b() { + return z; + } + T& a() { + return w; + } + + const T& r() const { + return x; + } + const T& g() const { + return y; + } + const T& b() const { + return z; + } + const T& a() const { + return w; + } + +// Swizzlers - Create a subvector of specific components +// e.g. Vec2 uv() { return Vec2(x,y); } + +// _DEFINE_SWIZZLER2 defines a single such function +// DEFINE_SWIZZLER2_COMP1 defines one-component functions for all component names (x<->r) +// DEFINE_SWIZZLER2_COMP2 defines two component functions for all component names (x<->r) and +// permutations (xy<->yx) +#define _DEFINE_SWIZZLER2(a, b, name) \ + const Vec2 name() const { \ + return Vec2(a, b); \ + } +#define DEFINE_SWIZZLER2_COMP1(a, a2) \ + _DEFINE_SWIZZLER2(a, a, a##a); \ _DEFINE_SWIZZLER2(a, a, a2##a2) -#define DEFINE_SWIZZLER2_COMP2(a, b, a2, b2) \ - _DEFINE_SWIZZLER2(a, b, a##b); \ - _DEFINE_SWIZZLER2(a, b, a2##b2); \ - _DEFINE_SWIZZLER2(b, a, b##a); \ +#define DEFINE_SWIZZLER2_COMP2(a, b, a2, b2) \ + _DEFINE_SWIZZLER2(a, b, a##b); \ + _DEFINE_SWIZZLER2(a, b, a2##b2); \ + _DEFINE_SWIZZLER2(b, a, b##a); \ _DEFINE_SWIZZLER2(b, a, b2##a2) DEFINE_SWIZZLER2_COMP2(x, y, r, g); @@ -494,22 +567,25 @@ public: #undef DEFINE_SWIZZLER2_COMP2 #undef _DEFINE_SWIZZLER2 -#define _DEFINE_SWIZZLER3(a, b, c, name) const Vec3 name() const { return Vec3(a, b, c); } -#define DEFINE_SWIZZLER3_COMP1(a, a2) \ - _DEFINE_SWIZZLER3(a, a, a, a##a##a); \ +#define _DEFINE_SWIZZLER3(a, b, c, name) \ + const Vec3 name() const { \ + return Vec3(a, b, c); \ + } +#define DEFINE_SWIZZLER3_COMP1(a, a2) \ + _DEFINE_SWIZZLER3(a, a, a, a##a##a); \ _DEFINE_SWIZZLER3(a, a, a, a2##a2##a2) -#define DEFINE_SWIZZLER3_COMP3(a, b, c, a2, b2, c2) \ - _DEFINE_SWIZZLER3(a, b, c, a##b##c); \ - _DEFINE_SWIZZLER3(a, c, b, a##c##b); \ - _DEFINE_SWIZZLER3(b, a, c, b##a##c); \ - _DEFINE_SWIZZLER3(b, c, a, b##c##a); \ - _DEFINE_SWIZZLER3(c, a, b, c##a##b); \ - _DEFINE_SWIZZLER3(c, b, a, c##b##a); \ - _DEFINE_SWIZZLER3(a, b, c, a2##b2##c2); \ - _DEFINE_SWIZZLER3(a, c, b, a2##c2##b2); \ - _DEFINE_SWIZZLER3(b, a, c, b2##a2##c2); \ - _DEFINE_SWIZZLER3(b, c, a, b2##c2##a2); \ - _DEFINE_SWIZZLER3(c, a, b, c2##a2##b2); \ +#define DEFINE_SWIZZLER3_COMP3(a, b, c, a2, b2, c2) \ + _DEFINE_SWIZZLER3(a, b, c, a##b##c); \ + _DEFINE_SWIZZLER3(a, c, b, a##c##b); \ + _DEFINE_SWIZZLER3(b, a, c, b##a##c); \ + _DEFINE_SWIZZLER3(b, c, a, b##c##a); \ + _DEFINE_SWIZZLER3(c, a, b, c##a##b); \ + _DEFINE_SWIZZLER3(c, b, a, c##b##a); \ + _DEFINE_SWIZZLER3(a, b, c, a2##b2##c2); \ + _DEFINE_SWIZZLER3(a, c, b, a2##c2##b2); \ + _DEFINE_SWIZZLER3(b, a, c, b2##a2##c2); \ + _DEFINE_SWIZZLER3(b, c, a, b2##c2##a2); \ + _DEFINE_SWIZZLER3(c, a, b, c2##a2##b2); \ _DEFINE_SWIZZLER3(c, b, a, c2##b2##a2) DEFINE_SWIZZLER3_COMP3(x, y, z, r, g, b); @@ -525,123 +601,104 @@ public: #undef _DEFINE_SWIZZLER3 }; - -template -Vec4 operator * (const V& f, const Vec4& vec) -{ - return MakeVec(f*vec.x,f*vec.y,f*vec.z,f*vec.w); +template +Vec4 operator*(const V& f, const Vec4& vec) { + return MakeVec(f * vec.x, f * vec.y, f * vec.z, f * vec.w); } typedef Vec4 Vec4f; - -template -static inline decltype(T{}*T{}+T{}*T{}) Dot(const Vec2& a, const Vec2& b) -{ - return a.x*b.x + a.y*b.y; +template +static inline decltype(T{} * T{} + T{} * T{}) Dot(const Vec2& a, const Vec2& b) { + return a.x * b.x + a.y * b.y; } -template -static inline decltype(T{}*T{}+T{}*T{}) Dot(const Vec3& a, const Vec3& b) -{ - return a.x*b.x + a.y*b.y + a.z*b.z; +template +static inline decltype(T{} * T{} + T{} * T{}) Dot(const Vec3& a, const Vec3& b) { + return a.x * b.x + a.y * b.y + a.z * b.z; } -template -static inline decltype(T{}*T{}+T{}*T{}) Dot(const Vec4& a, const Vec4& b) -{ - return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w; +template +static inline decltype(T{} * T{} + T{} * T{}) Dot(const Vec4& a, const Vec4& b) { + return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; } -template -static inline Vec3 Cross(const Vec3& a, const Vec3& b) -{ - return MakeVec(a.y*b.z-a.z*b.y, a.z*b.x-a.x*b.z, a.x*b.y-a.y*b.x); +template +static inline Vec3 Cross(const Vec3& a, const Vec3& b) { + return MakeVec(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x); } // linear interpolation via float: 0.0=begin, 1.0=end -template -static inline decltype(X{}*float{}+X{}*float{}) Lerp(const X& begin, const X& end, const float t) -{ - return begin*(1.f-t) + end*t; +template +static inline decltype(X{} * float{} + X{} * float{}) Lerp(const X& begin, const X& end, + const float t) { + return begin * (1.f - t) + end * t; } // linear interpolation via int: 0=begin, base=end -template -static inline decltype((X{}*int{}+X{}*int{}) / base) LerpInt(const X& begin, const X& end, const int t) -{ - return (begin*(base-t) + end*t) / base; +template +static inline decltype((X{} * int{} + X{} * int{}) / base) LerpInt(const X& begin, const X& end, + const int t) { + return (begin * (base - t) + end * t) / base; } // Utility vector factories -template -static inline Vec2 MakeVec(const T& x, const T& y) -{ +template +static inline Vec2 MakeVec(const T& x, const T& y) { return Vec2{x, y}; } -template -static inline Vec3 MakeVec(const T& x, const T& y, const T& z) -{ +template +static inline Vec3 MakeVec(const T& x, const T& y, const T& z) { return Vec3{x, y, z}; } -template -static inline Vec4 MakeVec(const T& x, const T& y, const Vec2& zw) -{ +template +static inline Vec4 MakeVec(const T& x, const T& y, const Vec2& zw) { return MakeVec(x, y, zw[0], zw[1]); } -template -static inline Vec3 MakeVec(const Vec2& xy, const T& z) -{ +template +static inline Vec3 MakeVec(const Vec2& xy, const T& z) { return MakeVec(xy[0], xy[1], z); } -template -static inline Vec3 MakeVec(const T& x, const Vec2& yz) -{ +template +static inline Vec3 MakeVec(const T& x, const Vec2& yz) { return MakeVec(x, yz[0], yz[1]); } -template -static inline Vec4 MakeVec(const T& x, const T& y, const T& z, const T& w) -{ +template +static inline Vec4 MakeVec(const T& x, const T& y, const T& z, const T& w) { return Vec4{x, y, z, w}; } -template -static inline Vec4 MakeVec(const Vec2& xy, const T& z, const T& w) -{ +template +static inline Vec4 MakeVec(const Vec2& xy, const T& z, const T& w) { return MakeVec(xy[0], xy[1], z, w); } -template -static inline Vec4 MakeVec(const T& x, const Vec2& yz, const T& w) -{ +template +static inline Vec4 MakeVec(const T& x, const Vec2& yz, const T& w) { return MakeVec(x, yz[0], yz[1], w); } // NOTE: This has priority over "Vec2> MakeVec(const Vec2& x, const Vec2& y)". // Even if someone wanted to use an odd object like Vec2>, the compiler would error // out soon enough due to misuse of the returned structure. -template -static inline Vec4 MakeVec(const Vec2& xy, const Vec2& zw) -{ +template +static inline Vec4 MakeVec(const Vec2& xy, const Vec2& zw) { return MakeVec(xy[0], xy[1], zw[0], zw[1]); } -template -static inline Vec4 MakeVec(const Vec3& xyz, const T& w) -{ +template +static inline Vec4 MakeVec(const Vec3& xyz, const T& w) { return MakeVec(xyz[0], xyz[1], xyz[2], w); } -template -static inline Vec4 MakeVec(const T& x, const Vec3& yzw) -{ +template +static inline Vec4 MakeVec(const T& x, const Vec3& yzw) { return MakeVec(x, yzw[0], yzw[1], yzw[2]); } - } // namespace -- cgit v1.2.3