BKE_action.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
#pragma once

 
#include "BLI_compiler_attrs.h"
#include "BLI_function_ref.hh"
#include "BLI_span.hh"
 
struct BlendDataReader;
struct BlendLibReader;
struct BlendWriter;
struct bArmature;
 
/* The following structures are defined in DNA_action_types.h, and DNA_anim_types.h */
struct AnimationEvalContext;
struct BoneColor;
struct FCurve;
struct ID;
struct Main;
struct Object;
struct bAction;
struct bActionGroup;
struct bItasc;
struct bPose;
struct bPoseChannel;
struct bPoseChannel_Runtime;
 
namespace blender::animrig {

using slot_handle_t = int32_t;
 
}  // namespace blender::animrig
 
/* Action Lib Stuff ----------------- */
 
/* Allocate a new bAction with the given name */
bAction *BKE_action_add(Main *bmain, const char name[]);
 
/* Action API ----------------- */

void BKE_action_fcurves_clear(bAction *act);
 
/* Action Groups API ----------------- */

bActionGroup *get_active_actiongroup(bAction *act) ATTR_WARN_UNUSED_RESULT;

void set_active_action_group(bAction *act, bActionGroup *agrp, short select);

void action_group_colors_sync(bActionGroup *grp, const bActionGroup *ref_grp);

void action_group_colors_set(bActionGroup *grp, const BoneColor *color);

void action_group_colors_set_from_posebone(bActionGroup *grp, const bPoseChannel *pchan);

bActionGroup *action_groups_add_new(bAction *act, const char name[]);

void action_groups_add_channel(bAction *act, bActionGroup *agrp, FCurve *fcurve);

void action_groups_remove_channel(bAction *act, FCurve *fcu);

void BKE_action_groups_reconstruct(bAction *act);

bActionGroup *BKE_action_group_find_name(bAction *act, const char name[]);

void action_groups_clear_tempflags(bAction *act);
 
/* Pose API ----------------- */
 
void BKE_pose_channel_free(bPoseChannel *pchan) ATTR_NONNULL(1);
void BKE_pose_channel_free_ex(bPoseChannel *pchan, bool do_id_user) ATTR_NONNULL(1);

void BKE_pose_channel_runtime_reset(bPoseChannel_Runtime *runtime) ATTR_NONNULL(1);
void BKE_pose_channel_runtime_reset_on_copy(bPoseChannel_Runtime *runtime) ATTR_NONNULL(1);

void BKE_pose_channel_runtime_free(bPoseChannel_Runtime *runtime) ATTR_NONNULL(1);

void BKE_pose_channel_free_bbone_cache(bPoseChannel_Runtime *runtime) ATTR_NONNULL(1);
 
void BKE_pose_channels_free(bPose *pose) ATTR_NONNULL(1);
void BKE_pose_channels_free_ex(bPose *pose, bool do_id_user) ATTR_NONNULL(1);

void BKE_pose_channels_hash_ensure(bPose *pose) ATTR_NONNULL(1);
void BKE_pose_channels_hash_free(bPose *pose) ATTR_NONNULL(1);

void BKE_pose_channels_remove(Object *ob,
                              bool (*filter_fn)(const char *bone_name, void *user_data),
                              void *user_data) ATTR_NONNULL(1, 2);
 
void BKE_pose_free_data_ex(bPose *pose, bool do_id_user) ATTR_NONNULL(1);
void BKE_pose_free_data(bPose *pose) ATTR_NONNULL(1);
void BKE_pose_free(bPose *pose);
void BKE_pose_free_ex(bPose *pose, bool do_id_user);
void BKE_pose_copy_data_ex(bPose **dst, const bPose *src, int flag, bool copy_constraints);
void BKE_pose_copy_data(bPose **dst, const bPose *src, bool copy_constraints);
void BKE_pose_channel_copy_data(bPoseChannel *pchan, const bPoseChannel *pchan_from);
void BKE_pose_channel_session_uid_generate(bPoseChannel *pchan);
bPoseChannel *BKE_pose_channel_find_name(const bPose *pose, const char *name);
bool BKE_pose_is_bonecoll_visible(const bArmature *arm,
                                  const bPoseChannel *pchan) ATTR_WARN_UNUSED_RESULT;
bPoseChannel *BKE_pose_channel_active(Object *ob, bool check_bonecoll);
bPoseChannel *BKE_pose_channel_active_if_bonecoll_visible(Object *ob) ATTR_WARN_UNUSED_RESULT;
bPoseChannel *BKE_pose_channel_active_or_first_selected(Object *ob) ATTR_WARN_UNUSED_RESULT;
bPoseChannel *BKE_pose_channel_ensure(bPose *pose, const char *name) ATTR_NONNULL(2);
bPoseChannel *BKE_pose_channel_get_mirrored(const bPose *pose,
                                            const char *name) ATTR_WARN_UNUSED_RESULT;
 
void BKE_pose_check_uids_unique_and_report(const bPose *pose);
 
#ifndef NDEBUG
bool BKE_pose_channels_is_valid(const bPose *pose) ATTR_WARN_UNUSED_RESULT;
#endif

void BKE_pose_update_constraint_flags(bPose *pose) ATTR_NONNULL(1);

void BKE_pose_tag_update_constraint_flags(bPose *pose) ATTR_NONNULL(1);

const char *BKE_pose_ikparam_get_name(bPose *pose) ATTR_WARN_UNUSED_RESULT;

void BKE_pose_ikparam_init(bPose *pose) ATTR_NONNULL(1);

void BKE_pose_itasc_init(bItasc *itasc);

bool BKE_pose_channel_in_IK_chain(Object *ob, bPoseChannel *pchan);
 
/* Bone Groups API --------------------- */

bActionGroup *BKE_pose_add_group(bPose *pose, const char *name) ATTR_NONNULL(1);

void BKE_pose_remove_group(bPose *pose, bActionGroup *grp, int index) ATTR_NONNULL(1);
void BKE_pose_remove_group_index(bPose *pose, int index) ATTR_NONNULL(1);
 
/* Assorted Evaluation ----------------- */

void what_does_obaction(Object *ob,
                        Object *workob,
                        bPose *pose,
                        bAction *act,
                        int32_t action_slot_handle,
                        char groupname[],
                        const AnimationEvalContext *anim_eval_context) ATTR_NONNULL(1, 2);
 
void BKE_pose_copy_pchan_result(bPoseChannel *pchanto, const bPoseChannel *pchanfrom)
    ATTR_NONNULL(1, 2);
bool BKE_pose_copy_result(bPose *to, bPose *from);
void BKE_pose_rest(bPose *pose, bool selected_bones_only);

void BKE_pose_tag_recalc(Main *bmain, bPose *pose) ATTR_NONNULL(1, 2);
 
void BKE_pose_blend_write(BlendWriter *writer, bPose *pose, bArmature *arm) ATTR_NONNULL(1, 2, 3);
void BKE_pose_blend_read_data(BlendDataReader *reader, ID *id_owner, bPose *pose)
    ATTR_NONNULL(1, 2);
void BKE_pose_blend_read_after_liblink(BlendLibReader *reader, Object *ob, bPose *pose)
    ATTR_NONNULL(1, 2);
 
/* `action_mirror.cc` */

void BKE_action_flip_with_pose(bAction *act, blender::Span<Object *> objects) ATTR_NONNULL(1);
 
namespace blender::bke {
 
using FoundFCurveCallback = blender::FunctionRef<void(FCurve *fcurve, const char *bone_name)>;
using FoundFCurveCallbackConst =
    blender::FunctionRef<void(const FCurve *fcurve, const char *bone_name)>;

void BKE_action_find_fcurves_with_bones(bAction *action,
                                        blender::animrig::slot_handle_t slot_handle,
                                        FoundFCurveCallback callback);
void BKE_action_find_fcurves_with_bones(const bAction *action,
                                        blender::animrig::slot_handle_t slot_handle,
                                        FoundFCurveCallbackConst callback);
 
};  // namespace blender::bke