Cleanup: comments (long lines) in blenkernel
[blender.git] / source / blender / blenkernel / intern / constraint.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include <stdio.h>
25 #include <stddef.h>
26 #include <string.h>
27 #include <math.h>
28 #include <float.h>
29
30 #include "MEM_guardedalloc.h"
31
32 #include "BLI_blenlib.h"
33 #include "BLI_math.h"
34 #include "BLI_kdopbvh.h"
35 #include "BLI_utildefines.h"
36 #include "BLI_string_utils.h"
37 #include "BLT_translation.h"
38
39 #include "DNA_armature_types.h"
40 #include "DNA_cachefile_types.h"
41 #include "DNA_constraint_types.h"
42 #include "DNA_modifier_types.h"
43 #include "DNA_object_types.h"
44 #include "DNA_action_types.h"
45 #include "DNA_curve_types.h"
46 #include "DNA_mesh_types.h"
47 #include "DNA_meshdata_types.h"
48
49 #include "DNA_lattice_types.h"
50 #include "DNA_scene_types.h"
51 #include "DNA_tracking_types.h"
52 #include "DNA_movieclip_types.h"
53
54 #include "BKE_action.h"
55 #include "BKE_anim.h" /* for the curve calculation part */
56 #include "BKE_armature.h"
57 #include "BKE_bvhutils.h"
58 #include "BKE_cachefile.h"
59 #include "BKE_camera.h"
60 #include "BKE_constraint.h"
61 #include "BKE_curve.h"
62 #include "BKE_deform.h"
63 #include "BKE_displist.h"
64 #include "BKE_editmesh.h"
65 #include "BKE_global.h"
66 #include "BKE_idprop.h"
67 #include "BKE_library.h"
68 #include "BKE_mesh_runtime.h"
69 #include "BKE_movieclip.h"
70 #include "BKE_object.h"
71 #include "BKE_scene.h"
72 #include "BKE_shrinkwrap.h"
73 #include "BKE_tracking.h"
74
75 #include "BIK_api.h"
76
77 #include "DEG_depsgraph.h"
78 #include "DEG_depsgraph_query.h"
79
80 #include "CLG_log.h"
81
82 #ifdef WITH_PYTHON
83 #  include "BPY_extern.h"
84 #endif
85
86 #ifdef WITH_ALEMBIC
87 #  include "ABC_alembic.h"
88 #endif
89
90 /* ---------------------------------------------------------------------------- */
91 /* Useful macros for testing various common flag combinations */
92
93 /* Constraint Target Macros */
94 #define VALID_CONS_TARGET(ct) ((ct) && (ct->tar))
95
96 static CLG_LogRef LOG = {"bke.constraint"};
97
98 /* ************************ Constraints - General Utilities *************************** */
99 /* These functions here don't act on any specific constraints, and are therefore should/will
100  * not require any of the special function-pointers afforded by the relevant constraint
101  * type-info structs.
102  */
103
104 static void damptrack_do_transform(float matrix[4][4], const float tarvec[3], int track_axis);
105
106 static bConstraint *constraint_find_original(Object *ob,
107                                              bPoseChannel *pchan,
108                                              bConstraint *con,
109                                              Object **r_orig_ob);
110 static bConstraint *constraint_find_original_for_update(bConstraintOb *cob, bConstraint *con);
111
112 /* -------------- Naming -------------- */
113
114 /* Find the first available, non-duplicate name for a given constraint */
115 void BKE_constraint_unique_name(bConstraint *con, ListBase *list)
116 {
117   BLI_uniquename(list, con, DATA_("Const"), '.', offsetof(bConstraint, name), sizeof(con->name));
118 }
119
120 /* ----------------- Evaluation Loop Preparation --------------- */
121
122 /* package an object/bone for use in constraint evaluation */
123 /* This function MEM_calloc's a bConstraintOb struct,
124  * that will need to be freed after evaluation */
125 bConstraintOb *BKE_constraints_make_evalob(
126     Depsgraph *depsgraph, Scene *scene, Object *ob, void *subdata, short datatype)
127 {
128   bConstraintOb *cob;
129
130   /* create regardless of whether we have any data! */
131   cob = MEM_callocN(sizeof(bConstraintOb), "bConstraintOb");
132
133   /* for system time, part of deglobalization, code nicer later with local time (ton) */
134   cob->scene = scene;
135   cob->depsgraph = depsgraph;
136
137   /* based on type of available data */
138   switch (datatype) {
139     case CONSTRAINT_OBTYPE_OBJECT: {
140       /* disregard subdata... calloc should set other values right */
141       if (ob) {
142         cob->ob = ob;
143         cob->type = datatype;
144
145         if (cob->ob->rotmode > 0) {
146           /* Should be some kind of Euler order, so use it */
147           /* NOTE: Versions <= 2.76 assumed that "default" order
148            *       would always get used, so we may seem some rig
149            *       breakage as a result. However, this change here
150            *       is needed to fix T46599
151            */
152           cob->rotOrder = ob->rotmode;
153         }
154         else {
155           /* Quats/Axis-Angle, so Eulers should just use default order */
156           cob->rotOrder = EULER_ORDER_DEFAULT;
157         }
158         copy_m4_m4(cob->matrix, ob->obmat);
159       }
160       else {
161         unit_m4(cob->matrix);
162       }
163
164       copy_m4_m4(cob->startmat, cob->matrix);
165       break;
166     }
167     case CONSTRAINT_OBTYPE_BONE: {
168       /* only set if we have valid bone, otherwise default */
169       if (ob && subdata) {
170         cob->ob = ob;
171         cob->pchan = (bPoseChannel *)subdata;
172         cob->type = datatype;
173
174         if (cob->pchan->rotmode > 0) {
175           /* should be some type of Euler order */
176           cob->rotOrder = cob->pchan->rotmode;
177         }
178         else {
179           /* Quats, so eulers should just use default order */
180           cob->rotOrder = EULER_ORDER_DEFAULT;
181         }
182
183         /* matrix in world-space */
184         mul_m4_m4m4(cob->matrix, ob->obmat, cob->pchan->pose_mat);
185       }
186       else {
187         unit_m4(cob->matrix);
188       }
189
190       copy_m4_m4(cob->startmat, cob->matrix);
191       break;
192     }
193     default: /* other types not yet handled */
194       unit_m4(cob->matrix);
195       unit_m4(cob->startmat);
196       break;
197   }
198
199   return cob;
200 }
201
202 /* cleanup after constraint evaluation */
203 void BKE_constraints_clear_evalob(bConstraintOb *cob)
204 {
205   float delta[4][4], imat[4][4];
206
207   /* prevent crashes */
208   if (cob == NULL) {
209     return;
210   }
211
212   /* calculate delta of constraints evaluation */
213   invert_m4_m4(imat, cob->startmat);
214   /* XXX This would seem to be in wrong order. However, it does not work in 'right' order -
215    *     would be nice to understand why premul is needed here instead of usual postmul?
216    *     In any case, we **do not get a delta** here (e.g. startmat & matrix having same location,
217    *     still gives a 'delta' with non-null translation component :/ ).*/
218   mul_m4_m4m4(delta, cob->matrix, imat);
219
220   /* copy matrices back to source */
221   switch (cob->type) {
222     case CONSTRAINT_OBTYPE_OBJECT: {
223       /* cob->ob might not exist! */
224       if (cob->ob) {
225         /* copy new ob-matrix back to owner */
226         copy_m4_m4(cob->ob->obmat, cob->matrix);
227
228         /* copy inverse of delta back to owner */
229         invert_m4_m4(cob->ob->constinv, delta);
230       }
231       break;
232     }
233     case CONSTRAINT_OBTYPE_BONE: {
234       /* cob->ob or cob->pchan might not exist */
235       if (cob->ob && cob->pchan) {
236         /* copy new pose-matrix back to owner */
237         mul_m4_m4m4(cob->pchan->pose_mat, cob->ob->imat, cob->matrix);
238
239         /* copy inverse of delta back to owner */
240         invert_m4_m4(cob->pchan->constinv, delta);
241       }
242       break;
243     }
244   }
245
246   /* free tempolary struct */
247   MEM_freeN(cob);
248 }
249
250 /* -------------- Space-Conversion API -------------- */
251
252 /* This function is responsible for the correct transformations/conversions
253  * of a matrix from one space to another for constraint evaluation.
254  * For now, this is only implemented for Objects and PoseChannels.
255  */
256 void BKE_constraint_mat_convertspace(
257     Object *ob, bPoseChannel *pchan, float mat[4][4], short from, short to, const bool keep_scale)
258 {
259   float diff_mat[4][4];
260   float imat[4][4];
261
262   /* prevent crashes in these unlikely events  */
263   if (ob == NULL || mat == NULL) {
264     return;
265   }
266   /* optimize trick - check if need to do anything */
267   if (from == to) {
268     return;
269   }
270
271   /* are we dealing with pose-channels or objects */
272   if (pchan) {
273     /* pose channels */
274     switch (from) {
275       case CONSTRAINT_SPACE_WORLD: /* ---------- FROM WORLDSPACE ---------- */
276       {
277         /* world to pose */
278         invert_m4_m4(imat, ob->obmat);
279         mul_m4_m4m4(mat, imat, mat);
280
281         /* use pose-space as stepping stone for other spaces... */
282         if (ELEM(to, CONSTRAINT_SPACE_LOCAL, CONSTRAINT_SPACE_PARLOCAL)) {
283           /* call self with slightly different values */
284           BKE_constraint_mat_convertspace(ob, pchan, mat, CONSTRAINT_SPACE_POSE, to, keep_scale);
285         }
286         break;
287       }
288       case CONSTRAINT_SPACE_POSE: /* ---------- FROM POSESPACE ---------- */
289       {
290         /* pose to world */
291         if (to == CONSTRAINT_SPACE_WORLD) {
292           mul_m4_m4m4(mat, ob->obmat, mat);
293         }
294         /* pose to local */
295         else if (to == CONSTRAINT_SPACE_LOCAL) {
296           if (pchan->bone) {
297             BKE_armature_mat_pose_to_bone(pchan, mat, mat);
298           }
299         }
300         /* pose to local with parent */
301         else if (to == CONSTRAINT_SPACE_PARLOCAL) {
302           if (pchan->bone) {
303             invert_m4_m4(imat, pchan->bone->arm_mat);
304             mul_m4_m4m4(mat, imat, mat);
305           }
306         }
307         break;
308       }
309       case CONSTRAINT_SPACE_LOCAL: /* ------------ FROM LOCALSPACE --------- */
310       {
311         /* local to pose - do inverse procedure that was done for pose to local */
312         if (pchan->bone) {
313           /* we need the posespace_matrix = local_matrix + (parent_posespace_matrix + restpos) */
314           BKE_armature_mat_bone_to_pose(pchan, mat, mat);
315         }
316
317         /* use pose-space as stepping stone for other spaces */
318         if (ELEM(to, CONSTRAINT_SPACE_WORLD, CONSTRAINT_SPACE_PARLOCAL)) {
319           /* call self with slightly different values */
320           BKE_constraint_mat_convertspace(ob, pchan, mat, CONSTRAINT_SPACE_POSE, to, keep_scale);
321         }
322         break;
323       }
324       case CONSTRAINT_SPACE_PARLOCAL: /* -------------- FROM LOCAL WITH PARENT ---------- */
325       {
326         /* local + parent to pose */
327         if (pchan->bone) {
328           mul_m4_m4m4(mat, pchan->bone->arm_mat, mat);
329         }
330
331         /* use pose-space as stepping stone for other spaces */
332         if (ELEM(to, CONSTRAINT_SPACE_WORLD, CONSTRAINT_SPACE_LOCAL)) {
333           /* call self with slightly different values */
334           BKE_constraint_mat_convertspace(ob, pchan, mat, CONSTRAINT_SPACE_POSE, to, keep_scale);
335         }
336         break;
337       }
338     }
339   }
340   else {
341     /* objects */
342     if (from == CONSTRAINT_SPACE_WORLD && to == CONSTRAINT_SPACE_LOCAL) {
343       /* check if object has a parent */
344       if (ob->parent) {
345         /* 'subtract' parent's effects from owner */
346         mul_m4_m4m4(diff_mat, ob->parent->obmat, ob->parentinv);
347         invert_m4_m4_safe(imat, diff_mat);
348         mul_m4_m4m4(mat, imat, mat);
349       }
350       else {
351         /* Local space in this case will have to be defined as local to the owner's
352          * transform-property-rotated axes. So subtract this rotation component.
353          */
354         /* XXX This is actually an ugly hack, local space of a parent-less object *is* the same as
355          *     global space!
356          *     Think what we want actually here is some kind of 'Final Space', i.e
357          *     . once transformations are applied - users are often confused about this too,
358          *     this is not consistent with bones
359          *     local space either... Meh :|
360          *     --mont29
361          */
362         BKE_object_to_mat4(ob, diff_mat);
363         if (!keep_scale) {
364           normalize_m4(diff_mat);
365         }
366         zero_v3(diff_mat[3]);
367
368         invert_m4_m4_safe(imat, diff_mat);
369         mul_m4_m4m4(mat, imat, mat);
370       }
371     }
372     else if (from == CONSTRAINT_SPACE_LOCAL && to == CONSTRAINT_SPACE_WORLD) {
373       /* check that object has a parent - otherwise this won't work */
374       if (ob->parent) {
375         /* 'add' parent's effect back to owner */
376         mul_m4_m4m4(diff_mat, ob->parent->obmat, ob->parentinv);
377         mul_m4_m4m4(mat, diff_mat, mat);
378       }
379       else {
380         /* Local space in this case will have to be defined as local to the owner's
381          * transform-property-rotated axes. So add back this rotation component.
382          */
383         /* XXX See comment above for world->local case... */
384         BKE_object_to_mat4(ob, diff_mat);
385         if (!keep_scale) {
386           normalize_m4(diff_mat);
387         }
388         zero_v3(diff_mat[3]);
389
390         mul_m4_m4m4(mat, diff_mat, mat);
391       }
392     }
393   }
394 }
395
396 /* ------------ General Target Matrix Tools ---------- */
397
398 /* function that sets the given matrix based on given vertex group in mesh */
399 static void contarget_get_mesh_mat(Object *ob, const char *substring, float mat[4][4])
400 {
401   /* when not in EditMode, use the 'final' evaluated mesh, depsgraph
402    * ensures we build with CD_MDEFORMVERT layer
403    */
404   Mesh *me_eval = ob->runtime.mesh_eval;
405   BMEditMesh *em = BKE_editmesh_from_object(ob);
406   float plane[3];
407   float imat[3][3], tmat[3][3];
408   const int defgroup = defgroup_name_index(ob, substring);
409
410   /* initialize target matrix using target matrix */
411   copy_m4_m4(mat, ob->obmat);
412
413   /* get index of vertex group */
414   if (defgroup == -1) {
415     return;
416   }
417
418   float vec[3] = {0.0f, 0.0f, 0.0f};
419   float normal[3] = {0.0f, 0.0f, 0.0f};
420   float weightsum = 0.0f;
421   if (me_eval) {
422     MDeformVert *dvert = CustomData_get_layer(&me_eval->vdata, CD_MDEFORMVERT);
423     int numVerts = me_eval->totvert;
424
425     /* check that dvert is a valid pointers (just in case) */
426     if (dvert) {
427       MDeformVert *dv = dvert;
428       MVert *mv = me_eval->mvert;
429
430       /* get the average of all verts with that are in the vertex-group */
431       for (int i = 0; i < numVerts; i++, dv++, mv++) {
432         MDeformWeight *dw = defvert_find_index(dv, defgroup);
433
434         if (dw && dw->weight > 0.0f) {
435           float nor[3];
436           normal_short_to_float_v3(nor, mv->no);
437           madd_v3_v3fl(vec, mv->co, dw->weight);
438           madd_v3_v3fl(normal, nor, dw->weight);
439           weightsum += dw->weight;
440         }
441       }
442     }
443   }
444   else if (em) {
445     if (CustomData_has_layer(&em->bm->vdata, CD_MDEFORMVERT)) {
446       BMVert *v;
447       BMIter iter;
448
449       BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
450         MDeformVert *dv = CustomData_bmesh_get(&em->bm->vdata, v->head.data, CD_MDEFORMVERT);
451         MDeformWeight *dw = defvert_find_index(dv, defgroup);
452
453         if (dw && dw->weight > 0.0f) {
454           madd_v3_v3fl(vec, v->co, dw->weight);
455           madd_v3_v3fl(normal, v->no, dw->weight);
456           weightsum += dw->weight;
457         }
458       }
459     }
460   }
461   else {
462     /* No valid edit or evaluated mesh, just abort. */
463     return;
464   }
465
466   /* calculate averages of normal and coordinates */
467   if (weightsum > 0) {
468     mul_v3_fl(vec, 1.0f / weightsum);
469     mul_v3_fl(normal, 1.0f / weightsum);
470   }
471
472   /* derive the rotation from the average normal:
473    * - code taken from transform_gizmo.c,
474    *   calc_gizmo_stats, V3D_ORIENT_NORMAL case
475    */
476   /*  we need the transpose of the inverse for a normal... */
477   copy_m3_m4(imat, ob->obmat);
478
479   invert_m3_m3(tmat, imat);
480   transpose_m3(tmat);
481   mul_m3_v3(tmat, normal);
482
483   normalize_v3(normal);
484   copy_v3_v3(plane, tmat[1]);
485
486   cross_v3_v3v3(mat[0], normal, plane);
487   if (len_squared_v3(mat[0]) < SQUARE(1e-3f)) {
488     copy_v3_v3(plane, tmat[0]);
489     cross_v3_v3v3(mat[0], normal, plane);
490   }
491
492   copy_v3_v3(mat[2], normal);
493   cross_v3_v3v3(mat[1], mat[2], mat[0]);
494
495   normalize_m4(mat);
496
497   /* apply the average coordinate as the new location */
498   mul_v3_m4v3(mat[3], ob->obmat, vec);
499 }
500
501 /* function that sets the given matrix based on given vertex group in lattice */
502 static void contarget_get_lattice_mat(Object *ob, const char *substring, float mat[4][4])
503 {
504   Lattice *lt = (Lattice *)ob->data;
505
506   DispList *dl = ob->runtime.curve_cache ?
507                      BKE_displist_find(&ob->runtime.curve_cache->disp, DL_VERTS) :
508                      NULL;
509   const float *co = dl ? dl->verts : NULL;
510   BPoint *bp = lt->def;
511
512   MDeformVert *dv = lt->dvert;
513   int tot_verts = lt->pntsu * lt->pntsv * lt->pntsw;
514   float vec[3] = {0.0f, 0.0f, 0.0f}, tvec[3];
515   int grouped = 0;
516   int i, n;
517   const int defgroup = defgroup_name_index(ob, substring);
518
519   /* initialize target matrix using target matrix */
520   copy_m4_m4(mat, ob->obmat);
521
522   /* get index of vertex group */
523   if (defgroup == -1) {
524     return;
525   }
526   if (dv == NULL) {
527     return;
528   }
529
530   /* 1. Loop through control-points checking if in nominated vertex-group.
531    * 2. If it is, add it to vec to find the average point.
532    */
533   for (i = 0; i < tot_verts; i++, dv++) {
534     for (n = 0; n < dv->totweight; n++) {
535       MDeformWeight *dw = defvert_find_index(dv, defgroup);
536       if (dw && dw->weight > 0.0f) {
537         /* copy coordinates of point to temporary vector, then add to find average */
538         memcpy(tvec, co ? co : bp->vec, 3 * sizeof(float));
539
540         add_v3_v3(vec, tvec);
541         grouped++;
542       }
543     }
544
545     /* advance pointer to coordinate data */
546     if (co) {
547       co += 3;
548     }
549     else {
550       bp++;
551     }
552   }
553
554   /* find average location, then multiply by ob->obmat to find world-space location */
555   if (grouped) {
556     mul_v3_fl(vec, 1.0f / grouped);
557   }
558   mul_v3_m4v3(tvec, ob->obmat, vec);
559
560   /* copy new location to matrix */
561   copy_v3_v3(mat[3], tvec);
562 }
563
564 /* generic function to get the appropriate matrix for most target cases */
565 /* The cases where the target can be object data have not been implemented */
566 static void constraint_target_to_mat4(Object *ob,
567                                       const char *substring,
568                                       float mat[4][4],
569                                       short from,
570                                       short to,
571                                       short flag,
572                                       float headtail)
573 {
574   /* Case OBJECT */
575   if (substring[0] == '\0') {
576     copy_m4_m4(mat, ob->obmat);
577     BKE_constraint_mat_convertspace(ob, NULL, mat, from, to, false);
578   }
579   /*  Case VERTEXGROUP */
580   /* Current method just takes the average location of all the points in the
581    * VertexGroup, and uses that as the location value of the targets. Where
582    * possible, the orientation will also be calculated, by calculating an
583    * 'average' vertex normal, and deriving the rotation from that.
584    *
585    * NOTE: EditMode is not currently supported, and will most likely remain that
586    *       way as constraints can only really affect things on object/bone level.
587    */
588   else if (ob->type == OB_MESH) {
589     contarget_get_mesh_mat(ob, substring, mat);
590     BKE_constraint_mat_convertspace(ob, NULL, mat, from, to, false);
591   }
592   else if (ob->type == OB_LATTICE) {
593     contarget_get_lattice_mat(ob, substring, mat);
594     BKE_constraint_mat_convertspace(ob, NULL, mat, from, to, false);
595   }
596   /* Case BONE */
597   else {
598     bPoseChannel *pchan;
599
600     pchan = BKE_pose_channel_find_name(ob->pose, substring);
601     if (pchan) {
602       /* Multiply the PoseSpace accumulation/final matrix for this
603        * PoseChannel by the Armature Object's Matrix to get a worldspace
604        * matrix.
605        */
606       bool is_bbone = (pchan->bone) && (pchan->bone->segments > 1) &&
607                       (flag & CONSTRAINT_BBONE_SHAPE);
608       bool full_bbone = (flag & CONSTRAINT_BBONE_SHAPE_FULL) != 0;
609
610       if (headtail < 0.000001f && !(is_bbone && full_bbone)) {
611         /* skip length interpolation if set to head */
612         mul_m4_m4m4(mat, ob->obmat, pchan->pose_mat);
613       }
614       else if (is_bbone && pchan->bone->segments == pchan->runtime.bbone_segments) {
615         /* use point along bbone */
616         Mat4 *bbone = pchan->runtime.bbone_pose_mats;
617         float tempmat[4][4];
618         float loc[3], fac;
619         int index;
620
621         /* figure out which segment(s) the headtail value falls in */
622         BKE_pchan_bbone_deform_segment_index(pchan, headtail, &index, &fac);
623
624         /* apply full transformation of the segment if requested */
625         if (full_bbone) {
626           interp_m4_m4m4(tempmat, bbone[index].mat, bbone[index + 1].mat, fac);
627
628           mul_m4_m4m4(tempmat, pchan->pose_mat, tempmat);
629         }
630         /* only interpolate location */
631         else {
632           interp_v3_v3v3(loc, bbone[index].mat[3], bbone[index + 1].mat[3], fac);
633
634           copy_m4_m4(tempmat, pchan->pose_mat);
635           mul_v3_m4v3(tempmat[3], pchan->pose_mat, loc);
636         }
637
638         mul_m4_m4m4(mat, ob->obmat, tempmat);
639       }
640       else {
641         float tempmat[4][4], loc[3];
642
643         /* interpolate along length of bone */
644         interp_v3_v3v3(loc, pchan->pose_head, pchan->pose_tail, headtail);
645
646         /* use interpolated distance for subtarget */
647         copy_m4_m4(tempmat, pchan->pose_mat);
648         copy_v3_v3(tempmat[3], loc);
649
650         mul_m4_m4m4(mat, ob->obmat, tempmat);
651       }
652     }
653     else {
654       copy_m4_m4(mat, ob->obmat);
655     }
656
657     /* convert matrix space as required */
658     BKE_constraint_mat_convertspace(ob, pchan, mat, from, to, false);
659   }
660 }
661
662 /* ************************* Specific Constraints ***************************** */
663 /* Each constraint defines a set of functions, which will be called at the appropriate
664  * times. In addition to this, each constraint should have a type-info struct, where
665  * its functions are attached for use.
666  */
667
668 /* Template for type-info data:
669  * - make a copy of this when creating new constraints, and just change the functions
670  *   pointed to as necessary
671  * - although the naming of functions doesn't matter, it would help for code
672  *   readability, to follow the same naming convention as is presented here
673  * - any functions that a constraint doesn't need to define, don't define
674  *   for such cases, just use NULL
675  * - these should be defined after all the functions have been defined, so that
676  *   forward-definitions/prototypes don't need to be used!
677  * - keep this copy #if-def'd so that future constraints can get based off this
678  */
679 #if 0
680 static bConstraintTypeInfo CTI_CONSTRNAME = {
681     CONSTRAINT_TYPE_CONSTRNAME,    /* type */
682     sizeof(bConstrNameConstraint), /* size */
683     "ConstrName",                  /* name */
684     "bConstrNameConstraint",       /* struct name */
685     constrname_free,               /* free data */
686     constrname_id_looper,          /* id looper */
687     constrname_copy,               /* copy data */
688     constrname_new_data,           /* new data */
689     constrname_get_tars,           /* get constraint targets */
690     constrname_flush_tars,         /* flush constraint targets */
691     constrname_get_tarmat,         /* get target matrix */
692     constrname_evaluate,           /* evaluate */
693 };
694 #endif
695
696 /* This function should be used for the get_target_matrix member of all
697  * constraints that are not picky about what happens to their target matrix.
698  */
699 static void default_get_tarmat(struct Depsgraph *UNUSED(depsgraph),
700                                bConstraint *con,
701                                bConstraintOb *UNUSED(cob),
702                                bConstraintTarget *ct,
703                                float UNUSED(ctime))
704 {
705   if (VALID_CONS_TARGET(ct)) {
706     constraint_target_to_mat4(ct->tar,
707                               ct->subtarget,
708                               ct->matrix,
709                               CONSTRAINT_SPACE_WORLD,
710                               ct->space,
711                               con->flag,
712                               con->headtail);
713   }
714   else if (ct) {
715     unit_m4(ct->matrix);
716   }
717 }
718
719 /* This is a variant that extracts full transformation from B-Bone segments.
720  */
721 static void default_get_tarmat_full_bbone(struct Depsgraph *UNUSED(depsgraph),
722                                           bConstraint *con,
723                                           bConstraintOb *UNUSED(cob),
724                                           bConstraintTarget *ct,
725                                           float UNUSED(ctime))
726 {
727   if (VALID_CONS_TARGET(ct)) {
728     constraint_target_to_mat4(ct->tar,
729                               ct->subtarget,
730                               ct->matrix,
731                               CONSTRAINT_SPACE_WORLD,
732                               ct->space,
733                               con->flag | CONSTRAINT_BBONE_SHAPE_FULL,
734                               con->headtail);
735   }
736   else if (ct) {
737     unit_m4(ct->matrix);
738   }
739 }
740
741 /* This following macro should be used for all standard single-target *_get_tars functions
742  * to save typing and reduce maintenance woes.
743  * (Hopefully all compilers will be happy with the lines with just a space on them. Those are
744  *  really just to help this code easier to read)
745  */
746 // TODO: cope with getting rotation order...
747 #define SINGLETARGET_GET_TARS(con, datatar, datasubtarget, ct, list) \
748   { \
749     ct = MEM_callocN(sizeof(bConstraintTarget), "tempConstraintTarget"); \
750 \
751     ct->tar = datatar; \
752     BLI_strncpy(ct->subtarget, datasubtarget, sizeof(ct->subtarget)); \
753     ct->space = con->tarspace; \
754     ct->flag = CONSTRAINT_TAR_TEMP; \
755 \
756     if (ct->tar) { \
757       if ((ct->tar->type == OB_ARMATURE) && (ct->subtarget[0])) { \
758         bPoseChannel *pchan = BKE_pose_channel_find_name(ct->tar->pose, ct->subtarget); \
759         ct->type = CONSTRAINT_OBTYPE_BONE; \
760         ct->rotOrder = (pchan) ? (pchan->rotmode) : EULER_ORDER_DEFAULT; \
761       } \
762       else if (OB_TYPE_SUPPORT_VGROUP(ct->tar->type) && (ct->subtarget[0])) { \
763         ct->type = CONSTRAINT_OBTYPE_VERT; \
764         ct->rotOrder = EULER_ORDER_DEFAULT; \
765       } \
766       else { \
767         ct->type = CONSTRAINT_OBTYPE_OBJECT; \
768         ct->rotOrder = ct->tar->rotmode; \
769       } \
770     } \
771 \
772     BLI_addtail(list, ct); \
773   } \
774   (void)0
775
776 /* This following macro should be used for all standard single-target *_get_tars functions
777  * to save typing and reduce maintenance woes. It does not do the subtarget related operations
778  * (Hopefully all compilers will be happy with the lines with just a space on them. Those are
779  *  really just to help this code easier to read)
780  */
781 // TODO: cope with getting rotation order...
782 #define SINGLETARGETNS_GET_TARS(con, datatar, ct, list) \
783   { \
784     ct = MEM_callocN(sizeof(bConstraintTarget), "tempConstraintTarget"); \
785 \
786     ct->tar = datatar; \
787     ct->space = con->tarspace; \
788     ct->flag = CONSTRAINT_TAR_TEMP; \
789 \
790     if (ct->tar) \
791       ct->type = CONSTRAINT_OBTYPE_OBJECT; \
792 \
793     BLI_addtail(list, ct); \
794   } \
795   (void)0
796
797 /* This following macro should be used for all standard single-target *_flush_tars functions
798  * to save typing and reduce maintenance woes.
799  * Note: the pointer to ct will be changed to point to the next in the list (as it gets removed)
800  * (Hopefully all compilers will be happy with the lines with just a space on them. Those are
801  *  really just to help this code easier to read)
802  */
803 #define SINGLETARGET_FLUSH_TARS(con, datatar, datasubtarget, ct, list, no_copy) \
804   { \
805     if (ct) { \
806       bConstraintTarget *ctn = ct->next; \
807       if (no_copy == 0) { \
808         datatar = ct->tar; \
809         BLI_strncpy(datasubtarget, ct->subtarget, sizeof(datasubtarget)); \
810         con->tarspace = (char)ct->space; \
811       } \
812 \
813       BLI_freelinkN(list, ct); \
814       ct = ctn; \
815     } \
816   } \
817   (void)0
818
819 /* This following macro should be used for all standard single-target *_flush_tars functions
820  * to save typing and reduce maintenance woes. It does not do the subtarget related operations.
821  * Note: the pointer to ct will be changed to point to the next in the list (as it gets removed)
822  * (Hopefully all compilers will be happy with the lines with just a space on them. Those are
823  *  really just to help this code easier to read)
824  */
825 #define SINGLETARGETNS_FLUSH_TARS(con, datatar, ct, list, no_copy) \
826   { \
827     if (ct) { \
828       bConstraintTarget *ctn = ct->next; \
829       if (no_copy == 0) { \
830         datatar = ct->tar; \
831         con->tarspace = (char)ct->space; \
832       } \
833 \
834       BLI_freelinkN(list, ct); \
835       ct = ctn; \
836     } \
837   } \
838   (void)0
839
840 /* --------- ChildOf Constraint ------------ */
841
842 static void childof_new_data(void *cdata)
843 {
844   bChildOfConstraint *data = (bChildOfConstraint *)cdata;
845
846   data->flag = (CHILDOF_LOCX | CHILDOF_LOCY | CHILDOF_LOCZ | CHILDOF_ROTX | CHILDOF_ROTY |
847                 CHILDOF_ROTZ | CHILDOF_SIZEX | CHILDOF_SIZEY | CHILDOF_SIZEZ);
848   unit_m4(data->invmat);
849 }
850
851 static void childof_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata)
852 {
853   bChildOfConstraint *data = con->data;
854
855   /* target only */
856   func(con, (ID **)&data->tar, false, userdata);
857 }
858
859 static int childof_get_tars(bConstraint *con, ListBase *list)
860 {
861   if (con && list) {
862     bChildOfConstraint *data = con->data;
863     bConstraintTarget *ct;
864
865     /* standard target-getting macro for single-target constraints */
866     SINGLETARGET_GET_TARS(con, data->tar, data->subtarget, ct, list);
867
868     return 1;
869   }
870
871   return 0;
872 }
873
874 static void childof_flush_tars(bConstraint *con, ListBase *list, bool no_copy)
875 {
876   if (con && list) {
877     bChildOfConstraint *data = con->data;
878     bConstraintTarget *ct = list->first;
879
880     /* the following macro is used for all standard single-target constraints */
881     SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, no_copy);
882   }
883 }
884
885 static void childof_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets)
886 {
887   bChildOfConstraint *data = con->data;
888   bConstraintTarget *ct = targets->first;
889
890   /* only evaluate if there is a target */
891   if (VALID_CONS_TARGET(ct)) {
892     float parmat[4][4];
893
894     /* simple matrix parenting */
895     if (data->flag == CHILDOF_ALL) {
896
897       /* multiply target (parent matrix) by offset (parent inverse) to get
898        * the effect of the parent that will be exerted on the owner
899        */
900       mul_m4_m4m4(parmat, ct->matrix, data->invmat);
901
902       /* now multiply the parent matrix by the owner matrix to get the
903        * the effect of this constraint (i.e. owner is 'parented' to parent)
904        */
905       mul_m4_m4m4(cob->matrix, parmat, cob->matrix);
906     }
907     else {
908       float invmat[4][4], tempmat[4][4];
909       float loc[3], eul[3], size[3];
910       float loco[3], eulo[3], sizo[3];
911
912       /* get offset (parent-inverse) matrix */
913       copy_m4_m4(invmat, data->invmat);
914
915       /* extract components of both matrices */
916       copy_v3_v3(loc, ct->matrix[3]);
917       mat4_to_eulO(eul, ct->rotOrder, ct->matrix);
918       mat4_to_size(size, ct->matrix);
919
920       copy_v3_v3(loco, invmat[3]);
921       mat4_to_eulO(eulo, cob->rotOrder, invmat);
922       mat4_to_size(sizo, invmat);
923
924       /* disable channels not enabled */
925       if (!(data->flag & CHILDOF_LOCX)) {
926         loc[0] = loco[0] = 0.0f;
927       }
928       if (!(data->flag & CHILDOF_LOCY)) {
929         loc[1] = loco[1] = 0.0f;
930       }
931       if (!(data->flag & CHILDOF_LOCZ)) {
932         loc[2] = loco[2] = 0.0f;
933       }
934       if (!(data->flag & CHILDOF_ROTX)) {
935         eul[0] = eulo[0] = 0.0f;
936       }
937       if (!(data->flag & CHILDOF_ROTY)) {
938         eul[1] = eulo[1] = 0.0f;
939       }
940       if (!(data->flag & CHILDOF_ROTZ)) {
941         eul[2] = eulo[2] = 0.0f;
942       }
943       if (!(data->flag & CHILDOF_SIZEX)) {
944         size[0] = sizo[0] = 1.0f;
945       }
946       if (!(data->flag & CHILDOF_SIZEY)) {
947         size[1] = sizo[1] = 1.0f;
948       }
949       if (!(data->flag & CHILDOF_SIZEZ)) {
950         size[2] = sizo[2] = 1.0f;
951       }
952
953       /* make new target mat and offset mat */
954       loc_eulO_size_to_mat4(ct->matrix, loc, eul, size, ct->rotOrder);
955       loc_eulO_size_to_mat4(invmat, loco, eulo, sizo, cob->rotOrder);
956
957       /* multiply target (parent matrix) by offset (parent inverse) to get
958        * the effect of the parent that will be exerted on the owner
959        */
960       mul_m4_m4m4(parmat, ct->matrix, invmat);
961
962       /* now multiply the parent matrix by the owner matrix to get the
963        * the effect of this constraint (i.e.  owner is 'parented' to parent)
964        */
965       copy_m4_m4(tempmat, cob->matrix);
966       mul_m4_m4m4(cob->matrix, parmat, tempmat);
967
968       /* without this, changes to scale and rotation can change location
969        * of a parentless bone or a disconnected bone. Even though its set
970        * to zero above. */
971       if (!(data->flag & CHILDOF_LOCX)) {
972         cob->matrix[3][0] = tempmat[3][0];
973       }
974       if (!(data->flag & CHILDOF_LOCY)) {
975         cob->matrix[3][1] = tempmat[3][1];
976       }
977       if (!(data->flag & CHILDOF_LOCZ)) {
978         cob->matrix[3][2] = tempmat[3][2];
979       }
980     }
981   }
982 }
983
984 /* XXX note, con->flag should be CONSTRAINT_SPACEONCE for bone-childof, patched in readfile.c */
985 static bConstraintTypeInfo CTI_CHILDOF = {
986     CONSTRAINT_TYPE_CHILDOF,    /* type */
987     sizeof(bChildOfConstraint), /* size */
988     "Child Of",                 /* name */
989     "bChildOfConstraint",       /* struct name */
990     NULL,                       /* free data */
991     childof_id_looper,          /* id looper */
992     NULL,                       /* copy data */
993     childof_new_data,           /* new data */
994     childof_get_tars,           /* get constraint targets */
995     childof_flush_tars,         /* flush constraint targets */
996     default_get_tarmat,         /* get a target matrix */
997     childof_evaluate,           /* evaluate */
998 };
999
1000 /* -------- TrackTo Constraint ------- */
1001
1002 static void trackto_new_data(void *cdata)
1003 {
1004   bTrackToConstraint *data = (bTrackToConstraint *)cdata;
1005
1006   data->reserved1 = TRACK_Y;
1007   data->reserved2 = UP_Z;
1008 }
1009
1010 static void trackto_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata)
1011 {
1012   bTrackToConstraint *data = con->data;
1013
1014   /* target only */
1015   func(con, (ID **)&data->tar, false, userdata);
1016 }
1017
1018 static int trackto_get_tars(bConstraint *con, ListBase *list)
1019 {
1020   if (con && list) {
1021     bTrackToConstraint *data = con->data;
1022     bConstraintTarget *ct;
1023
1024     /* standard target-getting macro for single-target constraints */
1025     SINGLETARGET_GET_TARS(con, data->tar, data->subtarget, ct, list);
1026
1027     return 1;
1028   }
1029
1030   return 0;
1031 }
1032
1033 static void trackto_flush_tars(bConstraint *con, ListBase *list, bool no_copy)
1034 {
1035   if (con && list) {
1036     bTrackToConstraint *data = con->data;
1037     bConstraintTarget *ct = list->first;
1038
1039     /* the following macro is used for all standard single-target constraints */
1040     SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, no_copy);
1041   }
1042 }
1043
1044 static int basis_cross(int n, int m)
1045 {
1046   switch (n - m) {
1047     case 1:
1048     case -2:
1049       return 1;
1050
1051     case -1:
1052     case 2:
1053       return -1;
1054
1055     default:
1056       return 0;
1057   }
1058 }
1059
1060 static void vectomat(const float vec[3],
1061                      const float target_up[3],
1062                      short axis,
1063                      short upflag,
1064                      short flags,
1065                      float m[3][3])
1066 {
1067   float n[3];
1068   float u[3]; /* vector specifying the up axis */
1069   float proj[3];
1070   float right[3];
1071   float neg = -1;
1072   int right_index;
1073
1074   if (normalize_v3_v3(n, vec) == 0.0f) {
1075     n[0] = 0.0f;
1076     n[1] = 0.0f;
1077     n[2] = 1.0f;
1078   }
1079   if (axis > 2) {
1080     axis -= 3;
1081   }
1082   else {
1083     negate_v3(n);
1084   }
1085
1086   /* n specifies the transformation of the track axis */
1087   if (flags & TARGET_Z_UP) {
1088     /* target Z axis is the global up axis */
1089     copy_v3_v3(u, target_up);
1090   }
1091   else {
1092     /* world Z axis is the global up axis */
1093     u[0] = 0;
1094     u[1] = 0;
1095     u[2] = 1;
1096   }
1097
1098   /* note: even though 'n' is normalized, don't use 'project_v3_v3v3_normalized' below
1099    * because precision issues cause a problem in near degenerate states, see: T53455. */
1100
1101   /* project the up vector onto the plane specified by n */
1102   project_v3_v3v3(proj, u, n); /* first u onto n... */
1103   sub_v3_v3v3(proj, u, proj);  /* then onto the plane */
1104   /* proj specifies the transformation of the up axis */
1105
1106   if (normalize_v3(proj) == 0.0f) { /* degenerate projection */
1107     proj[0] = 0.0f;
1108     proj[1] = 1.0f;
1109     proj[2] = 0.0f;
1110   }
1111
1112   /* Normalized cross product of n and proj specifies transformation of the right axis */
1113   cross_v3_v3v3(right, proj, n);
1114   normalize_v3(right);
1115
1116   if (axis != upflag) {
1117     right_index = 3 - axis - upflag;
1118     neg = (float)basis_cross(axis, upflag);
1119
1120     /* account for up direction, track direction */
1121     m[right_index][0] = neg * right[0];
1122     m[right_index][1] = neg * right[1];
1123     m[right_index][2] = neg * right[2];
1124
1125     copy_v3_v3(m[upflag], proj);
1126
1127     copy_v3_v3(m[axis], n);
1128   }
1129   /* identity matrix - don't do anything if the two axes are the same */
1130   else {
1131     unit_m3(m);
1132   }
1133 }
1134
1135 static void trackto_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets)
1136 {
1137   bTrackToConstraint *data = con->data;
1138   bConstraintTarget *ct = targets->first;
1139
1140   if (VALID_CONS_TARGET(ct)) {
1141     float size[3], vec[3];
1142     float totmat[3][3];
1143
1144     /* Get size property, since ob->scale is only the object's own relative size,
1145      * not its global one. */
1146     mat4_to_size(size, cob->matrix);
1147
1148     /* Clear the object's rotation */
1149     cob->matrix[0][0] = size[0];
1150     cob->matrix[0][1] = 0;
1151     cob->matrix[0][2] = 0;
1152     cob->matrix[1][0] = 0;
1153     cob->matrix[1][1] = size[1];
1154     cob->matrix[1][2] = 0;
1155     cob->matrix[2][0] = 0;
1156     cob->matrix[2][1] = 0;
1157     cob->matrix[2][2] = size[2];
1158
1159     /* targetmat[2] instead of ownermat[2] is passed to vectomat
1160      * for backwards compatibility it seems... (Aligorith)
1161      */
1162     sub_v3_v3v3(vec, cob->matrix[3], ct->matrix[3]);
1163     vectomat(
1164         vec, ct->matrix[2], (short)data->reserved1, (short)data->reserved2, data->flags, totmat);
1165
1166     mul_m4_m3m4(cob->matrix, totmat, cob->matrix);
1167   }
1168 }
1169
1170 static bConstraintTypeInfo CTI_TRACKTO = {
1171     CONSTRAINT_TYPE_TRACKTO,    /* type */
1172     sizeof(bTrackToConstraint), /* size */
1173     "Track To",                 /* name */
1174     "bTrackToConstraint",       /* struct name */
1175     NULL,                       /* free data */
1176     trackto_id_looper,          /* id looper */
1177     NULL,                       /* copy data */
1178     trackto_new_data,           /* new data */
1179     trackto_get_tars,           /* get constraint targets */
1180     trackto_flush_tars,         /* flush constraint targets */
1181     default_get_tarmat,         /* get target matrix */
1182     trackto_evaluate,           /* evaluate */
1183 };
1184
1185 /* --------- Inverse-Kinematics --------- */
1186
1187 static void kinematic_new_data(void *cdata)
1188 {
1189   bKinematicConstraint *data = (bKinematicConstraint *)cdata;
1190
1191   data->weight = 1.0f;
1192   data->orientweight = 1.0f;
1193   data->iterations = 500;
1194   data->dist = 1.0f;
1195   data->flag = CONSTRAINT_IK_TIP | CONSTRAINT_IK_STRETCH | CONSTRAINT_IK_POS;
1196 }
1197
1198 static void kinematic_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata)
1199 {
1200   bKinematicConstraint *data = con->data;
1201
1202   /* chain target */
1203   func(con, (ID **)&data->tar, false, userdata);
1204
1205   /* poletarget */
1206   func(con, (ID **)&data->poletar, false, userdata);
1207 }
1208
1209 static int kinematic_get_tars(bConstraint *con, ListBase *list)
1210 {
1211   if (con && list) {
1212     bKinematicConstraint *data = con->data;
1213     bConstraintTarget *ct;
1214
1215     /* standard target-getting macro for single-target constraints is used twice here */
1216     SINGLETARGET_GET_TARS(con, data->tar, data->subtarget, ct, list);
1217     SINGLETARGET_GET_TARS(con, data->poletar, data->polesubtarget, ct, list);
1218
1219     return 2;
1220   }
1221
1222   return 0;
1223 }
1224
1225 static void kinematic_flush_tars(bConstraint *con, ListBase *list, bool no_copy)
1226 {
1227   if (con && list) {
1228     bKinematicConstraint *data = con->data;
1229     bConstraintTarget *ct = list->first;
1230
1231     /* the following macro is used for all standard single-target constraints */
1232     SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, no_copy);
1233     SINGLETARGET_FLUSH_TARS(con, data->poletar, data->polesubtarget, ct, list, no_copy);
1234   }
1235 }
1236
1237 static void kinematic_get_tarmat(struct Depsgraph *UNUSED(depsgraph),
1238                                  bConstraint *con,
1239                                  bConstraintOb *cob,
1240                                  bConstraintTarget *ct,
1241                                  float UNUSED(ctime))
1242 {
1243   bKinematicConstraint *data = con->data;
1244
1245   if (VALID_CONS_TARGET(ct)) {
1246     constraint_target_to_mat4(ct->tar,
1247                               ct->subtarget,
1248                               ct->matrix,
1249                               CONSTRAINT_SPACE_WORLD,
1250                               ct->space,
1251                               con->flag,
1252                               con->headtail);
1253   }
1254   else if (ct) {
1255     if (data->flag & CONSTRAINT_IK_AUTO) {
1256       Object *ob = cob->ob;
1257
1258       if (ob == NULL) {
1259         unit_m4(ct->matrix);
1260       }
1261       else {
1262         float vec[3];
1263         /* move grabtarget into world space */
1264         mul_v3_m4v3(vec, ob->obmat, data->grabtarget);
1265         copy_m4_m4(ct->matrix, ob->obmat);
1266         copy_v3_v3(ct->matrix[3], vec);
1267       }
1268     }
1269     else {
1270       unit_m4(ct->matrix);
1271     }
1272   }
1273 }
1274
1275 static bConstraintTypeInfo CTI_KINEMATIC = {
1276     CONSTRAINT_TYPE_KINEMATIC,    /* type */
1277     sizeof(bKinematicConstraint), /* size */
1278     "IK",                         /* name */
1279     "bKinematicConstraint",       /* struct name */
1280     NULL,                         /* free data */
1281     kinematic_id_looper,          /* id looper */
1282     NULL,                         /* copy data */
1283     kinematic_new_data,           /* new data */
1284     kinematic_get_tars,           /* get constraint targets */
1285     kinematic_flush_tars,         /* flush constraint targets */
1286     kinematic_get_tarmat,         /* get target matrix */
1287     NULL,                         /* evaluate - solved as separate loop */
1288 };
1289
1290 /* -------- Follow-Path Constraint ---------- */
1291
1292 static void followpath_new_data(void *cdata)
1293 {
1294   bFollowPathConstraint *data = (bFollowPathConstraint *)cdata;
1295
1296   data->trackflag = TRACK_Y;
1297   data->upflag = UP_Z;
1298   data->offset = 0;
1299   data->followflag = 0;
1300 }
1301
1302 static void followpath_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata)
1303 {
1304   bFollowPathConstraint *data = con->data;
1305
1306   /* target only */
1307   func(con, (ID **)&data->tar, false, userdata);
1308 }
1309
1310 static int followpath_get_tars(bConstraint *con, ListBase *list)
1311 {
1312   if (con && list) {
1313     bFollowPathConstraint *data = con->data;
1314     bConstraintTarget *ct;
1315
1316     /* standard target-getting macro for single-target constraints without subtargets */
1317     SINGLETARGETNS_GET_TARS(con, data->tar, ct, list);
1318
1319     return 1;
1320   }
1321
1322   return 0;
1323 }
1324
1325 static void followpath_flush_tars(bConstraint *con, ListBase *list, bool no_copy)
1326 {
1327   if (con && list) {
1328     bFollowPathConstraint *data = con->data;
1329     bConstraintTarget *ct = list->first;
1330
1331     /* the following macro is used for all standard single-target constraints */
1332     SINGLETARGETNS_FLUSH_TARS(con, data->tar, ct, list, no_copy);
1333   }
1334 }
1335
1336 static void followpath_get_tarmat(struct Depsgraph *UNUSED(depsgraph),
1337                                   bConstraint *con,
1338                                   bConstraintOb *UNUSED(cob),
1339                                   bConstraintTarget *ct,
1340                                   float UNUSED(ctime))
1341 {
1342   bFollowPathConstraint *data = con->data;
1343
1344   if (VALID_CONS_TARGET(ct) && (ct->tar->type == OB_CURVE)) {
1345     Curve *cu = ct->tar->data;
1346     float vec[4], dir[3], radius;
1347     float curvetime;
1348
1349     unit_m4(ct->matrix);
1350
1351     /* note: when creating constraints that follow path, the curve gets the CU_PATH set now,
1352      * currently for paths to work it needs to go through the bevlist/displist system (ton)
1353      */
1354
1355     if (ct->tar->runtime.curve_cache && ct->tar->runtime.curve_cache->path &&
1356         ct->tar->runtime.curve_cache->path->data) {
1357       float quat[4];
1358       if ((data->followflag & FOLLOWPATH_STATIC) == 0) {
1359         /* animated position along curve depending on time */
1360         Nurb *nu = cu->nurb.first;
1361         curvetime = cu->ctime - data->offset;
1362
1363         /* ctime is now a proper var setting of Curve which gets set by Animato like any other var
1364          * that's animated, but this will only work if it actually is animated...
1365          *
1366          * we divide the curvetime calculated in the previous step by the length of the path,
1367          * to get a time factor, which then gets clamped to lie within 0.0 - 1.0 range. */
1368         curvetime /= cu->pathlen;
1369
1370         if (nu && nu->flagu & CU_NURB_CYCLIC) {
1371           /* If the curve is cyclic, enable looping around if the time is
1372            * outside the bounds 0..1 */
1373           if ((curvetime < 0.0f) || (curvetime > 1.0f)) {
1374             curvetime -= floorf(curvetime);
1375           }
1376         }
1377         else {
1378           /* The curve is not cyclic, so clamp to the begin/end points. */
1379           CLAMP(curvetime, 0.0f, 1.0f);
1380         }
1381       }
1382       else {
1383         /* fixed position along curve */
1384         curvetime = data->offset_fac;
1385       }
1386
1387       if (where_on_path(ct->tar,
1388                         curvetime,
1389                         vec,
1390                         dir,
1391                         (data->followflag & FOLLOWPATH_FOLLOW) ? quat : NULL,
1392                         &radius,
1393                         NULL)) { /* quat_pt is quat or NULL*/
1394         float totmat[4][4];
1395         unit_m4(totmat);
1396
1397         if (data->followflag & FOLLOWPATH_FOLLOW) {
1398           quat_apply_track(quat, data->trackflag, data->upflag);
1399           quat_to_mat4(totmat, quat);
1400         }
1401
1402         if (data->followflag & FOLLOWPATH_RADIUS) {
1403           float tmat[4][4], rmat[4][4];
1404           scale_m4_fl(tmat, radius);
1405           mul_m4_m4m4(rmat, tmat, totmat);
1406           copy_m4_m4(totmat, rmat);
1407         }
1408
1409         copy_v3_v3(totmat[3], vec);
1410
1411         mul_m4_m4m4(ct->matrix, ct->tar->obmat, totmat);
1412       }
1413     }
1414   }
1415   else if (ct) {
1416     unit_m4(ct->matrix);
1417   }
1418 }
1419
1420 static void followpath_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets)
1421 {
1422   bConstraintTarget *ct = targets->first;
1423
1424   /* only evaluate if there is a target */
1425   if (VALID_CONS_TARGET(ct)) {
1426     float obmat[4][4];
1427     float size[3];
1428     bFollowPathConstraint *data = con->data;
1429
1430     /* get Object transform (loc/rot/size) to determine transformation from path */
1431     /* TODO: this used to be local at one point, but is probably more useful as-is */
1432     copy_m4_m4(obmat, cob->matrix);
1433
1434     /* get scaling of object before applying constraint */
1435     mat4_to_size(size, cob->matrix);
1436
1437     /* apply targetmat - containing location on path, and rotation */
1438     mul_m4_m4m4(cob->matrix, ct->matrix, obmat);
1439
1440     /* un-apply scaling caused by path */
1441     if ((data->followflag & FOLLOWPATH_RADIUS) == 0) {
1442       /* XXX: Assume that scale correction means that radius
1443        * will have some scale error in it - Campbell. */
1444       float obsize[3];
1445
1446       mat4_to_size(obsize, cob->matrix);
1447       if (obsize[0]) {
1448         mul_v3_fl(cob->matrix[0], size[0] / obsize[0]);
1449       }
1450       if (obsize[1]) {
1451         mul_v3_fl(cob->matrix[1], size[1] / obsize[1]);
1452       }
1453       if (obsize[2]) {
1454         mul_v3_fl(cob->matrix[2], size[2] / obsize[2]);
1455       }
1456     }
1457   }
1458 }
1459
1460 static bConstraintTypeInfo CTI_FOLLOWPATH = {
1461     CONSTRAINT_TYPE_FOLLOWPATH,    /* type */
1462     sizeof(bFollowPathConstraint), /* size */
1463     "Follow Path",                 /* name */
1464     "bFollowPathConstraint",       /* struct name */
1465     NULL,                          /* free data */
1466     followpath_id_looper,          /* id looper */
1467     NULL,                          /* copy data */
1468     followpath_new_data,           /* new data */
1469     followpath_get_tars,           /* get constraint targets */
1470     followpath_flush_tars,         /* flush constraint targets */
1471     followpath_get_tarmat,         /* get target matrix */
1472     followpath_evaluate,           /* evaluate */
1473 };
1474
1475 /* --------- Limit Location --------- */
1476
1477 static void loclimit_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *UNUSED(targets))
1478 {
1479   bLocLimitConstraint *data = con->data;
1480
1481   if (data->flag & LIMIT_XMIN) {
1482     if (cob->matrix[3][0] < data->xmin) {
1483       cob->matrix[3][0] = data->xmin;
1484     }
1485   }
1486   if (data->flag & LIMIT_XMAX) {
1487     if (cob->matrix[3][0] > data->xmax) {
1488       cob->matrix[3][0] = data->xmax;
1489     }
1490   }
1491   if (data->flag & LIMIT_YMIN) {
1492     if (cob->matrix[3][1] < data->ymin) {
1493       cob->matrix[3][1] = data->ymin;
1494     }
1495   }
1496   if (data->flag & LIMIT_YMAX) {
1497     if (cob->matrix[3][1] > data->ymax) {
1498       cob->matrix[3][1] = data->ymax;
1499     }
1500   }
1501   if (data->flag & LIMIT_ZMIN) {
1502     if (cob->matrix[3][2] < data->zmin) {
1503       cob->matrix[3][2] = data->zmin;
1504     }
1505   }
1506   if (data->flag & LIMIT_ZMAX) {
1507     if (cob->matrix[3][2] > data->zmax) {
1508       cob->matrix[3][2] = data->zmax;
1509     }
1510   }
1511 }
1512
1513 static bConstraintTypeInfo CTI_LOCLIMIT = {
1514     CONSTRAINT_TYPE_LOCLIMIT,    /* type */
1515     sizeof(bLocLimitConstraint), /* size */
1516     "Limit Location",            /* name */
1517     "bLocLimitConstraint",       /* struct name */
1518     NULL,                        /* free data */
1519     NULL,                        /* id looper */
1520     NULL,                        /* copy data */
1521     NULL,                        /* new data */
1522     NULL,                        /* get constraint targets */
1523     NULL,                        /* flush constraint targets */
1524     NULL,                        /* get target matrix */
1525     loclimit_evaluate,           /* evaluate */
1526 };
1527
1528 /* -------- Limit Rotation --------- */
1529
1530 static void rotlimit_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *UNUSED(targets))
1531 {
1532   bRotLimitConstraint *data = con->data;
1533   float loc[3];
1534   float eul[3];
1535   float size[3];
1536
1537   copy_v3_v3(loc, cob->matrix[3]);
1538   mat4_to_size(size, cob->matrix);
1539
1540   mat4_to_eulO(eul, cob->rotOrder, cob->matrix);
1541
1542   /* constraint data uses radians internally */
1543
1544   /* limiting of euler values... */
1545   if (data->flag & LIMIT_XROT) {
1546     if (eul[0] < data->xmin) {
1547       eul[0] = data->xmin;
1548     }
1549
1550     if (eul[0] > data->xmax) {
1551       eul[0] = data->xmax;
1552     }
1553   }
1554   if (data->flag & LIMIT_YROT) {
1555     if (eul[1] < data->ymin) {
1556       eul[1] = data->ymin;
1557     }
1558
1559     if (eul[1] > data->ymax) {
1560       eul[1] = data->ymax;
1561     }
1562   }
1563   if (data->flag & LIMIT_ZROT) {
1564     if (eul[2] < data->zmin) {
1565       eul[2] = data->zmin;
1566     }
1567
1568     if (eul[2] > data->zmax) {
1569       eul[2] = data->zmax;
1570     }
1571   }
1572
1573   loc_eulO_size_to_mat4(cob->matrix, loc, eul, size, cob->rotOrder);
1574 }
1575
1576 static bConstraintTypeInfo CTI_ROTLIMIT = {
1577     CONSTRAINT_TYPE_ROTLIMIT,    /* type */
1578     sizeof(bRotLimitConstraint), /* size */
1579     "Limit Rotation",            /* name */
1580     "bRotLimitConstraint",       /* struct name */
1581     NULL,                        /* free data */
1582     NULL,                        /* id looper */
1583     NULL,                        /* copy data */
1584     NULL,                        /* new data */
1585     NULL,                        /* get constraint targets */
1586     NULL,                        /* flush constraint targets */
1587     NULL,                        /* get target matrix */
1588     rotlimit_evaluate,           /* evaluate */
1589 };
1590
1591 /* --------- Limit Scale --------- */
1592
1593 static void sizelimit_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *UNUSED(targets))
1594 {
1595   bSizeLimitConstraint *data = con->data;
1596   float obsize[3], size[3];
1597
1598   mat4_to_size(size, cob->matrix);
1599   mat4_to_size(obsize, cob->matrix);
1600
1601   if (data->flag & LIMIT_XMIN) {
1602     if (size[0] < data->xmin) {
1603       size[0] = data->xmin;
1604     }
1605   }
1606   if (data->flag & LIMIT_XMAX) {
1607     if (size[0] > data->xmax) {
1608       size[0] = data->xmax;
1609     }
1610   }
1611   if (data->flag & LIMIT_YMIN) {
1612     if (size[1] < data->ymin) {
1613       size[1] = data->ymin;
1614     }
1615   }
1616   if (data->flag & LIMIT_YMAX) {
1617     if (size[1] > data->ymax) {
1618       size[1] = data->ymax;
1619     }
1620   }
1621   if (data->flag & LIMIT_ZMIN) {
1622     if (size[2] < data->zmin) {
1623       size[2] = data->zmin;
1624     }
1625   }
1626   if (data->flag & LIMIT_ZMAX) {
1627     if (size[2] > data->zmax) {
1628       size[2] = data->zmax;
1629     }
1630   }
1631
1632   if (obsize[0]) {
1633     mul_v3_fl(cob->matrix[0], size[0] / obsize[0]);
1634   }
1635   if (obsize[1]) {
1636     mul_v3_fl(cob->matrix[1], size[1] / obsize[1]);
1637   }
1638   if (obsize[2]) {
1639     mul_v3_fl(cob->matrix[2], size[2] / obsize[2]);
1640   }
1641 }
1642
1643 static bConstraintTypeInfo CTI_SIZELIMIT = {
1644     CONSTRAINT_TYPE_SIZELIMIT,    /* type */
1645     sizeof(bSizeLimitConstraint), /* size */
1646     "Limit Scale",                /* name */
1647     "bSizeLimitConstraint",       /* struct name */
1648     NULL,                         /* free data */
1649     NULL,                         /* id looper */
1650     NULL,                         /* copy data */
1651     NULL,                         /* new data */
1652     NULL,                         /* get constraint targets */
1653     NULL,                         /* flush constraint targets */
1654     NULL,                         /* get target matrix */
1655     sizelimit_evaluate,           /* evaluate */
1656 };
1657
1658 /* ----------- Copy Location ------------- */
1659
1660 static void loclike_new_data(void *cdata)
1661 {
1662   bLocateLikeConstraint *data = (bLocateLikeConstraint *)cdata;
1663
1664   data->flag = LOCLIKE_X | LOCLIKE_Y | LOCLIKE_Z;
1665 }
1666
1667 static void loclike_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata)
1668 {
1669   bLocateLikeConstraint *data = con->data;
1670
1671   /* target only */
1672   func(con, (ID **)&data->tar, false, userdata);
1673 }
1674
1675 static int loclike_get_tars(bConstraint *con, ListBase *list)
1676 {
1677   if (con && list) {
1678     bLocateLikeConstraint *data = con->data;
1679     bConstraintTarget *ct;
1680
1681     /* standard target-getting macro for single-target constraints */
1682     SINGLETARGET_GET_TARS(con, data->tar, data->subtarget, ct, list);
1683
1684     return 1;
1685   }
1686
1687   return 0;
1688 }
1689
1690 static void loclike_flush_tars(bConstraint *con, ListBase *list, bool no_copy)
1691 {
1692   if (con && list) {
1693     bLocateLikeConstraint *data = con->data;
1694     bConstraintTarget *ct = list->first;
1695
1696     /* the following macro is used for all standard single-target constraints */
1697     SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, no_copy);
1698   }
1699 }
1700
1701 static void loclike_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets)
1702 {
1703   bLocateLikeConstraint *data = con->data;
1704   bConstraintTarget *ct = targets->first;
1705
1706   if (VALID_CONS_TARGET(ct)) {
1707     float offset[3] = {0.0f, 0.0f, 0.0f};
1708
1709     if (data->flag & LOCLIKE_OFFSET) {
1710       copy_v3_v3(offset, cob->matrix[3]);
1711     }
1712
1713     if (data->flag & LOCLIKE_X) {
1714       cob->matrix[3][0] = ct->matrix[3][0];
1715
1716       if (data->flag & LOCLIKE_X_INVERT) {
1717         cob->matrix[3][0] *= -1;
1718       }
1719       cob->matrix[3][0] += offset[0];
1720     }
1721     if (data->flag & LOCLIKE_Y) {
1722       cob->matrix[3][1] = ct->matrix[3][1];
1723
1724       if (data->flag & LOCLIKE_Y_INVERT) {
1725         cob->matrix[3][1] *= -1;
1726       }
1727       cob->matrix[3][1] += offset[1];
1728     }
1729     if (data->flag & LOCLIKE_Z) {
1730       cob->matrix[3][2] = ct->matrix[3][2];
1731
1732       if (data->flag & LOCLIKE_Z_INVERT) {
1733         cob->matrix[3][2] *= -1;
1734       }
1735       cob->matrix[3][2] += offset[2];
1736     }
1737   }
1738 }
1739
1740 static bConstraintTypeInfo CTI_LOCLIKE = {
1741     CONSTRAINT_TYPE_LOCLIKE,       /* type */
1742     sizeof(bLocateLikeConstraint), /* size */
1743     "Copy Location",               /* name */
1744     "bLocateLikeConstraint",       /* struct name */
1745     NULL,                          /* free data */
1746     loclike_id_looper,             /* id looper */
1747     NULL,                          /* copy data */
1748     loclike_new_data,              /* new data */
1749     loclike_get_tars,              /* get constraint targets */
1750     loclike_flush_tars,            /* flush constraint targets */
1751     default_get_tarmat,            /* get target matrix */
1752     loclike_evaluate,              /* evaluate */
1753 };
1754
1755 /* ----------- Copy Rotation ------------- */
1756
1757 static void rotlike_new_data(void *cdata)
1758 {
1759   bRotateLikeConstraint *data = (bRotateLikeConstraint *)cdata;
1760
1761   data->flag = ROTLIKE_X | ROTLIKE_Y | ROTLIKE_Z;
1762 }
1763
1764 static void rotlike_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata)
1765 {
1766   bRotateLikeConstraint *data = con->data;
1767
1768   /* target only */
1769   func(con, (ID **)&data->tar, false, userdata);
1770 }
1771
1772 static int rotlike_get_tars(bConstraint *con, ListBase *list)
1773 {
1774   if (con && list) {
1775     bRotateLikeConstraint *data = con->data;
1776     bConstraintTarget *ct;
1777
1778     /* standard target-getting macro for single-target constraints */
1779     SINGLETARGET_GET_TARS(con, data->tar, data->subtarget, ct, list);
1780
1781     return 1;
1782   }
1783
1784   return 0;
1785 }
1786
1787 static void rotlike_flush_tars(bConstraint *con, ListBase *list, bool no_copy)
1788 {
1789   if (con && list) {
1790     bRotateLikeConstraint *data = con->data;
1791     bConstraintTarget *ct = list->first;
1792
1793     /* the following macro is used for all standard single-target constraints */
1794     SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, no_copy);
1795   }
1796 }
1797
1798 static void rotlike_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets)
1799 {
1800   bRotateLikeConstraint *data = con->data;
1801   bConstraintTarget *ct = targets->first;
1802
1803   if (VALID_CONS_TARGET(ct)) {
1804     float loc[3];
1805     float eul[3], obeul[3];
1806     float size[3];
1807
1808     copy_v3_v3(loc, cob->matrix[3]);
1809     mat4_to_size(size, cob->matrix);
1810
1811     /* To allow compatible rotations, must get both rotations in the order of the owner... */
1812     mat4_to_eulO(obeul, cob->rotOrder, cob->matrix);
1813     /* We must get compatible eulers from the beginning because
1814      * some of them can be modified below (see bug T21875). */
1815     mat4_to_compatible_eulO(eul, obeul, cob->rotOrder, ct->matrix);
1816
1817     if ((data->flag & ROTLIKE_X) == 0) {
1818       eul[0] = obeul[0];
1819     }
1820     else {
1821       if (data->flag & ROTLIKE_OFFSET) {
1822         rotate_eulO(eul, cob->rotOrder, 'X', obeul[0]);
1823       }
1824
1825       if (data->flag & ROTLIKE_X_INVERT) {
1826         eul[0] *= -1;
1827       }
1828     }
1829
1830     if ((data->flag & ROTLIKE_Y) == 0) {
1831       eul[1] = obeul[1];
1832     }
1833     else {
1834       if (data->flag & ROTLIKE_OFFSET) {
1835         rotate_eulO(eul, cob->rotOrder, 'Y', obeul[1]);
1836       }
1837
1838       if (data->flag & ROTLIKE_Y_INVERT) {
1839         eul[1] *= -1;
1840       }
1841     }
1842
1843     if ((data->flag & ROTLIKE_Z) == 0) {
1844       eul[2] = obeul[2];
1845     }
1846     else {
1847       if (data->flag & ROTLIKE_OFFSET) {
1848         rotate_eulO(eul, cob->rotOrder, 'Z', obeul[2]);
1849       }
1850
1851       if (data->flag & ROTLIKE_Z_INVERT) {
1852         eul[2] *= -1;
1853       }
1854     }
1855
1856     /* Good to make eulers compatible again,
1857      * since we don't know how much they were changed above. */
1858     compatible_eul(eul, obeul);
1859     loc_eulO_size_to_mat4(cob->matrix, loc, eul, size, cob->rotOrder);
1860   }
1861 }
1862
1863 static bConstraintTypeInfo CTI_ROTLIKE = {
1864     CONSTRAINT_TYPE_ROTLIKE,       /* type */
1865     sizeof(bRotateLikeConstraint), /* size */
1866     "Copy Rotation",               /* name */
1867     "bRotateLikeConstraint",       /* struct name */
1868     NULL,                          /* free data */
1869     rotlike_id_looper,             /* id looper */
1870     NULL,                          /* copy data */
1871     rotlike_new_data,              /* new data */
1872     rotlike_get_tars,              /* get constraint targets */
1873     rotlike_flush_tars,            /* flush constraint targets */
1874     default_get_tarmat,            /* get target matrix */
1875     rotlike_evaluate,              /* evaluate */
1876 };
1877
1878 /* ---------- Copy Scale ---------- */
1879
1880 static void sizelike_new_data(void *cdata)
1881 {
1882   bSizeLikeConstraint *data = (bSizeLikeConstraint *)cdata;
1883
1884   data->flag = SIZELIKE_X | SIZELIKE_Y | SIZELIKE_Z | SIZELIKE_MULTIPLY;
1885 }
1886
1887 static void sizelike_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata)
1888 {
1889   bSizeLikeConstraint *data = con->data;
1890
1891   /* target only */
1892   func(con, (ID **)&data->tar, false, userdata);
1893 }
1894
1895 static int sizelike_get_tars(bConstraint *con, ListBase *list)
1896 {
1897   if (con && list) {
1898     bSizeLikeConstraint *data = con->data;
1899     bConstraintTarget *ct;
1900
1901     /* standard target-getting macro for single-target constraints */
1902     SINGLETARGET_GET_TARS(con, data->tar, data->subtarget, ct, list);
1903
1904     return 1;
1905   }
1906
1907   return 0;
1908 }
1909
1910 static void sizelike_flush_tars(bConstraint *con, ListBase *list, bool no_copy)
1911 {
1912   if (con && list) {
1913     bSizeLikeConstraint *data = con->data;
1914     bConstraintTarget *ct = list->first;
1915
1916     /* the following macro is used for all standard single-target constraints */
1917     SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, no_copy);
1918   }
1919 }
1920
1921 static void sizelike_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets)
1922 {
1923   bSizeLikeConstraint *data = con->data;
1924   bConstraintTarget *ct = targets->first;
1925
1926   if (VALID_CONS_TARGET(ct)) {
1927     float obsize[3], size[3];
1928
1929     mat4_to_size(size, ct->matrix);
1930     mat4_to_size(obsize, cob->matrix);
1931
1932     if (data->flag & SIZELIKE_OFFSET) {
1933       /* Scale is a multiplicative quantity, so adding it makes no sense.
1934        * However, the additive mode has to stay for backward compatibility. */
1935       if (data->flag & SIZELIKE_MULTIPLY) {
1936         /* size[i] *= obsize[i] */
1937         mul_v3_v3(size, obsize);
1938       }
1939       else {
1940         /* 2.7 compatibility mode: size[i] += (obsize[i] - 1.0f) */
1941         add_v3_v3(size, obsize);
1942         add_v3_fl(size, -1.0f);
1943       }
1944     }
1945
1946     if ((data->flag & SIZELIKE_X) && (obsize[0] != 0)) {
1947       mul_v3_fl(cob->matrix[0], size[0] / obsize[0]);
1948     }
1949     if ((data->flag & SIZELIKE_Y) && (obsize[1] != 0)) {
1950       mul_v3_fl(cob->matrix[1], size[1] / obsize[1]);
1951     }
1952     if ((data->flag & SIZELIKE_Z) && (obsize[2] != 0)) {
1953       mul_v3_fl(cob->matrix[2], size[2] / obsize[2]);
1954     }
1955   }
1956 }
1957
1958 static bConstraintTypeInfo CTI_SIZELIKE = {
1959     CONSTRAINT_TYPE_SIZELIKE,    /* type */
1960     sizeof(bSizeLikeConstraint), /* size */
1961     "Copy Scale",                /* name */
1962     "bSizeLikeConstraint",       /* struct name */
1963     NULL,                        /* free data */
1964     sizelike_id_looper,          /* id looper */
1965     NULL,                        /* copy data */
1966     sizelike_new_data,           /* new data */
1967     sizelike_get_tars,           /* get constraint targets */
1968     sizelike_flush_tars,         /* flush constraint targets */
1969     default_get_tarmat,          /* get target matrix */
1970     sizelike_evaluate,           /* evaluate */
1971 };
1972
1973 /* ----------- Copy Transforms ------------- */
1974
1975 static void translike_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata)
1976 {
1977   bTransLikeConstraint *data = con->data;
1978
1979   /* target only */
1980   func(con, (ID **)&data->tar, false, userdata);
1981 }
1982
1983 static int translike_get_tars(bConstraint *con, ListBase *list)
1984 {
1985   if (con && list) {
1986     bTransLikeConstraint *data = con->data;
1987     bConstraintTarget *ct;
1988
1989     /* standard target-getting macro for single-target constraints */
1990     SINGLETARGET_GET_TARS(con, data->tar, data->subtarget, ct, list);
1991
1992     return 1;
1993   }
1994
1995   return 0;
1996 }
1997
1998 static void translike_flush_tars(bConstraint *con, ListBase *list, bool no_copy)
1999 {
2000   if (con && list) {
2001     bTransLikeConstraint *data = con->data;
2002     bConstraintTarget *ct = list->first;
2003
2004     /* the following macro is used for all standard single-target constraints */
2005     SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, no_copy);
2006   }
2007 }
2008
2009 static void translike_evaluate(bConstraint *UNUSED(con), bConstraintOb *cob, ListBase *targets)
2010 {
2011   bConstraintTarget *ct = targets->first;
2012
2013   if (VALID_CONS_TARGET(ct)) {
2014     /* just copy the entire transform matrix of the target */
2015     copy_m4_m4(cob->matrix, ct->matrix);
2016   }
2017 }
2018
2019 static bConstraintTypeInfo CTI_TRANSLIKE = {
2020     CONSTRAINT_TYPE_TRANSLIKE,     /* type */
2021     sizeof(bTransLikeConstraint),  /* size */
2022     "Copy Transforms",             /* name */
2023     "bTransLikeConstraint",        /* struct name */
2024     NULL,                          /* free data */
2025     translike_id_looper,           /* id looper */
2026     NULL,                          /* copy data */
2027     NULL,                          /* new data */
2028     translike_get_tars,            /* get constraint targets */
2029     translike_flush_tars,          /* flush constraint targets */
2030     default_get_tarmat_full_bbone, /* get target matrix */
2031     translike_evaluate,            /* evaluate */
2032 };
2033
2034 /* ---------- Maintain Volume ---------- */
2035
2036 static void samevolume_new_data(void *cdata)
2037 {
2038   bSameVolumeConstraint *data = (bSameVolumeConstraint *)cdata;
2039
2040   data->flag = SAMEVOL_Y;
2041   data->volume = 1.0f;
2042 }
2043
2044 static void samevolume_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *UNUSED(targets))
2045 {
2046   bSameVolumeConstraint *data = con->data;
2047
2048   float volume = data->volume;
2049   float fac = 1.0f, total_scale;
2050   float obsize[3];
2051
2052   mat4_to_size(obsize, cob->matrix);
2053
2054   /* calculate normalizing scale factor for non-essential values */
2055   total_scale = obsize[0] * obsize[1] * obsize[2];
2056   if (total_scale != 0) {
2057     fac = sqrtf(volume / total_scale);
2058   }
2059
2060   /* apply scaling factor to the channels not being kept */
2061   switch (data->flag) {
2062     case SAMEVOL_X:
2063       mul_v3_fl(cob->matrix[1], fac);
2064       mul_v3_fl(cob->matrix[2], fac);
2065       break;
2066     case SAMEVOL_Y:
2067       mul_v3_fl(cob->matrix[0], fac);
2068       mul_v3_fl(cob->matrix[2], fac);
2069       break;
2070     case SAMEVOL_Z:
2071       mul_v3_fl(cob->matrix[0], fac);
2072       mul_v3_fl(cob->matrix[1], fac);
2073       break;
2074   }
2075 }
2076
2077 static bConstraintTypeInfo CTI_SAMEVOL = {
2078     CONSTRAINT_TYPE_SAMEVOL,       /* type */
2079     sizeof(bSameVolumeConstraint), /* size */
2080     "Maintain Volume",             /* name */
2081     "bSameVolumeConstraint",       /* struct name */
2082     NULL,                          /* free data */
2083     NULL,                          /* id looper */
2084     NULL,                          /* copy data */
2085     samevolume_new_data,           /* new data */
2086     NULL,                          /* get constraint targets */
2087     NULL,                          /* flush constraint targets */
2088     NULL,                          /* get target matrix */
2089     samevolume_evaluate,           /* evaluate */
2090 };
2091
2092 /* ----------- Python Constraint -------------- */
2093
2094 static void pycon_free(bConstraint *con)
2095 {
2096   bPythonConstraint *data = con->data;
2097
2098   /* id-properties */
2099   IDP_FreeProperty(data->prop);
2100   MEM_freeN(data->prop);
2101
2102   /* multiple targets */
2103   BLI_freelistN(&data->targets);
2104 }
2105
2106 static void pycon_copy(bConstraint *con, bConstraint *srccon)
2107 {
2108   bPythonConstraint *pycon = (bPythonConstraint *)con->data;
2109   bPythonConstraint *opycon = (bPythonConstraint *)srccon->data;
2110
2111   pycon->prop = IDP_CopyProperty(opycon->prop);
2112   BLI_duplicatelist(&pycon->targets, &opycon->targets);
2113 }
2114
2115 static void pycon_new_data(void *cdata)
2116 {
2117   bPythonConstraint *data = (bPythonConstraint *)cdata;
2118
2119   /* everything should be set correctly by calloc, except for the prop->type constant.*/
2120   data->prop = MEM_callocN(sizeof(IDProperty), "PyConstraintProps");
2121   data->prop->type = IDP_GROUP;
2122 }
2123
2124 static int pycon_get_tars(bConstraint *con, ListBase *list)
2125 {
2126   if (con && list) {
2127     bPythonConstraint *data = con->data;
2128
2129     list->first = data->targets.first;
2130     list->last = data->targets.last;
2131
2132     return data->tarnum;
2133   }
2134
2135   return 0;
2136 }
2137
2138 static void pycon_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata)
2139 {
2140   bPythonConstraint *data = con->data;
2141   bConstraintTarget *ct;
2142
2143   /* targets */
2144   for (ct = data->targets.first; ct; ct = ct->next) {
2145     func(con, (ID **)&ct->tar, false, userdata);
2146   }
2147
2148   /* script */
2149   func(con, (ID **)&data->text, true, userdata);
2150 }
2151
2152 /* Whether this approach is maintained remains to be seen (aligorith) */
2153 static void pycon_get_tarmat(struct Depsgraph *UNUSED(depsgraph),
2154                              bConstraint *con,
2155                              bConstraintOb *UNUSED(cob),
2156                              bConstraintTarget *ct,
2157                              float UNUSED(ctime))
2158 {
2159 #ifdef WITH_PYTHON
2160   bPythonConstraint *data = con->data;
2161 #endif
2162
2163   if (VALID_CONS_TARGET(ct)) {
2164     if (ct->tar->type == OB_CURVE && ct->tar->runtime.curve_cache == NULL) {
2165       unit_m4(ct->matrix);
2166       return;
2167     }
2168
2169     /* firstly calculate the matrix the normal way, then let the py-function override
2170      * this matrix if it needs to do so
2171      */
2172     constraint_target_to_mat4(ct->tar,
2173                               ct->subtarget,
2174                               ct->matrix,
2175                               CONSTRAINT_SPACE_WORLD,
2176                               ct->space,
2177                               con->flag,
2178                               con->headtail);
2179
2180     /* only execute target calculation if allowed */
2181 #ifdef WITH_PYTHON
2182     if (G.f & G_FLAG_SCRIPT_AUTOEXEC) {
2183       BPY_pyconstraint_target(data, ct);
2184     }
2185 #endif
2186   }
2187   else if (ct) {
2188     unit_m4(ct->matrix);
2189   }
2190 }
2191
2192 static void pycon_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets)
2193 {
2194 #ifndef WITH_PYTHON
2195   UNUSED_VARS(con, cob, targets);
2196   return;
2197 #else
2198   bPythonConstraint *data = con->data;
2199
2200   /* only evaluate in python if we're allowed to do so */
2201   if ((G.f & G_FLAG_SCRIPT_AUTOEXEC) == 0) {
2202     return;
2203   }
2204
2205   /* Now, run the actual 'constraint' function, which should only access the matrices */
2206   BPY_pyconstraint_exec(data, cob, targets);
2207 #endif /* WITH_PYTHON */
2208 }
2209
2210 static bConstraintTypeInfo CTI_PYTHON = {
2211     CONSTRAINT_TYPE_PYTHON,    /* type */
2212     sizeof(bPythonConstraint), /* size */
2213     "Script",                  /* name */
2214     "bPythonConstraint",       /* struct name */
2215     pycon_free,                /* free data */
2216     pycon_id_looper,           /* id looper */
2217     pycon_copy,                /* copy data */
2218     pycon_new_data,            /* new data */
2219     pycon_get_tars,            /* get constraint targets */
2220     NULL,                      /* flush constraint targets */
2221     pycon_get_tarmat,          /* get target matrix */
2222     pycon_evaluate,            /* evaluate */
2223 };
2224
2225 /* ----------- Armature Constraint -------------- */
2226
2227 static void armdef_free(bConstraint *con)
2228 {
2229   bArmatureConstraint *data = con->data;
2230
2231   /* Target list. */
2232   BLI_freelistN(&data->targets);
2233 }
2234
2235 static void armdef_copy(bConstraint *con, bConstraint *srccon)
2236 {
2237   bArmatureConstraint *pcon = (bArmatureConstraint *)con->data;
2238   bArmatureConstraint *opcon = (bArmatureConstraint *)srccon->data;
2239
2240   BLI_duplicatelist(&pcon->targets, &opcon->targets);
2241 }
2242
2243 static int armdef_get_tars(bConstraint *con, ListBase *list)
2244 {
2245   if (con && list) {
2246     bArmatureConstraint *data = con->data;
2247
2248     *list = data->targets;
2249
2250     return BLI_listbase_count(&data->targets);
2251   }
2252
2253   return 0;
2254 }
2255
2256 static void armdef_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata)
2257 {
2258   bArmatureConstraint *data = con->data;
2259   bConstraintTarget *ct;
2260
2261   /* Target list. */
2262   for (ct = data->targets.first; ct; ct = ct->next) {
2263     func(con, (ID **)&ct->tar, false, userdata);
2264   }
2265 }
2266
2267 /* Compute the world space pose matrix of the target bone. */
2268 static void armdef_get_tarmat(struct Depsgraph *UNUSED(depsgraph),
2269                               bConstraint *UNUSED(con),
2270                               bConstraintOb *UNUSED(cob),
2271                               bConstraintTarget *ct,
2272                               float UNUSED(ctime))
2273 {
2274   if (ct != NULL) {
2275     if (ct->tar && ct->tar->type == OB_ARMATURE) {
2276       bPoseChannel *pchan = BKE_pose_channel_find_name(ct->tar->pose, ct->subtarget);
2277
2278       if (pchan != NULL) {
2279         mul_m4_m4m4(ct->matrix, ct->tar->obmat, pchan->pose_mat);
2280         return;
2281       }
2282     }
2283
2284     unit_m4(ct->matrix);
2285   }
2286 }
2287
2288 static void armdef_accumulate_matrix(float obmat[4][4],
2289                                      float iobmat[4][4],
2290                                      float basemat[4][4],
2291                                      float bonemat[4][4],
2292                                      float weight,
2293                                      float r_sum_mat[4][4],
2294                                      DualQuat *r_sum_dq)
2295 {
2296   if (weight == 0.0f) {
2297     return;
2298   }
2299
2300   /* Convert the selected matrix into object space. */
2301   float mat[4][4];
2302   mul_m4_series(mat, obmat, bonemat, iobmat);
2303
2304   /* Accumulate the transformation. */
2305   if (r_sum_dq != NULL) {
2306     DualQuat tmpdq;
2307
2308     mat4_to_dquat(&tmpdq, basemat, mat);
2309     add_weighted_dq_dq(r_sum_dq, &tmpdq, weight);
2310   }
2311   else {
2312     madd_m4_m4m4fl(r_sum_mat, r_sum_mat, mat, weight);
2313   }
2314 }
2315
2316 /* Compute and accumulate transformation for a single target bone. */
2317 static void armdef_accumulate_bone(bConstraintTarget *ct,
2318                                    bPoseChannel *pchan,
2319                                    const float wco[3],
2320                                    bool force_envelope,
2321                                    float *r_totweight,
2322                                    float r_sum_mat[4][4],
2323                                    DualQuat *r_sum_dq)
2324 {
2325   float iobmat[4][4], basemat[4][4], co[3];
2326   Bone *bone = pchan->bone;
2327   float weight = ct->weight;
2328
2329   /* Our object's location in target pose space. */
2330   invert_m4_m4(iobmat, ct->tar->obmat);
2331   mul_v3_m4v3(co, iobmat, wco);
2332
2333   /* Multiply by the envelope weight when appropriate. */
2334   if (force_envelope || (bone->flag & BONE_MULT_VG_ENV)) {
2335     weight *= distfactor_to_bone(
2336         co, bone->arm_head, bone->arm_tail, bone->rad_head, bone->rad_tail, bone->dist);
2337   }
2338
2339   /* Compute the quaternion base matrix. */
2340   if (r_sum_dq != NULL) {
2341     mul_m4_series(basemat, ct->tar->obmat, bone->arm_mat, iobmat);
2342   }
2343
2344   /* Find the correct bone transform matrix in world space. */
2345   if (bone->segments > 1 && bone->segments == pchan->runtime.bbone_segments) {
2346     Mat4 *b_bone_mats = pchan->runtime.bbone_deform_mats;
2347     float(*iamat)[4] = b_bone_mats[0].mat;
2348
2349     /* The target is a B-Bone:
2350      * FIRST: find the segment (see b_bone_deform in armature.c)
2351      * Need to transform co back to bonespace, only need y. */
2352     float y = iamat[0][1] * co[0] + iamat[1][1] * co[1] + iamat[2][1] * co[2] + iamat[3][1];
2353
2354     /* Blend the matrix. */
2355     int index;
2356     float blend;
2357     BKE_pchan_bbone_deform_segment_index(pchan, y / bone->length, &index, &blend);
2358
2359     armdef_accumulate_matrix(ct->tar->obmat,
2360                              iobmat,
2361                              basemat,
2362                              b_bone_mats[index + 1].mat,
2363                              weight * (1.0f - blend),
2364                              r_sum_mat,
2365                              r_sum_dq);
2366     armdef_accumulate_matrix(ct->tar->obmat,
2367                              iobmat,
2368                              basemat,
2369                              b_bone_mats[index + 2].mat,
2370                              weight * blend,
2371                              r_sum_mat,
2372                              r_sum_dq);
2373   }
2374   else {
2375     /* Simple bone. This requires DEG_OPCODE_BONE_DONE dependency due to chan_mat. */
2376     armdef_accumulate_matrix(
2377         ct->tar->obmat, iobmat, basemat, pchan->chan_mat, weight, r_sum_mat, r_sum_dq);
2378   }
2379
2380   /* Accumulate the weight. */
2381   *r_totweight += weight;
2382 }
2383
2384 static void armdef_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets)
2385 {
2386   bArmatureConstraint *data = con->data;
2387
2388   float sum_mat[4][4], input_co[3];
2389   DualQuat sum_dq;
2390   float weight = 0.0f;
2391
2392   /* Prepare for blending. */
2393   zero_m4(sum_mat);
2394   memset(&sum_dq, 0, sizeof(sum_dq));
2395
2396   DualQuat *pdq = (data->flag & CONSTRAINT_ARMATURE_QUATERNION) ? &sum_dq : NULL;
2397   bool use_envelopes = (data->flag & CONSTRAINT_ARMATURE_ENVELOPE) != 0;
2398
2399   if (cob->pchan && cob->pchan->bone && !(data->flag & CONSTRAINT_ARMATURE_CUR_LOCATION)) {
2400     /* For constraints on bones, use the rest position to bind b-bone segments
2401      * and envelopes, to allow safely changing the bone location as if parented. */
2402     copy_v3_v3(input_co, cob->pchan->bone->arm_head);
2403     mul_m4_v3(cob->ob->obmat, input_co);
2404   }
2405   else {
2406     copy_v3_v3(input_co, cob->matrix[3]);
2407   }
2408
2409   /* Process all targets. */
2410   for (bConstraintTarget *ct = targets->first; ct; ct = ct->next) {
2411     if (ct->weight <= 0.0f) {
2412       continue;
2413     }
2414
2415     /* Lookup the bone and abort if failed. */
2416     if (!VALID_CONS_TARGET(ct) || ct->tar->type != OB_ARMATURE) {
2417       return;
2418     }
2419
2420     bPoseChannel *pchan = BKE_pose_channel_find_name(ct->tar->pose, ct->subtarget);
2421
2422     if (pchan == NULL || pchan->bone == NULL) {
2423       return;
2424     }
2425
2426     armdef_accumulate_bone(ct, pchan, input_co, use_envelopes, &weight, sum_mat, pdq);
2427   }
2428
2429   /* Compute the final transform. */
2430   if (weight > 0.0f) {
2431     if (pdq != NULL) {
2432       normalize_dq(pdq, weight);
2433       dquat_to_mat4(sum_mat, pdq);
2434     }
2435     else {
2436       mul_m4_fl(sum_mat, 1.0f / weight);
2437     }
2438
2439     /* Apply the transform to the result matrix. */
2440     mul_m4_m4m4(cob->matrix, sum_mat, cob->matrix);
2441   }
2442 }
2443
2444 static bConstraintTypeInfo CTI_ARMATURE = {
2445     CONSTRAINT_TYPE_ARMATURE,    /* type */
2446     sizeof(bArmatureConstraint), /* size */
2447     "Armature",                  /* name */
2448     "bArmatureConstraint",       /* struct name */
2449     armdef_free,                 /* free data */
2450     armdef_id_looper,            /* id looper */
2451     armdef_copy,                 /* copy data */
2452     NULL,                        /* new data */
2453     armdef_get_tars,             /* get constraint targets */
2454     NULL,                        /* flush constraint targets */
2455     armdef_get_tarmat,           /* get target matrix */
2456     armdef_evaluate,             /* evaluate */
2457 };
2458
2459 /* -------- Action Constraint ----------- */
2460
2461 static void actcon_new_data(void *cdata)
2462 {
2463   bActionConstraint *data = (bActionConstraint *)cdata;
2464
2465   /* set type to 20 (Loc X), as 0 is Rot X for backwards compatibility */
2466   data->type = 20;
2467 }
2468
2469 static void actcon_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata)
2470 {
2471   bActionConstraint *data = con->data;
2472
2473   /* target */
2474   func(con, (ID **)&data->tar, false, userdata);
2475
2476   /* action */
2477   func(con, (ID **)&data->act, true, userdata);
2478 }
2479
2480 static int actcon_get_tars(bConstraint *con, ListBase *list)
2481 {
2482   if (con && list) {
2483     bActionConstraint *data = con->data;
2484     bConstraintTarget *ct;
2485
2486     /* standard target-getting macro for single-target constraints */
2487     SINGLETARGET_GET_TARS(con, data->tar, data->subtarget, ct, list);
2488
2489     return 1;
2490   }
2491
2492   return 0;
2493 }
2494
2495 static void actcon_flush_tars(bConstraint *con, ListBase *list, bool no_copy)
2496 {
2497   if (con && list) {
2498     bActionConstraint *data = con->data;
2499     bConstraintTarget *ct = list->first;
2500
2501     /* the following macro is used for all standard single-target constraints */
2502     SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, no_copy);
2503   }
2504 }
2505
2506 static void actcon_get_tarmat(struct Depsgraph *UNUSED(depsgraph),
2507                               bConstraint *con,
2508                               bConstraintOb *cob,
2509                               bConstraintTarget *ct,
2510                               float UNUSED(ctime))
2511 {
2512   bActionConstraint *data = con->data;
2513
2514   if (VALID_CONS_TARGET(ct)) {
2515     float tempmat[4][4], vec[3];
2516     float s, t;
2517     short axis;
2518
2519     /* initialize return matrix */
2520     unit_m4(ct->matrix);
2521
2522     /* get the transform matrix of the target */
2523     constraint_target_to_mat4(ct->tar,
2524                               ct->subtarget,
2525                               tempmat,
2526                               CONSTRAINT_SPACE_WORLD,
2527                               ct->space,
2528                               con->flag,
2529                               con->headtail);
2530
2531     /* determine where in transform range target is */
2532     /* data->type is mapped as follows for backwards compatibility:
2533      * 00,01,02 - rotation (it used to be like this)
2534      * 10,11,12 - scaling
2535      * 20,21,22 - location
2536      */
2537     if (data->type < 10) {
2538       /* extract rotation (is in whatever space target should be in) */
2539       mat4_to_eul(vec, tempmat);
2540       mul_v3_fl(vec, RAD2DEGF(1.0f)); /* rad -> deg */
2541       axis = data->type;
2542     }
2543     else if (data->type < 20) {
2544       /* extract scaling (is in whatever space target should be in) */
2545       mat4_to_size(vec, tempmat);
2546       axis = data->type - 10;
2547     }
2548     else {
2549       /* extract location */
2550       copy_v3_v3(vec, tempmat[3]);
2551       axis = data->type - 20;
2552     }
2553
2554     BLI_assert((unsigned int)axis < 3);
2555
2556     /* Target defines the animation */
2557     s = (vec[axis] - data->min) / (data->max - data->min);
2558     CLAMP(s, 0, 1);
2559     t = (s * (data->end - data->start)) + data->start;
2560
2561     if (G.debug & G_DEBUG) {
2562       printf("do Action Constraint %s - Ob %s Pchan %s\n",
2563              con->name,
2564              cob->ob->id.name + 2,
2565              (cob->pchan) ? cob->pchan->name : NULL);
2566     }
2567
2568     /* Get the appropriate information from the action */
2569     if (cob->type == CONSTRAINT_OBTYPE_OBJECT || (data->flag & ACTCON_BONE_USE_OBJECT_ACTION)) {
2570       Object workob;
2571
2572       /* evaluate using workob */
2573       /* FIXME: we don't have any consistent standards on limiting effects on object... */
2574       what_does_obaction(cob->ob, &workob, NULL, data->act, NULL, t);
2575       BKE_object_to_mat4(&workob, ct->matrix);
2576     }
2577     else if (cob->type == CONSTRAINT_OBTYPE_BONE) {
2578       Object workob;
2579       bPose pose = {{0}};
2580       bPoseChannel *pchan, *tchan;
2581
2582       /* make a copy of the bone of interest in the temp pose before evaluating action,
2583        * so that it can get set - we need to manually copy over a few settings,
2584        * including rotation order, otherwise this fails. */
2585       pchan = cob->pchan;
2586
2587       tchan = BKE_pose_channel_verify(&pose, pchan->name);
2588       tchan->rotmode = pchan->rotmode;
2589
2590       /* evaluate action using workob (it will only set the PoseChannel in question) */
2591       what_does_obaction(cob->ob, &workob, &pose, data->act, pchan->name, t);
2592
2593       /* convert animation to matrices for use here */
2594       BKE_pchan_calc_mat(tchan);
2595       copy_m4_m4(ct->matrix, tchan->chan_mat);
2596
2597       /* Clean up */
2598       BKE_pose_free_data(&pose);
2599     }
2600     else {
2601       /* behavior undefined... */
2602       puts("Error: unknown owner type for Action Constraint");
2603     }
2604   }
2605 }
2606
2607 static void actcon_evaluate(bConstraint *UNUSED(con), bConstraintOb *cob, ListBase *targets)
2608 {
2609   bConstraintTarget *ct = targets->first;
2610
2611   if (VALID_CONS_TARGET(ct)) {
2612     float temp[4][4];
2613
2614     /* Nice and simple... we just need to multiply the matrices, as the get_target_matrix
2615      * function has already taken care of everything else.
2616      */
2617     copy_m4_m4(temp, cob->matrix);
2618     mul_m4_m4m4(cob->matrix, temp, ct->matrix);
2619   }
2620 }
2621
2622 static bConstraintTypeInfo CTI_ACTION = {
2623     CONSTRAINT_TYPE_ACTION,    /* type */
2624     sizeof(bActionConstraint), /* size */
2625     "Action",                  /* name */
2626     "bActionConstraint",       /* struct name */
2627     NULL,                      /* free data */
2628     actcon_id_looper,          /* id looper */
2629     NULL,                      /* copy data */
2630     actcon_new_data,           /* new data */
2631     actcon_get_tars,           /* get constraint targets */
2632     actcon_flush_tars,         /* flush constraint targets */
2633     actcon_get_tarmat,         /* get target matrix */
2634     actcon_evaluate,           /* evaluate */
2635 };
2636
2637 /* --------- Locked Track ---------- */
2638
2639 static void locktrack_new_data(void *cdata)
2640 {
2641   bLockTrackConstraint *data = (bLockTrackConstraint *)cdata;
2642
2643   data->trackflag = TRACK_Y;
2644   data->lockflag = LOCK_Z;
2645 }
2646
2647 static void locktrack_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata)
2648 {
2649   bLockTrackConstraint *data = con->data;
2650
2651   /* target only */
2652   func(con, (ID **)&data->tar, false, userdata);
2653 }
2654
2655 static int locktrack_get_tars(bConstraint *con, ListBase *list)
2656 {
2657   if (con && list) {
2658     bLockTrackConstraint *data = con->data;
2659     bConstraintTarget *ct;
2660
2661     /* the following macro is used for all standard single-target constraints */
2662     SINGLETARGET_GET_TARS(con, data->tar, data->subtarget, ct, list);
2663
2664     return 1;
2665   }
2666
2667   return 0;
2668 }
2669
2670 static void locktrack_flush_tars(bConstraint *con, ListBase *list, bool no_copy)
2671 {
2672   if (con && list) {
2673     bLockTrackConstraint *data = con->data;
2674     bConstraintTarget *ct = list->first;
2675
2676     /* the following macro is used for all standard single-target constraints */
2677     SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, no_copy);
2678   }
2679 }
2680
2681 static void locktrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets)
2682 {
2683   bLockTrackConstraint *data = con->data;
2684   bConstraintTarget *ct = targets->first;
2685
2686   if (VALID_CONS_TARGET(ct)) {
2687     float vec[3], vec2[3];
2688     float totmat[3][3];
2689     float tmpmat[3][3];
2690     float invmat[3][3];
2691     float mdet;
2692
2693     /* Vector object -> target */
2694     sub_v3_v3v3(vec, ct->matrix[3], cob->matrix[3]);
2695     switch (data->lockflag) {
2696       case LOCK_X: /* LOCK X */
2697       {
2698         switch (data->trackflag) {
2699           case TRACK_Y: /* LOCK X TRACK Y */
2700           {
2701             /* Projection of Vector on the plane */
2702             project_v3_v3v3(vec2, vec, cob->matrix[0]);
2703             sub_v3_v3v3(totmat[1], vec, vec2);
2704             normalize_v3(totmat[1]);
2705
2706             /* the x axis is fixed */
2707             normalize_v3_v3(totmat[0], cob->matrix[0]);
2708
2709             /* the z axis gets mapped onto a third orthogonal vector */
2710             cross_v3_v3v3(totmat[2], totmat[0], totmat[1]);
2711             break;
2712           }
2713           case TRACK_Z: /* LOCK X TRACK Z */
2714           {
2715             /* Projection of Vector on the plane */
2716             project_v3_v3v3(vec2, vec, cob->matrix[0]);
2717             sub_v3_v3v3(totmat[2], vec, vec2);
2718             normalize_v3(totmat[2]);
2719
2720             /* the x axis is fixed */
2721             normalize_v3_v3(totmat[0], cob->matrix[0]);
2722
2723             /* the z axis gets mapped onto a third orthogonal vector */
2724             cross_v3_v3v3(totmat[1], totmat[2], totmat[0]);
2725             break;
2726           }
2727           case TRACK_nY: /* LOCK X TRACK -Y */
2728           {
2729             /* Projection of Vector on the plane */
2730             project_v3_v3v3(vec2, vec, cob->matrix[0]);
2731             sub_v3_v3v3(totmat[1], vec, vec2);
2732             normalize_v3(totmat[1]);
2733             negate_v3(totmat[1]);
2734
2735             /* the x axis is fixed */
2736             normalize_v3_v3(totmat[0], cob->matrix[0]);
2737
2738             /* the z axis gets mapped onto a third orthogonal vector */
2739             cross_v3_v3v3(totmat[2], totmat[0], totmat[1]);
2740             break;
2741           }
2742           case TRACK_nZ: /* LOCK X TRACK -Z */
2743           {
2744             /* Projection of Vector on the plane */
2745             project_v3_v3v3(vec2, vec, cob->matrix[0]);
2746             sub_v3_v3v3(totmat[2], vec, vec2);
2747             normalize_v3(totmat[2]);
2748             negate_v3(totmat[2]);
2749
2750             /* the x axis is fixed */
2751             normalize_v3_v3(totmat[0], cob->matrix[0]);
2752
2753             /* the z axis gets mapped onto a third orthogonal vector */
2754             cross_v3_v3v3(totmat[1], totmat[2], totmat[0]);
2755             break;
2756           }
2757           default: {
2758             unit_m3(totmat);
2759             break;
2760           }
2761         }
2762         break;
2763       }
2764       case LOCK_Y: /* LOCK Y */
2765       {
2766         switch (data->trackflag) {
2767           case TRACK_X: /* LOCK Y TRACK X */
2768           {
2769             /* Projection of Vector on the plane */
2770             project_v3_v3v3(vec2, vec, cob->matrix[1]);
2771             sub_v3_v3v3(totmat[0], vec, vec2);
2772             normalize_v3(totmat[0]);
2773
2774             /* the y axis is fixed */
2775             normalize_v3_v3(totmat[1], cob->matrix[1]);
2776
2777             /* the z axis gets mapped onto a third orthogonal vector */
2778             cross_v3_v3v3(totmat[2], totmat[0], totmat[1]);
2779             break;
2780           }
2781           case TRACK_Z: /* LOCK Y TRACK Z */
2782           {
2783             /* Projection of Vector on the plane */
2784             project_v3_v3v3(vec2, vec, cob->matrix[1]);
2785             sub_v3_v3v3(totmat[2], vec, vec2);
2786             normalize_v3(totmat[2]);
2787
2788             /* the y axis is fixed */
2789             normalize_v3_v3(totmat[1], cob->matrix[1]);
2790
2791             /* the z axis gets mapped onto a third orthogonal vector */
2792             cross_v3_v3v3(totmat[0], totmat[1], totmat[2]);
2793             break;
2794           }
2795           case TRACK_nX: /* LOCK Y TRACK -X */
2796           {
2797             /* Projection of Vector on the plane */
2798             project_v3_v3v3(vec2, vec, cob->matrix[1]);
2799             sub_v3_v3v3(totmat[0], vec, vec2);
2800             normalize_v3(totmat[0]);
2801             negate_v3(totmat[0]);
2802
2803             /* the y axis is fixed */
2804             normalize_v3_v3(totmat[1], cob->matrix[1]);
2805
2806             /* the z axis gets mapped onto a third orthogonal vector */
2807             cross_v3_v3v3(totmat[2], totmat[0], totmat[1]);
2808             break;
2809           }
2810           case TRACK_nZ: /* LOCK Y TRACK -Z */
2811           {
2812             /* Projection of Vector on the plane */
2813             project_v3_v3v3(vec2, vec, cob->matrix[1]);
2814             sub_v3_v3v3(totmat[2], vec, vec2);
2815             normalize_v3(totmat[2]);
2816             negate_v3(totmat[2]);
2817
2818             /* the y axis is fixed */
2819             normalize_v3_v3(totmat[1], cob->matrix[1]);
2820
2821             /* the z axis gets mapped onto a third orthogonal vector */
2822             cross_v3_v3v3(totmat[0], totmat[1], totmat[2]);
2823             break;
2824           }
2825           default: {
2826             unit_m3(totmat);
2827             break;
2828           }
2829         }
2830         break;
2831       }
2832       case LOCK_Z: /* LOCK Z */
2833       {
2834         switch (data->trackflag) {
2835           case TRACK_X: /* LOCK Z TRACK X */
2836           {
2837             /* Projection of Vector on the plane */
2838             project_v3_v3v3(vec2, vec, cob->matrix[2]);
2839             sub_v3_v3v3(totmat[0], vec, vec2);
2840             normalize_v3(totmat[0]);
2841
2842             /* the z axis is fixed */
2843             normalize_v3_v3(totmat[2], cob->matrix[2]);
2844
2845             /* the x axis gets mapped onto a third orthogonal vector */
2846             cross_v3_v3v3(totmat[1], totmat[2], totmat[0]);
2847             break;
2848           }
2849           case TRACK_Y: /* LOCK Z TRACK Y */
2850           {
2851             /* Projection of Vector on the plane */
2852             project_v3_v3v3(vec2, vec, cob->matrix[2]);
2853             sub_v3_v3v3(totmat[1], vec, vec2);
2854             normalize_v3(totmat[1]);
2855
2856             /* the z axis is fixed */
2857             normalize_v3_v3(totmat[2], cob->matrix[2]);
2858
2859             /* the x axis gets mapped onto a third orthogonal vector */
2860             cross_v3_v3v3(totmat[0], totmat[1], totmat[2]);
2861             break;
2862           }
2863           case TRACK_nX: /* LOCK Z TRACK -X */
2864           {
2865             /* Projection of Vector on the plane */
2866             project_v3_v3v3(vec2, vec, cob->matrix[2]);
2867             sub_v3_v3v3(totmat[0], vec, vec2);
2868             normalize_v3(totmat[0]);
2869             negate_v3(totmat[0]);
2870
2871             /* the z axis is fixed */
2872             normalize_v3_v3(totmat[2], cob->matrix[2]);
2873
2874             /* the x axis gets mapped onto a third orthogonal vector */
2875             cross_v3_v3v3(totmat[1], totmat[2], totmat[0]);
2876             break;
2877           }
2878           case TRACK_nY: /* LOCK Z TRACK -Y */
2879           {
2880             /* Projection of Vector on the plane */
2881             project_v3_v3v3(vec2, vec, cob->matrix[2]);
2882             sub_v3_v3v3(totmat[1], vec, vec2);
2883             normalize_v3(totmat[1]);
2884             negate_v3(totmat[1]);
2885
2886             /* the z axis is fixed */
2887             normalize_v3_v3(totmat[2], cob->matrix[2]);
2888
2889             /* the x axis gets mapped onto a third orthogonal vector */
2890             cross_v3_v3v3(totmat[0], totmat[1], totmat[2]);
2891             break;
2892           }
2893           default: {
2894             unit_m3(totmat);
2895             break;
2896           }
2897         }
2898         break;
2899       }
2900       default: {
2901         unit_m3(totmat);
2902         break;
2903       }
2904     }
2905     /* Block to keep matrix heading */
2906     copy_m3_m4(tmpmat, cob->matrix);
2907     normalize_m3(tmpmat);
2908     invert_m3_m3(invmat, tmpmat);
2909     mul_m3_m3m3(tmpmat, totmat, invmat);
2910     totmat[0][0] = tmpmat[0][0];
2911     totmat[0][1] = tmpmat[0][1];
2912     totmat[0][2] = tmpmat[0][2];
2913     totmat[1][0] = tmpmat[1][0];
2914     totmat[1][1] = tmpmat[1][1];
2915     totmat[1][2] = tmpmat[1][2];
2916     totmat[2][0] = tmpmat[2][0];
2917     totmat[2][1] = tmpmat[2][1];
2918     totmat[2][2] = tmpmat[2][2];
2919
2920     mdet = determinant_m3(totmat[0][0],
2921                           totmat[0][1],
2922                           totmat[0][2],
2923                           totmat[1][0],
2924                           totmat[1][1],
2925                           totmat[1][2],
2926                           totmat[2][0],
2927                           totmat[2][1],
2928                           totmat[2][2]);
2929     if (mdet == 0) {
2930       unit_m3(totmat);
2931     }
2932
2933     /* apply out transformation to the object */
2934     mul_m4_m3m4(cob->matrix, totmat, cob->matrix);
2935   }
2936 }
2937
2938 static bConstraintTypeInfo CTI_LOCKTRACK = {
2939     CONSTRAINT_TYPE_LOCKTRACK,    /* type */
2940     sizeof(bLockTrackConstraint), /* size */
2941     "Locked Track",               /* name */
2942     "bLockTrackConstraint",       /* struct name */
2943     NULL,                         /* free data */
2944     locktrack_id_looper,          /* id looper */
2945     NULL,                         /* copy data */
2946     locktrack_new_data,           /* new data */
2947     locktrack_get_tars,           /* get constraint targets */
2948     locktrack_flush_tars,         /* flush constraint targets */
2949     default_get_tarmat,           /* get target matrix */
2950     locktrack_evaluate,           /* evaluate */
2951 };
2952
2953 /* ---------- Limit Distance Constraint ----------- */
2954
2955 static void distlimit_new_data(void *cdata)
2956 {
2957   bDistLimitConstraint *data = (bDistLimitConstraint *)cdata;
2958
2959   data->dist = 0.0f;
2960 }
2961
2962 static void distlimit_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata)
2963 {
2964   bDistLimitConstraint *data = con->data;
2965
2966   /* target only */
2967   func(con, (ID **)&data->tar, false, userdata);
2968 }
2969
2970 static int distlimit_get_tars(bConstraint *con, ListBase *list)
2971 {
2972   if (con && list) {
2973     bDistLimitConstraint *data = con->data;
2974     bConstraintTarget *ct;
2975
2976     /* standard target-getting macro for single-target constraints */
2977     SINGLETARGET_GET_TARS(con, data->tar, data->subtarget, ct, list);
2978
2979     return 1;
2980   }
2981
2982   return 0;
2983 }
2984
2985 static void distlimit_flush_tars(bConstraint *con, ListBase *list, bool no_copy)
2986 {
2987   if (con && list) {
2988     bDistLimitConstraint *data = con->data;
2989     bConstraintTarget *ct = list->first;
2990
2991     /* the following macro is used for all standard single-target constraints */
2992     SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, no_copy);
2993   }
2994 }
2995
2996 static void distlimit_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets)
2997 {
2998   bDistLimitConstraint *data = con->data;
2999   bConstraintTarget *ct = targets->first;
3000
3001   /* only evaluate if there is a target */
3002   if (VALID_CONS_TARGET(ct)) {
3003     float dvec[3], dist, sfac = 1.0f;
3004     short clamp_surf = 0;
3005
3006     /* calculate our current distance from the target */
3007     dist = len_v3v3(cob->matrix[3], ct->matrix[3]);
3008
3009     /* set distance (flag is only set when user demands it) */
3010     if (data->dist == 0) {
3011       data->dist = dist;
3012
3013       /* Write the computed distance back to the master copy if in COW evaluation. */
3014       bConstraint *orig_con = constraint_find_original_for_update(cob, con);
3015
3016       if (orig_con != NULL) {
3017         bDistLimitConstraint *orig_data = orig_con->data;
3018
3019         orig_data->dist = data->dist;
3020       }
3021     }
3022
3023     /* check if we're which way to clamp from, and calculate interpolation factor (if needed) */
3024     if (data->mode == LIMITDIST_OUTSIDE) {
3025       /* if inside, then move to surface */
3026       if (dist <= data->dist) {
3027         clamp_surf = 1;
3028         if (dist != 0.0f) {
3029           sfac = data->dist / dist;
3030         }
3031       }
3032       /* if soft-distance is enabled, start fading once owner is dist+softdist from the target */
3033       else if (data->flag & LIMITDIST_USESOFT) {
3034         if (dist <= (data->dist + data->soft)) {
3035           /* pass */
3036         }
3037       }
3038     }
3039     else if (data->mode == LIMITDIST_INSIDE) {
3040       /* if outside, then move to surface */
3041       if (dist >= data->dist) {
3042         clamp_surf = 1;
3043         if (dist != 0.0f) {
3044           sfac = data->dist / dist;
3045         }
3046       }
3047       /* if soft-distance is enabled, start fading once owner is dist-soft from the target */
3048       else if (data->flag & LIMITDIST_USESOFT) {
3049         /* FIXME: there's a problem with "jumping" when this kicks in */
3050         if (dist >= (data->dist - data->soft)) {
3051           sfac = (float)(data->soft * (1.0f - expf(-(dist - data->dist) / data->soft)) +
3052                          data->dist);
3053           if (dist != 0.0f) {
3054             sfac /= dist;
3055           }
3056
3057           clamp_surf = 1;
3058         }
3059       }
3060     }
3061     else {
3062       if (IS_EQF(dist, data->dist) == 0) {
3063         clamp_surf = 1;
3064         if (dist != 0.0f) {
3065           sfac = data->dist / dist;
3066         }
3067       }
3068     }
3069
3070     /* clamp to 'surface' (i.e. move owner so that dist == data->dist) */
3071     if (clamp_surf) {
3072       /* simply interpolate along line formed by target -> owner */
3073       interp_v3_v3v3(dvec, ct->matrix[3], cob->matrix[3], sfac);
3074
3075       /* copy new vector onto owner */
3076       copy_v3_v3(cob->matrix[3], dvec);
3077     }
3078   }
3079 }
3080
3081 static bConstraintTypeInfo CTI_DISTLIMIT = {
3082     CONSTRAINT_TYPE_DISTLIMIT,    /* type */
3083     sizeof(bDistLimitConstraint), /* size */
3084     "Limit Distance",             /* name */
3085     "bDistLimitConstraint",       /* struct name */
3086     NULL,                         /* free data */
3087     distlimit_id_looper,          /* id looper */
3088     NULL,                         /* copy data */
3089     distlimit_new_data,           /* new data */
3090     distlimit_get_tars,           /* get constraint targets */
3091     distlimit_flush_tars,         /* flush constraint targets */
3092     default_get_tarmat,           /* get a target matrix */
3093     distlimit_evaluate,           /* evaluate */
3094 };
3095
3096 /* ---------- Stretch To ------------ */
3097
3098 static void stretchto_new_data(void *cdata)
3099 {
3100   bStretchToConstraint *data = (bStretchToConstraint *)cdata;
3101
3102   data->volmode = 0;
3103   data->plane = 0;
3104   data->orglength = 0.0;
3105   data->bulge = 1.0;
3106   data->bulge_max = 1.0f;
3107   data->bulge_min = 1.0f;
3108 }
3109
3110 static void stretchto_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata)
3111 {
3112   bStretchToConstraint *data = con->data;
3113
3114   /* target only */
3115   func(con, (ID **)&data->tar, false, userdata);
3116 }
3117
3118 static int stretchto_get_tars(bConstraint *con, ListBase *list)
3119 {
3120   if (con && list) {
3121     bStretchToConstraint *data = con->data;
3122     bConstraintTarget *ct;
3123
3124     /* standard target-getting macro for single-target constraints */
3125     SINGLETARGET_GET_TARS(con, data->tar, data->subtarget, ct, list);
3126
3127     return 1;
3128   }
3129
3130   return 0;
3131 }
3132
3133 static void stretchto_flush_tars(bConstraint *con, ListBase *list, bool no_copy)
3134 {
3135   if (con && list) {
3136     bStretchToConstraint *data = con->data;
3137     bConstraintTarget *ct = list->first;
3138
3139     /* the following macro is used for all standard single-target constraints */
3140     SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, no_copy);
3141   }
3142 }
3143
3144 static void stretchto_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets)
3145 {
3146   bStretchToConstraint *data = con->data;
3147   bConstraintTarget *ct = targets->first;
3148
3149   /* only evaluate if there is a target */
3150   if (VALID_CONS_TARGET(ct)) {
3151     float size[3], scale[3], vec[3], xx[3], zz[3], orth[3];
3152     float totmat[3][3];
3153     float dist, bulge;
3154
3155     /* store scaling before destroying obmat */
3156     mat4_to_size(size, cob->matrix);
3157
3158     /* store X orientation before destroying obmat */
3159     normalize_v3_v3(xx, cob->matrix[0]);
3160
3161     /* store Z orientation before destroying obmat */
3162     normalize_v3_v3(zz, cob->matrix[2]);
3163
3164     /* XXX That makes the constraint buggy with asymmetrically scaled objects, see #29940. */
3165 #if 0
3166     sub_v3_v3v3(vec, cob->matrix[3], ct->matrix[3]);
3167     vec[0] /= size[0];
3168     vec[1] /= size[1];
3169     vec[2] /= size[2];
3170
3171     dist = normalize_v3(vec);
3172 #endif
3173
3174     dist = len_v3v3(cob->matrix[3], ct->matrix[3]);
3175     /* Only Y constrained object axis scale should be used, to keep same length when scaling it. */
3176     dist /= size[1];
3177
3178     /* data->orglength==0 occurs on first run, and after 'R' button is clicked */
3179     if (data->orglength == 0) {
3180       data->orglength = dist;
3181
3182       /* Write the computed length back to the master copy if in COW evaluation. */
3183       bConstraint *orig_con = constraint_find_original_for_update(cob, con);
3184
3185       if (orig_con != NULL) {
3186         bStretchToConstraint *orig_data = orig_con->data;
3187
3188         orig_data->orglength = data->orglength;
3189       }
3190     }
3191
3192     scale[1] = dist / data->orglength;
3193
3194     bulge = powf(data->orglength / dist, data->bulge);
3195
3196     if (bulge > 1.0f) {
3197       if (data->flag & STRETCHTOCON_USE_BULGE_MAX) {
3198         float bulge_max = max_ff(data->bulge_max, 1.0f);
3199         float hard = min_ff(bulge, bulge_max);
3200
3201         float range = bulge_max - 1.0f;
3202         float scale_fac = (range > 0.0f) ? 1.0f / range : 0.0f;
3203         float soft = 1.0f + range * atanf((bulge - 1.0f) * scale_fac) / (float)M_PI_2;
3204
3205         bulge = interpf(soft, hard, data->bulge_smooth);
3206       }
3207     }
3208     if (bulge < 1.0f) {
3209       if (data->flag & STRETCHTOCON_USE_BULGE_MIN) {
3210         float bulge_min = CLAMPIS(data->bulge_min, 0.0f, 1.0f);
3211         float hard = max_ff(bulge, bulge_min);
3212
3213         float range = 1.0f - bulge_min;
3214         float scale_fac = (range > 0.0f) ? 1.0f / range : 0.0f;
3215         float soft = 1.0f - range * atanf((1.0f - bulge) * scale_fac) / (float)M_PI_2;
3216
3217         bulge = interpf(soft, hard, data->bulge_smooth);
3218       }
3219     }
3220
3221     switch (data->volmode) {
3222       /* volume preserving scaling */
3223       case VOLUME_XZ:
3224         scale[0] = sqrtf(bulge);
3225         scale[2] = scale[0];
3226         break;
3227       case VOLUME_X:
3228         scale[0] = bulge;
3229         scale[2] = 1.0;
3230         break;
3231       case VOLUME_Z:
3232         scale[0] = 1.0;
3233         scale[2] = bulge;
3234         break;
3235       /* don't care for volume */
3236       case NO_VOLUME:
3237         scale[0] = 1.0;
3238         scale[2] = 1.0;
3239         break;
3240       default: /* should not happen, but in case*/
3241         return;
3242     } /* switch (data->volmode) */
3243
3244     /* Clear the object's rotation and scale */
3245     cob->matrix[0][0] = size[0] * scale[0];
3246     cob->matrix[0][1] = 0;
3247     cob->matrix[0][2] = 0;
3248     cob->matrix[1][0] = 0;
3249     cob->matrix[1][1] = size[1] * scale[1];
3250     cob->matrix[1][2] = 0;
3251     cob->matrix[2][0] = 0;
3252     cob->matrix[2][1] = 0;
3253     cob->matrix[2][2] = size[2] * scale[2];
3254
3255     sub_v3_v3v3(vec, cob->matrix[3], ct->matrix[3]);
3256     normalize_v3(vec);
3257
3258     /* new Y aligns  object target connection*/
3259     negate_v3_v3(totmat[1], vec);
3260     switch (data->plane) {
3261       case PLANE_X:
3262         /* build new Z vector */
3263         /* othogonal to "new Y" "old X! plane */
3264         cross_v3_v3v3(orth, vec, xx);
3265         normalize_v3(orth);
3266
3267         /* new Z*/
3268         copy_v3_v3(totmat[2], orth);
3269
3270         /* we decided to keep X plane*/
3271         cross_v3_v3v3(xx, orth, vec);
3272         normalize_v3_v3(totmat[0], xx);
3273         break;
3274       case PLANE_Z:
3275         /* build new X vector */
3276         /* othogonal to "new Y" "old Z! plane */
3277         cross_v3_v3v3(orth, vec, zz);
3278         normalize_v3(orth);
3279
3280         /* new X */
3281         negate_v3_v3(totmat[0], orth);
3282
3283         /* we decided to keep Z */
3284         cross_v3_v3v3(zz, orth, vec);
3285         normalize_v3_v3(totmat[2], zz);
3286         break;
3287     } /* switch (data->plane) */
3288
3289     mul_m4_m3m4(cob->matrix, totmat, cob->matrix);
3290   }
3291 }
3292
3293 static bConstraintTypeInfo CTI_STRETCHTO = {
3294     CONSTRAINT_TYPE_STRETCHTO,    /* type */
3295     sizeof(bStretchToConstraint), /* size */
3296     "Stretch To",                 /* name */
3297     "bStretchToConstraint",       /* struct name */
3298     NULL,                         /* free data */
3299     stretchto_id_looper,          /* id looper */
3300     NULL,                         /* copy data */
3301     stretchto_new_data,           /* new data */
3302     stretchto_get_tars,           /* get constraint targets */
3303     stretchto_flush_tars,         /* flush constraint targets */
3304     default_get_tarmat,           /* get target matrix */
3305     stretchto_evaluate,           /* evaluate */
3306 };
3307
3308 /* ---------- Floor ------------ */
3309
3310 static void minmax_new_data(void *cdata)
3311 {
3312   bMinMaxConstraint *data = (bMinMaxConstraint *)cdata;
3313
3314   data->minmaxflag = TRACK_Z;
3315   data->offset = 0.0f;
3316   zero_v3(data->cache);
3317   data->flag = 0;
3318 }
3319
3320 static void minmax_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata)
3321 {
3322   bMinMaxConstraint *data = con->data;
3323
3324   /* target only */
3325   func(con, (ID **)&data->tar, false, userdata);
3326 }
3327
3328 static int minmax_get_tars(bConstraint *con, ListBase *list)
3329 {
3330   if (con && list) {
3331     bMinMaxConstraint *data = con->data;
3332     bConstraintTarget *ct;
3333
3334     /* standard target-getting macro for single-target constraints */
3335     SINGLETARGET_GET_TARS(con, data->tar, data->subtarget, ct, list);
3336
3337     return 1;
3338   }
3339
3340   return 0;
3341 }
3342
3343 static void minmax_flush_tars(bConstraint *con, ListBase *list, bool no_copy)
3344 {
3345   if (con && list) {
3346     bMinMaxConstraint *data = con->data;
3347     bConstraintTarget *ct = list->first;
3348
3349     /* the following macro is used for all standard single-target constraints */
3350     SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, no_copy);
3351   }
3352 }
3353
3354 static void minmax_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets)
3355 {
3356   bMinMaxConstraint *data = con->data;
3357   bConstraintTarget *ct = targets->first;
3358
3359   /* only evaluate if there is a target */
3360   if (VALID_CONS_TARGET(ct)) {
3361     float obmat[4][4], imat[4][4], tarmat[4][4], tmat[4][4];
3362     float val1, val2;
3363     int index;
3364
3365     copy_m4_m4(obmat, cob->matrix);
3366     copy_m4_m4(tarmat, ct->matrix);
3367
3368     if (data->flag & MINMAX_USEROT) {
3369       /* take rotation of target into account by doing the transaction in target's localspace */
3370       invert_m4_m4(imat, tarmat);
3371       mul_m4_m4m4(tmat, imat, obmat);
3372       copy_m4_m4(obmat, tmat);
3373       unit_m4(tarmat);
3374     }
3375
3376     switch (data->minmaxflag) {
3377       case TRACK_Z:
3378         val1 = tarmat[3][2];
3379         val2 = obmat[3][2] - data->offset;
3380         index = 2;
3381         break;
3382       case TRACK_Y:
3383         val1 = tarmat[3][1];
3384         val2 = obmat[3][1] - data->offset;
3385         index = 1;
3386         break;
3387       case TRACK_X:
3388         val1 = tarmat[3][0];
3389         val2 = obmat[3][0] - data->offset;
3390         index = 0;
3391         break;
3392       case TRACK_nZ:
3393         val2 = tarmat[3][2];
3394         val1 = obmat[3][2] - data->offset;
3395         index = 2;
3396         break;
3397       case TRACK_nY:
3398         val2 = tarmat[3][1];
3399         val1 = obmat[3][1] - data->offset;
3400         index = 1;
3401         break;
3402       case TRACK_nX:
3403         val2 = tarmat[3][0];
3404         val1 = obmat[3][0] - data->offset;
3405         index = 0;
3406         break;
3407       default:
3408         return;
3409     }
3410
3411     if (val1 > val2) {
3412       obmat[3][index] = tarmat[3][index] + data->offset;
3413       if (data->flag & MINMAX_STICKY) {
3414         if (data->flag & MINMAX_STUCK) {
3415           copy_v3_v3(obmat[3], data->cache);
3416         }
3417         else {
3418           copy_v3_v3(data->cache, obmat[3]);
3419           data->flag |= MINMAX_STUCK;
3420         }
3421       }
3422       if (data->flag & MINMAX_USEROT) {
3423         /* get out of localspace */
3424         mul_m4_m4m4(tmat, ct->matrix, obmat);
3425         copy_m4_m4(cob->matrix, tmat);
3426       }
3427       else {
3428         copy_v3_v3(cob->matrix[3], obmat[3]);
3429       }
3430     }
3431     else {
3432       data->flag &= ~MINMAX_STUCK;
3433     }
3434   }
3435 }
3436
3437 static bConstraintTypeInfo CTI_MINMAX = {
3438     CONSTRAINT_TYPE_MINMAX,    /* type */
3439     sizeof(bMinMaxConstraint), /* size */
3440     "Floor",                   /* name */
3441     "bMinMaxConstraint",       /* struct name */
3442     NULL,                      /* free data */
3443     minmax_id_looper,          /* id looper */
3444     NULL,                      /* copy data */
3445     minmax_new_data,           /* new data */
3446     minmax_get_tars,           /* get constraint targets */
3447     minmax_flush_tars,         /* flush constraint targets */
3448     default_get_tarmat,        /* get target matrix */
3449     minmax_evaluate,           /* evaluate */
3450 };
3451
3452 /* -------- Clamp To ---------- */
3453
3454 static void clampto_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata)
3455 {
3456   bClampToConstraint *data = con->data;
3457
3458   /* target only */
3459   func(con, (ID **)&data->tar, false, userdata);
3460 }
3461
3462 static int clampto_get_tars(bConstraint *con, ListBase *list)
3463 {
3464   if (con && list) {
3465     bClampToConstraint *data = con->data;
3466     bConstraintTarget *ct;
3467
3468     /* standard target-getting macro for single-target constraints without subtargets */
3469     SINGLETARGETNS_GET_TARS(con, data->tar, ct, list);
3470
3471     return 1;
3472   }
3473
3474   return 0;
3475 }
3476
3477 static void clampto_flush_tars(bConstraint *con, ListBase *list, bool no_copy)
3478 {
3479   if (con && list) {
3480     bClampToConstraint *data = con->data;
3481     bConstraintTarget *ct = list->first;
3482
3483     /* the following macro is used for all standard single-target constraints */
3484     SINGLETARGETNS_FLUSH_TARS(con, data->tar, ct, list, no_copy);
3485   }
3486 }
3487
3488 static void clampto_get_tarmat(struct Depsgraph *UNUSED(depsgraph),
3489                                bConstraint *UNUSED(con),
3490                                bConstraintOb *UNUSED(cob),
3491                                bConstraintTarget *ct,
3492                                float UNUSED(ctime))
3493 {
3494   /* technically, this isn't really needed for evaluation, but we don't know what else
3495    * might end up calling this...
3496    */
3497   if (ct) {
3498     unit_m4(ct->matrix);
3499   }
3500 }
3501
3502 static void clampto_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets)
3503 {
3504   bClampToConstraint *data = con->data;
3505   bConstraintTarget *ct = targets->first;
3506
3507   /* only evaluate if there is a target and it is a curve */
3508   if (VALID_CONS_TARGET(ct) && (ct->tar->type == OB_CURVE)) {
3509     float obmat[4][4], ownLoc[3];
3510     float curveMin[3], curveMax[3];
3511     float targetMatrix[4][4];
3512
3513     copy_m4_m4(obmat, cob->matrix);
3514     copy_v3_v3(ownLoc, obmat[3]);
3515
3516     unit_m4(targetMatrix);
3517     INIT_MINMAX(curveMin, curveMax);
3518     /* XXX - don't think this is good calling this here - campbell */
3519     BKE_object_minmax(ct->tar, curveMin, curveMax, true);
3520
3521     /* get targetmatrix */
3522     if (data->tar->runtime.curve_cache && data->tar->runtime.curve_cache->path &&
3523         data->tar->runtime.curve_cache->path->data) {
3524       float vec[4], dir[3], totmat[4][4];
3525       float curvetime;
3526       short clamp_axis;
3527
3528       /* find best position on curve */
3529       /* 1. determine which axis to sample on? */
3530       if (data->flag == CLAMPTO_AUTO) {
3531         float size[3];
3532         sub_v3_v3v3(size, curveMax, curveMin);
3533
3534         /* find axis along which the bounding box has the greatest
3535          * extent. Otherwise, default to the x-axis, as that is quite
3536          * frequently used.
3537          */
3538         if ((size[2] > size[0]) && (size[2] > size[1])) {
3539           clamp_axis = CLAMPTO_Z - 1;
3540         }
3541         else if ((size[1] > size[0]) && (size[1] > size[2])) {
3542           clamp_axis = CLAMPTO_Y - 1;
3543         }
3544         else {
3545           clamp_axis = CLAMPTO_X - 1;
3546         }
3547       }
3548       else {
3549         clamp_axis = data->flag - 1;
3550       }
3551
3552       /* 2. determine position relative to curve on a 0-1 scale based on bounding box */
3553       if (data->flag2 & CLAMPTO_CYCLIC) {
3554         /* cyclic, so offset within relative bounding box is used */
3555         float len = (curveMax[clamp_axis] - curveMin[clamp_axis]);
3556         float offset;
3557
3558         /* check to make sure len is not so close to zero that it'll cause errors */
3559         if (IS_EQF(len, 0.0f) == false) {
3560           /* find bounding-box range where target is located */
3561           if (ownLoc[clamp_axis] < curveMin[clamp_axis]) {
3562             /* bounding-box range is before */
3563             offset = curveMin[clamp_axis] -
3564                      ceilf((curveMin[clamp_axis] - ownLoc[clamp_axis]) / len) * len;
3565
3566             /* Now, we calculate as per normal,
3567              * except using offset instead of curveMin[clamp_axis]. */
3568             curvetime = (ownLoc[clamp_axis] - offset) / (len);
3569           }