d8b3fcfd0bb0e0b8d91287e0fb44a9dbe1e5d50f
[blender-staging.git] / source / blender / blenkernel / BKE_cloth.h
1 /**
2  * BKE_cloth.h
3  *
4  * $Id$
5  *
6  * ***** BEGIN GPL LICENSE BLOCK *****
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
21  *
22  * The Original Code is Copyright (C) Blender Foundation.
23  * All rights reserved.
24  *
25  * The Original Code is: all of this file.
26  *
27  * Contributor(s): Daniel Genrich
28  *
29  * ***** END GPL LICENSE BLOCK *****
30  */
31 #ifndef BKE_CLOTH_H
32 #define BKE_CLOTH_H
33
34 #include <float.h>
35
36 #include "BLI_linklist.h"
37 #include "BKE_customdata.h"
38 #include "BKE_DerivedMesh.h"
39
40 #include "BLI_blenlib.h"
41 #include "BLI_math.h"
42 #include "BLI_edgehash.h"
43
44 #include "DNA_cloth_types.h"
45 #include "DNA_customdata_types.h"
46 #include "DNA_meshdata_types.h"
47 #include "DNA_modifier_types.h"
48 #include "DNA_object_types.h"
49 #include "DNA_scene_types.h"
50
51 #include "BKE_collision.h"
52
53 struct Object;
54 struct Scene;
55 struct MFace;
56 struct DerivedMesh;
57 struct ClothModifierData;
58 struct CollisionTree;
59
60 // this is needed for inlining behaviour
61 #if defined _WIN32
62 #   define DO_INLINE __inline
63 #elif defined (__sgi)
64 #   define DO_INLINE
65 #elif defined (__sun) || defined (__sun__)
66 #   define DO_INLINE
67 #else
68 #   define DO_INLINE static inline
69 #endif
70
71 #define CLOTH_MAX_THREAD 2
72
73 /* goal defines */
74 #define SOFTGOALSNAP  0.999f
75
76 /* This is approximately the smallest number that can be
77 * represented by a float, given its precision. */
78 #define ALMOST_ZERO             FLT_EPSILON
79
80 /* Bits to or into the ClothVertex.flags. */
81 #define CLOTH_VERT_FLAG_PINNED 1
82 #define CLOTH_VERT_FLAG_COLLISION 2
83 #define CLOTH_VERT_FLAG_PINNED_EM 3
84
85 /**
86 * This structure describes a cloth object against which the
87 * simulation can run.
88 *
89 * The m and n members of this structure represent the assumed
90 * rectangular ordered grid for which the original paper is written.
91 * At some point they need to disappear and we need to determine out
92 * own connectivity of the mesh based on the actual edges in the mesh.
93 *
94 **/
95 typedef struct Cloth
96 {
97         struct ClothVertex      *verts;                 /* The vertices that represent this cloth. */
98         struct  LinkNode        *springs;               /* The springs connecting the mesh. */
99         unsigned int            numverts;               /* The number of verts == m * n. */
100         unsigned int            numsprings;             /* The count of springs. */
101         unsigned int            numfaces;
102         unsigned char           old_solver_type;        /* unused, only 1 solver here */
103         unsigned char           pad2;
104         short                   pad3;
105         struct BVHTree          *bvhtree;                       /* collision tree for this cloth object */
106         struct BVHTree          *bvhselftree;                   /* collision tree for this cloth object */
107         struct MFace            *mfaces;
108         struct Implicit_Data    *implicit;              /* our implicit solver connects to this pointer */
109         struct Implicit_Data    *implicitEM;            /* our implicit solver connects to this pointer */
110         struct EdgeHash         *edgehash;              /* used for selfcollisions */
111 } Cloth;
112
113 /**
114  * The definition of a cloth vertex.
115  */
116 typedef struct ClothVertex
117 {
118         int     flags;          /* General flags per vertex.            */
119         float   v [3];          /* The velocity of the point.           */
120         float   xconst [3];     /* constrained position                 */
121         float   x [3];          /* The current position of this vertex. */
122         float   xold [3];       /* The previous position of this vertex.*/
123         float   tx [3];         /* temporary position */
124         float   txold [3];      /* temporary old position */
125         float   tv[3];          /* temporary "velocity", mostly used as tv = tx-txold */
126         float   mass;           /* mass / weight of the vertex          */
127         float   goal;           /* goal, from SB                        */
128         float   impulse[3];     /* used in collision.c */
129         float   *xrest;         /* temporary valid for building springs */
130         unsigned int impulse_count; /* same as above */
131         float   avg_spring_len; /* average length of connected springs */
132         float   struct_stiff;
133         float   bend_stiff;
134         float   shear_stiff;
135         int     spring_count; /* how many springs attached? */
136 }
137 ClothVertex;
138
139 /**
140  * The definition of a spring.
141  */
142 typedef struct ClothSpring
143 {
144         int     ij;             /* Pij from the paper, one end of the spring.   */
145         int     kl;             /* Pkl from the paper, one end of the spring.   */
146         float   restlen;        /* The original length of the spring.   */
147         int     matrix_index;   /* needed for implicit solver (fast lookup) */
148         int     type;           /* types defined in BKE_cloth.h ("springType") */
149         int     flags;          /* defined in BKE_cloth.h, e.g. deactivated due to tearing */
150         float dfdx[3][3];
151         float dfdv[3][3];
152         float f[3];
153         float   stiffness;      /* stiffness factor from the vertex groups */
154         float editrestlen;
155 }
156 ClothSpring;
157
158 // some macro enhancements for vector treatment
159 #define VECADDADD(v1,v2,v3)     {*(v1)+= *(v2) + *(v3); *(v1+1)+= *(v2+1) + *(v3+1); *(v1+2)+= *(v2+2) + *(v3+2);}
160 #define VECSUBADD(v1,v2,v3)     {*(v1)-= *(v2) + *(v3); *(v1+1)-= *(v2+1) + *(v3+1); *(v1+2)-= *(v2+2) + *(v3+2);}
161 #define VECADDSUB(v1,v2,v3)     {*(v1)+= *(v2) - *(v3); *(v1+1)+= *(v2+1) - *(v3+1); *(v1+2)+= *(v2+2) - *(v3+2);}
162 #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;}
163 #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;}
164 #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;}
165 #define VECADDS(v1,v2,v3,bS)    {*(v1)= *(v2) + *(v3)*bS; *(v1+1)= *(v2+1) + *(v3+1)*bS; *(v1+2)= *(v2+2) + *(v3+2)*bS;}
166 #define VECSUBMUL(v1,v2,aS)     {*(v1)-= *(v2) * aS; *(v1+1)-= *(v2+1) * aS; *(v1+2)-= *(v2+2) * aS;}
167 #define VECSUBS(v1,v2,v3,bS)    {*(v1)= *(v2) - *(v3)*bS; *(v1+1)= *(v2+1) - *(v3+1)*bS; *(v1+2)= *(v2+2) - *(v3+2)*bS;}
168 #define VECSUBSB(v1,v2, v3,bS)  {*(v1)= (*(v2)- *(v3))*bS; *(v1+1)= (*(v2+1) - *(v3+1))*bS; *(v1+2)= (*(v2+2) - *(v3+2))*bS;}
169 #define VECMULS(v1,aS)  {*(v1)*= aS; *(v1+1)*= aS; *(v1+2)*= *aS;}
170 #define VECADDMUL(v1,v2,aS)     {*(v1)+= *(v2) * aS; *(v1+1)+= *(v2+1) * aS; *(v1+2)+= *(v2+2) * aS;}
171
172 /* SIMULATION FLAGS: goal flags,.. */
173 /* These are the bits used in SimSettings.flags. */
174 typedef enum
175 {
176         CLOTH_SIMSETTINGS_FLAG_COLLOBJ = ( 1 << 2 ),// object is only collision object, no cloth simulation is done
177         CLOTH_SIMSETTINGS_FLAG_GOAL = ( 1 << 3 ),       // we have goals enabled
178         CLOTH_SIMSETTINGS_FLAG_TEARING = ( 1 << 4 ),// true if tearing is enabled
179         CLOTH_SIMSETTINGS_FLAG_SCALING = ( 1 << 8 ), /* is advanced scaling active? */
180         CLOTH_SIMSETTINGS_FLAG_CCACHE_EDIT = (1 << 12), /* edit cache in editmode */
181         CLOTH_SIMSETTINGS_FLAG_NO_SPRING_COMPRESS = (1 << 13) /* don't allow spring compression */
182 } CLOTH_SIMSETTINGS_FLAGS;
183
184 /* COLLISION FLAGS */
185 typedef enum
186 {
187         CLOTH_COLLSETTINGS_FLAG_ENABLED = ( 1 << 1 ), /* enables cloth - object collisions */
188         CLOTH_COLLSETTINGS_FLAG_SELF = ( 1 << 2 ), /* enables selfcollisions */
189 } CLOTH_COLLISIONSETTINGS_FLAGS;
190
191 /* Spring types as defined in the paper.*/
192 typedef enum
193 {
194         CLOTH_SPRING_TYPE_STRUCTURAL  = ( 1 << 1 ),
195         CLOTH_SPRING_TYPE_SHEAR  = ( 1 << 2 ) ,
196         CLOTH_SPRING_TYPE_BENDING  = ( 1 << 3 ),
197         CLOTH_SPRING_TYPE_GOAL  = ( 1 << 4 ),
198 } CLOTH_SPRING_TYPES;
199
200 /* SPRING FLAGS */
201 typedef enum
202 {
203         CLOTH_SPRING_FLAG_DEACTIVATE = ( 1 << 1 ),
204         CLOTH_SPRING_FLAG_NEEDED = ( 1 << 2 ), // springs has values to be applied
205 } CLOTH_SPRINGS_FLAGS;
206
207
208 /////////////////////////////////////////////////
209 // collision.c
210 ////////////////////////////////////////////////
211
212 // needed for implicit.c
213 int cloth_bvh_objcollision (Object *ob, ClothModifierData * clmd, float step, float dt );
214
215 ////////////////////////////////////////////////
216
217
218 ////////////////////////////////////////////////
219 // implicit.c
220 ////////////////////////////////////////////////
221
222 // needed for cloth.c
223 int implicit_init ( Object *ob, ClothModifierData *clmd );
224 int implicit_free ( ClothModifierData *clmd );
225 int implicit_solver ( Object *ob, float frame, ClothModifierData *clmd, ListBase *effectors );
226 void implicit_set_positions ( ClothModifierData *clmd );
227
228 // globally needed
229 void clmdSetInterruptCallBack ( int ( *f ) ( void ) );
230 ////////////////////////////////////////////////
231
232
233 /////////////////////////////////////////////////
234 // cloth.c
235 ////////////////////////////////////////////////
236
237 // needed for modifier.c
238 void cloth_free_modifier_extern ( ClothModifierData *clmd );
239 void cloth_free_modifier ( Object *ob, ClothModifierData *clmd );
240 void cloth_init ( ClothModifierData *clmd );
241 DerivedMesh *clothModifier_do ( ClothModifierData *clmd, struct Scene *scene, Object *ob, DerivedMesh *dm, int useRenderParams, int isFinalCalc );
242
243 void cloth_update_normals ( ClothVertex *verts, int nVerts, MFace *face, int totface );
244 int cloth_uses_vgroup(ClothModifierData *clmd);
245
246 // needed for collision.c
247 void bvhtree_update_from_cloth ( ClothModifierData *clmd, int moving );
248 void bvhselftree_update_from_cloth ( ClothModifierData *clmd, int moving );
249
250 // needed for button_object.c
251 void cloth_clear_cache ( Object *ob, ClothModifierData *clmd, float framenr );
252
253 // needed for cloth.c
254 int cloth_add_spring ( ClothModifierData *clmd, unsigned int indexA, unsigned int indexB, float restlength, int spring_type);
255
256 ////////////////////////////////////////////////
257
258
259 /* This enum provides the IDs for our solvers. */
260 // only one available in the moment
261 typedef enum
262 {
263         CM_IMPLICIT = 0,
264 } CM_SOLVER_ID;
265
266
267 /* This structure defines how to call the solver.
268 */
269 typedef struct
270 {
271         char            *name;
272         CM_SOLVER_ID    id;
273         int     ( *init ) ( Object *ob, ClothModifierData *clmd );
274         int     ( *solver ) ( Object *ob, float framenr, ClothModifierData *clmd, ListBase *effectors );
275         int     ( *free ) ( ClothModifierData *clmd );
276 }
277 CM_SOLVER_DEF;
278
279
280 #endif
281