17#include <fmt/format.h>
41#include "RNA_prototypes.hh"
83 const Bone *bone_src_act,
84 Bone **r_bone_dst_act,
99 bArmature *armature = id_cast<bArmature *>(
id);
101 armature->
runtime = MEM_new<bke::bArmature_Runtime>(__func__);
121 const int lib_id_flag)
123 bcoll_dst = MEM_dupalloc(bcoll_src);
126 if (bcoll_dst->
prop) {
151 std::optional<Library *> ,
156 bArmature *armature_dst = id_cast<bArmature *>(id_dst);
157 const bArmature *armature_src = id_cast<const bArmature *>(id_src);
158 armature_dst->
runtime = MEM_new<bke::bArmature_Runtime>(__func__);
160 Bone *bone_src, *bone_dst;
161 Bone *bone_dst_act =
nullptr;
171 bone_dst = armature_dst->
bonebase.first();
172 for (bone_src = armature_src->
bonebase.first(); bone_src; bone_src = bone_src->
next) {
173 bone_dst->
parent =
nullptr;
175 bone_dst = bone_dst->
next;
178 armature_dst->
act_bone = bone_dst_act;
198 for (bone_dst = armature_dst->
bonebase.first(); bone_dst; bone_dst = bone_dst->
next) {
202 armature_dst->
edbo =
nullptr;
230 bArmature *armature = id_cast<bArmature *>(
id);
237 bcoll->bones.free_no_destruct();
249 if (armature->
edbo) {
251 MEM_delete(armature->
edbo);
252 armature->
edbo =
nullptr;
260 BKE_lib_query_idpropertiesForeachIDLink_callback(prop, data);
265 BKE_lib_query_idpropertiesForeachIDLink_callback(prop, data);
277 BKE_lib_query_idpropertiesForeachIDLink_callback(prop, data);
283 BKE_lib_query_idpropertiesForeachIDLink_callback(prop, data);
291 BKE_lib_query_idpropertiesForeachIDLink_callback(prop, data);
296 BKE_lib_query_idpropertiesForeachIDLink_callback(prop, data);
302 bArmature *arm = id_cast<bArmature *>(
id);
307 if (arm->
edbo !=
nullptr) {
329 bone->
runtime = runtime_backup;
365 bArmature *arm = id_cast<bArmature *>(
id);
414 if (bone->
name[0] ==
'\0') {
415 *all_bones_are_named =
false;
460 int min_child_index = 0;
464 if (bcoll.child_index > 0) {
465 min_child_index =
min_ii(min_child_index, bcoll.child_index);
473 if (min_child_index == 0) {
496 if (reset_bcoll_override_flag) {
510 constexpr const char *name_prefix =
"unnamed.";
511 constexpr const char *format_string =
"unnamed.{:0>3}";
516 if (bone.
name[0] ==
'\0') {
517 no_name_bones.
append(
const_cast<Bone *
>(&bone));
521 potential_duplicates.
add(bone.
name);
527 int unique_index = 0;
528 std::string bone_name;
529 for (
Bone *bone : no_name_bones) {
530 bone_name = fmt::format(format_string, unique_index);
531 while (potential_duplicates.
contains(bone_name)) {
533 bone_name = fmt::format(format_string, unique_index);
542 bArmature *arm = id_cast<bArmature *>(
id);
548 bool all_bones_are_named =
true;
552 if (!all_bones_are_named) {
553 CLOG_WARN(&
LOG,
"Found bones with empty names. Fixing automatically.\n");
564 arm->
runtime = MEM_new<bke::bArmature_Runtime>(__func__);
575 bArmature *arm_new = id_cast<bArmature *>(id_new);
576 bArmature *arm_old = id_cast<bArmature *>(id_old);
582 .id_code = bArmature::id_type,
589 .name_plural =
N_(
"armatures"),
592 .asset_type_info =
nullptr,
597 .make_local =
nullptr,
599 .foreach_cache =
nullptr,
600 .foreach_path =
nullptr,
601 .foreach_working_space_color =
nullptr,
602 .foreach_asset_weak_reference =
nullptr,
603 .owner_pointer_get =
nullptr,
607 .blend_read_after_liblink =
nullptr,
611 .lib_override_apply_post =
nullptr,
631 return id_cast<bArmature *>(ob->
data);
639 for (
Bone &bone : *lb) {
648 for (
Bone &bone : *lb) {
652 if (bone.system_properties) {
655 bone.runtime.collections.free_no_destruct();
659 lb->free_no_destruct();
664 for (
EditBone &edit_bone : lb->items_mutable()) {
665 if (edit_bone.prop) {
668 if (edit_bone.system_properties) {
672 MEM_delete(&edit_bone);
677 const Bone *bone_src,
678 const Bone *bone_src_act,
679 Bone **r_bone_dst_act,
682 Bone *bone_src_child, *bone_dst_child;
684 if (bone_src == bone_src_act) {
685 *r_bone_dst_act = bone_dst;
688 if (bone_src->
prop) {
704 for (bone_src_child = bone_src->
childbase.first(), bone_dst_child = bone_dst->
childbase.first();
706 bone_src_child = bone_src_child->
next, bone_dst_child = bone_dst_child->
next)
708 bone_dst_child->
parent = bone_dst;
709 copy_bonechildren(bone_dst_child, bone_src_child, bone_src_act, r_bone_dst_act, flag);
715 Bone *bone_dst_child;
724 for (bone_dst_child = bone_dst->
childbase.first(); bone_dst_child;
725 bone_dst_child = bone_dst_child->
next)
758 while (bone_dst !=
nullptr) {
761 bone_dst = bone_dst->
next;
762 bone_src = bone_src->
next;
776 const float mat[4][4],
779 const float mat3[3][3],
782 const Bone *bone_parent,
783 const float arm_mat_parent_inv[4][4])
785 for (
Bone &bone : *bonebase) {
792 float roll_mat3_pre[3][3];
797 if (bone.parent ==
nullptr) {
822 float roll_mat3_post[3][3], delta_mat3[3][3];
827 mul_m3_m3m3(delta_mat3, roll_mat3_post, roll_mat3_pre);
828 bone.roll =
atan2f(delta_mat3[2][0], delta_mat3[2][2]);
834 float arm_mat3[3][3];
840 bone.rad_head *=
scale;
841 bone.rad_tail *=
scale;
845 bone.xwidth *=
scale;
846 bone.zwidth *=
scale;
849 if (!bone.childbase.is_empty()) {
850 float arm_mat_inv[4][4];
879 for (
Bone &curBone : *lb) {
880 if (
STREQ(curBone.name, name)) {
908 for (
Bone &bone : *lb) {
951 if (bone->
flag & flag) {
967 char name[
MAXBONENAME],
int ,
short axis,
float head,
float tail)
983 const char *extension =
nullptr;
1003 else if (axis == 1) {
1005 if (
IS_EQF(head, 0.0f)) {
1009 else if (tail > 0) {
1024 if (
IS_EQF(head, 0.0f)) {
1028 else if (tail > 0) {
1037 else if (head > 0) {
1048 bool changed =
true;
1052 if (
len > 2 && basename[
len - 2] ==
'.') {
1053 if (
ELEM(basename[
len - 1],
'L',
'R')) {
1054 basename[
len - 2] =
'\0';
1059 else if (
len > 3 && basename[
len - 3] ==
'.') {
1060 if ((basename[
len - 2] ==
'F' && basename[
len - 1] ==
'r') ||
1061 (basename[
len - 2] ==
'B' && basename[
len - 1] ==
'k'))
1063 basename[
len - 3] =
'\0';
1068 else if (
len > 4 && basename[
len - 4] ==
'.') {
1069 if ((basename[
len - 3] ==
'T' && basename[
len - 2] ==
'o' &&
1070 basename[
len - 1] ==
'p') ||
1071 (basename[
len - 3] ==
'B' && basename[
len - 2] ==
'o' &&
1072 basename[
len - 1] ==
't'))
1074 basename[
len - 4] =
'\0';
1082 const int basename_maxncpy = (
MAXBONENAME - 1) - (1 + strlen(extension));
1101 const float *segment_scales,
1105 float *pdist =
static_cast<float *
>(
BLI_array_alloca(pdist, temp_segments + 1));
1108 for (
int i = 0; i < 3; i++) {
1121 for (
int i = 0; i < temp_segments; i++) {
1122 pdist[i + 1] = pdist[i] +
len_v3v3(coords[i], coords[i + 1]);
1126 float dist_step = pdist[temp_segments];
1127 float dist = 0, sum = 0;
1129 for (
int i = 0; i < final_segments; i++) {
1130 sum += segment_scales[i];
1135 r_t_points[0] = 0.0f;
1137 for (
int i = 1, nr = 1; i <= final_segments; i++) {
1138 dist += segment_scales[i - 1] * dist_step;
1141 while ((nr < temp_segments) && (dist >= pdist[nr])) {
1145 float fac = (pdist[nr] - dist) / (pdist[nr] - pdist[nr - 1]);
1147 r_t_points[i] = (nr - fac) / temp_segments;
1150 r_t_points[final_segments] = 1.0f;
1209 float imat[4][4], posemat[4][4], tmpmat[4][4];
1212 memset(param, 0,
sizeof(*param));
1231 const Bone *next_bone = next ? next->bone_get(armature) :
nullptr;
1232 const Bone *prev_bone = prev ? prev->bone_get(armature) :
nullptr;
1249 float prev_scale[3], next_scale[3];
1282 sub_v3_v3v3(delta, prev->pose_tail, prev->pose_head);
1391 param->
roll1 += prev->roll2;
1423 param->
scale_in[0] *= prev_scale[0];
1426 param->
scale_in[1] *= prev_scale[1];
1429 param->
scale_in[2] *= prev_scale[2];
1432 param->
ease1 *= prev_scale[1];
1447 param->
ease2 *= next_scale[1];
1457 const bool for_deform,
1477 float epsilon = 1
e-5 *
length;
1483 *r_roll1 = *r_roll2 = 0.0f;
1539 const float hlength1 = param->
ease1 * circle_factor;
1540 const float hlength2 = param->
ease2 * circle_factor;
1563 *r_roll1 += param->
roll1;
1564 *r_roll2 += param->
roll2;
1572 const float xscale_correction = (param->
do_scale) ? param->
scale[0] : 1.0f;
1573 const float zscale_correction = (param->
do_scale) ? param->
scale[2] : 1.0f;
1575 h1[0] += param->
curve_in_x * xscale_correction;
1576 h1[2] += param->
curve_in_z * zscale_correction;
1584 const float scalemats[2][4][4],
1586 const float axis[3],
1612 const float gap = 0.1f;
1617 if (len2 == 0.0f) [[unlikely]] {
1621 const float ratio = len1 / len2;
1622 if (ratio < gap * gap) {
1628 const bool for_deform,
1631 float scalemats[2][4][4];
1632 float bezt_controls[4][3];
1633 float h1[3], roll1, h2[3], roll2, prev[3], cur[3], axis[3];
1649 add_v3_v3v3(bezt_controls[2], bezt_controls[3], h2);
1659 const float log_scale_in_len =
logf(param->
scale_in[1]);
1662 for (
int i = 0; i < param->
segments; i++) {
1664 segment_scales[i] =
expf(
interpf(log_scale_out_len, log_scale_in_len, fac));
1676 float bezt_deriv1[3][3], bezt_deriv2[2][3];
1678 for (
int i = 0; i < 3; i++) {
1679 sub_v3_v3v3(bezt_deriv1[i], bezt_controls[i + 1], bezt_controls[i]);
1681 for (
int i = 0; i < 2; i++) {
1682 sub_v3_v3v3(bezt_deriv2[i], bezt_deriv1[i + 1], bezt_deriv1[i]);
1694 result_array[0].
mat);
1696 for (
int a = 1; a < param->
segments; a++) {
1700 float roll =
interpf(roll2, roll1, fac);
1705 param, scalemats, cur, axis, roll, scalex, scalez, result_array[a].mat);
1723 for (
int a = 0; a < param->
segments; a++) {
1728 float fac = (a + 0.5f) / param->
segments;
1729 float roll =
interpf(roll2, roll1, fac);
1734 param, scalemats, prev, axis, roll, scalex, scalez, result_array[a].mat);
1744 const bool use_boundaries)
1753 1 +
uint(segments),
"bPoseChannel_Runtime::bbone_rest_mats");
1755 1 +
uint(segments),
"bPoseChannel_Runtime::bbone_pose_mats");
1757 2 +
uint(segments),
"bPoseChannel_Runtime::bbone_deform_mats");
1759 "bPoseChannel_Runtime::bbone_dual_quats");
1765 1 +
uint(segments),
"bPoseChannel_Runtime::bbone_segment_boundaries");
1767 else if (!use_boundaries) {
1782 for (
int i = 0; i <= bone->
segments; i++) {
1789 for (
int i = 0; i <= bone->
segments; i++) {
1796 for (
int i = 0; i < bone->
segments; i++) {
1804 const int bsp_depth = int(
ceilf(log2f(bone->
segments + 2)));
1810 const float tuning_factor = 0.222f;
1812 const float max_depth_scale = bone->
segments * (straight_length /
arc_length) * tuning_factor;
1816 const float scale_factor =
powf(
max_ff(max_depth_scale, 1.0f), 1.0f / (bsp_depth - 1));
1820 for (
int i = 1; i < bsp_depth; i++) {
1867 for (a = 0; a <= bone->
segments; a++) {
1876 b_bone_mats[0].
mat);
1882 mat4_to_dquat(&b_bone_dual_quats[a], tmat, b_bone_mats[a + 1].mat);
1892 if (segments <= 1) {
1904 sizeof(
Mat4) * (2 + segments));
1907 sizeof(
DualQuat) * (1 + segments));
1909 if (use_curved_mapping) {
1925 float *r_blend_next)
1929 CLAMP(head_tail, 0.0f, 1.0f);
1935 float pre_blend = head_tail *
float(segments);
1940 float blend = pre_blend -
index;
1941 CLAMP(blend, 0.0f, 1.0f);
1944 *r_blend_next = blend;
1951 float *r_blend_next)
1954 const float (*mat)[4] = mats[0].
mat;
1957 const float y = mat[0][1] * co[0] + mat[1][1] * co[1] + mat[2][1] * co[2] + mat[3][1];
1975 float *r_blend_next)
1990 int start = -1, end = segments + 1, bias = 0;
1992 while (end - start > 1) {
1993 const int mid = (start + end + bias) / 2;
1999 boundary_idx_stack[++stack_top] = mid;
2000 boundary_dist[mid] = dist;
2015 const float segment_size = 1.0f / segments;
2021 else if (start >= segments) {
2026 const float d1 =
fabsf(boundary_dist[start]);
2027 const float d2 =
fabsf(boundary_dist[end]);
2028 const float t = d1 / (d1 + d2);
2030 head_tail = segment_size * (start + t);
2042 for (
int i = stack_top; i >= 0; --i) {
2043 const int boundary_idx = boundary_idx_stack[i];
2046 const float boundary_pos = boundary_idx * segment_size;
2050 const float point_dist = boundary_dist[boundary_idx] * segment_scale;
2051 const float point_dist_abs =
fabsf(point_dist);
2054 const float mapped_dist =
fabsf(head_tail - boundary_pos);
2058 const float slope_gap = mapped_dist - point_dist_abs;
2060 if (slope_gap <= 0) {
2066 const float dist_coeff = 1.0f - point_dist_abs * boundaries[i].
depth_scale;
2068 if (dist_coeff <= 0) {
2074 const float slope_tune_coeff = 3.0f;
2075 const float scaled_gap = slope_gap * slope_tune_coeff;
2076 const float slope_coeff = scaled_gap / (scaled_gap + point_dist_abs);
2079 const float dist_tune_coeff = 7.0f;
2080 const float dist_coeff_smooth = dist_coeff * dist_coeff * (dist_tune_coeff + 1.0f) /
2081 (dist_tune_coeff * dist_coeff + 1.0f);
2084 const float target_pos = boundary_pos + point_dist;
2086 head_tail =
interpf(target_pos, head_tail, slope_coeff * dist_coeff_smooth);
2096 float *r_blend_next)
2117 if (ob ==
nullptr) {
2130 float xLocMat[4][4];
2131 float nLocMat[4][4];
2173 float offs_bone[4][4];
2191 int inherit_scale_mode,
2192 const float offs_bone[4][4],
2193 const float parent_arm_mat[4][4],
2194 const float parent_pose_mat[4][4],
2199 if (parent_pose_mat) {
2200 const bool use_rotation = (bone_flag &
BONE_HINGE) == 0;
2204 if (full_transform) {
2209 float tmat[4][4], tscale[3];
2216 switch (inherit_scale_mode) {
2248 switch (inherit_scale_mode) {
2295 float bone_loc[4][4], bone_rotscale[3][3], tmat4[4][4], tmat3[3][3];
2300 mul_v3_m4v3(bone_loc[3], parent_pose_mat, offs_bone[3]);
2310 else if (!full_transform) {
2359 const float inmat[4][4],
2372 const float inmat[4][4],
2383 const float inmat[4][4],
2393 const float inloc[3],
2396 float xLocMat[4][4];
2397 float nLocMat[4][4];
2419 const float inmat[4][4],
2521 float pose_mat[4][4],
2522 float arm_mat[4][4])
2563 else if (oldMode > 0) {
2582 if (
IS_EQF(axis[0], axis[1]) &&
IS_EQF(axis[1], axis[2])) {
2598 pchan->
loc[0] = location[0];
2601 pchan->
loc[1] = location[1];
2604 pchan->
loc[2] = location[2];
2618 float angle, axis[3];
2647 pchan->
quat[0] = quat[0];
2650 pchan->
quat[1] = quat[1];
2653 pchan->
quat[2] = quat[2];
2656 pchan->
quat[3] = quat[3];
2663 pchan->
eul[0] = euler[0];
2666 pchan->
eul[1] = euler[1];
2669 pchan->
eul[2] = euler[2];
2674 const float axis[3],
2730 float vecmat[3][3], vecmatinv[3][3], rollmat[3][3], q[4];
2818 const float SAFE_THRESHOLD = 6.1e-3f;
2819 const float CRITICAL_THRESHOLD = 2.5e-4f;
2820 const float THRESHOLD_SQUARED = CRITICAL_THRESHOLD * CRITICAL_THRESHOLD;
2822 const float x = nor[0];
2823 const float y = nor[1];
2824 const float z = nor[2];
2826 float theta = 1.0f +
y;
2827 const float theta_alt =
x *
x +
z *
z;
2828 float rMatrix[3][3], bMatrix[3][3];
2840 if (theta > SAFE_THRESHOLD || theta_alt > THRESHOLD_SQUARED) {
2849 if (theta <= SAFE_THRESHOLD) {
2852 theta = theta_alt * 0.5f + theta_alt * theta_alt * 0.125f;
2855 bMatrix[0][0] = 1 -
x *
x / theta;
2856 bMatrix[2][2] = 1 -
z *
z / theta;
2857 bMatrix[2][0] = bMatrix[0][2] = -
x *
z / theta;
2862 bMatrix[0][0] = bMatrix[1][1] = -1.0;
2896 if (bone->
xwidth == 0.0f) {
2903 float offs_bone[4][4];
2916 if (use_recursion) {
2918 for (bone = bone->
childbase.first(); bone; bone = bone->
next) {
2962 if (pchan->
prev != prev_pchan) {
2975 pchan.
child =
nullptr;
2997 Bone *bone = pchan.bone_get(*armature_ob);
2998 if (bone ==
nullptr) {
3016 if (ob->
pose ==
nullptr) {
3018 ob->
pose = MEM_new<bPose>(
"new pose");
3019 ob->
pose->
runtime = MEM_new<bke::bPoseRuntime>(__func__);
3056 if (bmain !=
nullptr) {
3079 const bArmature &armature = *id_cast<const bArmature *>(pose_ob.
data);
3111 if (armature_generation_count != object_generation_count ||
3175 Bone *bone = pchan->bone_get(*ob);
3241 arm = id_cast<bArmature *>(ob->
data);
3243 if (
ELEM(
nullptr, arm, scene)) {
3255 const Bone *bone = pchan.bone_get(*arm);
3301 const Bone *bone = pchan.bone_get(*arm);
3322 const bool use_empty_drawtype,
3327 const bArmature *arm = id_cast<const bArmature *>(ob->
data);
3329 Object *ob_custom =
nullptr;
3337 ob_custom = pchan->
custom;
3343 std::optional<Bounds<float3>> bb_custom;
3346 if (use_empty_drawtype && (ob_custom->
type ==
OB_EMPTY) &&
3380 return std::nullopt;
3383 float3 min(std::numeric_limits<float>::max());
3384 float3 max(std::numeric_limits<float>::lowest());
3387 const bArmature *arm = id_cast<const bArmature *>(ob->
data);
3389 bool found_pchan =
false;
3393 const Bone *bone = pchan.bone_get(*ob);
3411 return std::nullopt;
3428 rootchan = rootchan->
parent;
3430 if (rootchan !=
nullptr) {
3432 while (rootchan->
parent) {
3435 if (segcount ==
data->rootbone) {
3438 rootchan = rootchan->
parent;
3450 while (rootchan->
parent) {
3453 if (segcount ==
data->chainlen) {
3456 rootchan = rootchan->
parent;
3496bool BoneCollection::is_visible()
const
3500bool BoneCollection::is_visible_ancestors()
const
3504bool BoneCollection::is_visible_with_ancestors()
const
3506 return this->is_visible() && this->is_visible_ancestors();
3508bool BoneCollection::is_solo()
const
3512bool BoneCollection::is_expanded()
const
3537 bones[bone_index] =
const_cast<Bone *
>(&bone);
3540 runtime.
bones = std::move(bones);
3546 this->
bones.clear_without_destruct();
3551 return !this->
bones.is_empty();
3554const Bone *bArmature::bone_get_indexed(
const int64_t bone_index)
const
3559 if (this->bonebase.is_empty()) {
3563 if (!this->runtime->is_bones_array_valid()) {
3569 BLI_assert(bone_index < this->runtime->bones.size());
3570 return this->runtime->bones[bone_index];
3573Bone *bArmature::bone_get_indexed(
const int64_t bone_index)
3575 return const_cast<Bone *
>(std::as_const(*this).bone_get_indexed(bone_index));
3584 callback(bone_index++, bone);
Functions to deal with Armatures.
C++ functions to deal with Armature collections (i.e. the successor of bone layers).
Blender kernel action and pose functionality.
#define IDP_BlendDataRead(reader, prop)
#define MAIN_ID_SESSION_UID_UNSET
#define BKE_LIB_FOREACHID_PROCESS_FUNCTION_CALL(data_, func_call_)
General operations, lookup, etc. for blender objects.
#define BLI_array_alloca(arr, realsize)
#define BLI_ASSERT_UNIT_M3(m)
#define BLI_ASSERT_UNIT_V3(v)
#define mul_m4_series(...)
#define STRNCPY_UTF8_RLEN(dst, src)
#define STRNCPY_UTF8(dst, src)
#define BLO_read_struct_list(reader, struct_name, list)
#define BLO_read_struct(reader, struct_name, ptr_p)
#define BLT_I18NCONTEXT_ID_ARMATURE
#define CLOG_WARN(clg_ref,...)
#define ID_IS_LINKED(_id)
#define PCHAN_CUSTOM_BONE_LENGTH(pchanbone)
These structs are the foundation for all linked lists in the library system.
Object is a sort of wrapper for general info.
Read Blender memory allocation and freeing.
#define BLI_assert_unreachable()
#define INIT_DEFAULT_STRUCT_AFTER(struct_dst, member)
ccl_device_inline float arc_length(const float e2, const float gamma)
SIMD_FORCE_INLINE const btScalar & z() const
Return the z value.
SIMD_FORCE_INLINE btScalar angle(const btVector3 &v) const
Return the angle between this and another vector.
bool contains(const Key &key) const
constexpr StringRefNull()
void append(const T &value)
float length(VecOp< float, D >) RET
float3x3 scale(float3x3 mat, float2 scale)
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
bool bone_is_visible(const bArmature *armature, const Bone *bone)
void bonecolls_copy_expanded_flag(Span< BoneCollection * > bcolls_dest, Span< const BoneCollection * > bcolls_source)
bool bone_is_selected(const bArmature *armature, const Bone *bone)
void settings_init(struct bAnimVizSettings *avs)
PChanBoneT< bPoseChannel, Bone > PChanBone
PChanBoneT< const bPoseChannel, const Bone > PChanBoneConst
Bounds< VecBase< T, 3 > > transform_bounds(const MatBase< T, D, D > &matrix, const Bounds< VecBase< T, 3 > > &bounds)
internal::ShallowDataConstRef< T > shallow_copy(const T &other)
T min(const T &a, const T &b)
T max(const T &a, const T &b)
static void rebuild_pose_from_armature(Object &pose_ob, const bArmature &armature)
MINLINE void madd_v3_v3v3fl(float r[3], const float a[3], const float b[3], float f)
bPoseChannel * BKE_pose_channel_ensure(bPose *pose, const char *name) ATTR_NONNULL(2)
void BIK_execute_tree(struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob, struct bPoseChannel *pchan, float ctime)
void ANIM_armature_runtime_free(bArmature *armature)
static void ease_handle_axis(const float deriv1[3], const float deriv2[3], float r_axis[3])
static void armature_copy_data(Main *, std::optional< Library * >, ID *id_dst, const ID *id_src, const int flag)
void mat3_vec_to_roll(const float mat[3][3], const float vec[3], float *r_roll)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void BKE_bone_parent_transform_combine(const BoneParentTransform *in1, const BoneParentTransform *in2, BoneParentTransform *result)
size_t size_t size_t BLI_snprintf_utf8(char *__restrict dst, size_t dst_maxncpy, const char *__restrict format,...) ATTR_NONNULL(1
void BKE_pchan_calc_mat(bke::PChanBone pchanbone)
bArmature * BKE_armature_from_object(Object *ob)
unsigned __int64 uint64_t
void BKE_pchan_mat3_to_rot(bPoseChannel *pchan, const float mat[3][3], bool use_compat)
bArmature * BKE_armature_add(Main *bmain, const char *name)
void IDP_FreeProperty_ex(IDProperty *prop, bool do_id_user)
static void copy_bone_collection(bArmature *armature_dst, BoneCollection *&bcoll_dst, const BoneCollection *bcoll_src, const int lib_id_flag)
void mat4_to_loc_rot_size(float loc[3], float rot[3][3], float size[3], const float wmat[4][4])
static void armature_init_data(ID *id)
static void armature_undo_preserve(BlendLibReader *, ID *id_new, ID *id_old)
void vec_roll_to_mat3(const float vec[3], float roll, float r_mat[3][3])
void BKE_pose_rebuild(Main *bmain, Object *ob, bArmature *arm, bool do_id_user)
void axis_angle_to_eulO(float eul[3], short order, const float axis[3], float angle)
MINLINE void copy_v3_v3(float r[3], const float a[3])
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void copy_m3_m4(float m1[3][3], const float m2[4][4])
void mat3_to_vec_roll(const float mat[3][3], float r_vec[3], float *r_roll)
void BKE_pose_channel_free_bbone_cache(bPoseChannel_Runtime *runtime) ATTR_NONNULL(1)
void mat3_normalized_to_axis_angle(float axis[3], float *angle, const float mat[3][3])
float quat_split_swing_and_twist(const float q_in[4], int axis, float r_swing[4], float r_twist[4])
void minmax_v3v3_v3(float min[3], float max[3], const float vec[3])
void BKE_constraints_solve(struct Depsgraph *depsgraph, ListBaseT< bConstraint > *conlist, struct bConstraintOb *cob, float ctime)
MINLINE void add_v3_v3v3(float r[3], const float a[3], const float b[3])
void copy_m3_m3(float m1[3][3], const float m2[3][3])
void ANIM_armature_bonecoll_active_index_set(bArmature *armature, int bone_collection_index)
void * BLI_ghash_lookup(const GHash *gh, const void *key) ATTR_WARN_UNUSED_RESULT
void void void void void void BLI_duplicatelist(ListBase *dst, const ListBase *src) ATTR_NONNULL(1
void copy_m4_m3(float m1[4][4], const float m2[3][3])
void mat3_normalized_to_quat(float q[4], const float mat[3][3])
static void armature_bone_from_name_insert_recursive(GHash *bone_hash, ListBaseT< Bone > *lb)
void BKE_pose_ensure(Main *bmain, Object *ob, bArmature *arm, bool do_id_user)
float mat4_to_scale(const float mat[4][4])
bool invert_m3_m3(float inverse[3][3], const float mat[3][3])
void mul_v3_m4v3(float r[3], const float mat[4][4], const float vec[3])
struct bConstraintOb * BKE_constraints_make_evalob(struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob, void *subdata, short datatype)
void BKE_armature_foreach_bone(const bArmature &armature, ForeachBoneFn callback)
void BKE_pose_channels_hash_free(bPose *pose) ATTR_NONNULL(1)
@ BBONE_ADD_PARENT_END_ROLL
void normalize_m3(float R[3][3]) ATTR_NONNULL()
static void copy_bonechildren_custom_handles(Bone *bone_dst, bArmature *arm_dst)
void BKE_pchan_protected_rotation_quaternion_set(bPoseChannel *pchan, const float quat[4])
float normalize_qt(float q[4])
void IDP_BlendWrite(BlendWriter *writer, const IDProperty *prop)
void BKE_pchan_bbone_handles_get(bke::PChanBoneConst pchanbone, bPoseChannel **r_prev, bPoseChannel **r_next)
void BKE_pchan_bbone_deform_clamp_segment_index(const Bone &bone, float head_tail, int *r_index, float *r_blend_next)
static void direct_link_bones(BlendDataReader *reader, Bone *bone, bool *all_bones_are_named)
bool invert_m4_m4(float inverse[4][4], const float mat[4][4])
void IDP_foreach_property(IDProperty *id_property_root, int type_filter, FunctionRef< void(IDProperty *id_property)> callback)
void BKE_pose_where_is_bone(Depsgraph *depsgraph, Scene *scene, Object *ob, bPoseChannel *pchan, float ctime, bool do_extra)
void BKE_pchan_protected_location_set(bPoseChannel *pchan, const float location[3])
std::optional< Bounds< float3 > > BKE_pose_minmax(const Object *ob, bool use_select)
static Bone * get_named_bone_bonechildren(ListBaseT< Bone > *lb, const char *name)
static void armature_foreach_id_editbone(EditBone *edit_bone, LibraryForeachIDData *data)
void mul_mat3_m4_fl(float R[4][4], float f)
void BKE_pose_clear_pointers(bPose *pose)
void mat3_to_compatible_eulO(float eul[3], const float oldrot[3], short order, const float mat[3][3])
void axis_angle_to_mat3(float R[3][3], const float axis[3], float angle)
void BKE_splineik_execute_tree(Depsgraph *depsgraph, Scene *scene, Object *ob, bPoseChannel *pchan_root, float ctime)
void mul_v3_mat3_m4v3(float r[3], const float mat[4][4], const float vec[3])
void axis_angle_to_quat(float r[4], const float axis[3], float angle)
void BKE_pose_channels_hash_ensure(bPose *pose) ATTR_NONNULL(1)
void mul_m4_m4m4(float R[4][4], const float A[4][4], const float B[4][4])
void BKE_pchan_protected_scale_set(bPoseChannel *pchan, const float scale[3])
bool invert_m4(float mat[4][4])
void translate_m4(float mat[4][4], float Tx, float Ty, float Tz)
void BKE_pchan_quat_to_rot(bPoseChannel &pchan, const float4 &quat)
void BKE_pchan_to_mat4(bke::PChanBoneConst pchanbone, float r_chanmat[4][4])
void BKE_armature_loc_world_to_pose(Object *ob, const float inloc[3], float outloc[3])
void BKE_pose_where_is(Depsgraph *depsgraph, Scene *scene, Object *ob)
MatBase< float, 4, 4 > float4x4
void mat3_normalized_to_compatible_eulO(float eul[3], const float oldrot[3], short order, const float mat[3][3])
void ANIM_bonecoll_free(BoneCollection *bcoll, bool do_id_user_count=true)
std::optional< Bounds< float3 > > BKE_armature_min_max(const Object *ob)
size_t size_t size_t bool BLI_str_utf8_truncate_at_size(char *str, const size_t str_size)
void BKE_armature_bone_hash_free(bArmature *arm)
void BKE_pose_ensure_bone_indices(const Object &pose_object)
void BKE_id_blend_write(BlendWriter *writer, ID *id)
void BKE_armature_mat_bone_to_pose(bke::PChanBoneConst pchanbone, const float inmat[4][4], float outmat[4][4])
static void equalize_cubic_bezier(const float control[4][3], int temp_segments, int final_segments, const float *segment_scales, float *r_t_points)
@ LIB_ID_CREATE_NO_USER_REFCOUNT
@ LIB_ID_COPY_SET_COPIED_ON_WRITE
MINLINE void mul_v3_fl(float r[3], float f)
void BLI_ghash_insert(GHash *gh, void *key, void *val)
void normalize_m4(float R[4][4]) ATTR_NONNULL()
static void make_bbone_spline_matrix(BBoneSplineParameters *param, const float scalemats[2][4][4], const float pos[3], const float axis[3], float roll, float scalex, float scalez, float result[4][4])
MINLINE void invert_v3_safe(float r[3])
void BKE_bone_parent_transform_apply(const BoneParentTransform *bpt, const float inmat[4][4], float outmat[4][4])
void BKE_pchan_bbone_segments_cache_copy(bPoseChannel *pchan, bPoseChannel *pchan_from)
VecBase< float, 4 > float4
void eulO_to_mat3(float M[3][3], const float e[3], short order)
void BKE_armature_editbonelist_free(ListBaseT< EditBone > *lb, bool do_id_user)
void BKE_bone_parent_transform_clear(BoneParentTransform *bpt)
void mul_m4_v3(const float M[4][4], float r[3])
void quat_to_mat3(float m[3][3], const float q[4])
void BKE_pchan_minmax(const Object *ob, bke::PChanBoneConst pchanbone, bool use_empty_drawtype, float3 &r_min, float3 &r_max)
MINLINE void madd_v3_v3fl(float r[3], const float a[3], float f)
bool bone_autoside_name(char name[64], int strip_number, short axis, float head, float tail)
void BKE_pchan_rot_to_mat3(const bPoseChannel *pchan, float r_mat[3][3])
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void BKE_pchan_bbone_spline_setup(bke::PChanBone pchanbone, const bArmature &armature, bool rest, bool for_deform, Mat4 *result_array)
void BKE_pchan_protected_rotation_set(bPoseChannel *pchan, const float mat[3][3])
void size_to_mat4(float R[4][4], const float size[3])
static GHash * armature_bone_from_name_map(bArmature *arm)
static void read_bone_collections(BlendDataReader *reader, bArmature *arm)
MINLINE void mul_v3_v3(float r[3], const float a[3])
void BKE_bone_parent_transform_calc_from_matrices(int bone_flag, int inherit_scale_mode, const float offs_bone[4][4], const float parent_arm_mat[4][4], const float parent_pose_mat[4][4], BoneParentTransform *r_bpt)
void BLI_ghash_free(GHash *gh, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp)
void eulO_to_axis_angle(float axis[3], float *angle, const float eul[3], short order)
void BKE_armature_mat_pose_to_bone(bke::PChanBoneConst pchanbone, const float inmat[4][4], float outmat[4][4])
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
void BKE_pchan_bbone_deform_segment_index(bke::PChanBoneConst pchanbone, const float *co, int *r_index, float *r_blend_next)
float4 BKE_pchan_rot_to_quat(const bPoseChannel &pchan)
BMesh const char void * data
void BLI_insertlinkafter(ListBase *listbase, void *vprevlink, void *vnewlink) ATTR_NONNULL(1)
void BKE_armature_loc_pose_to_bone(bke::PChanBoneConst pchanbone, const float inloc[3], float outloc[3])
static void fix_empty_bone_names(bArmature &armature)
int BKE_pchan_bbone_spline_compute(BBoneSplineParameters *param, bool for_deform, Mat4 *result_array)
void BKE_pchan_apply_mat4(bPoseChannel *pchan, const float mat[4][4], bool use_compat)
void BKE_pose_channels_clear_with_null_bone(Object *armature_ob, bool do_id_user)
static void armature_blend_read_data(BlendDataReader *reader, ID *id)
void quat_to_eulO(float e[3], short order, const float q[4])
static int visit_bone_and_descendants(const Bone &bone, int bone_index, const ForeachBoneFn callback)
static void armature_foreach_id_bone_collection(BoneCollection *bcoll, LibraryForeachIDData *data)
void BKE_bone_parent_transform_invert(BoneParentTransform *bpt)
void BIK_init_tree(struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob, float ctime)
void BLI_freelinkN(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
void quat_to_axis_angle(float axis[3], float *angle, const float q[4])
MINLINE void negate_v3(float r[3])
static void armature_free_data(ID *id)
void BKE_pchan_protected_rotation_euler_set(bPoseChannel *pchan, const float rotation_euler[3])
static void evaluate_cubic_bezier(const float control[4][3], float t, float r_pos[3], float r_tangent[3])
void BKE_pose_channel_free_ex(bPoseChannel *pchan, bool do_id_user) ATTR_NONNULL(1)
void unit_m4(float m[4][4])
void BKE_pchan_bbone_spline_params_get(bke::PChanBoneConst pchanbone, const bArmature &armature, bool rest, BBoneSplineParameters *param)
void BKE_armature_where_is(bArmature *arm)
void interp_v3_v3v3(float r[3], const float a[3], const float b[3], float t)
void BKE_pose_update_constraint_flags(Object &pose_ob)
void normalize_m4_ex(float R[4][4], float r_scale[3]) ATTR_NONNULL()
MINLINE float len_v3(const float a[3]) ATTR_WARN_UNUSED_RESULT
void BKE_armature_mat_world_to_pose(Object *ob, const float inmat[4][4], float outmat[4][4])
GHash * BLI_ghash_str_new_ex(const char *info, unsigned int nentries_reserve) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
@ BBONE_HANDLE_SCALE_EASE
void mat3_to_axis_angle(float axis[3], float *angle, const float mat[3][3])
MINLINE void zero_v3(float r[3])
void mat4_to_size_fix_shear(float size[3], const float M[4][4])
static void armature_transform_recurse(ListBaseT< Bone > *bonebase, const float mat[4][4], const bool do_props, const float mat3[3][3], const float scale, const Bone *bone_parent, const float arm_mat_parent_inv[4][4])
void BKE_armature_where_is_bone(Bone *bone, const Bone *bone_parent, bool use_recursion)
void BKE_armature_mat_pose_to_bone_ex(Depsgraph *depsgraph, Object *ob, const bPoseChannel *pchan, const float inmat[4][4], float outmat[4][4])
void BKE_armature_mat_pose_to_delta(float delta_mat[4][4], float pose_mat[4][4], float arm_mat[4][4])
bPoseChannel * BKE_armature_splineik_solver_find_root(bPoseChannel *pchan, bSplineIKConstraint *data)
static void find_bbone_segment_index_curved(const bke::PChanBoneConst pchanbone, const float *co, int *r_index, float *r_blend_next)
static void write_bone_collection(BlendWriter *writer, BoneCollection *bcoll)
void mul_mat3_m4_v3(const float mat[4][4], float r[3])
void BKE_pchan_bbone_handles_compute(const BBoneSplineParameters *param, float h1[3], float *r_roll1, float h2[3], float *r_roll2, bool ease, bool offsets)
MINLINE float normalize_v3_v3(float r[3], const float a[3])
void mat4_to_size(float size[3], const float M[4][4])
bool invert_m3(float mat[3][3])
void mat4_to_dquat(DualQuat *dq, const float basemat[4][4], const float mat[4][4])
static void rebuild_pose_bone_indices(const Object &pose_ob)
static void compute_bbone_segment_boundaries(bke::PChanBone pchanbone)
void BKE_rotMode_change_values(float quat[4], float eul[3], float axis[3], float *angle, eRotationModes oldMode, eRotationModes newMode)
bool BKE_object_minmax_empty_drawtype(const Object *ob, float r_min[3], float r_max[3])
MINLINE float normalize_v3(float n[3])
MINLINE void add_v3_v3(float r[3], const float a[3])
void BKE_pose_where_is_bone_tail(bke::PChanBone pchanbone)
MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3])
void BKE_pchan_protected_rotation_axisangle_set(bPoseChannel *pchan, const float axis[3], float angle)
MINLINE void copy_v3_fl3(float v[3], float x, float y, float z)
static void rebuild_bone_array(bArmature &armature)
static void copy_bonechildren(Bone *bone_dst, const Bone *bone_src, const Bone *bone_src_act, Bone **r_bone_dst_act, const int flag)
void BKE_armature_bone_hash_make(bArmature *arm)
@ BONE_INHERIT_SCALE_FULL
@ BONE_INHERIT_SCALE_AVERAGE
@ BONE_INHERIT_SCALE_ALIGNED
@ BONE_INHERIT_SCALE_NONE
@ BONE_INHERIT_SCALE_NONE_LEGACY
@ BONE_INHERIT_SCALE_FIX_SHEAR
void unit_m3(float m[3][3])
float BKE_scene_ctime_get(const Scene *scene)
MINLINE void copy_v3_fl(float r[3], float f)
void BKE_bone_offset_matrix_get(const Bone *bone, float offs_bone[4][4])
void BKE_constraints_clear_evalob(struct bConstraintOb *cob)
static void copy_bone_transform(Bone *bone_dst, const Bone *bone_src)
MINLINE float max_ff(float a, float b)
void eulO_to_quat(float q[4], const float e[3], short order)
void BKE_pchan_bbone_segments_cache_compute(bke::PChanBone pchanbone, const bArmature &armature)
static void allocate_bbone_cache(bPoseChannel *pchan, const int segments, const bool use_boundaries)
ID_Type GS(const char *name)
void BKE_pchan_rebuild_bbone_handles(bPose *pose, bke::PChanBone pchanbone)
MINLINE float len_squared_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT
void BKE_pose_splineik_init_tree(Scene *scene, Object *ob, float ctime)
void eulO_to_mat4(float mat[4][4], const float e[3], short order)
static void find_bbone_segment_index_straight(const bke::PChanBoneConst pchanbone, const float *co, int *r_index, float *r_blend_next)
void rescale_m4(float mat[4][4], const float scale[3])
int BKE_armature_bonelist_count(const ListBaseT< Bone > *lb)
MINLINE float interpf(float target, float origin, float t)
void size_to_mat3(float R[3][3], const float size[3])
void BKE_armature_copy_bone_transforms(bArmature *armature_dst, const bArmature *armature_src)
void DEG_relations_tag_update(Main *bmain)
bool BLI_remlink_safe(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
@ BONE_COLLECTION_OVERRIDE_LIBRARY_LOCAL
@ BONE_COLLECTION_EXPANDED
@ BONE_COLLECTION_VISIBLE
@ BONE_COLLECTION_ANCESTORS_VISIBLE
std::optional< Bounds< float3 > > BKE_object_boundbox_get(const Object *ob)
static void direct_link_bone_collection(BlendDataReader *reader, BoneCollection *bcoll)
void ANIM_armature_runtime_refresh(bArmature *armature)
void vec_roll_to_mat3_normalized(const float nor[3], float roll, float r_mat[3][3])
bool BKE_animdata_drivers_remove_for_rna_struct(ID &owner_id, struct StructRNA &type, void *data)
void mul_m3_m3m3(float R[3][3], const float A[3][3], const float B[3][3])
float bbone_segment_bsp_signed_distance(const bPoseChannel_BBoneSegmentBoundary &boundary, const float *co)
void copy_m4_m4(float m1[4][4], const float m2[4][4])
static void write_bone(BlendWriter *writer, Bone *bone)
VecBase< float, 3 > float3
@ BONE_DRAW_LOCKED_WEIGHT
bool BKE_armature_bone_flag_test_recursive(const Bone *bone, int flag)
void scale_m4_fl(float R[4][4], float scale)
float mat4_to_volume_scale(const float mat[4][4])
IDProperty * IDP_CopyProperty_ex(const IDProperty *prop, int flag) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
MINLINE float len_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
static void armature_foreach_id(ID *id, LibraryForeachIDData *data)
MINLINE void mul_v3_v3v3(float r[3], const float v1[3], const float v2[3])
bPoseChannel * BKE_armature_ik_solver_find_root(bPoseChannel *pchan, bKinematicConstraint *data)
static bPoseChannel * pose_channel_find_bone(bPose *pose, Bone *bone)
void BKE_curve_forward_diff_bezier(float q0, float q1, float q2, float q3, float *p, int it, int stride)
float cubic_tangent_factor_circle_v3(const float tan_l[3], const float tan_r[3])
void axis_angle_normalized_to_mat3(float R[3][3], const float axis[3], float angle)
MINLINE int min_ii(int a, int b)
MINLINE float dot_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
static void armature_blend_write(BlendWriter *writer, ID *id, const void *id_address)
void * BKE_id_new(Main *bmain, short type, const char *name)
void BKE_bone_parent_transform_calc_from_pchan(bke::PChanBoneConst pchanbone, BoneParentTransform *r_bpt)
void orthogonalize_m4_stable(float R[4][4], int axis, bool normalize)
Bone * BKE_armature_find_bone_name(bArmature *arm, const char *name)
bPoseChannel * BKE_pose_channel_find_name(const bPose *pose, const char *name)
static void armature_foreach_id_bone(Bone *bone, LibraryForeachIDData *data)
void mat3_to_quat(float q[4], const float mat[3][3])
void BKE_armature_bonelist_free(ListBaseT< Bone > *lb, bool do_id_user)
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
void BKE_armature_transform(bArmature *arm, const float mat[4][4], bool do_props)
void mat3_normalized_to_eulO(float eul[3], short order, const float m[3][3])
FunctionRef< void(int index, const Bone &bone)> ForeachBoneFn
float normalize_qt_qt(float r[4], const float q[4])
@ IDTYPE_FLAGS_APPEND_IS_REUSABLE
void BIK_release_tree(struct Scene *scene, struct Object *ob, float ctime)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
void write_id_struct(const void *id_address, const T *id, BlendStructWriterTypedFn< T > fn=nullptr)
void write_struct_list(const ListBaseT< T > *list, BlendStructWriterTypedFn< T > fn=nullptr)
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
struct BoneCollection * prev
eBoneCollection_Flag flags
struct IDProperty * system_properties
ListBaseT< BoneCollectionMember > bones
struct BoneCollection * next
ListBaseT< BoneCollectionReference > collections
eBone_BBoneFlag bbone_flag
eBone_BBoneHandleFlag bbone_next_flag
eBone_BBoneHandleType bbone_prev_type
eBone_BBoneHandleFlag bbone_prev_flag
eBone_BBoneMappingMode bbone_mapping_mode
eBone_BBoneHandleType bbone_next_type
IDProperty * system_properties
ListBaseT< Bone > childbase
eBone_InheritScaleMode inherit_scale_mode
IDProperty * system_properties
const c_style_mat & ptr() const
bke::ObjectRuntime * runtime
ListBaseT< EditBone > * edbo
struct EditBone * act_edbone
bke::bArmature_Runtime * runtime
ListBaseT< Bone > bonebase
struct BoneCollection ** collection_array
ListBaseT< BoneCollection > collections_legacy
int collection_root_count
struct Mat4 * bbone_rest_mats
struct DualQuat * bbone_dual_quats
struct Mat4 * bbone_pose_mats
float bbone_arc_length_reciprocal
struct Mat4 * bbone_deform_mats
struct bPoseChannel_BBoneSegmentBoundary * bbone_segment_boundaries
float custom_scale_xyz[3]
struct bPoseChannel * prev
struct bPoseChannel_Runtime runtime
struct bPoseChannel * parent
struct bPoseChannel * child
ListBaseT< struct bConstraint > constraints
struct bPoseChannel * custom_tx
struct bPoseChannel * bbone_next
float custom_rotation_euler[3]
struct bPoseChannel * bbone_prev
float custom_translation[3]
bke::bPoseRuntime * runtime
ListBaseT< bPoseChannel > chanbase
uint64_t pose_bones_generation_count
int active_collection_index
uint64_t bones_generation_count
bool is_bones_array_valid() const