BKE_cloth.h

Go to the documentation of this file.

/*
 * $Id: BKE_cloth.h 36419 2011-05-01 21:39:13Z joeedh $
 *
 * ***** 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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) Blender Foundation.
 * All rights reserved.
 *
 * The Original Code is: all of this file.
 *
 * Contributor(s): Daniel Genrich
 *
 * ***** END GPL LICENSE BLOCK *****
 */
#ifndef BKE_CLOTH_H
#define BKE_CLOTH_H

#include <float.h>
#include "BLI_math_inline.h"

struct Object;
struct ListBase;
struct Scene;
struct MFace;
struct DerivedMesh;
struct ClothModifierData;
struct CollisionTree;

#define DO_INLINE MALWAYS_INLINE

#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             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

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;

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 */
        float   *xrest;         /* temporary valid for building springs */
        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;

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);}
#define VECSUBADD(v1,v2,v3)     {*(v1)-= *(v2) + *(v3); *(v1+1)-= *(v2+1) + *(v3+1); *(v1+2)-= *(v2+2) + *(v3+2);}
#define VECADDSUB(v1,v2,v3)     {*(v1)+= *(v2) - *(v3); *(v1+1)+= *(v2+1) - *(v3+1); *(v1+2)+= *(v2+2) - *(v3+2);}
#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;}
#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;}
#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;}
#define VECADDS(v1,v2,v3,bS)    {*(v1)= *(v2) + *(v3)*bS; *(v1+1)= *(v2+1) + *(v3+1)*bS; *(v1+2)= *(v2+2) + *(v3+2)*bS;}
#define VECSUBMUL(v1,v2,aS)     {*(v1)-= *(v2) * aS; *(v1+1)-= *(v2+1) * aS; *(v1+2)-= *(v2+2) * aS;}
#define VECSUBS(v1,v2,v3,bS)    {*(v1)= *(v2) - *(v3)*bS; *(v1+1)= *(v2+1) - *(v3+1)*bS; *(v1+2)= *(v2+2) - *(v3+2)*bS;}
#define VECSUBSB(v1,v2, v3,bS)  {*(v1)= (*(v2)- *(v3))*bS; *(v1+1)= (*(v2+1) - *(v3+1))*bS; *(v1+2)= (*(v2+2) - *(v3+2))*bS;}
#define VECMULS(v1,aS)  {*(v1)*= aS; *(v1+1)*= aS; *(v1+2)*= *aS;}
#define VECADDMUL(v1,v2,aS)     {*(v1)+= *(v2) * aS; *(v1+1)+= *(v2+1) * aS; *(v1+2)+= *(v2+2) * aS;}

/* SIMULATION FLAGS: goal flags,.. */
/* These are the bits used in SimSettings.flags. */
typedef enum
{
        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_FLAG_NO_SPRING_COMPRESS = (1 << 13) /* don't allow spring compression */
} CLOTH_SIMSETTINGS_FLAGS;

/* COLLISION FLAGS */
typedef enum
{
        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  = ( 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_SPRINGS_FLAGS;


// collision.c

// needed for implicit.c
int cloth_bvh_objcollision (struct Object *ob, struct ClothModifierData * clmd, float step, float dt );



// implicit.c

// needed for cloth.c
int implicit_init ( struct Object *ob, struct ClothModifierData *clmd );
int implicit_free ( struct ClothModifierData *clmd );
int implicit_solver ( struct Object *ob, float frame, struct ClothModifierData *clmd, struct ListBase *effectors );
void implicit_set_positions ( struct ClothModifierData *clmd );

// globally needed
void clmdSetInterruptCallBack ( int ( *f ) ( void ) );


// cloth.c

// needed for modifier.c
void cloth_free_modifier_extern ( struct ClothModifierData *clmd );
void cloth_free_modifier ( struct ClothModifierData *clmd );
void cloth_init ( struct ClothModifierData *clmd );
struct DerivedMesh *clothModifier_do ( struct ClothModifierData *clmd, struct Scene *scene, struct Object *ob, struct DerivedMesh *dm);

void cloth_update_normals ( ClothVertex *verts, int nVerts, struct MFace *face, int totface );
int cloth_uses_vgroup(struct ClothModifierData *clmd);

// needed for collision.c
void bvhtree_update_from_cloth ( struct ClothModifierData *clmd, int moving );
void bvhselftree_update_from_cloth ( struct ClothModifierData *clmd, int moving );

// needed for button_object.c
void cloth_clear_cache ( struct Object *ob, struct ClothModifierData *clmd, float framenr );

// needed for cloth.c
int cloth_add_spring ( struct 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_SOLVER_ID;


/* This structure defines how to call the solver.
*/
typedef struct
{
        const char              *name;
        CM_SOLVER_ID    id;
        int     ( *init ) ( struct Object *ob, struct ClothModifierData *clmd );
        int     ( *solver ) ( struct Object *ob, float framenr, struct ClothModifierData *clmd, struct ListBase *effectors );
        int     ( *free ) ( struct ClothModifierData *clmd );
}
CM_SOLVER_DEF;


#endif