svn merge -r 21041:21301 https://svn.blender.org/svnroot/bf-blender/branches/blender2...
[blender.git] / source / blender / blenkernel / BKE_cloth.h
index 8be27ace3461e733352aa9ed3f613c4645dfeb54..4270c677338e5dd837a95aa4dd7e94b5a7204550 100644 (file)
@@ -1,17 +1,14 @@
 /**
  * BKE_cloth.h
  *
- * $Id: BKE_cloth.h,v 1.1 2007/08/01 02:07:27 daniel Exp $
+ * $Id$
  *
- * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ * ***** BEGIN GPL LICENSE BLOCK *****
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version. The Blender
- * Foundation also sells licenses for use in proprietary software under
- * the Blender License.  See http://www.blender.org/BL/ for information
- * about this.
+ * of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  *
  * The Original Code is: all of this file.
  *
- * Contributor(s): none yet.
+ * Contributor(s): Daniel Genrich
  *
- * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ * ***** END GPL LICENSE BLOCK *****
  */
 #ifndef BKE_CLOTH_H
 #define BKE_CLOTH_H
 
+#include <float.h>
+
 #include "BLI_linklist.h"
+#include "BKE_customdata.h"
 #include "BKE_DerivedMesh.h"
+
+#include "BLI_blenlib.h"
+#include "BLI_arithb.h"
+#include "BLI_edgehash.h"
+
+#include "DNA_cloth_types.h"
 #include "DNA_customdata_types.h"
-#include "BKE_customdata.h"
 #include "DNA_meshdata_types.h"
+#include "DNA_modifier_types.h"
+#include "DNA_object_types.h"
+#include "DNA_scene_types.h"
+
+#include "BKE_collision.h"
 
 struct Object;
-struct Cloth;
+struct Scene;
 struct MFace;
 struct DerivedMesh;
+struct ClothModifierData;
+struct CollisionTree;
 
 // this is needed for inlining behaviour
-
-#ifndef _WIN32
-#define LINUX
-#define DO_INLINE inline
+#if defined _WIN32
+#   define DO_INLINE __inline
+#elif defined (__sgi)
+#   define DO_INLINE
+#elif defined (__sun) || defined (__sun__)
+#   define DO_INLINE
 #else
-#define DO_INLINE
+#   define DO_INLINE inline
+#   define LINUX
 #endif
 
 #define CLOTH_MAX_THREAD 2
 
-
 /* goal defines */
 #define SOFTGOALSNAP  0.999f
 
 /* This is approximately the smallest number that can be
 * represented by a float, given its precision. */
-#define ALMOST_ZERO            0.000001
+#define ALMOST_ZERO            FLT_EPSILON
+
+/* Bits to or into the ClothVertex.flags. */
+#define CLOTH_VERT_FLAG_PINNED 1
+#define CLOTH_VERT_FLAG_COLLISION 2
+#define CLOTH_VERT_FLAG_PINNED_EM 3
+
+/**
+* This structure describes a cloth object against which the
+* simulation can run.
+*
+* The m and n members of this structure represent the assumed
+* rectangular ordered grid for which the original paper is written.
+* At some point they need to disappear and we need to determine out
+* own connectivity of the mesh based on the actual edges in the mesh.
+*
+**/
+typedef struct Cloth
+{
+       struct ClothVertex      *verts;                 /* The vertices that represent this cloth. */
+       struct  LinkNode        *springs;               /* The springs connecting the mesh. */
+       unsigned int            numverts;               /* The number of verts == m * n. */
+       unsigned int            numsprings;             /* The count of springs. */
+       unsigned int            numfaces;
+       unsigned char           old_solver_type;        /* unused, only 1 solver here */
+       unsigned char           pad2;
+       short                   pad3;
+       struct BVHTree          *bvhtree;                       /* collision tree for this cloth object */
+       struct BVHTree          *bvhselftree;                   /* collision tree for this cloth object */
+       struct MFace            *mfaces;
+       struct Implicit_Data    *implicit;              /* our implicit solver connects to this pointer */
+       struct Implicit_Data    *implicitEM;            /* our implicit solver connects to this pointer */
+       struct EdgeHash         *edgehash;              /* used for selfcollisions */
+} Cloth;
+
+/**
+ * The definition of a cloth vertex.
+ */
+typedef struct ClothVertex
+{
+       int     flags;          /* General flags per vertex.            */
+       float   v [3];          /* The velocity of the point.           */
+       float   xconst [3];     /* constrained position                 */
+       float   x [3];          /* The current position of this vertex. */
+       float   xold [3];       /* The previous position of this vertex.*/
+       float   tx [3];         /* temporary position */
+       float   txold [3];      /* temporary old position */
+       float   tv[3];          /* temporary "velocity", mostly used as tv = tx-txold */
+       float   mass;           /* mass / weight of the vertex          */
+       float   goal;           /* goal, from SB                        */
+       float   impulse[3];     /* used in collision.c */
+       unsigned int impulse_count; /* same as above */
+       float   avg_spring_len; /* average length of connected springs */
+       float   struct_stiff;
+       float   bend_stiff;
+       float   shear_stiff;
+       int     spring_count; /* how many springs attached? */
+}
+ClothVertex;
+
+/**
+ * The definition of a spring.
+ */
+typedef struct ClothSpring
+{
+       int     ij;             /* Pij from the paper, one end of the spring.   */
+       int     kl;             /* Pkl from the paper, one end of the spring.   */
+       float   restlen;        /* The original length of the spring.   */
+       int     matrix_index;   /* needed for implicit solver (fast lookup) */
+       int     type;           /* types defined in BKE_cloth.h ("springType") */
+       int     flags;          /* defined in BKE_cloth.h, e.g. deactivated due to tearing */
+       float dfdx[3][3];
+       float dfdv[3][3];
+       float f[3];
+       float   stiffness;      /* stiffness factor from the vertex groups */
+       float editrestlen;
+}
+ClothSpring;
 
 // some macro enhancements for vector treatment
 #define VECADDADD(v1,v2,v3)    {*(v1)+= *(v2) + *(v3); *(v1+1)+= *(v2+1) + *(v3+1); *(v1+2)+= *(v2+2) + *(v3+2);}
@@ -82,76 +173,96 @@ struct DerivedMesh;
 /* These are the bits used in SimSettings.flags. */
 typedef enum
 {
-    CLOTH_SIMSETTINGS_FLAG_RESET = ( 1 << 1 ),         // The CM object requires a reinitializaiton.
-    CLOTH_SIMSETTINGS_FLAG_COLLOBJ = ( 1 << 2 ),       // object is only collision object, no cloth simulation is done
-    CLOTH_SIMSETTINGS_FLAG_GOAL = ( 1 << 3 ),          // we have goals enabled
-    CLOTH_SIMSETTINGS_FLAG_TEARING = ( 1 << 4 ), // true if tearing is enabled
-    CLOTH_SIMSETTINGS_FLAG_CCACHE_PROTECT = ( 1 << 5 ),
-    CLOTH_SIMSETTINGS_FLAG_BIG_FORCE = ( 1 << 6 ), // true if we have big spring force for bending
-    CLOTH_SIMSETTINGS_FLAG_SLEEP = ( 1 << 7 ), // true if we let the cloth go to sleep
+       CLOTH_SIMSETTINGS_FLAG_COLLOBJ = ( 1 << 2 ),// object is only collision object, no cloth simulation is done
+       CLOTH_SIMSETTINGS_FLAG_GOAL = ( 1 << 3 ),       // we have goals enabled
+       CLOTH_SIMSETTINGS_FLAG_TEARING = ( 1 << 4 ),// true if tearing is enabled
+       CLOTH_SIMSETTINGS_FLAG_SCALING = ( 1 << 8 ), /* is advanced scaling active? */
+       CLOTH_SIMSETTINGS_FLAG_CCACHE_EDIT = (1 << 12)  /* edit cache in editmode */
 } CLOTH_SIMSETTINGS_FLAGS;
 
-/* SPRING FLAGS */
+/* COLLISION FLAGS */
 typedef enum
 {
-    CLOTH_COLLISIONSETTINGS_FLAG_ENABLED = ( 1 << 1 ),
+       CLOTH_COLLSETTINGS_FLAG_ENABLED = ( 1 << 1 ), /* enables cloth - object collisions */
+       CLOTH_COLLSETTINGS_FLAG_SELF = ( 1 << 2 ), /* enables selfcollisions */
 } CLOTH_COLLISIONSETTINGS_FLAGS;
 
 /* Spring types as defined in the paper.*/
 typedef enum
 {
-    CLOTH_SPRING_TYPE_STRUCTURAL = 0,
-    CLOTH_SPRING_TYPE_SHEAR,
-    CLOTH_SPRING_TYPE_BENDING,
+       CLOTH_SPRING_TYPE_STRUCTURAL  = ( 1 << 1 ),
+       CLOTH_SPRING_TYPE_SHEAR  = ( 1 << 2 ) ,
+       CLOTH_SPRING_TYPE_BENDING  = ( 1 << 3 ),
+       CLOTH_SPRING_TYPE_GOAL  = ( 1 << 4 ),
 } CLOTH_SPRING_TYPES;
 
 /* SPRING FLAGS */
 typedef enum
 {
-    CLOTH_SPRING_FLAG_DEACTIVATE = ( 1 << 1 ),
-    CLOTH_SPRING_FLAG_NEEDED = ( 1 << 2 ), // springs has values to be applied
+       CLOTH_SPRING_FLAG_DEACTIVATE = ( 1 << 1 ),
+       CLOTH_SPRING_FLAG_NEEDED = ( 1 << 2 ), // springs has values to be applied
 } CLOTH_SPRINGS_FLAGS;
 
-/* Bits to or into the ClothVertex.flags. */
-#define CVERT_FLAG_PINNED      1
-#define CVERT_FLAG_COLLISION   2
 
+/////////////////////////////////////////////////
+// collision.c
+////////////////////////////////////////////////
 
-// needed for buttons_object.c
-// void cloth_cache_free ( ClothModifierData *clmd, float time );
-void cloth_free_modifier ( ClothModifierData *clmd );
+// needed for implicit.c
+int cloth_bvh_objcollision (Object *ob, ClothModifierData * clmd, float step, float dt );
 
-// needed for cloth.c
-void implicit_set_positions ( ClothModifierData *clmd );
+////////////////////////////////////////////////
 
-// from cloth.c, needed for modifier.c
-DerivedMesh *clothModifier_do(ClothModifierData *clmd,Object *ob, DerivedMesh *dm, int useRenderParams, int isFinalCalc);
 
-// needed in implicit.c
-int cloth_bvh_objcollision(ClothModifierData * clmd, float step, float prevstep, float dt);
+////////////////////////////////////////////////
+// implicit.c
+////////////////////////////////////////////////
 
+// needed for cloth.c
+int implicit_init ( Object *ob, ClothModifierData *clmd );
+int implicit_free ( ClothModifierData *clmd );
+int implicit_solver ( Object *ob, float frame, ClothModifierData *clmd, ListBase *effectors );
+void implicit_set_positions ( ClothModifierData *clmd );
+
+// globally needed
+void clmdSetInterruptCallBack ( int ( *f ) ( void ) );
 ////////////////////////////////////////////////
 
 
 /////////////////////////////////////////////////
 // cloth.c
 ////////////////////////////////////////////////
-void cloth_free_modifier ( ClothModifierData *clmd );
+
+// needed for modifier.c
+void cloth_free_modifier_extern ( ClothModifierData *clmd );
+void cloth_free_modifier ( Object *ob, ClothModifierData *clmd );
 void cloth_init ( ClothModifierData *clmd );
+DerivedMesh *clothModifier_do ( ClothModifierData *clmd, struct Scene *scene, Object *ob, DerivedMesh *dm, int useRenderParams, int isFinalCalc );
+
 void cloth_update_normals ( ClothVertex *verts, int nVerts, MFace *face, int totface );
-////////////////////////////////////////////////
 
+// needed for collision.c
+void bvhtree_update_from_cloth ( ClothModifierData *clmd, int moving );
+void bvhselftree_update_from_cloth ( ClothModifierData *clmd, int moving );
 
-/* Typedefs for function pointers we need for solvers and collision detection. */
-typedef void ( *CM_COLLISION_SELF ) ( ClothModifierData *clmd, int step );
-// typedef void ( *CM_COLLISION_OBJ ) ( ClothModifierData *clmd, int step, CM_COLLISION_RESPONSE collision_response );
+// needed for editmesh.c
+void cloth_write_cache( Object *ob, ClothModifierData *clmd, int framenr );
+int cloth_read_cache( Scene *scene, Object *ob, ClothModifierData *clmd, float framenr, int *old_framenr );
+
+// needed for button_object.c
+void cloth_clear_cache ( Object *ob, ClothModifierData *clmd, float framenr );
+
+// needed for cloth.c
+int cloth_add_spring ( ClothModifierData *clmd, unsigned int indexA, unsigned int indexB, float restlength, int spring_type);
+
+////////////////////////////////////////////////
 
 
 /* This enum provides the IDs for our solvers. */
 // only one available in the moment
-typedef enum {
-    CM_IMPLICIT = 0,
-    CM_VERLET = 1,
+typedef enum
+{
+       CM_IMPLICIT = 0,
 } CM_SOLVER_ID;
 
 
@@ -168,74 +279,5 @@ typedef struct
 CM_SOLVER_DEF;
 
 
-/* new C implicit simulator */
-int implicit_init ( Object *ob, ClothModifierData *clmd );
-int implicit_free ( ClothModifierData *clmd );
-int implicit_solver ( Object *ob, float frame, ClothModifierData *clmd, ListBase *effectors );
-
-/* explicit verlet simulator */
-int verlet_init ( Object *ob, ClothModifierData *clmd );
-int verlet_free ( ClothModifierData *clmd );
-int verlet_solver ( Object *ob, float frame, ClothModifierData *clmd, ListBase *effectors );
-
-/* used for caching in implicit.c */
-typedef struct Frame
-{
-       ClothVertex *verts;
-       ClothSpring *springs;
-       unsigned int numverts, numsprings;
-       float time; /* we need float since we want to support sub-frames */
-       float (*x)[3];
-       float (*xold)[3];
-       float (*v)[3];
-       float (*current_xold)[3];
-}
-Frame;
-
-/* used for collisions in collision.c */
-/*
-typedef struct CollPair
-{
-       unsigned int face1; // cloth face
-       unsigned int face2; // object face
-       double distance; // magnitude of vector
-       float normal[3];
-       float vector[3]; // unnormalized collision vector: p2-p1
-       float pa[3], pb[3]; // collision point p1 on face1, p2 on face2
-       int lastsign; // indicates if the distance sign has changed, unused itm
-       float time; // collision time, from 0 up to 1
-       unsigned int ap1, ap2, ap3, bp1, bp2, bp3, bp4;
-       unsigned int pointsb[4];
-}
-CollPair;
-*/
-
-/* used for collisions in collision.c */
-typedef struct EdgeCollPair
-{
-       unsigned int p11, p12, p21, p22;
-       float normal[3];
-       float vector[3];
-       float time;
-       int lastsign;
-       float pa[3], pb[3]; // collision point p1 on face1, p2 on face2
-}
-EdgeCollPair;
-
-/* used for collisions in collision.c */
-typedef struct FaceCollPair
-{
-       unsigned int p11, p12, p13, p21;
-       float normal[3];
-       float vector[3];
-       float time;
-       int lastsign;
-       float pa[3], pb[3]; // collision point p1 on face1, p2 on face2
-}
-FaceCollPair;
-
-// function definitions from implicit.c
-DO_INLINE void mul_fvector_S(float to[3], float from[3], float scalar);
-
 #endif