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