== Constraints System - Recode 2 ==
authorJoshua Leung <aligorith@gmail.com>
Sun, 21 Oct 2007 23:00:29 +0000 (23:00 +0000)
committerJoshua Leung <aligorith@gmail.com>
Sun, 21 Oct 2007 23:00:29 +0000 (23:00 +0000)
Once again, I've recoded the constraints system. This time, the goals were:
* To make it more future-proof by 'modernising' the coding style. The long functions filled with switch statements, have given way to function-pointers with smaller functions for specific purposes.
* To make it support constraints which use multiple targets more readily that it did. In the past, it was assumed that constraints could only have at most one target.

As a result, a lot of code has been shuffled around, and modified. Also, the subversion number has been bumped up.

Known issues:
* PyConstraints, which were the main motivation for supporting multiple-targets, are currently broken. There are some bimport() error that keeps causing problems. I've also temporarily removed the doDriver support, although it may return in another form soon.
* Constraints BPy-API is currently has a few features which currently don't work yet
* Outliner currently only displays the names of the constraints instead of the fancy subtarget/target/constraint-name display it used to do. What gets displayed here needs further investigation, as the old way was certainly not that great (and is not compatible with the new system too)

25 files changed:
release/scripts/scripttemplate_pyconstraint.py
source/blender/blenkernel/BKE_bad_level_calls.h
source/blender/blenkernel/BKE_blender.h
source/blender/blenkernel/BKE_constraint.h
source/blender/blenkernel/bad_level_call_stubs/stubs.c
source/blender/blenkernel/intern/armature.c
source/blender/blenkernel/intern/constraint.c
source/blender/blenkernel/intern/depsgraph.c
source/blender/blenkernel/intern/object.c
source/blender/blenloader/intern/readfile.c
source/blender/blenloader/intern/writefile.c
source/blender/include/BIF_editconstraint.h
source/blender/include/butspace.h
source/blender/makesdna/DNA_constraint_types.h
source/blender/python/BPY_extern.h
source/blender/python/BPY_interface.c
source/blender/python/api2_2x/Constraint.c
source/blender/src/buttons_object.c
source/blender/src/drawobject.c
source/blender/src/editarmature.c
source/blender/src/editconstraint.c
source/blender/src/editobject.c
source/blender/src/header_text.c
source/blender/src/outliner.c
source/blender/src/poseobject.c

index 8dcc04360d0d9117401d96ea9a590b6323dd248d..68aa9194435e5dbb80846a890f881ec071185465 100644 (file)
@@ -21,17 +21,21 @@ from Blender import Draw
 from Blender import Mathutils
 import math
 
-USE_TARGET = True
+'''
+ This variable specifies the number of targets 
+ that this constraint can use
+'''
+NUM_TARGETS = 1
 
 
 '''
  This function is called to evaluate the constraint
-       obmatrix:               (Matrix) copy of owner's worldspace matrix
-       targetmatrix:   (Matrix) copy of target's worldspace matrix (where applicable)
+       obmatrix:               (Matrix) copy of owner's 'ownerspace' matrix
+       targetmatrices: (List) list of copies of the 'targetspace' matrices of the targets (where applicable)
        idprop:                 (IDProperties) wrapped data referring to this 
                                        constraint instance's idproperties
 '''
-def doConstraint(obmatrix, targetmatrix, idprop):
+def doConstraint(obmatrix, targetmatrices, idprop):
        # Separate out the tranformation components for easy access.
        obloc = obmatrix.translationPart()      # Translation
        obrot = obmatrix.toEuler()                      # Rotation
@@ -60,9 +64,9 @@ def doConstraint(obmatrix, targetmatrix, idprop):
 
 
 '''
- This function manipulates the target matrix prior to sending it to doConstraint()
+ This function manipulates the matrix of a target prior to sending it to doConstraint()
        target_object:                                  wrapped data, representing the target object
-       subtarget_bone:                                 wrapped data, representing the subtarget pose-bone (where applicable)
+       subtarget_bone:                                 wrapped data, representing the subtarget pose-bone/vertex-group (where applicable)
        target_matrix:                                  (Matrix) the transformation matrix of the target
        id_properties_of_constraint:    (IDProperties) wrapped idproperties
 '''
@@ -72,8 +76,8 @@ def doTarget(target_object, subtarget_bone, target_matrix, id_properties_of_cons
 
 '''
  This function draws a pupblock that lets the user set
      the values of custom settings the constraint defines.
      This function is called when the user presses the settings button.
+ the values of custom settings the constraint defines.
+ This function is called when the user presses the settings button.
        idprop: (IDProperties) wrapped data referring to this 
                        constraint instance's idproperties
 '''
index 296fd5837b57c923b3b96313afe1e7c2016ddc18..32128c68af5fc569f4c91ba9bb7acca3ebf412c9 100644 (file)
@@ -65,6 +65,7 @@ struct IpoDriver; /* DNA_curve_types.h */
 struct Object;
 struct bPythonConstraint;
 struct bConstraintOb;
+struct bConstraintTarget;
 void BPY_do_pyscript (struct ID *id, short int event);
 void BPY_clear_script (struct Script *script);
 void BPY_free_compiled_text (struct Text *text);
@@ -74,9 +75,9 @@ float BPY_pydriver_eval(struct IpoDriver *driver);
 void BPY_pydriver_update(void);
 /* button python evaluation */
 int BPY_button_eval(char *expr, double *value);
-void BPY_pyconstraint_eval(struct bPythonConstraint *con, float ownermat[][4], float targetmat[][4]);
-void BPY_pyconstraint_driver(struct bPythonConstraint *con, struct bConstraintOb *cob, struct Object *target, char subtarget[]);
-int BPY_pyconstraint_targets(struct bPythonConstraint *con, float targetmat[][4]);
+/* pyconstraints */
+void BPY_pyconstraint_eval(struct bPythonConstraint *con, struct bConstraintOb *cob, struct ListBase *targets);
+void BPY_pyconstraint_targets(struct bPythonConstraint *con, struct bConstraintTarget *ct);
 
 
 /* writefile.c */
index 7f7ea79fcc60b339523a004dcfe8cf1a9e905d9f..55a542f51d54ab9eb30874acde34be9dea7eac40 100644 (file)
@@ -44,7 +44,7 @@ struct ListBase;
 struct MemFile;
 
 #define BLENDER_VERSION                        245
-#define BLENDER_SUBVERSION             6
+#define BLENDER_SUBVERSION             7
 
 #define BLENDER_MINVERSION             240
 #define BLENDER_MINSUBVERSION  0
index 39a3cf13087724102189d4c36ed9feddbaf7c783..40fd8c5ed1848c440d3bc401e8245de75ac090da 100644 (file)
 #ifndef BKE_CONSTRAINT_H
 #define BKE_CONSTRAINT_H
 
-
 struct bConstraint;
+struct bConstraintTarget;
 struct ListBase;
 struct Object;
 struct bConstraintChannel;
 struct bPoseChannel;
-struct bAction;
-struct bArmature;
-
-/* ---------------------------------------------------------------------------- */
-
-/* Constraint target/owner types */
-#define TARGET_OBJECT                  1       /*      string is ""                            */
-#define TARGET_BONE                            2       /*      string is bone-name             */
-#define TARGET_VERT                            3       /*      string is vertex-group name     */
-#define TARGET_CV                              4       /*      string is vertex-group name - is not available until curves get vgroups */
 
 /* ---------------------------------------------------------------------------- */
 
@@ -63,28 +53,79 @@ typedef struct bConstraintOb {
        short type;                                     /* type of owner  */
 } bConstraintOb;
 
+/* ---------------------------------------------------------------------------- */
+
+/* Constraint Type-Info (shorthand in code = cti):
+ *  This struct provides function pointers for runtime, so that functions can be
+ *  written more generally (with fewer/no special exceptions for various constraints).
+ *
+ *  Callers of these functions must check that they actually point to something useful,
+ *  as some constraints don't define some of these.
+ *
+ *  Warning: it is not too advisable to reorder order of members of this struct,
+ *                     as you'll have to edit quite a few ($NUM_CONSTRAINT_TYPES) of these
+ *                     structs.
+ */
+typedef struct bConstraintTypeInfo {
+       /* admin/ident */
+       short type;                             /* CONSTRAINT_TYPE_### */
+       short size;                             /* size in bytes of the struct */
+       char name[32];                  /* name constraint in interface */
+       char structName[32];    /* name of struct for SDNA */
+       
+       /* data management function pointers - special handling */
+               /* free any data that is allocated separately (optional) */
+       void (*free_data)(struct bConstraint *con);
+               /* adjust pointer to other ID-data using ID_NEW(), but not to targets (optional) */
+       void (*relink_data)(struct bConstraint *con);
+               /* copy any special data that is allocated separately (optional) */
+       void (*copy_data)(struct bConstraint *con, struct bConstraint *src);
+               /* set settings for data that will be used for bConstraint.data (memory already allocated) */
+       void (*new_data)(void *cdata);
+       
+       /* target handling function pointers */
+               /* for multi-target constraints: return that list; otherwise make a temporary list */
+       void (*get_constraint_targets)(struct bConstraint *con, struct ListBase *list);
+               /* for single-target constraints only: flush data back to source data, and the free memory used */
+       void (*flush_constraint_targets)(struct bConstraint *con, struct ListBase *list, short nocopy);
+       
+       /* evaluation */
+               /* set the ct->matrix for the given constraint target (at the given ctime) */
+       void (*get_target_matrix)(struct bConstraint *con, struct bConstraintOb *cob, struct bConstraintTarget *ct, float ctime);
+               /* evaluate the constraint for the given time */
+       void (*evaluate_constraint)(struct bConstraint *con, struct bConstraintOb *cob, struct ListBase *targets);
+} bConstraintTypeInfo;
+
+/* Function Prototypes for bConstraintTypeInfo's */
+bConstraintTypeInfo *constraint_get_typeinfo(struct bConstraint *con);
+bConstraintTypeInfo *get_constraint_typeinfo(int type);
+
+/* ---------------------------------------------------------------------------- */
+/* Useful macros for testing various common flag combinations */
+
+/* Constraint Target Macros */
+#define VALID_CONS_TARGET(ct) ((ct) && (ct->tar))
+
+
 /* ---------------------------------------------------------------------------- */
 
 /* Constraint function prototypes */
 void unique_constraint_name(struct bConstraint *con, struct ListBase *list);
-void *new_constraint_data(short type);
+
 void free_constraints(struct ListBase *conlist);
 void copy_constraints(struct ListBase *dst, struct ListBase *src);
 void relink_constraints(struct ListBase *list);
 void free_constraint_data(struct bConstraint *con);
 
+
 /* Constraint Channel function prototypes */
-struct bConstraintChannel *get_constraint_channel(ListBase *list, const char *name);
-struct bConstraintChannel *verify_constraint_channel(ListBase *list, const char *name);
-void do_constraint_channels(struct ListBase *conbase, struct ListBase *chanbase, float ctime, int onlydrivers);
-void copy_constraint_channels(ListBase *dst, ListBase *src);
+struct bConstraintChannel *get_constraint_channel(struct ListBase *list, const char *name);
+struct bConstraintChannel *verify_constraint_channel(struct ListBase *list, const char *name);
+void do_constraint_channels(struct ListBase *conbase, struct ListBase *chanbase, float ctime, short onlydrivers);
+void copy_constraint_channels(struct ListBase *dst, struct ListBase *src);
 void clone_constraint_channels(struct ListBase *dst, struct ListBase *src);
-void free_constraint_channels(ListBase *chanbase);
+void free_constraint_channels(struct ListBase *chanbase);
 
-/* Target function prototypes  */
-char constraint_has_target(struct bConstraint *con);
-struct Object *get_constraint_target(struct bConstraint *con, char **subtarget);
-void set_constraint_target(struct bConstraint *con, struct Object *ob, char *subtarget);
 
 /* Constraint Evaluation function prototypes */
 struct bConstraintOb *constraints_make_evalob(struct Object *ob, void *subdata, short datatype);
@@ -92,8 +133,8 @@ void constraints_clear_evalob(struct bConstraintOb *cob);
 
 void constraint_mat_convertspace(struct Object *ob, struct bPoseChannel *pchan, float mat[][4], short from, short to);
 
-short get_constraint_target_matrix(struct bConstraint *con, short ownertype, void *ownerdata, float mat[][4], float time);
-void solve_constraints (struct ListBase *conlist, struct bConstraintOb *cob, float ctime);
+void get_constraint_target_matrix(struct bConstraint *con, short ownertype, void *ownerdata, float mat[][4], float ctime);
+void solve_constraints(struct ListBase *conlist, struct bConstraintOb *cob, float ctime);
 
 
 #endif
index 2524a804e530794d811cff3310bb4e7552d600c3..9d00db8076d84116f0359b27964a5b6381ccd675 100644 (file)
@@ -57,6 +57,8 @@ struct RenderResult;
 struct Object;
 struct bPythonConstraint;
 struct bConstraintOb;
+struct bConstraintTarget;
+struct ListBase;
 
 char *getIpoCurveName( struct IpoCurve * icu );
 void insert_vert_icu(struct IpoCurve *icu, float x, float y, short fast);
@@ -128,16 +130,12 @@ int BPY_button_eval(char *expr, double *value)
 }
 
 /* PyConstraints - BPY_interface.c */
-void BPY_pyconstraint_eval(struct bPythonConstraint *con, float ownermat[][4], float targetmat[][4])
+void BPY_pyconstraint_eval(struct bPythonConstraint *con, struct bConstraintOb *cob, struct ListBase *targets)
 {
 }
-void BPY_pyconstraint_driver(struct bPythonConstraint *con, struct bConstraintOb *cob, struct Object *target, char subtarget[])
+void BPY_pyconstraint_target(struct bPythonConstraint *con, struct bConstraintTarget *ct)
 {
 }
-int BPY_pyconstraint_targets(struct bPythonConstraint *con, float targetmat[][4])
-{
-       return 0;
-}
 
 
 /* writefile.c */
index 10b2a3648271148f6350a2861c5a5df71233233f..2030859000f3cc444762c7dc642abe71edb070e0 100644 (file)
@@ -1239,7 +1239,6 @@ static void pose_proxy_synchronize(Object *ob, Object *from, int layer_protected
        bPose *pose= ob->pose, *frompose= from->pose;
        bPoseChannel *pchan, *pchanp, pchanw;
        bConstraint *con;
-       char *str;
        
        if(frompose==NULL) return;
        
@@ -1267,8 +1266,23 @@ static void pose_proxy_synchronize(Object *ob, Object *from, int layer_protected
                        copy_constraints(&pchanw.constraints, &pchanp->constraints);
 
                        for(con= pchanw.constraints.first; con; con= con->next) {
-                               if(from==get_constraint_target(con, &str))
-                                       set_constraint_target(con, ob, NULL);
+                               bConstraintTypeInfo *cti= constraint_get_typeinfo(con);
+                               ListBase targets = {NULL, NULL};
+                               bConstraintTarget *ct;
+                               
+                               if (cti && cti->get_constraint_targets) {
+                                       cti->get_constraint_targets(con, &targets);
+                                       
+                                       for (ct= targets.first; ct; ct= ct->next) {
+                                               if (ct->tar == from) {
+                                                       ct->tar = ob;
+                                                       strcpy(ct->subtarget, "");
+                                               }
+                                       }
+                                       
+                                       if (cti->flush_constraint_targets)
+                                               cti->flush_constraint_targets(con, &targets, 0);
+                               }
                        }
                        
                        /* free stuff from current channel */
@@ -1609,45 +1623,47 @@ static void execute_posetree(Object *ob, PoseTree *tree)
        Mat4MulMat4 (imat, rootmat, ob->obmat);
        Mat4Invert (goalinv, imat);
        
-       for(target=tree->targets.first; target; target=target->next) {
+       for (target=tree->targets.first; target; target=target->next) {
                data= (bKinematicConstraint*)target->con->data;
-
-               /* 1.0=ctime, we pass on object for auto-ik */
-               get_constraint_target_matrix(target->con, TARGET_BONE, ob, rootmat, 1.0);
-
+               
+               /* 1.0=ctime, we pass on object for auto-ik (owner-type here is object, even though
+                * strictly speaking, it is a posechannel)
+                */
+               get_constraint_target_matrix(target->con, CONSTRAINT_OBTYPE_OBJECT, ob, rootmat, 1.0);
+               
                /* and set and transform goal */
                Mat4MulMat4(goal, rootmat, goalinv);
-
+               
                VECCOPY(goalpos, goal[3]);
                Mat3CpyMat4(goalrot, goal);
-
+               
                /* do we need blending? */
-               if(target->con->enforce!=1.0) {
+               if (target->con->enforce!=1.0) {
                        float q1[4], q2[4], q[4];
                        float fac= target->con->enforce;
                        float mfac= 1.0-fac;
                        
                        pchan= tree->pchan[target->tip];
-
+                       
                        /* end effector in world space */
                        Mat4CpyMat4(end_pose, pchan->pose_mat);
                        VECCOPY(end_pose[3], pchan->pose_tail);
                        Mat4MulSerie(world_pose, goalinv, ob->obmat, end_pose, 0, 0, 0, 0, 0);
-
+                       
                        /* blend position */
                        goalpos[0]= fac*goalpos[0] + mfac*world_pose[3][0];
                        goalpos[1]= fac*goalpos[1] + mfac*world_pose[3][1];
                        goalpos[2]= fac*goalpos[2] + mfac*world_pose[3][2];
-
+                       
                        /* blend rotation */
                        Mat3ToQuat(goalrot, q1);
                        Mat4ToQuat(world_pose, q2);
                        QuatInterpol(q, q1, q2, mfac);
                        QuatToMat3(q, goalrot);
                }
-
+               
                iktarget= iktree[target->tip];
-
+               
                if(data->weight != 0.0)
                        IK_SolverAddGoal(solver, iktarget, goalpos, data->weight);
                if((data->flag & CONSTRAINT_IK_ROT) && (data->orientweight != 0.0) && (data->flag & CONSTRAINT_IK_AUTO)==0)
@@ -1932,7 +1948,7 @@ static void where_is_pose_bone(Object *ob, bPoseChannel *pchan, float ctime)
                /* prepare PoseChannel for Constraint solving 
                 * - makes a copy of matrix, and creates temporary struct to use 
                 */
-               cob= constraints_make_evalob(ob, pchan, TARGET_BONE);
+               cob= constraints_make_evalob(ob, pchan, CONSTRAINT_OBTYPE_BONE);
                
                /* Solve PoseChannel's Constraints */
                solve_constraints(&pchan->constraints, cob, ctime);     // ctime doesnt alter objects
index 020350d9e6f1864f6067147c306d9d41ab1c82c4..b46504b0e6d1921c4044fce031b2daa86862708f 100644 (file)
@@ -48,6 +48,7 @@
 #include "DNA_meshdata_types.h"
 #include "DNA_lattice_types.h"
 #include "DNA_scene_types.h"
+#include "DNA_text_types.h"
 
 #include "BKE_utildefines.h"
 #include "BKE_action.h"
 #endif
 
 
-/* ********************* Data level ****************** */
-
-void free_constraint_data (bConstraint *con)
-{
-       if (con->data) {
-               /* any constraint-type specific stuff here */
-               switch (con->type) {
-                       case CONSTRAINT_TYPE_PYTHON:
-                       {
-                               bPythonConstraint *data= con->data;
-                               IDP_FreeProperty(data->prop);
-                               MEM_freeN(data->prop);
-                       }
-                               break;
-               }
-               
-               MEM_freeN(con->data);
-       }
-}
-
-void free_constraints (ListBase *conlist)
-{
-       bConstraint *con;
-       
-       /* Do any specific freeing */
-       for (con=conlist->first; con; con=con->next) {
-               free_constraint_data(con);
-       }
-       
-       /* Free the whole list */
-       BLI_freelistN(conlist);
-}
+/* ******************* Constraint Channels ********************** */
+/* Constraint Channels exist in one of two places:
+ *     - Under Action Channels in an Action  (act->chanbase->achan->constraintChannels)
+ *     - Under Object without object-level action yet (ob->constraintChannels)
+ * 
+ * The main purpose that constraint channels serve is to act as a link
+ * between an IPO-block which 
+ */
 
+/* ------------ Data Management ----------- */
+/* Free constraint channels, and reduce the number of users of the related ipo-blocks */
 void free_constraint_channels (ListBase *chanbase)
 {
        bConstraintChannel *chan;
@@ -125,27 +105,14 @@ void free_constraint_channels (ListBase *chanbase)
        BLI_freelistN(chanbase);
 }
 
-void relink_constraints (struct ListBase *list)
-{
-       bConstraint *con;
-       
-       for (con = list->first; con; con=con->next) {
-               /* check if constraint has a target that needs relinking */
-               if (constraint_has_target(con)) {
-                       Object *tar;
-                       char *subtarget;
-                       
-                       tar = get_constraint_target(con, &subtarget);
-                       ID_NEW(tar);
-               }
-       }
-}
-
+/* Make a copy of the constraint channels from dst to src, and also give the
+ * new constraint channels their own copy of the original's IPO.
+ */
 void copy_constraint_channels (ListBase *dst, ListBase *src)
 {
        bConstraintChannel *dchan, *schan;
        
-       dst->first=dst->last=NULL;
+       dst->first = dst->last = NULL;
        duplicatelist(dst, src);
        
        for (dchan=dst->first, schan=src->first; dchan; dchan=dchan->next, schan=schan->next) {
@@ -153,11 +120,14 @@ void copy_constraint_channels (ListBase *dst, ListBase *src)
        }
 }
 
+/* Make a copy of the constraint channels from dst to src, but make the
+ * new constraint channels use the same IPO-data as their twin.
+ */
 void clone_constraint_channels (ListBase *dst, ListBase *src)
 {
        bConstraintChannel *dchan, *schan;
        
-       dst->first=dst->last=NULL;
+       dst->first = dst->last = NULL;
        duplicatelist(dst, src);
        
        for (dchan=dst->first, schan=src->first; dchan; dchan=dchan->next, schan=schan->next) {
@@ -165,354 +135,81 @@ void clone_constraint_channels (ListBase *dst, ListBase *src)
        }
 }
 
-void copy_constraints (ListBase *dst, ListBase *src)
-{
-       bConstraint *con, *srccon;
-       
-       dst->first= dst->last= NULL;
-       duplicatelist (dst, src);
-       
-       for (con = dst->first, srccon=src->first; con; srccon=srccon->next, con=con->next) {
-               con->data = MEM_dupallocN (con->data);
-               
-               /* only do specific constraints if required */
-               if (con->type == CONSTRAINT_TYPE_PYTHON) {
-                       bPythonConstraint *pycon = (bPythonConstraint *)con->data;
-                       bPythonConstraint *opycon = (bPythonConstraint *)srccon->data;
-                       
-                       pycon->prop = IDP_CopyProperty(opycon->prop);
-               }
-       }
-}
-
-/* **************** Editor Functions **************** */
+/* ------------- Constraint Channel Tools ------------ */
 
-char constraint_has_target (bConstraint *con) 
+/* Find the constraint channel with a given name */
+bConstraintChannel *get_constraint_channel (ListBase *list, const char name[])
 {
-       switch (con->type) {
-       case CONSTRAINT_TYPE_PYTHON:
-               {
-                       bPythonConstraint *data = con->data;
-                       if (data->tar) return 1;
-               }
-               break;
-       case CONSTRAINT_TYPE_TRACKTO:
-               {
-                       bTrackToConstraint *data = con->data;
-                       if (data->tar) return 1;
-               }
-               break;
-       case CONSTRAINT_TYPE_KINEMATIC:
-               {
-                       bKinematicConstraint *data = con->data;
-                       if (data->tar) return 1;
-               }
-               break;
-       case CONSTRAINT_TYPE_FOLLOWPATH:
-               {
-                       bFollowPathConstraint *data = con->data;
-                       if (data->tar) return 1;
-               }
-               break;
-       case CONSTRAINT_TYPE_ROTLIKE:
-               {
-                       bRotateLikeConstraint *data = con->data;
-                       if (data->tar) return 1;
-               }
-               break;
-       case CONSTRAINT_TYPE_LOCLIKE:
-               {
-                       bLocateLikeConstraint *data = con->data;
-                       if (data->tar) return 1;
-               }
-               break;
-       case CONSTRAINT_TYPE_SIZELIKE:
-               {
-                       bSizeLikeConstraint *data = con->data;
-                       if (data->tar) return 1;
-               }
-               break;
-       case CONSTRAINT_TYPE_MINMAX:
-               {
-                       bMinMaxConstraint *data = con->data;
-                       if (data->tar) return 1;
-               }
-               break;
-       case CONSTRAINT_TYPE_ACTION:
-               {
-                       bActionConstraint *data = con->data;
-                       if (data->tar) return 1;
-               }
-               break;
-       case CONSTRAINT_TYPE_LOCKTRACK:
-               {
-                       bLockTrackConstraint *data = con->data;
-                       if (data->tar) return 1;
-               }
-       case CONSTRAINT_TYPE_STRETCHTO:
-               {
-                       bStretchToConstraint *data = con->data;
-                       if (data->tar) return 1;
-               }
-               break;
-       case CONSTRAINT_TYPE_RIGIDBODYJOINT:
-               {
-                       bRigidBodyJointConstraint *data = con->data;
-                       if (data->tar) return 1;
-               }
-               break;
-       case CONSTRAINT_TYPE_CLAMPTO:
-               {
-                       bClampToConstraint *data = con->data;
-                       if (data->tar) return 1;
-               }
-                       break;
-       case CONSTRAINT_TYPE_CHILDOF:
-               {
-                       bChildOfConstraint *data = con->data;
-                       if (data->tar) return 1;
-               }
-               break;
-       case CONSTRAINT_TYPE_TRANSFORM:
-               {
-                       bTransformConstraint *data = con->data;
-                       if (data->tar) return 1;
+       bConstraintChannel *chan;
+
+       for (chan = list->first; chan; chan=chan->next) {
+               if (!strcmp(name, chan->name)) {
+                       return chan;
                }
-               break;
        }
        
-       /* Unknown types or CONSTRAINT_TYPE_NULL or no target */
-       return 0;
+       return NULL;
 }
 
-Object *get_constraint_target(bConstraint *con, char **subtarget)
+/* Find or create a new constraint channel */
+bConstraintChannel *verify_constraint_channel (ListBase *list, const char name[])
 {
-       /* If the target for this constraint is target, return a pointer 
-        * to the name for this constraints subtarget ... NULL otherwise
-        */
-       switch (con->type) {
-       case CONSTRAINT_TYPE_PYTHON:
-               {
-                       bPythonConstraint *data=con->data;
-                       *subtarget = data->subtarget;
-                       return data->tar;
-               }
-               break;
-       case CONSTRAINT_TYPE_ACTION:
-               {
-                       bActionConstraint *data = con->data;
-                       *subtarget= data->subtarget;
-                       return data->tar;
-               }
-               break;
-       case CONSTRAINT_TYPE_LOCLIKE:
-               {
-                       bLocateLikeConstraint *data = con->data;
-                       *subtarget= data->subtarget;
-                       return data->tar;
-               }
-               break;
-       case CONSTRAINT_TYPE_ROTLIKE:
-               {
-                       bRotateLikeConstraint *data = con->data;
-                       *subtarget= data->subtarget;
-                       return data->tar;
-               }
-               break;
-       case CONSTRAINT_TYPE_SIZELIKE:
-               {
-                       bSizeLikeConstraint *data = con->data;
-                       *subtarget= data->subtarget;
-                       return data->tar;
-               }
-               break;
-       case CONSTRAINT_TYPE_KINEMATIC:
-               {
-                       bKinematicConstraint *data = con->data;
-                       *subtarget= data->subtarget;
-                       return data->tar;
-               }
-               break;
-       case CONSTRAINT_TYPE_TRACKTO:
-               {
-                       bTrackToConstraint *data = con->data;
-                       *subtarget= data->subtarget;
-                       return data->tar;
-               }
-               break;
-       case CONSTRAINT_TYPE_MINMAX:
-               {
-                       bMinMaxConstraint *data = con->data;
-                       *subtarget= data->subtarget;
-                       return data->tar;
-               }
-               break;
-       case CONSTRAINT_TYPE_LOCKTRACK:
-               {
-                       bLockTrackConstraint *data = con->data;
-                       *subtarget= data->subtarget;
-                       return data->tar;
-               }
-               break;
-       case CONSTRAINT_TYPE_FOLLOWPATH: 
-               {
-                       bFollowPathConstraint *data = con->data;
-                       *subtarget= NULL;
-                       return data->tar;
-               }
-               break;
-       case CONSTRAINT_TYPE_STRETCHTO:
-               {
-                       bStretchToConstraint *data = con->data;
-                       *subtarget= data->subtarget;
-                       return data->tar;
-               }
-               break;
-       case CONSTRAINT_TYPE_RIGIDBODYJOINT: 
-               {
-                       bRigidBodyJointConstraint *data = con->data;
-                       *subtarget= NULL;
-                       return data->tar;
-               }
-               break;
-       case CONSTRAINT_TYPE_CLAMPTO:
-               {
-                       bClampToConstraint *data = con->data;
-                       *subtarget= NULL;
-                       return data->tar;
-               }
-               break;
-       case CONSTRAINT_TYPE_CHILDOF:   
-               {
-                       bChildOfConstraint *data = con->data;
-                       *subtarget= data->subtarget;
-                       return data->tar;
-               }
-               break;
-       case CONSTRAINT_TYPE_TRANSFORM: 
-               {
-                       bTransformConstraint *data = con->data;
-                       *subtarget= data->subtarget;
-                       return data->tar;
-               }
-               break;
-       default:
-               *subtarget= NULL;
-               break;
+       bConstraintChannel *chan;
+       
+       chan= get_constraint_channel(list, name);
+       
+       if (chan == NULL) {
+               chan= MEM_callocN(sizeof(bConstraintChannel), "new constraint channel");
+               BLI_addtail(list, chan);
+               strcpy(chan->name, name);
        }
        
-       return NULL;  
+       return chan;
 }
 
-void set_constraint_target(bConstraint *con, Object *ob, char *subtarget)
+/* --------- Constraint Channel Evaluation/Execution --------- */
+
+/* IPO-system call: calculate IPO-block for constraint channels, and flush that
+ * info onto the corresponding constraint.
+ */
+void do_constraint_channels (ListBase *conbase, ListBase *chanbase, float ctime, short onlydrivers)
 {
-       /* Set the target for this constraint */
-       switch (con->type) {
-               case CONSTRAINT_TYPE_PYTHON:
-               {
-                       bPythonConstraint *data = con->data;
-                       data->tar= ob;
-                       if (subtarget) BLI_strncpy(data->subtarget, subtarget, 32);
-               }
-                       break;          
-               case CONSTRAINT_TYPE_ACTION:
-               {
-                       bActionConstraint *data = con->data;
-                       data->tar= ob;
-                       if (subtarget) BLI_strncpy(data->subtarget, subtarget, 32);
-               }
-                       break;
-               case CONSTRAINT_TYPE_LOCLIKE:
-               {
-                       bLocateLikeConstraint *data = con->data;
-                       data->tar= ob;
-                       if (subtarget) BLI_strncpy(data->subtarget, subtarget, 32);
-               }
-                       break;
-               case CONSTRAINT_TYPE_ROTLIKE:
-               {
-                       bRotateLikeConstraint *data = con->data;
-                       data->tar= ob;
-                       if (subtarget) BLI_strncpy(data->subtarget, subtarget, 32);
-               }
-                       break;
-               case CONSTRAINT_TYPE_SIZELIKE:
-               {
-                       bSizeLikeConstraint *data = con->data;
-                       data->tar= ob;
-                       if (subtarget) BLI_strncpy(data->subtarget, subtarget, 32);
-               }
-                       break;
-               case CONSTRAINT_TYPE_KINEMATIC:
-               {
-                       bKinematicConstraint *data = con->data;
-                       data->tar= ob;
-                       if (subtarget) BLI_strncpy(data->subtarget, subtarget, 32);
-               }
-                       break;
-               case CONSTRAINT_TYPE_TRACKTO:
-               {
-                       bTrackToConstraint *data = con->data;
-                       data->tar= ob;
-                       if (subtarget) BLI_strncpy(data->subtarget, subtarget, 32);
-               }
-                       break;
-               case CONSTRAINT_TYPE_LOCKTRACK:
-               {
-                       bLockTrackConstraint *data = con->data;
-                       data->tar= ob;
-                       if (subtarget) BLI_strncpy(data->subtarget, subtarget, 32);
-               }
-                       break;
-               case CONSTRAINT_TYPE_FOLLOWPATH: 
-               {
-                       bFollowPathConstraint *data = con->data;
-                       data->tar= ob;
-               }
-                       break;
-               case CONSTRAINT_TYPE_STRETCHTO:
-               {
-                       bStretchToConstraint *data = con->data;
-                       data->tar= ob;
-                       if (subtarget) BLI_strncpy(data->subtarget, subtarget, 32);
-               }
-                       break;
-               case CONSTRAINT_TYPE_RIGIDBODYJOINT: 
-               {
-                       bRigidBodyJointConstraint *data = con->data;
-                       data->tar= ob;
-               }
-                       break;
-               case CONSTRAINT_TYPE_MINMAX:
-               {
-                       bMinMaxConstraint *data = (bMinMaxConstraint*)con->data;
-                       data->tar= ob;
-                       if (subtarget) BLI_strncpy(data->subtarget, subtarget, 32);
-               }
-                       break;
-               case CONSTRAINT_TYPE_CLAMPTO: 
-               {
-                       bClampToConstraint *data = con->data;
-                       data->tar= ob;
-               }
-                       break;
-               case CONSTRAINT_TYPE_CHILDOF:
-               {
-                       bChildOfConstraint *data = con->data;
-                       data->tar= ob;
-                       if (subtarget) BLI_strncpy(data->subtarget, subtarget, 32);
-               }
-                       break;
-               case CONSTRAINT_TYPE_TRANSFORM:
-               {
-                       bTransformConstraint *data = con->data;
-                       data->tar= ob;
-                       if (subtarget) BLI_strncpy(data->subtarget, subtarget, 32);
+       bConstraint *con;
+       bConstraintChannel *chan;
+       IpoCurve *icu= NULL;
+       
+       /* for each Constraint, calculate its Influence from the corresponding ConstraintChannel */
+       for (con=conbase->first; con; con=con->next) {
+               chan = get_constraint_channel(chanbase, con->name);
+               
+               if (chan && chan->ipo) {
+                       calc_ipo(chan->ipo, ctime);
+                       
+                       for (icu=chan->ipo->curve.first; icu; icu=icu->next) {
+                               if (!onlydrivers || icu->driver) {
+                                       switch (icu->adrcode) {
+                                               case CO_ENFORCE:
+                                               {
+                                                       /* Influence is clamped to 0.0f -> 1.0f range */
+                                                       con->enforce = CLAMPIS(icu->curval, 0.0f, 1.0f);
+                                               }
+                                                       break;
+                                       }
+                               }
+                       }
                }
-                       break;
        }
 }
 
+/* ************************ Constraints - General Utilities *************************** */
+/* These functions here don't act on any specific constraints, and are therefore should/will
+ * not require any of the special function-pointers afforded by the relevant constraint 
+ * type-info structs.
+ */
+
+/* -------------- Naming -------------- */
+
+/* Find the first available, non-duplicate name for a given constraint */
 void unique_constraint_name (bConstraint *con, ListBase *list)
 {
        bConstraint *curcon;
@@ -536,11 +233,11 @@ void unique_constraint_name (bConstraint *con, ListBase *list)
                }
        }
        
-       if (!exists)
+       if (exists == 0)
                return;
 
        /*      Strip off the suffix */
-       dot=strchr(con->name, '.');
+       dot = strchr(con->name, '.');
        if (dot)
                *dot=0;
        
@@ -549,332 +246,111 @@ void unique_constraint_name (bConstraint *con, ListBase *list)
                
                exists = 0;
                for (curcon=list->first; curcon; curcon=curcon->next) {
-                       if (con!=curcon) {
-                               if (!strcmp(curcon->name, tempname)) {
+                       if (con != curcon) {
+                               if (strcmp(curcon->name, tempname)==0) {
                                        exists = 1;
                                        break;
                                }
                        }
                }
-               if (!exists) {
+               if (exists == 0) {
                        strcpy(con->name, tempname);
                        return;
                }
        }
 }
 
-void *new_constraint_data (short type)
+/* ----------------- Evaluation Loop Preparation --------------- */
+
+/* package an object/bone for use in constraint evaluation */
+/* This function MEM_calloc's a bConstraintOb struct, that will need to be freed after evaluation */
+bConstraintOb *constraints_make_evalob (Object *ob, void *subdata, short datatype)
 {
-       void *result;
+       bConstraintOb *cob;
+       
+       /* create regardless of whether we have any data! */
+       cob= MEM_callocN(sizeof(bConstraintOb), "bConstraintOb");
        
-       switch (type) {
-       case CONSTRAINT_TYPE_PYTHON:
+       /* based on type of available data */
+       switch (datatype) {
+               case CONSTRAINT_OBTYPE_OBJECT:
                {
-                       bPythonConstraint *data;
-                       data = MEM_callocN(sizeof(bPythonConstraint), "pythonConstraint");
-                       
-                       /* everything should be set correctly by calloc, except for the prop->type constant.*/
-                       data->prop = MEM_callocN(sizeof(IDProperty), "PyConstraintProps");
-                       data->prop->type = IDP_GROUP;
+                       /* disregard subdata... calloc should set other values right */
+                       if (ob) {
+                               cob->ob = ob;
+                               cob->type = datatype;
+                               Mat4CpyMat4(cob->matrix, ob->obmat);
+                       }
+                       else
+                               Mat4One(cob->matrix);
                        
-                       result = data;
+                       Mat4CpyMat4(cob->startmat, cob->matrix);
                }
-               break;          
-       case CONSTRAINT_TYPE_KINEMATIC:
+                       break;
+               case CONSTRAINT_OBTYPE_BONE:
                {
-                       bKinematicConstraint *data;
-                       data = MEM_callocN(sizeof(bKinematicConstraint), "kinematicConstraint");
-
-                       data->weight= (float)1.0;
-                       data->orientweight= (float)1.0;
-                       data->iterations = 500;
-                       data->flag= CONSTRAINT_IK_TIP|CONSTRAINT_IK_STRETCH|CONSTRAINT_IK_POS;
-                       
-                       result = data;
+                       /* only set if we have valid bone, otherwise default */
+                       if (ob && subdata) {
+                               cob->ob = ob;
+                               cob->pchan = (bPoseChannel *)subdata;
+                               cob->type = datatype;
+                               
+                               /* matrix in world-space */
+                               Mat4MulMat4(cob->matrix, cob->pchan->pose_mat, ob->obmat);
+                       }
+                       else
+                               Mat4One(cob->matrix);
+                               
+                       Mat4CpyMat4(cob->startmat, cob->matrix);
                }
-               break;
-       case CONSTRAINT_TYPE_TRACKTO:
-               {
-                       bTrackToConstraint *data;
-                       data = MEM_callocN(sizeof(bTrackToConstraint), "tracktoConstraint");
-                       
-                       data->reserved1 = TRACK_Y;
-                       data->reserved2 = UP_Z;
+                       break;
                        
-                       result = data;
-               }
-               break;
-       case CONSTRAINT_TYPE_MINMAX:
+               default: /* other types not yet handled */
+                       Mat4One(cob->matrix);
+                       Mat4One(cob->startmat);
+                       break;
+       }
+       
+       return cob;
+}
+
+/* cleanup after constraint evaluation */
+void constraints_clear_evalob (bConstraintOb *cob)
+{
+       float delta[4][4], imat[4][4];
+       
+       /* prevent crashes */
+       if (cob == NULL) 
+               return;
+       
+       /* calculate delta of constraints evaluation */
+       Mat4Invert(imat, cob->startmat);
+       Mat4MulMat4(delta, cob->matrix, imat);
+       
+       /* copy matrices back to source */
+       switch (cob->type) {
+               case CONSTRAINT_OBTYPE_OBJECT:
                {
-                       bMinMaxConstraint *data;
-                       data = MEM_callocN(sizeof(bMinMaxConstraint), "minmaxConstraint");
-                       
-                       data->minmaxflag = TRACK_Z;
-                       data->offset = 0.0f;
-                       data->cache[0] = data->cache[1] = data->cache[2] = 0.0f;
-                       data->flag = 0;
-                       
-                       result = data;
-               }
-               break;
-       case CONSTRAINT_TYPE_LOCLIKE:
-               {
-                       bLocateLikeConstraint *data;
-                       data = MEM_callocN(sizeof(bLocateLikeConstraint), "LocLikeConstraint");
-                       data->flag = LOCLIKE_X|LOCLIKE_Y|LOCLIKE_Z;
-                       result = data;
-               }
-               break;
-       case CONSTRAINT_TYPE_ROTLIKE:
-               {
-                       bRotateLikeConstraint *data;
-                       data = MEM_callocN(sizeof(bRotateLikeConstraint), "RotLikeConstraint");
-                       data->flag = ROTLIKE_X|ROTLIKE_Y|ROTLIKE_Z;
-                       result = data;
-               }
-               break;
-       case CONSTRAINT_TYPE_SIZELIKE:
-               {
-                       bSizeLikeConstraint *data;
-                       data = MEM_callocN(sizeof(bLocateLikeConstraint), "SizeLikeConstraint");
-                       data->flag = SIZELIKE_X|SIZELIKE_Y|SIZELIKE_Z;
-                       result = data;
-               }
-               break;
-       case CONSTRAINT_TYPE_ACTION:
-               {
-                       bActionConstraint *data;
-                       data = MEM_callocN(sizeof(bActionConstraint), "ActionConstraint");
-                       
-                       /* set type to 20 (Loc X), as 0 is Rot X for backwards compatability */
-                       data->type = 20;
-                       
-                       result = data;
-               }
-               break;
-       case CONSTRAINT_TYPE_LOCKTRACK:
-               {
-                       bLockTrackConstraint *data;
-                       data = MEM_callocN(sizeof(bLockTrackConstraint), "locktrackConstraint");
-                       
-                       data->trackflag = TRACK_Y;
-                       data->lockflag = LOCK_Z;
-                       
-                       result = data;
-               }
-               break;
-       case CONSTRAINT_TYPE_FOLLOWPATH:
-               {
-                       bFollowPathConstraint *data;
-                       data = MEM_callocN(sizeof(bFollowPathConstraint), "followpathConstraint");
-
-                       data->trackflag = TRACK_Y;
-                       data->upflag = UP_Z;
-                       data->offset = 0;
-                       data->followflag = 0;
-
-                       result = data;
-               }
-               break;
-       case CONSTRAINT_TYPE_STRETCHTO:
-               {
-                       bStretchToConstraint *data;
-                       data = MEM_callocN(sizeof(bStretchToConstraint), "StretchToConstraint");
-
-                       data->volmode = 0;
-                       data->plane = 0;
-                       data->orglength = 0.0; 
-                       data->bulge = 1.0;
-                       result = data;
-               }
-               break; 
-       case CONSTRAINT_TYPE_LOCLIMIT:
-               {
-                       bLocLimitConstraint *data;
-                       data = MEM_callocN(sizeof(bLocLimitConstraint), "LocLimitConstraint");
-                       result = data;
-               }
-               break;
-       case CONSTRAINT_TYPE_ROTLIMIT:
-               {
-                       bRotLimitConstraint *data;
-                       data = MEM_callocN(sizeof(bRotLimitConstraint), "RotLimitConstraint");
-                       result = data;
-               }
-               break;
-       case CONSTRAINT_TYPE_SIZELIMIT:
-               {
-                       bSizeLimitConstraint *data;
-                       data = MEM_callocN(sizeof(bSizeLimitConstraint), "SizeLimitConstraint");
-                       result = data;
-               }
-               break;
-    case CONSTRAINT_TYPE_RIGIDBODYJOINT:
-               {
-                       bRigidBodyJointConstraint *data;
-                       data = MEM_callocN(sizeof(bRigidBodyJointConstraint), "RigidBodyToConstraint");
-                       
-                       // removed code which set target of this constraint  
-            data->type=1;
-                       
-                       result = data;
-               }
-               break;
-       case CONSTRAINT_TYPE_CLAMPTO:
-               {
-                       bClampToConstraint *data;
-                       data = MEM_callocN(sizeof(bClampToConstraint), "ClampToConstraint");
-                       result = data;
-               }
-               break;
-       case CONSTRAINT_TYPE_CHILDOF:
-               {
-                       bChildOfConstraint *data;
-                       data = MEM_callocN(sizeof(bChildOfConstraint), "ChildOfConstraint");
-                       
-                       data->flag = (CHILDOF_LOCX | CHILDOF_LOCY | CHILDOF_LOCZ |
-                                                       CHILDOF_ROTX |CHILDOF_ROTY | CHILDOF_ROTZ |
-                                                       CHILDOF_SIZEX | CHILDOF_SIZEY | CHILDOF_SIZEZ);
-                       Mat4One(data->invmat);
-                       
-                       result = data;
-               }
-               break;
-       case CONSTRAINT_TYPE_TRANSFORM:
-               {
-                       bTransformConstraint *data;
-                       data = MEM_callocN(sizeof(bTransformConstraint), "TransformationConstraint");
-                       
-                       data->map[0]= 0;
-                       data->map[1]= 1;
-                       data->map[2]= 2;
-                       
-                       result = data;
-               }
-               break;
-  
-       default:
-               result = NULL;
-               break;
-       }
-
-       return result;
-}
-
-bConstraintChannel *get_constraint_channel (ListBase *list, const char *name)
-{
-       bConstraintChannel *chan;
-
-       for (chan = list->first; chan; chan=chan->next) {
-               if (!strcmp(name, chan->name)) {
-                       return chan;
-               }
-       }
-       return NULL;
-}
-
-/* finds or creates new constraint channel */
-bConstraintChannel *verify_constraint_channel (ListBase *list, const char *name)
-{
-       bConstraintChannel *chan;
-       
-       chan= get_constraint_channel(list, name);
-       
-       if(chan == NULL) {
-               chan= MEM_callocN(sizeof(bConstraintChannel), "new constraint chan");
-               BLI_addtail(list, chan);
-               strcpy(chan->name, name);
-       }
-       
-       return chan;
-}
-
-
-/* ***************** Evaluating ********************* */
-
-/* package an object/bone for use in constraint evaluation */
-/* This function MEM_calloc's a bConstraintOb struct, that will need to be freed after evaluation */
-bConstraintOb *constraints_make_evalob (Object *ob, void *subdata, short datatype)
-{
-       bConstraintOb *cob;
-       
-       /* create regardless of whether we have any data! */
-       cob= MEM_callocN(sizeof(bConstraintOb), "bConstraintOb");
-       
-       /* based on type of available data */
-       switch (datatype) {
-               case TARGET_OBJECT:
-               {
-                       /* disregard subdata... calloc should set other values right */
-                       if (ob) {
-                               cob->ob = ob;
-                               cob->type = datatype;
-                               Mat4CpyMat4(cob->matrix, ob->obmat);
+                       /* cob->ob might not exist! */
+                       if (cob->ob) {
+                               /* copy new ob-matrix back to owner */
+                               Mat4CpyMat4(cob->ob->obmat, cob->matrix);
+                               
+                               /* copy inverse of delta back to owner */
+                               Mat4Invert(cob->ob->constinv, delta);
                        }
-                       else
-                               Mat4One(cob->matrix);
-                       
-                       Mat4CpyMat4(cob->startmat, cob->matrix);
                }
                        break;
-               case TARGET_BONE:
+               case CONSTRAINT_OBTYPE_BONE:
                {
-                       /* only set if we have valid bone, otherwise default */
-                       if (ob && subdata) {
-                               cob->ob = ob;
-                               cob->pchan = (bPoseChannel *)subdata;
-                               cob->type = datatype;
+                       /* cob->ob or cob->pchan might not exist */
+                       if (cob->ob && cob->pchan) {
+                               /* copy new pose-matrix back to owner */
+                               Mat4MulMat4(cob->pchan->pose_mat, cob->matrix, cob->ob->imat);
                                
-                               /* matrix in world-space */
-                               Mat4MulMat4(cob->matrix, cob->pchan->pose_mat, ob->obmat);
+                               /* copy inverse of delta back to owner */
+                               Mat4Invert(cob->pchan->constinv, delta);
                        }
-                       else
-                               Mat4One(cob->matrix);
-                               
-                       Mat4CpyMat4(cob->startmat, cob->matrix);
-               }
-                       break;
-                       
-               default: // other types not yet handled
-                       Mat4One(cob->matrix);
-                       Mat4One(cob->startmat);
-                       break;
-       }
-       
-       return cob;
-}
-
-/* cleanup after constraint evaluation */
-void constraints_clear_evalob (bConstraintOb *cob)
-{
-       float delta[4][4], imat[4][4];
-       
-       /* prevent crashes */
-       if (cob == NULL) 
-               return;
-       
-       /* calculate delta of constraints evaluation */
-       Mat4Invert(imat, cob->startmat);
-       Mat4MulMat4(delta, cob->matrix, imat);
-       
-       /* copy matrices back to source */
-       switch (cob->type) {
-               case TARGET_OBJECT:
-               {
-                       /* copy new ob-matrix back to owner */
-                       Mat4CpyMat4(cob->ob->obmat, cob->matrix);
-                       
-                       /* copy inverse of delta back to owner */
-                       Mat4Invert(cob->ob->constinv, delta);
-               }
-                       break;
-               case TARGET_BONE:
-               {
-                       /* copy new pose-matrix back to owner */
-                       Mat4MulMat4(cob->pchan->pose_mat, cob->matrix, cob->ob->imat);
-                       
-                       /* copy inverse of delta back to owner */
-                       Mat4Invert(cob->pchan->constinv, delta);
                }
                        break;
        }
@@ -883,40 +359,7 @@ void constraints_clear_evalob (bConstraintOb *cob)
        MEM_freeN(cob);
 }
 
-/* -------------------------------- Constraint Channels ---------------------------- */
-
-/* does IPO's of constraint channels only */
-void do_constraint_channels (ListBase *conbase, ListBase *chanbase, float ctime, int onlydrivers)
-{
-       bConstraint *con;
-       bConstraintChannel *chan;
-       IpoCurve *icu= NULL;
-       
-       /* for each Constraint, calculate its Influence from the corresponding ConstraintChannel */
-       for (con=conbase->first; con; con=con->next) {
-               
-               chan = get_constraint_channel(chanbase, con->name);
-               
-               if (chan && chan->ipo) {
-                       calc_ipo(chan->ipo, ctime);
-                       
-                       for (icu=chan->ipo->curve.first; icu; icu=icu->next) {
-                               if(!onlydrivers || icu->driver) {
-                                       switch (icu->adrcode) {
-                                               case CO_ENFORCE:
-                                               {
-                                                       /* Influence is clamped to 0.0f -> 1.0f range */
-                                                       con->enforce = CLAMPIS(icu->curval, 0.0f, 1.0f);
-                                               }
-                                                       break;
-                                       }
-                               }
-                       }
-               }
-       }
-}
-
-/* ------------------------------- Space-Conversion API ---------------------------- */
+/* -------------- Space-Conversion API -------------- */
 
 /* This function is responsible for the correct transformations/conversions 
  * of a matrix from one space to another for constraint evaluation.
@@ -1112,7 +555,7 @@ void constraint_mat_convertspace (Object *ob, bPoseChannel *pchan, float mat[][4
        }
 }
 
-/* ------------------------------- Target ---------------------------- */
+/* ------------ General Target Matrix Tools ---------- */
 
 /* function that sets the given matrix based on given vertex group in mesh */
 static void contarget_get_mesh_mat (Object *ob, char *substring, float mat[][4])
@@ -1311,18 +754,277 @@ static void constraint_target_to_mat4 (Object *ob, char *substring, float mat[][
        }
 }
 
+/* ************************* Specific Constraints ***************************** */
+/* Each constraint defines a set of functions, which will be called at the appropriate
+ * times. In addition to this, each constraint should have a type-info struct, where
+ * its functions are attached for use. 
+ */
+/* Template for type-info data:
+ *     - make a copy of this when creating new constraints, and just change the functions
+ *       pointed to as necessary
+ *     - although the naming of functions doesn't matter, it would help for code
+ *       readability, to follow the same naming convention as is presented here
+ *     - any functions that a constraint doesn't need to define, don't define
+ *       for such cases, just use NULL 
+ *     - these should be defined after all the functions have been defined, so that
+ *       forward-definitions/prototypes don't need to be used!
+ *     - keep this copy #if-def'd so that future constraints can get based off this
+ */
+#if 0
+static bConstraintTypeInfo CTI_CONSTRNAME = {
+       CONSTRAINT_TYPE_CONSTRNAME, /* type */
+       sizeof(bConstrNameConstraint), /* size */
+       "ConstrName", /* name */
+       "bConstrNameConstraint", /* struct name */
+       constrname_free, /* free data */
+       constrname_relink, /* relink data */
+       constrname_copy, /* copy data */
+       constrname_new_data, /* new data */
+       constrname_get_tars, /* get constraint targets */
+       constrname_flush_tars, /* flush constraint targets */
+       constrname_get_tarmat, /* get target matrix */
+       constrname_evaluate /* evaluate */
+};
+#endif
+
+/* This function should be used for the get_target_matrix member of all 
+ * constraints that are not picky about what happens to their target matrix.
+ */
+static void default_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstraintTarget *ct, float ctime)
+{
+       if (VALID_CONS_TARGET(ct))
+               constraint_target_to_mat4(ct->tar, ct->subtarget, ct->matrix, CONSTRAINT_SPACE_WORLD, ct->space);
+       else if (ct)
+               Mat4One(ct->matrix);
+}
+
+/* This following macro should be used for all standard single-target *_get_tars functions 
+ * to save typing and reduce maintainance woes.
+ * (Hopefully all compilers will be happy with the lines with just a space on them. Those are
+ *  really just to help this code easier to read)
+ */
+#define SINGLETARGET_GET_TARS(con, data, ct, list) \
+       { \
+               ct= MEM_callocN(sizeof(bConstraintTarget), "tempConstraintTarget"); \
+                \
+               ct->tar= data->tar; \
+               strcpy(ct->subtarget, data->subtarget); \
+               ct->space= con->tarspace; \
+               ct->flag= CONSTRAINT_TAR_TEMP; \
+                \
+               if (ct->tar) { \
+                       if ((ct->tar->type==OB_ARMATURE) && (ct->subtarget[0])) ct->type = CONSTRAINT_OBTYPE_BONE; \
+                       else if (ELEM(ct->tar->type, OB_MESH, OB_LATTICE) && (ct->subtarget[0])) ct->type = CONSTRAINT_OBTYPE_VERT; \
+                       else ct->type = CONSTRAINT_OBTYPE_OBJECT; \
+               } \
+                \
+               BLI_addtail(list, ct); \
+       }
+       
+/* This following macro should be used for all standard single-target *_get_tars functions 
+ * to save typing and reduce maintainance woes. It does not do the subtarget related operations
+ * (Hopefully all compilers will be happy with the lines with just a space on them. Those are
+ *  really just to help this code easier to read)
+ */
+#define SINGLETARGETNS_GET_TARS(con, data, ct, list) \
+       { \
+               ct= MEM_callocN(sizeof(bConstraintTarget), "tempConstraintTarget"); \
+                \
+               ct->tar= data->tar; \
+               ct->space= con->tarspace; \
+               ct->flag= CONSTRAINT_TAR_TEMP; \
+                \
+               if (ct->tar) ct->type = CONSTRAINT_OBTYPE_OBJECT; \
+                \
+               BLI_addtail(list, ct); \
+       }
+
+/* This following macro should be used for all standard single-target *_flush_tars functions
+ * to save typing and reduce maintainance woes.
+ * (Hopefully all compilers will be happy with the lines with just a space on them. Those are
+ *  really just to help this code easier to read)
+ */
+#define SINGLETARGET_FLUSH_TARS(con, data, ct, list, nocopy) \
+       { \
+               if (ct) { \
+                       if (nocopy == 0) { \
+                               data->tar= ct->tar; \
+                               strcpy(data->subtarget, ct->subtarget); \
+                               con->tarspace= ct->space; \
+                       } \
+                        \
+                       BLI_freelistN(list); \
+               } \
+       }
+       
+/* This following macro should be used for all standard single-target *_flush_tars functions
+ * to save typing and reduce maintainance woes. It does not do the subtarget related operations
+ * (Hopefully all compilers will be happy with the lines with just a space on them. Those are
+ *  really just to help this code easier to read)
+ */
+#define SINGLETARGETNS_FLUSH_TARS(con, data, ct, list, nocopy) \
+       { \
+               if (ct) { \
+                       if (nocopy == 0) { \
+                               data->tar= ct->tar; \
+                               con->tarspace= ct->space; \
+                       } \
+                        \
+                       BLI_freelistN(list); \
+               } \
+       }
+/* --------- ChildOf Constraint ------------ */
+
+static void childof_new_data (void *cdata)
+{
+       bChildOfConstraint *data= (bChildOfConstraint *)cdata;
+       
+       data->flag = (CHILDOF_LOCX | CHILDOF_LOCY | CHILDOF_LOCZ |
+                                       CHILDOF_ROTX |CHILDOF_ROTY | CHILDOF_ROTZ |
+                                       CHILDOF_SIZEX | CHILDOF_SIZEY | CHILDOF_SIZEZ);
+       Mat4One(data->invmat);
+}
+
+static void childof_get_tars (bConstraint *con, ListBase *list)
+{
+       if (con && list) {
+               bChildOfConstraint *data= con->data;
+               bConstraintTarget *ct;
+               
+               /* standard target-getting macro for single-target constraints */
+               SINGLETARGET_GET_TARS(con, data, ct, list)
+       }
+}
+
+static void childof_flush_tars (bConstraint *con, ListBase *list, short nocopy)
+{
+       if (con && list) {
+               bChildOfConstraint *data= con->data;
+               bConstraintTarget *ct= list->first;
+               
+               /* the following macro is used for all standard single-target constraints */
+               SINGLETARGET_FLUSH_TARS(con, data, ct, list, nocopy)
+       }
+}
+
+static void childof_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets)
+{
+       bChildOfConstraint *data= con->data;
+       bConstraintTarget *ct= targets->first;
+       
+       /* only evaluate if there is a target */
+       if (VALID_CONS_TARGET(ct)) {
+               float parmat[4][4], invmat[4][4], tempmat[4][4];
+               float loc[3], eul[3], size[3];
+               float loco[3], eulo[3], sizo[3];
+               
+               /* get offset (parent-inverse) matrix */
+               Mat4CpyMat4(invmat, data->invmat);
+               
+               /* extract components of both matrices */
+               VECCOPY(loc, ct->matrix[3]);
+               Mat4ToEul(ct->matrix, eul);
+               Mat4ToSize(ct->matrix, size);
+               
+               VECCOPY(loco, invmat[3]);
+               Mat4ToEul(invmat, eulo);
+               Mat4ToSize(invmat, sizo);
+               
+               /* disable channels not enabled */
+               if (!(data->flag & CHILDOF_LOCX)) loc[0]= loco[0]= 0.0f;
+               if (!(data->flag & CHILDOF_LOCY)) loc[1]= loco[1]= 0.0f;
+               if (!(data->flag & CHILDOF_LOCZ)) loc[2]= loco[2]= 0.0f;
+               if (!(data->flag & CHILDOF_ROTX)) eul[0]= eulo[0]= 0.0f;
+               if (!(data->flag & CHILDOF_ROTY)) eul[1]= eulo[1]= 0.0f;
+               if (!(data->flag & CHILDOF_ROTZ)) eul[2]= eulo[2]= 0.0f;
+               if (!(data->flag & CHILDOF_SIZEX)) size[0]= sizo[0]= 1.0f;
+               if (!(data->flag & CHILDOF_SIZEY)) size[1]= sizo[1]= 1.0f;
+               if (!(data->flag & CHILDOF_SIZEZ)) size[2]= sizo[2]= 1.0f;
+               
+               /* make new target mat and offset mat */
+               LocEulSizeToMat4(ct->matrix, loc, eul, size);
+               LocEulSizeToMat4(invmat, loco, eulo, sizo);
+               
+               /* multiply target (parent matrix) by offset (parent inverse) to get 
+                * the effect of the parent that will be exherted on the owner
+                */
+               Mat4MulMat4(parmat, invmat, ct->matrix);
+               
+               /* now multiply the parent matrix by the owner matrix to get the 
+                * the effect of this constraint (i.e.  owner is 'parented' to parent)
+                */
+               Mat4CpyMat4(tempmat, cob->matrix);
+               Mat4MulMat4(cob->matrix, tempmat, parmat); 
+       }
+}
+
+static bConstraintTypeInfo CTI_CHILDOF = {
+       CONSTRAINT_TYPE_CHILDOF, /* type */
+       sizeof(bChildOfConstraint), /* size */
+       "ChildOf", /* name */
+       "bChildOfConstraint", /* struct name */
+       NULL, /* free data */
+       NULL, /* relink data */
+       NULL, /* copy data */
+       childof_new_data, /* new data */
+       childof_get_tars, /* get constraint targets */
+       childof_flush_tars, /* flush constraint targets */
+       default_get_tarmat, /* get a target matrix */
+       childof_evaluate /* evaluate */
+};
+
+/* -------- TrackTo Constraint ------- */
+
+static void trackto_new_data (void *cdata)
+{
+       bTrackToConstraint *data= (bTrackToConstraint *)cdata;
+       
+       data->reserved1 = TRACK_Y;
+       data->reserved2 = UP_Z;
+}      
+
+static void trackto_get_tars (bConstraint *con, ListBase *list)
+{
+       if (con && list) {
+               bTrackToConstraint *data= con->data;
+               bConstraintTarget *ct;
+               
+               /* standard target-getting macro for single-target constraints */
+               SINGLETARGET_GET_TARS(con, data, ct, list)
+       }
+}
+
+static void trackto_flush_tars (bConstraint *con, ListBase *list, short nocopy)
+{
+       if (con && list) {
+               bTrackToConstraint *data= con->data;
+               bConstraintTarget *ct= list->first;
+               
+               /* the following macro is used for all standard single-target constraints */
+               SINGLETARGET_FLUSH_TARS(con, data, ct, list, nocopy)
+       }
+}
+
 
-/* stupid little cross product function, 0:x, 1:y, 2:z axes */
-static int basis_cross(int n, int m)
+static int basis_cross (int n, int m)
 {
-       if(n-m == 1) return 1;
-       if(n-m == -1) return -1;
-       if(n-m == 2) return -1;
-       if(n-m == -2) return 1;
-       else return 0;
+       switch (n-m) {
+               case 1: 
+               case -2:
+                       return 1;
+                       
+               case -1: 
+               case 2:
+                       return -1;
+                       
+               default:
+                       return 0;
+       }
 }
 
-static void vectomat(float *vec, float *target_up, short axis, short upflag, short flags, float m[][3])
+static void vectomat (float *vec, float *target_up, short axis, short upflag, short flags, float m[][3])
 {
        float n[3];
        float u[3]; /* vector specifying the up axis */
@@ -1332,17 +1034,16 @@ static void vectomat(float *vec, float *target_up, short axis, short upflag, sho
        int right_index;
        
        VecCopyf(n, vec);
-       if(Normalize(n) == 0.0) { 
+       if (Normalize(n) == 0.0) { 
                n[0] = 0.0;
                n[1] = 0.0;
                n[2] = 1.0;
        }
-       if(axis > 2) axis -= 3;
+       if (axis > 2) axis -= 3;
        else VecMulf(n,-1);
 
        /* n specifies the transformation of the track axis */
-
-       if(flags & TARGET_Z_UP) { 
+       if (flags & TARGET_Z_UP) { 
                /* target Z axis is the global up axis */
                u[0] = target_up[0];
                u[1] = target_up[1];
@@ -1360,7 +1061,7 @@ static void vectomat(float *vec, float *target_up, short axis, short upflag, sho
        VecSubf(proj, u, proj); /* then onto the plane */
        /* proj specifies the transformation of the up axis */
 
-       if(Normalize(proj) == 0.0) { /* degenerate projection */
+       if (Normalize(proj) == 0.0) { /* degenerate projection */
                proj[0] = 0.0;
                proj[1] = 1.0;
                proj[2] = 0.0;
@@ -1370,19 +1071,19 @@ static void vectomat(float *vec, float *target_up, short axis, short upflag, sho
        Crossf(right, proj, n);
        Normalize(right);
 
-       if(axis != upflag) {
+       if (axis != upflag) {
                right_index = 3 - axis - upflag;
-               neg = (float) basis_cross(axis, upflag);
-
+               neg = (float)basis_cross(axis, upflag);
+               
                /* account for up direction, track direction */
                m[right_index][0] = neg * right[0];
                m[right_index][1] = neg * right[1];
                m[right_index][2] = neg * right[2];
-
+               
                m[upflag][0] = proj[0];
                m[upflag][1] = proj[1];
                m[upflag][2] = proj[2];
-
+               
                m[axis][0] = n[0];
                m[axis][1] = n[1];
                m[axis][2] = n[2];
@@ -1397,1449 +1098,2209 @@ static void vectomat(float *vec, float *target_up, short axis, short upflag, sho
 }
 
 
-/* called during solve_constraints */
-/* also for make_parent, to find correct inverse of "follow path" */
-/* warning: ownerdata is PoseChannel or Object */
-/* ctime is global time, uncorrected for local bsystem_time */
-short get_constraint_target_matrix (bConstraint *con, short ownertype, void *ownerdata, float mat[][4], float ctime)
+static void trackto_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets)
 {
-       short valid=0;
+       bTrackToConstraint *data= con->data;
+       bConstraintTarget *ct= targets->first;
+       
+       if (VALID_CONS_TARGET(ct)) {
+               float size[3], vec[3];
+               float totmat[3][3];
+               float tmat[4][4];
+               
+               /* Get size property, since ob->size is only the object's own relative size, not its global one */
+               Mat4ToSize(cob->matrix, size);
+               
+               /* Clear the object's rotation */       
+               cob->matrix[0][0]=size[0];
+               cob->matrix[0][1]=0;
+               cob->matrix[0][2]=0;
+               cob->matrix[1][0]=0;
+               cob->matrix[1][1]=size[1];
+               cob->matrix[1][2]=0;
+               cob->matrix[2][0]=0;
+               cob->matrix[2][1]=0;
+               cob->matrix[2][2]=size[2];
+               
+               /* targetmat[2] instead of ownermat[2] is passed to vectomat
+                * for backwards compatability it seems... (Aligorith)
+                */
+               VecSubf(vec, cob->matrix[3], ct->matrix[3]);
+               vectomat(vec, ct->matrix[2], 
+                               (short)data->reserved1, (short)data->reserved2, 
+                               data->flags, totmat);
+               
+               Mat4CpyMat4(tmat, cob->matrix);
+               Mat4MulMat34(cob->matrix, totmat, tmat);
+       }
+}
 
-       switch (con->type) {
-       case CONSTRAINT_TYPE_NULL:
-               {
-                       Mat4One(mat);
-               }
-               break;
-       case CONSTRAINT_TYPE_ACTION:
-               {
-                       if (ownertype == TARGET_BONE) {
-                               extern void chan_calc_mat(bPoseChannel *chan);
-                               bActionConstraint *data = (bActionConstraint*)con->data;
-                               bPose *pose;
-                               bPoseChannel *pchan, *tchan;
-                               float tempmat[4][4], vec[3];
-                               float s, t;
-                               short axis;
-                               
-                               /* initialise return matrix */
-                               Mat4One(mat);
-                               
-                               /* only continue if there is a target  */
-                               if (data->tar==NULL) return 0;
-                               
-                               /* get the transform matrix of the target */
-                               constraint_target_to_mat4(data->tar, data->subtarget, tempmat, CONSTRAINT_SPACE_WORLD, con->tarspace); // FIXME: change these spaces 
-                               
-                               /* determine where in transform range target is */
-                               /* data->type is mapped as follows for backwards compatability:
-                                *      00,01,02        - rotation (it used to be like this)
-                                *      10,11,12        - scaling
-                                *      20,21,22        - location
-                                */
-                               if (data->type < 10) {
-                                       /* extract rotation (is in whatever space target should be in) */
-                                       Mat4ToEul(tempmat, vec);
-                                       vec[0] *= (float)(180.0/M_PI);
-                                       vec[1] *= (float)(180.0/M_PI);
-                                       vec[2] *= (float)(180.0/M_PI);
-                                       axis= data->type;
-                               }
-                               else if (data->type < 20) {
-                                       /* extract scaling (is in whatever space target should be in) */
-                                       Mat4ToSize(tempmat, vec);
-                                       axis= data->type - 10;
-                               }
-                               else {
-                                       /* extract location */
-                                       VECCOPY(vec, tempmat[3]);
-                                       axis= data->type - 20;
-                               }
-                               
-                               /* Target defines the animation */
-                               s = (vec[axis]-data->min) / (data->max-data->min);
-                               CLAMP(s, 0, 1);
-                               t = ( s * (data->end-data->start)) + data->start;
-                               
-                               /* Get the appropriate information from the action, we make temp pose */
-                               pose = MEM_callocN(sizeof(bPose), "pose");
-                               
-                               pchan = ownerdata;
-                               tchan= verify_pose_channel(pose, pchan->name);
-                               extract_pose_from_action(pose, data->act, t);
-                               
-                               chan_calc_mat(tchan);
-                               
-                               Mat4CpyMat4(mat, tchan->chan_mat);
-                               
-                               /* Clean up */
-                               free_pose_channels(pose);
-                               MEM_freeN(pose);
-                       }
-               }
-               break;
-       case CONSTRAINT_TYPE_LOCLIKE:
-               {
-                       bLocateLikeConstraint *data = (bLocateLikeConstraint*)con->data;
-                       Object *ob= data->tar;
-                       
-                       if (data->tar) {
-                               if (data->tar->type==OB_ARMATURE && strlen(data->subtarget)) {
-                                       /* Pose-Channels for the CopyLoc target are handled specially, so that
-                                        * we can support using the bone-tip as an option.
-                                        */
-                                       bPoseChannel *pchan;
-                                       float tmat[4][4];
-                                       
-                                       pchan = get_pose_channel(ob->pose, data->subtarget);
-                                       if (pchan) {
-                                               Mat4CpyMat4(tmat, pchan->pose_mat);
-                                               
-                                               if (data->flag & LOCLIKE_TIP) { 
-                                                       VECCOPY(tmat[3], pchan->pose_tail);
-                                               }
-                                                       
-                                               Mat4MulMat4(mat, tmat, ob->obmat);
-                                       }
-                                       else 
-                                               Mat4CpyMat4(mat, ob->obmat);
-                                               
-                                       /* convert matrix space as required  */
-                                       constraint_mat_convertspace(ob, pchan, mat, CONSTRAINT_SPACE_WORLD, con->tarspace);
-                               }
-                               else {
-                                       /* get target matrix as is done normally for other constraints */
-                                       constraint_target_to_mat4(data->tar, data->subtarget, mat, CONSTRAINT_SPACE_WORLD, con->tarspace);
-                               }
-                               valid=1;
-                       }
-                       else
-                               Mat4One(mat);
-               } 
-               break;
-       case CONSTRAINT_TYPE_ROTLIKE:
-               {
-                       bRotateLikeConstraint *data;
-                       data = (bRotateLikeConstraint*)con->data;
-                       
-                       if (data->tar) {
-                               constraint_target_to_mat4(data->tar, data->subtarget, mat, CONSTRAINT_SPACE_WORLD, con->tarspace);
-                               valid=1;
-                       }
-                       else
-                               Mat4One(mat);
-               } 
-               break;
-       case CONSTRAINT_TYPE_SIZELIKE:
-               {
-                       bSizeLikeConstraint *data;
-                       data = (bSizeLikeConstraint*)con->data;
-                       
-                       if (data->tar) {
-                               constraint_target_to_mat4(data->tar, data->subtarget, mat, CONSTRAINT_SPACE_WORLD, con->tarspace);
-                               valid=1;
-                       }
-                       else
-                               Mat4One(mat);
-               } 
-               break;
-       case CONSTRAINT_TYPE_MINMAX:
-               {
-                       bMinMaxConstraint *data = (bMinMaxConstraint*)con->data;
-                       
-                       if (data->tar) {
-                               constraint_target_to_mat4(data->tar, data->subtarget, mat, CONSTRAINT_SPACE_WORLD, con->tarspace);
-                               valid=1;
+static bConstraintTypeInfo CTI_TRACKTO = {
+       CONSTRAINT_TYPE_TRACKTO, /* type */
+       sizeof(bTrackToConstraint), /* size */
+       "TrackTo", /* name */
+       "bTrackToConstraint", /* struct name */
+       NULL, /* free data */
+       NULL, /* relink data */
+       NULL, /* copy data */
+       trackto_new_data, /* new data */
+       trackto_get_tars, /* get constraint targets */
+       trackto_flush_tars, /* flush constraint targets */
+       default_get_tarmat, /* get target matrix */
+       trackto_evaluate /* evaluate */
+};
+
+/* --------- Inverse-Kinemetics --------- */
+
+static void kinematic_new_data (void *cdata)
+{
+       bKinematicConstraint *data= (bKinematicConstraint *)cdata;
+       
+       data->weight= (float)1.0;
+       data->orientweight= (float)1.0;
+       data->iterations = 500;
+       data->flag= CONSTRAINT_IK_TIP|CONSTRAINT_IK_STRETCH|CONSTRAINT_IK_POS;
+}
+
+static void kinematic_get_tars (bConstraint *con, ListBase *list)
+{
+       if (con && list) {
+               bKinematicConstraint *data= con->data;
+               bConstraintTarget *ct;
+               
+               /* standard target-getting macro for single-target constraints */
+               SINGLETARGET_GET_TARS(con, data, ct, list)
+       }
+}
+
+static void kinematic_flush_tars (bConstraint *con, ListBase *list, short nocopy)
+{
+       if (con && list) {
+               bKinematicConstraint *data= con->data;
+               bConstraintTarget *ct= list->first;
+               
+               /* the following macro is used for all standard single-target constraints */
+               SINGLETARGET_FLUSH_TARS(con, data, ct, list, nocopy)
+       }
+}
+
+static void kinematic_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstraintTarget *ct, float ctime)
+{
+       bKinematicConstraint *data= con->data;
+       
+       if (VALID_CONS_TARGET(ct)) 
+               constraint_target_to_mat4(ct->tar, ct->subtarget, ct->matrix, CONSTRAINT_SPACE_WORLD, ct->space);
+       else if (ct) {
+               if (data->flag & CONSTRAINT_IK_AUTO) {
+                       Object *ob= cob->ob;
+                       
+                       if (ob == NULL) {
+                               Mat4One(ct->matrix);
                        }
-                       else
-                               Mat4One(mat);
-               } 
-               break;
-       case CONSTRAINT_TYPE_TRACKTO:
-               {
-                       bTrackToConstraint *data;
-                       data = (bTrackToConstraint*)con->data;
-                       
-                       if (data->tar) {
-                               constraint_target_to_mat4(data->tar, data->subtarget, mat, CONSTRAINT_SPACE_WORLD, con->tarspace);
-                               valid=1;
+                       else {
+                               float vec[3];
+                               /* move grabtarget into world space */
+                               VECCOPY(vec, data->grabtarget);
+                               Mat4MulVecfl(ob->obmat, vec);
+                               Mat4CpyMat4(ct->matrix, ob->obmat);
+                               VECCOPY(ct->matrix[3], vec);
                        }
-                       else
-                               Mat4One (mat);
                }
-               break;
-       case CONSTRAINT_TYPE_KINEMATIC:
-               {
-                       bKinematicConstraint *data;
-                       data = (bKinematicConstraint*)con->data;
-                       
-                       if (data->tar) {
-                               constraint_target_to_mat4(data->tar, data->subtarget, mat, CONSTRAINT_SPACE_WORLD, con->tarspace);
-                               valid=1;
-                       }
-                       else if (data->flag & CONSTRAINT_IK_AUTO) {
-                               Object *ob= (Object *)ownerdata;
-                               
-                               if (ob==NULL)
-                                       Mat4One(mat);
-                               else {
-                                       float vec[3];
-                                       /* move grabtarget into world space */
-                                       VECCOPY(vec, data->grabtarget);
-                                       Mat4MulVecfl(ob->obmat, vec);
-                                       Mat4CpyMat4(mat, ob->obmat);
-                                       VECCOPY(mat[3], vec);
-                               }
-                       }
-                       else
-                               Mat4One(mat);
-               } 
-               break;
-       case CONSTRAINT_TYPE_LOCKTRACK:
-               {
-                       bLockTrackConstraint *data;
-                       data = (bLockTrackConstraint*)con->data;
+               else
+                       Mat4One(ct->matrix);
+       }
+}
+
+static bConstraintTypeInfo CTI_KINEMATIC = {
+       CONSTRAINT_TYPE_KINEMATIC, /* type */
+       sizeof(bKinematicConstraint), /* size */
+       "IK", /* name */
+       "bKinematicConstraint", /* struct name */
+       NULL, /* free data */
+       NULL, /* relink data */
+       NULL, /* copy data */
+       kinematic_new_data, /* new data */
+       kinematic_get_tars, /* get constraint targets */
+       kinematic_flush_tars, /* flush constraint targets */
+       kinematic_get_tarmat, /* get target matrix */
+       NULL /* evaluate - solved as separate loop */
+};
+
+/* -------- Follow-Path Constraint ---------- */
+
+static void followpath_new_data (void *cdata)
+{
+       bFollowPathConstraint *data= (bFollowPathConstraint *)cdata;
+       
+       data->trackflag = TRACK_Y;
+       data->upflag = UP_Z;
+       data->offset = 0;
+       data->followflag = 0;
+}
+
+static void followpath_get_tars (bConstraint *con, ListBase *list)
+{
+       if (con && list) {
+               bFollowPathConstraint *data= con->data;
+               bConstraintTarget *ct;
+               
+               /* standard target-getting macro for single-target constraints without subtargets */
+               SINGLETARGETNS_GET_TARS(con, data, ct, list)
+       }
+}
+
+static void followpath_flush_tars (bConstraint *con, ListBase *list, short nocopy)
+{
+       if (con && list) {
+               bFollowPathConstraint *data= con->data;
+               bConstraintTarget *ct= list->first;
+               
+               /* the following macro is used for all standard single-target constraints */
+               SINGLETARGETNS_FLUSH_TARS(con, data, ct, list, nocopy)
+       }
+}
+
+static void followpath_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstraintTarget *ct, float ctime)
+{
+       bFollowPathConstraint *data= con->data;
+       
+       if (VALID_CONS_TARGET(ct)) {
+               Curve *cu= ct->tar->data;
+               float q[4], vec[4], dir[3], *quat, x1;
+               float totmat[4][4];
+               float curvetime;
+               
+               Mat4One(totmat);
+               Mat4One(ct->matrix);
+               
+               /* note: when creating constraints that follow path, the curve gets the CU_PATH set now,
+                *              currently for paths to work it needs to go through the bevlist/displist system (ton) 
+                */
+               
+               /* only happens on reload file, but violates depsgraph still... fix! */
+               if (cu->path==NULL || cu->path->data==NULL) 
+                       makeDispListCurveTypes(ct->tar, 0);
+               
+               if (cu->path && cu->path->data) {
+                       curvetime= bsystem_time(ct->tar, (float)ctime, 0.0) - data->offset;
                        
-                       if (data->tar) {
-                               constraint_target_to_mat4(data->tar, data->subtarget, mat, CONSTRAINT_SPACE_WORLD, con->tarspace); 
-                               valid=1;
+                       if (calc_ipo_spec(cu->ipo, CU_SPEED, &curvetime)==0) {
+                               curvetime /= cu->pathlen;
+                               CLAMP(curvetime, 0.0, 1.0);
                        }
-                       else
-                               Mat4One(mat);
-               } 
-               break;
-       case CONSTRAINT_TYPE_FOLLOWPATH:
-               {
-                       bFollowPathConstraint *data;
-                       data = (bFollowPathConstraint*)con->data;
                        
-                       if (data->tar) {
-                               Curve *cu;
-                               float q[4], vec[4], dir[3], *quat, x1;
-                               float totmat[4][4];
-                               float curvetime;
-                               
-                               Mat4One(totmat);
-                               Mat4One(mat);
-                               
-                               cu= data->tar->data;
-                               
-                               /* note: when creating constraints that follow path, the curve gets the CU_PATH set now,
-                                       currently for paths to work it needs to go through the bevlist/displist system (ton) */
-                               
-                               if (cu->path==NULL || cu->path->data==NULL) /* only happens on reload file, but violates depsgraph still... fix! */
-                                       makeDispListCurveTypes(data->tar, 0);
-                               if (cu->path && cu->path->data) {
-                                       curvetime= bsystem_time(data->tar, (float)ctime, 0.0) - data->offset;
+                       if ( where_on_path(ct->tar, curvetime, vec, dir) ) {
+                               if (data->followflag) {
+                                       quat= vectoquat(dir, (short) data->trackflag, (short) data->upflag);
                                        
-                                       if (calc_ipo_spec(cu->ipo, CU_SPEED, &curvetime)==0) {
-                                               curvetime /= cu->pathlen;
-                                               CLAMP(curvetime, 0.0, 1.0);
-                                       }
+                                       Normalize(dir);
+                                       q[0]= (float)cos(0.5*vec[3]);
+                                       x1= (float)sin(0.5*vec[3]);
+                                       q[1]= -x1*dir[0];
+                                       q[2]= -x1*dir[1];
+                                       q[3]= -x1*dir[2];
+                                       QuatMul(quat, q, quat);
                                        
-                                       if (where_on_path(data->tar, curvetime, vec, dir) ) {
-                                               if (data->followflag) {
-                                                       quat= vectoquat(dir, (short) data->trackflag, (short) data->upflag);
-                                                       
-                                                       Normalize(dir);
-                                                       q[0]= (float)cos(0.5*vec[3]);
-                                                       x1= (float)sin(0.5*vec[3]);
-                                                       q[1]= -x1*dir[0];
-                                                       q[2]= -x1*dir[1];
-                                                       q[3]= -x1*dir[2];
-                                                       QuatMul(quat, q, quat);
-                                                       
-                                                       QuatToMat4(quat, totmat);
-                                               }
-                                               VECCOPY(totmat[3], vec);
-                                               
-                                               Mat4MulSerie(mat, data->tar->obmat, totmat, NULL, NULL, NULL, NULL, NULL, NULL);
-                                       }
+                                       QuatToMat4(quat, totmat);
                                }
-                               valid=1;
-                       }
-                       else
-                               Mat4One(mat);
-               }
-               break;
-       case CONSTRAINT_TYPE_STRETCHTO:
-               {
-                       bStretchToConstraint *data;
-                       data = (bStretchToConstraint*)con->data;
-                       
-                       if (data->tar) {
-                               constraint_target_to_mat4(data->tar, data->subtarget, mat, CONSTRAINT_SPACE_WORLD, con->tarspace);
-                               valid = 1;
-                       }
-                       else
-                               Mat4One(mat);
-               }
-               break;
-       case CONSTRAINT_TYPE_PYTHON:
-               {
-                       bPythonConstraint *data;
-                       data = (bPythonConstraint*)con->data;
-                       
-                       /* special exception for curves - depsgraph issues */
-                       if (data->tar && data->tar->type == OB_CURVE) {
-                               Curve *cu= data->tar->data;
+                               VECCOPY(totmat[3], vec);
                                
-                               /* this check is to make sure curve objects get updated on file load correctly.*/
-                               if (cu->path==NULL || cu->path->data==NULL) /* only happens on reload file, but violates depsgraph still... fix! */
-                                       makeDispListCurveTypes(data->tar, 0);                           
+                               Mat4MulSerie(ct->matrix, ct->tar->obmat, totmat, NULL, NULL, NULL, NULL, NULL, NULL);
                        }
-                       
-                       /* if the script doesn't set the target matrix for any reason, fall back to standard methods */
-                       if (data->tar) {
-                               constraint_target_to_mat4(data->tar, data->subtarget, mat, CONSTRAINT_SPACE_WORLD, con->tarspace);
-                               if (BPY_pyconstraint_targets(data, mat) >= 1) {
-                                       valid = 1;
-                               }
-                       }
-                       if (!valid)
-                               Mat4One(mat);
                }
-               break;
-       case CONSTRAINT_TYPE_CLAMPTO:
-               {
-                       bClampToConstraint *data;
-                       data = (bClampToConstraint*)con->data;
-                       
-                       if (data->tar) {
-                               Curve *cu= data->tar->data;
-                               
-                               /* note; when creating constraints that follow path, the curve gets the CU_PATH set now,
-                                       currently for paths to work it needs to go through the bevlist/displist system (ton) */
-                               
-                               if (cu->path==NULL || cu->path->data==NULL) /* only happens on reload file, but violates depsgraph still... fix! */
-                                       makeDispListCurveTypes(data->tar, 0);
-                               
-                               valid = 1;
-                       }
+       }
+       else if (ct)
+               Mat4One(ct->matrix);
+}
+
+static void followpath_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets)
+{
+       bConstraintTarget *ct= targets->first;
+       
+       /* only evaluate if there is a target */
+       if (VALID_CONS_TARGET(ct)) {
+               float obmat[4][4];
+               float size[3], obsize[3];
+               
+               /* get Object local transform (loc/rot/size) to determine transformation from path */
+               //object_to_mat4(ob, obmat);
+               Mat4CpyMat4(obmat, cob->matrix); // FIXME!!!
+               
+               /* get scaling of object before applying constraint */
+               Mat4ToSize(cob->matrix, size);
+               
+               /* apply targetmat - containing location on path, and rotation */
+               Mat4MulSerie(cob->matrix, ct->matrix, obmat, NULL, NULL, NULL, NULL, NULL, NULL);
+               
+               /* un-apply scaling caused by path */
+               Mat4ToSize(cob->matrix, obsize);
+               if (obsize[0])
+                       VecMulf(cob->matrix[0], size[0] / obsize[0]);
+               if (obsize[1])
+                       VecMulf(cob->matrix[1], size[1] / obsize[1]);
+               if (obsize[2])
+                       VecMulf(cob->matrix[2], size[2] / obsize[2]);
+       }
+}
+
+static bConstraintTypeInfo CTI_FOLLOWPATH = {
+       CONSTRAINT_TYPE_FOLLOWPATH, /* type */
+       sizeof(bFollowPathConstraint), /* size */
+       "Follow Path", /* name */
+       "bFollowPathConstraint", /* struct name */
+       NULL, /* free data */
+       NULL, /* relink data */
+       NULL, /* copy data */
+       followpath_new_data, /* new data */
+       followpath_get_tars, /* get constraint targets */
+       followpath_flush_tars, /* flush constraint targets */
+       followpath_get_tarmat, /* get target matrix */
+       followpath_evaluate /* evaluate */
+};
+
+/* --------- Limit Location --------- */
+
+
+static void loclimit_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets)
+{
+       bLocLimitConstraint *data = con->data;
+       
+       if (data->flag & LIMIT_XMIN) {
+               if (cob->matrix[3][0] < data->xmin)
+                       cob->matrix[3][0] = data->xmin;
+       }
+       if (data->flag & LIMIT_XMAX) {
+               if (cob->matrix[3][0] > data->xmax)
+                       cob->matrix[3][0] = data->xmax;
+       }
+       if (data->flag & LIMIT_YMIN) {
+               if (cob->matrix[3][1] < data->ymin)
+                       cob->matrix[3][1] = data->ymin;
+       }
+       if (data->flag & LIMIT_YMAX) {
+               if (cob->matrix[3][1] > data->ymax)
+                       cob->matrix[3][1] = data->ymax;
+       }
+       if (data->flag & LIMIT_ZMIN) {
+               if (cob->matrix[3][2] < data->zmin) 
+                       cob->matrix[3][2] = data->zmin;
+       }
+       if (data->flag & LIMIT_ZMAX) {
+               if (cob->matrix[3][2] > data->zmax)
+                       cob->matrix[3][2] = data->zmax;
+       }
+}
+
+static bConstraintTypeInfo CTI_LOCLIMIT = {
+       CONSTRAINT_TYPE_LOCLIMIT, /* type */
+       sizeof(bLocLimitConstraint), /* size */
+       "Limit Location", /* name */
+       "bLocLimitConstraint", /* struct name */
+       NULL, /* free data */
+       NULL, /* relink data */
+       NULL, /* copy data */
+       NULL, /* new data */
+       NULL, /* get constraint targets */
+       NULL, /* flush constraint targets */
+       NULL, /* get target matrix */
+       loclimit_evaluate /* evaluate */
+};
+
+/* -------- Limit Rotation --------- */
+
+static void rotlimit_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets)
+{
+       bRotLimitConstraint *data = con->data;
+       float loc[3];
+       float eul[3];
+       float size[3];
+       
+       VECCOPY(loc, cob->matrix[3]);
+       Mat4ToSize(cob->matrix, size);
+       
+       Mat4ToEul(cob->matrix, eul);
+       
+       /* eulers: radians to degrees! */
+       eul[0] = (eul[0] / M_PI * 180);
+       eul[1] = (eul[1] / M_PI * 180);
+       eul[2] = (eul[2] / M_PI * 180);
+       
+       /* limiting of euler values... */
+       if (data->flag & LIMIT_XROT) {
+               if (eul[0] < data->xmin) 
+                       eul[0] = data->xmin;
                        
-                       Mat4One(mat);
-               }
-               break;
-       case CONSTRAINT_TYPE_CHILDOF:
-               {
-                       bChildOfConstraint *data;
-                       data= (bChildOfConstraint *)con->data;
+               if (eul[0] > data->xmax)
+                       eul[0] = data->xmax;
+       }
+       if (data->flag & LIMIT_YROT) {
+               if (eul[1] < data->ymin)
+                       eul[1] = data->ymin;
                        
-                       if (data->tar) {
-                               constraint_target_to_mat4(data->tar, data->subtarget, mat, CONSTRAINT_SPACE_WORLD, con->tarspace);
-                               valid = 1;
-                       }
-                       else
-                               Mat4One(mat);
-               }
-               break;
-       case CONSTRAINT_TYPE_TRANSFORM:
-               {
-                       bTransformConstraint *data;
-                       data= (bTransformConstraint *)con->data;
+               if (eul[1] > data->ymax)
+                       eul[1] = data->ymax;
+       }
+       if (data->flag & LIMIT_ZROT) {
+               if (eul[2] < data->zmin)
+                       eul[2] = data->zmin;
                        
-                       if (data->tar) {
-                               constraint_target_to_mat4(data->tar, data->subtarget, mat, CONSTRAINT_SPACE_WORLD, con->tarspace);
-                               valid = 1;
-                       }
-                       else
-                               Mat4One(mat);
-               }
-               break;
+               if (eul[2] > data->zmax)
+                       eul[2] = data->zmax;
+       }
+               
+       /* eulers: degrees to radians ! */
+       eul[0] = (eul[0] / 180 * M_PI); 
+       eul[1] = (eul[1] / 180 * M_PI);
+       eul[2] = (eul[2] / 180 * M_PI);
+       
+       LocEulSizeToMat4(cob->matrix, loc, eul, size);
+}
 
-       default:
-               Mat4One(mat);
-               break;
+static bConstraintTypeInfo CTI_ROTLIMIT = {
+       CONSTRAINT_TYPE_ROTLIMIT, /* type */
+       sizeof(bRotLimitConstraint), /* size */
+       "Limit Rotation", /* name */
+       "bRotLimitConstraint", /* struct name */
+       NULL, /* free data */
+       NULL, /* relink data */
+       NULL, /* copy data */
+       NULL, /* new data */
+       NULL, /* get constraint targets */
+       NULL, /* flush constraint targets */
+       NULL, /* get target matrix */
+       rotlimit_evaluate /* evaluate */
+};
+
+/* --------- Limit Scaling --------- */
+
+
+static void sizelimit_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets)
+{
+       bSizeLimitConstraint *data = con->data;
+       float obsize[3], size[3];
+       
+       Mat4ToSize(cob->matrix, size);
+       Mat4ToSize(cob->matrix, obsize);
+       
+       if (data->flag & LIMIT_XMIN) {
+               if (size[0] < data->xmin) 
+                       size[0] = data->xmin;   
+       }
+       if (data->flag & LIMIT_XMAX) {
+               if (size[0] > data->xmax) 
+                       size[0] = data->xmax;
        }
+       if (data->flag & LIMIT_YMIN) {
+               if (size[1] < data->ymin) 
+                       size[1] = data->ymin;   
+       }
+       if (data->flag & LIMIT_YMAX) {
+               if (size[1] > data->ymax) 
+                       size[1] = data->ymax;
+       }
+       if (data->flag & LIMIT_ZMIN) {
+               if (size[2] < data->zmin) 
+                       size[2] = data->zmin;   
+       }
+       if (data->flag & LIMIT_ZMAX) {
+               if (size[2] > data->zmax) 
+                       size[2] = data->zmax;
+       }
+       
+       if (obsize[0]) 
+               VecMulf(cob->matrix[0], size[0]/obsize[0]);
+       if (obsize[1]) 
+               VecMulf(cob->matrix[1], size[1]/obsize[1]);
+       if (obsize[2]) 
+               VecMulf(cob->matrix[2], size[2]/obsize[2]);
+}
 
-       return valid;
+static bConstraintTypeInfo CTI_SIZELIMIT = {
+       CONSTRAINT_TYPE_SIZELIMIT, /* type */
+       sizeof(bSizeLimitConstraint), /* size */
+       "Limit Scaling", /* name */
+       "bSizeLimitConstraint", /* struct name */
+       NULL, /* free data */
+       NULL, /* relink data */
+       NULL, /* copy data */
+       NULL, /* new data */
+       NULL, /* get constraint targets */
+       NULL, /* flush constraint targets */
+       NULL, /* get target matrix */
+       sizelimit_evaluate /* evaluate */
+};
+
+/* ----------- Copy Location ------------- */
+
+static void loclike_new_data (void *cdata)
+{
+       bLocateLikeConstraint *data= (bLocateLikeConstraint *)cdata;
+       
+       data->flag = LOCLIKE_X|LOCLIKE_Y|LOCLIKE_Z;
 }
 
-/* ---------------------------------------------- Constraint Evaluation ------------------------------------------------- */
+static void loclike_get_tars (bConstraint *con, ListBase *list)
+{
+       if (con && list) {
+               bLocateLikeConstraint *data= con->data;
+               bConstraintTarget *ct;
+               
+               /* standard target-getting macro for single-target constraints */
+               SINGLETARGET_GET_TARS(con, data, ct, list)
+       }
+}
 
-/* This is only called during solve_constraints to solve a particular constraint.
- * It works on ownermat, and uses targetmat to help accomplish its tasks.
- */
-static void evaluate_constraint (bConstraint *constraint, float ownermat[][4], float targetmat[][4])
+static void loclike_flush_tars (bConstraint *con, ListBase *list, short nocopy)
 {
-       if (constraint == NULL || constraint->data == NULL)
-               return;
+       if (con && list) {
+               bLocateLikeConstraint *data= con->data;
+               bConstraintTarget *ct= list->first;
                
-       switch (constraint->type) {
-       case CONSTRAINT_TYPE_NULL:
-       case CONSTRAINT_TYPE_KINEMATIC: /* removed */
-               break;
-       case CONSTRAINT_TYPE_PYTHON:
-               {
-                       bPythonConstraint *data;
-                       
-                       data = constraint->data;
-                       BPY_pyconstraint_eval(data, ownermat, targetmat);
-               } 
-               break;
-       case CONSTRAINT_TYPE_ACTION:
-               {
-                       bActionConstraint *data;
-                       float temp[4][4];
-                       
-                       data = constraint->data;
-                       Mat4CpyMat4(temp, ownermat);
-                       
-                       Mat4MulMat4(ownermat, targetmat, temp);
-               }
-               break;
-       case CONSTRAINT_TYPE_LOCLIKE:
-               {
-                       bLocateLikeConstraint *data;
-                       float offset[3] = {0.0f, 0.0f, 0.0f};
+               /* the following macro is used for all standard single-target constraints */
+               SINGLETARGET_FLUSH_TARS(con, data, ct, list, nocopy)
+       }
+}
 
-                       data = constraint->data;
-                       
-                       if (data->flag & LOCLIKE_OFFSET)
-                               VECCOPY(offset, ownermat[3]);
+static void loclike_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstraintTarget *ct, float ctime)
+{
+       bLocateLikeConstraint *data = con->data;
+
+       if (VALID_CONS_TARGET(ct)) {
+               if (ct->tar->type==OB_ARMATURE && strlen(ct->subtarget)) {
+                       /* Pose-Channels for the CopyLoc target are handled specially, so that
+                        * we can support using the bone-tip as an option.
+                        */
+                       bPoseChannel *pchan;
+                       float tmat[4][4];
                        
-                       if (data->flag & LOCLIKE_X) {
-                               ownermat[3][0] = targetmat[3][0];
-                               
-                               if(data->flag & LOCLIKE_X_INVERT) ownermat[3][0] *= -1;
-                               ownermat[3][0] += offset[0];
-                       }
-                       if (data->flag & LOCLIKE_Y) {
-                               ownermat[3][1] = targetmat[3][1];
+                       pchan = get_pose_channel(ct->tar->pose, ct->subtarget);
+                       if (pchan) {
+                               Mat4CpyMat4(tmat, pchan->pose_mat);
                                
-                               if(data->flag & LOCLIKE_Y_INVERT) ownermat[3][1] *= -1;
-                               ownermat[3][1] += offset[1];
+                               if (data->flag & LOCLIKE_TIP) { 
+                                       VECCOPY(tmat[3], pchan->pose_tail);
+                               }
+                                       
+                               Mat4MulMat4(ct->matrix, tmat, ct->tar->obmat);
                        }
-                       if (data->flag & LOCLIKE_Z) {
-                               ownermat[3][2] = targetmat[3][2];
+                       else 
+                               Mat4CpyMat4(ct->matrix, ct->tar->obmat);
                                
-                               if(data->flag & LOCLIKE_Z_INVERT) ownermat[3][2] *= -1;
-                               ownermat[3][2] += offset[2];
-                       }
+                       /* convert matrix space as required  */
+                       constraint_mat_convertspace(ct->tar, pchan, ct->matrix, CONSTRAINT_SPACE_WORLD, ct->space);
                }
-               break;
-       case CONSTRAINT_TYPE_ROTLIKE:
-               {
-                       bRotateLikeConstraint *data;
-                       float   loc[3];
-                       float   eul[3], obeul[3];
-                       float   size[3];
-                       
-                       data = constraint->data;
-                       
-                       VECCOPY(loc, ownermat[3]);
-                       Mat4ToSize(ownermat, size);
-                       
-                       Mat4ToEul(targetmat, eul);
-                       Mat4ToEul(ownermat, obeul);
-                       
-                       if ((data->flag & ROTLIKE_X)==0) {
-                               eul[0] = obeul[0];
-                       }
-                       else if (data->flag & ROTLIKE_X_INVERT) {
-                               eul[0] *= -1;
-                       }       
-                       
-                       if ((data->flag & ROTLIKE_Y)==0) {
-                               eul[1] = obeul[1];
-                       }
-                       else if (data->flag & ROTLIKE_Y_INVERT) {
-                               eul[1] *= -1;
-                       }
-                       
-                       if ((data->flag & ROTLIKE_Z)==0) {
-                               eul[2] = obeul[2];
-                       }
-                       else if (data->flag & ROTLIKE_Z_INVERT) {
-                               eul[2] *= -1;
-                       }
-                       
-                       compatible_eul(eul, obeul);
-                       LocEulSizeToMat4(ownermat, loc, eul, size);
+               else {
+                       /* get target matrix as is done normally for other constraints */
+                       constraint_target_to_mat4(ct->tar, ct->subtarget, ct->matrix, CONSTRAINT_SPACE_WORLD, ct->space);
                }
-               break;
-       case CONSTRAINT_TYPE_SIZELIKE:
-               {
-                       bSizeLikeConstraint *data;
-                       float obsize[3], size[3];
-                       
-                       data = constraint->data;
-                       Mat4ToSize(targetmat, size);
-                       Mat4ToSize(ownermat, obsize);
-                       
-                       if ((data->flag & SIZELIKE_X) && obsize[0] != 0)
-                               VecMulf(ownermat[0], size[0] / obsize[0]);
-                       if ((data->flag & SIZELIKE_Y) && obsize[1] != 0)
-                               VecMulf(ownermat[1], size[1] / obsize[1]);
-                       if ((data->flag & SIZELIKE_Z) && obsize[2] != 0)
-                               VecMulf(ownermat[2], size[2] / obsize[2]);
-               }
-               break;
-       case CONSTRAINT_TYPE_MINMAX:
-               {
-                       bMinMaxConstraint *data;
-                       float obmat[4][4], imat[4][4], tarmat[4][4], tmat[4][4];
-                       float val1, val2;
-                       int index;
-                       
-                       data = constraint->data;
+       }
+       else if (ct)
+               Mat4One(ct->matrix);
+}
+
+static void loclike_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets)
+{
+       bLocateLikeConstraint *data= con->data;
+       bConstraintTarget *ct= targets->first;
+       
+       if (VALID_CONS_TARGET(ct)) {
+               float offset[3] = {0.0f, 0.0f, 0.0f};
+               
+               if (data->flag & LOCLIKE_OFFSET)
+                       VECCOPY(offset, cob->matrix[3]);
                        
-                       Mat4CpyMat4(obmat, ownermat);
-                       Mat4CpyMat4(tarmat, targetmat);
+               if (data->flag & LOCLIKE_X) {
+                       cob->matrix[3][0] = ct->matrix[3][0];
                        
-                       if (data->flag & MINMAX_USEROT) {
-                               /* take rotation of target into account by doing the transaction in target's localspace */
-                               Mat4Invert(imat, tarmat);
-                               Mat4MulMat4(tmat, obmat, imat);
-                               Mat4CpyMat4(obmat, tmat);
-                               Mat4One(tarmat);
-                       }
+                       if (data->flag & LOCLIKE_X_INVERT) cob->matrix[3][0] *= -1;
+                       cob->matrix[3][0] += offset[0];
+               }
+               if (data->flag & LOCLIKE_Y) {
+                       cob->matrix[3][1] = ct->matrix[3][1];
                        
-                       switch (data->minmaxflag) {
-                       case TRACK_Z:
-                               val1 = tarmat[3][2];
-                               val2 = obmat[3][2]-data->offset;
-                               index = 2;
-                               break;
-                       case TRACK_Y:
-                               val1 = tarmat[3][1];
-                               val2 = obmat[3][1]-data->offset;
-                               index = 1;
-                               break;
-                       case TRACK_X:
-                               val1 = tarmat[3][0];
-                               val2 = obmat[3][0]-data->offset;
-                               index = 0;
-                               break;
-                       case TRACK_nZ:
-                               val2 = tarmat[3][2];
-                               val1 = obmat[3][2]-data->offset;
-                               index = 2;
-                               break;
-                       case TRACK_nY:
-                               val2 = tarmat[3][1];
-                               val1 = obmat[3][1]-data->offset;
-                               index = 1;
-                               break;
-                       case TRACK_nX:
-                               val2 = tarmat[3][0];
-                               val1 = obmat[3][0]-data->offset;
-                               index = 0;
-                               break;
-                       default:
-                               return;
-                       }
+                       if (data->flag & LOCLIKE_Y_INVERT) cob->matrix[3][1] *= -1;
+                       cob->matrix[3][1] += offset[1];
+               }
+               if (data->flag & LOCLIKE_Z) {
+                       cob->matrix[3][2] = ct->matrix[3][2];
                        
-                       if (val1 > val2) {
-                               obmat[3][index] = tarmat[3][index] + data->offset;
-                               if (data->flag & MINMAX_STICKY) {
-                                       if (data->flag & MINMAX_STUCK) {
-                                               VECCOPY(obmat[3], data->cache);
-                                       } 
-                                       else {
-                                               VECCOPY(data->cache, obmat[3]);
-                                               data->flag |= MINMAX_STUCK;
-                                       }
-                               }
-                               if (data->flag & MINMAX_USEROT) {
-                                       /* get out of localspace */
-                                       Mat4MulMat4(tmat, obmat, targetmat);
-                                       Mat4CpyMat4(ownermat, tmat);
-                               } 
-                               else {                  
-                                       VECCOPY(ownermat[3], obmat[3]);
-                               }
-                       } 
-                       else {
-                               data->flag &= ~MINMAX_STUCK;
-                       }
+                       if (data->flag & LOCLIKE_Z_INVERT) cob->matrix[3][2] *= -1;
+                       cob->matrix[3][2] += offset[2];
                }
-               break;
-       case CONSTRAINT_TYPE_TRACKTO:
-               {
-                       bTrackToConstraint *data;
-                       float size[3], vec[3];
-                       float totmat[3][3];
-                       float tmat[4][4];
+       }
+}
 
-                       data = constraint->data;                        
+static bConstraintTypeInfo CTI_LOCLIKE = {
+       CONSTRAINT_TYPE_LOCLIKE, /* type */
+       sizeof(bLocateLikeConstraint), /* size */
+       "Copy Location", /* name */
+       "bLocateLikeConstraint", /* struct name */
+       NULL, /* free data */
+       NULL, /* relink data */
+       NULL, /* copy data */
+       loclike_new_data, /* new data */
+       loclike_get_tars, /* get constraint targets */
+       loclike_flush_tars, /* flush constraint targets */
+       loclike_get_tarmat, /* get target matrix */
+       loclike_evaluate /* evaluate */
+};
+
+/* ----------- Copy Rotation ------------- */
+
+static void rotlike_new_data (void *cdata)
+{
+       bRotateLikeConstraint *data= (bRotateLikeConstraint *)cdata;
+       
+       data->flag = ROTLIKE_X|ROTLIKE_Y|ROTLIKE_Z;
+}
+
+static void rotlike_get_tars (bConstraint *con, ListBase *list)
+{
+       if (con && list) {
+               bRotateLikeConstraint *data= con->data;
+               bConstraintTarget *ct;
+               
+               /* standard target-getting macro for single-target constraints */
+               SINGLETARGET_GET_TARS(con, data, ct, list)
+       }
+}
+
+static void rotlike_flush_tars (bConstraint *con, ListBase *list, short nocopy)
+{
+       if (con && list) {
+               bRotateLikeConstraint *data= con->data;
+               bConstraintTarget *ct= list->first;
+               
+               /* the following macro is used for all standard single-target constraints */
+               SINGLETARGET_FLUSH_TARS(con, data, ct, list, nocopy)
+       }
+}
+
+static void rotlike_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets)
+{
+       bRotateLikeConstraint *data= con->data;
+       bConstraintTarget *ct= targets->first;
+       
+       if (VALID_CONS_TARGET(ct)) {
+               float   loc[3];
+               float   eul[3], obeul[3];
+               float   size[3];
+               
+               VECCOPY(loc, cob->matrix[3]);
+               Mat4ToSize(cob->matrix, size);
+               
+               Mat4ToEul(ct->matrix, eul);
+               Mat4ToEul(cob->matrix, obeul);
+               
+               if ((data->flag & ROTLIKE_X)==0) {
+                       eul[0] = obeul[0];
+               }
+               else if (data->flag & ROTLIKE_X_INVERT) {
+                       eul[0] *= -1;
+               }       
+               
+               if ((data->flag & ROTLIKE_Y)==0) {
+                       eul[1] = obeul[1];
+               }
+               else if (data->flag & ROTLIKE_Y_INVERT) {
+                       eul[1] *= -1;
+               }
+               
+               if ((data->flag & ROTLIKE_Z)==0) {
+                       eul[2] = obeul[2];
+               }
+               else if (data->flag & ROTLIKE_Z_INVERT) {
+                       eul[2] *= -1;
+               }
+               
+               compatible_eul(eul, obeul);
+               LocEulSizeToMat4(cob->matrix, loc, eul, size);
+       }
+}
+
+static bConstraintTypeInfo CTI_ROTLIKE = {
+       CONSTRAINT_TYPE_ROTLIKE, /* type */
+       sizeof(bRotateLikeConstraint), /* size */
+       "Copy Rotation", /* name */
+       "bRotateLikeConstraint", /* struct name */
+       NULL, /* free data */
+       NULL, /* relink data */
+       NULL, /* copy data */
+       rotlike_new_data, /* new data */
+       rotlike_get_tars, /* get constraint targets */
+       rotlike_flush_tars, /* flush constraint targets */
+       default_get_tarmat, /* get target matrix */
+       rotlike_evaluate /* evaluate */
+};
+
+/* ---------- Copy Scaling ---------- */
+
+static void sizelike_new_data (void *cdata)
+{
+       bSizeLikeConstraint *data= (bSizeLikeConstraint *)cdata;
+       
+       data->flag = SIZELIKE_X|SIZELIKE_Y|SIZELIKE_Z;
+}
+
+static void sizelike_get_tars (bConstraint *con, ListBase *list)
+{
+       if (con && list) {
+               bSizeLikeConstraint *data= con->data;
+               bConstraintTarget *ct;
+               
+               /* standard target-getting macro for single-target constraints */
+               SINGLETARGET_GET_TARS(con, data, ct, list)
+       }
+}
+
+static void sizelike_flush_tars (bConstraint *con, ListBase *list, short nocopy)
+{
+       if (con && list) {
+               bSizeLikeConstraint *data= con->data;
+               bConstraintTarget *ct= list->first;
+               
+               /* the following macro is used for all standard single-target constraints */
+               SINGLETARGET_FLUSH_TARS(con, data, ct, list, nocopy)
+       }
+}
+
+static void sizelike_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets)
+{
+       bSizeLikeConstraint *data= con->data;
+       bConstraintTarget *ct= targets->first;
+       
+       if (VALID_CONS_TARGET(ct)) {
+               float obsize[3], size[3];
+               
+               Mat4ToSize(ct->matrix, size);
+               Mat4ToSize(cob->matrix, obsize);
+               
+               if ((data->flag & SIZELIKE_X) && obsize[0] != 0)
+                       VecMulf(cob->matrix[0], size[0] / obsize[0]);
+               if ((data->flag & SIZELIKE_Y) && obsize[1] != 0)
+                       VecMulf(cob->matrix[1], size[1] / obsize[1]);
+               if ((data->flag & SIZELIKE_Z) && obsize[2] != 0)
+                       VecMulf(cob->matrix[2], size[2] / obsize[2]);
+       }
+}
+
+static bConstraintTypeInfo CTI_SIZELIKE = {
+       CONSTRAINT_TYPE_SIZELIKE, /* type */
+       sizeof(bSizeLikeConstraint), /* size */
+       "Copy Scale", /* name */
+       "bSizeLikeConstraint", /* struct name */
+       NULL, /* free data */
+       NULL, /* relink data */
+       NULL, /* copy data */
+       sizelike_new_data, /* new data */
+       sizelike_get_tars, /* get constraint targets */
+       sizelike_flush_tars, /* flush constraint targets */
+       default_get_tarmat, /* get target matrix */
+       sizelike_evaluate /* evaluate */
+};
+
+/* ----------- Python Constraint -------------- */
+
+static void pycon_free (bConstraint *con)
+{
+       bPythonConstraint *data= con->data;
+       bConstraintTarget *ct;
+       
+       /* id-properties */
+       IDP_FreeProperty(data->prop);
+       MEM_freeN(data->prop);
+       
+       /* multiple targets */
+       while ( (ct = data->targets.first) ) 
+               MEM_freeN(ct);
+}      
+
+static void pycon_relink (bConstraint *con)
+{
+       bPythonConstraint *data= con->data;
+       
+       ID_NEW(data->text);
+}
+
+static void pycon_copy (bConstraint *con, bConstraint *srccon)
+{
+       bPythonConstraint *pycon = (bPythonConstraint *)con->data;
+       bPythonConstraint *opycon = (bPythonConstraint *)srccon->data;
+       
+       pycon->prop = IDP_CopyProperty(opycon->prop);
+       duplicatelist(&pycon->targets, &opycon->targets);
+}
+
+static void pycon_new_data (void *cdata)
+{
+       bPythonConstraint *data= (bPythonConstraint *)cdata;
+       
+       /* everything should be set correctly by calloc, except for the prop->type constant.*/
+       data->prop = MEM_callocN(sizeof(IDProperty), "PyConstraintProps");
+       data->prop->type = IDP_GROUP;
+}
+
+static void pycon_get_tars (bConstraint *con, ListBase *list)
+{
+       if (con && list) {
+               bPythonConstraint *data= con->data;
+               
+               list->first = data->targets.first;
+               list->last = data->targets.last;
+       }
+}
+
+/* Whether this approach is maintained remains to be seen (aligorith) */
+static void pycon_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstraintTarget *ct, float ctime)
+{
+       bPythonConstraint *data= con->data;
+       
+       if (VALID_CONS_TARGET(ct)) {
+               /* special exception for curves - depsgraph issues */
+               if (ct->tar->type == OB_CURVE) {
+                       Curve *cu= ct->tar->data;
                        
-                       if (data->tar) {
-                               /* Get size property, since ob->size is only the object's own relative size, not its global one */
-                               Mat4ToSize(ownermat, size);
-                               
-                               /* Clear the object's rotation */       
-                               ownermat[0][0]=size[0];
-                               ownermat[0][1]=0;
-                               ownermat[0][2]=0;
-                               ownermat[1][0]=0;
-                               ownermat[1][1]=size[1];
-                               ownermat[1][2]=0;
-                               ownermat[2][0]=0;
-                               ownermat[2][1]=0;
-                               ownermat[2][2]=size[2];
-                               
-                               /* targetmat[2] instead of ownermat[2] is passed to vectomat
-                                * for backwards compatability it seems... (Aligorith)
-                                */
-                               VecSubf(vec, ownermat[3], targetmat[3]);
-                               vectomat(vec, targetmat[2], 
-                                               (short)data->reserved1, (short)data->reserved2, 
-                                               data->flags, totmat);
-                               
-                               Mat4CpyMat4(tmat, ownermat);
-                               Mat4MulMat34(ownermat, totmat, tmat);
+                       /* this check is to make sure curve objects get updated on file load correctly.*/
+                       if (cu->path==NULL || cu->path->data==NULL) /* only happens on reload file, but violates depsgraph still... fix! */
+                               makeDispListCurveTypes(ct->tar, 0);                             
+               }
+               
+               /* firstly calculate the matrix the normal way, then let the py-function override
+                * this matrix if it needs to do so
+                */
+               constraint_target_to_mat4(ct->tar, ct->subtarget, ct->matrix, CONSTRAINT_SPACE_WORLD, ct->space);
+               BPY_pyconstraint_target(data, ct);
+       }
+       else if (ct)
+               Mat4One(ct->matrix);
+}
+
+static void pycon_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets)
+{
+       bPythonConstraint *data= con->data;
+       
+/* currently removed, until I this can be re-implemented for multiple targets */
+#if 0
+       /* Firstly, run the 'driver' function which has direct access to the objects involved 
+        * Technically, this is potentially dangerous as users may abuse this and cause dependency-problems,
+        * but it also allows certain 'clever' rigging hacks to work.
+        */
+       BPY_pyconstraint_driver(data, cob, targets);
+#endif
+       
+       /* Now, run the actual 'constraint' function, which should only access the matrices */
+       BPY_pyconstraint_eval(data, cob, targets);
+}
+
+static bConstraintTypeInfo CTI_PYTHON = {
+       CONSTRAINT_TYPE_PYTHON, /* type */
+       sizeof(bPythonConstraint), /* size */
+       "Script", /* name */
+       "bPythonConstraint", /* struct name */
+       pycon_free, /* free data */
+       pycon_relink, /* relink data */
+       pycon_copy, /* copy data */
+       pycon_new_data, /* new data */
+       pycon_get_tars, /* get constraint targets */
+       NULL, /* flush constraint targets */
+       pycon_get_tarmat, /* get target matrix */
+       pycon_evaluate /* evaluate */
+};
+
+/* -------- Action Constraint ----------- */
+
+static void actcon_relink (bConstraint *con)
+{
+       bActionConstraint *data= con->data;
+       ID_NEW(data->act);
+}
+
+static void actcon_new_data (void *cdata)
+{
+       bActionConstraint *data= (bActionConstraint *)cdata;
+       
+       /* set type to 20 (Loc X), as 0 is Rot X for backwards compatability */
+       data->type = 20;
+}
+
+static void actcon_get_tars (bConstraint *con, ListBase *list)
+{
+       if (con && list) {
+               bActionConstraint *data= con->data;
+               bConstraintTarget *ct;
+               
+               /* standard target-getting macro for single-target constraints */
+               SINGLETARGET_GET_TARS(con, data, ct, list)
+       }
+}
+
+static void actcon_flush_tars (bConstraint *con, ListBase *list, short nocopy)
+{
+       if (con && list) {
+               bActionConstraint *data= con->data;
+               bConstraintTarget *ct= list->first;
+               
+               /* the following macro is used for all standard single-target constraints */
+               SINGLETARGET_FLUSH_TARS(con, data, ct, list, nocopy)
+       }
+}
+
+static void actcon_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstraintTarget *ct, float ctime)
+{
+       extern void chan_calc_mat(bPoseChannel *chan);
+       bActionConstraint *data = con->data;
+       
+       if (VALID_CONS_TARGET(ct)) {
+               bPose *pose;
+               bPoseChannel *pchan, *tchan;
+               float tempmat[4][4], vec[3];
+               float s, t;
+               short axis;
+               
+               /* initialise return matrix */
+               Mat4One(ct->matrix);
+               
+               /* currently, only pose-channels are supported owners for action constraints, as
+                * the method for extracting the pose from the actions is currently hardcoded for 
+                * poses... this may change in the future
+                */
+               if (cob->type != CONSTRAINT_OBTYPE_BONE)
+                       return;
+               
+               /* get the transform matrix of the target */
+               constraint_target_to_mat4(ct->tar, ct->subtarget, tempmat, CONSTRAINT_SPACE_WORLD, ct->space);
+               
+               /* determine where in transform range target is */
+               /* data->type is mapped as follows for backwards compatability:
+                *      00,01,02        - rotation (it used to be like this)
+                *      10,11,12        - scaling
+                *      20,21,22        - location
+                */
+               if (data->type < 10) {
+                       /* extract rotation (is in whatever space target should be in) */
+                       Mat4ToEul(tempmat, vec);
+                       vec[0] *= (float)(180.0/M_PI);
+                       vec[1] *= (float)(180.0/M_PI);
+                       vec[2] *= (float)(180.0/M_PI);
+                       axis= data->type;
+               }
+               else if (data->type < 20) {
+                       /* extract scaling (is in whatever space target should be in) */
+                       Mat4ToSize(tempmat, vec);
+                       axis= data->type - 10;
+               }
+               else {
+                       /* extract location */
+                       VECCOPY(vec, tempmat[3]);
+                       axis= data->type - 20;
+               }
+               
+               /* Target defines the animation */
+               s = (vec[axis]-data->min) / (data->max-data->min);
+               CLAMP(s, 0, 1);
+               t = ( s * (data->end-data->start)) + data->start;
+               
+               /* Get the appropriate information from the action */
+                       /* a temporary pose is made for this... 
+                        * TODO: extend this to objects too
+                        */
+               pose = MEM_callocN(sizeof(bPose), "pose");
+               
+               pchan = cob->pchan;
+               tchan= verify_pose_channel(pose, pchan->name);
+               extract_pose_from_action(pose, data->act, t);
+               
+               chan_calc_mat(tchan);
+               
+               Mat4CpyMat4(ct->matrix, tchan->chan_mat);
+               
+               /* Clean up */
+               free_pose_channels(pose);
+               MEM_freeN(pose);
+       }
+}
+
+static void actcon_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets)
+{
+       bConstraintTarget *ct= targets->first;
+       
+       if (VALID_CONS_TARGET(ct)) {
+               float temp[4][4];
+               
+               /* Nice and simple... we just need to multiply the matrices, as the get_target_matrix
+                * function has already taken care of everything else.
+                */
+               Mat4CpyMat4(temp, cob->matrix);
+               Mat4MulMat4(cob->matrix, ct->matrix, temp);
+       }
+}
+
+static bConstraintTypeInfo CTI_ACTION = {
+       CONSTRAINT_TYPE_ACTION, /* type */
+       sizeof(bActionConstraint), /* size */
+       "Action", /* name */
+       "bActionConstraint", /* struct name */
+       NULL, /* free data */
+       actcon_relink, /* relink data */
+       NULL, /* copy data */
+       actcon_new_data, /* new data */
+       actcon_get_tars, /* get constraint targets */
+       actcon_flush_tars, /* flush constraint targets */
+       actcon_get_tarmat, /* get target matrix */
+       actcon_evaluate /* evaluate */
+};
+
+/* --------- Locked Track ---------- */
+
+static void locktrack_new_data (void *cdata)
+{
+       bLockTrackConstraint *data= (bLockTrackConstraint *)cdata;
+       
+       data->trackflag = TRACK_Y;
+                       data->lockflag = LOCK_Z;
+}      
+
+static void locktrack_get_tars (bConstraint *con, ListBase *list)
+{
+       if (con && list) {
+               bLockTrackConstraint *data= con->data;
+               bConstraintTarget *ct;
+               
+               /* the following macro is used for all standard single-target constraints */
+               SINGLETARGET_GET_TARS(con, data, ct, list)
+       }
+}
+
+static void locktrack_flush_tars (bConstraint *con, ListBase *list, short nocopy)
+{
+       if (con && list) {
+               bLockTrackConstraint *data= con->data;
+               bConstraintTarget *ct= list->first;
+               
+               /* the following macro is used for all standard single-target constraints */
+               SINGLETARGET_FLUSH_TARS(con, data, ct, list, nocopy)
+       }
+}
+
+static void locktrack_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets)
+{
+       bLockTrackConstraint *data= con->data;
+       bConstraintTarget *ct= targets->first;
+       
+       if (VALID_CONS_TARGET(ct)) {
+               float vec[3],vec2[3];
+               float totmat[3][3];
+               float tmpmat[3][3];
+               float invmat[3][3];
+               float tmat[4][4];
+               float mdet;
+               
+               /* Vector object -> target */
+               VecSubf(vec, ct->matrix[3], cob->matrix[3]);
+               switch (data->lockflag){
+               case LOCK_X: /* LOCK X */
+               {
+                       switch (data->trackflag) {
+                               case TRACK_Y: /* LOCK X TRACK Y */
+                               {
+                                       /* Projection of Vector on the plane */
+                                       Projf(vec2, vec, cob->matrix[0]);
+                                       VecSubf(totmat[1], vec, vec2);
+                                       Normalize(totmat[1]);
+                                       
+                                       /* the x axis is fixed */
+                                       totmat[0][0] = cob->matrix[0][0];
+                                       totmat[0][1] = cob->matrix[0][1];
+                                       totmat[0][2] = cob->matrix[0][2];
+                                       Normalize(totmat[0]);
+                                       
+                                       /* the z axis gets mapped onto a third orthogonal vector */
+                                       Crossf(totmat[2], totmat[0], totmat[1]);
+                               }
+                                       break;
+                               case TRACK_Z: /* LOCK X TRACK Z */
+                               {
+                                       /* Projection of Vector on the plane */
+                                       Projf(vec2, vec, cob->matrix[0]);
+                                       VecSubf(totmat[2], vec, vec2);
+                                       Normalize(totmat[2]);
+
+                                       /* the x axis is fixed */
+                                       totmat[0][0] = cob->matrix[0][0];
+                                       totmat[0][1] = cob->matrix[0][1];
+                                       totmat[0][2] = cob->matrix[0][2];
+                                       Normalize(totmat[0]);
+                       
+                                       /* the z axis gets mapped onto a third orthogonal vector */
+                                       Crossf(totmat[1], totmat[2], totmat[0]);
+                               }
+                                       break;
+                               case TRACK_nY: /* LOCK X TRACK -Y */
+                               {
+                                       /* Projection of Vector on the plane */
+                                       Projf(vec2, vec, cob->matrix[0]);
+                                       VecSubf(totmat[1], vec, vec2);
+                                       Normalize(totmat[1]);
+                                       VecMulf(totmat[1],-1);
+                                       
+                                       /* the x axis is fixed */
+                                       totmat[0][0] = cob->matrix[0][0];
+                                       totmat[0][1] = cob->matrix[0][1];
+                                       totmat[0][2] = cob->matrix[0][2];
+                                       Normalize(totmat[0]);
+                                       
+                                       /* the z axis gets mapped onto a third orthogonal vector */
+                                       Crossf(totmat[2], totmat[0], totmat[1]);
+                               }
+                                       break;
+                               case TRACK_nZ: /* LOCK X TRACK -Z */
+                               {
+                                       /* Projection of Vector on the plane */
+                                       Projf(vec2, vec, cob->matrix[0]);
+                                       VecSubf(totmat[2], vec, vec2);
+                                       Normalize(totmat[2]);
+                                       VecMulf(totmat[2],-1);
+                                               
+                                       /* the x axis is fixed */
+                                       totmat[0][0] = cob->matrix[0][0];
+                                       totmat[0][1] = cob->matrix[0][1];
+                                       totmat[0][2] = cob->matrix[0][2];
+                                       Normalize(totmat[0]);
+                                               
+                                       /* the z axis gets mapped onto a third orthogonal vector */
+                                       Crossf(totmat[1], totmat[2], totmat[0]);
+                               }
+                                       break;
+                               default:
+                               {
+                                       totmat[0][0] = 1;totmat[0][1] = 0;totmat[0][2] = 0;
+                                       totmat[1][0] = 0;totmat[1][1] = 1;totmat[1][2] = 0;
+                                       totmat[2][0] = 0;totmat[2][1] = 0;totmat[2][2] = 1;
+                               }
+                                       break;
                        }
                }
-               break;
-       case CONSTRAINT_TYPE_LOCKTRACK:
+                       break;
+               case LOCK_Y: /* LOCK Y */
                {
-                       bLockTrackConstraint *data;
-                       float vec[3],vec2[3];
-                       float totmat[3][3];
-                       float tmpmat[3][3];
-                       float invmat[3][3];
-                       float tmat[4][4];
-                       float mdet;
-
-                       data = constraint->data;                        
-                       
-                       if (data->tar) {
-                               /* Vector object -> target */
-                               VecSubf(vec, targetmat[3], ownermat[3]);
-                               switch (data->lockflag){
-                               case LOCK_X: /* LOCK X */
+                       switch (data->trackflag) {
+                               case TRACK_X: /* LOCK Y TRACK X */
                                {
-                                       switch (data->trackflag) {
-                                               case TRACK_Y: /* LOCK X TRACK Y */
-                                               {
-                                                       /* Projection of Vector on the plane */
-                                                       Projf(vec2, vec, ownermat[0]);
-                                                       VecSubf(totmat[1], vec, vec2);
-                                                       Normalize(totmat[1]);
-                                                       
-                                                       /* the x axis is fixed */
-                                                       totmat[0][0] = ownermat[0][0];
-                                                       totmat[0][1] = ownermat[0][1];
-                                                       totmat[0][2] = ownermat[0][2];
-                                                       Normalize(totmat[0]);
-                                                       
-                                                       /* the z axis gets mapped onto a third orthogonal vector */
-                                                       Crossf(totmat[2], totmat[0], totmat[1]);
-                                               }
-                                                       break;
-                                               case TRACK_Z: /* LOCK X TRACK Z */
-                                               {
-                                                       /* Projection of Vector on the plane */
-                                                       Projf(vec2, vec, ownermat[0]);
-                                                       VecSubf(totmat[2], vec, vec2);
-                                                       Normalize(totmat[2]);
-
-                                                       /* the x axis is fixed */
-                                                       totmat[0][0] = ownermat[0][0];
-                                                       totmat[0][1] = ownermat[0][1];
-                                                       totmat[0][2] = ownermat[0][2];
-                                                       Normalize(totmat[0]);
+                                       /* Projection of Vector on the plane */
+                                       Projf(vec2, vec, cob->matrix[1]);
+                                       VecSubf(totmat[0], vec, vec2);
+                                       Normalize(totmat[0]);
                                        
-                                                       /* the z axis gets mapped onto a third orthogonal vector */
-                                                       Crossf(totmat[1], totmat[2], totmat[0]);
-                                               }
-                                                       break;
-                                               case TRACK_nY: /* LOCK X TRACK -Y */
-                                               {
-                                                       /* Projection of Vector on the plane */
-                                                       Projf(vec2, vec, ownermat[0]);
-                                                       VecSubf(totmat[1], vec, vec2);
-                                                       Normalize(totmat[1]);
-                                                       VecMulf(totmat[1],-1);
-                                                       
-                                                       /* the x axis is fixed */
-                                                       totmat[0][0] = ownermat[0][0];
-                                                       totmat[0][1] = ownermat[0][1];
-                                                       totmat[0][2] = ownermat[0][2];
-                                                       Normalize(totmat[0]);
-                                                       
-                                                       /* the z axis gets mapped onto a third orthogonal vector */
-                                                       Crossf(totmat[2], totmat[0], totmat[1]);
-                                               }
-                                                       break;
-                                               case TRACK_nZ: /* LOCK X TRACK -Z */
-                                               {
-                                                       /* Projection of Vector on the plane */
-                                                       Projf(vec2, vec, ownermat[0]);
-                                                       VecSubf(totmat[2], vec, vec2);
-                                                       Normalize(totmat[2]);
-                                                       VecMulf(totmat[2],-1);
-                                                               
-                                                       /* the x axis is fixed */
-                                                       totmat[0][0] = ownermat[0][0];
-                                                       totmat[0][1] = ownermat[0][1];
-                                                       totmat[0][2] = ownermat[0][2];
-                                                       Normalize(totmat[0]);
-                                                               
-                                                       /* the z axis gets mapped onto a third orthogonal vector */
-                                                       Crossf(totmat[1], totmat[2], totmat[0]);
-                                               }
-                                                       break;
-                                               default:
-                                               {
-                                                       totmat[0][0] = 1;totmat[0][1] = 0;totmat[0][2] = 0;
-                                                       totmat[1][0] = 0;totmat[1][1] = 1;totmat[1][2] = 0;
-                                                       totmat[2][0] = 0;totmat[2][1] = 0;totmat[2][2] = 1;
-                                               }
-                                                       break;
-                                       }
+                                       /* the y axis is fixed */
+                                       totmat[1][0] = cob->matrix[1][0];
+                                       totmat[1][1] = cob->matrix[1][1];
+                                       totmat[1][2] = cob->matrix[1][2];
+                                       Normalize(totmat[1]);
+                                       
+                                       /* the z axis gets mapped onto a third orthogonal vector */
+                                       Crossf(totmat[2], totmat[0], totmat[1]);
                                }
                                        break;
-                               case LOCK_Y: /* LOCK Y */
+                               case TRACK_Z: /* LOCK Y TRACK Z */
                                {
-                                       switch (data->trackflag) {
-                                               case TRACK_X: /* LOCK Y TRACK X */
-                                               {
-                                                       /* Projection of Vector on the plane */
-                                                       Projf(vec2, vec, ownermat[1]);
-                                                       VecSubf(totmat[0], vec, vec2);
-                                                       Normalize(totmat[0]);
-                                                       
-                                                       /* the y axis is fixed */
-                                                       totmat[1][0] = ownermat[1][0];
-                                                       totmat[1][1] = ownermat[1][1];
-                                                       totmat[1][2] = ownermat[1][2];
-                                                       Normalize(totmat[1]);
-                                                       
-                                                       /* the z axis gets mapped onto a third orthogonal vector */
-                                                       Crossf(totmat[2], totmat[0], totmat[1]);
-                                               }
-                                                       break;
-                                               case TRACK_Z: /* LOCK Y TRACK Z */
-                                               {
-                                                       /* Projection of Vector on the plane */
-                                                       Projf(vec2, vec, ownermat[1]);
-                                                       VecSubf(totmat[2], vec, vec2);
-                                                       Normalize(totmat[2]);
-
-                                                       /* the y axis is fixed */
-                                                       totmat[1][0] = ownermat[1][0];
-                                                       totmat[1][1] = ownermat[1][1];
-                                                       totmat[1][2] = ownermat[1][2];
-                                                       Normalize(totmat[1]);
-                                                       
-                                                       /* the z axis gets mapped onto a third orthogonal vector */
-                                                       Crossf(totmat[0], totmat[1], totmat[2]);
-                                               }
-                                                       break;
-                                               case TRACK_nX: /* LOCK Y TRACK -X */
-                                               {
-                                                       /* Projection of Vector on the plane */
-                                                       Projf(vec2, vec, ownermat[1]);
-                                                       VecSubf(totmat[0], vec, vec2);
-                                                       Normalize(totmat[0]);
-                                                       VecMulf(totmat[0],-1);
-                                                       
-                                                       /* the y axis is fixed */
-                                                       totmat[1][0] = ownermat[1][0];
-                                                       totmat[1][1] = ownermat[1][1];
-                                                       totmat[1][2] = ownermat[1][2];
-                                                       Normalize(totmat[1]);
-                                                       
-                                                       /* the z axis gets mapped onto a third orthogonal vector */
-                                                       Crossf(totmat[2], totmat[0], totmat[1]);
-                                               }
-                                                       break;
-                                               case TRACK_nZ: /* LOCK Y TRACK -Z */
-                                               {
-                                                       /* Projection of Vector on the plane */
-                                                       Projf(vec2, vec, ownermat[1]);
-                                                       VecSubf(totmat[2], vec, vec2);
-                                                       Normalize(totmat[2]);
-                                                       VecMulf(totmat[2],-1);
-                                                       
-                                                       /* the y axis is fixed */
-                                                       totmat[1][0] = ownermat[1][0];
-                                                       totmat[1][1] = ownermat[1][1];
-                                                       totmat[1][2] = ownermat[1][2];
-                                                       Normalize(totmat[1]);
-                                                       
-                                                       /* the z axis gets mapped onto a third orthogonal vector */
-                                                       Crossf(totmat[0], totmat[1], totmat[2]);
-                                               }
-                                                       break;
-                                               default:
-                                               {
-                                                       totmat[0][0] = 1;totmat[0][1] = 0;totmat[0][2] = 0;
-                                                       totmat[1][0] = 0;totmat[1][1] = 1;totmat[1][2] = 0;
-                                                       totmat[2][0] = 0;totmat[2][1] = 0;totmat[2][2] = 1;
-                                               }
-                                                       break;
-                                       }
+                                       /* Projection of Vector on the plane */
+                                       Projf(vec2, vec, cob->matrix[1]);
+                                       VecSubf(totmat[2], vec, vec2);
+                                       Normalize(totmat[2]);
+
+                                       /* the y axis is fixed */
+                                       totmat[1][0] = cob->matrix[1][0];
+                                       totmat[1][1] = cob->matrix[1][1];
+                                       totmat[1][2] = cob->matrix[1][2];
+                                       Normalize(totmat[1]);
+                                       
+                                       /* the z axis gets mapped onto a third orthogonal vector */
+                                       Crossf(totmat[0], totmat[1], totmat[2]);
                                }
                                        break;
-                               case LOCK_Z: /* LOCK Z */
+                               case TRACK_nX: /* LOCK Y TRACK -X */
                                {
-                                       switch (data->trackflag) {
-                                               case TRACK_X: /* LOCK Z TRACK X */
-                                               {
-                                                       /* Projection of Vector on the plane */
-                                                       Projf(vec2, vec, ownermat[2]);
-                                                       VecSubf(totmat[0], vec, vec2);
-                                                       Normalize(totmat[0]);
-                                                       
-                                                       /* the z axis is fixed */
-                                                       totmat[2][0] = ownermat[2][0];
-                                                       totmat[2][1] = ownermat[2][1];
-                                                       totmat[2][2] = ownermat[2][2];
-                                                       Normalize(totmat[2]);
-                                                       
-                                                       /* the x axis gets mapped onto a third orthogonal vector */
-                                                       Crossf(totmat[1], totmat[2], totmat[0]);
-                                               }
-                                                       break;
-                                               case TRACK_Y: /* LOCK Z TRACK Y */
-                                               {
-                                                       /* Projection of Vector on the plane */
-                                                       Projf(vec2, vec, ownermat[2]);
-                                                       VecSubf(totmat[1], vec, vec2);
-                                                       Normalize(totmat[1]);
-                                                       
-                                                       /* the z axis is fixed */
-                                                       totmat[2][0] = ownermat[2][0];
-                                                       totmat[2][1] = ownermat[2][1];
-                                                       totmat[2][2] = ownermat[2][2];
-                                                       Normalize(totmat[2]);
-                                                               
-                                                       /* the x axis gets mapped onto a third orthogonal vector */
-                                                       Crossf(totmat[0], totmat[1], totmat[2]);
-                                               }
-                                                       break;
-                                               case TRACK_nX: /* LOCK Z TRACK -X */
-                                               {
-                                                       /* Projection of Vector on the plane */
-                                                       Projf(vec2, vec, ownermat[2]);
-                                                       VecSubf(totmat[0], vec, vec2);
-                                                       Normalize(totmat[0]);
-                                                       VecMulf(totmat[0],-1);
-                                                       
-                                                       /* the z axis is fixed */
-                                                       totmat[2][0] = ownermat[2][0];
-                                                       totmat[2][1] = ownermat[2][1];
-                                                       totmat[2][2] = ownermat[2][2];
-                                                       Normalize(totmat[2]);
-                                                       
-                                                       /* the x axis gets mapped onto a third orthogonal vector */
-                                                       Crossf(totmat[1], totmat[2], totmat[0]);
-                                               }
-                                                       break;
-                                               case TRACK_nY: /* LOCK Z TRACK -Y */
-                                               {
-                                                       /* Projection of Vector on the plane */
-                                                       Projf(vec2, vec, ownermat[2]);
-                                                       VecSubf(totmat[1], vec, vec2);
-                                                       Normalize(totmat[1]);
-                                                       VecMulf(totmat[1],-1);
-                                                       
-                                                       /* the z axis is fixed */
-                                                       totmat[2][0] = ownermat[2][0];
-                                                       totmat[2][1] = ownermat[2][1];
-                                                       totmat[2][2] = ownermat[2][2];
-                                                       Normalize(totmat[2]);
-                                                               
-                                                       /* the x axis gets mapped onto a third orthogonal vector */
-                                                       Crossf(totmat[0], totmat[1], totmat[2]);
-                                               }
-                                                       break;
-                                               default:
-                                               {
-                                                               totmat[0][0] = 1;totmat[0][1] = 0;totmat[0][2] = 0;
-                                                               totmat[1][0] = 0;totmat[1][1] = 1;totmat[1][2] = 0;
-                                                               totmat[2][0] = 0;totmat[2][1] = 0;totmat[2][2] = 1;
-                                               }
-                                                       break;
-                                       }
+                                       /* Projection of Vector on the plane */
+                                       Projf(vec2, vec, cob->matrix[1]);
+                                       VecSubf(totmat[0], vec, vec2);
+                                       Normalize(totmat[0]);
+                                       VecMulf(totmat[0],-1);
+                                       
+                                       /* the y axis is fixed */
+                                       totmat[1][0] = cob->matrix[1][0];
+                                       totmat[1][1] = cob->matrix[1][1];
+                                       totmat[1][2] = cob->matrix[1][2];
+                                       Normalize(totmat[1]);
+                                       
+                                       /* the z axis gets mapped onto a third orthogonal vector */
+                                       Crossf(totmat[2], totmat[0], totmat[1]);
+                               }
+                                       break;
+                               case TRACK_nZ: /* LOCK Y TRACK -Z */
+                               {
+                                       /* Projection of Vector on the plane */
+                                       Projf(vec2, vec, cob->matrix[1]);
+                                       VecSubf(totmat[2], vec, vec2);
+                                       Normalize(totmat[2]);
+                                       VecMulf(totmat[2],-1);
+                                       
+                                       /* the y axis is fixed */
+                                       totmat[1][0] = cob->matrix[1][0];
+                                       totmat[1][1] = cob->matrix[1][1];
+                                       totmat[1][2] = cob->matrix[1][2];
+                                       Normalize(totmat[1]);
+                                       
+                                       /* the z axis gets mapped onto a third orthogonal vector */
+                                       Crossf(totmat[0], totmat[1], totmat[2]);
+                               }
+                                       break;
+                               default:
+                               {
+                                       totmat[0][0] = 1;totmat[0][1] = 0;totmat[0][2] = 0;
+                                       totmat[1][0] = 0;totmat[1][1] = 1;totmat[1][2] = 0;
+                                       totmat[2][0] = 0;totmat[2][1] = 0;totmat[2][2] = 1;
+                               }
+                                       break;
+                       }
+               }
+                       break;
+               case LOCK_Z: /* LOCK Z */
+               {
+                       switch (data->trackflag) {
+                               case TRACK_X: /* LOCK Z TRACK X */
+                               {
+                                       /* Projection of Vector on the plane */
+                                       Projf(vec2, vec, cob->matrix[2]);
+                                       VecSubf(totmat[0], vec, vec2);
+                                       Normalize(totmat[0]);
+                                       
+                                       /* the z axis is fixed */
+                                       totmat[2][0] = cob->matrix[2][0];
+                                       totmat[2][1] = cob->matrix[2][1];
+                                       totmat[2][2] = cob->matrix[2][2];
+                                       Normalize(totmat[2]);
+                                       
+                                       /* the x axis gets mapped onto a third orthogonal vector */
+                                       Crossf(totmat[1], totmat[2], totmat[0]);
+                               }
+                                       break;
+                               case TRACK_Y: /* LOCK Z TRACK Y */
+                               {
+                                       /* Projection of Vector on the plane */
+                                       Projf(vec2, vec, cob->matrix[2]);
+                                       VecSubf(totmat[1], vec, vec2);
+                                       Normalize(totmat[1]);
+                                       
+                                       /* the z axis is fixed */
+                                       totmat[2][0] = cob->matrix[2][0];
+                                       totmat[2][1] = cob->matrix[2][1];
+                                       totmat[2][2] = cob->matrix[2][2];
+                                       Normalize(totmat[2]);
+                                               
+                                       /* the x axis gets mapped onto a third orthogonal vector */
+                                       Crossf(totmat[0], totmat[1], totmat[2]);
+                               }
+                                       break;
+                               case TRACK_nX: /* LOCK Z TRACK -X */
+                               {
+                                       /* Projection of Vector on the plane */
+                                       Projf(vec2, vec, cob->matrix[2]);
+                                       VecSubf(totmat[0], vec, vec2);
+                                       Normalize(totmat[0]);
+                                       VecMulf(totmat[0],-1);
+                                       
+                                       /* the z axis is fixed */
+                                       totmat[2][0] = cob->matrix[2][0];
+                                       totmat[2][1] = cob->matrix[2][1];
+                                       totmat[2][2] = cob->matrix[2][2];
+                                       Normalize(totmat[2]);
+                                       
+                                       /* the x axis gets mapped onto a third orthogonal vector */
+                                       Crossf(totmat[1], totmat[2], totmat[0]);
+                               }
+                                       break;
+                               case TRACK_nY: /* LOCK Z TRACK -Y */
+                               {
+                                       /* Projection of Vector on the plane */
+                                       Projf(vec2, vec, cob->matrix[2]);
+                                       VecSubf(totmat[1], vec, vec2);
+                                       Normalize(totmat[1]);
+                                       VecMulf(totmat[1],-1);
+                                       
+                                       /* the z axis is fixed */
+                                       totmat[2][0] = cob->matrix[2][0];
+                                       totmat[2][1] = cob->matrix[2][1];
+                                       totmat[2][2] = cob->matrix[2][2];
+                                       Normalize(totmat[2]);
+                                               
+                                       /* the x axis gets mapped onto a third orthogonal vector */
+                                       Crossf(totmat[0], totmat[1], totmat[2]);
                                }
                                        break;
                                default:
-                                       {
+                               {
                                                totmat[0][0] = 1;totmat[0][1] = 0;totmat[0][2] = 0;
                                                totmat[1][0] = 0;totmat[1][1] = 1;totmat[1][2] = 0;
                                                totmat[2][0] = 0;totmat[2][1] = 0;totmat[2][2] = 1;
+                               }
+                                       break;
+                       }
+               }
+                       break;
+               default:
+                       {
+                               totmat[0][0] = 1;totmat[0][1] = 0;totmat[0][2] = 0;
+                               totmat[1][0] = 0;totmat[1][1] = 1;totmat[1][2] = 0;
+                               totmat[2][0] = 0;totmat[2][1] = 0;totmat[2][2] = 1;
+                       }
+                       break;
+               }
+               /* Block to keep matrix heading */
+               tmpmat[0][0] = cob->matrix[0][0];tmpmat[0][1] = cob->matrix[0][1];tmpmat[0][2] = cob->matrix[0][2];
+               tmpmat[1][0] = cob->matrix[1][0];tmpmat[1][1] = cob->matrix[1][1];tmpmat[1][2] = cob->matrix[1][2];
+               tmpmat[2][0] = cob->matrix[2][0];tmpmat[2][1] = cob->matrix[2][1];tmpmat[2][2] = cob->matrix[2][2];
+               Normalize(tmpmat[0]);
+               Normalize(tmpmat[1]);
+               Normalize(tmpmat[2]);
+               Mat3Inv(invmat, tmpmat);
+               Mat3MulMat3(tmpmat, totmat, invmat);
+               totmat[0][0] = tmpmat[0][0];totmat[0][1] = tmpmat[0][1];totmat[0][2] = tmpmat[0][2];
+               totmat[1][0] = tmpmat[1][0];totmat[1][1] = tmpmat[1][1];totmat[1][2] = tmpmat[1][2];
+               totmat[2][0] = tmpmat[2][0];totmat[2][1] = tmpmat[2][1];totmat[2][2] = tmpmat[2][2];
+               
+               Mat4CpyMat4(tmat, cob->matrix);
+               
+               mdet = Det3x3(  totmat[0][0],totmat[0][1],totmat[0][2],
+                                               totmat[1][0],totmat[1][1],totmat[1][2],
+                                               totmat[2][0],totmat[2][1],totmat[2][2]);
+               if (mdet==0) {
+                       totmat[0][0] = 1;totmat[0][1] = 0;totmat[0][2] = 0;
+                       totmat[1][0] = 0;totmat[1][1] = 1;totmat[1][2] = 0;
+                       totmat[2][0] = 0;totmat[2][1] = 0;totmat[2][2] = 1;
+               }
+               
+               /* apply out transformaton to the object */
+               Mat4MulMat34(cob->matrix, totmat, tmat);
+       }
+}
+
+static bConstraintTypeInfo CTI_LOCKTRACK = {
+       CONSTRAINT_TYPE_LOCKTRACK, /* type */
+       sizeof(bLockTrackConstraint), /* size */
+       "Locked Track", /* name */
+       "bLockTrackConstraint", /* struct name */
+       NULL, /* free data */
+       NULL, /* relink data */
+       NULL, /* copy data */
+       locktrack_new_data, /* new data */
+       locktrack_get_tars, /* get constraint targets */
+       locktrack_flush_tars, /* flush constraint targets */
+       default_get_tarmat, /* get target matrix */
+       locktrack_evaluate /* evaluate */
+};
+
+/* ---------- Stretch To ------------ */
+
+static void stretchto_new_data (void *cdata)
+{
+       bStretchToConstraint *data= (bStretchToConstraint *)cdata;
+       
+       data->volmode = 0;
+       data->plane = 0;
+       data->orglength = 0.0; 
+       data->bulge = 1.0;
+}
+
+static void stretchto_get_tars (bConstraint *con, ListBase *list)
+{
+       if (con && list) {
+               bStretchToConstraint *data= con->data;
+               bConstraintTarget *ct;
+               
+               /* standard target-getting macro for single-target constraints */
+               SINGLETARGET_GET_TARS(con, data, ct, list)
+       }
+}
+
+static void stretchto_flush_tars (bConstraint *con, ListBase *list, short nocopy)
+{
+       if (con && list) {
+               bStretchToConstraint *data= con->data;
+               bConstraintTarget *ct= list->first;
+               
+               /* the following macro is used for all standard single-target constraints */
+               SINGLETARGET_FLUSH_TARS(con, data, ct, list, nocopy)
+       }
+}
+
+static void stretchto_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets)
+{
+       bStretchToConstraint *data= con->data;
+       bConstraintTarget *ct= targets->first;
+       
+       /* only evaluate if there is a target */
+       if (VALID_CONS_TARGET(ct)) {
+               float size[3], scale[3], vec[3], xx[3], zz[3], orth[3];
+               float totmat[3][3];
+               float tmat[4][4];
+               float dist;
+               
+               /* store scaling before destroying obmat */
+               Mat4ToSize(cob->matrix, size);
+               
+               /* store X orientation before destroying obmat */
+               xx[0] = cob->matrix[0][0];
+               xx[1] = cob->matrix[0][1];
+               xx[2] = cob->matrix[0][2];
+               Normalize(xx);
+               
+               /* store Z orientation before destroying obmat */
+               zz[0] = cob->matrix[2][0];
+               zz[1] = cob->matrix[2][1];
+               zz[2] = cob->matrix[2][2];
+               Normalize(zz);
+               
+               VecSubf(vec, cob->matrix[3], ct->matrix[3]);
+               vec[0] /= size[0];
+               vec[1] /= size[1];
+               vec[2] /= size[2];
+               
+               dist = Normalize(vec);
+               //dist = VecLenf( ob->obmat[3], targetmat[3]);
+               
+               /* data->orglength==0 occurs on first run, and after 'R' button is clicked */
+               if (data->orglength == 0)  
+                       data->orglength = dist;
+               if (data->bulge == 0) 
+                       data->bulge = 1.0;
+               
+               scale[1] = dist/data->orglength;
+               switch (data->volmode) {
+               /* volume preserving scaling */
+               case VOLUME_XZ :
+                       scale[0] = 1.0f - (float)sqrt(data->bulge) + (float)sqrt(data->bulge*(data->orglength/dist));
+                       scale[2] = scale[0];
+                       break;
+               case VOLUME_X:
+                       scale[0] = 1.0f + data->bulge * (data->orglength /dist - 1);
+                       scale[2] = 1.0;
+                       break;
+               case VOLUME_Z:
+                       scale[0] = 1.0;
+                       scale[2] = 1.0f + data->bulge * (data->orglength /dist - 1);
+                       break;
+                       /* don't care for volume */
+               case NO_VOLUME:
+                       scale[0] = 1.0;
+                       scale[2] = 1.0;
+                       break;
+               default: /* should not happen, but in case*/
+                       return;    
+               } /* switch (data->volmode) */
+
+               /* Clear the object's rotation and scale */
+               cob->matrix[0][0]=size[0]*scale[0];
+               cob->matrix[0][1]=0;
+               cob->matrix[0][2]=0;
+               cob->matrix[1][0]=0;
+               cob->matrix[1][1]=size[1]*scale[1];
+               cob->matrix[1][2]=0;
+               cob->matrix[2][0]=0;
+               cob->matrix[2][1]=0;
+               cob->matrix[2][2]=size[2]*scale[2];
+               
+               VecSubf(vec, cob->matrix[3], ct->matrix[3]);
+               Normalize(vec);
+               
+               /* new Y aligns  object target connection*/
+               totmat[1][0] = -vec[0];
+               totmat[1][1] = -vec[1];
+               totmat[1][2] = -vec[2];
+               switch (data->plane) {
+               case PLANE_X:
+                       /* build new Z vector */
+                       /* othogonal to "new Y" "old X! plane */
+                       Crossf(orth, vec, xx);
+                       Normalize(orth);
+                       
+                       /* new Z*/
+                       totmat[2][0] = orth[0];
+                       totmat[2][1] = orth[1];
+                       totmat[2][2] = orth[2];
+                       
+                       /* we decided to keep X plane*/
+                       Crossf(xx, orth, vec);
+                       Normalize(xx);
+                       totmat[0][0] = xx[0];
+                       totmat[0][1] = xx[1];
+                       totmat[0][2] = xx[2];
+                       break;
+               case PLANE_Z:
+                       /* build new X vector */
+                       /* othogonal to "new Y" "old Z! plane */
+                       Crossf(orth, vec, zz);
+                       Normalize(orth);
+                       
+                       /* new X */
+                       totmat[0][0] = -orth[0];
+                       totmat[0][1] = -orth[1];
+                       totmat[0][2] = -orth[2];
+                       
+                       /* we decided to keep Z */
+                       Crossf(zz, orth, vec);
+                       Normalize(zz);
+                       totmat[2][0] = zz[0];
+                       totmat[2][1] = zz[1];
+                       totmat[2][2] = zz[2];
+                       break;
+               } /* switch (data->plane) */
+               
+               Mat4CpyMat4(tmat, cob->matrix);
+               Mat4MulMat34(cob->matrix, totmat, tmat);
+       }
+}
+
+static bConstraintTypeInfo CTI_STRETCHTO = {
+       CONSTRAINT_TYPE_STRETCHTO, /* type */
+       sizeof(bStretchToConstraint), /* size */
+       "Stretch To", /* name */
+       "bStretchToConstraint", /* struct name */
+       NULL, /* free data */
+       NULL, /* relink data */
+       NULL, /* copy data */
+       stretchto_new_data, /* new data */
+       stretchto_get_tars, /* get constraint targets */
+       stretchto_flush_tars, /* flush constraint targets */
+       default_get_tarmat, /* get target matrix */
+       stretchto_evaluate /* evaluate */
+};
+
+/* ---------- Floor ------------ */
+
+static void minmax_new_data (void *cdata)
+{
+       bMinMaxConstraint *data= (bMinMaxConstraint *)cdata;
+       
+       data->minmaxflag = TRACK_Z;
+       data->offset = 0.0f;
+       data->cache[0] = data->cache[1] = data->cache[2] = 0.0f;
+       data->flag = 0;
+}
+
+static void minmax_get_tars (bConstraint *con, ListBase *list)
+{
+       if (con && list) {
+               bMinMaxConstraint *data= con->data;
+               bConstraintTarget *ct;
+               
+               /* standard target-getting macro for single-target constraints */
+               SINGLETARGET_GET_TARS(con, data, ct, list)
+       }
+}
+
+static void minmax_flush_tars (bConstraint *con, ListBase *list, short nocopy)
+{
+       if (con && list) {
+               bMinMaxConstraint *data= con->data;
+               bConstraintTarget *ct= list->first;
+               
+               /* the following macro is used for all standard single-target constraints */
+               SINGLETARGET_FLUSH_TARS(con, data, ct, list, nocopy)
+       }
+}
+
+static void minmax_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets)
+{
+       bMinMaxConstraint *data= con->data;
+       bConstraintTarget *ct= targets->first;
+       
+       /* only evaluate if there is a target */
+       if (VALID_CONS_TARGET(ct)) {
+               float obmat[4][4], imat[4][4], tarmat[4][4], tmat[4][4];
+               float val1, val2;
+               int index;
+               
+               Mat4CpyMat4(obmat, cob->matrix);
+               Mat4CpyMat4(tarmat, ct->matrix);
+               
+               if (data->flag & MINMAX_USEROT) {
+                       /* take rotation of target into account by doing the transaction in target's localspace */
+                       Mat4Invert(imat, tarmat);
+                       Mat4MulMat4(tmat, obmat, imat);
+                       Mat4CpyMat4(obmat, tmat);
+                       Mat4One(tarmat);
+               }
+               
+               switch (data->minmaxflag) {
+               case TRACK_Z:
+                       val1 = tarmat[3][2];
+                       val2 = obmat[3][2]-data->offset;
+                       index = 2;
+                       break;
+               case TRACK_Y:
+                       val1 = tarmat[3][1];
+                       val2 = obmat[3][1]-data->offset;
+                       index = 1;
+                       break;
+               case TRACK_X:
+                       val1 = tarmat[3][0];
+                       val2 = obmat[3][0]-data->offset;
+                       index = 0;
+                       break;
+               case TRACK_nZ:
+                       val2 = tarmat[3][2];
+                       val1 = obmat[3][2]-data->offset;
+                       index = 2;
+                       break;
+               case TRACK_nY:
+                       val2 = tarmat[3][1];
+                       val1 = obmat[3][1]-data->offset;
+                       index = 1;
+                       break;
+               case TRACK_nX:
+                       val2 = tarmat[3][0];
+                       val1 = obmat[3][0]-data->offset;
+                       index = 0;
+                       break;
+               default:
+                       return;
+               }
+               
+               if (val1 > val2) {
+                       obmat[3][index] = tarmat[3][index] + data->offset;
+                       if (data->flag & MINMAX_STICKY) {
+                               if (data->flag & MINMAX_STUCK) {
+                                       VECCOPY(obmat[3], data->cache);
+                               } 
+                               else {
+                                       VECCOPY(data->cache, obmat[3]);
+                                       data->flag |= MINMAX_STUCK;
+                               }
+                       }
+                       if (data->flag & MINMAX_USEROT) {
+                               /* get out of localspace */
+                               Mat4MulMat4(tmat, obmat, ct->matrix);
+                               Mat4CpyMat4(cob->matrix, tmat);
+                       } 
+                       else {                  
+                               VECCOPY(cob->matrix[3], obmat[3]);
+                       }
+               } 
+               else {
+                       data->flag &= ~MINMAX_STUCK;
+               }
+       }
+}
+
+static bConstraintTypeInfo CTI_MINMAX = {
+       CONSTRAINT_TYPE_MINMAX, /* type */
+       sizeof(bMinMaxConstraint), /* size */
+       "Floor", /* name */
+       "bMinMaxConstraint", /* struct name */
+       NULL, /* free data */
+       NULL, /* relink data */
+       NULL, /* copy data */
+       minmax_new_data, /* new data */
+       minmax_get_tars, /* get constraint targets */
+       minmax_flush_tars, /* flush constraint targets */
+       default_get_tarmat, /* get target matrix */
+       minmax_evaluate /* evaluate */
+};
+
+/* ------- RigidBody Joint ---------- */
+
+static void rbj_new_data (void *cdata)
+{
+       bRigidBodyJointConstraint *data= (bRigidBodyJointConstraint *)cdata;
+       
+       // removed code which set target of this constraint  
+    data->type=1;
+}
+
+static void rbj_get_tars (bConstraint *con, ListBase *list)
+{
+       if (con && list) {
+               bRigidBodyJointConstraint *data= con->data;
+               bConstraintTarget *ct;
+               
+               /* standard target-getting macro for single-target constraints without subtargets */
+               SINGLETARGETNS_GET_TARS(con, data, ct, list)
+       }
+}
+
+static void rbj_flush_tars (bConstraint *con, ListBase *list, short nocopy)
+{
+       if (con && list) {
+               bRigidBodyJointConstraint *data= con->data;
+               bConstraintTarget *ct= list->first;
+               
+               /* the following macro is used for all standard single-target constraints */
+               SINGLETARGETNS_FLUSH_TARS(con, data, ct, list, nocopy)
+       }
+}
+
+static bConstraintTypeInfo CTI_RIGIDBODYJOINT = {
+       CONSTRAINT_TYPE_RIGIDBODYJOINT, /* type */
+       sizeof(bRigidBodyJointConstraint), /* size */
+       "RigidBody Joint", /* name */
+       "bRigidBodyJointConstraint", /* struct name */
+       NULL, /* free data */
+       NULL, /* relink data */
+       NULL, /* copy data */
+       rbj_new_data, /* new data */
+       rbj_get_tars, /* get constraint targets */
+       rbj_flush_tars, /* flush constraint targets */
+       default_get_tarmat, /* get target matrix */
+       NULL /* evaluate - this is not solved here... is just an interface for game-engine */
+};
+
+/* -------- Clamp To ---------- */
+
+static void clampto_get_tars (bConstraint *con, ListBase *list)
+{
+       if (con && list) {
+               bClampToConstraint *data= con->data;
+               bConstraintTarget *ct;
+               
+               /* standard target-getting macro for single-target constraints without subtargets */
+               SINGLETARGETNS_GET_TARS(con, data, ct, list)
+       }
+}
+
+static void clampto_flush_tars (bConstraint *con, ListBase *list, short nocopy)
+{
+       if (con && list) {
+               bClampToConstraint *data= con->data;
+               bConstraintTarget *ct= list->first;
+               
+               /* the following macro is used for all standard single-target constraints */
+               SINGLETARGETNS_FLUSH_TARS(con, data, ct, list, nocopy)
+       }
+}
+
+static void clampto_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstraintTarget *ct, float ctime)
+{
+       if (VALID_CONS_TARGET(ct)) {
+               Curve *cu= ct->tar->data;
+               
+               /* note: when creating constraints that follow path, the curve gets the CU_PATH set now,
+                *              currently for paths to work it needs to go through the bevlist/displist system (ton) 
+                */
+               
+               /* only happens on reload file, but violates depsgraph still... fix! */
+               if (cu->path==NULL || cu->path->data==NULL) 
+                       makeDispListCurveTypes(ct->tar, 0);
+       }
+       
+       /* technically, this isn't really needed for evaluation, but we don't know what else
+        * might end up calling this...
+        */
+       if (ct)
+               Mat4One(ct->matrix);
+}
+
+static void clampto_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets)
+{
+       bClampToConstraint *data= con->data;
+       bConstraintTarget *ct= targets->first;
+       
+       /* only evaluate if there is a target and it is a curve */
+       if (VALID_CONS_TARGET(ct) && (ct->tar->type == OB_CURVE)) {
+               Curve *cu= data->tar->data;
+               float obmat[4][4], targetMatrix[4][4], ownLoc[3];
+               float curveMin[3], curveMax[3];
+               
+               Mat4CpyMat4(obmat, cob->matrix);
+               Mat4One(targetMatrix);
+               VECCOPY(ownLoc, obmat[3]);
+               
+               INIT_MINMAX(curveMin, curveMax)
+               minmax_object(ct->tar, curveMin, curveMax);
+               
+               /* get targetmatrix */
+               if (cu->path && cu->path->data) {
+                       float vec[4], dir[3], totmat[4][4];
+                       float curvetime;
+                       short clamp_axis;
+                       
+                       /* find best position on curve */
+                       /* 1. determine which axis to sample on? */
+                       if (data->flag == CLAMPTO_AUTO) {
+                               float size[3];
+                               VecSubf(size, curveMax, curveMin);
+                               
+                               /* find axis along which the bounding box has the greatest
+                                * extent. Otherwise, default to the x-axis, as that is quite
+                                * frequently used.
+                                */
+                               if ((size[2]>size[0]) && (size[2]>size[1]))
+                                       clamp_axis= CLAMPTO_Z - 1;
+                               else if ((size[1]>size[0]) && (size[1]>size[2]))
+                                       clamp_axis= CLAMPTO_Y - 1;
+                               else
+                                       clamp_axis = CLAMPTO_X - 1;
+                       }
+                       else 
+                               clamp_axis= data->flag - 1;
+                               
+                       /* 2. determine position relative to curve on a 0-1 scale based on bounding box */
+                       if (data->flag2 & CLAMPTO_CYCLIC) {
+                               /* cyclic, so offset within relative bounding box is used */
+                               float len= (curveMax[clamp_axis] - curveMin[clamp_axis]);
+                               float offset;
+                               
+                               /* find bounding-box range where target is located */
+                               if (ownLoc[clamp_axis] < curveMin[clamp_axis]) {
+                                       /* bounding-box range is before */
+                                       offset= curveMin[clamp_axis];
+                                       
+                                       while (ownLoc[clamp_axis] < offset)
+                                               offset -= len;
+                                       
+                                       /* now, we calculate as per normal, except using offset instead of curveMin[clamp_axis] */
+                                       curvetime = (ownLoc[clamp_axis] - offset) / (len);
+                               }
+                               else if (ownLoc[clamp_axis] > curveMax[clamp_axis]) {
+                                       /* bounding-box range is after */
+                                       offset= curveMax[clamp_axis];
+                                       
+                                       while (ownLoc[clamp_axis] > offset) {
+                                               if ((offset + len) > ownLoc[clamp_axis])
+                                                       break;
+                                               else
+                                                       offset += len;
                                        }
-                                       break;
+                                       
+                                       /* now, we calculate as per normal, except using offset instead of curveMax[clamp_axis] */
+                                       curvetime = (ownLoc[clamp_axis] - offset) / (len);
                                }
-                               /* Block to keep matrix heading */
-                               tmpmat[0][0] = ownermat[0][0];tmpmat[0][1] = ownermat[0][1];tmpmat[0][2] = ownermat[0][2];
-                               tmpmat[1][0] = ownermat[1][0];tmpmat[1][1] = ownermat[1][1];tmpmat[1][2] = ownermat[1][2];
-                               tmpmat[2][0] = ownermat[2][0];tmpmat[2][1] = ownermat[2][1];tmpmat[2][2] = ownermat[2][2];
-                               Normalize(tmpmat[0]);
-                               Normalize(tmpmat[1]);
-                               Normalize(tmpmat[2]);
-                               Mat3Inv(invmat,tmpmat);
-                               Mat3MulMat3(tmpmat, totmat, invmat);
-                               totmat[0][0] = tmpmat[0][0];totmat[0][1] = tmpmat[0][1];totmat[0][2] = tmpmat[0][2];
-                               totmat[1][0] = tmpmat[1][0];totmat[1][1] = tmpmat[1][1];totmat[1][2] = tmpmat[1][2];
-                               totmat[2][0] = tmpmat[2][0];totmat[2][1] = tmpmat[2][1];totmat[2][2] = tmpmat[2][2];
-                               
-                               Mat4CpyMat4(tmat, ownermat);
-                               
-                               mdet = Det3x3(  totmat[0][0],totmat[0][1],totmat[0][2],
-                                                               totmat[1][0],totmat[1][1],totmat[1][2],
-                                                               totmat[2][0],totmat[2][1],totmat[2][2]);
-                               if (mdet==0) {
-                                       totmat[0][0] = 1;totmat[0][1] = 0;totmat[0][2] = 0;
-                                       totmat[1][0] = 0;totmat[1][1] = 1;totmat[1][2] = 0;
-                                       totmat[2][0] = 0;totmat[2][1] = 0;totmat[2][2] = 1;
+                               else {
+                                       /* as the location falls within bounds, just calculate */
+                                       curvetime = (ownLoc[clamp_axis] - curveMin[clamp_axis]) / (len);
                                }
-                               
-                               /* apply out transformaton to the object */
-                               Mat4MulMat34(ownermat, totmat, tmat);
                        }
-               }
-               break;
-       case CONSTRAINT_TYPE_FOLLOWPATH:
-               {
-                       bFollowPathConstraint *data;
-                       float obmat[4][4];
-                       float size[3], obsize[3];
-                       
-                       data = constraint->data;                        
+                       else {
+                               /* no cyclic, so position is clamped to within the bounding box */
+                               if (ownLoc[clamp_axis] <= curveMin[clamp_axis])
+                                       curvetime = 0.0;
+                               else if (ownLoc[clamp_axis] >= curveMax[clamp_axis])
+                                       curvetime = 1.0;
+                               else
+                                       curvetime = (ownLoc[clamp_axis] - curveMin[clamp_axis]) / (curveMax[clamp_axis] - curveMin[clamp_axis]);
+                       }
                        
-                       if (data->tar) {
-                               /* get Object local transform (loc/rot/size) to determine transformation from path */
-                               //object_to_mat4(ob, obmat);
-                               Mat4CpyMat4(obmat, ownermat); // FIXME!!!
-                               
-                               /* get scaling of object before applying constraint */
-                               Mat4ToSize(ownermat, size);
-                               
-                               /* apply targetmat - containing location on path, and rotation */
-                               Mat4MulSerie(ownermat, targetmat, obmat, NULL, NULL, NULL, NULL, NULL, NULL);
+                       /* 3. position on curve */
+                       if (where_on_path(ct->tar, curvetime, vec, dir) ) {
+                               Mat4One(totmat);
+                               VECCOPY(totmat[3], vec);
                                
-                               /* un-apply scaling caused by path */
-                               Mat4ToSize(ownermat, obsize);
-                               if (obsize[0] != 0)
-                                       VecMulf(ownermat[0], size[0] / obsize[0]);
-                               if (obsize[1] != 0)
-                                       VecMulf(ownermat[1], size[1] / obsize[1]);
-                               if (obsize[2] != 0)
-                                       VecMulf(ownermat[2], size[2] / obsize[2]);
+                               Mat4MulSerie(targetMatrix, ct->tar->obmat, totmat, NULL, NULL, NULL, NULL, NULL, NULL);
                        }
                }
-               break;
-       case CONSTRAINT_TYPE_STRETCHTO:
-        {
-            bStretchToConstraint *data;
-            float size[3],scale[3],vec[3],xx[3],zz[3],orth[3];
-            float totmat[3][3];
-            float tmat[4][4];
-            float dist;
-                       
-            data = constraint->data;            
-            Mat4ToSize (ownermat, size);
-            
-            if (data->tar) {
-                /* store X orientation before destroying obmat */
-                xx[0] = ownermat[0][0];
-                xx[1] = ownermat[0][1];
-                xx[2] = ownermat[0][2];
-                Normalize(xx);
-                               
-                /* store Z orientation before destroying obmat */
-                zz[0] = ownermat[2][0];
-                zz[1] = ownermat[2][1];
-                zz[2] = ownermat[2][2];
-                Normalize(zz);
-                               
-                               VecSubf(vec, ownermat[3], targetmat[3]);
-                               vec[0] /= size[0];
-                               vec[1] /= size[1];
-                               vec[2] /= size[2];
-
-                               dist = Normalize(vec);
-                //dist = VecLenf( ob->obmat[3], targetmat[3]);
-
-                if (data->orglength == 0)  data->orglength = dist;
-                if (data->bulge == 0) data->bulge = 1.0;
-
-                scale[1] = dist/data->orglength;
-                switch (data->volmode) {
-                /* volume preserving scaling */
-                case VOLUME_XZ :
-                    scale[0] = 1.0f - (float)sqrt(data->bulge) + (float)sqrt(data->bulge*(data->orglength/dist));
-                    scale[2] = scale[0];
-                    break;
-                case VOLUME_X:
-                    scale[0] = 1.0f + data->bulge * (data->orglength /dist - 1);
-                    scale[2] = 1.0;
-                    break;
-                case VOLUME_Z:
-                    scale[0] = 1.0;
-                    scale[2] = 1.0f + data->bulge * (data->orglength /dist - 1);
-                    break;
-                    /* don't care for volume */
-                case NO_VOLUME:
-                    scale[0] = 1.0;
-                    scale[2] = 1.0;
-                    break;
-                default: /* should not happen, but in case*/
-                    return;    
-                } /* switch (data->volmode) */
-
-                /* Clear the object's rotation and scale */
-                               ownermat[0][0]=size[0]*scale[0];
-                               ownermat[0][1]=0;
-                               ownermat[0][2]=0;
-                               ownermat[1][0]=0;
-                               ownermat[1][1]=size[1]*scale[1];
-                               ownermat[1][2]=0;
-                               ownermat[2][0]=0;
-                               ownermat[2][1]=0;
-                               ownermat[2][2]=size[2]*scale[2];
-                
-                               VecSubf(vec, ownermat[3], targetmat[3]);
-                               Normalize(vec);
-                               
-                /* new Y aligns  object target connection*/
-                totmat[1][0] = -vec[0];
-                totmat[1][1] = -vec[1];
-                totmat[1][2] = -vec[2];
-                switch (data->plane) {
-                case PLANE_X:
-                    /* build new Z vector */
-                    /* othogonal to "new Y" "old X! plane */
-                    Crossf(orth, vec, xx);
-                    Normalize(orth);
-                    
-                    /* new Z*/
-                    totmat[2][0] = orth[0];
-                    totmat[2][1] = orth[1];
-                    totmat[2][2] = orth[2];
-                    
-                    /* we decided to keep X plane*/
-                    Crossf(xx, orth, vec);
-                    Normalize(xx);
-                    totmat[0][0] = xx[0];
-                    totmat[0][1] = xx[1];
-                    totmat[0][2] = xx[2];
-                    break;
-                case PLANE_Z:
-                    /* build new X vector */
-                    /* othogonal to "new Y" "old Z! plane */
-                    Crossf(orth, vec, zz);
-                    Normalize(orth);
-                    
-                    /* new X */
-                    totmat[0][0] = -orth[0];
-                    totmat[0][1] = -orth[1];
-                    totmat[0][2] = -orth[2];
-                    
-                    /* we decided to keep Z */
-                    Crossf(zz, orth, vec);
-                    Normalize(zz);
-                    totmat[2][0] = zz[0];
-                    totmat[2][1] = zz[1];
-                    totmat[2][2] = zz[2];
-                    break;
-                } /* switch (data->plane) */
-                
-                Mat4CpyMat4(tmat, ownermat);
-                               
-                Mat4MulMat34(ownermat, totmat, tmat);
-            }
-        }
-        break;
-       case CONSTRAINT_TYPE_LOCLIMIT:
-               {
-                       bLocLimitConstraint *data;
+               
+               /* obtain final object position */
+               VECCOPY(cob->matrix[3], targetMatrix[3]);
+       }
+}
 
-                       data = constraint->data;
-                       
-                       if (data->flag & LIMIT_XMIN) {
-                               if(ownermat[3][0] < data->xmin)
-                                       ownermat[3][0] = data->xmin;
-                       }
-                       if (data->flag & LIMIT_XMAX) {
-                               if (ownermat[3][0] > data->xmax)
-                                       ownermat[3][0] = data->xmax;
-                       }
-                       if (data->flag & LIMIT_YMIN) {
-                               if(ownermat[3][1] < data->ymin)
-                                       ownermat[3][1] = data->ymin;
-                       }
-                       if (data->flag & LIMIT_YMAX) {
-                               if (ownermat[3][1] > data->ymax)
-                                       ownermat[3][1] = data->ymax;
-                       }
-                       if (data->flag & LIMIT_ZMIN) {
-                               if(ownermat[3][2] < data->zmin) 
-                                       ownermat[3][2] = data->zmin;
-                       }
-                       if (data->flag & LIMIT_ZMAX) {
-                               if (ownermat[3][2] > data->zmax)
-                                       ownermat[3][2] = data->zmax;
-                       }
+static bConstraintTypeInfo CTI_CLAMPTO = {
+       CONSTRAINT_TYPE_CLAMPTO, /* type */
+       sizeof(bClampToConstraint), /* size */
+       "Clamp To", /* name */
+       "bClampToConstraint", /* struct name */
+       NULL, /* free data */
+       NULL, /* relink data */
+       NULL, /* copy data */
+       NULL, /* new data */
+       clampto_get_tars, /* get constraint targets */
+       clampto_flush_tars, /* flush constraint targets */
+       clampto_get_tarmat, /* get target matrix */
+       clampto_evaluate /* evaluate */
+};
+
+/* ---------- Transform Constraint ----------- */
+
+static void transform_new_data (void *cdata)
+{
+       bTransformConstraint *data= (bTransformConstraint *)cdata;
+       
+       data->map[0]= 0;
+       data->map[1]= 1;
+       data->map[2]= 2;
+}
+
+static void transform_get_tars (bConstraint *con, ListBase *list)
+{
+       if (con && list) {
+               bTransformConstraint *data= con->data;
+               bConstraintTarget *ct;
+               
+               /* standard target-getting macro for single-target constraints */
+               SINGLETARGET_GET_TARS(con, data, ct, list)
+       }
+}
+
+static void transform_flush_tars (bConstraint *con, ListBase *list, short nocopy)
+{
+       if (con && list) {
+               bTransformConstraint *data= con->data;
+               bConstraintTarget *ct= list->first;
+               
+               /* the following macro is used for all standard single-target constraints */
+               SINGLETARGET_FLUSH_TARS(con, data, ct, list, nocopy)
+       }
+}
+
+static void transform_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets)
+{
+       bTransformConstraint *data= con->data;
+       bConstraintTarget *ct= targets->first;
+       
+       /* only evaluate if there is a target */
+       if (VALID_CONS_TARGET(ct)) {
+               float loc[3], eul[3], size[3];
+               float dvec[3], sval[3];
+               short i;
+               
+               /* obtain target effect */
+               switch (data->from) {
+                       case 2: /* scale */
+                               Mat4ToSize(ct->matrix, dvec);
+                               break;
+                       case 1: /* rotation */
+                               Mat4ToEul(ct->matrix, dvec);
+                               break;
+                       default: /* location */
+                               VecCopyf(dvec, ct->matrix[3]);
+                               break;
                }
-               break;
-       case CONSTRAINT_TYPE_ROTLIMIT:
-               {
-                       bRotLimitConstraint *data;
-                       float loc[3];
-                       float eul[3];
-                       float size[3];
-                       
-                       data = constraint->data;
-                       
-                       VECCOPY(loc, ownermat[3]);
-                       Mat4ToSize(ownermat, size);
-                       
-                       Mat4ToEul(ownermat, eul);
-                       
-                       /* eulers: radians to degrees! */
-                       eul[0] = (eul[0] / M_PI * 180);
-                       eul[1] = (eul[1] / M_PI * 180);
-                       eul[2] = (eul[2] / M_PI * 180);
-                       
-                       /* limiting of euler values... */
-                       if (data->flag & LIMIT_XROT) {
-                               if (eul[0] < data->xmin) 
-                                       eul[0] = data->xmin;
-                                       
-                               if (eul[0] > data->xmax)
-                                       eul[0] = data->xmax;
-                       }
-                       if (data->flag & LIMIT_YROT) {
-                               if (eul[1] < data->ymin)
-                                       eul[1] = data->ymin;
-                                       
-                               if (eul[1] > data->ymax)
-                                       eul[1] = data->ymax;
-                       }
-                       if (data->flag & LIMIT_ZROT) {
-                               if (eul[2] < data->zmin)
-                                       eul[2] = data->zmin;
-                                       
-                               if (eul[2] > data->zmax)
-                                       eul[2] = data->zmax;
+               
+               /* extract components of owner's matrix */
+               VECCOPY(loc, cob->matrix[3]);
+               Mat4ToEul(cob->matrix, eul);
+               Mat4ToSize(cob->matrix, size);
+               
+               /* determine where in range current transforms lie */
+               if (data->expo) {
+                       for (i=0; i<3; i++) {
+                               if (data->from_max[i] - data->from_min[i])
+                                       sval[i]= (dvec[i] - data->from_min[i]) / (data->from_max[i] - data->from_min[i]);
+                               else
+                                       sval[i]= 0.0f;
                        }
-                               
-                       /* eulers: degrees to radians ! */
-                       eul[0] = (eul[0] / 180 * M_PI); 
-                       eul[1] = (eul[1] / 180 * M_PI);
-                       eul[2] = (eul[2] / 180 * M_PI);
-                       
-                       LocEulSizeToMat4(ownermat, loc, eul, size);
                }
-               break;
-       case CONSTRAINT_TYPE_SIZELIMIT:
-               {
-                       bSizeLimitConstraint *data;
-                       float obsize[3], size[3];
-                       
-                       data = constraint->data;
-                       
-                       Mat4ToSize(ownermat, size);
-                       Mat4ToSize(ownermat, obsize);
-                       
-                       if (data->flag & LIMIT_XMIN) {
-                               if (size[0] < data->xmin) 
-                                       size[0] = data->xmin;   
-                       }
-                       if (data->flag & LIMIT_XMAX) {
-                               if (size[0] > data->xmax) 
-                                       size[0] = data->xmax;
-                       }
-                       if (data->flag & LIMIT_YMIN) {
-                               if (size[1] < data->ymin) 
-                                       size[1] = data->ymin;   
-                       }
-                       if (data->flag & LIMIT_YMAX) {
-                               if (size[1] > data->ymax) 
-                                       size[1] = data->ymax;
-                       }
-                       if (data->flag & LIMIT_ZMIN) {
-                               if (size[2] < data->zmin) 
-                                       size[2] = data->zmin;   
-                       }
-                       if (data->flag & LIMIT_ZMAX) {
-                               if (size[2] > data->zmax) 
-                                       size[2] = data->zmax;
+               else {
+                       /* clamp transforms out of range */
+                       for (i=0; i<3; i++) {
+                               CLAMP(dvec[i], data->from_min[i], data->from_max[i]);
+                               if (data->from_max[i] - data->from_min[i])
+                                       sval[i]= (dvec[i] - data->from_min[i]) / (data->from_max[i] - data->from_min[i]);
+                               else
+                                       sval[i]= 0.0f;
                        }
-                       
-                       VecMulf(ownermat[0], size[0]/obsize[0]);
-                       VecMulf(ownermat[1], size[1]/obsize[1]);
-                       VecMulf(ownermat[2], size[2]/obsize[2]);
                }
-               break;
-       case CONSTRAINT_TYPE_RIGIDBODYJOINT:
-        {
-                       /* Do nothing. The GameEngine will take care of this.*/
-        }
-        break; 
-       case CONSTRAINT_TYPE_CLAMPTO:
-               {
-                       bClampToConstraint *data;
-                       Curve *cu;
-                       float obmat[4][4], targetMatrix[4][4], ownLoc[3];
-                       float curveMin[3], curveMax[3];
-                       
-                       data = constraint->data;
-                       
-                       /* prevent crash if user deletes curve */
-                       if ((data->tar == NULL) || (data->tar->type != OB_CURVE) ) 
-                               return;
-                       else
-                               cu= data->tar->data;
-                       
-                       Mat4CpyMat4(obmat, ownermat);
-                       Mat4One(targetMatrix);
-                       VECCOPY(ownLoc, obmat[3]);
-                       
-                       INIT_MINMAX(curveMin, curveMax)
-                       minmax_object(data->tar, curveMin, curveMax);
-                       
-                       /* get targetmatrix */
-                       if (cu->path && cu->path->data) {
-                               float vec[4], dir[3], totmat[4][4];
-                               float curvetime;
-                               short clamp_axis;
-                               
-                               /* find best position on curve */
-                               /* 1. determine which axis to sample on? */
-                               if (data->flag == CLAMPTO_AUTO) {
-                                       float size[3];
-                                       VecSubf(size, curveMax, curveMin);
-                                       
-                                       /* find axis along which the bounding box has the greatest
-                                        * extent. Otherwise, default to the x-axis, as that is quite
-                                        * frequently used.
-                                        */
-                                       if ((size[2]>size[0]) && (size[2]>size[1]))
-                                               clamp_axis= CLAMPTO_Z - 1;
-                                       else if ((size[1]>size[0]) && (size[1]>size[2]))
-                                               clamp_axis= CLAMPTO_Y - 1;
-                                       else
-                                               clamp_axis = CLAMPTO_X - 1;
-                               }
-                               else 
-                                       clamp_axis= data->flag - 1;
+               
+               /* convert radian<->degree */
+               if (data->from==1 && data->to==0) {
+                       /* from radians to degrees */
+                       for (i=0; i<3; i++) 
+                               sval[i] = sval[i] / M_PI * 180;
+               }
+               else if (data->from==0 && data->to==1) {
+                       /* from degrees to radians */
+                       for (i=0; i<3; i++) 
+                               sval[i] = sval[i] / 180 * M_PI;
+               }
+               
+               /* apply transforms */
+               switch (data->to) {
+                       case 2: /* scaling */
+                               for (i=0; i<3; i++)
+                                       size[i]= data->to_min[i] + (sval[data->map[i]] * (data->to_max[i] - data->to_min[i])); 
+                               break;
+                       case 1: /* rotation */
+                               for (i=0; i<3; i++) {
+                                       float tmin, tmax;
                                        
-                               /* 2. determine position relative to curve on a 0-1 scale based on bounding box */
-                               if (data->flag2 & CLAMPTO_CYCLIC) {
-                                       /* cyclic, so offset within relative bounding box is used */
-                                       float len= (curveMax[clamp_axis] - curveMin[clamp_axis]);
-                                       float offset;
+                                       /* convert destination min/max ranges from degrees to radians */
+                                       tmin= data->to_min[i] / M_PI * 180;
+                                       tmax= data->to_max[i] / M_PI * 180;
                                        
-                                       /* find bounding-box range where target is located */
-                                       if (ownLoc[clamp_axis] < curveMin[clamp_axis]) {
-                                               /* bounding-box range is before */
-                                               offset= curveMin[clamp_axis];
-                                               
-                                               while (ownLoc[clamp_axis] < offset)
-                                                       offset -= len;
-                                               
-                                               /* now, we calculate as per normal, except using offset instead of curveMin[clamp_axis] */
-                                               curvetime = (ownLoc[clamp_axis] - offset) / (len);
-                                       }
-                                       else if (ownLoc[clamp_axis] > curveMax[clamp_axis]) {
-                                               /* bounding-box range is after */
-                                               offset= curveMax[clamp_axis];
-                                               
-                                               while (ownLoc[clamp_axis] > offset) {
-                                                       if ((offset + len) > ownLoc[clamp_axis])
-                                                               break;
-                                                       else
-                                                               offset += len;
-                                               }
-                                               
-                                               /* now, we calculate as per normal, except using offset instead of curveMax[clamp_axis] */
-                                               curvetime = (ownLoc[clamp_axis] - offset) / (len);
-                                       }
-                                       else {
-                                               /* as the location falls within bounds, just calculate */
-                                               curvetime = (ownLoc[clamp_axis] - curveMin[clamp_axis]) / (len);
-                                       }
-                               }
-                               else {
-                                       /* no cyclic, so position is clamped to within the bounding box */
-                                       if (ownLoc[clamp_axis] <= curveMin[clamp_axis])
-                                               curvetime = 0.0;
-                                       else if (ownLoc[clamp_axis] >= curveMax[clamp_axis])
-                                               curvetime = 1.0;
-                                       else
-                                               curvetime = (ownLoc[clamp_axis] - curveMin[clamp_axis]) / (curveMax[clamp_axis] - curveMin[clamp_axis]);
+                                       eul[i]= tmin + (sval[data->map[i]] * (tmax - tmin)); 
                                }
+                               break;
+                       default: /* location */
+                               /* get new location */
+                               for (i=0; i<3; i++)
+                                       loc[i]= (data->to_min[i] + (sval[data->map[i]] * (data->to_max[i] - data->to_min[i])));
                                
-                               /* 3. position on curve */
-                               if(where_on_path(data->tar, curvetime, vec, dir) ) {
-                                       Mat4One(totmat);
-                                       VECCOPY(totmat[3], vec);
-                                       
-                                       Mat4MulSerie(targetMatrix, data->tar->obmat, totmat, NULL, NULL, NULL, NULL, NULL, NULL);
-                               }
-                       }
-                       
-                       /* obtain final object position */
-                       VECCOPY(ownermat[3], targetMatrix[3]);
+                               /* add original location back on (so that it can still be moved) */
+                               VecAddf(loc, cob->matrix[3], loc);
+                               break;
                }
-               break;
-       case CONSTRAINT_TYPE_CHILDOF: 
-               {
-                       bChildOfConstraint *data;
-                       
-                       data = constraint->data;
-                       
-                       /* only evaluate if there is a target */
-                       if (data->tar) {
-                               float parmat[4][4], invmat[4][4], tempmat[4][4];
-                               float loc[3], eul[3], size[3];
-                               float loco[3], eulo[3], sizo[3];
-                               
-                               /* get offset (parent-inverse) matrix */
-                               Mat4CpyMat4(invmat, data->invmat);
-                               
-                               /* extract components of both matrices */
-                               VECCOPY(loc, targetmat[3]);
-                               Mat4ToEul(targetmat, eul);
-                               Mat4ToSize(targetmat, size);
-                               
-                               VECCOPY(loco, invmat[3]);
-                               Mat4ToEul(invmat, eulo);
-                               Mat4ToSize(invmat, sizo);
-                               
-                               /* disable channels not enabled */
-                               if (!(data->flag & CHILDOF_LOCX)) loc[0]= loco[0]= 0.0f;
-                               if (!(data->flag & CHILDOF_LOCY)) loc[1]= loco[1]= 0.0f;
-                               if (!(data->flag & CHILDOF_LOCZ)) loc[2]= loco[2]= 0.0f;
-                               if (!(data->flag & CHILDOF_ROTX)) eul[0]= eulo[0]= 0.0f;
-                               if (!(data->flag & CHILDOF_ROTY)) eul[1]= eulo[1]= 0.0f;
-                               if (!(data->flag & CHILDOF_ROTZ)) eul[2]= eulo[2]= 0.0f;
-                               if (!(data->flag & CHILDOF_SIZEX)) size[0]= sizo[0]= 1.0f;
-                               if (!(data->flag & CHILDOF_SIZEY)) size[1]= sizo[1]= 1.0f;
-                               if (!(data->flag & CHILDOF_SIZEZ)) size[2]= sizo[2]= 1.0f;
-                               
-                               /* make new target mat and offset mat */
-                               LocEulSizeToMat4(targetmat, loc, eul, size);
-                               LocEulSizeToMat4(invmat, loco, eulo, sizo);
+               
+               /* apply to matrix */
+               LocEulSizeToMat4(cob->matrix, loc, eul, size);
+       }
+}
+
+static bConstraintTypeInfo CTI_TRANSFORM = {
+       CONSTRAINT_TYPE_TRANSFORM, /* type */
+       sizeof(bTransformConstraint), /* size */
+       "Transform", /* name */
+       "bTransformConstraint", /* struct name */
+       NULL, /* free data */
+       NULL, /* relink data */
+       NULL, /* copy data */
+       transform_new_data, /* new data */
+       transform_get_tars, /* get constraint targets */
+       transform_flush_tars, /* flush constraint targets */
+       default_get_tarmat, /* get a target matrix */
+       transform_evaluate /* evaluate */
+};
+
+/* ************************* Constraints Type-Info *************************** */
+/* All of the constraints api functions use bConstraintTypeInfo structs to carry out
+ * and operations that involve constraint specifc code.
+ */
+
+/* These globals only ever get directly accessed in this file */
+static bConstraintTypeInfo *constraintsTypeInfo[NUM_CONSTRAINT_TYPES];
+static short CTI_INIT= 1; /* when non-zero, the list needs to be updated */
+
+/* This function only gets called when CTI_INIT is non-zero */
+static void constraints_init_typeinfo () {
+       constraintsTypeInfo[0]=  NULL;                                  /* 'Null' Constraint */
+       constraintsTypeInfo[1]=  &CTI_CHILDOF;                  /* ChildOf Constraint */
+       constraintsTypeInfo[2]=  &CTI_TRACKTO;                  /* TrackTo Constraint */
+       constraintsTypeInfo[3]=  &CTI_KINEMATIC;                /* IK Constraint */
+       constraintsTypeInfo[4]=  &CTI_FOLLOWPATH;               /* Follow-Path Constraint */
+       constraintsTypeInfo[5]=  &CTI_ROTLIMIT;                 /* Limit Rotation Constraint */
+       constraintsTypeInfo[6]=  &CTI_LOCLIMIT;                 /* Limit Location Constraint */
+       constraintsTypeInfo[7]=  &CTI_SIZELIMIT;                /* Limit Scaling Constraint */
+       constraintsTypeInfo[8]=  &CTI_ROTLIKE;                  /* Copy Rotation Constraint */
+       constraintsTypeInfo[9]=  &CTI_LOCLIKE;                  /* Copy Location Constraint */
+       constraintsTypeInfo[10]= &CTI_SIZELIKE;                 /* Copy Scaling Constraint */
+       constraintsTypeInfo[11]= &CTI_PYTHON;                   /* Python/Script Constraint */
+       constraintsTypeInfo[12]= &CTI_ACTION;                   /* Action Constraint */
+       constraintsTypeInfo[13]= &CTI_LOCKTRACK;                /* Locked-Track Constraint */
+       constraintsTypeInfo[14]= NULL;                                  /* 'Distance Limit' Constraint */
+       constraintsTypeInfo[15]= &CTI_STRETCHTO;                /* StretchTo Constaint */ 
+       constraintsTypeInfo[16]= &CTI_MINMAX;                   /* Floor Constraint */
+       constraintsTypeInfo[17]= &CTI_RIGIDBODYJOINT;   /* RigidBody Constraint */
+       constraintsTypeInfo[18]= &CTI_CLAMPTO;                  /* ClampTo Constraint */        
+       constraintsTypeInfo[19]= &CTI_TRANSFORM;                /* Transformation Constraint */ 
+}
+
+/* This function should be used for getting the appropriate type-info when only
+ * a constraint type is known
+ */
+bConstraintTypeInfo *get_constraint_typeinfo (int type)
+{
+       /* initialise the type-info list? */
+       if (CTI_INIT) {
+               constraints_init_typeinfo();
+               CTI_INIT = 0;
+       }
+       
+       /* only return for valid types */
+       if ( (type >= CONSTRAINT_TYPE_NULL) && 
+                (type <= NUM_CONSTRAINT_TYPES ) ) 
+       {
+               /* there shouldn't be any segfaults here... */
+               return constraintsTypeInfo[type];
+       }
+       else {
+               printf("No valid constraint type-info data available. Type = %i \n", type);
+       }
+       
+       return NULL;
+} 
+/* This function should always be used to get the appropriate type-info, as it
+ * has checks which prevent segfaults in some weird cases.
+ */
+bConstraintTypeInfo *constraint_get_typeinfo (bConstraint *con)
+{
+       /* only return typeinfo for valid constraints */
+       if (con)
+               return get_constraint_typeinfo(con->type);
+       else
+               return NULL;
+}
+
+/* ************************* 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 *conlist)
+{
+       bConstraint *con;
+       
+       /* Free constraint data and also any extra data */
+       for (con= conlist->first; con; con= con->next) {
+               free_constraint_data(con);
+       }
+       
+       /* Free the whole list */
+       BLI_freelistN(conlist);
+}
+
+/* Reassign links that constraints have to other data (called during file loading?) */
+void relink_constraints (ListBase *conlist)
+{
+       bConstraint *con;
+       bConstraintTarget *ct;
+       
+       for (con= conlist->first; con; con= con->next) {
+               bConstraintTypeInfo *cti= constraint_get_typeinfo(con);
+               
+               if (cti) {
+                       /* relink any targets */
+                       if (cti->get_constraint_targets) {
+                               ListBase targets = {NULL, NULL};
                                
-                               /* multiply target (parent matrix) by offset (parent inverse) to get 
-                                * the effect of the parent that will be exherted on the owner
-                                */
-                               Mat4MulMat4(parmat, invmat, targetmat);
+                               cti->get_constraint_targets(con, &targets);
+                               for (ct= targets.first; ct; ct= ct->next) {
+                                       ID_NEW(ct->tar);
+                               }
                                
-                               /* now multiply the parent matrix by the owner matrix to get the 
-                                * the effect of this constraint (i.e.  owner is 'parented' to parent)
-                                */
-                               Mat4CpyMat4(tempmat, ownermat);
-                               Mat4MulMat4(ownermat, tempmat, parmat); 
+                               if (cti->flush_constraint_targets)
+                                       cti->flush_constraint_targets(con, &targets, 0);
                        }
-               }
-               break;
-       case CONSTRAINT_TYPE_TRANSFORM:
-               {
-                       bTransformConstraint *data;
                        
-                       data = constraint->data;
-                       
-                       /* only work if there is a target */
-                       if (data->tar) {
-                               float loc[3], eul[3], size[3];
-                               float dvec[3], sval[3];
-                               short i;
-                               
-                               /* obtain target effect */
-                               switch (data->from) {
-                                       case 2: /* scale */
-                                               Mat4ToSize(targetmat, dvec);
-                                               break;
-                                       case 1: /* rotation */
-                                               Mat4ToEul(targetmat, dvec);
-                                               break;
-                                       default: /* location */
-                                               VecCopyf(dvec, targetmat[3]);
-                                               break;
-                               }
-                               
-                               /* extract components of owner's matrix */
-                               VECCOPY(loc, ownermat[3]);
-                               Mat4ToEul(ownermat, eul);
-                               Mat4ToSize(ownermat, size);
-                               
-                               /* determine where in range current transforms lie */
-                               if (data->expo) {
-                                       for (i=0; i<3; i++) {
-                                               if (data->from_max[i] - data->from_min[i])
-                                                       sval[i]= (dvec[i] - data->from_min[i]) / (data->from_max[i] - data->from_min[i]);
-                                               else
-                                                       sval[i]= 0.0f;
-                                       }
+                       /* relink any other special data */
+                       if (cti->relink_data)
+                               cti->relink_data(con);
+               }
+       }
+}
+
+/* duplicate all of the constraints in a constraint stack */
+void copy_constraints (ListBase *dst, ListBase *src)
+{
+       bConstraint *con, *srccon;
+       
+       dst->first= dst->last= NULL;
+       duplicatelist(dst, src);
+       
+       for (con=dst->first, srccon=src->first; con; srccon=srccon->next, con=con->next) {
+               bConstraintTypeInfo *cti= constraint_get_typeinfo(con);
+               
+               /* make a new copy of the constraint's data */
+               con->data = MEM_dupallocN(con->data);
+               
+               /* only do specific constraints if required */
+               if (cti && cti->copy_data)
+                       cti->copy_data(con, srccon);
+       }
+}
+
+/* -------- Target-Matrix Stuff ------- */
+
+/* This function is a relic from the prior implementations of the constraints system, when all
+ * constraints either had one or no targets. It used to be called during the main constraint solving
+ * loop, but is now only used for the remaining cases for a few constraints. 
+ *
+ * None of the actual calculations of the matricies should be done here! Also, this function is 
+ * not to be used by any new constraints, particularly any that have multiple targets.
+ */
+void get_constraint_target_matrix (bConstraint *con, short ownertype, void *ownerdata, float mat[][4], float ctime)
+{
+       bConstraintTypeInfo *cti= constraint_get_typeinfo(con);
+       ListBase targets = {NULL, NULL};
+       bConstraintOb *cob;
+       bConstraintTarget *ct;
+       
+       if (cti && cti->get_constraint_targets) {
+               /* make 'constraint-ob' */
+               cob= MEM_callocN(sizeof(bConstraintOb), "tempConstraintOb");
+               cob->type= ownertype;
+               switch (ownertype) {
+                       case CONSTRAINT_OBTYPE_OBJECT: /* it is usually this case */
+                       {
+                               cob->ob= (Object *)ownerdata;
+                               cob->pchan= NULL;
+                               if (cob->ob) {
+                                       Mat4CpyMat4(cob->matrix, cob->ob->obmat);
+                                       Mat4CpyMat4(cob->startmat, cob->matrix);
                                }
                                else {
-                                       /* clamp transforms out of range */
-                                       for (i=0; i<3; i++) {
-                                               CLAMP(dvec[i], data->from_min[i], data->from_max[i]);
-                                               if (data->from_max[i] - data->from_min[i])
-                                                       sval[i]= (dvec[i] - data->from_min[i]) / (data->from_max[i] - data->from_min[i]);
-                                               else
-                                                       sval[i]= 0.0f;
-                                       }
+                                       Mat4One(cob->matrix);
+                                       Mat4One(cob->startmat);
                                }
-                               
-                               /* convert radian<->degree */
-                               if (data->from==1 && data->to==0) {
-                                       /* from radians to degrees */
-                                       for (i=0; i<3; i++) 
-                                               sval[i] = sval[i] / M_PI * 180;
-                               }
-                               else if (data->from==0 && data->to==1) {
-                                       /* from degrees to radians */
-                                       for (i=0; i<3; i++) 
-                                               sval[i] = sval[i] / 180 * M_PI;
+                       }       
+                               break;
+                       case CONSTRAINT_OBTYPE_BONE: /* this may occur in some cases */
+                       {
+                               cob->ob= NULL; /* this might not work at all :/ */
+                               cob->pchan= (bPoseChannel *)ownerdata;
+                               if (cob->pchan) {
+                                       Mat4CpyMat4(cob->matrix, cob->pchan->pose_mat);
+                                       Mat4CpyMat4(cob->startmat, cob->matrix);
                                }
-                               
-                               /* apply transforms */
-                               switch (data->to) {
-                                       case 2: /* scaling */
-                                               for (i=0; i<3; i++)
-                                                       size[i]= data->to_min[i] + (sval[data->map[i]] * (data->to_max[i] - data->to_min[i])); 
-                                               break;
-                                       case 1: /* rotation */
-                                               for (i=0; i<3; i++) {
-                                                       float tmin, tmax;
-                                                       
-                                                       /* convert destination min/max ranges from degrees to radians */
-                                                       tmin= data->to_min[i] / M_PI * 180;
-                                                       tmax= data->to_max[i] / M_PI * 180;
-                                                       
-                                                       eul[i]= tmin + (sval[data->map[i]] * (tmax - tmin)); 
-                                               }
-                                               break;
-                                       default: /* location */
-                                               /* get new location */
-                                               for (i=0; i<3; i++)
-                                                       loc[i]= (data->to_min[i] + (sval[data->map[i]] * (data->to_max[i] - data->to_min[i])));
-                                               
-                                               /* add original location back on (so that it can still be moved) */
-                                               VecAddf(loc, ownermat[3], loc);
-                                               break;
+                               else {
+                                       Mat4One(cob->matrix);
+                                       Mat4One(cob->startmat);
                                }
-                               
-                               /* apply to matrix */
-                               LocEulSizeToMat4(ownermat, loc, eul, size);
                        }
+                               break;
                }
-               break;
-       default:
-               printf("Error: Unknown constraint type\n");
-               break;
+               
+               /* get targets - we only need the first one though (and there should only be one) */
+               cti->get_constraint_targets(con, &targets);
+               
+               /* only calculate the target matrix on the first target */
+               ct= (bConstraintTarget *)targets.first;
+               if (ct) {
+                       if (cti->get_target_matrix)
+                               cti->get_target_matrix(con, cob, ct, ctime);
+                       Mat4CpyMat4(mat, ct->matrix);
+               }
+               
+               /* free targets + 'constraint-ob' */
+               if (cti->flush_constraint_targets)
+                       cti->flush_constraint_targets(con, &targets, 1);
+               MEM_freeN(cob);
+       }
+       else {
+               /* invalid constraint - perhaps... */
+               Mat4One(mat);
        }
 }
+/* ---------- Evaluation ----------- */
 
-/* this function is called whenever constraints need to be evaluated  */
+/* This function is called whenever constraints need to be evaluated. Currently, all
+ * constraints that can be evaluated are everytime this gets run.
+ *
+ * constraints_make_evalob and constraints_clear_evalob should be called before and 
+ * after running this function, to sort out cob
+ */
 void solve_constraints (ListBase *conlist, bConstraintOb *cob, float ctime)
 {
        bConstraint *con;
-       void *ownerdata;
-       float tarmat[4][4], oldmat[4][4];
-       float solution[4][4], delta[4][4], imat[4][4];
+       float solution[4][4], delta[4][4];
+       float oldmat[4][4], imat[4][4];
        float enf;
 
        /* check that there is a valid constraint object to evaluate */
@@ -2848,43 +3309,59 @@ void solve_constraints (ListBase *conlist, bConstraintOb *cob, float ctime)
        
        /* loop over available constraints, solving and blending them */
        for (con= conlist->first; con; con= con->next) {
-               /* this we can skip completely */
+               bConstraintTypeInfo *cti= constraint_get_typeinfo(con);
+               ListBase targets = {NULL, NULL};
+               
+               /* these we can skip completely (invalid constraints...) */
+               if (cti == NULL) continue;
                if (con->flag & CONSTRAINT_DISABLE) continue;
+               /* these constraints can't be evaluated anyway */
+               if (cti->evaluate_constraint == NULL) continue;
                /* influence == 0 should be ignored */
                if (con->enforce == 0.0f) continue;
-               /* and inverse kinematics is solved seperate */ 
-               if (con->type==CONSTRAINT_TYPE_KINEMATIC) continue;
-               /* rigidbody is really a game-engine thing - and is not solved here */
-               if (con->type==CONSTRAINT_TYPE_RIGIDBODYJOINT) continue;
                
-               /* influence of constraint */
-               /* value should have been set from IPO's/Constraint Channels already */
+               /* influence of constraint
+                *      - value should have been set from IPO's/Constraint Channels already 
+                */
                enf = con->enforce;
                
                /* move owner matrix into right space */
                constraint_mat_convertspace(cob->ob, cob->pchan, cob->matrix, CONSTRAINT_SPACE_WORLD, con->ownspace);
                Mat4CpyMat4(oldmat, cob->matrix);
                
-               /* get the target matrix - in right space to be used */
-               ownerdata= ((cob->pchan)? (void *)cob->pchan : (void *)cob->ob);
-               get_constraint_target_matrix(con, cob->type, ownerdata, tarmat, ctime);
-               
-               
-               /* Special Hack for PyConstraints to be able to set settings on the owner and/or
-                * target. Technically, this violates the design of constraints (as constraints should
-                * only act on matrices to alter the final transform of an owner), but on the other
-                * hand, this makes PyConstraints more powerful as it enables certain setups to be created
-                * and work reliably. 
-                */
-               if (con->type == CONSTRAINT_TYPE_PYTHON) {
-                       bPythonConstraint *pycon= (bPythonConstraint *)con->data;
+               /* prepare targets for constraint solving */
+               if (cti->get_constraint_targets) {
+                       bConstraintTarget *ct;
+                       
+                       /* get targets 
+                        *      - constraints should use ct->matrix, not directly accessing values
+                        *      - ct->matrix members have not yet been calculated here! 
+                        */
+                       cti->get_constraint_targets(con, &targets);
                        
-                       /* as usual, the function for this is defined in BPY_interface.c  */
-                       BPY_pyconstraint_driver(pycon, cob, pycon->tar, pycon->subtarget);
+                       /* set matrices 
+                        *      - calculate if possible, otherwise just initialise as identity matrix 
+                        */
+                       if (cti->get_target_matrix) {
+                               for (ct= targets.first; ct; ct= ct->next) 
+                                       cti->get_target_matrix(con, cob, ct, ctime);
+                       }
+                       else {
+                               for (ct= targets.first; ct; ct= ct->next)
+                                       Mat4One(ct->matrix);
+                       }
                }
                
                /* Solve the constraint */
-               evaluate_constraint(con, cob->matrix, tarmat);
+               cti->evaluate_constraint(con, cob, &targets);
+               
+               /* clear targets after use 
+                *      - this should free temp targets but no data should be copied back
+                *        as constraints may have done some nasty things to it...
+                */
+               if (cti->flush_constraint_targets) {
+                       cti->flush_constraint_targets(con, &targets, 1);
+               }
                
                /* Interpolate the enforcement, to blend result of constraint into final owner transform */
                /* 1. Remove effects of original matrix from constraint solution ==> delta */
@@ -2904,7 +3381,7 @@ void solve_constraints (ListBase *conlist, bConstraintOb *cob, float ctime)
                /* 3. Now multiply the delta by the matrix in use before the evaluation */
                Mat4MulMat4(cob->matrix, delta, oldmat);
                
-               /* move target/owner back into worldspace for next constraint/other business */
+               /* move owner back into worldspace for next constraint/other business */
                if ((con->flag & CONSTRAINT_SPACEONCE) == 0) 
                        constraint_mat_convertspace(cob->ob, cob->pchan, cob->matrix, con->ownspace, CONSTRAINT_SPACE_WORLD);
        }
index eb651a925e024acdcdfe620b6fde335d9fcb0fbc..fc7e6d61f8ad73081fb34d22163cd1756ecfe3fd 100644 (file)
@@ -368,27 +368,34 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Object *ob, int
                if (ob->pose){
                        bPoseChannel *pchan;
                        bConstraint *con;
-                       Object * target;
-                       char *subtarget;
                        
-                       for (pchan = ob->pose->chanbase.first; pchan; pchan=pchan->next){
-                               for (con = pchan->constraints.first; con; con=con->next){
-                                       if (constraint_has_target(con)) {
+                       for (pchan = ob->pose->chanbase.first; pchan; pchan=pchan->next) {
+                               for (con = pchan->constraints.first; con; con=con->next) {
+                                       bConstraintTypeInfo *cti= constraint_get_typeinfo(con);
+                                       ListBase targets = {NULL, NULL};
+                                       bConstraintTarget *ct;
+                                       
+                                       if (cti && cti->get_constraint_targets) {
+                                               cti->get_constraint_targets(con, &targets);
                                                
-                                               target = get_constraint_target(con, &subtarget);
-                                               if (target!=ob) {
-                                                       // fprintf(stderr,"armature %s target :%s \n", ob->id.name, target->id.name);
-                                                       node3 = dag_get_node(dag, target);
-                                                       
-                                                       if(subtarget && subtarget[0])
-                                                               dag_add_relation(dag,node3,node, DAG_RL_OB_DATA|DAG_RL_DATA_DATA);
-                                                       else if(ELEM(con->type, CONSTRAINT_TYPE_FOLLOWPATH, CONSTRAINT_TYPE_CLAMPTO))   
-                                                               dag_add_relation(dag,node3,node, DAG_RL_DATA_DATA|DAG_RL_OB_DATA);
-                                                       else
-                                                               dag_add_relation(dag,node3,node, DAG_RL_OB_DATA);
-                                                       
+                                               for (ct= targets.first; ct; ct= ct->next) {
+                                                       if (ct->tar != ob) {
+                                                               // fprintf(stderr,"armature %s target :%s \n", ob->id.name, target->id.name);
+                                                               node3 = dag_get_node(dag, ct->tar);
+                                                               
+                                                               if (ct->subtarget[0])
+                                                                       dag_add_relation(dag,node3,node, DAG_RL_OB_DATA|DAG_RL_DATA_DATA);
+                                                               else if(ELEM(con->type, CONSTRAINT_TYPE_FOLLOWPATH, CONSTRAINT_TYPE_CLAMPTO))   
+                                                                       dag_add_relation(dag,node3,node, DAG_RL_DATA_DATA|DAG_RL_OB_DATA);
+                                                               else
+                                                                       dag_add_relation(dag,node3,node, DAG_RL_OB_DATA);
+                                                       }
                                                }
+                                               
+                                               if (cti->flush_constraint_targets)
+                                                       cti->flush_constraint_targets(con, &targets, 1);
                                        }
+                                       
                                }
                        }
                }
@@ -581,20 +588,35 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Object *ob, int
        }
        
        for (con = ob->constraints.first; con; con=con->next) {
-               if (constraint_has_target(con)) {
-                       char *str;
-                       Object *obt= get_constraint_target(con, &str);
+               bConstraintTypeInfo *cti= constraint_get_typeinfo(con);
+               ListBase targets = {NULL, NULL};
+               bConstraintTarget *ct;
+               
+               if (cti && cti->get_constraint_targets) {
+                       cti->get_constraint_targets(con, &targets);
                        
-                       node2 = dag_get_node(dag, obt);
-                       if(ELEM(con->type, CONSTRAINT_TYPE_FOLLOWPATH, CONSTRAINT_TYPE_CLAMPTO))
-                               dag_add_relation(dag, node2, node, DAG_RL_DATA_OB|DAG_RL_OB_OB);
-                       else {
-                               if(ELEM3(obt->type, OB_ARMATURE, OB_MESH, OB_LATTICE) && str && str[0])
-                                       dag_add_relation(dag, node2, node, DAG_RL_DATA_OB|DAG_RL_OB_OB);
+                       for (ct= targets.first; ct; ct= ct->next) {
+                               Object *obt;
+                               
+                               if (ct->tar)
+                                       obt= ct->tar;
                                else
-                                       dag_add_relation(dag, node2, node, DAG_RL_OB_OB);
+                                       continue;
+                               
+                               node2 = dag_get_node(dag, obt);
+                               if (ELEM(con->type, CONSTRAINT_TYPE_FOLLOWPATH, CONSTRAINT_TYPE_CLAMPTO))
+                                       dag_add_relation(dag, node2, node, DAG_RL_DATA_OB|DAG_RL_OB_OB);
+                               else {
+                                       if (ELEM3(obt->type, OB_ARMATURE, OB_MESH, OB_LATTICE) && (ct->subtarget[0]))
+                                               dag_add_relation(dag, node2, node, DAG_RL_DATA_OB|DAG_RL_OB_OB);
+                                       else
+                                               dag_add_relation(dag, node2, node, DAG_RL_OB_OB);
+                               }
+                               addtoroot = 0;
                        }
-                       addtoroot = 0;
+                       
+                       if (cti->flush_constraint_targets)
+                               cti->flush_constraint_targets(con, &targets, 1);
                }
        }
 
@@ -1718,10 +1740,23 @@ static void dag_object_time_update_flags(Object *ob)
        if(ob->ipo)