1387 lines
48 KiB
C++
1387 lines
48 KiB
C++
/*************************************************************************/
|
|
/* bone_map_editor_plugin.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
|
|
/* */
|
|
/* 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 "bone_map_editor_plugin.h"
|
|
|
|
#include "editor/editor_scale.h"
|
|
#include "editor/import/post_import_plugin_skeleton_renamer.h"
|
|
#include "editor/import/post_import_plugin_skeleton_rest_fixer.h"
|
|
#include "editor/import/post_import_plugin_skeleton_track_organizer.h"
|
|
#include "editor/import/scene_import_settings.h"
|
|
|
|
void BoneMapperButton::fetch_textures() {
|
|
if (selected) {
|
|
set_texture_normal(get_theme_icon(SNAME("BoneMapperHandleSelected"), SNAME("EditorIcons")));
|
|
} else {
|
|
set_texture_normal(get_theme_icon(SNAME("BoneMapperHandle"), SNAME("EditorIcons")));
|
|
}
|
|
set_offset(SIDE_LEFT, 0);
|
|
set_offset(SIDE_RIGHT, 0);
|
|
set_offset(SIDE_TOP, 0);
|
|
set_offset(SIDE_BOTTOM, 0);
|
|
|
|
// Hack to avoid handle color darkening...
|
|
set_modulate(EditorSettings::get_singleton()->is_dark_theme() ? Color(1, 1, 1) : Color(4.25, 4.25, 4.25));
|
|
|
|
circle = memnew(TextureRect);
|
|
circle->set_texture(get_theme_icon(SNAME("BoneMapperHandleCircle"), SNAME("EditorIcons")));
|
|
add_child(circle);
|
|
set_state(BONE_MAP_STATE_UNSET);
|
|
}
|
|
|
|
StringName BoneMapperButton::get_profile_bone_name() const {
|
|
return profile_bone_name;
|
|
}
|
|
|
|
void BoneMapperButton::set_state(BoneMapState p_state) {
|
|
switch (p_state) {
|
|
case BONE_MAP_STATE_UNSET: {
|
|
circle->set_modulate(EDITOR_GET("editors/bone_mapper/handle_colors/unset"));
|
|
} break;
|
|
case BONE_MAP_STATE_SET: {
|
|
circle->set_modulate(EDITOR_GET("editors/bone_mapper/handle_colors/set"));
|
|
} break;
|
|
case BONE_MAP_STATE_MISSING: {
|
|
circle->set_modulate(EDITOR_GET("editors/bone_mapper/handle_colors/missing"));
|
|
} break;
|
|
case BONE_MAP_STATE_ERROR: {
|
|
circle->set_modulate(EDITOR_GET("editors/bone_mapper/handle_colors/error"));
|
|
} break;
|
|
default: {
|
|
} break;
|
|
}
|
|
}
|
|
|
|
bool BoneMapperButton::is_require() const {
|
|
return require;
|
|
}
|
|
|
|
void BoneMapperButton::_notification(int p_what) {
|
|
switch (p_what) {
|
|
case NOTIFICATION_ENTER_TREE: {
|
|
fetch_textures();
|
|
} break;
|
|
}
|
|
}
|
|
|
|
BoneMapperButton::BoneMapperButton(const StringName p_profile_bone_name, bool p_require, bool p_selected) {
|
|
profile_bone_name = p_profile_bone_name;
|
|
require = p_require;
|
|
selected = p_selected;
|
|
}
|
|
|
|
BoneMapperButton::~BoneMapperButton() {
|
|
}
|
|
|
|
void BoneMapperItem::create_editor() {
|
|
HBoxContainer *hbox = memnew(HBoxContainer);
|
|
add_child(hbox);
|
|
|
|
skeleton_bone_selector = memnew(EditorPropertyText);
|
|
skeleton_bone_selector->set_label(profile_bone_name);
|
|
skeleton_bone_selector->set_selectable(false);
|
|
skeleton_bone_selector->set_h_size_flags(SIZE_EXPAND_FILL);
|
|
skeleton_bone_selector->set_object_and_property(bone_map.ptr(), "bone_map/" + String(profile_bone_name));
|
|
skeleton_bone_selector->update_property();
|
|
skeleton_bone_selector->connect("property_changed", callable_mp(this, &BoneMapperItem::_value_changed));
|
|
hbox->add_child(skeleton_bone_selector);
|
|
|
|
picker_button = memnew(Button);
|
|
picker_button->set_icon(get_theme_icon(SNAME("ClassList"), SNAME("EditorIcons")));
|
|
picker_button->connect("pressed", callable_mp(this, &BoneMapperItem::_open_picker));
|
|
hbox->add_child(picker_button);
|
|
|
|
add_child(memnew(HSeparator));
|
|
}
|
|
|
|
void BoneMapperItem::_update_property() {
|
|
if (skeleton_bone_selector->get_edited_object() && skeleton_bone_selector->get_edited_property()) {
|
|
skeleton_bone_selector->update_property();
|
|
}
|
|
}
|
|
|
|
void BoneMapperItem::_open_picker() {
|
|
emit_signal(SNAME("pick"), profile_bone_name);
|
|
}
|
|
|
|
void BoneMapperItem::_value_changed(const String &p_property, Variant p_value, const String &p_name, bool p_changing) {
|
|
bone_map->set(p_property, p_value);
|
|
}
|
|
|
|
void BoneMapperItem::_notification(int p_what) {
|
|
switch (p_what) {
|
|
case NOTIFICATION_ENTER_TREE: {
|
|
create_editor();
|
|
bone_map->connect("bone_map_updated", callable_mp(this, &BoneMapperItem::_update_property));
|
|
} break;
|
|
case NOTIFICATION_EXIT_TREE: {
|
|
if (!bone_map.is_null() && bone_map->is_connected("bone_map_updated", callable_mp(this, &BoneMapperItem::_update_property))) {
|
|
bone_map->disconnect("bone_map_updated", callable_mp(this, &BoneMapperItem::_update_property));
|
|
}
|
|
} break;
|
|
}
|
|
}
|
|
|
|
void BoneMapperItem::_bind_methods() {
|
|
ADD_SIGNAL(MethodInfo("pick", PropertyInfo(Variant::STRING_NAME, "profile_bone_name")));
|
|
}
|
|
|
|
BoneMapperItem::BoneMapperItem(Ref<BoneMap> &p_bone_map, const StringName &p_profile_bone_name) {
|
|
bone_map = p_bone_map;
|
|
profile_bone_name = p_profile_bone_name;
|
|
}
|
|
|
|
BoneMapperItem::~BoneMapperItem() {
|
|
}
|
|
|
|
void BonePicker::create_editors() {
|
|
set_title(TTR("Bone Picker:"));
|
|
|
|
VBoxContainer *vbox = memnew(VBoxContainer);
|
|
add_child(vbox);
|
|
|
|
bones = memnew(Tree);
|
|
bones->set_select_mode(Tree::SELECT_SINGLE);
|
|
bones->set_v_size_flags(Control::SIZE_EXPAND_FILL);
|
|
bones->set_hide_root(true);
|
|
bones->connect("item_activated", callable_mp(this, &BonePicker::_confirm));
|
|
vbox->add_child(bones);
|
|
|
|
create_bones_tree(skeleton);
|
|
}
|
|
|
|
void BonePicker::create_bones_tree(Skeleton3D *p_skeleton) {
|
|
bones->clear();
|
|
|
|
if (!p_skeleton) {
|
|
return;
|
|
}
|
|
|
|
TreeItem *root = bones->create_item();
|
|
|
|
HashMap<int, TreeItem *> items;
|
|
|
|
items.insert(-1, root);
|
|
|
|
Ref<Texture> bone_icon = get_theme_icon(SNAME("BoneAttachment3D"), SNAME("EditorIcons"));
|
|
|
|
Vector<int> bones_to_process = p_skeleton->get_parentless_bones();
|
|
bool is_first = true;
|
|
while (bones_to_process.size() > 0) {
|
|
int current_bone_idx = bones_to_process[0];
|
|
bones_to_process.erase(current_bone_idx);
|
|
|
|
Vector<int> current_bone_child_bones = p_skeleton->get_bone_children(current_bone_idx);
|
|
int child_bone_size = current_bone_child_bones.size();
|
|
for (int i = 0; i < child_bone_size; i++) {
|
|
bones_to_process.push_back(current_bone_child_bones[i]);
|
|
}
|
|
|
|
const int parent_idx = p_skeleton->get_bone_parent(current_bone_idx);
|
|
TreeItem *parent_item = items.find(parent_idx)->value;
|
|
|
|
TreeItem *joint_item = bones->create_item(parent_item);
|
|
items.insert(current_bone_idx, joint_item);
|
|
|
|
joint_item->set_text(0, p_skeleton->get_bone_name(current_bone_idx));
|
|
joint_item->set_icon(0, bone_icon);
|
|
joint_item->set_selectable(0, true);
|
|
joint_item->set_metadata(0, "bones/" + itos(current_bone_idx));
|
|
if (is_first) {
|
|
is_first = false;
|
|
} else {
|
|
joint_item->set_collapsed(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
void BonePicker::_confirm() {
|
|
_ok_pressed();
|
|
}
|
|
|
|
void BonePicker::popup_bones_tree(const Size2i &p_minsize) {
|
|
popup_centered(p_minsize);
|
|
}
|
|
|
|
bool BonePicker::has_selected_bone() {
|
|
TreeItem *selected = bones->get_selected();
|
|
if (!selected) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
StringName BonePicker::get_selected_bone() {
|
|
TreeItem *selected = bones->get_selected();
|
|
if (!selected) {
|
|
return StringName();
|
|
}
|
|
return selected->get_text(0);
|
|
}
|
|
|
|
void BonePicker::_bind_methods() {
|
|
}
|
|
|
|
void BonePicker::_notification(int p_what) {
|
|
switch (p_what) {
|
|
case NOTIFICATION_ENTER_TREE: {
|
|
create_editors();
|
|
} break;
|
|
}
|
|
}
|
|
|
|
BonePicker::BonePicker(Skeleton3D *p_skeleton) {
|
|
skeleton = p_skeleton;
|
|
}
|
|
|
|
BonePicker::~BonePicker() {
|
|
}
|
|
|
|
void BoneMapper::create_editor() {
|
|
// Create Bone picker.
|
|
picker = memnew(BonePicker(skeleton));
|
|
picker->connect("confirmed", callable_mp(this, &BoneMapper::_apply_picker_selection));
|
|
add_child(picker, false, INTERNAL_MODE_FRONT);
|
|
|
|
profile_selector = memnew(EditorPropertyResource);
|
|
profile_selector->setup(bone_map.ptr(), "profile", "SkeletonProfile");
|
|
profile_selector->set_label("Profile");
|
|
profile_selector->set_selectable(false);
|
|
profile_selector->set_object_and_property(bone_map.ptr(), "profile");
|
|
profile_selector->update_property();
|
|
profile_selector->connect("property_changed", callable_mp(this, &BoneMapper::_profile_changed));
|
|
add_child(profile_selector);
|
|
add_child(memnew(HSeparator));
|
|
|
|
HBoxContainer *group_hbox = memnew(HBoxContainer);
|
|
add_child(group_hbox);
|
|
|
|
profile_group_selector = memnew(EditorPropertyEnum);
|
|
profile_group_selector->set_label("Group");
|
|
profile_group_selector->set_selectable(false);
|
|
profile_group_selector->set_h_size_flags(SIZE_EXPAND_FILL);
|
|
profile_group_selector->set_object_and_property(this, "current_group_idx");
|
|
profile_group_selector->update_property();
|
|
profile_group_selector->connect("property_changed", callable_mp(this, &BoneMapper::_value_changed));
|
|
group_hbox->add_child(profile_group_selector);
|
|
|
|
clear_mapping_button = memnew(Button);
|
|
clear_mapping_button->set_icon(get_theme_icon(SNAME("Clear"), SNAME("EditorIcons")));
|
|
clear_mapping_button->set_tooltip_text(TTR("Clear mappings in current group."));
|
|
clear_mapping_button->connect("pressed", callable_mp(this, &BoneMapper::_clear_mapping_current_group));
|
|
group_hbox->add_child(clear_mapping_button);
|
|
|
|
bone_mapper_field = memnew(AspectRatioContainer);
|
|
bone_mapper_field->set_stretch_mode(AspectRatioContainer::STRETCH_FIT);
|
|
bone_mapper_field->set_custom_minimum_size(Vector2(0, 256.0) * EDSCALE);
|
|
bone_mapper_field->set_h_size_flags(Control::SIZE_FILL);
|
|
add_child(bone_mapper_field);
|
|
|
|
profile_bg = memnew(ColorRect);
|
|
profile_bg->set_color(Color(0, 0, 0, 1));
|
|
profile_bg->set_h_size_flags(Control::SIZE_FILL);
|
|
profile_bg->set_v_size_flags(Control::SIZE_FILL);
|
|
bone_mapper_field->add_child(profile_bg);
|
|
|
|
profile_texture = memnew(TextureRect);
|
|
profile_texture->set_stretch_mode(TextureRect::STRETCH_KEEP_ASPECT_CENTERED);
|
|
profile_texture->set_ignore_texture_size(true);
|
|
profile_texture->set_h_size_flags(Control::SIZE_FILL);
|
|
profile_texture->set_v_size_flags(Control::SIZE_FILL);
|
|
bone_mapper_field->add_child(profile_texture);
|
|
|
|
mapper_item_vbox = memnew(VBoxContainer);
|
|
add_child(mapper_item_vbox);
|
|
|
|
recreate_items();
|
|
}
|
|
|
|
void BoneMapper::update_group_idx() {
|
|
if (!bone_map->get_profile().is_valid()) {
|
|
return;
|
|
}
|
|
|
|
PackedStringArray group_names;
|
|
int len = bone_map->get_profile()->get_group_size();
|
|
for (int i = 0; i < len; i++) {
|
|
group_names.push_back(bone_map->get_profile()->get_group_name(i));
|
|
}
|
|
if (current_group_idx >= len) {
|
|
current_group_idx = 0;
|
|
}
|
|
if (len > 0) {
|
|
profile_group_selector->setup(group_names);
|
|
profile_group_selector->update_property();
|
|
profile_group_selector->set_read_only(false);
|
|
}
|
|
}
|
|
|
|
void BoneMapper::_pick_bone(const StringName &p_bone_name) {
|
|
picker_key_name = p_bone_name;
|
|
picker->popup_bones_tree(Size2(500, 500) * EDSCALE);
|
|
}
|
|
|
|
void BoneMapper::_apply_picker_selection() {
|
|
if (!picker->has_selected_bone()) {
|
|
return;
|
|
}
|
|
bone_map->set_skeleton_bone_name(picker_key_name, picker->get_selected_bone());
|
|
}
|
|
|
|
void BoneMapper::set_current_group_idx(int p_group_idx) {
|
|
current_group_idx = p_group_idx;
|
|
recreate_editor();
|
|
}
|
|
|
|
int BoneMapper::get_current_group_idx() const {
|
|
return current_group_idx;
|
|
}
|
|
|
|
void BoneMapper::set_current_bone_idx(int p_bone_idx) {
|
|
current_bone_idx = p_bone_idx;
|
|
recreate_editor();
|
|
}
|
|
|
|
int BoneMapper::get_current_bone_idx() const {
|
|
return current_bone_idx;
|
|
}
|
|
|
|
void BoneMapper::recreate_editor() {
|
|
// Clear buttons.
|
|
int len = bone_mapper_buttons.size();
|
|
for (int i = 0; i < len; i++) {
|
|
profile_texture->remove_child(bone_mapper_buttons[i]);
|
|
memdelete(bone_mapper_buttons[i]);
|
|
}
|
|
bone_mapper_buttons.clear();
|
|
|
|
// Organize mapper items.
|
|
len = bone_mapper_items.size();
|
|
for (int i = 0; i < len; i++) {
|
|
bone_mapper_items[i]->set_visible(current_bone_idx == i);
|
|
}
|
|
|
|
Ref<SkeletonProfile> profile = bone_map->get_profile();
|
|
if (profile.is_valid()) {
|
|
SkeletonProfileHumanoid *hmn = Object::cast_to<SkeletonProfileHumanoid>(profile.ptr());
|
|
if (hmn) {
|
|
StringName hmn_group_name = profile->get_group_name(current_group_idx);
|
|
if (hmn_group_name == "Body") {
|
|
profile_texture->set_texture(get_theme_icon(SNAME("BoneMapHumanBody"), SNAME("EditorIcons")));
|
|
} else if (hmn_group_name == "Face") {
|
|
profile_texture->set_texture(get_theme_icon(SNAME("BoneMapHumanFace"), SNAME("EditorIcons")));
|
|
} else if (hmn_group_name == "LeftHand") {
|
|
profile_texture->set_texture(get_theme_icon(SNAME("BoneMapHumanLeftHand"), SNAME("EditorIcons")));
|
|
} else if (hmn_group_name == "RightHand") {
|
|
profile_texture->set_texture(get_theme_icon(SNAME("BoneMapHumanRightHand"), SNAME("EditorIcons")));
|
|
}
|
|
} else {
|
|
profile_texture->set_texture(profile->get_texture(current_group_idx));
|
|
}
|
|
} else {
|
|
profile_texture->set_texture(Ref<Texture2D>());
|
|
}
|
|
|
|
if (!profile.is_valid()) {
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < len; i++) {
|
|
if (profile->get_group(i) == profile->get_group_name(current_group_idx)) {
|
|
BoneMapperButton *mb = memnew(BoneMapperButton(profile->get_bone_name(i), profile->is_require(i), current_bone_idx == i));
|
|
mb->connect("pressed", callable_mp(this, &BoneMapper::set_current_bone_idx).bind(i), CONNECT_DEFERRED);
|
|
mb->set_h_grow_direction(GROW_DIRECTION_BOTH);
|
|
mb->set_v_grow_direction(GROW_DIRECTION_BOTH);
|
|
Vector2 vc = profile->get_handle_offset(i);
|
|
bone_mapper_buttons.push_back(mb);
|
|
profile_texture->add_child(mb);
|
|
mb->set_anchor(SIDE_LEFT, vc.x);
|
|
mb->set_anchor(SIDE_RIGHT, vc.x);
|
|
mb->set_anchor(SIDE_TOP, vc.y);
|
|
mb->set_anchor(SIDE_BOTTOM, vc.y);
|
|
}
|
|
}
|
|
|
|
_update_state();
|
|
}
|
|
|
|
void BoneMapper::clear_items() {
|
|
// Clear items.
|
|
int len = bone_mapper_items.size();
|
|
for (int i = 0; i < len; i++) {
|
|
bone_mapper_items[i]->disconnect("pick", callable_mp(this, &BoneMapper::_pick_bone));
|
|
mapper_item_vbox->remove_child(bone_mapper_items[i]);
|
|
memdelete(bone_mapper_items[i]);
|
|
}
|
|
bone_mapper_items.clear();
|
|
}
|
|
|
|
void BoneMapper::recreate_items() {
|
|
clear_items();
|
|
// Create items by profile.
|
|
Ref<SkeletonProfile> profile = bone_map->get_profile();
|
|
if (profile.is_valid()) {
|
|
int len = profile->get_bone_size();
|
|
for (int i = 0; i < len; i++) {
|
|
StringName bn = profile->get_bone_name(i);
|
|
bone_mapper_items.append(memnew(BoneMapperItem(bone_map, bn)));
|
|
bone_mapper_items[i]->connect("pick", callable_mp(this, &BoneMapper::_pick_bone), CONNECT_DEFERRED);
|
|
mapper_item_vbox->add_child(bone_mapper_items[i]);
|
|
}
|
|
}
|
|
|
|
update_group_idx();
|
|
recreate_editor();
|
|
}
|
|
|
|
void BoneMapper::_update_state() {
|
|
int len = bone_mapper_buttons.size();
|
|
for (int i = 0; i < len; i++) {
|
|
StringName pbn = bone_mapper_buttons[i]->get_profile_bone_name();
|
|
StringName sbn = bone_map->get_skeleton_bone_name(pbn);
|
|
int bone_idx = skeleton->find_bone(sbn);
|
|
if (bone_idx >= 0) {
|
|
if (bone_map->get_skeleton_bone_name_count(sbn) == 1) {
|
|
Ref<SkeletonProfile> prof = bone_map->get_profile();
|
|
|
|
StringName parent_name = prof->get_bone_parent(prof->find_bone(pbn));
|
|
Vector<int> prof_parent_bones;
|
|
while (parent_name != StringName()) {
|
|
prof_parent_bones.push_back(skeleton->find_bone(bone_map->get_skeleton_bone_name(parent_name)));
|
|
if (prof->find_bone(parent_name) == -1) {
|
|
break;
|
|
}
|
|
parent_name = prof->get_bone_parent(prof->find_bone(parent_name));
|
|
}
|
|
|
|
int parent_id = skeleton->get_bone_parent(bone_idx);
|
|
Vector<int> skel_parent_bones;
|
|
while (parent_id >= 0) {
|
|
skel_parent_bones.push_back(parent_id);
|
|
parent_id = skeleton->get_bone_parent(parent_id);
|
|
}
|
|
|
|
bool is_broken = false;
|
|
for (int j = 0; j < prof_parent_bones.size(); j++) {
|
|
if (prof_parent_bones[j] != -1 && !skel_parent_bones.has(prof_parent_bones[j])) {
|
|
is_broken = true;
|
|
}
|
|
}
|
|
|
|
if (is_broken) {
|
|
bone_mapper_buttons[i]->set_state(BoneMapperButton::BONE_MAP_STATE_ERROR);
|
|
} else {
|
|
bone_mapper_buttons[i]->set_state(BoneMapperButton::BONE_MAP_STATE_SET);
|
|
}
|
|
} else {
|
|
bone_mapper_buttons[i]->set_state(BoneMapperButton::BONE_MAP_STATE_ERROR);
|
|
}
|
|
} else {
|
|
if (bone_mapper_buttons[i]->is_require()) {
|
|
bone_mapper_buttons[i]->set_state(BoneMapperButton::BONE_MAP_STATE_MISSING);
|
|
} else {
|
|
bone_mapper_buttons[i]->set_state(BoneMapperButton::BONE_MAP_STATE_UNSET);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void BoneMapper::_clear_mapping_current_group() {
|
|
if (bone_map.is_valid()) {
|
|
Ref<SkeletonProfile> profile = bone_map->get_profile();
|
|
if (profile.is_valid() && profile->get_group_size() > 0) {
|
|
int len = profile->get_bone_size();
|
|
for (int i = 0; i < len; i++) {
|
|
if (profile->get_group(i) == profile->get_group_name(current_group_idx)) {
|
|
bone_map->_set_skeleton_bone_name(profile->get_bone_name(i), StringName());
|
|
}
|
|
}
|
|
recreate_items();
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef MODULE_REGEX_ENABLED
|
|
int BoneMapper::search_bone_by_name(Skeleton3D *p_skeleton, Vector<String> p_picklist, BoneSegregation p_segregation, int p_parent, int p_child, int p_children_count) {
|
|
// There may be multiple candidates hit by existing the subsidiary bone.
|
|
// The one with the shortest name is probably the original.
|
|
LocalVector<String> hit_list;
|
|
String shortest = "";
|
|
|
|
for (int word_idx = 0; word_idx < p_picklist.size(); word_idx++) {
|
|
RegEx re = RegEx(p_picklist[word_idx]);
|
|
if (p_child == -1) {
|
|
Vector<int> bones_to_process = p_parent == -1 ? p_skeleton->get_parentless_bones() : p_skeleton->get_bone_children(p_parent);
|
|
while (bones_to_process.size() > 0) {
|
|
int idx = bones_to_process[0];
|
|
bones_to_process.erase(idx);
|
|
Vector<int> children = p_skeleton->get_bone_children(idx);
|
|
for (int i = 0; i < children.size(); i++) {
|
|
bones_to_process.push_back(children[i]);
|
|
}
|
|
|
|
if (p_children_count == 0 && children.size() > 0) {
|
|
continue;
|
|
}
|
|
if (p_children_count > 0 && children.size() < p_children_count) {
|
|
continue;
|
|
}
|
|
|
|
String bn = skeleton->get_bone_name(idx);
|
|
if (!re.search(bn.to_lower()).is_null() && guess_bone_segregation(bn) == p_segregation) {
|
|
hit_list.push_back(bn);
|
|
}
|
|
}
|
|
|
|
if (hit_list.size() > 0) {
|
|
shortest = hit_list[0];
|
|
for (uint32_t i = 0; i < hit_list.size(); i++) {
|
|
if (hit_list[i].length() < shortest.length()) {
|
|
shortest = hit_list[i]; // Prioritize parent.
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
int idx = skeleton->get_bone_parent(p_child);
|
|
while (idx != p_parent && idx >= 0) {
|
|
Vector<int> children = p_skeleton->get_bone_children(idx);
|
|
if (p_children_count == 0 && children.size() > 0) {
|
|
continue;
|
|
}
|
|
if (p_children_count > 0 && children.size() < p_children_count) {
|
|
continue;
|
|
}
|
|
|
|
String bn = skeleton->get_bone_name(idx);
|
|
if (!re.search(bn.to_lower()).is_null() && guess_bone_segregation(bn) == p_segregation) {
|
|
hit_list.push_back(bn);
|
|
}
|
|
idx = skeleton->get_bone_parent(idx);
|
|
}
|
|
|
|
if (hit_list.size() > 0) {
|
|
shortest = hit_list[0];
|
|
for (uint32_t i = 0; i < hit_list.size(); i++) {
|
|
if (hit_list[i].length() <= shortest.length()) {
|
|
shortest = hit_list[i]; // Prioritize parent.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (shortest != "") {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (shortest == "") {
|
|
return -1;
|
|
}
|
|
|
|
return skeleton->find_bone(shortest);
|
|
}
|
|
|
|
BoneMapper::BoneSegregation BoneMapper::guess_bone_segregation(String p_bone_name) {
|
|
String fixed_bn = p_bone_name.to_snake_case();
|
|
|
|
LocalVector<String> left_words;
|
|
left_words.push_back("(?<![a-zA-Z])left");
|
|
left_words.push_back("(?<![a-zA-Z0-9])l(?![a-zA-Z0-9])");
|
|
|
|
LocalVector<String> right_words;
|
|
right_words.push_back("(?<![a-zA-Z])right");
|
|
right_words.push_back("(?<![a-zA-Z0-9])r(?![a-zA-Z0-9])");
|
|
|
|
for (uint32_t i = 0; i < left_words.size(); i++) {
|
|
RegEx re_l = RegEx(left_words[i]);
|
|
if (!re_l.search(fixed_bn).is_null()) {
|
|
return BONE_SEGREGATION_LEFT;
|
|
}
|
|
RegEx re_r = RegEx(right_words[i]);
|
|
if (!re_r.search(fixed_bn).is_null()) {
|
|
return BONE_SEGREGATION_RIGHT;
|
|
}
|
|
}
|
|
|
|
return BONE_SEGREGATION_NONE;
|
|
}
|
|
|
|
void BoneMapper::_run_auto_mapping() {
|
|
auto_mapping_process(bone_map);
|
|
recreate_items();
|
|
}
|
|
|
|
void BoneMapper::auto_mapping_process(Ref<BoneMap> &p_bone_map) {
|
|
WARN_PRINT("Run auto mapping.");
|
|
|
|
int bone_idx = -1;
|
|
Vector<String> picklist; // Use Vector<String> because match words have priority.
|
|
Vector<int> search_path;
|
|
|
|
// 1. Guess Hips
|
|
picklist.push_back("hip");
|
|
picklist.push_back("pelvis");
|
|
picklist.push_back("waist");
|
|
picklist.push_back("torso");
|
|
int hips = search_bone_by_name(skeleton, picklist);
|
|
if (hips == -1) {
|
|
WARN_PRINT("Auto Mapping couldn't guess Hips. Abort auto mapping.");
|
|
return; // If there is no Hips, we cannot guess bone after then.
|
|
} else {
|
|
p_bone_map->_set_skeleton_bone_name("Hips", skeleton->get_bone_name(hips));
|
|
}
|
|
picklist.clear();
|
|
|
|
// 2. Guess Root
|
|
bone_idx = skeleton->get_bone_parent(hips);
|
|
while (bone_idx >= 0) {
|
|
search_path.push_back(bone_idx);
|
|
bone_idx = skeleton->get_bone_parent(bone_idx);
|
|
}
|
|
if (search_path.size() == 0) {
|
|
bone_idx = -1;
|
|
} else if (search_path.size() == 1) {
|
|
bone_idx = search_path[0]; // It is only one bone which can be root.
|
|
} else {
|
|
bool found = false;
|
|
for (int i = 0; i < search_path.size(); i++) {
|
|
RegEx re = RegEx("root");
|
|
if (!re.search(skeleton->get_bone_name(search_path[i]).to_lower()).is_null()) {
|
|
bone_idx = search_path[i]; // Name match is preferred.
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!found) {
|
|
for (int i = 0; i < search_path.size(); i++) {
|
|
if (skeleton->get_bone_global_rest(search_path[i]).origin.is_zero_approx()) {
|
|
bone_idx = search_path[i]; // The bone existing at the origin is appropriate as a root.
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!found) {
|
|
bone_idx = search_path[search_path.size() - 1]; // Ambiguous, but most parental bone selected.
|
|
}
|
|
}
|
|
if (bone_idx == -1) {
|
|
WARN_PRINT("Auto Mapping couldn't guess Root."); // Root is not required, so continue.
|
|
} else {
|
|
p_bone_map->_set_skeleton_bone_name("Root", skeleton->get_bone_name(bone_idx));
|
|
}
|
|
bone_idx = -1;
|
|
search_path.clear();
|
|
|
|
// 3. Guess Neck
|
|
picklist.push_back("neck");
|
|
picklist.push_back("head"); // For no neck model.
|
|
picklist.push_back("face"); // Same above.
|
|
int neck = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_NONE, hips);
|
|
picklist.clear();
|
|
|
|
// 4. Guess Head
|
|
picklist.push_back("head");
|
|
picklist.push_back("face");
|
|
int head = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_NONE, neck);
|
|
if (head == -1) {
|
|
search_path = skeleton->get_bone_children(neck);
|
|
if (search_path.size() == 1) {
|
|
head = search_path[0]; // Maybe only one child of the Neck is Head.
|
|
}
|
|
}
|
|
if (head == -1) {
|
|
if (neck != -1) {
|
|
head = neck; // The head animation should have more movement.
|
|
neck = -1;
|
|
p_bone_map->_set_skeleton_bone_name("Head", skeleton->get_bone_name(head));
|
|
} else {
|
|
WARN_PRINT("Auto Mapping couldn't guess Neck or Head."); // Continued for guessing on the other bones. But abort when guessing spines step.
|
|
}
|
|
} else {
|
|
p_bone_map->_set_skeleton_bone_name("Neck", skeleton->get_bone_name(neck));
|
|
p_bone_map->_set_skeleton_bone_name("Head", skeleton->get_bone_name(head));
|
|
}
|
|
picklist.clear();
|
|
search_path.clear();
|
|
|
|
int neck_or_head = neck != -1 ? neck : (head != -1 ? head : -1);
|
|
if (neck_or_head != -1) {
|
|
// 4-1. Guess Eyes
|
|
picklist.push_back("eye(?!.*(brow|lash|lid))");
|
|
bone_idx = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_LEFT, neck_or_head);
|
|
if (bone_idx == -1) {
|
|
WARN_PRINT("Auto Mapping couldn't guess LeftEye.");
|
|
} else {
|
|
p_bone_map->_set_skeleton_bone_name("LeftEye", skeleton->get_bone_name(bone_idx));
|
|
}
|
|
|
|
bone_idx = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_RIGHT, neck_or_head);
|
|
if (bone_idx == -1) {
|
|
WARN_PRINT("Auto Mapping couldn't guess RightEye.");
|
|
} else {
|
|
p_bone_map->_set_skeleton_bone_name("RightEye", skeleton->get_bone_name(bone_idx));
|
|
}
|
|
picklist.clear();
|
|
|
|
// 4-2. Guess Jaw
|
|
picklist.push_back("jaw");
|
|
bone_idx = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_NONE, neck_or_head);
|
|
if (bone_idx == -1) {
|
|
WARN_PRINT("Auto Mapping couldn't guess Jaw.");
|
|
} else {
|
|
p_bone_map->_set_skeleton_bone_name("Jaw", skeleton->get_bone_name(bone_idx));
|
|
}
|
|
bone_idx = -1;
|
|
picklist.clear();
|
|
}
|
|
|
|
// 5. Guess Foots
|
|
picklist.push_back("foot");
|
|
picklist.push_back("ankle");
|
|
int left_foot = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_LEFT, hips);
|
|
if (left_foot == -1) {
|
|
WARN_PRINT("Auto Mapping couldn't guess LeftFoot.");
|
|
} else {
|
|
p_bone_map->_set_skeleton_bone_name("LeftFoot", skeleton->get_bone_name(left_foot));
|
|
}
|
|
int right_foot = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_RIGHT, hips);
|
|
if (right_foot == -1) {
|
|
WARN_PRINT("Auto Mapping couldn't guess RightFoot.");
|
|
} else {
|
|
p_bone_map->_set_skeleton_bone_name("RightFoot", skeleton->get_bone_name(right_foot));
|
|
}
|
|
picklist.clear();
|
|
|
|
// 5-1. Guess LowerLegs
|
|
picklist.push_back("(low|under).*leg");
|
|
picklist.push_back("knee");
|
|
picklist.push_back("shin");
|
|
picklist.push_back("calf");
|
|
picklist.push_back("leg");
|
|
int left_lower_leg = -1;
|
|
if (left_foot != -1) {
|
|
left_lower_leg = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_LEFT, hips, left_foot);
|
|
}
|
|
if (left_lower_leg == -1) {
|
|
WARN_PRINT("Auto Mapping couldn't guess LeftLowerLeg.");
|
|
} else {
|
|
p_bone_map->_set_skeleton_bone_name("LeftLowerLeg", skeleton->get_bone_name(left_lower_leg));
|
|
}
|
|
int right_lower_leg = -1;
|
|
if (right_foot != -1) {
|
|
right_lower_leg = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_RIGHT, hips, right_foot);
|
|
}
|
|
if (right_lower_leg == -1) {
|
|
WARN_PRINT("Auto Mapping couldn't guess RightLowerLeg.");
|
|
} else {
|
|
p_bone_map->_set_skeleton_bone_name("RightLowerLeg", skeleton->get_bone_name(right_lower_leg));
|
|
}
|
|
picklist.clear();
|
|
|
|
// 5-2. Guess UpperLegs
|
|
picklist.push_back("up.*leg");
|
|
picklist.push_back("thigh");
|
|
picklist.push_back("leg");
|
|
if (left_lower_leg != -1) {
|
|
bone_idx = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_LEFT, hips, left_lower_leg);
|
|
}
|
|
if (bone_idx == -1) {
|
|
WARN_PRINT("Auto Mapping couldn't guess LeftUpperLeg.");
|
|
} else {
|
|
p_bone_map->_set_skeleton_bone_name("LeftUpperLeg", skeleton->get_bone_name(bone_idx));
|
|
}
|
|
bone_idx = -1;
|
|
if (right_lower_leg != -1) {
|
|
bone_idx = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_RIGHT, hips, right_lower_leg);
|
|
}
|
|
if (bone_idx == -1) {
|
|
WARN_PRINT("Auto Mapping couldn't guess RightUpperLeg.");
|
|
} else {
|
|
p_bone_map->_set_skeleton_bone_name("RightUpperLeg", skeleton->get_bone_name(bone_idx));
|
|
}
|
|
bone_idx = -1;
|
|
picklist.clear();
|
|
|
|
// 5-3. Guess Toes
|
|
picklist.push_back("toe");
|
|
picklist.push_back("ball");
|
|
if (left_foot != -1) {
|
|
bone_idx = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_LEFT, left_foot);
|
|
if (bone_idx == -1) {
|
|
search_path = skeleton->get_bone_children(left_foot);
|
|
if (search_path.size() == 1) {
|
|
bone_idx = search_path[0]; // Maybe only one child of the Foot is Toes.
|
|
}
|
|
search_path.clear();
|
|
}
|
|
}
|
|
if (bone_idx == -1) {
|
|
WARN_PRINT("Auto Mapping couldn't guess LeftToes.");
|
|
} else {
|
|
p_bone_map->_set_skeleton_bone_name("LeftToes", skeleton->get_bone_name(bone_idx));
|
|
}
|
|
bone_idx = -1;
|
|
if (right_foot != -1) {
|
|
bone_idx = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_RIGHT, right_foot);
|
|
if (bone_idx == -1) {
|
|
search_path = skeleton->get_bone_children(right_foot);
|
|
if (search_path.size() == 1) {
|
|
bone_idx = search_path[0]; // Maybe only one child of the Foot is Toes.
|
|
}
|
|
search_path.clear();
|
|
}
|
|
}
|
|
if (bone_idx == -1) {
|
|
WARN_PRINT("Auto Mapping couldn't guess RightToes.");
|
|
} else {
|
|
p_bone_map->_set_skeleton_bone_name("RightToes", skeleton->get_bone_name(bone_idx));
|
|
}
|
|
bone_idx = -1;
|
|
picklist.clear();
|
|
|
|
// 6. Guess Hands
|
|
picklist.push_back("hand");
|
|
picklist.push_back("wrist");
|
|
picklist.push_back("palm");
|
|
picklist.push_back("fingers");
|
|
int left_hand_or_palm = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_LEFT, hips, -1, 5);
|
|
if (left_hand_or_palm == -1) {
|
|
// Ambiguous, but try again for fewer finger models.
|
|
left_hand_or_palm = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_LEFT, hips);
|
|
}
|
|
int left_hand = left_hand_or_palm; // Check for the presence of a wrist, since bones with five children may be palmar.
|
|
while (left_hand != -1) {
|
|
bone_idx = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_LEFT, hips, left_hand);
|
|
if (bone_idx == -1) {
|
|
break;
|
|
}
|
|
left_hand = bone_idx;
|
|
}
|
|
if (left_hand == -1) {
|
|
WARN_PRINT("Auto Mapping couldn't guess LeftHand.");
|
|
} else {
|
|
p_bone_map->_set_skeleton_bone_name("LeftHand", skeleton->get_bone_name(left_hand));
|
|
}
|
|
bone_idx = -1;
|
|
int right_hand_or_palm = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_RIGHT, hips, -1, 5);
|
|
if (right_hand_or_palm == -1) {
|
|
// Ambiguous, but try again for fewer finger models.
|
|
right_hand_or_palm = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_RIGHT, hips);
|
|
}
|
|
int right_hand = right_hand_or_palm;
|
|
while (right_hand != -1) {
|
|
bone_idx = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_RIGHT, hips, right_hand);
|
|
if (bone_idx == -1) {
|
|
break;
|
|
}
|
|
right_hand = bone_idx;
|
|
}
|
|
if (right_hand == -1) {
|
|
WARN_PRINT("Auto Mapping couldn't guess RightHand.");
|
|
} else {
|
|
p_bone_map->_set_skeleton_bone_name("RightHand", skeleton->get_bone_name(right_hand));
|
|
}
|
|
bone_idx = -1;
|
|
picklist.clear();
|
|
|
|
// 6-1. Guess Finger
|
|
bool named_finger_is_found = false;
|
|
LocalVector<String> fingers;
|
|
fingers.push_back("thumb|pollex");
|
|
fingers.push_back("index|fore");
|
|
fingers.push_back("middle");
|
|
fingers.push_back("ring");
|
|
fingers.push_back("little|pinkie|pinky");
|
|
if (left_hand_or_palm != -1) {
|
|
LocalVector<LocalVector<String>> left_fingers_map;
|
|
left_fingers_map.resize(5);
|
|
left_fingers_map[0].push_back("LeftThumbMetacarpal");
|
|
left_fingers_map[0].push_back("LeftThumbProximal");
|
|
left_fingers_map[0].push_back("LeftThumbDistal");
|
|
left_fingers_map[1].push_back("LeftIndexProximal");
|
|
left_fingers_map[1].push_back("LeftIndexIntermediate");
|
|
left_fingers_map[1].push_back("LeftIndexDistal");
|
|
left_fingers_map[2].push_back("LeftMiddleProximal");
|
|
left_fingers_map[2].push_back("LeftMiddleIntermediate");
|
|
left_fingers_map[2].push_back("LeftMiddleDistal");
|
|
left_fingers_map[3].push_back("LeftRingProximal");
|
|
left_fingers_map[3].push_back("LeftRingIntermediate");
|
|
left_fingers_map[3].push_back("LeftRingDistal");
|
|
left_fingers_map[4].push_back("LeftLittleProximal");
|
|
left_fingers_map[4].push_back("LeftLittleIntermediate");
|
|
left_fingers_map[4].push_back("LeftLittleDistal");
|
|
for (int i = 0; i < 5; i++) {
|
|
picklist.push_back(fingers[i]);
|
|
int finger = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_LEFT, left_hand_or_palm, -1, 0);
|
|
if (finger != -1) {
|
|
while (finger != left_hand_or_palm && finger >= 0) {
|
|
search_path.push_back(finger);
|
|
finger = skeleton->get_bone_parent(finger);
|
|
}
|
|
search_path.reverse();
|
|
if (search_path.size() == 1) {
|
|
p_bone_map->_set_skeleton_bone_name(left_fingers_map[i][0], skeleton->get_bone_name(search_path[0]));
|
|
named_finger_is_found = true;
|
|
} else if (search_path.size() == 2) {
|
|
p_bone_map->_set_skeleton_bone_name(left_fingers_map[i][0], skeleton->get_bone_name(search_path[0]));
|
|
p_bone_map->_set_skeleton_bone_name(left_fingers_map[i][1], skeleton->get_bone_name(search_path[1]));
|
|
named_finger_is_found = true;
|
|
} else if (search_path.size() >= 3) {
|
|
search_path = search_path.slice(-3); // Eliminate the possibility of carpal bone.
|
|
p_bone_map->_set_skeleton_bone_name(left_fingers_map[i][0], skeleton->get_bone_name(search_path[0]));
|
|
p_bone_map->_set_skeleton_bone_name(left_fingers_map[i][1], skeleton->get_bone_name(search_path[1]));
|
|
p_bone_map->_set_skeleton_bone_name(left_fingers_map[i][2], skeleton->get_bone_name(search_path[2]));
|
|
named_finger_is_found = true;
|
|
}
|
|
}
|
|
picklist.clear();
|
|
search_path.clear();
|
|
}
|
|
|
|
// It is a bit corner case, but possibly the finger names are sequentially numbered...
|
|
if (!named_finger_is_found) {
|
|
picklist.push_back("finger");
|
|
RegEx finger_re = RegEx("finger");
|
|
search_path = skeleton->get_bone_children(left_hand_or_palm);
|
|
Vector<String> finger_names;
|
|
for (int i = 0; i < search_path.size(); i++) {
|
|
String bn = skeleton->get_bone_name(search_path[i]);
|
|
if (!finger_re.search(bn.to_lower()).is_null()) {
|
|
finger_names.push_back(bn);
|
|
}
|
|
}
|
|
finger_names.sort(); // Order by lexicographic, normal use cases never have more than 10 fingers in one hand.
|
|
search_path.clear();
|
|
for (int i = 0; i < finger_names.size(); i++) {
|
|
if (i >= 5) {
|
|
break;
|
|
}
|
|
int finger_root = skeleton->find_bone(finger_names[i]);
|
|
int finger = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_LEFT, finger_root, -1, 0);
|
|
if (finger != -1) {
|
|
while (finger != finger_root && finger >= 0) {
|
|
search_path.push_back(finger);
|
|
finger = skeleton->get_bone_parent(finger);
|
|
}
|
|
}
|
|
search_path.push_back(finger_root);
|
|
search_path.reverse();
|
|
if (search_path.size() == 1) {
|
|
p_bone_map->_set_skeleton_bone_name(left_fingers_map[i][0], skeleton->get_bone_name(search_path[0]));
|
|
} else if (search_path.size() == 2) {
|
|
p_bone_map->_set_skeleton_bone_name(left_fingers_map[i][0], skeleton->get_bone_name(search_path[0]));
|
|
p_bone_map->_set_skeleton_bone_name(left_fingers_map[i][1], skeleton->get_bone_name(search_path[1]));
|
|
} else if (search_path.size() >= 3) {
|
|
search_path = search_path.slice(-3); // Eliminate the possibility of carpal bone.
|
|
p_bone_map->_set_skeleton_bone_name(left_fingers_map[i][0], skeleton->get_bone_name(search_path[0]));
|
|
p_bone_map->_set_skeleton_bone_name(left_fingers_map[i][1], skeleton->get_bone_name(search_path[1]));
|
|
p_bone_map->_set_skeleton_bone_name(left_fingers_map[i][2], skeleton->get_bone_name(search_path[2]));
|
|
}
|
|
search_path.clear();
|
|
}
|
|
picklist.clear();
|
|
}
|
|
}
|
|
named_finger_is_found = false;
|
|
if (right_hand_or_palm != -1) {
|
|
LocalVector<LocalVector<String>> right_fingers_map;
|
|
right_fingers_map.resize(5);
|
|
right_fingers_map[0].push_back("RightThumbMetacarpal");
|
|
right_fingers_map[0].push_back("RightThumbProximal");
|
|
right_fingers_map[0].push_back("RightThumbDistal");
|
|
right_fingers_map[1].push_back("RightIndexProximal");
|
|
right_fingers_map[1].push_back("RightIndexIntermediate");
|
|
right_fingers_map[1].push_back("RightIndexDistal");
|
|
right_fingers_map[2].push_back("RightMiddleProximal");
|
|
right_fingers_map[2].push_back("RightMiddleIntermediate");
|
|
right_fingers_map[2].push_back("RightMiddleDistal");
|
|
right_fingers_map[3].push_back("RightRingProximal");
|
|
right_fingers_map[3].push_back("RightRingIntermediate");
|
|
right_fingers_map[3].push_back("RightRingDistal");
|
|
right_fingers_map[4].push_back("RightLittleProximal");
|
|
right_fingers_map[4].push_back("RightLittleIntermediate");
|
|
right_fingers_map[4].push_back("RightLittleDistal");
|
|
for (int i = 0; i < 5; i++) {
|
|
picklist.push_back(fingers[i]);
|
|
int finger = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_RIGHT, right_hand_or_palm, -1, 0);
|
|
if (finger != -1) {
|
|
while (finger != right_hand_or_palm && finger >= 0) {
|
|
search_path.push_back(finger);
|
|
finger = skeleton->get_bone_parent(finger);
|
|
}
|
|
search_path.reverse();
|
|
if (search_path.size() == 1) {
|
|
p_bone_map->_set_skeleton_bone_name(right_fingers_map[i][0], skeleton->get_bone_name(search_path[0]));
|
|
named_finger_is_found = true;
|
|
} else if (search_path.size() == 2) {
|
|
p_bone_map->_set_skeleton_bone_name(right_fingers_map[i][0], skeleton->get_bone_name(search_path[0]));
|
|
p_bone_map->_set_skeleton_bone_name(right_fingers_map[i][1], skeleton->get_bone_name(search_path[1]));
|
|
named_finger_is_found = true;
|
|
} else if (search_path.size() >= 3) {
|
|
search_path = search_path.slice(-3); // Eliminate the possibility of carpal bone.
|
|
p_bone_map->_set_skeleton_bone_name(right_fingers_map[i][0], skeleton->get_bone_name(search_path[0]));
|
|
p_bone_map->_set_skeleton_bone_name(right_fingers_map[i][1], skeleton->get_bone_name(search_path[1]));
|
|
p_bone_map->_set_skeleton_bone_name(right_fingers_map[i][2], skeleton->get_bone_name(search_path[2]));
|
|
named_finger_is_found = true;
|
|
}
|
|
}
|
|
picklist.clear();
|
|
search_path.clear();
|
|
}
|
|
|
|
// It is a bit corner case, but possibly the finger names are sequentially numbered...
|
|
if (!named_finger_is_found) {
|
|
picklist.push_back("finger");
|
|
RegEx finger_re = RegEx("finger");
|
|
search_path = skeleton->get_bone_children(right_hand_or_palm);
|
|
Vector<String> finger_names;
|
|
for (int i = 0; i < search_path.size(); i++) {
|
|
String bn = skeleton->get_bone_name(search_path[i]);
|
|
if (!finger_re.search(bn.to_lower()).is_null()) {
|
|
finger_names.push_back(bn);
|
|
}
|
|
}
|
|
finger_names.sort(); // Order by lexicographic, normal use cases never have more than 10 fingers in one hand.
|
|
search_path.clear();
|
|
for (int i = 0; i < finger_names.size(); i++) {
|
|
if (i >= 5) {
|
|
break;
|
|
}
|
|
int finger_root = skeleton->find_bone(finger_names[i]);
|
|
int finger = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_RIGHT, finger_root, -1, 0);
|
|
if (finger != -1) {
|
|
while (finger != finger_root && finger >= 0) {
|
|
search_path.push_back(finger);
|
|
finger = skeleton->get_bone_parent(finger);
|
|
}
|
|
}
|
|
search_path.push_back(finger_root);
|
|
search_path.reverse();
|
|
if (search_path.size() == 1) {
|
|
p_bone_map->_set_skeleton_bone_name(right_fingers_map[i][0], skeleton->get_bone_name(search_path[0]));
|
|
} else if (search_path.size() == 2) {
|
|
p_bone_map->_set_skeleton_bone_name(right_fingers_map[i][0], skeleton->get_bone_name(search_path[0]));
|
|
p_bone_map->_set_skeleton_bone_name(right_fingers_map[i][1], skeleton->get_bone_name(search_path[1]));
|
|
} else if (search_path.size() >= 3) {
|
|
search_path = search_path.slice(-3); // Eliminate the possibility of carpal bone.
|
|
p_bone_map->_set_skeleton_bone_name(right_fingers_map[i][0], skeleton->get_bone_name(search_path[0]));
|
|
p_bone_map->_set_skeleton_bone_name(right_fingers_map[i][1], skeleton->get_bone_name(search_path[1]));
|
|
p_bone_map->_set_skeleton_bone_name(right_fingers_map[i][2], skeleton->get_bone_name(search_path[2]));
|
|
}
|
|
search_path.clear();
|
|
}
|
|
picklist.clear();
|
|
}
|
|
}
|
|
|
|
// 7. Guess Arms
|
|
picklist.push_back("shoulder");
|
|
picklist.push_back("clavicle");
|
|
picklist.push_back("collar");
|
|
int left_shoulder = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_LEFT, hips);
|
|
if (left_shoulder == -1) {
|
|
WARN_PRINT("Auto Mapping couldn't guess LeftShoulder.");
|
|
} else {
|
|
p_bone_map->_set_skeleton_bone_name("LeftShoulder", skeleton->get_bone_name(left_shoulder));
|
|
}
|
|
int right_shoulder = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_RIGHT, hips);
|
|
if (right_shoulder == -1) {
|
|
WARN_PRINT("Auto Mapping couldn't guess RightShoulder.");
|
|
} else {
|
|
p_bone_map->_set_skeleton_bone_name("RightShoulder", skeleton->get_bone_name(right_shoulder));
|
|
}
|
|
picklist.clear();
|
|
|
|
// 7-1. Guess LowerArms
|
|
picklist.push_back("(low|fore).*arm");
|
|
picklist.push_back("elbow");
|
|
picklist.push_back("arm");
|
|
int left_lower_arm = -1;
|
|
if (left_shoulder != -1 && left_hand_or_palm != -1) {
|
|
left_lower_arm = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_LEFT, left_shoulder, left_hand_or_palm);
|
|
}
|
|
if (left_lower_arm == -1) {
|
|
WARN_PRINT("Auto Mapping couldn't guess LeftLowerArm.");
|
|
} else {
|
|
p_bone_map->_set_skeleton_bone_name("LeftLowerArm", skeleton->get_bone_name(left_lower_arm));
|
|
}
|
|
int right_lower_arm = -1;
|
|
if (right_shoulder != -1 && right_hand_or_palm != -1) {
|
|
right_lower_arm = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_RIGHT, right_shoulder, right_hand_or_palm);
|
|
}
|
|
if (right_lower_arm == -1) {
|
|
WARN_PRINT("Auto Mapping couldn't guess RightLowerArm.");
|
|
} else {
|
|
p_bone_map->_set_skeleton_bone_name("RightLowerArm", skeleton->get_bone_name(right_lower_arm));
|
|
}
|
|
picklist.clear();
|
|
|
|
// 7-2. Guess UpperArms
|
|
picklist.push_back("up.*arm");
|
|
picklist.push_back("arm");
|
|
if (left_shoulder != -1 && left_lower_arm != -1) {
|
|
bone_idx = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_LEFT, left_shoulder, left_lower_arm);
|
|
}
|
|
if (bone_idx == -1) {
|
|
WARN_PRINT("Auto Mapping couldn't guess LeftUpperArm.");
|
|
} else {
|
|
p_bone_map->_set_skeleton_bone_name("LeftUpperArm", skeleton->get_bone_name(bone_idx));
|
|
}
|
|
bone_idx = -1;
|
|
if (right_shoulder != -1 && right_lower_arm != -1) {
|
|
bone_idx = search_bone_by_name(skeleton, picklist, BONE_SEGREGATION_RIGHT, right_shoulder, right_lower_arm);
|
|
}
|
|
if (bone_idx == -1) {
|
|
WARN_PRINT("Auto Mapping couldn't guess RightUpperArm.");
|
|
} else {
|
|
p_bone_map->_set_skeleton_bone_name("RightUpperArm", skeleton->get_bone_name(bone_idx));
|
|
}
|
|
bone_idx = -1;
|
|
picklist.clear();
|
|
|
|
// 8. Guess UpperChest or Chest
|
|
if (neck_or_head == -1) {
|
|
return; // Abort.
|
|
}
|
|
int chest_or_upper_chest = skeleton->get_bone_parent(neck_or_head);
|
|
bool is_appropriate = true;
|
|
if (left_shoulder != -1) {
|
|
bone_idx = skeleton->get_bone_parent(left_shoulder);
|
|
bool detect = false;
|
|
while (bone_idx != hips && bone_idx >= 0) {
|
|
if (bone_idx == chest_or_upper_chest) {
|
|
detect = true;
|
|
break;
|
|
}
|
|
bone_idx = skeleton->get_bone_parent(bone_idx);
|
|
}
|
|
if (!detect) {
|
|
is_appropriate = false;
|
|
}
|
|
bone_idx = -1;
|
|
}
|
|
if (right_shoulder != -1) {
|
|
bone_idx = skeleton->get_bone_parent(right_shoulder);
|
|
bool detect = false;
|
|
while (bone_idx != hips && bone_idx >= 0) {
|
|
if (bone_idx == chest_or_upper_chest) {
|
|
detect = true;
|
|
break;
|
|
}
|
|
bone_idx = skeleton->get_bone_parent(bone_idx);
|
|
}
|
|
if (!detect) {
|
|
is_appropriate = false;
|
|
}
|
|
bone_idx = -1;
|
|
}
|
|
if (!is_appropriate) {
|
|
if (skeleton->get_bone_parent(left_shoulder) == skeleton->get_bone_parent(right_shoulder)) {
|
|
chest_or_upper_chest = skeleton->get_bone_parent(left_shoulder);
|
|
} else {
|
|
chest_or_upper_chest = -1;
|
|
}
|
|
}
|
|
if (chest_or_upper_chest == -1) {
|
|
WARN_PRINT("Auto Mapping couldn't guess Chest or UpperChest. Abort auto mapping.");
|
|
return; // Will be not able to guess Spines.
|
|
}
|
|
|
|
// 9. Guess Spines
|
|
bone_idx = skeleton->get_bone_parent(chest_or_upper_chest);
|
|
while (bone_idx != hips && bone_idx >= 0) {
|
|
search_path.push_back(bone_idx);
|
|
bone_idx = skeleton->get_bone_parent(bone_idx);
|
|
}
|
|
search_path.reverse();
|
|
if (search_path.size() == 0) {
|
|
p_bone_map->_set_skeleton_bone_name("Spine", skeleton->get_bone_name(chest_or_upper_chest)); // Maybe chibi model...?
|
|
} else if (search_path.size() == 1) {
|
|
p_bone_map->_set_skeleton_bone_name("Spine", skeleton->get_bone_name(search_path[0]));
|
|
p_bone_map->_set_skeleton_bone_name("Chest", skeleton->get_bone_name(chest_or_upper_chest));
|
|
} else if (search_path.size() >= 2) {
|
|
p_bone_map->_set_skeleton_bone_name("Spine", skeleton->get_bone_name(search_path[0]));
|
|
p_bone_map->_set_skeleton_bone_name("Chest", skeleton->get_bone_name(search_path[search_path.size() - 1])); // Probably UppeChest's parent is appropriate.
|
|
p_bone_map->_set_skeleton_bone_name("UpperChest", skeleton->get_bone_name(chest_or_upper_chest));
|
|
}
|
|
bone_idx = -1;
|
|
search_path.clear();
|
|
|
|
WARN_PRINT("Finish auto mapping.");
|
|
}
|
|
#endif // MODULE_REGEX_ENABLED
|
|
|
|
void BoneMapper::_value_changed(const String &p_property, Variant p_value, const String &p_name, bool p_changing) {
|
|
set(p_property, p_value);
|
|
recreate_editor();
|
|
}
|
|
|
|
void BoneMapper::_profile_changed(const String &p_property, Variant p_value, const String &p_name, bool p_changing) {
|
|
bone_map->set(p_property, p_value);
|
|
|
|
// Run auto mapping when setting SkeletonProfileHumanoid by GUI Editor.
|
|
Ref<SkeletonProfile> profile = bone_map->get_profile();
|
|
if (profile.is_valid()) {
|
|
SkeletonProfileHumanoid *hmn = Object::cast_to<SkeletonProfileHumanoid>(profile.ptr());
|
|
if (hmn) {
|
|
#ifdef MODULE_REGEX_ENABLED
|
|
_run_auto_mapping();
|
|
#endif // MODULE_REGEX_ENABLED
|
|
}
|
|
}
|
|
}
|
|
|
|
void BoneMapper::_bind_methods() {
|
|
ClassDB::bind_method(D_METHOD("set_current_group_idx", "current_group_idx"), &BoneMapper::set_current_group_idx);
|
|
ClassDB::bind_method(D_METHOD("get_current_group_idx"), &BoneMapper::get_current_group_idx);
|
|
ClassDB::bind_method(D_METHOD("set_current_bone_idx", "current_bone_idx"), &BoneMapper::set_current_bone_idx);
|
|
ClassDB::bind_method(D_METHOD("get_current_bone_idx"), &BoneMapper::get_current_bone_idx);
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "current_group_idx"), "set_current_group_idx", "get_current_group_idx");
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "current_bone_idx"), "set_current_bone_idx", "get_current_bone_idx");
|
|
}
|
|
|
|
void BoneMapper::_notification(int p_what) {
|
|
switch (p_what) {
|
|
case NOTIFICATION_ENTER_TREE: {
|
|
create_editor();
|
|
bone_map->connect("bone_map_updated", callable_mp(this, &BoneMapper::_update_state));
|
|
bone_map->connect("profile_updated", callable_mp(this, &BoneMapper::recreate_items));
|
|
} break;
|
|
case NOTIFICATION_EXIT_TREE: {
|
|
clear_items();
|
|
if (!bone_map.is_null()) {
|
|
if (bone_map->is_connected("bone_map_updated", callable_mp(this, &BoneMapper::_update_state))) {
|
|
bone_map->disconnect("bone_map_updated", callable_mp(this, &BoneMapper::_update_state));
|
|
}
|
|
if (bone_map->is_connected("profile_updated", callable_mp(this, &BoneMapper::recreate_items))) {
|
|
bone_map->disconnect("profile_updated", callable_mp(this, &BoneMapper::recreate_items));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
BoneMapper::BoneMapper(Skeleton3D *p_skeleton, Ref<BoneMap> &p_bone_map) {
|
|
skeleton = p_skeleton;
|
|
bone_map = p_bone_map;
|
|
}
|
|
|
|
BoneMapper::~BoneMapper() {
|
|
}
|
|
|
|
void BoneMapEditor::create_editors() {
|
|
if (!skeleton) {
|
|
return;
|
|
}
|
|
bone_mapper = memnew(BoneMapper(skeleton, bone_map));
|
|
add_child(bone_mapper);
|
|
}
|
|
|
|
void BoneMapEditor::fetch_objects() {
|
|
skeleton = nullptr;
|
|
// Hackey... but it may be the easiest way to get a selected object from "ImporterScene".
|
|
SceneImportSettings *si = SceneImportSettings::get_singleton();
|
|
if (!si) {
|
|
return;
|
|
}
|
|
if (!si->is_visible()) {
|
|
return;
|
|
}
|
|
Node *selected = si->get_selected_node();
|
|
if (selected) {
|
|
Skeleton3D *sk = Object::cast_to<Skeleton3D>(selected);
|
|
if (!sk) {
|
|
return;
|
|
}
|
|
skeleton = sk;
|
|
} else {
|
|
// Editor should not exist.
|
|
skeleton = nullptr;
|
|
}
|
|
}
|
|
|
|
void BoneMapEditor::_notification(int p_what) {
|
|
switch (p_what) {
|
|
case NOTIFICATION_ENTER_TREE: {
|
|
fetch_objects();
|
|
create_editors();
|
|
} break;
|
|
case NOTIFICATION_EXIT_TREE: {
|
|
skeleton = nullptr;
|
|
} break;
|
|
}
|
|
}
|
|
|
|
BoneMapEditor::BoneMapEditor(Ref<BoneMap> &p_bone_map) {
|
|
bone_map = p_bone_map;
|
|
}
|
|
|
|
BoneMapEditor::~BoneMapEditor() {
|
|
}
|
|
|
|
bool EditorInspectorPluginBoneMap::can_handle(Object *p_object) {
|
|
return Object::cast_to<BoneMap>(p_object) != nullptr;
|
|
}
|
|
|
|
void EditorInspectorPluginBoneMap::parse_begin(Object *p_object) {
|
|
BoneMap *bm = Object::cast_to<BoneMap>(p_object);
|
|
if (!bm) {
|
|
return;
|
|
}
|
|
Ref<BoneMap> r(bm);
|
|
editor = memnew(BoneMapEditor(r));
|
|
add_custom_control(editor);
|
|
}
|
|
|
|
BoneMapEditorPlugin::BoneMapEditorPlugin() {
|
|
// Register properties in editor settings.
|
|
EDITOR_DEF("editors/bone_mapper/handle_colors/unset", Color(0.3, 0.3, 0.3));
|
|
EDITOR_DEF("editors/bone_mapper/handle_colors/set", Color(0.1, 0.6, 0.25));
|
|
EDITOR_DEF("editors/bone_mapper/handle_colors/missing", Color(0.8, 0.2, 0.8));
|
|
EDITOR_DEF("editors/bone_mapper/handle_colors/error", Color(0.8, 0.2, 0.2));
|
|
|
|
Ref<EditorInspectorPluginBoneMap> inspector_plugin;
|
|
inspector_plugin.instantiate();
|
|
add_inspector_plugin(inspector_plugin);
|
|
|
|
Ref<PostImportPluginSkeletonTrackOrganizer> post_import_plugin_track_organizer;
|
|
post_import_plugin_track_organizer.instantiate();
|
|
add_scene_post_import_plugin(post_import_plugin_track_organizer);
|
|
|
|
Ref<PostImportPluginSkeletonRenamer> post_import_plugin_renamer;
|
|
post_import_plugin_renamer.instantiate();
|
|
add_scene_post_import_plugin(post_import_plugin_renamer);
|
|
|
|
Ref<PostImportPluginSkeletonRestFixer> post_import_plugin_rest_fixer;
|
|
post_import_plugin_rest_fixer.instantiate();
|
|
add_scene_post_import_plugin(post_import_plugin_rest_fixer);
|
|
}
|