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