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