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