Blender V5.3
gpu_math_test.bsl.hh
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5/* Directive for resetting the line numbering so the failing tests lines can be printed.
6 * This conflict with the shader compiler error logging scheme.
7 * Comment out for correct compilation error line. */
8#line 9
9
10#pragma once
11
13
15
29
30[[compute, local_size(1)]]
32{
33 TEST(math_matrix, MatrixInverse)
34 {
36 float3x3 inv = invert(mat);
37 float3x3 expect = mat3x3_diagonal(0.5f);
38 EXPECT_NEAR(inv, expect, 1e-5f);
39
40 bool success;
41 float3x3 m2 = mat3x3_all(1);
42 float3x3 inv2 = invert(m2, success);
43 float3x3 expect2 = mat3x3_all(0);
44 EXPECT_NEAR(inv2, expect2, 1e-5f);
45 EXPECT_FALSE(success);
46 }
47
48 TEST(math_matrix, MatrixDeterminant)
49 {
50 float2x2 m2 = float2x2(float2(1, 2), float2(3, 4));
51 float3x3 m3 = float3x3(float3(1, 2, 3), float3(-3, 4, -5), float3(5, -6, 7));
52 float4x4 m4 = float4x4(
53 float4(1, 2, -3, 3), float4(3, 4, -5, 3), float4(5, 6, 7, -3), float4(5, 6, 7, 1));
54 EXPECT_NEAR(determinant(m2), -2.0f, 1e-8f);
55 EXPECT_NEAR(determinant(m3), -16.0f, 1e-8f);
56 EXPECT_NEAR(determinant(m4), -112.0f, 1e-8f);
57 }
58
59 TEST(math_matrix, MatrixAdjoint)
60 {
61 float2x2 m2 = float2x2(float2(1, 2), float2(3, 4));
62 float3x3 m3 = float3x3(float3(1, 2, 3), float3(-3, 4, -5), float3(5, -6, 7));
63 float4x4 m4 = float4x4(
64 float4(1, 2, -3, 3), float4(3, 4, -5, 3), float4(5, 6, 7, -3), float4(5, 6, 7, 1));
65 float2x2 expect2 = transpose(float2x2(float2(4, -3), float2(-2, 1)));
66 float3x3 expect3 = transpose(
67 float3x3(float3(-2, -4, -2), float3(-32, -8, 16), float3(-22, -4, 10)));
68 float4x4 expect4 = transpose(float4x4(float4(232, -184, -8, -0),
69 float4(-128, 88, 16, 0),
70 float4(80, -76, 4, 28),
71 float4(-72, 60, -12, -28)));
72 EXPECT_NEAR(adjoint(m2), expect2, 1e-8f);
73 EXPECT_NEAR(adjoint(m3), expect3, 1e-8f);
74 EXPECT_NEAR(adjoint(m4), expect4, 1e-8f);
75 }
76
77 TEST(math_matrix, MatrixInit)
78 {
79 float4x4 expect;
80
81 float4x4 m = from_location(float3(1, 2, 3));
82 expect = float4x4(
83 float4(1, 0, 0, 0), float4(0, 1, 0, 0), float4(0, 0, 1, 0), float4(1, 2, 3, 1));
84 EXPECT_TRUE(is_equal(m, expect, 0.00001f));
85
86 expect = transpose(float4x4(float4(0.411982f, -0.833738f, -0.36763f, 0),
87 float4(-0.0587266f, -0.426918f, 0.902382f, 0),
88 float4(-0.909297f, -0.350175f, -0.224845f, 0),
89 float4(0, 0, 0, 1)));
90 EulerXYZ euler = EulerXYZ{1, 2, 3};
91 Quaternion quat = to_quaternion(euler);
92 AxisAngle axis_angle = to_axis_angle(euler);
93 m = to_float4x4(from_rotation(euler));
94 EXPECT_NEAR(m, expect, 1e-5f);
95 m = to_float4x4(from_rotation(quat));
96 EXPECT_NEAR(m, expect, 1e-5f);
97 m = to_float4x4(from_rotation(axis_angle));
98 EXPECT_NEAR(m, expect, 3e-4f); /* Has some precision issue on some platform. */
99
100 m = from_scale(float4(1, 2, 3, 4));
101 expect = float4x4(
102 float4(1, 0, 0, 0), float4(0, 2, 0, 0), float4(0, 0, 3, 0), float4(0, 0, 0, 4));
103 EXPECT_TRUE(is_equal(m, expect, 0.00001f));
104
105 m = to_float4x4(from_scale(float3(1, 2, 3)));
106 expect = float4x4(
107 float4(1, 0, 0, 0), float4(0, 2, 0, 0), float4(0, 0, 3, 0), float4(0, 0, 0, 1));
108 EXPECT_TRUE(is_equal(m, expect, 0.00001f));
109
110 m = to_float4x4(from_scale(float2(1, 2)));
111 expect = float4x4(
112 float4(1, 0, 0, 0), float4(0, 2, 0, 0), float4(0, 0, 1, 0), float4(0, 0, 0, 1));
113 EXPECT_TRUE(is_equal(m, expect, 0.00001f));
114
115 m = from_loc_rot(float3(1, 2, 3), EulerXYZ{1, 2, 3});
116 expect = float4x4(float4(0.411982f, -0.0587266f, -0.909297f, 0),
117 float4(-0.833738f, -0.426918f, -0.350175f, 0),
118 float4(-0.36763f, 0.902382f, -0.224845f, 0),
119 float4(1, 2, 3, 1));
120 EXPECT_TRUE(is_equal(m, expect, 0.00001f));
121
122 m = from_loc_rot_scale(float3(1, 2, 3), EulerXYZ{1, 2, 3}, float3(1, 2, 3));
123 expect = float4x4(float4(0.411982f, -0.0587266f, -0.909297f, 0),
124 float4(-1.66748f, -0.853835f, -0.700351f, 0),
125 float4(-1.10289f, 2.70714f, -0.674535f, 0),
126 float4(1, 2, 3, 1));
127 EXPECT_TRUE(is_equal(m, expect, 0.00001f));
128 }
129
130 TEST(math_matrix, MatrixModify)
131 {
132 constexpr float epsilon = 1e-6f;
133 float4x4 result, expect;
134 float4x4 m1 = float4x4(
135 float4(0, 3, 0, 0), float4(2, 0, 0, 0), float4(0, 0, 2, 0), float4(0, 0, 0, 1));
136
137 expect = float4x4(
138 float4(0, 3, 0, 0), float4(2, 0, 0, 0), float4(0, 0, 2, 0), float4(4, 9, 2, 1));
139 result = translate(m1, float3(3, 2, 1));
140 EXPECT_NEAR(result, expect, epsilon);
141
142 expect = float4x4(
143 float4(0, 3, 0, 0), float4(2, 0, 0, 0), float4(0, 0, 2, 0), float4(4, 0, 0, 1));
144 result = translate(m1, float2(0, 2));
145 EXPECT_NEAR(result, expect, epsilon);
146
147 expect = float4x4(
148 float4(0, 0, -2, 0), float4(2, 0, 0, 0), float4(0, 3, 0, 0), float4(0, 0, 0, 1));
149 result = rotate(m1, AxisAngle{float3(0, 1, 0), M_PI_2});
150 EXPECT_NEAR(result, expect, epsilon);
151
152 expect = float4x4(
153 float4(0, 9, 0, 0), float4(4, 0, 0, 0), float4(0, 0, 8, 0), float4(0, 0, 0, 1));
154 result = scale(m1, float3(3, 2, 4));
155 EXPECT_NEAR(result, expect, epsilon);
156
157 expect = float4x4(
158 float4(0, 9, 0, 0), float4(4, 0, 0, 0), float4(0, 0, 2, 0), float4(0, 0, 0, 1));
159 result = scale(m1, float2(3, 2));
160 EXPECT_NEAR(result, expect, epsilon);
161 }
162
163 TEST(math_matrix, MatrixCompareTest)
164 {
165 float4x4 m1 = float4x4(
166 float4(0, 3, 0, 0), float4(2, 0, 0, 0), float4(0, 0, 2, 0), float4(0, 0, 0, 1));
167 float4x4 m2 = float4x4(float4(0, 3.001f, 0, 0),
168 float4(1.999f, 0, 0, 0),
169 float4(0, 0, 2.001f, 0),
170 float4(0, 0, 0, 1.001f));
171 float4x4 m3 = float4x4(float4(0, 3.001f, 0, 0),
172 float4(1, 1, 0, 0),
173 float4(0, 0, 2.001f, 0),
174 float4(0, 0, 0, 1.001f));
175 float4x4 m4 = float4x4(
176 float4(0, 1, 0, 0), float4(1, 0, 0, 0), float4(0, 0, 1, 0), float4(0, 0, 0, 1));
177 float4x4 m5 = float4x4(
178 float4(0, 0, 0, 0), float4(0, 0, 0, 0), float4(0, 0, 0, 0), float4(0, 0, 0, 0));
179 float4x4 m6 = float4x4(
180 float4(1, 0, 0, 0), float4(0, 1, 0, 0), float4(0, 0, 1, 0), float4(0, 0, 0, 1));
181 EXPECT_TRUE(is_equal(m1, m2, 0.01f));
182 EXPECT_FALSE(is_equal(m1, m2, 0.0001f));
183 EXPECT_FALSE(is_equal(m1, m3, 0.01f));
192 EXPECT_TRUE(is_zero(m5));
196 }
197
198 TEST(math_matrix, MatrixMethods)
199 {
200 float4x4 m = float4x4(
201 float4(0, 3, 0, 0), float4(2, 0, 0, 0), float4(0, 0, 2, 0), float4(0, 1, 0, 1));
202 EulerXYZ expect_eul = EulerXYZ{0, 0, M_PI_2};
203 Quaternion expect_qt = Quaternion{0, -M_SQRT1_2, M_SQRT1_2, 0};
204 float3 expect_scale = float3(3, 2, 2);
205 float3 expect_location = float3(0, 1, 0);
206
207 EXPECT_NEAR(to_euler(m).as_float3(), expect_eul.as_float3(), 0.0002f);
208 EXPECT_NEAR(to_quaternion(m).as_float4(), expect_qt.as_float4(), 0.0002f);
209 EXPECT_NEAR(to_scale(m), expect_scale, 0.00001f);
210
211 float4 expect_size = float4(3, 2, 2, M_SQRT2);
212 float4 size;
213 float4x4 m1 = normalize_and_get_size(m, size);
215 EXPECT_NEAR(size, expect_size, 0.0002f);
216
217 float4x4 m2 = normalize(m);
219
220 EulerXYZ eul;
221 Quaternion qt;
223 to_rot_scale(to_float3x3(m), eul, scale);
224 to_rot_scale(to_float3x3(m), qt, scale);
225 EXPECT_NEAR(scale, expect_scale, 0.00001f);
226 EXPECT_NEAR(qt.as_float4(), expect_qt.as_float4(), 0.0002f);
227 EXPECT_NEAR(eul.as_float3(), expect_eul.as_float3(), 0.0002f);
228
229 float3 loc;
230 to_loc_rot_scale(m, loc, eul, scale);
231 to_loc_rot_scale(m, loc, qt, scale);
232 EXPECT_NEAR(scale, expect_scale, 0.00001f);
233 EXPECT_NEAR(loc, expect_location, 0.00001f);
234 EXPECT_NEAR(qt.as_float4(), expect_qt.as_float4(), 0.0002f);
235 EXPECT_NEAR(eul.as_float3(), expect_eul.as_float3(), 0.0002f);
236 }
237
238 TEST(math_matrix, MatrixTranspose)
239 {
240 float4x4 m = float4x4(
241 float4(1, 2, 3, 4), float4(5, 6, 7, 8), float4(9, 1, 2, 3), float4(2, 5, 6, 7));
243 float4x4 expect = float4x4(
244 float4(1, 5, 9, 2), float4(2, 6, 1, 5), float4(3, 7, 2, 6), float4(4, 8, 3, 7));
245 /* Split into vector comparison because lack of operator==(matrix,matrix) on metal. */
246 EXPECT_NEAR(transposed[0], expect[0], 0.0f);
247 EXPECT_NEAR(transposed[1], expect[1], 0.0f);
248 EXPECT_NEAR(transposed[2], expect[2], 0.0f);
249 EXPECT_NEAR(transposed[3], expect[3], 0.0f);
250 }
251
252 TEST(math_matrix, MatrixInterpolationRegular)
253 {
254 /* Test 4x4 matrix interpolation without singularity, i.e. without axis flip. */
255
256 /* Transposed matrix, so that the code here is written in the same way as print_m4() outputs.
257 */
258 /* This matrix represents T=(0.1, 0.2, 0.3), R=(40, 50, 60) degrees, S=(0.7, 0.8, 0.9) */
259 float4x4 m2 = transpose(float4x4(float4(0.224976f, -0.333770f, 0.765074f, 0.100000f),
260 float4(0.389669f, 0.647565f, 0.168130f, 0.200000f),
261 float4(-0.536231f, 0.330541f, 0.443163f, 0.300000f),
262 float4(0.000000f, 0.000000f, 0.000000f, 1.000000f)));
264 float4x4 result;
265 constexpr float epsilon = 2e-5f;
266 result = interpolate_fast(m1, m2, 0.0f);
267 EXPECT_NEAR(result, m1, epsilon);
268 result = interpolate_fast(m1, m2, 1.0f);
269 EXPECT_NEAR(result, m2, epsilon);
270
271 /* This matrix is based on the current implementation of the code, and isn't guaranteed to be
272 * correct. It's just consistent with the current implementation. */
273 float4x4 expect = transpose(float4x4(float4(0.690643f, -0.253244f, 0.484996f, 0.050000f),
274 float4(0.271924f, 0.852623f, 0.012348f, 0.100000f),
275 float4(-0.414209f, 0.137484f, 0.816778f, 0.150000f),
276 float4(0.000000f, 0.000000f, 0.000000f, 1.000000f)));
277 result = interpolate_fast(m1, m2, 0.5f);
278 EXPECT_NEAR(result, expect, epsilon);
279 }
280
281 TEST(math_matrix, MatrixTransform)
282 {
283 float3 expect, result;
284 constexpr float3 p = float3(1, 2, 3);
287 float4x4 pers4 = projection_perspective(-0.1f, 0.1f, -0.1f, 0.1f, -0.1f, -1.0f);
288 float3x3 pers3 = float3x3(float3(1, 0, 0.1f), float3(0, 1, 0.1f), float3(0, 0.1f, 1));
289
290 expect = float3(13, 2, -1);
291 result = transform_point(m4, p);
292 EXPECT_NEAR(result, expect, 1e-2f);
293
294 expect = float3(3, 2, -1);
295 result = transform_point(m3, p);
296 EXPECT_NEAR(result, expect, 1e-5f);
297
298 result = transform_direction(m4, p);
299 EXPECT_NEAR(result, expect, 1e-5f);
300
301 result = transform_direction(m3, p);
302 EXPECT_NEAR(result, expect, 1e-5f);
303
304 expect = float3(-0.333333f, -0.666667f, -1.14815f);
305 result = project_point(pers4, p);
306 EXPECT_NEAR(result, expect, 1e-5f);
307
308 float2 expect2 = float2(0.76923f, 1.61538f);
309 float2 result2 = project_point(pers3, p.xy);
310 EXPECT_NEAR(result2, expect2, 1e-5f);
311 }
312
313 TEST(math_matrix, MatrixProjection)
314 {
315 float4x4 expect;
316 float4x4 ortho = projection_orthographic(-0.2f, 0.3f, -0.2f, 0.4f, -0.2f, -0.5f);
317 float4x4 pers1 = projection_perspective(-0.2f, 0.3f, -0.2f, 0.4f, -0.2f, -0.5f);
319 atan(-0.2f), atan(0.3f), atan(-0.2f), atan(0.4f), -0.2f, -0.5f);
320
321 expect = transpose(float4x4(float4(4.0f, 0.0f, 0.0f, -0.2f),
322 float4(0.0f, 3.33333f, 0.0f, -0.333333f),
323 float4(0.0f, 0.0f, 6.66667f, -2.33333f),
324 float4(0.0f, 0.0f, 0.0f, 1.0f)));
325 EXPECT_NEAR(ortho, expect, 1e-5f);
326
327 expect = transpose(float4x4(float4(-0.8f, 0.0f, 0.2f, 0.0f),
328 float4(0.0f, -0.666667f, 0.333333f, 0.0f),
329 float4(0.0f, 0.0f, -2.33333f, 0.666667f),
330 float4(0.0f, 0.0f, -1.0f, 0.0f)));
331 EXPECT_NEAR(pers1, expect, 1e-4f);
332
333 expect = transpose(float4x4(float4(4.0f, 0.0f, 0.2f, 0.0f),
334 float4(0.0f, 3.33333f, 0.333333f, 0.0f),
335 float4(0.0f, 0.0f, -2.33333f, 0.666667f),
336 float4(0.0f, 0.0f, -1.0f, 0.0f)));
337 EXPECT_NEAR(pers2, expect, 1e-4f);
338 }
339
340 TEST(math_matrix, OrderedInt)
341 {
342 /* Identity. */
347
353 }
354}
355
#define M_SQRT2
#define M_PI_2
#define M_SQRT1_2
PipelineCompute gpu_math_test(gpu_math_test_main)
void gpu_math_test_main(const ShaderTestOutput &)
#define resource_table
#define compute
#define local_size(...)
#define atan
b[1] b &&[1] b &&[1] b &&[1] b &&[1] b[3] b &&[1] b[3] float determinant(MatBase< C, R >) RET
VecBase< float, D > normalize(VecOp< float, D >) RET
MatBase< R, C > transpose(MatBase< C, R >) RET
bool is_equal(float a, float b, const float epsilon)
float2x2 invert(float2x2 mat)
float3x3 scale(float3x3 mat, float2 scale)
float4x4 translate(float4x4 mat, float3 translation)
float2x2 adjoint(float2x2 mat)
bool is_unit_scale(float4x4 m)
bool is_zero(float3x3 a)
bool is_orthogonal(float3x3 mat)
bool is_uniformly_scaled(float3x3 mat)
bool is_negative(float3x3 mat)
bool is_orthonormal(float3x3 mat)
float4x4 from_location(float3 location)
float2x2 from_scale(float2 scale)
float4x4 from_loc_rot(float3 location, EulerXYZ rotation)
float2x2 from_rotation(AngleRadian rotation)
float3x3 mat3x3_all(float v)
float4x4 from_loc_rot_scale(float3 location, EulerXYZ rotation, float3 scale)
float3x3 mat3x3_diagonal(float v)
float3 to_scale(float3x3 mat)
float4x4 interpolate_fast(float4x4 a, float4x4 b, float t)
float3x3 normalize_and_get_size(float3x3 mat, float3 &r_size)
float4x4 projection_perspective_fov(float angle_left, float angle_right, float angle_bottom, float angle_top, float near_clip, float far_clip)
Create a perspective projection matrix using OpenGL coordinate convention: Maps each axis range to [-...
float4x4 projection_orthographic(float left, float right, float bottom, float top, float near_clip, float far_clip)
Create an orthographic projection matrix using OpenGL coordinate convention: Maps each axis range to ...
float4x4 projection_perspective(float left, float right, float bottom, float top, float near_clip, float far_clip)
Create a perspective projection matrix using OpenGL coordinate convention: Maps each axis range to [-...
float3 transform_direction(float3x3 mat, float3 direction)
float3 transform_point(float3x3 mat, float3 point)
float2 project_point(float3x3 mat, float2 point)
float3x3 rotate(float3x3 mat, AxisAngle rotation)
Quaternion to_quaternion(EulerXYZ eul)
AxisAngle to_axis_angle(Quaternion quat)
void to_rot_scale(float3x3 mat, EulerXYZ &r_rotation, float3 &r_scale)
EulerXYZ to_euler(float3x3 mat, const bool normalized)
void to_loc_rot_scale(float4x4 mat, float3 &r_location, EulerXYZ &r_rotation, float3 &r_scale)
#define EXPECT_FALSE(result)
#define EXPECT_GE(result, expect)
#define TEST(a, b)
#define EXPECT_TRUE(result)
#define EXPECT_EQ(result, expect)
#define EXPECT_NEAR(result, expect, threshold)
#define EXPECT_LE(result, expect)
int floatBitsToOrderedInt(float value)
float orderedIntBitsToFloat(int int_value)
ccl_device_inline float3x3 transposed(const float3x3 m)
MatBase< float, 2, 2 > float2x2
MatBase< float, 4, 4 > float4x4
float3 as_float3() const