1 /*************************************************************************/
2 /* joints_2d.cpp */
3 /*************************************************************************/
4 /* This file is part of: */
5 /* GODOT ENGINE */
6 /* https://godotengine.org */
7 /*************************************************************************/
8 /* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
9 /* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
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 "joints_2d.h"
32
33 #include "core/engine.h"
34 #include "physics_body_2d.h"
35 #include "servers/physics_2d_server.h"
36
_update_joint(bool p_only_free)37 void Joint2D::_update_joint(bool p_only_free) {
38
39 if (joint.is_valid()) {
40 if (ba.is_valid() && bb.is_valid() && exclude_from_collision)
41 Physics2DServer::get_singleton()->joint_disable_collisions_between_bodies(joint, false);
42
43 Physics2DServer::get_singleton()->free(joint);
44 joint = RID();
45 ba = RID();
46 bb = RID();
47 }
48
49 if (p_only_free || !is_inside_tree())
50 return;
51
52 Node *node_a = has_node(get_node_a()) ? get_node(get_node_a()) : (Node *)NULL;
53 Node *node_b = has_node(get_node_b()) ? get_node(get_node_b()) : (Node *)NULL;
54
55 if (!node_a || !node_b)
56 return;
57
58 PhysicsBody2D *body_a = Object::cast_to<PhysicsBody2D>(node_a);
59 PhysicsBody2D *body_b = Object::cast_to<PhysicsBody2D>(node_b);
60
61 if (!body_a || !body_b)
62 return;
63
64 joint = _configure_joint(body_a, body_b);
65
66 if (!joint.is_valid())
67 return;
68
69 Physics2DServer::get_singleton()->get_singleton()->joint_set_param(joint, Physics2DServer::JOINT_PARAM_BIAS, bias);
70
71 ba = body_a->get_rid();
72 bb = body_b->get_rid();
73
74 Physics2DServer::get_singleton()->joint_disable_collisions_between_bodies(joint, exclude_from_collision);
75 }
76
set_node_a(const NodePath & p_node_a)77 void Joint2D::set_node_a(const NodePath &p_node_a) {
78
79 if (a == p_node_a)
80 return;
81
82 a = p_node_a;
83 _update_joint();
84 }
85
get_node_a() const86 NodePath Joint2D::get_node_a() const {
87
88 return a;
89 }
90
set_node_b(const NodePath & p_node_b)91 void Joint2D::set_node_b(const NodePath &p_node_b) {
92
93 if (b == p_node_b)
94 return;
95 b = p_node_b;
96 _update_joint();
97 }
get_node_b() const98 NodePath Joint2D::get_node_b() const {
99
100 return b;
101 }
102
_notification(int p_what)103 void Joint2D::_notification(int p_what) {
104
105 switch (p_what) {
106
107 case NOTIFICATION_READY: {
108 _update_joint();
109 } break;
110 case NOTIFICATION_EXIT_TREE: {
111 if (joint.is_valid()) {
112 _update_joint(true);
113 }
114 } break;
115 }
116 }
117
set_bias(real_t p_bias)118 void Joint2D::set_bias(real_t p_bias) {
119
120 bias = p_bias;
121 if (joint.is_valid())
122 Physics2DServer::get_singleton()->get_singleton()->joint_set_param(joint, Physics2DServer::JOINT_PARAM_BIAS, bias);
123 }
124
get_bias() const125 real_t Joint2D::get_bias() const {
126
127 return bias;
128 }
129
set_exclude_nodes_from_collision(bool p_enable)130 void Joint2D::set_exclude_nodes_from_collision(bool p_enable) {
131
132 if (exclude_from_collision == p_enable)
133 return;
134
135 _update_joint(true);
136 exclude_from_collision = p_enable;
137 _update_joint();
138 }
139
get_exclude_nodes_from_collision() const140 bool Joint2D::get_exclude_nodes_from_collision() const {
141
142 return exclude_from_collision;
143 }
144
_bind_methods()145 void Joint2D::_bind_methods() {
146
147 ClassDB::bind_method(D_METHOD("set_node_a", "node"), &Joint2D::set_node_a);
148 ClassDB::bind_method(D_METHOD("get_node_a"), &Joint2D::get_node_a);
149
150 ClassDB::bind_method(D_METHOD("set_node_b", "node"), &Joint2D::set_node_b);
151 ClassDB::bind_method(D_METHOD("get_node_b"), &Joint2D::get_node_b);
152
153 ClassDB::bind_method(D_METHOD("set_bias", "bias"), &Joint2D::set_bias);
154 ClassDB::bind_method(D_METHOD("get_bias"), &Joint2D::get_bias);
155
156 ClassDB::bind_method(D_METHOD("set_exclude_nodes_from_collision", "enable"), &Joint2D::set_exclude_nodes_from_collision);
157 ClassDB::bind_method(D_METHOD("get_exclude_nodes_from_collision"), &Joint2D::get_exclude_nodes_from_collision);
158
159 ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "node_a", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "CollisionObject2D"), "set_node_a", "get_node_a");
160 ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "node_b", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "CollisionObject2D"), "set_node_b", "get_node_b");
161 ADD_PROPERTY(PropertyInfo(Variant::REAL, "bias", PROPERTY_HINT_RANGE, "0,0.9,0.001"), "set_bias", "get_bias");
162 ADD_PROPERTY(PropertyInfo(Variant::BOOL, "disable_collision"), "set_exclude_nodes_from_collision", "get_exclude_nodes_from_collision");
163 }
164
Joint2D()165 Joint2D::Joint2D() {
166
167 bias = 0;
168 exclude_from_collision = true;
169 }
170
171 ///////////////////////////////////////////////////////////////////////////////
172 ///////////////////////////////////////////////////////////////////////////////
173 ///////////////////////////////////////////////////////////////////////////////
174
_notification(int p_what)175 void PinJoint2D::_notification(int p_what) {
176
177 switch (p_what) {
178 case NOTIFICATION_DRAW: {
179
180 if (!is_inside_tree())
181 break;
182
183 if (!Engine::get_singleton()->is_editor_hint() && !get_tree()->is_debugging_collisions_hint()) {
184 break;
185 }
186
187 draw_line(Point2(-10, 0), Point2(+10, 0), Color(0.7, 0.6, 0.0, 0.5), 3);
188 draw_line(Point2(0, -10), Point2(0, +10), Color(0.7, 0.6, 0.0, 0.5), 3);
189 } break;
190 }
191 }
192
_configure_joint(PhysicsBody2D * body_a,PhysicsBody2D * body_b)193 RID PinJoint2D::_configure_joint(PhysicsBody2D *body_a, PhysicsBody2D *body_b) {
194
195 RID pj = Physics2DServer::get_singleton()->pin_joint_create(get_global_transform().get_origin(), body_a->get_rid(), body_b ? body_b->get_rid() : RID());
196 Physics2DServer::get_singleton()->pin_joint_set_param(pj, Physics2DServer::PIN_JOINT_SOFTNESS, softness);
197 return pj;
198 }
199
set_softness(real_t p_softness)200 void PinJoint2D::set_softness(real_t p_softness) {
201
202 softness = p_softness;
203 update();
204 if (get_joint().is_valid())
205 Physics2DServer::get_singleton()->pin_joint_set_param(get_joint(), Physics2DServer::PIN_JOINT_SOFTNESS, p_softness);
206 }
207
get_softness() const208 real_t PinJoint2D::get_softness() const {
209
210 return softness;
211 }
212
_bind_methods()213 void PinJoint2D::_bind_methods() {
214
215 ClassDB::bind_method(D_METHOD("set_softness", "softness"), &PinJoint2D::set_softness);
216 ClassDB::bind_method(D_METHOD("get_softness"), &PinJoint2D::get_softness);
217
218 ADD_PROPERTY(PropertyInfo(Variant::REAL, "softness", PROPERTY_HINT_EXP_RANGE, "0.00,16,0.01"), "set_softness", "get_softness");
219 }
220
PinJoint2D()221 PinJoint2D::PinJoint2D() {
222
223 softness = 0;
224 }
225
226 ///////////////////////////////////////////////////////////////////////////////
227 ///////////////////////////////////////////////////////////////////////////////
228 ///////////////////////////////////////////////////////////////////////////////
229
_notification(int p_what)230 void GrooveJoint2D::_notification(int p_what) {
231
232 switch (p_what) {
233 case NOTIFICATION_DRAW: {
234 if (!is_inside_tree())
235 break;
236
237 if (!Engine::get_singleton()->is_editor_hint() && !get_tree()->is_debugging_collisions_hint()) {
238 break;
239 }
240
241 draw_line(Point2(-10, 0), Point2(+10, 0), Color(0.7, 0.6, 0.0, 0.5), 3);
242 draw_line(Point2(-10, length), Point2(+10, length), Color(0.7, 0.6, 0.0, 0.5), 3);
243 draw_line(Point2(0, 0), Point2(0, length), Color(0.7, 0.6, 0.0, 0.5), 3);
244 draw_line(Point2(-10, initial_offset), Point2(+10, initial_offset), Color(0.8, 0.8, 0.9, 0.5), 5);
245 } break;
246 }
247 }
248
_configure_joint(PhysicsBody2D * body_a,PhysicsBody2D * body_b)249 RID GrooveJoint2D::_configure_joint(PhysicsBody2D *body_a, PhysicsBody2D *body_b) {
250
251 Transform2D gt = get_global_transform();
252 Vector2 groove_A1 = gt.get_origin();
253 Vector2 groove_A2 = gt.xform(Vector2(0, length));
254 Vector2 anchor_B = gt.xform(Vector2(0, initial_offset));
255
256 return Physics2DServer::get_singleton()->groove_joint_create(groove_A1, groove_A2, anchor_B, body_a->get_rid(), body_b->get_rid());
257 }
258
set_length(real_t p_length)259 void GrooveJoint2D::set_length(real_t p_length) {
260
261 length = p_length;
262 update();
263 }
264
get_length() const265 real_t GrooveJoint2D::get_length() const {
266
267 return length;
268 }
269
set_initial_offset(real_t p_initial_offset)270 void GrooveJoint2D::set_initial_offset(real_t p_initial_offset) {
271
272 initial_offset = p_initial_offset;
273 update();
274 }
275
get_initial_offset() const276 real_t GrooveJoint2D::get_initial_offset() const {
277
278 return initial_offset;
279 }
280
_bind_methods()281 void GrooveJoint2D::_bind_methods() {
282
283 ClassDB::bind_method(D_METHOD("set_length", "length"), &GrooveJoint2D::set_length);
284 ClassDB::bind_method(D_METHOD("get_length"), &GrooveJoint2D::get_length);
285 ClassDB::bind_method(D_METHOD("set_initial_offset", "offset"), &GrooveJoint2D::set_initial_offset);
286 ClassDB::bind_method(D_METHOD("get_initial_offset"), &GrooveJoint2D::get_initial_offset);
287
288 ADD_PROPERTY(PropertyInfo(Variant::REAL, "length", PROPERTY_HINT_EXP_RANGE, "1,65535,1"), "set_length", "get_length");
289 ADD_PROPERTY(PropertyInfo(Variant::REAL, "initial_offset", PROPERTY_HINT_EXP_RANGE, "1,65535,1"), "set_initial_offset", "get_initial_offset");
290 }
291
GrooveJoint2D()292 GrooveJoint2D::GrooveJoint2D() {
293
294 length = 50;
295 initial_offset = 25;
296 }
297
298 ///////////////////////////////////////////////////////////////////////////////
299 ///////////////////////////////////////////////////////////////////////////////
300 ///////////////////////////////////////////////////////////////////////////////
301
_notification(int p_what)302 void DampedSpringJoint2D::_notification(int p_what) {
303
304 switch (p_what) {
305 case NOTIFICATION_DRAW: {
306
307 if (!is_inside_tree())
308 break;
309
310 if (!Engine::get_singleton()->is_editor_hint() && !get_tree()->is_debugging_collisions_hint()) {
311 break;
312 }
313
314 draw_line(Point2(-10, 0), Point2(+10, 0), Color(0.7, 0.6, 0.0, 0.5), 3);
315 draw_line(Point2(-10, length), Point2(+10, length), Color(0.7, 0.6, 0.0, 0.5), 3);
316 draw_line(Point2(0, 0), Point2(0, length), Color(0.7, 0.6, 0.0, 0.5), 3);
317 } break;
318 }
319 }
320
_configure_joint(PhysicsBody2D * body_a,PhysicsBody2D * body_b)321 RID DampedSpringJoint2D::_configure_joint(PhysicsBody2D *body_a, PhysicsBody2D *body_b) {
322
323 Transform2D gt = get_global_transform();
324 Vector2 anchor_A = gt.get_origin();
325 Vector2 anchor_B = gt.xform(Vector2(0, length));
326
327 RID dsj = Physics2DServer::get_singleton()->damped_spring_joint_create(anchor_A, anchor_B, body_a->get_rid(), body_b->get_rid());
328 if (rest_length)
329 Physics2DServer::get_singleton()->damped_string_joint_set_param(dsj, Physics2DServer::DAMPED_STRING_REST_LENGTH, rest_length);
330 Physics2DServer::get_singleton()->damped_string_joint_set_param(dsj, Physics2DServer::DAMPED_STRING_STIFFNESS, stiffness);
331 Physics2DServer::get_singleton()->damped_string_joint_set_param(dsj, Physics2DServer::DAMPED_STRING_DAMPING, damping);
332
333 return dsj;
334 }
335
set_length(real_t p_length)336 void DampedSpringJoint2D::set_length(real_t p_length) {
337
338 length = p_length;
339 update();
340 }
341
get_length() const342 real_t DampedSpringJoint2D::get_length() const {
343
344 return length;
345 }
346
set_rest_length(real_t p_rest_length)347 void DampedSpringJoint2D::set_rest_length(real_t p_rest_length) {
348
349 rest_length = p_rest_length;
350 update();
351 if (get_joint().is_valid())
352 Physics2DServer::get_singleton()->damped_string_joint_set_param(get_joint(), Physics2DServer::DAMPED_STRING_REST_LENGTH, p_rest_length ? p_rest_length : length);
353 }
354
get_rest_length() const355 real_t DampedSpringJoint2D::get_rest_length() const {
356
357 return rest_length;
358 }
359
set_stiffness(real_t p_stiffness)360 void DampedSpringJoint2D::set_stiffness(real_t p_stiffness) {
361
362 stiffness = p_stiffness;
363 update();
364 if (get_joint().is_valid())
365 Physics2DServer::get_singleton()->damped_string_joint_set_param(get_joint(), Physics2DServer::DAMPED_STRING_STIFFNESS, p_stiffness);
366 }
367
get_stiffness() const368 real_t DampedSpringJoint2D::get_stiffness() const {
369
370 return stiffness;
371 }
372
set_damping(real_t p_damping)373 void DampedSpringJoint2D::set_damping(real_t p_damping) {
374
375 damping = p_damping;
376 update();
377 if (get_joint().is_valid())
378 Physics2DServer::get_singleton()->damped_string_joint_set_param(get_joint(), Physics2DServer::DAMPED_STRING_DAMPING, p_damping);
379 }
380
get_damping() const381 real_t DampedSpringJoint2D::get_damping() const {
382
383 return damping;
384 }
385
_bind_methods()386 void DampedSpringJoint2D::_bind_methods() {
387
388 ClassDB::bind_method(D_METHOD("set_length", "length"), &DampedSpringJoint2D::set_length);
389 ClassDB::bind_method(D_METHOD("get_length"), &DampedSpringJoint2D::get_length);
390 ClassDB::bind_method(D_METHOD("set_rest_length", "rest_length"), &DampedSpringJoint2D::set_rest_length);
391 ClassDB::bind_method(D_METHOD("get_rest_length"), &DampedSpringJoint2D::get_rest_length);
392 ClassDB::bind_method(D_METHOD("set_stiffness", "stiffness"), &DampedSpringJoint2D::set_stiffness);
393 ClassDB::bind_method(D_METHOD("get_stiffness"), &DampedSpringJoint2D::get_stiffness);
394 ClassDB::bind_method(D_METHOD("set_damping", "damping"), &DampedSpringJoint2D::set_damping);
395 ClassDB::bind_method(D_METHOD("get_damping"), &DampedSpringJoint2D::get_damping);
396
397 ADD_PROPERTY(PropertyInfo(Variant::REAL, "length", PROPERTY_HINT_EXP_RANGE, "1,65535,1"), "set_length", "get_length");
398 ADD_PROPERTY(PropertyInfo(Variant::REAL, "rest_length", PROPERTY_HINT_EXP_RANGE, "0,65535,1"), "set_rest_length", "get_rest_length");
399 ADD_PROPERTY(PropertyInfo(Variant::REAL, "stiffness", PROPERTY_HINT_EXP_RANGE, "0.1,64,0.1"), "set_stiffness", "get_stiffness");
400 ADD_PROPERTY(PropertyInfo(Variant::REAL, "damping", PROPERTY_HINT_EXP_RANGE, "0.01,16,0.01"), "set_damping", "get_damping");
401 }
402
DampedSpringJoint2D()403 DampedSpringJoint2D::DampedSpringJoint2D() {
404
405 length = 50;
406 rest_length = 0;
407 stiffness = 20;
408 damping = 1;
409 }
410