/**************************************************************************/
/* retarget_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 "retarget_modifier_3d.h"
#include "core/object/callable_mp.h"
#include "core/object/class_db.h"
PackedStringArray RetargetModifier3D::get_configuration_warnings() const {
PackedStringArray warnings = SkeletonModifier3D::get_configuration_warnings();
if (child_skeletons.is_empty()) {
warnings.push_back(RTR("There is no child Skeleton3D!"));
}
return warnings;
}
/// Caching
void RetargetModifier3D::_profile_changed(Ref<SkeletonProfile> p_old, Ref<SkeletonProfile> p_new) {
if (p_old.is_valid() && p_old->is_connected(SNAME("profile_updated"), callable_mp(this, &RetargetModifier3D::cache_rests_with_reset))) {
p_old->disconnect(SNAME("profile_updated"), callable_mp(this, &RetargetModifier3D::cache_rests_with_reset));
}
profile = p_new;
if (p_new.is_valid() && !p_new->is_connected(SNAME("profile_updated"), callable_mp(this, &RetargetModifier3D::cache_rests_with_reset))) {
p_new->connect(SNAME("profile_updated"), callable_mp(this, &RetargetModifier3D::cache_rests_with_reset));
}
cache_rests_with_reset();
}
void RetargetModifier3D::_skeleton_changed(Skeleton3D *p_old, Skeleton3D *p_new) {
if (p_old && p_old->is_connected(SNAME("rest_updated"), callable_mp(this, &RetargetModifier3D::cache_rests))) {
p_old->disconnect(SNAME("rest_updated"), callable_mp(this, &RetargetModifier3D::cache_rests));
}
if (p_new && !p_new->is_connected(SNAME("rest_updated"), callable_mp(this, &RetargetModifier3D::cache_rests))) {
p_new->connect(SNAME("rest_updated"), callable_mp(this, &RetargetModifier3D::cache_rests));
}
cache_rests();
}
void RetargetModifier3D::cache_rests_with_reset() {
_reset_child_skeleton_poses();
cache_rests();
}
void RetargetModifier3D::cache_rests() {
source_bone_ids.clear();
Skeleton3D *source_skeleton = get_skeleton();
if (profile.is_null() || !source_skeleton) {
return;
}
PackedStringArray bone_names = profile->get_bone_names();
for (const String &E : bone_names) {
source_bone_ids.push_back(source_skeleton->find_bone(E));
}
for (int i = 0; i < child_skeletons.size(); i++) {
_update_child_skeleton_rests(i);
}
}
Vector<RetargetModifier3D::RetargetBoneInfo> RetargetModifier3D::cache_bone_global_rests(Skeleton3D *p_skeleton) {
// Retarget global pose in model space:
// tgt_global_pose.basis = src_global_pose.basis * src_rest.basis.inv * src_parent_global_rest.basis.inv * tgt_parent_global_rest.basis * tgt_rest.basis
// tgt_global_pose.origin = src_global_pose.origin
Skeleton3D *source_skeleton = get_skeleton();
Vector<RetargetBoneInfo> bone_rests;
if (profile.is_null() || !source_skeleton) {
return bone_rests;
}
PackedStringArray bone_names = profile->get_bone_names();
for (const String &E : bone_names) {
RetargetBoneInfo rbi;
int source_bone_id = source_skeleton->find_bone(E);
if (source_bone_id >= 0) {
Transform3D parent_global_rest;
int bone_parent = source_skeleton->get_bone_parent(source_bone_id);
if (bone_parent >= 0) {
parent_global_rest = source_skeleton->get_bone_global_rest(bone_parent);
}
rbi.post_basis = source_skeleton->get_bone_rest(source_bone_id).basis.inverse() * parent_global_rest.basis.inverse();
}
int target_bone_id = p_skeleton->find_bone(E);
rbi.bone_id = target_bone_id;
if (target_bone_id >= 0) {
Transform3D parent_global_rest;
int bone_parent = p_skeleton->get_bone_parent(target_bone_id);
if (bone_parent >= 0) {
parent_global_rest = p_skeleton->get_bone_global_rest(bone_parent);
}
rbi.post_basis = rbi.post_basis * parent_global_rest.basis * p_skeleton->get_bone_rest(target_bone_id).basis;
}
bone_rests.push_back(rbi);
}
return bone_rests;
}
Vector<RetargetModifier3D::RetargetBoneInfo> RetargetModifier3D::cache_bone_rests(Skeleton3D *p_skeleton) {
// Retarget pose in model space:
// tgt_pose.basis = tgt_parent_global_rest.basis.inv * src_parent_global_rest.basis * src_pose.basis * src_rest.basis.inv * src_parent_global_rest.basis.inv * tgt_parent_global_rest.basis * tgt_rest.basis
// tgt_pose.origin = tgt_parent_global_rest.basis.inv.xform(src_parent_global_rest.basis.xform(src_pose.origin - src_rest.origin)) + tgt_rest.origin
Skeleton3D *source_skeleton = get_skeleton();
Vector<RetargetBoneInfo> bone_rests;
if (profile.is_null() || !source_skeleton) {
return bone_rests;
}
PackedStringArray bone_names = profile->get_bone_names();
for (const String &E : bone_names) {
RetargetBoneInfo rbi;
int source_bone_id = source_skeleton->find_bone(E);
if (source_bone_id >= 0) {
Transform3D parent_global_rest;
int bone_parent = source_skeleton->get_bone_parent(source_bone_id);
if (bone_parent >= 0) {
parent_global_rest = source_skeleton->get_bone_global_rest(bone_parent);
}
rbi.pre_basis = parent_global_rest.basis;
rbi.post_basis = source_skeleton->get_bone_rest(source_bone_id).basis.inverse() * parent_global_rest.basis.inverse();
}
int target_bone_id = p_skeleton->find_bone(E);
rbi.bone_id = target_bone_id;
if (target_bone_id >= 0) {
Transform3D parent_global_rest;
int bone_parent = p_skeleton->get_bone_parent(target_bone_id);
if (bone_parent >= 0) {
parent_global_rest = p_skeleton->get_bone_global_rest(bone_parent);
}
rbi.pre_basis = parent_global_rest.basis.inverse() * rbi.pre_basis;
rbi.post_basis = rbi.post_basis * parent_global_rest.basis * p_skeleton->get_bone_rest(target_bone_id).basis;
}
bone_rests.push_back(rbi);
}
return bone_rests;
}
void RetargetModifier3D::_update_child_skeleton_rests(int p_child_skeleton_idx) {
ERR_FAIL_INDEX(p_child_skeleton_idx, child_skeletons.size());
Skeleton3D *c = ObjectDB::get_instance<Skeleton3D>(child_skeletons[p_child_skeleton_idx].skeleton_id);
if (!c) {
return;
}
if (use_global_pose) {
child_skeletons.write[p_child_skeleton_idx].humanoid_bone_rests = cache_bone_global_rests(c);
} else {
child_skeletons.write[p_child_skeleton_idx].humanoid_bone_rests = cache_bone_rests(c);
}
}
void RetargetModifier3D::_update_child_skeletons() {
_reset_child_skeletons();
for (int i = 0; i < get_child_count(); i++) {
RetargetInfo ri;
Skeleton3D *c = Object::cast_to<Skeleton3D>(get_child(i));
if (c) {
int id = child_skeletons.size();
ri.skeleton_id = c->get_instance_id();
child_skeletons.push_back(ri);
c->connect(SNAME("rest_updated"), callable_mp(this, &RetargetModifier3D::_update_child_skeleton_rests).bind(id));
}
}
cache_rests();
update_configuration_warnings();
}
void RetargetModifier3D::_reset_child_skeleton_poses() {
for (const RetargetInfo &E : child_skeletons) {
Skeleton3D *c = ObjectDB::get_instance<Skeleton3D>(E.skeleton_id);
if (!c) {
continue;
}
if (c->is_connected(SNAME("rest_updated"), callable_mp(this, &RetargetModifier3D::_update_child_skeleton_rests))) {
c->disconnect(SNAME("rest_updated"), callable_mp(this, &RetargetModifier3D::_update_child_skeleton_rests));
}
for (const RetargetBoneInfo &F : E.humanoid_bone_rests) {
if (F.bone_id < 0) {
continue;
}
c->reset_bone_pose(F.bone_id);
}
}
}
void RetargetModifier3D::_reset_child_skeletons() {
_reset_child_skeleton_poses();
child_skeletons.clear();
}
#ifdef TOOLS_ENABLED
void RetargetModifier3D::_force_update_child_skeletons() {
for (const RetargetInfo &E : child_skeletons) {
Skeleton3D *c = ObjectDB::get_instance<Skeleton3D>(E.skeleton_id);
if (!c) {
continue;
}
c->force_update_all_dirty_bones();
c->emit_signal(SceneStringName(skeleton_updated));
}
}
#endif // TOOLS_ENABLED
/// General functions
void RetargetModifier3D::add_child_notify(Node *p_child) {
if (Object::cast_to<Skeleton3D>(p_child)) {
_update_child_skeletons();
}
}
void RetargetModifier3D::move_child_notify(Node *p_child) {
if (Object::cast_to<Skeleton3D>(p_child)) {
_update_child_skeletons();
}
}
void RetargetModifier3D::remove_child_notify(Node *p_child) {
if (Object::cast_to<Skeleton3D>(p_child)) {
// Reset after process.
callable_mp(this, &RetargetModifier3D::_update_child_skeletons).call_deferred();
}
}
void RetargetModifier3D::_validate_property(PropertyInfo &p_property) const {
if (use_global_pose) {
if (p_property.name == "enable") {
p_property.usage = PROPERTY_USAGE_NONE;
}
}
}
void RetargetModifier3D::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_profile", "profile"), &RetargetModifier3D::set_profile);
ClassDB::bind_method(D_METHOD("get_profile"), &RetargetModifier3D::get_profile);
ClassDB::bind_method(D_METHOD("set_use_global_pose", "use_global_pose"), &RetargetModifier3D::set_use_global_pose);
ClassDB::bind_method(D_METHOD("is_using_global_pose"), &RetargetModifier3D::is_using_global_pose);
ClassDB::bind_method(D_METHOD("set_enable_flags", "enable_flags"), &RetargetModifier3D::set_enable_flags);
ClassDB::bind_method(D_METHOD("get_enable_flags"), &RetargetModifier3D::get_enable_flags);
ClassDB::bind_method(D_METHOD("set_position_enabled", "enabled"), &RetargetModifier3D::set_position_enabled);
ClassDB::bind_method(D_METHOD("is_position_enabled"), &RetargetModifier3D::is_position_enabled);
ClassDB::bind_method(D_METHOD("set_rotation_enabled", "enabled"), &RetargetModifier3D::set_rotation_enabled);
ClassDB::bind_method(D_METHOD("is_rotation_enabled"), &RetargetModifier3D::is_rotation_enabled);
ClassDB::bind_method(D_METHOD("set_scale_enabled", "enabled"), &RetargetModifier3D::set_scale_enabled);
ClassDB::bind_method(D_METHOD("is_scale_enabled"), &RetargetModifier3D::is_scale_enabled);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "profile", PROPERTY_HINT_RESOURCE_TYPE, SkeletonProfile::get_class_static()), "set_profile", "get_profile");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "use_global_pose"), "set_use_global_pose", "is_using_global_pose");
ADD_PROPERTY(PropertyInfo(Variant::INT, "enable", PROPERTY_HINT_FLAGS, "Position,Rotation,Scale"), "set_enable_flags", "get_enable_flags");
BIND_BITFIELD_FLAG(TRANSFORM_FLAG_POSITION);
BIND_BITFIELD_FLAG(TRANSFORM_FLAG_ROTATION);
BIND_BITFIELD_FLAG(TRANSFORM_FLAG_SCALE);
BIND_BITFIELD_FLAG(TRANSFORM_FLAG_ALL);
}
void RetargetModifier3D::_set_active(bool p_active) {
if (!p_active) {
_reset_child_skeleton_poses();
}
}
void RetargetModifier3D::_retarget_global_pose() {
Skeleton3D *source_skeleton = get_skeleton();
if (profile.is_null() || !source_skeleton) {
return;
}
LocalVector<Transform3D> source_poses;
if (influence < 1.0) {
for (int source_bone_id : source_bone_ids) {
source_poses.push_back(source_bone_id < 0 ? Transform3D() : source_skeleton->get_bone_global_rest(source_bone_id).interpolate_with(source_skeleton->get_bone_global_pose(source_bone_id), influence));
}
} else {
for (int source_bone_id : source_bone_ids) {
source_poses.push_back(source_bone_id < 0 ? Transform3D() : source_skeleton->get_bone_global_pose(source_bone_id));
}
}
for (const RetargetInfo &E : child_skeletons) {
Skeleton3D *target_skeleton = ObjectDB::get_instance<Skeleton3D>(E.skeleton_id);
if (!target_skeleton) {
continue;
}
for (int i = 0; i < source_bone_ids.size(); i++) {
int target_bone_id = E.humanoid_bone_rests[i].bone_id;
if (target_bone_id < 0) {
continue;
}
Transform3D retarget_pose = source_poses[i];
retarget_pose.basis = retarget_pose.basis * E.humanoid_bone_rests[i].post_basis;
target_skeleton->set_bone_global_pose(target_bone_id, retarget_pose);
}
}
}
void RetargetModifier3D::_retarget_pose() {
Skeleton3D *source_skeleton = get_skeleton();
if (profile.is_null() || !source_skeleton) {
return;
}
LocalVector<Transform3D> source_poses;
if (influence < 1.0) {
for (int source_bone_id : source_bone_ids) {
source_poses.push_back(source_bone_id < 0 ? Transform3D() : source_skeleton->get_bone_rest(source_bone_id).interpolate_with(source_skeleton->get_bone_pose(source_bone_id), influence));
}
} else {
for (int source_bone_id : source_bone_ids) {
source_poses.push_back(source_bone_id < 0 ? Transform3D() : source_skeleton->get_bone_pose(source_bone_id));
}
}
for (const RetargetInfo &E : child_skeletons) {
Skeleton3D *target_skeleton = ObjectDB::get_instance<Skeleton3D>(E.skeleton_id);
if (!target_skeleton) {
continue;
}
float motion_scale_ratio = target_skeleton->get_motion_scale() / source_skeleton->get_motion_scale();
for (int i = 0; i < source_bone_ids.size(); i++) {
int target_bone_id = E.humanoid_bone_rests[i].bone_id;
if (target_bone_id < 0) {
continue;
}
int source_bone_id = source_bone_ids[i];
if (source_bone_id < 0) {
continue;
}
Transform3D extracted_transform = source_poses[i];
extracted_transform.basis = E.humanoid_bone_rests[i].pre_basis * extracted_transform.basis * E.humanoid_bone_rests[i].post_basis;
extracted_transform.origin = E.humanoid_bone_rests[i].pre_basis.xform((extracted_transform.origin - source_skeleton->get_bone_rest(source_bone_id).origin) * motion_scale_ratio) + target_skeleton->get_bone_rest(target_bone_id).origin;
if (enable_flags.has_flag(TRANSFORM_FLAG_POSITION)) {
target_skeleton->set_bone_pose_position(target_bone_id, extracted_transform.origin);
}
if (enable_flags.has_flag(TRANSFORM_FLAG_ROTATION)) {
target_skeleton->set_bone_pose_rotation(target_bone_id, extracted_transform.basis.get_rotation_quaternion());
}
if (enable_flags.has_flag(TRANSFORM_FLAG_SCALE)) {
target_skeleton->set_bone_pose_scale(target_bone_id, extracted_transform.basis.get_scale());
}
}
}
}
void RetargetModifier3D::_process_modification(double p_delta) {
if (use_global_pose) {
_retarget_global_pose();
} else {
_retarget_pose();
}
}
void RetargetModifier3D::set_profile(Ref<SkeletonProfile> p_profile) {
if (profile == p_profile) {
return;
}
_profile_changed(profile, p_profile);
}
Ref<SkeletonProfile> RetargetModifier3D::get_profile() const {
return profile;
}
void RetargetModifier3D::set_use_global_pose(bool p_use_global_pose) {
if (use_global_pose == p_use_global_pose) {
return;
}
use_global_pose = p_use_global_pose;
cache_rests_with_reset();
notify_property_list_changed();
}
bool RetargetModifier3D::is_using_global_pose() const {
return use_global_pose;
}
void RetargetModifier3D::set_enable_flags(BitField<TransformFlag> p_enable_flag) {
if (enable_flags != p_enable_flag) {
_reset_child_skeleton_poses();
}
enable_flags = p_enable_flag;
}
BitField<RetargetModifier3D::TransformFlag> RetargetModifier3D::get_enable_flags() const {
return enable_flags;
}
void RetargetModifier3D::set_position_enabled(bool p_enabled) {
if (enable_flags.has_flag(TRANSFORM_FLAG_POSITION) != p_enabled) {
_reset_child_skeleton_poses();
}
if (p_enabled) {
enable_flags.set_flag(TRANSFORM_FLAG_POSITION);
} else {
enable_flags.clear_flag(TRANSFORM_FLAG_POSITION);
}
}
bool RetargetModifier3D::is_position_enabled() const {
return enable_flags.has_flag(TRANSFORM_FLAG_POSITION);
}
void RetargetModifier3D::set_rotation_enabled(bool p_enabled) {
if (enable_flags.has_flag(TRANSFORM_FLAG_ROTATION) != p_enabled) {
_reset_child_skeleton_poses();
}
if (p_enabled) {
enable_flags.set_flag(TRANSFORM_FLAG_ROTATION);
} else {
enable_flags.clear_flag(TRANSFORM_FLAG_ROTATION);
}
}
bool RetargetModifier3D::is_rotation_enabled() const {
return enable_flags.has_flag(TRANSFORM_FLAG_ROTATION);
}
void RetargetModifier3D::set_scale_enabled(bool p_enabled) {
if (enable_flags.has_flag(TRANSFORM_FLAG_SCALE) != p_enabled) {
_reset_child_skeleton_poses();
}
if (p_enabled) {
enable_flags.set_flag(TRANSFORM_FLAG_SCALE);
} else {
enable_flags.clear_flag(TRANSFORM_FLAG_SCALE);
}
}
bool RetargetModifier3D::is_scale_enabled() const {
return enable_flags.has_flag(TRANSFORM_FLAG_SCALE);
}
void RetargetModifier3D::_notification(int p_what) {
switch (p_what) {
case NOTIFICATION_ENTER_TREE: {
_update_child_skeletons();
} break;
case NOTIFICATION_EXIT_TREE: {
_reset_child_skeletons();
} break;
}
}
RetargetModifier3D::RetargetModifier3D() {
}
RetargetModifier3D::~RetargetModifier3D() {
}