CoCalc -- test_convert_transform_modifier

GitHub Repository: godotengine/godot
Path: blob/master/tests/scene/test_convert_transform_modifier_3d.cpp
⁴⁵⁹⁹¹ views
1
/**************************************************************************/
2
/*  test_convert_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_convert_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/convert_transform_modifier_3d.h"
40
#include "scene/main/scene_tree.h"
41
#include "scene/main/window.h"
42

43
namespace TestConvertTransformModifier3D {
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
TEST_CASE("[SceneTree][ConvertTransformModifier3D]") {
80
	SceneTree *tree = SceneTree::get_singleton();
81
	int seed = 12345;
82
	Skeleton3D *skeleton = memnew(Skeleton3D);
83
	ConvertTransformModifier3D *mod = memnew(ConvertTransformModifier3D);
84

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

89
	tree->get_root()->add_child(skeleton);
90

91
	int root = skeleton->add_bone("root");
92
	skeleton->set_bone_rest(root, make_random_transform_3d(++seed));
93
	skeleton->set_bone_pose(root, make_random_transform_3d(++seed));
94

95
	int apl_root = skeleton->add_bone("apl_root");
96
	skeleton->set_bone_parent(apl_root, root);
97
	skeleton->set_bone_rest(apl_root, make_random_transform_3d(++seed));
98
	skeleton->set_bone_pose(apl_root, make_random_transform_3d(++seed));
99

100
	int apl_bone = skeleton->add_bone("apl_bone");
101
	skeleton->set_bone_parent(apl_bone, apl_root);
102
	skeleton->set_bone_rest(apl_bone, make_random_transform_3d(++seed));
103
	skeleton->set_bone_pose(apl_bone, make_random_transform_3d(++seed));
104

105
	int tgt_root = skeleton->add_bone("tgt_root");
106
	skeleton->set_bone_parent(tgt_root, root);
107
	skeleton->set_bone_rest(tgt_root, make_random_transform_3d(++seed));
108
	skeleton->set_bone_pose(tgt_root, make_random_transform_3d(++seed));
109

110
	int tgt_bone = skeleton->add_bone("tgt_bone");
111
	skeleton->set_bone_parent(tgt_bone, tgt_root);
112
	skeleton->set_bone_rest(tgt_bone, make_random_transform_3d(++seed));
113
	skeleton->set_bone_pose(tgt_bone, make_random_transform_3d(++seed));
114

115
	skeleton->add_child(mod);
116
	skeleton->add_child(modified);
117
	modified->set_rotation_edit_mode(Node3D::ROTATION_EDIT_MODE_QUATERNION);
118
	modified->set_bone_idx(apl_bone);
119

120
	mod->set_setting_count(1);
121
	mod->set_reference_bone(0, tgt_bone);
122
	mod->set_apply_bone(0, apl_bone);
123

124
	mod->set_reference_axis(0, Vector3::AXIS_X);
125
	mod->set_apply_axis(0, Vector3::AXIS_Y);
126

127
	// ===== [ConvertTransformModifier3D] Position x to y =====
128
	mod->set_reference_transform_mode(0, ConvertTransformModifier3D::TRANSFORM_MODE_POSITION);
129
	mod->set_reference_range_min(0, -100.0);
130
	mod->set_reference_range_max(0, 100.0);
131
	mod->set_apply_transform_mode(0, ConvertTransformModifier3D::TRANSFORM_MODE_POSITION);
132
	mod->set_apply_range_min(0, -100.0);
133
	mod->set_apply_range_max(0, 100.0);
134

135
	SUBCASE("[ConvertTransformModifier3D] Position x to y, additive=false, relative=false") {
136
		mod->set_additive(0, false);
137
		mod->set_relative(0, false);
138
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
139
		CHECK(Math::is_equal_approx(
140
				skeleton->get_bone_pose_position(tgt_bone).x,
141
				(skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin.y));
142
	}
143

144
	SUBCASE("[ConvertTransformModifier3D] Position x to y, additive=true, relative=false") {
145
		mod->set_additive(0, true);
146
		mod->set_relative(0, false);
147
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
148
		CHECK(Math::is_equal_approx(
149
				skeleton->get_bone_pose_position(tgt_bone).x,
150
				((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_pose_position(apl_bone)).y));
151
	}
152

153
	SUBCASE("[ConvertTransformModifier3D] Position x to y, additive=false, relative=true") {
154
		mod->set_additive(0, false);
155
		mod->set_relative(0, true);
156
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
157
		CHECK(Math::is_equal_approx(
158
				(skeleton->get_bone_pose_position(tgt_bone) - skeleton->get_bone_rest(tgt_bone).origin).x,
159
				((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_rest(apl_bone).origin).y));
160
	}
161

162
	SUBCASE("[ConvertTransformModifier3D] Position x to y, additive=true, relative=true") {
163
		mod->set_additive(0, true);
164
		mod->set_relative(0, true);
165
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
166
		CHECK(Math::is_equal_approx(
167
				(skeleton->get_bone_pose_position(tgt_bone) - skeleton->get_bone_rest(tgt_bone).origin).x,
168
				((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).origin - skeleton->get_bone_pose_position(apl_bone)).y));
169
	}
170

171
	// ===== [ConvertTransformModifier3D] Rotation (roll) x to y =====
172
	mod->set_reference_transform_mode(0, ConvertTransformModifier3D::TRANSFORM_MODE_ROTATION);
173
	mod->set_reference_range_min(0, -180.0);
174
	mod->set_reference_range_max(0, 180.0);
175
	mod->set_apply_transform_mode(0, ConvertTransformModifier3D::TRANSFORM_MODE_ROTATION);
176
	mod->set_apply_range_min(0, -180.0);
177
	mod->set_apply_range_max(0, 180.0);
178

179
	SUBCASE("[ConvertTransformModifier3D] Rotation (roll) x to y, additive=false, relative=false") {
180
		mod->set_additive(0, false);
181
		mod->set_relative(0, false);
182
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
183
		CHECK(Math::is_equal_approx(
184
				BoneConstraint3D::get_roll_angle(skeleton->get_bone_pose_rotation(tgt_bone), BoneConstraint3D::get_vector_from_axis(Vector3::AXIS_X)),
185
				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_Y))));
186
	}
187

188
	SUBCASE("[ConvertTransformModifier3D] Rotation (roll) x to y, additive=true, relative=false") {
189
		mod->set_additive(0, true);
190
		mod->set_relative(0, false);
191
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
192
		CHECK(Math::is_equal_approx(
193
				BoneConstraint3D::get_roll_angle(skeleton->get_bone_pose_rotation(tgt_bone), BoneConstraint3D::get_vector_from_axis(Vector3::AXIS_X)),
194
				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_Y))));
195
	}
196

197
	SUBCASE("[ConvertTransformModifier3D] Rotation (roll) x to y, additive=false, relative=true") {
198
		mod->set_additive(0, false);
199
		mod->set_relative(0, true);
200
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
201
		CHECK(Math::is_equal_approx(
202
				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)),
203
				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_Y))));
204
	}
205

206
	SUBCASE("[ConvertTransformModifier3D] Rotation (roll) x to y, additive=true, relative=true") {
207
		mod->set_additive(0, true);
208
		mod->set_relative(0, true);
209
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
210
		CHECK(Math::is_equal_approx(
211
				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)),
212
				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_Y))));
213
	}
214

215
	// ===== [ConvertTransformModifier3D] Scale x to y =====
216
	mod->set_reference_transform_mode(0, ConvertTransformModifier3D::TRANSFORM_MODE_SCALE);
217
	mod->set_reference_range_min(0, 0);
218
	mod->set_reference_range_max(0, 10.0);
219
	mod->set_apply_transform_mode(0, ConvertTransformModifier3D::TRANSFORM_MODE_SCALE);
220
	mod->set_apply_range_min(0, 0);
221
	mod->set_apply_range_max(0, 10.0);
222

223
	SUBCASE("[ConvertTransformModifier3D] Scale x to y, additive=false, relative=false") {
224
		mod->set_additive(0, false);
225
		mod->set_relative(0, false);
226
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
227
		CHECK(Math::is_equal_approx(
228
				skeleton->get_bone_pose_scale(tgt_bone).x,
229
				(skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale().y));
230
	}
231

232
	SUBCASE("[ConvertTransformModifier3D] Scale x to y, additive=true, relative=false") {
233
		mod->set_additive(0, true);
234
		mod->set_relative(0, false);
235
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
236
		CHECK(Math::is_equal_approx(
237
				skeleton->get_bone_pose_scale(tgt_bone).x,
238
				((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_pose_scale(apl_bone)).y));
239
	}
240

241
	SUBCASE("[ConvertTransformModifier3D] Scale x to y, additive=false, relative=true") {
242
		mod->set_additive(0, false);
243
		mod->set_relative(0, true);
244
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
245
		CHECK(Math::is_equal_approx(
246
				(skeleton->get_bone_pose_scale(tgt_bone) / skeleton->get_bone_rest(tgt_bone).basis.get_scale()).x,
247
				((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));
248
	}
249

250
	SUBCASE("[ConvertTransformModifier3D] Scale x to y, additive=true, relative=true") {
251
		mod->set_additive(0, true);
252
		mod->set_relative(0, true);
253
		skeleton->notification(Skeleton3D::NOTIFICATION_UPDATE_SKELETON);
254
		CHECK(Math::is_equal_approx(
255
				(skeleton->get_bone_pose_scale(tgt_bone) / skeleton->get_bone_rest(tgt_bone).basis.get_scale()).x,
256
				((skeleton->get_bone_global_pose(apl_root).affine_inverse() * modified->get_transform()).basis.get_scale() / skeleton->get_bone_pose_scale(apl_bone)).y));
257
	}
258

259
	memdelete(modified);
260
	memdelete(mod);
261
	memdelete(skeleton);
262
}
263

264
} // namespace TestConvertTransformModifier3D
265

266
#endif // _3D_DISABLED
267

268
Product

Resources

Company
