206c6e19c4113aa8f14fdad3fdd29a01ea136ac3
[blender.git] / source / blender / makesrna / intern / rna_rigidbody.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Blender Foundation 2013, Joshua Leung, Sergej Reich
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file rna_rigidbody.c
24  *  \ingroup rna
25  *  \brief RNA property definitions for Rigid Body datatypes
26  */
27
28 #include <stdlib.h>
29 #include <string.h>
30
31 #include "RNA_define.h"
32
33 #include "rna_internal.h"
34
35 #include "DNA_group_types.h"
36 #include "DNA_object_types.h"
37 #include "DNA_rigidbody_types.h"
38 #include "DNA_scene_types.h"
39
40 #include "BLI_utildefines.h"
41 #include "BLI_math.h"
42
43 #include "WM_types.h"
44
45 /* roles of objects in RigidBody Sims */
46 EnumPropertyItem rigidbody_ob_type_items[] = {
47         {RBO_TYPE_ACTIVE, "ACTIVE", 0, "Active", "Object is directly controlled by simulation results"},
48         {RBO_TYPE_PASSIVE, "PASSIVE", 0, "Passive", "Object is directly controlled by animation system"},
49         {0, NULL, 0, NULL, NULL}};
50
51 /* collision shapes of objects in rigid body sim */
52 EnumPropertyItem rigidbody_ob_shape_items[] = {
53         {RB_SHAPE_BOX, "BOX", ICON_MESH_CUBE, "Box", "Box-like shapes (i.e. cubes), including planes (i.e. ground planes)"},
54         {RB_SHAPE_SPHERE, "SPHERE", ICON_MESH_UVSPHERE, "Sphere", ""},
55         {RB_SHAPE_CAPSULE, "CAPSULE", ICON_OUTLINER_OB_META, "Capsule", ""},
56         {RB_SHAPE_CYLINDER, "CYLINDER", ICON_MESH_CYLINDER, "Cylinder", ""},
57         {RB_SHAPE_CONE, "CONE", ICON_MESH_CONE, "Cone", ""},
58         {RB_SHAPE_CONVEXH, "CONVEX_HULL", ICON_MESH_ICOSPHERE, "Convex Hull", "A mesh-like surface encompassing (i.e. shrinkwrap over) all verts. Best results with fewer vertices"},
59         {RB_SHAPE_TRIMESH, "MESH", ICON_MESH_MONKEY, "Mesh", "Mesh consisting of triangles only, allowing for more detailed interactions than convex hulls"},
60         {0, NULL, 0, NULL, NULL}};
61
62 /* collision shapes of constraints in rigid body sim */
63 EnumPropertyItem rigidbody_con_type_items[] = {
64         {RBC_TYPE_FIXED, "FIXED", ICON_FORCE_FORCE, "Fixed", "Glues rigid bodies together"},
65         {RBC_TYPE_POINT, "POINT", ICON_FORCE_FORCE, "Point", "Constrains rigid bodies to move aound common pivot point"},
66         {RBC_TYPE_HINGE, "HINGE", ICON_FORCE_FORCE, "Hinge", "Restricts rigid body rotation to one axis"},
67         {RBC_TYPE_SLIDER, "SLIDER", ICON_FORCE_FORCE, "Slider", "Restricts rigid boddy translation to one axis"},
68         {RBC_TYPE_PISTON, "PISTON", ICON_FORCE_FORCE, "Piston", "Restricts rigid boddy translation and rotation to one axis"},
69         {RBC_TYPE_6DOF, "GENERIC", ICON_FORCE_FORCE, "Generic", "Restricts translation and rotation to specified axes"},
70         {0, NULL, 0, NULL, NULL}};
71
72
73 #ifdef RNA_RUNTIME
74
75 #include "RBI_api.h"
76
77 #include "BKE_depsgraph.h"
78 #include "BKE_rigidbody.h"
79
80 #define RB_FLAG_SET(dest, value, flag) { \
81         if (value) \
82                 dest |= flag; \
83         else \
84                 dest &= ~flag; \
85 }
86
87
88 /* ******************************** */
89
90 static void rna_RigidBodyWorld_reset(Main *bmain, Scene *scene, PointerRNA *ptr)
91 {
92         RigidBodyWorld *rbw = (RigidBodyWorld *)ptr->data;
93         
94         BKE_rigidbody_cache_reset(rbw);
95 }
96
97 static char *rna_RigidBodyWorld_path(PointerRNA *ptr)
98 {       
99         return BLI_sprintfN("rigidbody_world");
100 }
101
102 static void rna_RigidBodyWorld_num_solver_iterations_set(PointerRNA *ptr, int value)
103 {
104         RigidBodyWorld *rbw = (RigidBodyWorld *)ptr->data;
105         
106         rbw->num_solver_iterations = value;
107         
108         if (rbw->physics_world)
109                 RB_dworld_set_solver_iterations(rbw->physics_world, value);
110 }
111
112 static void rna_RigidBodyWorld_split_impulse_set(PointerRNA *ptr, int value)
113 {
114         RigidBodyWorld *rbw = (RigidBodyWorld *)ptr->data;
115         
116         RB_FLAG_SET(rbw->flag, value, RBW_FLAG_USE_SPLIT_IMPULSE);
117         
118         if (rbw->physics_world)
119                 RB_dworld_set_split_impulse(rbw->physics_world, value);
120 }
121
122 /* ******************************** */
123
124 static void rna_RigidBodyOb_reset(Main *bmain, Scene *scene, PointerRNA *ptr)
125 {
126         RigidBodyWorld *rbw = scene->rigidbody_world;
127         
128         BKE_rigidbody_cache_reset(rbw);
129 }
130
131 static void rna_RigidBodyOb_shape_reset(Main *bmain, Scene *scene, PointerRNA *ptr)
132 {
133         RigidBodyWorld *rbw = scene->rigidbody_world;
134         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
135         
136         BKE_rigidbody_cache_reset(rbw);
137         if (rbo->physics_shape)
138                 rbo->flag |= RBO_FLAG_NEEDS_RESHAPE;
139 }
140
141 static char *rna_RigidBodyOb_path(PointerRNA *ptr)
142 {
143         /* NOTE: this hardcoded path should work as long as only Objects have this */
144         return BLI_sprintfN("rigid_body");
145 }
146
147 static void rna_RigidBodyOb_type_set(PointerRNA *ptr, int value)
148 {
149         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
150         
151         rbo->type = value;
152         rbo->flag |= RBO_FLAG_NEEDS_VALIDATE;
153         
154         /* do physics sim updates */
155         if (rbo->physics_object)
156                 RB_body_set_mass(rbo->physics_object, RBO_GET_MASS(rbo));
157 }
158
159 static void rna_RigidBodyOb_disabled_set(PointerRNA *ptr, int value)
160 {
161         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
162         
163         RB_FLAG_SET(rbo->flag, !value, RBO_FLAG_DISABLED);
164         
165         /* update kinematic state if necessary - only needed for active bodies */
166         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE)) {
167                 RB_body_set_mass(rbo->physics_object, RBO_GET_MASS(rbo));
168                 RB_body_set_kinematic_state(rbo->physics_object, !value);
169                 rbo->flag |= RBO_FLAG_NEEDS_VALIDATE;
170         }
171 }
172
173 static void rna_RigidBodyOb_shape_set(PointerRNA *ptr, int value)
174 {
175         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
176         Object *ob = (Object *)ptr->id.data;
177         
178         rbo->shape = value;
179         
180         /* force creation of new collision shape reflecting this */
181         BKE_rigidbody_validate_sim_shape(ob, TRUE);
182         
183         /* now tell RB sim about it */
184         if (rbo->physics_object && rbo->physics_shape)
185                 RB_body_set_collision_shape(rbo->physics_object, rbo->physics_shape);
186 }
187
188
189 static void rna_RigidBodyOb_mass_set(PointerRNA *ptr, float value)
190 {
191         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
192         
193         rbo->mass = value;
194         
195         /* only active bodies need mass update */
196         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE))
197                 RB_body_set_mass(rbo->physics_object, RBO_GET_MASS(rbo));
198 }
199
200 static void rna_RigidBodyOb_friction_set(PointerRNA *ptr, float value)
201 {
202         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
203         
204         rbo->friction = value;
205         
206         if (rbo->physics_object)
207                 RB_body_set_friction(rbo->physics_object, value);
208 }
209
210 static void rna_RigidBodyOb_restitution_set(PointerRNA *ptr, float value)
211 {
212         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
213         
214         rbo->restitution = value;
215         
216         if (rbo->physics_object)
217                 RB_body_set_restitution(rbo->physics_object, value);
218 }
219
220 static void rna_RigidBodyOb_collision_margin_set(PointerRNA *ptr, float value)
221 {
222         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
223         
224         rbo->margin = value;
225         
226         if (rbo->physics_shape)
227                 RB_shape_set_margin(rbo->physics_shape, RBO_GET_MARGIN(rbo));
228 }
229
230 static void rna_RigidBodyOb_kinematic_state_set(PointerRNA *ptr, int value)
231 {
232         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
233         
234         RB_FLAG_SET(rbo->flag, value, RBO_FLAG_KINEMATIC);
235         
236         /* update kinematic state if necessary */
237         if (rbo->physics_object) {
238                 RB_body_set_mass(rbo->physics_object, RBO_GET_MASS(rbo));
239                 RB_body_set_kinematic_state(rbo->physics_object, value);
240                 rbo->flag |= RBO_FLAG_NEEDS_VALIDATE;
241         }
242 }
243
244 static void rna_RigidBodyOb_activation_state_set(PointerRNA *ptr, int value)
245 {
246         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
247         
248         RB_FLAG_SET(rbo->flag, value, RBO_FLAG_USE_DEACTIVATION);
249         
250         /* update activation state if necessary - only active bodies can be deactivated */
251         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE))
252                 RB_body_set_activation_state(rbo->physics_object, value);
253 }
254
255 static void rna_RigidBodyOb_linear_sleepThresh_set(PointerRNA *ptr, float value)
256 {
257         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
258         
259         rbo->lin_sleep_thresh = value;
260         
261         /* only active bodies need sleep threshold update */
262         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE))
263                 RB_body_set_linear_sleep_thresh(rbo->physics_object, value);
264 }
265
266 static void rna_RigidBodyOb_angular_sleepThresh_set(PointerRNA *ptr, float value)
267 {
268         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
269         
270         rbo->ang_sleep_thresh = value;
271         
272         /* only active bodies need sleep threshold update */
273         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE))
274                 RB_body_set_angular_sleep_thresh(rbo->physics_object, value);
275 }
276
277 static void rna_RigidBodyOb_linear_damping_set(PointerRNA *ptr, float value)
278 {
279         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
280         
281         rbo->lin_damping = value;
282         
283         /* only active bodies need damping update */
284         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE))
285                 RB_body_set_linear_damping(rbo->physics_object, value);
286 }
287
288 static void rna_RigidBodyOb_angular_damping_set(PointerRNA *ptr, float value)
289 {
290         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
291         
292         rbo->ang_damping = value;
293         
294         /* only active bodies need damping update */
295         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE))
296                 RB_body_set_angular_damping(rbo->physics_object, value);
297 }
298
299 static char *rna_RigidBodyCon_path(PointerRNA *ptr)
300 {
301         /* NOTE: this hardcoded path should work as long as only Objects have this */
302         return BLI_sprintfN("rigid_body_constraint");
303 }
304
305 static void rna_RigidBodyCon_type_set(PointerRNA *ptr, int value)
306 {
307         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
308
309         rbc->type = value;
310         rbc->flag |= RBC_FLAG_NEEDS_VALIDATE;
311 }
312
313 static void rna_RigidBodyCon_enabled_set(PointerRNA *ptr, int value)
314 {
315         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
316
317         RB_FLAG_SET(rbc->flag, value, RBC_FLAG_ENABLED);
318
319         if (rbc->physics_constraint)
320                 RB_constraint_set_enabled(rbc->physics_constraint, value);
321 }
322
323 static void rna_RigidBodyCon_disable_collisions_set(PointerRNA *ptr, int value)
324 {
325         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
326
327         RB_FLAG_SET(rbc->flag, value, RBC_FLAG_DISABLE_COLLISIONS);
328
329         rbc->flag |= RBC_FLAG_NEEDS_VALIDATE;
330 }
331
332 static void rna_RigidBodyCon_use_breaking_set(PointerRNA *ptr, int value)
333 {
334         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
335
336         if (value) {
337                 rbc->flag |= RBC_FLAG_USE_BREAKING;
338                 if (rbc->physics_constraint)
339                         RB_constraint_set_breaking_threshold(rbc->physics_constraint, rbc->breaking_threshold);
340         }
341         else {
342                 rbc->flag &= ~RBC_FLAG_USE_BREAKING;
343                 if (rbc->physics_constraint)
344                         RB_constraint_set_breaking_threshold(rbc->physics_constraint, FLT_MAX);
345         }
346 }
347
348 static void rna_RigidBodyCon_breaking_threshold_set(PointerRNA *ptr, float value)
349 {
350         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
351
352         rbc->breaking_threshold = value;
353
354         if (rbc->physics_constraint && (rbc->flag & RBC_FLAG_USE_BREAKING))
355                 RB_constraint_set_breaking_threshold(rbc->physics_constraint, value);
356 }
357
358 static void rna_RigidBodyCon_override_solver_iterations_set(PointerRNA *ptr, int value)
359 {
360         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
361
362         if (value) {
363                 rbc->flag |= RBC_FLAG_OVERRIDE_SOLVER_ITERATIONS;
364                 if (rbc->physics_constraint)
365                         RB_constraint_set_solver_iterations(rbc->physics_constraint, rbc->num_solver_iterations);
366         }
367         else {
368                 rbc->flag &= ~RBC_FLAG_OVERRIDE_SOLVER_ITERATIONS;
369                 if (rbc->physics_constraint)
370                         RB_constraint_set_solver_iterations(rbc->physics_constraint, -1);
371         }
372 }
373
374 static void rna_RigidBodyCon_num_solver_iterations_set(PointerRNA *ptr, int value)
375 {
376         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
377
378         rbc->num_solver_iterations = value;
379
380         if (rbc->physics_constraint && (rbc->flag & RBC_FLAG_OVERRIDE_SOLVER_ITERATIONS))
381                 RB_constraint_set_solver_iterations(rbc->physics_constraint, value);
382 }
383
384 #else
385
386 static void rna_def_rigidbody_world(BlenderRNA *brna)
387 {
388         StructRNA *srna;
389         PropertyRNA *prop;
390         
391         srna = RNA_def_struct(brna, "RigidBodyWorld", NULL);
392         RNA_def_struct_sdna(srna, "RigidBodyWorld");
393         RNA_def_struct_ui_text(srna, "Rigid Body World", "Self-contained rigid body simulation environment and settings");
394         RNA_def_struct_path_func(srna, "rna_RigidBodyWorld_path");
395         
396         /* groups */
397         prop = RNA_def_property(srna, "group", PROP_POINTER, PROP_NONE);
398         RNA_def_property_struct_type(prop, "Group");
399         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_ID_SELF_CHECK);
400         RNA_def_property_ui_text(prop, "Group", "Group containing objects participating in this simulation");
401         RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
402
403         prop = RNA_def_property(srna, "constraints", PROP_POINTER, PROP_NONE);
404         RNA_def_property_struct_type(prop, "Group");
405         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_ID_SELF_CHECK);
406         RNA_def_property_ui_text(prop, "Constraints", "Group containing rigid body constraint objects");
407         RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
408         
409         /* booleans */
410         prop = RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
411         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", RBW_FLAG_MUTED);
412         RNA_def_property_ui_text(prop, "Enabled", "Simulation will be evaluated");
413         RNA_def_property_update(prop, NC_SCENE, NULL);
414         
415         /* time scale */
416         prop = RNA_def_property(srna, "time_scale", PROP_FLOAT, PROP_NONE);
417         RNA_def_property_float_sdna(prop, NULL, "time_scale");
418         RNA_def_property_range(prop, 0.0f, 100.0f);
419         RNA_def_property_ui_range(prop, 0.0f, 10.0f, 1, 3);
420         RNA_def_property_float_default(prop, 1.0f);
421         RNA_def_property_ui_text(prop, "Time Scale", "Changes the speed of the simulation");
422         RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
423         
424         /* timestep */
425         prop = RNA_def_property(srna, "steps_per_second", PROP_INT, PROP_NONE);
426         RNA_def_property_int_sdna(prop, NULL, "steps_per_second");
427         RNA_def_property_range(prop, 1, SHRT_MAX);
428         RNA_def_property_ui_range(prop, 60, 1000, 1, 0);
429         RNA_def_property_int_default(prop, 60);
430         RNA_def_property_ui_text(prop, "Steps Per Second", "Number of simulation steps taken per second (higher values are more accurate but slower)");
431         RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
432         
433         /* constraint solver iterations */
434         prop = RNA_def_property(srna, "num_solver_iterations", PROP_INT, PROP_NONE);
435         RNA_def_property_int_sdna(prop, NULL, "num_solver_iterations");
436         RNA_def_property_range(prop, 1, 1000);
437         RNA_def_property_ui_range(prop, 10, 100, 1, 0);
438         RNA_def_property_int_default(prop, 10);
439         RNA_def_property_int_funcs(prop, NULL, "rna_RigidBodyWorld_num_solver_iterations_set", NULL);
440         RNA_def_property_ui_text(prop, "Solver Iterations", "Number of constraint solver iterations made per simulation step (higher values are more accurate but slower)");
441         RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
442         
443         /* split impulse */
444         prop = RNA_def_property(srna, "use_split_impulse", PROP_BOOLEAN, PROP_NONE);
445         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBW_FLAG_USE_SPLIT_IMPULSE);
446         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyWorld_split_impulse_set");
447         RNA_def_property_ui_text(prop, "Split Impulse", "Reduces extra velocity that can build up when objects collide (lowers simulation stabilty a litte so use only when necessary)");
448         RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
449
450         /* cache */
451         prop = RNA_def_property(srna, "point_cache", PROP_POINTER, PROP_NONE);
452         RNA_def_property_flag(prop, PROP_NEVER_NULL);
453         RNA_def_property_pointer_sdna(prop, NULL, "pointcache");
454         RNA_def_property_ui_text(prop, "Point Cache", "");
455
456         /* effector weights */
457         prop = RNA_def_property(srna, "effector_weights", PROP_POINTER, PROP_NONE);
458         RNA_def_property_struct_type(prop, "EffectorWeights");
459         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
460         RNA_def_property_ui_text(prop, "Effector Weights", "");
461 }
462
463 static void rna_def_rigidbody_object(BlenderRNA *brna)
464 {
465         StructRNA *srna;
466         PropertyRNA *prop;
467         
468         
469         srna = RNA_def_struct(brna, "RigidBodyObject", NULL);
470         RNA_def_struct_sdna(srna, "RigidBodyOb");
471         RNA_def_struct_ui_text(srna, "Rigid Body Object", "Settings for object participating in Rigid Body Simulation");
472         RNA_def_struct_path_func(srna, "rna_RigidBodyOb_path");
473         
474         /* Enums */
475         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
476         RNA_def_property_enum_sdna(prop, NULL, "type");
477         RNA_def_property_enum_items(prop, rigidbody_ob_type_items);
478         RNA_def_property_enum_funcs(prop, NULL, "rna_RigidBodyOb_type_set", NULL);
479         RNA_def_property_ui_text(prop, "Type", "Role of object in Rigid Body Simulations");
480         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
481         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
482         
483         /* booleans */
484         prop = RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
485         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", RBO_FLAG_DISABLED);
486         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyOb_disabled_set");
487         RNA_def_property_ui_text(prop, "Enabled", "Rigid Body actively participated in the simulation");
488         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
489         
490         prop = RNA_def_property(srna, "collision_shape", PROP_ENUM, PROP_NONE);
491         RNA_def_property_enum_sdna(prop, NULL, "shape");
492         RNA_def_property_enum_items(prop, rigidbody_ob_shape_items);
493         RNA_def_property_enum_funcs(prop, NULL, "rna_RigidBodyOb_shape_set", NULL);
494         RNA_def_property_ui_text(prop, "Collision Shape", "Collision Shape of object in Rigid Body Simulations");
495         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
496         
497         prop = RNA_def_property(srna, "kinematic", PROP_BOOLEAN, PROP_NONE);
498         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBO_FLAG_KINEMATIC);
499         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyOb_kinematic_state_set");
500         RNA_def_property_ui_text(prop, "Kinematic", "Allows rigid body to be controlled by the animation system");
501         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
502         
503         /* Physics Parameters */
504         prop = RNA_def_property(srna, "mass", PROP_FLOAT, PROP_UNIT_MASS);
505         RNA_def_property_float_sdna(prop, NULL, "mass");
506         RNA_def_property_range(prop, 0.001f, FLT_MAX); // range must always be positive (and non-zero)
507         RNA_def_property_float_default(prop, 1.0f);
508         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_mass_set", NULL);
509         RNA_def_property_ui_text(prop, "Mass", "How much the object 'weighs' irrespective of gravity");
510         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
511         
512         /* Dynamics Parameters - Activation */
513         // TODO: define and figure out how to implement these
514         
515         /* Dynamics Parameters - Deactivation */
516         prop = RNA_def_property(srna, "use_deactivation", PROP_BOOLEAN, PROP_NONE);
517         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBO_FLAG_USE_DEACTIVATION);
518         RNA_def_property_boolean_default(prop, TRUE);
519         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyOb_activation_state_set");
520         RNA_def_property_ui_text(prop, "Enable Deactivation", "Enables deactivation of resting rigid bodies (increases performance and stability but can cause glitches)");
521         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
522         
523         prop = RNA_def_property(srna, "start_deactivated", PROP_BOOLEAN, PROP_NONE);
524         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBO_FLAG_START_DEACTIVATED);
525         RNA_def_property_ui_text(prop, "Start Deactivated", "Deactivates rigid body at the start of the simulation");
526         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
527         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
528         
529         prop = RNA_def_property(srna, "deactivate_linear_velocity", PROP_FLOAT, PROP_UNIT_VELOCITY);
530         RNA_def_property_float_sdna(prop, NULL, "lin_sleep_thresh");
531         RNA_def_property_range(prop, FLT_MIN, FLT_MAX); // range must always be positive (and non-zero)
532         RNA_def_property_float_default(prop, 0.4f);
533         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_linear_sleepThresh_set", NULL);
534         RNA_def_property_ui_text(prop, "Linear Velocity Deactivation Threshold", "Linear Velocity below which simulation stops simulating object");
535         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
536         
537         prop = RNA_def_property(srna, "deactivate_angular_velocity", PROP_FLOAT, PROP_UNIT_VELOCITY);
538         RNA_def_property_float_sdna(prop, NULL, "ang_sleep_thresh");
539         RNA_def_property_range(prop, FLT_MIN, FLT_MAX); // range must always be positive (and non-zero)
540         RNA_def_property_float_default(prop, 0.5f);
541         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_angular_sleepThresh_set", NULL);
542         RNA_def_property_ui_text(prop, "Angular Velocity Deactivation Threshold", "Angular Velocity below which simulation stops simulating object");
543         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
544         
545         /* Dynamics Parameters - Damping Parameters */
546         prop = RNA_def_property(srna, "linear_damping", PROP_FLOAT, PROP_FACTOR);
547         RNA_def_property_float_sdna(prop, NULL, "lin_damping");
548         RNA_def_property_range(prop, 0.0f, 1.0f);
549         RNA_def_property_float_default(prop, 0.04f);
550         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_linear_damping_set", NULL);
551         RNA_def_property_ui_text(prop, "Linear Damping", "Amount of linear velocity that is lost over time");
552         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
553         
554         prop = RNA_def_property(srna, "angular_damping", PROP_FLOAT, PROP_FACTOR);
555         RNA_def_property_float_sdna(prop, NULL, "ang_damping");
556         RNA_def_property_range(prop, 0.0f, 1.0f);
557         RNA_def_property_float_default(prop, 0.1f);
558         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_angular_damping_set", NULL);
559         RNA_def_property_ui_text(prop, "Angular Damping", "Amount of angular velocity that is lost over time");
560         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
561         
562         /* Collision Parameters - Surface Parameters */
563         prop = RNA_def_property(srna, "friction", PROP_FLOAT, PROP_FACTOR);
564         RNA_def_property_float_sdna(prop, NULL, "friction");
565         RNA_def_property_range(prop, 0.0f, FLT_MAX);
566         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 1, 3);
567         RNA_def_property_float_default(prop, 0.5f);
568         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_friction_set", NULL);
569         RNA_def_property_ui_text(prop, "Friction", "Resistance of object to movement");
570         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
571         
572         prop = RNA_def_property(srna, "restitution", PROP_FLOAT, PROP_FACTOR);
573         RNA_def_property_float_sdna(prop, NULL, "restitution");
574         RNA_def_property_range(prop, 0.0f, FLT_MAX);
575         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 1, 3);
576         RNA_def_property_float_default(prop, 0.0f);
577         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_restitution_set", NULL);
578         RNA_def_property_ui_text(prop, "Restitution", "Tendency of object to bounce after colliding with another (0 = stays still, 1 = perfectly elastic)");
579         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
580         
581         /* Collision Parameters - Sensitivity */
582         prop = RNA_def_property(srna, "use_margin", PROP_BOOLEAN, PROP_NONE);
583         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBO_FLAG_USE_MARGIN);
584         RNA_def_property_boolean_default(prop, FALSE);
585         RNA_def_property_ui_text(prop, "Collision Margin", "Use custom collision margin (some shapes will have a visible gap around them)");
586         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_shape_reset");
587         
588         prop = RNA_def_property(srna, "collision_margin", PROP_FLOAT, PROP_UNIT_LENGTH);
589         RNA_def_property_float_sdna(prop, NULL, "margin");
590         RNA_def_property_range(prop, 0.0f, 1.0f);
591         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.01, 3);
592         RNA_def_property_float_default(prop, 0.04f);
593         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_collision_margin_set", NULL);
594         RNA_def_property_ui_text(prop, "Collision Margin", "Threshold of distance near surface where collisions are still considered (best results when non-zero)");
595         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_shape_reset");
596         
597         prop = RNA_def_property(srna, "collision_groups", PROP_BOOLEAN, PROP_LAYER_MEMBER);
598         RNA_def_property_boolean_sdna(prop, NULL, "col_groups", 1);
599         RNA_def_property_array(prop, 20);
600         RNA_def_property_ui_text(prop, "Collison Groups", "Collision Groups Rigid Body belongs to");
601         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
602         RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
603 }
604
605 static void rna_def_rigidbody_constraint(BlenderRNA *brna)
606 {
607         StructRNA *srna;
608         PropertyRNA *prop;
609
610         srna = RNA_def_struct(brna, "RigidBodyConstraint", NULL);
611         RNA_def_struct_sdna(srna, "RigidBodyCon");
612         RNA_def_struct_ui_text(srna, "Rigid Body Constraint", "Constraint influencing Objects inside Rigid Body Simulation");
613         RNA_def_struct_path_func(srna, "rna_RigidBodyCon_path");
614
615         /* Enums */
616         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
617         RNA_def_property_enum_sdna(prop, NULL, "type");
618         RNA_def_property_enum_items(prop, rigidbody_con_type_items);
619         RNA_def_property_enum_funcs(prop, NULL, "rna_RigidBodyCon_type_set", NULL);
620         RNA_def_property_ui_text(prop, "Type", "Type of Rigid Body Constraint");
621         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
622         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
623
624         prop = RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
625         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_ENABLED);
626         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyCon_enabled_set");
627         RNA_def_property_ui_text(prop, "Enabled", "Enable this constraint");
628         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
629
630         prop = RNA_def_property(srna, "disable_collisions", PROP_BOOLEAN, PROP_NONE);
631         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_DISABLE_COLLISIONS);
632         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyCon_disable_collisions_set");
633         RNA_def_property_ui_text(prop, "Disable Collisions", "Disables collisions between constrained ridid bodies");
634         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
635
636         prop = RNA_def_property(srna, "object1", PROP_POINTER, PROP_NONE);
637         RNA_def_property_pointer_sdna(prop, NULL, "ob1");
638         RNA_def_property_flag(prop, PROP_EDITABLE);
639         RNA_def_property_ui_text(prop, "Object 1", "First Rigid Body Object to be constrained");
640         RNA_def_property_flag(prop, PROP_EDITABLE);
641         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
642
643         prop = RNA_def_property(srna, "object2", PROP_POINTER, PROP_NONE);
644         RNA_def_property_pointer_sdna(prop, NULL, "ob2");
645         RNA_def_property_flag(prop, PROP_EDITABLE);
646         RNA_def_property_ui_text(prop, "Object 2", "Second Rigid Body Object to be constrained");
647         RNA_def_property_flag(prop, PROP_EDITABLE);
648         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
649
650         /* Breaking Threshold */
651         prop = RNA_def_property(srna, "use_breaking", PROP_BOOLEAN, PROP_NONE);
652         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_BREAKING);
653         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyCon_use_breaking_set");
654         RNA_def_property_ui_text(prop, "Breakable", "Constraint can be broaken if it receives an impulse above the threshold");
655         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
656
657         prop = RNA_def_property(srna, "breaking_threshold", PROP_FLOAT, PROP_NONE);
658         RNA_def_property_float_sdna(prop, NULL, "breaking_threshold");
659         RNA_def_property_range(prop, 0.0f, FLT_MAX);
660         RNA_def_property_ui_range(prop, 0.0f, 1000.0f, 100.0, 2);
661         RNA_def_property_float_default(prop, 10.0f);
662         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_breaking_threshold_set", NULL);
663         RNA_def_property_ui_text(prop, "Breaking Threshold", "Impulse threshold that must be reached for the constraint to break");
664         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
665
666         /* Solver Iterations */
667         prop = RNA_def_property(srna, "override_solver_iterations", PROP_BOOLEAN, PROP_NONE);
668         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_OVERRIDE_SOLVER_ITERATIONS);
669         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyCon_override_solver_iterations_set");
670         RNA_def_property_ui_text(prop, "Override Solver Iterations", "Overrides the number of solver iterations for this constraint");
671         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
672
673         prop = RNA_def_property(srna, "num_solver_iterations", PROP_INT, PROP_NONE);
674         RNA_def_property_int_sdna(prop, NULL, "num_solver_iterations");
675         RNA_def_property_range(prop, 1, 1000);
676         RNA_def_property_ui_range(prop, 1, 100, 1, 0);
677         RNA_def_property_int_default(prop, 10);
678         RNA_def_property_int_funcs(prop, NULL, "rna_RigidBodyCon_num_solver_iterations_set", NULL);
679         RNA_def_property_ui_text(prop, "Solver Iterations", "Number of constraint solver iterations made per simulation step (higher values are more accurate but slower)");
680         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
681
682         /* Limits */
683         prop = RNA_def_property(srna, "use_limit_lin_x", PROP_BOOLEAN, PROP_NONE);
684         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_LIN_X);
685         RNA_def_property_ui_text(prop, "X Axis", "Limits translation on x axis");
686         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
687
688         prop = RNA_def_property(srna, "use_limit_lin_y", PROP_BOOLEAN, PROP_NONE);
689         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_LIN_Y);
690         RNA_def_property_ui_text(prop, "Y Axis", "Limits translation on y axis");
691         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
692
693         prop = RNA_def_property(srna, "use_limit_lin_z", PROP_BOOLEAN, PROP_NONE);
694         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_LIN_Z);
695         RNA_def_property_ui_text(prop, "Z Axis", "Limits translation on z axis");
696         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
697
698         prop = RNA_def_property(srna, "use_limit_ang_x", PROP_BOOLEAN, PROP_NONE);
699         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_ANG_X);
700         RNA_def_property_ui_text(prop, "X Angle", "Limits rotation around x axis");
701         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
702
703         prop = RNA_def_property(srna, "use_limit_ang_y", PROP_BOOLEAN, PROP_NONE);
704         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_ANG_Y);
705         RNA_def_property_ui_text(prop, "Y Angle", "Limits rotation around y axis");
706         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
707
708         prop = RNA_def_property(srna, "use_limit_ang_z", PROP_BOOLEAN, PROP_NONE);
709         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_ANG_Z);
710         RNA_def_property_ui_text(prop, "Z Angle", "Limits rotation around z axis");
711         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
712
713         prop = RNA_def_property(srna, "limit_lin_x_lower", PROP_FLOAT, PROP_UNIT_LENGTH);
714         RNA_def_property_float_sdna(prop, NULL, "limit_lin_x_lower");
715         RNA_def_property_float_default(prop, -1.0f);
716         RNA_def_property_ui_text(prop, "Lower X Limit", "Lower limit of x axis translation");
717         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
718
719         prop = RNA_def_property(srna, "limit_lin_x_upper", PROP_FLOAT, PROP_UNIT_LENGTH);
720         RNA_def_property_float_sdna(prop, NULL, "limit_lin_x_upper");
721         RNA_def_property_float_default(prop, 1.0f);
722         RNA_def_property_ui_text(prop, "Upper X Limit", "Upper limit of x axis translation");
723         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
724
725         prop = RNA_def_property(srna, "limit_lin_y_lower", PROP_FLOAT, PROP_UNIT_LENGTH);
726         RNA_def_property_float_sdna(prop, NULL, "limit_lin_y_lower");
727         RNA_def_property_float_default(prop, -1.0f);
728         RNA_def_property_ui_text(prop, "Lower Y Limit", "Lower limit of y axis translation");
729         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
730
731         prop = RNA_def_property(srna, "limit_lin_y_upper", PROP_FLOAT, PROP_UNIT_LENGTH);
732         RNA_def_property_float_sdna(prop, NULL, "limit_lin_y_upper");
733         RNA_def_property_float_default(prop, 1.0f);
734         RNA_def_property_ui_text(prop, "Upper Y Limit", "Upper limit of y axis translation");
735         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
736
737         prop = RNA_def_property(srna, "limit_lin_z_lower", PROP_FLOAT, PROP_UNIT_LENGTH);
738         RNA_def_property_float_sdna(prop, NULL, "limit_lin_z_lower");
739         RNA_def_property_float_default(prop, -1.0f);
740         RNA_def_property_ui_text(prop, "Lower Z Limit", "Lower limit of z axis translation");
741         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
742
743         prop = RNA_def_property(srna, "limit_lin_z_upper", PROP_FLOAT, PROP_UNIT_LENGTH);
744         RNA_def_property_float_sdna(prop, NULL, "limit_lin_z_upper");
745         RNA_def_property_float_default(prop, 1.0f);
746         RNA_def_property_ui_text(prop, "Upper Z Limit", "Upper limit of z axis translation");
747         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
748
749         prop = RNA_def_property(srna, "limit_ang_x_lower", PROP_FLOAT, PROP_ANGLE);
750         RNA_def_property_float_sdna(prop, NULL, "limit_ang_x_lower");
751         RNA_def_property_range(prop, -M_PI * 2, M_PI * 2);
752         RNA_def_property_float_default(prop, -M_PI_4);
753         RNA_def_property_ui_text(prop, "Lower X Angle Limit", "Lower limit of x axis rotation");
754         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
755
756         prop = RNA_def_property(srna, "limit_ang_x_upper", PROP_FLOAT, PROP_ANGLE);
757         RNA_def_property_float_sdna(prop, NULL, "limit_ang_x_upper");
758         RNA_def_property_range(prop, -M_PI * 2, M_PI * 2);
759         RNA_def_property_float_default(prop, M_PI_4);
760         RNA_def_property_ui_text(prop, "Upper X Angle Limit", "Upper limit of x axis rotation");
761         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
762
763         prop = RNA_def_property(srna, "limit_ang_y_lower", PROP_FLOAT, PROP_ANGLE);
764         RNA_def_property_float_sdna(prop, NULL, "limit_ang_y_lower");
765         RNA_def_property_range(prop, -M_PI * 2, M_PI * 2);
766         RNA_def_property_float_default(prop, -M_PI_4);
767         RNA_def_property_ui_text(prop, "Lower Y Angle Limit", "Lower limit of y axis rotation");
768         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
769
770         prop = RNA_def_property(srna, "limit_ang_y_upper", PROP_FLOAT, PROP_ANGLE);
771         RNA_def_property_float_sdna(prop, NULL, "limit_ang_y_upper");
772         RNA_def_property_range(prop, -M_PI * 2, M_PI * 2);
773         RNA_def_property_float_default(prop, M_PI_4);
774         RNA_def_property_ui_text(prop, "Upper Y Angle Limit", "Upper limit of y axis rotation");
775         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
776
777         prop = RNA_def_property(srna, "limit_ang_z_lower", PROP_FLOAT, PROP_ANGLE);
778         RNA_def_property_float_sdna(prop, NULL, "limit_ang_z_lower");
779         RNA_def_property_range(prop, -M_PI * 2, M_PI * 2);
780         RNA_def_property_float_default(prop, -M_PI_4);
781         RNA_def_property_ui_text(prop, "Lower Z Angle Limit", "Lower limit of z axis rotation");
782         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
783
784         prop = RNA_def_property(srna, "limit_ang_z_upper", PROP_FLOAT, PROP_ANGLE);
785         RNA_def_property_float_sdna(prop, NULL, "limit_ang_z_upper");
786         RNA_def_property_range(prop, -M_PI * 2, M_PI * 2);
787         RNA_def_property_float_default(prop, M_PI_4);
788         RNA_def_property_ui_text(prop, "Upper Z Angle Limit", "Upper limit of z axis rotation");
789         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
790 }
791
792 void RNA_def_rigidbody(BlenderRNA *brna)
793 {
794         rna_def_rigidbody_world(brna);
795         rna_def_rigidbody_object(brna);
796         rna_def_rigidbody_constraint(brna);
797 }
798
799
800 #endif