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