1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
/*
* Copyright (c) 2021, Stephan Unverwerth <s.unverwerth@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Math.h>
#include <AK/String.h>
namespace Gfx {
template<typename T>
class Vector4 final {
public:
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)
{
}
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; }
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; }
constexpr Vector4& operator+=(const Vector4& other)
{
m_x += other.m_x;
m_y += other.m_y;
m_z += other.m_z;
m_w += other.m_w;
return *this;
}
constexpr Vector4& operator-=(const Vector4& other)
{
m_x -= other.m_x;
m_y -= other.m_y;
m_z -= other.m_z;
m_w -= other.m_w;
return *this;
}
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);
}
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);
}
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);
}
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);
}
constexpr Vector4 operator*(T f) const
{
return Vector4(m_x * f, m_y * f, m_z * f, m_w * f);
}
constexpr Vector4 operator/(T f) const
{
return Vector4(m_x / f, m_y / f, m_z / f, m_w / f);
}
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;
}
constexpr Vector4 normalized() const
{
T inv_length = 1 / length();
return *this * inv_length;
}
constexpr Vector4 clamped(T m, T x) const
{
Vector4 copy { *this };
copy.clamp(m, x);
return copy;
}
constexpr void clamp(T min_value, T max_value)
{
m_x = max(min_value, m_x);
m_y = max(min_value, m_y);
m_z = max(min_value, m_z);
m_w = max(min_value, m_w);
m_x = min(max_value, m_x);
m_y = min(max_value, m_y);
m_z = min(max_value, m_z);
m_w = min(max_value, m_w);
}
constexpr void normalize()
{
T inv_length = 1 / length();
m_x *= inv_length;
m_y *= inv_length;
m_z *= inv_length;
m_w *= inv_length;
}
constexpr T length() const
{
return AK::sqrt(m_x * m_x + m_y * m_y + m_z * m_z + m_w * m_w);
}
String to_string() const
{
return String::formatted("[{},{},{},{}]", x(), y(), z(), w());
}
private:
T m_x;
T m_y;
T m_z;
T m_w;
};
typedef Vector4<float> FloatVector4;
typedef Vector4<double> DoubleVector4;
}
namespace AK {
template<typename T>
struct Formatter<Gfx::Vector4<T>> : Formatter<StringView> {
void format(FormatBuilder& builder, const Gfx::Vector4<T>& value)
{
Formatter<StringView>::format(builder, value.to_string());
}
};
}
using Gfx::DoubleVector4;
using Gfx::FloatVector4;
using Gfx::Vector4;
|
