/* SPDX-License-Identifier: GPL-2.0-or-later * Copyright 2008 Blender Foundation. All rights reserved. */ /** \file * \ingroup spview3d */ /* Allow using deprecated functionality for .blend file I/O. */ #define DNA_DEPRECATED_ALLOW #include #include #include "DNA_collection_types.h" #include "DNA_defaults.h" #include "DNA_gpencil_types.h" #include "DNA_lightprobe_types.h" #include "DNA_material_types.h" #include "DNA_object_types.h" #include "DNA_scene_types.h" #include "DNA_view3d_types.h" #include "MEM_guardedalloc.h" #include "BLI_blenlib.h" #include "BLI_math.h" #include "BLI_utildefines.h" #include "BLT_translation.h" #include "BKE_asset.h" #include "BKE_context.h" #include "BKE_curve.h" #include "BKE_global.h" #include "BKE_gpencil.h" #include "BKE_icons.h" #include "BKE_idprop.h" #include "BKE_lattice.h" #include "BKE_layer.h" #include "BKE_lib_remap.h" #include "BKE_main.h" #include "BKE_mball.h" #include "BKE_mesh.h" #include "BKE_object.h" #include "BKE_scene.h" #include "BKE_screen.h" #include "BKE_viewer_path.h" #include "BKE_workspace.h" #include "ED_object.h" #include "ED_outliner.h" #include "ED_render.h" #include "ED_screen.h" #include "ED_space_api.h" #include "ED_transform.h" #include "ED_undo.h" #include "ED_viewer_path.hh" #include "GPU_matrix.h" #include "DRW_engine.h" #include "WM_api.h" #include "WM_message.h" #include "WM_toolsystem.h" #include "WM_types.h" #include "RE_engine.h" #include "RE_pipeline.h" #include "RNA_access.h" #include "UI_interface.h" #include "UI_resources.h" #include "BLO_read_write.h" #ifdef WITH_PYTHON # include "BPY_extern.h" #endif #include "DEG_depsgraph.h" #include "DEG_depsgraph_build.h" #include "view3d_intern.h" /* own include */ #include "view3d_navigate.h" /* ******************** manage regions ********************* */ RegionView3D *ED_view3d_context_rv3d(bContext *C) { RegionView3D *rv3d = CTX_wm_region_view3d(C); if (rv3d == nullptr) { ScrArea *area = CTX_wm_area(C); if (area && area->spacetype == SPACE_VIEW3D) { ARegion *region = BKE_area_find_region_active_win(area); if (region) { rv3d = static_cast(region->regiondata); } } } return rv3d; } bool ED_view3d_context_user_region(bContext *C, View3D **r_v3d, ARegion **r_region) { ScrArea *area = CTX_wm_area(C); *r_v3d = nullptr; *r_region = nullptr; if (area && area->spacetype == SPACE_VIEW3D) { ARegion *region = CTX_wm_region(C); View3D *v3d = (View3D *)area->spacedata.first; if (region) { RegionView3D *rv3d; if ((region->regiontype == RGN_TYPE_WINDOW) && (rv3d = static_cast(region->regiondata)) && (rv3d->viewlock & RV3D_LOCK_ROTATION) == 0) { *r_v3d = v3d; *r_region = region; return true; } if (ED_view3d_area_user_region(area, v3d, r_region)) { *r_v3d = v3d; return true; } } } return false; } bool ED_view3d_area_user_region(const ScrArea *area, const View3D *v3d, ARegion **r_region) { RegionView3D *rv3d = nullptr; ARegion *region_unlock_user = nullptr; ARegion *region_unlock = nullptr; const ListBase *region_list = (v3d == area->spacedata.first) ? &area->regionbase : &v3d->regionbase; BLI_assert(v3d->spacetype == SPACE_VIEW3D); LISTBASE_FOREACH (ARegion *, region, region_list) { /* find the first unlocked rv3d */ if (region->regiondata && region->regiontype == RGN_TYPE_WINDOW) { rv3d = static_cast(region->regiondata); if ((rv3d->viewlock & RV3D_LOCK_ROTATION) == 0) { region_unlock = region; if (ELEM(rv3d->persp, RV3D_PERSP, RV3D_CAMOB)) { region_unlock_user = region; break; } } } } /* camera/perspective view get priority when the active region is locked */ if (region_unlock_user) { *r_region = region_unlock_user; return true; } if (region_unlock) { *r_region = region_unlock; return true; } return false; } void ED_view3d_init_mats_rv3d(const struct Object *ob, struct RegionView3D *rv3d) { /* local viewmat and persmat, to calculate projections */ mul_m4_m4m4(rv3d->viewmatob, rv3d->viewmat, ob->object_to_world); mul_m4_m4m4(rv3d->persmatob, rv3d->persmat, ob->object_to_world); /* initializes object space clipping, speeds up clip tests */ ED_view3d_clipping_local(rv3d, ob->object_to_world); } void ED_view3d_init_mats_rv3d_gl(const struct Object *ob, struct RegionView3D *rv3d) { ED_view3d_init_mats_rv3d(ob, rv3d); /* We have to multiply instead of loading `viewmatob` to make * it work with duplis using display-lists, otherwise it will * override the dupli-matrix. */ GPU_matrix_mul(ob->object_to_world); } #ifdef DEBUG void ED_view3d_clear_mats_rv3d(struct RegionView3D *rv3d) { zero_m4(rv3d->viewmatob); zero_m4(rv3d->persmatob); } void ED_view3d_check_mats_rv3d(struct RegionView3D *rv3d) { BLI_ASSERT_ZERO_M4(rv3d->viewmatob); BLI_ASSERT_ZERO_M4(rv3d->persmatob); } #endif void ED_view3d_stop_render_preview(wmWindowManager *wm, ARegion *region) { RegionView3D *rv3d = static_cast(region->regiondata); if (rv3d->render_engine) { #ifdef WITH_PYTHON BPy_BEGIN_ALLOW_THREADS; #endif WM_jobs_kill_type(wm, region, WM_JOB_TYPE_RENDER_PREVIEW); #ifdef WITH_PYTHON BPy_END_ALLOW_THREADS; #endif RE_engine_free(rv3d->render_engine); rv3d->render_engine = nullptr; } /* A bit overkill but this make sure the viewport is reset completely. (fclem) */ WM_draw_region_free(region, false); } void ED_view3d_shade_update(Main *bmain, View3D *v3d, ScrArea *area) { wmWindowManager *wm = static_cast(bmain->wm.first); if (v3d->shading.type != OB_RENDER) { ARegion *region; for (region = static_cast(area->regionbase.first); region; region = region->next) { if ((region->regiontype == RGN_TYPE_WINDOW) && region->regiondata) { ED_view3d_stop_render_preview(wm, region); } } } } /* ******************** default callbacks for view3d space ***************** */ static SpaceLink *view3d_create(const ScrArea * /*area*/, const Scene *scene) { ARegion *region; View3D *v3d; RegionView3D *rv3d; v3d = DNA_struct_default_alloc(View3D); if (scene) { v3d->camera = scene->camera; } /* header */ region = MEM_cnew("header for view3d"); BLI_addtail(&v3d->regionbase, region); region->regiontype = RGN_TYPE_HEADER; region->alignment = (U.uiflag & USER_HEADER_BOTTOM) ? RGN_ALIGN_BOTTOM : RGN_ALIGN_TOP; /* tool header */ region = MEM_cnew("tool header for view3d"); BLI_addtail(&v3d->regionbase, region); region->regiontype = RGN_TYPE_TOOL_HEADER; region->alignment = (U.uiflag & USER_HEADER_BOTTOM) ? RGN_ALIGN_BOTTOM : RGN_ALIGN_TOP; region->flag = RGN_FLAG_HIDDEN | RGN_FLAG_HIDDEN_BY_USER; /* tool shelf */ region = MEM_cnew("toolshelf for view3d"); BLI_addtail(&v3d->regionbase, region); region->regiontype = RGN_TYPE_TOOLS; region->alignment = RGN_ALIGN_LEFT; region->flag = RGN_FLAG_HIDDEN; /* buttons/list view */ region = MEM_cnew("buttons for view3d"); BLI_addtail(&v3d->regionbase, region); region->regiontype = RGN_TYPE_UI; region->alignment = RGN_ALIGN_RIGHT; region->flag = RGN_FLAG_HIDDEN; /* main region */ region = MEM_cnew("main region for view3d"); BLI_addtail(&v3d->regionbase, region); region->regiontype = RGN_TYPE_WINDOW; region->regiondata = MEM_cnew("region view3d"); rv3d = static_cast(region->regiondata); rv3d->viewquat[0] = 1.0f; rv3d->persp = RV3D_PERSP; rv3d->view = RV3D_VIEW_USER; rv3d->dist = 10.0; return (SpaceLink *)v3d; } /* not spacelink itself */ static void view3d_free(SpaceLink *sl) { View3D *vd = (View3D *)sl; if (vd->localvd) { MEM_freeN(vd->localvd); } MEM_SAFE_FREE(vd->runtime.local_stats); if (vd->runtime.properties_storage) { MEM_freeN(vd->runtime.properties_storage); } if (vd->shading.prop) { IDP_FreeProperty(vd->shading.prop); vd->shading.prop = nullptr; } BKE_viewer_path_clear(&vd->viewer_path); } /* spacetype; init callback */ static void view3d_init(wmWindowManager * /*wm*/, ScrArea * /*area*/) { } static void view3d_exit(wmWindowManager * /*wm*/, ScrArea *area) { BLI_assert(area->spacetype == SPACE_VIEW3D); View3D *v3d = static_cast(area->spacedata.first); MEM_SAFE_FREE(v3d->runtime.local_stats); } static SpaceLink *view3d_duplicate(SpaceLink *sl) { View3D *v3do = (View3D *)sl; View3D *v3dn = static_cast(MEM_dupallocN(sl)); memset(&v3dn->runtime, 0x0, sizeof(v3dn->runtime)); /* clear or remove stuff from old */ if (v3dn->localvd) { v3dn->localvd = nullptr; } v3dn->local_collections_uuid = 0; v3dn->flag &= ~(V3D_LOCAL_COLLECTIONS | V3D_XR_SESSION_MIRROR); if (v3dn->shading.type == OB_RENDER) { v3dn->shading.type = OB_SOLID; } if (v3dn->shading.prop) { v3dn->shading.prop = IDP_CopyProperty(v3do->shading.prop); } BKE_viewer_path_copy(&v3dn->viewer_path, &v3do->viewer_path); /* copy or clear inside new stuff */ return (SpaceLink *)v3dn; } /* add handlers, stuff you only do once or on area/region changes */ static void view3d_main_region_init(wmWindowManager *wm, ARegion *region) { ListBase *lb; wmKeyMap *keymap; /* object ops. */ /* important to be before Pose keymap since they can both be enabled at once */ keymap = WM_keymap_ensure(wm->defaultconf, "Paint Face Mask (Weight, Vertex, Texture)", 0, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); keymap = WM_keymap_ensure(wm->defaultconf, "Paint Vertex Selection (Weight, Vertex)", 0, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); /* Before 'Weight/Vertex Paint' so adding curve points is not overridden. */ keymap = WM_keymap_ensure(wm->defaultconf, "Paint Curve", 0, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); /* Before 'Pose' so weight paint menus aren't overridden by pose menus. */ keymap = WM_keymap_ensure(wm->defaultconf, "Weight Paint", 0, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); keymap = WM_keymap_ensure(wm->defaultconf, "Vertex Paint", 0, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); /* pose is not modal, operator poll checks for this */ keymap = WM_keymap_ensure(wm->defaultconf, "Pose", 0, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); keymap = WM_keymap_ensure(wm->defaultconf, "Object Mode", 0, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); keymap = WM_keymap_ensure(wm->defaultconf, "Curve", 0, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); keymap = WM_keymap_ensure(wm->defaultconf, "Image Paint", 0, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); keymap = WM_keymap_ensure(wm->defaultconf, "Sculpt", 0, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); keymap = WM_keymap_ensure(wm->defaultconf, "Mesh", 0, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); keymap = WM_keymap_ensure(wm->defaultconf, "Armature", 0, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); keymap = WM_keymap_ensure(wm->defaultconf, "Metaball", 0, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); keymap = WM_keymap_ensure(wm->defaultconf, "Lattice", 0, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); keymap = WM_keymap_ensure(wm->defaultconf, "Particle", 0, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); keymap = WM_keymap_ensure(wm->defaultconf, "Sculpt Curves", 0, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); /* editfont keymap swallows all... */ keymap = WM_keymap_ensure(wm->defaultconf, "Font", 0, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); keymap = WM_keymap_ensure(wm->defaultconf, "Object Non-modal", 0, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); keymap = WM_keymap_ensure(wm->defaultconf, "Frames", 0, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); /* own keymap, last so modes can override it */ keymap = WM_keymap_ensure(wm->defaultconf, "3D View Generic", SPACE_VIEW3D, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); keymap = WM_keymap_ensure(wm->defaultconf, "3D View", SPACE_VIEW3D, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); /* add drop boxes */ lb = WM_dropboxmap_find("View3D", SPACE_VIEW3D, RGN_TYPE_WINDOW); WM_event_add_dropbox_handler(®ion->handlers, lb); } static void view3d_main_region_exit(wmWindowManager *wm, ARegion *region) { ED_view3d_stop_render_preview(wm, region); } static bool view3d_drop_in_main_region_poll(bContext *C, const wmEvent *event) { ScrArea *area = CTX_wm_area(C); return ED_region_overlap_isect_any_xy(area, event->xy) == false; } static ID_Type view3d_drop_id_in_main_region_poll_get_id_type(bContext *C, wmDrag *drag, const wmEvent *event) { const ScrArea *area = CTX_wm_area(C); if (ED_region_overlap_isect_any_xy(area, event->xy)) { return ID_Type(0); } if (!view3d_drop_in_main_region_poll(C, event)) { return ID_Type(0); } ID *local_id = WM_drag_get_local_ID(drag, 0); if (local_id) { return GS(local_id->name); } wmDragAsset *asset_drag = WM_drag_get_asset_data(drag, 0); if (asset_drag) { return ID_Type(asset_drag->id_type); } return ID_Type(0); } static bool view3d_drop_id_in_main_region_poll(bContext *C, wmDrag *drag, const wmEvent *event, ID_Type id_type) { if (!view3d_drop_in_main_region_poll(C, event)) { return false; } return WM_drag_is_ID_type(drag, id_type); } static void view3d_ob_drop_draw_activate(struct wmDropBox *drop, wmDrag *drag) { V3DSnapCursorState *state = static_cast(drop->draw_data); if (state) { return; } /* Don't use the snap cursor when linking the object. Object transform isn't editable then and * would be reset on reload. */ if (WM_drag_asset_will_import_linked(drag)) { return; } state = static_cast(ED_view3d_cursor_snap_active()); drop->draw_data = state; state->draw_plane = true; float dimensions[3] = {0.0f}; if (drag->type == WM_DRAG_ID) { Object *ob = (Object *)WM_drag_get_local_ID(drag, ID_OB); BKE_object_dimensions_get(ob, dimensions); } else { struct AssetMetaData *meta_data = WM_drag_get_asset_meta_data(drag, ID_OB); IDProperty *dimensions_prop = BKE_asset_metadata_idprop_find(meta_data, "dimensions"); if (dimensions_prop) { copy_v3_v3(dimensions, static_cast(IDP_Array(dimensions_prop))); } } if (!is_zero_v3(dimensions)) { mul_v3_v3fl(state->box_dimensions, dimensions, 0.5f); UI_GetThemeColor4ubv(TH_GIZMO_PRIMARY, state->color_box); state->draw_box = true; } } static void view3d_ob_drop_draw_deactivate(struct wmDropBox *drop, wmDrag * /*drag*/) { V3DSnapCursorState *state = static_cast(drop->draw_data); if (state) { ED_view3d_cursor_snap_deactive(state); drop->draw_data = nullptr; } } static bool view3d_ob_drop_poll(bContext *C, wmDrag *drag, const wmEvent *event) { return view3d_drop_id_in_main_region_poll(C, drag, event, ID_OB); } static bool view3d_ob_drop_poll_external_asset(bContext *C, wmDrag *drag, const wmEvent *event) { if (!view3d_ob_drop_poll(C, drag, event) || (drag->type != WM_DRAG_ASSET)) { return false; } return true; } /** * \note the term local here refers to not being an external asset, * poll will succeed for linked library objects. */ static bool view3d_ob_drop_poll_local_id(bContext *C, wmDrag *drag, const wmEvent *event) { if (!view3d_ob_drop_poll(C, drag, event) || (drag->type != WM_DRAG_ID)) { return false; } return true; } static bool view3d_collection_drop_poll(bContext *C, wmDrag *drag, const wmEvent *event) { return view3d_drop_id_in_main_region_poll(C, drag, event, ID_GR); } static bool view3d_collection_drop_poll_local_id(bContext *C, wmDrag *drag, const wmEvent *event) { if (!view3d_collection_drop_poll(C, drag, event) || (drag->type != WM_DRAG_ID)) { return false; } return true; } static bool view3d_collection_drop_poll_external_asset(bContext *C, wmDrag *drag, const wmEvent *event) { if (!view3d_collection_drop_poll(C, drag, event) || (drag->type != WM_DRAG_ASSET)) { return false; } return true; } static bool view3d_mat_drop_poll(bContext *C, wmDrag *drag, const wmEvent *event) { return view3d_drop_id_in_main_region_poll(C, drag, event, ID_MA); } static char *view3d_mat_drop_tooltip(bContext *C, wmDrag *drag, const int xy[2], wmDropBox * /*drop*/) { const char *name = WM_drag_get_item_name(drag); ARegion *region = CTX_wm_region(C); const int mval[2] = { xy[0] - region->winrct.xmin, xy[1] - region->winrct.ymin, }; return ED_object_ot_drop_named_material_tooltip(C, name, mval); } static bool view3d_world_drop_poll(bContext *C, wmDrag *drag, const wmEvent *event) { return view3d_drop_id_in_main_region_poll(C, drag, event, ID_WO); } static bool view3d_object_data_drop_poll(bContext *C, wmDrag *drag, const wmEvent *event) { ID_Type id_type = view3d_drop_id_in_main_region_poll_get_id_type(C, drag, event); if (id_type && OB_DATA_SUPPORT_ID(id_type)) { return true; } return false; } static char *view3d_object_data_drop_tooltip(bContext * /*C*/, wmDrag * /*drag*/, const int /*xy*/[2], wmDropBox * /*drop*/) { return BLI_strdup(TIP_("Create object instance from object-data")); } static bool view3d_ima_drop_poll(bContext *C, wmDrag *drag, const wmEvent *event) { if (ED_region_overlap_isect_any_xy(CTX_wm_area(C), event->xy)) { return false; } if (drag->type == WM_DRAG_PATH) { /* rule might not work? */ return ELEM(drag->icon, 0, ICON_FILE_IMAGE, ICON_FILE_MOVIE); } return WM_drag_is_ID_type(drag, ID_IM); } static bool view3d_ima_bg_is_camera_view(bContext *C) { RegionView3D *rv3d = CTX_wm_region_view3d(C); if (rv3d && (rv3d->persp == RV3D_CAMOB)) { View3D *v3d = CTX_wm_view3d(C); if (v3d && v3d->camera && v3d->camera->type == OB_CAMERA) { return true; } } return false; } static bool view3d_ima_bg_drop_poll(bContext *C, wmDrag *drag, const wmEvent *event) { if (!view3d_ima_drop_poll(C, drag, event)) { return false; } if (ED_view3d_is_object_under_cursor(C, event->mval)) { return false; } return view3d_ima_bg_is_camera_view(C); } static bool view3d_ima_empty_drop_poll(bContext *C, wmDrag *drag, const wmEvent *event) { if (!view3d_ima_drop_poll(C, drag, event)) { return false; } Object *ob = ED_view3d_give_object_under_cursor(C, event->mval); if (ob == nullptr) { return true; } if (ob->type == OB_EMPTY && ob->empty_drawtype == OB_EMPTY_IMAGE) { return true; } return false; } static bool view3d_volume_drop_poll(bContext * /*C*/, wmDrag *drag, const wmEvent * /*event*/) { return (drag->type == WM_DRAG_PATH) && (drag->icon == ICON_FILE_VOLUME); } static void view3d_ob_drop_matrix_from_snap(V3DSnapCursorState *snap_state, Object *ob, float obmat_final[4][4]) { V3DSnapCursorData *snap_data = ED_view3d_cursor_snap_data_get(); BLI_assert(snap_state->draw_box || snap_state->draw_plane); UNUSED_VARS_NDEBUG(snap_state); copy_m4_m3(obmat_final, snap_data->plane_omat); copy_v3_v3(obmat_final[3], snap_data->loc); float scale[3]; mat4_to_size(scale, ob->object_to_world); rescale_m4(obmat_final, scale); const BoundBox *bb = BKE_object_boundbox_get(ob); if (bb) { float offset[3]; BKE_boundbox_calc_center_aabb(bb, offset); offset[2] = bb->vec[0][2]; mul_mat3_m4_v3(obmat_final, offset); sub_v3_v3(obmat_final[3], offset); } } static void view3d_ob_drop_copy_local_id(bContext * /*C*/, wmDrag *drag, wmDropBox *drop) { ID *id = WM_drag_get_local_ID(drag, ID_OB); RNA_int_set(drop->ptr, "session_uuid", id->session_uuid); /* Don't duplicate ID's which were just imported. Only do that for existing, local IDs. */ BLI_assert(drag->type != WM_DRAG_ASSET); V3DSnapCursorState *snap_state = ED_view3d_cursor_snap_state_get(); float obmat_final[4][4]; view3d_ob_drop_matrix_from_snap(snap_state, (Object *)id, obmat_final); RNA_float_set_array(drop->ptr, "matrix", &obmat_final[0][0]); } /* Mostly the same logic as #view3d_collection_drop_copy_external_asset(), just different enough to * make sharing code a bit difficult. */ static void view3d_ob_drop_copy_external_asset(bContext * /*C*/, wmDrag *drag, wmDropBox *drop) { /* NOTE(@campbellbarton): Selection is handled here, de-selecting objects before append, * using auto-select to ensure the new objects are selected. * This is done so #OBJECT_OT_transform_to_mouse (which runs after this drop handler) * can use the context setup here to place the objects. */ BLI_assert(drag->type == WM_DRAG_ASSET); wmDragAsset *asset_drag = WM_drag_get_asset_data(drag, 0); bContext *C = asset_drag->evil_C; Scene *scene = CTX_data_scene(C); ViewLayer *view_layer = CTX_data_view_layer(C); BKE_view_layer_base_deselect_all(scene, view_layer); ID *id = WM_drag_asset_id_import(asset_drag, FILE_AUTOSELECT); /* TODO(sergey): Only update relations for the current scene. */ DEG_relations_tag_update(CTX_data_main(C)); WM_event_add_notifier(C, NC_SCENE | ND_LAYER_CONTENT, scene); RNA_int_set(drop->ptr, "session_uuid", id->session_uuid); BKE_view_layer_synced_ensure(scene, view_layer); Base *base = BKE_view_layer_base_find(view_layer, (Object *)id); if (base != nullptr) { BKE_view_layer_base_select_and_set_active(view_layer, base); WM_main_add_notifier(NC_SCENE | ND_OB_ACTIVE, scene); } DEG_id_tag_update(&scene->id, ID_RECALC_SELECT); ED_outliner_select_sync_from_object_tag(C); V3DSnapCursorState *snap_state = static_cast(drop->draw_data); if (snap_state) { float obmat_final[4][4]; view3d_ob_drop_matrix_from_snap(snap_state, (Object *)id, obmat_final); RNA_float_set_array(drop->ptr, "matrix", &obmat_final[0][0]); } } static void view3d_collection_drop_copy_local_id(bContext * /*C*/, wmDrag *drag, wmDropBox *drop) { ID *id = WM_drag_get_local_ID(drag, ID_GR); RNA_int_set(drop->ptr, "session_uuid", int(id->session_uuid)); } /* Mostly the same logic as #view3d_ob_drop_copy_external_asset(), just different enough to make * sharing code a bit difficult. */ static void view3d_collection_drop_copy_external_asset(bContext * /*C*/, wmDrag *drag, wmDropBox *drop) { BLI_assert(drag->type == WM_DRAG_ASSET); wmDragAsset *asset_drag = WM_drag_get_asset_data(drag, 0); bContext *C = asset_drag->evil_C; Scene *scene = CTX_data_scene(C); ViewLayer *view_layer = CTX_data_view_layer(C); BKE_view_layer_base_deselect_all(scene, view_layer); ID *id = WM_drag_asset_id_import(asset_drag, FILE_AUTOSELECT); Collection *collection = (Collection *)id; /* TODO(sergey): Only update relations for the current scene. */ DEG_relations_tag_update(CTX_data_main(C)); WM_event_add_notifier(C, NC_SCENE | ND_LAYER_CONTENT, scene); RNA_int_set(drop->ptr, "session_uuid", int(id->session_uuid)); /* Make an object active, just use the first one in the collection. */ CollectionObject *cobject = static_cast(collection->gobject.first); BKE_view_layer_synced_ensure(scene, view_layer); Base *base = cobject ? BKE_view_layer_base_find(view_layer, cobject->ob) : nullptr; if (base) { BLI_assert((base->flag & BASE_SELECTABLE) && (base->flag & BASE_ENABLED_VIEWPORT)); BKE_view_layer_base_select_and_set_active(view_layer, base); WM_main_add_notifier(NC_SCENE | ND_OB_ACTIVE, scene); } DEG_id_tag_update(&scene->id, ID_RECALC_SELECT); ED_outliner_select_sync_from_object_tag(C); /* XXX Without an undo push here, there will be a crash when the user modifies operator * properties. The stuff we do in these drop callbacks just isn't safe over undo/redo. */ ED_undo_push(C, "Collection_Drop"); } static void view3d_id_drop_copy(bContext * /*C*/, wmDrag *drag, wmDropBox *drop) { ID *id = WM_drag_get_local_ID_or_import_from_asset(drag, 0); WM_operator_properties_id_lookup_set_from_id(drop->ptr, id); } static void view3d_id_drop_copy_with_type(bContext * /*C*/, wmDrag *drag, wmDropBox *drop) { ID *id = WM_drag_get_local_ID_or_import_from_asset(drag, 0); RNA_enum_set(drop->ptr, "type", GS(id->name)); WM_operator_properties_id_lookup_set_from_id(drop->ptr, id); } static void view3d_id_path_drop_copy(bContext * /*C*/, wmDrag *drag, wmDropBox *drop) { ID *id = WM_drag_get_local_ID_or_import_from_asset(drag, 0); if (id) { WM_operator_properties_id_lookup_set_from_id(drop->ptr, id); RNA_struct_property_unset(drop->ptr, "filepath"); } else if (drag->path[0]) { RNA_string_set(drop->ptr, "filepath", drag->path); RNA_struct_property_unset(drop->ptr, "image"); } } static void view3d_lightcache_update(bContext *C) { PointerRNA op_ptr; Scene *scene = CTX_data_scene(C); if (!BKE_scene_uses_blender_eevee(scene)) { /* Only do auto bake if eevee is the active engine */ return; } wmOperatorType *ot = WM_operatortype_find("SCENE_OT_light_cache_bake", true); WM_operator_properties_create_ptr(&op_ptr, ot); RNA_int_set(&op_ptr, "delay", 200); RNA_enum_set_identifier(C, &op_ptr, "subset", "DIRTY"); WM_operator_name_call_ptr(C, ot, WM_OP_INVOKE_DEFAULT, &op_ptr, nullptr); WM_operator_properties_free(&op_ptr); } /* region dropbox definition */ static void view3d_dropboxes() { ListBase *lb = WM_dropboxmap_find("View3D", SPACE_VIEW3D, RGN_TYPE_WINDOW); struct wmDropBox *drop; drop = WM_dropbox_add(lb, "OBJECT_OT_add_named", view3d_ob_drop_poll_local_id, view3d_ob_drop_copy_local_id, WM_drag_free_imported_drag_ID, nullptr); drop->draw_droptip = WM_drag_draw_item_name_fn; drop->draw_activate = view3d_ob_drop_draw_activate; drop->draw_deactivate = view3d_ob_drop_draw_deactivate; drop = WM_dropbox_add(lb, "OBJECT_OT_transform_to_mouse", view3d_ob_drop_poll_external_asset, view3d_ob_drop_copy_external_asset, WM_drag_free_imported_drag_ID, nullptr); drop->draw_droptip = WM_drag_draw_item_name_fn; drop->draw_activate = view3d_ob_drop_draw_activate; drop->draw_deactivate = view3d_ob_drop_draw_deactivate; WM_dropbox_add(lb, "OBJECT_OT_collection_external_asset_drop", view3d_collection_drop_poll_external_asset, view3d_collection_drop_copy_external_asset, WM_drag_free_imported_drag_ID, nullptr); WM_dropbox_add(lb, "OBJECT_OT_collection_instance_add", view3d_collection_drop_poll_local_id, view3d_collection_drop_copy_local_id, WM_drag_free_imported_drag_ID, nullptr); WM_dropbox_add(lb, "OBJECT_OT_drop_named_material", view3d_mat_drop_poll, view3d_id_drop_copy, WM_drag_free_imported_drag_ID, view3d_mat_drop_tooltip); WM_dropbox_add(lb, "VIEW3D_OT_background_image_add", view3d_ima_bg_drop_poll, view3d_id_path_drop_copy, WM_drag_free_imported_drag_ID, nullptr); WM_dropbox_add(lb, "OBJECT_OT_drop_named_image", view3d_ima_empty_drop_poll, view3d_id_path_drop_copy, WM_drag_free_imported_drag_ID, nullptr); WM_dropbox_add(lb, "OBJECT_OT_volume_import", view3d_volume_drop_poll, view3d_id_path_drop_copy, WM_drag_free_imported_drag_ID, nullptr); WM_dropbox_add(lb, "OBJECT_OT_data_instance_add", view3d_object_data_drop_poll, view3d_id_drop_copy_with_type, WM_drag_free_imported_drag_ID, view3d_object_data_drop_tooltip); WM_dropbox_add(lb, "VIEW3D_OT_drop_world", view3d_world_drop_poll, view3d_id_drop_copy, WM_drag_free_imported_drag_ID, nullptr); } static void view3d_widgets() { wmGizmoMapType_Params params{SPACE_VIEW3D, RGN_TYPE_WINDOW}; wmGizmoMapType *gzmap_type = WM_gizmomaptype_ensure(¶ms); WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_xform_gizmo_context); WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_light_spot); WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_light_area); WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_light_target); WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_force_field); WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_camera); WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_camera_view); WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_empty_image); /* TODO(@campbellbarton): Not working well enough, disable for now. */ #if 0 WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_armature_spline); #endif WM_gizmogrouptype_append(VIEW3D_GGT_xform_gizmo); WM_gizmogrouptype_append(VIEW3D_GGT_xform_cage); WM_gizmogrouptype_append(VIEW3D_GGT_xform_shear); WM_gizmogrouptype_append(VIEW3D_GGT_xform_extrude); WM_gizmogrouptype_append(VIEW3D_GGT_mesh_preselect_elem); WM_gizmogrouptype_append(VIEW3D_GGT_mesh_preselect_edgering); WM_gizmogrouptype_append(VIEW3D_GGT_tool_generic_handle_normal); WM_gizmogrouptype_append(VIEW3D_GGT_tool_generic_handle_free); WM_gizmogrouptype_append(VIEW3D_GGT_ruler); WM_gizmotype_append(VIEW3D_GT_ruler_item); WM_gizmogrouptype_append(VIEW3D_GGT_placement); WM_gizmogrouptype_append_and_link(gzmap_type, VIEW3D_GGT_navigate); WM_gizmotype_append(VIEW3D_GT_navigate_rotate); } /* type callback, not region itself */ static void view3d_main_region_free(ARegion *region) { RegionView3D *rv3d = static_cast(region->regiondata); if (rv3d) { if (rv3d->localvd) { MEM_freeN(rv3d->localvd); } if (rv3d->clipbb) { MEM_freeN(rv3d->clipbb); } if (rv3d->render_engine) { RE_engine_free(rv3d->render_engine); } if (rv3d->sms) { MEM_freeN(rv3d->sms); } MEM_freeN(rv3d); region->regiondata = nullptr; } } /* copy regiondata */ static void *view3d_main_region_duplicate(void *poin) { if (poin) { RegionView3D *rv3d = static_cast(poin); RegionView3D *new_rv3d; new_rv3d = static_cast(MEM_dupallocN(rv3d)); if (rv3d->localvd) { new_rv3d->localvd = static_cast(MEM_dupallocN(rv3d->localvd)); } if (rv3d->clipbb) { new_rv3d->clipbb = static_cast(MEM_dupallocN(rv3d->clipbb)); } new_rv3d->render_engine = nullptr; new_rv3d->sms = nullptr; new_rv3d->smooth_timer = nullptr; return new_rv3d; } return nullptr; } static void view3d_main_region_listener(const wmRegionListenerParams *params) { wmWindow *window = params->window; ScrArea *area = params->area; ARegion *region = params->region; const wmNotifier *wmn = params->notifier; const Scene *scene = params->scene; View3D *v3d = static_cast(area->spacedata.first); RegionView3D *rv3d = static_cast(region->regiondata); wmGizmoMap *gzmap = region->gizmo_map; /* context changes */ switch (wmn->category) { case NC_WM: if (ELEM(wmn->data, ND_UNDO)) { WM_gizmomap_tag_refresh(gzmap); } else if (ELEM(wmn->data, ND_XR_DATA_CHANGED)) { /* Only cause a redraw if this a VR session mirror. Should more features be added that * require redraws, we could pass something to wmn->reference, e.g. the flag value. */ if (v3d->flag & V3D_XR_SESSION_MIRROR) { ED_region_tag_redraw(region); } } break; case NC_ANIMATION: switch (wmn->data) { case ND_KEYFRAME_PROP: case ND_NLA_ACTCHANGE: ED_region_tag_redraw(region); break; case ND_NLA: case ND_KEYFRAME: if (ELEM(wmn->action, NA_EDITED, NA_ADDED, NA_REMOVED)) { ED_region_tag_redraw(region); } break; case ND_ANIMCHAN: if (ELEM(wmn->action, NA_EDITED, NA_ADDED, NA_REMOVED, NA_SELECTED)) { ED_region_tag_redraw(region); } break; } break; case NC_SCENE: switch (wmn->data) { case ND_SCENEBROWSE: case ND_LAYER_CONTENT: ED_region_tag_redraw(region); WM_gizmomap_tag_refresh(gzmap); break; case ND_LAYER: if (wmn->reference) { BKE_screen_view3d_sync(v3d, static_cast(wmn->reference)); } ED_region_tag_redraw(region); WM_gizmomap_tag_refresh(gzmap); break; case ND_OB_ACTIVE: case ND_OB_SELECT: ATTR_FALLTHROUGH; case ND_FRAME: case ND_TRANSFORM: case ND_OB_VISIBLE: case ND_RENDER_OPTIONS: case ND_MARKERS: case ND_MODE: ED_region_tag_redraw(region); WM_gizmomap_tag_refresh(gzmap); break; case ND_WORLD: /* handled by space_view3d_listener() for v3d access */ break; case ND_DRAW_RENDER_VIEWPORT: { if (v3d->camera && (scene == wmn->reference)) { if (rv3d->persp == RV3D_CAMOB) { ED_region_tag_redraw(region); } } break; } } if (wmn->action == NA_EDITED) { ED_region_tag_redraw(region); } break; case NC_OBJECT: switch (wmn->data) { case ND_BONE_ACTIVE: case ND_BONE_SELECT: case ND_TRANSFORM: case ND_POSE: case ND_DRAW: case ND_MODIFIER: case ND_SHADERFX: case ND_CONSTRAINT: case ND_KEYS: case ND_PARTICLE: case ND_POINTCACHE: case ND_LOD: ED_region_tag_redraw(region); WM_gizmomap_tag_refresh(gzmap); break; case ND_DRAW_ANIMVIZ: ED_region_tag_redraw(region); break; } switch (wmn->action) { case NA_ADDED: ED_region_tag_redraw(region); break; } break; case NC_GEOM: switch (wmn->data) { case ND_SELECT: { WM_gizmomap_tag_refresh(gzmap); ATTR_FALLTHROUGH; } case ND_DATA: ED_region_tag_redraw(region); WM_gizmomap_tag_refresh(gzmap); break; case ND_VERTEX_GROUP: ED_region_tag_redraw(region); break; } switch (wmn->action) { case NA_EDITED: ED_region_tag_redraw(region); break; } break; case NC_CAMERA: switch (wmn->data) { case ND_DRAW_RENDER_VIEWPORT: { if (v3d->camera && (v3d->camera->data == wmn->reference)) { if (rv3d->persp == RV3D_CAMOB) { ED_region_tag_redraw(region); } } break; } } break; case NC_GROUP: /* all group ops for now */ ED_region_tag_redraw(region); break; case NC_BRUSH: switch (wmn->action) { case NA_EDITED: ED_region_tag_redraw_cursor(region); break; case NA_SELECTED: /* used on brush changes - needed because 3d cursor * has to be drawn if clone brush is selected */ ED_region_tag_redraw(region); break; } break; case NC_MATERIAL: switch (wmn->data) { case ND_SHADING: case ND_NODES: /* TODO(sergey): This is a bit too much updates, but needed to * have proper material drivers update in the viewport. * * How to solve? */ ED_region_tag_redraw(region); break; case ND_SHADING_DRAW: case ND_SHADING_LINKS: ED_region_tag_redraw(region); break; } break; case NC_NODE: ED_region_tag_redraw(region); break; case NC_WORLD: switch (wmn->data) { case ND_WORLD_DRAW: /* handled by space_view3d_listener() for v3d access */ break; case ND_WORLD: /* Needed for updating world materials */ ED_region_tag_redraw(region); break; } break; case NC_LAMP: switch (wmn->data) { case ND_LIGHTING: /* TODO(sergey): This is a bit too much, but needed to * handle updates from new depsgraph. */ ED_region_tag_redraw(region); break; case ND_LIGHTING_DRAW: ED_region_tag_redraw(region); WM_gizmomap_tag_refresh(gzmap); break; } break; case NC_LIGHTPROBE: ED_area_tag_refresh(area); break; case NC_IMAGE: /* this could be more fine grained checks if we had * more context than just the region */ ED_region_tag_redraw(region); break; case NC_TEXTURE: /* same as above */ ED_region_tag_redraw(region); break; case NC_MOVIECLIP: if (wmn->data == ND_DISPLAY || wmn->action == NA_EDITED) { ED_region_tag_redraw(region); } break; case NC_SPACE: if (wmn->data == ND_SPACE_VIEW3D) { if (wmn->subtype == NS_VIEW3D_GPU) { rv3d->rflag |= RV3D_GPULIGHT_UPDATE; } else if (wmn->subtype == NS_VIEW3D_SHADING) { #ifdef WITH_XR_OPENXR ED_view3d_xr_shading_update( static_cast(G_MAIN->wm.first), v3d, scene); #endif ViewLayer *view_layer = WM_window_get_active_view_layer(window); Depsgraph *depsgraph = BKE_scene_get_depsgraph(scene, view_layer); if (depsgraph) { ED_render_view3d_update(depsgraph, window, area, true); } } ED_region_tag_redraw(region); WM_gizmomap_tag_refresh(gzmap); } break; case NC_ID: if (ELEM(wmn->action, NA_RENAME, NA_EDITED, NA_ADDED, NA_REMOVED)) { ED_region_tag_redraw(region); } break; case NC_SCREEN: switch (wmn->data) { case ND_ANIMPLAY: case ND_SKETCH: ED_region_tag_redraw(region); break; case ND_LAYOUTBROWSE: case ND_LAYOUTDELETE: case ND_LAYOUTSET: WM_gizmomap_tag_refresh(gzmap); ED_region_tag_redraw(region); break; case ND_LAYER: ED_region_tag_redraw(region); break; } break; case NC_GPENCIL: if (wmn->data == ND_DATA || ELEM(wmn->action, NA_EDITED, NA_SELECTED)) { ED_region_tag_redraw(region); } break; case NC_WORKSPACE: /* In case the region displays workspace settings. */ ED_region_tag_redraw(region); break; case NC_VIEWER_PATH: { if (v3d->flag2 & V3D_SHOW_VIEWER) { ViewLayer *view_layer = WM_window_get_active_view_layer(window); if (Depsgraph *depsgraph = BKE_scene_get_depsgraph(scene, view_layer)) { ED_render_view3d_update(depsgraph, window, area, true); } ED_region_tag_redraw(region); } break; } } } static void view3d_do_msg_notify_workbench_view_update(struct bContext *C, struct wmMsgSubscribeKey * /*msg_key*/, struct wmMsgSubscribeValue *msg_val) { Scene *scene = CTX_data_scene(C); ScrArea *area = (ScrArea *)msg_val->user_data; View3D *v3d = (View3D *)area->spacedata.first; if (v3d->shading.type == OB_SOLID) { RenderEngineType *engine_type = ED_view3d_engine_type(scene, v3d->shading.type); DRWUpdateContext drw_context = {nullptr}; drw_context.bmain = CTX_data_main(C); drw_context.depsgraph = CTX_data_depsgraph_pointer(C); drw_context.scene = scene; drw_context.view_layer = CTX_data_view_layer(C); drw_context.region = (ARegion *)(msg_val->owner); drw_context.v3d = v3d; drw_context.engine_type = engine_type; DRW_notify_view_update(&drw_context); } } static void view3d_main_region_message_subscribe(const wmRegionMessageSubscribeParams *params) { struct wmMsgBus *mbus = params->message_bus; const bContext *C = params->context; ScrArea *area = params->area; ARegion *region = params->region; /* Developer NOTE: there are many properties that impact 3D view drawing, * so instead of subscribing to individual properties, just subscribe to types * accepting some redundant redraws. * * For other space types we might try avoid this, keep the 3D view as an exceptional case! */ wmMsgParams_RNA msg_key_params{}; /* Only subscribe to types. */ StructRNA *type_array[] = { &RNA_Window, /* These object have properties that impact drawing. */ &RNA_AreaLight, &RNA_Camera, &RNA_Light, &RNA_Speaker, &RNA_SunLight, /* General types the 3D view depends on. */ &RNA_Object, &RNA_UnitSettings, /* grid-floor */ &RNA_View3DCursor, &RNA_View3DOverlay, &RNA_View3DShading, &RNA_World, }; wmMsgSubscribeValue msg_sub_value_region_tag_redraw{}; msg_sub_value_region_tag_redraw.owner = region; msg_sub_value_region_tag_redraw.user_data = region; msg_sub_value_region_tag_redraw.notify = ED_region_do_msg_notify_tag_redraw; wmMsgSubscribeValue msg_sub_value_workbench_view_update{}; msg_sub_value_workbench_view_update.owner = region; msg_sub_value_workbench_view_update.user_data = area; msg_sub_value_workbench_view_update.notify = view3d_do_msg_notify_workbench_view_update; for (int i = 0; i < ARRAY_SIZE(type_array); i++) { msg_key_params.ptr.type = type_array[i]; WM_msg_subscribe_rna_params(mbus, &msg_key_params, &msg_sub_value_region_tag_redraw, __func__); } /* Subscribe to a handful of other properties. */ RegionView3D *rv3d = static_cast(region->regiondata); WM_msg_subscribe_rna_anon_prop(mbus, RenderSettings, engine, &msg_sub_value_region_tag_redraw); WM_msg_subscribe_rna_anon_prop( mbus, RenderSettings, resolution_x, &msg_sub_value_region_tag_redraw); WM_msg_subscribe_rna_anon_prop( mbus, RenderSettings, resolution_y, &msg_sub_value_region_tag_redraw); WM_msg_subscribe_rna_anon_prop( mbus, RenderSettings, pixel_aspect_x, &msg_sub_value_region_tag_redraw); WM_msg_subscribe_rna_anon_prop( mbus, RenderSettings, pixel_aspect_y, &msg_sub_value_region_tag_redraw); if (rv3d->persp == RV3D_CAMOB) { WM_msg_subscribe_rna_anon_prop( mbus, RenderSettings, use_border, &msg_sub_value_region_tag_redraw); } WM_msg_subscribe_rna_anon_type(mbus, SceneEEVEE, &msg_sub_value_region_tag_redraw); WM_msg_subscribe_rna_anon_type(mbus, SceneDisplay, &msg_sub_value_region_tag_redraw); WM_msg_subscribe_rna_anon_type(mbus, ObjectDisplay, &msg_sub_value_region_tag_redraw); const Scene *scene = CTX_data_scene(C); ViewLayer *view_layer = CTX_data_view_layer(C); BKE_view_layer_synced_ensure(scene, view_layer); Object *obact = BKE_view_layer_active_object_get(view_layer); if (obact != nullptr) { switch (obact->mode) { case OB_MODE_PARTICLE_EDIT: WM_msg_subscribe_rna_anon_type(mbus, ParticleEdit, &msg_sub_value_region_tag_redraw); break; case OB_MODE_SCULPT: WM_msg_subscribe_rna_anon_prop( mbus, WorkSpace, tools, &msg_sub_value_workbench_view_update); break; default: break; } } { wmMsgSubscribeValue msg_sub_value_region_tag_refresh{}; msg_sub_value_region_tag_refresh.owner = region; msg_sub_value_region_tag_refresh.user_data = area; msg_sub_value_region_tag_refresh.notify = WM_toolsystem_do_msg_notify_tag_refresh; WM_msg_subscribe_rna_anon_prop(mbus, Object, mode, &msg_sub_value_region_tag_refresh); WM_msg_subscribe_rna_anon_prop(mbus, LayerObjects, active, &msg_sub_value_region_tag_refresh); } } /* concept is to retrieve cursor type context-less */ static void view3d_main_region_cursor(wmWindow *win, ScrArea *area, ARegion *region) { if (WM_cursor_set_from_tool(win, area, region)) { return; } Scene *scene = WM_window_get_active_scene(win); ViewLayer *view_layer = WM_window_get_active_view_layer(win); BKE_view_layer_synced_ensure(scene, view_layer); Object *obedit = BKE_view_layer_edit_object_get(view_layer); if (obedit) { WM_cursor_set(win, WM_CURSOR_EDIT); } else { WM_cursor_set(win, WM_CURSOR_DEFAULT); } } /* add handlers, stuff you only do once or on area/region changes */ static void view3d_header_region_init(wmWindowManager *wm, ARegion *region) { wmKeyMap *keymap = WM_keymap_ensure(wm->defaultconf, "3D View Generic", SPACE_VIEW3D, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); ED_region_header_init(region); } static void view3d_header_region_draw(const bContext *C, ARegion *region) { ED_region_header(C, region); } static void view3d_header_region_listener(const wmRegionListenerParams *params) { ARegion *region = params->region; const wmNotifier *wmn = params->notifier; /* context changes */ switch (wmn->category) { case NC_SCENE: switch (wmn->data) { case ND_FRAME: case ND_OB_ACTIVE: case ND_OB_SELECT: case ND_OB_VISIBLE: case ND_MODE: case ND_LAYER: case ND_TOOLSETTINGS: case ND_LAYER_CONTENT: case ND_RENDER_OPTIONS: ED_region_tag_redraw(region); break; } break; case NC_SPACE: if (wmn->data == ND_SPACE_VIEW3D) { ED_region_tag_redraw(region); } break; case NC_GPENCIL: if (wmn->data & ND_GPENCIL_EDITMODE) { ED_region_tag_redraw(region); } else if (wmn->action == NA_EDITED) { ED_region_tag_redraw(region); } break; case NC_BRUSH: ED_region_tag_redraw(region); break; } /* From top-bar, which ones are needed? split per header? */ /* Disable for now, re-enable if needed, or remove - campbell. */ #if 0 /* context changes */ switch (wmn->category) { case NC_WM: if (wmn->data == ND_HISTORY) { ED_region_tag_redraw(region); } break; case NC_SCENE: if (wmn->data == ND_MODE) { ED_region_tag_redraw(region); } break; case NC_SPACE: if (wmn->data == ND_SPACE_VIEW3D) { ED_region_tag_redraw(region); } break; case NC_GPENCIL: if (wmn->data == ND_DATA) { ED_region_tag_redraw(region); } break; } #endif } static void view3d_header_region_message_subscribe(const wmRegionMessageSubscribeParams *params) { struct wmMsgBus *mbus = params->message_bus; ARegion *region = params->region; wmMsgParams_RNA msg_key_params{}; /* Only subscribe to types. */ StructRNA *type_array[] = { &RNA_View3DShading, }; wmMsgSubscribeValue msg_sub_value_region_tag_redraw{}; msg_sub_value_region_tag_redraw.owner = region; msg_sub_value_region_tag_redraw.user_data = region; msg_sub_value_region_tag_redraw.notify = ED_region_do_msg_notify_tag_redraw; for (int i = 0; i < ARRAY_SIZE(type_array); i++) { msg_key_params.ptr.type = type_array[i]; WM_msg_subscribe_rna_params(mbus, &msg_key_params, &msg_sub_value_region_tag_redraw, __func__); } } /* add handlers, stuff you only do once or on area/region changes */ static void view3d_buttons_region_init(wmWindowManager *wm, ARegion *region) { wmKeyMap *keymap; ED_region_panels_init(wm, region); keymap = WM_keymap_ensure(wm->defaultconf, "3D View Generic", SPACE_VIEW3D, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); } void ED_view3d_buttons_region_layout_ex(const bContext *C, ARegion *region, const char *category_override) { const enum eContextObjectMode mode = CTX_data_mode_enum(C); const char *contexts_base[4] = {nullptr}; contexts_base[0] = CTX_data_mode_string(C); const char **contexts = &contexts_base[1]; switch (mode) { case CTX_MODE_EDIT_MESH: ARRAY_SET_ITEMS(contexts, ".mesh_edit"); break; case CTX_MODE_EDIT_CURVE: ARRAY_SET_ITEMS(contexts, ".curve_edit"); break; case CTX_MODE_EDIT_CURVES: ARRAY_SET_ITEMS(contexts, ".curves_edit"); break; case CTX_MODE_EDIT_SURFACE: ARRAY_SET_ITEMS(contexts, ".curve_edit"); break; case CTX_MODE_EDIT_TEXT: ARRAY_SET_ITEMS(contexts, ".text_edit"); break; case CTX_MODE_EDIT_ARMATURE: ARRAY_SET_ITEMS(contexts, ".armature_edit"); break; case CTX_MODE_EDIT_METABALL: ARRAY_SET_ITEMS(contexts, ".mball_edit"); break; case CTX_MODE_EDIT_LATTICE: ARRAY_SET_ITEMS(contexts, ".lattice_edit"); break; case CTX_MODE_POSE: ARRAY_SET_ITEMS(contexts, ".posemode"); break; case CTX_MODE_SCULPT: ARRAY_SET_ITEMS(contexts, ".paint_common", ".sculpt_mode"); break; case CTX_MODE_PAINT_WEIGHT: ARRAY_SET_ITEMS(contexts, ".paint_common", ".weightpaint"); break; case CTX_MODE_PAINT_VERTEX: ARRAY_SET_ITEMS(contexts, ".paint_common", ".vertexpaint"); break; case CTX_MODE_PAINT_TEXTURE: ARRAY_SET_ITEMS(contexts, ".paint_common", ".imagepaint"); break; case CTX_MODE_PARTICLE: ARRAY_SET_ITEMS(contexts, ".paint_common", ".particlemode"); break; case CTX_MODE_OBJECT: ARRAY_SET_ITEMS(contexts, ".objectmode"); break; case CTX_MODE_PAINT_GPENCIL: ARRAY_SET_ITEMS(contexts, ".greasepencil_paint"); break; case CTX_MODE_SCULPT_GPENCIL: ARRAY_SET_ITEMS(contexts, ".greasepencil_sculpt"); break; case CTX_MODE_WEIGHT_GPENCIL: ARRAY_SET_ITEMS(contexts, ".greasepencil_weight"); break; case CTX_MODE_VERTEX_GPENCIL: ARRAY_SET_ITEMS(contexts, ".greasepencil_vertex"); break; case CTX_MODE_SCULPT_CURVES: ARRAY_SET_ITEMS(contexts, ".paint_common", ".curves_sculpt"); break; default: break; } switch (mode) { case CTX_MODE_PAINT_GPENCIL: ARRAY_SET_ITEMS(contexts, ".greasepencil_paint"); break; case CTX_MODE_SCULPT_GPENCIL: ARRAY_SET_ITEMS(contexts, ".greasepencil_sculpt"); break; case CTX_MODE_WEIGHT_GPENCIL: ARRAY_SET_ITEMS(contexts, ".greasepencil_weight"); break; case CTX_MODE_EDIT_GPENCIL: ARRAY_SET_ITEMS(contexts, ".greasepencil_edit"); break; case CTX_MODE_VERTEX_GPENCIL: ARRAY_SET_ITEMS(contexts, ".greasepencil_vertex"); break; default: break; } ListBase *paneltypes = ®ion->type->paneltypes; /* Allow drawing 3D view toolbar from non 3D view space type. */ if (category_override != nullptr) { SpaceType *st = BKE_spacetype_from_id(SPACE_VIEW3D); ARegionType *art = BKE_regiontype_from_id(st, RGN_TYPE_UI); paneltypes = &art->paneltypes; } ED_region_panels_layout_ex(C, region, paneltypes, contexts_base, category_override); } static void view3d_buttons_region_layout(const bContext *C, ARegion *region) { ED_view3d_buttons_region_layout_ex(C, region, nullptr); } static void view3d_buttons_region_listener(const wmRegionListenerParams *params) { ARegion *region = params->region; const wmNotifier *wmn = params->notifier; /* context changes */ switch (wmn->category) { case NC_ANIMATION: switch (wmn->data) { case ND_KEYFRAME_PROP: case ND_NLA_ACTCHANGE: ED_region_tag_redraw(region); break; case ND_NLA: case ND_KEYFRAME: if (ELEM(wmn->action, NA_EDITED, NA_ADDED, NA_REMOVED)) { ED_region_tag_redraw(region); } break; } break; case NC_SCENE: switch (wmn->data) { case ND_FRAME: case ND_OB_ACTIVE: case ND_OB_SELECT: case ND_OB_VISIBLE: case ND_MODE: case ND_LAYER: case ND_LAYER_CONTENT: case ND_TOOLSETTINGS: ED_region_tag_redraw(region); break; } switch (wmn->action) { case NA_EDITED: ED_region_tag_redraw(region); break; } break; case NC_OBJECT: switch (wmn->data) { case ND_BONE_ACTIVE: case ND_BONE_SELECT: case ND_TRANSFORM: case ND_POSE: case ND_DRAW: case ND_KEYS: case ND_MODIFIER: case ND_SHADERFX: ED_region_tag_redraw(region); break; } break; case NC_GEOM: switch (wmn->data) { case ND_DATA: case ND_VERTEX_GROUP: case ND_SELECT: ED_region_tag_redraw(region); break; } if (wmn->action == NA_EDITED) { ED_region_tag_redraw(region); } break; case NC_TEXTURE: case NC_MATERIAL: /* for brush textures */ ED_region_tag_redraw(region); break; case NC_BRUSH: /* NA_SELECTED is used on brush changes */ if (ELEM(wmn->action, NA_EDITED, NA_SELECTED)) { ED_region_tag_redraw(region); } break; case NC_SPACE: if (wmn->data == ND_SPACE_VIEW3D) { ED_region_tag_redraw(region); } break; case NC_ID: if (wmn->action == NA_RENAME) { ED_region_tag_redraw(region); } break; case NC_GPENCIL: if ((wmn->data & (ND_DATA | ND_GPENCIL_EDITMODE)) || (wmn->action == NA_EDITED)) { ED_region_tag_redraw(region); } break; case NC_IMAGE: /* Update for the image layers in texture paint. */ if (wmn->action == NA_EDITED) { ED_region_tag_redraw(region); } break; case NC_WM: if (wmn->data == ND_XR_DATA_CHANGED) { ED_region_tag_redraw(region); } break; } } /* add handlers, stuff you only do once or on area/region changes */ static void view3d_tools_region_init(wmWindowManager *wm, ARegion *region) { wmKeyMap *keymap; ED_region_panels_init(wm, region); keymap = WM_keymap_ensure(wm->defaultconf, "3D View Generic", SPACE_VIEW3D, 0); WM_event_add_keymap_handler(®ion->handlers, keymap); } static void view3d_tools_region_draw(const bContext *C, ARegion *region) { const char *contexts[] = {CTX_data_mode_string(C), nullptr}; ED_region_panels_ex(C, region, contexts); } /* area (not region) level listener */ static void space_view3d_listener(const wmSpaceTypeListenerParams *params) { ScrArea *area = params->area; const wmNotifier *wmn = params->notifier; View3D *v3d = static_cast(area->spacedata.first); /* context changes */ switch (wmn->category) { case NC_SCENE: switch (wmn->data) { case ND_WORLD: { const bool use_scene_world = V3D_USES_SCENE_WORLD(v3d); if (v3d->flag2 & V3D_HIDE_OVERLAYS || use_scene_world) { ED_area_tag_redraw_regiontype(area, RGN_TYPE_WINDOW); } break; } } break; case NC_WORLD: switch (wmn->data) { case ND_WORLD_DRAW: case ND_WORLD: if (v3d->shading.background_type == V3D_SHADING_BACKGROUND_WORLD) { ED_area_tag_redraw_regiontype(area, RGN_TYPE_WINDOW); } break; } break; case NC_MATERIAL: switch (wmn->data) { case ND_NODES: if (v3d->shading.type == OB_TEXTURE) { ED_area_tag_redraw_regiontype(area, RGN_TYPE_WINDOW); } break; } break; } } static void space_view3d_refresh(const bContext *C, ScrArea *area) { Scene *scene = CTX_data_scene(C); LightCache *lcache = scene->eevee.light_cache_data; if (lcache && (lcache->flag & LIGHTCACHE_UPDATE_AUTO) != 0) { lcache->flag &= ~LIGHTCACHE_UPDATE_AUTO; view3d_lightcache_update((bContext *)C); } View3D *v3d = (View3D *)area->spacedata.first; MEM_SAFE_FREE(v3d->runtime.local_stats); } const char *view3d_context_dir[] = { "active_object", "selected_ids", nullptr, }; static int view3d_context(const bContext *C, const char *member, bContextDataResult *result) { /* fallback to the scene layer, * allows duplicate and other object operators to run outside the 3d view */ if (CTX_data_dir(member)) { CTX_data_dir_set(result, view3d_context_dir); return CTX_RESULT_OK; } if (CTX_data_equals(member, "active_object")) { /* In most cases the active object is the `view_layer->basact->object`. * For the 3D view however it can be nullptr when hidden. * * This is ignored in the case the object is in any mode (besides object-mode), * since the object's mode impacts the current tool, cursor, gizmos etc. * If we didn't have this exception, changing visibility would need to perform * many of the same updates as changing the objects mode. * * Further, there are multiple ways to hide objects - by collection, by object type, etc. * it's simplest if all these methods behave consistently - respecting the object-mode * without showing the object. * * See T85532 for alternatives that were considered. */ const Scene *scene = CTX_data_scene(C); ViewLayer *view_layer = CTX_data_view_layer(C); BKE_view_layer_synced_ensure(scene, view_layer); Base *base = BKE_view_layer_active_base_get(view_layer); if (base) { Object *ob = base->object; /* if hidden but in edit mode, we still display, can happen with animation */ if ((base->flag & BASE_ENABLED_AND_MAYBE_VISIBLE_IN_VIEWPORT) != 0 || (ob->mode != OB_MODE_OBJECT)) { CTX_data_id_pointer_set(result, &ob->id); } } return CTX_RESULT_OK; } if (CTX_data_equals(member, "selected_ids")) { ListBase selected_objects; CTX_data_selected_objects(C, &selected_objects); LISTBASE_FOREACH (CollectionPointerLink *, object_ptr_link, &selected_objects) { ID *selected_id = object_ptr_link->ptr.owner_id; CTX_data_id_list_add(result, selected_id); } BLI_freelistN(&selected_objects); CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION); return CTX_RESULT_OK; } return CTX_RESULT_MEMBER_NOT_FOUND; } static void view3d_id_remap_v3d_ob_centers(View3D *v3d, const struct IDRemapper *mappings) { if (BKE_id_remapper_apply(mappings, (ID **)&v3d->ob_center, ID_REMAP_APPLY_DEFAULT) == ID_REMAP_RESULT_SOURCE_UNASSIGNED) { /* Otherwise, bone-name may remain valid... * We could be smart and check this, too? */ v3d->ob_center_bone[0] = '\0'; } } static void view3d_id_remap_v3d(ScrArea *area, SpaceLink *slink, View3D *v3d, const struct IDRemapper *mappings, const bool is_local) { ARegion *region; if (BKE_id_remapper_apply(mappings, (ID **)&v3d->camera, ID_REMAP_APPLY_DEFAULT) == ID_REMAP_RESULT_SOURCE_UNASSIGNED) { /* 3D view might be inactive, in that case needs to use slink->regionbase */ ListBase *regionbase = (slink == area->spacedata.first) ? &area->regionbase : &slink->regionbase; for (region = static_cast(regionbase->first); region; region = region->next) { if (region->regiontype == RGN_TYPE_WINDOW) { RegionView3D *rv3d = is_local ? ((RegionView3D *)region->regiondata)->localvd : static_cast(region->regiondata); if (rv3d && (rv3d->persp == RV3D_CAMOB)) { rv3d->persp = RV3D_PERSP; } } } } } static void view3d_id_remap(ScrArea *area, SpaceLink *slink, const struct IDRemapper *mappings) { if (!BKE_id_remapper_has_mapping_for( mappings, FILTER_ID_OB | FILTER_ID_MA | FILTER_ID_IM | FILTER_ID_MC)) { return; } View3D *view3d = (View3D *)slink; view3d_id_remap_v3d(area, slink, view3d, mappings, false); view3d_id_remap_v3d_ob_centers(view3d, mappings); if (view3d->localvd != nullptr) { /* Object centers in local-view aren't used, see: T52663 */ view3d_id_remap_v3d(area, slink, view3d->localvd, mappings, true); } BKE_viewer_path_id_remap(&view3d->viewer_path, mappings); } static void view3d_blend_read_data(BlendDataReader *reader, SpaceLink *sl) { View3D *v3d = (View3D *)sl; memset(&v3d->runtime, 0x0, sizeof(v3d->runtime)); if (v3d->gpd) { BLO_read_data_address(reader, &v3d->gpd); BKE_gpencil_blend_read_data(reader, v3d->gpd); } BLO_read_data_address(reader, &v3d->localvd); /* render can be quite heavy, set to solid on load */ if (v3d->shading.type == OB_RENDER) { v3d->shading.type = OB_SOLID; } v3d->shading.prev_type = OB_SOLID; BKE_screen_view3d_shading_blend_read_data(reader, &v3d->shading); BKE_screen_view3d_do_versions_250(v3d, &sl->regionbase); BKE_viewer_path_blend_read_data(reader, &v3d->viewer_path); } static void view3d_blend_read_lib(BlendLibReader *reader, ID *parent_id, SpaceLink *sl) { View3D *v3d = (View3D *)sl; BLO_read_id_address(reader, parent_id->lib, &v3d->camera); BLO_read_id_address(reader, parent_id->lib, &v3d->ob_center); if (v3d->localvd) { BLO_read_id_address(reader, parent_id->lib, &v3d->localvd->camera); } BKE_viewer_path_blend_read_lib(reader, parent_id->lib, &v3d->viewer_path); } static void view3d_blend_write(BlendWriter *writer, SpaceLink *sl) { View3D *v3d = (View3D *)sl; BLO_write_struct(writer, View3D, v3d); if (v3d->localvd) { BLO_write_struct(writer, View3D, v3d->localvd); } BKE_screen_view3d_shading_blend_write(writer, &v3d->shading); BKE_viewer_path_blend_write(writer, &v3d->viewer_path); } void ED_spacetype_view3d() { SpaceType *st = MEM_cnew("spacetype view3d"); ARegionType *art; st->spaceid = SPACE_VIEW3D; STRNCPY(st->name, "View3D"); st->create = view3d_create; st->free = view3d_free; st->init = view3d_init; st->exit = view3d_exit; st->listener = space_view3d_listener; st->refresh = space_view3d_refresh; st->duplicate = view3d_duplicate; st->operatortypes = view3d_operatortypes; st->keymap = view3d_keymap; st->dropboxes = view3d_dropboxes; st->gizmos = view3d_widgets; st->context = view3d_context; st->id_remap = view3d_id_remap; st->blend_read_data = view3d_blend_read_data; st->blend_read_lib = view3d_blend_read_lib; st->blend_write = view3d_blend_write; /* regions: main window */ art = MEM_cnew("spacetype view3d main region"); art->regionid = RGN_TYPE_WINDOW; art->keymapflag = ED_KEYMAP_GIZMO | ED_KEYMAP_TOOL | ED_KEYMAP_GPENCIL; art->draw = view3d_main_region_draw; art->init = view3d_main_region_init; art->exit = view3d_main_region_exit; art->free = view3d_main_region_free; art->duplicate = view3d_main_region_duplicate; art->listener = view3d_main_region_listener; art->message_subscribe = view3d_main_region_message_subscribe; art->cursor = view3d_main_region_cursor; art->lock = 1; /* can become flag, see BKE_spacedata_draw_locks */ BLI_addhead(&st->regiontypes, art); /* regions: listview/buttons */ art = MEM_cnew("spacetype view3d buttons region"); art->regionid = RGN_TYPE_UI; art->prefsizex = UI_SIDEBAR_PANEL_WIDTH; art->keymapflag = ED_KEYMAP_UI | ED_KEYMAP_FRAMES; art->listener = view3d_buttons_region_listener; art->message_subscribe = ED_area_do_mgs_subscribe_for_tool_ui; art->init = view3d_buttons_region_init; art->layout = view3d_buttons_region_layout; art->draw = ED_region_panels_draw; BLI_addhead(&st->regiontypes, art); view3d_buttons_register(art); /* regions: tool(bar) */ art = MEM_cnew("spacetype view3d tools region"); art->regionid = RGN_TYPE_TOOLS; art->prefsizex = 58; /* XXX */ art->prefsizey = 50; /* XXX */ art->keymapflag = ED_KEYMAP_UI | ED_KEYMAP_FRAMES; art->listener = view3d_buttons_region_listener; art->message_subscribe = ED_region_generic_tools_region_message_subscribe; art->snap_size = ED_region_generic_tools_region_snap_size; art->init = view3d_tools_region_init; art->draw = view3d_tools_region_draw; BLI_addhead(&st->regiontypes, art); /* regions: tool header */ art = MEM_cnew("spacetype view3d tool header region"); art->regionid = RGN_TYPE_TOOL_HEADER; art->prefsizey = HEADERY; art->keymapflag = ED_KEYMAP_UI | ED_KEYMAP_VIEW2D | ED_KEYMAP_FRAMES | ED_KEYMAP_HEADER; art->listener = view3d_header_region_listener; art->message_subscribe = ED_area_do_mgs_subscribe_for_tool_header; art->init = view3d_header_region_init; art->draw = view3d_header_region_draw; BLI_addhead(&st->regiontypes, art); /* regions: header */ art = MEM_cnew("spacetype view3d header region"); art->regionid = RGN_TYPE_HEADER; art->prefsizey = HEADERY; art->keymapflag = ED_KEYMAP_UI | ED_KEYMAP_VIEW2D | ED_KEYMAP_FRAMES | ED_KEYMAP_HEADER; art->listener = view3d_header_region_listener; art->message_subscribe = view3d_header_region_message_subscribe; art->init = view3d_header_region_init; art->draw = view3d_header_region_draw; BLI_addhead(&st->regiontypes, art); /* regions: hud */ art = ED_area_type_hud(st->spaceid); BLI_addhead(&st->regiontypes, art); /* regions: xr */ art = MEM_cnew("spacetype view3d xr region"); art->regionid = RGN_TYPE_XR; BLI_addhead(&st->regiontypes, art); BKE_spacetype_register(st); }