Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / object / object_transform.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edobj
22  */
23
24 #include <stdlib.h>
25 #include <string.h>
26
27 #include "DNA_anim_types.h"
28 #include "DNA_armature_types.h"
29 #include "DNA_mesh_types.h"
30 #include "DNA_meta_types.h"
31 #include "DNA_light_types.h"
32 #include "DNA_object_types.h"
33 #include "DNA_scene_types.h"
34 #include "DNA_gpencil_types.h"
35 #include "DNA_collection_types.h"
36 #include "DNA_lattice_types.h"
37
38 #include "BLI_math.h"
39 #include "BLI_listbase.h"
40 #include "BLI_utildefines.h"
41 #include "BLI_array.h"
42
43 #include "BKE_context.h"
44 #include "BKE_curve.h"
45 #include "BKE_main.h"
46 #include "BKE_idcode.h"
47 #include "BKE_mball.h"
48 #include "BKE_mesh.h"
49 #include "BKE_object.h"
50 #include "BKE_report.h"
51 #include "BKE_editmesh.h"
52 #include "BKE_multires.h"
53 #include "BKE_armature.h"
54 #include "BKE_lattice.h"
55 #include "BKE_tracking.h"
56 #include "BKE_gpencil.h"
57
58 #include "DEG_depsgraph.h"
59
60 #include "RNA_define.h"
61 #include "RNA_access.h"
62
63 #include "WM_api.h"
64 #include "WM_types.h"
65
66 #include "ED_armature.h"
67 #include "ED_keyframing.h"
68 #include "ED_mesh.h"
69 #include "ED_screen.h"
70 #include "ED_view3d.h"
71 #include "ED_gpencil.h"
72
73 #include "MEM_guardedalloc.h"
74
75 #include "object_intern.h"
76
77 /*************************** Clear Transformation ****************************/
78
79 /* clear location of object */
80 static void object_clear_loc(Object *ob, const bool clear_delta)
81 {
82   /* clear location if not locked */
83   if ((ob->protectflag & OB_LOCK_LOCX) == 0) {
84     ob->loc[0] = 0.0f;
85     if (clear_delta) {
86       ob->dloc[0] = 0.0f;
87     }
88   }
89   if ((ob->protectflag & OB_LOCK_LOCY) == 0) {
90     ob->loc[1] = 0.0f;
91     if (clear_delta) {
92       ob->dloc[1] = 0.0f;
93     }
94   }
95   if ((ob->protectflag & OB_LOCK_LOCZ) == 0) {
96     ob->loc[2] = 0.0f;
97     if (clear_delta) {
98       ob->dloc[2] = 0.0f;
99     }
100   }
101 }
102
103 /* clear rotation of object */
104 static void object_clear_rot(Object *ob, const bool clear_delta)
105 {
106   /* clear rotations that aren't locked */
107   if (ob->protectflag & (OB_LOCK_ROTX | OB_LOCK_ROTY | OB_LOCK_ROTZ | OB_LOCK_ROTW)) {
108     if (ob->protectflag & OB_LOCK_ROT4D) {
109       /* perform clamping on a component by component basis */
110       if (ob->rotmode == ROT_MODE_AXISANGLE) {
111         if ((ob->protectflag & OB_LOCK_ROTW) == 0) {
112           ob->rotAngle = 0.0f;
113           if (clear_delta) {
114             ob->drotAngle = 0.0f;
115           }
116         }
117         if ((ob->protectflag & OB_LOCK_ROTX) == 0) {
118           ob->rotAxis[0] = 0.0f;
119           if (clear_delta) {
120             ob->drotAxis[0] = 0.0f;
121           }
122         }
123         if ((ob->protectflag & OB_LOCK_ROTY) == 0) {
124           ob->rotAxis[1] = 0.0f;
125           if (clear_delta) {
126             ob->drotAxis[1] = 0.0f;
127           }
128         }
129         if ((ob->protectflag & OB_LOCK_ROTZ) == 0) {
130           ob->rotAxis[2] = 0.0f;
131           if (clear_delta) {
132             ob->drotAxis[2] = 0.0f;
133           }
134         }
135
136         /* Check validity of axis - axis should never be 0,0,0
137          * (if so, then we make it rotate about y). */
138         if (IS_EQF(ob->rotAxis[0], ob->rotAxis[1]) && IS_EQF(ob->rotAxis[1], ob->rotAxis[2])) {
139           ob->rotAxis[1] = 1.0f;
140         }
141         if (IS_EQF(ob->drotAxis[0], ob->drotAxis[1]) && IS_EQF(ob->drotAxis[1], ob->drotAxis[2]) &&
142             clear_delta) {
143           ob->drotAxis[1] = 1.0f;
144         }
145       }
146       else if (ob->rotmode == ROT_MODE_QUAT) {
147         if ((ob->protectflag & OB_LOCK_ROTW) == 0) {
148           ob->quat[0] = 1.0f;
149           if (clear_delta) {
150             ob->dquat[0] = 1.0f;
151           }
152         }
153         if ((ob->protectflag & OB_LOCK_ROTX) == 0) {
154           ob->quat[1] = 0.0f;
155           if (clear_delta) {
156             ob->dquat[1] = 0.0f;
157           }
158         }
159         if ((ob->protectflag & OB_LOCK_ROTY) == 0) {
160           ob->quat[2] = 0.0f;
161           if (clear_delta) {
162             ob->dquat[2] = 0.0f;
163           }
164         }
165         if ((ob->protectflag & OB_LOCK_ROTZ) == 0) {
166           ob->quat[3] = 0.0f;
167           if (clear_delta) {
168             ob->dquat[3] = 0.0f;
169           }
170         }
171         /* TODO: does this quat need normalizing now? */
172       }
173       else {
174         /* the flag may have been set for the other modes, so just ignore the extra flag... */
175         if ((ob->protectflag & OB_LOCK_ROTX) == 0) {
176           ob->rot[0] = 0.0f;
177           if (clear_delta) {
178             ob->drot[0] = 0.0f;
179           }
180         }
181         if ((ob->protectflag & OB_LOCK_ROTY) == 0) {
182           ob->rot[1] = 0.0f;
183           if (clear_delta) {
184             ob->drot[1] = 0.0f;
185           }
186         }
187         if ((ob->protectflag & OB_LOCK_ROTZ) == 0) {
188           ob->rot[2] = 0.0f;
189           if (clear_delta) {
190             ob->drot[2] = 0.0f;
191           }
192         }
193       }
194     }
195     else {
196       /* perform clamping using euler form (3-components) */
197       /* FIXME: deltas are not handled for these cases yet... */
198       float eul[3], oldeul[3], quat1[4] = {0};
199
200       if (ob->rotmode == ROT_MODE_QUAT) {
201         copy_qt_qt(quat1, ob->quat);
202         quat_to_eul(oldeul, ob->quat);
203       }
204       else if (ob->rotmode == ROT_MODE_AXISANGLE) {
205         axis_angle_to_eulO(oldeul, EULER_ORDER_DEFAULT, ob->rotAxis, ob->rotAngle);
206       }
207       else {
208         copy_v3_v3(oldeul, ob->rot);
209       }
210
211       eul[0] = eul[1] = eul[2] = 0.0f;
212
213       if (ob->protectflag & OB_LOCK_ROTX) {
214         eul[0] = oldeul[0];
215       }
216       if (ob->protectflag & OB_LOCK_ROTY) {
217         eul[1] = oldeul[1];
218       }
219       if (ob->protectflag & OB_LOCK_ROTZ) {
220         eul[2] = oldeul[2];
221       }
222
223       if (ob->rotmode == ROT_MODE_QUAT) {
224         eul_to_quat(ob->quat, eul);
225         /* quaternions flip w sign to accumulate rotations correctly */
226         if ((quat1[0] < 0.0f && ob->quat[0] > 0.0f) || (quat1[0] > 0.0f && ob->quat[0] < 0.0f)) {
227           mul_qt_fl(ob->quat, -1.0f);
228         }
229       }
230       else if (ob->rotmode == ROT_MODE_AXISANGLE) {
231         eulO_to_axis_angle(ob->rotAxis, &ob->rotAngle, eul, EULER_ORDER_DEFAULT);
232       }
233       else {
234         copy_v3_v3(ob->rot, eul);
235       }
236     }
237   }  // Duplicated in source/blender/editors/armature/editarmature.c
238   else {
239     if (ob->rotmode == ROT_MODE_QUAT) {
240       unit_qt(ob->quat);
241       if (clear_delta) {
242         unit_qt(ob->dquat);
243       }
244     }
245     else if (ob->rotmode == ROT_MODE_AXISANGLE) {
246       unit_axis_angle(ob->rotAxis, &ob->rotAngle);
247       if (clear_delta) {
248         unit_axis_angle(ob->drotAxis, &ob->drotAngle);
249       }
250     }
251     else {
252       zero_v3(ob->rot);
253       if (clear_delta) {
254         zero_v3(ob->drot);
255       }
256     }
257   }
258 }
259
260 /* clear scale of object */
261 static void object_clear_scale(Object *ob, const bool clear_delta)
262 {
263   /* clear scale factors which are not locked */
264   if ((ob->protectflag & OB_LOCK_SCALEX) == 0) {
265     ob->scale[0] = 1.0f;
266     if (clear_delta) {
267       ob->dscale[0] = 1.0f;
268     }
269   }
270   if ((ob->protectflag & OB_LOCK_SCALEY) == 0) {
271     ob->scale[1] = 1.0f;
272     if (clear_delta) {
273       ob->dscale[1] = 1.0f;
274     }
275   }
276   if ((ob->protectflag & OB_LOCK_SCALEZ) == 0) {
277     ob->scale[2] = 1.0f;
278     if (clear_delta) {
279       ob->dscale[2] = 1.0f;
280     }
281   }
282 }
283
284 /* --------------- */
285
286 /* generic exec for clear-transform operators */
287 static int object_clear_transform_generic_exec(bContext *C,
288                                                wmOperator *op,
289                                                void (*clear_func)(Object *, const bool),
290                                                const char default_ksName[])
291 {
292   Scene *scene = CTX_data_scene(C);
293   KeyingSet *ks;
294   const bool clear_delta = RNA_boolean_get(op->ptr, "clear_delta");
295
296   /* sanity checks */
297   if (ELEM(NULL, clear_func, default_ksName)) {
298     BKE_report(op->reports,
299                RPT_ERROR,
300                "Programming error: missing clear transform function or keying set name");
301     return OPERATOR_CANCELLED;
302   }
303
304   /* get KeyingSet to use */
305   ks = ANIM_get_keyingset_for_autokeying(scene, default_ksName);
306
307   /* operate on selected objects only if they aren't in weight-paint mode
308    * (so that object-transform clearing won't be applied at same time as bone-clearing)
309    */
310   CTX_DATA_BEGIN (C, Object *, ob, selected_editable_objects) {
311     if (!(ob->mode & OB_MODE_WEIGHT_PAINT)) {
312       /* run provided clearing function */
313       clear_func(ob, clear_delta);
314
315       ED_autokeyframe_object(C, scene, ob, ks);
316
317       /* tag for updates */
318       DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM);
319     }
320   }
321   CTX_DATA_END;
322
323   /* this is needed so children are also updated */
324   WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, NULL);
325
326   return OPERATOR_FINISHED;
327 }
328
329 /* --------------- */
330
331 static int object_location_clear_exec(bContext *C, wmOperator *op)
332 {
333   return object_clear_transform_generic_exec(C, op, object_clear_loc, ANIM_KS_LOCATION_ID);
334 }
335
336 void OBJECT_OT_location_clear(wmOperatorType *ot)
337 {
338   /* identifiers */
339   ot->name = "Clear Location";
340   ot->description = "Clear the object's location";
341   ot->idname = "OBJECT_OT_location_clear";
342
343   /* api callbacks */
344   ot->exec = object_location_clear_exec;
345   ot->poll = ED_operator_scene_editable;
346
347   /* flags */
348   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
349
350   /* properties */
351   ot->prop = RNA_def_boolean(
352       ot->srna,
353       "clear_delta",
354       false,
355       "Clear Delta",
356       "Clear delta location in addition to clearing the normal location transform");
357 }
358
359 static int object_rotation_clear_exec(bContext *C, wmOperator *op)
360 {
361   return object_clear_transform_generic_exec(C, op, object_clear_rot, ANIM_KS_ROTATION_ID);
362 }
363
364 void OBJECT_OT_rotation_clear(wmOperatorType *ot)
365 {
366   /* identifiers */
367   ot->name = "Clear Rotation";
368   ot->description = "Clear the object's rotation";
369   ot->idname = "OBJECT_OT_rotation_clear";
370
371   /* api callbacks */
372   ot->exec = object_rotation_clear_exec;
373   ot->poll = ED_operator_scene_editable;
374
375   /* flags */
376   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
377
378   /* properties */
379   ot->prop = RNA_def_boolean(
380       ot->srna,
381       "clear_delta",
382       false,
383       "Clear Delta",
384       "Clear delta rotation in addition to clearing the normal rotation transform");
385 }
386
387 static int object_scale_clear_exec(bContext *C, wmOperator *op)
388 {
389   return object_clear_transform_generic_exec(C, op, object_clear_scale, ANIM_KS_SCALING_ID);
390 }
391
392 void OBJECT_OT_scale_clear(wmOperatorType *ot)
393 {
394   /* identifiers */
395   ot->name = "Clear Scale";
396   ot->description = "Clear the object's scale";
397   ot->idname = "OBJECT_OT_scale_clear";
398
399   /* api callbacks */
400   ot->exec = object_scale_clear_exec;
401   ot->poll = ED_operator_scene_editable;
402
403   /* flags */
404   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
405
406   /* properties */
407   ot->prop = RNA_def_boolean(
408       ot->srna,
409       "clear_delta",
410       false,
411       "Clear Delta",
412       "Clear delta scale in addition to clearing the normal scale transform");
413 }
414
415 /* --------------- */
416
417 static int object_origin_clear_exec(bContext *C, wmOperator *UNUSED(op))
418 {
419   float *v1, *v3;
420   float mat[3][3];
421
422   CTX_DATA_BEGIN (C, Object *, ob, selected_editable_objects) {
423     if (ob->parent) {
424       /* vectors pointed to by v1 and v3 will get modified */
425       v1 = ob->loc;
426       v3 = ob->parentinv[3];
427
428       copy_m3_m4(mat, ob->parentinv);
429       negate_v3_v3(v3, v1);
430       mul_m3_v3(mat, v3);
431     }
432
433     DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM);
434   }
435   CTX_DATA_END;
436
437   WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, NULL);
438
439   return OPERATOR_FINISHED;
440 }
441
442 void OBJECT_OT_origin_clear(wmOperatorType *ot)
443 {
444   /* identifiers */
445   ot->name = "Clear Origin";
446   ot->description = "Clear the object's origin";
447   ot->idname = "OBJECT_OT_origin_clear";
448
449   /* api callbacks */
450   ot->exec = object_origin_clear_exec;
451   ot->poll = ED_operator_scene_editable;
452
453   /* flags */
454   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
455 }
456
457 /*************************** Apply Transformation ****************************/
458
459 /* use this when the loc/size/rot of the parent has changed but the children
460  * should stay in the same place, e.g. for apply-size-rot or object center */
461 static void ignore_parent_tx(const bContext *C, Main *bmain, Scene *scene, Object *ob)
462 {
463   Object workob;
464   Object *ob_child;
465   Depsgraph *depsgraph = CTX_data_depsgraph(C);
466
467   /* a change was made, adjust the children to compensate */
468   for (ob_child = bmain->objects.first; ob_child; ob_child = ob_child->id.next) {
469     if (ob_child->parent == ob) {
470       BKE_object_apply_mat4(ob_child, ob_child->obmat, true, false);
471       BKE_object_workob_calc_parent(depsgraph, scene, ob_child, &workob);
472       invert_m4_m4(ob_child->parentinv, workob.obmat);
473     }
474   }
475 }
476
477 static int apply_objects_internal(bContext *C,
478                                   ReportList *reports,
479                                   bool apply_loc,
480                                   bool apply_rot,
481                                   bool apply_scale,
482                                   bool do_props)
483 {
484   Main *bmain = CTX_data_main(C);
485   Scene *scene = CTX_data_scene(C);
486   Depsgraph *depsgraph = CTX_data_depsgraph(C);
487   float rsmat[3][3], obmat[3][3], iobmat[3][3], mat[4][4], scale;
488   bool changed = true;
489
490   /* first check if we can execute */
491   CTX_DATA_BEGIN (C, Object *, ob, selected_editable_objects) {
492     if (ELEM(ob->type,
493              OB_MESH,
494              OB_ARMATURE,
495              OB_LATTICE,
496              OB_MBALL,
497              OB_CURVE,
498              OB_SURF,
499              OB_FONT,
500              OB_GPENCIL)) {
501       ID *obdata = ob->data;
502       if (ID_REAL_USERS(obdata) > 1) {
503         BKE_reportf(reports,
504                     RPT_ERROR,
505                     "Cannot apply to a multi user: Object \"%s\", %s \"%s\", aborting",
506                     ob->id.name + 2,
507                     BKE_idcode_to_name(GS(obdata->name)),
508                     obdata->name + 2);
509         changed = false;
510       }
511
512       if (ID_IS_LINKED(obdata)) {
513         BKE_reportf(reports,
514                     RPT_ERROR,
515                     "Cannot apply to library data: Object \"%s\", %s \"%s\", aborting",
516                     ob->id.name + 2,
517                     BKE_idcode_to_name(GS(obdata->name)),
518                     obdata->name + 2);
519         changed = false;
520       }
521     }
522
523     if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
524       ID *obdata = ob->data;
525       Curve *cu;
526
527       cu = ob->data;
528
529       if (((ob->type == OB_CURVE) && !(cu->flag & CU_3D)) && (apply_rot || apply_loc)) {
530         BKE_reportf(
531             reports,
532             RPT_ERROR,
533             "Rotation/Location can't apply to a 2D curve: Object \"%s\", %s \"%s\", aborting",
534             ob->id.name + 2,
535             BKE_idcode_to_name(GS(obdata->name)),
536             obdata->name + 2);
537         changed = false;
538       }
539       if (cu->key) {
540         BKE_reportf(reports,
541                     RPT_ERROR,
542                     "Can't apply to a curve with shape-keys: Object \"%s\", %s \"%s\", aborting",
543                     ob->id.name + 2,
544                     BKE_idcode_to_name(GS(obdata->name)),
545                     obdata->name + 2);
546         changed = false;
547       }
548     }
549
550     if (ob->type == OB_FONT) {
551       if (apply_rot || apply_loc) {
552         BKE_reportf(
553             reports, RPT_ERROR, "Font's can only have scale applied: \"%s\"", ob->id.name + 2);
554         changed = false;
555       }
556     }
557
558     if (ob->type == OB_GPENCIL) {
559       bGPdata *gpd = ob->data;
560       if (gpd) {
561         if (gpd->layers.first) {
562           /* Unsupported configuration */
563           bool has_unparented_layers = false;
564
565           for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
566             /* Parented layers aren't supported as we can't easily re-evaluate
567              * the scene to sample parent movement */
568             if (gpl->parent == NULL) {
569               has_unparented_layers = true;
570               break;
571             }
572           }
573
574           if (has_unparented_layers == false) {
575             BKE_reportf(reports,
576                         RPT_ERROR,
577                         "Can't apply to a GP datablock where all layers are parented: Object "
578                         "\"%s\", %s \"%s\", aborting",
579                         ob->id.name + 2,
580                         BKE_idcode_to_name(ID_GD),
581                         gpd->id.name + 2);
582             changed = false;
583           }
584         }
585         else {
586           /* No layers/data */
587           BKE_reportf(
588               reports,
589               RPT_ERROR,
590               "Can't apply to GP datablock with no layers: Object \"%s\", %s \"%s\", aborting",
591               ob->id.name + 2,
592               BKE_idcode_to_name(ID_GD),
593               gpd->id.name + 2);
594         }
595       }
596     }
597
598     if (ob->type == OB_LAMP) {
599       Light *la = ob->data;
600       if (la->type == LA_AREA) {
601         if (apply_rot || apply_loc) {
602           BKE_reportf(reports,
603                       RPT_ERROR,
604                       "Area Lights can only have scale applied: \"%s\"",
605                       ob->id.name + 2);
606           changed = false;
607         }
608       }
609     }
610   }
611   CTX_DATA_END;
612
613   if (!changed) {
614     return OPERATOR_CANCELLED;
615   }
616
617   changed = false;
618
619   /* now execute */
620   CTX_DATA_BEGIN (C, Object *, ob, selected_editable_objects) {
621
622     /* calculate rotation/scale matrix */
623     if (apply_scale && apply_rot) {
624       BKE_object_to_mat3(ob, rsmat);
625     }
626     else if (apply_scale) {
627       BKE_object_scale_to_mat3(ob, rsmat);
628     }
629     else if (apply_rot) {
630       float tmat[3][3], timat[3][3];
631
632       /* simple rotation matrix */
633       BKE_object_rot_to_mat3(ob, rsmat, true);
634
635       /* correct for scale, note mul_m3_m3m3 has swapped args! */
636       BKE_object_scale_to_mat3(ob, tmat);
637       invert_m3_m3(timat, tmat);
638       mul_m3_m3m3(rsmat, timat, rsmat);
639       mul_m3_m3m3(rsmat, rsmat, tmat);
640     }
641     else {
642       unit_m3(rsmat);
643     }
644
645     copy_m4_m3(mat, rsmat);
646
647     /* calculate translation */
648     if (apply_loc) {
649       copy_v3_v3(mat[3], ob->loc);
650
651       if (!(apply_scale && apply_rot)) {
652         float tmat[3][3];
653         /* correct for scale and rotation that is still applied */
654         BKE_object_to_mat3(ob, obmat);
655         invert_m3_m3(iobmat, obmat);
656         mul_m3_m3m3(tmat, rsmat, iobmat);
657         mul_m3_v3(tmat, mat[3]);
658       }
659     }
660
661     /* apply to object data */
662     if (ob->type == OB_MESH) {
663       Mesh *me = ob->data;
664
665       if (apply_scale) {
666         multiresModifier_scale_disp(depsgraph, scene, ob);
667       }
668
669       /* adjust data */
670       BKE_mesh_transform(me, mat, true);
671
672       /* update normals */
673       BKE_mesh_calc_normals(me);
674     }
675     else if (ob->type == OB_ARMATURE) {
676       ED_armature_transform_apply(bmain, ob, mat, do_props);
677     }
678     else if (ob->type == OB_LATTICE) {
679       Lattice *lt = ob->data;
680
681       BKE_lattice_transform(lt, mat, true);
682     }
683     else if (ob->type == OB_MBALL) {
684       MetaBall *mb = ob->data;
685       BKE_mball_transform(mb, mat, do_props);
686     }
687     else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
688       Curve *cu = ob->data;
689       scale = mat3_to_scale(rsmat);
690       BKE_curve_transform_ex(cu, mat, true, do_props, scale);
691     }
692     else if (ob->type == OB_FONT) {
693       Curve *cu = ob->data;
694       int i;
695
696       scale = mat3_to_scale(rsmat);
697
698       for (i = 0; i < cu->totbox; i++) {
699         TextBox *tb = &cu->tb[i];
700         tb->x *= scale;
701         tb->y *= scale;
702         tb->w *= scale;
703         tb->h *= scale;
704       }
705
706       if (do_props) {
707         cu->fsize *= scale;
708       }
709     }
710     else if (ob->type == OB_GPENCIL) {
711       bGPdata *gpd = ob->data;
712       BKE_gpencil_transform(gpd, mat);
713     }
714     else if (ob->type == OB_CAMERA) {
715       MovieClip *clip = BKE_object_movieclip_get(scene, ob, false);
716
717       /* applying scale on camera actually scales clip's reconstruction.
718        * of there's clip assigned to camera nothing to do actually.
719        */
720       if (!clip) {
721         continue;
722       }
723
724       if (apply_scale) {
725         BKE_tracking_reconstruction_scale(&clip->tracking, ob->scale);
726       }
727     }
728     else if (ob->type == OB_EMPTY) {
729       /* It's possible for empties too, even though they don't
730        * really have obdata, since we can simply apply the maximum
731        * scaling to the empty's drawsize.
732        *
733        * Core Assumptions:
734        * 1) Most scaled empties have uniform scaling
735        *    (i.e. for visibility reasons), AND/OR
736        * 2) Preserving non-uniform scaling is not that important,
737        *    and is something that many users would be willing to
738        *    sacrifice for having an easy way to do this.
739        */
740
741       if ((apply_loc == false) && (apply_rot == false) && (apply_scale == true)) {
742         float max_scale = max_fff(fabsf(ob->scale[0]), fabsf(ob->scale[1]), fabsf(ob->scale[2]));
743         ob->empty_drawsize *= max_scale;
744       }
745     }
746     else if (ob->type == OB_LAMP) {
747       Light *la = ob->data;
748       if (la->type != LA_AREA) {
749         continue;
750       }
751
752       bool keeps_aspect_ratio = compare_ff_relative(rsmat[0][0], rsmat[1][1], FLT_EPSILON, 64);
753       if ((la->area_shape == LA_AREA_SQUARE) && !keeps_aspect_ratio) {
754         la->area_shape = LA_AREA_RECT;
755         la->area_sizey = la->area_size;
756       }
757       else if ((la->area_shape == LA_AREA_DISK) && !keeps_aspect_ratio) {
758         la->area_shape = LA_AREA_ELLIPSE;
759         la->area_sizey = la->area_size;
760       }
761
762       la->area_size *= rsmat[0][0];
763       la->area_sizey *= rsmat[1][1];
764       la->area_sizez *= rsmat[2][2];
765     }
766     else {
767       continue;
768     }
769
770     if (apply_loc) {
771       zero_v3(ob->loc);
772     }
773     if (apply_scale) {
774       ob->scale[0] = ob->scale[1] = ob->scale[2] = 1.0f;
775     }
776     if (apply_rot) {
777       zero_v3(ob->rot);
778       unit_qt(ob->quat);
779       unit_axis_angle(ob->rotAxis, &ob->rotAngle);
780     }
781
782     BKE_object_where_is_calc(depsgraph, scene, ob);
783     if (ob->type == OB_ARMATURE) {
784       BKE_pose_where_is(depsgraph, scene, ob); /* needed for bone parents */
785     }
786
787     ignore_parent_tx(C, bmain, scene, ob);
788
789     DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
790
791     changed = true;
792   }
793   CTX_DATA_END;
794
795   if (!changed) {
796     BKE_report(reports, RPT_WARNING, "Objects have no data to transform");
797     return OPERATOR_CANCELLED;
798   }
799
800   WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, NULL);
801   return OPERATOR_FINISHED;
802 }
803
804 static int visual_transform_apply_exec(bContext *C, wmOperator *UNUSED(op))
805 {
806   Scene *scene = CTX_data_scene(C);
807   Depsgraph *depsgraph = CTX_data_depsgraph(C);
808   bool changed = false;
809
810   CTX_DATA_BEGIN (C, Object *, ob, selected_editable_objects) {
811     BKE_object_where_is_calc(depsgraph, scene, ob);
812     BKE_object_apply_mat4(ob, ob->obmat, true, true);
813     BKE_object_where_is_calc(depsgraph, scene, ob);
814
815     /* update for any children that may get moved */
816     DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM);
817
818     changed = true;
819   }
820   CTX_DATA_END;
821
822   if (!changed) {
823     return OPERATOR_CANCELLED;
824   }
825
826   WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, NULL);
827   return OPERATOR_FINISHED;
828 }
829
830 void OBJECT_OT_visual_transform_apply(wmOperatorType *ot)
831 {
832   /* identifiers */
833   ot->name = "Apply Visual Transform";
834   ot->description = "Apply the object's visual transformation to its data";
835   ot->idname = "OBJECT_OT_visual_transform_apply";
836
837   /* api callbacks */
838   ot->exec = visual_transform_apply_exec;
839   ot->poll = ED_operator_scene_editable;
840
841   /* flags */
842   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
843 }
844
845 static int object_transform_apply_exec(bContext *C, wmOperator *op)
846 {
847   const bool loc = RNA_boolean_get(op->ptr, "location");
848   const bool rot = RNA_boolean_get(op->ptr, "rotation");
849   const bool sca = RNA_boolean_get(op->ptr, "scale");
850   const bool do_props = RNA_boolean_get(op->ptr, "properties");
851
852   if (loc || rot || sca) {
853     return apply_objects_internal(C, op->reports, loc, rot, sca, do_props);
854   }
855   else {
856     /* allow for redo */
857     return OPERATOR_FINISHED;
858   }
859 }
860
861 void OBJECT_OT_transform_apply(wmOperatorType *ot)
862 {
863   /* identifiers */
864   ot->name = "Apply Object Transform";
865   ot->description = "Apply the object's transformation to its data";
866   ot->idname = "OBJECT_OT_transform_apply";
867
868   /* api callbacks */
869   ot->exec = object_transform_apply_exec;
870   ot->poll = ED_operator_objectmode;
871
872   /* flags */
873   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
874
875   RNA_def_boolean(ot->srna, "location", true, "Location", "");
876   RNA_def_boolean(ot->srna, "rotation", true, "Rotation", "");
877   RNA_def_boolean(ot->srna, "scale", true, "Scale", "");
878   RNA_def_boolean(ot->srna,
879                   "properties",
880                   true,
881                   "Apply Properties",
882                   "Modify properties such as curve vertex radius, font size and bone envelope");
883 }
884
885 /********************* Set Object Center ************************/
886
887 enum {
888   GEOMETRY_TO_ORIGIN = 0,
889   ORIGIN_TO_GEOMETRY,
890   ORIGIN_TO_CURSOR,
891   ORIGIN_TO_CENTER_OF_MASS_SURFACE,
892   ORIGIN_TO_CENTER_OF_MASS_VOLUME,
893 };
894
895 static int object_origin_set_exec(bContext *C, wmOperator *op)
896 {
897   Main *bmain = CTX_data_main(C);
898   Scene *scene = CTX_data_scene(C);
899   Object *obact = CTX_data_active_object(C);
900   Object *obedit = CTX_data_edit_object(C);
901   Depsgraph *depsgraph = CTX_data_depsgraph(C);
902   Object *tob;
903   float cent[3], cent_neg[3], centn[3];
904   const float *cursor = scene->cursor.location;
905   int centermode = RNA_enum_get(op->ptr, "type");
906
907   ListBase ctx_data_list;
908   CollectionPointerLink *ctx_ob;
909   CollectionPointerLink *ctx_ob_act = NULL;
910
911   /* keep track of what is changed */
912   int tot_change = 0, tot_lib_error = 0, tot_multiuser_arm_error = 0;
913
914   if (obedit && centermode != GEOMETRY_TO_ORIGIN) {
915     BKE_report(op->reports, RPT_ERROR, "Operation cannot be performed in edit mode");
916     return OPERATOR_CANCELLED;
917   }
918
919   int around;
920   {
921     PropertyRNA *prop_center = RNA_struct_find_property(op->ptr, "center");
922     if (RNA_property_is_set(op->ptr, prop_center)) {
923       around = RNA_property_enum_get(op->ptr, prop_center);
924     }
925     else {
926       if (scene->toolsettings->transform_pivot_point == V3D_AROUND_CENTER_BOUNDS) {
927         around = V3D_AROUND_CENTER_BOUNDS;
928       }
929       else {
930         around = V3D_AROUND_CENTER_MEDIAN;
931       }
932       RNA_property_enum_set(op->ptr, prop_center, around);
933     }
934   }
935
936   zero_v3(cent);
937
938   if (obedit) {
939     if (obedit->type == OB_MESH) {
940       Mesh *me = obedit->data;
941       BMEditMesh *em = me->edit_mesh;
942       BMVert *eve;
943       BMIter iter;
944
945       if (centermode == ORIGIN_TO_CURSOR) {
946         copy_v3_v3(cent, cursor);
947         invert_m4_m4(obedit->imat, obedit->obmat);
948         mul_m4_v3(obedit->imat, cent);
949       }
950       else {
951         if (around == V3D_AROUND_CENTER_MEDIAN) {
952           if (em->bm->totvert) {
953             const float total_div = 1.0f / (float)em->bm->totvert;
954             BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
955               madd_v3_v3fl(cent, eve->co, total_div);
956             }
957           }
958         }
959         else {
960           float min[3], max[3];
961           INIT_MINMAX(min, max);
962           BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
963             minmax_v3v3_v3(min, max, eve->co);
964           }
965           mid_v3_v3v3(cent, min, max);
966         }
967       }
968
969       BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
970         sub_v3_v3(eve->co, cent);
971       }
972
973       EDBM_mesh_normals_update(em);
974       tot_change++;
975       DEG_id_tag_update(&obedit->id, ID_RECALC_GEOMETRY);
976     }
977   }
978
979   CTX_data_selected_editable_objects(C, &ctx_data_list);
980
981   /* reset flags */
982   for (ctx_ob = ctx_data_list.first; ctx_ob; ctx_ob = ctx_ob->next) {
983     Object *ob = ctx_ob->ptr.data;
984     ob->flag &= ~OB_DONE;
985
986     /* move active first */
987     if (ob == obact) {
988       ctx_ob_act = ctx_ob;
989     }
990   }
991
992   if (ctx_ob_act) {
993     BLI_listbase_rotate_first(&ctx_data_list, (LinkData *)ctx_ob_act);
994   }
995
996   for (tob = bmain->objects.first; tob; tob = tob->id.next) {
997     if (tob->data) {
998       ((ID *)tob->data)->tag &= ~LIB_TAG_DOIT;
999     }
1000     if (tob->instance_collection) {
1001       ((ID *)tob->instance_collection)->tag &= ~LIB_TAG_DOIT;
1002     }
1003   }
1004
1005   for (ctx_ob = ctx_data_list.first; ctx_ob; ctx_ob = ctx_ob->next) {
1006     Object *ob = ctx_ob->ptr.data;
1007
1008     if ((ob->flag & OB_DONE) == 0) {
1009       bool do_inverse_offset = false;
1010       ob->flag |= OB_DONE;
1011
1012       if (centermode == ORIGIN_TO_CURSOR) {
1013         copy_v3_v3(cent, cursor);
1014         invert_m4_m4(ob->imat, ob->obmat);
1015         mul_m4_v3(ob->imat, cent);
1016       }
1017
1018       if (ob->data == NULL) {
1019         /* special support for dupligroups */
1020         if ((ob->transflag & OB_DUPLICOLLECTION) && ob->instance_collection &&
1021             (ob->instance_collection->id.tag & LIB_TAG_DOIT) == 0) {
1022           if (ID_IS_LINKED(ob->instance_collection)) {
1023             tot_lib_error++;
1024           }
1025           else {
1026             if (centermode == ORIGIN_TO_CURSOR) {
1027               /* done */
1028             }
1029             else {
1030               float min[3], max[3];
1031               /* only bounds support */
1032               INIT_MINMAX(min, max);
1033               BKE_object_minmax_dupli(depsgraph, scene, ob, min, max, true);
1034               mid_v3_v3v3(cent, min, max);
1035               invert_m4_m4(ob->imat, ob->obmat);
1036               mul_m4_v3(ob->imat, cent);
1037             }
1038
1039             add_v3_v3(ob->instance_collection->instance_offset, cent);
1040
1041             tot_change++;
1042             ob->instance_collection->id.tag |= LIB_TAG_DOIT;
1043             do_inverse_offset = true;
1044           }
1045         }
1046       }
1047       else if (ID_IS_LINKED(ob->data)) {
1048         tot_lib_error++;
1049       }
1050
1051       if (obedit == NULL && ob->type == OB_MESH) {
1052         Mesh *me = ob->data;
1053
1054         if (centermode == ORIGIN_TO_CURSOR) {
1055           /* done */
1056         }
1057         else if (centermode == ORIGIN_TO_CENTER_OF_MASS_SURFACE) {
1058           BKE_mesh_center_of_surface(me, cent);
1059         }
1060         else if (centermode == ORIGIN_TO_CENTER_OF_MASS_VOLUME) {
1061           BKE_mesh_center_of_volume(me, cent);
1062         }
1063         else if (around == V3D_AROUND_CENTER_MEDIAN) {
1064           BKE_mesh_center_median(me, cent);
1065         }
1066         else {
1067           BKE_mesh_center_bounds(me, cent);
1068         }
1069
1070         negate_v3_v3(cent_neg, cent);
1071         BKE_mesh_translate(me, cent_neg, 1);
1072
1073         tot_change++;
1074         me->id.tag |= LIB_TAG_DOIT;
1075         do_inverse_offset = true;
1076       }
1077       else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
1078         Curve *cu = ob->data;
1079
1080         if (centermode == ORIGIN_TO_CURSOR) { /* done */
1081         }
1082         else if (around == V3D_AROUND_CENTER_MEDIAN) {
1083           BKE_curve_center_median(cu, cent);
1084         }
1085         else {
1086           BKE_curve_center_bounds(cu, cent);
1087         }
1088
1089         /* don't allow Z change if curve is 2D */
1090         if ((ob->type == OB_CURVE) && !(cu->flag & CU_3D)) {
1091           cent[2] = 0.0;
1092         }
1093
1094         negate_v3_v3(cent_neg, cent);
1095         BKE_curve_translate(cu, cent_neg, 1);
1096
1097         tot_change++;
1098         cu->id.tag |= LIB_TAG_DOIT;
1099         do_inverse_offset = true;
1100
1101         if (obedit) {
1102           if (centermode == GEOMETRY_TO_ORIGIN) {
1103             DEG_id_tag_update(&obedit->id, ID_RECALC_GEOMETRY);
1104           }
1105           break;
1106         }
1107       }
1108       else if (ob->type == OB_FONT) {
1109         /* get from bb */
1110
1111         Curve *cu = ob->data;
1112
1113         if (ob->runtime.bb == NULL && (centermode != ORIGIN_TO_CURSOR)) {
1114           /* do nothing*/
1115         }
1116         else {
1117           if (centermode == ORIGIN_TO_CURSOR) {
1118             /* done */
1119           }
1120           else {
1121             /* extra 0.5 is the height o above line */
1122             cent[0] = 0.5f * (ob->runtime.bb->vec[4][0] + ob->runtime.bb->vec[0][0]);
1123             cent[1] = 0.5f * (ob->runtime.bb->vec[0][1] + ob->runtime.bb->vec[2][1]);
1124           }
1125
1126           cent[2] = 0.0f;
1127
1128           cu->xof = cu->xof - cent[0];
1129           cu->yof = cu->yof - cent[1];
1130
1131           tot_change++;
1132           cu->id.tag |= LIB_TAG_DOIT;
1133           do_inverse_offset = true;
1134         }
1135       }
1136       else if (ob->type == OB_ARMATURE) {
1137         bArmature *arm = ob->data;
1138
1139         if (ID_REAL_USERS(arm) > 1) {
1140 #if 0
1141           BKE_report(op->reports, RPT_ERROR, "Cannot apply to a multi user armature");
1142           return;
1143 #endif
1144           tot_multiuser_arm_error++;
1145         }
1146         else {
1147           /* Function to recenter armatures in editarmature.c
1148            * Bone + object locations are handled there.
1149            */
1150           ED_armature_origin_set(bmain, ob, cursor, centermode, around);
1151
1152           tot_change++;
1153           arm->id.tag |= LIB_TAG_DOIT;
1154           /* do_inverse_offset = true; */ /* docenter_armature() handles this */
1155
1156           BKE_object_where_is_calc(depsgraph, scene, ob);
1157           BKE_pose_where_is(depsgraph, scene, ob); /* needed for bone parents */
1158
1159           ignore_parent_tx(C, bmain, scene, ob);
1160
1161           if (obedit) {
1162             break;
1163           }
1164         }
1165       }
1166       else if (ob->type == OB_MBALL) {
1167         MetaBall *mb = ob->data;
1168
1169         if (centermode == ORIGIN_TO_CURSOR) { /* done */
1170         }
1171         else if (around == V3D_AROUND_CENTER_MEDIAN) {
1172           BKE_mball_center_median(mb, cent);
1173         }
1174         else {
1175           BKE_mball_center_bounds(mb, cent);
1176         }
1177
1178         negate_v3_v3(cent_neg, cent);
1179         BKE_mball_translate(mb, cent_neg);
1180
1181         tot_change++;
1182         mb->id.tag |= LIB_TAG_DOIT;
1183         do_inverse_offset = true;
1184
1185         if (obedit) {
1186           if (centermode == GEOMETRY_TO_ORIGIN) {
1187             DEG_id_tag_update(&obedit->id, ID_RECALC_GEOMETRY);
1188           }
1189           break;
1190         }
1191       }
1192       else if (ob->type == OB_LATTICE) {
1193         Lattice *lt = ob->data;
1194
1195         if (centermode == ORIGIN_TO_CURSOR) { /* done */
1196         }
1197         else if (around == V3D_AROUND_CENTER_MEDIAN) {
1198           BKE_lattice_center_median(lt, cent);
1199         }
1200         else {
1201           BKE_lattice_center_bounds(lt, cent);
1202         }
1203
1204         negate_v3_v3(cent_neg, cent);
1205         BKE_lattice_translate(lt, cent_neg, 1);
1206
1207         tot_change++;
1208         lt->id.tag |= LIB_TAG_DOIT;
1209         do_inverse_offset = true;
1210       }
1211       else if (ob->type == OB_GPENCIL) {
1212         bGPdata *gpd = ob->data;
1213         float gpcenter[3];
1214         if (gpd) {
1215           if (centermode == ORIGIN_TO_GEOMETRY) {
1216             zero_v3(gpcenter);
1217             BKE_gpencil_centroid_3d(gpd, gpcenter);
1218             add_v3_v3(gpcenter, ob->obmat[3]);
1219           }
1220           if (centermode == ORIGIN_TO_CURSOR) {
1221             copy_v3_v3(gpcenter, cursor);
1222           }
1223           if ((centermode == ORIGIN_TO_GEOMETRY) || (centermode == ORIGIN_TO_CURSOR)) {
1224             bGPDspoint *pt;
1225             float imat[3][3], bmat[3][3];
1226             float offset_global[3];
1227             float offset_local[3];
1228             int i;
1229
1230             sub_v3_v3v3(offset_global, gpcenter, ob->obmat[3]);
1231             copy_m3_m4(bmat, obact->obmat);
1232             invert_m3_m3(imat, bmat);
1233             mul_m3_v3(imat, offset_global);
1234             mul_v3_m3v3(offset_local, imat, offset_global);
1235
1236             float diff_mat[4][4];
1237             float inverse_diff_mat[4][4];
1238
1239             /* recalculate all strokes
1240              * (all layers are considered without evaluating lock attributes) */
1241             for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
1242               /* calculate difference matrix */
1243               ED_gpencil_parent_location(depsgraph, obact, gpd, gpl, diff_mat);
1244               /* undo matrix */
1245               invert_m4_m4(inverse_diff_mat, diff_mat);
1246               for (bGPDframe *gpf = gpl->frames.first; gpf; gpf = gpf->next) {
1247                 for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) {
1248                   /* skip strokes that are invalid for current view */
1249                   if (ED_gpencil_stroke_can_use(C, gps) == false) {
1250                     continue;
1251                   }
1252
1253                   for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
1254                     float mpt[3];
1255                     mul_v3_m4v3(mpt, inverse_diff_mat, &pt->x);
1256                     sub_v3_v3(mpt, offset_local);
1257                     mul_v3_m4v3(&pt->x, diff_mat, mpt);
1258                   }
1259                 }
1260               }
1261             }
1262             DEG_id_tag_update(&gpd->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
1263
1264             tot_change++;
1265             if (centermode == ORIGIN_TO_GEOMETRY) {
1266               copy_v3_v3(ob->loc, gpcenter);
1267             }
1268             ob->id.tag |= LIB_TAG_DOIT;
1269             do_inverse_offset = true;
1270           }
1271           else {
1272             BKE_report(op->reports,
1273                        RPT_WARNING,
1274                        "Grease Pencil Object does not support this set origin option");
1275           }
1276         }
1277       }
1278
1279       /* offset other selected objects */
1280       if (do_inverse_offset && (centermode != GEOMETRY_TO_ORIGIN)) {
1281         CollectionPointerLink *ctx_link_other;
1282         float obmat[4][4];
1283
1284         /* was the object data modified
1285          * note: the functions above must set 'cent' */
1286
1287         /* convert the offset to parent space */
1288         BKE_object_to_mat4(ob, obmat);
1289         mul_v3_mat3_m4v3(centn, obmat, cent); /* omit translation part */
1290
1291         add_v3_v3(ob->loc, centn);
1292
1293         BKE_object_where_is_calc(depsgraph, scene, ob);
1294         if (ob->type == OB_ARMATURE) {
1295           BKE_pose_where_is(depsgraph, scene, ob); /* needed for bone parents */
1296         }
1297
1298         ignore_parent_tx(C, bmain, scene, ob);
1299
1300         /* other users? */
1301         //CTX_DATA_BEGIN (C, Object *, ob_other, selected_editable_objects)
1302         //{
1303
1304         /* use existing context looper */
1305         for (ctx_link_other = ctx_data_list.first; ctx_link_other;
1306              ctx_link_other = ctx_link_other->next) {
1307           Object *ob_other = ctx_link_other->ptr.data;
1308
1309           if ((ob_other->flag & OB_DONE) == 0 &&
1310               ((ob->data && (ob->data == ob_other->data)) ||
1311                (ob->instance_collection == ob_other->instance_collection &&
1312                 (ob->transflag | ob_other->transflag) & OB_DUPLICOLLECTION))) {
1313             ob_other->flag |= OB_DONE;
1314             DEG_id_tag_update(&ob_other->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
1315
1316             mul_v3_mat3_m4v3(centn, ob_other->obmat, cent); /* omit translation part */
1317             add_v3_v3(ob_other->loc, centn);
1318
1319             BKE_object_where_is_calc(depsgraph, scene, ob_other);
1320             if (ob_other->type == OB_ARMATURE) {
1321               /* needed for bone parents */
1322               BKE_pose_where_is(depsgraph, scene, ob_other);
1323             }
1324             ignore_parent_tx(C, bmain, scene, ob_other);
1325           }
1326         }
1327         //CTX_DATA_END;
1328       }
1329     }
1330   }
1331   BLI_freelistN(&ctx_data_list);
1332
1333   for (tob = bmain->objects.first; tob; tob = tob->id.next) {
1334     if (tob->data && (((ID *)tob->data)->tag & LIB_TAG_DOIT)) {
1335       BKE_object_batch_cache_dirty_tag(tob);
1336       DEG_id_tag_update(&tob->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
1337     }
1338   }
1339
1340   if (tot_change) {
1341     WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, NULL);
1342   }
1343
1344   /* Warn if any errors occurred */
1345   if (tot_lib_error + tot_multiuser_arm_error) {
1346     BKE_reportf(op->reports,
1347                 RPT_WARNING,
1348                 "%i object(s) not centered, %i changed:",
1349                 tot_lib_error + tot_multiuser_arm_error,
1350                 tot_change);
1351     if (tot_lib_error) {
1352       BKE_reportf(op->reports, RPT_WARNING, "|%i linked library object(s)", tot_lib_error);
1353     }
1354     if (tot_multiuser_arm_error) {
1355       BKE_reportf(
1356           op->reports, RPT_WARNING, "|%i multiuser armature object(s)", tot_multiuser_arm_error);
1357     }
1358   }
1359
1360   return OPERATOR_FINISHED;
1361 }
1362
1363 void OBJECT_OT_origin_set(wmOperatorType *ot)
1364 {
1365   static const EnumPropertyItem prop_set_center_types[] = {
1366       {GEOMETRY_TO_ORIGIN,
1367        "GEOMETRY_ORIGIN",
1368        0,
1369        "Geometry to Origin",
1370        "Move object geometry to object origin"},
1371       {ORIGIN_TO_GEOMETRY,
1372        "ORIGIN_GEOMETRY",
1373        0,
1374        "Origin to Geometry",
1375        "Calculate the center of geometry based on the current pivot point (median, otherwise "
1376        "bounding-box)"},
1377       {ORIGIN_TO_CURSOR,
1378        "ORIGIN_CURSOR",
1379        0,
1380        "Origin to 3D Cursor",
1381        "Move object origin to position of the 3D cursor"},
1382       /* Intentional naming mismatch since some scripts refer to this. */
1383       {ORIGIN_TO_CENTER_OF_MASS_SURFACE,
1384        "ORIGIN_CENTER_OF_MASS",
1385        0,
1386        "Origin to Center of Mass (Surface)",
1387        "Calculate the center of mass from the surface area"},
1388       {ORIGIN_TO_CENTER_OF_MASS_VOLUME,
1389        "ORIGIN_CENTER_OF_VOLUME",
1390        0,
1391        "Origin to Center of Mass (Volume)",
1392        "Calculate the center of mass from the volume (must be manifold geometry with consistent "
1393        "normals)"},
1394       {0, NULL, 0, NULL, NULL},
1395   };
1396
1397   static const EnumPropertyItem prop_set_bounds_types[] = {
1398       {V3D_AROUND_CENTER_MEDIAN, "MEDIAN", 0, "Median Center", ""},
1399       {V3D_AROUND_CENTER_BOUNDS, "BOUNDS", 0, "Bounds Center", ""},
1400       {0, NULL, 0, NULL, NULL},
1401   };
1402
1403   /* identifiers */
1404   ot->name = "Set Origin";
1405   ot->description =
1406       "Set the object's origin, by either moving the data, or set to center of data, or use 3D "
1407       "cursor";
1408   ot->idname = "OBJECT_OT_origin_set";
1409
1410   /* api callbacks */
1411   ot->invoke = WM_menu_invoke;
1412   ot->exec = object_origin_set_exec;
1413
1414   ot->poll = ED_operator_scene_editable;
1415
1416   /* flags */
1417   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1418
1419   ot->prop = RNA_def_enum(ot->srna, "type", prop_set_center_types, 0, "Type", "");
1420   RNA_def_enum(ot->srna, "center", prop_set_bounds_types, V3D_AROUND_CENTER_MEDIAN, "Center", "");
1421 }
1422
1423 /* -------------------------------------------------------------------- */
1424 /** \name Transform Axis Target
1425  *
1426  * Note this is an experemental operator to point lights/cameras at objects.
1427  * We may re-work how this behaves based on user feedback.
1428  * - campbell.
1429  * \{ */
1430
1431 /** When using multiple objects, apply their relative rotational offset to the active object. */
1432 #define USE_RELATIVE_ROTATION
1433 /** Disable overlays, ignoring user setting (light wire gets in the way). */
1434 #define USE_RENDER_OVERRIDE
1435 /** Calculate a depth if the cursor isn't already over a depth
1436  * (not essential but feels buggy without). */
1437 #define USE_FAKE_DEPTH_INIT
1438
1439 struct XFormAxisItem {
1440   Object *ob;
1441   float rot_mat[3][3];
1442   void *obtfm;
1443   float xform_dist;
1444
1445 #ifdef USE_RELATIVE_ROTATION
1446   /* use when translating multiple */
1447   float xform_rot_offset[3][3];
1448 #endif
1449 };
1450
1451 struct XFormAxisData {
1452   ViewContext vc;
1453   struct {
1454     float depth;
1455     float normal[3];
1456     bool is_depth_valid;
1457     bool is_normal_valid;
1458   } prev;
1459
1460   struct XFormAxisItem *object_data;
1461   uint object_data_len;
1462   bool is_translate;
1463
1464   int init_event;
1465 };
1466
1467 #ifdef USE_FAKE_DEPTH_INIT
1468 static void object_transform_axis_target_calc_depth_init(struct XFormAxisData *xfd,
1469                                                          const int mval[2])
1470 {
1471   struct XFormAxisItem *item = xfd->object_data;
1472   float view_co_a[3], view_co_b[3];
1473   const float mval_fl[2] = {UNPACK2(mval)};
1474   ED_view3d_win_to_ray(xfd->vc.ar, mval_fl, view_co_a, view_co_b);
1475   add_v3_v3(view_co_b, view_co_a);
1476   float center[3] = {0.0f};
1477   int center_tot = 0;
1478   for (int i = 0; i < xfd->object_data_len; i++, item++) {
1479     const Object *ob = item->ob;
1480     const float *ob_co_a = ob->obmat[3];
1481     float ob_co_b[3];
1482     add_v3_v3v3(ob_co_b, ob->obmat[3], ob->obmat[2]);
1483     float view_isect[3], ob_isect[3];
1484     if (isect_line_line_v3(view_co_a, view_co_b, ob_co_a, ob_co_b, view_isect, ob_isect)) {
1485       add_v3_v3(center, view_isect);
1486       center_tot += 1;
1487     }
1488   }
1489   if (center_tot) {
1490     mul_v3_fl(center, 1.0f / center_tot);
1491     float center_proj[3];
1492     ED_view3d_project(xfd->vc.ar, center, center_proj);
1493     xfd->prev.depth = center_proj[2];
1494     xfd->prev.is_depth_valid = true;
1495   }
1496 }
1497 #endif /* USE_FAKE_DEPTH_INIT */
1498
1499 static bool object_is_target_compat(const Object *ob)
1500 {
1501   if (ob->type == OB_LAMP) {
1502     const Light *la = ob->data;
1503     if (ELEM(la->type, LA_SUN, LA_SPOT, LA_AREA)) {
1504       return true;
1505     }
1506   }
1507   /* We might want to enable this later, for now just lights. */
1508 #if 0
1509   else if (ob->type == OB_CAMERA) {
1510     return true;
1511   }
1512 #endif
1513   return false;
1514 }
1515
1516 static void object_transform_axis_target_free_data(wmOperator *op)
1517 {
1518   struct XFormAxisData *xfd = op->customdata;
1519   struct XFormAxisItem *item = xfd->object_data;
1520
1521 #ifdef USE_RENDER_OVERRIDE
1522   if (xfd->vc.rv3d->depths) {
1523     xfd->vc.rv3d->depths->damaged = true;
1524   }
1525 #endif
1526
1527   for (int i = 0; i < xfd->object_data_len; i++, item++) {
1528     MEM_freeN(item->obtfm);
1529   }
1530   MEM_freeN(xfd->object_data);
1531   MEM_freeN(xfd);
1532   op->customdata = NULL;
1533 }
1534
1535 /* We may want to expose as alternative to: BKE_object_apply_rotation */
1536 static void object_apply_rotation(Object *ob, const float rmat[3][3])
1537 {
1538   float size[3];
1539   float loc[3];
1540   float rmat4[4][4];
1541   copy_m4_m3(rmat4, rmat);
1542
1543   copy_v3_v3(size, ob->scale);
1544   copy_v3_v3(loc, ob->loc);
1545   BKE_object_apply_mat4(ob, rmat4, true, true);
1546   copy_v3_v3(ob->scale, size);
1547   copy_v3_v3(ob->loc, loc);
1548 }
1549 /* We may want to extract this to: BKE_object_apply_location */
1550 static void object_apply_location(Object *ob, const float loc[3])
1551 {
1552   /* quick but weak */
1553   Object ob_prev = *ob;
1554   float mat[4][4];
1555   copy_m4_m4(mat, ob->obmat);
1556   copy_v3_v3(mat[3], loc);
1557   BKE_object_apply_mat4(ob, mat, true, true);
1558   copy_v3_v3(mat[3], ob->loc);
1559   *ob = ob_prev;
1560   copy_v3_v3(ob->loc, mat[3]);
1561 }
1562
1563 static void object_orient_to_location(Object *ob,
1564                                       float rot_orig[3][3],
1565                                       const float axis[3],
1566                                       const float location[3])
1567 {
1568   float delta[3];
1569   sub_v3_v3v3(delta, ob->obmat[3], location);
1570   if (normalize_v3(delta) != 0.0f) {
1571     if (len_squared_v3v3(delta, axis) > FLT_EPSILON) {
1572       float delta_rot[3][3];
1573       float final_rot[3][3];
1574       rotation_between_vecs_to_mat3(delta_rot, axis, delta);
1575
1576       mul_m3_m3m3(final_rot, delta_rot, rot_orig);
1577
1578       object_apply_rotation(ob, final_rot);
1579
1580       DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM);
1581     }
1582   }
1583 }
1584
1585 static void object_transform_axis_target_cancel(bContext *C, wmOperator *op)
1586 {
1587   struct XFormAxisData *xfd = op->customdata;
1588   struct XFormAxisItem *item = xfd->object_data;
1589   for (int i = 0; i < xfd->object_data_len; i++, item++) {
1590     BKE_object_tfm_restore(item->ob, item->obtfm);
1591     DEG_id_tag_update(&item->ob->id, ID_RECALC_TRANSFORM);
1592     WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, item->ob);
1593   }
1594
1595   object_transform_axis_target_free_data(op);
1596 }
1597
1598 static int object_transform_axis_target_invoke(bContext *C, wmOperator *op, const wmEvent *event)
1599 {
1600   ViewContext vc;
1601   ED_view3d_viewcontext_init(C, &vc);
1602
1603   if (vc.obact == NULL || !object_is_target_compat(vc.obact)) {
1604     /* Falls back to texture space transform. */
1605     return OPERATOR_PASS_THROUGH;
1606   }
1607
1608 #ifdef USE_RENDER_OVERRIDE
1609   int flag2_prev = vc.v3d->flag2;
1610   vc.v3d->flag2 |= V3D_HIDE_OVERLAYS;
1611 #endif
1612
1613   ED_view3d_autodist_init(vc.depsgraph, vc.ar, vc.v3d, 0);
1614
1615   if (vc.rv3d->depths != NULL) {
1616     vc.rv3d->depths->damaged = true;
1617   }
1618   ED_view3d_depth_update(vc.ar);
1619
1620 #ifdef USE_RENDER_OVERRIDE
1621   vc.v3d->flag2 = flag2_prev;
1622 #endif
1623
1624   if (vc.rv3d->depths == NULL) {
1625     BKE_report(op->reports, RPT_WARNING, "Unable to access depth buffer, using view plane");
1626     return OPERATOR_CANCELLED;
1627   }
1628
1629   ED_region_tag_redraw(vc.ar);
1630
1631   struct XFormAxisData *xfd;
1632   xfd = op->customdata = MEM_callocN(sizeof(struct XFormAxisData), __func__);
1633
1634   /* Don't change this at runtime. */
1635   xfd->vc = vc;
1636   xfd->vc.mval[0] = event->mval[0];
1637   xfd->vc.mval[1] = event->mval[1];
1638
1639   xfd->prev.depth = 1.0f;
1640   xfd->prev.is_depth_valid = false;
1641   xfd->prev.is_normal_valid = false;
1642   xfd->is_translate = false;
1643
1644   xfd->init_event = WM_userdef_event_type_from_keymap_type(event->type);
1645
1646   {
1647     struct XFormAxisItem *object_data = NULL;
1648     BLI_array_declare(object_data);
1649
1650     struct XFormAxisItem *item = BLI_array_append_ret(object_data);
1651     item->ob = xfd->vc.obact;
1652
1653     CTX_DATA_BEGIN (C, Object *, ob, selected_editable_objects) {
1654       if ((ob != xfd->vc.obact) && object_is_target_compat(ob)) {
1655         item = BLI_array_append_ret(object_data);
1656         item->ob = ob;
1657       }
1658     }
1659     CTX_DATA_END;
1660
1661     xfd->object_data = object_data;
1662     xfd->object_data_len = BLI_array_len(object_data);
1663
1664     if (xfd->object_data_len != BLI_array_len(object_data)) {
1665       xfd->object_data = MEM_reallocN(xfd->object_data,
1666                                       xfd->object_data_len * sizeof(*xfd->object_data));
1667     }
1668   }
1669
1670   {
1671     struct XFormAxisItem *item = xfd->object_data;
1672     for (int i = 0; i < xfd->object_data_len; i++, item++) {
1673       item->obtfm = BKE_object_tfm_backup(item->ob);
1674       BKE_object_rot_to_mat3(item->ob, item->rot_mat, true);
1675     }
1676   }
1677
1678   WM_event_add_modal_handler(C, op);
1679
1680   return OPERATOR_RUNNING_MODAL;
1681 }
1682
1683 static int object_transform_axis_target_modal(bContext *C, wmOperator *op, const wmEvent *event)
1684 {
1685   struct XFormAxisData *xfd = op->customdata;
1686   ARegion *ar = xfd->vc.ar;
1687
1688   view3d_operator_needs_opengl(C);
1689
1690   const bool is_translate = (event->ctrl != 0);
1691   const bool is_translate_init = is_translate && (xfd->is_translate != is_translate);
1692
1693   if (event->type == MOUSEMOVE || is_translate_init) {
1694     const ViewDepths *depths = xfd->vc.rv3d->depths;
1695     if (depths && ((unsigned int)event->mval[0] < depths->w) &&
1696         ((unsigned int)event->mval[1] < depths->h)) {
1697       double depth = (double)ED_view3d_depth_read_cached(&xfd->vc, event->mval);
1698       float location_world[3];
1699       if (depth == 1.0f) {
1700         if (xfd->prev.is_depth_valid) {
1701           depth = (double)xfd->prev.depth;
1702         }
1703       }
1704
1705 #ifdef USE_FAKE_DEPTH_INIT
1706       /* First time only. */
1707       if (depth == 1.0f) {
1708         if (xfd->prev.is_depth_valid == false) {
1709           object_transform_axis_target_calc_depth_init(xfd, event->mval);
1710           if (xfd->prev.is_depth_valid) {
1711             depth = (double)xfd->prev.depth;
1712           }
1713         }
1714       }
1715 #endif
1716
1717       if ((depth > depths->depth_range[0]) && (depth < depths->depth_range[1])) {
1718         xfd->prev.depth = depth;
1719         xfd->prev.is_depth_valid = true;
1720         if (ED_view3d_depth_unproject(ar, event->mval, depth, location_world)) {
1721           if (is_translate) {
1722
1723             float normal[3];
1724             bool normal_found = false;
1725             if (ED_view3d_depth_read_cached_normal(&xfd->vc, event->mval, normal)) {
1726               normal_found = true;
1727
1728               /* cheap attempt to smooth normals out a bit! */
1729               const uint ofs = 2;
1730               for (uint x = -ofs; x <= ofs; x += ofs / 2) {
1731                 for (uint y = -ofs; y <= ofs; y += ofs / 2) {
1732                   if (x != 0 && y != 0) {
1733                     int mval_ofs[2] = {event->mval[0] + x, event->mval[1] + y};
1734                     float n[3];
1735                     if (ED_view3d_depth_read_cached_normal(&xfd->vc, mval_ofs, n)) {
1736                       add_v3_v3(normal, n);
1737                     }
1738                   }
1739                 }
1740               }
1741               normalize_v3(normal);
1742             }
1743             else if (xfd->prev.is_normal_valid) {
1744               copy_v3_v3(normal, xfd->prev.normal);
1745               normal_found = true;
1746             }
1747
1748             if (normal_found) {
1749 #ifdef USE_RELATIVE_ROTATION
1750               if (is_translate_init && xfd->object_data_len > 1) {
1751                 float xform_rot_offset_inv_first[3][3];
1752                 struct XFormAxisItem *item = xfd->object_data;
1753                 for (int i = 0; i < xfd->object_data_len; i++, item++) {
1754                   copy_m3_m4(item->xform_rot_offset, item->ob->obmat);
1755                   normalize_m3(item->xform_rot_offset);
1756
1757                   if (i == 0) {
1758                     invert_m3_m3(xform_rot_offset_inv_first, xfd->object_data[0].xform_rot_offset);
1759                   }
1760                   else {
1761                     mul_m3_m3m3(item->xform_rot_offset,
1762                                 item->xform_rot_offset,
1763                                 xform_rot_offset_inv_first);
1764                   }
1765                 }
1766               }
1767
1768 #endif
1769
1770               struct XFormAxisItem *item = xfd->object_data;
1771               for (int i = 0; i < xfd->object_data_len; i++, item++) {
1772                 if (is_translate_init) {
1773                   float ob_axis[3];
1774                   item->xform_dist = len_v3v3(item->ob->obmat[3], location_world);
1775                   normalize_v3_v3(ob_axis, item->ob->obmat[2]);
1776                   /* Scale to avoid adding distance when moving between surfaces. */
1777                   float scale = fabsf(dot_v3v3(ob_axis, normal));
1778                   item->xform_dist *= scale;
1779                 }
1780
1781                 float target_normal[3];
1782                 copy_v3_v3(target_normal, normal);
1783
1784 #ifdef USE_RELATIVE_ROTATION
1785                 if (i != 0) {
1786                   mul_m3_v3(item->xform_rot_offset, target_normal);
1787                 }
1788 #endif
1789                 {
1790                   float loc[3];
1791
1792                   copy_v3_v3(loc, location_world);
1793                   madd_v3_v3fl(loc, target_normal, item->xform_dist);
1794                   object_apply_location(item->ob, loc);
1795                   /* so orient behaves as expected */
1796                   copy_v3_v3(item->ob->obmat[3], loc);
1797                 }
1798
1799                 object_orient_to_location(
1800                     item->ob, item->rot_mat, item->rot_mat[2], location_world);
1801                 WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, item->ob);
1802               }
1803               copy_v3_v3(xfd->prev.normal, normal);
1804               xfd->prev.is_normal_valid = true;
1805             }
1806           }
1807           else {
1808             struct XFormAxisItem *item = xfd->object_data;
1809             for (int i = 0; i < xfd->object_data_len; i++, item++) {
1810               object_orient_to_location(item->ob, item->rot_mat, item->rot_mat[2], location_world);
1811               WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, item->ob);
1812             }
1813             xfd->prev.is_normal_valid = false;
1814           }
1815         }
1816       }
1817     }
1818     xfd->is_translate = is_translate;
1819
1820     ED_region_tag_redraw(xfd->vc.ar);
1821   }
1822
1823   bool is_finished = false;
1824
1825   if (ISMOUSE(xfd->init_event)) {
1826     if ((event->type == xfd->init_event) && (event->val == KM_RELEASE)) {
1827       is_finished = true;
1828     }
1829   }
1830   else {
1831     if (ELEM(event->type, LEFTMOUSE, RETKEY, PADENTER)) {
1832       is_finished = true;
1833     }
1834   }
1835
1836   if (is_finished) {
1837     object_transform_axis_target_free_data(op);
1838     return OPERATOR_FINISHED;
1839   }
1840   else if (ELEM(event->type, ESCKEY, RIGHTMOUSE)) {
1841     object_transform_axis_target_cancel(C, op);
1842     return OPERATOR_CANCELLED;
1843   }
1844
1845   return OPERATOR_RUNNING_MODAL;
1846 }
1847
1848 void OBJECT_OT_transform_axis_target(wmOperatorType *ot)
1849 {
1850   /* identifiers */
1851   ot->name = "Interactive Light Track to Cursor";
1852   ot->description = "Interactively point cameras and lights to a location (Ctrl translates)";
1853   ot->idname = "OBJECT_OT_transform_axis_target";
1854
1855   /* api callbacks */
1856   ot->invoke = object_transform_axis_target_invoke;
1857   ot->cancel = object_transform_axis_target_cancel;
1858   ot->modal = object_transform_axis_target_modal;
1859   ot->poll = ED_operator_region_view3d_active;
1860
1861   /* flags */
1862   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_BLOCKING;
1863 }
1864
1865 #undef USE_RELATIVE_ROTATION
1866
1867 /** \} */