case NOTIFICATION_EXIT_TREE: {

if (skeleton) {

if (skeleton->bones[i].bone == this) {

skeleton->bones.remove_at(i);

break;

bones.sort(); //sorting so that they are always in the same order/index

Bone2D *parent_bone = Object::cast_to<Bone2D>(bones[i].bone->get_parent());

if (parent_bone) {

} else {

}

}

transform_dirty = true;

transform_dirty = false;

if (bones[i].parent_index >= 0) {

} else {

}

}

Transform2D final_xform = bones[i].accum_transform * bones[i].rest_inverse;

RS::get_singleton()->skeleton_bone_set_transform_2d(skeleton, i, final_xform);

}

Bone2D *Skeleton2D::get_bone(int p_idx) {

ERR_FAIL_COND_V(!is_inside_tree(), nullptr);

return bones[p_idx].bone;

}

}

void Skeleton2D::set_bone_local_pose_override(int p_bone_idx, Transform2D p_override, real_t p_amount, bool p_persistent) {

}

Transform2D Skeleton2D::get_bone_local_pose_override(int p_bone_idx) {

return bones[p_bone_idx].local_pose_override;

}

}

// Do not cache the transform changes caused by the modifications!

bones[i].bone->copy_transform_to_cache = false;

}

// Only apply the local pose override on _process. Otherwise, just calculate the local_pose_override and reset the transform.

if (p_execution_mode == SkeletonModificationStack2D::EXECUTION_MODE::execution_mode_process) {

if (bones[i].local_pose_override_amount > 0) {

bones[i].bone->set_meta("_local_pose_override_enabled_", true);

bones[i].bone->propagate_call("force_update_transform");

if (bones[i].local_pose_override_persistent) {

}

} else {

// TODO: see if there is a way to undo the override without having to resort to setting every bone's transform.

}

// Cache any future transform changes

bones[i].bone->copy_transform_to_cache = true;

}

bool local_pose_override_persistent = false;

};

bool bone_setup_dirty = true;

void _make_bone_setup_dirty();

}

bool Node3D::_property_can_revert(const StringName &p_name) const {

return true;

return true;

return true;

return true;

return true;

}

return false;

bool Node3D::_property_get_revert(const StringName &p_name, Variant &r_property) const {

bool valid = false;

Variant variant = PropertyUtils::get_property_default_value(this, "transform", &valid);

if (valid && variant.get_type() == Variant::Type::TRANSFORM3D) {

r_property = Transform3D(variant).get_basis();

} else {

r_property = Basis();

}

Variant variant = PropertyUtils::get_property_default_value(this, "transform", &valid);

if (valid && variant.get_type() == Variant::Type::TRANSFORM3D) {

r_property = Transform3D(variant).get_basis().get_scale();

} else {

r_property = Vector3(1.0, 1.0, 1.0);

}

Variant variant = PropertyUtils::get_property_default_value(this, "transform", &valid);

if (valid && variant.get_type() == Variant::Type::TRANSFORM3D) {

r_property = Quaternion(Transform3D(variant).get_basis().get_rotation_quaternion());

} else {

r_property = Quaternion();

}

Variant variant = PropertyUtils::get_property_default_value(this, "transform", &valid);

if (valid && variant.get_type() == Variant::Type::TRANSFORM3D) {

r_property = Transform3D(variant).get_basis().get_euler_normalized(data.euler_rotation_order);

} else {

r_property = Vector3();

}

Variant variant = PropertyUtils::get_property_default_value(this, "transform", &valid);

if (valid) {

r_property = Transform3D(variant).get_origin();

return false;

}

String what = path.get_slicec('/', 2);

if (which == bones.size() && what == "name") {

return true;

}

if (what == "parent") {

set_bone_parent(which, p_value);

return false;

}

String what = path.get_slicec('/', 2);

if (what == "name") {

r_ret = get_bone_name(which);

}

void Skeleton3D::_get_property_list(List<PropertyInfo> *p_list) const {

const String prep = vformat("%s/%d/", PNAME("bones"), i);

p_list->push_back(PropertyInfo(Variant::STRING, prep + PNAME("name"), PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR));

p_list->push_back(PropertyInfo(Variant::INT, prep + PNAME("parent"), PROPERTY_HINT_RANGE, "-1," + itos(bones.size() - 1) + ",1", PROPERTY_USAGE_NO_EDITOR));

return;

}

int len = bones.size();

parentless_bones.clear();

void Skeleton3D::_update_bone_names() const {

String names;

if (i > 0) {

names += ",";

}

updating = true;

int len = bones.size();

// Process modifiers.

_find_modifiers();

if (!modifiers.is_empty()) {

// Store unmodified bone poses.

bones_backup[i].save(bones[i]);

}

_process_modifiers();

if (!modifiers.is_empty()) {

// Restore unmodified bone poses.

}

}

}

name_to_bone_index.erase(bones[p_bone].name);

name_to_bone_index.insert(p_name, p_bone);

version++;

ERR_FAIL_INDEX(p_bone, bone_size);

if (p_value.get_type() == Variant::NIL) {

}

return;

}

}

bool Skeleton3D::is_bone_parent_of(int p_bone, int p_parent_bone_id) const {

ERR_FAIL_COND(p_parent != -1 && (p_parent < 0));

ERR_FAIL_COND(p_bone == p_parent);

process_order_dirty = true;

rest_dirty = true;

_make_dirty();

int parent = bones[p_bone].parent;

while (parent >= 0) {

parent = bones[parent].parent;

}

process_order_dirty = true;

rest_dirty = true;

const int bone_size = bones.size();

ERR_FAIL_INDEX(p_bone, bone_size);

rest_dirty = true;

_make_dirty();

}

const int bone_size = bones.size();

ERR_FAIL_INDEX(p_bone, bone_size);

emit_signal(SceneStringName(bone_enabled_changed), p_bone);

_make_dirty();

}

const int bone_size = bones.size();

ERR_FAIL_INDEX(p_bone, bone_size);

if (is_inside_tree()) {

_make_dirty();

}

const int bone_size = bones.size();

ERR_FAIL_INDEX(p_bone, bone_size);

if (is_inside_tree()) {

_make_dirty();

}

const int bone_size = bones.size();

ERR_FAIL_INDEX(p_bone, bone_size);

if (is_inside_tree()) {

_make_dirty();

}

const int bone_size = bones.size();

ERR_FAIL_INDEX(p_bone, bone_size);

if (is_inside_tree()) {

_make_dirty();

}

}

void Skeleton3D::reset_bone_poses() {

reset_bone_pose(i);

}

}

Transform3D Skeleton3D::get_bone_pose(int p_bone) const {

const int bone_size = bones.size();

ERR_FAIL_INDEX_V(p_bone, bone_size, Transform3D());

return bones[p_bone].pose_cache;

}

// Pose changed, rebuild cache of inverses.

const Bone *bonesptr = bones.ptr();

// Calculate global rests and invert them.

LocalVector<int> bones_to_process;

}

}

// The inverse is what is actually required.

skin->set_bind_bone(i, i);

skin->set_bind_pose(i, skin->get_bind_pose(i).affine_inverse());

const int bone_size = bones.size();

ERR_FAIL_INDEX(p_bone_idx, bone_size);

thread_local LocalVector<int> bones_to_process;

bones_to_process.clear();

bones_to_process.push_back(p_bone_idx);

#ifndef DISABLE_DEPRECATED

void Skeleton3D::clear_bones_global_pose_override() {

}

_make_dirty();

}

void Skeleton3D::set_bone_global_pose_override(int p_bone, const Transform3D &p_pose, real_t p_amount, bool p_persistent) {

const int bone_size = bones.size();

ERR_FAIL_INDEX(p_bone, bone_size);

_make_dirty();

}

HashSet<SkinReference *> skin_bindings;

void _skin_changed();

bool process_order_dirty = false;

Vector<int> parentless_bones;

bool ShaderMaterial::_property_can_revert(const StringName &p_name) const {

if (shader.is_valid()) {

return true;

}

}

return false;

}