ED_armature.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include "BLI_compiler_attrs.h"
#include "BLI_span.hh"
 
#include "DNA_windowmanager_enums.h"
 
struct Base;
struct Bone;
struct Depsgraph;
struct EditBone;
struct GPUSelectResult;
struct ListBase;
struct Main;
struct Mesh;
struct MeshDeformModifierData;
struct Object;
struct ReportList;
struct Scene;
struct SelectPick_Params;
struct UndoType;
struct View3D;
struct ViewLayer;
struct bArmature;
struct bContext;
struct bPoseChannel;
struct wmKeyConfig;
struct wmOperator;
 
#define BONESEL_ROOT (1u << 29)
#define BONESEL_TIP (1u << 30)
#define BONESEL_BONE (1u << 31)
#define BONESEL_ANY (BONESEL_TIP | BONESEL_ROOT | BONESEL_BONE)
 
#define EBONE_SELECTABLE(arm, ebone) \
  (blender::animrig::bone_is_visible(arm, ebone) && !((ebone)->flag & BONE_UNSELECTABLE))
 
#define EBONE_EDITABLE(ebone) \
  (CHECK_TYPE_INLINE(ebone, EditBone *), \
   (((ebone)->flag & BONE_SELECTED) && !((ebone)->flag & BONE_EDITMODE_LOCKED)))
 
/* Used in `armature_select.cc` and `pose_select.cc`. */
 
#define BONE_SELECT_PARENT 0
#define BONE_SELECT_CHILD 1
 
/* `armature_add.cc` */

EditBone *ED_armature_ebone_add(bArmature *arm, const char *name);
EditBone *ED_armature_ebone_add_primitive(Object *obedit_arm, float length, bool view_aligned);
 
void ED_armature_ebone_copy(EditBone *dest, const EditBone *source);

bArmature *ED_armature_context(const bContext *C);

float ED_armature_ebone_roll_to_vector(const EditBone *bone,
                                       const float align_axis[3],
                                       bool axis_only);
void ED_armature_origin_set(
    Main *bmain, Object *ob, const float cursor[3], int centermode, int around);
void ED_armature_edit_transform(bArmature *arm, const float mat[4][4], bool do_props);
void ED_armature_transform(bArmature *arm, const float mat[4][4], bool do_props);
 
/* `armature_naming.cc` */

void ED_armature_ebone_unique_name(ListBase *ebones, char *name, EditBone *bone);

void ED_armature_bone_rename(Main *bmain,
                             bArmature *arm,
                             const char *oldnamep,
                             const char *newnamep);
void ED_armature_bones_flip_names(Main *bmain,
                                  bArmature *arm,
                                  ListBase *bones_names,
                                  bool do_strip_numbers);
 
/* `armature_ops.cc` */
 
void ED_operatortypes_armature();
void ED_operatormacros_armature();
void ED_keymap_armature(wmKeyConfig *keyconf);
 
/* `armature_relations.cc` */

wmOperatorStatus ED_armature_join_objects_exec(bContext *C, wmOperator *op);
 
/* `armature_select.cc` */
 
Base *ED_armature_base_and_ebone_from_select_buffer(blender::Span<Base *> bases,
                                                    unsigned int select_id,
                                                    EditBone **r_ebone);
Object *ED_armature_object_and_ebone_from_select_buffer(blender::Span<Object *> objects,
                                                        unsigned int select_id,
                                                        EditBone **r_ebone);
Base *ED_armature_base_and_pchan_from_select_buffer(blender::Span<Base *> bases,
                                                    unsigned int select_id,
                                                    bPoseChannel **r_pchan);
Base *ED_armature_base_and_bone_from_select_buffer(blender::Span<Base *> bases,
                                                   unsigned int select_id,
                                                   Bone **r_bone);
bool ED_armature_edit_deselect_all(Object *obedit);
bool ED_armature_edit_deselect_all_visible(Object *obedit);
bool ED_armature_edit_deselect_all_multi_ex(blender::Span<Base *> bases);
bool ED_armature_edit_deselect_all_visible_multi_ex(blender::Span<Base *> bases);
bool ED_armature_edit_deselect_all_visible_multi(bContext *C);
bool ED_armature_edit_select_pick_bone(
    bContext *C, Base *basact, EditBone *ebone, int selmask, const SelectPick_Params &params);
bool ED_armature_edit_select_pick(bContext *C, const int mval[2], const SelectPick_Params &params);
bool ED_armature_edit_select_op_from_tagged(bArmature *arm, int sel_op);
 
/* `armature_skinning.cc` */
 
#define ARM_GROUPS_NAME 1
#define ARM_GROUPS_ENVELOPE 2
#define ARM_GROUPS_AUTO 3
void ED_object_vgroup_calc_from_armature(ReportList *reports,
                                         Depsgraph *depsgraph,
                                         Scene *scene,
                                         Object *ob,
                                         Object *par,
                                         int mode,
                                         bool mirror);
 
/* `editarmature_undo.cc` */

void ED_armature_undosys_type(UndoType *ut);
 
/* `armature_utils.cc` */

void ED_armature_edit_sync_selection(ListBase *edbo);
void ED_armature_ebone_remove_ex(bArmature *arm, EditBone *exBone, bool clear_connected);
void ED_armature_ebone_remove(bArmature *arm, EditBone *exBone);
bool ED_armature_ebone_is_child_recursive(EditBone *ebone_parent, EditBone *ebone_child);
EditBone *ED_armature_ebone_find_shared_parent(EditBone *ebone_child[],
                                               unsigned int ebone_child_tot);
void ED_armature_ebone_to_mat3(EditBone *ebone, float r_mat[3][3]);
void ED_armature_ebone_to_mat4(EditBone *ebone, float r_mat[4][4]);
void ED_armature_ebone_from_mat3(EditBone *ebone, const float mat[3][3]);
void ED_armature_ebone_from_mat4(EditBone *ebone, const float mat[4][4]);
EditBone *ED_armature_ebone_find_name(const ListBase *edbo, const char *name);
EditBone *ED_armature_ebone_get_mirrored(const ListBase *edbo, EditBone *ebo);
void ED_armature_ebone_transform_mirror_update(bArmature *arm, EditBone *ebo, bool check_select);
void ED_armature_edit_transform_mirror_update(Object *obedit);
void ED_armature_from_edit(Main *bmain, bArmature *arm);
void ED_armature_to_edit(bArmature *arm);
void ED_armature_edit_free(bArmature *arm);
void ED_armature_ebone_listbase_temp_clear(ListBase *lb);

void ED_armature_ebone_listbase_free(ListBase *lb, bool do_id_user);
void ED_armature_ebone_listbase_copy(ListBase *lb_dst, ListBase *lb_src, bool do_id_user);
 
int ED_armature_ebone_selectflag_get(const EditBone *ebone);
void ED_armature_ebone_selectflag_set(EditBone *ebone, int flag);
void ED_armature_ebone_select_set(EditBone *ebone, bool select);
void ED_armature_ebone_selectflag_enable(EditBone *ebone, int flag);
void ED_armature_ebone_selectflag_disable(EditBone *ebone, int flag);
 
/* `pose_edit.cc` */
 
Object *ED_pose_object_from_context(bContext *C);
bool ED_object_posemode_exit_ex(Main *bmain, Object *ob);
bool ED_object_posemode_exit(bContext *C, Object *ob);
bool ED_object_posemode_enter_ex(Main *bmain, Object *ob);
bool ED_object_posemode_enter(bContext *C, Object *ob);

enum ePosePathCalcRange {
  POSE_PATH_CALC_RANGE_CURRENT_FRAME,
  POSE_PATH_CALC_RANGE_CHANGED,
  POSE_PATH_CALC_RANGE_FULL,
};

void ED_pose_recalculate_paths(bContext *C, Scene *scene, Object *ob, ePosePathCalcRange range);
 
/* `pose_select.cc` */

bool ED_armature_pose_select_pick_bone(const Scene *scene,
                                       ViewLayer *view_layer,
                                       View3D *v3d,
                                       Object *ob,
                                       bPoseChannel *pchan,
                                       const SelectPick_Params &params) ATTR_NONNULL(1, 2, 3, 4);
bool ED_armature_pose_select_pick_with_buffer(const Scene *scene,
                                              ViewLayer *view_layer,
                                              View3D *v3d,
                                              Base *base,
                                              const GPUSelectResult *hit_results,
                                              int hits,
                                              const SelectPick_Params &params,
                                              bool do_nearest) ATTR_NONNULL(1, 2, 3, 4, 5);
void ED_armature_pose_select_in_wpaint_mode(const Scene *scene,
                                            ViewLayer *view_layer,
                                            Base *base_select);
bool ED_pose_deselect_all_multi_ex(blender::Span<Base *> bases,
                                   int select_mode,
                                   bool ignore_visibility);
bool ED_pose_deselect_all_multi(bContext *C, int select_mode, bool ignore_visibility);
bool ED_pose_deselect_all(Object *ob, int select_mode, bool ignore_visibility);
void ED_pose_bone_select_tag_update(Object *ob);
void ED_pose_bone_select(Object *ob, bPoseChannel *pchan, bool select, bool change_active);
 
/* `meshlaplacian.cc` */
 
void ED_mesh_deform_bind_callback(Object *object,
                                  MeshDeformModifierData *mmd,
                                  Mesh *cagemesh,
                                  float *vertexcos,
                                  int verts_num,
                                  float cagemat[4][4]);
 
EditBone *ED_armature_pick_ebone(bContext *C, const int xy[2], bool findunsel, Base **r_base);
bPoseChannel *ED_armature_pick_pchan(bContext *C, const int xy[2], bool findunsel, Base **r_base);
Bone *ED_armature_pick_bone(bContext *C, const int xy[2], bool findunsel, Base **r_base);