CoCalc -- test_copy_transform_modifier

GitHub Repository: godotengine/godot
Path: blob/master/tests/scene/test_copy_transform_modifier_3d.cpp
⁴⁵⁹⁹¹ views
1
/**************************************************************************/
2
/*  test_copy_transform_modifier_3d.cpp                                   */
3
/**************************************************************************/
4
/*                         This file is part of:                          */
5
/*                             GODOT ENGINE                               */
6
/*                        https://godotengine.org                         */
7
/**************************************************************************/
8
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
9
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
10
/*                                                                        */
11
/* Permission is hereby granted, free of charge, to any person obtaining  */
12
/* a copy of this software and associated documentation files (the        */
13
/* "Software"), to deal in the Software without restriction, including    */
14
/* without limitation the rights to use, copy, modify, merge, publish,    */
15
/* distribute, sublicense, and/or sell copies of the Software, and to     */
16
/* permit persons to whom the Software is furnished to do so, subject to  */
17
/* the following conditions:                                              */
18
/*                                                                        */
19
/* The above copyright notice and this permission notice shall be         */
20
/* included in all copies or substantial portions of the Software.        */
21
/*                                                                        */
22
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
23
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
24
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
25
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
26
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
27
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
28
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
29
/**************************************************************************/
30

31
#include "tests/test_macros.h"
32

33
TEST_FORCE_LINK(test_copy_transform_modifier_3d)
34

35
#ifndef _3D_DISABLED
36

37
#include "core/math/random_number_generator.h"
38
#include "scene/3d/bone_attachment_3d.h"
39
#include "scene/3d/copy_transform_modifier_3d.h"
40
#include "scene/main/scene_tree.h"
41
#include "scene/main/window.h"
42

43
namespace TestCopyTransformModifier3D {
44

45
Transform3D make_random_transform_3d(int p_seed) {
46
	RandomNumberGenerator rng;
47
	rng.set_seed(p_seed);
48

49
	Vector3 pos;
50
	pos.x = rng.randf_range(-10.0, 10.0);
51
	rng.set_seed(++p_seed);
52
	pos.y = rng.randf_range(-10.0, 10.0);
53
	rng.set_seed(++p_seed);
54
	pos.z = rng.randf_range(-10.0, 10.0);
55
	rng.set_seed(++p_seed);
56

57
	Quaternion rot;
58
	rot.x = rng.randf_range(-1.0, 1.0);
59
	rng.set_seed(++p_seed);
60
	rot.y = rng.randf_range(-1.0, 1.0);
61
	rng.set_seed(++p_seed);
62
	rot.z = rng.randf_range(-1.0, 1.0);
63
	rng.set_seed(++p_seed);
64
	rot.w = rng.randf_range(-1.0, 1.0);
65
	rng.set_seed(++p_seed);
66
	rot = rot.normalized();
67

68
	Vector3 scl;
69
	scl.x = rng.randf_range(0.5, 2.0);
70
	rng.set_seed(++p_seed);
71
	scl.y = rng.randf_range(0.5, 2.0);
72
	rng.set_seed(++p_seed);
73
	scl.z = rng.randf_range(0.5, 2.0);
74
	rng.set_seed(++p_seed);
75

76
	return Transform3D(Basis(rot).scaled(scl), pos);
77
}
78

79
Vector3 flip_x(Vector3 p_pos) {
80
	return Vector3(-p_pos.x, p_pos.y, p_pos.z);
81
}
82

83
Vector3 flip_xy(Vector3 p_pos) {
84
	return Vector3(-p_pos.x, -p_pos.y, p_pos.z);
85
}
86

87
Vector3 flip_all(Vector3 p_pos) {
88
	return -p_pos;
89
}
90

91
// Quaternion's phase can be confused by inversion, it is aligned via casting to Basis.
92

93
Quaternion flip_x(Quaternion p_rot) {
94
	return Basis(Quaternion(-p_rot.x, p_rot.y, p_rot.z, p_rot.w).normalized()).get_rotation_quaternion();
95
}
96

97
Quaternion flip_xy(Quaternion p_rot) {
98
	return Basis(Quaternion(-p_rot.x, -p_rot.y, p_rot.z, p_rot.w).normalized()).get_rotation_quaternion();
99
}
100

101
Quaternion flip_all(Quaternion p_rot) {
102
	return Basis(p_rot.inverse()).get_rotation_quaternion();
103
}
104

105
Vector3 inv_x(Vector3 p_scl) {
106
	return Vector3(1.0 / p_scl.x, p_scl.y, p_scl.z);
107
}
108

109
Vector3 inv_xy(Vector3 p_scl) {
110
	return Vector3(1.0 / p_scl.x, 1.0 / p_scl.y, p_scl.z);
111
}
112

113
Vector3 inv_all(Vector3 p_scl) {
114
	return Vector3(1.0, 1.0, 1.0) / p_scl;
115
}
116

117
TEST_CASE("[SceneTree][CopyTransformModifier3D]") {
118
	SceneTree *tree = SceneTree::get_singleton();
119
	int seed = 12345;
120
	Skeleton3D *skeleton = memnew(Skeleton3D);
121
	CopyTransformModifier3D *mod = memnew(CopyTransformModifier3D);
122

123
	// Instead of awaiting the process to wait to finish deferred process and watch "skeleton_updated" signal,
124
	// force notify NOTIFICATION_UPDATE_SKELETON and get the modified pose from the BoneAttachment's transform.
125
	BoneAttachment3D *modified = memnew(BoneAttachment3D);
126

127
	tree->get_root()->add_child(skeleton);
128

129
	int root = skeleton->add_bone("root");
130
	skeleton->set_bone_rest(root, make_random_transform_3d(++seed));
131
	skeleton->set_bone_pose(root, make_random_transform_3d(++seed));
132

133
	int apl_root = skeleton->add_bone("apl_root");
134
	skeleton->set_bone_parent(apl_root, root);
135
	skeleton->set_bone_rest(apl_root, make_random_transform_3d(++seed));
136
	skeleton->set_bone_pose(apl_root, make_random_transform_3d(++seed));
137

138
	int apl_bone = skeleton->add_bone("apl_bone");
139
	skeleton->set_bone_parent(apl_bone, apl_root);
140
	skeleton->set_bone_rest(apl_bone, make_random_transform_3d(++seed));
141
	skeleton->set_bone_pose(apl_bone, make_random_transform_3d(++seed));
142

143
	int tgt_root = skeleton->add_bone("tgt_root");
144
	skeleton->set_bone_parent(tgt_root, root);
145
	skeleton->set_bone_rest(tgt_root, make_random_transform_3d(++seed));
146
	skeleton->set_bone_pose(tgt_root, make_random_transform_3d(++seed));
147

148
	int tgt_bone = skeleton->add_bone("tgt_bone");
149
	skeleton->set_bone_parent(tgt_bone, tgt_root);
150
	skeleton->set_bone_rest(tgt_bone, make_random_transform_3d(++seed));
151
	skeleton->set_bone_pose(tgt_bone, make_random_transform_3d(++seed));
152

153
	skeleton->add_child(mod);
154
	skeleton->add_child(modified);
155
	modified->set_rotation_edit_mode(Node3D::ROTATION_EDIT_MODE_QUATERNION);
156
	modified->set_bone_idx(apl_bone);
157

158
	mod->set_setting_count(1);
159
	mod->set_reference_bone(0, tgt_bone);
160
	mod->set_apply_bone(0, apl_bone);
161

162
	mod->set_copy_position(0, true);
163
	mod->set_copy_rotation(0, true);
164
	mod->set_copy_scale(0, true);
165

166
	// ===== [CopyTransformModifier3D] Enable 1 axis =====
167
	mod->set_axis_x_enabled(0, true);
168
	mod->set_axis_y_enabled(0, false);
169
	mod->set_axis_z_enabled(0, false);
170
	mod->set_axis_x_inverted(0, false);
171
	mod->set_axis_y_inverted(0, false);
172
	mod->set_axis_z_inverted(0, false);
173

174
	SUBCASE("[CopyTransformModifier3D] Enable 1 axis, additive=false, relative=false") {
175
		mod->set_additive(0, false);
176
		mod->set_relative(0, false);
177
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
178
		CHECK_MESSAGE(Math::is_equal_approx(
179
							  skeleton->get_bone_pose_position(tgt_bone).x,
180
							  (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin.x),
181
				"Position x is copied correctly.");
182
		CHECK_MESSAGE(Math::is_equal_approx(
183
							  BoneConstraint3D::get_roll_angle(skeleton->get_bone_pose_rotation(tgt_bone), BoneConstraint3D::get_vector_from_axis(Vector3::AXIS_X)),
184
							  BoneConstraint3D::get_roll_angle((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion(), BoneConstraint3D::get_vector_from_axis(Vector3::AXIS_X))),
185
				"Rotation x (roll x) is copied correctly.");
186
		CHECK_MESSAGE(Math::is_equal_approx(
187
							  skeleton->get_bone_pose_scale(tgt_bone).x,
188
							  (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale().x),
189
				"Scale x is copied correctly.");
190
	}
191

192
	SUBCASE("[CopyTransformModifier3D] Enable 1 axis, additive=true, relative=false") {
193
		mod->set_additive(0, true);
194
		mod->set_relative(0, false);
195
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
196
		CHECK_MESSAGE(Math::is_equal_approx(
197
							  skeleton->get_bone_pose_position(tgt_bone).x,
198
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_pose_position(apl_bone)).x),
199
				"Position x is copied correctly.");
200
		CHECK_MESSAGE(Math::is_equal_approx(
201
							  BoneConstraint3D::get_roll_angle(skeleton->get_bone_pose_rotation(tgt_bone), BoneConstraint3D::get_vector_from_axis(Vector3::AXIS_X)),
202
							  BoneConstraint3D::get_roll_angle(skeleton->get_bone_pose_rotation(apl_bone).inverse() * (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion(), BoneConstraint3D::get_vector_from_axis(Vector3::AXIS_X))),
203
				"Rotation x (roll x) is copied correctly.");
204
		CHECK_MESSAGE(Math::is_equal_approx(
205
							  skeleton->get_bone_pose_scale(tgt_bone).x,
206
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_pose_scale(apl_bone)).x),
207
				"Scale x is copied correctly.");
208
	}
209

210
	SUBCASE("[CopyTransformModifier3D] Enable 1 axis, additive=false, relative=true") {
211
		mod->set_additive(0, false);
212
		mod->set_relative(0, true);
213
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
214
		CHECK_MESSAGE(Math::is_equal_approx(
215
							  (skeleton->get_bone_pose_position(tgt_bone) - skeleton->get_bone_rest(tgt_bone).origin).x,
216
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_rest(apl_bone).origin).x),
217
				"Position x is copied correctly.");
218
		CHECK_MESSAGE(Math::is_equal_approx(
219
							  BoneConstraint3D::get_roll_angle(skeleton->get_bone_rest(tgt_bone).basis.get_rotation_quaternion().inverse() * skeleton->get_bone_pose_rotation(tgt_bone), BoneConstraint3D::get_vector_from_axis(Vector3::AXIS_X)),
220
							  BoneConstraint3D::get_roll_angle(skeleton->get_bone_rest(apl_bone).basis.get_rotation_quaternion().inverse() * (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion(), BoneConstraint3D::get_vector_from_axis(Vector3::AXIS_X))),
221
				"Rotation x (roll x) is copied correctly.");
222
		CHECK_MESSAGE(Math::is_equal_approx(
223
							  (skeleton->get_bone_pose_scale(tgt_bone) / skeleton->get_bone_rest(tgt_bone).basis.get_scale()).x,
224
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_rest(apl_bone).basis.get_scale()).x),
225
				"Scale x is copied correctly.");
226
	}
227

228
	SUBCASE("[CopyTransformModifier3D] Enable 1 axis, additive=true, relative=true") {
229
		mod->set_additive(0, true);
230
		mod->set_relative(0, true);
231
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
232
		CHECK_MESSAGE(Math::is_equal_approx(
233
							  (skeleton->get_bone_pose_position(tgt_bone) - skeleton->get_bone_rest(tgt_bone).origin).x,
234
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_pose_position(apl_bone)).x),
235
				"Position x is copied correctly.");
236
		CHECK_MESSAGE(Math::is_equal_approx(
237
							  BoneConstraint3D::get_roll_angle(skeleton->get_bone_rest(tgt_bone).basis.get_rotation_quaternion().inverse() * skeleton->get_bone_pose_rotation(tgt_bone), BoneConstraint3D::get_vector_from_axis(Vector3::AXIS_X)),
238
							  BoneConstraint3D::get_roll_angle(skeleton->get_bone_pose_rotation(apl_bone).inverse() * (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion(), BoneConstraint3D::get_vector_from_axis(Vector3::AXIS_X))),
239
				"Rotation x (roll x) is copied correctly.");
240
		CHECK_MESSAGE(Math::is_equal_approx(
241
							  (skeleton->get_bone_pose_scale(tgt_bone) / skeleton->get_bone_rest(tgt_bone).basis.get_scale()).x,
242
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_pose_scale(apl_bone)).x),
243
				"Scale x is copied correctly.");
244
	}
245

246
	// ===== [CopyTransformModifier3D] Enable 2 axes =====
247
	mod->set_axis_x_enabled(0, true);
248
	mod->set_axis_y_enabled(0, true);
249
	mod->set_axis_z_enabled(0, false);
250
	mod->set_axis_x_inverted(0, false);
251
	mod->set_axis_y_inverted(0, false);
252
	mod->set_axis_z_inverted(0, false);
253

254
	SUBCASE("[CopyTransformModifier3D] Enable 2 axes, additive=false, relative=false") {
255
		mod->set_additive(0, false);
256
		mod->set_relative(0, false);
257
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
258
		CHECK_MESSAGE(Math::is_equal_approx(
259
							  skeleton->get_bone_pose_position(tgt_bone).x,
260
							  (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin.x),
261
				"Position x is copied correctly.");
262
		CHECK_MESSAGE(Math::is_equal_approx(
263
							  skeleton->get_bone_pose_position(tgt_bone).y,
264
							  (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin.y),
265
				"Position y is copied correctly.");
266
		CHECK_MESSAGE(Math::is_zero_approx(
267
							  BoneConstraint3D::get_roll_angle((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion(), BoneConstraint3D::get_vector_from_axis(Vector3::AXIS_Z))),
268
				"Rotation z (roll z) is zero correctly.");
269
		CHECK_MESSAGE(Math::is_equal_approx(
270
							  skeleton->get_bone_pose_scale(tgt_bone).x,
271
							  (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale().x),
272
				"Scale x is copied correctly.");
273
		CHECK_MESSAGE(Math::is_equal_approx(
274
							  skeleton->get_bone_pose_scale(tgt_bone).y,
275
							  (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale().y),
276
				"Scale y is copied correctly.");
277
	}
278

279
	SUBCASE("[CopyTransformModifier3D] Enable 2 axes, additive=true, relative=false") {
280
		mod->set_additive(0, true);
281
		mod->set_relative(0, false);
282
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
283
		CHECK_MESSAGE(Math::is_equal_approx(
284
							  skeleton->get_bone_pose_position(tgt_bone).x,
285
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_pose_position(apl_bone)).x),
286
				"Position x is copied correctly.");
287
		CHECK_MESSAGE(Math::is_equal_approx(
288
							  skeleton->get_bone_pose_position(tgt_bone).y,
289
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_pose_position(apl_bone)).y),
290
				"Position y is copied correctly.");
291
		CHECK_MESSAGE(Math::is_zero_approx(
292
							  BoneConstraint3D::get_roll_angle(skeleton->get_bone_pose_rotation(apl_bone).inverse() * (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion(), BoneConstraint3D::get_vector_from_axis(Vector3::AXIS_Z))),
293
				"Rotation z (roll z) is zero correctly.");
294
		CHECK_MESSAGE(Math::is_equal_approx(
295
							  skeleton->get_bone_pose_scale(tgt_bone).x,
296
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_pose_scale(apl_bone)).x),
297
				"Scale x is copied correctly.");
298
		CHECK_MESSAGE(Math::is_equal_approx(
299
							  skeleton->get_bone_pose_scale(tgt_bone).y,
300
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_pose_scale(apl_bone)).y),
301
				"Scale y is copied correctly.");
302
	}
303

304
	SUBCASE("[CopyTransformModifier3D] Enable 2 axes, additive=false, relative=true") {
305
		mod->set_additive(0, false);
306
		mod->set_relative(0, true);
307
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
308
		CHECK_MESSAGE(Math::is_equal_approx(
309
							  (skeleton->get_bone_pose_position(tgt_bone) - skeleton->get_bone_rest(tgt_bone).origin).x,
310
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_rest(apl_bone).origin).x),
311
				"Position x is copied correctly.");
312
		CHECK_MESSAGE(Math::is_equal_approx(
313
							  (skeleton->get_bone_pose_position(tgt_bone) - skeleton->get_bone_rest(tgt_bone).origin).y,
314
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_rest(apl_bone).origin).y),
315
				"Position y is copied correctly.");
316
		CHECK_MESSAGE(Math::is_zero_approx(
317
							  BoneConstraint3D::get_roll_angle(skeleton->get_bone_rest(apl_bone).basis.get_rotation_quaternion().inverse() * (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion(), BoneConstraint3D::get_vector_from_axis(Vector3::AXIS_Z))),
318
				"Rotation z (roll z) is zero correctly.");
319
		CHECK_MESSAGE(Math::is_equal_approx(
320
							  (skeleton->get_bone_pose_scale(tgt_bone) / skeleton->get_bone_rest(tgt_bone).basis.get_scale()).x,
321
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_rest(apl_bone).basis.get_scale()).x),
322
				"Scale x is copied correctly.");
323
		CHECK_MESSAGE(Math::is_equal_approx(
324
							  (skeleton->get_bone_pose_scale(tgt_bone) / skeleton->get_bone_rest(tgt_bone).basis.get_scale()).y,
325
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_rest(apl_bone).basis.get_scale()).y),
326
				"Scale y is copied correctly.");
327
	}
328

329
	SUBCASE("[CopyTransformModifier3D] Enable 2 axes, additive=true, relative=true") {
330
		mod->set_additive(0, true);
331
		mod->set_relative(0, true);
332
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
333
		CHECK_MESSAGE(Math::is_equal_approx(
334
							  (skeleton->get_bone_pose_position(tgt_bone) - skeleton->get_bone_rest(tgt_bone).origin).x,
335
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_pose_position(apl_bone)).x),
336
				"Position x is copied correctly.");
337
		CHECK_MESSAGE(Math::is_equal_approx(
338
							  (skeleton->get_bone_pose_position(tgt_bone) - skeleton->get_bone_rest(tgt_bone).origin).y,
339
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_pose_position(apl_bone)).y),
340
				"Position y is copied correctly.");
341
		CHECK_MESSAGE(Math::is_zero_approx(
342
							  BoneConstraint3D::get_roll_angle(skeleton->get_bone_pose_rotation(apl_bone).inverse() * (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion(), BoneConstraint3D::get_vector_from_axis(Vector3::AXIS_Z))),
343
				"Rotation z (roll z) is zero correctly.");
344
		CHECK_MESSAGE(Math::is_equal_approx(
345
							  (skeleton->get_bone_pose_scale(tgt_bone) / skeleton->get_bone_rest(tgt_bone).basis.get_scale()).x,
346
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_pose_scale(apl_bone)).x),
347
				"Scale x is copied correctly.");
348
		CHECK_MESSAGE(Math::is_equal_approx(
349
							  (skeleton->get_bone_pose_scale(tgt_bone) / skeleton->get_bone_rest(tgt_bone).basis.get_scale()).y,
350
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_pose_scale(apl_bone)).y),
351
				"Scale y is copied correctly.");
352
	}
353

354
	// ===== [CopyTransformModifier3D] Enable all axes =====
355
	mod->set_axis_x_enabled(0, true);
356
	mod->set_axis_y_enabled(0, true);
357
	mod->set_axis_z_enabled(0, true);
358
	mod->set_axis_x_inverted(0, false);
359
	mod->set_axis_y_inverted(0, false);
360
	mod->set_axis_z_inverted(0, false);
361

362
	SUBCASE("[CopyTransformModifier3D] Enable all axes, additive=false, relative=false") {
363
		mod->set_additive(0, false);
364
		mod->set_relative(0, false);
365
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
366
		CHECK_MESSAGE(skeleton->get_bone_pose_position(tgt_bone).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin), "Position is copied correctly.");
367
		CHECK_MESSAGE(Basis(skeleton->get_bone_pose_rotation(tgt_bone)).is_equal_approx(Basis((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion())), "Rotation is copied correctly.");
368
		CHECK_MESSAGE(skeleton->get_bone_pose_scale(tgt_bone).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale()), "Scale is copied correctly.");
369
	}
370

371
	SUBCASE("[CopyTransformModifier3D] Enable all axes, additive=true, relative=false") {
372
		mod->set_additive(0, true);
373
		mod->set_relative(0, false);
374
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
375
		CHECK_MESSAGE(skeleton->get_bone_pose_position(tgt_bone).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_pose_position(apl_bone)), "Position is copied correctly.");
376
		CHECK_MESSAGE(Basis(skeleton->get_bone_pose_rotation(tgt_bone)).is_equal_approx(skeleton->get_bone_pose_rotation(apl_bone).inverse() * (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion()), "Rotation is copied correctly.");
377
		CHECK_MESSAGE(skeleton->get_bone_pose_scale(tgt_bone).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_pose_scale(apl_bone)), "Scale is copied correctly.");
378
	}
379

380
	SUBCASE("[CopyTransformModifier3D] Enable all axes, additive=false, relative=true") {
381
		mod->set_additive(0, false);
382
		mod->set_relative(0, true);
383
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
384
		CHECK_MESSAGE((skeleton->get_bone_pose_position(tgt_bone) - skeleton->get_bone_rest(tgt_bone).origin).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_rest(apl_bone).origin), "Position is copied correctly.");
385
		CHECK_MESSAGE(Basis(skeleton->get_bone_rest(tgt_bone).basis.get_rotation_quaternion().inverse() * skeleton->get_bone_pose_rotation(tgt_bone)).is_equal_approx(Basis(skeleton->get_bone_rest(apl_bone).basis.get_rotation_quaternion().inverse() * (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion())), "Rotation is copied correctly.");
386
		CHECK_MESSAGE((skeleton->get_bone_pose_scale(tgt_bone) / skeleton->get_bone_rest(tgt_bone).basis.get_scale()).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_rest(apl_bone).basis.get_scale()), "Scale is copied correctly.");
387
	}
388

389
	SUBCASE("[CopyTransformModifier3D] Enable all axes, additive=true, relative=true") {
390
		mod->set_additive(0, true);
391
		mod->set_relative(0, true);
392
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
393
		CHECK_MESSAGE((skeleton->get_bone_pose_position(tgt_bone) - skeleton->get_bone_rest(tgt_bone).origin).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_pose_position(apl_bone)), "Position is copied correctly.");
394
		CHECK_MESSAGE(Basis(skeleton->get_bone_rest(tgt_bone).basis.get_rotation_quaternion().inverse() * skeleton->get_bone_pose_rotation(tgt_bone)).is_equal_approx(skeleton->get_bone_pose_rotation(apl_bone).inverse() * (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion()), "Rotation is copied correctly.");
395
		CHECK_MESSAGE((skeleton->get_bone_pose_scale(tgt_bone) / skeleton->get_bone_rest(tgt_bone).basis.get_scale()).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_pose_scale(apl_bone)), "Scale is copied correctly.");
396
	}
397

398
	// ===== [CopyTransformModifier3D] Enable all axes, invert 1 axis =====
399
	mod->set_axis_x_enabled(0, true);
400
	mod->set_axis_y_enabled(0, true);
401
	mod->set_axis_z_enabled(0, true);
402
	mod->set_axis_x_inverted(0, true);
403
	mod->set_axis_y_inverted(0, false);
404
	mod->set_axis_z_inverted(0, false);
405

406
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert 1 axis, additive=false, relative=false") {
407
		mod->set_additive(0, false);
408
		mod->set_relative(0, false);
409
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
410
		CHECK_MESSAGE(flip_x(skeleton->get_bone_pose_position(tgt_bone)).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin), "Position is copied/inverted correctly.");
411
		CHECK_MESSAGE(flip_x(skeleton->get_bone_pose_rotation(tgt_bone)).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion()), "Rotation is copied/inverted correctly.");
412
		CHECK_MESSAGE(inv_x(skeleton->get_bone_pose_scale(tgt_bone)).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale()), "Scale is copied/inverted correctly.");
413
	}
414

415
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert 1 axis, additive=true, relative=false") {
416
		mod->set_additive(0, true);
417
		mod->set_relative(0, false);
418
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
419
		CHECK_MESSAGE(flip_x(skeleton->get_bone_pose_position(tgt_bone)).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_pose_position(apl_bone)), "Position is copied/inverted correctly.");
420
		CHECK_MESSAGE(flip_x(skeleton->get_bone_pose_rotation(tgt_bone)).is_equal_approx(Basis(skeleton->get_bone_pose_rotation(apl_bone).inverse() * (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion()).get_rotation_quaternion()), "Rotation is copied/inverted correctly.");
421
		CHECK_MESSAGE(inv_x(skeleton->get_bone_pose_scale(tgt_bone)).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_pose_scale(apl_bone)), "Scale is copied/inverted correctly.");
422
	}
423

424
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert 1 axis, additive=false, relative=true") {
425
		mod->set_additive(0, false);
426
		mod->set_relative(0, true);
427
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
428
		CHECK_MESSAGE(flip_x(skeleton->get_bone_pose_position(tgt_bone) - skeleton->get_bone_rest(tgt_bone).origin).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_rest(apl_bone).origin), "Position is copied/inverted correctly.");
429
		CHECK_MESSAGE(flip_x(skeleton->get_bone_rest(tgt_bone).basis.get_rotation_quaternion().inverse() * skeleton->get_bone_pose_rotation(tgt_bone)).is_equal_approx(Basis(skeleton->get_bone_rest(apl_bone).basis.get_rotation_quaternion().inverse() * (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion()).get_rotation_quaternion()), "Rotation is copied/inverted correctly.");
430
		CHECK_MESSAGE(inv_x(skeleton->get_bone_pose_scale(tgt_bone) / skeleton->get_bone_rest(tgt_bone).basis.get_scale()).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_rest(apl_bone).basis.get_scale()), "Scale is copied/inverted correctly.");
431
	}
432

433
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert 1 axis, additive=true, relative=true") {
434
		mod->set_additive(0, true);
435
		mod->set_relative(0, true);
436
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
437
		CHECK_MESSAGE(flip_x(skeleton->get_bone_pose_position(tgt_bone) - skeleton->get_bone_rest(tgt_bone).origin).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_pose_position(apl_bone)), "Position is copied/inverted correctly.");
438
		CHECK_MESSAGE(flip_x(skeleton->get_bone_rest(tgt_bone).basis.get_rotation_quaternion().inverse() * skeleton->get_bone_pose_rotation(tgt_bone)).is_equal_approx(Basis(skeleton->get_bone_pose_rotation(apl_bone).inverse() * (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion()).get_rotation_quaternion()), "Rotation is copied/inverted correctly.");
439
		CHECK_MESSAGE(inv_x(skeleton->get_bone_pose_scale(tgt_bone) / skeleton->get_bone_rest(tgt_bone).basis.get_scale()).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_pose_scale(apl_bone)), "Scale is copied/inverted correctly.");
440
	}
441

442
	// ===== [CopyTransformModifier3D] Enable all axes, invert 2 axes =====
443
	mod->set_axis_x_enabled(0, true);
444
	mod->set_axis_y_enabled(0, true);
445
	mod->set_axis_z_enabled(0, true);
446
	mod->set_axis_x_inverted(0, true);
447
	mod->set_axis_y_inverted(0, true);
448
	mod->set_axis_z_inverted(0, false);
449

450
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert 2 axes, additive=false, relative=false") {
451
		mod->set_additive(0, false);
452
		mod->set_relative(0, false);
453
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
454
		CHECK_MESSAGE(flip_xy(skeleton->get_bone_pose_position(tgt_bone)).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin), "Position is copied/inverted correctly.");
455
		CHECK_MESSAGE(flip_xy(skeleton->get_bone_pose_rotation(tgt_bone)).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion()), "Rotation is copied/inverted correctly.");
456
		CHECK_MESSAGE(inv_xy(skeleton->get_bone_pose_scale(tgt_bone)).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale()), "Scale is copied/inverted correctly.");
457
	}
458

459
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert 2 axes, additive=true, relative=false") {
460
		mod->set_additive(0, true);
461
		mod->set_relative(0, false);
462
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
463
		CHECK_MESSAGE(flip_xy(skeleton->get_bone_pose_position(tgt_bone)).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_pose_position(apl_bone)), "Position is copied/inverted correctly.");
464
		CHECK_MESSAGE(flip_xy(skeleton->get_bone_pose_rotation(tgt_bone)).is_equal_approx(Basis(skeleton->get_bone_pose_rotation(apl_bone).inverse() * (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion()).get_rotation_quaternion()), "Rotation is copied/inverted correctly.");
465
		CHECK_MESSAGE(inv_xy(skeleton->get_bone_pose_scale(tgt_bone)).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_pose_scale(apl_bone)), "Scale is copied/inverted correctly.");
466
	}
467

468
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert 2 axes, additive=false, relative=true") {
469
		mod->set_additive(0, false);
470
		mod->set_relative(0, true);
471
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
472
		CHECK_MESSAGE(flip_xy(skeleton->get_bone_pose_position(tgt_bone) - skeleton->get_bone_rest(tgt_bone).origin).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_rest(apl_bone).origin), "Position is copied/inverted correctly.");
473
		CHECK_MESSAGE(flip_xy(skeleton->get_bone_rest(tgt_bone).basis.get_rotation_quaternion().inverse() * skeleton->get_bone_pose_rotation(tgt_bone)).is_equal_approx(Basis(skeleton->get_bone_rest(apl_bone).basis.get_rotation_quaternion().inverse() * (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion()).get_rotation_quaternion()), "Rotation is copied/inverted correctly.");
474
		CHECK_MESSAGE(inv_xy(skeleton->get_bone_pose_scale(tgt_bone) / skeleton->get_bone_rest(tgt_bone).basis.get_scale()).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_rest(apl_bone).basis.get_scale()), "Scale is copied/inverted correctly.");
475
	}
476

477
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert 2 axes, additive=true, relative=true") {
478
		mod->set_additive(0, true);
479
		mod->set_relative(0, true);
480
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
481
		CHECK_MESSAGE(flip_xy(skeleton->get_bone_pose_position(tgt_bone) - skeleton->get_bone_rest(tgt_bone).origin).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_pose_position(apl_bone)), "Position is copied/inverted correctly.");
482
		CHECK_MESSAGE(flip_xy(skeleton->get_bone_rest(tgt_bone).basis.get_rotation_quaternion().inverse() * skeleton->get_bone_pose_rotation(tgt_bone)).is_equal_approx(Basis(skeleton->get_bone_pose_rotation(apl_bone).inverse() * (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion()).get_rotation_quaternion()), "Rotation is copied/inverted correctly.");
483
		CHECK_MESSAGE(inv_xy(skeleton->get_bone_pose_scale(tgt_bone) / skeleton->get_bone_rest(tgt_bone).basis.get_scale()).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_pose_scale(apl_bone)), "Scale is copied/inverted correctly.");
484
	}
485

486
	// ===== [CopyTransformModifier3D] Enable all axes, invert all axes =====
487
	mod->set_axis_x_enabled(0, true);
488
	mod->set_axis_y_enabled(0, true);
489
	mod->set_axis_z_enabled(0, true);
490
	mod->set_axis_x_inverted(0, true);
491
	mod->set_axis_y_inverted(0, true);
492
	mod->set_axis_z_inverted(0, true);
493

494
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert all axes, additive=false, relative=false") {
495
		mod->set_additive(0, false);
496
		mod->set_relative(0, false);
497
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
498
		CHECK_MESSAGE(flip_all(skeleton->get_bone_pose_position(tgt_bone)).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin), "Position is copied/inverted correctly.");
499
		CHECK_MESSAGE(flip_all(skeleton->get_bone_pose_rotation(tgt_bone)).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion()), "Rotation is copied/inverted correctly.");
500
		CHECK_MESSAGE(inv_all(skeleton->get_bone_pose_scale(tgt_bone)).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale()), "Scale is copied/inverted correctly.");
501
	}
502

503
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert all axes, additive=true, relative=false") {
504
		mod->set_additive(0, true);
505
		mod->set_relative(0, false);
506
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
507
		CHECK_MESSAGE(flip_all(skeleton->get_bone_pose_position(tgt_bone)).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_pose_position(apl_bone)), "Position is copied/inverted correctly.");
508
		CHECK_MESSAGE(flip_all(skeleton->get_bone_pose_rotation(tgt_bone)).is_equal_approx(Basis(skeleton->get_bone_pose_rotation(apl_bone).inverse() * (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion()).get_rotation_quaternion()), "Rotation is copied/inverted correctly.");
509
		CHECK_MESSAGE(inv_all(skeleton->get_bone_pose_scale(tgt_bone)).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_pose_scale(apl_bone)), "Scale is copied/inverted correctly.");
510
	}
511

512
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert all axes, additive=false, relative=true") {
513
		mod->set_additive(0, false);
514
		mod->set_relative(0, true);
515
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
516
		CHECK_MESSAGE(flip_all(skeleton->get_bone_pose_position(tgt_bone) - skeleton->get_bone_rest(tgt_bone).origin).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_rest(apl_bone).origin), "Position is copied/inverted correctly.");
517
		CHECK_MESSAGE(flip_all(skeleton->get_bone_rest(tgt_bone).basis.get_rotation_quaternion().inverse() * skeleton->get_bone_pose_rotation(tgt_bone)).is_equal_approx(Basis(skeleton->get_bone_rest(apl_bone).basis.get_rotation_quaternion().inverse() * (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion()).get_rotation_quaternion()), "Rotation is copied/inverted correctly.");
518
		CHECK_MESSAGE(inv_all(skeleton->get_bone_pose_scale(tgt_bone) / skeleton->get_bone_rest(tgt_bone).basis.get_scale()).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_rest(apl_bone).basis.get_scale()), "Scale is copied/inverted correctly.");
519
	}
520

521
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert all axes, additive=true, relative=true") {
522
		mod->set_additive(0, true);
523
		mod->set_relative(0, true);
524
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
525
		CHECK_MESSAGE(flip_all(skeleton->get_bone_pose_position(tgt_bone) - skeleton->get_bone_rest(tgt_bone).origin).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_pose_position(apl_bone)), "Position is copied/inverted correctly.");
526
		CHECK_MESSAGE(flip_all(skeleton->get_bone_rest(tgt_bone).basis.get_rotation_quaternion().inverse() * skeleton->get_bone_pose_rotation(tgt_bone)).is_equal_approx(Basis(skeleton->get_bone_pose_rotation(apl_bone).inverse() * (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_rotation_quaternion()).get_rotation_quaternion()), "Rotation is copied/inverted correctly.");
527
		CHECK_MESSAGE(inv_all(skeleton->get_bone_pose_scale(tgt_bone) / skeleton->get_bone_rest(tgt_bone).basis.get_scale()).is_equal_approx((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_pose_scale(apl_bone)), "Scale is copied/inverted correctly.");
528
	}
529

530
	memdelete(modified);
531
	memdelete(mod);
532
	memdelete(skeleton);
533
}
534

535
} // namespace TestCopyTransformModifier3D
536

537
#endif // _3D_DISABLED
538

539
Product

Resources

Company
