svn merge -r 12937:13095 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/BL DUAL 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. The Blender
12  * Foundation also sells licenses for use in proprietary software under
13  * the Blender License.  See http://www.blender.org/BL/ for information
14  * about this.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software Foundation,
23  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
24  *
25  * The Original Code is Copyright (C) Blender Foundation.
26  * All rights reserved.
27  *
28  * The Original Code is: all of this file.
29  *
30  * Contributor(s): none yet.
31  *
32  * ***** END GPL/BL DUAL LICENSE BLOCK *****
33  */
34 #ifndef BKE_CLOTH_H
35 #define BKE_CLOTH_H
36
37 #include "BKE_customdata.h"
38 #include "BLI_linklist.h"
39 #include "BKE_DerivedMesh.h"
40 #include "BKE_object.h"
41
42 #include "DNA_cloth_types.h"
43 #include "DNA_customdata_types.h"
44 #include "DNA_meshdata_types.h"
45
46 struct Object;
47 struct Cloth;
48 struct MFace;
49 struct DerivedMesh;
50 struct ClothModifierData;
51
52 // this is needed for inlining behaviour
53
54 #ifndef _WIN32
55 #define LINUX
56 #define DO_INLINE inline
57 #else
58 #define DO_INLINE
59 #endif
60
61 #define CLOTH_MAX_THREAD 2
62
63 typedef struct fc
64 {
65         float *d, *d0;                  // density
66         float *T, *T0;                  // temperature
67         float *u, *u0;                  // velocity in x direction
68         float *v, *v0;                  // velocity in y direction
69         float *w, *w0;                  // velocity in z direction
70         unsigned char* _texture_data;   
71         float _light_dir[3];
72         int _ray_templ[4096][3];
73         FILE* _fp;
74         int _cur_frame;
75         int _nframes;
76 } fc;
77 fc *f_init(void);
78 void f_free(fc *m_fc);
79 void step(fc *m_fc, float dt);
80
81
82 typedef struct ClothVertex {
83         int     flags;          /* General flags per vertex.            */
84         float   mass;           /* mass / weight of the vertex          */
85         float   goal;           /* goal, from SB                        */
86         float   impulse[3];     /* used in collision.c */
87         unsigned int impulse_count; /* same as above */
88         float collball;
89         char octantflag;
90         float weight;
91 } ClothVertex;
92
93 typedef struct ClothSpring {
94         unsigned int    ij;             /* Pij from the paper, one end of the spring.   */
95         unsigned int    kl;             /* Pkl from the paper, one end of the spring.   */
96         float   restlen;        /* The original length of the spring.   */
97         unsigned int    matrix_index;   /* needed for implicit solver (fast lookup) */
98         int     type;           /* types defined in BKE_cloth.h ("springType") */
99         int     flags;          /* defined in BKE_cloth.h, e.g. deactivated due to tearing */
100         float dfdx[3][3];
101         float dfdv[3][3];
102         float f[3];
103 } ClothSpring;
104
105 typedef struct Cloth {
106         struct ClothVertex      *verts;                 /* The vertices that represent this cloth. */
107         struct LinkNode         *springs;               /* The springs connecting the mesh. */
108         struct BVH              *tree;          /* collision tree for this cloth object */
109         struct BVH              *selftree;              /* self collision tree for this cloth object */
110         struct MFace            *mfaces;
111         struct Implicit_Data    *implicit;      /* our implicit solver connects to this pointer */
112         struct EdgeHash         *edgehash; /* used for fast checking adjacent points */
113         unsigned int            numverts;               /* The number of verts == m * n. */
114         unsigned int            numsprings;             /* The count of springs. */
115         unsigned int            numfaces;
116         unsigned int            numothersprings;
117         unsigned int            numspringssave;
118         unsigned int            old_solver_type;
119         float                   (*x)[3]; /* The current position of all vertices.*/
120         float                   (*xold)[3]; /* The previous position of all vertices.*/
121         float                   (*current_x)[3]; /* The TEMPORARY current position of all vertices.*/
122         float                   (*current_xold)[3]; /* The TEMPORARY previous position of all vertices.*/
123         float                   (*v)[4]; /* the current velocity of all vertices */
124         float                   (*current_v)[3];
125         float                   (*xconst)[3];
126         struct fc               *m_fc;
127 } Cloth;
128
129 /* goal defines */
130 #define SOFTGOALSNAP  0.999f
131
132 /* This is approximately the smallest number that can be
133 * represented by a float, given its precision. */
134 #define ALMOST_ZERO             0.000001
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_RESET = ( 1 << 1 ),          // The CM object requires a reinitializaiton.
155     CLOTH_SIMSETTINGS_FLAG_COLLOBJ = ( 1 << 2 ),        // object is only collision object, no cloth simulation is done
156     CLOTH_SIMSETTINGS_FLAG_GOAL = ( 1 << 3 ),           // we have goals enabled
157     CLOTH_SIMSETTINGS_FLAG_TEARING = ( 1 << 4 ), // true if tearing is enabled
158     CLOTH_SIMSETTINGS_FLAG_CCACHE_PROTECT = ( 1 << 5 ),
159     CLOTH_SIMSETTINGS_FLAG_BIG_FORCE = ( 1 << 6 ), // true if we have big spring force for bending
160     CLOTH_SIMSETTINGS_FLAG_SLEEP = ( 1 << 7 ), // true if we let the cloth go to sleep
161 } CLOTH_SIMSETTINGS_FLAGS;
162
163 /* SPRING FLAGS */
164 typedef enum
165 {
166     CLOTH_COLLISIONSETTINGS_FLAG_ENABLED = ( 1 << 1 ),
167 } CLOTH_COLLISIONSETTINGS_FLAGS;
168
169 /* Spring types as defined in the paper.*/
170 typedef enum
171 {
172     CLOTH_SPRING_TYPE_STRUCTURAL = 0,
173     CLOTH_SPRING_TYPE_SHEAR,
174     CLOTH_SPRING_TYPE_BENDING,
175     CLOTH_SPRING_TYPE_COLLISION,
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 /* Bits to or into the ClothVertex.flags. */
186 #define CVERT_FLAG_PINNED       1
187 #define CVERT_FLAG_COLLISION    2
188
189
190 // needed for buttons_object.c
191 void cloth_clear_cache(struct Object *ob, struct ClothModifierData *clmd, float framenr);
192 void cloth_free_modifier ( struct ClothModifierData *clmd );
193
194 // needed for cloth.c
195 void implicit_set_positions ( struct ClothModifierData *clmd );
196
197 // from cloth.c, needed for modifier.c
198 DerivedMesh *clothModifier_do(struct ClothModifierData *clmd, struct Object *ob, struct DerivedMesh *dm, int useRenderParams, int isFinalCalc);
199
200 // needed in implicit.c
201 int cloth_bvh_objcollision(struct ClothModifierData *clmd, float step, float prevstep, float dt);
202
203 ////////////////////////////////////////////////
204
205
206 /////////////////////////////////////////////////
207 // cloth.c
208 ////////////////////////////////////////////////
209 void cloth_free_modifier ( struct ClothModifierData *clmd );
210 void cloth_init ( struct ClothModifierData *clmd );
211 ////////////////////////////////////////////////
212
213
214 /* Typedefs for function pointers we need for solvers and collision detection. */
215 typedef void ( *CM_COLLISION_SELF ) ( struct ClothModifierData *clmd, int step );
216 // typedef void ( *CM_COLLISION_OBJ ) ( ClothModifierData *clmd, int step, CM_COLLISION_RESPONSE collision_response );
217
218
219 /* This enum provides the IDs for our solvers. */
220 // only one available in the moment
221 typedef enum {
222     CM_IMPLICIT = 0,
223 } CM_SOLVER_ID;
224
225
226 /* This structure defines how to call the solver.
227 */
228 typedef struct
229 {
230         char            *name;
231         CM_SOLVER_ID    id;
232         int     ( *init ) ( struct Object *ob, struct ClothModifierData *clmd );
233         int     ( *solver ) ( struct Object *ob, float framenr, struct ClothModifierData *clmd, struct ListBase *effectors );
234         int     ( *free ) ( struct ClothModifierData *clmd );
235 }
236 CM_SOLVER_DEF;
237
238
239 /* new C implicit simulator */
240 int implicit_init ( struct Object *ob, struct ClothModifierData *clmd );
241 int implicit_free ( struct ClothModifierData *clmd );
242 int implicit_solver ( struct Object *ob, float frame, struct ClothModifierData *clmd, struct ListBase *effectors );
243
244 /* explicit verlet simulator */
245 int verlet_init ( struct Object *ob, struct ClothModifierData *clmd );
246 int verlet_free ( struct ClothModifierData *clmd );
247 int verlet_solver ( struct Object *ob, float frame, struct ClothModifierData *clmd, struct ListBase *effectors );
248
249
250 /* used for collisions in collision.c */
251 /*
252 typedef struct CollPair
253 {
254         unsigned int face1; // cloth face
255         unsigned int face2; // object face
256         double distance; // magnitude of vector
257         float normal[3];
258         float vector[3]; // unnormalized collision vector: p2-p1
259         float pa[3], pb[3]; // collision point p1 on face1, p2 on face2
260         int lastsign; // indicates if the distance sign has changed, unused itm
261         float time; // collision time, from 0 up to 1
262         unsigned int ap1, ap2, ap3, bp1, bp2, bp3, bp4;
263         unsigned int pointsb[4];
264 }
265 CollPair;
266 */
267
268 /* used for collisions in collision.c */
269 typedef struct EdgeCollPair
270 {
271         unsigned int p11, p12, p21, p22;
272         float normal[3];
273         float vector[3];
274         float time;
275         int lastsign;
276         float pa[3], pb[3]; // collision point p1 on face1, p2 on face2
277 }
278 EdgeCollPair;
279
280 /* used for collisions in collision.c */
281 typedef struct FaceCollPair
282 {
283         unsigned int p11, p12, p13, p21;
284         float normal[3];
285         float vector[3];
286         float time;
287         int lastsign;
288         float pa[3], pb[3]; // collision point p1 on face1, p2 on face2
289 }
290 FaceCollPair;
291
292 // function definitions from implicit.c
293 DO_INLINE void mul_fvector_S(float to[3], float from[3], float scalar);
294
295 #endif
296