You've already forked godot
mirror of
https://github.com/godotengine/godot.git
synced 2025-11-21 14:57:09 +00:00
413 lines
15 KiB
C++
413 lines
15 KiB
C++
/**************************************************************************/
|
|
/* limit_angular_velocity_modifier_3d.cpp */
|
|
/**************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/**************************************************************************/
|
|
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
|
|
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
/* a copy of this software and associated documentation files (the */
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
/* the following conditions: */
|
|
/* */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/**************************************************************************/
|
|
|
|
#include "limit_angular_velocity_modifier_3d.h"
|
|
|
|
bool LimitAngularVelocityModifier3D::_set(const StringName &p_path, const Variant &p_value) {
|
|
String path = p_path;
|
|
|
|
if (path.begins_with("chains/")) {
|
|
int which = path.get_slicec('/', 1).to_int();
|
|
String what = path.get_slicec('/', 2);
|
|
ERR_FAIL_INDEX_V(which, (int)chains.size(), false);
|
|
|
|
if (what == "root_bone_name") {
|
|
set_root_bone_name(which, p_value);
|
|
} else if (what == "root_bone") {
|
|
set_root_bone(which, p_value);
|
|
} else if (what == "end_bone_name") {
|
|
set_end_bone_name(which, p_value);
|
|
} else if (what == "end_bone") {
|
|
set_end_bone(which, p_value);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool LimitAngularVelocityModifier3D::_get(const StringName &p_path, Variant &r_ret) const {
|
|
String path = p_path;
|
|
|
|
if (path.begins_with("chains/")) {
|
|
int which = path.get_slicec('/', 1).to_int();
|
|
String what = path.get_slicec('/', 2);
|
|
ERR_FAIL_INDEX_V(which, (int)chains.size(), false);
|
|
|
|
if (what == "root_bone_name") {
|
|
r_ret = get_root_bone_name(which);
|
|
} else if (what == "root_bone") {
|
|
r_ret = get_root_bone(which);
|
|
} else if (what == "end_bone_name") {
|
|
r_ret = get_end_bone_name(which);
|
|
} else if (what == "end_bone") {
|
|
r_ret = get_end_bone(which);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
if (path.begins_with("joints/")) {
|
|
int which = path.get_slicec('/', 1).to_int();
|
|
String what = path.get_slicec('/', 2);
|
|
ERR_FAIL_COND_V(!joints.has(which), false);
|
|
if (what == "bone_name") {
|
|
r_ret = _get_joint_bone_name(which);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void LimitAngularVelocityModifier3D::_get_property_list(List<PropertyInfo> *p_list) const {
|
|
String enum_hint;
|
|
Skeleton3D *skeleton = get_skeleton();
|
|
if (skeleton) {
|
|
enum_hint = skeleton->get_concatenated_bone_names();
|
|
}
|
|
|
|
for (uint32_t i = 0; i < chains.size(); i++) {
|
|
String path = "chains/" + itos(i) + "/";
|
|
p_list->push_back(PropertyInfo(Variant::STRING, path + "root_bone_name", PROPERTY_HINT_ENUM_SUGGESTION, enum_hint));
|
|
p_list->push_back(PropertyInfo(Variant::INT, path + "root_bone", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR));
|
|
p_list->push_back(PropertyInfo(Variant::STRING, path + "end_bone_name", PROPERTY_HINT_ENUM_SUGGESTION, enum_hint));
|
|
p_list->push_back(PropertyInfo(Variant::INT, path + "end_bone", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR));
|
|
}
|
|
|
|
for (const KeyValue<int, StringName> &E : joints) {
|
|
String path = "joints/" + itos(E.key) + "/";
|
|
p_list->push_back(PropertyInfo(Variant::STRING, path + "bone_name", PROPERTY_HINT_ENUM_SUGGESTION, enum_hint, PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_READ_ONLY));
|
|
}
|
|
}
|
|
|
|
void LimitAngularVelocityModifier3D::_validate_property(PropertyInfo &p_property) const {
|
|
if (p_property.name == "joint_count") {
|
|
p_property.usage = PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_ARRAY | PROPERTY_USAGE_READ_ONLY;
|
|
p_property.class_name = "Joints,joints/,static,const";
|
|
}
|
|
}
|
|
|
|
void LimitAngularVelocityModifier3D::_notification(int p_what) {
|
|
switch (p_what) {
|
|
case NOTIFICATION_ENTER_TREE: {
|
|
_make_joints_dirty();
|
|
} break;
|
|
}
|
|
}
|
|
|
|
// Setting.
|
|
|
|
void LimitAngularVelocityModifier3D::set_root_bone_name(int p_index, const String &p_bone_name) {
|
|
ERR_FAIL_INDEX(p_index, (int)chains.size());
|
|
chains[p_index].root_bone.name = p_bone_name;
|
|
Skeleton3D *sk = get_skeleton();
|
|
if (sk) {
|
|
set_root_bone(p_index, sk->find_bone(chains[p_index].root_bone.name));
|
|
}
|
|
}
|
|
|
|
String LimitAngularVelocityModifier3D::get_root_bone_name(int p_index) const {
|
|
ERR_FAIL_INDEX_V(p_index, (int)chains.size(), String());
|
|
return chains[p_index].root_bone.name;
|
|
}
|
|
|
|
void LimitAngularVelocityModifier3D::set_root_bone(int p_index, int p_bone) {
|
|
ERR_FAIL_INDEX(p_index, (int)chains.size());
|
|
bool changed = chains[p_index].root_bone.bone != p_bone;
|
|
chains[p_index].root_bone.bone = p_bone;
|
|
Skeleton3D *sk = get_skeleton();
|
|
if (sk) {
|
|
if (chains[p_index].root_bone.bone <= -1 || chains[p_index].root_bone.bone >= sk->get_bone_count()) {
|
|
WARN_PRINT("Root bone index out of range!");
|
|
chains[p_index].root_bone.bone = -1;
|
|
} else {
|
|
chains[p_index].root_bone.name = sk->get_bone_name(chains[p_index].root_bone.bone);
|
|
}
|
|
}
|
|
if (changed) {
|
|
_make_joints_dirty();
|
|
}
|
|
}
|
|
|
|
int LimitAngularVelocityModifier3D::get_root_bone(int p_index) const {
|
|
ERR_FAIL_INDEX_V(p_index, (int)chains.size(), -1);
|
|
return chains[p_index].root_bone.bone;
|
|
}
|
|
|
|
void LimitAngularVelocityModifier3D::set_end_bone_name(int p_index, const String &p_bone_name) {
|
|
ERR_FAIL_INDEX(p_index, (int)chains.size());
|
|
chains[p_index].end_bone.name = p_bone_name;
|
|
Skeleton3D *sk = get_skeleton();
|
|
if (sk) {
|
|
set_end_bone(p_index, sk->find_bone(chains[p_index].end_bone.name));
|
|
}
|
|
}
|
|
|
|
String LimitAngularVelocityModifier3D::get_end_bone_name(int p_index) const {
|
|
ERR_FAIL_INDEX_V(p_index, (int)chains.size(), String());
|
|
return chains[p_index].end_bone.name;
|
|
}
|
|
|
|
void LimitAngularVelocityModifier3D::set_end_bone(int p_index, int p_bone) {
|
|
ERR_FAIL_INDEX(p_index, (int)chains.size());
|
|
bool changed = chains[p_index].end_bone.bone != p_bone;
|
|
chains[p_index].end_bone.bone = p_bone;
|
|
Skeleton3D *sk = get_skeleton();
|
|
if (sk) {
|
|
if (chains[p_index].end_bone.bone <= -1 || chains[p_index].end_bone.bone >= sk->get_bone_count()) {
|
|
WARN_PRINT("End bone index out of range!");
|
|
chains[p_index].end_bone.bone = -1;
|
|
} else {
|
|
chains[p_index].end_bone.name = sk->get_bone_name(chains[p_index].end_bone.bone);
|
|
}
|
|
}
|
|
if (changed) {
|
|
_make_joints_dirty();
|
|
}
|
|
notify_property_list_changed();
|
|
}
|
|
|
|
int LimitAngularVelocityModifier3D::get_end_bone(int p_index) const {
|
|
ERR_FAIL_INDEX_V(p_index, (int)chains.size(), -1);
|
|
return chains[p_index].end_bone.bone;
|
|
}
|
|
|
|
void LimitAngularVelocityModifier3D::set_chain_count(int p_count) {
|
|
ERR_FAIL_COND(p_count < 0);
|
|
chains.resize(p_count);
|
|
_make_joints_dirty();
|
|
notify_property_list_changed();
|
|
}
|
|
|
|
int LimitAngularVelocityModifier3D::get_chain_count() const {
|
|
return chains.size();
|
|
}
|
|
|
|
void LimitAngularVelocityModifier3D::clear_chains() {
|
|
set_chain_count(0);
|
|
}
|
|
|
|
String LimitAngularVelocityModifier3D::_get_joint_bone_name(int p_bone) const {
|
|
ERR_FAIL_COND_V(!joints.has(p_bone), String());
|
|
return joints[p_bone];
|
|
}
|
|
|
|
int LimitAngularVelocityModifier3D::_get_joint_count() const {
|
|
return joints.size();
|
|
}
|
|
|
|
void LimitAngularVelocityModifier3D::set_max_angular_velocity(double p_angular_velocity) {
|
|
max_angular_velocity = p_angular_velocity;
|
|
}
|
|
|
|
double LimitAngularVelocityModifier3D::get_max_angular_velocity() const {
|
|
return max_angular_velocity;
|
|
}
|
|
|
|
void LimitAngularVelocityModifier3D::set_exclude(bool p_exclude) {
|
|
exclude = p_exclude;
|
|
}
|
|
|
|
bool LimitAngularVelocityModifier3D::is_exclude() const {
|
|
return exclude;
|
|
}
|
|
|
|
void LimitAngularVelocityModifier3D::_bind_methods() {
|
|
// Setting.
|
|
ClassDB::bind_method(D_METHOD("set_root_bone_name", "index", "bone_name"), &LimitAngularVelocityModifier3D::set_root_bone_name);
|
|
ClassDB::bind_method(D_METHOD("get_root_bone_name", "index"), &LimitAngularVelocityModifier3D::get_root_bone_name);
|
|
ClassDB::bind_method(D_METHOD("set_root_bone", "index", "bone"), &LimitAngularVelocityModifier3D::set_root_bone);
|
|
ClassDB::bind_method(D_METHOD("get_root_bone", "index"), &LimitAngularVelocityModifier3D::get_root_bone);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_end_bone_name", "index", "bone_name"), &LimitAngularVelocityModifier3D::set_end_bone_name);
|
|
ClassDB::bind_method(D_METHOD("get_end_bone_name", "index"), &LimitAngularVelocityModifier3D::get_end_bone_name);
|
|
ClassDB::bind_method(D_METHOD("set_end_bone", "index", "bone"), &LimitAngularVelocityModifier3D::set_end_bone);
|
|
ClassDB::bind_method(D_METHOD("get_end_bone", "index"), &LimitAngularVelocityModifier3D::get_end_bone);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_chain_count", "count"), &LimitAngularVelocityModifier3D::set_chain_count);
|
|
ClassDB::bind_method(D_METHOD("get_chain_count"), &LimitAngularVelocityModifier3D::get_chain_count);
|
|
ClassDB::bind_method(D_METHOD("clear_chains"), &LimitAngularVelocityModifier3D::clear_chains);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_max_angular_velocity", "angular_velocity"), &LimitAngularVelocityModifier3D::set_max_angular_velocity);
|
|
ClassDB::bind_method(D_METHOD("get_max_angular_velocity"), &LimitAngularVelocityModifier3D::get_max_angular_velocity);
|
|
ClassDB::bind_method(D_METHOD("set_exclude", "exclude"), &LimitAngularVelocityModifier3D::set_exclude);
|
|
ClassDB::bind_method(D_METHOD("is_exclude"), &LimitAngularVelocityModifier3D::is_exclude);
|
|
|
|
ClassDB::bind_method(D_METHOD("reset"), &LimitAngularVelocityModifier3D::reset);
|
|
|
|
ClassDB::bind_method(D_METHOD("_get_joint_count"), &LimitAngularVelocityModifier3D::_get_joint_count);
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "max_angular_velocity", PROPERTY_HINT_RANGE, "0,720,or_greater,radians_as_degrees,suffix:" + String(U"°") + "/s"), "set_max_angular_velocity", "get_max_angular_velocity");
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "exclude"), "set_exclude", "is_exclude");
|
|
ADD_ARRAY_COUNT("Chains", "chain_count", "set_chain_count", "get_chain_count", "chains/");
|
|
ADD_ARRAY_COUNT("Joints", "joint_count", "", "_get_joint_count", "joints/");
|
|
}
|
|
|
|
void LimitAngularVelocityModifier3D::_set_active(bool p_active) {
|
|
if (p_active) {
|
|
reset();
|
|
}
|
|
}
|
|
|
|
void LimitAngularVelocityModifier3D::_skeleton_changed(Skeleton3D *p_old, Skeleton3D *p_new) {
|
|
_make_joints_dirty();
|
|
}
|
|
|
|
void LimitAngularVelocityModifier3D::_validate_bone_names() {
|
|
for (uint32_t i = 0; i < chains.size(); i++) {
|
|
// Prior bone name.
|
|
if (!chains[i].root_bone.name.is_empty()) {
|
|
set_root_bone_name(i, chains[i].root_bone.name);
|
|
} else if (chains[i].root_bone.bone != -1) {
|
|
set_root_bone(i, chains[i].root_bone.bone);
|
|
}
|
|
// Prior bone name.
|
|
if (!chains[i].end_bone.name.is_empty()) {
|
|
set_end_bone_name(i, chains[i].end_bone.name);
|
|
} else if (chains[i].end_bone.bone != -1) {
|
|
set_end_bone(i, chains[i].end_bone.bone);
|
|
}
|
|
}
|
|
}
|
|
|
|
void LimitAngularVelocityModifier3D::_make_joints_dirty() {
|
|
if (joints_dirty) {
|
|
return;
|
|
}
|
|
joints_dirty = true;
|
|
callable_mp(this, &LimitAngularVelocityModifier3D::_update_joints).call_deferred();
|
|
}
|
|
|
|
void LimitAngularVelocityModifier3D::_update_joints() {
|
|
joints.clear();
|
|
bones.clear();
|
|
|
|
Skeleton3D *sk = get_skeleton();
|
|
if (!sk) {
|
|
joints_dirty = false;
|
|
return;
|
|
}
|
|
|
|
LocalVector<int> tmp_joints;
|
|
for (uint32_t i = 0; i < chains.size(); i++) {
|
|
tmp_joints.clear();
|
|
Chain cn = chains[i];
|
|
int current_bone = cn.end_bone.bone;
|
|
int root_bone = cn.root_bone.bone;
|
|
if (current_bone < 0 || root_bone < 0) {
|
|
continue;
|
|
}
|
|
// Validation.
|
|
bool valid = false;
|
|
while (current_bone >= 0) {
|
|
if (current_bone == root_bone) {
|
|
valid = true;
|
|
break;
|
|
}
|
|
current_bone = sk->get_bone_parent(current_bone);
|
|
}
|
|
if (!valid) {
|
|
ERR_FAIL_EDMSG("Chains[" + itos(i) + "]: End bone must be the same as or a child of root bone.");
|
|
continue;
|
|
}
|
|
current_bone = cn.end_bone.bone;
|
|
while (current_bone != root_bone) {
|
|
tmp_joints.push_back(current_bone);
|
|
current_bone = sk->get_bone_parent(current_bone);
|
|
}
|
|
tmp_joints.push_back(current_bone);
|
|
for (uint32_t j = 0; j < tmp_joints.size(); j++) {
|
|
int bn = tmp_joints[j];
|
|
if (!joints.has(bn)) {
|
|
joints.insert(bn, sk->get_bone_name(bn));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (exclude) {
|
|
for (int b = 0; b < sk->get_bone_count(); b++) {
|
|
if (joints.has(b)) {
|
|
continue;
|
|
}
|
|
BoneRot br;
|
|
br.first = b;
|
|
br.second = sk->get_bone_pose_rotation(b);
|
|
bones.push_back(br);
|
|
}
|
|
} else {
|
|
for (const KeyValue<int, StringName> &E : joints) {
|
|
BoneRot br;
|
|
br.first = E.key;
|
|
br.second = sk->get_bone_pose_rotation(E.key);
|
|
bones.push_back(br);
|
|
}
|
|
}
|
|
|
|
joints_dirty = false;
|
|
reset();
|
|
}
|
|
|
|
void LimitAngularVelocityModifier3D::_process_modification(double p_delta) {
|
|
Skeleton3D *skeleton = get_skeleton();
|
|
if (!skeleton) {
|
|
return;
|
|
}
|
|
|
|
if (init_needed) {
|
|
// Note:
|
|
// The pose retrieval within `_update_joints()` is done outside the skeleton's update process,
|
|
// so it ignores the pose resulting from the previous modifier's modification.
|
|
// This causes unintended initialization when `active` is set to true, so it must be initialized here.
|
|
for (uint32_t i = 0; i < bones.size(); i++) {
|
|
bones[i].second = skeleton->get_bone_pose_rotation(bones[i].first);
|
|
}
|
|
init_needed = false;
|
|
}
|
|
|
|
double limit_in_frame = max_angular_velocity * p_delta;
|
|
for (uint32_t i = 0; i < bones.size(); i++) {
|
|
int bn = bones[i].first;
|
|
Quaternion dest = skeleton->get_bone_pose_rotation(bn);
|
|
double diff = bones[i].second.angle_to(dest);
|
|
if (!Math::is_zero_approx(diff)) {
|
|
bones[i].second = bones[i].second.slerp(dest, MIN(1.0, limit_in_frame / diff));
|
|
}
|
|
skeleton->set_bone_pose_rotation(bn, bones[i].second);
|
|
}
|
|
}
|
|
|
|
void LimitAngularVelocityModifier3D::reset() {
|
|
init_needed = true;
|
|
}
|
|
|
|
LimitAngularVelocityModifier3D::~LimitAngularVelocityModifier3D() {
|
|
clear_chains();
|
|
}
|