Physically based defaults for Eevee Bloom and Shutter
[blender.git] / source / blender / blenkernel / BKE_cloth.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) Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): Daniel Genrich
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27 #ifndef __BKE_CLOTH_H__
28 #define __BKE_CLOTH_H__
29
30 /** \file BKE_cloth.h
31  *  \ingroup bke
32  *  \author Daniel Genrich
33  */
34
35 #include <float.h>
36 #include "BLI_math_inline.h"
37
38 struct Object;
39 struct Scene;
40 struct Mesh;
41 struct MFace;
42 struct ClothModifierData;
43 struct CollisionModifierData;
44 struct Depsgraph;
45
46 #define DO_INLINE MALWAYS_INLINE
47
48 /* goal defines */
49 #define SOFTGOALSNAP  0.999f
50
51 /* This is approximately the smallest number that can be
52  * represented by a float, given its precision. */
53 #define ALMOST_ZERO             FLT_EPSILON
54
55 /* Bits to or into the ClothVertex.flags. */
56 typedef enum eClothVertexFlag {
57         CLOTH_VERT_FLAG_PINNED      = 1,
58         CLOTH_VERT_FLAG_NOSELFCOLL  = 2, /* vertex NOT used for self collisions */
59 } eClothVertexFlag;
60
61 typedef struct ClothHairData {
62         float loc[3];
63         float rot[3][3];
64         float rest_target[3]; /* rest target direction for each segment */
65         float radius;
66         float bending_stiffness;
67 } ClothHairData;
68
69 typedef struct ClothSolverResult {
70         int status;
71
72         int max_iterations, min_iterations;
73         float avg_iterations;
74         float max_error, min_error, avg_error;
75 } ClothSolverResult;
76
77 /**
78  * This structure describes a cloth object against which the
79  * simulation can run.
80  *
81  * The m and n members of this structure represent the assumed
82  * rectangular ordered grid for which the original paper is written.
83  * At some point they need to disappear and we need to determine out
84  * own connectivity of the mesh based on the actual edges in the mesh.
85  *
86  */
87 typedef struct Cloth {
88         struct ClothVertex      *verts;                 /* The vertices that represent this cloth. */
89         struct  LinkNode        *springs;               /* The springs connecting the mesh. */
90         unsigned int            numsprings;             /* The count of springs. */
91         unsigned int            mvert_num;              /* The number of verts == m * n. */
92         unsigned int            tri_num;
93         unsigned char           old_solver_type;        /* unused, only 1 solver here */
94         unsigned char           pad2;
95         short                   pad3;
96         struct BVHTree          *bvhtree;                       /* collision tree for this cloth object */
97         struct BVHTree          *bvhselftree;                   /* collision tree for this cloth object */
98         struct MVertTri         *tri;
99         struct Implicit_Data    *implicit;              /* our implicit solver connects to this pointer */
100         struct EdgeSet          *edgeset;               /* used for selfcollisions */
101         int last_frame, pad4;
102 } Cloth;
103
104 /**
105  * The definition of a cloth vertex.
106  */
107 typedef struct ClothVertex {
108         int     flags;          /* General flags per vertex.            */
109         float   v[3];           /* The velocity of the point.           */
110         float   xconst[3];      /* constrained position                 */
111         float   x[3];           /* The current position of this vertex. */
112         float   xold[3];        /* The previous position of this vertex.*/
113         float   tx[3];          /* temporary position */
114         float   txold[3];       /* temporary old position */
115         float   tv[3];          /* temporary "velocity", mostly used as tv = tx-txold */
116         float   mass;           /* mass / weight of the vertex          */
117         float   goal;           /* goal, from SB                        */
118         float   impulse[3];     /* used in collision.c */
119         float   xrest[3];   /* rest position of the vertex */
120         float   dcvel[3];       /* delta velocities to be applied by collision response */
121         unsigned int impulse_count; /* same as above */
122         float   avg_spring_len; /* average length of connected springs */
123         float   struct_stiff;
124         float   bend_stiff;
125         float   shear_stiff;
126         int     spring_count; /* how many springs attached? */
127         float   shrink_factor; /* how much to shrink this cloth */
128 }
129 ClothVertex;
130
131 /**
132  * The definition of a spring.
133  */
134 typedef struct ClothSpring {
135         int     ij;             /* Pij from the paper, one end of the spring.   */
136         int     kl;             /* Pkl from the paper, one end of the spring.   */
137         int mn;         /* For hair springs: third vertex index; For bending springs: edge index; */
138         int *pa;        /* Array of vert indices for poly a (for bending springs). */
139         int *pb;        /* Array of vert indices for poly b (for bending springs). */
140         int la;         /* Length of *pa. */
141         int lb;         /* Length of *pb. */
142         float restlen;  /* The original length of the spring. */
143         float restang;  /* The original angle of the bending springs. */
144         int     type;           /* Types defined in BKE_cloth.h ("springType"). */
145         int     flags;          /* Defined in BKE_cloth.h, e.g. deactivated due to tearing. */
146         float lin_stiffness;    /* Linear stiffness factor from the vertex groups. */
147         float ang_stiffness;    /* Angular stiffness factor from the vertex groups. */
148         float editrestlen;
149
150         /* angular bending spring target and derivatives */
151         float target[3];
152 }
153 ClothSpring;
154
155 // some macro enhancements for vector treatment
156 #define VECADDADD(v1,v2,v3)     {*(v1)+= *(v2) + *(v3); *(v1+1)+= *(v2+1) + *(v3+1); *(v1+2)+= *(v2+2) + *(v3+2);}
157 #define VECSUBADD(v1,v2,v3)     {*(v1)-= *(v2) + *(v3); *(v1+1)-= *(v2+1) + *(v3+1); *(v1+2)-= *(v2+2) + *(v3+2);}
158 #define VECADDSUB(v1,v2,v3)     {*(v1)+= *(v2) - *(v3); *(v1+1)+= *(v2+1) - *(v3+1); *(v1+2)+= *(v2+2) - *(v3+2);}
159 #define VECSUBADDSS(v1,v2,aS,v3,bS)     {*(v1)-= *(v2)*aS + *(v3)*bS; *(v1+1)-= *(v2+1)*aS + *(v3+1)*bS; *(v1+2)-= *(v2+2)*aS + *(v3+2)*bS;}
160 #define VECADDSUBSS(v1,v2,aS,v3,bS)     {*(v1)+= *(v2)*aS - *(v3)*bS; *(v1+1)+= *(v2+1)*aS - *(v3+1)*bS; *(v1+2)+= *(v2+2)*aS - *(v3+2)*bS;}
161 #define VECADDSS(v1,v2,aS,v3,bS)        {*(v1)= *(v2)*aS + *(v3)*bS; *(v1+1)= *(v2+1)*aS + *(v3+1)*bS; *(v1+2)= *(v2+2)*aS + *(v3+2)*bS;}
162 #define VECADDS(v1,v2,v3,bS)    {*(v1)= *(v2) + *(v3)*bS; *(v1+1)= *(v2+1) + *(v3+1)*bS; *(v1+2)= *(v2+2) + *(v3+2)*bS;}
163 #define VECSUBMUL(v1,v2,aS)     {*(v1)-= *(v2) * aS; *(v1+1)-= *(v2+1) * aS; *(v1+2)-= *(v2+2) * aS;}
164 #define VECSUBS(v1,v2,v3,bS)    {*(v1)= *(v2) - *(v3)*bS; *(v1+1)= *(v2+1) - *(v3+1)*bS; *(v1+2)= *(v2+2) - *(v3+2)*bS;}
165 #define VECSUBSB(v1,v2, v3,bS)  {*(v1)= (*(v2)- *(v3))*bS; *(v1+1)= (*(v2+1) - *(v3+1))*bS; *(v1+2)= (*(v2+2) - *(v3+2))*bS;}
166 #define VECMULS(v1,aS)  {*(v1)*= aS; *(v1+1)*= aS; *(v1+2)*= *aS;}
167 #define VECADDMUL(v1,v2,aS)     {*(v1)+= *(v2) * aS; *(v1+1)+= *(v2+1) * aS; *(v1+2)+= *(v2+2) * aS;}
168
169 /* SIMULATION FLAGS: goal flags,.. */
170 /* These are the bits used in SimSettings.flags. */
171 typedef enum {
172         CLOTH_SIMSETTINGS_FLAG_COLLOBJ = ( 1 << 2 ),// object is only collision object, no cloth simulation is done
173         CLOTH_SIMSETTINGS_FLAG_GOAL = ( 1 << 3 ), /* DEPRECATED, for versioning only. */
174         CLOTH_SIMSETTINGS_FLAG_TEARING = ( 1 << 4 ),// true if tearing is enabled
175         CLOTH_SIMSETTINGS_FLAG_SCALING = ( 1 << 8 ), /* DEPRECATED, for versioning only. */
176         CLOTH_SIMSETTINGS_FLAG_CCACHE_EDIT = (1 << 12), /* edit cache in editmode */
177         CLOTH_SIMSETTINGS_FLAG_RESIST_SPRING_COMPRESS = (1 << 13), /* don't allow spring compression */
178         CLOTH_SIMSETTINGS_FLAG_SEW = (1 << 14), /* pull ends of loose edges together */
179         CLOTH_SIMSETTINGS_FLAG_DYNAMIC_BASEMESH = (1 << 15), /* make simulation respect deformations in the base object */
180 } CLOTH_SIMSETTINGS_FLAGS;
181
182 /* ClothSimSettings.bending_model. */
183 typedef enum {
184         CLOTH_BENDING_LINEAR    = 0,
185         CLOTH_BENDING_ANGULAR   = 1,
186 } CLOTH_BENDING_MODEL;
187
188 /* COLLISION FLAGS */
189 typedef enum {
190         CLOTH_COLLSETTINGS_FLAG_ENABLED = ( 1 << 1 ), /* enables cloth - object collisions */
191         CLOTH_COLLSETTINGS_FLAG_SELF = ( 1 << 2 ), /* enables selfcollisions */
192 } CLOTH_COLLISIONSETTINGS_FLAGS;
193
194 /* Spring types as defined in the paper.*/
195 typedef enum {
196         CLOTH_SPRING_TYPE_STRUCTURAL   = (1 << 1),
197         CLOTH_SPRING_TYPE_SHEAR        = (1 << 2),
198         CLOTH_SPRING_TYPE_BENDING      = (1 << 3),
199         CLOTH_SPRING_TYPE_GOAL         = (1 << 4),
200         CLOTH_SPRING_TYPE_SEWING       = (1 << 5),
201         CLOTH_SPRING_TYPE_BENDING_HAIR = (1 << 6),
202 } CLOTH_SPRING_TYPES;
203
204 /* SPRING FLAGS */
205 typedef enum {
206         CLOTH_SPRING_FLAG_DEACTIVATE = ( 1 << 1 ),
207         CLOTH_SPRING_FLAG_NEEDED = ( 1 << 2 ), // springs has values to be applied
208 } CLOTH_SPRINGS_FLAGS;
209
210
211 /////////////////////////////////////////////////
212 // collision.c
213 ////////////////////////////////////////////////
214
215 struct CollPair;
216
217 typedef struct ColliderContacts {
218         struct Object *ob;
219         struct CollisionModifierData *collmd;
220
221         struct CollPair *collisions;
222         int totcollisions;
223 } ColliderContacts;
224
225 // needed for implicit.c
226 int cloth_bvh_collision(struct Depsgraph *depsgraph, struct Object *ob, struct ClothModifierData *clmd, float step, float dt);
227
228 void cloth_find_point_contacts(struct Depsgraph *depsgraph, struct Object *ob, struct ClothModifierData *clmd, float step, float dt,
229                                ColliderContacts **r_collider_contacts, int *r_totcolliders);
230 void cloth_free_contacts(ColliderContacts *collider_contacts, int totcolliders);
231
232 ////////////////////////////////////////////////
233
234 /////////////////////////////////////////////////
235 // cloth.c
236 ////////////////////////////////////////////////
237
238 // needed for modifier.c
239 void cloth_free_modifier_extern (struct ClothModifierData *clmd );
240 void cloth_free_modifier (struct ClothModifierData *clmd );
241 void cloth_init (struct ClothModifierData *clmd );
242 void clothModifier_do(
243         struct ClothModifierData *clmd, struct Depsgraph *depsgraph, struct Scene *scene,
244         struct Object *ob, struct Mesh *me, float (*vertexCos)[3]);
245
246 int cloth_uses_vgroup(struct ClothModifierData *clmd);
247
248 // needed for collision.c
249 void bvhtree_update_from_cloth(struct ClothModifierData *clmd, bool moving, bool self);
250
251 // needed for button_object.c
252 void cloth_clear_cache(
253         struct Object *ob, struct ClothModifierData *clmd, float framenr );
254
255 void cloth_parallel_transport_hair_frame(float mat[3][3], const float dir_old[3], const float dir_new[3]);
256
257 ////////////////////////////////////////////////
258
259 #endif