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