Merge remote-tracking branch 'origin/master' into blender2.8
[blender.git] / source / blender / makesdna / DNA_rigidbody_types.h
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  * The Original Code is Copyright (C) 2013 Blender Foundation
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): Joshua Leung, Sergej Reich
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file DNA_rigidbody_types.h
29  *  \ingroup DNA
30  *  \brief Types and defines for representing Rigid Body entities
31  */
32
33 #ifndef __DNA_RIGIDBODY_TYPES_H__
34 #define __DNA_RIGIDBODY_TYPES_H__
35
36 #include "DNA_listBase.h"
37
38 struct Collection;
39
40 struct EffectorWeights;
41
42 /* ******************************** */
43 /* RigidBody World */
44
45 /* Container for data shared by original and evaluated copies of RigidBodyWorld */
46 typedef struct RigidBodyWorld_Shared {
47         /* cache */
48         struct PointCache *pointcache;
49         struct ListBase ptcaches;
50
51         /* References to Physics Sim objects. Exist at runtime only ---------------------- */
52         void *physics_world;            /* Physics sim world (i.e. btDiscreteDynamicsWorld) */
53 } RigidBodyWorld_Shared;
54
55 /* RigidBodyWorld (rbw)
56  *
57  * Represents a "simulation scene" existing within the parent scene.
58  */
59 typedef struct RigidBodyWorld {
60         /* Sim World Settings ------------------------------------------------------------- */
61         struct EffectorWeights *effector_weights; /* effectors info */
62
63         struct Collection *group;               /* Group containing objects to use for Rigid Bodies */
64         struct Object **objects;        /* Array to access group objects by index, only used at runtime */
65
66         struct Collection *constraints; /* Group containing objects to use for Rigid Body Constraints*/
67
68         int pad;
69         float ltime;                            /* last frame world was evaluated for (internal) */
70
71         struct RigidBodyWorld_Shared *shared; /* This pointer is shared between all evaluated copies */
72         struct PointCache *pointcache DNA_DEPRECATED; /* Moved to shared->pointcache */
73         struct ListBase ptcaches DNA_DEPRECATED; /* Moved to shared->ptcaches */
74         int numbodies;              /* number of objects in rigid body group */
75
76         short steps_per_second;         /* number of simulation steps thaken per second */
77         short num_solver_iterations;/* number of constraint solver iterations made per simulation step */
78
79         int flag;                                       /* (eRigidBodyWorld_Flag) settings for this RigidBodyWorld */
80         float time_scale;                       /* used to speed up or slow down the simulation */
81 } RigidBodyWorld;
82
83 /* Flags for RigidBodyWorld */
84 typedef enum eRigidBodyWorld_Flag {
85         /* should sim world be skipped when evaluating (user setting) */
86         RBW_FLAG_MUTED                          = (1 << 0),
87         /* sim data needs to be rebuilt */
88         RBW_FLAG_NEEDS_REBUILD          = (1 << 1),
89         /* usse split impulse when stepping the simulation */
90         RBW_FLAG_USE_SPLIT_IMPULSE      = (1 << 2)
91 } eRigidBodyWorld_Flag;
92
93 /* ******************************** */
94 /* RigidBody Object */
95
96 /* Container for data that is shared among CoW copies.
97  *
98  * This is placed in a separate struct so that, for example, the physics_shape
99  * pointer can be replaced without having to update all CoW copies. */
100 #
101 #
102 typedef struct RigidBodyOb_Shared {
103         /* References to Physics Sim objects. Exist at runtime only */
104         void *physics_object;   /* Physics object representation (i.e. btRigidBody) */
105         void *physics_shape;    /* Collision shape used by physics sim (i.e. btCollisionShape) */
106 } RigidBodyOb_Shared;
107
108 /* RigidBodyObject (rbo)
109  *
110  * Represents an object participating in a RigidBody sim.
111  * This is attached to each object that is currently
112  * participating in a sim.
113  */
114 typedef struct RigidBodyOb {
115         /* General Settings for this RigidBodyOb */
116         short type;                             /* (eRigidBodyOb_Type) role of RigidBody in sim  */
117         short shape;                    /* (eRigidBody_Shape) collision shape to use */
118
119         int flag;                               /* (eRigidBodyOb_Flag) */
120         int col_groups;                 /* Collision groups that determines which rigid bodies can collide with each other */
121         short mesh_source;              /* (eRigidBody_MeshSource) mesh source for mesh based collision shapes */
122         short pad;
123
124         /* Physics Parameters */
125         float mass;                             /* how much object 'weighs' (i.e. absolute 'amount of stuff' it holds) */
126
127         float friction;                 /* resistance of object to movement */
128         float restitution;              /* how 'bouncy' object is when it collides */
129
130         float margin;                   /* tolerance for detecting collisions */
131
132         float lin_damping;              /* damping for linear velocities */
133         float ang_damping;              /* damping for angular velocities */
134
135         float lin_sleep_thresh; /* deactivation threshold for linear velocities */
136         float ang_sleep_thresh; /* deactivation threshold for angular velocities */
137
138         float orn[4];                   /* rigid body orientation */
139         float pos[3];                   /* rigid body position */
140         float pad1;
141
142         struct RigidBodyOb_Shared *shared; /* This pointer is shared between all evaluated copies */
143 } RigidBodyOb;
144
145
146 /* Participation types for RigidBodyOb */
147 typedef enum eRigidBodyOb_Type {
148         /* active geometry participant in simulation. is directly controlled by sim */
149         RBO_TYPE_ACTIVE = 0,
150         /* passive geometry participant in simulation. is directly controlled by animsys */
151         RBO_TYPE_PASSIVE
152 } eRigidBodyOb_Type;
153
154 /* Flags for RigidBodyOb */
155 typedef enum eRigidBodyOb_Flag {
156         /* rigidbody is kinematic (controlled by the animation system) */
157         RBO_FLAG_KINEMATIC                      = (1 << 0),
158         /* rigidbody needs to be validated (usually set after duplicating and not hooked up yet) */
159         RBO_FLAG_NEEDS_VALIDATE         = (1 << 1),
160         /* rigidbody shape needs refreshing (usually after exiting editmode) */
161         RBO_FLAG_NEEDS_RESHAPE          = (1 << 2),
162         /* rigidbody can be deactivated */
163         RBO_FLAG_USE_DEACTIVATION       = (1 << 3),
164         /* rigidbody is deactivated at the beginning of simulation */
165         RBO_FLAG_START_DEACTIVATED      = (1 << 4),
166         /* rigidbody is not dynamically simulated */
167         RBO_FLAG_DISABLED                       = (1 << 5),
168         /* collision margin is not embedded (only used by convex hull shapes for now) */
169         RBO_FLAG_USE_MARGIN                     = (1 << 6),
170         /* collision shape deforms during simulation (only for passive triangle mesh shapes) */
171         RBO_FLAG_USE_DEFORM                     = (1 << 7)
172 } eRigidBodyOb_Flag;
173
174 /* RigidBody Collision Shape */
175 typedef enum eRigidBody_Shape {
176                 /* simple box (i.e. bounding box) */
177         RB_SHAPE_BOX = 0,
178                 /* sphere */
179         RB_SHAPE_SPHERE,
180                 /* rounded "pill" shape (i.e. calcium tablets) */
181         RB_SHAPE_CAPSULE,
182                 /* cylinder (i.e. pringles can) */
183         RB_SHAPE_CYLINDER,
184                 /* cone (i.e. party hat) */
185         RB_SHAPE_CONE,
186
187                 /* convex hull (minimal shrinkwrap encompassing all verts) */
188         RB_SHAPE_CONVEXH,
189                 /* triangulated mesh */
190         RB_SHAPE_TRIMESH,
191
192                 /* concave mesh approximated using primitives */
193         //RB_SHAPE_COMPOUND,
194 } eRigidBody_Shape;
195
196 typedef enum eRigidBody_MeshSource {
197         /* base mesh */
198         RBO_MESH_BASE = 0,
199         /* only deformations */
200         RBO_MESH_DEFORM,
201         /* final derived mesh */
202         RBO_MESH_FINAL
203 } eRigidBody_MeshSource;
204
205 /* ******************************** */
206 /* RigidBody Constraint */
207
208 /* RigidBodyConstraint (rbc)
209  *
210  * Represents an constraint connecting two rigid bodies.
211  */
212 typedef struct RigidBodyCon {
213         struct Object *ob1;                     /* First object influenced by the constraint */
214         struct Object *ob2;                     /* Second object influenced by the constraint */
215
216         /* General Settings for this RigidBodyCon */
217         short type;                                     /* (eRigidBodyCon_Type) role of RigidBody in sim  */
218         short num_solver_iterations;/* number of constraint solver iterations made per simulation step */
219
220         int flag;                                       /* (eRigidBodyCon_Flag) */
221
222         float breaking_threshold;       /* breaking impulse threshold */
223         char spring_type;               /* spring implementation to use */
224         char pad[3];
225
226         /* limits */
227         /* translation limits */
228         float limit_lin_x_lower;
229         float limit_lin_x_upper;
230         float limit_lin_y_lower;
231         float limit_lin_y_upper;
232         float limit_lin_z_lower;
233         float limit_lin_z_upper;
234         /* rotation limits */
235         float limit_ang_x_lower;
236         float limit_ang_x_upper;
237         float limit_ang_y_lower;
238         float limit_ang_y_upper;
239         float limit_ang_z_lower;
240         float limit_ang_z_upper;
241
242         /* spring settings */
243         /* resistance to deformation */
244         float spring_stiffness_x;
245         float spring_stiffness_y;
246         float spring_stiffness_z;
247         float spring_stiffness_ang_x;
248         float spring_stiffness_ang_y;
249         float spring_stiffness_ang_z;
250         /* amount of velocity lost over time */
251         float spring_damping_x;
252         float spring_damping_y;
253         float spring_damping_z;
254         float spring_damping_ang_x;
255         float spring_damping_ang_y;
256         float spring_damping_ang_z;
257
258         /* motor settings */
259         float motor_lin_target_velocity;        /* linear velocity the motor tries to hold */
260         float motor_ang_target_velocity;        /* angular velocity the motor tries to hold */
261         float motor_lin_max_impulse;            /* maximum force used to reach linear target velocity */
262         float motor_ang_max_impulse;            /* maximum force used to reach angular target velocity */
263
264         /* References to Physics Sim object. Exist at runtime only */
265         void *physics_constraint;       /* Physics object representation (i.e. btTypedConstraint) */
266 } RigidBodyCon;
267
268
269 /* Participation types for RigidBodyOb */
270 typedef enum eRigidBodyCon_Type {
271         /* lets bodies rotate around a specified point */
272         RBC_TYPE_POINT = 0,
273         /* lets bodies rotate around a specified axis */
274         RBC_TYPE_HINGE,
275         /* simulates wheel suspension */
276         RBC_TYPE_HINGE2,
277         /* restricts movent to a specified axis */
278         RBC_TYPE_SLIDER,
279         /* lets object rotate within a cpecified cone */
280         RBC_TYPE_CONE_TWIST,
281         /* allows user to specify constraint axes */
282         RBC_TYPE_6DOF,
283         /* like 6DOF but has springs */
284         RBC_TYPE_6DOF_SPRING,
285         /* simulates a universal joint */
286         RBC_TYPE_UNIVERSAL,
287         /* glues two bodies together */
288         RBC_TYPE_FIXED,
289         /* similar to slider but also allows rotation around slider axis */
290         RBC_TYPE_PISTON,
291         /* Simplified spring constraint with only once axis that's automatically placed between the connected bodies */
292         RBC_TYPE_SPRING,
293         /* dirves bodies by applying linear and angular forces */
294         RBC_TYPE_MOTOR,
295 } eRigidBodyCon_Type;
296
297 /* Spring implementation type for RigidBodyOb */
298 typedef enum eRigidBodyCon_SpringType {
299         RBC_SPRING_TYPE1 = 0,   /* btGeneric6DofSpringConstraint */
300         RBC_SPRING_TYPE2,       /* btGeneric6DofSpring2Constraint */
301 } eRigidBodyCon_SpringType;
302
303 /* Flags for RigidBodyCon */
304 typedef enum eRigidBodyCon_Flag {
305         /* constraint influences rigid body motion */
306         RBC_FLAG_ENABLED                                        = (1 << 0),
307         /* constraint needs to be validated */
308         RBC_FLAG_NEEDS_VALIDATE                         = (1 << 1),
309         /* allow constrained bodies to collide */
310         RBC_FLAG_DISABLE_COLLISIONS                     = (1 << 2),
311         /* constraint can break */
312         RBC_FLAG_USE_BREAKING                           = (1 << 3),
313         /* constraint use custom number of constraint solver iterations */
314         RBC_FLAG_OVERRIDE_SOLVER_ITERATIONS     = (1 << 4),
315         /* limits */
316         RBC_FLAG_USE_LIMIT_LIN_X                        = (1 << 5),
317         RBC_FLAG_USE_LIMIT_LIN_Y                        = (1 << 6),
318         RBC_FLAG_USE_LIMIT_LIN_Z                        = (1 << 7),
319         RBC_FLAG_USE_LIMIT_ANG_X                        = (1 << 8),
320         RBC_FLAG_USE_LIMIT_ANG_Y                        = (1 << 9),
321         RBC_FLAG_USE_LIMIT_ANG_Z                        = (1 << 10),
322         /* springs */
323         RBC_FLAG_USE_SPRING_X                           = (1 << 11),
324         RBC_FLAG_USE_SPRING_Y                           = (1 << 12),
325         RBC_FLAG_USE_SPRING_Z                           = (1 << 13),
326         /* motors */
327         RBC_FLAG_USE_MOTOR_LIN                          = (1 << 14),
328         RBC_FLAG_USE_MOTOR_ANG                          = (1 << 15),
329         /* angular springs */
330         RBC_FLAG_USE_SPRING_ANG_X                       = (1 << 16),
331         RBC_FLAG_USE_SPRING_ANG_Y                       = (1 << 17),
332         RBC_FLAG_USE_SPRING_ANG_Z                       = (1 << 18)
333 } eRigidBodyCon_Flag;
334
335 /* ******************************** */
336
337 #endif /* __DNA_RIGIDBODY_TYPES_H__ */