Blender V5.3
object_select.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <cctype>
10#include <cstdlib>
11#include <cstring>
12
13#include "MEM_guardedalloc.h"
14
15#include "DNA_anim_types.h"
16#include "DNA_armature_types.h"
18#include "DNA_light_types.h"
19#include "DNA_modifier_types.h"
20#include "DNA_scene_types.h"
21
22#include "BLI_listbase.hh"
23#include "BLI_math_vector_c.hh"
24#include "BLI_rand_c.hh"
25#include "BLI_string_utils.hh"
26#include "BLI_utildefines.hh"
27
28#include "BLT_translation.hh"
29
30#include "BKE_action.hh"
31#include "BKE_armature.hh"
32#include "BKE_collection.hh"
33#include "BKE_context.hh"
34#include "BKE_global.hh"
35#include "BKE_layer.hh"
36#include "BKE_lib_id.hh"
37#include "BKE_main.hh"
38#include "BKE_material.hh"
39#include "BKE_particle.h"
40#include "BKE_report.hh"
41#include "BKE_scene.hh"
42
43#include "DEG_depsgraph.hh"
44
45#include "WM_api.hh"
46#include "WM_message.hh"
47#include "WM_types.hh"
48
49#include "ED_armature.hh"
50#include "ED_keyframing.hh"
51#include "ED_object.hh"
52#include "ED_outliner.hh"
53#include "ED_screen.hh"
54#include "ED_select_utils.hh"
55
56#include "ANIM_armature.hh"
58#include "ANIM_keyingsets.hh"
59
60#include "UI_interface.hh"
62#include "UI_resources.hh"
63
64#include "RNA_access.hh"
65#include "RNA_define.hh"
66#include "RNA_enum_types.hh"
67
68#include "object_intern.hh"
69
70namespace blender::ed::object {
71
72/* -------------------------------------------------------------------- */
75
77{
78 if (mode == BA_INVERT) {
79 mode = (base->flag & BASE_SELECTED) != 0 ? BA_DESELECT : BA_SELECT;
80 }
81
82 if (base) {
83 switch (mode) {
84 case BA_SELECT:
85 if ((base->flag & BASE_SELECTABLE) != 0) {
86 base->flag |= BASE_SELECTED;
87 }
88 break;
89 case BA_DESELECT:
90 base->flag &= ~BASE_SELECTED;
91 break;
92 case BA_INVERT:
93 /* Never happens. */
94 break;
95 }
97 }
98}
99
100void base_active_refresh(Main *bmain, Scene *scene, ViewLayer *view_layer)
101{
104 wmMsgBus *mbus = (bmain->wm.first())->runtime->message_bus;
105 if (mbus != nullptr) {
106 WM_msg_publish_rna_prop(mbus, &scene->id, view_layer, LayerObjects, active);
107 }
108}
109
111{
112 Scene *scene = CTX_data_scene(C);
113 ViewLayer *view_layer = CTX_data_view_layer(C);
114 view_layer->basact = base;
115 base_active_refresh(CTX_data_main(C), scene, view_layer);
116}
117
119{
120 Main *bmain = CTX_data_main(C);
121 Scene *scene = CTX_data_scene(C);
122 ViewLayer *view_layer = CTX_data_view_layer(C);
123
124 /* Currently we only need to be concerned with edit-mode. */
125 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
126 Object *obedit = BKE_view_layer_edit_object_get(view_layer);
127 if (obedit) {
128 Object *ob = base->object;
129 if (((ob->mode & OB_MODE_EDIT) == 0) || (obedit->type != ob->type)) {
130 editmode_exit_multi_ex(bmain, scene, view_layer, EM_FREEDATA);
131 }
132 }
133 base_activate(C, base);
134}
135
136bool base_deselect_all_ex(const Main &bmain,
137 const Scene *scene,
138 ViewLayer *view_layer,
139 View3D *v3d,
140 int action,
141 bool *r_any_visible)
142{
143 if (action == SEL_TOGGLE) {
144 action = SEL_SELECT;
145 FOREACH_VISIBLE_BASE_BEGIN (&bmain, scene, view_layer, v3d, base) {
146 if (v3d && ((v3d->object_type_exclude_select & (1 << base->object->type)) != 0)) {
147 continue;
148 }
149 if ((base->flag & BASE_SELECTED) != 0) {
150 action = SEL_DESELECT;
151 break;
152 }
153 }
155 }
156
157 bool any_visible = false;
158 bool changed = false;
159 FOREACH_VISIBLE_BASE_BEGIN (&bmain, scene, view_layer, v3d, base) {
160 if (v3d && ((v3d->object_type_exclude_select & (1 << base->object->type)) != 0)) {
161 continue;
162 }
163 switch (action) {
164 case SEL_SELECT:
165 if ((base->flag & BASE_SELECTED) == 0) {
166 base_select(base, BA_SELECT);
167 changed = true;
168 }
169 break;
170 case SEL_DESELECT:
171 if ((base->flag & BASE_SELECTED) != 0) {
173 changed = true;
174 }
175 break;
176 case SEL_INVERT:
177 if ((base->flag & BASE_SELECTED) != 0) {
179 changed = true;
180 }
181 else {
182 base_select(base, BA_SELECT);
183 changed = true;
184 }
185 break;
186 }
187 any_visible = true;
188 }
190 if (r_any_visible) {
191 *r_any_visible = any_visible;
192 }
193 return changed;
194}
195
197 const Main &bmain, const Scene *scene, ViewLayer *view_layer, View3D *v3d, int action)
198{
199 return base_deselect_all_ex(bmain, scene, view_layer, v3d, action, nullptr);
200}
201
203
204/* -------------------------------------------------------------------- */
207
209{
211 if (base->flag & BASE_SELECTABLE) {
212 return 3;
213 }
214 return 2;
215 }
216 return 1;
217}
218
219Base *find_first_by_data_id(const Main &bmain, const Scene *scene, ViewLayer *view_layer, ID *id)
220{
222
223 /* Try active object. */
224 BKE_view_layer_synced_ensure(bmain, scene, view_layer);
225 Base *basact = BKE_view_layer_active_base_get(view_layer);
226
227 if (basact && basact->object && basact->object->data == id) {
228 return basact;
229 }
230
231 /* Try all objects. */
232 Base *base_best = nullptr;
233 int priority_best = 0;
234
235 for (Base &base : *BKE_view_layer_object_bases_get(view_layer)) {
236 if (base.object && base.object->data == id) {
237 if (base.flag & BASE_SELECTED) {
238 return &base;
239 }
240
241 int priority_test = get_base_select_priority(&base);
242
243 if (priority_test > priority_best) {
244 priority_best = priority_test;
245 base_best = &base;
246 }
247 }
248 }
249
250 return base_best;
251}
252
253bool jump_to_object(bContext *C, Object *ob, const bool /*reveal_hidden*/)
254{
255 const Main *bmain = CTX_data_main(C);
256 const Scene *scene = CTX_data_scene(C);
257 ViewLayer *view_layer = CTX_data_view_layer(C);
258 View3D *v3d = CTX_wm_view3d(C);
259 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
260 Base *base = BKE_view_layer_base_find(view_layer, ob);
261
262 if (base == nullptr) {
263 return false;
264 }
265
266 /* TODO: use 'reveal_hidden', as is done with bones. */
267
268 if (BKE_view_layer_active_base_get(view_layer) != base || !(base->flag & BASE_SELECTED)) {
269 /* Select if not selected. */
270 if (!(base->flag & BASE_SELECTED)) {
271 base_deselect_all(*bmain, scene, view_layer, v3d, SEL_DESELECT);
272
273 if (BASE_VISIBLE(v3d, base)) {
274 base_select(base, BA_SELECT);
275 }
276
278 }
279
280 /* Make active if not active. */
281 base_activate(C, base);
283 }
284
285 return true;
286}
287
288bool jump_to_bone(bContext *C, Object *ob, const char *bone_name, const bool reveal_hidden)
289{
290 /* Verify it's a valid armature object. */
291 if (ob == nullptr || ob->type != OB_ARMATURE) {
292 return false;
293 }
294
295 bArmature *arm = id_cast<bArmature *>(ob->data);
296
297 /* Activate the armature object. */
298 if (!jump_to_object(C, ob, reveal_hidden)) {
299 return false;
300 }
301
302 /* Switch to pose mode from object mode. */
303 if (!ELEM(ob->mode, OB_MODE_EDIT, OB_MODE_POSE)) {
305 }
306
307 if (ob->mode == OB_MODE_EDIT && arm->edbo != nullptr) {
308 /* In Edit mode select and activate the target Edit-Bone. */
309 EditBone *ebone = ED_armature_ebone_find_name(arm->edbo, bone_name);
310 if (ebone != nullptr) {
311 if (reveal_hidden) {
312 /* Unhide the bone. */
313 ebone->flag &= ~BONE_HIDDEN_A;
315 }
316
317 /* Select it. */
319
320 if (EBONE_SELECTABLE(arm, ebone)) {
321 ED_armature_ebone_select_set(ebone, true);
323 }
324
325 arm->act_edbone = ebone;
326
329 return true;
330 }
331 }
332 else if (ob->mode == OB_MODE_POSE && ob->pose != nullptr) {
333 /* In Pose mode select and activate the target Bone/Pose-Channel. */
334 bPoseChannel *pchan = BKE_pose_channel_find_name(ob->pose, bone_name);
335 if (pchan != nullptr) {
336 if (reveal_hidden) {
337 /* Unhide the bone. */
340 }
341
342 /* Select it. */
344 ED_pose_bone_select(ob, pchan, true, true);
345
346 arm->act_bone = pchan->bone_get(*ob);
347
350 return true;
351 }
352 }
353
354 return false;
355}
356
358
359/* -------------------------------------------------------------------- */
362
364{
365 /* we don't check for linked scenes here, selection is
366 * still allowed then for inspection of scene */
368
369 if (CTX_data_edit_object(C)) {
370 return false;
371 }
372 if (obact && obact->mode) {
373 return false;
374 }
375
376 return true;
377}
378
380
381/* -------------------------------------------------------------------- */
384
386{
387 const Main *bmain = CTX_data_main(C);
388 Scene *scene = CTX_data_scene(C);
389 ViewLayer *view_layer = CTX_data_view_layer(C);
390 View3D *v3d = CTX_wm_view3d(C);
391 short obtype, extend;
392
393 obtype = RNA_enum_get(op->ptr, "type");
394 extend = RNA_boolean_get(op->ptr, "extend");
395
396 if (extend == 0) {
397 base_deselect_all(*bmain, scene, view_layer, v3d, SEL_DESELECT);
398 }
399
400 CTX_DATA_BEGIN (C, Base *, base, visible_bases) {
401 if (base->object->type == obtype) {
402 base_select(base, BA_SELECT);
403 }
404 }
406
409
411
412 return OPERATOR_FINISHED;
413}
414
416{
417 /* identifiers */
418 ot->name = "Select by Type";
419 ot->description = "Select all visible objects that are of a type";
420 ot->idname = "OBJECT_OT_select_by_type";
421
422 /* API callbacks. */
426
427 /* flags */
429
430 /* properties */
432 "extend",
433 false,
434 "Extend",
435 "Extend selection instead of deselecting everything first");
436 ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_object_type_items, 1, "Type", "");
438}
439
441
442/* -------------------------------------------------------------------- */
445
446enum {
454};
455
457 /* XXX deprecated animation system stuff. */
458 // {OBJECT_SELECT_LINKED_IPO, "IPO", 0, "Object IPO", ""},
459 {OBJECT_SELECT_LINKED_OBDATA, "OBDATA", 0, "Object Data", ""},
460 {OBJECT_SELECT_LINKED_MATERIAL, "MATERIAL", 0, "Material", ""},
461 {OBJECT_SELECT_LINKED_DUPGROUP, "DUPGROUP", 0, "Instanced Collection", ""},
462 {OBJECT_SELECT_LINKED_PARTICLE, "PARTICLE", 0, "Particle System", ""},
463 {OBJECT_SELECT_LINKED_LIBRARY, "LIBRARY", 0, "Library", ""},
464 {OBJECT_SELECT_LINKED_LIBRARY_OBDATA, "LIBRARY_OBDATA", 0, "Library (Object Data)", ""},
465 {0, nullptr, 0, nullptr, nullptr},
466};
467
468static bool object_select_all_by_obdata(bContext *C, void *obdata)
469{
470 bool changed = false;
471
472 CTX_DATA_BEGIN (C, Base *, base, visible_bases) {
473 if (((base->flag & BASE_SELECTED) == 0) && ((base->flag & BASE_SELECTABLE) != 0)) {
474 if (base->object->data == obdata) {
475 base_select(base, BA_SELECT);
476 changed = true;
477 }
478 }
479 }
481
482 return changed;
483}
484
486{
487 bool changed = false;
488
489 CTX_DATA_BEGIN (C, Base *, base, visible_bases) {
490 if (((base->flag & BASE_SELECTED) == 0) && ((base->flag & BASE_SELECTABLE) != 0)) {
491 Object *ob = base->object;
492 Material *mat1;
493 int a;
494
495 for (a = 1; a <= ob->totcol; a++) {
496 mat1 = BKE_object_material_get(ob, a);
497
498 if (mat1 == mat) {
499 base_select(base, BA_SELECT);
500 changed = true;
501 }
502 }
503 }
504 }
506
507 return changed;
508}
509
511{
512 bool changed = false;
513 Collection *instance_collection = (ob->transflag & OB_DUPLICOLLECTION) ?
515 nullptr;
516
517 CTX_DATA_BEGIN (C, Base *, base, visible_bases) {
518 if (((base->flag & BASE_SELECTED) == 0) && ((base->flag & BASE_SELECTABLE) != 0)) {
519 Collection *instance_collection_other = (base->object->transflag & OB_DUPLICOLLECTION) ?
520 base->object->instance_collection :
521 nullptr;
522 if (instance_collection == instance_collection_other) {
523 base_select(base, BA_SELECT);
524 changed = true;
525 }
526 }
527 }
529
530 return changed;
531}
532
534{
535 bool changed = false;
536
537 CTX_DATA_BEGIN (C, Base *, base, visible_bases) {
538 if (((base->flag & BASE_SELECTED) == 0) && ((base->flag & BASE_SELECTABLE) != 0)) {
539 /* Loop through other particles. */
540 for (ParticleSystem &psys : base->object->particlesystem) {
541 if (psys.part == psys_act->part) {
542 base_select(base, BA_SELECT);
543 changed = true;
544 break;
545 }
546
547 if (base->flag & BASE_SELECTED) {
548 break;
549 }
550 }
551 }
552 }
554
555 return changed;
556}
557
559{
560 bool changed = false;
561
562 CTX_DATA_BEGIN (C, Base *, base, visible_bases) {
563 if (((base->flag & BASE_SELECTED) == 0) && ((base->flag & BASE_SELECTABLE) != 0)) {
564 if (lib == base->object->id.lib) {
565 base_select(base, BA_SELECT);
566 changed = true;
567 }
568 }
569 }
571
572 return changed;
573}
574
576{
577 bool changed = false;
578
579 CTX_DATA_BEGIN (C, Base *, base, visible_bases) {
580 if (((base->flag & BASE_SELECTED) == 0) && ((base->flag & BASE_SELECTABLE) != 0)) {
581 if (base->object->data && lib == (base->object->data)->lib) {
582 base_select(base, BA_SELECT);
583 changed = true;
584 }
585 }
586 }
588
589 return changed;
590}
591
593{
594 int idtype = GS(id->name);
595 bool changed = false;
596
597 if (OB_DATA_SUPPORT_ID(idtype)) {
598 changed = object_select_all_by_obdata(C, id);
599 }
600 else if (idtype == ID_MA) {
601 changed = object_select_all_by_material(C, id_cast<Material *>(id));
602 }
603 else if (idtype == ID_LI) {
604 changed = object_select_all_by_library(C, id_cast<Library *>(id));
605 }
606
607 if (changed) {
608 Scene *scene = CTX_data_scene(C);
611 }
612}
613
615{
616 const Main *bmain = CTX_data_main(C);
617 Scene *scene = CTX_data_scene(C);
618 ViewLayer *view_layer = CTX_data_view_layer(C);
619 View3D *v3d = CTX_wm_view3d(C);
620 Object *ob;
621 int nr = RNA_enum_get(op->ptr, "type");
622 bool changed = false, extend;
623
624 extend = RNA_boolean_get(op->ptr, "extend");
625
626 if (extend == 0) {
627 base_deselect_all(*bmain, scene, view_layer, v3d, SEL_DESELECT);
628 }
629
630 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
631 ob = BKE_view_layer_active_object_get(view_layer);
632 if (ob == nullptr) {
633 BKE_report(op->reports, RPT_ERROR, "No active object");
634 return OPERATOR_CANCELLED;
635 }
636
637 if (nr == OBJECT_SELECT_LINKED_IPO) {
638 /* XXX old animation system */
639 // if (ob->ipo == 0) return OPERATOR_CANCELLED;
640 // object_select_all_by_ipo(C, ob->ipo)
641 return OPERATOR_CANCELLED;
642 }
643 if (nr == OBJECT_SELECT_LINKED_OBDATA) {
644 if (ob->data == nullptr) {
645 return OPERATOR_CANCELLED;
646 }
647
648 changed = object_select_all_by_obdata(C, ob->data);
649 }
650 else if (nr == OBJECT_SELECT_LINKED_MATERIAL) {
651 Material *mat = nullptr;
652
653 mat = BKE_object_material_get(ob, ob->actcol);
654 if (mat == nullptr) {
655 return OPERATOR_CANCELLED;
656 }
657
658 changed = object_select_all_by_material(C, mat);
659 }
660 else if (nr == OBJECT_SELECT_LINKED_DUPGROUP) {
661 if (ob->instance_collection == nullptr) {
662 return OPERATOR_CANCELLED;
663 }
664
666 }
667 else if (nr == OBJECT_SELECT_LINKED_PARTICLE) {
668 const ParticleSystem *psys_act = psys_get_current(ob);
669 if (psys_act == nullptr) {
670 return OPERATOR_CANCELLED;
671 }
672
673 changed = object_select_all_by_particle(C, psys_act);
674 }
675 else if (nr == OBJECT_SELECT_LINKED_LIBRARY) {
676 /* do nothing */
677 changed = object_select_all_by_library(C, ob->id.lib);
678 }
680 if (ob->data == nullptr) {
681 return OPERATOR_CANCELLED;
682 }
683
685 }
686 else {
687 return OPERATOR_CANCELLED;
688 }
689
690 if (changed) {
694 return OPERATOR_FINISHED;
695 }
696
697 return OPERATOR_CANCELLED;
698}
699
701{
702 /* identifiers */
703 ot->name = "Select Linked";
704 ot->description = "Select all visible objects that are linked";
705 ot->idname = "OBJECT_OT_select_linked";
706
707 /* API callbacks. */
711
712 /* flags */
714
715 /* properties */
717 "extend",
718 false,
719 "Extend",
720 "Extend selection instead of deselecting everything first");
721 ot->prop = RNA_def_enum(ot->srna, "type", prop_select_linked_types, 0, "Type", "");
722}
723
725
726/* -------------------------------------------------------------------- */
729
730enum {
742};
743
745 {OBJECT_GRPSEL_CHILDREN_RECURSIVE, "CHILDREN_RECURSIVE", 0, "Children", ""},
746 {OBJECT_GRPSEL_CHILDREN, "CHILDREN", 0, "Immediate Children", ""},
747 {OBJECT_GRPSEL_PARENT, "PARENT", 0, "Parent", ""},
748 {OBJECT_GRPSEL_SIBLINGS, "SIBLINGS", 0, "Siblings", "Shared parent"},
749 {OBJECT_GRPSEL_TYPE, "TYPE", 0, "Type", "Shared object type"},
750 {OBJECT_GRPSEL_COLLECTION, "COLLECTION", 0, "Collection", "Shared collection"},
751 {OBJECT_GRPSEL_HOOK, "HOOK", 0, "Hook", ""},
752 {OBJECT_GRPSEL_PASS, "PASS", 0, "Pass", "Render pass index"},
753 {OBJECT_GRPSEL_COLOR, "COLOR", 0, "Color", "Object color"},
755 "KEYINGSET",
756 0,
757 "Keying Set",
758 "Objects included in active Keying Set"},
759 {OBJECT_GRPSEL_LIGHT_TYPE, "LIGHT_TYPE", 0, "Light Type", "Matching light types"},
760 {0, nullptr, 0, nullptr, nullptr},
761};
762
763static bool select_grouped_children(bContext *C, Object *ob, const bool recursive)
764{
765 bool changed = false;
766
767 CTX_DATA_BEGIN (C, Base *, base, selectable_bases) {
768 if (ob == base->object->parent) {
769 if ((base->flag & BASE_SELECTED) == 0) {
770 base_select(base, BA_SELECT);
771 changed = true;
772 }
773
774 if (recursive) {
775 changed |= select_grouped_children(C, base->object, true);
776 }
777 }
778 }
780 return changed;
781}
782
783/* Makes parent active and de-selected BKE_view_layer_active_object_get. */
785{
786 const Main *bmain = CTX_data_main(C);
787 Scene *scene = CTX_data_scene(C);
788 ViewLayer *view_layer = CTX_data_view_layer(C);
789 View3D *v3d = CTX_wm_view3d(C);
790 Base *baspar, *basact = CTX_data_active_base(C);
791 bool changed = false;
792
793 if (!basact || !(basact->object->parent)) {
794 /* We know BKE_view_layer_active_object_get is valid. */
795 return false;
796 }
797
798 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
799 baspar = BKE_view_layer_base_find(view_layer, basact->object->parent);
800
801 /* can be nullptr if parent in other scene */
802 if (baspar && BASE_SELECTABLE(v3d, baspar)) {
803 base_select(baspar, BA_SELECT);
804 base_activate(C, baspar);
805 changed = true;
806 }
807 return changed;
808}
809
810#define COLLECTION_MENU_MAX 24
811/* Select objects in the same group as the active */
813{
814 Main *bmain = CTX_data_main(C);
815 bool changed = false;
816 Collection *collection, *ob_collections[COLLECTION_MENU_MAX];
817 int collection_count = 0, i;
818
819 for (collection = bmain->collections.first();
820 collection && (collection_count < COLLECTION_MENU_MAX);
821 collection = static_cast<Collection *>(collection->id.next))
822 {
823 if (BKE_collection_has_object(collection, ob)) {
824 ob_collections[collection_count] = collection;
825 collection_count++;
826 }
827 }
828
829 if (!collection_count) {
830 return false;
831 }
832 if (collection_count == 1) {
833 collection = ob_collections[0];
834 CTX_DATA_BEGIN (C, Base *, base, visible_bases) {
835 if (((base->flag & BASE_SELECTED) == 0) && ((base->flag & BASE_SELECTABLE) != 0)) {
836 if (BKE_collection_has_object(collection, base->object)) {
837 base_select(base, BA_SELECT);
838 changed = true;
839 }
840 }
841 }
843 return changed;
844 }
845
846 /* Popup menus need a window, which isn't available in background mode. */
847 if (G.background || CTX_wm_window(C) == nullptr) {
848 BKE_report(reports, RPT_ERROR, "Active object is in multiple collections");
849 return false;
850 }
851
852 /* build the menu. */
853 ui::PopupMenu *pup = ui::popup_menu_begin(C, IFACE_("Select Collection"), ICON_NONE);
854 ui::Layout &layout = *popup_menu_layout(pup);
855
856 for (i = 0; i < collection_count; i++) {
857 collection = ob_collections[i];
858 PointerRNA op_ptr = layout.op(
859 "OBJECT_OT_select_same_collection", collection->id.name + 2, ICON_NONE);
860 RNA_string_set(&op_ptr, "collection", collection->id.name + 2);
861 }
862
863 popup_menu_end(C, pup);
864 return changed; /* The operator already handle this! */
865}
866
868{
869 const Main *bmain = CTX_data_main(C);
870 const Scene *scene = CTX_data_scene(C);
871 ViewLayer *view_layer = CTX_data_view_layer(C);
872 View3D *v3d = CTX_wm_view3d(C);
873
874 bool changed = false;
875 Base *base;
876 HookModifierData *hmd;
877
878 for (ModifierData &md : ob->modifiers) {
879 if (md.type == eModifierType_Hook) {
880 hmd = reinterpret_cast<HookModifierData *>(&md);
881 if (hmd->object) {
882 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
883 base = BKE_view_layer_base_find(view_layer, hmd->object);
884 if (base && ((base->flag & BASE_SELECTED) == 0) && BASE_SELECTABLE(v3d, base)) {
885 base_select(base, BA_SELECT);
886 changed = true;
887 }
888 }
889 }
890 }
891 return changed;
892}
893
894/* Select objects with the same parent as the active (siblings),
895 * parent can be nullptr also */
897{
898 bool changed = false;
899
900 CTX_DATA_BEGIN (C, Base *, base, selectable_bases) {
901 if ((base->object->parent == ob->parent) && ((base->flag & BASE_SELECTED) == 0)) {
902 base_select(base, BA_SELECT);
903 changed = true;
904 }
905 }
907 return changed;
908}
910{
911 Light *la = id_cast<Light *>(ob->data);
912
913 bool changed = false;
914
915 CTX_DATA_BEGIN (C, Base *, base, selectable_bases) {
916 if (base->object->type == OB_LAMP) {
917 Light *la_test = id_cast<Light *>(base->object->data);
918 if ((la->type == la_test->type) && ((base->flag & BASE_SELECTED) == 0)) {
919 base_select(base, BA_SELECT);
920 changed = true;
921 }
922 }
923 }
925 return changed;
926}
928{
929 bool changed = false;
930
931 CTX_DATA_BEGIN (C, Base *, base, selectable_bases) {
932 if ((base->object->type == ob->type) && ((base->flag & BASE_SELECTED) == 0)) {
933 base_select(base, BA_SELECT);
934 changed = true;
935 }
936 }
938 return changed;
939}
940
942{
943 bool changed = false;
944
945 CTX_DATA_BEGIN (C, Base *, base, selectable_bases) {
946 if ((base->object->index == ob->index) && ((base->flag & BASE_SELECTED) == 0)) {
947 base_select(base, BA_SELECT);
948 changed = true;
949 }
950 }
952 return changed;
953}
954
956{
957 bool changed = false;
958
959 CTX_DATA_BEGIN (C, Base *, base, selectable_bases) {
960 if (((base->flag & BASE_SELECTED) == 0) &&
961 compare_v3v3(base->object->color, ob->color, 0.005f))
962 {
963 base_select(base, BA_SELECT);
964 changed = true;
965 }
966 }
968 return changed;
969}
970
971static bool select_grouped_keyingset(bContext *C, Object * /*ob*/, ReportList *reports)
972{
974 bool changed = false;
975
976 /* firstly, validate KeyingSet */
977 if (ks == nullptr) {
978 BKE_report(reports, RPT_ERROR, "No active Keying Set to use");
979 return false;
980 }
982 if (ks->paths.first_ == nullptr) {
983 if ((ks->flag & KEYINGSET_ABSOLUTE) == 0) {
984 BKE_report(reports,
985 RPT_ERROR,
986 "Use another Keying Set, as the active one depends on the currently "
987 "selected objects or cannot find any targets due to unsuitable context");
988 }
989 else {
990 BKE_report(reports, RPT_ERROR, "Keying Set does not contain any paths");
991 }
992 }
993 return false;
994 }
995
996 /* select each object that Keying Set refers to */
997 /* TODO: perhaps to be more in line with the rest of these, we should only take objects
998 * if the passed in object is included in this too */
999 CTX_DATA_BEGIN (C, Base *, base, selectable_bases) {
1000 /* only check for this object if it isn't selected already, to limit time wasted */
1001 if ((base->flag & BASE_SELECTED) == 0) {
1002 /* This is the slow way... we could end up with > 500 items here,
1003 * with none matching, but end up doing this on 1000 objects. */
1004 for (KS_Path &ksp : ks->paths) {
1005 /* if id matches, select then stop looping (match found) */
1006 if (ksp.id == id_cast<ID *>(base->object)) {
1007 base_select(base, BA_SELECT);
1008 changed = true;
1009 break;
1010 }
1011 }
1012 }
1013 }
1015
1016 return changed;
1017}
1018
1020{
1021 const Main *bmain = CTX_data_main(C);
1022 Scene *scene = CTX_data_scene(C);
1023 ViewLayer *view_layer = CTX_data_view_layer(C);
1024 View3D *v3d = CTX_wm_view3d(C);
1025 Object *ob;
1026 const int type = RNA_enum_get(op->ptr, "type");
1027 bool changed = false, extend;
1028
1029 extend = RNA_boolean_get(op->ptr, "extend");
1030
1031 if (extend == 0) {
1032 changed = base_deselect_all(*bmain, scene, view_layer, v3d, SEL_DESELECT);
1033 }
1034
1035 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
1036 ob = BKE_view_layer_active_object_get(view_layer);
1037 if (ob == nullptr) {
1038 BKE_report(op->reports, RPT_ERROR, "No active object");
1039 return OPERATOR_CANCELLED;
1040 }
1041
1042 switch (type) {
1044 changed |= select_grouped_children(C, ob, true);
1045 break;
1047 changed |= select_grouped_children(C, ob, false);
1048 break;
1050 changed |= select_grouped_parent(C);
1051 break;
1053 changed |= select_grouped_siblings(C, ob);
1054 break;
1055 case OBJECT_GRPSEL_TYPE:
1056 changed |= select_grouped_type(C, ob);
1057 break;
1059 changed |= select_grouped_collection(C, ob, op->reports);
1060 break;
1061 case OBJECT_GRPSEL_HOOK:
1062 changed |= select_grouped_object_hooks(C, ob);
1063 break;
1064 case OBJECT_GRPSEL_PASS:
1065 changed |= select_grouped_index_object(C, ob);
1066 break;
1068 changed |= select_grouped_color(C, ob);
1069 break;
1071 changed |= select_grouped_keyingset(C, ob, op->reports);
1072 break;
1074 if (ob->type != OB_LAMP) {
1075 BKE_report(op->reports, RPT_ERROR, "Active object must be a light");
1076 break;
1077 }
1078 changed |= select_grouped_lighttype(C, ob);
1079 break;
1080 default:
1081 break;
1082 }
1083
1084 if (changed) {
1088 return OPERATOR_FINISHED;
1089 }
1090
1091 return OPERATOR_CANCELLED;
1092}
1093
1095{
1096 /* identifiers */
1097 ot->name = "Select Grouped";
1098 ot->description = "Select all visible objects grouped by various properties";
1099 ot->idname = "OBJECT_OT_select_grouped";
1100
1101 /* API callbacks. */
1102 ot->invoke = WM_menu_invoke;
1105
1106 /* flags */
1108
1109 /* properties */
1111 "extend",
1112 false,
1113 "Extend",
1114 "Extend selection instead of deselecting everything first");
1115 ot->prop = RNA_def_enum(ot->srna, "type", prop_select_grouped_types, 0, "Type", "");
1116}
1117
1119
1120/* -------------------------------------------------------------------- */
1123
1125{
1126 const Main *bmain = CTX_data_main(C);
1127 Scene *scene = CTX_data_scene(C);
1128 ViewLayer *view_layer = CTX_data_view_layer(C);
1129 View3D *v3d = CTX_wm_view3d(C);
1130 int action = RNA_enum_get(op->ptr, "action");
1131 bool any_visible = false;
1132
1133 bool changed = base_deselect_all_ex(*bmain, scene, view_layer, v3d, action, &any_visible);
1134
1135 if (changed) {
1138
1140
1141 return OPERATOR_FINISHED;
1142 }
1143 if (any_visible == false) {
1144 /* TODO(@ideasman42): Looks like we could remove this,
1145 * if not comment should say why its needed. */
1146 return OPERATOR_PASS_THROUGH;
1147 }
1148 return OPERATOR_CANCELLED;
1149}
1150
1152{
1153
1154 /* identifiers */
1155 ot->name = "(De)select All";
1156 ot->description = "Change selection of all visible objects in scene";
1157 ot->idname = "OBJECT_OT_select_all";
1158
1159 /* API callbacks. */
1162
1163 /* flags */
1165
1167}
1168
1170
1171/* -------------------------------------------------------------------- */
1174
1176{
1177 Main *bmain = CTX_data_main(C);
1178 Collection *collection;
1179 char collection_name[MAX_ID_NAME - 2];
1180
1181 /* passthrough if no objects are visible */
1182 if (CTX_DATA_COUNT(C, visible_bases) == 0) {
1183 return OPERATOR_PASS_THROUGH;
1184 }
1185
1186 RNA_string_get(op->ptr, "collection", collection_name);
1187
1188 collection = id_cast<Collection *>(BKE_libblock_find_name(bmain, ID_GR, collection_name));
1189
1190 if (!collection) {
1191 return OPERATOR_PASS_THROUGH;
1192 }
1193
1194 CTX_DATA_BEGIN (C, Base *, base, visible_bases) {
1195 if (((base->flag & BASE_SELECTED) == 0) && ((base->flag & BASE_SELECTABLE) != 0)) {
1196 if (BKE_collection_has_object(collection, base->object)) {
1197 base_select(base, BA_SELECT);
1198 }
1199 }
1200 }
1202
1203 Scene *scene = CTX_data_scene(C);
1206
1208
1209 return OPERATOR_FINISHED;
1210}
1211
1213{
1214
1215 /* identifiers */
1216 ot->name = "Select Same Collection";
1217 ot->description = "Select object in the same collection";
1218 ot->idname = "OBJECT_OT_select_same_collection";
1219
1220 /* API callbacks. */
1223
1224 /* flags */
1226
1227 RNA_def_string(ot->srna,
1228 "collection",
1229 nullptr,
1230 MAX_ID_NAME - 2,
1231 "Collection",
1232 "Name of the collection to select");
1233}
1234
1236
1237/* -------------------------------------------------------------------- */
1240
1242{
1243 Main *bmain = CTX_data_main(C);
1244 Scene *scene = CTX_data_scene(C);
1245 ViewLayer *view_layer = CTX_data_view_layer(C);
1246 bool extend;
1247
1248 extend = RNA_boolean_get(op->ptr, "extend");
1249
1250 CTX_DATA_BEGIN (C, Base *, primbase, selected_bases) {
1251 char name_flip[MAXBONENAME];
1252
1253 BLI_string_flip_side_name(name_flip, primbase->object->id.name + 2, true, sizeof(name_flip));
1254
1255 if (!STREQ(name_flip, primbase->object->id.name + 2)) {
1256 Object *ob = id_cast<Object *>(BKE_libblock_find_name(bmain, ID_OB, name_flip));
1257 if (ob) {
1258 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
1259 Base *secbase = BKE_view_layer_base_find(view_layer, ob);
1260
1261 if (secbase) {
1262 base_select(secbase, BA_SELECT);
1263 }
1264 }
1265 }
1266
1267 if (extend == false) {
1268 base_select(primbase, BA_DESELECT);
1269 }
1270 }
1272
1273 /* undo? */
1276
1278
1279 return OPERATOR_FINISHED;
1280}
1281
1283{
1284
1285 /* identifiers */
1286 ot->name = "Select Mirror";
1287 ot->description =
1288 "Select the mirror objects of the selected object e.g. \"L.sword\" and \"R.sword\"";
1289 ot->idname = "OBJECT_OT_select_mirror";
1290
1291 /* API callbacks. */
1294
1295 /* flags */
1297
1299 "extend",
1300 false,
1301 "Extend",
1302 "Extend selection instead of deselecting everything first");
1303}
1304
1306
1307/* -------------------------------------------------------------------- */
1310
1311static bool object_select_more_less(bContext *C, const bool select)
1312{
1313 const Main *bmain = CTX_data_main(C);
1314 Scene *scene = CTX_data_scene(C);
1315 ViewLayer *view_layer = CTX_data_view_layer(C);
1316
1317 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
1318 for (Base &base : *BKE_view_layer_object_bases_get(view_layer)) {
1319 Object *ob = base.object;
1320 ob->flag &= ~OB_DONE;
1321 ob->id.tag &= ~ID_TAG_DOIT;
1322 /* parent may be in another scene */
1323 if (ob->parent) {
1324 ob->parent->flag &= ~OB_DONE;
1325 ob->parent->id.tag &= ~ID_TAG_DOIT;
1326 }
1327 }
1328
1329 Vector<PointerRNA> ctx_base_list;
1330 CTX_data_selectable_bases(C, &ctx_base_list);
1331
1332 CTX_DATA_BEGIN (C, Object *, ob, selected_objects) {
1333 ob->flag |= OB_DONE;
1334 }
1336
1337 for (PointerRNA &ptr : ctx_base_list) {
1338 Object *ob = (static_cast<Base *>(ptr.data))->object;
1339 if (ob->parent) {
1340 if ((ob->flag & OB_DONE) != (ob->parent->flag & OB_DONE)) {
1341 ob->id.tag |= ID_TAG_DOIT;
1342 ob->parent->id.tag |= ID_TAG_DOIT;
1343 }
1344 }
1345 }
1346
1347 bool changed = false;
1348 const short select_mode = select ? BA_SELECT : BA_DESELECT;
1349 const short select_flag = select ? BASE_SELECTED : 0;
1350
1351 for (PointerRNA &ptr : ctx_base_list) {
1352 Base *base = static_cast<Base *>(ptr.data);
1353 Object *ob = base->object;
1354 if ((ob->id.tag & ID_TAG_DOIT) && ((base->flag & BASE_SELECTED) != select_flag)) {
1355 base_select(base, eObjectSelect_Mode(select_mode));
1356 changed = true;
1357 }
1358 }
1359
1360 return changed;
1361}
1362
1364{
1365 bool changed = object_select_more_less(C, true);
1366
1367 if (changed) {
1368 Scene *scene = CTX_data_scene(C);
1371
1373
1374 return OPERATOR_FINISHED;
1375 }
1376 return OPERATOR_CANCELLED;
1377}
1378
1380{
1381 /* identifiers */
1382 ot->name = "Select More";
1383 ot->idname = "OBJECT_OT_select_more";
1384 ot->description = "Select connected parent/child objects";
1385
1386 /* API callbacks. */
1389
1390 /* flags */
1392}
1393
1395{
1396 bool changed = object_select_more_less(C, false);
1397
1398 if (changed) {
1399 Scene *scene = CTX_data_scene(C);
1402
1404
1405 return OPERATOR_FINISHED;
1406 }
1407 return OPERATOR_CANCELLED;
1408}
1409
1411{
1412 /* identifiers */
1413 ot->name = "Select Less";
1414 ot->idname = "OBJECT_OT_select_less";
1415 ot->description = "Deselect objects at the boundaries of parent/child relationships";
1416
1417 /* API callbacks. */
1420
1421 /* flags */
1423}
1424
1426
1427/* -------------------------------------------------------------------- */
1430
1432{
1433 const bool select = (RNA_enum_get(op->ptr, "action") == SEL_SELECT);
1434 const float randfac = RNA_float_get(op->ptr, "ratio");
1436
1437 Vector<PointerRNA> ctx_data_list;
1438 CTX_data_selectable_bases(C, &ctx_data_list);
1439 int elem_map_len = 0;
1440 Base **elem_map = MEM_new_array_uninitialized<Base *>(ctx_data_list.size(), __func__);
1441
1442 for (PointerRNA &ptr : ctx_data_list) {
1443 elem_map[elem_map_len++] = static_cast<Base *>(ptr.data);
1444 }
1445
1446 BLI_array_randomize(elem_map, sizeof(*elem_map), elem_map_len, seed);
1447 const int count_select = elem_map_len * randfac;
1448 for (int i = 0; i < count_select; i++) {
1449 base_select(elem_map[i], eObjectSelect_Mode(select));
1450 }
1451 MEM_delete(elem_map);
1452
1453 Scene *scene = CTX_data_scene(C);
1456
1458
1459 return OPERATOR_FINISHED;
1460}
1461
1463{
1464 /* identifiers */
1465 ot->name = "Select Random";
1466 ot->description = "Select or deselect random visible objects";
1467 ot->idname = "OBJECT_OT_select_random";
1468
1469 /* API callbacks. */
1470 // ot->invoke = object_select_random_invoke; /* TODO: need a number popup. */
1473
1474 /* flags */
1476
1477 /* properties */
1479}
1480
1482
1483} // namespace blender::ed::object
Functions to deal with Armatures.
C++ functions to deal with Armature collections (i.e. the successor of bone layers).
Functionality to interact with keying sets.
Blender kernel action and pose functionality.
#define CTX_DATA_BEGIN(C, Type, instance, member)
#define CTX_DATA_COUNT(C, member)
#define CTX_DATA_END
#define FOREACH_VISIBLE_BASE_END
Definition BKE_layer.hh:518
#define FOREACH_VISIBLE_BASE_BEGIN(_bmain, _scene, _view_layer, _v3d, _instance)
Definition BKE_layer.hh:505
General operations, lookup, etc. for materials.
Random number functions.
#define BLT_I18NCONTEXT_ID_ID
#define IFACE_(msgid)
#define MAX_ID_NAME
Definition DNA_ID.h:367
#define MAXBONENAME
Object groups, one object can be in many groups at once.
#define OB_DATA_SUPPORT_ID(_id_type)
#define BASE_VISIBLE(v3d, base)
#define EBONE_SELECTABLE(arm, ebone)
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define ND_OB_ACTIVE
Definition WM_types.hh:459
#define ND_OB_SELECT
Definition WM_types.hh:461
#define NC_SCENE
Definition WM_types.hh:391
#define ELEM(...)
#define STREQ(a, b)
int64_t size() const
KeyingSet * scene_get_active_keyingset(const Scene *scene)
ModifyKeyReturn validate_keyingset(bContext *C, Vector< PointerRNA > *sources, KeyingSet *keyingset)
static bool select_grouped_object_hooks(bContext *C, Object *ob)
static bool select_grouped_index_object(bContext *C, Object *ob)
bool jump_to_object(bContext *C, Object *ob, bool reveal_hidden)
static bool select_grouped_collection(bContext *C, Object *ob, ReportList *reports)
void OBJECT_OT_select_more(wmOperatorType *ot)
static wmOperatorStatus object_select_more_exec(bContext *C, wmOperator *)
void OBJECT_OT_select_mirror(wmOperatorType *ot)
static wmOperatorStatus object_select_random_exec(bContext *C, wmOperator *op)
static const EnumPropertyItem prop_select_grouped_types[]
static wmOperatorStatus object_select_same_collection_exec(bContext *C, wmOperator *op)
static bool object_select_all_by_library_obdata(bContext *C, Library *lib)
void OBJECT_OT_select_all(wmOperatorType *ot)
static bool select_grouped_color(bContext *C, Object *ob)
void OBJECT_OT_select_same_collection(wmOperatorType *ot)
static wmOperatorStatus object_select_less_exec(bContext *C, wmOperator *)
void base_activate(bContext *C, Base *base)
static wmOperatorStatus object_select_all_exec(bContext *C, wmOperator *op)
static const EnumPropertyItem prop_select_linked_types[]
static bool select_grouped_parent(bContext *C)
void base_select(Base *base, eObjectSelect_Mode mode)
static bool object_select_all_by_material(bContext *C, Material *mat)
void OBJECT_OT_select_linked(wmOperatorType *ot)
void OBJECT_OT_select_by_type(wmOperatorType *ot)
static bool select_grouped_children(bContext *C, Object *ob, const bool recursive)
static bool object_select_all_by_library(bContext *C, Library *lib)
static bool object_select_all_by_instance_collection(bContext *C, Object *ob)
void OBJECT_OT_select_less(wmOperatorType *ot)
static bool select_grouped_siblings(bContext *C, Object *ob)
static bool select_grouped_type(bContext *C, Object *ob)
bool base_deselect_all_ex(const Main &bmain, const Scene *scene, ViewLayer *view_layer, View3D *v3d, int action, bool *r_any_visible)
static bool object_select_more_less(bContext *C, const bool select)
Base * find_first_by_data_id(const Main &bmain, const Scene *scene, ViewLayer *view_layer, ID *id)
static wmOperatorStatus object_select_by_type_exec(bContext *C, wmOperator *op)
void base_activate_with_mode_exit_if_needed(bContext *C, Base *base)
static bool objects_selectable_poll(bContext *C)
bool editmode_exit_multi_ex(Main *bmain, Scene *scene, ViewLayer *view_layer, int flag)
static wmOperatorStatus object_select_mirror_exec(bContext *C, wmOperator *op)
static bool object_select_all_by_obdata(bContext *C, void *obdata)
bool jump_to_bone(bContext *C, Object *ob, const char *bone_name, bool reveal_hidden)
void base_active_refresh(Main *bmain, Scene *scene, ViewLayer *view_layer)
void select_linked_by_id(bContext *C, ID *id)
static bool object_select_all_by_particle(bContext *C, const ParticleSystem *psys_act)
void OBJECT_OT_select_grouped(wmOperatorType *ot)
static bool select_grouped_keyingset(bContext *C, Object *, ReportList *reports)
static bool select_grouped_lighttype(bContext *C, Object *ob)
static int get_base_select_priority(Base *base)
void OBJECT_OT_select_random(wmOperatorType *ot)
bool mode_set(bContext *C, eObjectMode mode)
bool base_deselect_all(const Main &bmain, const Scene *scene, ViewLayer *view_layer, View3D *v3d, int action)
static wmOperatorStatus object_select_linked_exec(bContext *C, wmOperator *op)
static wmOperatorStatus object_select_grouped_exec(bContext *C, wmOperator *op)
PopupMenu * popup_menu_begin(bContext *C, const char *title, int icon) ATTR_NONNULL()
void WM_main_add_notifier(uint type, void *reference)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
wmOperatorStatus WM_menu_invoke(bContext *C, wmOperator *op, const wmEvent *)
int RNA_enum_get(PointerRNA *ptr, const char *name)
Object * BKE_view_layer_active_object_get(const ViewLayer *view_layer)
PropertyRNA * RNA_def_string(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value, const int maxlen, const char *ui_name, const char *ui_description)
ID * BKE_libblock_find_name(Main *bmain, short type, const char *name, const std::optional< Library * > lib=std::nullopt) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Definition lib_id.cc:1808
void WM_operator_properties_select_random(wmOperatorType *ot)
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void ED_outliner_select_sync_from_pose_bone_tag(bContext *C)
const EnumPropertyItem rna_enum_object_type_items[]
struct ParticleSystem * psys_get_current(struct Object *ob)
Definition particle.cc:571
@ BASE_ENABLED_AND_MAYBE_VISIBLE_IN_VIEWPORT
Material * BKE_object_material_get(Object *ob, short act)
int WM_operator_properties_select_random_seed_increment_get(wmOperator *op)
void RNA_string_set(PointerRNA *ptr, const char *name, const char *value)
PropertyRNA * RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, const int default_value, const char *ui_name, const char *ui_description)
wmWindow * CTX_wm_window(const bContext *C)
Base * BKE_view_layer_active_base_get(ViewLayer *view_layer)
Base * CTX_data_active_base(const bContext *C)
ViewLayer * CTX_data_view_layer(const bContext *C)
void ED_outliner_select_sync_from_object_tag(bContext *C)
void WM_operator_properties_select_all(wmOperatorType *ot)
void BLI_array_randomize(void *data, unsigned int elem_size, unsigned int elem_num, unsigned int seed)
Definition rand.cc:158
bool BKE_collection_has_object(Collection *collection, const Object *ob)
Global G
Definition blender.cc:57
Object * BKE_view_layer_edit_object_get(const ViewLayer *view_layer)
void DEG_id_tag_update(ID *id, unsigned int flags)
void BKE_report(ReportList *reports, eReportType type, const char *message)
Definition report.cc:162
void ED_armature_edit_sync_selection(ListBaseT< EditBone > *edbo)
bool ED_pose_deselect_all(Object *ob, int select_mode, const bool ignore_visibility)
Object * CTX_data_edit_object(const bContext *C)
void BKE_scene_object_base_flag_sync_from_base(Base *base)
Definition scene.cc:3111
void ED_pose_bone_select(Object *ob, bPoseChannel *pchan, bool select, bool change_active)
bool BKE_view_layer_synced_ensure(const Main &bmain, const Scene *scene, ViewLayer *view_layer)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
void ED_pose_bone_select_tag_update(Object *ob)
void RNA_def_property_translation_context(PropertyRNA *prop, const char *context)
void ANIM_armature_bonecoll_show_from_ebone(bArmature *armature, const EditBone *ebone)
bool ED_operator_objectmode(bContext *C)
MINLINE bool compare_v3v3(const float v1[3], const float v2[3], float limit) ATTR_WARN_UNUSED_RESULT
void ANIM_armature_bonecoll_show_from_pchan(bArmature *armature, const bPoseChannel *pchan)
Main * CTX_data_main(const bContext *C)
@ ID_RECALC_SELECT
Definition DNA_ID.h:1101
ID_Type GS(const char *name)
Definition DNA_ID.h:410
Base * BKE_view_layer_base_find(ViewLayer *view_layer, Object *ob)
@ ID_TAG_DOIT
Definition DNA_ID.h:1029
void ED_outliner_select_sync_from_edit_bone_tag(bContext *C)
Scene * CTX_data_scene(const bContext *C)
@ OPTYPE_REGISTER
Definition WM_types.hh:188
@ OPTYPE_UNDO
Definition WM_types.hh:190
std::string RNA_string_get(PointerRNA *ptr, const char *name)
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, const bool default_value, const char *ui_name, const char *ui_description)
Object * CTX_data_active_object(const bContext *C)
void ED_armature_ebone_select_set(EditBone *ebone, bool select)
ListBaseT< Base > * BKE_view_layer_object_bases_get(ViewLayer *view_layer)
float RNA_float_get(PointerRNA *ptr, const char *name)
bPoseChannel * BKE_pose_channel_find_name(const bPose *pose, const char *name)
View3D * CTX_wm_view3d(const bContext *C)
EditBone * ED_armature_ebone_find_name(const ListBaseT< EditBone > *edbo, const char *name)
bool CTX_data_selectable_bases(const bContext *C, Vector< PointerRNA > *list)
bool ED_armature_edit_deselect_all(Object *obedit)
size_t BLI_string_flip_side_name(char *name_dst, const char *name_src, bool strip_number, size_t name_dst_maxncpy) ATTR_NONNULL(1
#define COLLECTION_MENU_MAX
struct Object * object
char name[258]
Definition DNA_ID.h:433
struct Library * lib
Definition DNA_ID.h:421
void * next
Definition DNA_ID.h:418
ListBaseT< KS_Path > paths
ListBaseT< wmWindowManager > wm
Definition BKE_main.hh:415
ListBaseT< Collection > collections
Definition BKE_main.hh:406
struct Object * parent
ListBaseT< ModifierData > modifiers
eObject_TransFlag transflag
struct bPose * pose
struct Collection * instance_collection
ListBaseT< EditBone > * edbo
struct EditBone * act_edbone
PointerRNA op(wmOperatorType *ot, std::optional< StringRef > name, int icon, wm::OpCallContext context, eUI_Item_Flag flag)
wmOperatorStatus(*) exec(bContext *C, wmOperator *op) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1125
const char * description
Definition WM_types.hh:1115
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1165
wmOperatorStatus(*) invoke(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1141
struct ReportList * reports
#define WM_msg_publish_rna_prop(mbus, id_, data_, type_, prop_)