* Rest length parameter for harmonic force springs. Implementation is a slightly...
[blender-staging.git] / source / blender / makesdna / DNA_object_force.h
1 /**
2  *
3  * $Id$
4  *
5  * ***** BEGIN GPL LICENSE BLOCK *****
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License
9  * as published by the Free Software Foundation; either version 2
10  * of the License, or (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software Foundation,
19  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
20  *
21  * The Original Code is Copyright (C) 2004-2005 by Blender Foundation
22  * All rights reserved.
23  *
24  * The Original Code is: all of this file.
25  *
26  * Contributor(s): none yet.
27  *
28  * ***** END GPL LICENSE BLOCK *****
29  */
30 #ifndef DNA_OBJECT_FORCE_H
31 #define DNA_OBJECT_FORCE_H
32
33 #ifdef __cplusplus
34 extern "C" {
35 #endif
36
37 #include "DNA_listBase.h"
38
39 /* pd->forcefield:  Effector Fields types */
40 typedef enum PFieldType {
41         PFIELD_NULL = 0,        /* (this is used for general effector weight)                                                   */
42         PFIELD_FORCE,           /* Force away/towards a point depending on force strength                               */
43         PFIELD_VORTEX,          /* Force around the effector normal                                                                             */
44         PFIELD_MAGNET,          /* Force from the cross product of effector normal and point velocity   */
45         PFIELD_WIND,            /* Force away and towards a point depending which side of the effector  */
46                                                 /*       normal the point is                                                                                            */
47         PFIELD_GUIDE,           /* Force along curve for dynamics, a shaping curve for hair paths               */
48         PFIELD_TEXTURE,         /* Force based on texture values calculated at point coordinates                */
49         PFIELD_HARMONIC,        /* Force of a harmonic (damped) oscillator                                                              */
50         PFIELD_CHARGE,          /* Force away/towards a point depending on point charge                                 */
51         PFIELD_LENNARDJ,        /* Force due to a Lennard-Jones potential                                                               */
52         PFIELD_BOID,            /* Defines predator / goal for boids                                                                    */
53         PFIELD_TURBULENCE,      /* Force defined by BLI_gTurbulence                                                                             */
54         PFIELD_DRAG,            /* Linear & quadratic drag                                                                                              */
55         NUM_PFIELD_TYPES
56 } PFieldType;
57         
58 typedef struct PartDeflect {
59         int       flag;                 /* general settings flag                                                                                */
60         short deflect;          /* Deflection flag - does mesh deflect particles                                */
61         short forcefield;       /* Force field type, do the vertices attract / repel particles? */
62         short falloff;          /* fall-off type                                                                                                */
63         short shape;            /* point, plane or surface                                                                              */
64         short tex_mode;         /* texture effector                                                                                             */
65         short kink, kink_axis; /* for curve guide                                                                                       */
66         short zdir;
67         
68         /* Main effector values */
69         float f_strength;       /* The strength of the force (+ or - )                                  */
70         float f_damp;           /* Damping ratio of the harmonic effector.                              */
71         float f_flow;           /* How much force is converted into "air flow", i.e.    */
72                                                 /* force used as the velocity of surrounding medium.    */
73
74         float f_size;           /* Noise size for noise effector, restlength for harmonic effector */
75
76         /* fall-off */
77         float f_power;          /* The power law - real gravitation is 2 (square)       */
78         float maxdist;          /* if indicated, use this maximum                                       */
79         float mindist;          /* if indicated, use this minimum                                       */
80         float f_power_r;        /* radial fall-off power                                                        */
81         float maxrad;           /* radial versions of above                                                     */
82         float minrad;
83
84         /* particle collisions */
85         float pdef_damp;        /* Damping factor for particle deflection       */
86         float pdef_rdamp;       /* Random element of damping for deflection     */
87         float pdef_perm;        /* Chance of particle passing through mesh      */
88         float pdef_frict;       /* Friction factor for particle deflection              */
89         float pdef_rfrict;      /* Random element of friction for deflection    */
90
91         float absorption, pad;  /* used for forces */
92         
93         /* softbody collisions */
94         float pdef_sbdamp;      /* Damping factor for softbody deflection       */
95         float pdef_sbift;       /* inner face thickness for softbody deflection */
96         float pdef_sboft;       /* outer face thickness for softbody deflection */
97
98         /* guide curve, same as for particle child effects */
99         float clump_fac, clump_pow;
100         float kink_freq, kink_shape, kink_amp, free_end;
101
102         /* texture effector */
103         float tex_nabla;        /* Used for calculating partial derivatives */
104         struct Tex *tex;        /* Texture of the texture effector                      */
105
106         /* effector noise */
107         struct RNG *rng;        /* random noise generator for e.g. wind */
108         float f_noise;          /* noise of force                                               */
109         int seed;                       /* noise random seed                                    */
110 } PartDeflect;
111
112 typedef struct EffectorWeights {
113         struct Group *group;            /* only use effectors from this group of objects */
114         
115         float weight[13];                       /* effector type specific weights */
116         float global_gravity;
117         short flag, rt[3];
118 } EffectorWeights;
119
120 /* EffectorWeights->flag */
121 #define EFF_WEIGHT_DO_HAIR              1
122
123 /* Point cache file data types:
124  * - used as (1<<flag) so poke jahka if you reach the limit of 15
125  * - to add new data types update:
126  *              * BKE_ptcache_data_size()
127  *              * ptcache_file_init_pointers()
128 */
129 #define BPHYS_DATA_INDEX                0
130 #define BPHYS_DATA_LOCATION             1
131 #define BPHYS_DATA_VELOCITY             2
132 #define BPHYS_DATA_ROTATION             3
133 #define BPHYS_DATA_AVELOCITY    4       /* used for particles */
134 #define BPHYS_DATA_XCONST               4       /* used for cloth */
135 #define BPHYS_DATA_SIZE                 5
136 #define BPHYS_DATA_TIMES                6
137 #define BPHYS_DATA_BOIDS                7
138
139 #define BPHYS_TOT_DATA                  8
140
141 typedef struct PTCacheMem {
142         struct PTCacheMem *next, *prev;
143         int frame, totpoint;
144         unsigned int data_types, flag;
145         int *index_array; /* quick access to stored points with index */
146
147         void *data[8]; /* BPHYS_TOT_DATA */
148         void *cur[8]; /* BPHYS_TOT_DATA */
149 } PTCacheMem;
150
151 typedef struct PointCache {
152         struct PointCache *next, *prev;
153         int flag;               /* generic flag */
154         int step;               /* frames between cached frames */
155         int simframe;   /* current frame of simulation (only if SIMULATION_VALID) */
156         int startframe; /* simulation start frame */
157         int endframe;   /* simulation end frame */
158         int editframe;  /* frame being edited (runtime only) */
159         int last_exact; /* last exact frame that's cached */
160
161         /* for external cache files */
162         int totpoint;   /* number of cached points */
163         int index, rt;  /* modifier stack index */
164         
165         char name[64];
166         char prev_name[64];
167         char info[64];
168         char path[240]; /* file path */
169         struct ListBase mem_cache;
170
171         struct PTCacheEdit *edit;
172         void (*free_edit)(struct PTCacheEdit *edit);    /* free callback */
173 } PointCache;
174
175 typedef struct SBVertex {
176         float vec[4];
177 } SBVertex;
178
179 typedef struct BulletSoftBody {
180         int flag;                               /* various boolean options */
181         float linStiff;                 /* linear stiffness 0..1 */
182         float   angStiff;               /* angular stiffness 0..1 */
183         float   volume;                 /* volume preservation 0..1 */
184
185         int     viterations;            /* Velocities solver iterations */
186         int     piterations;            /* Positions solver iterations */
187         int     diterations;            /* Drift solver iterations */
188         int     citerations;            /* Cluster solver iterations */
189
190         float   kSRHR_CL;               /* Soft vs rigid hardness [0,1] (cluster only) */
191         float   kSKHR_CL;               /* Soft vs kinetic hardness [0,1] (cluster only) */
192         float   kSSHR_CL;               /* Soft vs soft hardness [0,1] (cluster only) */
193         float   kSR_SPLT_CL;    /* Soft vs rigid impulse split [0,1] (cluster only) */
194
195         float   kSK_SPLT_CL;    /* Soft vs rigid impulse split [0,1] (cluster only) */
196         float   kSS_SPLT_CL;    /* Soft vs rigid impulse split [0,1] (cluster only) */
197         float   kVCF;                   /* Velocities correction factor (Baumgarte) */
198         float   kDP;                    /* Damping coefficient [0,1] */
199
200         float   kDG;                    /* Drag coefficient [0,+inf] */
201         float   kLF;                    /* Lift coefficient [0,+inf] */
202         float   kPR;                    /* Pressure coefficient [-inf,+inf] */
203         float   kVC;                    /* Volume conversation coefficient [0,+inf] */
204
205         float   kDF;                    /* Dynamic friction coefficient [0,1] */
206         float   kMT;                    /* Pose matching coefficient [0,1] */
207         float   kCHR;                   /* Rigid contacts hardness [0,1] */
208         float   kKHR;                   /* Kinetic contacts hardness [0,1] */
209
210         float   kSHR;                   /* Soft contacts hardness [0,1] */
211         float   kAHR;                   /* Anchors hardness [0,1] */
212         int             collisionflags; /* Vertex/Face or Signed Distance Field(SDF) or Clusters, Soft versus Soft or Rigid */
213         int             numclusteriterations;   /* number of iterations to refine collision clusters*/
214         float   welding;                /* welding limit to remove duplicate/nearby vertices, 0.0..0.01 */
215         float   margin;                 /* margin specific to softbody */
216 } BulletSoftBody;
217
218 /* BulletSoftBody.flag */
219 #define OB_BSB_SHAPE_MATCHING   2
220 #define OB_BSB_UNUSED 4
221 #define OB_BSB_BENDING_CONSTRAINTS 8
222 #define OB_BSB_AERO_VPOINT 16 /* aero model, Vertex normals are oriented toward velocity*/
223 #define OB_BSB_AERO_VTWOSIDE 32 /* aero model, Vertex normals are flipped to match velocity */
224
225 /* BulletSoftBody.collisionflags */
226 #define OB_BSB_COL_SDF_RS       2 /* SDF based rigid vs soft */
227 #define OB_BSB_COL_CL_RS        4 /* Cluster based rigid vs soft */
228 #define OB_BSB_COL_CL_SS        8 /* Cluster based soft vs soft */
229 #define OB_BSB_COL_VF_SS        16 /* Vertex/Face based soft vs soft */
230
231
232 typedef struct SoftBody {
233         /* dynamic data */
234         int totpoint, totspring;
235         struct BodyPoint *bpoint;               /* not saved in file */
236         struct BodySpring *bspring;             /* not saved in file */
237         char   pad;
238         char   msg_lock;
239         short  msg_value;
240         
241         /* part of UI: */
242         
243         /* general options */
244         float nodemass;         /* softbody mass of *vertex* */
245         char  namedVG_Mass[32]; /* along with it introduce mass painting
246                                                         starting to fix old bug .. nastyness that VG are indexes 
247                                                                 rather find them by name tag to find it -> jow20090613 */
248         float grav;                     /* softbody amount of gravitaion to apply */
249         float mediafrict;       /* friction to env */
250         float rklimit;          /* error limit for ODE solver */
251         float physics_speed;/* user control over simulation speed */
252         
253         /* goal */
254         float goalspring;       /* softbody goal springs */
255         float goalfrict;        /* softbody goal springs friction */
256         float mingoal;          /* quick limits for goal */
257         float maxgoal;
258         float defgoal;          /* default goal for vertices without vgroup */
259         short vertgroup;        /* index starting at 1 */
260         char  namedVG_Softgoal[32]; /* starting to fix old bug .. nastyness that VG are indexes 
261                                                                 rather find them by name tag to find it -> jow20090613 */
262   
263         short fuzzyness;      /* */
264         
265         /* springs */
266         float inspring;         /* softbody inner springs */
267         float infrict;          /* softbody inner springs friction */
268         char  namedVG_Spring_K[32]; /* along with it introduce Spring_K painting
269                                                         starting to fix old bug .. nastyness that VG are indexes 
270                                                                 rather find them by name tag to find it -> jow20090613 */
271         
272         /* baking */
273         int sfra, efra;
274         int interval;
275         short local, solverflags;               /* local==1: use local coords for baking */
276         
277         /* -- these must be kept for backwards compatibility -- */
278         SBVertex **keys;                        /* array of size totpointkey */
279         int totpointkey, totkey;        /* if totpointkey != totpoint or totkey!- (efra-sfra)/interval -> free keys */
280         /* ---------------------------------------------------- */
281         float secondspring;
282
283         /* self collision*/
284         float colball;          /* fixed collision ball size if > 0 */
285         float balldamp;         /* cooling down collision response  */
286         float ballstiff;        /* pressure the ball is loaded with  */
287         short sbc_mode;
288     short aeroedge,
289                 minloops,
290                 maxloops,
291                 choke,
292                 solver_ID,
293                 plastic,springpreload
294                 ;   
295
296         struct SBScratch *scratch;      /* scratch pad/cache on live time not saved in file */
297         float shearstiff;
298         float inpush;
299
300         struct PointCache *pointcache;
301         struct ListBase ptcaches;
302
303         struct EffectorWeights *effector_weights;
304     /* reverse esimated obmatrix .. no need to store in blend file .. how ever who cares */ 
305         float lcom[3];
306         float lrot[3][3];
307         float lscale[3][3];
308     char  pad4[4];
309
310 } SoftBody;
311
312
313 /* pd->flag: various settings */
314 #define PFIELD_USEMAX                   1
315 #define PDEFLE_DEFORM                   2
316 #define PFIELD_GUIDE_PATH_ADD   4                       /* TODO: do_versions for below */
317 #define PFIELD_PLANAR                   8                       /* used for do_versions */
318 #define PDEFLE_KILL_PART                16
319 #define PFIELD_POSZ                             32                      /* used for do_versions */
320 #define PFIELD_TEX_OBJECT               64
321 #define PFIELD_GLOBAL_CO                64                      /* used for turbulence */
322 #define PFIELD_TEX_2D                   128
323 #define PFIELD_MULTIPLE_SPRINGS 128                     /* used for harmonic force */
324 #define PFIELD_USEMIN                   256
325 #define PFIELD_USEMAXR                  512
326 #define PFIELD_USEMINR                  1024
327 #define PFIELD_TEX_ROOTCO               2048
328 #define PFIELD_SURFACE                  (1<<12)         /* used for do_versions */
329 #define PFIELD_VISIBILITY               (1<<13)
330 #define PFIELD_DO_LOCATION              (1<<14)
331 #define PFIELD_DO_ROTATION              (1<<15)
332
333 /* pd->falloff */
334 #define PFIELD_FALL_SPHERE              0
335 #define PFIELD_FALL_TUBE                1
336 #define PFIELD_FALL_CONE                2
337
338 /* pd->shape */
339 #define PFIELD_SHAPE_POINT              0
340 #define PFIELD_SHAPE_PLANE              1
341 #define PFIELD_SHAPE_SURFACE    2
342 #define PFIELD_SHAPE_POINTS             3
343
344 /* pd->tex_mode */
345 #define PFIELD_TEX_RGB  0
346 #define PFIELD_TEX_GRAD 1
347 #define PFIELD_TEX_CURL 2
348
349 /* pd->zdir */
350 #define PFIELD_Z_BOTH   0
351 #define PFIELD_Z_POS    1
352 #define PFIELD_Z_NEG    2
353
354 /* pointcache->flag */
355 #define PTCACHE_BAKED                           1
356 #define PTCACHE_OUTDATED                        2
357 #define PTCACHE_SIMULATION_VALID        4
358 #define PTCACHE_BAKING                          8
359 //#define PTCACHE_BAKE_EDIT                     16
360 //#define PTCACHE_BAKE_EDIT_ACTIVE      32
361 #define PTCACHE_DISK_CACHE                      64
362 #define PTCACHE_QUICK_CACHE                     128
363 #define PTCACHE_FRAMES_SKIPPED          256
364 #define PTCACHE_EXTERNAL                        512
365 #define PTCACHE_READ_INFO                       1024
366
367 /* PTCACHE_OUTDATED + PTCACHE_FRAMES_SKIPPED */
368 #define PTCACHE_REDO_NEEDED                     258
369
370 /* ob->softflag */
371 #define OB_SB_ENABLE    1               /* deprecated, use modifier */
372 #define OB_SB_GOAL              2
373 #define OB_SB_EDGES             4
374 #define OB_SB_QUADS             8
375 #define OB_SB_POSTDEF   16
376 // #define OB_SB_REDO           32
377 // #define OB_SB_BAKESET        64
378 // #define OB_SB_BAKEDO 128
379 // #define OB_SB_RESET          256
380 #define OB_SB_SELF              512
381 #define OB_SB_FACECOLL  1024
382 #define OB_SB_EDGECOLL  2048
383 #define OB_SB_COLLFINAL 4096
384 #define OB_SB_BIG_UI    8192
385 #define OB_SB_AERO_ANGLE        16384
386
387 /* sb->solverflags */
388 #define SBSO_MONITOR            1 
389 #define SBSO_OLDERR                     2 
390 #define SBSO_ESTIMATEIPO    4 
391
392 /* sb->sbc_mode */
393 #define SBC_MODE_MANUAL         0
394 #define SBC_MODE_AVG            1
395 #define SBC_MODE_MIN            2
396 #define SBC_MODE_MAX            3
397 #define SBC_MODE_AVGMINMAX      4
398
399 #ifdef __cplusplus
400 }
401 #endif
402
403 #endif
404