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