d95794ec8a
As many open source projects have started doing it, we're removing the current year from the copyright notice, so that we don't need to bump it every year. It seems like only the first year of publication is technically relevant for copyright notices, and even that seems to be something that many companies stopped listing altogether (in a version controlled codebase, the commits are a much better source of date of publication than a hardcoded copyright statement). We also now list Godot Engine contributors first as we're collectively the current maintainers of the project, and we clarify that the "exclusive" copyright of the co-founders covers the timespan before opensourcing (their further contributions are included as part of Godot Engine contributors). Also fixed "cf." Frenchism - it's meant as "refer to / see".
475 lines
22 KiB
C++
475 lines
22 KiB
C++
/**************************************************************************/
|
|
/* skeleton_modification_3d_ccdik.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 "scene/resources/skeleton_modification_3d_ccdik.h"
|
|
#include "scene/3d/skeleton_3d.h"
|
|
#include "scene/resources/skeleton_modification_3d.h"
|
|
|
|
bool SkeletonModification3DCCDIK::_set(const StringName &p_path, const Variant &p_value) {
|
|
String path = p_path;
|
|
|
|
if (path.begins_with("joint_data/")) {
|
|
int ccdik_data_size = ccdik_data_chain.size();
|
|
int which = path.get_slicec('/', 1).to_int();
|
|
String what = path.get_slicec('/', 2);
|
|
ERR_FAIL_INDEX_V(which, ccdik_data_size, false);
|
|
|
|
if (what == "bone_name") {
|
|
set_ccdik_joint_bone_name(which, p_value);
|
|
} else if (what == "bone_index") {
|
|
set_ccdik_joint_bone_index(which, p_value);
|
|
} else if (what == "ccdik_axis") {
|
|
set_ccdik_joint_ccdik_axis(which, p_value);
|
|
} else if (what == "enable_joint_constraint") {
|
|
set_ccdik_joint_enable_constraint(which, p_value);
|
|
} else if (what == "joint_constraint_angle_min") {
|
|
set_ccdik_joint_constraint_angle_min(which, Math::deg_to_rad(real_t(p_value)));
|
|
} else if (what == "joint_constraint_angle_max") {
|
|
set_ccdik_joint_constraint_angle_max(which, Math::deg_to_rad(real_t(p_value)));
|
|
} else if (what == "joint_constraint_angles_invert") {
|
|
set_ccdik_joint_constraint_invert(which, p_value);
|
|
}
|
|
return true;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool SkeletonModification3DCCDIK::_get(const StringName &p_path, Variant &r_ret) const {
|
|
String path = p_path;
|
|
|
|
if (path.begins_with("joint_data/")) {
|
|
const int ccdik_data_size = ccdik_data_chain.size();
|
|
int which = path.get_slicec('/', 1).to_int();
|
|
String what = path.get_slicec('/', 2);
|
|
ERR_FAIL_INDEX_V(which, ccdik_data_size, false);
|
|
|
|
if (what == "bone_name") {
|
|
r_ret = get_ccdik_joint_bone_name(which);
|
|
} else if (what == "bone_index") {
|
|
r_ret = get_ccdik_joint_bone_index(which);
|
|
} else if (what == "ccdik_axis") {
|
|
r_ret = get_ccdik_joint_ccdik_axis(which);
|
|
} else if (what == "enable_joint_constraint") {
|
|
r_ret = get_ccdik_joint_enable_constraint(which);
|
|
} else if (what == "joint_constraint_angle_min") {
|
|
r_ret = Math::rad_to_deg(get_ccdik_joint_constraint_angle_min(which));
|
|
} else if (what == "joint_constraint_angle_max") {
|
|
r_ret = Math::rad_to_deg(get_ccdik_joint_constraint_angle_max(which));
|
|
} else if (what == "joint_constraint_angles_invert") {
|
|
r_ret = get_ccdik_joint_constraint_invert(which);
|
|
}
|
|
return true;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void SkeletonModification3DCCDIK::_get_property_list(List<PropertyInfo> *p_list) const {
|
|
for (uint32_t i = 0; i < ccdik_data_chain.size(); i++) {
|
|
String base_string = "joint_data/" + itos(i) + "/";
|
|
|
|
p_list->push_back(PropertyInfo(Variant::STRING_NAME, base_string + "bone_name", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
|
|
p_list->push_back(PropertyInfo(Variant::INT, base_string + "bone_index", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
|
|
|
|
p_list->push_back(PropertyInfo(Variant::INT, base_string + "ccdik_axis",
|
|
PROPERTY_HINT_ENUM, "X Axis,Y Axis,Z Axis", PROPERTY_USAGE_DEFAULT));
|
|
|
|
p_list->push_back(PropertyInfo(Variant::BOOL, base_string + "enable_joint_constraint", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
|
|
if (ccdik_data_chain[i].enable_constraint) {
|
|
p_list->push_back(PropertyInfo(Variant::FLOAT, base_string + "joint_constraint_angle_min", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
|
|
p_list->push_back(PropertyInfo(Variant::FLOAT, base_string + "joint_constraint_angle_max", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
|
|
p_list->push_back(PropertyInfo(Variant::BOOL, base_string + "joint_constraint_angles_invert", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
|
|
}
|
|
}
|
|
}
|
|
|
|
void SkeletonModification3DCCDIK::_execute(real_t p_delta) {
|
|
ERR_FAIL_COND_MSG(!stack || !is_setup || stack->skeleton == nullptr,
|
|
"Modification is not setup and therefore cannot execute!");
|
|
if (!enabled) {
|
|
return;
|
|
}
|
|
|
|
if (target_node_cache.is_null()) {
|
|
_print_execution_error(true, "Target cache is out of date. Attempting to update");
|
|
update_target_cache();
|
|
return;
|
|
}
|
|
if (tip_node_cache.is_null()) {
|
|
_print_execution_error(true, "Tip cache is out of date. Attempting to update");
|
|
update_tip_cache();
|
|
return;
|
|
}
|
|
|
|
// Reset the local bone overrides for CCDIK affected nodes
|
|
for (uint32_t i = 0; i < ccdik_data_chain.size(); i++) {
|
|
stack->skeleton->set_bone_local_pose_override(ccdik_data_chain[i].bone_idx,
|
|
stack->skeleton->get_bone_local_pose_override(ccdik_data_chain[i].bone_idx),
|
|
0.0, false);
|
|
}
|
|
|
|
Node3D *node_target = Object::cast_to<Node3D>(ObjectDB::get_instance(target_node_cache));
|
|
Node3D *node_tip = Object::cast_to<Node3D>(ObjectDB::get_instance(tip_node_cache));
|
|
|
|
if (_print_execution_error(!node_target || !node_target->is_inside_tree(), "Target node is not in the scene tree. Cannot execute modification!")) {
|
|
return;
|
|
}
|
|
if (_print_execution_error(!node_tip || !node_tip->is_inside_tree(), "Tip node is not in the scene tree. Cannot execute modification!")) {
|
|
return;
|
|
}
|
|
|
|
if (use_high_quality_solve) {
|
|
for (uint32_t i = 0; i < ccdik_data_chain.size(); i++) {
|
|
for (uint32_t j = i; j < ccdik_data_chain.size(); j++) {
|
|
_execute_ccdik_joint(j, node_target, node_tip);
|
|
}
|
|
}
|
|
} else {
|
|
for (uint32_t i = 0; i < ccdik_data_chain.size(); i++) {
|
|
_execute_ccdik_joint(i, node_target, node_tip);
|
|
}
|
|
}
|
|
|
|
execution_error_found = false;
|
|
}
|
|
|
|
void SkeletonModification3DCCDIK::_execute_ccdik_joint(int p_joint_idx, Node3D *p_target, Node3D *p_tip) {
|
|
CCDIK_Joint_Data ccdik_data = ccdik_data_chain[p_joint_idx];
|
|
|
|
if (_print_execution_error(ccdik_data.bone_idx < 0 || ccdik_data.bone_idx > stack->skeleton->get_bone_count(),
|
|
"CCDIK joint: bone index for joint" + itos(p_joint_idx) + " not found. Cannot execute modification!")) {
|
|
return;
|
|
}
|
|
|
|
Transform3D bone_trans = stack->skeleton->global_pose_to_local_pose(ccdik_data.bone_idx, stack->skeleton->get_bone_global_pose(ccdik_data.bone_idx));
|
|
Transform3D tip_trans = stack->skeleton->global_pose_to_local_pose(ccdik_data.bone_idx, stack->skeleton->world_transform_to_global_pose(p_tip->get_global_transform()));
|
|
Transform3D target_trans = stack->skeleton->global_pose_to_local_pose(ccdik_data.bone_idx, stack->skeleton->world_transform_to_global_pose(p_target->get_global_transform()));
|
|
|
|
if (tip_trans.origin.distance_to(target_trans.origin) <= 0.01) {
|
|
return;
|
|
}
|
|
|
|
// Inspired (and very loosely based on) by the CCDIK algorithm made by Zalo on GitHub (https://github.com/zalo/MathUtilities)
|
|
// Convert the 3D position to a 2D position so we can use Atan2 (via the angle function)
|
|
// to know how much rotation we need on the given axis to place the tip at the target.
|
|
Vector2 tip_pos_2d;
|
|
Vector2 target_pos_2d;
|
|
if (ccdik_data.ccdik_axis == CCDIK_Axes::AXIS_X) {
|
|
tip_pos_2d = Vector2(tip_trans.origin.y, tip_trans.origin.z);
|
|
target_pos_2d = Vector2(target_trans.origin.y, target_trans.origin.z);
|
|
bone_trans.basis.rotate_local(Vector3(1, 0, 0), target_pos_2d.angle() - tip_pos_2d.angle());
|
|
} else if (ccdik_data.ccdik_axis == CCDIK_Axes::AXIS_Y) {
|
|
tip_pos_2d = Vector2(tip_trans.origin.z, tip_trans.origin.x);
|
|
target_pos_2d = Vector2(target_trans.origin.z, target_trans.origin.x);
|
|
bone_trans.basis.rotate_local(Vector3(0, 1, 0), target_pos_2d.angle() - tip_pos_2d.angle());
|
|
} else if (ccdik_data.ccdik_axis == CCDIK_Axes::AXIS_Z) {
|
|
tip_pos_2d = Vector2(tip_trans.origin.x, tip_trans.origin.y);
|
|
target_pos_2d = Vector2(target_trans.origin.x, target_trans.origin.y);
|
|
bone_trans.basis.rotate_local(Vector3(0, 0, 1), target_pos_2d.angle() - tip_pos_2d.angle());
|
|
} else {
|
|
// Should never happen, but...
|
|
ERR_FAIL_MSG("CCDIK joint: Unknown axis vector passed for joint" + itos(p_joint_idx) + ". Cannot execute modification!");
|
|
}
|
|
|
|
if (ccdik_data.enable_constraint) {
|
|
Vector3 rotation_axis;
|
|
real_t rotation_angle;
|
|
bone_trans.basis.get_axis_angle(rotation_axis, rotation_angle);
|
|
|
|
// Note: When the axis has a negative direction, the angle is OVER 180 degrees and therefore we need to account for this
|
|
// when constraining.
|
|
if (ccdik_data.ccdik_axis == CCDIK_Axes::AXIS_X) {
|
|
if (rotation_axis.x < 0) {
|
|
rotation_angle += Math_PI;
|
|
rotation_axis = Vector3(1, 0, 0);
|
|
}
|
|
} else if (ccdik_data.ccdik_axis == CCDIK_Axes::AXIS_Y) {
|
|
if (rotation_axis.y < 0) {
|
|
rotation_angle += Math_PI;
|
|
rotation_axis = Vector3(0, 1, 0);
|
|
}
|
|
} else if (ccdik_data.ccdik_axis == CCDIK_Axes::AXIS_Z) {
|
|
if (rotation_axis.z < 0) {
|
|
rotation_angle += Math_PI;
|
|
rotation_axis = Vector3(0, 0, 1);
|
|
}
|
|
} else {
|
|
// Should never happen, but...
|
|
ERR_FAIL_MSG("CCDIK joint: Unknown axis vector passed for joint" + itos(p_joint_idx) + ". Cannot execute modification!");
|
|
}
|
|
rotation_angle = clamp_angle(rotation_angle, ccdik_data.constraint_angle_min, ccdik_data.constraint_angle_max, ccdik_data.constraint_angles_invert);
|
|
|
|
bone_trans.basis.set_axis_angle(rotation_axis, rotation_angle);
|
|
}
|
|
|
|
stack->skeleton->set_bone_local_pose_override(ccdik_data.bone_idx, bone_trans, stack->strength, true);
|
|
stack->skeleton->force_update_bone_children_transforms(ccdik_data.bone_idx);
|
|
}
|
|
|
|
void SkeletonModification3DCCDIK::_setup_modification(SkeletonModificationStack3D *p_stack) {
|
|
stack = p_stack;
|
|
if (stack != nullptr) {
|
|
is_setup = true;
|
|
execution_error_found = false;
|
|
update_target_cache();
|
|
update_tip_cache();
|
|
}
|
|
}
|
|
|
|
void SkeletonModification3DCCDIK::update_target_cache() {
|
|
if (!is_setup || !stack) {
|
|
_print_execution_error(true, "Cannot update target cache: modification is not properly setup!");
|
|
return;
|
|
}
|
|
|
|
target_node_cache = ObjectID();
|
|
if (stack->skeleton) {
|
|
if (stack->skeleton->is_inside_tree()) {
|
|
if (stack->skeleton->has_node(target_node)) {
|
|
Node *node = stack->skeleton->get_node(target_node);
|
|
ERR_FAIL_COND_MSG(!node || stack->skeleton == node,
|
|
"Cannot update target cache: node is this modification's skeleton or cannot be found!");
|
|
ERR_FAIL_COND_MSG(!node->is_inside_tree(),
|
|
"Cannot update target cache: node is not in scene tree!");
|
|
target_node_cache = node->get_instance_id();
|
|
|
|
execution_error_found = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SkeletonModification3DCCDIK::update_tip_cache() {
|
|
if (!is_setup || !stack) {
|
|
_print_execution_error(true, "Cannot update tip cache: modification is not properly setup!");
|
|
return;
|
|
}
|
|
|
|
tip_node_cache = ObjectID();
|
|
if (stack->skeleton) {
|
|
if (stack->skeleton->is_inside_tree()) {
|
|
if (stack->skeleton->has_node(tip_node)) {
|
|
Node *node = stack->skeleton->get_node(tip_node);
|
|
ERR_FAIL_COND_MSG(!node || stack->skeleton == node,
|
|
"Cannot update tip cache: node is this modification's skeleton or cannot be found!");
|
|
ERR_FAIL_COND_MSG(!node->is_inside_tree(),
|
|
"Cannot update tip cache: node is not in scene tree!");
|
|
tip_node_cache = node->get_instance_id();
|
|
|
|
execution_error_found = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SkeletonModification3DCCDIK::set_target_node(const NodePath &p_target_node) {
|
|
target_node = p_target_node;
|
|
update_target_cache();
|
|
}
|
|
|
|
NodePath SkeletonModification3DCCDIK::get_target_node() const {
|
|
return target_node;
|
|
}
|
|
|
|
void SkeletonModification3DCCDIK::set_tip_node(const NodePath &p_tip_node) {
|
|
tip_node = p_tip_node;
|
|
update_tip_cache();
|
|
}
|
|
|
|
NodePath SkeletonModification3DCCDIK::get_tip_node() const {
|
|
return tip_node;
|
|
}
|
|
|
|
void SkeletonModification3DCCDIK::set_use_high_quality_solve(bool p_high_quality) {
|
|
use_high_quality_solve = p_high_quality;
|
|
}
|
|
|
|
bool SkeletonModification3DCCDIK::get_use_high_quality_solve() const {
|
|
return use_high_quality_solve;
|
|
}
|
|
|
|
// CCDIK joint data functions
|
|
String SkeletonModification3DCCDIK::get_ccdik_joint_bone_name(int p_joint_idx) const {
|
|
const int bone_chain_size = ccdik_data_chain.size();
|
|
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, String());
|
|
return ccdik_data_chain[p_joint_idx].bone_name;
|
|
}
|
|
|
|
void SkeletonModification3DCCDIK::set_ccdik_joint_bone_name(int p_joint_idx, String p_bone_name) {
|
|
const int bone_chain_size = ccdik_data_chain.size();
|
|
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
|
|
ccdik_data_chain[p_joint_idx].bone_name = p_bone_name;
|
|
|
|
if (stack) {
|
|
if (stack->skeleton) {
|
|
ccdik_data_chain[p_joint_idx].bone_idx = stack->skeleton->find_bone(p_bone_name);
|
|
}
|
|
}
|
|
execution_error_found = false;
|
|
notify_property_list_changed();
|
|
}
|
|
|
|
int SkeletonModification3DCCDIK::get_ccdik_joint_bone_index(int p_joint_idx) const {
|
|
const int bone_chain_size = ccdik_data_chain.size();
|
|
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, -1);
|
|
return ccdik_data_chain[p_joint_idx].bone_idx;
|
|
}
|
|
|
|
void SkeletonModification3DCCDIK::set_ccdik_joint_bone_index(int p_joint_idx, int p_bone_idx) {
|
|
const int bone_chain_size = ccdik_data_chain.size();
|
|
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
|
|
ERR_FAIL_COND_MSG(p_bone_idx < 0, "Bone index is out of range: The index is too low!");
|
|
ccdik_data_chain[p_joint_idx].bone_idx = p_bone_idx;
|
|
|
|
if (stack) {
|
|
if (stack->skeleton) {
|
|
ccdik_data_chain[p_joint_idx].bone_name = stack->skeleton->get_bone_name(p_bone_idx);
|
|
}
|
|
}
|
|
execution_error_found = false;
|
|
notify_property_list_changed();
|
|
}
|
|
|
|
int SkeletonModification3DCCDIK::get_ccdik_joint_ccdik_axis(int p_joint_idx) const {
|
|
const int bone_chain_size = ccdik_data_chain.size();
|
|
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, -1);
|
|
return ccdik_data_chain[p_joint_idx].ccdik_axis;
|
|
}
|
|
|
|
void SkeletonModification3DCCDIK::set_ccdik_joint_ccdik_axis(int p_joint_idx, int p_axis) {
|
|
const int bone_chain_size = ccdik_data_chain.size();
|
|
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
|
|
ERR_FAIL_COND_MSG(p_axis < 0, "CCDIK axis is out of range: The axis mode is too low!");
|
|
ccdik_data_chain[p_joint_idx].ccdik_axis = p_axis;
|
|
notify_property_list_changed();
|
|
}
|
|
|
|
bool SkeletonModification3DCCDIK::get_ccdik_joint_enable_constraint(int p_joint_idx) const {
|
|
const int bone_chain_size = ccdik_data_chain.size();
|
|
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, false);
|
|
return ccdik_data_chain[p_joint_idx].enable_constraint;
|
|
}
|
|
|
|
void SkeletonModification3DCCDIK::set_ccdik_joint_enable_constraint(int p_joint_idx, bool p_enable) {
|
|
const int bone_chain_size = ccdik_data_chain.size();
|
|
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
|
|
ccdik_data_chain[p_joint_idx].enable_constraint = p_enable;
|
|
notify_property_list_changed();
|
|
}
|
|
|
|
real_t SkeletonModification3DCCDIK::get_ccdik_joint_constraint_angle_min(int p_joint_idx) const {
|
|
const int bone_chain_size = ccdik_data_chain.size();
|
|
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, false);
|
|
return ccdik_data_chain[p_joint_idx].constraint_angle_min;
|
|
}
|
|
|
|
void SkeletonModification3DCCDIK::set_ccdik_joint_constraint_angle_min(int p_joint_idx, real_t p_angle_min) {
|
|
const int bone_chain_size = ccdik_data_chain.size();
|
|
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
|
|
ccdik_data_chain[p_joint_idx].constraint_angle_min = p_angle_min;
|
|
}
|
|
|
|
real_t SkeletonModification3DCCDIK::get_ccdik_joint_constraint_angle_max(int p_joint_idx) const {
|
|
const int bone_chain_size = ccdik_data_chain.size();
|
|
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, false);
|
|
return ccdik_data_chain[p_joint_idx].constraint_angle_max;
|
|
}
|
|
|
|
void SkeletonModification3DCCDIK::set_ccdik_joint_constraint_angle_max(int p_joint_idx, real_t p_angle_max) {
|
|
const int bone_chain_size = ccdik_data_chain.size();
|
|
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
|
|
ccdik_data_chain[p_joint_idx].constraint_angle_max = p_angle_max;
|
|
}
|
|
|
|
bool SkeletonModification3DCCDIK::get_ccdik_joint_constraint_invert(int p_joint_idx) const {
|
|
const int bone_chain_size = ccdik_data_chain.size();
|
|
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, false);
|
|
return ccdik_data_chain[p_joint_idx].constraint_angles_invert;
|
|
}
|
|
|
|
void SkeletonModification3DCCDIK::set_ccdik_joint_constraint_invert(int p_joint_idx, bool p_invert) {
|
|
const int bone_chain_size = ccdik_data_chain.size();
|
|
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
|
|
ccdik_data_chain[p_joint_idx].constraint_angles_invert = p_invert;
|
|
}
|
|
|
|
int SkeletonModification3DCCDIK::get_ccdik_data_chain_length() {
|
|
return ccdik_data_chain.size();
|
|
}
|
|
void SkeletonModification3DCCDIK::set_ccdik_data_chain_length(int p_length) {
|
|
ERR_FAIL_COND(p_length < 0);
|
|
ccdik_data_chain.resize(p_length);
|
|
execution_error_found = false;
|
|
notify_property_list_changed();
|
|
}
|
|
|
|
void SkeletonModification3DCCDIK::_bind_methods() {
|
|
ClassDB::bind_method(D_METHOD("set_target_node", "target_nodepath"), &SkeletonModification3DCCDIK::set_target_node);
|
|
ClassDB::bind_method(D_METHOD("get_target_node"), &SkeletonModification3DCCDIK::get_target_node);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_tip_node", "tip_nodepath"), &SkeletonModification3DCCDIK::set_tip_node);
|
|
ClassDB::bind_method(D_METHOD("get_tip_node"), &SkeletonModification3DCCDIK::get_tip_node);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_use_high_quality_solve", "high_quality_solve"), &SkeletonModification3DCCDIK::set_use_high_quality_solve);
|
|
ClassDB::bind_method(D_METHOD("get_use_high_quality_solve"), &SkeletonModification3DCCDIK::get_use_high_quality_solve);
|
|
|
|
// CCDIK joint data functions
|
|
ClassDB::bind_method(D_METHOD("get_ccdik_joint_bone_name", "joint_idx"), &SkeletonModification3DCCDIK::get_ccdik_joint_bone_name);
|
|
ClassDB::bind_method(D_METHOD("set_ccdik_joint_bone_name", "joint_idx", "bone_name"), &SkeletonModification3DCCDIK::set_ccdik_joint_bone_name);
|
|
ClassDB::bind_method(D_METHOD("get_ccdik_joint_bone_index", "joint_idx"), &SkeletonModification3DCCDIK::get_ccdik_joint_bone_index);
|
|
ClassDB::bind_method(D_METHOD("set_ccdik_joint_bone_index", "joint_idx", "bone_index"), &SkeletonModification3DCCDIK::set_ccdik_joint_bone_index);
|
|
ClassDB::bind_method(D_METHOD("get_ccdik_joint_ccdik_axis", "joint_idx"), &SkeletonModification3DCCDIK::get_ccdik_joint_ccdik_axis);
|
|
ClassDB::bind_method(D_METHOD("set_ccdik_joint_ccdik_axis", "joint_idx", "axis"), &SkeletonModification3DCCDIK::set_ccdik_joint_ccdik_axis);
|
|
ClassDB::bind_method(D_METHOD("get_ccdik_joint_enable_joint_constraint", "joint_idx"), &SkeletonModification3DCCDIK::get_ccdik_joint_enable_constraint);
|
|
ClassDB::bind_method(D_METHOD("set_ccdik_joint_enable_joint_constraint", "joint_idx", "enable"), &SkeletonModification3DCCDIK::set_ccdik_joint_enable_constraint);
|
|
ClassDB::bind_method(D_METHOD("get_ccdik_joint_constraint_angle_min", "joint_idx"), &SkeletonModification3DCCDIK::get_ccdik_joint_constraint_angle_min);
|
|
ClassDB::bind_method(D_METHOD("set_ccdik_joint_constraint_angle_min", "joint_idx", "min_angle"), &SkeletonModification3DCCDIK::set_ccdik_joint_constraint_angle_min);
|
|
ClassDB::bind_method(D_METHOD("get_ccdik_joint_constraint_angle_max", "joint_idx"), &SkeletonModification3DCCDIK::get_ccdik_joint_constraint_angle_max);
|
|
ClassDB::bind_method(D_METHOD("set_ccdik_joint_constraint_angle_max", "joint_idx", "max_angle"), &SkeletonModification3DCCDIK::set_ccdik_joint_constraint_angle_max);
|
|
ClassDB::bind_method(D_METHOD("get_ccdik_joint_constraint_invert", "joint_idx"), &SkeletonModification3DCCDIK::get_ccdik_joint_constraint_invert);
|
|
ClassDB::bind_method(D_METHOD("set_ccdik_joint_constraint_invert", "joint_idx", "invert"), &SkeletonModification3DCCDIK::set_ccdik_joint_constraint_invert);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_ccdik_data_chain_length", "length"), &SkeletonModification3DCCDIK::set_ccdik_data_chain_length);
|
|
ClassDB::bind_method(D_METHOD("get_ccdik_data_chain_length"), &SkeletonModification3DCCDIK::get_ccdik_data_chain_length);
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "target_nodepath", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Node3D"), "set_target_node", "get_target_node");
|
|
ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "tip_nodepath", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Node3D"), "set_tip_node", "get_tip_node");
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "high_quality_solve", PROPERTY_HINT_NONE, ""), "set_use_high_quality_solve", "get_use_high_quality_solve");
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "ccdik_data_chain_length", PROPERTY_HINT_RANGE, "0,100,1"), "set_ccdik_data_chain_length", "get_ccdik_data_chain_length");
|
|
}
|
|
|
|
SkeletonModification3DCCDIK::SkeletonModification3DCCDIK() {
|
|
stack = nullptr;
|
|
is_setup = false;
|
|
enabled = true;
|
|
}
|
|
|
|
SkeletonModification3DCCDIK::~SkeletonModification3DCCDIK() {
|
|
}
|