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