Blender V5.3
space_view3d.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2008 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9/* Allow using deprecated functionality for .blend file I/O. */
10#define DNA_DEPRECATED_ALLOW
11
12#include <array>
13#include <cstring>
14
16#include "DNA_curve_types.h"
19#include "DNA_object_types.h"
20#include "DNA_scene_types.h"
21#include "DNA_view3d_types.h"
22
23#include "MEM_guardedalloc.h"
24
25#include "BLI_listbase.hh"
26#include "BLI_math_matrix.hh"
27#include "BLI_math_matrix_c.hh"
28#include "BLI_math_vector_c.hh"
29#include "BLI_string_utf8.hh"
30#include "BLI_utildefines.hh"
31
32#include "BKE_annotations.h"
33#include "BKE_asset.hh"
34#include "BKE_compositor.hh"
35#include "BKE_context.hh"
36#include "BKE_global.hh"
37#include "BKE_idprop.hh"
38#include "BKE_layer.hh"
39#include "BKE_lib_id.hh"
40#include "BKE_lib_query.hh"
41#include "BKE_lib_remap.hh"
42#include "BKE_library.hh"
43#include "BKE_main.hh"
44#include "BKE_object.hh"
45#include "BKE_scene.hh"
46#include "BKE_screen.hh"
47#include "BKE_vfont.hh"
48#include "BKE_viewer_path.hh"
49
50#include "ED_asset_shelf.hh"
51#include "ED_geometry.hh"
52#include "ED_info.hh"
53#include "ED_object.hh"
54#include "ED_outliner.hh"
55#include "ED_render.hh"
56#include "ED_screen.hh"
57#include "ED_space_api.hh"
58#include "ED_transform.hh"
59#include "ED_undo.hh"
60
61#include "GPU_matrix.hh"
62
63#include "DRW_engine.hh"
64
65#include "WM_api.hh"
66#include "WM_message.hh"
67#include "WM_toolsystem.hh"
68#include "WM_types.hh"
69
70#include "RNA_access.hh"
71
72#include "UI_interface.hh"
73
74#include "BLO_read_write.hh"
75
76#ifdef WITH_PYTHON
77# include "BPY_extern.hh"
78#endif
79
80#include "DEG_depsgraph.hh"
82
83#include "view3d_intern.hh" /* own include */
84#include "view3d_navigate.hh"
85
86namespace blender {
87
88/* ******************** manage regions ********************* */
89
90bool ED_view3d_area_user_region(const ScrArea *area, const View3D *v3d, ARegion **r_region)
91{
92 RegionView3D *rv3d = nullptr;
93 ARegion *region_unlock_user = nullptr;
94 ARegion *region_unlock = nullptr;
95 const ListBaseT<ARegion> *region_list = (v3d == area->spacedata.first_) ? &area->regionbase :
96 &v3d->regionbase;
97
99
100 for (ARegion &region : *region_list) {
101 /* find the first unlocked rv3d */
102 if (region.regiondata && region.regiontype == RGN_TYPE_WINDOW) {
103 rv3d = static_cast<RegionView3D *>(region.regiondata);
104 if ((rv3d->viewlock & RV3D_LOCK_ROTATION) == 0) {
105 region_unlock = &region;
106 if (ELEM(rv3d->persp, RV3D_PERSP, RV3D_CAMOB)) {
107 region_unlock_user = &region;
108 break;
109 }
110 }
111 }
112 }
113
114 /* camera/perspective view get priority when the active region is locked */
115 if (region_unlock_user) {
116 *r_region = region_unlock_user;
117 return true;
118 }
119
120 if (region_unlock) {
121 *r_region = region_unlock;
122 return true;
123 }
124
125 return false;
126}
127
129{
130 /* local viewmat and persmat, to calculate projections */
131 mul_m4_m4m4(rv3d->viewmatob, rv3d->viewmat, ob->object_to_world().ptr());
132 mul_m4_m4m4(rv3d->persmatob, rv3d->persmat, ob->object_to_world().ptr());
133
134 /* initializes object space clipping, speeds up clip tests */
135 ED_view3d_clipping_local(rv3d, ob->object_to_world().ptr());
136}
137
139{
140 ED_view3d_init_mats_rv3d(ob, rv3d);
141
142 /* We have to multiply instead of loading `viewmatob` to make
143 * it work with duplis using display-lists, otherwise it will
144 * override the dupli-matrix. */
145 GPU_matrix_mul(ob->object_to_world().ptr());
146}
147
148#ifndef NDEBUG
150{
151 zero_m4(rv3d->viewmatob);
152 zero_m4(rv3d->persmatob);
153}
154
160#endif
161
163{
164 RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
165
166 if (rv3d->view_render) {
167#ifdef WITH_PYTHON
169#endif
170
172
173#ifdef WITH_PYTHON
175#endif
176
178 }
179
180 /* A bit overkill but this make sure the viewport is reset completely. (fclem) */
181 WM_draw_region_free(region);
182}
183
184void ED_view3d_shade_update(Main *bmain, View3D *v3d, ScrArea *area)
185{
186 wmWindowManager *wm = bmain->wm.first();
187
188 if (v3d->shading.type != OB_RENDER) {
189 for (ARegion &region : area->regionbase) {
190 if ((region.regiontype == RGN_TYPE_WINDOW) && region.regiondata) {
192 }
193 }
194 }
195}
196
197/* ******************** default callbacks for view3d space ***************** */
198
199static SpaceLink *view3d_create(const ScrArea * /*area*/, const Scene *scene)
200{
201 View3D *v3d = MEM_new<View3D>(__func__);
202
203 if (scene) {
204 v3d->camera = scene->camera;
205 }
206
207 /* header */
208 ARegion *region = BKE_area_region_new();
209
210 BLI_addtail(&v3d->regionbase, region);
211 region->regiontype = RGN_TYPE_HEADER;
213
214 /* tool header */
215 region = BKE_area_region_new();
216
217 BLI_addtail(&v3d->regionbase, region);
221
222 /* asset shelf */
223 region = BKE_area_region_new();
224
225 BLI_addtail(&v3d->regionbase, region);
227 region->alignment = RGN_ALIGN_BOTTOM;
228 region->flag |= RGN_FLAG_HIDDEN;
229
230 /* asset shelf header */
231 region = BKE_area_region_new();
232 BLI_addtail(&v3d->regionbase, region);
235
236 /* tool shelf */
237 region = BKE_area_region_new();
238
239 BLI_addtail(&v3d->regionbase, region);
240 region->regiontype = RGN_TYPE_TOOLS;
241 region->alignment = RGN_ALIGN_LEFT;
242 region->flag = RGN_FLAG_HIDDEN;
243
244 /* buttons/list view */
245 region = BKE_area_region_new();
246
247 BLI_addtail(&v3d->regionbase, region);
248 region->regiontype = RGN_TYPE_UI;
249 region->alignment = RGN_ALIGN_RIGHT;
250 region->flag = RGN_FLAG_HIDDEN;
251
252 /* main region */
253 region = BKE_area_region_new();
254
255 BLI_addtail(&v3d->regionbase, region);
256 region->regiontype = RGN_TYPE_WINDOW;
257
258 RegionView3D *rv3d = MEM_new<RegionView3D>("region view3d");
259 rv3d->viewquat[0] = 1.0f;
260 rv3d->persp = RV3D_PERSP;
261 rv3d->view = RV3D_VIEW_USER;
262 rv3d->dist = 10.0;
263 region->regiondata = rv3d;
264
265 return reinterpret_cast<SpaceLink *>(v3d);
266}
267
268/* Doesn't free the space-link itself. */
269static void view3d_free(SpaceLink *sl)
270{
271 View3D *vd = reinterpret_cast<View3D *>(sl);
272
273 if (vd->localvd) {
274 MEM_delete(vd->localvd);
275 }
276
278
281 vd->runtime.properties_storage_free = nullptr;
282 }
283
284 if (vd->shading.prop) {
286 vd->shading.prop = nullptr;
287 }
288
290}
291
292/* spacetype; init callback */
293static void view3d_init(wmWindowManager * /*wm*/, ScrArea * /*area*/) {}
294
295static void view3d_exit(wmWindowManager * /*wm*/, ScrArea *area)
296{
298 View3D *v3d = area->spacedata.first_as<View3D>();
300}
301
303{
304 View3D *v3do = reinterpret_cast<View3D *>(sl);
305 View3D *v3dn = MEM_dupalloc(v3do);
306
307 v3dn->runtime = View3D_Runtime{};
308
309 /* clear or remove stuff from old */
310
311 if (v3dn->localvd) {
312 v3dn->localvd = nullptr;
313 }
314
315 v3dn->local_collections_uid = 0;
317
318 if (v3dn->shading.type == OB_RENDER) {
319 v3dn->shading.type = OB_SOLID;
320 }
321
322 if (v3dn->shading.prop) {
324 }
325
327
328 /* copy or clear inside new stuff */
329
330 return reinterpret_cast<SpaceLink *>(v3dn);
331}
332
333/* add handlers, stuff you only do once or on area/region changes */
335{
336 ListBaseT<wmDropBox> *lb;
337 wmKeyMap *keymap;
338
339 /* object ops. */
340
341 /* important to be before Pose keymap since they can both be enabled at once */
342 keymap = WM_keymap_ensure(wm->runtime->defaultconf,
343 "Paint Face Mask (Weight, Vertex, Texture)",
347
348 keymap = WM_keymap_ensure(wm->runtime->defaultconf,
349 "Paint Vertex Selection (Weight, Vertex)",
353
354 /* Before 'Weight/Vertex Paint' so adding curve points is not overridden. */
355 keymap = WM_keymap_ensure(wm->runtime->defaultconf, "Paint Curve", SPACE_EMPTY, RGN_TYPE_WINDOW);
357
358 /* Before 'Pose' so weight paint menus aren't overridden by pose menus. */
359 keymap = WM_keymap_ensure(
360 wm->runtime->defaultconf, "Weight Paint", SPACE_EMPTY, RGN_TYPE_WINDOW);
362
363 keymap = WM_keymap_ensure(
364 wm->runtime->defaultconf, "Vertex Paint", SPACE_EMPTY, RGN_TYPE_WINDOW);
366
367 keymap = WM_keymap_ensure(
368 wm->runtime->defaultconf, "Grease Pencil Weight Paint", SPACE_EMPTY, RGN_TYPE_WINDOW);
370
371 /* pose is not modal, operator poll checks for this */
372 keymap = WM_keymap_ensure(wm->runtime->defaultconf, "Pose", SPACE_EMPTY, RGN_TYPE_WINDOW);
374
375 keymap = WM_keymap_ensure(wm->runtime->defaultconf, "Object Mode", SPACE_EMPTY, RGN_TYPE_WINDOW);
377
378 keymap = WM_keymap_ensure(wm->runtime->defaultconf, "Curve", SPACE_EMPTY, RGN_TYPE_WINDOW);
380
381 keymap = WM_keymap_ensure(wm->runtime->defaultconf, "Curves", SPACE_EMPTY, RGN_TYPE_WINDOW);
383
384 keymap = WM_keymap_ensure(wm->runtime->defaultconf, "Image Paint", SPACE_EMPTY, RGN_TYPE_WINDOW);
386
387 keymap = WM_keymap_ensure(wm->runtime->defaultconf, "Sculpt", SPACE_EMPTY, RGN_TYPE_WINDOW);
389
390 keymap = WM_keymap_ensure(wm->runtime->defaultconf, "Mesh", SPACE_EMPTY, RGN_TYPE_WINDOW);
392
393 keymap = WM_keymap_ensure(wm->runtime->defaultconf, "Armature", SPACE_EMPTY, RGN_TYPE_WINDOW);
395
396 keymap = WM_keymap_ensure(wm->runtime->defaultconf, "Metaball", SPACE_EMPTY, RGN_TYPE_WINDOW);
398
399 keymap = WM_keymap_ensure(wm->runtime->defaultconf, "Lattice", SPACE_EMPTY, RGN_TYPE_WINDOW);
401
402 keymap = WM_keymap_ensure(wm->runtime->defaultconf, "Particle", SPACE_EMPTY, RGN_TYPE_WINDOW);
404
405 keymap = WM_keymap_ensure(wm->runtime->defaultconf, "Point Cloud", SPACE_EMPTY, RGN_TYPE_WINDOW);
407
408 keymap = WM_keymap_ensure(
409 wm->runtime->defaultconf, "Sculpt Curves", SPACE_EMPTY, RGN_TYPE_WINDOW);
411
412 /* NOTE: Grease Pencil handlers used to be added using #ED_KEYMAP_GPENCIL in
413 * `ed_default_handlers` because it needed to be added to multiple editors (as other editors use
414 * annotations.). But for OB_GREASE_PENCIL, we only need it to register the keymaps for the
415 * 3D View. */
416 keymap = WM_keymap_ensure(
417 wm->runtime->defaultconf, "Grease Pencil Selection", SPACE_EMPTY, RGN_TYPE_WINDOW);
419
420 keymap = WM_keymap_ensure(
421 wm->runtime->defaultconf, "Grease Pencil Edit Mode", SPACE_EMPTY, RGN_TYPE_WINDOW);
423
424 keymap = WM_keymap_ensure(
425 wm->runtime->defaultconf, "Grease Pencil Draw Mode", SPACE_EMPTY, RGN_TYPE_WINDOW);
427
428 keymap = WM_keymap_ensure(
429 wm->runtime->defaultconf, "Grease Pencil Sculpt Mode", SPACE_EMPTY, RGN_TYPE_WINDOW);
431
432 keymap = WM_keymap_ensure(
433 wm->runtime->defaultconf, "Grease Pencil Vertex Paint", SPACE_EMPTY, RGN_TYPE_WINDOW);
435
436 keymap = WM_keymap_ensure(
437 wm->runtime->defaultconf, "Grease Pencil Brush Stroke", SPACE_EMPTY, RGN_TYPE_WINDOW);
439
440 keymap = WM_keymap_ensure(
441 wm->runtime->defaultconf, "Grease Pencil Fill Tool", SPACE_EMPTY, RGN_TYPE_WINDOW);
443
444 /* Edit-font key-map swallows almost all (because of text input). */
445 keymap = WM_keymap_ensure(wm->runtime->defaultconf, "Font", SPACE_EMPTY, RGN_TYPE_WINDOW);
447
448 keymap = WM_keymap_ensure(
449 wm->runtime->defaultconf, "Object Non-modal", SPACE_EMPTY, RGN_TYPE_WINDOW);
451
452 keymap = WM_keymap_ensure(wm->runtime->defaultconf, "Frames", SPACE_EMPTY, RGN_TYPE_WINDOW);
454
455 /* own keymap, last so modes can override it */
456 keymap = WM_keymap_ensure(
457 wm->runtime->defaultconf, "3D View Generic", SPACE_VIEW3D, RGN_TYPE_WINDOW);
459
460 keymap = WM_keymap_ensure(wm->runtime->defaultconf, "3D View", SPACE_VIEW3D, RGN_TYPE_WINDOW);
462
463 /* add drop boxes */
465
467}
468
473
474static void view3d_widgets()
475{
477 wmGizmoMapType *gzmap_type = WM_gizmomaptype_ensure(&params);
478
489 /* TODO(@ideasman42): Not working well enough, disable for now. */
490#if 0
492#endif
493
502
505
507
510}
511
512/* type callback, not region itself */
514{
515 RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
516
517 if (rv3d) {
518 if (rv3d->localvd) {
519 MEM_delete(rv3d->localvd);
520 }
521 if (rv3d->clipbb) {
522 MEM_delete(rv3d->clipbb);
523 }
524
525 if (rv3d->view_render) {
527 }
528
529 if (rv3d->sms) {
530 view3d_smooth_free(rv3d);
531 }
532
533 MEM_delete(rv3d);
534 region->regiondata = nullptr;
535 }
536}
537
538/* copy regiondata */
539static void *view3d_main_region_duplicate(void *poin)
540{
541 if (poin) {
542 RegionView3D *rv3d = static_cast<RegionView3D *>(poin);
543 RegionView3D *new_rv3d;
544
545 new_rv3d = MEM_dupalloc(rv3d);
546 if (rv3d->localvd) {
547 new_rv3d->localvd = MEM_dupalloc(rv3d->localvd);
548 }
549 if (rv3d->clipbb) {
550 new_rv3d->clipbb = MEM_dupalloc(rv3d->clipbb);
551 }
552
553 new_rv3d->view_render = nullptr;
554 new_rv3d->sms = nullptr;
555 new_rv3d->smooth_timer = nullptr;
556
557 return new_rv3d;
558 }
559 return nullptr;
560}
561
562#ifdef WITH_INPUT_IME
563static std::optional<ARegionIMECursorState> view3d_main_region_cursor_ime(
564 wmWindow *win, const ScrArea * /*area*/, const ARegion *region, ARegionIMECursor *r_cursor)
565{
566 /* The position is pending during viewport navigation (orbit, pan, zoom, fly, walk). */
567 const RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
568 if (rv3d->rflag & RV3D_NAVIGATING) {
570 }
571
573 if (!view_layer) {
574 return std::nullopt;
575 }
577 if (!(ob && ob->type == OB_FONT && ob->mode == OB_MODE_EDIT)) {
578 return std::nullopt;
579 }
580
581 const Curve *cu = id_cast<Curve *>(ob->data);
582 const EditFont *ef = cu->editfont;
583 /* `cu->editfont` can be nullptr on Blender startup. */
584 if (!ef) {
585 return std::nullopt;
586 }
587
588 /* Use the lower-left corner of the cursor with a zero width, since the object transform may
589 * rotate it, where an axis-aligned width wouldn't represent it. */
590 const float3 cursor_local = {ef->textcurs[0].x, ef->textcurs[0].y, 0.0f};
591 /* Transform to world space, then project to region coordinates. */
592 const float3 cursor_world = math::transform_point(ob->object_to_world(), cursor_local);
593 float2 cursor_screen;
595 region, cursor_world, cursor_screen, V3D_PROJ_TEST_CLIP_NEAR) != V3D_PROJ_RET_OK)
596 {
597 /* Behind the view, so pending since editing is still active and the view may move back. */
599 }
600
601 const int x = int(cursor_screen[0]);
602 const int y = int(cursor_screen[1]);
603 r_cursor->rect = {
604 .xmin = x,
605 .xmax = x,
606 .ymin = y,
607 .ymax = y + int(UI_UNIT_Y),
608 };
609 r_cursor->font_size = UI_UNIT_Y;
611}
612
613#endif
614
616{
617 wmWindow *window = params->window;
618 ScrArea *area = params->area;
619 ARegion *region = params->region;
620 const wmNotifier *wmn = params->notifier;
621 const Scene *scene = params->scene;
622 View3D *v3d = area->spacedata.first_as<View3D>();
623 RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
624 wmGizmoMap *gzmap = region->runtime->gizmo_map;
625
626 /* context changes */
627 switch (wmn->category) {
628 case NC_WM:
629 if (ELEM(wmn->data, ND_UNDO)) {
631 }
632 else if (ELEM(wmn->data, ND_XR_DATA_CHANGED)) {
633 /* Only cause a redraw if this a VR session mirror. Should more features be added that
634 * require redraws, we could pass something to wmn->reference, e.g. the flag value. */
635 if (v3d->flag & V3D_XR_SESSION_MIRROR) {
636 ED_region_tag_redraw(region);
637 }
638 }
639 break;
640 case NC_ANIMATION:
641 switch (wmn->data) {
642 case ND_KEYFRAME_PROP:
643 case ND_NLA_ACTCHANGE:
644 ED_region_tag_redraw(region);
645 break;
646 case ND_NLA:
647 case ND_KEYFRAME:
648 if (ELEM(wmn->action, NA_EDITED, NA_ADDED, NA_REMOVED)) {
649 ED_region_tag_redraw(region);
650 }
651 break;
652 case ND_ANIMCHAN:
654 ED_region_tag_redraw(region);
655 }
656 break;
657 }
658 break;
659 case NC_SCENE:
660 switch (wmn->data) {
661 case ND_SCENEBROWSE:
662 case ND_LAYER_CONTENT:
663 ED_region_tag_redraw(region);
667 }
668 break;
669 case ND_LAYER:
670 if (wmn->reference) {
671 BKE_screen_view3d_sync(v3d, static_cast<Scene *>(wmn->reference));
672 }
673 ED_region_tag_redraw(region);
675 break;
676 case ND_OB_ACTIVE:
677 case ND_OB_SELECT:
678 [[fallthrough]];
679 case ND_FRAME:
680 case ND_TRANSFORM:
681 case ND_OB_VISIBLE:
683 case ND_MARKERS:
684 case ND_MODE:
685 ED_region_tag_redraw(region);
687 break;
688 case ND_WORLD:
689 /* handled by space_view3d_listener() for v3d access */
690 break;
692 if (v3d->camera && (scene == wmn->reference)) {
693 if (rv3d->persp == RV3D_CAMOB) {
694 ED_region_tag_redraw(region);
695 }
696 }
697 break;
698 }
699 case ND_COMPO_RESULT:
701 ED_region_tag_redraw(region);
702 }
703 break;
704 }
705 if (wmn->action == NA_EDITED) {
706 ED_region_tag_redraw(region);
707 }
708 break;
709 case NC_OBJECT:
710 switch (wmn->data) {
711 case ND_BONE_ACTIVE:
712 case ND_BONE_SELECT:
714 case ND_TRANSFORM:
715 case ND_POSE:
716 case ND_DRAW:
717 case ND_MODIFIER:
718 case ND_SHADERFX:
719 case ND_CONSTRAINT:
720 case ND_KEYS:
721 case ND_PARTICLE:
722 case ND_POINTCACHE:
723 case ND_LOD:
724 ED_region_tag_redraw(region);
726 break;
727 case ND_DRAW_ANIMVIZ:
728 ED_region_tag_redraw(region);
729 break;
730 }
731 switch (wmn->action) {
732 case NA_ADDED:
733 ED_region_tag_redraw(region);
734 break;
735 }
736 break;
737 case NC_GEOM:
738 switch (wmn->data) {
739 case ND_SELECT: {
742 }
743 case ND_DATA:
744 ED_region_tag_redraw(region);
746 break;
747 case ND_VERTEX_GROUP:
748 ED_region_tag_redraw(region);
749 break;
750 }
751 switch (wmn->action) {
752 case NA_EDITED:
753 ED_region_tag_redraw(region);
754 break;
755 }
756 break;
757 case NC_CAMERA:
758 switch (wmn->data) {
760 if (v3d->camera && (v3d->camera->data == wmn->reference)) {
761 if (rv3d->persp == RV3D_CAMOB) {
762 ED_region_tag_redraw(region);
763 }
764 }
765 break;
766 }
767 }
768 break;
769 case NC_GROUP:
770 /* all group ops for now */
771 ED_region_tag_redraw(region);
772 break;
773 case NC_BRUSH:
774 switch (wmn->action) {
775 case NA_EDITED:
777 break;
778 case NA_SELECTED:
779 /* used on brush changes - needed because 3d cursor
780 * has to be drawn if clone brush is selected */
781 ED_region_tag_redraw(region);
782 break;
783 }
784 break;
785 case NC_MATERIAL:
786 switch (wmn->data) {
787 case ND_SHADING:
788 case ND_NODES:
789 /* TODO(sergey): This is a bit too much updates, but needed to
790 * have proper material drivers update in the viewport.
791 *
792 * How to solve?
793 */
794 ED_region_tag_redraw(region);
795 break;
796 case ND_SHADING_DRAW:
797 case ND_SHADING_LINKS:
798 ED_region_tag_redraw(region);
799 break;
800 }
801 break;
802 case NC_NODE:
803 switch (wmn->data) {
804 case ND_NODE_GIZMO: {
806 break;
807 }
808 }
809 ED_region_tag_redraw(region);
810 break;
811 case NC_WORLD:
812 switch (wmn->data) {
813 case ND_WORLD_DRAW:
814 /* handled by space_view3d_listener() for v3d access */
815 break;
816 case ND_WORLD:
817 /* Needed for updating world materials */
818 ED_region_tag_redraw(region);
819 break;
820 }
821 break;
822 case NC_LAMP:
823 switch (wmn->data) {
824 case ND_LIGHTING:
825 /* TODO(sergey): This is a bit too much, but needed to
826 * handle updates from new depsgraph.
827 */
828 ED_region_tag_redraw(region);
829 break;
830 case ND_LIGHTING_DRAW:
831 ED_region_tag_redraw(region);
833 break;
834 }
835 break;
836 case NC_LIGHTPROBE:
838 break;
839 case NC_IMAGE:
840 /* this could be more fine grained checks if we had
841 * more context than just the region */
842 ED_region_tag_redraw(region);
843 break;
844 case NC_TEXTURE:
845 /* Same as #NC_IMAGE. */
846 ED_region_tag_redraw(region);
847 break;
848 case NC_MOVIECLIP:
849 if (wmn->data == ND_DISPLAY || wmn->action == NA_EDITED) {
850 ED_region_tag_redraw(region);
851 }
852 break;
853 case NC_SPACE:
854 if (wmn->data == ND_SPACE_VIEW3D) {
855 if (wmn->subtype == NS_VIEW3D_GPU) {
856 rv3d->rflag |= RV3D_GPULIGHT_UPDATE;
857 }
858 else if (wmn->subtype == NS_VIEW3D_SHADING) {
859#ifdef WITH_XR_OPENXR
860 ED_view3d_xr_shading_update(G_MAIN->wm.first(), v3d, scene);
861#endif
862
863 ViewLayer *view_layer = WM_window_get_active_view_layer(window);
864 Depsgraph *depsgraph = BKE_scene_get_depsgraph(scene, view_layer);
865 if (depsgraph) {
866 ED_render_view3d_update(depsgraph, window, area, true);
867 }
868 }
869 ED_region_tag_redraw(region);
871 }
872 break;
873 case NC_ID:
875 if (ELEM(wmn->action, NA_EDITED, NA_REMOVED) && v3d->localvd &&
877 {
879 }
880 ED_region_tag_redraw(region);
882 }
883 break;
884 case NC_SCREEN:
885 switch (wmn->data) {
886 case ND_ANIMPLAY:
887 case ND_SKETCH:
888 ED_region_tag_redraw(region);
889 break;
890 case ND_LAYOUTBROWSE:
891 case ND_LAYOUTDELETE:
892 case ND_LAYOUTSET:
894 ED_region_tag_redraw(region);
895 break;
896 case ND_LAYER:
897 ED_region_tag_redraw(region);
898 break;
899 }
900 switch (wmn->action) {
901 case NA_EDITED:
903 ED_region_tag_redraw(region);
904 break;
905 }
906
907 break;
908 case NC_GPENCIL:
909 if (wmn->data == ND_DATA || ELEM(wmn->action, NA_EDITED, NA_SELECTED)) {
910 ED_region_tag_redraw(region);
911 }
912 break;
913 case NC_WORKSPACE:
914 /* In case the region displays workspace settings. */
915 ED_region_tag_redraw(region);
916 break;
917 case NC_VIEWER_PATH: {
918 if (v3d->flag2 & V3D_SHOW_VIEWER) {
919 ViewLayer *view_layer = WM_window_get_active_view_layer(window);
920 if (Depsgraph *depsgraph = BKE_scene_get_depsgraph(scene, view_layer)) {
921 ED_render_view3d_update(depsgraph, window, area, true);
922 }
923 ED_region_tag_redraw(region);
924 }
925 break;
926 }
927 }
928}
929
931{
932 wmMsgBus *mbus = params->message_bus;
933 const bContext *C = params->context;
934 ScrArea *area = params->area;
935 ARegion *region = params->region;
936
937 /* Developer NOTE: there are many properties that impact 3D view drawing,
938 * so instead of subscribing to individual properties, just subscribe to types
939 * accepting some redundant redraws.
940 *
941 * For other space types we might try avoid this, keep the 3D view as an exceptional case! */
942 wmMsgParams_RNA msg_key_params{};
943
944 /* Only subscribe to types. */
945 StructRNA *type_array[] = {
946 RNA_Window,
947
948 /* These object have properties that impact drawing. */
949 RNA_AreaLight,
950 RNA_Camera,
951 RNA_Light,
952 RNA_Speaker,
953 RNA_SunLight,
954
955 /* General types the 3D view depends on. */
956 RNA_Object,
957 RNA_UnitSettings, /* grid-floor */
958
959 RNA_View3DCursor,
960 RNA_View3DOverlay,
961 RNA_View3DShading,
962 RNA_World,
963 };
964
965 wmMsgSubscribeValue msg_sub_value_region_tag_redraw{};
966 msg_sub_value_region_tag_redraw.owner = region;
967 msg_sub_value_region_tag_redraw.user_data = region;
968 msg_sub_value_region_tag_redraw.notify = ED_region_do_msg_notify_tag_redraw;
969
970 for (int i = 0; i < ARRAY_SIZE(type_array); i++) {
971 msg_key_params.ptr.type = type_array[i];
972 WM_msg_subscribe_rna_params(mbus, &msg_key_params, &msg_sub_value_region_tag_redraw, __func__);
973 }
974
975 /* Subscribe to a handful of other properties. */
976 RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
977
978 WM_msg_subscribe_rna_anon_prop(mbus, RenderSettings, engine, &msg_sub_value_region_tag_redraw);
980 mbus, RenderSettings, resolution_x, &msg_sub_value_region_tag_redraw);
982 mbus, RenderSettings, resolution_y, &msg_sub_value_region_tag_redraw);
984 mbus, RenderSettings, pixel_aspect_x, &msg_sub_value_region_tag_redraw);
986 mbus, RenderSettings, pixel_aspect_y, &msg_sub_value_region_tag_redraw);
987 if (rv3d->persp == RV3D_CAMOB) {
989 mbus, RenderSettings, use_border, &msg_sub_value_region_tag_redraw);
990 }
991
992 WM_msg_subscribe_rna_anon_type(mbus, SceneEEVEE, &msg_sub_value_region_tag_redraw);
993 WM_msg_subscribe_rna_anon_type(mbus, SceneDisplay, &msg_sub_value_region_tag_redraw);
994 WM_msg_subscribe_rna_anon_type(mbus, ObjectDisplay, &msg_sub_value_region_tag_redraw);
995
996 const Main *bmain = CTX_data_main(C);
997 const Scene *scene = CTX_data_scene(C);
998 ViewLayer *view_layer = CTX_data_view_layer(C);
999 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
1000 Object *obact = BKE_view_layer_active_object_get(view_layer);
1001 if (obact != nullptr) {
1002 switch (obact->mode) {
1004 WM_msg_subscribe_rna_anon_type(mbus, ParticleEdit, &msg_sub_value_region_tag_redraw);
1005 break;
1006 default:
1007 break;
1008 }
1009 }
1010
1011 {
1012 wmMsgSubscribeValue msg_sub_value_region_tag_refresh{};
1013 msg_sub_value_region_tag_refresh.owner = region;
1014 msg_sub_value_region_tag_refresh.user_data = area;
1015 msg_sub_value_region_tag_refresh.notify = WM_toolsystem_do_msg_notify_tag_refresh;
1016 WM_msg_subscribe_rna_anon_prop(mbus, Object, mode, &msg_sub_value_region_tag_refresh);
1017 WM_msg_subscribe_rna_anon_prop(mbus, LayerObjects, active, &msg_sub_value_region_tag_refresh);
1018 }
1019}
1020
1022static void view3d_main_region_cursor(wmWindow *win, ScrArea *area, ARegion *region)
1023{
1024 if (WM_cursor_set_from_tool(win, area, region)) {
1025 return;
1026 }
1027
1028 Scene *scene = WM_window_get_active_scene(win);
1029 ViewLayer *view_layer = WM_window_get_active_view_layer(win);
1030 /* FIXME: Probably need to pass Main to this callback? For now though, using G_MAIN should be
1031 * fine here.*/
1032 BKE_view_layer_synced_ensure(*G_MAIN, scene, view_layer);
1033 Object *obedit = BKE_view_layer_edit_object_get(view_layer);
1034 if (obedit) {
1036 }
1037 else {
1039 }
1040}
1041
1042/* add handlers, stuff you only do once or on area/region changes */
1044{
1045 wmKeyMap *keymap = WM_keymap_ensure(
1046 wm->runtime->defaultconf, "3D View Generic", SPACE_VIEW3D, RGN_TYPE_WINDOW);
1047
1048 WM_event_add_keymap_handler(&region->runtime->handlers, keymap);
1049
1050 ED_region_header_init(region);
1051}
1052
1053static void view3d_header_region_draw(const bContext *C, ARegion *region)
1054{
1055 ED_region_header(C, region);
1056}
1057
1059{
1060 ARegion *region = params->region;
1061 const wmNotifier *wmn = params->notifier;
1062
1063 /* context changes */
1064 switch (wmn->category) {
1065 case NC_SCENE:
1066 switch (wmn->data) {
1067 case ND_FRAME:
1068 case ND_OB_ACTIVE:
1069 case ND_OB_SELECT:
1070 case ND_OB_VISIBLE:
1071 case ND_MODE:
1072 case ND_LAYER:
1073 case ND_TOOLSETTINGS:
1074 case ND_LAYER_CONTENT:
1075 case ND_RENDER_OPTIONS:
1076 ED_region_tag_redraw(region);
1077 break;
1078 }
1079 break;
1080 case NC_SPACE:
1081 switch (wmn->data) {
1082 case ND_SPACE_VIEW3D:
1083 ED_region_tag_redraw(region);
1084 break;
1086 ED_region_tag_redraw(region);
1087 break;
1088 }
1089 break;
1090 case NC_ASSET:
1091 switch (wmn->data) {
1092 case ND_ASSET_CATALOGS:
1093 case ND_ASSET_LIST:
1095 ED_region_tag_redraw(region);
1096 break;
1097 default:
1098 if (ELEM(wmn->action, NA_ADDED, NA_REMOVED)) {
1099 ED_region_tag_redraw(region);
1100 }
1101 }
1102 break;
1103 case NC_NODE:
1104 switch (wmn->data) {
1105 case ND_NODE_ASSET_DATA:
1106 ED_region_tag_redraw(region);
1107 break;
1108 }
1109 break;
1110 case NC_GPENCIL:
1111 if (wmn->data & ND_GPENCIL_EDITMODE) {
1112 ED_region_tag_redraw(region);
1113 }
1114 else if (wmn->action == NA_EDITED) {
1115 ED_region_tag_redraw(region);
1116 }
1117 break;
1118 case NC_BRUSH:
1119 ED_region_tag_redraw(region);
1120 break;
1121 case NC_GEOM:
1122 if (ELEM(wmn->data, ND_VERTEX_GROUP, ND_DATA)) {
1123 ED_region_tag_redraw(region);
1124 }
1125 break;
1126 case NC_MATERIAL:
1127 /* For the canvas picker. */
1128 if (ELEM(wmn->data, ND_SHADING_LINKS, ND_NODES)) {
1129 ED_region_tag_redraw(region);
1130 }
1131 break;
1132 }
1133
1134 /* From top-bar, which ones are needed? split per header? */
1135 /* Disable for now, re-enable if needed, or remove - campbell. */
1136#if 0
1137 /* context changes */
1138 switch (wmn->category) {
1139 case NC_WM:
1140 if (wmn->data == ND_HISTORY) {
1141 ED_region_tag_redraw(region);
1142 }
1143 break;
1144 case NC_SCENE:
1145 if (wmn->data == ND_MODE) {
1146 ED_region_tag_redraw(region);
1147 }
1148 break;
1149 case NC_SPACE:
1150 if (wmn->data == ND_SPACE_VIEW3D) {
1151 ED_region_tag_redraw(region);
1152 }
1153 break;
1154 case NC_GPENCIL:
1155 if (wmn->data == ND_DATA) {
1156 ED_region_tag_redraw(region);
1157 }
1158 break;
1159 }
1160#endif
1161}
1162
1164{
1165 wmMsgBus *mbus = params->message_bus;
1166 ARegion *region = params->region;
1167
1168 wmMsgParams_RNA msg_key_params{};
1169
1170 /* Only subscribe to types. */
1171 StructRNA *type_array[] = {
1172 RNA_View3DShading,
1173 };
1174
1175 wmMsgSubscribeValue msg_sub_value_region_tag_redraw{};
1176 msg_sub_value_region_tag_redraw.owner = region;
1177 msg_sub_value_region_tag_redraw.user_data = region;
1178 msg_sub_value_region_tag_redraw.notify = ED_region_do_msg_notify_tag_redraw;
1179
1180 for (int i = 0; i < ARRAY_SIZE(type_array); i++) {
1181 msg_key_params.ptr.type = type_array[i];
1182 WM_msg_subscribe_rna_params(mbus, &msg_key_params, &msg_sub_value_region_tag_redraw, __func__);
1183 }
1184}
1185
1186/* add handlers, stuff you only do once or on area/region changes */
1188{
1189 wmKeyMap *keymap;
1190
1191 ED_region_panels_init(wm, region);
1192
1194
1195 keymap = WM_keymap_ensure(
1196 wm->runtime->defaultconf, "3D View Generic", SPACE_VIEW3D, RGN_TYPE_WINDOW);
1197 WM_event_add_keymap_handler(&region->runtime->handlers, keymap);
1198}
1199
1200std::array<const char *, 4> ED_view3d_buttons_contexts(const bContext *C)
1201{
1202 const enum eContextObjectMode mode = CTX_data_mode_enum(C);
1203
1204 std::array<const char *, 4> contexts_base = {nullptr};
1205 contexts_base[0] = CTX_data_mode_string(C);
1206
1207 const char **contexts = &contexts_base[1];
1208
1209 switch (mode) {
1210 case CTX_MODE_EDIT_MESH:
1211 ARRAY_SET_ITEMS(contexts, ".mesh_edit");
1212 break;
1214 ARRAY_SET_ITEMS(contexts, ".curve_edit");
1215 break;
1217 ARRAY_SET_ITEMS(contexts, ".curves_edit");
1218 break;
1220 ARRAY_SET_ITEMS(contexts, ".curve_edit");
1221 break;
1222 case CTX_MODE_EDIT_TEXT:
1223 ARRAY_SET_ITEMS(contexts, ".text_edit");
1224 break;
1226 ARRAY_SET_ITEMS(contexts, ".armature_edit");
1227 break;
1229 ARRAY_SET_ITEMS(contexts, ".mball_edit");
1230 break;
1232 ARRAY_SET_ITEMS(contexts, ".lattice_edit");
1233 break;
1235 ARRAY_SET_ITEMS(contexts, ".grease_pencil_edit");
1236 break;
1238 ARRAY_SET_ITEMS(contexts, ".grease_pencil_paint");
1239 break;
1241 ARRAY_SET_ITEMS(contexts, ".grease_pencil_sculpt");
1242 break;
1244 ARRAY_SET_ITEMS(contexts, ".greasepencil_weight");
1245 break;
1247 ARRAY_SET_ITEMS(contexts, ".greasepencil_vertex");
1248 break;
1250 ARRAY_SET_ITEMS(contexts, ".pointcloud_edit");
1251 break;
1252 case CTX_MODE_POSE:
1253 ARRAY_SET_ITEMS(contexts, ".posemode");
1254 break;
1255 case CTX_MODE_SCULPT:
1256 ARRAY_SET_ITEMS(contexts, ".paint_common", ".sculpt_mode");
1257 break;
1259 ARRAY_SET_ITEMS(contexts, ".paint_common", ".weightpaint");
1260 break;
1262 ARRAY_SET_ITEMS(contexts, ".paint_common", ".vertexpaint");
1263 break;
1265 ARRAY_SET_ITEMS(contexts, ".paint_common", ".imagepaint");
1266 break;
1267 case CTX_MODE_PARTICLE:
1268 ARRAY_SET_ITEMS(contexts, ".paint_common", ".particlemode");
1269 break;
1270 case CTX_MODE_OBJECT:
1271 ARRAY_SET_ITEMS(contexts, ".objectmode");
1272 break;
1274 ARRAY_SET_ITEMS(contexts, ".greasepencil_paint");
1275 break;
1277 ARRAY_SET_ITEMS(contexts, ".greasepencil_sculpt");
1278 break;
1280 ARRAY_SET_ITEMS(contexts, ".greasepencil_weight");
1281 break;
1283 ARRAY_SET_ITEMS(contexts, ".greasepencil_vertex");
1284 break;
1286 ARRAY_SET_ITEMS(contexts, ".paint_common", ".curves_sculpt");
1287 break;
1288 default:
1289 break;
1290 }
1291
1292 switch (mode) {
1294 ARRAY_SET_ITEMS(contexts, ".greasepencil_paint");
1295 break;
1297 ARRAY_SET_ITEMS(contexts, ".greasepencil_sculpt");
1298 break;
1300 ARRAY_SET_ITEMS(contexts, ".greasepencil_weight");
1301 break;
1303 ARRAY_SET_ITEMS(contexts, ".greasepencil_edit");
1304 break;
1306 ARRAY_SET_ITEMS(contexts, ".greasepencil_vertex");
1307 break;
1308 default:
1309 break;
1310 }
1311
1312 return contexts_base;
1313}
1314
1316 ARegion *region,
1317 const char *category_override)
1318{
1319 std::array<const char *, 4> contexts = ED_view3d_buttons_contexts(C);
1320
1321 ListBaseT<PanelType> *paneltypes = &region->runtime->type->paneltypes;
1322
1323 /* Allow drawing 3D view toolbar from non 3D view space type. */
1324 if (category_override != nullptr) {
1327 paneltypes = &art->paneltypes;
1328 }
1329
1331 region,
1332 paneltypes,
1334 contexts.data(),
1335 category_override);
1336}
1337
1339{
1340 ED_view3d_buttons_region_layout_ex(C, region, nullptr);
1341}
1342
1344{
1345 ARegion *region = params->region;
1346 const wmNotifier *wmn = params->notifier;
1347
1348 /* context changes */
1349 switch (wmn->category) {
1350 case NC_ANIMATION:
1351 switch (wmn->data) {
1352 case ND_KEYFRAME_PROP:
1353 case ND_NLA_ACTCHANGE:
1354 ED_region_tag_redraw(region);
1355 break;
1356 case ND_NLA:
1357 case ND_KEYFRAME:
1358 if (ELEM(wmn->action, NA_EDITED, NA_ADDED, NA_REMOVED)) {
1359 ED_region_tag_redraw(region);
1360 }
1361 break;
1362 }
1363 break;
1364 case NC_SCENE:
1365 switch (wmn->data) {
1366 case ND_FRAME:
1367 case ND_OB_ACTIVE:
1368 case ND_OB_SELECT:
1369 case ND_OB_VISIBLE:
1370 case ND_MODE:
1371 case ND_LAYER:
1372 case ND_LAYER_CONTENT:
1373 case ND_TOOLSETTINGS:
1374 case ND_TRANSFORM:
1375 ED_region_tag_redraw(region);
1376 break;
1377 }
1378 switch (wmn->action) {
1379 case NA_EDITED:
1380 ED_region_tag_redraw(region);
1381 break;
1382 }
1383 break;
1384 case NC_OBJECT:
1385 switch (wmn->data) {
1386 case ND_BONE_ACTIVE:
1387 case ND_BONE_SELECT:
1388 case ND_BONE_COLLECTION:
1389 case ND_TRANSFORM:
1390 case ND_POSE:
1391 case ND_DRAW:
1392 case ND_KEYS:
1393 case ND_MODIFIER:
1394 case ND_SHADERFX:
1395 ED_region_tag_redraw(region);
1396 break;
1397 }
1398 break;
1399 case NC_GEOM:
1400 switch (wmn->data) {
1401 case ND_DATA:
1402 case ND_VERTEX_GROUP:
1403 case ND_SELECT:
1404 ED_region_tag_redraw(region);
1405 break;
1406 }
1407 if (wmn->action == NA_EDITED) {
1408 ED_region_tag_redraw(region);
1409 }
1410 break;
1411 case NC_TEXTURE:
1412 case NC_MATERIAL:
1413 /* for brush textures */
1414 ED_region_tag_redraw(region);
1415 break;
1416 case NC_BRUSH:
1417 /* NA_SELECTED is used on brush changes */
1418 if (ELEM(wmn->action, NA_EDITED, NA_SELECTED)) {
1419 ED_region_tag_redraw(region);
1420 }
1421 break;
1422 case NC_SPACE:
1423 if (wmn->data == ND_SPACE_VIEW3D) {
1424 ED_region_tag_redraw(region);
1425 }
1426 break;
1427 case NC_ID:
1428 if (wmn->action == NA_RENAME) {
1429 ED_region_tag_redraw(region);
1430 }
1431 break;
1432 case NC_GPENCIL:
1433 if ((wmn->data & (ND_DATA | ND_GPENCIL_EDITMODE)) || (wmn->action == NA_EDITED)) {
1434 ED_region_tag_redraw(region);
1435 }
1436 break;
1437 case NC_IMAGE:
1438 /* Update for the image layers in texture paint. */
1439 if (wmn->action == NA_EDITED) {
1440 ED_region_tag_redraw(region);
1441 }
1442 break;
1443 case NC_WM:
1444 if (wmn->data == ND_XR_DATA_CHANGED) {
1445 ED_region_tag_redraw(region);
1446 }
1447 break;
1448 }
1449}
1450
1451/* add handlers, stuff you only do once or on area/region changes */
1453{
1454 wmKeyMap *keymap;
1455
1456 ED_region_panels_init(wm, region);
1457
1459
1460 keymap = WM_keymap_ensure(
1461 wm->runtime->defaultconf, "3D View Generic", SPACE_VIEW3D, RGN_TYPE_WINDOW);
1462 WM_event_add_keymap_handler(&region->runtime->handlers, keymap);
1463}
1464
1465static void view3d_tools_region_draw(const bContext *C, ARegion *region)
1466{
1467 const char *contexts[] = {CTX_data_mode_string(C), nullptr};
1469}
1470
1480
1481/* add handlers, stuff you only do once or on area/region changes */
1483{
1484 using namespace blender::ed;
1485 wmKeyMap *keymap = WM_keymap_ensure(
1486 wm->runtime->defaultconf, "3D View Generic", SPACE_VIEW3D, RGN_TYPE_WINDOW);
1487 WM_event_add_keymap_handler(&region->runtime->handlers, keymap);
1488
1490}
1491
1492/* area (not region) level listener */
1494{
1495 ScrArea *area = params->area;
1496 const wmNotifier *wmn = params->notifier;
1497 View3D *v3d = area->spacedata.first_as<View3D>();
1498
1499 /* context changes */
1500 switch (wmn->category) {
1501 case NC_SCENE:
1502 switch (wmn->data) {
1503 case ND_WORLD: {
1504 const bool use_scene_world = V3D_USES_SCENE_WORLD(v3d);
1505 if (v3d->flag2 & V3D_HIDE_OVERLAYS || use_scene_world) {
1507 }
1508 break;
1509 }
1510 }
1511 break;
1512 case NC_WORLD:
1513 switch (wmn->data) {
1514 case ND_WORLD_DRAW:
1515 case ND_WORLD:
1518 }
1519 break;
1520 }
1521 break;
1522 case NC_MATERIAL:
1523 switch (wmn->data) {
1524 case ND_NODES:
1525 if (v3d->shading.type == OB_TEXTURE) {
1527 }
1528 break;
1529 }
1530 break;
1531 }
1532}
1533
1534static void space_view3d_refresh(const bContext *C, ScrArea *area)
1535{
1536 View3D *v3d = area->spacedata.first_as<View3D>();
1538
1545 v3d,
1546 CTX_wm_area(C),
1547 true,
1548 U.smooth_viewtx);
1549 }
1550}
1551
1553{
1554 if (mappings.apply(reinterpret_cast<ID **>(&v3d->ob_center), ID_REMAP_APPLY_DEFAULT) ==
1556 {
1557 /* Otherwise, bone-name may remain valid...
1558 * We could be smart and check this, too? */
1559 v3d->ob_center_bone[0] = '\0';
1560 }
1561}
1562
1564 SpaceLink *slink,
1565 View3D *v3d,
1566 const bke::id::IDRemapper &mappings,
1567 const bool is_local)
1568{
1569 if (mappings.apply(reinterpret_cast<ID **>(&v3d->camera), ID_REMAP_APPLY_DEFAULT) ==
1571 {
1572 /* 3D view might be inactive, in that case needs to use slink->regionbase */
1573 ListBaseT<ARegion> *regionbase = (slink == area->spacedata.first_) ? &area->regionbase :
1574 &slink->regionbase;
1575 for (ARegion &region : *regionbase) {
1576 if (region.regiontype == RGN_TYPE_WINDOW) {
1577 RegionView3D *rv3d = is_local ? (static_cast<RegionView3D *>(region.regiondata))->localvd :
1578 static_cast<RegionView3D *>(region.regiondata);
1579 if (rv3d && (rv3d->persp == RV3D_CAMOB)) {
1580 rv3d->persp = RV3D_PERSP;
1581 }
1582 }
1583 }
1584 }
1585}
1586
1587static void view3d_id_remap(ScrArea *area, SpaceLink *slink, const bke::id::IDRemapper &mappings)
1588{
1590 FILTER_ID_MC))
1591 {
1592 return;
1593 }
1594
1595 View3D *view3d = reinterpret_cast<View3D *>(slink);
1596 view3d_id_remap_v3d(area, slink, view3d, mappings, false);
1598 if (view3d->localvd != nullptr) {
1599 /* Object centers in local-view aren't used, see: #52663 */
1600 view3d_id_remap_v3d(area, slink, view3d->localvd, mappings, true);
1601 /* Remapping is potentially modifying ID pointers, and there is a local View3D, mark it for a
1602 * check for emptiness. */
1603 view3d->localvd->runtime.flag |= V3D_RUNTIME_LOCAL_MAYBE_EMPTY;
1604 }
1605 BKE_viewer_path_id_remap(&view3d->viewer_path, mappings);
1606}
1607
1609{
1610 View3D *v3d = reinterpret_cast<View3D *>(space_link);
1611
1614 if (v3d->localvd) {
1616
1617 /* If potentially modifying ID pointers, and there is a local View3D, mark it for a check for
1618 * emptiness. */
1620 if ((flags & IDWALK_READONLY) == 0) {
1622 }
1623 }
1625}
1626
1628{
1629 View3D *v3d = reinterpret_cast<View3D *>(sl);
1630
1631 v3d->runtime = View3D_Runtime{};
1632
1633 if (BLO_read_struct_nonnull(reader, bGPdata, &v3d->gpd)) {
1635 }
1636 BLO_read_struct(reader, RegionView3D, &v3d->localvd);
1637
1638 /* render can be quite heavy, set to solid on load */
1639 if (v3d->shading.type == OB_RENDER) {
1640 v3d->shading.type = OB_SOLID;
1641 }
1642 v3d->shading.prev_type = OB_SOLID;
1643
1645
1647
1649}
1650
1652{
1653 View3D *v3d = reinterpret_cast<View3D *>(sl);
1654 writer->write_struct(v3d, [](BlendStructWriter<View3D> &struct_writer) {
1655 struct_writer.shallow_data.runtime = {};
1656 });
1657
1658 if (v3d->localvd) {
1659 writer->write_struct(v3d->localvd, [](BlendStructWriter<View3D> &struct_writer) {
1660 View3D &shallow_v3d = struct_writer.shallow_data;
1661 memset((void *)&shallow_v3d.runtime, 0, sizeof(shallow_v3d.runtime));
1662 });
1663 }
1664
1666
1668}
1669
1671{
1672 using namespace blender::ed;
1673 std::unique_ptr<SpaceType> st = std::make_unique<SpaceType>();
1674 ARegionType *art;
1675
1676 st->spaceid = SPACE_VIEW3D;
1677 STRNCPY_UTF8(st->name, "View3D");
1678 st->struct_size = sizeof(View3D);
1679
1680 st->create = view3d_create;
1681 st->free = view3d_free;
1682 st->init = view3d_init;
1683 st->exit = view3d_exit;
1684 st->listener = space_view3d_listener;
1685 st->refresh = space_view3d_refresh;
1686 st->duplicate = view3d_duplicate;
1687 st->operatortypes = view3d_operatortypes;
1688 st->keymap = view3d_keymap;
1689 st->dropboxes = view3d_dropboxes;
1690 st->gizmos = view3d_widgets;
1691 st->context = view3d_context;
1692 st->id_remap = view3d_id_remap;
1693 st->foreach_id = view3d_foreach_id;
1694 st->blend_read_data = view3d_space_blend_read_data;
1695 st->blend_read_after_liblink = nullptr;
1696 st->blend_write = view3d_space_blend_write;
1697
1698 /* regions: main window */
1699 art = MEM_new_zeroed<ARegionType>("spacetype view3d main region");
1707#ifdef WITH_INPUT_IME
1708 art->cursor_ime = view3d_main_region_cursor_ime;
1709#endif
1714 BLI_addhead(&st->regiontypes, art);
1715
1716 /* regions: list-view/buttons */
1717 art = MEM_new_zeroed<ARegionType>("spacetype view3d buttons region");
1718 art->regionid = RGN_TYPE_UI;
1728 BLI_addhead(&st->regiontypes, art);
1729
1731
1732 /* regions: tool(bar) */
1733 art = MEM_new_zeroed<ARegionType>("spacetype view3d tools region");
1734 art->regionid = RGN_TYPE_TOOLS;
1735 art->prefsizex = int(UI_TOOLBAR_WIDTH);
1736 art->prefsizey = 50; /* XXX */
1743 BLI_addhead(&st->regiontypes, art);
1744
1745 /* regions: tool header */
1746 art = MEM_new_zeroed<ARegionType>("spacetype view3d tool header region");
1748 art->prefsizey = HEADERY;
1754 BLI_addhead(&st->regiontypes, art);
1755
1756 /* regions: header */
1757 art = MEM_new_zeroed<ARegionType>("spacetype view3d header region");
1759 art->prefsizey = HEADERY;
1765 BLI_addhead(&st->regiontypes, art);
1766
1767 /* regions: asset shelf */
1768 art = MEM_new_zeroed<ARegionType>("spacetype view3d asset shelf region");
1783 BLI_addhead(&st->regiontypes, art);
1784
1785 /* regions: asset shelf header */
1786 art = MEM_new_zeroed<ARegionType>("spacetype view3d asset shelf header region");
1794 BLI_addhead(&st->regiontypes, art);
1796
1797 /* regions: hud */
1798 art = ui::ED_area_type_hud(st->spaceid);
1799 BLI_addhead(&st->regiontypes, art);
1800
1801 /* regions: xr */
1802 art = MEM_new_zeroed<ARegionType>("spacetype view3d xr region");
1803 art->regionid = RGN_TYPE_XR;
1804 BLI_addhead(&st->regiontypes, art);
1805
1806 WM_menutype_add(MEM_new<MenuType>(__func__, ed::geometry::node_group_operator_assets_menu()));
1808 MEM_new<MenuType>(__func__, ed::geometry::node_group_operator_assets_menu_unassigned()));
1809
1810 BKE_spacetype_register(std::move(st));
1811}
1812
1813} // namespace blender
#define G_MAIN
#define BKE_LIB_FOREACHID_PROCESS_IDSUPER(data_, id_super_, cb_flag_)
General operations, lookup, etc. for blender objects.
#define ATTR_FALLTHROUGH
#define BLI_ASSERT_ZERO_M4(m)
#define STRNCPY_UTF8(dst, src)
#define BLO_read_struct_nonnull(reader, struct_name, ptr_p)
#define BLO_read_struct(reader, struct_name, ptr_p)
#define BPy_BEGIN_ALLOW_THREADS
Definition BPY_extern.hh:52
#define BPy_END_ALLOW_THREADS
Definition BPY_extern.hh:56
#define FILTER_ID_OB
Definition DNA_ID.h:1216
#define FILTER_ID_MC
Definition DNA_ID.h:1212
#define FILTER_ID_MA
Definition DNA_ID.h:1210
#define FILTER_ID_IM
Definition DNA_ID.h:1206
Object groups, one object can be in many groups at once.
Object is a sort of wrapper for general info.
#define HEADERY
#define RGN_ALIGN_ENUM_FROM_MASK(align)
#define V3D_USES_SCENE_WORLD(v3d)
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define UI_UNIT_Y
#define UI_SIDEBAR_PANEL_WIDTH
#define UI_TOOLBAR_WIDTH
#define NC_WORLD
Definition WM_types.hh:400
#define ND_SHADING
Definition WM_types.hh:520
#define ND_WORLD
Definition WM_types.hh:471
#define ND_ASSET_LIST_READING
Definition WM_types.hh:593
#define NC_ID
Definition WM_types.hh:408
#define NC_NODE
Definition WM_types.hh:407
#define NC_GEOM
Definition WM_types.hh:406
#define ND_NLA_ACTCHANGE
Definition WM_types.hh:541
#define ND_DRAW
Definition WM_types.hh:502
#define NC_BRUSH
Definition WM_types.hh:398
#define ND_OB_ACTIVE
Definition WM_types.hh:459
#define NC_WM
Definition WM_types.hh:387
#define ND_DATA
Definition WM_types.hh:552
#define ND_GPENCIL_EDITMODE
Definition WM_types.hh:547
#define ND_LIGHTING_DRAW
Definition WM_types.hh:527
#define ND_RENDER_OPTIONS
Definition WM_types.hh:454
#define ND_SPACE_ASSET_PARAMS
Definition WM_types.hh:568
#define NC_ANIMATION
Definition WM_types.hh:401
#define NC_VIEWER_PATH
Definition WM_types.hh:419
#define ND_VERTEX_GROUP
Definition WM_types.hh:553
#define ND_DISPLAY
Definition WM_types.hh:534
#define ND_COMPO_RESULT
Definition WM_types.hh:466
#define ND_LOD
Definition WM_types.hh:509
#define NC_SCREEN
Definition WM_types.hh:390
#define NC_MOVIECLIP
Definition WM_types.hh:410
#define ND_SKETCH
Definition WM_types.hh:444
#define ND_MODE
Definition WM_types.hh:464
#define ND_OB_SELECT
Definition WM_types.hh:461
#define ND_ANIMPLAY
Definition WM_types.hh:441
#define NC_SCENE
Definition WM_types.hh:391
#define NA_ADDED
Definition WM_types.hh:636
#define ND_OB_VISIBLE
Definition WM_types.hh:462
#define ND_LAYER_CONTENT
Definition WM_types.hh:472
#define NC_GROUP
Definition WM_types.hh:396
#define ND_NODES
Definition WM_types.hh:455
#define ND_TOOLSETTINGS
Definition WM_types.hh:468
#define ND_MODIFIER
Definition WM_types.hh:503
#define ND_POSE
Definition WM_types.hh:482
#define NA_EDITED
Definition WM_types.hh:634
#define ND_PARTICLE
Definition WM_types.hh:506
#define ND_KEYFRAME_PROP
Definition WM_types.hh:538
#define NC_MATERIAL
Definition WM_types.hh:393
#define NC_LAMP
Definition WM_types.hh:395
#define NC_IMAGE
Definition WM_types.hh:397
#define ND_CONSTRAINT
Definition WM_types.hh:505
#define NC_WORKSPACE
Definition WM_types.hh:389
#define ND_UNDO
Definition WM_types.hh:433
#define ND_MARKERS
Definition WM_types.hh:452
#define NC_CAMERA
Definition WM_types.hh:414
#define ND_FRAME
Definition WM_types.hh:453
#define NC_ASSET
Definition WM_types.hh:417
#define NA_REMOVED
Definition WM_types.hh:637
#define ND_SELECT
Definition WM_types.hh:551
#define NC_GPENCIL
Definition WM_types.hh:412
#define ND_NLA
Definition WM_types.hh:540
#define NC_TEXTURE
Definition WM_types.hh:394
#define NS_VIEW3D_GPU
Definition WM_types.hh:626
#define ND_LIGHTING
Definition WM_types.hh:526
#define ND_BONE_ACTIVE
Definition WM_types.hh:483
#define ND_TRANSFORM
Definition WM_types.hh:475
#define ND_LAYER
Definition WM_types.hh:469
#define ND_BONE_COLLECTION
Definition WM_types.hh:515
#define ND_ASSET_LIST
Definition WM_types.hh:591
#define ND_KEYS
Definition WM_types.hh:504
#define NA_RENAME
Definition WM_types.hh:638
#define ND_ASSET_CATALOGS
Definition WM_types.hh:599
#define ND_NODE_GIZMO
Definition WM_types.hh:559
#define ND_HISTORY
Definition WM_types.hh:431
#define NC_LIGHTPROBE
Definition WM_types.hh:415
#define ND_POINTCACHE
Definition WM_types.hh:507
#define ND_XR_DATA_CHANGED
Definition WM_types.hh:434
#define ND_SHADERFX
Definition WM_types.hh:512
#define ND_WORLD_DRAW
Definition WM_types.hh:530
#define ND_LAYOUTBROWSE
Definition WM_types.hh:439
#define ND_DRAW_ANIMVIZ
Definition WM_types.hh:514
#define ND_BONE_SELECT
Definition WM_types.hh:491
#define ND_SPACE_VIEW3D
Definition WM_types.hh:571
#define ND_KEYFRAME
Definition WM_types.hh:537
#define ND_LAYOUTSET
Definition WM_types.hh:443
#define NC_OBJECT
Definition WM_types.hh:392
#define ND_SCENEBROWSE
Definition WM_types.hh:451
#define NS_VIEW3D_SHADING
Definition WM_types.hh:627
#define ND_LAYOUTDELETE
Definition WM_types.hh:440
#define ND_NODE_ASSET_DATA
Definition WM_types.hh:558
#define ND_ANIMCHAN
Definition WM_types.hh:539
#define ND_SHADING_LINKS
Definition WM_types.hh:522
#define ND_SHADING_DRAW
Definition WM_types.hh:521
#define NC_SPACE
Definition WM_types.hh:405
#define NA_SELECTED
Definition WM_types.hh:639
#define ND_DRAW_RENDER_VIEWPORT
Definition WM_types.hh:511
#define ARRAY_SET_ITEMS(...)
#define ELEM(...)
IDRemapperApplyResult apply(ID **r_id_ptr, IDRemapperApplyOptions options, ID *id_self=nullptr) const
bool contains_mappings_for_any(IDTypeFilter filter) const
bool is_viewport_compositor_enabled(const View3D &view_3d, const RegionView3D &region_view_3d)
void header_region(const bContext *C, ARegion *region)
void region_init(wmWindowManager *wm, ARegion *region)
void types_register(ARegionType *region_type, const int space_type)
void region_listen(const wmRegionListenerParams *params)
void region_on_poll_success(const bContext *C, ARegion *region)
void header_region_listen(const wmRegionListenerParams *params)
void region_on_user_resize(const ARegion *region)
int context(const bContext *C, const char *member, bContextDataResult *result)
int region_snap(const ARegion *region, int size, int axis)
void * region_duplicate(void *regiondata)
bool regions_poll(const RegionPollParams *params)
void header_region_init(wmWindowManager *wm, ARegion *region)
void region_draw(const bContext *C, ARegion *region)
void region_message_subscribe(const wmRegionMessageSubscribeParams *params)
void region_layout(const bContext *C, ARegion *region)
void region_free(ARegion *region)
MenuType node_group_operator_assets_menu_unassigned()
void VIEW3D_GGT_xform_gizmo_context(wmGizmoGroupType *gzgt)
void VIEW3D_GGT_xform_gizmo(wmGizmoGroupType *gzgt)
void VIEW3D_GGT_xform_cage(wmGizmoGroupType *gzgt)
void VIEW3D_GGT_xform_shear(wmGizmoGroupType *gzgt)
void VIEW3D_GGT_xform_extrude(wmGizmoGroupType *gzgt)
VecBase< T, 3 > transform_point(const CartesianBasis &basis, const VecBase< T, 3 > &v)
ARegionType * ED_area_type_hud(int space_type)
BMesh Iterators.
@ ID_REMAP_RESULT_SOURCE_UNASSIGNED
UserDef U
Definition blender.cc:58
void view3d_operatortypes()
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
const char * CTX_data_mode_string(const bContext *C)
@ V3D_PROJ_RET_OK
Definition ED_view3d.hh:273
@ V3D_RUNTIME_LOCAL_MAYBE_EMPTY
static void view3d_header_region_draw(const bContext *C, ARegion *region)
ScrArea * CTX_wm_area(const bContext *C)
void BKE_viewer_path_id_remap(ViewerPath *viewer_path, const bke::id::IDRemapper &mappings)
static void view3d_tools_header_region_draw(const bContext *C, ARegion *region)
Object * BKE_view_layer_active_object_get(const ViewLayer *view_layer)
void ED_view3d_clipping_local(RegionView3D *rv3d, const float mat[4][4])
static void view3d_buttons_region_init(wmWindowManager *wm, ARegion *region)
void ED_region_generic_tools_region_message_subscribe(const wmRegionMessageSubscribeParams *params)
Definition area_utils.cc:30
static void view3d_foreach_id(SpaceLink *space_link, LibraryForeachIDData *data)
static void view3d_buttons_region_layout(const bContext *C, ARegion *region)
Depsgraph * BKE_scene_get_depsgraph(const Scene *scene, const ViewLayer *view_layer)
Definition scene.cc:3631
void BLI_addhead(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:98
static void view3d_space_blend_write(BlendWriter *writer, SpaceLink *sl)
bool WM_cursor_set_from_tool(wmWindow *win, const ScrArea *area, const ARegion *region)
void VIEW3D_GT_navigate_rotate(wmGizmoType *gzt)
@ REGION_DRAW_LOCK_ALL
void WM_gizmotype_append(void(*gtfunc)(wmGizmoType *))
@ RGN_TYPE_ASSET_SHELF_HEADER
void ED_view3d_clear_mats_rv3d(RegionView3D *rv3d)
static void view3d_header_region_init(wmWindowManager *wm, ARegion *region)
void BKE_viewer_path_blend_read_data(BlendDataReader *reader, ViewerPath *viewer_path)
IDProperty * IDP_CopyProperty(const IDProperty *prop) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Definition idprop.cc:986
static void view3d_main_region_listener(const wmRegionListenerParams *params)
@ WM_JOB_TYPE_RENDER_PREVIEW
Definition WM_api.hh:2012
void VIEW3D_GGT_force_field(wmGizmoGroupType *gzgt)
static void view3d_id_remap(ScrArea *area, SpaceLink *slink, const bke::id::IDRemapper &mappings)
void VIEW3D_GGT_geometry_nodes(wmGizmoGroupType *gzgt)
void ED_region_panels_ex(const bContext *C, ARegion *region, wm::OpCallContext op_context, const char *contexts[])
Definition area.cc:3988
void VIEW3D_GGT_mesh_preselect_edgering(wmGizmoGroupType *gzgt)
void WM_draw_region_free(ARegion *region)
Definition wm_draw.cc:1788
void mul_m4_m4m4(float R[4][4], const float A[4][4], const float B[4][4])
wmWindow * CTX_wm_window(const bContext *C)
@ V3D_LOCAL_COLLECTIONS
@ V3D_XR_SESSION_MIRROR
static SpaceLink * view3d_duplicate(SpaceLink *sl)
enum eContextObjectMode CTX_data_mode_enum(const bContext *C)
void VIEW3D_GGT_empty_image(wmGizmoGroupType *gzgt)
void BKE_screen_view3d_shading_blend_read_data(BlendDataReader *reader, View3DShading *shading)
Definition screen.cc:1352
void VIEW3D_GGT_light_point(wmGizmoGroupType *gzgt)
void WM_msg_subscribe_rna_params(wmMsgBus *mbus, const wmMsgParams_RNA *msg_key_params, const wmMsgSubscribeValue *msg_val_params, const char *id_repr)
void WM_gizmomap_tag_refresh(wmGizmoMap *gzmap)
void ED_region_tag_redraw_cursor(ARegion *region)
Definition area.cc:720
ViewLayer * WM_window_get_active_view_layer(const wmWindow *win)
void ED_region_tag_redraw(ARegion *region)
Definition area.cc:681
LibraryForeachIDFlag BKE_lib_query_foreachid_process_flags_get(const LibraryForeachIDData *data)
Definition lib_query.cc:133
void VIEW3D_GGT_camera(wmGizmoGroupType *gzgt)
static void view3d_main_region_cursor(wmWindow *win, ScrArea *area, ARegion *region)
void view3d_dropboxes()
@ CTX_MODE_VERTEX_GREASE_PENCIL
@ CTX_MODE_PARTICLE
@ CTX_MODE_EDIT_TEXT
@ CTX_MODE_EDIT_SURFACE
@ CTX_MODE_PAINT_VERTEX
@ CTX_MODE_EDIT_GPENCIL_LEGACY
@ CTX_MODE_VERTEX_GPENCIL_LEGACY
@ CTX_MODE_WEIGHT_GPENCIL_LEGACY
@ CTX_MODE_SCULPT_CURVES
@ CTX_MODE_EDIT_ARMATURE
@ CTX_MODE_SCULPT
@ CTX_MODE_EDIT_CURVES
@ CTX_MODE_EDIT_LATTICE
@ CTX_MODE_PAINT_GREASE_PENCIL
@ CTX_MODE_PAINT_GPENCIL_LEGACY
@ CTX_MODE_SCULPT_GREASE_PENCIL
@ CTX_MODE_EDIT_POINTCLOUD
@ CTX_MODE_EDIT_MESH
@ CTX_MODE_PAINT_TEXTURE
@ CTX_MODE_SCULPT_GPENCIL_LEGACY
@ CTX_MODE_EDIT_METABALL
@ CTX_MODE_OBJECT
@ CTX_MODE_EDIT_GREASE_PENCIL
@ CTX_MODE_WEIGHT_GREASE_PENCIL
@ CTX_MODE_EDIT_CURVE
@ CTX_MODE_PAINT_WEIGHT
ViewLayer * CTX_data_view_layer(const bContext *C)
void ED_area_tag_redraw_regiontype(ScrArea *area, int regiontype)
Definition area.cc:802
void GPU_matrix_mul(const float m[4][4])
@ RGN_ALIGN_HIDE_WITH_PREV
static void view3d_main_region_exit(wmWindowManager *wm, ARegion *region)
static void view3d_free(SpaceLink *sl)
void VIEW3D_GGT_camera_view(wmGizmoGroupType *gzgt)
void BKE_viewer_path_foreach_id(LibraryForeachIDData *data, ViewerPath *viewer_path)
int view3d_context(const bContext *C, const char *member, bContextDataResult *result)
static void view3d_id_remap_v3d(ScrArea *area, SpaceLink *slink, View3D *v3d, const bke::id::IDRemapper &mappings, const bool is_local)
void DRW_engine_external_free(RegionView3D *rv3d)
static void view3d_main_region_message_subscribe(const wmRegionMessageSubscribeParams *params)
static void view3d_id_remap_v3d_ob_centers(View3D *v3d, const bke::id::IDRemapper &mappings)
wmEventHandler_Dropbox * WM_event_add_dropbox_handler(ListBaseT< wmEventHandler > *handlers, ListBaseT< wmDropBox > *dropboxes)
Scene * WM_window_get_active_scene(const wmWindow *win)
VecBase< float, 2 > float2
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
int ED_region_generic_panel_region_snap_size(const ARegion *region, int size, int axis)
Definition area_utils.cc:73
wmGizmoGroupTypeRef * WM_gizmogrouptype_append_and_link(wmGizmoMapType *gzmap_type, void(*wtfunc)(wmGizmoGroupType *))
void WM_toolsystem_do_msg_notify_tag_refresh(bContext *C, wmMsgSubscribeKey *, wmMsgSubscribeValue *msg_val)
Object * BKE_view_layer_edit_object_get(const ViewLayer *view_layer)
@ OB_MODE_PARTICLE_EDIT
BMesh const char void * data
static void view3d_header_region_listener(const wmRegionListenerParams *params)
void VIEW3D_GGT_tool_generic_handle_free(wmGizmoGroupType *gzgt)
void ED_view3d_local_stats_free(View3D *v3d)
void ED_region_header_with_button_sections(const bContext *C, ARegion *region, ui::ButtonSectionsAlign align)
Definition area.cc:4398
wmWindowManager * CTX_wm_manager(const bContext *C)
void VIEW3D_GGT_placement(wmGizmoGroupType *gzgt)
Depsgraph * CTX_data_ensure_evaluated_depsgraph(const bContext *C, bool rna_write_check=false)
void VIEW3D_GGT_mesh_preselect_elem(wmGizmoGroupType *gzgt)
void view3d_keymap(wmKeyConfig *keyconf)
void BKE_viewer_path_copy(ViewerPath *dst, const ViewerPath *src)
eV3DProjStatus ED_view3d_project_float_global(const ARegion *region, const float co[3], float r_co[2], eV3DProjTest flag)
void BKE_annotations_blend_read_data(struct BlendDataReader *reader, struct bGPdata *gpd)
constexpr size_t ARRAY_SIZE(const T(&arg)[N]) noexcept
void view3d_smooth_free(RegionView3D *rv3d)
bool BKE_view_layer_synced_ensure(const Main &bmain, const Scene *scene, ViewLayer *view_layer)
wmKeyMap * WM_keymap_ensure(wmKeyConfig *keyconf, const char *idname, int spaceid, int regionid)
Definition wm_keymap.cc:935
static void view3d_buttons_region_listener(const wmRegionListenerParams *params)
static void view3d_space_blend_read_data(BlendDataReader *reader, SpaceLink *sl)
void VIEW3D_GGT_light_spot(wmGizmoGroupType *gzgt)
void ED_view3d_init_mats_rv3d_gl(const Object *ob, RegionView3D *rv3d)
static void space_view3d_refresh(const bContext *C, ScrArea *area)
static void * view3d_main_region_duplicate(void *poin)
ARegionType * BKE_regiontype_from_id(const SpaceType *st, int regionid)
Definition screen.cc:364
SpaceType * BKE_spacetype_from_id(int spaceid)
Definition screen.cc:354
void ED_view3d_stop_render_preview(wmWindowManager *wm, ARegion *region)
void VIEW3D_GGT_light_target(wmGizmoGroupType *gzgt)
void ED_area_do_mgs_subscribe_for_tool_ui(const wmRegionMessageSubscribeParams *params)
Definition area.cc:442
void BKE_screen_view3d_sync(View3D *v3d, Scene *scene)
Definition screen.cc:1231
wmEventHandler_Keymap * WM_event_add_keymap_handler(ListBaseT< wmEventHandler > *handlers, wmKeyMap *keymap)
static void view3d_header_region_message_subscribe(const wmRegionMessageSubscribeParams *params)
ARegion * BKE_area_region_new()
Definition screen.cc:522
void ED_view3d_init_mats_rv3d(const Object *ob, RegionView3D *rv3d)
int ED_region_generic_tools_region_snap_size(const ARegion *region, int size, int axis)
Definition area_utils.cc:42
void ED_region_panels_layout_ex(const bContext *C, ARegion *region, ListBaseT< PanelType > *paneltypes, wm::OpCallContext op_context, const char *contexts[], const char *category_override)
Definition area.cc:3524
static void view3d_exit(wmWindowManager *, ScrArea *area)
void BKE_viewer_path_blend_write(BlendWriter *writer, const ViewerPath *viewer_path)
static void view3d_tools_region_init(wmWindowManager *wm, ARegion *region)
@ ED_KEYMAP_UI
Definition ED_screen.hh:852
@ ED_KEYMAP_FOOTER
Definition ED_screen.hh:859
@ ED_KEYMAP_HEADER
Definition ED_screen.hh:858
@ ED_KEYMAP_GPENCIL
Definition ED_screen.hh:860
@ ED_KEYMAP_TOOL
Definition ED_screen.hh:854
@ ED_KEYMAP_ASSET_SHELF
Definition ED_screen.hh:862
@ ED_KEYMAP_VIEW2D
Definition ED_screen.hh:855
@ ED_KEYMAP_FRAMES
Definition ED_screen.hh:857
@ ED_KEYMAP_GIZMO
Definition ED_screen.hh:853
void ED_view3d_buttons_region_layout_ex(const bContext *C, ARegion *region, const char *category_override)
void ED_render_view3d_update(Depsgraph *depsgraph, wmWindow *window, ScrArea *area, bool updated)
void BKE_screen_view3d_do_versions_250(View3D *v3d, ListBaseT< ARegion > *regions)
Definition screen.cc:1653
bool ED_localview_exit_if_empty(const Depsgraph *depsgraph, Scene *scene, ViewLayer *view_layer, wmWindowManager *wm, wmWindow *win, View3D *v3d, ScrArea *area, bool frame_selected=true, int smooth_viewtx=0)
@ V3D_SHADING_BACKGROUND_WORLD
void VIEW3D_GGT_armature_spline(wmGizmoGroupType *gzgt)
void VIEW3D_GGT_tool_generic_handle_normal(wmGizmoGroupType *gzgt)
void WM_jobs_kill_type(wmWindowManager *wm, const void *owner, int job_type)
Definition wm_jobs.cc:642
static void view3d_tools_region_draw(const bContext *C, ARegion *region)
@ WM_CURSOR_EDIT
Definition wm_cursors.hh:21
@ WM_CURSOR_DEFAULT
Definition wm_cursors.hh:17
void VIEW3D_GGT_light_area(wmGizmoGroupType *gzgt)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
Main * CTX_data_main(const bContext *C)
void IDP_FreeProperty(IDProperty *prop)
Definition idprop.cc:1403
bool WM_menutype_add(MenuType *mt)
void ED_spacetype_view3d()
void BKE_spacetype_register(std::unique_ptr< SpaceType > st)
Definition screen.cc:379
std::array< const char *, 4 > ED_view3d_buttons_contexts(const bContext *C)
static void view3d_widgets()
void VIEW3D_GGT_ruler(wmGizmoGroupType *gzgt)
@ V3D_PROJ_TEST_CLIP_NEAR
Definition ED_view3d.hh:298
void ED_region_header_init(ARegion *region)
Definition area.cc:4406
void VIEW3D_GT_ruler_item(wmGizmoType *gzt)
wmGizmoMapType * WM_gizmomaptype_ensure(const wmGizmoMapType_Params *gzmap_params)
void zero_m4(float m[4][4])
static SpaceLink * view3d_create(const ScrArea *, const Scene *scene)
void ED_view3d_check_mats_rv3d(RegionView3D *rv3d)
Scene * CTX_data_scene(const bContext *C)
void WM_cursor_set(wmWindow *win, int curs)
static void space_view3d_listener(const wmSpaceTypeListenerParams *params)
void VIEW3D_GGT_navigate(wmGizmoGroupType *gzgt)
void ED_area_do_mgs_subscribe_for_tool_header(const wmRegionMessageSubscribeParams *params)
Definition area.cc:427
void BKE_screen_view3d_shading_blend_write(BlendWriter *writer, View3DShading *shading)
Definition screen.cc:1345
@ RGN_FLAG_INDICATE_OVERFLOW
@ RGN_FLAG_HIDDEN_BY_USER
void ED_area_tag_refresh(ScrArea *area)
Definition area.cc:813
@ ID_REMAP_APPLY_DEFAULT
@ IDWALK_CB_DIRECT_WEAK_LINK
VecBase< float, 3 > float3
bool ED_view3d_area_user_region(const ScrArea *area, const View3D *v3d, ARegion **r_region)
void ED_region_do_msg_notify_tag_redraw(bContext *C, wmMsgSubscribeKey *msg_key, wmMsgSubscribeValue *msg_val)
Definition area.cc:394
static void view3d_main_region_init(wmWindowManager *wm, ARegion *region)
ListBaseT< wmDropBox > * WM_dropboxmap_find(const char *idname, int spaceid, int regionid)
void BKE_viewer_path_clear(ViewerPath *viewer_path)
void view3d_main_region_draw(const bContext *C, ARegion *region)
void ED_region_header(const bContext *C, ARegion *region)
Definition area.cc:4391
static void view3d_init(wmWindowManager *, ScrArea *)
void view3d_buttons_register(ARegionType *art)
void ED_region_panels_draw(const bContext *C, ARegion *region)
Definition area.cc:3916
void ED_region_panels_init(wmWindowManager *wm, ARegion *region)
Definition area.cc:4006
static void view3d_asset_shelf_region_init(wmWindowManager *wm, ARegion *region)
wmGizmoGroupType * WM_gizmogrouptype_append(void(*wtfunc)(wmGizmoGroupType *))
void ED_view3d_shade_update(Main *bmain, View3D *v3d, ScrArea *area)
static void view3d_main_region_free(ARegion *region)
const NodeType * type
Definition graph/node.h:179
void(*) exit(wmWindowManager *wm, ARegion *region)
void(*) on_user_resize(const ARegion *region)
void(*) cursor(wmWindow *win, ScrArea *area, ARegion *region)
ARegionTypeFlag flag
int(*) snap_size(const ARegion *region, int size, int axis)
void *(*) duplicate(void *poin)
void(*) on_poll_success(const bContext *C, ARegion *region)
void(*) message_subscribe(const wmRegionMessageSubscribeParams *params)
bContextDataCallback context
void(*) free(ARegion *)
void(*) draw(const bContext *C, ARegion *region)
void(*) listener(const wmRegionListenerParams *params)
void(*) layout(const bContext *C, ARegion *region)
bool(*) poll(const RegionPollParams *params)
std::optional< ARegionIMECursorState >(*) cursor_ime(wmWindow *win, const ScrArea *area, const ARegion *region, ARegionIMECursor *r_cursor)
ListBaseT< PanelType > paneltypes
void(*) init(wmWindowManager *wm, ARegion *region)
bke::ARegionRuntime * runtime
eRegion_Alignment alignment
eRegion_Type regiontype
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
ListBaseT< wmWindowManager > wm
Definition BKE_main.hh:415
StructRNA * type
Definition RNA_types.hh:63
struct RegionView3D * localvd
struct ViewRender * view_render
struct BoundBox * clipbb
struct wmTimer * smooth_timer
eRegionView3D_Persp persp
struct SmoothView3DStore * sms
eRegionView3D_ViewLock viewlock
eRegionView3D_View view
struct Object * camera
ListBaseT< ARegion > regionbase
ListBaseT< SpaceLink > spacedata
struct IDProperty * prop
eV3DShadingBackgroundType background_type
void(*) properties_storage_free(void *properties_storage)
eView3D_Flag2 flag2
struct Object * ob_center
struct Object * camera
View3DShading shading
ListBaseT< ARegion > regionbase
unsigned short local_collections_uid
struct View3D * localvd
View3D_Runtime runtime
DNA_DEPRECATED struct bGPdata * gpd
ListBaseT< wmEventHandler > handlers
struct ARegionType * type
unsigned int action
Definition WM_types.hh:371
unsigned int subtype
Definition WM_types.hh:371
unsigned int category
Definition WM_types.hh:371
unsigned int data
Definition WM_types.hh:371
#define WM_msg_subscribe_rna_anon_prop(mbus, type_, prop_, value)
#define WM_msg_subscribe_rna_anon_type(mbus, type_, value)