Fri, 13 Dec 2019 21:35:59 +0200
things
3 | 1 | /* |
2 | * LDForge: LDraw parts authoring CAD | |
3 | * Copyright(C) 2013 - 2018 Teemu Piippo | |
4 | * | |
5 | * This program is free software: you can redistribute it and/or modify | |
6 | * it under the terms of the GNU General Public License as published by | |
7 | * the Free Software Foundation, either version 3 of the License, or | |
8 | * (at your option) any later version. | |
9 | * | |
10 | * This program is distributed in the hope that it will be useful, | |
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | * GNU General Public License for more details. | |
14 | * | |
15 | * You should have received a copy of the GNU General Public License | |
16 | * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
17 | */ | |
18 | ||
19 | #include "main.h" | |
20 | #include "vertex.h" | |
21 | ||
22 | /* | |
23 | void Vertex::transform(const Matrix& matrix, const Vertex& pos) | |
24 | { | |
25 | double x2 = (matrix(0, 0) * x) + (matrix(0, 1) * y) + (matrix(0, 2) * z) + pos.x; | |
26 | double y2 = (matrix(1, 0) * x) + (matrix(1, 1) * y) + (matrix(1, 2) * z) + pos.y; | |
27 | double z2 = (matrix(2, 0) * x) + (matrix(2, 1) * y) + (matrix(2, 2) * z) + pos.z; | |
28 | this->x = x2; | |
29 | this->y = y2; | |
30 | this->z = z2; | |
31 | } | |
32 | */ | |
33 | ||
18 | 34 | Point3D::CoordinateType& Point3D::get(Axis axis) |
3 | 35 | { |
36 | switch (axis) | |
37 | { | |
38 | case X: | |
39 | return this->x; | |
40 | case Y: | |
41 | return this->y; | |
42 | case Z: | |
43 | return this->z; | |
44 | default: | |
45 | throw std::runtime_error("Non-axis given to Vertex::operator[]"); | |
46 | } | |
47 | } | |
48 | ||
18 | 49 | Point3D::CoordinateType Point3D::get(Axis axis) const |
3 | 50 | { |
51 | switch (axis) | |
52 | { | |
53 | case X: | |
54 | return this->x; | |
55 | case Y: | |
56 | return this->y; | |
57 | case Z: | |
58 | return this->z; | |
59 | default: | |
5 | 60 | return 0; |
3 | 61 | } |
62 | } | |
63 | ||
18 | 64 | void Point3D::assign(Axis axis, CoordinateType value) |
3 | 65 | { |
18 | 66 | this->get(axis) = value; |
3 | 67 | } |
68 | ||
18 | 69 | Point3D VertexFromVector(const QVector3D& vector) |
3 | 70 | { |
71 | return {vector.x(), vector.y(), vector.z()}; | |
72 | } | |
73 | ||
18 | 74 | Point3D operator*(const Point3D& point, Point3D::CoordinateType scalar) |
3 | 75 | { |
18 | 76 | return {point.x * scalar, point.y * scalar, point.z * scalar}; |
3 | 77 | } |
78 | ||
18 | 79 | Point3D& operator+=(Point3D& point, const QVector3D& other) |
3 | 80 | { |
18 | 81 | point.x += other.x(); |
82 | point.y += other.y(); | |
83 | point.z += other.z(); | |
84 | return point; | |
3 | 85 | } |
86 | ||
18 | 87 | Point3D operator+(Point3D point, const QVector3D& other) |
3 | 88 | { |
18 | 89 | point += other; |
90 | return point; | |
3 | 91 | } |
92 | ||
93 | ||
18 | 94 | QVector3D vertexToVector(const Point3D& vertex) |
3 | 95 | { |
96 | return { | |
97 | static_cast<float>(vertex.x), | |
98 | static_cast<float>(vertex.y), | |
99 | static_cast<float>(vertex.z) | |
100 | }; | |
101 | } | |
102 | ||
18 | 103 | Point3D operator-(Point3D point, const QVector3D& vector) |
3 | 104 | { |
18 | 105 | point -= vector; |
106 | return point; | |
3 | 107 | } |
108 | ||
18 | 109 | Point3D& operator-=(Point3D& point, const QVector3D& vector) |
3 | 110 | { |
18 | 111 | point.x -= vector.x(); |
112 | point.y -= vector.y(); | |
113 | point.z -= vector.z(); | |
114 | return point; | |
3 | 115 | } |
116 | ||
18 | 117 | QVector3D operator-(const Point3D& point, const Point3D& other) |
3 | 118 | { |
119 | return { | |
18 | 120 | static_cast<float>(point.x - other.x), |
121 | static_cast<float>(point.y - other.y), | |
122 | static_cast<float>(point.z - other.z) | |
3 | 123 | }; |
124 | } | |
125 | ||
18 | 126 | Point3D& operator*=(Point3D& point, Point3D::CoordinateType scalar) |
3 | 127 | { |
18 | 128 | point.x *= scalar; |
129 | point.y *= scalar; | |
130 | point.z *= scalar; | |
131 | return point; | |
3 | 132 | } |
133 | ||
18 | 134 | bool operator==(const Point3D& point, const Point3D& other) |
3 | 135 | { |
18 | 136 | return point.x == other.x and point.y == other.y and point.z == other.z; |
3 | 137 | } |
138 | ||
18 | 139 | bool operator!=(const Point3D& point, const Point3D& other) |
3 | 140 | { |
18 | 141 | return not (point == other); |
3 | 142 | } |
143 | ||
18 | 144 | bool operator<(const Point3D& point, const Point3D& other) |
3 | 145 | { |
18 | 146 | if (not qFuzzyCompare(point.x, other.x)) |
147 | return point.x < other.x; | |
148 | else if (not qFuzzyCompare(point.y, other.y)) | |
149 | return point.y < other.y; | |
3 | 150 | else |
18 | 151 | return point.z < other.z; |
3 | 152 | } |
153 | ||
154 | /* | |
155 | * Transforms this vertex with a tranformation matrix and returns the result. | |
156 | */ | |
18 | 157 | Point3D math::transform(const Point3D point, const GLRotationMatrix& matrix) |
3 | 158 | { |
159 | return { | |
18 | 160 | matrix(0, 0) * point.x |
161 | + matrix(0, 1) * point.y | |
162 | + matrix(0, 2) * point.z, | |
163 | matrix(1, 0) * point.x | |
164 | + matrix(1, 1) * point.y | |
165 | + matrix(1, 2) * point.z, | |
166 | matrix(2, 0) * point.x | |
167 | + matrix(2, 1) * point.y | |
168 | + matrix(2, 2) * point.z, | |
3 | 169 | }; |
170 | } | |
171 | ||
172 | /* | |
173 | * Returns the distance from one vertex to another. | |
174 | */ | |
18 | 175 | qreal math::distance(const Point3D& one, const Point3D& other) |
3 | 176 | { |
177 | return (one - other).length(); | |
178 | } | |
179 | ||
180 | /* | |
181 | * Returns a vertex with all coordinates inverted. | |
182 | */ | |
18 | 183 | Point3D operator-(const Point3D& vertex) |
3 | 184 | { |
185 | return {-vertex.x, -vertex.y, -vertex.z}; | |
186 | } | |
187 | ||
188 | /* | |
189 | * Inserts this vertex into a data stream. This is needed for vertices to be | |
190 | * stored in QSettings. | |
191 | */ | |
18 | 192 | QDataStream& operator<<(QDataStream& out, const Point3D& vertex) |
3 | 193 | { |
194 | return out << vertex.x << vertex.y << vertex.z; | |
195 | } | |
196 | ||
197 | /* | |
198 | * Takes a vertex from a data stream. | |
199 | */ | |
18 | 200 | QDataStream& operator>>(QDataStream& in, Point3D& vertex) |
3 | 201 | { |
202 | return in >> vertex.x >> vertex.y >> vertex.z; | |
203 | } | |
204 | ||
18 | 205 | unsigned int qHash(const Point3D& key) |
3 | 206 | { |
8
44679e468ba9
major update with many things
Teemu Piippo <teemu@hecknology.net>
parents:
6
diff
changeset
|
207 | return qHash(key.x) ^ utility::rotl10(qHash(key.y)) ^ utility::rotl20(qHash(key.z)); |
3 | 208 | } |
6 | 209 | |
18 | 210 | QString vertexToStringParens(const Point3D& vertex) |
6 | 211 | { |
8
44679e468ba9
major update with many things
Teemu Piippo <teemu@hecknology.net>
parents:
6
diff
changeset
|
212 | return utility::format("(%1, %2, %3)", vertex.x, vertex.y, vertex.z); |
6 | 213 | } |