Cleanup: unused region init functions
[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   /* header */
297   ar = MEM_callocN(sizeof(ARegion), "header for view3d");
298
299   BLI_addtail(&v3d->regionbase, ar);
300   ar->regiontype = RGN_TYPE_HEADER;
301   ar->alignment = (U.uiflag & USER_HEADER_BOTTOM) ? RGN_ALIGN_BOTTOM : RGN_ALIGN_TOP;
302
303   /* tool shelf */
304   ar = MEM_callocN(sizeof(ARegion), "toolshelf for view3d");
305
306   BLI_addtail(&v3d->regionbase, ar);
307   ar->regiontype = RGN_TYPE_TOOLS;
308   ar->alignment = RGN_ALIGN_LEFT;
309   ar->flag = RGN_FLAG_HIDDEN;
310
311   /* buttons/list view */
312   ar = MEM_callocN(sizeof(ARegion), "buttons for view3d");
313
314   BLI_addtail(&v3d->regionbase, ar);
315   ar->regiontype = RGN_TYPE_UI;
316   ar->alignment = RGN_ALIGN_RIGHT;
317   ar->flag = RGN_FLAG_HIDDEN;
318
319   /* main region */
320   ar = MEM_callocN(sizeof(ARegion), "main region for view3d");
321
322   BLI_addtail(&v3d->regionbase, ar);
323   ar->regiontype = RGN_TYPE_WINDOW;
324
325   ar->regiondata = MEM_callocN(sizeof(RegionView3D), "region view3d");
326   rv3d = ar->regiondata;
327   rv3d->viewquat[0] = 1.0f;
328   rv3d->persp = RV3D_PERSP;
329   rv3d->view = RV3D_VIEW_USER;
330   rv3d->dist = 10.0;
331
332   return (SpaceLink *)v3d;
333 }
334
335 /* not spacelink itself */
336 static void view3d_free(SpaceLink *sl)
337 {
338   View3D *vd = (View3D *)sl;
339
340   if (vd->localvd) {
341     MEM_freeN(vd->localvd);
342   }
343
344   if (vd->runtime.properties_storage) {
345     MEM_freeN(vd->runtime.properties_storage);
346   }
347
348   if (vd->fx_settings.ssao) {
349     MEM_freeN(vd->fx_settings.ssao);
350   }
351   if (vd->fx_settings.dof) {
352     MEM_freeN(vd->fx_settings.dof);
353   }
354 }
355
356 /* spacetype; init callback */
357 static void view3d_init(wmWindowManager *UNUSED(wm), ScrArea *UNUSED(sa))
358 {
359 }
360
361 static SpaceLink *view3d_duplicate(SpaceLink *sl)
362 {
363   View3D *v3do = (View3D *)sl;
364   View3D *v3dn = MEM_dupallocN(sl);
365
366   /* clear or remove stuff from old */
367
368   if (v3dn->localvd) {
369     v3dn->localvd = NULL;
370     v3dn->runtime.properties_storage = NULL;
371   }
372
373   if (v3dn->shading.type == OB_RENDER) {
374     v3dn->shading.type = OB_SOLID;
375   }
376
377   /* copy or clear inside new stuff */
378
379   v3dn->runtime.properties_storage = NULL;
380   if (v3dn->fx_settings.dof) {
381     v3dn->fx_settings.dof = MEM_dupallocN(v3do->fx_settings.dof);
382   }
383   if (v3dn->fx_settings.ssao) {
384     v3dn->fx_settings.ssao = MEM_dupallocN(v3do->fx_settings.ssao);
385   }
386
387   return (SpaceLink *)v3dn;
388 }
389
390 /* add handlers, stuff you only do once or on area/region changes */
391 static void view3d_main_region_init(wmWindowManager *wm, ARegion *ar)
392 {
393   ListBase *lb;
394   wmKeyMap *keymap;
395
396   /* object ops. */
397
398   /* important to be before Pose keymap since they can both be enabled at once */
399   keymap = WM_keymap_ensure(wm->defaultconf, "Face Mask", 0, 0);
400   WM_event_add_keymap_handler(&ar->handlers, keymap);
401
402   keymap = WM_keymap_ensure(wm->defaultconf, "Weight Paint Vertex Selection", 0, 0);
403   WM_event_add_keymap_handler(&ar->handlers, keymap);
404
405   /* pose is not modal, operator poll checks for this */
406   keymap = WM_keymap_ensure(wm->defaultconf, "Pose", 0, 0);
407   WM_event_add_keymap_handler(&ar->handlers, keymap);
408
409   keymap = WM_keymap_ensure(wm->defaultconf, "Object Mode", 0, 0);
410   WM_event_add_keymap_handler(&ar->handlers, keymap);
411
412   keymap = WM_keymap_ensure(wm->defaultconf, "Paint Curve", 0, 0);
413   WM_event_add_keymap_handler(&ar->handlers, keymap);
414
415   keymap = WM_keymap_ensure(wm->defaultconf, "Curve", 0, 0);
416   WM_event_add_keymap_handler(&ar->handlers, keymap);
417
418   keymap = WM_keymap_ensure(wm->defaultconf, "Image Paint", 0, 0);
419   WM_event_add_keymap_handler(&ar->handlers, keymap);
420
421   keymap = WM_keymap_ensure(wm->defaultconf, "Vertex Paint", 0, 0);
422   WM_event_add_keymap_handler(&ar->handlers, keymap);
423
424   keymap = WM_keymap_ensure(wm->defaultconf, "Weight Paint", 0, 0);
425   WM_event_add_keymap_handler(&ar->handlers, keymap);
426
427   keymap = WM_keymap_ensure(wm->defaultconf, "Sculpt", 0, 0);
428   WM_event_add_keymap_handler(&ar->handlers, keymap);
429
430   keymap = WM_keymap_ensure(wm->defaultconf, "Mesh", 0, 0);
431   WM_event_add_keymap_handler(&ar->handlers, keymap);
432
433   keymap = WM_keymap_ensure(wm->defaultconf, "Curve", 0, 0);
434   WM_event_add_keymap_handler(&ar->handlers, keymap);
435
436   keymap = WM_keymap_ensure(wm->defaultconf, "Armature", 0, 0);
437   WM_event_add_keymap_handler(&ar->handlers, keymap);
438
439   keymap = WM_keymap_ensure(wm->defaultconf, "Pose", 0, 0);
440   WM_event_add_keymap_handler(&ar->handlers, keymap);
441
442   keymap = WM_keymap_ensure(wm->defaultconf, "Metaball", 0, 0);
443   WM_event_add_keymap_handler(&ar->handlers, keymap);
444
445   keymap = WM_keymap_ensure(wm->defaultconf, "Lattice", 0, 0);
446   WM_event_add_keymap_handler(&ar->handlers, keymap);
447
448   keymap = WM_keymap_ensure(wm->defaultconf, "Particle", 0, 0);
449   WM_event_add_keymap_handler(&ar->handlers, keymap);
450
451   /* editfont keymap swallows all... */
452   keymap = WM_keymap_ensure(wm->defaultconf, "Font", 0, 0);
453   WM_event_add_keymap_handler(&ar->handlers, keymap);
454
455   keymap = WM_keymap_ensure(wm->defaultconf, "Object Non-modal", 0, 0);
456   WM_event_add_keymap_handler(&ar->handlers, keymap);
457
458   keymap = WM_keymap_ensure(wm->defaultconf, "Frames", 0, 0);
459   WM_event_add_keymap_handler(&ar->handlers, keymap);
460
461   /* own keymap, last so modes can override it */
462   keymap = WM_keymap_ensure(wm->defaultconf, "3D View Generic", SPACE_VIEW3D, 0);
463   WM_event_add_keymap_handler(&ar->handlers, keymap);
464
465   keymap = WM_keymap_ensure(wm->defaultconf, "3D View", SPACE_VIEW3D, 0);
466   WM_event_add_keymap_handler(&ar->handlers, keymap);
467
468   /* add drop boxes */
469   lb = WM_dropboxmap_find("View3D", SPACE_VIEW3D, RGN_TYPE_WINDOW);
470
471   WM_event_add_dropbox_handler(&ar->handlers, lb);
472 }
473
474 static void view3d_main_region_exit(wmWindowManager *wm, ARegion *ar)
475 {
476   ED_view3d_stop_render_preview(wm, ar);
477 }
478
479 static bool view3d_ob_drop_poll(bContext *UNUSED(C),
480                                 wmDrag *drag,
481                                 const wmEvent *UNUSED(event),
482                                 const char **UNUSED(tooltip))
483 {
484   return WM_drag_ID(drag, ID_OB) != NULL;
485 }
486
487 static bool view3d_collection_drop_poll(bContext *UNUSED(C),
488                                         wmDrag *drag,
489                                         const wmEvent *UNUSED(event),
490                                         const char **UNUSED(tooltip))
491 {
492   return WM_drag_ID(drag, ID_GR) != NULL;
493 }
494
495 static bool view3d_mat_drop_poll(bContext *UNUSED(C),
496                                  wmDrag *drag,
497                                  const wmEvent *UNUSED(event),
498                                  const char **UNUSED(tooltip))
499 {
500   return WM_drag_ID(drag, ID_MA) != NULL;
501 }
502
503 static bool view3d_ima_drop_poll(bContext *UNUSED(C),
504                                  wmDrag *drag,
505                                  const wmEvent *UNUSED(event),
506                                  const char **UNUSED(tooltip))
507 {
508   if (drag->type == WM_DRAG_PATH) {
509     /* rule might not work? */
510     return (ELEM(drag->icon, 0, ICON_FILE_IMAGE, ICON_FILE_MOVIE));
511   }
512   else {
513     return WM_drag_ID(drag, ID_IM) != NULL;
514   }
515 }
516
517 static bool view3d_ima_bg_is_camera_view(bContext *C)
518 {
519   RegionView3D *rv3d = CTX_wm_region_view3d(C);
520   if ((rv3d && (rv3d->persp == RV3D_CAMOB))) {
521     View3D *v3d = CTX_wm_view3d(C);
522     if (v3d && v3d->camera && v3d->camera->type == OB_CAMERA) {
523       return true;
524     }
525   }
526   return false;
527 }
528
529 static bool view3d_ima_bg_drop_poll(bContext *C,
530                                     wmDrag *drag,
531                                     const wmEvent *event,
532                                     const char **tooltip)
533 {
534   if (!view3d_ima_drop_poll(C, drag, event, tooltip)) {
535     return false;
536   }
537
538   if (ED_view3d_is_object_under_cursor(C, event->mval)) {
539     return false;
540   }
541
542   return view3d_ima_bg_is_camera_view(C);
543 }
544
545 static bool view3d_ima_empty_drop_poll(bContext *C,
546                                        wmDrag *drag,
547                                        const wmEvent *event,
548                                        const char **tooltip)
549 {
550   if (!view3d_ima_drop_poll(C, drag, event, tooltip)) {
551     return false;
552   }
553
554   Object *ob = ED_view3d_give_object_under_cursor(C, event->mval);
555
556   if (ob == NULL) {
557     return true;
558   }
559
560   if (ob->type == OB_EMPTY && ob->empty_drawtype == OB_EMPTY_IMAGE) {
561     return true;
562   }
563
564   return false;
565 }
566
567 static void view3d_ob_drop_copy(wmDrag *drag, wmDropBox *drop)
568 {
569   ID *id = WM_drag_ID(drag, ID_OB);
570
571   RNA_string_set(drop->ptr, "name", id->name + 2);
572 }
573
574 static void view3d_collection_drop_copy(wmDrag *drag, wmDropBox *drop)
575 {
576   ID *id = WM_drag_ID(drag, ID_GR);
577
578   drop->opcontext = WM_OP_EXEC_DEFAULT;
579   RNA_string_set(drop->ptr, "name", id->name + 2);
580 }
581
582 static void view3d_id_drop_copy(wmDrag *drag, wmDropBox *drop)
583 {
584   ID *id = WM_drag_ID(drag, 0);
585
586   RNA_string_set(drop->ptr, "name", id->name + 2);
587 }
588
589 static void view3d_id_path_drop_copy(wmDrag *drag, wmDropBox *drop)
590 {
591   ID *id = WM_drag_ID(drag, 0);
592
593   if (id) {
594     RNA_string_set(drop->ptr, "name", id->name + 2);
595     RNA_struct_property_unset(drop->ptr, "filepath");
596   }
597   else if (drag->path[0]) {
598     RNA_string_set(drop->ptr, "filepath", drag->path);
599     RNA_struct_property_unset(drop->ptr, "image");
600   }
601 }
602
603 static void view3d_lightcache_update(bContext *C)
604 {
605   PointerRNA op_ptr;
606
607   Scene *scene = CTX_data_scene(C);
608
609   if (strcmp(scene->r.engine, RE_engine_id_BLENDER_EEVEE) != 0) {
610     /* Only do auto bake if eevee is the active engine */
611     return;
612   }
613
614   WM_operator_properties_create(&op_ptr, "SCENE_OT_light_cache_bake");
615   RNA_int_set(&op_ptr, "delay", 200);
616   RNA_enum_set_identifier(C, &op_ptr, "subset", "DIRTY");
617
618   WM_operator_name_call(C, "SCENE_OT_light_cache_bake", WM_OP_INVOKE_DEFAULT, &op_ptr);
619
620   WM_operator_properties_free(&op_ptr);
621 }
622
623 /* region dropbox definition */
624 static void view3d_dropboxes(void)
625 {
626   ListBase *lb = WM_dropboxmap_find("View3D", SPACE_VIEW3D, RGN_TYPE_WINDOW);
627
628   WM_dropbox_add(lb, "OBJECT_OT_add_named", view3d_ob_drop_poll, view3d_ob_drop_copy);
629   WM_dropbox_add(lb, "OBJECT_OT_drop_named_material", view3d_mat_drop_poll, view3d_id_drop_copy);
630   WM_dropbox_add(
631       lb, "VIEW3D_OT_background_image_add", view3d_ima_bg_drop_poll, view3d_id_path_drop_copy);
632   WM_dropbox_add(
633       lb, "OBJECT_OT_drop_named_image", view3d_ima_empty_drop_poll, view3d_id_path_drop_copy);
634   WM_dropbox_add(lb,
635                  "OBJECT_OT_collection_instance_add",
636                  view3d_collection_drop_poll,
637                  view3d_collection_drop_copy);
638 }
639
640 static void view3d_widgets(void)
641 {
642   wmGizmoMapType *gzmap_type = WM_gizmomaptype_ensure(
643       &(const struct wmGizmoMapType_Params){SPACE_VIEW3D, RGN_TYPE_WINDOW});
644
645   WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_xform_gizmo_context);
646   WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_light_spot);
647   WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_light_area);
648   WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_light_target);
649   WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_force_field);
650   WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_camera);
651   WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_camera_view);
652   WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_empty_image);
653   WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_armature_spline);
654
655   WM_gizmogrouptype_append(VIEW3D_GGT_xform_gizmo);
656   WM_gizmogrouptype_append(VIEW3D_GGT_xform_cage);
657   WM_gizmogrouptype_append(VIEW3D_GGT_xform_shear);
658   WM_gizmogrouptype_append(VIEW3D_GGT_xform_extrude);
659   WM_gizmogrouptype_append(VIEW3D_GGT_mesh_preselect_elem);
660   WM_gizmogrouptype_append(VIEW3D_GGT_mesh_preselect_edgering);
661
662   WM_gizmogrouptype_append(VIEW3D_GGT_ruler);
663   WM_gizmotype_append(VIEW3D_GT_ruler_item);
664
665   WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_navigate);
666   WM_gizmotype_append(VIEW3D_GT_navigate_rotate);
667 }
668
669 /* type callback, not region itself */
670 static void view3d_main_region_free(ARegion *ar)
671 {
672   RegionView3D *rv3d = ar->regiondata;
673
674   if (rv3d) {
675     if (rv3d->localvd) {
676       MEM_freeN(rv3d->localvd);
677     }
678     if (rv3d->clipbb) {
679       MEM_freeN(rv3d->clipbb);
680     }
681
682     if (rv3d->render_engine) {
683       RE_engine_free(rv3d->render_engine);
684     }
685
686     if (rv3d->depths) {
687       if (rv3d->depths->depths) {
688         MEM_freeN(rv3d->depths->depths);
689       }
690       MEM_freeN(rv3d->depths);
691     }
692     if (rv3d->sms) {
693       MEM_freeN(rv3d->sms);
694     }
695
696     MEM_freeN(rv3d);
697     ar->regiondata = NULL;
698   }
699 }
700
701 /* copy regiondata */
702 static void *view3d_main_region_duplicate(void *poin)
703 {
704   if (poin) {
705     RegionView3D *rv3d = poin, *new;
706
707     new = MEM_dupallocN(rv3d);
708     if (rv3d->localvd) {
709       new->localvd = MEM_dupallocN(rv3d->localvd);
710     }
711     if (rv3d->clipbb) {
712       new->clipbb = MEM_dupallocN(rv3d->clipbb);
713     }
714
715     new->depths = NULL;
716     new->render_engine = NULL;
717     new->sms = NULL;
718     new->smooth_timer = NULL;
719
720     return new;
721   }
722   return NULL;
723 }
724
725 static void view3d_main_region_listener(
726     wmWindow *UNUSED(win), ScrArea *sa, ARegion *ar, wmNotifier *wmn, const Scene *scene)
727 {
728   View3D *v3d = sa->spacedata.first;
729   RegionView3D *rv3d = ar->regiondata;
730   wmGizmoMap *gzmap = ar->gizmo_map;
731
732   /* context changes */
733   switch (wmn->category) {
734     case NC_WM:
735       if (ELEM(wmn->data, ND_UNDO)) {
736         WM_gizmomap_tag_refresh(gzmap);
737       }
738       break;
739     case NC_ANIMATION:
740       switch (wmn->data) {
741         case ND_KEYFRAME_PROP:
742         case ND_NLA_ACTCHANGE:
743           ED_region_tag_redraw(ar);
744           break;
745         case ND_NLA:
746         case ND_KEYFRAME:
747           if (ELEM(wmn->action, NA_EDITED, NA_ADDED, NA_REMOVED)) {
748             ED_region_tag_redraw(ar);
749           }
750           break;
751         case ND_ANIMCHAN:
752           if (ELEM(wmn->action, NA_EDITED, NA_ADDED, NA_REMOVED, NA_SELECTED)) {
753             ED_region_tag_redraw(ar);
754           }
755           break;
756       }
757       break;
758     case NC_SCENE:
759       switch (wmn->data) {
760         case ND_SCENEBROWSE:
761         case ND_LAYER_CONTENT:
762           ED_region_tag_redraw(ar);
763           WM_gizmomap_tag_refresh(gzmap);
764           break;
765         case ND_LAYER:
766           if (wmn->reference) {
767             BKE_screen_view3d_sync(v3d, wmn->reference);
768           }
769           ED_region_tag_redraw(ar);
770           WM_gizmomap_tag_refresh(gzmap);
771           break;
772         case ND_OB_ACTIVE:
773         case ND_OB_SELECT:
774           ATTR_FALLTHROUGH;
775         case ND_FRAME:
776         case ND_TRANSFORM:
777         case ND_OB_VISIBLE:
778         case ND_RENDER_OPTIONS:
779         case ND_MARKERS:
780         case ND_MODE:
781           ED_region_tag_redraw(ar);
782           WM_gizmomap_tag_refresh(gzmap);
783           break;
784         case ND_WORLD:
785           /* handled by space_view3d_listener() for v3d access */
786           break;
787         case ND_DRAW_RENDER_VIEWPORT: {
788           if (v3d->camera && (scene == wmn->reference)) {
789             if (rv3d->persp == RV3D_CAMOB) {
790               ED_region_tag_redraw(ar);
791             }
792           }
793           break;
794         }
795       }
796       if (wmn->action == NA_EDITED) {
797         ED_region_tag_redraw(ar);
798       }
799       break;
800     case NC_OBJECT:
801       switch (wmn->data) {
802         case ND_BONE_ACTIVE:
803         case ND_BONE_SELECT:
804         case ND_TRANSFORM:
805         case ND_POSE:
806         case ND_DRAW:
807         case ND_MODIFIER:
808         case ND_CONSTRAINT:
809         case ND_KEYS:
810         case ND_PARTICLE:
811         case ND_POINTCACHE:
812         case ND_LOD:
813           ED_region_tag_redraw(ar);
814           WM_gizmomap_tag_refresh(gzmap);
815           break;
816       }
817       switch (wmn->action) {
818         case NA_ADDED:
819           ED_region_tag_redraw(ar);
820           break;
821       }
822       break;
823     case NC_GEOM:
824       switch (wmn->data) {
825         case ND_SELECT: {
826           WM_gizmomap_tag_refresh(gzmap);
827           ATTR_FALLTHROUGH;
828         }
829         case ND_DATA:
830         case ND_VERTEX_GROUP:
831           ED_region_tag_redraw(ar);
832           break;
833       }
834       switch (wmn->action) {
835         case NA_EDITED:
836           ED_region_tag_redraw(ar);
837           break;
838       }
839       break;
840     case NC_CAMERA:
841       switch (wmn->data) {
842         case ND_DRAW_RENDER_VIEWPORT: {
843           if (v3d->camera && (v3d->camera->data == wmn->reference)) {
844             if (rv3d->persp == RV3D_CAMOB) {
845               ED_region_tag_redraw(ar);
846             }
847           }
848           break;
849         }
850       }
851       break;
852     case NC_GROUP:
853       /* all group ops for now */
854       ED_region_tag_redraw(ar);
855       break;
856     case NC_BRUSH:
857       switch (wmn->action) {
858         case NA_EDITED:
859           ED_region_tag_redraw_overlay(ar);
860           break;
861         case NA_SELECTED:
862           /* used on brush changes - needed because 3d cursor
863            * has to be drawn if clone brush is selected */
864           ED_region_tag_redraw(ar);
865           break;
866       }
867       break;
868     case NC_MATERIAL:
869       switch (wmn->data) {
870         case ND_SHADING:
871         case ND_NODES:
872           /* TODO(sergey) This is a bit too much updates, but needed to
873            * have proper material drivers update in the viewport.
874            *
875            * How to solve?
876            */
877           ED_region_tag_redraw(ar);
878           break;
879         case ND_SHADING_DRAW:
880         case ND_SHADING_LINKS:
881           ED_region_tag_redraw(ar);
882           break;
883       }
884       break;
885     case NC_WORLD:
886       switch (wmn->data) {
887         case ND_WORLD_DRAW:
888           /* handled by space_view3d_listener() for v3d access */
889           break;
890         case ND_WORLD:
891           /* Needed for updating world materials */
892           ED_region_tag_redraw(ar);
893           break;
894       }
895       break;
896     case NC_LAMP:
897       switch (wmn->data) {
898         case ND_LIGHTING:
899           /* TODO(sergey): This is a bit too much, but needed to
900            * handle updates from new depsgraph.
901            */
902           ED_region_tag_redraw(ar);
903           break;
904         case ND_LIGHTING_DRAW:
905           ED_region_tag_redraw(ar);
906           WM_gizmomap_tag_refresh(gzmap);
907           break;
908       }
909       break;
910     case NC_LIGHTPROBE:
911       ED_area_tag_refresh(sa);
912       break;
913     case NC_IMAGE:
914       /* this could be more fine grained checks if we had
915        * more context than just the region */
916       ED_region_tag_redraw(ar);
917       break;
918     case NC_TEXTURE:
919       /* same as above */
920       ED_region_tag_redraw(ar);
921       break;
922     case NC_MOVIECLIP:
923       if (wmn->data == ND_DISPLAY || wmn->action == NA_EDITED) {
924         ED_region_tag_redraw(ar);
925       }
926       break;
927     case NC_SPACE:
928       if (wmn->data == ND_SPACE_VIEW3D) {
929         if (wmn->subtype == NS_VIEW3D_GPU) {
930           rv3d->rflag |= RV3D_GPULIGHT_UPDATE;
931         }
932         ED_region_tag_redraw(ar);
933         WM_gizmomap_tag_refresh(gzmap);
934       }
935       break;
936     case NC_ID:
937       if (wmn->action == NA_RENAME) {
938         ED_region_tag_redraw(ar);
939       }
940       break;
941     case NC_SCREEN:
942       switch (wmn->data) {
943         case ND_ANIMPLAY:
944         case ND_SKETCH:
945           ED_region_tag_redraw(ar);
946           break;
947         case ND_LAYOUTBROWSE:
948         case ND_LAYOUTDELETE:
949         case ND_LAYOUTSET:
950           WM_gizmomap_tag_refresh(gzmap);
951           ED_region_tag_redraw(ar);
952           break;
953         case ND_LAYER:
954           ED_region_tag_redraw(ar);
955           break;
956       }
957
958       break;
959     case NC_GPENCIL:
960       if (wmn->data == ND_DATA || ELEM(wmn->action, NA_EDITED, NA_SELECTED)) {
961         ED_region_tag_redraw(ar);
962       }
963       break;
964   }
965 }
966
967 static void view3d_main_region_message_subscribe(const struct bContext *C,
968                                                  struct WorkSpace *UNUSED(workspace),
969                                                  struct Scene *UNUSED(scene),
970                                                  struct bScreen *UNUSED(screen),
971                                                  struct ScrArea *sa,
972                                                  struct ARegion *ar,
973                                                  struct wmMsgBus *mbus)
974 {
975   /* Developer note: there are many properties that impact 3D view drawing,
976    * so instead of subscribing to individual properties, just subscribe to types
977    * accepting some redundant redraws.
978    *
979    * For other space types we might try avoid this, keep the 3D view as an exceptional case! */
980   wmMsgParams_RNA msg_key_params = {{{0}}};
981
982   /* Only subscribe to types. */
983   StructRNA *type_array[] = {
984       &RNA_Window,
985
986       /* These object have properties that impact drawing. */
987       &RNA_AreaLight,
988       &RNA_Camera,
989       &RNA_Light,
990       &RNA_Speaker,
991       &RNA_SunLight,
992
993       /* General types the 3D view depends on. */
994       &RNA_Object,
995       &RNA_UnitSettings, /* grid-floor */
996
997       &RNA_View3DOverlay,
998       &RNA_View3DShading,
999       &RNA_World,
1000   };
1001
1002   wmMsgSubscribeValue msg_sub_value_region_tag_redraw = {
1003       .owner = ar,
1004       .user_data = ar,
1005       .notify = ED_region_do_msg_notify_tag_redraw,
1006   };
1007
1008   for (int i = 0; i < ARRAY_SIZE(type_array); i++) {
1009     msg_key_params.ptr.type = type_array[i];
1010     WM_msg_subscribe_rna_params(mbus, &msg_key_params, &msg_sub_value_region_tag_redraw, __func__);
1011   }
1012
1013   /* Subscribe to a handful of other properties. */
1014   RegionView3D *rv3d = ar->regiondata;
1015
1016   WM_msg_subscribe_rna_anon_prop(mbus, RenderSettings, engine, &msg_sub_value_region_tag_redraw);
1017   WM_msg_subscribe_rna_anon_prop(
1018       mbus, RenderSettings, resolution_x, &msg_sub_value_region_tag_redraw);
1019   WM_msg_subscribe_rna_anon_prop(
1020       mbus, RenderSettings, resolution_y, &msg_sub_value_region_tag_redraw);
1021   WM_msg_subscribe_rna_anon_prop(
1022       mbus, RenderSettings, pixel_aspect_x, &msg_sub_value_region_tag_redraw);
1023   WM_msg_subscribe_rna_anon_prop(
1024       mbus, RenderSettings, pixel_aspect_y, &msg_sub_value_region_tag_redraw);
1025   if (rv3d->persp == RV3D_CAMOB) {
1026     WM_msg_subscribe_rna_anon_prop(
1027         mbus, RenderSettings, use_border, &msg_sub_value_region_tag_redraw);
1028   }
1029
1030   WM_msg_subscribe_rna_anon_type(mbus, SceneEEVEE, &msg_sub_value_region_tag_redraw);
1031   WM_msg_subscribe_rna_anon_type(mbus, SceneDisplay, &msg_sub_value_region_tag_redraw);
1032   WM_msg_subscribe_rna_anon_type(mbus, ObjectDisplay, &msg_sub_value_region_tag_redraw);
1033
1034   ViewLayer *view_layer = CTX_data_view_layer(C);
1035   Object *obact = OBACT(view_layer);
1036   if (obact != NULL) {
1037     switch (obact->mode) {
1038       case OB_MODE_PARTICLE_EDIT:
1039         WM_msg_subscribe_rna_anon_type(mbus, ParticleEdit, &msg_sub_value_region_tag_redraw);
1040         break;
1041       default:
1042         break;
1043     }
1044   }
1045
1046   {
1047     wmMsgSubscribeValue msg_sub_value_region_tag_refresh = {
1048         .owner = ar,
1049         .user_data = sa,
1050         .notify = WM_toolsystem_do_msg_notify_tag_refresh,
1051     };
1052     WM_msg_subscribe_rna_anon_prop(mbus, Object, mode, &msg_sub_value_region_tag_refresh);
1053     WM_msg_subscribe_rna_anon_prop(mbus, LayerObjects, active, &msg_sub_value_region_tag_refresh);
1054   }
1055 }
1056
1057 /* concept is to retrieve cursor type context-less */
1058 static void view3d_main_region_cursor(wmWindow *win, ScrArea *sa, ARegion *ar)
1059 {
1060   if (WM_cursor_set_from_tool(win, sa, ar)) {
1061     return;
1062   }
1063
1064   ViewLayer *view_layer = WM_window_get_active_view_layer(win);
1065   Object *obedit = OBEDIT_FROM_VIEW_LAYER(view_layer);
1066   if (obedit) {
1067     WM_cursor_set(win, CURSOR_EDIT);
1068   }
1069   else {
1070     WM_cursor_set(win, CURSOR_STD);
1071   }
1072 }
1073
1074 /* add handlers, stuff you only do once or on area/region changes */
1075 static void view3d_header_region_init(wmWindowManager *wm, ARegion *ar)
1076 {
1077   wmKeyMap *keymap = WM_keymap_ensure(wm->defaultconf, "3D View Generic", SPACE_VIEW3D, 0);
1078
1079   WM_event_add_keymap_handler(&ar->handlers, keymap);
1080
1081   ED_region_header_init(ar);
1082 }
1083
1084 static void view3d_header_region_draw(const bContext *C, ARegion *ar)
1085 {
1086   ED_region_header(C, ar);
1087 }
1088
1089 static void view3d_header_region_listener(wmWindow *UNUSED(win),
1090                                           ScrArea *UNUSED(sa),
1091                                           ARegion *ar,
1092                                           wmNotifier *wmn,
1093                                           const Scene *UNUSED(scene))
1094 {
1095   /* context changes */
1096   switch (wmn->category) {
1097     case NC_SCENE:
1098       switch (wmn->data) {
1099         case ND_FRAME:
1100         case ND_OB_ACTIVE:
1101         case ND_OB_SELECT:
1102         case ND_OB_VISIBLE:
1103         case ND_MODE:
1104         case ND_LAYER:
1105         case ND_TOOLSETTINGS:
1106         case ND_LAYER_CONTENT:
1107         case ND_RENDER_OPTIONS:
1108           ED_region_tag_redraw(ar);
1109           break;
1110       }
1111       break;
1112     case NC_SPACE:
1113       if (wmn->data == ND_SPACE_VIEW3D) {
1114         ED_region_tag_redraw(ar);
1115       }
1116       break;
1117     case NC_GPENCIL:
1118       if (wmn->data & ND_GPENCIL_EDITMODE) {
1119         ED_region_tag_redraw(ar);
1120       }
1121       break;
1122   }
1123 }
1124
1125 static void view3d_header_region_message_subscribe(const struct bContext *UNUSED(C),
1126                                                    struct WorkSpace *UNUSED(workspace),
1127                                                    struct Scene *UNUSED(scene),
1128                                                    struct bScreen *UNUSED(screen),
1129                                                    struct ScrArea *UNUSED(sa),
1130                                                    struct ARegion *ar,
1131                                                    struct wmMsgBus *mbus)
1132 {
1133   wmMsgParams_RNA msg_key_params = {{{0}}};
1134
1135   /* Only subscribe to types. */
1136   StructRNA *type_array[] = {
1137       &RNA_View3DShading,
1138   };
1139
1140   wmMsgSubscribeValue msg_sub_value_region_tag_redraw = {
1141       .owner = ar,
1142       .user_data = ar,
1143       .notify = ED_region_do_msg_notify_tag_redraw,
1144   };
1145
1146   for (int i = 0; i < ARRAY_SIZE(type_array); i++) {
1147     msg_key_params.ptr.type = type_array[i];
1148     WM_msg_subscribe_rna_params(mbus, &msg_key_params, &msg_sub_value_region_tag_redraw, __func__);
1149   }
1150 }
1151
1152 /* add handlers, stuff you only do once or on area/region changes */
1153 static void view3d_buttons_region_init(wmWindowManager *wm, ARegion *ar)
1154 {
1155   wmKeyMap *keymap;
1156
1157   ED_region_panels_init(wm, ar);
1158
1159   keymap = WM_keymap_ensure(wm->defaultconf, "3D View Generic", SPACE_VIEW3D, 0);
1160   WM_event_add_keymap_handler(&ar->handlers, keymap);
1161 }
1162
1163 static void view3d_buttons_region_draw(const bContext *C, ARegion *ar)
1164 {
1165   ED_region_panels_ex(C, ar, (const char *[]){CTX_data_mode_string(C), NULL}, -1, true);
1166 }
1167
1168 static void view3d_buttons_region_listener(wmWindow *UNUSED(win),
1169                                            ScrArea *UNUSED(sa),
1170                                            ARegion *ar,
1171                                            wmNotifier *wmn,
1172                                            const Scene *UNUSED(scene))
1173 {
1174   /* context changes */
1175   switch (wmn->category) {
1176     case NC_ANIMATION:
1177       switch (wmn->data) {
1178         case ND_KEYFRAME_PROP:
1179         case ND_NLA_ACTCHANGE:
1180           ED_region_tag_redraw(ar);
1181           break;
1182         case ND_NLA:
1183         case ND_KEYFRAME:
1184           if (ELEM(wmn->action, NA_EDITED, NA_ADDED, NA_REMOVED)) {
1185             ED_region_tag_redraw(ar);
1186           }
1187           break;
1188       }
1189       break;
1190     case NC_SCENE:
1191       switch (wmn->data) {
1192         case ND_FRAME:
1193         case ND_OB_ACTIVE:
1194         case ND_OB_SELECT:
1195         case ND_OB_VISIBLE:
1196         case ND_MODE:
1197         case ND_LAYER:
1198         case ND_LAYER_CONTENT:
1199         case ND_TOOLSETTINGS:
1200           ED_region_tag_redraw(ar);
1201           break;
1202       }
1203       switch (wmn->action) {
1204         case NA_EDITED:
1205           ED_region_tag_redraw(ar);
1206           break;
1207       }
1208       break;
1209     case NC_OBJECT:
1210       switch (wmn->data) {
1211         case ND_BONE_ACTIVE:
1212         case ND_BONE_SELECT:
1213         case ND_TRANSFORM:
1214         case ND_POSE:
1215         case ND_DRAW:
1216         case ND_KEYS:
1217         case ND_MODIFIER:
1218           ED_region_tag_redraw(ar);
1219           break;
1220       }
1221       break;
1222     case NC_GEOM:
1223       switch (wmn->data) {
1224         case ND_DATA:
1225         case ND_VERTEX_GROUP:
1226         case ND_SELECT:
1227           ED_region_tag_redraw(ar);
1228           break;
1229       }
1230       if (wmn->action == NA_EDITED) {
1231         ED_region_tag_redraw(ar);
1232       }
1233       break;
1234     case NC_TEXTURE:
1235     case NC_MATERIAL:
1236       /* for brush textures */
1237       ED_region_tag_redraw(ar);
1238       break;
1239     case NC_BRUSH:
1240       /* NA_SELECTED is used on brush changes */
1241       if (ELEM(wmn->action, NA_EDITED, NA_SELECTED)) {
1242         ED_region_tag_redraw(ar);
1243       }
1244       break;
1245     case NC_SPACE:
1246       if (wmn->data == ND_SPACE_VIEW3D) {
1247         ED_region_tag_redraw(ar);
1248       }
1249       break;
1250     case NC_ID:
1251       if (wmn->action == NA_RENAME) {
1252         ED_region_tag_redraw(ar);
1253       }
1254       break;
1255     case NC_GPENCIL:
1256       if ((wmn->data & (ND_DATA | ND_GPENCIL_EDITMODE)) || (wmn->action == NA_EDITED)) {
1257         ED_region_tag_redraw(ar);
1258       }
1259       break;
1260     case NC_IMAGE:
1261       /* Update for the image layers in texture paint. */
1262       if (wmn->action == NA_EDITED) {
1263         ED_region_tag_redraw(ar);
1264       }
1265       break;
1266   }
1267 }
1268
1269 /* add handlers, stuff you only do once or on area/region changes */
1270 static void view3d_tools_region_init(wmWindowManager *wm, ARegion *ar)
1271 {
1272   wmKeyMap *keymap;
1273
1274   ED_region_panels_init(wm, ar);
1275
1276   keymap = WM_keymap_ensure(wm->defaultconf, "3D View Generic", SPACE_VIEW3D, 0);
1277   WM_event_add_keymap_handler(&ar->handlers, keymap);
1278 }
1279
1280 static void view3d_tools_region_draw(const bContext *C, ARegion *ar)
1281 {
1282   ED_region_panels_ex(C, ar, (const char *[]){CTX_data_mode_string(C), NULL}, -1, true);
1283 }
1284
1285 /* area (not region) level listener */
1286 static void space_view3d_listener(wmWindow *UNUSED(win),
1287                                   ScrArea *sa,
1288                                   struct wmNotifier *wmn,
1289                                   Scene *UNUSED(scene))
1290 {
1291   View3D *v3d = sa->spacedata.first;
1292
1293   /* context changes */
1294   switch (wmn->category) {
1295     case NC_SCENE:
1296       switch (wmn->data) {
1297         case ND_WORLD:
1298           if (v3d->flag2 & V3D_HIDE_OVERLAYS) {
1299             ED_area_tag_redraw_regiontype(sa, RGN_TYPE_WINDOW);
1300           }
1301           break;
1302       }
1303       break;
1304     case NC_WORLD:
1305       switch (wmn->data) {
1306         case ND_WORLD_DRAW:
1307         case ND_WORLD:
1308           if (v3d->shading.background_type == V3D_SHADING_BACKGROUND_WORLD) {
1309             ED_area_tag_redraw_regiontype(sa, RGN_TYPE_WINDOW);
1310           }
1311           break;
1312       }
1313       break;
1314     case NC_MATERIAL:
1315       switch (wmn->data) {
1316         case ND_NODES:
1317           if (v3d->shading.type == OB_TEXTURE) {
1318             ED_area_tag_redraw_regiontype(sa, RGN_TYPE_WINDOW);
1319           }
1320           break;
1321       }
1322       break;
1323   }
1324 }
1325
1326 static void space_view3d_refresh(const bContext *C, ScrArea *UNUSED(sa))
1327 {
1328   Scene *scene = CTX_data_scene(C);
1329   LightCache *lcache = scene->eevee.light_cache;
1330
1331   if (lcache && (lcache->flag & LIGHTCACHE_UPDATE_AUTO) != 0) {
1332     lcache->flag &= ~LIGHTCACHE_UPDATE_AUTO;
1333     view3d_lightcache_update((bContext *)C);
1334   }
1335 }
1336
1337 const char *view3d_context_dir[] = {
1338     "active_base",
1339     "active_object",
1340     NULL,
1341 };
1342
1343 static int view3d_context(const bContext *C, const char *member, bContextDataResult *result)
1344 {
1345   /* fallback to the scene layer,
1346    * allows duplicate and other object operators to run outside the 3d view */
1347
1348   if (CTX_data_dir(member)) {
1349     CTX_data_dir_set(result, view3d_context_dir);
1350   }
1351   else if (CTX_data_equals(member, "active_base")) {
1352     Scene *scene = CTX_data_scene(C);
1353     ViewLayer *view_layer = CTX_data_view_layer(C);
1354     if (view_layer->basact) {
1355       Object *ob = view_layer->basact->object;
1356       /* if hidden but in edit mode, we still display, can happen with animation */
1357       if ((view_layer->basact->flag & BASE_VISIBLE) != 0 || (ob->mode & OB_MODE_EDIT)) {
1358         CTX_data_pointer_set(result, &scene->id, &RNA_ObjectBase, view_layer->basact);
1359       }
1360     }
1361
1362     return 1;
1363   }
1364   else if (CTX_data_equals(member, "active_object")) {
1365     ViewLayer *view_layer = CTX_data_view_layer(C);
1366     if (view_layer->basact) {
1367       Object *ob = view_layer->basact->object;
1368       /* if hidden but in edit mode, we still display, can happen with animation */
1369       if ((view_layer->basact->flag & BASE_VISIBLE) != 0 || (ob->mode & OB_MODE_EDIT) != 0) {
1370         CTX_data_id_pointer_set(result, &ob->id);
1371       }
1372     }
1373
1374     return 1;
1375   }
1376   else {
1377     return 0; /* not found */
1378   }
1379
1380   return -1; /* found but not available */
1381 }
1382
1383 static void view3d_id_remap(ScrArea *sa, SpaceLink *slink, ID *old_id, ID *new_id)
1384 {
1385   View3D *v3d;
1386   ARegion *ar;
1387   bool is_local = false;
1388
1389   if (!ELEM(GS(old_id->name), ID_OB, ID_MA, ID_IM, ID_MC)) {
1390     return;
1391   }
1392
1393   for (v3d = (View3D *)slink; v3d; v3d = v3d->localvd, is_local = true) {
1394     if ((ID *)v3d->camera == old_id) {
1395       v3d->camera = (Object *)new_id;
1396       if (!new_id) {
1397         /* 3D view might be inactive, in that case needs to use slink->regionbase */
1398         ListBase *regionbase = (slink == sa->spacedata.first) ? &sa->regionbase :
1399                                                                 &slink->regionbase;
1400         for (ar = regionbase->first; ar; ar = ar->next) {
1401           if (ar->regiontype == RGN_TYPE_WINDOW) {
1402             RegionView3D *rv3d = is_local ? ((RegionView3D *)ar->regiondata)->localvd :
1403                                             ar->regiondata;
1404             if (rv3d && (rv3d->persp == RV3D_CAMOB)) {
1405               rv3d->persp = RV3D_PERSP;
1406             }
1407           }
1408         }
1409       }
1410     }
1411
1412     /* Values in local-view aren't used, see: T52663 */
1413     if (is_local == false) {
1414       if ((ID *)v3d->ob_centre == old_id) {
1415         v3d->ob_centre = (Object *)new_id;
1416         /* Otherwise, bonename may remain valid...
1417          * We could be smart and check this, too? */
1418         if (new_id == NULL) {
1419           v3d->ob_centre_bone[0] = '\0';
1420         }
1421       }
1422     }
1423
1424     if (is_local) {
1425       break;
1426     }
1427   }
1428 }
1429
1430 /* only called once, from space/spacetypes.c */
1431 void ED_spacetype_view3d(void)
1432 {
1433   SpaceType *st = MEM_callocN(sizeof(SpaceType), "spacetype view3d");
1434   ARegionType *art;
1435
1436   st->spaceid = SPACE_VIEW3D;
1437   strncpy(st->name, "View3D", BKE_ST_MAXNAME);
1438
1439   st->new = view3d_new;
1440   st->free = view3d_free;
1441   st->init = view3d_init;
1442   st->listener = space_view3d_listener;
1443   st->refresh = space_view3d_refresh;
1444   st->duplicate = view3d_duplicate;
1445   st->operatortypes = view3d_operatortypes;
1446   st->keymap = view3d_keymap;
1447   st->dropboxes = view3d_dropboxes;
1448   st->gizmos = view3d_widgets;
1449   st->context = view3d_context;
1450   st->id_remap = view3d_id_remap;
1451
1452   /* regions: main window */
1453   art = MEM_callocN(sizeof(ARegionType), "spacetype view3d main region");
1454   art->regionid = RGN_TYPE_WINDOW;
1455   art->keymapflag = ED_KEYMAP_GIZMO | ED_KEYMAP_TOOL | ED_KEYMAP_GPENCIL;
1456   art->draw = view3d_main_region_draw;
1457   art->init = view3d_main_region_init;
1458   art->exit = view3d_main_region_exit;
1459   art->free = view3d_main_region_free;
1460   art->duplicate = view3d_main_region_duplicate;
1461   art->listener = view3d_main_region_listener;
1462   art->message_subscribe = view3d_main_region_message_subscribe;
1463   art->cursor = view3d_main_region_cursor;
1464   art->lock = 1; /* can become flag, see BKE_spacedata_draw_locks */
1465   BLI_addhead(&st->regiontypes, art);
1466
1467   /* regions: listview/buttons */
1468   art = MEM_callocN(sizeof(ARegionType), "spacetype view3d buttons region");
1469   art->regionid = RGN_TYPE_UI;
1470   art->prefsizex = 180; /* XXX */
1471   art->keymapflag = ED_KEYMAP_UI | ED_KEYMAP_FRAMES;
1472   art->listener = view3d_buttons_region_listener;
1473   art->init = view3d_buttons_region_init;
1474   art->draw = view3d_buttons_region_draw;
1475   BLI_addhead(&st->regiontypes, art);
1476
1477   view3d_buttons_register(art);
1478
1479   /* regions: tool(bar) */
1480   art = MEM_callocN(sizeof(ARegionType), "spacetype view3d tools region");
1481   art->regionid = RGN_TYPE_TOOLS;
1482   art->prefsizex = 58; /* XXX */
1483   art->prefsizey = 50; /* XXX */
1484   art->keymapflag = ED_KEYMAP_UI | ED_KEYMAP_FRAMES;
1485   art->listener = view3d_buttons_region_listener;
1486   art->message_subscribe = ED_region_generic_tools_region_message_subscribe;
1487   art->snap_size = ED_region_generic_tools_region_snap_size;
1488   art->init = view3d_tools_region_init;
1489   art->draw = view3d_tools_region_draw;
1490   BLI_addhead(&st->regiontypes, art);
1491
1492   /* regions: header */
1493   art = MEM_callocN(sizeof(ARegionType), "spacetype view3d header region");
1494   art->regionid = RGN_TYPE_HEADER;
1495   art->prefsizey = HEADERY;
1496   art->keymapflag = ED_KEYMAP_UI | ED_KEYMAP_VIEW2D | ED_KEYMAP_FRAMES | ED_KEYMAP_HEADER;
1497   art->listener = view3d_header_region_listener;
1498   art->init = view3d_header_region_init;
1499   art->draw = view3d_header_region_draw;
1500   art->message_subscribe = view3d_header_region_message_subscribe;
1501   BLI_addhead(&st->regiontypes, art);
1502
1503   /* regions: hud */
1504   art = ED_area_type_hud(st->spaceid);
1505   BLI_addhead(&st->regiontypes, art);
1506
1507   BKE_spacetype_register(st);
1508 }