435832f8c87fe1ac06d0269795ad836a925e74de
[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 ListBase;
40 struct Scene;
41 struct MFace;
42 struct DerivedMesh;
43 struct ClothModifierData;
44 struct CollisionTree;
45
46 #define DO_INLINE MALWAYS_INLINE
47
48 #define CLOTH_MAX_THREAD 2
49
50 /* goal defines */
51 #define SOFTGOALSNAP  0.999f
52
53 /* This is approximately the smallest number that can be
54  * represented by a float, given its precision. */
55 #define ALMOST_ZERO             FLT_EPSILON
56
57 /* Bits to or into the ClothVertex.flags. */
58 #define CLOTH_VERT_FLAG_PINNED 1
59 #define CLOTH_VERT_FLAG_COLLISION 2
60 #define CLOTH_VERT_FLAG_PINNED_EM 3
61
62 /**
63  * This structure describes a cloth object against which the
64  * simulation can run.
65  *
66  * The m and n members of this structure represent the assumed
67  * rectangular ordered grid for which the original paper is written.
68  * At some point they need to disappear and we need to determine out
69  * own connectivity of the mesh based on the actual edges in the mesh.
70  *
71  */
72 typedef struct Cloth
73 {
74         struct ClothVertex      *verts;                 /* The vertices that represent this cloth. */
75         struct  LinkNode        *springs;               /* The springs connecting the mesh. */
76         unsigned int            numverts;               /* The number of verts == m * n. */
77         unsigned int            numsprings;             /* The count of springs. */
78         unsigned int            numfaces;
79         unsigned char           old_solver_type;        /* unused, only 1 solver here */
80         unsigned char           pad2;
81         short                   pad3;
82         struct BVHTree          *bvhtree;                       /* collision tree for this cloth object */
83         struct BVHTree          *bvhselftree;                   /* collision tree for this cloth object */
84         struct MFace            *mfaces;
85         struct Implicit_Data    *implicit;              /* our implicit solver connects to this pointer */
86         struct Implicit_Data    *implicitEM;            /* our implicit solver connects to this pointer */
87         struct EdgeHash         *edgehash;              /* used for selfcollisions */
88         int last_frame, pad4;
89 } Cloth;
90
91 /**
92  * The definition of a cloth vertex.
93  */
94 typedef struct ClothVertex
95 {
96         int     flags;          /* General flags per vertex.            */
97         float   v [3];          /* The velocity of the point.           */
98         float   xconst [3];     /* constrained position                 */
99         float   x [3];          /* The current position of this vertex. */
100         float   xold [3];       /* The previous position of this vertex.*/
101         float   tx [3];         /* temporary position */
102         float   txold [3];      /* temporary old position */
103         float   tv[3];          /* temporary "velocity", mostly used as tv = tx-txold */
104         float   mass;           /* mass / weight of the vertex          */
105         float   goal;           /* goal, from SB                        */
106         float   impulse[3];     /* used in collision.c */
107         float   *xrest;         /* temporary valid for building springs */
108         unsigned int impulse_count; /* same as above */
109         float   avg_spring_len; /* average length of connected springs */
110         float   struct_stiff;
111         float   bend_stiff;
112         float   shear_stiff;
113         int     spring_count; /* how many springs attached? */
114 }
115 ClothVertex;
116
117 /**
118  * The definition of a spring.
119  */
120 typedef struct ClothSpring
121 {
122         int     ij;             /* Pij from the paper, one end of the spring.   */
123         int     kl;             /* Pkl from the paper, one end of the spring.   */
124         float   restlen;        /* The original length of the spring.   */
125         int     matrix_index;   /* needed for implicit solver (fast lookup) */
126         int     type;           /* types defined in BKE_cloth.h ("springType") */
127         int     flags;          /* defined in BKE_cloth.h, e.g. deactivated due to tearing */
128         float dfdx[3][3];
129         float dfdv[3][3];
130         float f[3];
131         float   stiffness;      /* stiffness factor from the vertex groups */
132         float editrestlen;
133 }
134 ClothSpring;
135
136 // some macro enhancements for vector treatment
137 #define VECADDADD(v1,v2,v3)     {*(v1)+= *(v2) + *(v3); *(v1+1)+= *(v2+1) + *(v3+1); *(v1+2)+= *(v2+2) + *(v3+2);}
138 #define VECSUBADD(v1,v2,v3)     {*(v1)-= *(v2) + *(v3); *(v1+1)-= *(v2+1) + *(v3+1); *(v1+2)-= *(v2+2) + *(v3+2);}
139 #define VECADDSUB(v1,v2,v3)     {*(v1)+= *(v2) - *(v3); *(v1+1)+= *(v2+1) - *(v3+1); *(v1+2)+= *(v2+2) - *(v3+2);}
140 #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;}
141 #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;}
142 #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;}
143 #define VECADDS(v1,v2,v3,bS)    {*(v1)= *(v2) + *(v3)*bS; *(v1+1)= *(v2+1) + *(v3+1)*bS; *(v1+2)= *(v2+2) + *(v3+2)*bS;}
144 #define VECSUBMUL(v1,v2,aS)     {*(v1)-= *(v2) * aS; *(v1+1)-= *(v2+1) * aS; *(v1+2)-= *(v2+2) * aS;}
145 #define VECSUBS(v1,v2,v3,bS)    {*(v1)= *(v2) - *(v3)*bS; *(v1+1)= *(v2+1) - *(v3+1)*bS; *(v1+2)= *(v2+2) - *(v3+2)*bS;}
146 #define VECSUBSB(v1,v2, v3,bS)  {*(v1)= (*(v2)- *(v3))*bS; *(v1+1)= (*(v2+1) - *(v3+1))*bS; *(v1+2)= (*(v2+2) - *(v3+2))*bS;}
147 #define VECMULS(v1,aS)  {*(v1)*= aS; *(v1+1)*= aS; *(v1+2)*= *aS;}
148 #define VECADDMUL(v1,v2,aS)     {*(v1)+= *(v2) * aS; *(v1+1)+= *(v2+1) * aS; *(v1+2)+= *(v2+2) * aS;}
149
150 /* SIMULATION FLAGS: goal flags,.. */
151 /* These are the bits used in SimSettings.flags. */
152 typedef enum
153 {
154         CLOTH_SIMSETTINGS_FLAG_COLLOBJ = ( 1 << 2 ),// object is only collision object, no cloth simulation is done
155         CLOTH_SIMSETTINGS_FLAG_GOAL = ( 1 << 3 ),       // we have goals enabled
156         CLOTH_SIMSETTINGS_FLAG_TEARING = ( 1 << 4 ),// true if tearing is enabled
157         CLOTH_SIMSETTINGS_FLAG_SCALING = ( 1 << 8 ), /* is advanced scaling active? */
158         CLOTH_SIMSETTINGS_FLAG_CCACHE_EDIT = (1 << 12), /* edit cache in editmode */
159         CLOTH_SIMSETTINGS_FLAG_NO_SPRING_COMPRESS = (1 << 13) /* don't allow spring compression */
160 } CLOTH_SIMSETTINGS_FLAGS;
161
162 /* COLLISION FLAGS */
163 typedef enum
164 {
165         CLOTH_COLLSETTINGS_FLAG_ENABLED = ( 1 << 1 ), /* enables cloth - object collisions */
166         CLOTH_COLLSETTINGS_FLAG_SELF = ( 1 << 2 ), /* enables selfcollisions */
167 } CLOTH_COLLISIONSETTINGS_FLAGS;
168
169 /* Spring types as defined in the paper.*/
170 typedef enum
171 {
172         CLOTH_SPRING_TYPE_STRUCTURAL  = ( 1 << 1 ),
173         CLOTH_SPRING_TYPE_SHEAR  = ( 1 << 2 ) ,
174         CLOTH_SPRING_TYPE_BENDING  = ( 1 << 3 ),
175         CLOTH_SPRING_TYPE_GOAL  = ( 1 << 4 ),
176 } CLOTH_SPRING_TYPES;
177
178 /* SPRING FLAGS */
179 typedef enum
180 {
181         CLOTH_SPRING_FLAG_DEACTIVATE = ( 1 << 1 ),
182         CLOTH_SPRING_FLAG_NEEDED = ( 1 << 2 ), // springs has values to be applied
183 } CLOTH_SPRINGS_FLAGS;
184
185
186 /////////////////////////////////////////////////
187 // collision.c
188 ////////////////////////////////////////////////
189
190 // needed for implicit.c
191 int cloth_bvh_objcollision (struct Object *ob, struct ClothModifierData * clmd, float step, float dt );
192
193 ////////////////////////////////////////////////
194
195
196 ////////////////////////////////////////////////
197 // implicit.c
198 ////////////////////////////////////////////////
199
200 // needed for cloth.c
201 int implicit_init (struct Object *ob, struct ClothModifierData *clmd );
202 int implicit_free (struct ClothModifierData *clmd );
203 int implicit_solver (struct Object *ob, float frame, struct ClothModifierData *clmd, struct ListBase *effectors );
204 void implicit_set_positions (struct ClothModifierData *clmd );
205
206 /////////////////////////////////////////////////
207 // cloth.c
208 ////////////////////////////////////////////////
209
210 // needed for modifier.c
211 void cloth_free_modifier_extern (struct ClothModifierData *clmd );
212 void cloth_free_modifier (struct ClothModifierData *clmd );
213 void cloth_init (struct ClothModifierData *clmd );
214 void clothModifier_do (struct ClothModifierData *clmd, struct Scene *scene, struct Object *ob, struct DerivedMesh *dm, float (*vertexCos)[3]);
215
216 int cloth_uses_vgroup(struct ClothModifierData *clmd);
217
218 // needed for collision.c
219 void bvhtree_update_from_cloth (struct ClothModifierData *clmd, int moving );
220 void bvhselftree_update_from_cloth (struct ClothModifierData *clmd, int moving );
221
222 // needed for button_object.c
223 void cloth_clear_cache (struct Object *ob, struct ClothModifierData *clmd, float framenr );
224
225 // needed for cloth.c
226 int cloth_add_spring (struct ClothModifierData *clmd, unsigned int indexA, unsigned int indexB, float restlength, int spring_type);
227
228 ////////////////////////////////////////////////
229
230
231 /* This enum provides the IDs for our solvers. */
232 // only one available in the moment
233 typedef enum
234 {
235         CM_IMPLICIT = 0,
236 } CM_SOLVER_ID;
237
238
239 /* This structure defines how to call the solver.
240  */
241 typedef struct
242 {
243         const char              *name;
244         CM_SOLVER_ID    id;
245         int     ( *init ) (struct Object *ob, struct ClothModifierData *clmd );
246         int     ( *solver ) (struct Object *ob, float framenr, struct ClothModifierData *clmd, struct ListBase *effectors );
247         int     ( *free ) (struct ClothModifierData *clmd );
248 }
249 CM_SOLVER_DEF;
250
251
252 #endif
253