Merging r46456 through r46468 from trunk into soc-2011-tomato
[blender.git] / source / blender / editors / transform / transform_conversions.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/editors/transform/transform_conversions.c
29  *  \ingroup edtransform
30  */
31
32
33 #ifndef WIN32
34 #include <unistd.h>
35 #else
36 #include <io.h>
37 #endif
38 #include <string.h>
39 #include <math.h>
40
41 #include "DNA_anim_types.h"
42 #include "DNA_armature_types.h"
43 #include "DNA_lattice_types.h"
44 #include "DNA_mesh_types.h"
45 #include "DNA_meta_types.h"
46 #include "DNA_node_types.h"
47 #include "DNA_screen_types.h"
48 #include "DNA_space_types.h"
49 #include "DNA_sequence_types.h"
50 #include "DNA_view3d_types.h"
51 #include "DNA_constraint_types.h"
52 #include "DNA_scene_types.h"
53 #include "DNA_meshdata_types.h"
54 #include "DNA_gpencil_types.h"
55 #include "DNA_movieclip_types.h"
56 #include "DNA_mask_types.h"
57
58 #include "MEM_guardedalloc.h"
59
60 #include "BLI_math.h"
61 #include "BLI_blenlib.h"
62 #include "BLI_array.h"
63 #include "BLI_utildefines.h"
64 #include "BLI_smallhash.h"
65
66 #include "BKE_DerivedMesh.h"
67 #include "BKE_action.h"
68 #include "BKE_armature.h"
69 #include "BKE_bmesh.h"
70 #include "BKE_constraint.h"
71 #include "BKE_context.h"
72 #include "BKE_curve.h"
73 #include "BKE_depsgraph.h"
74 #include "BKE_fcurve.h"
75 #include "BKE_global.h"
76 #include "BKE_gpencil.h"
77 #include "BKE_key.h"
78 #include "BKE_main.h"
79 #include "BKE_modifier.h"
80 #include "BKE_movieclip.h"
81 #include "BKE_nla.h"
82 #include "BKE_node.h"
83 #include "BKE_object.h"
84 #include "BKE_particle.h"
85 #include "BKE_pointcache.h"
86 #include "BKE_report.h"
87 #include "BKE_scene.h"
88 #include "BKE_sequencer.h"
89 #include "BKE_tessmesh.h"
90 #include "BKE_tracking.h"
91 #include "BKE_mask.h"
92
93
94 #include "ED_anim_api.h"
95 #include "ED_armature.h"
96 #include "ED_particle.h"
97 #include "ED_image.h"
98 #include "ED_keyframing.h"
99 #include "ED_keyframes_edit.h"
100 #include "ED_object.h"
101 #include "ED_markers.h"
102 #include "ED_mesh.h"
103 #include "ED_node.h"
104 #include "ED_types.h"
105 #include "ED_uvedit.h"
106 #include "ED_clip.h"
107 #include "ED_mask.h"
108 #include "ED_util.h"  /* for crazyspace correction */
109
110 #include "WM_api.h"             /* for WM_event_add_notifier to deal with stabilization nodes */
111 #include "WM_types.h"
112
113 #include "UI_view2d.h"
114
115 #include "RNA_access.h"
116
117 #include "transform.h"
118 #include "bmesh.h"
119
120 #include "BLO_sys_types.h" // for intptr_t support
121
122 /* local function prototype - for Object/Bone Constraints */
123 static short constraints_list_needinv(TransInfo *t, ListBase *list);
124
125 /* ************************** Functions *************************** */
126
127 static void qsort_trans_data(TransInfo *t, TransData *head, TransData *tail, TransData *temp)
128 {
129         TransData *ihead = head;
130         TransData *itail = tail;
131         *temp = *head;
132
133         while (head < tail) {
134                 if (t->flag & T_PROP_CONNECTED) {
135                         while ((tail->dist >= temp->dist) && (head < tail))
136                                 tail--;
137                 }
138                 else {
139                         while ((tail->rdist >= temp->rdist) && (head < tail))
140                                 tail--;
141                 }
142
143                 if (head != tail) {
144                         *head = *tail;
145                         head++;
146                 }
147
148                 if (t->flag & T_PROP_CONNECTED) {
149                         while ((head->dist <= temp->dist) && (head < tail))
150                                 head++;
151                 }
152                 else {
153                         while ((head->rdist <= temp->rdist) && (head < tail))
154                                 head++;
155                 }
156
157                 if (head != tail) {
158                         *tail = *head;
159                         tail--;
160                 }
161         }
162
163         *head = *temp;
164         if (ihead < head) {
165                 qsort_trans_data(t, ihead, head-1, temp);
166         }
167         if (itail > head) {
168                 qsort_trans_data(t, head+1, itail, temp);
169         }
170 }
171
172 void sort_trans_data_dist(TransInfo *t)
173 {
174         TransData temp;
175         TransData *start = t->data;
176         int i = 1;
177
178         while (i < t->total && start->flag & TD_SELECTED) {
179                 start++;
180                 i++;
181         }
182         qsort_trans_data(t, start, t->data + t->total - 1, &temp);
183 }
184
185 static void sort_trans_data(TransInfo *t)
186 {
187         TransData *sel, *unsel;
188         TransData temp;
189         unsel = t->data;
190         sel = t->data;
191         sel += t->total - 1;
192         while (sel > unsel) {
193                 while (unsel->flag & TD_SELECTED) {
194                         unsel++;
195                         if (unsel == sel) {
196                                 return;
197                         }
198                 }
199                 while (!(sel->flag & TD_SELECTED)) {
200                         sel--;
201                         if (unsel == sel) {
202                                 return;
203                         }
204                 }
205                 temp = *unsel;
206                 *unsel = *sel;
207                 *sel = temp;
208                 sel--;
209                 unsel++;
210         }
211 }
212
213 /* distance calculated from not-selected vertex to nearest selected vertex
214  * warning; this is loops inside loop, has minor N^2 issues, but by sorting list it is OK */
215 static void set_prop_dist(TransInfo *t, short with_dist)
216 {
217         TransData *tob;
218         int a;
219
220         for (a=0, tob= t->data; a<t->total; a++, tob++) {
221
222                 tob->rdist= 0.0f; // init, it was mallocced
223
224                 if ((tob->flag & TD_SELECTED)==0) {
225                         TransData *td;
226                         int i;
227                         float dist, vec[3];
228
229                         tob->rdist = -1.0f; // signal for next loop
230
231                         for (i = 0, td= t->data; i < t->total; i++, td++) {
232                                 if (td->flag & TD_SELECTED) {
233                                         sub_v3_v3v3(vec, tob->center, td->center);
234                                         mul_m3_v3(tob->mtx, vec);
235                                         dist = normalize_v3(vec);
236                                         if (tob->rdist == -1.0f) {
237                                                 tob->rdist = dist;
238                                         }
239                                         else if (dist < tob->rdist) {
240                                                 tob->rdist = dist;
241                                         }
242                                 }
243                                 else break;     // by definition transdata has selected items in beginning
244                         }
245                         if (with_dist) {
246                                 tob->dist = tob->rdist;
247                         }
248                 }
249         }
250 }
251
252 /* ************************** CONVERSIONS ************************* */
253
254 /* ********************* texture space ********* */
255
256 static void createTransTexspace(TransInfo *t)
257 {
258         Scene *scene = t->scene;
259         TransData *td;
260         Object *ob;
261         ID *id;
262         short *texflag;
263
264         ob = OBACT;
265
266         if (ob == NULL) { // Shouldn't logically happen, but still...
267                 t->total = 0;
268                 return;
269         }
270
271         id = ob->data;
272         if (id == NULL || !ELEM3(GS(id->name), ID_ME, ID_CU, ID_MB )) {
273                 t->total = 0;
274                 return;
275         }
276
277         t->total = 1;
278         td= t->data= MEM_callocN(sizeof(TransData), "TransTexspace");
279         td->ext= t->ext= MEM_callocN(sizeof(TransDataExtension), "TransTexspace");
280
281         td->flag= TD_SELECTED;
282         copy_v3_v3(td->center, ob->obmat[3]);
283         td->ob = ob;
284
285         copy_m3_m4(td->mtx, ob->obmat);
286         copy_m3_m4(td->axismtx, ob->obmat);
287         normalize_m3(td->axismtx);
288         invert_m3_m3(td->smtx, td->mtx);
289
290         if (BKE_object_obdata_texspace_get(ob, &texflag, &td->loc, &td->ext->size, &td->ext->rot)) {
291                 ob->dtx |= OB_TEXSPACE;
292                 *texflag &= ~ME_AUTOSPACE;
293         }
294
295         copy_v3_v3(td->iloc, td->loc);
296         copy_v3_v3(td->ext->irot, td->ext->rot);
297         copy_v3_v3(td->ext->isize, td->ext->size);
298 }
299
300 /* ********************* edge (for crease) ***** */
301
302 static void createTransEdge(TransInfo *t)
303 {
304         BMEditMesh *em = BMEdit_FromObject(t->obedit);
305         TransData *td = NULL;
306         BMEdge *eed;
307         BMIter iter;
308         float mtx[3][3], smtx[3][3];
309         int count=0, countsel=0;
310         int propmode = t->flag & T_PROP_EDIT;
311
312         BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
313                 if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
314                         if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) countsel++;
315                         if (propmode) count++;
316                 }
317         }
318
319         if (countsel == 0)
320                 return;
321
322         if (propmode) {
323                 t->total = count;
324         }
325         else {
326                 t->total = countsel;
327         }
328
329         td= t->data= MEM_callocN(t->total * sizeof(TransData), "TransCrease");
330
331         copy_m3_m4(mtx, t->obedit->obmat);
332         invert_m3_m3(smtx, mtx);
333
334         BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) {
335                 if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN) && (BM_elem_flag_test(eed, BM_ELEM_SELECT) || propmode)) { 
336                         float *bweight = CustomData_bmesh_get(&em->bm->edata, eed->head.data, CD_BWEIGHT);
337                         float *crease = CustomData_bmesh_get(&em->bm->edata, eed->head.data, CD_CREASE);
338                         
339                         /* need to set center for center calculations */
340                         add_v3_v3v3(td->center, eed->v1->co, eed->v2->co);
341                         mul_v3_fl(td->center, 0.5f);
342
343                         td->loc= NULL;
344                         if (BM_elem_flag_test(eed, BM_ELEM_SELECT))
345                                 td->flag= TD_SELECTED;
346                         else
347                                 td->flag= 0;
348
349
350                         copy_m3_m3(td->smtx, smtx);
351                         copy_m3_m3(td->mtx, mtx);
352
353                         td->ext = NULL;
354                         if (t->mode == TFM_BWEIGHT) {
355                                 td->val = bweight;
356                                 td->ival = bweight ? *bweight : 1.0f;
357                         }
358                         else {
359                                 td->val = crease;
360                                 td->ival = crease ? *crease : 0.0f;
361                         }
362
363                         td++;
364                 }
365         }
366 }
367
368 /* ********************* pose mode ************* */
369
370 static bKinematicConstraint *has_targetless_ik(bPoseChannel *pchan)
371 {
372         bConstraint *con= pchan->constraints.first;
373
374         for (;con; con= con->next) {
375                 if (con->type==CONSTRAINT_TYPE_KINEMATIC && (con->enforce!=0.0f)) {
376                         bKinematicConstraint *data= con->data;
377
378                         if (data->tar==NULL)
379                                 return data;
380                         if (data->tar->type==OB_ARMATURE && data->subtarget[0]==0)
381                                 return data;
382                 }
383         }
384         return NULL;
385 }
386
387 static short apply_targetless_ik(Object *ob)
388 {
389         bPoseChannel *pchan, *parchan, *chanlist[256];
390         bKinematicConstraint *data;
391         int segcount, apply= 0;
392
393         /* now we got a difficult situation... we have to find the
394          * target-less IK pchans, and apply transformation to the all
395          * pchans that were in the chain */
396
397         for (pchan=ob->pose->chanbase.first; pchan; pchan=pchan->next) {
398                 data= has_targetless_ik(pchan);
399                 if (data && (data->flag & CONSTRAINT_IK_AUTO)) {
400
401                         /* fill the array with the bones of the chain (armature.c does same, keep it synced) */
402                         segcount= 0;
403
404                         /* exclude tip from chain? */
405                         if (!(data->flag & CONSTRAINT_IK_TIP))
406                                 parchan= pchan->parent;
407                         else
408                                 parchan= pchan;
409
410                         /* Find the chain's root & count the segments needed */
411                         for (; parchan; parchan=parchan->parent) {
412                                 chanlist[segcount]= parchan;
413                                 segcount++;
414
415                                 if (segcount==data->rootbone || segcount>255) break; // 255 is weak
416                         }
417                         for (;segcount;segcount--) {
418                                 Bone *bone;
419                                 float rmat[4][4]/*, tmat[4][4], imat[4][4]*/;
420
421                                 /* pose_mat(b) = pose_mat(b-1) * offs_bone * channel * constraint * IK  */
422                                 /* we put in channel the entire result of rmat= (channel * constraint * IK) */
423                                 /* pose_mat(b) = pose_mat(b-1) * offs_bone * rmat  */
424                                 /* rmat = pose_mat(b) * inv(pose_mat(b-1) * offs_bone ) */
425
426                                 parchan= chanlist[segcount-1];
427                                 bone= parchan->bone;
428                                 bone->flag |= BONE_TRANSFORM;   /* ensures it gets an auto key inserted */
429
430                                 BKE_armature_mat_pose_to_bone(parchan, parchan->pose_mat, rmat);
431
432                                 /* apply and decompose, doesn't work for constraints or non-uniform scale well */
433                                 {
434                                         float rmat3[3][3], qrmat[3][3], imat3[3][3], smat[3][3];
435                                         
436                                         copy_m3_m4(rmat3, rmat);
437                                         
438                                         /* rotation */
439                                                 /* [#22409] is partially caused by this, as slight numeric error introduced during 
440                                                  * the solving process leads to locked-axis values changing. However, we cannot modify
441                                                  * the values here, or else there are huge discreptancies between IK-solver (interactive)
442                                                  * and applied poses.
443                                                  */
444                                         if (parchan->rotmode > 0)
445                                                 mat3_to_eulO(parchan->eul, parchan->rotmode, rmat3);
446                                         else if (parchan->rotmode == ROT_MODE_AXISANGLE)
447                                                 mat3_to_axis_angle(parchan->rotAxis, &parchan->rotAngle, rmat3);
448                                         else
449                                                 mat3_to_quat(parchan->quat, rmat3);
450                                         
451                                         /* for size, remove rotation */
452                                         /* causes problems with some constraints (so apply only if needed) */
453                                         if (data->flag & CONSTRAINT_IK_STRETCH) {
454                                                 if (parchan->rotmode > 0)
455                                                         eulO_to_mat3(qrmat, parchan->eul, parchan->rotmode);
456                                                 else if (parchan->rotmode == ROT_MODE_AXISANGLE)
457                                                         axis_angle_to_mat3(qrmat, parchan->rotAxis, parchan->rotAngle);
458                                                 else
459                                                         quat_to_mat3(qrmat, parchan->quat);
460                                                 
461                                                 invert_m3_m3(imat3, qrmat);
462                                                 mul_m3_m3m3(smat, rmat3, imat3);
463                                                 mat3_to_size(parchan->size, smat);
464                                         }
465                                         
466                                         /* causes problems with some constraints (e.g. childof), so disable this */
467                                         /* as it is IK shouldn't affect location directly */
468                                         /* copy_v3_v3(parchan->loc, rmat[3]); */
469                                 }
470
471                         }
472
473                         apply= 1;
474                         data->flag &= ~CONSTRAINT_IK_AUTO;
475                 }
476         }
477
478         return apply;
479 }
480
481 static void add_pose_transdata(TransInfo *t, bPoseChannel *pchan, Object *ob, TransData *td)
482 {
483         Bone *bone= pchan->bone;
484         float pmat[3][3], omat[3][3];
485         float cmat[3][3], tmat[3][3];
486         float vec[3];
487
488         copy_v3_v3(vec, pchan->pose_mat[3]);
489         copy_v3_v3(td->center, vec);
490
491         td->ob = ob;
492         td->flag = TD_SELECTED;
493         if (bone->flag & BONE_HINGE_CHILD_TRANSFORM) {
494                 td->flag |= TD_NOCENTER;
495         }
496
497         if (bone->flag & BONE_TRANSFORM_CHILD) {
498                 td->flag |= TD_NOCENTER;
499                 td->flag |= TD_NO_LOC;
500         }
501
502         td->protectflag= pchan->protectflag;
503
504         td->loc = pchan->loc;
505         copy_v3_v3(td->iloc, pchan->loc);
506
507         td->ext->size= pchan->size;
508         copy_v3_v3(td->ext->isize, pchan->size);
509
510         if (pchan->rotmode > 0) {
511                 td->ext->rot= pchan->eul;
512                 td->ext->rotAxis= NULL;
513                 td->ext->rotAngle= NULL;
514                 td->ext->quat= NULL;
515                 
516                 copy_v3_v3(td->ext->irot, pchan->eul);
517         }
518         else if (pchan->rotmode == ROT_MODE_AXISANGLE) {
519                 td->ext->rot= NULL;
520                 td->ext->rotAxis= pchan->rotAxis;
521                 td->ext->rotAngle= &pchan->rotAngle;
522                 td->ext->quat= NULL;
523                 
524                 td->ext->irotAngle= pchan->rotAngle;
525                 copy_v3_v3(td->ext->irotAxis, pchan->rotAxis);
526         }
527         else {
528                 td->ext->rot= NULL;
529                 td->ext->rotAxis= NULL;
530                 td->ext->rotAngle= NULL;
531                 td->ext->quat= pchan->quat;
532                 
533                 copy_qt_qt(td->ext->iquat, pchan->quat);
534         }
535         td->ext->rotOrder= pchan->rotmode;
536
537
538         /* proper way to get parent transform + own transform + constraints transform */
539         copy_m3_m4(omat, ob->obmat);
540
541         /* New code, using "generic" BKE_pchan_to_pose_mat(). */
542         {
543                 float rotscale_mat[4][4], loc_mat[4][4];
544
545                 BKE_pchan_to_pose_mat(pchan, rotscale_mat, loc_mat);
546                 if (t->mode == TFM_TRANSLATION)
547                         copy_m3_m4(pmat, loc_mat);
548                 else
549                         copy_m3_m4(pmat, rotscale_mat);
550
551                 if (constraints_list_needinv(t, &pchan->constraints)) {
552                         copy_m3_m4(tmat, pchan->constinv);
553                         invert_m3_m3(cmat, tmat);
554                         mul_serie_m3(td->mtx, pmat, omat, cmat, NULL, NULL, NULL, NULL, NULL);
555                 }
556                 else
557                         mul_serie_m3(td->mtx, pmat, omat, NULL, NULL, NULL, NULL, NULL, NULL);
558         }
559
560         invert_m3_m3(td->smtx, td->mtx);
561
562         /* exceptional case: rotate the pose bone which also applies transformation
563          * when a parentless bone has BONE_NO_LOCAL_LOCATION [] */
564         if (!ELEM(t->mode, TFM_TRANSLATION, TFM_RESIZE) && (pchan->bone->flag & BONE_NO_LOCAL_LOCATION)) {
565                 if (pchan->parent) {
566                         /* same as td->smtx but without pchan->bone->bone_mat */
567                         td->flag |= TD_PBONE_LOCAL_MTX_C;
568                         mul_m3_m3m3(td->ext->l_smtx, pchan->bone->bone_mat, td->smtx);
569                 }
570                 else {
571                         td->flag |= TD_PBONE_LOCAL_MTX_P;
572                 }
573         }
574         
575         /* for axismat we use bone's own transform */
576         copy_m3_m4(pmat, pchan->pose_mat);
577         mul_m3_m3m3(td->axismtx, omat, pmat);
578         normalize_m3(td->axismtx);
579
580         if (t->mode==TFM_BONESIZE) {
581                 bArmature *arm= t->poseobj->data;
582
583                 if (arm->drawtype==ARM_ENVELOPE) {
584                         td->loc= NULL;
585                         td->val= &bone->dist;
586                         td->ival= bone->dist;
587                 }
588                 else {
589                         // abusive storage of scale in the loc pointer :)
590                         td->loc= &bone->xwidth;
591                         copy_v3_v3(td->iloc, td->loc);
592                         td->val= NULL;
593                 }
594         }
595
596         /* in this case we can do target-less IK grabbing */
597         if (t->mode==TFM_TRANSLATION) {
598                 bKinematicConstraint *data= has_targetless_ik(pchan);
599                 if (data) {
600                         if (data->flag & CONSTRAINT_IK_TIP) {
601                                 copy_v3_v3(data->grabtarget, pchan->pose_tail);
602                         }
603                         else {
604                                 copy_v3_v3(data->grabtarget, pchan->pose_head);
605                         }
606                         td->loc = data->grabtarget;
607                         copy_v3_v3(td->iloc, td->loc);
608                         data->flag |= CONSTRAINT_IK_AUTO;
609
610                         /* only object matrix correction */
611                         copy_m3_m3(td->mtx, omat);
612                         invert_m3_m3(td->smtx, td->mtx);
613                 }
614         }
615
616         /* store reference to first constraint */
617         td->con= pchan->constraints.first;
618 }
619
620 static void bone_children_clear_transflag(int mode, short around, ListBase *lb)
621 {
622         Bone *bone= lb->first;
623
624         for ( ; bone;bone= bone->next) {
625                 if ((bone->flag & BONE_HINGE) && (bone->flag & BONE_CONNECTED)) {
626                         bone->flag |= BONE_HINGE_CHILD_TRANSFORM;
627                 }
628                 else if ((bone->flag & BONE_TRANSFORM) &&
629                          (mode == TFM_ROTATION || mode == TFM_TRACKBALL) &&
630                          (around == V3D_LOCAL))
631                 {
632                         bone->flag |= BONE_TRANSFORM_CHILD;
633                 }
634                 else {
635                         bone->flag &= ~BONE_TRANSFORM;
636                 }
637
638                 bone_children_clear_transflag(mode, around, &bone->childbase);
639         }
640 }
641
642 /* sets transform flags in the bones
643  * returns total number of bones with BONE_TRANSFORM */
644 int count_set_pose_transflags(int *out_mode, short around, Object *ob)
645 {
646         bArmature *arm= ob->data;
647         bPoseChannel *pchan;
648         Bone *bone;
649         int mode = *out_mode;
650         int hastranslation = 0;
651         int total = 0;
652
653         for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
654                 bone = pchan->bone;
655                 if (PBONE_VISIBLE(arm, bone)) {
656                         if ((bone->flag & BONE_SELECTED))
657                                 bone->flag |= BONE_TRANSFORM;
658                         else
659                                 bone->flag &= ~BONE_TRANSFORM;
660                         
661                         bone->flag &= ~BONE_HINGE_CHILD_TRANSFORM;
662                         bone->flag &= ~BONE_TRANSFORM_CHILD;
663                 }
664                 else
665                         bone->flag &= ~BONE_TRANSFORM;
666         }
667
668         /* make sure no bone can be transformed when a parent is transformed */
669         /* since pchans are depsgraph sorted, the parents are in beginning of list */
670         if (mode != TFM_BONESIZE) {
671                 for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
672                         bone = pchan->bone;
673                         if (bone->flag & BONE_TRANSFORM)
674                                 bone_children_clear_transflag(mode, around, &bone->childbase);
675                 }
676         }
677         /* now count, and check if we have autoIK or have to switch from translate to rotate */
678         hastranslation = 0;
679
680         for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
681                 bone = pchan->bone;
682                 if (bone->flag & BONE_TRANSFORM) {
683                         total++;
684                         
685                         if (mode == TFM_TRANSLATION) {
686                                 if (has_targetless_ik(pchan) == NULL) {
687                                         if (pchan->parent && (pchan->bone->flag & BONE_CONNECTED)) {
688                                                 if (pchan->bone->flag & BONE_HINGE_CHILD_TRANSFORM)
689                                                         hastranslation = 1;
690                                         }
691                                         else if ((pchan->protectflag & OB_LOCK_LOC)!=OB_LOCK_LOC)
692                                                 hastranslation = 1;
693                                 }
694                                 else
695                                         hastranslation = 1;
696                         }
697                 }
698         }
699
700         /* if there are no translatable bones, do rotation */
701         if (mode == TFM_TRANSLATION && !hastranslation) {
702                 *out_mode = TFM_ROTATION;
703         }
704
705         return total;
706 }
707
708
709 /* -------- Auto-IK ---------- */
710
711 /* adjust pose-channel's auto-ik chainlen */
712 static void pchan_autoik_adjust (bPoseChannel *pchan, short chainlen)
713 {
714         bConstraint *con;
715
716         /* don't bother to search if no valid constraints */
717         if ((pchan->constflag & (PCHAN_HAS_IK|PCHAN_HAS_TARGET))==0)
718                 return;
719
720         /* check if pchan has ik-constraint */
721         for (con= pchan->constraints.first; con; con= con->next) {
722                 if (con->type == CONSTRAINT_TYPE_KINEMATIC && (con->enforce!=0.0f)) {
723                         bKinematicConstraint *data= con->data;
724                         
725                         /* only accept if a temporary one (for auto-ik) */
726                         if (data->flag & CONSTRAINT_IK_TEMP) {
727                                 /* chainlen is new chainlen, but is limited by maximum chainlen */
728                                 if ((chainlen==0) || (chainlen > data->max_rootbone))
729                                         data->rootbone= data->max_rootbone;
730                                 else
731                                         data->rootbone= chainlen;
732                         }
733                 }
734         }
735 }
736
737 /* change the chain-length of auto-ik */
738 void transform_autoik_update(TransInfo *t, short mode)
739 {
740         short *chainlen= &t->settings->autoik_chainlen;
741         bPoseChannel *pchan;
742
743         /* mode determines what change to apply to chainlen */
744         if (mode == 1) {
745                 /* mode=1 is from WHEELMOUSEDOWN... increases len */
746                 (*chainlen)++;
747         }
748         else if (mode == -1) {
749                 /* mode==-1 is from WHEELMOUSEUP... decreases len */
750                 if (*chainlen > 0) (*chainlen)--;
751         }
752
753         /* sanity checks (don't assume t->poseobj is set, or that it is an armature) */
754         if (ELEM(NULL, t->poseobj, t->poseobj->pose))
755                 return;
756
757         /* apply to all pose-channels */
758         for (pchan=t->poseobj->pose->chanbase.first; pchan; pchan=pchan->next) {
759                 pchan_autoik_adjust(pchan, *chainlen);
760         }
761 }
762
763 /* frees temporal IKs */
764 static void pose_grab_with_ik_clear(Object *ob)
765 {
766         bKinematicConstraint *data;
767         bPoseChannel *pchan;
768         bConstraint *con, *next;
769
770         for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
771                 /* clear all temporary lock flags */
772                 pchan->ikflag &= ~(BONE_IK_NO_XDOF_TEMP|BONE_IK_NO_YDOF_TEMP|BONE_IK_NO_ZDOF_TEMP);
773                 
774                 pchan->constflag &= ~(PCHAN_HAS_IK|PCHAN_HAS_TARGET);
775                 
776                 /* remove all temporary IK-constraints added */
777                 for (con= pchan->constraints.first; con; con= next) {
778                         next= con->next;
779                         if (con->type==CONSTRAINT_TYPE_KINEMATIC) {
780                                 data= con->data;
781                                 if (data->flag & CONSTRAINT_IK_TEMP) {
782                                         BLI_remlink(&pchan->constraints, con);
783                                         MEM_freeN(con->data);
784                                         MEM_freeN(con);
785                                         continue;
786                                 }
787                                 pchan->constflag |= PCHAN_HAS_IK;
788                                 if (data->tar==NULL || (data->tar->type==OB_ARMATURE && data->subtarget[0]==0))
789                                         pchan->constflag |= PCHAN_HAS_TARGET;
790                         }
791                 }
792         }
793 }
794
795 /* adds the IK to pchan - returns if added */
796 static short pose_grab_with_ik_add(bPoseChannel *pchan)
797 {
798         bKinematicConstraint *targetless = NULL;
799         bKinematicConstraint *data;
800         bConstraint *con;
801
802         /* Sanity check */
803         if (pchan == NULL)
804                 return 0;
805
806         /* Rule: not if there's already an IK on this channel */
807         for (con= pchan->constraints.first; con; con= con->next) {
808                 if (con->type==CONSTRAINT_TYPE_KINEMATIC) {
809                         data= con->data;
810                         
811                         if (data->tar==NULL || (data->tar->type==OB_ARMATURE && data->subtarget[0]=='\0')) {
812                                 /* make reference to constraint to base things off later (if it's the last targetless constraint encountered) */
813                                 targetless = (bKinematicConstraint *)con->data;
814                                 
815                                 /* but, if this is a targetless IK, we make it auto anyway (for the children loop) */
816                                 if (con->enforce!=0.0f) {
817                                         data->flag |= CONSTRAINT_IK_AUTO;
818                                         
819                                         /* if no chain length has been specified, just make things obey standard rotation locks too */
820                                         if (data->rootbone == 0) {
821                                                 for (; pchan; pchan=pchan->parent) {
822                                                         /* here, we set ik-settings for bone from pchan->protectflag */
823                                                         // XXX: careful with quats/axis-angle rotations where we're locking 4d components
824                                                         if (pchan->protectflag & OB_LOCK_ROTX) pchan->ikflag |= BONE_IK_NO_XDOF_TEMP;
825                                                         if (pchan->protectflag & OB_LOCK_ROTY) pchan->ikflag |= BONE_IK_NO_YDOF_TEMP;
826                                                         if (pchan->protectflag & OB_LOCK_ROTZ) pchan->ikflag |= BONE_IK_NO_ZDOF_TEMP;
827                                                 }
828                                         }
829                                         
830                                         return 0; 
831                                 }
832                         }
833                         
834                         if ((con->flag & CONSTRAINT_DISABLE)==0 && (con->enforce!=0.0f))
835                                 return 0;
836                 }
837         }
838
839         con = add_pose_constraint(NULL, pchan, "TempConstraint", CONSTRAINT_TYPE_KINEMATIC);
840         pchan->constflag |= (PCHAN_HAS_IK|PCHAN_HAS_TARGET);    /* for draw, but also for detecting while pose solving */
841         data= con->data;
842         if (targetless) { 
843                 /* if exists, use values from last targetless (but disabled) IK-constraint as base */
844                 *data = *targetless;
845         }
846         else
847                 data->flag= CONSTRAINT_IK_TIP;
848         data->flag |= CONSTRAINT_IK_TEMP|CONSTRAINT_IK_AUTO;
849         copy_v3_v3(data->grabtarget, pchan->pose_tail);
850         data->rootbone= 0; /* watch-it! has to be 0 here, since we're still on the same bone for the first time through the loop [#25885] */
851         
852         /* we only include bones that are part of a continual connected chain */
853         while (pchan) {
854                 /* here, we set ik-settings for bone from pchan->protectflag */
855                 // XXX: careful with quats/axis-angle rotations where we're locking 4d components
856                 if (pchan->protectflag & OB_LOCK_ROTX) pchan->ikflag |= BONE_IK_NO_XDOF_TEMP;
857                 if (pchan->protectflag & OB_LOCK_ROTY) pchan->ikflag |= BONE_IK_NO_YDOF_TEMP;
858                 if (pchan->protectflag & OB_LOCK_ROTZ) pchan->ikflag |= BONE_IK_NO_ZDOF_TEMP;
859                 
860                 /* now we count this pchan as being included */
861                 data->rootbone++;
862                 
863                 /* continue to parent, but only if we're connected to it */
864                 if (pchan->bone->flag & BONE_CONNECTED)
865                         pchan = pchan->parent;
866                 else
867                         pchan = NULL;
868         }
869
870         /* make a copy of maximum chain-length */
871         data->max_rootbone= data->rootbone;
872
873         return 1;
874 }
875
876 /* bone is a candidate to get IK, but we don't do it if it has children connected */
877 static short pose_grab_with_ik_children(bPose *pose, Bone *bone)
878 {
879         Bone *bonec;
880         short wentdeeper=0, added=0;
881
882         /* go deeper if children & children are connected */
883         for (bonec= bone->childbase.first; bonec; bonec= bonec->next) {
884                 if (bonec->flag & BONE_CONNECTED) {
885                         wentdeeper= 1;
886                         added+= pose_grab_with_ik_children(pose, bonec);
887                 }
888         }
889         if (wentdeeper==0) {
890                 bPoseChannel *pchan= BKE_pose_channel_find_name(pose, bone->name);
891                 if (pchan)
892                         added+= pose_grab_with_ik_add(pchan);
893         }
894
895         return added;
896 }
897
898 /* main call which adds temporal IK chains */
899 static short pose_grab_with_ik(Object *ob)
900 {
901         bArmature *arm;
902         bPoseChannel *pchan, *parent;
903         Bone *bonec;
904         short tot_ik= 0;
905
906         if ((ob==NULL) || (ob->pose==NULL) || (ob->mode & OB_MODE_POSE)==0)
907                 return 0;
908
909         arm = ob->data;
910
911         /* Rule: allow multiple Bones (but they must be selected, and only one ik-solver per chain should get added) */
912         for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
913                 if (pchan->bone->layer & arm->layer) {
914                         if (pchan->bone->flag & BONE_SELECTED) {
915                                 /* Rule: no IK for solitatry (unconnected) bones */
916                                 for (bonec=pchan->bone->childbase.first; bonec; bonec=bonec->next) {
917                                         if (bonec->flag & BONE_CONNECTED) {
918                                                 break;
919                                         }
920                                 }
921                                 if ((pchan->bone->flag & BONE_CONNECTED)==0 && (bonec == NULL))
922                                         continue;
923
924                                 /* rule: if selected Bone is not a root bone, it gets a temporal IK */
925                                 if (pchan->parent) {
926                                         /* only adds if there's no IK yet (and no parent bone was selected) */
927                                         for (parent= pchan->parent; parent; parent= parent->parent) {
928                                                 if (parent->bone->flag & BONE_SELECTED)
929                                                         break;
930                                         }
931                                         if (parent == NULL)
932                                                 tot_ik += pose_grab_with_ik_add(pchan);
933                                 }
934                                 else {
935                                         /* rule: go over the children and add IK to the tips */
936                                         tot_ik += pose_grab_with_ik_children(ob->pose, pchan->bone);
937                                 }
938                         }
939                 }
940         }
941
942         return (tot_ik) ? 1 : 0;
943 }
944
945
946 /* only called with pose mode active object now */
947 static void createTransPose(TransInfo *t, Object *ob)
948 {
949         bArmature *arm;
950         bPoseChannel *pchan;
951         TransData *td;
952         TransDataExtension *tdx;
953         short ik_on= 0;
954         int i;
955
956         t->total= 0;
957
958         /* check validity of state */
959         arm= BKE_armature_from_object(ob);
960         if ((arm==NULL) || (ob->pose==NULL)) return;
961
962         if (arm->flag & ARM_RESTPOS) {
963                 if (ELEM(t->mode, TFM_DUMMY, TFM_BONESIZE)==0) {
964                         // XXX use transform operator reports
965                         // BKE_report(op->reports, RPT_ERROR, "Can't select linked when sync selection is enabled");
966                         return;
967                 }
968         }
969
970         /* do we need to add temporal IK chains? */
971         if ((arm->flag & ARM_AUTO_IK) && t->mode==TFM_TRANSLATION) {
972                 ik_on= pose_grab_with_ik(ob);
973                 if (ik_on) t->flag |= T_AUTOIK;
974         }
975
976         /* set flags and count total (warning, can change transform to rotate) */
977         t->total = count_set_pose_transflags(&t->mode, t->around, ob);
978
979         if (t->total == 0) return;
980
981         t->flag |= T_POSE;
982         t->poseobj= ob; /* we also allow non-active objects to be transformed, in weightpaint */
983
984         /* init trans data */
985         td = t->data = MEM_callocN(t->total*sizeof(TransData), "TransPoseBone");
986         tdx = t->ext = MEM_callocN(t->total*sizeof(TransDataExtension), "TransPoseBoneExt");
987         for (i=0; i<t->total; i++, td++, tdx++) {
988                 td->ext= tdx;
989                 td->val = NULL;
990         }
991
992         /* use pose channels to fill trans data */
993         td= t->data;
994         for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
995                 if (pchan->bone->flag & BONE_TRANSFORM) {
996                         add_pose_transdata(t, pchan, ob, td);
997                         td++;
998                 }
999         }
1000
1001         if (td != (t->data+t->total)) {
1002                 // XXX use transform operator reports
1003                 // BKE_report(op->reports, RPT_DEBUG, "Bone selection count error");
1004         }
1005
1006         /* initialize initial auto=ik chainlen's? */
1007         if (ik_on) transform_autoik_update(t, 0);
1008 }
1009
1010 /* ********************* armature ************** */
1011
1012 static void createTransArmatureVerts(TransInfo *t)
1013 {
1014         EditBone *ebo;
1015         bArmature *arm= t->obedit->data;
1016         ListBase *edbo = arm->edbo;
1017         TransData *td;
1018         float mtx[3][3], smtx[3][3], delta[3], bonemat[3][3];
1019         
1020         /* special hack for envelope drawmode and scaling:
1021          *      to allow scaling the size of the envelope around single points,
1022          *      mode should become TFM_BONE_ENVELOPE in this case
1023          */
1024         // TODO: maybe we need a separate hotkey for it, but this is consistent with 2.4x for now
1025         if ((t->mode == TFM_RESIZE) && (arm->drawtype==ARM_ENVELOPE))
1026                 t->mode= TFM_BONE_ENVELOPE;
1027         
1028         t->total = 0;
1029         for (ebo = edbo->first; ebo; ebo = ebo->next) {
1030                 if (EBONE_VISIBLE(arm, ebo) && !(ebo->flag & BONE_EDITMODE_LOCKED)) {
1031                         if (t->mode == TFM_BONESIZE) {
1032                                 if (ebo->flag & BONE_SELECTED)
1033                                         t->total++;
1034                         }
1035                         else if (t->mode == TFM_BONE_ROLL) {
1036                                 if (ebo->flag & BONE_SELECTED)
1037                                         t->total++;
1038                         }
1039                         else {
1040                                 if (ebo->flag & BONE_TIPSEL)
1041                                         t->total++;
1042                                 if (ebo->flag & BONE_ROOTSEL)
1043                                         t->total++;
1044                         }
1045                 }
1046         }
1047
1048         if (!t->total) return;
1049
1050         copy_m3_m4(mtx, t->obedit->obmat);
1051         invert_m3_m3(smtx, mtx);
1052
1053         td = t->data = MEM_callocN(t->total*sizeof(TransData), "TransEditBone");
1054
1055         for (ebo = edbo->first; ebo; ebo = ebo->next) {
1056                 ebo->oldlength = ebo->length;   // length==0.0 on extrude, used for scaling radius of bone points
1057
1058                 if (EBONE_VISIBLE(arm, ebo) && !(ebo->flag & BONE_EDITMODE_LOCKED)) {
1059                         if (t->mode==TFM_BONE_ENVELOPE) {
1060                                 if (ebo->flag & BONE_ROOTSEL) {
1061                                         td->val= &ebo->rad_head;
1062                                         td->ival= *td->val;
1063
1064                                         copy_v3_v3(td->center, ebo->head);
1065                                         td->flag= TD_SELECTED;
1066
1067                                         copy_m3_m3(td->smtx, smtx);
1068                                         copy_m3_m3(td->mtx, mtx);
1069
1070                                         td->loc = NULL;
1071                                         td->ext = NULL;
1072                                         td->ob = t->obedit;
1073
1074                                         td++;
1075                                 }
1076                                 if (ebo->flag & BONE_TIPSEL) {
1077                                         td->val= &ebo->rad_tail;
1078                                         td->ival= *td->val;
1079                                         copy_v3_v3(td->center, ebo->tail);
1080                                         td->flag= TD_SELECTED;
1081
1082                                         copy_m3_m3(td->smtx, smtx);
1083                                         copy_m3_m3(td->mtx, mtx);
1084
1085                                         td->loc = NULL;
1086                                         td->ext = NULL;
1087                                         td->ob = t->obedit;
1088
1089                                         td++;
1090                                 }
1091
1092                         }
1093                         else if (t->mode==TFM_BONESIZE) {
1094                                 if (ebo->flag & BONE_SELECTED) {
1095                                         if (arm->drawtype==ARM_ENVELOPE) {
1096                                                 td->loc= NULL;
1097                                                 td->val= &ebo->dist;
1098                                                 td->ival= ebo->dist;
1099                                         }
1100                                         else {
1101                                                 // abusive storage of scale in the loc pointer :)
1102                                                 td->loc= &ebo->xwidth;
1103                                                 copy_v3_v3(td->iloc, td->loc);
1104                                                 td->val= NULL;
1105                                         }
1106                                         copy_v3_v3(td->center, ebo->head);
1107                                         td->flag= TD_SELECTED;
1108
1109                                         /* use local bone matrix */
1110                                         sub_v3_v3v3(delta, ebo->tail, ebo->head);
1111                                         vec_roll_to_mat3(delta, ebo->roll, bonemat);
1112                                         mul_m3_m3m3(td->mtx, mtx, bonemat);
1113                                         invert_m3_m3(td->smtx, td->mtx);
1114
1115                                         copy_m3_m3(td->axismtx, td->mtx);
1116                                         normalize_m3(td->axismtx);
1117
1118                                         td->ext = NULL;
1119                                         td->ob = t->obedit;
1120
1121                                         td++;
1122                                 }
1123                         }
1124                         else if (t->mode==TFM_BONE_ROLL) {
1125                                 if (ebo->flag & BONE_SELECTED) {
1126                                         td->loc= NULL;
1127                                         td->val= &(ebo->roll);
1128                                         td->ival= ebo->roll;
1129
1130                                         copy_v3_v3(td->center, ebo->head);
1131                                         td->flag= TD_SELECTED;
1132
1133                                         td->ext = NULL;
1134                                         td->ob = t->obedit;
1135
1136                                         td++;
1137                                 }
1138                         }
1139                         else {
1140                                 if (ebo->flag & BONE_TIPSEL) {
1141                                         copy_v3_v3(td->iloc, ebo->tail);
1142                                         copy_v3_v3(td->center, (t->around==V3D_LOCAL) ? ebo->head : td->iloc);
1143                                         td->loc= ebo->tail;
1144                                         td->flag= TD_SELECTED;
1145                                         if (ebo->flag & BONE_EDITMODE_LOCKED)
1146                                                 td->protectflag = OB_LOCK_LOC|OB_LOCK_ROT|OB_LOCK_SCALE;
1147
1148                                         copy_m3_m3(td->smtx, smtx);
1149                                         copy_m3_m3(td->mtx, mtx);
1150
1151                                         sub_v3_v3v3(delta, ebo->tail, ebo->head);
1152                                         vec_roll_to_mat3(delta, ebo->roll, td->axismtx);
1153
1154                                         if ((ebo->flag & BONE_ROOTSEL) == 0) {
1155                                                 td->extra = ebo;
1156                                         }
1157
1158                                         td->ext = NULL;
1159                                         td->val = NULL;
1160                                         td->ob = t->obedit;
1161
1162                                         td++;
1163                                 }
1164                                 if (ebo->flag & BONE_ROOTSEL) {
1165                                         copy_v3_v3(td->iloc, ebo->head);
1166                                         copy_v3_v3(td->center, td->iloc);
1167                                         td->loc= ebo->head;
1168                                         td->flag= TD_SELECTED;
1169                                         if (ebo->flag & BONE_EDITMODE_LOCKED)
1170                                                 td->protectflag = OB_LOCK_LOC|OB_LOCK_ROT|OB_LOCK_SCALE;
1171
1172                                         copy_m3_m3(td->smtx, smtx);
1173                                         copy_m3_m3(td->mtx, mtx);
1174
1175                                         sub_v3_v3v3(delta, ebo->tail, ebo->head);
1176                                         vec_roll_to_mat3(delta, ebo->roll, td->axismtx);
1177
1178                                         td->extra = ebo; /* to fix roll */
1179
1180                                         td->ext = NULL;
1181                                         td->val = NULL;
1182                                         td->ob = t->obedit;
1183
1184                                         td++;
1185                                 }
1186                         }
1187                 }
1188         }
1189 }
1190
1191 /* ********************* meta elements ********* */
1192
1193 static void createTransMBallVerts(TransInfo *t)
1194 {
1195         MetaBall *mb = (MetaBall*)t->obedit->data;
1196         MetaElem *ml;
1197         TransData *td;
1198         TransDataExtension *tx;
1199         float mtx[3][3], smtx[3][3];
1200         int count=0, countsel=0;
1201         int propmode = t->flag & T_PROP_EDIT;
1202
1203         /* count totals */
1204         for (ml= mb->editelems->first; ml; ml= ml->next) {
1205                 if (ml->flag & SELECT) countsel++;
1206                 if (propmode) count++;
1207         }
1208
1209         /* note: in prop mode we need at least 1 selected */
1210         if (countsel==0) return;
1211
1212         if (propmode) t->total = count;
1213         else t->total = countsel;
1214
1215         td = t->data= MEM_callocN(t->total*sizeof(TransData), "TransObData(MBall EditMode)");
1216         tx = t->ext = MEM_callocN(t->total*sizeof(TransDataExtension), "MetaElement_TransExtension");
1217
1218         copy_m3_m4(mtx, t->obedit->obmat);
1219         invert_m3_m3(smtx, mtx);
1220
1221         for (ml= mb->editelems->first; ml; ml= ml->next) {
1222                 if (propmode || (ml->flag & SELECT)) {
1223                         td->loc= &ml->x;
1224                         copy_v3_v3(td->iloc, td->loc);
1225                         copy_v3_v3(td->center, td->loc);
1226
1227                         if (ml->flag & SELECT) td->flag= TD_SELECTED | TD_USEQUAT | TD_SINGLESIZE;
1228                         else td->flag= TD_USEQUAT;
1229
1230                         copy_m3_m3(td->smtx, smtx);
1231                         copy_m3_m3(td->mtx, mtx);
1232
1233                         td->ext = tx;
1234
1235                         /* Radius of MetaElem (mass of MetaElem influence) */
1236                         if (ml->flag & MB_SCALE_RAD) {
1237                                 td->val = &ml->rad;
1238                                 td->ival = ml->rad;
1239                         }
1240                         else {
1241                                 td->val = &ml->s;
1242                                 td->ival = ml->s;
1243                         }
1244
1245                         /* expx/expy/expz determine "shape" of some MetaElem types */
1246                         tx->size = &ml->expx;
1247                         tx->isize[0] = ml->expx;
1248                         tx->isize[1] = ml->expy;
1249                         tx->isize[2] = ml->expz;
1250
1251                         /* quat is used for rotation of MetaElem */
1252                         tx->quat = ml->quat;
1253                         copy_qt_qt(tx->iquat, ml->quat);
1254
1255                         tx->rot = NULL;
1256
1257                         td++;
1258                         tx++;
1259                 }
1260         }
1261 }
1262
1263 /* ********************* curve/surface ********* */
1264
1265 static void calc_distanceCurveVerts(TransData *head, TransData *tail)
1266 {
1267         TransData *td, *td_near = NULL;
1268         for (td = head; td<=tail; td++) {
1269                 if (td->flag & TD_SELECTED) {
1270                         td_near = td;
1271                         td->dist = 0.0f;
1272                 }
1273                 else if (td_near) {
1274                         float dist;
1275                         dist = len_v3v3(td_near->center, td->center);
1276                         if (dist < (td-1)->dist) {
1277                                 td->dist = (td-1)->dist;
1278                         }
1279                         else {
1280                                 td->dist = dist;
1281                         }
1282                 }
1283                 else {
1284                         td->dist = MAXFLOAT;
1285                         td->flag |= TD_NOTCONNECTED;
1286                 }
1287         }
1288         td_near = NULL;
1289         for (td = tail; td>=head; td--) {
1290                 if (td->flag & TD_SELECTED) {
1291                         td_near = td;
1292                         td->dist = 0.0f;
1293                 }
1294                 else if (td_near) {
1295                         float dist;
1296                         dist = len_v3v3(td_near->center, td->center);
1297                         if (td->flag & TD_NOTCONNECTED || dist < td->dist || (td+1)->dist < td->dist) {
1298                                 td->flag &= ~TD_NOTCONNECTED;
1299                                 if (dist < (td+1)->dist) {
1300                                         td->dist = (td+1)->dist;
1301                                 }
1302                                 else {
1303                                         td->dist = dist;
1304                                 }
1305                         }
1306                 }
1307         }
1308 }
1309
1310 /* Utility function for getting the handle data from bezier's */
1311 static TransDataCurveHandleFlags *initTransDataCurveHandles(TransData *td, struct BezTriple *bezt)
1312 {
1313         TransDataCurveHandleFlags *hdata;
1314         td->flag |= TD_BEZTRIPLE;
1315         hdata = td->hdata = MEM_mallocN(sizeof(TransDataCurveHandleFlags), "CuHandle Data");
1316         hdata->ih1 = bezt->h1;
1317         hdata->h1 = &bezt->h1;
1318         hdata->ih2 = bezt->h2; /* in case the second is not selected */
1319         hdata->h2 = &bezt->h2;
1320         return hdata;
1321 }
1322
1323 static void createTransCurveVerts(bContext *C, TransInfo *t)
1324 {
1325         Object *obedit= CTX_data_edit_object(C);
1326         Curve *cu= obedit->data;
1327         TransData *td = NULL;
1328           Nurb *nu;
1329         BezTriple *bezt;
1330         BPoint *bp;
1331         float mtx[3][3], smtx[3][3];
1332         int a;
1333         int count=0, countsel=0;
1334         int propmode = t->flag & T_PROP_EDIT;
1335         short hide_handles = (cu->drawflag & CU_HIDE_HANDLES);
1336         ListBase *nurbs;
1337
1338         /* to be sure */
1339         if (cu->editnurb==NULL) return;
1340
1341         /* count total of vertices, check identical as in 2nd loop for making transdata! */
1342         nurbs= BKE_curve_editNurbs_get(cu);
1343         for (nu= nurbs->first; nu; nu= nu->next) {
1344                 if (nu->type == CU_BEZIER) {
1345                         for (a=0, bezt= nu->bezt; a<nu->pntsu; a++, bezt++) {
1346                                 if (bezt->hide==0) {
1347                                         if (hide_handles) {
1348                                                 if (bezt->f2 & SELECT) countsel+=3;
1349                                                 if (propmode) count+= 3;
1350                                         }
1351                                         else {
1352                                                 if (bezt->f1 & SELECT) countsel++;
1353                                                 if (bezt->f2 & SELECT) countsel++;
1354                                                 if (bezt->f3 & SELECT) countsel++;
1355                                                 if (propmode) count+= 3;
1356                                         }
1357                                 }
1358                         }
1359                 }
1360                 else {
1361                         for (a= nu->pntsu*nu->pntsv, bp= nu->bp; a>0; a--, bp++) {
1362                                 if (bp->hide==0) {
1363                                         if (propmode) count++;
1364                                         if (bp->f1 & SELECT) countsel++;
1365                                 }
1366                         }
1367                 }
1368         }
1369         /* note: in prop mode we need at least 1 selected */
1370         if (countsel==0) return;
1371
1372         if (propmode) t->total = count;
1373         else t->total = countsel;
1374         t->data= MEM_callocN(t->total*sizeof(TransData), "TransObData(Curve EditMode)");
1375
1376         copy_m3_m4(mtx, t->obedit->obmat);
1377         invert_m3_m3(smtx, mtx);
1378
1379         td = t->data;
1380         for (nu= nurbs->first; nu; nu= nu->next) {
1381                 if (nu->type == CU_BEZIER) {
1382                         TransData *head, *tail;
1383                         head = tail = td;
1384                         for (a=0, bezt= nu->bezt; a<nu->pntsu; a++, bezt++) {
1385                                 if (bezt->hide==0) {
1386                                         TransDataCurveHandleFlags *hdata = NULL;
1387
1388                                         if (            propmode ||
1389                                                         ((bezt->f2 & SELECT) && hide_handles) ||
1390                                                         ((bezt->f1 & SELECT) && hide_handles == 0)
1391                                           ) {
1392                                                 copy_v3_v3(td->iloc, bezt->vec[0]);
1393                                                 td->loc= bezt->vec[0];
1394                                                 copy_v3_v3(td->center, bezt->vec[(hide_handles || bezt->f2 & SELECT) ? 1:0]);
1395                                                 if (hide_handles) {
1396                                                         if (bezt->f2 & SELECT) td->flag= TD_SELECTED;
1397                                                         else td->flag= 0;
1398                                                 }
1399                                                 else {
1400                                                         if (bezt->f1 & SELECT) td->flag= TD_SELECTED;
1401                                                         else td->flag= 0;
1402                                                 }
1403                                                 td->ext = NULL;
1404                                                 td->val = NULL;
1405
1406                                                 hdata = initTransDataCurveHandles(td, bezt);
1407
1408                                                 copy_m3_m3(td->smtx, smtx);
1409                                                 copy_m3_m3(td->mtx, mtx);
1410
1411                                                 td++;
1412                                                 count++;
1413                                                 tail++;
1414                                         }
1415
1416                                         /* This is the Curve Point, the other two are handles */
1417                                         if (propmode || (bezt->f2 & SELECT)) {
1418                                                 copy_v3_v3(td->iloc, bezt->vec[1]);
1419                                                 td->loc= bezt->vec[1];
1420                                                 copy_v3_v3(td->center, td->loc);
1421                                                 if (bezt->f2 & SELECT) td->flag= TD_SELECTED;
1422                                                 else td->flag= 0;
1423                                                 td->ext = NULL;
1424
1425                                                 if (t->mode==TFM_CURVE_SHRINKFATTEN) { /* || t->mode==TFM_RESIZE) {*/ /* TODO - make points scale */
1426                                                         td->val = &(bezt->radius);
1427                                                         td->ival = bezt->radius;
1428                                                 }
1429                                                 else if (t->mode==TFM_TILT) {
1430                                                         td->val = &(bezt->alfa);
1431                                                         td->ival = bezt->alfa;
1432                                                 }
1433                                                 else {
1434                                                         td->val = NULL;
1435                                                 }
1436
1437                                                 copy_m3_m3(td->smtx, smtx);
1438                                                 copy_m3_m3(td->mtx, mtx);
1439
1440                                                 if ((bezt->f1&SELECT)==0 && (bezt->f3&SELECT)==0)
1441                                                 /* If the middle is selected but the sides arnt, this is needed */
1442                                                 if (hdata==NULL) { /* if the handle was not saved by the previous handle */
1443                                                         hdata = initTransDataCurveHandles(td, bezt);
1444                                                 }
1445
1446                                                 td++;
1447                                                 count++;
1448                                                 tail++;
1449                                         }
1450                                         if (            propmode ||
1451                                                         ((bezt->f2 & SELECT) && hide_handles) ||
1452                                                         ((bezt->f3 & SELECT) && hide_handles == 0)
1453                                           ) {
1454                                                 copy_v3_v3(td->iloc, bezt->vec[2]);
1455                                                 td->loc= bezt->vec[2];
1456                                                 copy_v3_v3(td->center, bezt->vec[(hide_handles || bezt->f2 & SELECT) ? 1:2]);
1457                                                 if (hide_handles) {
1458                                                         if (bezt->f2 & SELECT) td->flag= TD_SELECTED;
1459                                                         else td->flag= 0;
1460                                                 }
1461                                                 else {
1462                                                         if (bezt->f3 & SELECT) td->flag= TD_SELECTED;
1463                                                         else td->flag= 0;
1464                                                 }
1465                                                 td->ext = NULL;
1466                                                 td->val = NULL;
1467
1468                                                 if (hdata==NULL) { /* if the handle was not saved by the previous handle */
1469                                                         hdata = initTransDataCurveHandles(td, bezt);
1470                                                 }
1471
1472                                                 copy_m3_m3(td->smtx, smtx);
1473                                                 copy_m3_m3(td->mtx, mtx);
1474
1475                                                 td++;
1476                                                 count++;
1477                                                 tail++;
1478                                         }
1479                                 }
1480                                 else if (propmode && head != tail) {
1481                                         calc_distanceCurveVerts(head, tail-1);
1482                                         head = tail;
1483                                 }
1484                         }
1485                         if (propmode && head != tail)
1486                                 calc_distanceCurveVerts(head, tail-1);
1487
1488                         /* TODO - in the case of tilt and radius we can also avoid allocating the initTransDataCurveHandles
1489                          * but for now just don't change handle types */
1490                         if (ELEM(t->mode, TFM_CURVE_SHRINKFATTEN, TFM_TILT) == 0) {
1491                                 /* sets the handles based on their selection, do this after the data is copied to the TransData */
1492                                 BKE_nurb_handles_test(nu);
1493                         }
1494                 }
1495                 else {
1496                         TransData *head, *tail;
1497                         head = tail = td;
1498                         for (a= nu->pntsu*nu->pntsv, bp= nu->bp; a>0; a--, bp++) {
1499                                 if (bp->hide==0) {
1500                                         if (propmode || (bp->f1 & SELECT)) {
1501                                                 copy_v3_v3(td->iloc, bp->vec);
1502                                                 td->loc= bp->vec;
1503                                                 copy_v3_v3(td->center, td->loc);
1504                                                 if (bp->f1 & SELECT) td->flag= TD_SELECTED;
1505                                                 else td->flag= 0;
1506                                                 td->ext = NULL;
1507
1508                                                 if (t->mode==TFM_CURVE_SHRINKFATTEN || t->mode==TFM_RESIZE) {
1509                                                         td->val = &(bp->radius);
1510                                                         td->ival = bp->radius;
1511                                                 }
1512                                                 else {
1513                                                         td->val = &(bp->alfa);
1514                                                         td->ival = bp->alfa;
1515                                                 }
1516
1517                                                 copy_m3_m3(td->smtx, smtx);
1518                                                 copy_m3_m3(td->mtx, mtx);
1519
1520                                                 td++;
1521                                                 count++;
1522                                                 tail++;
1523                                         }
1524                                 }
1525                                 else if (propmode && head != tail) {
1526                                         calc_distanceCurveVerts(head, tail-1);
1527                                         head = tail;
1528                                 }
1529                         }
1530                         if (propmode && head != tail)
1531                                 calc_distanceCurveVerts(head, tail-1);
1532                 }
1533         }
1534 }
1535
1536 /* ********************* lattice *************** */
1537
1538 static void createTransLatticeVerts(TransInfo *t)
1539 {
1540         Lattice *latt = ((Lattice*)t->obedit->data)->editlatt->latt;
1541         TransData *td = NULL;
1542         BPoint *bp;
1543         float mtx[3][3], smtx[3][3];
1544         int a;
1545         int count=0, countsel=0;
1546         int propmode = t->flag & T_PROP_EDIT;
1547
1548         bp = latt->def;
1549         a  = latt->pntsu * latt->pntsv * latt->pntsw;
1550         while (a--) {
1551                 if (bp->hide==0) {
1552                         if (bp->f1 & SELECT) countsel++;
1553                         if (propmode) count++;
1554                 }
1555                 bp++;
1556         }
1557
1558          /* note: in prop mode we need at least 1 selected */
1559         if (countsel==0) return;
1560
1561         if (propmode) t->total = count;
1562         else t->total = countsel;
1563         t->data= MEM_callocN(t->total*sizeof(TransData), "TransObData(Lattice EditMode)");
1564
1565         copy_m3_m4(mtx, t->obedit->obmat);
1566         invert_m3_m3(smtx, mtx);
1567
1568         td = t->data;
1569         bp = latt->def;
1570         a  = latt->pntsu * latt->pntsv * latt->pntsw;
1571         while (a--) {
1572                 if (propmode || (bp->f1 & SELECT)) {
1573                         if (bp->hide==0) {
1574                                 copy_v3_v3(td->iloc, bp->vec);
1575                                 td->loc= bp->vec;
1576                                 copy_v3_v3(td->center, td->loc);
1577                                 if (bp->f1 & SELECT) td->flag= TD_SELECTED;
1578                                 else td->flag= 0;
1579                                 copy_m3_m3(td->smtx, smtx);
1580                                 copy_m3_m3(td->mtx, mtx);
1581
1582                                 td->ext = NULL;
1583                                 td->val = NULL;
1584
1585                                 td++;
1586                                 count++;
1587                         }
1588                 }
1589                 bp++;
1590         }
1591 }
1592
1593 /* ******************* particle edit **************** */
1594 static void createTransParticleVerts(bContext *C, TransInfo *t)
1595 {
1596         TransData *td = NULL;
1597         TransDataExtension *tx;
1598         Base *base = CTX_data_active_base(C);
1599         Object *ob = CTX_data_active_object(C);
1600         ParticleEditSettings *pset = PE_settings(t->scene);
1601         PTCacheEdit *edit = PE_get_current(t->scene, ob);
1602         ParticleSystem *psys = NULL;
1603         ParticleSystemModifierData *psmd = NULL;
1604         PTCacheEditPoint *point;
1605         PTCacheEditKey *key;
1606         float mat[4][4];
1607         int i, k, transformparticle;
1608         int count = 0, hasselected = 0;
1609         int propmode = t->flag & T_PROP_EDIT;
1610
1611         if (edit==NULL || t->settings->particle.selectmode==SCE_SELECT_PATH) return;
1612
1613         psys = edit->psys;
1614
1615         if (psys)
1616                 psmd = psys_get_modifier(ob, psys);
1617
1618         base->flag |= BA_HAS_RECALC_DATA;
1619
1620         for (i=0, point=edit->points; i<edit->totpoint; i++, point++) {
1621                 point->flag &= ~PEP_TRANSFORM;
1622                 transformparticle= 0;
1623
1624                 if ((point->flag & PEP_HIDE)==0) {
1625                         for (k=0, key=point->keys; k<point->totkey; k++, key++) {
1626                                 if ((key->flag&PEK_HIDE)==0) {
1627                                         if (key->flag&PEK_SELECT) {
1628                                                 hasselected= 1;
1629                                                 transformparticle= 1;
1630                                         }
1631                                         else if (propmode)
1632                                                 transformparticle= 1;
1633                                 }
1634                         }
1635                 }
1636
1637                 if (transformparticle) {
1638                         count += point->totkey;
1639                         point->flag |= PEP_TRANSFORM;
1640                 }
1641         }
1642
1643          /* note: in prop mode we need at least 1 selected */
1644         if (hasselected==0) return;
1645
1646         t->total = count;
1647         td = t->data = MEM_callocN(t->total * sizeof(TransData), "TransObData(Particle Mode)");
1648
1649         if (t->mode == TFM_BAKE_TIME)
1650                 tx = t->ext = MEM_callocN(t->total * sizeof(TransDataExtension), "Particle_TransExtension");
1651         else
1652                 tx = t->ext = NULL;
1653
1654         unit_m4(mat);
1655
1656         invert_m4_m4(ob->imat, ob->obmat);
1657
1658         for (i=0, point=edit->points; i<edit->totpoint; i++, point++) {
1659                 TransData *head, *tail;
1660                 head = tail = td;
1661
1662                 if (!(point->flag & PEP_TRANSFORM)) continue;
1663
1664                 if (psys && !(psys->flag & PSYS_GLOBAL_HAIR))
1665                         psys_mat_hair_to_global(ob, psmd->dm, psys->part->from, psys->particles + i, mat);
1666
1667                 for (k=0, key=point->keys; k<point->totkey; k++, key++) {
1668                         if (key->flag & PEK_USE_WCO) {
1669                                 copy_v3_v3(key->world_co, key->co);
1670                                 mul_m4_v3(mat, key->world_co);
1671                                 td->loc = key->world_co;
1672                         }
1673                         else
1674                                 td->loc = key->co;
1675
1676                         copy_v3_v3(td->iloc, td->loc);
1677                         copy_v3_v3(td->center, td->loc);
1678
1679                         if (key->flag & PEK_SELECT)
1680                                 td->flag |= TD_SELECTED;
1681                         else if (!propmode)
1682                                 td->flag |= TD_SKIP;
1683
1684                         unit_m3(td->mtx);
1685                         unit_m3(td->smtx);
1686
1687                         /* don't allow moving roots */
1688                         if (k==0 && pset->flag & PE_LOCK_FIRST && (!psys || !(psys->flag & PSYS_GLOBAL_HAIR)))
1689                                 td->protectflag |= OB_LOCK_LOC;
1690
1691                         td->ob = ob;
1692                         td->ext = tx;
1693                         if (t->mode == TFM_BAKE_TIME) {
1694                                 td->val = key->time;
1695                                 td->ival = *(key->time);
1696                                 /* abuse size and quat for min/max values */
1697                                 td->flag |= TD_NO_EXT;
1698                                 if (k==0) tx->size = NULL;
1699                                 else tx->size = (key - 1)->time;
1700
1701                                 if (k == point->totkey - 1) tx->quat = NULL;
1702                                 else tx->quat = (key + 1)->time;
1703                         }
1704
1705                         td++;
1706                         if (tx)
1707                                 tx++;
1708                         tail++;
1709                 }
1710                 if (propmode && head != tail)
1711                         calc_distanceCurveVerts(head, tail - 1);
1712         }
1713 }
1714
1715 void flushTransParticles(TransInfo *t)
1716 {
1717         Scene *scene = t->scene;
1718         Object *ob = OBACT;
1719         PTCacheEdit *edit = PE_get_current(scene, ob);
1720         ParticleSystem *psys = edit->psys;
1721         ParticleSystemModifierData *psmd = NULL;
1722         PTCacheEditPoint *point;
1723         PTCacheEditKey *key;
1724         TransData *td;
1725         float mat[4][4], imat[4][4], co[3];
1726         int i, k, propmode = t->flag & T_PROP_EDIT;
1727
1728         if (psys)
1729                 psmd = psys_get_modifier(ob, psys);
1730
1731         /* we do transform in world space, so flush world space position
1732          * back to particle local space (only for hair particles) */
1733         td= t->data;
1734         for (i=0, point=edit->points; i<edit->totpoint; i++, point++, td++) {
1735                 if (!(point->flag & PEP_TRANSFORM)) continue;
1736
1737                 if (psys && !(psys->flag & PSYS_GLOBAL_HAIR)) {
1738                         psys_mat_hair_to_global(ob, psmd->dm, psys->part->from, psys->particles + i, mat);
1739                         invert_m4_m4(imat, mat);
1740
1741                         for (k=0, key=point->keys; k<point->totkey; k++, key++) {
1742                                 copy_v3_v3(co, key->world_co);
1743                                 mul_m4_v3(imat, co);
1744
1745
1746                                 /* optimization for proportional edit */
1747                                 if (!propmode || !compare_v3v3(key->co, co, 0.0001f)) {
1748                                         copy_v3_v3(key->co, co);
1749                                         point->flag |= PEP_EDIT_RECALC;
1750                                 }
1751                         }
1752                 }
1753                 else
1754                         point->flag |= PEP_EDIT_RECALC;
1755         }
1756
1757         PE_update_object(scene, OBACT, 1);
1758 }
1759
1760 /* ********************* mesh ****************** */
1761
1762 /* proportional distance based on connectivity  */
1763 #define THRESHOLDFACTOR (1.0f-0.0001f)
1764
1765 /* I did this wrong, it should be a breadth-first search
1766  * but instead it's a depth-first search, fudged
1767  * to report shortest distances.  I have no idea how fast
1768  * or slow this is. */
1769 static void editmesh_set_connectivity_distance(BMEditMesh *em, float mtx[][3], float *dists)
1770 {
1771         BMVert **queue = NULL;
1772         float *dqueue = NULL;
1773         int *tots = MEM_callocN(sizeof(int)*em->bm->totvert, "tots editmesh_set_connectivity_distance");
1774         BLI_array_declare(queue);
1775         BLI_array_declare(dqueue);
1776         SmallHash svisit, *visit=&svisit;
1777         BMVert *v;
1778         BMIter viter;
1779         int i, start;
1780         
1781         fill_vn_fl(dists, em->bm->totvert, FLT_MAX);
1782
1783         BM_mesh_elem_index_ensure(em->bm, BM_VERT);
1784
1785         BLI_smallhash_init(visit);
1786
1787         BM_ITER_MESH (v, &viter, em->bm, BM_VERTS_OF_MESH) {
1788                 if (BM_elem_flag_test(v, BM_ELEM_SELECT)==0 || BM_elem_flag_test(v, BM_ELEM_HIDDEN))
1789                         continue;
1790                         
1791                 
1792                 BLI_smallhash_insert(visit, (uintptr_t)v, NULL);
1793                 BLI_array_append(queue, v);
1794                 BLI_array_append(dqueue, 0.0f);
1795                 dists[BM_elem_index_get(v)] = 0.0f;
1796         }
1797         
1798         start = 0;
1799         while (start < BLI_array_count(queue)) {
1800                 BMIter eiter;
1801                 BMEdge *e;
1802                 BMVert *v3, *v2;
1803                 float d, vec[3];
1804                 
1805                 v2 = queue[start];
1806                 d = dqueue[start];
1807                 
1808                 BM_ITER_ELEM (e, &eiter, v2, BM_EDGES_OF_VERT) {
1809                         float d2;
1810                         v3 = BM_edge_other_vert(e, v2);
1811                         
1812                         if (BM_elem_flag_test(v3, BM_ELEM_SELECT) || BM_elem_flag_test(v3, BM_ELEM_HIDDEN))
1813                                 continue;
1814                         
1815                         sub_v3_v3v3(vec, v2->co, v3->co);
1816                         mul_m3_v3(mtx, vec);
1817                         
1818                         d2 = d + len_v3(vec);
1819                         
1820                         if (dists[BM_elem_index_get(v3)] != FLT_MAX)
1821                                 dists[BM_elem_index_get(v3)] = MIN2(d2, dists[BM_elem_index_get(v3)]);
1822                         else
1823                                 dists[BM_elem_index_get(v3)] = d2;
1824                         
1825                         tots[BM_elem_index_get(v3)] = 1;
1826
1827                         if (BLI_smallhash_haskey(visit, (uintptr_t)v3))
1828                                 continue;
1829                         
1830                         BLI_smallhash_insert(visit, (uintptr_t)v3, NULL);
1831                         
1832                         BLI_array_append(queue, v3);
1833                         BLI_array_append(dqueue, d2);
1834                 }
1835                 
1836                 start++;
1837         }
1838
1839         BLI_smallhash_release(visit);
1840         
1841         for (i=0; i<em->bm->totvert; i++) {
1842                 if (tots[i])
1843                         dists[i] /= (float)tots[i];
1844         }
1845         
1846         BLI_array_free(queue);
1847         BLI_array_free(dqueue);
1848         MEM_freeN(tots);
1849 }
1850
1851 /* loop-in-a-loop I know, but we need it! (ton) */
1852  static void get_face_center(float cent_r[3], BMVert *eve)
1853
1854 {
1855         BMFace *efa;
1856         BMIter iter;
1857
1858         BM_ITER_ELEM (efa, &iter, eve, BM_FACES_OF_VERT) {
1859                 if (BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
1860                         BM_face_calc_center_mean(efa, cent_r);
1861                         break;
1862                 }
1863         }
1864 }
1865
1866 static void get_edge_center(float cent_r[3], BMVert *eve)
1867 {
1868         BMEdge *eed;
1869         BMIter iter;
1870
1871         BM_ITER_ELEM (eed, &iter, eve, BM_EDGES_OF_VERT) {
1872                 if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
1873                         mid_v3_v3v3(cent_r, eed->v1->co, eed->v2->co);
1874                         break;
1875                 }
1876         }
1877 }
1878
1879 /* way to overwrite what data is edited with transform */
1880 static void VertsToTransData(TransInfo *t, TransData *td, BMEditMesh *em, BMVert *eve, float *bweight)
1881 {
1882         td->flag = 0;
1883         //if (key)
1884         //      td->loc = key->co;
1885         //else
1886         td->loc = eve->co;
1887
1888         copy_v3_v3(td->center, td->loc);
1889
1890         if (t->around==V3D_LOCAL) {
1891                 if (em->selectmode & SCE_SELECT_FACE)
1892                         get_face_center(td->center, eve);
1893                 else if (em->selectmode & SCE_SELECT_EDGE)
1894                         get_edge_center(td->center, eve);
1895         }
1896         copy_v3_v3(td->iloc, td->loc);
1897
1898         // Setting normals
1899         copy_v3_v3(td->axismtx[2], eve->no);
1900         td->axismtx[0][0]               =
1901                 td->axismtx[0][1]       =
1902                 td->axismtx[0][2]       =
1903                 td->axismtx[1][0]       =
1904                 td->axismtx[1][1]       =
1905                 td->axismtx[1][2]       = 0.0f;
1906
1907         td->ext = NULL;
1908         td->val = NULL;
1909         td->extra = NULL;
1910         if (t->mode == TFM_BWEIGHT) {
1911                 td->val = bweight;
1912                 td->ival = bweight ? *(bweight) : 1.0f;
1913         }
1914 }
1915
1916 static void createTransEditVerts(bContext *C, TransInfo *t)
1917 {
1918         ToolSettings *ts = CTX_data_tool_settings(C);
1919         TransData *tob = NULL;
1920         BMEditMesh *em = BMEdit_FromObject(t->obedit);
1921         BMesh *bm = em->bm;
1922         BMVert *eve;
1923         BMIter iter;
1924         BMVert *eve_act = NULL;
1925         float *mappedcos = NULL, *quats= NULL;
1926         float mtx[3][3], smtx[3][3], (*defmats)[3][3] = NULL, (*defcos)[3] = NULL;
1927         float *dists=NULL;
1928         int count=0, countsel=0, a, totleft;
1929         int propmode = (t->flag & T_PROP_EDIT) ? (t->flag & (T_PROP_EDIT | T_PROP_CONNECTED)) : 0;
1930         int mirror = 0;
1931         char *selstate = NULL;
1932         short selectmode = ts->selectmode;
1933
1934         if (t->flag & T_MIRROR) {
1935                 EDBM_verts_mirror_cache_begin(em, TRUE);
1936                 mirror = 1;
1937         }
1938
1939         /* edge slide forces edge select */
1940         if (t->mode == TFM_EDGE_SLIDE) {
1941                 selectmode = SCE_SELECT_EDGE;
1942         }
1943
1944         /* BMESH_TODO, writing into the index values is BAD!, means we cant
1945          * use the values for vertex mirror - campbell */
1946
1947         // transform now requires awareness for select mode, so we tag the f1 flags in verts
1948         if (selectmode & SCE_SELECT_VERTEX) {
1949                 BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
1950                         BM_elem_flag_set(eve, BM_ELEM_TAG, BM_elem_flag_test(eve, BM_ELEM_SELECT));
1951                 }
1952         }
1953         else if (selectmode & SCE_SELECT_EDGE) {
1954                 BMEdge *eed;
1955
1956                 eve = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL);
1957                 for ( ; eve; eve=BM_iter_step(&iter)) BM_elem_flag_disable(eve, BM_ELEM_TAG);
1958
1959                 eed = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, NULL);
1960                 for ( ; eed; eed=BM_iter_step(&iter)) {
1961                         if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
1962                                 BM_elem_flag_enable(eed->v1, BM_ELEM_TAG);
1963                                 BM_elem_flag_enable(eed->v2, BM_ELEM_TAG);
1964                         }
1965                 }
1966         }
1967         else {
1968                 BMFace *efa;
1969                 eve = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL);
1970                 for ( ; eve; eve=BM_iter_step(&iter)) BM_elem_flag_disable(eve, BM_ELEM_TAG);
1971
1972                 efa = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, NULL);
1973                 for ( ; efa; efa=BM_iter_step(&iter)) {
1974                         if (BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
1975                                 BMIter liter;
1976                                 BMLoop *l;
1977
1978                                 l = BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, efa);
1979                                 for (; l; l=BM_iter_step(&liter)) {
1980                                         BM_elem_flag_enable(l->v, BM_ELEM_TAG);
1981                                 }
1982                         }
1983                 }
1984         }
1985
1986         /* now we can count. we store selection state in selstate, since
1987          * get_crazy_mapped_editverts messes up the index state of the
1988          * verts*/
1989         selstate = MEM_callocN(sizeof(*selstate) * bm->totvert, __func__);
1990         eve = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL);
1991         for (a=0; eve; eve=BM_iter_step(&iter), a++) {
1992                 if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
1993                         if (BM_elem_flag_test(eve, BM_ELEM_TAG)) {
1994                                 selstate[a] = 1;
1995                                 countsel++;
1996                         }
1997                         if (propmode) count++;
1998                 }
1999         }
2000
2001         /* note: in prop mode we need at least 1 selected */
2002         if (countsel == 0) {
2003                 goto cleanup;
2004         }
2005
2006         /* check active */
2007         if (em->bm->selected.last) {
2008                 BMEditSelection *ese = em->bm->selected.last;
2009                 if (ese->htype == BM_VERT) {
2010                         eve_act = (BMVert *)ese->ele;
2011                 }
2012         }
2013
2014
2015         if (propmode) {
2016                 t->total = count;
2017
2018                 /* allocating scratch arrays */
2019                 if (propmode & T_PROP_CONNECTED)
2020                         dists = MEM_mallocN(em->bm->totvert * sizeof(float), "scratch nears");
2021         }
2022         else t->total = countsel;
2023
2024         tob= t->data= MEM_callocN(t->total*sizeof(TransData), "TransObData(Mesh EditMode)");
2025
2026         copy_m3_m4(mtx, t->obedit->obmat);
2027         invert_m3_m3(smtx, mtx);
2028
2029         if (propmode & T_PROP_CONNECTED) {
2030                 editmesh_set_connectivity_distance(em, mtx, dists);
2031         }
2032
2033         /* detect CrazySpace [tm] */
2034         if (modifiers_getCageIndex(t->scene, t->obedit, NULL, 1)>=0) {
2035                 if (modifiers_isCorrectableDeformed(t->obedit)) {
2036                         /* check if we can use deform matrices for modifier from the
2037                          * start up to stack, they are more accurate than quats */
2038                         totleft= editbmesh_get_first_deform_matrices(t->scene, t->obedit, em, &defmats, &defcos);
2039
2040                         /* if we still have more modifiers, also do crazyspace
2041                          * correction with quats, relative to the coordinates after
2042                          * the modifiers that support deform matrices (defcos) */
2043                         if (totleft > 0) {
2044                                 mappedcos= crazyspace_get_mapped_editverts(t->scene, t->obedit);
2045                                 quats= MEM_mallocN((t->total)*sizeof(float)*4, "crazy quats");
2046                                 crazyspace_set_quats_editmesh(em, (float*)defcos, mappedcos, quats); /* BMESH_TODO, abuses vertex index, should use an int array */
2047                                 if (mappedcos)
2048                                         MEM_freeN(mappedcos);
2049                         }
2050
2051                         if (defcos)
2052                                 MEM_freeN(defcos);
2053                 }
2054         }
2055
2056         /* find out which half we do */
2057         if (mirror) {
2058                 eve = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL);
2059                 for (a=0; eve; eve=BM_iter_step(&iter), a++) {
2060                         if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN) && selstate[a] && eve->co[0]!=0.0f) {
2061                                 if (eve->co[0] < 0.0f) {
2062                                         t->mirror = -1;
2063                                         mirror = -1;
2064                                 }
2065                                 break;
2066                         }
2067                 }
2068         }
2069
2070         eve = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL);
2071         for (a=0; eve; eve=BM_iter_step(&iter), a++) {
2072                 if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
2073                         if (propmode || selstate[a]) {
2074                                 float *bweight = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_BWEIGHT);
2075                                 
2076                                 VertsToTransData(t, tob, em, eve, bweight);
2077
2078                                 /* selected */
2079                                 if (selstate[a]) tob->flag |= TD_SELECTED;
2080
2081                                 /* active */
2082                                 if (eve == eve_act) tob->flag |= TD_ACTIVE;
2083
2084                                 if (propmode) {
2085                                         if (propmode & T_PROP_CONNECTED) {
2086                                                 tob->dist = dists[a];
2087                                         }
2088                                         else {
2089                                                 tob->flag |= TD_NOTCONNECTED;
2090                                                 tob->dist = MAXFLOAT;
2091                                         }
2092                                 }
2093
2094                                 /* CrazySpace */
2095                                 if (defmats || (quats && BM_elem_index_get(eve) != -1)) {
2096                                         float mat[3][3], qmat[3][3], imat[3][3];
2097
2098                                         /* use both or either quat and defmat correction */
2099                                         if (quats && BM_elem_index_get(eve) != -1) {
2100                                                 quat_to_mat3(qmat, quats + 4*BM_elem_index_get(eve));
2101
2102                                                 if (defmats)
2103                                                         mul_serie_m3(mat, mtx, qmat, defmats[a],
2104                                                                 NULL, NULL, NULL, NULL, NULL);
2105                                                 else
2106                                                         mul_m3_m3m3(mat, mtx, qmat);
2107                                         }
2108                                         else
2109                                                 mul_m3_m3m3(mat, mtx, defmats[a]);
2110
2111                                         invert_m3_m3(imat, mat);
2112
2113                                         copy_m3_m3(tob->smtx, imat);
2114                                         copy_m3_m3(tob->mtx, mat);
2115                                 }
2116                                 else {
2117                                         copy_m3_m3(tob->smtx, smtx);
2118                                         copy_m3_m3(tob->mtx, mtx);
2119                                 }
2120
2121                                 /* Mirror? */
2122                                 if ((mirror>0 && tob->iloc[0]>0.0f) || (mirror<0 && tob->iloc[0]<0.0f)) {
2123                                         BMVert *vmir= EDBM_verts_mirror_get(em, eve); //t->obedit, em, eve, tob->iloc, a);
2124                                         if (vmir && vmir != eve) {
2125                                                 tob->extra = vmir;
2126                                         }
2127                                 }
2128                                 tob++;
2129                         }
2130                 }
2131         }
2132         
2133         if (mirror != 0) {
2134                 tob = t->data;
2135                 for (a = 0; a < t->total; a++, tob++ ) {
2136                         if (ABS(tob->loc[0]) <= 0.00001f) {
2137                                 tob->flag |= TD_MIRROR_EDGE;
2138                         }
2139                 }
2140         }
2141
2142 cleanup:
2143         /* crazy space free */
2144         if (quats)
2145                 MEM_freeN(quats);
2146         if (defmats)
2147                 MEM_freeN(defmats);
2148         if (dists)
2149                 MEM_freeN(dists);
2150         
2151         MEM_freeN(selstate);
2152
2153         if (t->flag & T_MIRROR) {
2154                 EDBM_verts_mirror_cache_end(em);
2155                 mirror = 1;
2156         }
2157 }
2158
2159 /* *** NODE EDITOR *** */
2160 void flushTransNodes(TransInfo *t)
2161 {
2162         int a;
2163         TransData2D *td;
2164
2165         /* flush to 2d vector from internally used 3d vector */
2166         for (a=0, td= t->data2d; a<t->total; a++, td++) {
2167                 td->loc2d[0]= td->loc[0];
2168                 td->loc2d[1]= td->loc[1];
2169         }
2170         
2171         /* handle intersection with noodles */
2172         if (t->total==1) {
2173                 ED_node_link_intersect_test(t->sa, 1);
2174         }
2175         
2176 }
2177
2178 /* *** SEQUENCE EDITOR *** */
2179
2180 /* commented _only_ because the meta may have animation data which
2181  * needs moving too [#28158] */
2182
2183 #define SEQ_TX_NESTED_METAS
2184
2185 void flushTransSeq(TransInfo *t)
2186 {
2187         ListBase *seqbasep= seq_give_editing(t->scene, FALSE)->seqbasep; /* Editing null check already done */
2188         int a, new_frame, old_start;
2189         TransData *td= NULL;
2190         TransData2D *td2d= NULL;
2191         TransDataSeq *tdsq= NULL;
2192         Sequence *seq;
2193
2194
2195
2196         /* prevent updating the same seq twice
2197          * if the transdata order is changed this will mess up
2198          * but so will TransDataSeq */
2199         Sequence *seq_prev= NULL;
2200
2201         /* flush to 2d vector from internally used 3d vector */
2202         for (a=0, td= t->data, td2d= t->data2d; a<t->total; a++, td++, td2d++) {
2203                 tdsq= (TransDataSeq *)td->extra;
2204                 seq= tdsq->seq;
2205                 old_start = seq->start;
2206                 new_frame= (int)floor(td2d->loc[0] + 0.5f);
2207
2208                 switch (tdsq->sel_flag) {
2209                 case SELECT:
2210 #ifdef SEQ_TX_NESTED_METAS
2211                         if ((seq->depth != 0 || seq_tx_test(seq))) /* for meta's, their children move */
2212                                 seq->start= new_frame - tdsq->start_offset;
2213 #else
2214                         if (seq->type != SEQ_META && (seq->depth != 0 || seq_tx_test(seq))) /* for meta's, their children move */
2215                                 seq->start= new_frame - tdsq->start_offset;
2216 #endif
2217                         if (seq->depth==0) {
2218                                 seq->machine= (int)floor(td2d->loc[1] + 0.5f);
2219                                 CLAMP(seq->machine, 1, MAXSEQ);
2220                         }
2221                         break;
2222                 case SEQ_LEFTSEL: /* no vertical transform  */
2223                         seq_tx_set_final_left(seq, new_frame);
2224                         seq_tx_handle_xlimits(seq, tdsq->flag&SEQ_LEFTSEL, tdsq->flag&SEQ_RIGHTSEL);
2225                         seq_single_fix(seq); /* todo - move this into aftertrans update? - old seq tx needed it anyway */
2226                         break;
2227                 case SEQ_RIGHTSEL: /* no vertical transform  */
2228                         seq_tx_set_final_right(seq, new_frame);
2229                         seq_tx_handle_xlimits(seq, tdsq->flag&SEQ_LEFTSEL, tdsq->flag&SEQ_RIGHTSEL);
2230                         seq_single_fix(seq); /* todo - move this into aftertrans update? - old seq tx needed it anyway */
2231                         break;
2232                 }
2233
2234                 if (seq != seq_prev) {
2235                         if (seq->depth==0) {
2236                                 /* Calculate this strip and all nested strips
2237                                  * children are ALWAYS transformed first
2238                                  * so we don't need to do this in another loop. */
2239                                 calc_sequence(t->scene, seq);
2240                         }
2241                         else {
2242                                 calc_sequence_disp(t->scene, seq);
2243                         }
2244
2245                         if (tdsq->sel_flag == SELECT)
2246                                 seq_offset_animdata(t->scene, seq, seq->start - old_start);
2247                 }
2248                 seq_prev= seq;
2249         }
2250
2251
2252         if (ELEM(t->mode, TFM_SEQ_SLIDE, TFM_TIME_TRANSLATE)) { /* originally TFM_TIME_EXTEND, transform changes */
2253                 /* Special annoying case here, need to calc metas with TFM_TIME_EXTEND only */
2254
2255                 /* calc all meta's then effects [#27953] */
2256                 for (seq = seqbasep->first; seq; seq = seq->next) {
2257                         if (seq->type == SEQ_META && seq->flag & SELECT) {
2258                                 calc_sequence(t->scene, seq);
2259                         }
2260                 }
2261                 for (seq = seqbasep->first; seq; seq = seq->next) {
2262                         if (seq->seq1 || seq->seq2 || seq->seq3) {
2263                                 calc_sequence(t->scene, seq);
2264                         }
2265                 }
2266         }
2267
2268         /* need to do the overlap check in a new loop otherwise adjacent strips
2269          * will not be updated and we'll get false positives */
2270         seq_prev= NULL;
2271         for (a=0, td= t->data, td2d= t->data2d; a<t->total; a++, td++, td2d++) {
2272
2273                 tdsq= (TransDataSeq *)td->extra;
2274                 seq= tdsq->seq;
2275
2276                 if (seq != seq_prev) {
2277                         if (seq->depth==0) {
2278                                 /* test overlap, displayes red outline */
2279                                 seq->flag &= ~SEQ_OVERLAP;
2280                                 if (seq_test_overlap(seqbasep, seq)) {
2281                                         seq->flag |= SEQ_OVERLAP;
2282                                 }
2283                         }
2284                 }
2285                 seq_prev= seq;
2286         }
2287 }
2288
2289 /* ********************* UV ****************** */
2290
2291 static void UVsToTransData(SpaceImage *sima, TransData *td, TransData2D *td2d, float *uv, int selected)
2292 {
2293         float aspx, aspy;
2294
2295         ED_space_image_uv_aspect(sima, &aspx, &aspy);
2296
2297         /* uv coords are scaled by aspects. this is needed for rotations and
2298          * proportional editing to be consistent with the stretched uv coords
2299          * that are displayed. this also means that for display and numinput,
2300          * and when the the uv coords are flushed, these are converted each time */
2301         td2d->loc[0] = uv[0]*aspx;
2302         td2d->loc[1] = uv[1]*aspy;
2303         td2d->loc[2] = 0.0f;
2304         td2d->loc2d = uv;
2305
2306         td->flag = 0;
2307         td->loc = td2d->loc;
2308         copy_v3_v3(td->center, td->loc);
2309         copy_v3_v3(td->iloc, td->loc);
2310
2311         memset(td->axismtx, 0, sizeof(td->axismtx));
2312         td->axismtx[2][2] = 1.0f;
2313
2314         td->ext= NULL; td->val= NULL;
2315
2316         if (selected) {
2317                 td->flag |= TD_SELECTED;
2318                 td->dist= 0.0;
2319         }
2320         else {
2321                 td->dist= MAXFLOAT;
2322         }
2323         unit_m3(td->mtx);
2324         unit_m3(td->smtx);
2325 }
2326
2327 static void createTransUVs(bContext *C, TransInfo *t)
2328 {
2329         SpaceImage *sima = CTX_wm_space_image(C);
2330         Image *ima = CTX_data_edit_image(C);
2331         Scene *scene = t->scene;
2332         TransData *td = NULL;
2333         TransData2D *td2d = NULL;
2334         MTexPoly *tf;
2335         MLoopUV *luv;
2336         BMEditMesh *em = BMEdit_FromObject(t->obedit);
2337         BMFace *efa;
2338         BMLoop *l;
2339         BMIter iter, liter;
2340         int count=0, countsel=0;
2341         int propmode = t->flag & T_PROP_EDIT;
2342
2343         if (!ED_space_image_show_uvedit(sima, t->obedit)) return;
2344
2345         /* count */
2346         BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
2347                 tf= CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
2348
2349                 if (!uvedit_face_visible_test(scene, ima, efa, tf)) {
2350                         BM_elem_flag_disable(efa, BM_ELEM_TAG);
2351                         continue;
2352                 }
2353                 
2354                 BM_elem_flag_enable(efa, BM_ELEM_TAG);
2355                 BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
2356                         if (uvedit_uv_select_test(em, scene, l)) 
2357                                 countsel++;
2358
2359                         if (propmode)
2360                                 count++;
2361                 }
2362         }
2363
2364          /* note: in prop mode we need at least 1 selected */
2365         if (countsel==0) return;
2366
2367         t->total= (propmode)? count: countsel;
2368         t->data= MEM_callocN(t->total*sizeof(TransData), "TransObData(UV Editing)");
2369         /* for each 2d uv coord a 3d vector is allocated, so that they can be
2370          * treated just as if they were 3d verts */
2371         t->data2d= MEM_callocN(t->total*sizeof(TransData2D), "TransObData2D(UV Editing)");
2372
2373         if (sima->flag & SI_CLIP_UV)
2374                 t->flag |= T_CLIP_UV;
2375
2376         td= t->data;
2377         td2d= t->data2d;
2378
2379         BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
2380                 if (!BM_elem_flag_test(efa, BM_ELEM_TAG))
2381                         continue;
2382
2383                 BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
2384                         if (!propmode && !uvedit_uv_select_test(em, scene, l))
2385                                 continue;
2386                         
2387                         luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
2388                         UVsToTransData(sima, td++, td2d++, luv->uv, uvedit_uv_select_test(em, scene, l));
2389                 }
2390         }
2391
2392         if (sima->flag & SI_LIVE_UNWRAP)
2393                 ED_uvedit_live_unwrap_begin(t->scene, t->obedit);
2394 }
2395
2396 void flushTransUVs(TransInfo *t)
2397 {
2398         SpaceImage *sima = t->sa->spacedata.first;
2399         TransData2D *td;
2400         int a, width, height;
2401         float aspx, aspy, invx, invy;
2402
2403         ED_space_image_uv_aspect(sima, &aspx, &aspy);
2404         ED_space_image_size(sima, &width, &height);
2405         invx= 1.0f/aspx;
2406         invy= 1.0f/aspy;
2407
2408         /* flush to 2d vector from internally used 3d vector */
2409         for (a=0, td= t->data2d; a<t->total; a++, td++) {
2410                 td->loc2d[0]= td->loc[0]*invx;
2411                 td->loc2d[1]= td->loc[1]*invy;
2412
2413                 if ((sima->flag & SI_PIXELSNAP) && (t->state != TRANS_CANCEL)) {
2414                         td->loc2d[0]= (float)floor(width*td->loc2d[0] + 0.5f)/width;
2415                         td->loc2d[1]= (float)floor(height*td->loc2d[1] + 0.5f)/height;
2416                 }
2417         }
2418 }
2419
2420 int clipUVTransform(TransInfo *t, float *vec, int resize)
2421 {
2422         TransData *td;
2423         int a, clipx=1, clipy=1;
2424         float aspx, aspy, min[2], max[2];
2425
2426         ED_space_image_uv_aspect(t->sa->spacedata.first, &aspx, &aspy);
2427         min[0]= min[1]= 0.0f;
2428         max[0]= aspx; max[1]= aspy;
2429
2430         for (a=0, td= t->data; a<t->total; a++, td++) {
2431                 DO_MINMAX2(td->loc, min, max);
2432         }
2433
2434         if (resize) {
2435                 if (min[0] < 0.0f && t->center[0] > 0.0f && t->center[0] < aspx*0.5f)
2436                         vec[0] *= t->center[0]/(t->center[0] - min[0]);
2437                 else if (max[0] > aspx && t->center[0] < aspx)
2438                         vec[0] *= (t->center[0] - aspx)/(t->center[0] - max[0]);
2439                 else
2440                         clipx= 0;
2441
2442                 if (min[1] < 0.0f && t->center[1] > 0.0f && t->center[1] < aspy*0.5f)
2443                         vec[1] *= t->center[1]/(t->center[1] - min[1]);
2444                 else if (max[1] > aspy && t->center[1] < aspy)
2445                         vec[1] *= (t->center[1] - aspy)/(t->center[1] - max[1]);
2446                 else
2447                         clipy= 0;
2448         }
2449         else {
2450                 if (min[0] < 0.0f)
2451                         vec[0] -= min[0];
2452                 else if (max[0] > aspx)
2453                         vec[0] -= max[0]-aspx;
2454                 else
2455                         clipx= 0;
2456
2457                 if (min[1] < 0.0f)
2458                         vec[1] -= min[1];
2459                 else if (max[1] > aspy)
2460                         vec[1] -= max[1]-aspy;
2461                 else
2462                         clipy= 0;
2463         }
2464
2465         return (clipx || clipy);
2466 }
2467
2468 /* ********************* ANIMATION EDITORS (GENERAL) ************************* */
2469
2470 /* This function tests if a point is on the "mouse" side of the cursor/frame-marking */
2471 static short FrameOnMouseSide(char side, float frame, float cframe)
2472 {
2473         /* both sides, so it doesn't matter */
2474         if (side == 'B') return 1;
2475
2476         /* only on the named side */
2477         if (side == 'R')
2478                 return (frame >= cframe) ? 1 : 0;
2479         else
2480                 return (frame <= cframe) ? 1 : 0;
2481 }
2482
2483 /* ********************* NLA EDITOR ************************* */
2484
2485 static void createTransNlaData(bContext *C, TransInfo *t)
2486 {
2487         Scene *scene= t->scene;
2488         SpaceNla *snla = NULL;
2489         TransData *td = NULL;
2490         TransDataNla *tdn = NULL;
2491         
2492         bAnimContext ac;
2493         ListBase anim_data = {NULL, NULL};
2494         bAnimListElem *ale;
2495         int filter;
2496         
2497         int count=0;
2498         
2499         /* determine what type of data we are operating on */
2500         if (ANIM_animdata_get_context(C, &ac) == 0)
2501                 return;
2502         snla = (SpaceNla *)ac.sl;
2503         
2504         /* filter data */
2505         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT);
2506         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
2507         
2508         /* which side of the current frame should be allowed */
2509         if (t->mode == TFM_TIME_EXTEND) {
2510                 /* only side on which mouse is gets transformed */
2511                 float xmouse, ymouse;
2512                 
2513                 UI_view2d_region_to_view(&ac.ar->v2d, t->imval[0], t->imval[1], &xmouse, &ymouse);
2514                 t->frame_side= (xmouse > CFRA) ? 'R' : 'L';
2515         }
2516         else {
2517                 /* normal transform - both sides of current frame are considered */
2518                 t->frame_side = 'B';
2519         }
2520         
2521         /* loop 1: count how many strips are selected (consider each strip as 2 points) */
2522         for (ale= anim_data.first; ale; ale= ale->next) {
2523                 NlaTrack *nlt= (NlaTrack *)ale->data;
2524                 NlaStrip *strip;
2525                 
2526                 /* make some meta-strips for chains of selected strips */
2527                 BKE_nlastrips_make_metas(&nlt->strips, 1);
2528                 
2529                 /* only consider selected strips */
2530                 for (strip= nlt->strips.first; strip; strip= strip->next) {
2531                         // TODO: we can make strips have handles later on...
2532                         /* transition strips can't get directly transformed */
2533                         if (strip->type != NLASTRIP_TYPE_TRANSITION) {
2534                                 if (strip->flag & NLASTRIP_FLAG_SELECT) {
2535                                         if (FrameOnMouseSide(t->frame_side, strip->start, (float)CFRA)) count++;
2536                                         if (FrameOnMouseSide(t->frame_side, strip->end, (float)CFRA)) count++;
2537                                 }
2538                         }
2539                 }
2540         }
2541         
2542         /* stop if trying to build list if nothing selected */
2543         if (count == 0) {
2544                 /* cleanup temp list */
2545                 BLI_freelistN(&anim_data);
2546                 return;
2547         }
2548         
2549         /* allocate memory for data */
2550         t->total= count;
2551         
2552         t->data= MEM_callocN(t->total*sizeof(TransData), "TransData(NLA Editor)");
2553         td= t->data;
2554         t->customData= MEM_callocN(t->total*sizeof(TransDataNla), "TransDataNla (NLA Editor)");
2555         tdn= t->customData;
2556         t->flag |= T_FREE_CUSTOMDATA;
2557         
2558         /* loop 2: build transdata array */
2559         for (ale= anim_data.first; ale; ale= ale->next) {
2560                 /* only if a real NLA-track */
2561                 if (ale->type == ANIMTYPE_NLATRACK) {
2562                         AnimData *adt = ale->adt;
2563                         NlaTrack *nlt= (NlaTrack *)ale->data;
2564                         NlaStrip *strip;
2565                         
2566                         /* only consider selected strips */
2567                         for (strip= nlt->strips.first; strip; strip= strip->next) {
2568                                 // TODO: we can make strips have handles later on...
2569                                 /* transition strips can't get directly transformed */
2570                                 if (strip->type != NLASTRIP_TYPE_TRANSITION) {
2571                                         if (strip->flag & NLASTRIP_FLAG_SELECT) {
2572                                                 /* our transform data is constructed as follows:
2573                                                  *      - only the handles on the right side of the current-frame get included
2574                                                  *      - td structs are transform-elements operated on by the transform system
2575                                                  *        and represent a single handle. The storage/pointer used (val or loc) depends on
2576                                                  *        whether we're scaling or transforming. Ultimately though, the handles
2577                                                  *        the td writes to will simply be a dummy in tdn
2578                                                  *      - for each strip being transformed, a single tdn struct is used, so in some
2579                                                  *        cases, there will need to be 1 of these tdn elements in the array skipped...
2580                                                  */
2581                                                 float center[3], yval;
2582                                                 
2583                                                 /* firstly, init tdn settings */
2584                                                 tdn->id= ale->id;
2585                                                 tdn->oldTrack= tdn->nlt= nlt;
2586                                                 tdn->strip= strip;
2587                                                 tdn->trackIndex= BLI_findindex(&adt->nla_tracks, nlt);
2588                                                 
2589                                                 yval= (float)(tdn->trackIndex * NLACHANNEL_STEP(snla));
2590                                                 
2591                                                 tdn->h1[0]= strip->start;
2592                                                 tdn->h1[1]= yval;
2593                                                 tdn->h2[0]= strip->end;
2594                                                 tdn->h2[1]= yval;
2595                                                 
2596                                                 center[0]= (float)CFRA;
2597                                                 center[1]= yval;
2598                                                 center[2]= 0.0f;
2599                                                 
2600                                                 /* set td's based on which handles are applicable */
2601                                                 if (FrameOnMouseSide(t->frame_side, strip->start, (float)CFRA)) {
2602                                                         /* just set tdn to assume that it only has one handle for now */
2603                                                         tdn->handle= -1;
2604                                                         
2605                                                         /* now, link the transform data up to this data */
2606                                                         if (ELEM(t->mode, TFM_TRANSLATION, TFM_TIME_EXTEND)) {
2607                                                                 td->loc= tdn->h1;
2608                                                                 copy_v3_v3(td->iloc, tdn->h1);
2609                                                                 
2610                                                                 /* store all the other gunk that is required by transform */
2611                                                                 copy_v3_v3(td->center, center);
2612                                                                 memset(td->axismtx, 0, sizeof(td->axismtx));
2613                                                                 td->axismtx[2][2] = 1.0f;
2614                                                                 
2615                                                                 td->ext= NULL; td->val= NULL;
2616                                                                 
2617                                                                 td->flag |= TD_SELECTED;
2618                                                                 td->dist= 0.0f;
2619                                                                 
2620                                                                 unit_m3(td->mtx);
2621                                                                 unit_m3(td->smtx);
2622                                                         }
2623                                                         else {
2624                                                                 /* time scaling only needs single value */
2625                                                                 td->val= &tdn->h1[0];
2626                                                                 td->ival= tdn->h1[0];
2627                                                         }
2628                                                         
2629                                                         td->extra= tdn;
2630                                                         td++;
2631                                                 }
2632                                                 if (FrameOnMouseSide(t->frame_side, strip->end, (float)CFRA)) {
2633                                                         /* if tdn is already holding the start handle, then we're doing both, otherwise, only end */
2634                                                         tdn->handle= (tdn->handle) ? 2 : 1;
2635                                                         
2636                                                         /* now, link the transform data up to this data */
2637                                                         if (ELEM(t->mode, TFM_TRANSLATION, TFM_TIME_EXTEND)) {
2638                                                                 td->loc= tdn->h2;
2639                                                                 copy_v3_v3(td->iloc, tdn->h2);
2640                                                                 
2641                                                                 /* store all the other gunk that is required by transform */
2642                                                                 copy_v3_v3(td->center, center);
2643                                                                 memset(td->axismtx, 0, sizeof(td->axismtx));
2644                                                                 td->axismtx[2][2] = 1.0f;
2645                                                                 
2646                                                                 td->ext= NULL; td->val= NULL;
2647                                                                 
2648                                                                 td->flag |= TD_SELECTED;
2649                                                                 td->dist= 0.0f;
2650                                                                 
2651                                                                 unit_m3(td->mtx);
2652                                                                 unit_m3(td->smtx);
2653                                                         }
2654                                                         else {
2655                                                                 /* time scaling only needs single value */
2656                                                                 td->val= &tdn->h2[0];
2657                                                                 td->ival= tdn->h2[0];
2658                                                         }
2659                                                         
2660                                                         td->extra= tdn;
2661                                                         td++;
2662                                                 }
2663                                                 
2664                                                 /* if both handles were used, skip the next tdn (i.e. leave it blank) since the counting code is dumb...
2665                                                  * otherwise, just advance to the next one...
2666                                                  */
2667                                                 if (tdn->handle == 2)
2668                                                         tdn += 2;
2669                                                 else
2670                                                         tdn++;
2671                                         }
2672                                 }
2673                         }
2674                 }
2675         }
2676         
2677         /* cleanup temp list */
2678         BLI_freelistN(&anim_data);
2679 }
2680
2681 /* ********************* ACTION EDITOR ****************** */
2682
2683 /* Called by special_aftertrans_update to make sure selected gp-frames replace
2684  * any other gp-frames which may reside on that frame (that are not selected).
2685  * It also makes sure gp-frames are still stored in chronological order after
2686  * transform.
2687  */
2688 static void posttrans_gpd_clean (bGPdata *gpd)
2689 {
2690         bGPDlayer *gpl;
2691         
2692         for (gpl= gpd->layers.first; gpl; gpl= gpl->next) {
2693                 ListBase sel_buffer = {NULL, NULL};
2694                 bGPDframe *gpf, *gpfn;
2695                 bGPDframe *gfs, *gfsn;
2696                 
2697                 /* loop 1: loop through and isolate selected gp-frames to buffer
2698                  * (these need to be sorted as they are isolated)
2699                  */
2700                 for (gpf= gpl->frames.first; gpf; gpf= gpfn) {
2701                         short added= 0;
2702                         gpfn= gpf->next;
2703                         
2704                         if (gpf->flag & GP_FRAME_SELECT) {
2705                                 BLI_remlink(&gpl->frames, gpf);
2706                                 
2707                                 /* find place to add them in buffer
2708                                  * - go backwards as most frames will still be in order,
2709                                  *   so doing it this way will be faster
2710                                  */
2711                                 for (gfs= sel_buffer.last; gfs; gfs= gfs->prev) {
2712                                         /* if current (gpf) occurs after this one in buffer, add! */
2713                                         if (gfs->framenum < gpf->framenum) {
2714                                                 BLI_insertlinkafter(&sel_buffer, gfs, gpf);
2715                                                 added= 1;
2716                                                 break;
2717                                         }
2718                                 }
2719                                 if (added == 0)
2720                                         BLI_addhead(&sel_buffer, gpf);
2721                         }
2722                 }
2723                 
2724                 /* error checking: it is unlikely, but may be possible to have none selected */
2725                 if (sel_buffer.first == NULL)
2726                         continue;
2727                 
2728                 /* if all were selected (i.e. gpl->frames is empty), then just transfer sel-buf over */
2729                 if (gpl->frames.first == NULL) {
2730                         gpl->frames.first= sel_buffer.first;
2731                         gpl->frames.last= sel_buffer.last;
2732                         
2733                         continue;
2734                 }
2735                 
2736                 /* loop 2: remove duplicates of frames in buffers */
2737                 for (gpf= gpl->frames.first; gpf && sel_buffer.first; gpf= gpfn) {
2738                         gpfn= gpf->next;
2739                         
2740                         /* loop through sel_buffer, emptying stuff from front of buffer if ok */
2741                         for (gfs= sel_buffer.first; gfs && gpf; gfs= gfsn) {
2742                                 gfsn= gfs->next;
2743                                 
2744                                 /* if this buffer frame needs to go before current, add it! */
2745                                 if (gfs->framenum < gpf->framenum) {
2746                                         /* transfer buffer frame to frames list (before current) */
2747                                         BLI_remlink(&sel_buffer, gfs);
2748                                         BLI_insertlinkbefore(&gpl->frames, gpf, gfs);
2749                                 }
2750                                 /* if this buffer frame is on same frame, replace current with it and stop */
2751                                 else if (gfs->framenum == gpf->framenum) {
2752                                         /* transfer buffer frame to frames list (before current) */
2753                                         BLI_remlink(&sel_buffer, gfs);
2754                                         BLI_insertlinkbefore(&gpl->frames, gpf, gfs);
2755                                         
2756                                         /* get rid of current frame */
2757                                         gpencil_layer_delframe(gpl, gpf);
2758                                 }
2759                         }
2760                 }
2761                 
2762                 /* if anything is still in buffer, append to end */
2763                 for (gfs= sel_buffer.first; gfs; gfs= gfsn) {
2764                         gfsn= gfs->next;
2765                         
2766                         BLI_remlink(&sel_buffer, gfs);
2767                         BLI_addtail(&gpl->frames, gfs);
2768                 }
2769         }