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