GPencil: Performance improvement for Multiframe and Onion Skin
[blender.git] / source / blender / editors / space_view3d / space_view3d.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) 2008 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup spview3d
22  */
23
24 #include <string.h>
25 #include <stdio.h>
26
27 #include "DNA_lightprobe_types.h"
28 #include "DNA_material_types.h"
29 #include "DNA_object_types.h"
30 #include "DNA_scene_types.h"
31 #include "DNA_gpencil_types.h"
32 #include "DNA_defaults.h"
33
34 #include "MEM_guardedalloc.h"
35
36 #include "BLI_blenlib.h"
37 #include "BLI_math.h"
38 #include "BLI_utildefines.h"
39
40 #include "BKE_context.h"
41 #include "BKE_curve.h"
42 #include "BKE_icons.h"
43 #include "BKE_idprop.h"
44 #include "BKE_lattice.h"
45 #include "BKE_main.h"
46 #include "BKE_mball.h"
47 #include "BKE_mesh.h"
48 #include "BKE_object.h"
49 #include "BKE_scene.h"
50 #include "BKE_screen.h"
51 #include "BKE_workspace.h"
52
53 #include "ED_space_api.h"
54 #include "ED_screen.h"
55 #include "ED_transform.h"
56
57 #include "GPU_matrix.h"
58
59 #include "DRW_engine.h"
60
61 #include "WM_api.h"
62 #include "WM_types.h"
63 #include "WM_message.h"
64 #include "WM_toolsystem.h"
65
66 #include "RE_engine.h"
67 #include "RE_pipeline.h"
68
69 #include "RNA_access.h"
70
71 #include "UI_interface.h"
72 #include "UI_resources.h"
73
74 #ifdef WITH_PYTHON
75 #  include "BPY_extern.h"
76 #endif
77
78 #include "DEG_depsgraph.h"
79
80 #include "view3d_intern.h" /* own include */
81
82 /* ******************** manage regions ********************* */
83
84 /* function to always find a regionview3d context inside 3D window */
85 RegionView3D *ED_view3d_context_rv3d(bContext *C)
86 {
87   RegionView3D *rv3d = CTX_wm_region_view3d(C);
88
89   if (rv3d == NULL) {
90     ScrArea *sa = CTX_wm_area(C);
91     if (sa && sa->spacetype == SPACE_VIEW3D) {
92       ARegion *ar = BKE_area_find_region_active_win(sa);
93       if (ar) {
94         rv3d = ar->regiondata;
95       }
96     }
97   }
98   return rv3d;
99 }
100
101 /* ideally would return an rv3d but in some cases the region is needed too
102  * so return that, the caller can then access the ar->regiondata */
103 bool ED_view3d_context_user_region(bContext *C, View3D **r_v3d, ARegion **r_ar)
104 {
105   ScrArea *sa = CTX_wm_area(C);
106
107   *r_v3d = NULL;
108   *r_ar = NULL;
109
110   if (sa && sa->spacetype == SPACE_VIEW3D) {
111     ARegion *ar = CTX_wm_region(C);
112     View3D *v3d = (View3D *)sa->spacedata.first;
113
114     if (ar) {
115       RegionView3D *rv3d;
116       if ((ar->regiontype == RGN_TYPE_WINDOW) && (rv3d = ar->regiondata) &&
117           (rv3d->viewlock & RV3D_LOCKED) == 0) {
118         *r_v3d = v3d;
119         *r_ar = ar;
120         return true;
121       }
122       else {
123         ARegion *ar_unlock_user = NULL;
124         ARegion *ar_unlock = NULL;
125         for (ar = sa->regionbase.first; ar; ar = ar->next) {
126           /* find the first unlocked rv3d */
127           if (ar->regiondata && ar->regiontype == RGN_TYPE_WINDOW) {
128             rv3d = ar->regiondata;
129             if ((rv3d->viewlock & RV3D_LOCKED) == 0) {
130               ar_unlock = ar;
131               if (rv3d->persp == RV3D_PERSP || rv3d->persp == RV3D_CAMOB) {
132                 ar_unlock_user = ar;
133                 break;
134               }
135             }
136           }
137         }
138
139         /* camera/perspective view get priority when the active region is locked */
140         if (ar_unlock_user) {
141           *r_v3d = v3d;
142           *r_ar = ar_unlock_user;
143           return true;
144         }
145
146         if (ar_unlock) {
147           *r_v3d = v3d;
148           *r_ar = ar_unlock;
149           return true;
150         }
151       }
152     }
153   }
154
155   return false;
156 }
157
158 /* Most of the time this isn't needed since you could assume the view matrix was
159  * set while drawing, however when functions like mesh_foreachScreenVert are
160  * called by selection tools, we can't be sure this object was the last.
161  *
162  * for example, transparent objects are drawn after editmode and will cause
163  * the rv3d mat's to change and break selection.
164  *
165  * 'ED_view3d_init_mats_rv3d' should be called before
166  * view3d_project_short_clip and view3d_project_short_noclip in cases where
167  * these functions are not used during draw_object
168  */
169 void ED_view3d_init_mats_rv3d(struct Object *ob, struct RegionView3D *rv3d)
170 {
171   /* local viewmat and persmat, to calculate projections */
172   mul_m4_m4m4(rv3d->viewmatob, rv3d->viewmat, ob->obmat);
173   mul_m4_m4m4(rv3d->persmatob, rv3d->persmat, ob->obmat);
174
175   /* initializes object space clipping, speeds up clip tests */
176   ED_view3d_clipping_local(rv3d, ob->obmat);
177 }
178
179 void ED_view3d_init_mats_rv3d_gl(struct Object *ob, struct RegionView3D *rv3d)
180 {
181   ED_view3d_init_mats_rv3d(ob, rv3d);
182
183   /* we have to multiply instead of loading viewmatob to make
184    * it work with duplis using displists, otherwise it will
185    * override the dupli-matrix */
186   GPU_matrix_mul(ob->obmat);
187 }
188
189 #ifdef DEBUG
190 /* ensure we correctly initialize */
191 void ED_view3d_clear_mats_rv3d(struct RegionView3D *rv3d)
192 {
193   zero_m4(rv3d->viewmatob);
194   zero_m4(rv3d->persmatob);
195 }
196
197 void ED_view3d_check_mats_rv3d(struct RegionView3D *rv3d)
198 {
199   BLI_ASSERT_ZERO_M4(rv3d->viewmatob);
200   BLI_ASSERT_ZERO_M4(rv3d->persmatob);
201 }
202 #endif
203
204 void ED_view3d_stop_render_preview(wmWindowManager *wm, ARegion *ar)
205 {
206   RegionView3D *rv3d = ar->regiondata;
207
208   if (rv3d->render_engine) {
209 #ifdef WITH_PYTHON
210     BPy_BEGIN_ALLOW_THREADS;
211 #endif
212
213     WM_jobs_kill_type(wm, ar, WM_JOB_TYPE_RENDER_PREVIEW);
214
215 #ifdef WITH_PYTHON
216     BPy_END_ALLOW_THREADS;
217 #endif
218
219     RE_engine_free(rv3d->render_engine);
220     rv3d->render_engine = NULL;
221   }
222 }
223
224 void ED_view3d_shade_update(Main *bmain, View3D *v3d, ScrArea *sa)
225 {
226   wmWindowManager *wm = bmain->wm.first;
227
228   if (v3d->shading.type != OB_RENDER) {
229     ARegion *ar;
230
231     for (ar = sa->regionbase.first; ar; ar = ar->next) {
232       if ((ar->regiontype == RGN_TYPE_WINDOW) && ar->regiondata) {
233         ED_view3d_stop_render_preview(wm, ar);
234         break;
235       }
236     }
237   }
238 }
239
240 /* ******************** default callbacks for view3d space ***************** */
241
242 static SpaceLink *view3d_new(const ScrArea *UNUSED(sa), const Scene *scene)
243 {
244   ARegion *ar;
245   View3D *v3d;
246   RegionView3D *rv3d;
247
248   v3d = DNA_struct_default_alloc(View3D);
249
250   if (scene) {
251     v3d->camera = scene->camera;
252   }
253
254   /* tool header */
255   ar = MEM_callocN(sizeof(ARegion), "tool header for view3d");
256
257   BLI_addtail(&v3d->regionbase, ar);
258   ar->regiontype = RGN_TYPE_TOOL_HEADER;
259   ar->alignment = (U.uiflag & USER_HEADER_BOTTOM) ? RGN_ALIGN_BOTTOM : RGN_ALIGN_TOP;
260   ar->flag = RGN_FLAG_HIDDEN | RGN_FLAG_HIDDEN_BY_USER;
261
262   /* header */
263   ar = MEM_callocN(sizeof(ARegion), "header for view3d");
264
265   BLI_addtail(&v3d->regionbase, ar);
266   ar->regiontype = RGN_TYPE_HEADER;
267   ar->alignment = (U.uiflag & USER_HEADER_BOTTOM) ? RGN_ALIGN_BOTTOM : RGN_ALIGN_TOP;
268
269   /* tool shelf */
270   ar = MEM_callocN(sizeof(ARegion), "toolshelf for view3d");
271
272   BLI_addtail(&v3d->regionbase, ar);
273   ar->regiontype = RGN_TYPE_TOOLS;
274   ar->alignment = RGN_ALIGN_LEFT;
275   ar->flag = RGN_FLAG_HIDDEN;
276
277   /* buttons/list view */
278   ar = MEM_callocN(sizeof(ARegion), "buttons for view3d");
279
280   BLI_addtail(&v3d->regionbase, ar);
281   ar->regiontype = RGN_TYPE_UI;
282   ar->alignment = RGN_ALIGN_RIGHT;
283   ar->flag = RGN_FLAG_HIDDEN;
284
285   /* main region */
286   ar = MEM_callocN(sizeof(ARegion), "main region for view3d");
287
288   BLI_addtail(&v3d->regionbase, ar);
289   ar->regiontype = RGN_TYPE_WINDOW;
290
291   ar->regiondata = MEM_callocN(sizeof(RegionView3D), "region view3d");
292   rv3d = ar->regiondata;
293   rv3d->viewquat[0] = 1.0f;
294   rv3d->persp = RV3D_PERSP;
295   rv3d->view = RV3D_VIEW_USER;
296   rv3d->dist = 10.0;
297
298   return (SpaceLink *)v3d;
299 }
300
301 /* not spacelink itself */
302 static void view3d_free(SpaceLink *sl)
303 {
304   View3D *vd = (View3D *)sl;
305
306   if (vd->localvd) {
307     MEM_freeN(vd->localvd);
308   }
309
310   if (vd->runtime.properties_storage) {
311     MEM_freeN(vd->runtime.properties_storage);
312   }
313
314   if (vd->fx_settings.ssao) {
315     MEM_freeN(vd->fx_settings.ssao);
316   }
317   if (vd->fx_settings.dof) {
318     MEM_freeN(vd->fx_settings.dof);
319   }
320
321   if (vd->shading.prop) {
322     IDP_FreeProperty(vd->shading.prop);
323     vd->shading.prop = NULL;
324   }
325 }
326
327 /* spacetype; init callback */
328 static void view3d_init(wmWindowManager *UNUSED(wm), ScrArea *UNUSED(sa))
329 {
330 }
331
332 static SpaceLink *view3d_duplicate(SpaceLink *sl)
333 {
334   View3D *v3do = (View3D *)sl;
335   View3D *v3dn = MEM_dupallocN(sl);
336
337   /* clear or remove stuff from old */
338
339   if (v3dn->localvd) {
340     v3dn->localvd = NULL;
341     v3dn->runtime.properties_storage = NULL;
342   }
343
344   if (v3dn->shading.type == OB_RENDER) {
345     v3dn->shading.type = OB_SOLID;
346   }
347
348   if (v3dn->shading.prop) {
349     v3dn->shading.prop = IDP_CopyProperty(v3do->shading.prop);
350   }
351
352   /* copy or clear inside new stuff */
353
354   v3dn->runtime.properties_storage = NULL;
355   if (v3dn->fx_settings.dof) {
356     v3dn->fx_settings.dof = MEM_dupallocN(v3do->fx_settings.dof);
357   }
358   if (v3dn->fx_settings.ssao) {
359     v3dn->fx_settings.ssao = MEM_dupallocN(v3do->fx_settings.ssao);
360   }
361
362   return (SpaceLink *)v3dn;
363 }
364
365 /* add handlers, stuff you only do once or on area/region changes */
366 static void view3d_main_region_init(wmWindowManager *wm, ARegion *ar)
367 {
368   ListBase *lb;
369   wmKeyMap *keymap;
370
371   /* object ops. */
372
373   /* important to be before Pose keymap since they can both be enabled at once */
374   keymap = WM_keymap_ensure(wm->defaultconf, "Face Mask", 0, 0);
375   WM_event_add_keymap_handler(&ar->handlers, keymap);
376
377   keymap = WM_keymap_ensure(wm->defaultconf, "Weight Paint Vertex Selection", 0, 0);
378   WM_event_add_keymap_handler(&ar->handlers, keymap);
379
380   /* pose is not modal, operator poll checks for this */
381   keymap = WM_keymap_ensure(wm->defaultconf, "Pose", 0, 0);
382   WM_event_add_keymap_handler(&ar->handlers, keymap);
383
384   keymap = WM_keymap_ensure(wm->defaultconf, "Object Mode", 0, 0);
385   WM_event_add_keymap_handler(&ar->handlers, keymap);
386
387   keymap = WM_keymap_ensure(wm->defaultconf, "Paint Curve", 0, 0);
388   WM_event_add_keymap_handler(&ar->handlers, keymap);
389
390   keymap = WM_keymap_ensure(wm->defaultconf, "Curve", 0, 0);
391   WM_event_add_keymap_handler(&ar->handlers, keymap);
392
393   keymap = WM_keymap_ensure(wm->defaultconf, "Image Paint", 0, 0);
394   WM_event_add_keymap_handler(&ar->handlers, keymap);
395
396   keymap = WM_keymap_ensure(wm->defaultconf, "Vertex Paint", 0, 0);
397   WM_event_add_keymap_handler(&ar->handlers, keymap);
398
399   keymap = WM_keymap_ensure(wm->defaultconf, "Weight Paint", 0, 0);
400   WM_event_add_keymap_handler(&ar->handlers, keymap);
401
402   keymap = WM_keymap_ensure(wm->defaultconf, "Sculpt", 0, 0);
403   WM_event_add_keymap_handler(&ar->handlers, keymap);
404
405   keymap = WM_keymap_ensure(wm->defaultconf, "Mesh", 0, 0);
406   WM_event_add_keymap_handler(&ar->handlers, keymap);
407
408   keymap = WM_keymap_ensure(wm->defaultconf, "Curve", 0, 0);
409   WM_event_add_keymap_handler(&ar->handlers, keymap);
410
411   keymap = WM_keymap_ensure(wm->defaultconf, "Armature", 0, 0);
412   WM_event_add_keymap_handler(&ar->handlers, keymap);
413
414   keymap = WM_keymap_ensure(wm->defaultconf, "Pose", 0, 0);
415   WM_event_add_keymap_handler(&ar->handlers, keymap);
416
417   keymap = WM_keymap_ensure(wm->defaultconf, "Metaball", 0, 0);
418   WM_event_add_keymap_handler(&ar->handlers, keymap);
419
420   keymap = WM_keymap_ensure(wm->defaultconf, "Lattice", 0, 0);
421   WM_event_add_keymap_handler(&ar->handlers, keymap);
422
423   keymap = WM_keymap_ensure(wm->defaultconf, "Particle", 0, 0);
424   WM_event_add_keymap_handler(&ar->handlers, keymap);
425
426   /* editfont keymap swallows all... */
427   keymap = WM_keymap_ensure(wm->defaultconf, "Font", 0, 0);
428   WM_event_add_keymap_handler(&ar->handlers, keymap);
429
430   keymap = WM_keymap_ensure(wm->defaultconf, "Object Non-modal", 0, 0);
431   WM_event_add_keymap_handler(&ar->handlers, keymap);
432
433   keymap = WM_keymap_ensure(wm->defaultconf, "Frames", 0, 0);
434   WM_event_add_keymap_handler(&ar->handlers, keymap);
435
436   /* own keymap, last so modes can override it */
437   keymap = WM_keymap_ensure(wm->defaultconf, "3D View Generic", SPACE_VIEW3D, 0);
438   WM_event_add_keymap_handler(&ar->handlers, keymap);
439
440   keymap = WM_keymap_ensure(wm->defaultconf, "3D View", SPACE_VIEW3D, 0);
441   WM_event_add_keymap_handler(&ar->handlers, keymap);
442
443   /* add drop boxes */
444   lb = WM_dropboxmap_find("View3D", SPACE_VIEW3D, RGN_TYPE_WINDOW);
445
446   WM_event_add_dropbox_handler(&ar->handlers, lb);
447 }
448
449 static void view3d_main_region_exit(wmWindowManager *wm, ARegion *ar)
450 {
451   ED_view3d_stop_render_preview(wm, ar);
452 }
453
454 static bool view3d_ob_drop_poll(bContext *UNUSED(C),
455                                 wmDrag *drag,
456                                 const wmEvent *UNUSED(event),
457                                 const char **UNUSED(tooltip))
458 {
459   return WM_drag_ID(drag, ID_OB) != NULL;
460 }
461
462 static bool view3d_collection_drop_poll(bContext *UNUSED(C),
463                                         wmDrag *drag,
464                                         const wmEvent *UNUSED(event),
465                                         const char **UNUSED(tooltip))
466 {
467   return WM_drag_ID(drag, ID_GR) != NULL;
468 }
469
470 static bool view3d_mat_drop_poll(bContext *UNUSED(C),
471                                  wmDrag *drag,
472                                  const wmEvent *UNUSED(event),
473                                  const char **UNUSED(tooltip))
474 {
475   return WM_drag_ID(drag, ID_MA) != NULL;
476 }
477
478 static bool view3d_ima_drop_poll(bContext *UNUSED(C),
479                                  wmDrag *drag,
480                                  const wmEvent *UNUSED(event),
481                                  const char **UNUSED(tooltip))
482 {
483   if (drag->type == WM_DRAG_PATH) {
484     /* rule might not work? */
485     return (ELEM(drag->icon, 0, ICON_FILE_IMAGE, ICON_FILE_MOVIE));
486   }
487   else {
488     return WM_drag_ID(drag, ID_IM) != NULL;
489   }
490 }
491
492 static bool view3d_ima_bg_is_camera_view(bContext *C)
493 {
494   RegionView3D *rv3d = CTX_wm_region_view3d(C);
495   if ((rv3d && (rv3d->persp == RV3D_CAMOB))) {
496     View3D *v3d = CTX_wm_view3d(C);
497     if (v3d && v3d->camera && v3d->camera->type == OB_CAMERA) {
498       return true;
499     }
500   }
501   return false;
502 }
503
504 static bool view3d_ima_bg_drop_poll(bContext *C,
505                                     wmDrag *drag,
506                                     const wmEvent *event,
507                                     const char **tooltip)
508 {
509   if (!view3d_ima_drop_poll(C, drag, event, tooltip)) {
510     return false;
511   }
512
513   if (ED_view3d_is_object_under_cursor(C, event->mval)) {
514     return false;
515   }
516
517   return view3d_ima_bg_is_camera_view(C);
518 }
519
520 static bool view3d_ima_empty_drop_poll(bContext *C,
521                                        wmDrag *drag,
522                                        const wmEvent *event,
523                                        const char **tooltip)
524 {
525   if (!view3d_ima_drop_poll(C, drag, event, tooltip)) {
526     return false;
527   }
528
529   Object *ob = ED_view3d_give_object_under_cursor(C, event->mval);
530
531   if (ob == NULL) {
532     return true;
533   }
534
535   if (ob->type == OB_EMPTY && ob->empty_drawtype == OB_EMPTY_IMAGE) {
536     return true;
537   }
538
539   return false;
540 }
541
542 static void view3d_ob_drop_copy(wmDrag *drag, wmDropBox *drop)
543 {
544   ID *id = WM_drag_ID(drag, ID_OB);
545
546   RNA_string_set(drop->ptr, "name", id->name + 2);
547 }
548
549 static void view3d_collection_drop_copy(wmDrag *drag, wmDropBox *drop)
550 {
551   ID *id = WM_drag_ID(drag, ID_GR);
552
553   drop->opcontext = WM_OP_EXEC_DEFAULT;
554   RNA_string_set(drop->ptr, "name", id->name + 2);
555 }
556
557 static void view3d_id_drop_copy(wmDrag *drag, wmDropBox *drop)
558 {
559   ID *id = WM_drag_ID(drag, 0);
560
561   RNA_string_set(drop->ptr, "name", id->name + 2);
562 }
563
564 static void view3d_id_path_drop_copy(wmDrag *drag, wmDropBox *drop)
565 {
566   ID *id = WM_drag_ID(drag, 0);
567
568   if (id) {
569     RNA_string_set(drop->ptr, "name", id->name + 2);
570     RNA_struct_property_unset(drop->ptr, "filepath");
571   }
572   else if (drag->path[0]) {
573     RNA_string_set(drop->ptr, "filepath", drag->path);
574     RNA_struct_property_unset(drop->ptr, "image");
575   }
576 }
577
578 static void view3d_lightcache_update(bContext *C)
579 {
580   PointerRNA op_ptr;
581
582   Scene *scene = CTX_data_scene(C);
583
584   if (!BKE_scene_uses_blender_eevee(scene)) {
585     /* Only do auto bake if eevee is the active engine */
586     return;
587   }
588
589   WM_operator_properties_create(&op_ptr, "SCENE_OT_light_cache_bake");
590   RNA_int_set(&op_ptr, "delay", 200);
591   RNA_enum_set_identifier(C, &op_ptr, "subset", "DIRTY");
592
593   WM_operator_name_call(C, "SCENE_OT_light_cache_bake", WM_OP_INVOKE_DEFAULT, &op_ptr);
594
595   WM_operator_properties_free(&op_ptr);
596 }
597
598 /* region dropbox definition */
599 static void view3d_dropboxes(void)
600 {
601   ListBase *lb = WM_dropboxmap_find("View3D", SPACE_VIEW3D, RGN_TYPE_WINDOW);
602
603   WM_dropbox_add(lb, "OBJECT_OT_add_named", view3d_ob_drop_poll, view3d_ob_drop_copy);
604   WM_dropbox_add(lb, "OBJECT_OT_drop_named_material", view3d_mat_drop_poll, view3d_id_drop_copy);
605   WM_dropbox_add(
606       lb, "VIEW3D_OT_background_image_add", view3d_ima_bg_drop_poll, view3d_id_path_drop_copy);
607   WM_dropbox_add(
608       lb, "OBJECT_OT_drop_named_image", view3d_ima_empty_drop_poll, view3d_id_path_drop_copy);
609   WM_dropbox_add(lb,
610                  "OBJECT_OT_collection_instance_add",
611                  view3d_collection_drop_poll,
612                  view3d_collection_drop_copy);
613 }
614
615 static void view3d_widgets(void)
616 {
617   wmGizmoMapType *gzmap_type = WM_gizmomaptype_ensure(
618       &(const struct wmGizmoMapType_Params){SPACE_VIEW3D, RGN_TYPE_WINDOW});
619
620   WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_xform_gizmo_context);
621   WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_light_spot);
622   WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_light_area);
623   WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_light_target);
624   WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_force_field);
625   WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_camera);
626   WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_camera_view);
627   WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_empty_image);
628   /* TODO(campbell): Not working well enough, disable for now. */
629 #if 0
630   WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_armature_spline);
631 #endif
632
633   WM_gizmogrouptype_append(VIEW3D_GGT_xform_gizmo);
634   WM_gizmogrouptype_append(VIEW3D_GGT_xform_cage);
635   WM_gizmogrouptype_append(VIEW3D_GGT_xform_shear);
636   WM_gizmogrouptype_append(VIEW3D_GGT_xform_extrude);
637   WM_gizmogrouptype_append(VIEW3D_GGT_mesh_preselect_elem);
638   WM_gizmogrouptype_append(VIEW3D_GGT_mesh_preselect_edgering);
639
640   WM_gizmogrouptype_append(VIEW3D_GGT_ruler);
641   WM_gizmotype_append(VIEW3D_GT_ruler_item);
642
643   WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_navigate);
644   WM_gizmotype_append(VIEW3D_GT_navigate_rotate);
645 }
646
647 /* type callback, not region itself */
648 static void view3d_main_region_free(ARegion *ar)
649 {
650   RegionView3D *rv3d = ar->regiondata;
651
652   if (rv3d) {
653     if (rv3d->localvd) {
654       MEM_freeN(rv3d->localvd);
655     }
656     if (rv3d->clipbb) {
657       MEM_freeN(rv3d->clipbb);
658     }
659
660     if (rv3d->render_engine) {
661       RE_engine_free(rv3d->render_engine);
662     }
663
664     if (rv3d->depths) {
665       if (rv3d->depths->depths) {
666         MEM_freeN(rv3d->depths->depths);
667       }
668       MEM_freeN(rv3d->depths);
669     }
670     if (rv3d->sms) {
671       MEM_freeN(rv3d->sms);
672     }
673
674     MEM_freeN(rv3d);
675     ar->regiondata = NULL;
676   }
677 }
678
679 /* copy regiondata */
680 static void *view3d_main_region_duplicate(void *poin)
681 {
682   if (poin) {
683     RegionView3D *rv3d = poin, *new;
684
685     new = MEM_dupallocN(rv3d);
686     if (rv3d->localvd) {
687       new->localvd = MEM_dupallocN(rv3d->localvd);
688     }
689     if (rv3d->clipbb) {
690       new->clipbb = MEM_dupallocN(rv3d->clipbb);
691     }
692
693     new->depths = NULL;
694     new->render_engine = NULL;
695     new->sms = NULL;
696     new->smooth_timer = NULL;
697
698     return new;
699   }
700   return NULL;
701 }
702
703 static void view3d_main_region_listener(
704     wmWindow *UNUSED(win), ScrArea *sa, ARegion *ar, wmNotifier *wmn, const Scene *scene)
705 {
706   View3D *v3d = sa->spacedata.first;
707   RegionView3D *rv3d = ar->regiondata;
708   wmGizmoMap *gzmap = ar->gizmo_map;
709
710   /* context changes */
711   switch (wmn->category) {
712     case NC_WM:
713       if (ELEM(wmn->data, ND_UNDO)) {
714         WM_gizmomap_tag_refresh(gzmap);
715       }
716       break;
717     case NC_ANIMATION:
718       switch (wmn->data) {
719         case ND_KEYFRAME_PROP:
720         case ND_NLA_ACTCHANGE:
721           ED_region_tag_redraw(ar);
722           break;
723         case ND_NLA:
724         case ND_KEYFRAME:
725           if (ELEM(wmn->action, NA_EDITED, NA_ADDED, NA_REMOVED)) {
726             ED_region_tag_redraw(ar);
727           }
728           break;
729         case ND_ANIMCHAN:
730           if (ELEM(wmn->action, NA_EDITED, NA_ADDED, NA_REMOVED, NA_SELECTED)) {
731             ED_region_tag_redraw(ar);
732           }
733           break;
734       }
735       break;
736     case NC_SCENE:
737       switch (wmn->data) {
738         case ND_SCENEBROWSE:
739         case ND_LAYER_CONTENT:
740           ED_region_tag_redraw(ar);
741           WM_gizmomap_tag_refresh(gzmap);
742           break;
743         case ND_LAYER:
744           if (wmn->reference) {
745             BKE_screen_view3d_sync(v3d, wmn->reference);
746           }
747           ED_region_tag_redraw(ar);
748           WM_gizmomap_tag_refresh(gzmap);
749           break;
750         case ND_OB_ACTIVE:
751         case ND_OB_SELECT:
752           ATTR_FALLTHROUGH;
753         case ND_FRAME:
754         case ND_TRANSFORM:
755         case ND_OB_VISIBLE:
756         case ND_RENDER_OPTIONS:
757         case ND_MARKERS:
758         case ND_MODE:
759           ED_region_tag_redraw(ar);
760           WM_gizmomap_tag_refresh(gzmap);
761           break;
762         case ND_WORLD:
763           /* handled by space_view3d_listener() for v3d access */
764           break;
765         case ND_DRAW_RENDER_VIEWPORT: {
766           if (v3d->camera && (scene == wmn->reference)) {
767             if (rv3d->persp == RV3D_CAMOB) {
768               ED_region_tag_redraw(ar);
769             }
770           }
771           break;
772         }
773       }
774       if (wmn->action == NA_EDITED) {
775         ED_region_tag_redraw(ar);
776       }
777       break;
778     case NC_OBJECT:
779       switch (wmn->data) {
780         case ND_BONE_ACTIVE:
781         case ND_BONE_SELECT:
782         case ND_TRANSFORM:
783         case ND_POSE:
784         case ND_DRAW:
785         case ND_MODIFIER:
786         case ND_CONSTRAINT:
787         case ND_KEYS:
788         case ND_PARTICLE:
789         case ND_POINTCACHE:
790         case ND_LOD:
791           ED_region_tag_redraw(ar);
792           WM_gizmomap_tag_refresh(gzmap);
793           break;
794       }
795       switch (wmn->action) {
796         case NA_ADDED:
797           ED_region_tag_redraw(ar);
798           break;
799       }
800       break;
801     case NC_GEOM:
802       switch (wmn->data) {
803         case ND_SELECT: {
804           WM_gizmomap_tag_refresh(gzmap);
805           ATTR_FALLTHROUGH;
806         }
807         case ND_DATA:
808         case ND_VERTEX_GROUP:
809           ED_region_tag_redraw(ar);
810           break;
811       }
812       switch (wmn->action) {
813         case NA_EDITED:
814           ED_region_tag_redraw(ar);
815           break;
816       }
817       break;
818     case NC_CAMERA:
819       switch (wmn->data) {
820         case ND_DRAW_RENDER_VIEWPORT: {
821           if (v3d->camera && (v3d->camera->data == wmn->reference)) {
822             if (rv3d->persp == RV3D_CAMOB) {
823               ED_region_tag_redraw(ar);
824             }
825           }
826           break;
827         }
828       }
829       break;
830     case NC_GROUP:
831       /* all group ops for now */
832       ED_region_tag_redraw(ar);
833       break;
834     case NC_BRUSH:
835       switch (wmn->action) {
836         case NA_EDITED:
837           ED_region_tag_redraw_overlay(ar);
838           break;
839         case NA_SELECTED:
840           /* used on brush changes - needed because 3d cursor
841            * has to be drawn if clone brush is selected */
842           ED_region_tag_redraw(ar);
843           break;
844       }
845       break;
846     case NC_MATERIAL:
847       switch (wmn->data) {
848         case ND_SHADING:
849         case ND_NODES:
850           /* TODO(sergey) This is a bit too much updates, but needed to
851            * have proper material drivers update in the viewport.
852            *
853            * How to solve?
854            */
855           ED_region_tag_redraw(ar);
856           break;
857         case ND_SHADING_DRAW:
858         case ND_SHADING_LINKS:
859           ED_region_tag_redraw(ar);
860           break;
861       }
862       break;
863     case NC_WORLD:
864       switch (wmn->data) {
865         case ND_WORLD_DRAW:
866           /* handled by space_view3d_listener() for v3d access */
867           break;
868         case ND_WORLD:
869           /* Needed for updating world materials */
870           ED_region_tag_redraw(ar);
871           break;
872       }
873       break;
874     case NC_LAMP:
875       switch (wmn->data) {
876         case ND_LIGHTING:
877           /* TODO(sergey): This is a bit too much, but needed to
878            * handle updates from new depsgraph.
879            */
880           ED_region_tag_redraw(ar);
881           break;
882         case ND_LIGHTING_DRAW:
883           ED_region_tag_redraw(ar);
884           WM_gizmomap_tag_refresh(gzmap);
885           break;
886       }
887       break;
888     case NC_LIGHTPROBE:
889       ED_area_tag_refresh(sa);
890       break;
891     case NC_IMAGE:
892       /* this could be more fine grained checks if we had
893        * more context than just the region */
894       ED_region_tag_redraw(ar);
895       break;
896     case NC_TEXTURE:
897       /* same as above */
898       ED_region_tag_redraw(ar);
899       break;
900     case NC_MOVIECLIP:
901       if (wmn->data == ND_DISPLAY || wmn->action == NA_EDITED) {
902         ED_region_tag_redraw(ar);
903       }
904       break;
905     case NC_SPACE:
906       if (wmn->data == ND_SPACE_VIEW3D) {
907         if (wmn->subtype == NS_VIEW3D_GPU) {
908           rv3d->rflag |= RV3D_GPULIGHT_UPDATE;
909         }
910         ED_region_tag_redraw(ar);
911         WM_gizmomap_tag_refresh(gzmap);
912       }
913       break;
914     case NC_ID:
915       if (wmn->action == NA_RENAME) {
916         ED_region_tag_redraw(ar);
917       }
918       break;
919     case NC_SCREEN:
920       switch (wmn->data) {
921         case ND_ANIMPLAY:
922         case ND_SKETCH:
923           ED_region_tag_redraw(ar);
924           break;
925         case ND_LAYOUTBROWSE:
926         case ND_LAYOUTDELETE:
927         case ND_LAYOUTSET:
928           WM_gizmomap_tag_refresh(gzmap);
929           ED_region_tag_redraw(ar);
930           break;
931         case ND_LAYER:
932           ED_region_tag_redraw(ar);
933           break;
934       }
935
936       break;
937     case NC_GPENCIL:
938       if (wmn->data == ND_DATA || ELEM(wmn->action, NA_EDITED, NA_SELECTED)) {
939         ED_region_tag_redraw(ar);
940       }
941       break;
942   }
943 }
944
945 static void view3d_main_region_message_subscribe(const struct bContext *C,
946                                                  struct WorkSpace *UNUSED(workspace),
947                                                  struct Scene *UNUSED(scene),
948                                                  struct bScreen *UNUSED(screen),
949                                                  struct ScrArea *sa,
950                                                  struct ARegion *ar,
951                                                  struct wmMsgBus *mbus)
952 {
953   /* Developer note: there are many properties that impact 3D view drawing,
954    * so instead of subscribing to individual properties, just subscribe to types
955    * accepting some redundant redraws.
956    *
957    * For other space types we might try avoid this, keep the 3D view as an exceptional case! */
958   wmMsgParams_RNA msg_key_params = {{0}};
959
960   /* Only subscribe to types. */
961   StructRNA *type_array[] = {
962       &RNA_Window,
963
964       /* These object have properties that impact drawing. */
965       &RNA_AreaLight,
966       &RNA_Camera,
967       &RNA_Light,
968       &RNA_Speaker,
969       &RNA_SunLight,
970
971       /* General types the 3D view depends on. */
972       &RNA_Object,
973       &RNA_UnitSettings, /* grid-floor */
974
975       &RNA_View3DOverlay,
976       &RNA_View3DShading,
977       &RNA_World,
978   };
979
980   wmMsgSubscribeValue msg_sub_value_region_tag_redraw = {
981       .owner = ar,
982       .user_data = ar,
983       .notify = ED_region_do_msg_notify_tag_redraw,
984   };
985
986   for (int i = 0; i < ARRAY_SIZE(type_array); i++) {
987     msg_key_params.ptr.type = type_array[i];
988     WM_msg_subscribe_rna_params(mbus, &msg_key_params, &msg_sub_value_region_tag_redraw, __func__);
989   }
990
991   /* Subscribe to a handful of other properties. */
992   RegionView3D *rv3d = ar->regiondata;
993
994   WM_msg_subscribe_rna_anon_prop(mbus, RenderSettings, engine, &msg_sub_value_region_tag_redraw);
995   WM_msg_subscribe_rna_anon_prop(
996       mbus, RenderSettings, resolution_x, &msg_sub_value_region_tag_redraw);
997   WM_msg_subscribe_rna_anon_prop(
998       mbus, RenderSettings, resolution_y, &msg_sub_value_region_tag_redraw);
999   WM_msg_subscribe_rna_anon_prop(
1000       mbus, RenderSettings, pixel_aspect_x, &msg_sub_value_region_tag_redraw);
1001   WM_msg_subscribe_rna_anon_prop(
1002       mbus, RenderSettings, pixel_aspect_y, &msg_sub_value_region_tag_redraw);
1003   if (rv3d->persp == RV3D_CAMOB) {
1004     WM_msg_subscribe_rna_anon_prop(
1005         mbus, RenderSettings, use_border, &msg_sub_value_region_tag_redraw);
1006   }
1007
1008   WM_msg_subscribe_rna_anon_type(mbus, SceneEEVEE, &msg_sub_value_region_tag_redraw);
1009   WM_msg_subscribe_rna_anon_type(mbus, SceneDisplay, &msg_sub_value_region_tag_redraw);
1010   WM_msg_subscribe_rna_anon_type(mbus, ObjectDisplay, &msg_sub_value_region_tag_redraw);
1011
1012   ViewLayer *view_layer = CTX_data_view_layer(C);
1013   Object *obact = OBACT(view_layer);
1014   if (obact != NULL) {
1015     switch (obact->mode) {
1016       case OB_MODE_PARTICLE_EDIT:
1017         WM_msg_subscribe_rna_anon_type(mbus, ParticleEdit, &msg_sub_value_region_tag_redraw);
1018         break;
1019       default:
1020         break;
1021     }
1022   }
1023
1024   {
1025     wmMsgSubscribeValue msg_sub_value_region_tag_refresh = {
1026         .owner = ar,
1027         .user_data = sa,
1028         .notify = WM_toolsystem_do_msg_notify_tag_refresh,
1029     };
1030     WM_msg_subscribe_rna_anon_prop(mbus, Object, mode, &msg_sub_value_region_tag_refresh);
1031     WM_msg_subscribe_rna_anon_prop(mbus, LayerObjects, active, &msg_sub_value_region_tag_refresh);
1032   }
1033 }
1034
1035 /* concept is to retrieve cursor type context-less */
1036 static void view3d_main_region_cursor(wmWindow *win, ScrArea *sa, ARegion *ar)
1037 {
1038   if (WM_cursor_set_from_tool(win, sa, ar)) {
1039     return;
1040   }
1041
1042   ViewLayer *view_layer = WM_window_get_active_view_layer(win);
1043   Object *obedit = OBEDIT_FROM_VIEW_LAYER(view_layer);
1044   if (obedit) {
1045     WM_cursor_set(win, CURSOR_EDIT);
1046   }
1047   else {
1048     WM_cursor_set(win, CURSOR_STD);
1049   }
1050 }
1051
1052 /* add handlers, stuff you only do once or on area/region changes */
1053 static void view3d_header_region_init(wmWindowManager *wm, ARegion *ar)
1054 {
1055   wmKeyMap *keymap = WM_keymap_ensure(wm->defaultconf, "3D View Generic", SPACE_VIEW3D, 0);
1056
1057   WM_event_add_keymap_handler(&ar->handlers, keymap);
1058
1059   ED_region_header_init(ar);
1060 }
1061
1062 static void view3d_header_region_draw(const bContext *C, ARegion *ar)
1063 {
1064   ED_region_header(C, ar);
1065 }
1066
1067 static void view3d_header_region_listener(wmWindow *UNUSED(win),
1068                                           ScrArea *UNUSED(sa),
1069                                           ARegion *ar,
1070                                           wmNotifier *wmn,
1071                                           const Scene *UNUSED(scene))
1072 {
1073   /* context changes */
1074   switch (wmn->category) {
1075     case NC_SCENE:
1076       switch (wmn->data) {
1077         case ND_FRAME:
1078         case ND_OB_ACTIVE:
1079         case ND_OB_SELECT:
1080         case ND_OB_VISIBLE:
1081         case ND_MODE:
1082         case ND_LAYER:
1083         case ND_TOOLSETTINGS:
1084         case ND_LAYER_CONTENT:
1085         case ND_RENDER_OPTIONS:
1086           ED_region_tag_redraw(ar);
1087           break;
1088       }
1089       break;
1090     case NC_SPACE:
1091       if (wmn->data == ND_SPACE_VIEW3D) {
1092         ED_region_tag_redraw(ar);
1093       }
1094       break;
1095     case NC_GPENCIL:
1096       if (wmn->data & ND_GPENCIL_EDITMODE) {
1097         ED_region_tag_redraw(ar);
1098       }
1099       break;
1100     case NC_BRUSH:
1101       ED_region_tag_redraw(ar);
1102       break;
1103   }
1104
1105     /* From topbar, which ones are needed? split per header? */
1106     /* Disable for now, re-enable if needed, or remove - campbell. */
1107 #if 0
1108   /* context changes */
1109   switch (wmn->category) {
1110     case NC_WM:
1111       if (wmn->data == ND_HISTORY) {
1112         ED_region_tag_redraw(ar);
1113       }
1114       break;
1115     case NC_SCENE:
1116       if (wmn->data == ND_MODE) {
1117         ED_region_tag_redraw(ar);
1118       }
1119       break;
1120     case NC_SPACE:
1121       if (wmn->data == ND_SPACE_VIEW3D) {
1122         ED_region_tag_redraw(ar);
1123       }
1124       break;
1125     case NC_GPENCIL:
1126       if (wmn->data == ND_DATA) {
1127         ED_region_tag_redraw(ar);
1128       }
1129       break;
1130   }
1131 #endif
1132 }
1133
1134 static void view3d_header_region_message_subscribe(const struct bContext *UNUSED(C),
1135                                                    struct WorkSpace *UNUSED(workspace),
1136                                                    struct Scene *UNUSED(scene),
1137                                                    struct bScreen *UNUSED(screen),
1138                                                    struct ScrArea *UNUSED(sa),
1139                                                    struct ARegion *ar,
1140                                                    struct wmMsgBus *mbus)
1141 {
1142   wmMsgParams_RNA msg_key_params = {{0}};
1143
1144   /* Only subscribe to types. */
1145   StructRNA *type_array[] = {
1146       &RNA_View3DShading,
1147   };
1148
1149   wmMsgSubscribeValue msg_sub_value_region_tag_redraw = {
1150       .owner = ar,
1151       .user_data = ar,
1152       .notify = ED_region_do_msg_notify_tag_redraw,
1153   };
1154
1155   for (int i = 0; i < ARRAY_SIZE(type_array); i++) {
1156     msg_key_params.ptr.type = type_array[i];
1157     WM_msg_subscribe_rna_params(mbus, &msg_key_params, &msg_sub_value_region_tag_redraw, __func__);
1158   }
1159 }
1160
1161 /* add handlers, stuff you only do once or on area/region changes */
1162 static void view3d_buttons_region_init(wmWindowManager *wm, ARegion *ar)
1163 {
1164   wmKeyMap *keymap;
1165
1166   ED_region_panels_init(wm, ar);
1167
1168   keymap = WM_keymap_ensure(wm->defaultconf, "3D View Generic", SPACE_VIEW3D, 0);
1169   WM_event_add_keymap_handler(&ar->handlers, keymap);
1170 }
1171
1172 void ED_view3d_buttons_region_layout_ex(const bContext *C,
1173                                         ARegion *ar,
1174                                         const char *category_override)
1175 {
1176   const enum eContextObjectMode mode = CTX_data_mode_enum(C);
1177
1178   const char *contexts_base[4] = {NULL};
1179   contexts_base[0] = CTX_data_mode_string(C);
1180
1181   const char **contexts = &contexts_base[1];
1182
1183   switch (mode) {
1184     case CTX_MODE_EDIT_MESH:
1185       ARRAY_SET_ITEMS(contexts, ".mesh_edit");
1186       break;
1187     case CTX_MODE_EDIT_CURVE:
1188       ARRAY_SET_ITEMS(contexts, ".curve_edit");
1189       break;
1190     case CTX_MODE_EDIT_SURFACE:
1191       ARRAY_SET_ITEMS(contexts, ".curve_edit");
1192       break;
1193     case CTX_MODE_EDIT_TEXT:
1194       ARRAY_SET_ITEMS(contexts, ".text_edit");
1195       break;
1196     case CTX_MODE_EDIT_ARMATURE:
1197       ARRAY_SET_ITEMS(contexts, ".armature_edit");
1198       break;
1199     case CTX_MODE_EDIT_METABALL:
1200       ARRAY_SET_ITEMS(contexts, ".mball_edit");
1201       break;
1202     case CTX_MODE_EDIT_LATTICE:
1203       ARRAY_SET_ITEMS(contexts, ".lattice_edit");
1204       break;
1205     case CTX_MODE_POSE:
1206       ARRAY_SET_ITEMS(contexts, ".posemode");
1207       break;
1208     case CTX_MODE_SCULPT:
1209       ARRAY_SET_ITEMS(contexts, ".paint_common", ".sculpt_mode");
1210       break;
1211     case CTX_MODE_PAINT_WEIGHT:
1212       ARRAY_SET_ITEMS(contexts, ".paint_common", ".weightpaint");
1213       break;
1214     case CTX_MODE_PAINT_VERTEX:
1215       ARRAY_SET_ITEMS(contexts, ".paint_common", ".vertexpaint");
1216       break;
1217     case CTX_MODE_PAINT_TEXTURE:
1218       ARRAY_SET_ITEMS(contexts, ".paint_common", ".imagepaint");
1219       break;
1220     case CTX_MODE_PARTICLE:
1221       ARRAY_SET_ITEMS(contexts, ".paint_common", ".particlemode");
1222       break;
1223     case CTX_MODE_OBJECT:
1224       ARRAY_SET_ITEMS(contexts, ".objectmode");
1225       break;
1226     case CTX_MODE_PAINT_GPENCIL:
1227       ARRAY_SET_ITEMS(contexts, ".greasepencil_paint");
1228       break;
1229     case CTX_MODE_SCULPT_GPENCIL:
1230       ARRAY_SET_ITEMS(contexts, ".greasepencil_sculpt");
1231       break;
1232     case CTX_MODE_WEIGHT_GPENCIL:
1233       ARRAY_SET_ITEMS(contexts, ".greasepencil_weight");
1234       break;
1235     default:
1236       break;
1237   }
1238
1239   switch (mode) {
1240     case CTX_MODE_PAINT_GPENCIL:
1241       ARRAY_SET_ITEMS(contexts, ".greasepencil_paint");
1242       break;
1243     case CTX_MODE_SCULPT_GPENCIL:
1244       ARRAY_SET_ITEMS(contexts, ".greasepencil_sculpt");
1245       break;
1246     case CTX_MODE_WEIGHT_GPENCIL:
1247       ARRAY_SET_ITEMS(contexts, ".greasepencil_weight");
1248       break;
1249     case CTX_MODE_EDIT_GPENCIL:
1250       ARRAY_SET_ITEMS(contexts, ".greasepencil_edit");
1251       break;
1252     default:
1253       break;
1254   }
1255
1256   ListBase *paneltypes = &ar->type->paneltypes;
1257
1258   /* Allow drawing 3D view toolbar from non 3D view space type. */
1259   if (category_override != NULL) {
1260     SpaceType *st = BKE_spacetype_from_id(SPACE_VIEW3D);
1261     ARegionType *art = BKE_regiontype_from_id(st, RGN_TYPE_UI);
1262     paneltypes = &art->paneltypes;
1263   }
1264
1265   const bool vertical = true;
1266   ED_region_panels_layout_ex(C, ar, paneltypes, contexts_base, -1, vertical, category_override);
1267 }
1268
1269 static void view3d_buttons_region_layout(const bContext *C, ARegion *ar)
1270 {
1271   ED_view3d_buttons_region_layout_ex(C, ar, NULL);
1272 }
1273
1274 static void view3d_buttons_region_listener(wmWindow *UNUSED(win),
1275                                            ScrArea *UNUSED(sa),
1276                                            ARegion *ar,
1277                                            wmNotifier *wmn,
1278                                            const Scene *UNUSED(scene))
1279 {
1280   /* context changes */
1281   switch (wmn->category) {
1282     case NC_ANIMATION:
1283       switch (wmn->data) {
1284         case ND_KEYFRAME_PROP:
1285         case ND_NLA_ACTCHANGE:
1286           ED_region_tag_redraw(ar);
1287           break;
1288         case ND_NLA:
1289         case ND_KEYFRAME:
1290           if (ELEM(wmn->action, NA_EDITED, NA_ADDED, NA_REMOVED)) {
1291             ED_region_tag_redraw(ar);
1292           }
1293           break;
1294       }
1295       break;
1296     case NC_SCENE:
1297       switch (wmn->data) {
1298         case ND_FRAME:
1299         case ND_OB_ACTIVE:
1300         case ND_OB_SELECT:
1301         case ND_OB_VISIBLE:
1302         case ND_MODE:
1303         case ND_LAYER:
1304         case ND_LAYER_CONTENT:
1305         case ND_TOOLSETTINGS:
1306           ED_region_tag_redraw(ar);
1307           break;
1308       }
1309       switch (wmn->action) {
1310         case NA_EDITED:
1311           ED_region_tag_redraw(ar);
1312           break;
1313       }
1314       break;
1315     case NC_OBJECT:
1316       switch (wmn->data) {
1317         case ND_BONE_ACTIVE:
1318         case ND_BONE_SELECT:
1319         case ND_TRANSFORM:
1320         case ND_POSE:
1321         case ND_DRAW:
1322         case ND_KEYS:
1323         case ND_MODIFIER:
1324           ED_region_tag_redraw(ar);
1325           break;
1326       }
1327       break;
1328     case NC_GEOM:
1329       switch (wmn->data) {
1330         case ND_DATA:
1331         case ND_VERTEX_GROUP:
1332         case ND_SELECT:
1333           ED_region_tag_redraw(ar);
1334           break;
1335       }
1336       if (wmn->action == NA_EDITED) {
1337         ED_region_tag_redraw(ar);
1338       }
1339       break;
1340     case NC_TEXTURE:
1341     case NC_MATERIAL:
1342       /* for brush textures */
1343       ED_region_tag_redraw(ar);
1344       break;
1345     case NC_BRUSH:
1346       /* NA_SELECTED is used on brush changes */
1347       if (ELEM(wmn->action, NA_EDITED, NA_SELECTED)) {
1348         ED_region_tag_redraw(ar);
1349       }
1350       break;
1351     case NC_SPACE:
1352       if (wmn->data == ND_SPACE_VIEW3D) {
1353         ED_region_tag_redraw(ar);
1354       }
1355       break;
1356     case NC_ID:
1357       if (wmn->action == NA_RENAME) {
1358         ED_region_tag_redraw(ar);
1359       }
1360       break;
1361     case NC_GPENCIL:
1362       if ((wmn->data & (ND_DATA | ND_GPENCIL_EDITMODE)) || (wmn->action == NA_EDITED)) {
1363         ED_region_tag_redraw(ar);
1364       }
1365       break;
1366     case NC_IMAGE:
1367       /* Update for the image layers in texture paint. */
1368       if (wmn->action == NA_EDITED) {
1369         ED_region_tag_redraw(ar);
1370       }
1371       break;
1372   }
1373 }
1374
1375 /* add handlers, stuff you only do once or on area/region changes */
1376 static void view3d_tools_region_init(wmWindowManager *wm, ARegion *ar)
1377 {
1378   wmKeyMap *keymap;
1379
1380   ED_region_panels_init(wm, ar);
1381
1382   keymap = WM_keymap_ensure(wm->defaultconf, "3D View Generic", SPACE_VIEW3D, 0);
1383   WM_event_add_keymap_handler(&ar->handlers, keymap);
1384 }
1385
1386 static void view3d_tools_region_draw(const bContext *C, ARegion *ar)
1387 {
1388   ED_region_panels_ex(C, ar, (const char *[]){CTX_data_mode_string(C), NULL}, -1, true);
1389 }
1390
1391 /* area (not region) level listener */
1392 static void space_view3d_listener(wmWindow *UNUSED(win),
1393                                   ScrArea *sa,
1394                                   struct wmNotifier *wmn,
1395                                   Scene *UNUSED(scene))
1396 {
1397   View3D *v3d = sa->spacedata.first;
1398
1399   /* context changes */
1400   switch (wmn->category) {
1401     case NC_SCENE:
1402       switch (wmn->data) {
1403         case ND_WORLD:
1404           if (v3d->flag2 & V3D_HIDE_OVERLAYS) {
1405             ED_area_tag_redraw_regiontype(sa, RGN_TYPE_WINDOW);
1406           }
1407           break;
1408       }
1409       break;
1410     case NC_WORLD:
1411       switch (wmn->data) {
1412         case ND_WORLD_DRAW:
1413         case ND_WORLD:
1414           if (v3d->shading.background_type == V3D_SHADING_BACKGROUND_WORLD) {
1415             ED_area_tag_redraw_regiontype(sa, RGN_TYPE_WINDOW);
1416           }
1417           break;
1418       }
1419       break;
1420     case NC_MATERIAL:
1421       switch (wmn->data) {
1422         case ND_NODES:
1423           if (v3d->shading.type == OB_TEXTURE) {
1424             ED_area_tag_redraw_regiontype(sa, RGN_TYPE_WINDOW);
1425           }
1426           break;
1427       }
1428       break;
1429   }
1430 }
1431
1432 static void space_view3d_refresh(const bContext *C, ScrArea *UNUSED(sa))
1433 {
1434   Scene *scene = CTX_data_scene(C);
1435   LightCache *lcache = scene->eevee.light_cache;
1436
1437   if (lcache && (lcache->flag & LIGHTCACHE_UPDATE_AUTO) != 0) {
1438     lcache->flag &= ~LIGHTCACHE_UPDATE_AUTO;
1439     view3d_lightcache_update((bContext *)C);
1440   }
1441 }
1442
1443 const char *view3d_context_dir[] = {
1444     "active_base",
1445     "active_object",
1446     NULL,
1447 };
1448
1449 static int view3d_context(const bContext *C, const char *member, bContextDataResult *result)
1450 {
1451   /* fallback to the scene layer,
1452    * allows duplicate and other object operators to run outside the 3d view */
1453
1454   if (CTX_data_dir(member)) {
1455     CTX_data_dir_set(result, view3d_context_dir);
1456   }
1457   else if (CTX_data_equals(member, "active_base")) {
1458     Scene *scene = CTX_data_scene(C);
1459     ViewLayer *view_layer = CTX_data_view_layer(C);
1460     if (view_layer->basact) {
1461       Object *ob = view_layer->basact->object;
1462       /* if hidden but in edit mode, we still display, can happen with animation */
1463       if ((view_layer->basact->flag & BASE_VISIBLE) != 0 || (ob->mode & OB_MODE_EDIT)) {
1464         CTX_data_pointer_set(result, &scene->id, &RNA_ObjectBase, view_layer->basact);
1465       }
1466     }
1467
1468     return 1;
1469   }
1470   else if (CTX_data_equals(member, "active_object")) {
1471     ViewLayer *view_layer = CTX_data_view_layer(C);
1472     if (view_layer->basact) {
1473       Object *ob = view_layer->basact->object;
1474       /* if hidden but in edit mode, we still display, can happen with animation */
1475       if ((view_layer->basact->flag & BASE_VISIBLE) != 0 || (ob->mode & OB_MODE_EDIT) != 0) {
1476         CTX_data_id_pointer_set(result, &ob->id);
1477       }
1478     }
1479
1480     return 1;
1481   }
1482   else {
1483     return 0; /* not found */
1484   }
1485
1486   return -1; /* found but not available */
1487 }
1488
1489 static void view3d_id_remap(ScrArea *sa, SpaceLink *slink, ID *old_id, ID *new_id)
1490 {
1491   View3D *v3d;
1492   ARegion *ar;
1493   bool is_local = false;
1494
1495   if (!ELEM(GS(old_id->name), ID_OB, ID_MA, ID_IM, ID_MC)) {
1496     return;
1497   }
1498
1499   for (v3d = (View3D *)slink; v3d; v3d = v3d->localvd, is_local = true) {
1500     if ((ID *)v3d->camera == old_id) {
1501       v3d->camera = (Object *)new_id;
1502       if (!new_id) {
1503         /* 3D view might be inactive, in that case needs to use slink->regionbase */
1504         ListBase *regionbase = (slink == sa->spacedata.first) ? &sa->regionbase :
1505                                                                 &slink->regionbase;
1506         for (ar = regionbase->first; ar; ar = ar->next) {
1507           if (ar->regiontype == RGN_TYPE_WINDOW) {
1508             RegionView3D *rv3d = is_local ? ((RegionView3D *)ar->regiondata)->localvd :
1509                                             ar->regiondata;
1510             if (rv3d && (rv3d->persp == RV3D_CAMOB)) {
1511               rv3d->persp = RV3D_PERSP;
1512             }
1513           }
1514         }
1515       }
1516     }
1517
1518     /* Values in local-view aren't used, see: T52663 */
1519     if (is_local == false) {
1520       if ((ID *)v3d->ob_centre == old_id) {
1521         v3d->ob_centre = (Object *)new_id;
1522         /* Otherwise, bonename may remain valid...
1523          * We could be smart and check this, too? */
1524         if (new_id == NULL) {
1525           v3d->ob_centre_bone[0] = '\0';
1526         }
1527       }
1528     }
1529
1530     if (is_local) {
1531       break;
1532     }
1533   }
1534 }
1535
1536 /* only called once, from space/spacetypes.c */
1537 void ED_spacetype_view3d(void)
1538 {
1539   SpaceType *st = MEM_callocN(sizeof(SpaceType), "spacetype view3d");
1540   ARegionType *art;
1541
1542   st->spaceid = SPACE_VIEW3D;
1543   strncpy(st->name, "View3D", BKE_ST_MAXNAME);
1544
1545   st->new = view3d_new;
1546   st->free = view3d_free;
1547   st->init = view3d_init;
1548   st->listener = space_view3d_listener;
1549   st->refresh = space_view3d_refresh;
1550   st->duplicate = view3d_duplicate;
1551   st->operatortypes = view3d_operatortypes;
1552   st->keymap = view3d_keymap;
1553   st->dropboxes = view3d_dropboxes;
1554   st->gizmos = view3d_widgets;
1555   st->context = view3d_context;
1556   st->id_remap = view3d_id_remap;
1557
1558   /* regions: main window */
1559   art = MEM_callocN(sizeof(ARegionType), "spacetype view3d main region");
1560   art->regionid = RGN_TYPE_WINDOW;
1561   art->keymapflag = ED_KEYMAP_GIZMO | ED_KEYMAP_TOOL | ED_KEYMAP_GPENCIL;
1562   art->draw = view3d_main_region_draw;
1563   art->init = view3d_main_region_init;
1564   art->exit = view3d_main_region_exit;
1565   art->free = view3d_main_region_free;
1566   art->duplicate = view3d_main_region_duplicate;
1567   art->listener = view3d_main_region_listener;
1568   art->message_subscribe = view3d_main_region_message_subscribe;
1569   art->cursor = view3d_main_region_cursor;
1570   art->lock = 1; /* can become flag, see BKE_spacedata_draw_locks */
1571   BLI_addhead(&st->regiontypes, art);
1572
1573   /* regions: listview/buttons */
1574   art = MEM_callocN(sizeof(ARegionType), "spacetype view3d buttons region");
1575   art->regionid = RGN_TYPE_UI;
1576   art->prefsizex = UI_SIDEBAR_PANEL_WIDTH;
1577   art->keymapflag = ED_KEYMAP_UI | ED_KEYMAP_FRAMES;
1578   art->listener = view3d_buttons_region_listener;
1579   art->message_subscribe = ED_area_do_mgs_subscribe_for_tool_ui;
1580   art->init = view3d_buttons_region_init;
1581   art->layout = view3d_buttons_region_layout;
1582   art->draw = ED_region_panels_draw;
1583   BLI_addhead(&st->regiontypes, art);
1584
1585   view3d_buttons_register(art);
1586
1587   /* regions: tool(bar) */
1588   art = MEM_callocN(sizeof(ARegionType), "spacetype view3d tools region");
1589   art->regionid = RGN_TYPE_TOOLS;
1590   art->prefsizex = 58; /* XXX */
1591   art->prefsizey = 50; /* XXX */
1592   art->keymapflag = ED_KEYMAP_UI | ED_KEYMAP_FRAMES;
1593   art->listener = view3d_buttons_region_listener;
1594   art->message_subscribe = ED_region_generic_tools_region_message_subscribe;
1595   art->snap_size = ED_region_generic_tools_region_snap_size;
1596   art->init = view3d_tools_region_init;
1597   art->draw = view3d_tools_region_draw;
1598   BLI_addhead(&st->regiontypes, art);
1599
1600   /* regions: tool header */
1601   art = MEM_callocN(sizeof(ARegionType), "spacetype view3d tool header region");
1602   art->regionid = RGN_TYPE_TOOL_HEADER;
1603   art->prefsizey = HEADERY;
1604   art->keymapflag = ED_KEYMAP_UI | ED_KEYMAP_VIEW2D | ED_KEYMAP_FRAMES | ED_KEYMAP_HEADER;
1605   art->listener = view3d_header_region_listener;
1606   art->message_subscribe = ED_area_do_mgs_subscribe_for_tool_header;
1607   art->init = view3d_header_region_init;
1608   art->draw = view3d_header_region_draw;
1609   BLI_addhead(&st->regiontypes, art);
1610
1611   /* regions: header */
1612   art = MEM_callocN(sizeof(ARegionType), "spacetype view3d header region");
1613   art->regionid = RGN_TYPE_HEADER;
1614   art->prefsizey = HEADERY;
1615   art->keymapflag = ED_KEYMAP_UI | ED_KEYMAP_VIEW2D | ED_KEYMAP_FRAMES | ED_KEYMAP_HEADER;
1616   art->listener = view3d_header_region_listener;
1617   art->message_subscribe = view3d_header_region_message_subscribe;
1618   art->init = view3d_header_region_init;
1619   art->draw = view3d_header_region_draw;
1620   BLI_addhead(&st->regiontypes, art);
1621
1622   /* regions: hud */
1623   art = ED_area_type_hud(st->spaceid);
1624   BLI_addhead(&st->regiontypes, art);
1625
1626   BKE_spacetype_register(st);
1627 }