From a12c2a85610e28248effd019ae46518da22dac30 Mon Sep 17 00:00:00 2001 From: Joshua Leung Date: Mon, 16 Nov 2009 12:33:42 +0000 Subject: Constraints: Code cleanup * Removing duplicate api functions * Shuffled around newly added api functions to make the ordering more consistent * Fixes for a few bugs in the api functions as I checked over them * Replaced most of the #defines for flags and modes with enums --- source/blender/blenkernel/BKE_constraint.h | 19 +- source/blender/blenkernel/intern/constraint.c | 234 ++++++++--------- source/blender/blenkernel/intern/fmodifier.c | 12 +- source/blender/editors/object/object_constraint.c | 7 +- source/blender/makesdna/DNA_constraint_types.h | 299 +++++++++++++--------- source/blender/makesrna/intern/rna_constraint.c | 11 +- source/blender/makesrna/intern/rna_object.c | 4 +- source/blender/makesrna/intern/rna_pose.c | 4 +- 8 files changed, 322 insertions(+), 268 deletions(-) (limited to 'source') diff --git a/source/blender/blenkernel/BKE_constraint.h b/source/blender/blenkernel/BKE_constraint.h index 7bb17d9a0e0..a8ccc84a7c3 100644 --- a/source/blender/blenkernel/BKE_constraint.h +++ b/source/blender/blenkernel/BKE_constraint.h @@ -102,23 +102,12 @@ typedef struct bConstraintTypeInfo { bConstraintTypeInfo *constraint_get_typeinfo(struct bConstraint *con); bConstraintTypeInfo *get_constraint_typeinfo(int type); -struct bConstraint *add_ob_constraint(struct Object *ob, const char *name, short type); -struct bConstraint *add_pose_constraint(struct Object *ob, struct bPoseChannel *pchan, const char *name, short type); - -struct bConstraint *find_active_constraint(ListBase *constraints); -void set_active_constraint(ListBase *constraints, struct bConstraint *con); - - -int remove_constraint(ListBase *constraints, struct bConstraint *con); -int remove_constraint_index(ListBase *constraints, int index); - /* ---------------------------------------------------------------------------- */ /* Useful macros for testing various common flag combinations */ /* Constraint Target Macros */ #define VALID_CONS_TARGET(ct) ((ct) && (ct->tar)) - /* ---------------------------------------------------------------------------- */ /* Constraint function prototypes */ @@ -129,7 +118,15 @@ void copy_constraints(struct ListBase *dst, struct ListBase *src); void relink_constraints(struct ListBase *list); void free_constraint_data(struct bConstraint *con); +/* Constraint API function prototypes */ struct bConstraint *constraints_get_active(struct ListBase *list); +void constraints_set_active(ListBase *list, struct bConstraint *con); + +struct bConstraint *add_ob_constraint(struct Object *ob, const char *name, short type); +struct bConstraint *add_pose_constraint(struct Object *ob, struct bPoseChannel *pchan, const char *name, short type); + +int remove_constraint(ListBase *list, struct bConstraint *con); +int remove_constraint_index(ListBase *list, int index); /* Constraints + Proxies function prototypes */ void extract_proxylocal_constraints(struct ListBase *dst, struct ListBase *src); diff --git a/source/blender/blenkernel/intern/constraint.c b/source/blender/blenkernel/intern/constraint.c index 5015420000d..46fdec90528 100644 --- a/source/blender/blenkernel/intern/constraint.c +++ b/source/blender/blenkernel/intern/constraint.c @@ -3605,171 +3605,155 @@ bConstraintTypeInfo *constraint_get_typeinfo (bConstraint *con) return NULL; } -/* Creates a new constraint, initialises its data, and returns it */ -static bConstraint *add_new_constraint_internal(const char *name, short type) +/* ************************* General Constraints API ************************** */ +/* The functions here are called by various parts of Blender. Very few (should be none if possible) + * constraint-specific code should occur here. + */ + +/* ---------- Data Management ------- */ + +/* Free data of a specific constraint if it has any info */ +void free_constraint_data (bConstraint *con) +{ + if (con->data) { + bConstraintTypeInfo *cti= constraint_get_typeinfo(con); + + /* perform any special freeing constraint may have */ + if (cti && cti->free_data) + cti->free_data(con); + + /* free constraint data now */ + MEM_freeN(con->data); + } +} + +/* Free all constraints from a constraint-stack */ +void free_constraints (ListBase *list) { bConstraint *con; - bConstraintTypeInfo *cti; + + /* Free constraint data and also any extra data */ + for (con= list->first; con; con= con->next) + free_constraint_data(con); + + /* Free the whole list */ + BLI_freelistN(list); +} - con = MEM_callocN(sizeof(bConstraint), "Constraint"); + +/* Remove the specified constraint from the given constraint stack */ +int remove_constraint (ListBase *list, bConstraint *con) +{ + if (con) { + free_constraint_data(con); + BLI_freelinkN(list, con); + return 1; + } + else + return 0; +} + +/* Remove the nth constraint from the given constraint stack */ +int remove_constraint_index (ListBase *list, int index) +{ + bConstraint *con= BLI_findlink(list, index); + + if (con) + return remove_constraint(list, con); + else + return 0; +} + +/* ......... */ + +/* Creates a new constraint, initialises its data, and returns it */ +static bConstraint *add_new_constraint_internal (const char *name, short type) +{ + bConstraint *con= MEM_callocN(sizeof(bConstraint), "Constraint"); + bConstraintTypeInfo *cti= get_constraint_typeinfo(type); + const char *newName; /* Set up a generic constraint datablock */ con->type = type; con->flag |= CONSTRAINT_EXPAND; con->enforce = 1.0f; - /* Load the data for it */ - cti = constraint_get_typeinfo(con); + /* Determine a basic name, and info */ if (cti) { + /* initialise constraint data */ con->data = MEM_callocN(cti->size, cti->structName); - + /* only constraints that change any settings need this */ if (cti->new_data) cti->new_data(con->data); - - /* set the name based on the type of constraint */ - name= name ? name : cti->name; + + /* if no name is provided, use the type of the constraint as the name */ + newName= (name && name[0]) ? name : cti->name; } - else - name= name ? name : "Const"; - - strcpy(con->name, name); - + else { + /* if no name is provided, use the generic "Const" name */ + // NOTE: any constraint type that gets here really shouldn't get added... + newName= (name && name[0]) ? name : "Const"; + } + + /* copy the name */ + BLI_strncpy(con->name, newName, sizeof(con->name)); + + /* return the new constraint */ return con; } /* if pchan is not NULL then assume we're adding a pose constraint */ -static bConstraint *add_new_constraint(Object *ob, bPoseChannel *pchan, const char *name, short type) +static bConstraint *add_new_constraint (Object *ob, bPoseChannel *pchan, const char *name, short type) { bConstraint *con; ListBase *list; - + + /* add the constraint */ con= add_new_constraint_internal(name, type); - - if(pchan) list= &pchan->constraints; - else list= &ob->constraints; - + + /* find the constraint stack - bone or object? */ + list = (pchan) ? (&pchan->constraints) : (&ob->constraints); + if (list) { - bConstraint *coniter; - /* add new constraint to end of list of constraints before ensuring that it has a unique name * (otherwise unique-naming code will fail, since it assumes element exists in list) */ BLI_addtail(list, con); unique_constraint_name(con, list); - + /* if the target list is a list on some PoseChannel belonging to a proxy-protected * Armature layer, we must tag newly added constraints with a flag which allows them * to persist after proxy syncing has been done */ if (proxylocked_constraints_owner(ob, pchan)) con->flag |= CONSTRAINT_PROXY_LOCAL; - - /* make this constraint the active one - * - since constraint was added at end of stack, we can just go - * through deactivating all previous ones - */ - con->flag |= CONSTRAINT_ACTIVE; - for (coniter= con->prev; coniter; coniter= coniter->prev) - coniter->flag &= ~CONSTRAINT_ACTIVE; + + /* make this constraint the active one */ + constraints_set_active(list, con); } - + return con; } -bConstraint *add_pose_constraint(Object *ob, bPoseChannel *pchan, const char *name, short type) +/* ......... */ + +/* Add new constraint for the given bone */ +bConstraint *add_pose_constraint (Object *ob, bPoseChannel *pchan, const char *name, short type) { - if(pchan==NULL) + if (pchan == NULL) return NULL; - + return add_new_constraint(ob, pchan, name, type); } +/* Add new constraint for the given object */ bConstraint *add_ob_constraint(Object *ob, const char *name, short type) { return add_new_constraint(ob, NULL, name, type); } -struct bConstraint *find_active_constraint(ListBase *constraints) -{ - bConstraint *con; - if (constraints==NULL) - return NULL; - - for(con= constraints->first; con; con= con->next) { - if(con->flag & CONSTRAINT_ACTIVE) - return con; - } - - return NULL; -} - -void set_active_constraint(ListBase *constraints, struct bConstraint *con) -{ - bConstraint *con_i; - for(con_i= constraints->first; con_i; con_i= con_i->next) { - if(con_i==con) con->flag |= CONSTRAINT_ACTIVE; - else con->flag &= ~CONSTRAINT_ACTIVE; - } -} - -int remove_constraint(ListBase *constraints, struct bConstraint *con) -{ - if(con) { - free_constraint_data(con); - BLI_freelinkN(constraints, con); - return 1; - } - else { - return 0; - } -} - -int remove_constraint_index(ListBase *constraints, int index) -{ - bConstraint *con= BLI_findlink(constraints, index); - if(con) { - return remove_constraint(constraints, con); - } - else { - return 0; - } -} - -/* ************************* General Constraints API ************************** */ -/* The functions here are called by various parts of Blender. Very few (should be none if possible) - * constraint-specific code should occur here. - */ - -/* ---------- Data Management ------- */ - -/* Free data of a specific constraint if it has any info */ -void free_constraint_data (bConstraint *con) -{ - if (con->data) { - bConstraintTypeInfo *cti= constraint_get_typeinfo(con); - - /* perform any special freeing constraint may have */ - if (cti && cti->free_data) - cti->free_data(con); - - /* free constraint data now */ - MEM_freeN(con->data); - } -} - -/* Free all constraints from a constraint-stack */ -void free_constraints (ListBase *list) -{ - bConstraint *con; - - /* Free constraint data and also any extra data */ - for (con= list->first; con; con= con->next) - free_constraint_data(con); - - /* Free the whole list */ - BLI_freelistN(list); -} +/* ......... */ /* Reassign links that constraints have to other data (called during file loading?) */ void relink_constraints (ListBase *conlist) @@ -3801,6 +3785,8 @@ void relink_constraints (ListBase *conlist) } } +/* ......... */ + /* duplicate all of the constraints in a constraint stack */ void copy_constraints (ListBase *dst, ListBase *src) { @@ -3815,6 +3801,7 @@ void copy_constraints (ListBase *dst, ListBase *src) /* make a new copy of the constraint's data */ con->data = MEM_dupallocN(con->data); + // NOTE: depreceated... old animation system id_us_plus((ID *)con->ipo); /* only do specific constraints if required */ @@ -3823,6 +3810,8 @@ void copy_constraints (ListBase *dst, ListBase *src) } } +/* ......... */ + /* finds the 'active' constraint in a constraint stack */ bConstraint *constraints_get_active (ListBase *list) { @@ -3840,6 +3829,19 @@ bConstraint *constraints_get_active (ListBase *list) return NULL; } +/* Set the given constraint as the active one (clearing all the others) */ +void constraints_set_active (ListBase *list, bConstraint *con) +{ + bConstraint *c; + + for (c= list->first; c; c= c->next) { + if (c == con) + c->flag |= CONSTRAINT_ACTIVE; + else + c->flag &= ~CONSTRAINT_ACTIVE; + } +} + /* -------- Constraints and Proxies ------- */ /* Rescue all constraints tagged as being CONSTRAINT_PROXY_LOCAL (i.e. added to bone that's proxy-synced in this file) */ diff --git a/source/blender/blenkernel/intern/fmodifier.c b/source/blender/blenkernel/intern/fmodifier.c index e9e12e29606..5daa2ed1924 100644 --- a/source/blender/blenkernel/intern/fmodifier.c +++ b/source/blender/blenkernel/intern/fmodifier.c @@ -1013,22 +1013,20 @@ int remove_fmodifier (ListBase *modifiers, FModifier *fcm) if (modifiers) { BLI_freelinkN(modifiers, fcm); return 1; - } else { + } + else { // XXX this case can probably be removed some day, as it shouldn't happen... printf("remove_fmodifier() - no modifier stack given \n"); MEM_freeN(fcm); return 0; } } + +/* Remove and free the nth F-Modifier from the given stack */ int remove_fmodifier_index (ListBase *modifiers, int index) { FModifier *fcm= BLI_findlink(modifiers, index); - if(fcm) { - return remove_fmodifier(modifiers, fcm); - } - else { - return 0; - } + return remove_fmodifier(modifiers, fcm); } /* Remove all of a given F-Curve's modifiers */ diff --git a/source/blender/editors/object/object_constraint.c b/source/blender/editors/object/object_constraint.c index 33cee59f0a8..4a4184c7035 100644 --- a/source/blender/editors/object/object_constraint.c +++ b/source/blender/editors/object/object_constraint.c @@ -101,7 +101,7 @@ ListBase *get_active_constraints (Object *ob) /* single constraint */ bConstraint *get_active_constraint (Object *ob) { - return find_active_constraint(get_active_constraints(ob)); + return constraints_get_active(get_active_constraints(ob)); } /* -------------- Constraint Management (Add New, Remove, Rename) -------------------- */ /* ------------- PyConstraints ------------------ */ @@ -646,10 +646,11 @@ void ED_object_constraint_rename(Object *ob, bConstraint *con, char *oldname) void ED_object_constraint_set_active(Object *ob, bConstraint *con) { /* lets be nice and escape if its active already */ - if(con && (con->flag & CONSTRAINT_ACTIVE)) + // NOTE: this assumes that the stack doesn't have other active ones set... + if (con && (con->flag & CONSTRAINT_ACTIVE)) return ; - set_active_constraint(get_active_constraints(ob), con); + constraints_set_active(get_active_constraints(ob), con); } void ED_object_constraint_update(Object *ob) diff --git a/source/blender/makesdna/DNA_constraint_types.h b/source/blender/makesdna/DNA_constraint_types.h index 8235d92d6f7..df2178992a9 100644 --- a/source/blender/makesdna/DNA_constraint_types.h +++ b/source/blender/makesdna/DNA_constraint_types.h @@ -377,7 +377,7 @@ typedef struct bShrinkwrapConstraint { * - Do not ever change the order of these, or else files could get * broken as their correct value cannot be resolved */ -typedef enum B_CONSTAINT_TYPES { +typedef enum eBConstraint_Types { CONSTRAINT_TYPE_NULL = 0, /* Invalid/legacy constraint */ CONSTRAINT_TYPE_CHILDOF, /* Unimplemented non longer :) - during constraints recode, Aligorith */ CONSTRAINT_TYPE_TRACKTO, @@ -404,12 +404,12 @@ typedef enum B_CONSTAINT_TYPES { /* NOTE: no constraints are allowed to be added after this */ NUM_CONSTRAINT_TYPES -} B_CONSTRAINT_TYPES; +} eBConstraint_Types; /* bConstraint->flag */ /* flags 0x2 (1<<1) and 0x8 (1<<3) were used in past */ /* flag 0x20 (1<<5) was used to indicate that a constraint was evaluated using a 'local' hack for posebones only */ -typedef enum B_CONSTRAINT_FLAG { +typedef enum eBConstraint_Flags { /* expand for UI */ CONSTRAINT_EXPAND = (1<<0), /* pre-check for illegal object name or bone name */ @@ -424,10 +424,10 @@ typedef enum B_CONSTRAINT_FLAG { CONSTRAINT_PROXY_LOCAL = (1<<8), /* indicates that constraint is temporarily disabled (only used in GE) */ CONSTRAINT_OFF = (1<<9) -} B_CONSTRAINT_FLAG; +} eBConstraint_Flags; /* bConstraint->ownspace/tarspace */ -typedef enum B_CONSTRAINT_SPACETYPES { +typedef enum eBConstraint_SpaceTypes { /* default for all - worldspace */ CONSTRAINT_SPACE_WORLD = 0, /* for objects (relative to parent/without parent influence), @@ -440,13 +440,14 @@ typedef enum B_CONSTRAINT_SPACETYPES { CONSTRAINT_SPACE_PARLOCAL, /* = 3 */ /* for files from between 2.43-2.46 (should have been parlocal) */ CONSTRAINT_SPACE_INVALID, /* = 4. do not exchange for anything! */ -} B_CONSTRAINT_SPACETYPES; +} eBConstraint_SpaceTypes; /* bConstraintChannel.flag */ -typedef enum B_CONSTRAINTCHANNEL_FLAG { +// XXX depreceated... old AnimSys +typedef enum eConstraintChannel_Flags { CONSTRAINT_CHANNEL_SELECT = (1<<0), CONSTRAINT_CHANNEL_PROTECTED = (1<<1) -} B_CONSTRAINTCHANNEL_FLAG; +} eConstraintChannel_Flags; /* -------------------------------------- */ @@ -456,167 +457,219 @@ typedef enum B_CONSTRAINTCHANNEL_FLAG { */ /* bRotateLikeConstraint.flag */ -#define ROTLIKE_X 0x01 -#define ROTLIKE_Y 0x02 -#define ROTLIKE_Z 0x04 -#define ROTLIKE_X_INVERT 0x10 -#define ROTLIKE_Y_INVERT 0x20 -#define ROTLIKE_Z_INVERT 0x40 -#define ROTLIKE_OFFSET 0x80 +typedef enum eCopyRotation_Flags { + ROTLIKE_X = (1<<0), + ROTLIKE_Y = (1<<1), + ROTLIKE_Z = (1<<2), + ROTLIKE_X_INVERT = (1<<4), + ROTLIKE_Y_INVERT = (1<<5), + ROTLIKE_Z_INVERT = (1<<6), + ROTLIKE_OFFSET = (1<<7), +} eCopyRotation_Flags; /* bLocateLikeConstraint.flag */ -#define LOCLIKE_X 0x01 -#define LOCLIKE_Y 0x02 -#define LOCLIKE_Z 0x04 - /* LOCLIKE_TIP is a depreceated option... use headtail=1.0f instead */ -#define LOCLIKE_TIP 0x08 -#define LOCLIKE_X_INVERT 0x10 -#define LOCLIKE_Y_INVERT 0x20 -#define LOCLIKE_Z_INVERT 0x40 -#define LOCLIKE_OFFSET 0x80 +typedef enum eCopyLocation_Flags { + LOCLIKE_X = (1<<0), + LOCLIKE_Y = (1<<1), + LOCLIKE_Z = (1<<2), + /* LOCLIKE_TIP is a depreceated option... use headtail=1.0f instead */ + LOCLIKE_TIP = (1<<3), + LOCLIKE_X_INVERT = (1<<4), + LOCLIKE_Y_INVERT = (1<<5), + LOCLIKE_Z_INVERT = (1<<6), + LOCLIKE_OFFSET = (1<<7), +} eCopyLocation_Flags; /* bSizeLikeConstraint.flag */ -#define SIZELIKE_X 0x01 -#define SIZELIKE_Y 0x02 -#define SIZELIKE_Z 0x04 -#define SIZELIKE_OFFSET 0x80 - -/* Axis flags */ -#define LOCK_X 0x00 -#define LOCK_Y 0x01 -#define LOCK_Z 0x02 - -#define UP_X 0x00 -#define UP_Y 0x01 -#define UP_Z 0x02 - -#define TRACK_X 0x00 -#define TRACK_Y 0x01 -#define TRACK_Z 0x02 -#define TRACK_nX 0x03 -#define TRACK_nY 0x04 -#define TRACK_nZ 0x05 +typedef enum eCopyScale_Flags { + SIZELIKE_X = (1<<0), + SIZELIKE_Y = (1<<1), + SIZELIKE_Z = (1<<2), + SIZELIKE_OFFSET = (1<<3), +} eCopyScale_Flags; + +/* Locked-Axis Values (Locked Track) */ +typedef enum eLockAxis_Modes { + LOCK_X = 0, + LOCK_Y, + LOCK_Z, +} eLockAxis_Modes; + +/* Up-Axis Values (TrackTo and Locked Track) */ +typedef enum eUpAxis_Modes { + UP_X = 0, + UP_Y, + UP_Z, +} eUpAxis_Modes; + +/* Tracking axis (TrackTo, Locked Track, Damped Track) */ +typedef enum eTrackToAxis_Modes { + TRACK_X = 0, + TRACK_Y, + TRACK_Z, + TRACK_nX, + TRACK_nY, + TRACK_nZ, +} eTrackToAxis_Modes; /* FollowPath flags */ -#define FOLLOWPATH_FOLLOW 0x01 -#define FOLLOWPATH_STATIC 0x02 -#define FOLLOWPATH_RADIUS 0x04 +typedef enum eFollowPath_Flags { + FOLLOWPATH_FOLLOW = (1<<0), + FOLLOWPATH_STATIC = (1<<1), + FOLLOWPATH_RADIUS = (1<<2), +} eFollowPath_Flags; /* bTrackToConstraint->flags */ -#define TARGET_Z_UP 0x01 - -#define VOLUME_XZ 0x00 -#define VOLUME_X 0x01 -#define VOLUME_Z 0x02 -#define NO_VOLUME 0x03 - -#define PLANE_X 0x00 -#define PLANE_Y 0x01 -#define PLANE_Z 0x02 +typedef enum eTrackTo_Flags { + TARGET_Z_UP = (1<<0), +} eTrackTo_Flags; + +/* Strech To Constraint -> volmode */ +typedef enum eStretchTo_VolMode { + VOLUME_XZ = 0, + VOLUME_X, + VOLUME_Z, + NO_VOLUME, +} eStretchTo_VolMode; + +/* Stretch To Constraint -> plane mode */ +typedef enum eStretchTo_PlaneMode { + PLANE_X = 0, + PLANE_Y, + PLANE_Z, +} eStretchTo_PlaneMode; /* Clamp-To Constraint ->flag */ -#define CLAMPTO_AUTO 0 -#define CLAMPTO_X 1 -#define CLAMPTO_Y 2 -#define CLAMPTO_Z 3 +typedef enum eClampTo_Modes { + CLAMPTO_AUTO = 0, + CLAMPTO_X, + CLAMPTO_Y, + CLAMPTO_Z, +} eClampTo_Modes; /* ClampTo Constraint ->flag2 */ -#define CLAMPTO_CYCLIC 1 +typedef enum eClampTo_Flags { + CLAMPTO_CYCLIC = (1<<0), +} eClampTo_Flags; /* bKinematicConstraint->flag */ -#define CONSTRAINT_IK_TIP 1 -#define CONSTRAINT_IK_ROT 2 +typedef enum eKinematic_Flags { + CONSTRAINT_IK_TIP = (1<<0), + CONSTRAINT_IK_ROT = (1<<1), /* targetless */ -#define CONSTRAINT_IK_AUTO 4 + CONSTRAINT_IK_AUTO = (1<<2), /* autoik */ -#define CONSTRAINT_IK_TEMP 8 -#define CONSTRAINT_IK_STRETCH 16 -#define CONSTRAINT_IK_POS 32 -#define CONSTRAINT_IK_SETANGLE 64 -#define CONSTRAINT_IK_GETANGLE 128 + CONSTRAINT_IK_TEMP = (1<<3), + CONSTRAINT_IK_STRETCH = (1<<4), + CONSTRAINT_IK_POS = (1<<5), + CONSTRAINT_IK_SETANGLE = (1<<6), + CONSTRAINT_IK_GETANGLE = (1<<7), /* limit axis */ -#define CONSTRAINT_IK_NO_POS_X 256 -#define CONSTRAINT_IK_NO_POS_Y 512 -#define CONSTRAINT_IK_NO_POS_Z 1024 -#define CONSTRAINT_IK_NO_ROT_X 2048 -#define CONSTRAINT_IK_NO_ROT_Y 4096 -#define CONSTRAINT_IK_NO_ROT_Z 8192 + CONSTRAINT_IK_NO_POS_X = (1<<8), + CONSTRAINT_IK_NO_POS_Y = (1<<9), + CONSTRAINT_IK_NO_POS_Z = (1<<10), + CONSTRAINT_IK_NO_ROT_X = (1<<11), + CONSTRAINT_IK_NO_ROT_Y = (1<<12), + CONSTRAINT_IK_NO_ROT_Z = (1<<13), /* axis relative to target */ -#define CONSTRAINT_IK_TARGETAXIS 16384 + CONSTRAINT_IK_TARGETAXIS = (1<<14), +} eKinematic_Flags; /* bSplineIKConstraint->flag */ +typedef enum eSplineIK_Flags { /* chain has been attached to spline */ -#define CONSTRAINT_SPLINEIK_BOUND (1<<0) + CONSTRAINT_SPLINEIK_BOUND = (1<<0), /* root of chain is not influenced by the constraint */ -#define CONSTRAINT_SPLINEIK_NO_ROOT (1<<1) + CONSTRAINT_SPLINEIK_NO_ROOT = (1<<1), /* bones in the chain should not scale to fit the curve */ -#define CONSTRAINT_SPLINEIK_SCALE_LIMITED (1<<2) + CONSTRAINT_SPLINEIK_SCALE_LIMITED = (1<<2), /* evenly distribute the bones along the path regardless of length */ -#define CONSTRAINT_SPLINEIK_EVENSPLITS (1<<3) + CONSTRAINT_SPLINEIK_EVENSPLITS = (1<<3), +} eSplineIK_Flags; /* bSplineIKConstraint->xzScaleMode */ +typedef enum eSplineIK_XZScaleModes { /* no x/z scaling */ -#define CONSTRAINT_SPLINEIK_XZS_NONE 0 + CONSTRAINT_SPLINEIK_XZS_NONE = 0, /* bones in the chain should take their x/z scales from the curve radius */ -#define CONSTRAINT_SPLINEIK_XZS_RADIUS 1 + CONSTRAINT_SPLINEIK_XZS_RADIUS, /* bones in the chain should take their x/z scales from the original scaling */ -#define CONSTRAINT_SPLINEIK_XZS_ORIGINAL 2 + CONSTRAINT_SPLINEIK_XZS_ORIGINAL, +} eSplineIK_XZScaleModes; /* MinMax (floor) flags */ -#define MINMAX_STICKY 0x01 -#define MINMAX_STUCK 0x02 -#define MINMAX_USEROT 0x04 - -/* transform limiting constraints -> flag */ -#define LIMIT_XMIN 0x01 -#define LIMIT_XMAX 0x02 -#define LIMIT_YMIN 0x04 -#define LIMIT_YMAX 0x08 -#define LIMIT_ZMIN 0x10 -#define LIMIT_ZMAX 0x20 - -#define LIMIT_XROT 0x01 -#define LIMIT_YROT 0x02 -#define LIMIT_ZROT 0x04 - +typedef enum eFloor_Flags { + MINMAX_STICKY = (1<<0), + MINMAX_STUCK = (1<<1), + MINMAX_USEROT = (1<<2), +} eFloor_Flags; + +/* transform limiting constraints -> flag2 */ +typedef enum eTransformLimits_Flags2 { /* not used anymore - for older Limit Location constraints only */ -#define LIMIT_NOPARENT 0x01 + LIMIT_NOPARENT = (1<<0), /* for all Limit constraints - allow to be used during transform? */ -#define LIMIT_TRANSFORM 0x02 + LIMIT_TRANSFORM = (1<<1), +} eTransformLimits_Flags2; + +/* transform limiting constraints -> flag (own flags) */ +typedef enum eTransformLimits_Flags { + LIMIT_XMIN = (1<<0), + LIMIT_XMAX = (1<<1), + LIMIT_YMIN = (1<<2), + LIMIT_YMAX = (1<<3), + LIMIT_ZMIN = (1<<4), + LIMIT_ZMAX = (1<<5), +} eTransformLimits_Flags; + +/* limit rotation constraint -> flag (own flags) */ +typedef enum eRotLimit_Flags { + LIMIT_XROT = (1<<0), + LIMIT_YROT = (1<<1), + LIMIT_ZROT = (1<<2), +} eRotLimit_Flags; /* distance limit constraint */ /* bDistLimitConstraint->flag */ -#define LIMITDIST_USESOFT (1<<0) +typedef enum eDistLimit_Flag { + LIMITDIST_USESOFT = (1<<0), +} eDistLimit_Flag; /* bDistLimitConstraint->mode */ -#define LIMITDIST_INSIDE 0 -#define LIMITDIST_OUTSIDE 1 -#define LIMITDIST_ONSURFACE 2 +typedef enum eDistLimit_Modes { + LIMITDIST_INSIDE = 0, + LIMITDIST_OUTSIDE, + LIMITDIST_ONSURFACE, +} eDistLimit_Modes; /* python constraint -> flag */ -#define PYCON_USETARGETS 0x01 -#define PYCON_SCRIPTERROR 0x02 +typedef enum ePyConstraint_Flags { + PYCON_USETARGETS = (1<<0), + PYCON_SCRIPTERROR = (1<<1), +} ePyConstraint_Flags; /* ChildOf Constraint -> flag */ -#define CHILDOF_LOCX 0x001 -#define CHILDOF_LOCY 0x002 -#define CHILDOF_LOCZ 0x004 -#define CHILDOF_ROTX 0x008 -#define CHILDOF_ROTY 0x010 -#define CHILDOF_ROTZ 0x020 -#define CHILDOF_SIZEX 0x040 -#define CHILDOF_SIZEY 0x080 -#define CHILDOF_SIZEZ 0x100 +typedef enum eChildOf_Flags { + CHILDOF_LOCX = (1<<0), + CHILDOF_LOCY = (1<<1), + CHILDOF_LOCZ = (1<<2), + CHILDOF_ROTX = (1<<3), + CHILDOF_ROTY = (1<<4), + CHILDOF_ROTZ = (1<<5), + CHILDOF_SIZEX = (1<<6), + CHILDOF_SIZEY = (1<<7), + CHILDOF_SIZEZ = (1<<8), +} eChildOf_Flags; /* Rigid-Body Constraint */ #define CONSTRAINT_DRAW_PIVOT 0x40 -#define CONSTRAINT_DISABLE_LINKED_COLLISION 0x80 +#define CONSTRAINT_DISABLE_LINKED_COLLISION 0x80 /* important: these defines need to match up with PHY_DynamicTypes headerfile */ -#define CONSTRAINT_RB_BALL 1 -#define CONSTRAINT_RB_HINGE 2 -#define CONSTRAINT_RB_CONETWIST 4 -#define CONSTRAINT_RB_VEHICLE 11 -#define CONSTRAINT_RB_GENERIC6DOF 12 +#define CONSTRAINT_RB_BALL 1 +#define CONSTRAINT_RB_HINGE 2 +#define CONSTRAINT_RB_CONETWIST 4 +#define CONSTRAINT_RB_VEHICLE 11 +#define CONSTRAINT_RB_GENERIC6DOF 12 #endif diff --git a/source/blender/makesrna/intern/rna_constraint.c b/source/blender/makesrna/intern/rna_constraint.c index 24aff923ba8..1db9af227ff 100644 --- a/source/blender/makesrna/intern/rna_constraint.c +++ b/source/blender/makesrna/intern/rna_constraint.c @@ -287,7 +287,6 @@ static void rna_ActionConstraint_minmax_range(PointerRNA *ptr, float *min, float } } - #else EnumPropertyItem constraint_distance_items[] = { @@ -1681,9 +1680,9 @@ static void rna_def_constraint_spline_ik(BlenderRNA *brna) PropertyRNA *prop; static EnumPropertyItem splineik_xz_scale_mode[] = { - {CONSTRAINT_SPLINEIK_XZS_NONE, "NONE", 0, "None", "Don't scale the x and z axes, giving a volume preservation effect. (Default)"}, + {CONSTRAINT_SPLINEIK_XZS_NONE, "NONE", 0, "Volume Preserve", "Don't scale the x and z axes, giving a volume preservation effect. (Default)"}, {CONSTRAINT_SPLINEIK_XZS_RADIUS, "CURVE_RADIUS", 0, "Curve Radius", "Use the radius of the curve."}, - {CONSTRAINT_SPLINEIK_XZS_ORIGINAL, "ORIGINAL", 0, "Original", "Use the original scaling of the bones."}, + {CONSTRAINT_SPLINEIK_XZS_ORIGINAL, "BONE_ORIGINAL", 0, "Bone Original", "Use the original scaling of the bones."}, {0, NULL, 0, NULL, NULL}}; srna= RNA_def_struct(brna, "SplineIKConstraint", "Constraint"); @@ -1703,7 +1702,11 @@ static void rna_def_constraint_spline_ik(BlenderRNA *brna) RNA_def_property_ui_text(prop, "Chain Length", "How many bones are included in the chain"); RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_dependency_update"); - // TODO: add access to the positions array to allow more flexible aligning? + /* direct access to bindings */ + // NOTE: only to be used by experienced users + //prop= RNA_def_property(srna, "joint_bindings", PROP_FLOAT, PROP_FACTOR); + //RNA_def_property_collection_sdna(prop, NULL, "points", "numpoints"); + //RNA_def_property_ui_text(prop, "Joint Bindings", "(EXPERIENCED USERS ONLY) The relative positions of the joints along the chain as percentages."); /* settings */ prop= RNA_def_property(srna, "chain_offset", PROP_BOOLEAN, PROP_NONE); diff --git a/source/blender/makesrna/intern/rna_object.c b/source/blender/makesrna/intern/rna_object.c index 8f5a9520502..ad47a1c5535 100644 --- a/source/blender/makesrna/intern/rna_object.c +++ b/source/blender/makesrna/intern/rna_object.c @@ -865,14 +865,14 @@ static PointerRNA rna_Object_collision_get(PointerRNA *ptr) static PointerRNA rna_Object_active_constraint_get(PointerRNA *ptr) { Object *ob= (Object*)ptr->id.data; - bConstraint *con= find_active_constraint(&ob->constraints); + bConstraint *con= constraints_get_active(&ob->constraints); return rna_pointer_inherit_refine(ptr, &RNA_Constraint, con); } static void rna_Object_active_constraint_set(PointerRNA *ptr, PointerRNA value) { Object *ob= (Object*)ptr->id.data; - set_active_constraint(&ob->constraints, (bConstraint *)value.data); + constraints_set_active(&ob->constraints, (bConstraint *)value.data); } static bConstraint *rna_Object_constraints_new(Object *object, bContext *C, int type) diff --git a/source/blender/makesrna/intern/rna_pose.c b/source/blender/makesrna/intern/rna_pose.c index a0685a00fe0..ae912c6d7c6 100644 --- a/source/blender/makesrna/intern/rna_pose.c +++ b/source/blender/makesrna/intern/rna_pose.c @@ -419,14 +419,14 @@ static void rna_pose_pgroup_name_set(PointerRNA *ptr, const char *value, char *r static PointerRNA rna_PoseChannel_active_constraint_get(PointerRNA *ptr) { bPoseChannel *pchan= (bPoseChannel*)ptr->data; - bConstraint *con= find_active_constraint(&pchan->constraints); + bConstraint *con= constraints_get_active(&pchan->constraints); return rna_pointer_inherit_refine(ptr, &RNA_Constraint, con); } static void rna_PoseChannel_active_constraint_set(PointerRNA *ptr, PointerRNA value) { bPoseChannel *pchan= (bPoseChannel*)ptr->data; - set_active_constraint(&pchan->constraints, (bConstraint *)value.data); + constraints_set_active(&pchan->constraints, (bConstraint *)value.data); } static bConstraint *rna_PoseChannel_constraints_new(bPoseChannel *pchan, bContext *C, int type) -- cgit v1.2.3