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