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