CoCalc -- test_copy_transform_modifier

GitHub Repository: godotengine/godot
Path: blob/master/tests/scene/test_copy_transform_modifier_3d.h
¹⁰²⁷⁷ views
1
/**************************************************************************/
2
/*  test_copy_transform_modifier_3d.h                                     */
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
#pragma once
32

33
#include "tests/test_macros.h"
34

35
#include "scene/3d/bone_attachment_3d.h"
36
#include "scene/3d/copy_transform_modifier_3d.h"
37

38
namespace TestCopyTransformModifier3D {
39

40
Transform3D make_random_transform_3d(int p_seed) {
41
	RandomNumberGenerator rng;
42
	rng.set_seed(p_seed);
43

44
	Vector3 pos;
45
	pos.x = rng.randf_range(-10.0, 10.0);
46
	rng.set_seed(++p_seed);
47
	pos.y = rng.randf_range(-10.0, 10.0);
48
	rng.set_seed(++p_seed);
49
	pos.z = rng.randf_range(-10.0, 10.0);
50
	rng.set_seed(++p_seed);
51

52
	Quaternion rot;
53
	rot.x = rng.randf_range(-1.0, 1.0);
54
	rng.set_seed(++p_seed);
55
	rot.y = rng.randf_range(-1.0, 1.0);
56
	rng.set_seed(++p_seed);
57
	rot.z = rng.randf_range(-1.0, 1.0);
58
	rng.set_seed(++p_seed);
59
	rot.w = rng.randf_range(-1.0, 1.0);
60
	rng.set_seed(++p_seed);
61
	rot = rot.normalized();
62

63
	Vector3 scl;
64
	scl.x = rng.randf_range(0.5, 2.0);
65
	rng.set_seed(++p_seed);
66
	scl.y = rng.randf_range(0.5, 2.0);
67
	rng.set_seed(++p_seed);
68
	scl.z = rng.randf_range(0.5, 2.0);
69
	rng.set_seed(++p_seed);
70

71
	return Transform3D(Basis(rot).scaled(scl), pos);
72
}
73

74
Vector3 flip_x(Vector3 p_pos) {
75
	return Vector3(-p_pos.x, p_pos.y, p_pos.z);
76
}
77

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

82
Vector3 flip_all(Vector3 p_pos) {
83
	return -p_pos;
84
}
85

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

88
Quaternion flip_x(Quaternion p_rot) {
89
	return Basis(Quaternion(-p_rot.x, p_rot.y, p_rot.z, p_rot.w).normalized()).get_rotation_quaternion();
90
}
91

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

96
Quaternion flip_all(Quaternion p_rot) {
97
	return Basis(p_rot.inverse()).get_rotation_quaternion();
98
}
99

100
Vector3 inv_x(Vector3 p_scl) {
101
	return Vector3(1.0 / p_scl.x, p_scl.y, p_scl.z);
102
}
103

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

108
Vector3 inv_all(Vector3 p_scl) {
109
	return Vector3(1.0, 1.0, 1.0) / p_scl;
110
}
111

112
TEST_CASE("[SceneTree][CopyTransformModifier3D]") {
113
	SceneTree *tree = SceneTree::get_singleton();
114
	int seed = 12345;
115
	Skeleton3D *skeleton = memnew(Skeleton3D);
116
	CopyTransformModifier3D *mod = memnew(CopyTransformModifier3D);
117

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

122
	tree->get_root()->add_child(skeleton);
123

124
	int root = skeleton->add_bone("root");
125
	skeleton->set_bone_rest(root, make_random_transform_3d(++seed));
126
	skeleton->set_bone_pose(root, make_random_transform_3d(++seed));
127

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

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

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

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

148
	skeleton->add_child(mod);
149
	skeleton->add_child(modified);
150
	modified->set_rotation_edit_mode(Node3D::ROTATION_EDIT_MODE_QUATERNION);
151
	modified->set_bone_idx(apl_bone);
152

153
	mod->set_setting_count(1);
154
	mod->set_reference_bone(0, tgt_bone);
155
	mod->set_apply_bone(0, apl_bone);
156

157
	mod->set_copy_position(0, true);
158
	mod->set_copy_rotation(0, true);
159
	mod->set_copy_scale(0, true);
160

161
	// ===== [CopyTransformModifier3D] Enable 1 axis =====
162
	mod->set_axis_x_enabled(0, true);
163
	mod->set_axis_y_enabled(0, false);
164
	mod->set_axis_z_enabled(0, false);
165
	mod->set_axis_x_inverted(0, false);
166
	mod->set_axis_y_inverted(0, false);
167
	mod->set_axis_z_inverted(0, false);
168

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

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

205
	SUBCASE("[CopyTransformModifier3D] Enable 1 axis, additive=false, relative=true") {
206
		mod->set_additive(0, false);
207
		mod->set_relative(0, true);
208
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
209
		CHECK_MESSAGE(Math::is_equal_approx(
210
							  (skeleton->get_bone_pose_position(tgt_bone) - skeleton->get_bone_rest(tgt_bone).origin).x,
211
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_rest(apl_bone).origin).x),
212
				"Position x is copied correctly.");
213
		CHECK_MESSAGE(Math::is_equal_approx(
214
							  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)),
215
							  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))),
216
				"Rotation x (roll x) is copied correctly.");
217
		CHECK_MESSAGE(Math::is_equal_approx(
218
							  (skeleton->get_bone_pose_scale(tgt_bone) / skeleton->get_bone_rest(tgt_bone).basis.get_scale()).x,
219
							  ((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),
220
				"Scale x is copied correctly.");
221
	}
222

223
	SUBCASE("[CopyTransformModifier3D] Enable 1 axis, additive=true, relative=true") {
224
		mod->set_additive(0, true);
225
		mod->set_relative(0, true);
226
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
227
		CHECK_MESSAGE(Math::is_equal_approx(
228
							  (skeleton->get_bone_pose_position(tgt_bone) - skeleton->get_bone_rest(tgt_bone).origin).x,
229
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_pose_position(apl_bone)).x),
230
				"Position x is copied correctly.");
231
		CHECK_MESSAGE(Math::is_equal_approx(
232
							  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)),
233
							  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))),
234
				"Rotation x (roll x) is copied correctly.");
235
		CHECK_MESSAGE(Math::is_equal_approx(
236
							  (skeleton->get_bone_pose_scale(tgt_bone) / skeleton->get_bone_rest(tgt_bone).basis.get_scale()).x,
237
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_pose_scale(apl_bone)).x),
238
				"Scale x is copied correctly.");
239
	}
240

241
	// ===== [CopyTransformModifier3D] Enable 2 axes =====
242
	mod->set_axis_x_enabled(0, true);
243
	mod->set_axis_y_enabled(0, true);
244
	mod->set_axis_z_enabled(0, false);
245
	mod->set_axis_x_inverted(0, false);
246
	mod->set_axis_y_inverted(0, false);
247
	mod->set_axis_z_inverted(0, false);
248

249
	SUBCASE("[CopyTransformModifier3D] Enable 2 axes, additive=false, relative=false") {
250
		mod->set_additive(0, false);
251
		mod->set_relative(0, false);
252
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
253
		CHECK_MESSAGE(Math::is_equal_approx(
254
							  skeleton->get_bone_pose_position(tgt_bone).x,
255
							  (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin.x),
256
				"Position x is copied correctly.");
257
		CHECK_MESSAGE(Math::is_equal_approx(
258
							  skeleton->get_bone_pose_position(tgt_bone).y,
259
							  (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin.y),
260
				"Position y is copied correctly.");
261
		CHECK_MESSAGE(Math::is_zero_approx(
262
							  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))),
263
				"Rotation z (roll z) is zero correctly.");
264
		CHECK_MESSAGE(Math::is_equal_approx(
265
							  skeleton->get_bone_pose_scale(tgt_bone).x,
266
							  (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale().x),
267
				"Scale x is copied correctly.");
268
		CHECK_MESSAGE(Math::is_equal_approx(
269
							  skeleton->get_bone_pose_scale(tgt_bone).y,
270
							  (skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale().y),
271
				"Scale y is copied correctly.");
272
	}
273

274
	SUBCASE("[CopyTransformModifier3D] Enable 2 axes, additive=true, relative=false") {
275
		mod->set_additive(0, true);
276
		mod->set_relative(0, false);
277
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
278
		CHECK_MESSAGE(Math::is_equal_approx(
279
							  skeleton->get_bone_pose_position(tgt_bone).x,
280
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_pose_position(apl_bone)).x),
281
				"Position x is copied correctly.");
282
		CHECK_MESSAGE(Math::is_equal_approx(
283
							  skeleton->get_bone_pose_position(tgt_bone).y,
284
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_pose_position(apl_bone)).y),
285
				"Position y is copied correctly.");
286
		CHECK_MESSAGE(Math::is_zero_approx(
287
							  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))),
288
				"Rotation z (roll z) is zero correctly.");
289
		CHECK_MESSAGE(Math::is_equal_approx(
290
							  skeleton->get_bone_pose_scale(tgt_bone).x,
291
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_pose_scale(apl_bone)).x),
292
				"Scale x is copied correctly.");
293
		CHECK_MESSAGE(Math::is_equal_approx(
294
							  skeleton->get_bone_pose_scale(tgt_bone).y,
295
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_pose_scale(apl_bone)).y),
296
				"Scale y is copied correctly.");
297
	}
298

299
	SUBCASE("[CopyTransformModifier3D] Enable 2 axes, additive=false, relative=true") {
300
		mod->set_additive(0, false);
301
		mod->set_relative(0, true);
302
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
303
		CHECK_MESSAGE(Math::is_equal_approx(
304
							  (skeleton->get_bone_pose_position(tgt_bone) - skeleton->get_bone_rest(tgt_bone).origin).x,
305
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_rest(apl_bone).origin).x),
306
				"Position x is copied correctly.");
307
		CHECK_MESSAGE(Math::is_equal_approx(
308
							  (skeleton->get_bone_pose_position(tgt_bone) - skeleton->get_bone_rest(tgt_bone).origin).y,
309
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_rest(apl_bone).origin).y),
310
				"Position y is copied correctly.");
311
		CHECK_MESSAGE(Math::is_zero_approx(
312
							  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))),
313
				"Rotation z (roll z) is zero correctly.");
314
		CHECK_MESSAGE(Math::is_equal_approx(
315
							  (skeleton->get_bone_pose_scale(tgt_bone) / skeleton->get_bone_rest(tgt_bone).basis.get_scale()).x,
316
							  ((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),
317
				"Scale x is copied correctly.");
318
		CHECK_MESSAGE(Math::is_equal_approx(
319
							  (skeleton->get_bone_pose_scale(tgt_bone) / skeleton->get_bone_rest(tgt_bone).basis.get_scale()).y,
320
							  ((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),
321
				"Scale y is copied correctly.");
322
	}
323

324
	SUBCASE("[CopyTransformModifier3D] Enable 2 axes, additive=true, relative=true") {
325
		mod->set_additive(0, true);
326
		mod->set_relative(0, true);
327
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
328
		CHECK_MESSAGE(Math::is_equal_approx(
329
							  (skeleton->get_bone_pose_position(tgt_bone) - skeleton->get_bone_rest(tgt_bone).origin).x,
330
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_pose_position(apl_bone)).x),
331
				"Position x is copied correctly.");
332
		CHECK_MESSAGE(Math::is_equal_approx(
333
							  (skeleton->get_bone_pose_position(tgt_bone) - skeleton->get_bone_rest(tgt_bone).origin).y,
334
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_pose_position(apl_bone)).y),
335
				"Position y is copied correctly.");
336
		CHECK_MESSAGE(Math::is_zero_approx(
337
							  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))),
338
				"Rotation z (roll z) is zero correctly.");
339
		CHECK_MESSAGE(Math::is_equal_approx(
340
							  (skeleton->get_bone_pose_scale(tgt_bone) / skeleton->get_bone_rest(tgt_bone).basis.get_scale()).x,
341
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_pose_scale(apl_bone)).x),
342
				"Scale x is copied correctly.");
343
		CHECK_MESSAGE(Math::is_equal_approx(
344
							  (skeleton->get_bone_pose_scale(tgt_bone) / skeleton->get_bone_rest(tgt_bone).basis.get_scale()).y,
345
							  ((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_pose_scale(apl_bone)).y),
346
				"Scale y is copied correctly.");
347
	}
348

349
	// ===== [CopyTransformModifier3D] Enable all axes =====
350
	mod->set_axis_x_enabled(0, true);
351
	mod->set_axis_y_enabled(0, true);
352
	mod->set_axis_z_enabled(0, true);
353
	mod->set_axis_x_inverted(0, false);
354
	mod->set_axis_y_inverted(0, false);
355
	mod->set_axis_z_inverted(0, false);
356

357
	SUBCASE("[CopyTransformModifier3D] Enable all axes, additive=false, relative=false") {
358
		mod->set_additive(0, false);
359
		mod->set_relative(0, false);
360
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
361
		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.");
362
		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.");
363
		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.");
364
	}
365

366
	SUBCASE("[CopyTransformModifier3D] Enable all axes, additive=true, relative=false") {
367
		mod->set_additive(0, true);
368
		mod->set_relative(0, false);
369
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
370
		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.");
371
		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.");
372
		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.");
373
	}
374

375
	SUBCASE("[CopyTransformModifier3D] Enable all axes, additive=false, relative=true") {
376
		mod->set_additive(0, false);
377
		mod->set_relative(0, true);
378
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
379
		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.");
380
		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.");
381
		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.");
382
	}
383

384
	SUBCASE("[CopyTransformModifier3D] Enable all axes, additive=true, relative=true") {
385
		mod->set_additive(0, true);
386
		mod->set_relative(0, true);
387
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
388
		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.");
389
		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.");
390
		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.");
391
	}
392

393
	// ===== [CopyTransformModifier3D] Enable all axes, invert 1 axis =====
394
	mod->set_axis_x_enabled(0, true);
395
	mod->set_axis_y_enabled(0, true);
396
	mod->set_axis_z_enabled(0, true);
397
	mod->set_axis_x_inverted(0, true);
398
	mod->set_axis_y_inverted(0, false);
399
	mod->set_axis_z_inverted(0, false);
400

401
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert 1 axis, additive=false, relative=false") {
402
		mod->set_additive(0, false);
403
		mod->set_relative(0, false);
404
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
405
		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.");
406
		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.");
407
		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.");
408
	}
409

410
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert 1 axis, additive=true, relative=false") {
411
		mod->set_additive(0, true);
412
		mod->set_relative(0, false);
413
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
414
		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.");
415
		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.");
416
		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.");
417
	}
418

419
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert 1 axis, additive=false, relative=true") {
420
		mod->set_additive(0, false);
421
		mod->set_relative(0, true);
422
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
423
		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.");
424
		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.");
425
		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.");
426
	}
427

428
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert 1 axis, additive=true, relative=true") {
429
		mod->set_additive(0, true);
430
		mod->set_relative(0, true);
431
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
432
		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.");
433
		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.");
434
		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.");
435
	}
436

437
	// ===== [CopyTransformModifier3D] Enable all axes, invert 2 axes =====
438
	mod->set_axis_x_enabled(0, true);
439
	mod->set_axis_y_enabled(0, true);
440
	mod->set_axis_z_enabled(0, true);
441
	mod->set_axis_x_inverted(0, true);
442
	mod->set_axis_y_inverted(0, true);
443
	mod->set_axis_z_inverted(0, false);
444

445
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert 2 axes, additive=false, relative=false") {
446
		mod->set_additive(0, false);
447
		mod->set_relative(0, false);
448
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
449
		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.");
450
		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.");
451
		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.");
452
	}
453

454
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert 2 axes, additive=true, relative=false") {
455
		mod->set_additive(0, true);
456
		mod->set_relative(0, false);
457
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
458
		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.");
459
		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.");
460
		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.");
461
	}
462

463
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert 2 axes, additive=false, relative=true") {
464
		mod->set_additive(0, false);
465
		mod->set_relative(0, true);
466
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
467
		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.");
468
		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.");
469
		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.");
470
	}
471

472
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert 2 axes, additive=true, relative=true") {
473
		mod->set_additive(0, true);
474
		mod->set_relative(0, true);
475
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
476
		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.");
477
		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.");
478
		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.");
479
	}
480

481
	// ===== [CopyTransformModifier3D] Enable all axes, invert all axes =====
482
	mod->set_axis_x_enabled(0, true);
483
	mod->set_axis_y_enabled(0, true);
484
	mod->set_axis_z_enabled(0, true);
485
	mod->set_axis_x_inverted(0, true);
486
	mod->set_axis_y_inverted(0, true);
487
	mod->set_axis_z_inverted(0, true);
488

489
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert all axes, additive=false, relative=false") {
490
		mod->set_additive(0, false);
491
		mod->set_relative(0, false);
492
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
493
		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.");
494
		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.");
495
		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.");
496
	}
497

498
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert all axes, additive=true, relative=false") {
499
		mod->set_additive(0, true);
500
		mod->set_relative(0, false);
501
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
502
		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.");
503
		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.");
504
		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.");
505
	}
506

507
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert all axes, additive=false, relative=true") {
508
		mod->set_additive(0, false);
509
		mod->set_relative(0, true);
510
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
511
		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.");
512
		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.");
513
		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.");
514
	}
515

516
	SUBCASE("[CopyTransformModifier3D] Enable all axes, invert all axes, additive=true, relative=true") {
517
		mod->set_additive(0, true);
518
		mod->set_relative(0, true);
519
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
520
		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.");
521
		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.");
522
		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.");
523
	}
524

525
	memdelete(modified);
526
	memdelete(mod);
527
	memdelete(skeleton);
528
}
529
} // namespace TestCopyTransformModifier3D
530

531
Product

Resources

Company
