LibGfx: Constexpr Matrices and Vectors

Hendiadyoin1 · awesomekling · commit 1424c4651f91 · 2021-05-08T10:13:22.000+02:00
diff --git a/Userland/Libraries/LibGfx/Matrix.h b/Userland/Libraries/LibGfx/Matrix.h
@@ -16,8 +16,8 @@ class Matrix {
 public:
     static constexpr size_t Size = N;
 
-    Matrix() = default;
-    Matrix(std::initializer_list<T> elements)
+    constexpr Matrix() = default;
+    constexpr Matrix(std::initializer_list<T> elements)
     {
         VERIFY(elements.size() == N * N);
         size_t i = 0;
@@ -28,7 +28,7 @@ class Matrix {
     }
 
     template<typename... Args>
-    Matrix(Args... args)
+    constexpr Matrix(Args... args)
         : Matrix({ (T)args... })
     {
     }
@@ -38,10 +38,10 @@ class Matrix {
         __builtin_memcpy(m_elements, other.elements(), sizeof(T) * N * N);
     }
 
-    auto elements() const { return m_elements; }
-    auto elements() { return m_elements; }
+    constexpr auto elements() const { return m_elements; }
+    constexpr auto elements() { return m_elements; }
 
-    Matrix operator*(const Matrix& other) const
+    constexpr Matrix operator*(const Matrix& other) const
     {
         Matrix product;
         for (int i = 0; i < N; ++i) {
diff --git a/Userland/Libraries/LibGfx/Matrix4x4.h b/Userland/Libraries/LibGfx/Matrix4x4.h
@@ -16,8 +16,8 @@ namespace Gfx {
 template<typename T>
 class Matrix4x4 final : public Matrix<4, T> {
 public:
-    Matrix4x4() = default;
-    Matrix4x4(T _11, T _12, T _13, T _14,
+    constexpr Matrix4x4() = default;
+    constexpr Matrix4x4(T _11, T _12, T _13, T _14,
         T _21, T _22, T _23, T _24,
         T _31, T _32, T _33, T _34,
         T _41, T _42, T _43, T _44)
@@ -30,10 +30,10 @@ class Matrix4x4 final : public Matrix<4, T> {
     {
     }
 
-    auto elements() const { return m_elements; }
-    auto elements() { return m_elements; }
+    constexpr auto elements() const { return m_elements; }
+    constexpr auto elements() { return m_elements; }
 
-    Matrix4x4 operator*(const Matrix4x4& other) const
+    constexpr Matrix4x4 operator*(const Matrix4x4& other) const
     {
         Matrix4x4 product;
         for (int i = 0; i < 4; ++i) {
@@ -47,24 +47,24 @@ class Matrix4x4 final : public Matrix<4, T> {
         return product;
     }
 
-    Vector4<T> operator*(const Vector4<T>& v) const
+    constexpr Vector4<T> operator*(const Vector4<T>& v) const
     {
         return Vector4<T>(
             v.x() * m_elements[0][0] + v.y() * m_elements[1][0] + v.z() * m_elements[2][0] + v.w() * m_elements[3][0],
             v.x() * m_elements[0][1] + v.y() * m_elements[1][1] + v.z() * m_elements[2][1] + v.w() * m_elements[3][1],
             v.x() * m_elements[0][2] + v.y() * m_elements[1][2] + v.z() * m_elements[2][2] + v.w() * m_elements[3][2],
             v.x() * m_elements[0][3] + v.y() * m_elements[1][3] + v.z() * m_elements[2][3] + v.w() * m_elements[3][3]);
     }
-    
-    Vector3<T> transform_point(const Vector3<T>& p) const
+
+    constexpr Vector3<T> transform_point(const Vector3<T>& p) const
     {
         return Vector3<T>(
             p.x() * m_elements[0][0] + p.y() * m_elements[1][0] + p.z() * m_elements[2][0] + m_elements[3][0],
             p.x() * m_elements[0][1] + p.y() * m_elements[1][1] + p.z() * m_elements[2][1] + m_elements[3][1],
             p.x() * m_elements[0][2] + p.y() * m_elements[1][2] + p.z() * m_elements[2][2] + m_elements[3][2]);
     }
 
-    static Matrix4x4 identity()
+    constexpr static Matrix4x4 identity()
     {
         return Matrix4x4(
             1, 0, 0, 0,
@@ -73,7 +73,7 @@ class Matrix4x4 final : public Matrix<4, T> {
             0, 0, 0, 1);
     }
 
-    static Matrix4x4 translate(const Vector3<T>& p)
+    constexpr static Matrix4x4 translate(const Vector3<T>& p)
     {
         return Matrix4x4(
             1, 0, 0, 0,
@@ -82,7 +82,7 @@ class Matrix4x4 final : public Matrix<4, T> {
             p.x(), p.y(), p.z(), 1);
     }
 
-    static Matrix4x4 scale(const Vector3<T>& s)
+    constexpr static Matrix4x4 scale(const Vector3<T>& s)
     {
         return Matrix4x4(
             s.x(), 0, 0, 0,
@@ -91,7 +91,7 @@ class Matrix4x4 final : public Matrix<4, T> {
             0, 0, 0, 1);
     }
 
-    static Matrix4x4 rotate(const Vector3<T>& axis, T angle)
+    constexpr static Matrix4x4 rotate(const Vector3<T>& axis, T angle)
     {
         T c = cos(angle);
         T s = sin(angle);
diff --git a/Userland/Libraries/LibGfx/Vector3.h b/Userland/Libraries/LibGfx/Vector3.h
@@ -12,85 +12,85 @@ namespace Gfx {
 template<typename T>
 class Vector3 final {
 public:
-    Vector3() = default;
-    Vector3(T x, T y, T z)
+    constexpr Vector3() = default;
+    constexpr Vector3(T x, T y, T z)
         : m_x(x)
         , m_y(y)
         , m_z(z)
     {
     }
 
-    T x() const { return m_x; }
-    T y() const { return m_y; }
-    T z() const { return m_z; }
+    constexpr T x() const { return m_x; }
+    constexpr T y() const { return m_y; }
+    constexpr T z() const { return m_z; }
 
-    void set_x(T value) { m_x = value; }
-    void set_y(T value) { m_y = value; }
-    void set_z(T value) { m_z = value; }
+    constexpr void set_x(T value) { m_x = value; }
+    constexpr void set_y(T value) { m_y = value; }
+    constexpr void set_z(T value) { m_z = value; }
 
-    Vector3& operator+=(const Vector3& other)
+    constexpr Vector3& operator+=(const Vector3& other)
     {
         m_x += other.m_x;
         m_y += other.m_y;
         m_z += other.m_z;
         return *this;
     }
 
-    Vector3& operator-=(const Vector3& other)
+    constexpr Vector3& operator-=(const Vector3& other)
     {
         m_x -= other.m_x;
         m_y -= other.m_y;
         m_z -= other.m_z;
         return *this;
     }
 
-    Vector3 operator+(const Vector3& other) const
+    constexpr Vector3 operator+(const Vector3& other) const
     {
         return Vector3(m_x + other.m_x, m_y + other.m_y, m_z + other.m_z);
     }
 
-    Vector3 operator-(const Vector3& other) const
+    constexpr Vector3 operator-(const Vector3& other) const
     {
         return Vector3(m_x - other.m_x, m_y - other.m_y, m_z - other.m_z);
     }
 
-    Vector3 operator*(T f) const
+    constexpr Vector3 operator*(T f) const
     {
         return Vector3(m_x * f, m_y * f, m_z * f);
     }
 
-    Vector3 operator/(T f) const
+    constexpr Vector3 operator/(T f) const
     {
         return Vector3(m_x / f, m_y / f, m_z / f);
     }
 
-    T dot(const Vector3& other) const
+    constexpr T dot(const Vector3& other) const
     {
         return m_x * other.m_x + m_y * other.m_y + m_z * other.m_z;
     }
 
-    Vector3 cross(const Vector3& other) const
+    constexpr Vector3 cross(const Vector3& other) const
     {
         return Vector3(
             m_y * other.m_z - m_z * other.m_y,
             m_z * other.m_x - m_x * other.m_z,
             m_x * other.m_y - m_y * other.m_x);
     }
 
-    Vector3 normalized() const
+    constexpr Vector3 normalized() const
     {
         T inv_length = 1 / length();
         return *this * inv_length;
     }
 
-    Vector3 clamped(T m, T x) const
+    constexpr Vector3 clamped(T m, T x) const
     {
         Vector3 copy { *this };
         copy.clamp(m, x);
         return copy;
     }
 
-    void clamp(T min_value, T max_value)
+    constexpr void clamp(T min_value, T max_value)
     {
         m_x = max(min_value, m_x);
         m_y = max(min_value, m_y);
@@ -100,15 +100,15 @@ class Vector3 final {
         m_z = min(max_value, m_z);
     }
 
-    void normalize()
+    constexpr void normalize()
     {
         T inv_length = 1 / length();
         m_x *= inv_length;
         m_y *= inv_length;
         m_z *= inv_length;
     }
 
-    T length() const
+    constexpr T length() const
     {
         return sqrt(m_x * m_x + m_y * m_y + m_z * m_z);
     }
diff --git a/Userland/Libraries/LibGfx/Vector4.h b/Userland/Libraries/LibGfx/Vector4.h
@@ -12,26 +12,26 @@ namespace Gfx {
 template<typename T>
 class Vector4 final {
 public:
-    Vector4() = default;
-    Vector4(T x, T y, T z, T w)
+    constexpr Vector4() = default;
+    constexpr Vector4(T x, T y, T z, T w)
         : m_x(x)
         , m_y(y)
         , m_z(z)
         , m_w(w)
     {
     }
 
-    T x() const { return m_x; }
-    T y() const { return m_y; }
-    T z() const { return m_z; }
-    T w() const { return m_w; }
+    constexpr T x() const { return m_x; }
+    constexpr T y() const { return m_y; }
+    constexpr T z() const { return m_z; }
+    constexpr T w() const { return m_w; }
 
-    void set_x(T value) { m_x = value; }
-    void set_y(T value) { m_y = value; }
-    void set_z(T value) { m_z = value; }
-    void set_w(T value) { m_w = value; }
+    constexpr void set_x(T value) { m_x = value; }
+    constexpr void set_y(T value) { m_y = value; }
+    constexpr void set_z(T value) { m_z = value; }
+    constexpr void set_w(T value) { m_w = value; }
 
-    Vector4& operator+=(const Vector4& other)
+    constexpr Vector4& operator+=(const Vector4& other)
     {
         m_x += other.m_x;
         m_y += other.m_y;
@@ -40,7 +40,7 @@ class Vector4 final {
         return *this;
     }
 
-    Vector4& operator-=(const Vector4& other)
+    constexpr Vector4& operator-=(const Vector4& other)
     {
         m_x -= other.m_x;
         m_y -= other.m_y;
@@ -49,45 +49,45 @@ class Vector4 final {
         return *this;
     }
 
-    Vector4 operator+(const Vector4& other) const
+    constexpr Vector4 operator+(const Vector4& other) const
     {
         return Vector4(m_x + other.m_x, m_y + other.m_y, m_z + other.m_z, m_w + other.m_w);
     }
 
-    Vector4 operator-(const Vector4& other) const
+    constexpr Vector4 operator-(const Vector4& other) const
     {
         return Vector4(m_x - other.m_x, m_y - other.m_y, m_z - other.m_z, m_w - other.m_w);
     }
 
-    Vector4 operator*(T f) const
+    constexpr Vector4 operator*(T f) const
     {
         return Vector4(m_x * f, m_y * f, m_z * f, m_w * f);
     }
 
-    Vector4 operator/(T f) const
+    constexpr Vector4 operator/(T f) const
     {
         return Vector4(m_x / f, m_y / f, m_z / f, m_w / f);
     }
 
-    T dot(const Vector4& other) const
+    constexpr T dot(const Vector4& other) const
     {
         return m_x * other.m_x + m_y * other.m_y + m_z * other.m_z + m_w * other.m_w;
     }
 
-    Vector4 normalized() const
+    constexpr Vector4 normalized() const
     {
         T inv_length = 1 / length();
         return *this * inv_length;
     }
 
-    Vector4 clamped(T m, T x) const
+    constexpr Vector4 clamped(T m, T x) const
     {
         Vector4 copy { *this };
         copy.clamp(m, x);
         return copy;
     }
 
-    void clamp(T min_value, T max_value)
+    constexpr void clamp(T min_value, T max_value)
     {
         m_x = max(min_value, m_x);
         m_y = max(min_value, m_y);
@@ -99,7 +99,7 @@ class Vector4 final {
         m_w = min(max_value, m_w);
     }
 
-    void normalize()
+    constexpr void normalize()
     {
         T inv_length = 1 / length();
         m_x *= inv_length;
@@ -108,7 +108,7 @@ class Vector4 final {
         m_w *= inv_length;
     }
 
-    T length() const
+    constexpr T length() const
     {
         return sqrt(m_x * m_x + m_y * m_y + m_z * m_z + m_w * m_w);
     }

Original file line number	Diff line number	Diff line change
`@@ -16,8 +16,8 @@ class Matrix {`
`16`	`16`	`public:`
`17`	`17`	`static constexpr size_t Size = N;`
`18`	`18`
`19`		`- Matrix() = default;`
`20`		`- Matrix(std::initializer_list<T> elements)`
	`19`	`+ constexpr Matrix() = default;`
	`20`	`+ constexpr Matrix(std::initializer_list<T> elements)`
`21`	`21`	`{`
`22`	`22`	`VERIFY(elements.size() == N * N);`
`23`	`23`	`size_t i = 0;`
`@@ -28,7 +28,7 @@ class Matrix {`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`template<typename... Args>`
`31`		`- Matrix(Args... args)`
	`31`	`+ constexpr Matrix(Args... args)`
`32`	`32`	`: Matrix({ (T)args... })`
`33`	`33`	`{`
`34`	`34`	`}`
`@@ -38,10 +38,10 @@ class Matrix {`
`38`	`38`	`__builtin_memcpy(m_elements, other.elements(), sizeof(T) * N * N);`
`39`	`39`	`}`
`40`	`40`
`41`		`- auto elements() const { return m_elements; }`
`42`		`- auto elements() { return m_elements; }`
	`41`	`+ constexpr auto elements() const { return m_elements; }`
	`42`	`+ constexpr auto elements() { return m_elements; }`
`43`	`43`
`44`		`- Matrix operator*(const Matrix& other) const`
	`44`	`+ constexpr Matrix operator*(const Matrix& other) const`
`45`	`45`	`{`
`46`	`46`	`Matrix product;`
`47`	`47`	`for (int i = 0; i < N; ++i) {`
Original file line number	Diff line number	Diff line change
`@@ -16,8 +16,8 @@ namespace Gfx {`
`16`	`16`	`template<typename T>`
`17`	`17`	`class Matrix4x4 final : public Matrix<4, T> {`
`18`	`18`	`public:`
`19`		`- Matrix4x4() = default;`
`20`		`- Matrix4x4(T _11, T _12, T _13, T _14,`
	`19`	`+ constexpr Matrix4x4() = default;`
	`20`	`+ constexpr Matrix4x4(T _11, T _12, T _13, T _14,`
`21`	`21`	`T _21, T _22, T _23, T _24,`
`22`	`22`	`T _31, T _32, T _33, T _34,`
`23`	`23`	`T _41, T _42, T _43, T _44)`
`@@ -30,10 +30,10 @@ class Matrix4x4 final : public Matrix<4, T> {`
`30`	`30`	`{`
`31`	`31`	`}`
`32`	`32`
`33`		`- auto elements() const { return m_elements; }`
`34`		`- auto elements() { return m_elements; }`
	`33`	`+ constexpr auto elements() const { return m_elements; }`
	`34`	`+ constexpr auto elements() { return m_elements; }`
`35`	`35`
`36`		`- Matrix4x4 operator*(const Matrix4x4& other) const`
	`36`	`+ constexpr Matrix4x4 operator*(const Matrix4x4& other) const`
`37`	`37`	`{`
`38`	`38`	`Matrix4x4 product;`
`39`	`39`	`for (int i = 0; i < 4; ++i) {`
`@@ -47,24 +47,24 @@ class Matrix4x4 final : public Matrix<4, T> {`
`47`	`47`	`return product;`
`48`	`48`	`}`
`49`	`49`
`50`		`- Vector4<T> operator*(const Vector4<T>& v) const`
	`50`	`+ constexpr Vector4<T> operator*(const Vector4<T>& v) const`
`51`	`51`	`{`
`52`	`52`	`return Vector4<T>(`
`53`	`53`	`v.x() * m_elements[0][0] + v.y() * m_elements[1][0] + v.z() * m_elements[2][0] + v.w() * m_elements[3][0],`
`54`	`54`	`v.x() * m_elements[0][1] + v.y() * m_elements[1][1] + v.z() * m_elements[2][1] + v.w() * m_elements[3][1],`
`55`	`55`	`v.x() * m_elements[0][2] + v.y() * m_elements[1][2] + v.z() * m_elements[2][2] + v.w() * m_elements[3][2],`
`56`	`56`	`v.x() * m_elements[0][3] + v.y() * m_elements[1][3] + v.z() * m_elements[2][3] + v.w() * m_elements[3][3]);`
`57`	`57`	`}`
`58`		`-`
`59`		`- Vector3<T> transform_point(const Vector3<T>& p) const`
	`58`	`+`
	`59`	`+ constexpr Vector3<T> transform_point(const Vector3<T>& p) const`
`60`	`60`	`{`
`61`	`61`	`return Vector3<T>(`
`62`	`62`	`p.x() * m_elements[0][0] + p.y() * m_elements[1][0] + p.z() * m_elements[2][0] + m_elements[3][0],`
`63`	`63`	`p.x() * m_elements[0][1] + p.y() * m_elements[1][1] + p.z() * m_elements[2][1] + m_elements[3][1],`
`64`	`64`	`p.x() * m_elements[0][2] + p.y() * m_elements[1][2] + p.z() * m_elements[2][2] + m_elements[3][2]);`
`65`	`65`	`}`
`66`	`66`
`67`		`- static Matrix4x4 identity()`
	`67`	`+ constexpr static Matrix4x4 identity()`
`68`	`68`	`{`
`69`	`69`	`return Matrix4x4(`
`70`	`70`	`1, 0, 0, 0,`
`@@ -73,7 +73,7 @@ class Matrix4x4 final : public Matrix<4, T> {`
`73`	`73`	`0, 0, 0, 1);`
`74`	`74`	`}`
`75`	`75`
`76`		`- static Matrix4x4 translate(const Vector3<T>& p)`
	`76`	`+ constexpr static Matrix4x4 translate(const Vector3<T>& p)`
`77`	`77`	`{`
`78`	`78`	`return Matrix4x4(`
`79`	`79`	`1, 0, 0, 0,`
`@@ -82,7 +82,7 @@ class Matrix4x4 final : public Matrix<4, T> {`
`82`	`82`	`p.x(), p.y(), p.z(), 1);`
`83`	`83`	`}`
`84`	`84`
`85`		`- static Matrix4x4 scale(const Vector3<T>& s)`
	`85`	`+ constexpr static Matrix4x4 scale(const Vector3<T>& s)`
`86`	`86`	`{`
`87`	`87`	`return Matrix4x4(`
`88`	`88`	`s.x(), 0, 0, 0,`
`@@ -91,7 +91,7 @@ class Matrix4x4 final : public Matrix<4, T> {`
`91`	`91`	`0, 0, 0, 1);`
`92`	`92`	`}`
`93`	`93`
`94`		`- static Matrix4x4 rotate(const Vector3<T>& axis, T angle)`
	`94`	`+ constexpr static Matrix4x4 rotate(const Vector3<T>& axis, T angle)`
`95`	`95`	`{`
`96`	`96`	`T c = cos(angle);`
`97`	`97`	`T s = sin(angle);`
Original file line number	Diff line number	Diff line change
`@@ -12,85 +12,85 @@ namespace Gfx {`
`12`	`12`	`template<typename T>`
`13`	`13`	`class Vector3 final {`
`14`	`14`	`public:`
`15`		`- Vector3() = default;`
`16`		`- Vector3(T x, T y, T z)`
	`15`	`+ constexpr Vector3() = default;`
	`16`	`+ constexpr Vector3(T x, T y, T z)`
`17`	`17`	`: m_x(x)`
`18`	`18`	`, m_y(y)`
`19`	`19`	`, m_z(z)`
`20`	`20`	`{`
`21`	`21`	`}`
`22`	`22`
`23`		`- T x() const { return m_x; }`
`24`		`- T y() const { return m_y; }`
`25`		`- T z() const { return m_z; }`
	`23`	`+ constexpr T x() const { return m_x; }`
	`24`	`+ constexpr T y() const { return m_y; }`
	`25`	`+ constexpr T z() const { return m_z; }`
`26`	`26`
`27`		`- void set_x(T value) { m_x = value; }`
`28`		`- void set_y(T value) { m_y = value; }`
`29`		`- void set_z(T value) { m_z = value; }`
	`27`	`+ constexpr void set_x(T value) { m_x = value; }`
	`28`	`+ constexpr void set_y(T value) { m_y = value; }`
	`29`	`+ constexpr void set_z(T value) { m_z = value; }`
`30`	`30`
`31`		`- Vector3& operator+=(const Vector3& other)`
	`31`	`+ constexpr Vector3& operator+=(const Vector3& other)`
`32`	`32`	`{`
`33`	`33`	`m_x += other.m_x;`
`34`	`34`	`m_y += other.m_y;`
`35`	`35`	`m_z += other.m_z;`
`36`	`36`	`return *this;`
`37`	`37`	`}`
`38`	`38`
`39`		`- Vector3& operator-=(const Vector3& other)`
	`39`	`+ constexpr Vector3& operator-=(const Vector3& other)`
`40`	`40`	`{`
`41`	`41`	`m_x -= other.m_x;`
`42`	`42`	`m_y -= other.m_y;`
`43`	`43`	`m_z -= other.m_z;`
`44`	`44`	`return *this;`
`45`	`45`	`}`
`46`	`46`
`47`		`- Vector3 operator+(const Vector3& other) const`
	`47`	`+ constexpr Vector3 operator+(const Vector3& other) const`
`48`	`48`	`{`
`49`	`49`	`return Vector3(m_x + other.m_x, m_y + other.m_y, m_z + other.m_z);`
`50`	`50`	`}`
`51`	`51`
`52`		`- Vector3 operator-(const Vector3& other) const`
	`52`	`+ constexpr Vector3 operator-(const Vector3& other) const`
`53`	`53`	`{`
`54`	`54`	`return Vector3(m_x - other.m_x, m_y - other.m_y, m_z - other.m_z);`
`55`	`55`	`}`
`56`	`56`
`57`		`- Vector3 operator*(T f) const`
	`57`	`+ constexpr Vector3 operator*(T f) const`
`58`	`58`	`{`
`59`	`59`	`return Vector3(m_x * f, m_y * f, m_z * f);`
`60`	`60`	`}`
`61`	`61`
`62`		`- Vector3 operator/(T f) const`
	`62`	`+ constexpr Vector3 operator/(T f) const`
`63`	`63`	`{`
`64`	`64`	`return Vector3(m_x / f, m_y / f, m_z / f);`
`65`	`65`	`}`
`66`	`66`
`67`		`- T dot(const Vector3& other) const`
	`67`	`+ constexpr T dot(const Vector3& other) const`
`68`	`68`	`{`
`69`	`69`	`return m_x * other.m_x + m_y * other.m_y + m_z * other.m_z;`
`70`	`70`	`}`
`71`	`71`
`72`		`- Vector3 cross(const Vector3& other) const`
	`72`	`+ constexpr Vector3 cross(const Vector3& other) const`
`73`	`73`	`{`
`74`	`74`	`return Vector3(`
`75`	`75`	`m_y * other.m_z - m_z * other.m_y,`
`76`	`76`	`m_z * other.m_x - m_x * other.m_z,`
`77`	`77`	`m_x * other.m_y - m_y * other.m_x);`
`78`	`78`	`}`
`79`	`79`
`80`		`- Vector3 normalized() const`
	`80`	`+ constexpr Vector3 normalized() const`
`81`	`81`	`{`
`82`	`82`	`T inv_length = 1 / length();`
`83`	`83`	`return this inv_length;`
`84`	`84`	`}`
`85`	`85`
`86`		`- Vector3 clamped(T m, T x) const`
	`86`	`+ constexpr Vector3 clamped(T m, T x) const`
`87`	`87`	`{`
`88`	`88`	`Vector3 copy { *this };`
`89`	`89`	`copy.clamp(m, x);`
`90`	`90`	`return copy;`
`91`	`91`	`}`
`92`	`92`
`93`		`- void clamp(T min_value, T max_value)`
	`93`	`+ constexpr void clamp(T min_value, T max_value)`
`94`	`94`	`{`
`95`	`95`	`m_x = max(min_value, m_x);`
`96`	`96`	`m_y = max(min_value, m_y);`
`@@ -100,15 +100,15 @@ class Vector3 final {`
`100`	`100`	`m_z = min(max_value, m_z);`
`101`	`101`	`}`
`102`	`102`
`103`		`- void normalize()`
	`103`	`+ constexpr void normalize()`
`104`	`104`	`{`
`105`	`105`	`T inv_length = 1 / length();`
`106`	`106`	`m_x *= inv_length;`
`107`	`107`	`m_y *= inv_length;`
`108`	`108`	`m_z *= inv_length;`
`109`	`109`	`}`
`110`	`110`
`111`		`- T length() const`
	`111`	`+ constexpr T length() const`
`112`	`112`	`{`
`113`	`113`	`return sqrt(m_x * m_x + m_y * m_y + m_z * m_z);`
`114`	`114`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,26 +12,26 @@ namespace Gfx {`
`12`	`12`	`template<typename T>`
`13`	`13`	`class Vector4 final {`
`14`	`14`	`public:`
`15`		`- Vector4() = default;`
`16`		`- Vector4(T x, T y, T z, T w)`
	`15`	`+ constexpr Vector4() = default;`
	`16`	`+ constexpr Vector4(T x, T y, T z, T w)`
`17`	`17`	`: m_x(x)`
`18`	`18`	`, m_y(y)`
`19`	`19`	`, m_z(z)`
`20`	`20`	`, m_w(w)`
`21`	`21`	`{`
`22`	`22`	`}`
`23`	`23`
`24`		`- T x() const { return m_x; }`
`25`		`- T y() const { return m_y; }`
`26`		`- T z() const { return m_z; }`
`27`		`- T w() const { return m_w; }`
	`24`	`+ constexpr T x() const { return m_x; }`
	`25`	`+ constexpr T y() const { return m_y; }`
	`26`	`+ constexpr T z() const { return m_z; }`
	`27`	`+ constexpr T w() const { return m_w; }`
`28`	`28`
`29`		`- void set_x(T value) { m_x = value; }`
`30`		`- void set_y(T value) { m_y = value; }`
`31`		`- void set_z(T value) { m_z = value; }`
`32`		`- void set_w(T value) { m_w = value; }`
	`29`	`+ constexpr void set_x(T value) { m_x = value; }`
	`30`	`+ constexpr void set_y(T value) { m_y = value; }`
	`31`	`+ constexpr void set_z(T value) { m_z = value; }`
	`32`	`+ constexpr void set_w(T value) { m_w = value; }`
`33`	`33`
`34`		`- Vector4& operator+=(const Vector4& other)`
	`34`	`+ constexpr Vector4& operator+=(const Vector4& other)`
`35`	`35`	`{`
`36`	`36`	`m_x += other.m_x;`
`37`	`37`	`m_y += other.m_y;`
`@@ -40,7 +40,7 @@ class Vector4 final {`
`40`	`40`	`return *this;`
`41`	`41`	`}`
`42`	`42`
`43`		`- Vector4& operator-=(const Vector4& other)`
	`43`	`+ constexpr Vector4& operator-=(const Vector4& other)`
`44`	`44`	`{`
`45`	`45`	`m_x -= other.m_x;`
`46`	`46`	`m_y -= other.m_y;`
`@@ -49,45 +49,45 @@ class Vector4 final {`
`49`	`49`	`return *this;`
`50`	`50`	`}`
`51`	`51`
`52`		`- Vector4 operator+(const Vector4& other) const`
	`52`	`+ constexpr Vector4 operator+(const Vector4& other) const`
`53`	`53`	`{`
`54`	`54`	`return Vector4(m_x + other.m_x, m_y + other.m_y, m_z + other.m_z, m_w + other.m_w);`
`55`	`55`	`}`
`56`	`56`
`57`		`- Vector4 operator-(const Vector4& other) const`
	`57`	`+ constexpr Vector4 operator-(const Vector4& other) const`
`58`	`58`	`{`
`59`	`59`	`return Vector4(m_x - other.m_x, m_y - other.m_y, m_z - other.m_z, m_w - other.m_w);`
`60`	`60`	`}`
`61`	`61`
`62`		`- Vector4 operator*(T f) const`
	`62`	`+ constexpr Vector4 operator*(T f) const`
`63`	`63`	`{`
`64`	`64`	`return Vector4(m_x * f, m_y * f, m_z * f, m_w * f);`
`65`	`65`	`}`
`66`	`66`
`67`		`- Vector4 operator/(T f) const`
	`67`	`+ constexpr Vector4 operator/(T f) const`
`68`	`68`	`{`
`69`	`69`	`return Vector4(m_x / f, m_y / f, m_z / f, m_w / f);`
`70`	`70`	`}`
`71`	`71`
`72`		`- T dot(const Vector4& other) const`
	`72`	`+ constexpr T dot(const Vector4& other) const`
`73`	`73`	`{`
`74`	`74`	`return m_x * other.m_x + m_y * other.m_y + m_z * other.m_z + m_w * other.m_w;`
`75`	`75`	`}`
`76`	`76`
`77`		`- Vector4 normalized() const`
	`77`	`+ constexpr Vector4 normalized() const`
`78`	`78`	`{`
`79`	`79`	`T inv_length = 1 / length();`
`80`	`80`	`return this inv_length;`
`81`	`81`	`}`
`82`	`82`
`83`		`- Vector4 clamped(T m, T x) const`
	`83`	`+ constexpr Vector4 clamped(T m, T x) const`
`84`	`84`	`{`
`85`	`85`	`Vector4 copy { *this };`
`86`	`86`	`copy.clamp(m, x);`
`87`	`87`	`return copy;`
`88`	`88`	`}`
`89`	`89`
`90`		`- void clamp(T min_value, T max_value)`
	`90`	`+ constexpr void clamp(T min_value, T max_value)`
`91`	`91`	`{`
`92`	`92`	`m_x = max(min_value, m_x);`
`93`	`93`	`m_y = max(min_value, m_y);`
`@@ -99,7 +99,7 @@ class Vector4 final {`
`99`	`99`	`m_w = min(max_value, m_w);`
`100`	`100`	`}`
`101`	`101`
`102`		`- void normalize()`
	`102`	`+ constexpr void normalize()`
`103`	`103`	`{`
`104`	`104`	`T inv_length = 1 / length();`
`105`	`105`	`m_x *= inv_length;`
`@@ -108,7 +108,7 @@ class Vector4 final {`
`108`	`108`	`m_w *= inv_length;`
`109`	`109`	`}`
`110`	`110`
`111`		`- T length() const`
	`111`	`+ constexpr T length() const`
`112`	`112`	`{`
`113`	`113`	`return sqrt(m_x * m_x + m_y * m_y + m_z * m_z + m_w * m_w);`
`114`	`114`	`}`