1e0e250ac664398b000d7cd0afb704ce6caff3ce
[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
63 #ifdef RNA_RUNTIME
64
65 #include "RBI_api.h"
66
67 #include "BKE_depsgraph.h"
68 #include "BKE_rigidbody.h"
69
70 #define RB_FLAG_SET(dest, value, flag) { \
71         if (value) \
72                 dest |= flag; \
73         else \
74                 dest &= ~flag; \
75 }
76
77
78 /* ******************************** */
79
80 static void rna_RigidBodyWorld_reset(Main *bmain, Scene *scene, PointerRNA *ptr)
81 {
82         RigidBodyWorld *rbw = (RigidBodyWorld *)ptr->data;
83         
84         BKE_rigidbody_cache_reset(rbw);
85 }
86
87 static char *rna_RigidBodyWorld_path(PointerRNA *ptr)
88 {       
89         return BLI_sprintfN("rigidbody_world");
90 }
91
92 static void rna_RigidBodyWorld_num_solver_iterations_set(PointerRNA *ptr, int value)
93 {
94         RigidBodyWorld *rbw = (RigidBodyWorld *)ptr->data;
95         
96         rbw->num_solver_iterations = value;
97         
98         if (rbw->physics_world)
99                 RB_dworld_set_solver_iterations(rbw->physics_world, value);
100 }
101
102 static void rna_RigidBodyWorld_split_impulse_set(PointerRNA *ptr, int value)
103 {
104         RigidBodyWorld *rbw = (RigidBodyWorld *)ptr->data;
105         
106         RB_FLAG_SET(rbw->flag, value, RBW_FLAG_USE_SPLIT_IMPULSE);
107         
108         if (rbw->physics_world)
109                 RB_dworld_set_split_impulse(rbw->physics_world, value);
110 }
111
112 /* ******************************** */
113
114 static void rna_RigidBodyOb_reset(Main *bmain, Scene *scene, PointerRNA *ptr)
115 {
116         RigidBodyWorld *rbw = scene->rigidbody_world;
117         
118         BKE_rigidbody_cache_reset(rbw);
119 }
120
121 static void rna_RigidBodyOb_shape_reset(Main *bmain, Scene *scene, PointerRNA *ptr)
122 {
123         RigidBodyWorld *rbw = scene->rigidbody_world;
124         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
125         
126         BKE_rigidbody_cache_reset(rbw);
127         if (rbo->physics_shape)
128                 rbo->flag |= RBO_FLAG_NEEDS_RESHAPE;
129 }
130
131 static char *rna_RigidBodyOb_path(PointerRNA *ptr)
132 {
133         /* NOTE: this hardcoded path should work as long as only Objects have this */
134         return BLI_sprintfN("rigid_body");
135 }
136
137 static void rna_RigidBodyOb_type_set(PointerRNA *ptr, int value)
138 {
139         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
140         
141         rbo->type = value;
142         rbo->flag |= RBO_FLAG_NEEDS_VALIDATE;
143         
144         /* do physics sim updates */
145         if (rbo->physics_object)
146                 RB_body_set_mass(rbo->physics_object, RBO_GET_MASS(rbo));
147 }
148
149 static void rna_RigidBodyOb_disabled_set(PointerRNA *ptr, int value)
150 {
151         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
152         
153         RB_FLAG_SET(rbo->flag, !value, RBO_FLAG_DISABLED);
154         
155         /* update kinematic state if necessary - only needed for active bodies */
156         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE)) {
157                 RB_body_set_mass(rbo->physics_object, RBO_GET_MASS(rbo));
158                 RB_body_set_kinematic_state(rbo->physics_object, !value);
159                 rbo->flag |= RBO_FLAG_NEEDS_VALIDATE;
160         }
161 }
162
163 static void rna_RigidBodyOb_shape_set(PointerRNA *ptr, int value)
164 {
165         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
166         Object *ob = (Object *)ptr->id.data;
167         
168         rbo->shape = value;
169         
170         /* force creation of new collision shape reflecting this */
171         BKE_rigidbody_validate_sim_shape(ob, TRUE);
172         
173         /* now tell RB sim about it */
174         if (rbo->physics_object && rbo->physics_shape)
175                 RB_body_set_collision_shape(rbo->physics_object, rbo->physics_shape);
176 }
177
178
179 static void rna_RigidBodyOb_mass_set(PointerRNA *ptr, float value)
180 {
181         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
182         
183         rbo->mass = value;
184         
185         /* only active bodies need mass update */
186         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE))
187                 RB_body_set_mass(rbo->physics_object, RBO_GET_MASS(rbo));
188 }
189
190 static void rna_RigidBodyOb_friction_set(PointerRNA *ptr, float value)
191 {
192         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
193         
194         rbo->friction = value;
195         
196         if (rbo->physics_object)
197                 RB_body_set_friction(rbo->physics_object, value);
198 }
199
200 static void rna_RigidBodyOb_restitution_set(PointerRNA *ptr, float value)
201 {
202         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
203         
204         rbo->restitution = value;
205         
206         if (rbo->physics_object)
207                 RB_body_set_restitution(rbo->physics_object, value);
208 }
209
210 static void rna_RigidBodyOb_collision_margin_set(PointerRNA *ptr, float value)
211 {
212         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
213         
214         rbo->margin = value;
215         
216         if (rbo->physics_shape)
217                 RB_shape_set_margin(rbo->physics_shape, RBO_GET_MARGIN(rbo));
218 }
219
220 static void rna_RigidBodyOb_kinematic_state_set(PointerRNA *ptr, int value)
221 {
222         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
223         
224         RB_FLAG_SET(rbo->flag, value, RBO_FLAG_KINEMATIC);
225         
226         /* update kinematic state if necessary */
227         if (rbo->physics_object) {
228                 RB_body_set_mass(rbo->physics_object, RBO_GET_MASS(rbo));
229                 RB_body_set_kinematic_state(rbo->physics_object, value);
230                 rbo->flag |= RBO_FLAG_NEEDS_VALIDATE;
231         }
232 }
233
234 static void rna_RigidBodyOb_activation_state_set(PointerRNA *ptr, int value)
235 {
236         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
237         
238         RB_FLAG_SET(rbo->flag, value, RBO_FLAG_USE_DEACTIVATION);
239         
240         /* update activation state if necessary - only active bodies can be deactivated */
241         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE))
242                 RB_body_set_activation_state(rbo->physics_object, value);
243 }
244
245 static void rna_RigidBodyOb_linear_sleepThresh_set(PointerRNA *ptr, float value)
246 {
247         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
248         
249         rbo->lin_sleep_thresh = value;
250         
251         /* only active bodies need sleep threshold update */
252         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE))
253                 RB_body_set_linear_sleep_thresh(rbo->physics_object, value);
254 }
255
256 static void rna_RigidBodyOb_angular_sleepThresh_set(PointerRNA *ptr, float value)
257 {
258         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
259         
260         rbo->ang_sleep_thresh = value;
261         
262         /* only active bodies need sleep threshold update */
263         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE))
264                 RB_body_set_angular_sleep_thresh(rbo->physics_object, value);
265 }
266
267 static void rna_RigidBodyOb_linear_damping_set(PointerRNA *ptr, float value)
268 {
269         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
270         
271         rbo->lin_damping = value;
272         
273         /* only active bodies need damping update */
274         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE))
275                 RB_body_set_linear_damping(rbo->physics_object, value);
276 }
277
278 static void rna_RigidBodyOb_angular_damping_set(PointerRNA *ptr, float value)
279 {
280         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
281         
282         rbo->ang_damping = value;
283         
284         /* only active bodies need damping update */
285         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE))
286                 RB_body_set_angular_damping(rbo->physics_object, value);
287 }
288
289 #else
290
291 static void rna_def_rigidbody_world(BlenderRNA *brna)
292 {
293         StructRNA *srna;
294         PropertyRNA *prop;
295         
296         srna = RNA_def_struct(brna, "RigidBodyWorld", NULL);
297         RNA_def_struct_sdna(srna, "RigidBodyWorld");
298         RNA_def_struct_ui_text(srna, "Rigid Body World", "Self-contained rigid body simulation environment and settings");
299         RNA_def_struct_path_func(srna, "rna_RigidBodyWorld_path");
300         
301         /* groups */
302         prop = RNA_def_property(srna, "group", PROP_POINTER, PROP_NONE);
303         RNA_def_property_struct_type(prop, "Group");
304         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_ID_SELF_CHECK);
305         RNA_def_property_ui_text(prop, "Group", "Group containing objects participating in this simulation");
306         RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
307         
308         /* booleans */
309         prop = RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
310         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", RBW_FLAG_MUTED);
311         RNA_def_property_ui_text(prop, "Enabled", "Simulation will be evaluated");
312         RNA_def_property_update(prop, NC_SCENE, NULL);
313         
314         /* time scale */
315         prop = RNA_def_property(srna, "time_scale", PROP_FLOAT, PROP_NONE);
316         RNA_def_property_float_sdna(prop, NULL, "time_scale");
317         RNA_def_property_range(prop, 0.0f, 100.0f);
318         RNA_def_property_ui_range(prop, 0.0f, 10.0f, 1, 3);
319         RNA_def_property_float_default(prop, 1.0f);
320         RNA_def_property_ui_text(prop, "Time Scale", "Changes the speed of the simulation");
321         RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
322         
323         /* timestep */
324         prop = RNA_def_property(srna, "steps_per_second", PROP_INT, PROP_NONE);
325         RNA_def_property_int_sdna(prop, NULL, "steps_per_second");
326         RNA_def_property_range(prop, 1, SHRT_MAX);
327         RNA_def_property_ui_range(prop, 60, 1000, 1, 0);
328         RNA_def_property_int_default(prop, 60);
329         RNA_def_property_ui_text(prop, "Steps Per Second", "Number of simulation steps taken per second (higher values are more accurate but slower)");
330         RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
331         
332         /* constraint solver iterations */
333         prop = RNA_def_property(srna, "num_solver_iterations", PROP_INT, PROP_NONE);
334         RNA_def_property_int_sdna(prop, NULL, "num_solver_iterations");
335         RNA_def_property_range(prop, 1, 1000);
336         RNA_def_property_ui_range(prop, 10, 100, 1, 0);
337         RNA_def_property_int_default(prop, 10);
338         RNA_def_property_int_funcs(prop, NULL, "rna_RigidBodyWorld_num_solver_iterations_set", NULL);
339         RNA_def_property_ui_text(prop, "Solver Iterations", "Number of constraint solver iterations made per simulation step (higher values are more accurate but slower)");
340         RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
341         
342         /* split impulse */
343         prop = RNA_def_property(srna, "use_split_impulse", PROP_BOOLEAN, PROP_NONE);
344         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBW_FLAG_USE_SPLIT_IMPULSE);
345         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyWorld_split_impulse_set");
346         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)");
347         RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
348
349         /* cache */
350         prop = RNA_def_property(srna, "point_cache", PROP_POINTER, PROP_NONE);
351         RNA_def_property_flag(prop, PROP_NEVER_NULL);
352         RNA_def_property_pointer_sdna(prop, NULL, "pointcache");
353         RNA_def_property_ui_text(prop, "Point Cache", "");
354
355         /* effector weights */
356         prop = RNA_def_property(srna, "effector_weights", PROP_POINTER, PROP_NONE);
357         RNA_def_property_struct_type(prop, "EffectorWeights");
358         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
359         RNA_def_property_ui_text(prop, "Effector Weights", "");
360 }
361
362 static void rna_def_rigidbody_object(BlenderRNA *brna)
363 {
364         StructRNA *srna;
365         PropertyRNA *prop;
366         
367         
368         srna = RNA_def_struct(brna, "RigidBodyObject", NULL);
369         RNA_def_struct_sdna(srna, "RigidBodyOb");
370         RNA_def_struct_ui_text(srna, "Rigid Body Object", "Settings for object participating in Rigid Body Simulation");
371         RNA_def_struct_path_func(srna, "rna_RigidBodyOb_path");
372         
373         /* Enums */
374         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
375         RNA_def_property_enum_sdna(prop, NULL, "type");
376         RNA_def_property_enum_items(prop, rigidbody_ob_type_items);
377         RNA_def_property_enum_funcs(prop, NULL, "rna_RigidBodyOb_type_set", NULL);
378         RNA_def_property_ui_text(prop, "Type", "Role of object in Rigid Body Simulations");
379         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
380         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
381         
382         /* booleans */
383         prop = RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
384         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", RBO_FLAG_DISABLED);
385         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyOb_disabled_set");
386         RNA_def_property_ui_text(prop, "Enabled", "Rigid Body actively participated in the simulation");
387         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
388         
389         prop = RNA_def_property(srna, "collision_shape", PROP_ENUM, PROP_NONE);
390         RNA_def_property_enum_sdna(prop, NULL, "shape");
391         RNA_def_property_enum_items(prop, rigidbody_ob_shape_items);
392         RNA_def_property_enum_funcs(prop, NULL, "rna_RigidBodyOb_shape_set", NULL);
393         RNA_def_property_ui_text(prop, "Collision Shape", "Collision Shape of object in Rigid Body Simulations");
394         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
395         
396         prop = RNA_def_property(srna, "kinematic", PROP_BOOLEAN, PROP_NONE);
397         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBO_FLAG_KINEMATIC);
398         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyOb_kinematic_state_set");
399         RNA_def_property_ui_text(prop, "Kinematic", "Allows rigid body to be controlled by the animation system");
400         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
401         
402         /* Physics Parameters */
403         prop = RNA_def_property(srna, "mass", PROP_FLOAT, PROP_UNIT_MASS);
404         RNA_def_property_float_sdna(prop, NULL, "mass");
405         RNA_def_property_range(prop, 0.001f, FLT_MAX); // range must always be positive (and non-zero)
406         RNA_def_property_float_default(prop, 1.0f);
407         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_mass_set", NULL);
408         RNA_def_property_ui_text(prop, "Mass", "How much the object 'weighs' irrespective of gravity");
409         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
410         
411         /* Dynamics Parameters - Activation */
412         // TODO: define and figure out how to implement these
413         
414         /* Dynamics Parameters - Deactivation */
415         prop = RNA_def_property(srna, "use_deactivation", PROP_BOOLEAN, PROP_NONE);
416         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBO_FLAG_USE_DEACTIVATION);
417         RNA_def_property_boolean_default(prop, TRUE);
418         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyOb_activation_state_set");
419         RNA_def_property_ui_text(prop, "Enable Deactivation", "Enables deactivation of resting rigid bodies (increases performance and stability but can cause glitches)");
420         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
421         
422         prop = RNA_def_property(srna, "start_deactivated", PROP_BOOLEAN, PROP_NONE);
423         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBO_FLAG_START_DEACTIVATED);
424         RNA_def_property_ui_text(prop, "Start Deactivated", "Deactivates rigid body at the start of the simulation");
425         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
426         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
427         
428         prop = RNA_def_property(srna, "deactivate_linear_velocity", PROP_FLOAT, PROP_UNIT_VELOCITY);
429         RNA_def_property_float_sdna(prop, NULL, "lin_sleep_thresh");
430         RNA_def_property_range(prop, FLT_MIN, FLT_MAX); // range must always be positive (and non-zero)
431         RNA_def_property_float_default(prop, 0.4f);
432         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_linear_sleepThresh_set", NULL);
433         RNA_def_property_ui_text(prop, "Linear Velocity Deactivation Threshold", "Linear Velocity below which simulation stops simulating object");
434         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
435         
436         prop = RNA_def_property(srna, "deactivate_angular_velocity", PROP_FLOAT, PROP_UNIT_VELOCITY);
437         RNA_def_property_float_sdna(prop, NULL, "ang_sleep_thresh");
438         RNA_def_property_range(prop, FLT_MIN, FLT_MAX); // range must always be positive (and non-zero)
439         RNA_def_property_float_default(prop, 0.5f);
440         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_angular_sleepThresh_set", NULL);
441         RNA_def_property_ui_text(prop, "Angular Velocity Deactivation Threshold", "Angular Velocity below which simulation stops simulating object");
442         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
443         
444         /* Dynamics Parameters - Damping Parameters */
445         prop = RNA_def_property(srna, "linear_damping", PROP_FLOAT, PROP_FACTOR);
446         RNA_def_property_float_sdna(prop, NULL, "lin_damping");
447         RNA_def_property_range(prop, 0.0f, 1.0f);
448         RNA_def_property_float_default(prop, 0.04f);
449         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_linear_damping_set", NULL);
450         RNA_def_property_ui_text(prop, "Linear Damping", "Amount of linear velocity that is lost over time");
451         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
452         
453         prop = RNA_def_property(srna, "angular_damping", PROP_FLOAT, PROP_FACTOR);
454         RNA_def_property_float_sdna(prop, NULL, "ang_damping");
455         RNA_def_property_range(prop, 0.0f, 1.0f);
456         RNA_def_property_float_default(prop, 0.1f);
457         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_angular_damping_set", NULL);
458         RNA_def_property_ui_text(prop, "Angular Damping", "Amount of angular velocity that is lost over time");
459         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
460         
461         /* Collision Parameters - Surface Parameters */
462         prop = RNA_def_property(srna, "friction", PROP_FLOAT, PROP_FACTOR);
463         RNA_def_property_float_sdna(prop, NULL, "friction");
464         RNA_def_property_range(prop, 0.0f, FLT_MAX);
465         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 1, 3);
466         RNA_def_property_float_default(prop, 0.5f);
467         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_friction_set", NULL);
468         RNA_def_property_ui_text(prop, "Friction", "Resistance of object to movement");
469         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
470         
471         prop = RNA_def_property(srna, "restitution", PROP_FLOAT, PROP_FACTOR);
472         RNA_def_property_float_sdna(prop, NULL, "restitution");
473         RNA_def_property_range(prop, 0.0f, FLT_MAX);
474         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 1, 3);
475         RNA_def_property_float_default(prop, 0.0f);
476         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_restitution_set", NULL);
477         RNA_def_property_ui_text(prop, "Restitution", "Tendency of object to bounce after colliding with another (0 = stays still, 1 = perfectly elastic)");
478         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
479         
480         /* Collision Parameters - Sensitivity */
481         prop = RNA_def_property(srna, "use_margin", PROP_BOOLEAN, PROP_NONE);
482         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBO_FLAG_USE_MARGIN);
483         RNA_def_property_boolean_default(prop, FALSE);
484         RNA_def_property_ui_text(prop, "Collision Margin", "Use custom collision margin (some shapes will have a visible gap around them)");
485         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_shape_reset");
486         
487         prop = RNA_def_property(srna, "collision_margin", PROP_FLOAT, PROP_UNIT_LENGTH);
488         RNA_def_property_float_sdna(prop, NULL, "margin");
489         RNA_def_property_range(prop, 0.0f, 1.0f);
490         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.01, 3);
491         RNA_def_property_float_default(prop, 0.04f);
492         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_collision_margin_set", NULL);
493         RNA_def_property_ui_text(prop, "Collision Margin", "Threshold of distance near surface where collisions are still considered (best results when non-zero)");
494         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_shape_reset");
495         
496         prop = RNA_def_property(srna, "collision_groups", PROP_BOOLEAN, PROP_LAYER_MEMBER);
497         RNA_def_property_boolean_sdna(prop, NULL, "col_groups", 1);
498         RNA_def_property_array(prop, 20);
499         RNA_def_property_ui_text(prop, "Collison Groups", "Collision Groups Rigid Body belongs to");
500         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
501         RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
502 }
503
504 void RNA_def_rigidbody(BlenderRNA *brna)
505 {
506         rna_def_rigidbody_world(brna);
507         rna_def_rigidbody_object(brna);
508 }
509
510
511 #endif