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