Mesh Remap: Face Corner Data: Do not use large epsilon values to create bvhtrees.
[blender.git] / source / blender / blenkernel / BKE_cloth.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): Daniel Genrich
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27 #ifndef __BKE_CLOTH_H__
28 #define __BKE_CLOTH_H__
29
30 /** \file BKE_cloth.h
31  *  \ingroup bke
32  *  \author Daniel Genrich
33  */
34
35 #include <float.h>
36 #include "BLI_math_inline.h"
37
38 struct Object;
39 struct Scene;
40 struct MFace;
41 struct DerivedMesh;
42 struct ClothModifierData;
43 struct CollisionModifierData;
44
45 #define DO_INLINE MALWAYS_INLINE
46
47 /* goal defines */
48 #define SOFTGOALSNAP  0.999f
49
50 /* This is approximately the smallest number that can be
51  * represented by a float, given its precision. */
52 #define ALMOST_ZERO             FLT_EPSILON
53
54 /* Bits to or into the ClothVertex.flags. */
55 typedef enum eClothVertexFlag {
56         CLOTH_VERT_FLAG_PINNED      = 1,
57         CLOTH_VERT_FLAG_NOSELFCOLL  = 2, /* vertex NOT used for self collisions */
58 } eClothVertexFlag;
59
60 typedef struct ClothHairData {
61         float loc[3];
62         float rot[3][3];
63         float rest_target[3]; /* rest target direction for each segment */
64         float radius;
65         float bending_stiffness;
66 } ClothHairData;
67
68 typedef struct ClothSolverResult {
69         int status;
70         
71         int max_iterations, min_iterations;
72         float avg_iterations;
73         float max_error, min_error, avg_error;
74 } ClothSolverResult;
75
76 /**
77  * This structure describes a cloth object against which the
78  * simulation can run.
79  *
80  * The m and n members of this structure represent the assumed
81  * rectangular ordered grid for which the original paper is written.
82  * At some point they need to disappear and we need to determine out
83  * own connectivity of the mesh based on the actual edges in the mesh.
84  *
85  */
86 typedef struct Cloth {
87         struct ClothVertex      *verts;                 /* The vertices that represent this cloth. */
88         struct  LinkNode        *springs;               /* The springs connecting the mesh. */
89         unsigned int            numsprings;             /* The count of springs. */
90         unsigned int            mvert_num;              /* The number of verts == m * n. */
91         unsigned int            tri_num;
92         unsigned char           old_solver_type;        /* unused, only 1 solver here */
93         unsigned char           pad2;
94         short                   pad3;
95         struct BVHTree          *bvhtree;                       /* collision tree for this cloth object */
96         struct BVHTree          *bvhselftree;                   /* collision tree for this cloth object */
97         struct MVertTri         *tri;
98         struct Implicit_Data    *implicit;              /* our implicit solver connects to this pointer */
99         struct EdgeSet          *edgeset;               /* used for selfcollisions */
100         int last_frame, pad4;
101 } Cloth;
102
103 /**
104  * The definition of a cloth vertex.
105  */
106 typedef struct ClothVertex {
107         int     flags;          /* General flags per vertex.            */
108         float   v[3];           /* The velocity of the point.           */
109         float   xconst[3];      /* constrained position                 */
110         float   x[3];           /* The current position of this vertex. */
111         float   xold[3];        /* The previous position of this vertex.*/
112         float   tx[3];          /* temporary position */
113         float   txold[3];       /* temporary old position */
114         float   tv[3];          /* temporary "velocity", mostly used as tv = tx-txold */
115         float   mass;           /* mass / weight of the vertex          */
116         float   goal;           /* goal, from SB                        */
117         float   impulse[3];     /* used in collision.c */
118         float   xrest[3];   /* rest position of the vertex */
119         unsigned int impulse_count; /* same as above */
120         float   avg_spring_len; /* average length of connected springs */
121         float   struct_stiff;
122         float   bend_stiff;
123         float   shear_stiff;
124         int     spring_count; /* how many springs attached? */
125         float   shrink_factor; /* how much to shrink this cloth */
126 }
127 ClothVertex;
128
129 /**
130  * The definition of a spring.
131  */
132 typedef struct ClothSpring {
133         int     ij;             /* Pij from the paper, one end of the spring.   */
134         int     kl;             /* Pkl from the paper, one end of the spring.   */
135         int mn;
136         float   restlen;        /* The original length of the spring.   */
137         int     type;           /* types defined in BKE_cloth.h ("springType") */
138         int     flags;          /* defined in BKE_cloth.h, e.g. deactivated due to tearing */
139         float   stiffness;      /* stiffness factor from the vertex groups */
140         float editrestlen;
141         
142         /* angular bending spring target and derivatives */
143         float target[3];
144 }
145 ClothSpring;
146
147 // some macro enhancements for vector treatment
148 #define VECADDADD(v1,v2,v3)     {*(v1)+= *(v2) + *(v3); *(v1+1)+= *(v2+1) + *(v3+1); *(v1+2)+= *(v2+2) + *(v3+2);}
149 #define VECSUBADD(v1,v2,v3)     {*(v1)-= *(v2) + *(v3); *(v1+1)-= *(v2+1) + *(v3+1); *(v1+2)-= *(v2+2) + *(v3+2);}
150 #define VECADDSUB(v1,v2,v3)     {*(v1)+= *(v2) - *(v3); *(v1+1)+= *(v2+1) - *(v3+1); *(v1+2)+= *(v2+2) - *(v3+2);}
151 #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;}
152 #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;}
153 #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;}
154 #define VECADDS(v1,v2,v3,bS)    {*(v1)= *(v2) + *(v3)*bS; *(v1+1)= *(v2+1) + *(v3+1)*bS; *(v1+2)= *(v2+2) + *(v3+2)*bS;}
155 #define VECSUBMUL(v1,v2,aS)     {*(v1)-= *(v2) * aS; *(v1+1)-= *(v2+1) * aS; *(v1+2)-= *(v2+2) * aS;}
156 #define VECSUBS(v1,v2,v3,bS)    {*(v1)= *(v2) - *(v3)*bS; *(v1+1)= *(v2+1) - *(v3+1)*bS; *(v1+2)= *(v2+2) - *(v3+2)*bS;}
157 #define VECSUBSB(v1,v2, v3,bS)  {*(v1)= (*(v2)- *(v3))*bS; *(v1+1)= (*(v2+1) - *(v3+1))*bS; *(v1+2)= (*(v2+2) - *(v3+2))*bS;}
158 #define VECMULS(v1,aS)  {*(v1)*= aS; *(v1+1)*= aS; *(v1+2)*= *aS;}
159 #define VECADDMUL(v1,v2,aS)     {*(v1)+= *(v2) * aS; *(v1+1)+= *(v2+1) * aS; *(v1+2)+= *(v2+2) * aS;}
160
161 /* SIMULATION FLAGS: goal flags,.. */
162 /* These are the bits used in SimSettings.flags. */
163 typedef enum {
164         CLOTH_SIMSETTINGS_FLAG_COLLOBJ = ( 1 << 2 ),// object is only collision object, no cloth simulation is done
165         CLOTH_SIMSETTINGS_FLAG_GOAL = ( 1 << 3 ),       // we have goals enabled
166         CLOTH_SIMSETTINGS_FLAG_TEARING = ( 1 << 4 ),// true if tearing is enabled
167         CLOTH_SIMSETTINGS_FLAG_SCALING = ( 1 << 8 ), /* is advanced scaling active? */
168         CLOTH_SIMSETTINGS_FLAG_CCACHE_EDIT = (1 << 12), /* edit cache in editmode */
169         CLOTH_SIMSETTINGS_FLAG_NO_SPRING_COMPRESS = (1 << 13), /* don't allow spring compression */
170         CLOTH_SIMSETTINGS_FLAG_SEW = (1 << 14), /* pull ends of loose edges together */
171         CLOTH_SIMSETTINGS_FLAG_DYNAMIC_BASEMESH = (1 << 15), /* make simulation respect deformations in the base object */
172 } CLOTH_SIMSETTINGS_FLAGS;
173
174 /* COLLISION FLAGS */
175 typedef enum {
176         CLOTH_COLLSETTINGS_FLAG_ENABLED = ( 1 << 1 ), /* enables cloth - object collisions */
177         CLOTH_COLLSETTINGS_FLAG_SELF = ( 1 << 2 ), /* enables selfcollisions */
178 } CLOTH_COLLISIONSETTINGS_FLAGS;
179
180 /* Spring types as defined in the paper.*/
181 typedef enum {
182         CLOTH_SPRING_TYPE_STRUCTURAL  = (1 << 1),
183         CLOTH_SPRING_TYPE_SHEAR       = (1 << 2),
184         CLOTH_SPRING_TYPE_BENDING     = (1 << 3),
185         CLOTH_SPRING_TYPE_GOAL        = (1 << 4),
186         CLOTH_SPRING_TYPE_SEWING      = (1 << 5),
187         CLOTH_SPRING_TYPE_BENDING_ANG = (1 << 6),
188 } CLOTH_SPRING_TYPES;
189
190 /* SPRING FLAGS */
191 typedef enum {
192         CLOTH_SPRING_FLAG_DEACTIVATE = ( 1 << 1 ),
193         CLOTH_SPRING_FLAG_NEEDED = ( 1 << 2 ), // springs has values to be applied
194 } CLOTH_SPRINGS_FLAGS;
195
196
197 /////////////////////////////////////////////////
198 // collision.c
199 ////////////////////////////////////////////////
200
201 struct CollPair;
202
203 typedef struct ColliderContacts {
204         struct Object *ob;
205         struct CollisionModifierData *collmd;
206         
207         struct CollPair *collisions;
208         int totcollisions;
209 } ColliderContacts;
210
211 // needed for implicit.c
212 int cloth_bvh_objcollision (struct Object *ob, struct ClothModifierData *clmd, float step, float dt );
213 int cloth_points_objcollision(struct Object *ob, struct ClothModifierData *clmd, float step, float dt);
214
215 void cloth_find_point_contacts(struct Object *ob, struct ClothModifierData *clmd, float step, float dt,
216                                ColliderContacts **r_collider_contacts, int *r_totcolliders);
217 void cloth_free_contacts(ColliderContacts *collider_contacts, int totcolliders);
218
219 ////////////////////////////////////////////////
220
221 /////////////////////////////////////////////////
222 // cloth.c
223 ////////////////////////////////////////////////
224
225 // needed for modifier.c
226 void cloth_free_modifier_extern (struct ClothModifierData *clmd );
227 void cloth_free_modifier (struct ClothModifierData *clmd );
228 void cloth_init (struct ClothModifierData *clmd );
229 void clothModifier_do (struct ClothModifierData *clmd, struct Scene *scene, struct Object *ob, struct DerivedMesh *dm, float (*vertexCos)[3]);
230
231 int cloth_uses_vgroup(struct ClothModifierData *clmd);
232
233 // needed for collision.c
234 void bvhtree_update_from_cloth(struct ClothModifierData *clmd, bool moving);
235 void bvhselftree_update_from_cloth(struct ClothModifierData *clmd, bool moving);
236
237 // needed for button_object.c
238 void cloth_clear_cache (struct Object *ob, struct ClothModifierData *clmd, float framenr );
239
240 void cloth_parallel_transport_hair_frame(float mat[3][3], const float dir_old[3], const float dir_new[3]);
241
242 ////////////////////////////////////////////////
243
244 #endif
245