Bugfix: 32bit cloth files were loaded bad in 64bit blenders and the way arround....
[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): none yet.
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 struct Object;
53
54 struct MFace;
55 struct DerivedMesh;
56 struct ClothModifierData;
57 struct CollisionTree;
58
59 // this is needed for inlining behaviour
60 #if defined _WIN32
61 #   define DO_INLINE __inline
62 #elif defined (__sgi)
63 #   define DO_INLINE
64 #elif defined (__sun) || defined (__sun__)
65 #   define DO_INLINE
66 #else
67 #   define DO_INLINE inline
68 #   define LINUX
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 BVH              *tree;                  /* collision tree for this cloth object */
106         struct MFace            *mfaces;
107         struct Implicit_Data    *implicit;              /* our implicit solver connects to this pointer */
108         struct Implicit_Data    *implicitEM;            /* our implicit solver connects to this pointer */
109         struct EdgeHash         *edgehash;              /* used for selfcollisions */
110 } Cloth;
111
112 /**
113  * The definition of a cloth vertex.
114  */
115 typedef struct ClothVertex
116 {
117         int     flags;          /* General flags per vertex.            */
118         float   v [3];          /* The velocity of the point.           */
119         float   xconst [3];     /* constrained position                 */
120         float   x [3];          /* The current position of this vertex. */
121         float   xold [3];       /* The previous position of this vertex.*/
122         float   tx [3];         /* temporary position */
123         float   txold [3];      /* temporary old position */
124         float   tv[3];          /* temporary "velocity", mostly used as tv = tx-txold */
125         float   mass;           /* mass / weight of the vertex          */
126         float   goal;           /* goal, from SB                        */
127         float   impulse[3];     /* used in collision.c */
128         unsigned int impulse_count; /* same as above */
129         float   avg_spring_len; /* average length of connected springs */
130         float   struct_stiff;
131         float   bend_stiff;
132         float   shear_stiff;
133         int     spring_count; /* how many springs attached? */
134 }
135 ClothVertex;
136
137 /**
138  * The definition of a spring.
139  */
140 typedef struct ClothSpring
141 {
142         int     ij;             /* Pij from the paper, one end of the spring.   */
143         int     kl;             /* Pkl from the paper, one end of the spring.   */
144         float   restlen;        /* The original length of the spring.   */
145         int     matrix_index;   /* needed for implicit solver (fast lookup) */
146         int     type;           /* types defined in BKE_cloth.h ("springType") */
147         int     flags;          /* defined in BKE_cloth.h, e.g. deactivated due to tearing */
148         float dfdx[3][3];
149         float dfdv[3][3];
150         float f[3];
151         float   stiffness;      /* stiffness factor from the vertex groups */
152         float editrestlen;
153 }
154 ClothSpring;
155
156 // some macro enhancements for vector treatment
157 #define VECADDADD(v1,v2,v3)     {*(v1)+= *(v2) + *(v3); *(v1+1)+= *(v2+1) + *(v3+1); *(v1+2)+= *(v2+2) + *(v3+2);}
158 #define VECSUBADD(v1,v2,v3)     {*(v1)-= *(v2) + *(v3); *(v1+1)-= *(v2+1) + *(v3+1); *(v1+2)-= *(v2+2) + *(v3+2);}
159 #define VECADDSUB(v1,v2,v3)     {*(v1)+= *(v2) - *(v3); *(v1+1)+= *(v2+1) - *(v3+1); *(v1+2)+= *(v2+2) - *(v3+2);}
160 #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;}
161 #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;}
162 #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;}
163 #define VECADDS(v1,v2,v3,bS)    {*(v1)= *(v2) + *(v3)*bS; *(v1+1)= *(v2+1) + *(v3+1)*bS; *(v1+2)= *(v2+2) + *(v3+2)*bS;}
164 #define VECSUBMUL(v1,v2,aS)     {*(v1)-= *(v2) * aS; *(v1+1)-= *(v2+1) * aS; *(v1+2)-= *(v2+2) * aS;}
165 #define VECSUBS(v1,v2,v3,bS)    {*(v1)= *(v2) - *(v3)*bS; *(v1+1)= *(v2+1) - *(v3+1)*bS; *(v1+2)= *(v2+2) - *(v3+2)*bS;}
166 #define VECSUBSB(v1,v2, v3,bS)  {*(v1)= (*(v2)- *(v3))*bS; *(v1+1)= (*(v2+1) - *(v3+1))*bS; *(v1+2)= (*(v2+2) - *(v3+2))*bS;}
167 #define VECMULS(v1,aS)  {*(v1)*= aS; *(v1+1)*= aS; *(v1+2)*= *aS;}
168 #define VECADDMUL(v1,v2,aS)     {*(v1)+= *(v2) * aS; *(v1+1)+= *(v2+1) * aS; *(v1+2)+= *(v2+2) * aS;}
169
170 /* SIMULATION FLAGS: goal flags,.. */
171 /* These are the bits used in SimSettings.flags. */
172 typedef enum
173 {
174         //CLOTH_SIMSETTINGS_FLAG_RESET = ( 1 << 1 ),    // The CM object requires a reinitializaiton.
175         CLOTH_SIMSETTINGS_FLAG_COLLOBJ = ( 1 << 2 ),// object is only collision object, no cloth simulation is done
176         CLOTH_SIMSETTINGS_FLAG_GOAL = ( 1 << 3 ),       // we have goals enabled
177         CLOTH_SIMSETTINGS_FLAG_TEARING = ( 1 << 4 ),// true if tearing is enabled
178         //CLOTH_SIMSETTINGS_FLAG_CCACHE_PROTECT = ( 1 << 5 ), // true if tearing is enabled
179         //CLOTH_SIMSETTINGS_FLAG_EDITMODE = ( 1 << 6 ), // are we in editmode? -several things disabled
180         //CLOTH_SIMSETTINGS_FLAG_CCACHE_FFREE = ( 1 << 7 ), /* force cache freeing */
181         CLOTH_SIMSETTINGS_FLAG_SCALING = ( 1 << 8 ), /* is advanced scaling active? */
182         //CLOTH_SIMSETTINGS_FLAG_LOADED = ( 1 << 9 ), /* did we just got load? */
183         //CLOTH_SIMSETTINGS_FLAG_AUTOPROTECT = ( 1 << 10 ), /* is autoprotect enabled? */
184         //CLOTH_SIMSETTINGS_FLAG_CCACHE_OUTDATED = (1 << 11),   /* while protected, did cache get outdated? */
185         CLOTH_SIMSETTINGS_FLAG_CCACHE_EDIT = (1 << 12)  /* edit cache in editmode */
186 } CLOTH_SIMSETTINGS_FLAGS;
187
188 /* COLLISION FLAGS */
189 typedef enum
190 {
191         CLOTH_COLLSETTINGS_FLAG_ENABLED = ( 1 << 1 ), /* enables cloth - object collisions */
192         CLOTH_COLLSETTINGS_FLAG_SELF = ( 1 << 2 ), /* enables selfcollisions */
193 } CLOTH_COLLISIONSETTINGS_FLAGS;
194
195 /* Spring types as defined in the paper.*/
196 typedef enum
197 {
198         CLOTH_SPRING_TYPE_STRUCTURAL  = ( 1 << 1 ),
199         CLOTH_SPRING_TYPE_SHEAR  = ( 1 << 2 ) ,
200         CLOTH_SPRING_TYPE_BENDING  = ( 1 << 3 ),
201         CLOTH_SPRING_TYPE_GOAL  = ( 1 << 4 ),
202 } CLOTH_SPRING_TYPES;
203
204 /* SPRING FLAGS */
205 typedef enum
206 {
207         CLOTH_SPRING_FLAG_DEACTIVATE = ( 1 << 1 ),
208         CLOTH_SPRING_FLAG_NEEDED = ( 1 << 2 ), // springs has values to be applied
209 } CLOTH_SPRINGS_FLAGS;
210
211 /////////////////////////////////////////////////
212 // collision.c
213 ////////////////////////////////////////////////
214
215 // needed for implicit.c
216 int cloth_bvh_objcollision ( ClothModifierData * clmd, float step, float dt );
217
218 ////////////////////////////////////////////////
219
220
221 ////////////////////////////////////////////////
222 // implicit.c
223 ////////////////////////////////////////////////
224
225 // needed for cloth.c
226 int implicit_init ( Object *ob, ClothModifierData *clmd );
227 int implicit_free ( ClothModifierData *clmd );
228 int implicit_solver ( Object *ob, float frame, ClothModifierData *clmd, ListBase *effectors );
229 void implicit_set_positions ( ClothModifierData *clmd );
230
231 // globally needed
232 void clmdSetInterruptCallBack ( int ( *f ) ( void ) );
233 ////////////////////////////////////////////////
234
235
236 /////////////////////////////////////////////////
237 // cloth.c
238 ////////////////////////////////////////////////
239
240 // needed for modifier.c
241 void cloth_free_modifier_extern ( ClothModifierData *clmd );
242 void cloth_free_modifier ( Object *ob, ClothModifierData *clmd );
243 void cloth_init ( ClothModifierData *clmd );
244 DerivedMesh *clothModifier_do ( ClothModifierData *clmd,Object *ob, DerivedMesh *dm, int useRenderParams, int isFinalCalc );
245
246 void cloth_update_normals ( ClothVertex *verts, int nVerts, MFace *face, int totface );
247
248 // needed for collision.c
249 void bvh_update_from_cloth ( ClothModifierData *clmd, int moving );
250
251 // needed for editmesh.c
252 void cloth_write_cache ( Object *ob, ClothModifierData *clmd, float framenr );
253 int cloth_read_cache ( Object *ob, ClothModifierData *clmd, float framenr );
254
255 // needed for button_object.c
256 void cloth_clear_cache ( Object *ob, ClothModifierData *clmd, float framenr );
257
258 // needed for cloth.c
259 int cloth_add_spring ( ClothModifierData *clmd, unsigned int indexA, unsigned int indexB, float restlength, int spring_type);
260
261 ////////////////////////////////////////////////
262
263
264 /* Typedefs for function pointers we need for solvers and collision detection. */
265 typedef void ( *CM_COLLISION_SELF ) ( ClothModifierData *clmd, int step );
266 typedef void ( *CM_COLLISION_OBJ ) ( ClothModifierData *clmd, int step, CM_COLLISION_RESPONSE collision_response );
267
268
269 /* This enum provides the IDs for our solvers. */
270 // only one available in the moment
271 typedef enum
272 {
273         CM_IMPLICIT = 0,
274 } CM_SOLVER_ID;
275
276
277 /* This structure defines how to call the solver.
278 */
279 typedef struct
280 {
281         char            *name;
282         CM_SOLVER_ID    id;
283         int     ( *init ) ( Object *ob, ClothModifierData *clmd );
284         int     ( *solver ) ( Object *ob, float framenr, ClothModifierData *clmd, ListBase *effectors );
285         int     ( *free ) ( ClothModifierData *clmd );
286 }
287 CM_SOLVER_DEF;
288
289 /* used for caching in implicit.c */
290 typedef struct Frame
291 {
292         ClothVertex *verts;
293         ClothSpring *springs;
294         unsigned int numverts, numsprings;
295         float time; /* we need float since we want to support sub-frames */
296 }
297 Frame;
298
299 #endif
300