godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Style: Fix issues that went past CI

This commit is contained in:
Rémi Verschelde 2018-08-21 21:28:06 +02:00
parent a319d72071
commit 404ee1a56b
13 changed files with 92 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
editor/plugins/animation_blend_space_1d_editor.cpp
View File

@ -4,11 +4,10 @@
#include "scene/animation/animation_blend_tree.h" #include "scene/animation/animation_blend_tree.h"
StringName AnimationNodeBlendSpace1DEditor::get_blend_position_path() const { StringName AnimationNodeBlendSpace1DEditor::get_blend_position_path() const {
StringName path = AnimationTreeEditor::get_singleton()->get_base_path()+"blend_position"; StringName path = AnimationTreeEditor::get_singleton()->get_base_path() + "blend_position";
return path; return path;
} }
void AnimationNodeBlendSpace1DEditor::_blend_space_gui_input(const Ref<InputEvent> &p_event) { void AnimationNodeBlendSpace1DEditor::_blend_space_gui_input(const Ref<InputEvent> &p_event) {
Ref<InputEventKey> k = p_event; Ref<InputEventKey> k = p_event;
@ -55,7 +54,7 @@ void AnimationNodeBlendSpace1DEditor::_blend_space_gui_input(const Ref<InputEven
continue; continue;
int idx = menu->get_item_count(); int idx = menu->get_item_count();
menu->add_item(vformat("Add %s", name),idx); menu->add_item(vformat("Add %s", name), idx);
menu->set_item_metadata(idx, E->get()); menu->set_item_metadata(idx, E->get());
} }
@ -136,7 +135,7 @@ void AnimationNodeBlendSpace1DEditor::_blend_space_gui_input(const Ref<InputEven
blend_pos *= blend_space->get_max_space() - blend_space->get_min_space(); blend_pos *= blend_space->get_max_space() - blend_space->get_min_space();
blend_pos += blend_space->get_min_space(); blend_pos += blend_space->get_min_space();
AnimationTreeEditor::get_singleton()->get_tree()->set(get_blend_position_path(),blend_pos); AnimationTreeEditor::get_singleton()->get_tree()->set(get_blend_position_path(), blend_pos);
blend_space_draw->update(); blend_space_draw->update();
} }
@ -159,7 +158,7 @@ void AnimationNodeBlendSpace1DEditor::_blend_space_gui_input(const Ref<InputEven
blend_pos *= blend_space->get_max_space() - blend_space->get_min_space(); blend_pos *= blend_space->get_max_space() - blend_space->get_min_space();
blend_pos += blend_space->get_min_space(); blend_pos += blend_space->get_min_space();
AnimationTreeEditor::get_singleton()->get_tree()->set(get_blend_position_path(),blend_pos); AnimationTreeEditor::get_singleton()->get_tree()->set(get_blend_position_path(), blend_pos);
blend_space_draw->update(); blend_space_draw->update();
} }
@ -258,7 +257,6 @@ void AnimationNodeBlendSpace1DEditor::_blend_space_draw() {
float point = AnimationTreeEditor::get_singleton()->get_tree()->get(get_blend_position_path()); float point = AnimationTreeEditor::get_singleton()->get_tree()->get(get_blend_position_path());
point = (point - blend_space->get_min_space()) / (blend_space->get_max_space() - blend_space->get_min_space()); point = (point - blend_space->get_min_space()) / (blend_space->get_max_space() - blend_space->get_min_space());
point *= s.width; point *= s.width;
@ -501,8 +499,6 @@ void AnimationNodeBlendSpace1DEditor::_open_editor() {
} }
} }
void AnimationNodeBlendSpace1DEditor::_notification(int p_what) { void AnimationNodeBlendSpace1DEditor::_notification(int p_what) {
if (p_what == NOTIFICATION_ENTER_TREE || p_what == NOTIFICATION_THEME_CHANGED) { if (p_what == NOTIFICATION_ENTER_TREE || p_what == NOTIFICATION_THEME_CHANGED) {
error_panel->add_style_override("panel", get_stylebox("bg", "Tree")); error_panel->add_style_override("panel", get_stylebox("bg", "Tree"));
@ -514,7 +510,6 @@ void AnimationNodeBlendSpace1DEditor::_notification(int p_what) {
tool_erase->set_icon(get_icon("Remove", "EditorIcons")); tool_erase->set_icon(get_icon("Remove", "EditorIcons"));
snap->set_icon(get_icon("SnapGrid", "EditorIcons")); snap->set_icon(get_icon("SnapGrid", "EditorIcons"));
open_editor->set_icon(get_icon("Edit", "EditorIcons")); open_editor->set_icon(get_icon("Edit", "EditorIcons"));
} }
if (p_what == NOTIFICATION_PROCESS) { if (p_what == NOTIFICATION_PROCESS) {
@ -536,7 +531,7 @@ void AnimationNodeBlendSpace1DEditor::_notification(int p_what) {
} }
} }
if (p_what==NOTIFICATION_VISIBILITY_CHANGED) { if (p_what == NOTIFICATION_VISIBILITY_CHANGED) {
set_process(is_visible_in_tree()); set_process(is_visible_in_tree());
} }
} }
@ -561,22 +556,17 @@ void AnimationNodeBlendSpace1DEditor::_bind_methods() {
ClassDB::bind_method("_open_editor", &AnimationNodeBlendSpace1DEditor::_open_editor); ClassDB::bind_method("_open_editor", &AnimationNodeBlendSpace1DEditor::_open_editor);
ClassDB::bind_method("_file_opened", &AnimationNodeBlendSpace1DEditor::_file_opened); ClassDB::bind_method("_file_opened", &AnimationNodeBlendSpace1DEditor::_file_opened);
} }
bool AnimationNodeBlendSpace1DEditor::can_edit(const Ref<AnimationNode> &p_node) { bool AnimationNodeBlendSpace1DEditor::can_edit(const Ref<AnimationNode> &p_node) {
Ref<AnimationNodeBlendSpace1D> b1d=p_node; Ref<AnimationNodeBlendSpace1D> b1d = p_node;
return b1d.is_valid(); return b1d.is_valid();
} }
void AnimationNodeBlendSpace1DEditor::edit(const Ref<AnimationNode> &p_node) { void AnimationNodeBlendSpace1DEditor::edit(const Ref<AnimationNode> &p_node) {
blend_space = p_node;
blend_space=p_node;
if (!blend_space.is_null()) { if (!blend_space.is_null()) {
_update_space(); _update_space();
@ -595,7 +585,6 @@ AnimationNodeBlendSpace1DEditor::AnimationNodeBlendSpace1DEditor() {
Ref<ButtonGroup> bg; Ref<ButtonGroup> bg;
bg.instance(); bg.instance();
tool_blend = memnew(ToolButton); tool_blend = memnew(ToolButton);
tool_blend->set_toggle_mode(true); tool_blend->set_toggle_mode(true);
tool_blend->set_button_group(bg); tool_blend->set_button_group(bg);

2
editor/plugins/animation_blend_space_1d_editor.h
View File

@ -3,13 +3,13 @@
#include "editor/editor_node.h" #include "editor/editor_node.h"
#include "editor/editor_plugin.h" #include "editor/editor_plugin.h"
#include "editor/plugins/animation_tree_editor_plugin.h"
#include "editor/property_editor.h" #include "editor/property_editor.h"
#include "scene/animation/animation_blend_space_1d.h" #include "scene/animation/animation_blend_space_1d.h"
#include "scene/gui/button.h" #include "scene/gui/button.h"
#include "scene/gui/graph_edit.h" #include "scene/gui/graph_edit.h"
#include "scene/gui/popup.h" #include "scene/gui/popup.h"
#include "scene/gui/tree.h" #include "scene/gui/tree.h"
#include "editor/plugins/animation_tree_editor_plugin.h"
class AnimationNodeBlendSpace1DEditor : public AnimationTreeNodeEditorPlugin { class AnimationNodeBlendSpace1DEditor : public AnimationTreeNodeEditorPlugin {

16
editor/plugins/animation_blend_space_2d_editor.cpp
View File

@ -13,7 +13,7 @@
bool AnimationNodeBlendSpace2DEditor::can_edit(const Ref<AnimationNode> &p_node) { bool AnimationNodeBlendSpace2DEditor::can_edit(const Ref<AnimationNode> &p_node) {
Ref<AnimationNodeBlendSpace2D> bs2d=p_node; Ref<AnimationNodeBlendSpace2D> bs2d = p_node;
return bs2d.is_valid(); return bs2d.is_valid();
} }
@ -27,7 +27,7 @@ void AnimationNodeBlendSpace2DEditor::edit(const Ref<AnimationNode> &p_node) {
} }
StringName AnimationNodeBlendSpace2DEditor::get_blend_position_path() const { StringName AnimationNodeBlendSpace2DEditor::get_blend_position_path() const {
StringName path = AnimationTreeEditor::get_singleton()->get_base_path()+"blend_position"; StringName path = AnimationTreeEditor::get_singleton()->get_base_path() + "blend_position";
return path; return path;
} }
@ -73,7 +73,7 @@ void AnimationNodeBlendSpace2DEditor::_blend_space_gui_input(const Ref<InputEven
if (name == "Animation") if (name == "Animation")
continue; // nope continue; // nope
int idx = menu->get_item_count(); int idx = menu->get_item_count();
menu->add_item(vformat("Add %s", name),idx); menu->add_item(vformat("Add %s", name), idx);
menu->set_item_metadata(idx, E->get()); menu->set_item_metadata(idx, E->get());
} }
@ -85,7 +85,6 @@ void AnimationNodeBlendSpace2DEditor::_blend_space_gui_input(const Ref<InputEven
menu->add_separator(); menu->add_separator();
menu->add_item(TTR("Load.."), MENU_LOAD_FILE); menu->add_item(TTR("Load.."), MENU_LOAD_FILE);
menu->set_global_position(blend_space_draw->get_global_transform().xform(mb->get_position())); menu->set_global_position(blend_space_draw->get_global_transform().xform(mb->get_position()));
menu->popup(); menu->popup();
add_point_pos = (mb->get_position() / blend_space_draw->get_size()); add_point_pos = (mb->get_position() / blend_space_draw->get_size());
@ -211,7 +210,7 @@ void AnimationNodeBlendSpace2DEditor::_blend_space_gui_input(const Ref<InputEven
blend_pos *= (blend_space->get_max_space() - blend_space->get_min_space()); blend_pos *= (blend_space->get_max_space() - blend_space->get_min_space());
blend_pos += blend_space->get_min_space(); blend_pos += blend_space->get_min_space();
AnimationTreeEditor::get_singleton()->get_tree()->set(get_blend_position_path(),blend_pos); AnimationTreeEditor::get_singleton()->get_tree()->set(get_blend_position_path(), blend_pos);
blend_space_draw->update(); blend_space_draw->update();
} }
@ -246,7 +245,7 @@ void AnimationNodeBlendSpace2DEditor::_blend_space_gui_input(const Ref<InputEven
blend_pos *= (blend_space->get_max_space() - blend_space->get_min_space()); blend_pos *= (blend_space->get_max_space() - blend_space->get_min_space());
blend_pos += blend_space->get_min_space(); blend_pos += blend_space->get_min_space();
AnimationTreeEditor::get_singleton()->get_tree()->set(get_blend_position_path(),blend_pos); AnimationTreeEditor::get_singleton()->get_tree()->set(get_blend_position_path(), blend_pos);
blend_space_draw->update(); blend_space_draw->update();
} }
@ -750,12 +749,11 @@ void AnimationNodeBlendSpace2DEditor::_notification(int p_what) {
} }
} }
if (p_what==NOTIFICATION_VISIBILITY_CHANGED) { if (p_what == NOTIFICATION_VISIBILITY_CHANGED) {
set_process(is_visible_in_tree()); set_process(is_visible_in_tree());
} }
} }
void AnimationNodeBlendSpace2DEditor::_open_editor() { void AnimationNodeBlendSpace2DEditor::_open_editor() {
if (selected_point >= 0 && selected_point < blend_space->get_blend_point_count()) { if (selected_point >= 0 && selected_point < blend_space->get_blend_point_count()) {
@ -804,7 +802,6 @@ void AnimationNodeBlendSpace2DEditor::_bind_methods() {
ClassDB::bind_method("_auto_triangles_toggled", &AnimationNodeBlendSpace2DEditor::_auto_triangles_toggled); ClassDB::bind_method("_auto_triangles_toggled", &AnimationNodeBlendSpace2DEditor::_auto_triangles_toggled);
ClassDB::bind_method("_file_opened", &AnimationNodeBlendSpace2DEditor::_file_opened); ClassDB::bind_method("_file_opened", &AnimationNodeBlendSpace2DEditor::_file_opened);
} }
AnimationNodeBlendSpace2DEditor *AnimationNodeBlendSpace2DEditor::singleton = NULL; AnimationNodeBlendSpace2DEditor *AnimationNodeBlendSpace2DEditor::singleton = NULL;
@ -1019,4 +1016,3 @@ AnimationNodeBlendSpace2DEditor::AnimationNodeBlendSpace2DEditor() {
dragging_selected = false; dragging_selected = false;
dragging_selected_attempt = false; dragging_selected_attempt = false;
} }

4
editor/plugins/animation_blend_space_2d_editor.h
View File

@ -3,13 +3,13 @@
#include "editor/editor_node.h" #include "editor/editor_node.h"
#include "editor/editor_plugin.h" #include "editor/editor_plugin.h"
#include "editor/plugins/animation_tree_editor_plugin.h"
#include "editor/property_editor.h" #include "editor/property_editor.h"
#include "scene/animation/animation_blend_space_2d.h" #include "scene/animation/animation_blend_space_2d.h"
#include "scene/gui/button.h" #include "scene/gui/button.h"
#include "scene/gui/graph_edit.h" #include "scene/gui/graph_edit.h"
#include "scene/gui/popup.h" #include "scene/gui/popup.h"
#include "scene/gui/tree.h" #include "scene/gui/tree.h"
#include "editor/plugins/animation_tree_editor_plugin.h"
/** /**
@author Juan Linietsky <reduzio@gmail.com> @author Juan Linietsky <reduzio@gmail.com>
*/ */
@ -20,7 +20,6 @@ class AnimationNodeBlendSpace2DEditor : public AnimationTreeNodeEditorPlugin {
Ref<AnimationNodeBlendSpace2D> blend_space; Ref<AnimationNodeBlendSpace2D> blend_space;
PanelContainer *panel; PanelContainer *panel;
ToolButton *tool_blend; ToolButton *tool_blend;
ToolButton *tool_select; ToolButton *tool_select;
@ -119,5 +118,4 @@ public:
AnimationNodeBlendSpace2DEditor(); AnimationNodeBlendSpace2DEditor();
}; };
#endif // ANIMATION_BLEND_SPACE_2D_EDITOR_H #endif // ANIMATION_BLEND_SPACE_2D_EDITOR_H

2
editor/spatial_editor_gizmos.cpp
View File

@ -3655,7 +3655,7 @@ void NavigationMeshSpatialGizmoPlugin::redraw(EditorSpatialGizmo *p_gizmo) {
p_gizmo->add_collision_segments(lines); p_gizmo->add_collision_segments(lines);
} }
////// //////
#define BODY_A_RADIUS 0.25 #define BODY_A_RADIUS 0.25
#define BODY_B_RADIUS 0.27 #define BODY_B_RADIUS 0.27

4
modules/mono/utils/thread_local.cpp
View File

@ -69,7 +69,7 @@ struct ThreadLocalStorage::Impl {
#define _CALLBACK_FUNC_ #define _CALLBACK_FUNC_
#endif #endif
Impl(void (_CALLBACK_FUNC_ *p_destr_callback_func)(void *)) { Impl(void(_CALLBACK_FUNC_ *p_destr_callback_func)(void *)) {
#ifdef WINDOWS_ENABLED #ifdef WINDOWS_ENABLED
dwFlsIndex = FlsAlloc(p_destr_callback_func); dwFlsIndex = FlsAlloc(p_destr_callback_func);
ERR_FAIL_COND(dwFlsIndex == FLS_OUT_OF_INDEXES); ERR_FAIL_COND(dwFlsIndex == FLS_OUT_OF_INDEXES);
@ -95,7 +95,7 @@ void ThreadLocalStorage::set_value(void *p_value) const {
pimpl->set_value(p_value); pimpl->set_value(p_value);
} }
void ThreadLocalStorage::alloc(void (_CALLBACK_FUNC_ *p_destr_callback)(void *)) { void ThreadLocalStorage::alloc(void(_CALLBACK_FUNC_ *p_destr_callback)(void *)) {
pimpl = memnew(ThreadLocalStorage::Impl(p_destr_callback)); pimpl = memnew(ThreadLocalStorage::Impl(p_destr_callback));
} }

3
modules/mono/utils/thread_local.h
View File

@ -76,7 +76,7 @@ struct ThreadLocalStorage {
void *get_value() const; void *get_value() const;
void set_value(void *p_value) const; void set_value(void *p_value) const;
void alloc(void (_CALLBACK_FUNC_ *p_dest_callback)(void *)); void alloc(void(_CALLBACK_FUNC_ *p_dest_callback)(void *));
void free(); void free();
private: private:
@ -95,7 +95,6 @@ class ThreadLocal {
memdelete(static_cast<T *>(tls_data)); memdelete(static_cast<T *>(tls_data));
} }
T *_tls_get_value() const { T *_tls_get_value() const {
void *tls_data = storage.get_value(); void *tls_data = storage.get_value();

35
scene/animation/animation_blend_space_1d.cpp
View File

@ -1,8 +1,7 @@
#include "animation_blend_space_1d.h" #include "animation_blend_space_1d.h"
void AnimationNodeBlendSpace1D::get_parameter_list(List<PropertyInfo> *r_list) const { void AnimationNodeBlendSpace1D::get_parameter_list(List<PropertyInfo> *r_list) const {
r_list->push_back(PropertyInfo(Variant::REAL,blend_position)); r_list->push_back(PropertyInfo(Variant::REAL, blend_position));
} }
Variant AnimationNodeBlendSpace1D::get_parameter_default_value(const StringName &p_parameter) const { Variant AnimationNodeBlendSpace1D::get_parameter_default_value(const StringName &p_parameter) const {
return 0; return 0;
@ -64,10 +63,10 @@ void AnimationNodeBlendSpace1D::_bind_methods() {
} }
void AnimationNodeBlendSpace1D::get_child_nodes(List<ChildNode> *r_child_nodes) { void AnimationNodeBlendSpace1D::get_child_nodes(List<ChildNode> *r_child_nodes) {
for(int i=0;i<blend_points_used;i++) { for (int i = 0; i < blend_points_used; i++) {
ChildNode cn; ChildNode cn;
cn.name=itos(i); cn.name = itos(i);
cn.node=blend_points[i].node; cn.node = blend_points[i].node;
r_child_nodes->push_back(cn); r_child_nodes->push_back(cn);
} }
} }
@ -89,12 +88,10 @@ void AnimationNodeBlendSpace1D::add_blend_point(const Ref<AnimationRootNode> &p_
blend_points[p_at_index].node = p_node; blend_points[p_at_index].node = p_node;
blend_points[p_at_index].position = p_position; blend_points[p_at_index].position = p_position;
blend_points[p_at_index].node->connect("tree_changed",this,"_tree_changed",varray(),CONNECT_REFERENCE_COUNTED); blend_points[p_at_index].node->connect("tree_changed", this, "_tree_changed", varray(), CONNECT_REFERENCE_COUNTED);
blend_points_used++; blend_points_used++;
emit_signal("tree_changed"); emit_signal("tree_changed");
} }
void AnimationNodeBlendSpace1D::set_blend_point_position(int p_point, float p_position) { void AnimationNodeBlendSpace1D::set_blend_point_position(int p_point, float p_position) {
@ -108,14 +105,13 @@ void AnimationNodeBlendSpace1D::set_blend_point_node(int p_point, const Ref<Anim
ERR_FAIL_COND(p_node.is_null()); ERR_FAIL_COND(p_node.is_null());
if (blend_points[p_point].node.is_valid()) { if (blend_points[p_point].node.is_valid()) {
blend_points[p_point].node->disconnect("tree_changed",this,"_tree_changed"); blend_points[p_point].node->disconnect("tree_changed", this, "_tree_changed");
} }
blend_points[p_point].node = p_node; blend_points[p_point].node = p_node;
blend_points[p_point].node->connect("tree_changed",this,"_tree_changed",varray(),CONNECT_REFERENCE_COUNTED); blend_points[p_point].node->connect("tree_changed", this, "_tree_changed", varray(), CONNECT_REFERENCE_COUNTED);
emit_signal("tree_changed"); emit_signal("tree_changed");
} }
float AnimationNodeBlendSpace1D::get_blend_point_position(int p_point) const { float AnimationNodeBlendSpace1D::get_blend_point_position(int p_point) const {
@ -131,16 +127,14 @@ Ref<AnimationRootNode> AnimationNodeBlendSpace1D::get_blend_point_node(int p_poi
void AnimationNodeBlendSpace1D::remove_blend_point(int p_point) { void AnimationNodeBlendSpace1D::remove_blend_point(int p_point) {
ERR_FAIL_INDEX(p_point, blend_points_used); ERR_FAIL_INDEX(p_point, blend_points_used);
blend_points[p_point].node->disconnect("tree_changed",this,"_tree_changed"); blend_points[p_point].node->disconnect("tree_changed", this, "_tree_changed");
for (int i = p_point; i < blend_points_used - 1; i++) { for (int i = p_point; i < blend_points_used - 1; i++) {
blend_points[i] = blend_points[i + 1]; blend_points[i] = blend_points[i + 1];
} }
blend_points_used--; blend_points_used--;
emit_signal("tree_changed"); emit_signal("tree_changed");
} }
int AnimationNodeBlendSpace1D::get_blend_point_count() const { int AnimationNodeBlendSpace1D::get_blend_point_count() const {
@ -180,7 +174,6 @@ float AnimationNodeBlendSpace1D::get_snap() const {
return snap; return snap;
} }
void AnimationNodeBlendSpace1D::set_value_label(const String &p_label) { void AnimationNodeBlendSpace1D::set_value_label(const String &p_label) {
value_label = p_label; value_label = p_label;
} }
@ -203,10 +196,9 @@ float AnimationNodeBlendSpace1D::process(float p_time, bool p_seek) {
return 0.0; return 0.0;
} }
if (blend_points_used == 1) { if (blend_points_used == 1) {
// only one point available, just play that animation // only one point available, just play that animation
return blend_node(blend_points[0].name,blend_points[0].node, p_time, p_seek, 1.0, FILTER_IGNORE, false); return blend_node(blend_points[0].name, blend_points[0].node, p_time, p_seek, 1.0, FILTER_IGNORE, false);
} }
float blend_pos = get_parameter(blend_position); float blend_pos = get_parameter(blend_position);
@ -277,7 +269,7 @@ float AnimationNodeBlendSpace1D::process(float p_time, bool p_seek) {
float max_time_remaining = 0.0; float max_time_remaining = 0.0;
for (int i = 0; i < blend_points_used; i++) { for (int i = 0; i < blend_points_used; i++) {
float remaining = blend_node(blend_points[i].name,blend_points[i].node, p_time, p_seek, weights[i], FILTER_IGNORE, false); float remaining = blend_node(blend_points[i].name, blend_points[i].node, p_time, p_seek, weights[i], FILTER_IGNORE, false);
max_time_remaining = MAX(max_time_remaining, remaining); max_time_remaining = MAX(max_time_remaining, remaining);
} }
@ -291,8 +283,8 @@ String AnimationNodeBlendSpace1D::get_caption() const {
AnimationNodeBlendSpace1D::AnimationNodeBlendSpace1D() { AnimationNodeBlendSpace1D::AnimationNodeBlendSpace1D() {
for(int i=0;i<MAX_BLEND_POINTS;i++) { for (int i = 0; i < MAX_BLEND_POINTS; i++) {
blend_points[i].name=itos(i); blend_points[i].name = itos(i);
} }
blend_points_used = 0; blend_points_used = 0;
max_space = 1; max_space = 1;
@ -301,9 +293,8 @@ AnimationNodeBlendSpace1D::AnimationNodeBlendSpace1D() {
snap = 0.1; snap = 0.1;
value_label = "value"; value_label = "value";
blend_position="blend_position"; blend_position = "blend_position";
} }
AnimationNodeBlendSpace1D::~AnimationNodeBlendSpace1D() { AnimationNodeBlendSpace1D::~AnimationNodeBlendSpace1D() {
} }

2
scene/animation/animation_blend_space_1d.h
View File

@ -37,13 +37,11 @@ protected:
static void _bind_methods(); static void _bind_methods();
public: public:
virtual void get_parameter_list(List<PropertyInfo> *r_list) const; virtual void get_parameter_list(List<PropertyInfo> *r_list) const;
virtual Variant get_parameter_default_value(const StringName &p_parameter) const; virtual Variant get_parameter_default_value(const StringName &p_parameter) const;
virtual void get_child_nodes(List<ChildNode> *r_child_nodes); virtual void get_child_nodes(List<ChildNode> *r_child_nodes);
void add_blend_point(const Ref<AnimationRootNode> &p_node, float p_position, int p_at_index = -1); void add_blend_point(const Ref<AnimationRootNode> &p_node, float p_position, int p_at_index = -1);
void set_blend_point_position(int p_point, float p_position); void set_blend_point_position(int p_point, float p_position);
void set_blend_point_node(int p_point, const Ref<AnimationRootNode> &p_node); void set_blend_point_node(int p_point, const Ref<AnimationRootNode> &p_node);

33
scene/animation/animation_blend_space_2d.cpp
View File

@ -1,20 +1,18 @@
#include "animation_blend_space_2d.h" #include "animation_blend_space_2d.h"
#include "math/delaunay.h" #include "math/delaunay.h"
void AnimationNodeBlendSpace2D::get_parameter_list(List<PropertyInfo> *r_list) const { void AnimationNodeBlendSpace2D::get_parameter_list(List<PropertyInfo> *r_list) const {
r_list->push_back(PropertyInfo(Variant::VECTOR2,blend_position)); r_list->push_back(PropertyInfo(Variant::VECTOR2, blend_position));
} }
Variant AnimationNodeBlendSpace2D::get_parameter_default_value(const StringName &p_parameter) const { Variant AnimationNodeBlendSpace2D::get_parameter_default_value(const StringName &p_parameter) const {
return Vector2(); return Vector2();
} }
void AnimationNodeBlendSpace2D::get_child_nodes(List<ChildNode> *r_child_nodes) { void AnimationNodeBlendSpace2D::get_child_nodes(List<ChildNode> *r_child_nodes) {
for(int i=0;i<blend_points_used;i++) { for (int i = 0; i < blend_points_used; i++) {
ChildNode cn; ChildNode cn;
cn.name=itos(i); cn.name = itos(i);
cn.node=blend_points[i].node; cn.node = blend_points[i].node;
r_child_nodes->push_back(cn); r_child_nodes->push_back(cn);
} }
} }
@ -41,15 +39,13 @@ void AnimationNodeBlendSpace2D::add_blend_point(const Ref<AnimationRootNode> &p_
blend_points[p_at_index].node = p_node; blend_points[p_at_index].node = p_node;
blend_points[p_at_index].position = p_position; blend_points[p_at_index].position = p_position;
blend_points[p_at_index].node->connect("tree_changed",this,"_tree_changed",varray(),CONNECT_REFERENCE_COUNTED); blend_points[p_at_index].node->connect("tree_changed", this, "_tree_changed", varray(), CONNECT_REFERENCE_COUNTED);
blend_points_used++; blend_points_used++;
if (auto_triangles) { if (auto_triangles) {
trianges_dirty = true; trianges_dirty = true;
} }
emit_signal("tree_changed"); emit_signal("tree_changed");
} }
void AnimationNodeBlendSpace2D::set_blend_point_position(int p_point, const Vector2 &p_position) { void AnimationNodeBlendSpace2D::set_blend_point_position(int p_point, const Vector2 &p_position) {
@ -64,13 +60,12 @@ void AnimationNodeBlendSpace2D::set_blend_point_node(int p_point, const Ref<Anim
ERR_FAIL_COND(p_node.is_null()); ERR_FAIL_COND(p_node.is_null());
if (blend_points[p_point].node.is_valid()) { if (blend_points[p_point].node.is_valid()) {
blend_points[p_point].node->disconnect("tree_changed",this,"_tree_changed"); blend_points[p_point].node->disconnect("tree_changed", this, "_tree_changed");
} }
blend_points[p_point].node = p_node; blend_points[p_point].node = p_node;
blend_points[p_point].node->connect("tree_changed",this,"_tree_changed",varray(),CONNECT_REFERENCE_COUNTED); blend_points[p_point].node->connect("tree_changed", this, "_tree_changed", varray(), CONNECT_REFERENCE_COUNTED);
emit_signal("tree_changed"); emit_signal("tree_changed");
} }
Vector2 AnimationNodeBlendSpace2D::get_blend_point_position(int p_point) const { Vector2 AnimationNodeBlendSpace2D::get_blend_point_position(int p_point) const {
ERR_FAIL_INDEX_V(p_point, blend_points_used, Vector2()); ERR_FAIL_INDEX_V(p_point, blend_points_used, Vector2());
@ -83,7 +78,7 @@ Ref<AnimationRootNode> AnimationNodeBlendSpace2D::get_blend_point_node(int p_poi
void AnimationNodeBlendSpace2D::remove_blend_point(int p_point) { void AnimationNodeBlendSpace2D::remove_blend_point(int p_point) {
ERR_FAIL_INDEX(p_point, blend_points_used); ERR_FAIL_INDEX(p_point, blend_points_used);
blend_points[p_point].node->disconnect("tree_changed",this,"_tree_changed"); blend_points[p_point].node->disconnect("tree_changed", this, "_tree_changed");
for (int i = 0; i < triangles.size(); i++) { for (int i = 0; i < triangles.size(); i++) {
bool erase = false; bool erase = false;
@ -107,7 +102,6 @@ void AnimationNodeBlendSpace2D::remove_blend_point(int p_point) {
} }
blend_points_used--; blend_points_used--;
emit_signal("tree_changed"); emit_signal("tree_changed");
} }
int AnimationNodeBlendSpace2D::get_blend_point_count() const { int AnimationNodeBlendSpace2D::get_blend_point_count() const {
@ -451,7 +445,7 @@ float AnimationNodeBlendSpace2D::process(float p_time, bool p_seek) {
for (int j = 0; j < 3; j++) { for (int j = 0; j < 3; j++) {
if (i == triangle_points[j]) { if (i == triangle_points[j]) {
//blend with the given weight //blend with the given weight
float t = blend_node(blend_points[i].name,blend_points[i].node, p_time, p_seek, blend_weights[j], FILTER_IGNORE, false); float t = blend_node(blend_points[i].name, blend_points[i].node, p_time, p_seek, blend_weights[j], FILTER_IGNORE, false);
if (first || t < mind) { if (first || t < mind) {
mind = t; mind = t;
first = false; first = false;
@ -463,7 +457,7 @@ float AnimationNodeBlendSpace2D::process(float p_time, bool p_seek) {
if (!found) { if (!found) {
//ignore //ignore
blend_node(blend_points[i].name,blend_points[i].node, p_time, p_seek, 0, FILTER_IGNORE, false); blend_node(blend_points[i].name, blend_points[i].node, p_time, p_seek, 0, FILTER_IGNORE, false);
} }
} }
return mind; return mind;
@ -491,7 +485,6 @@ void AnimationNodeBlendSpace2D::set_auto_triangles(bool p_enable) {
} }
} }
bool AnimationNodeBlendSpace2D::get_auto_triangles() const { bool AnimationNodeBlendSpace2D::get_auto_triangles() const {
return auto_triangles; return auto_triangles;
} }
@ -562,8 +555,8 @@ void AnimationNodeBlendSpace2D::_bind_methods() {
AnimationNodeBlendSpace2D::AnimationNodeBlendSpace2D() { AnimationNodeBlendSpace2D::AnimationNodeBlendSpace2D() {
for(int i=0;i<MAX_BLEND_POINTS;i++) { for (int i = 0; i < MAX_BLEND_POINTS; i++) {
blend_points[i].name=itos(i); blend_points[i].name = itos(i);
} }
auto_triangles = true; auto_triangles = true;
blend_points_used = 0; blend_points_used = 0;
@ -577,6 +570,4 @@ AnimationNodeBlendSpace2D::AnimationNodeBlendSpace2D() {
} }
AnimationNodeBlendSpace2D::~AnimationNodeBlendSpace2D() { AnimationNodeBlendSpace2D::~AnimationNodeBlendSpace2D() {
} }

2
scene/animation/animation_blend_space_2d.h
View File

@ -45,13 +45,11 @@ class AnimationNodeBlendSpace2D : public AnimationRootNode {
void _tree_changed(); void _tree_changed();
protected: protected:
virtual void _validate_property(PropertyInfo &property) const; virtual void _validate_property(PropertyInfo &property) const;
static void _bind_methods(); static void _bind_methods();
public: public:
virtual void get_parameter_list(List<PropertyInfo> *r_list) const; virtual void get_parameter_list(List<PropertyInfo> *r_list) const;
virtual Variant get_parameter_default_value(const StringName &p_parameter) const; virtual Variant get_parameter_default_value(const StringName &p_parameter) const;

105
scene/animation/animation_tree.cpp
View File

@ -5,36 +5,32 @@
#include "scene/scene_string_names.h" #include "scene/scene_string_names.h"
#include "servers/audio/audio_stream.h" #include "servers/audio/audio_stream.h"
void AnimationNode::get_parameter_list(List<PropertyInfo> *r_list) const { void AnimationNode::get_parameter_list(List<PropertyInfo> *r_list) const {
} }
Variant AnimationNode::get_parameter_default_value(const StringName &p_parameter) const { Variant AnimationNode::get_parameter_default_value(const StringName &p_parameter) const {
return Variant(); return Variant();
} }
void AnimationNode::set_parameter(const StringName& p_name, const Variant& p_value) { void AnimationNode::set_parameter(const StringName &p_name, const Variant &p_value) {
ERR_FAIL_COND(!state); ERR_FAIL_COND(!state);
ERR_FAIL_COND(!state->tree->property_parent_map.has(base_path)); ERR_FAIL_COND(!state->tree->property_parent_map.has(base_path));
ERR_FAIL_COND(!state->tree->property_parent_map[base_path].has(p_name)); ERR_FAIL_COND(!state->tree->property_parent_map[base_path].has(p_name));
StringName path = state->tree->property_parent_map[base_path][p_name]; StringName path = state->tree->property_parent_map[base_path][p_name];
state->tree->property_map[path]=p_value; state->tree->property_map[path] = p_value;
} }
Variant AnimationNode::get_parameter(const StringName& p_name) const { Variant AnimationNode::get_parameter(const StringName &p_name) const {
ERR_FAIL_COND_V(!state,Variant()); ERR_FAIL_COND_V(!state, Variant());
ERR_FAIL_COND_V(!state->tree->property_parent_map.has(base_path),Variant()); ERR_FAIL_COND_V(!state->tree->property_parent_map.has(base_path), Variant());
ERR_FAIL_COND_V(!state->tree->property_parent_map[base_path].has(p_name),Variant()); ERR_FAIL_COND_V(!state->tree->property_parent_map[base_path].has(p_name), Variant());
StringName path = state->tree->property_parent_map[base_path][p_name]; StringName path = state->tree->property_parent_map[base_path][p_name];
return state->tree->property_map[path]; return state->tree->property_map[path];
} }
void AnimationNode::get_child_nodes(List<ChildNode> *r_child_nodes) { void AnimationNode::get_child_nodes(List<ChildNode> *r_child_nodes) {
} }
void AnimationNode::blend_animation(const StringName &p_animation, float p_time, float p_delta, bool p_seeked, float p_blend) { void AnimationNode::blend_animation(const StringName &p_animation, float p_time, float p_delta, bool p_seeked, float p_blend) {
@ -46,7 +42,7 @@ void AnimationNode::blend_animation(const StringName &p_animation, float p_time,
if (animation.is_null()) { if (animation.is_null()) {
AnimationNodeBlendTree* btree = Object::cast_to<AnimationNodeBlendTree>(parent); AnimationNodeBlendTree *btree = Object::cast_to<AnimationNodeBlendTree>(parent);
if (btree) { if (btree) {
String name = btree->get_node_name(Ref<AnimationNodeAnimation>(this)); String name = btree->get_node_name(Ref<AnimationNodeAnimation>(this));
make_invalid(vformat(RTR("In node '%s', invalid animation: '%s'."), name, p_animation)); make_invalid(vformat(RTR("In node '%s', invalid animation: '%s'."), name, p_animation));
@ -69,11 +65,11 @@ void AnimationNode::blend_animation(const StringName &p_animation, float p_time,
state->animation_states.push_back(anim_state); state->animation_states.push_back(anim_state);
} }
float AnimationNode::_pre_process(const StringName& p_base_path, AnimationNode *p_parent, State *p_state, float p_time, bool p_seek, const Vector<StringName>& p_connections) { float AnimationNode::_pre_process(const StringName &p_base_path, AnimationNode *p_parent, State *p_state, float p_time, bool p_seek, const Vector<StringName> &p_connections) {
base_path = p_base_path; base_path = p_base_path;
parent = p_parent; parent = p_parent;
connections=p_connections; connections = p_connections;
state = p_state; state = p_state;
float t = process(p_time, p_seek); float t = process(p_time, p_seek);
@ -99,8 +95,8 @@ float AnimationNode::blend_input(int p_input, float p_time, bool p_seek, float p
ERR_FAIL_INDEX_V(p_input, inputs.size(), 0); ERR_FAIL_INDEX_V(p_input, inputs.size(), 0);
ERR_FAIL_COND_V(!state, 0); ERR_FAIL_COND_V(!state, 0);
AnimationNodeBlendTree* blend_tree = Object::cast_to<AnimationNodeBlendTree>(parent); AnimationNodeBlendTree *blend_tree = Object::cast_to<AnimationNodeBlendTree>(parent);
ERR_FAIL_COND_V(!blend_tree,0); ERR_FAIL_COND_V(!blend_tree, 0);
StringName node_name = connections[p_input]; StringName node_name = connections[p_input];
@ -114,15 +110,15 @@ float AnimationNode::blend_input(int p_input, float p_time, bool p_seek, float p
//inputs.write[p_input].last_pass = state->last_pass; //inputs.write[p_input].last_pass = state->last_pass;
float activity; float activity;
return _blend_node(node_name,blend_tree->get_node_connection_array(node_name),NULL,node, p_time, p_seek, p_blend, p_filter, p_optimize, &activity); return _blend_node(node_name, blend_tree->get_node_connection_array(node_name), NULL, node, p_time, p_seek, p_blend, p_filter, p_optimize, &activity);
} }
float AnimationNode::blend_node(const StringName& p_sub_path,Ref<AnimationNode> p_node, float p_time, bool p_seek, float p_blend, FilterAction p_filter, bool p_optimize) { float AnimationNode::blend_node(const StringName &p_sub_path, Ref<AnimationNode> p_node, float p_time, bool p_seek, float p_blend, FilterAction p_filter, bool p_optimize) {
return _blend_node(p_sub_path,Vector<StringName>(),this,p_node, p_time, p_seek, p_blend, p_filter, p_optimize); return _blend_node(p_sub_path, Vector<StringName>(), this, p_node, p_time, p_seek, p_blend, p_filter, p_optimize);
} }
float AnimationNode::_blend_node(const StringName &p_subpath, const Vector<StringName>& p_connections, AnimationNode *p_new_parent, Ref<AnimationNode> p_node, float p_time, bool p_seek, float p_blend, FilterAction p_filter, bool p_optimize, float *r_max) { float AnimationNode::_blend_node(const StringName &p_subpath, const Vector<StringName> &p_connections, AnimationNode *p_new_parent, Ref<AnimationNode> p_node, float p_time, bool p_seek, float p_blend, FilterAction p_filter, bool p_optimize, float *r_max) {
ERR_FAIL_COND_V(!p_node.is_valid(), 0); ERR_FAIL_COND_V(!p_node.is_valid(), 0);
ERR_FAIL_COND_V(!state, 0); ERR_FAIL_COND_V(!state, 0);
@ -229,13 +225,13 @@ float AnimationNode::_blend_node(const StringName &p_subpath, const Vector<Strin
//this is the slowest part of processing, but as strings process in powers of 2, and the paths always exist, it will not result in that many allocations //this is the slowest part of processing, but as strings process in powers of 2, and the paths always exist, it will not result in that many allocations
if (p_new_parent) { if (p_new_parent) {
new_parent = p_new_parent; new_parent = p_new_parent;
new_path = String(base_path)+String(p_subpath)+"/"; new_path = String(base_path) + String(p_subpath) + "/";
} else { } else {
ERR_FAIL_COND_V(!parent,0); ERR_FAIL_COND_V(!parent, 0);
new_parent = parent; new_parent = parent;
new_path = String(parent->base_path) + String(p_subpath)+"/"; new_path = String(parent->base_path) + String(p_subpath) + "/";
} }
return p_node->_pre_process(new_path,new_parent,state, p_time, p_seek, p_connections); return p_node->_pre_process(new_path, new_parent, state, p_time, p_seek, p_connections);
} }
int AnimationNode::get_input_count() const { int AnimationNode::get_input_count() const {
@ -247,7 +243,6 @@ String AnimationNode::get_input_name(int p_input) {
return inputs[p_input].name; return inputs[p_input].name;
} }
String AnimationNode::get_caption() const { String AnimationNode::get_caption() const {
if (get_script_instance()) { if (get_script_instance()) {
@ -313,8 +308,6 @@ bool AnimationNode::has_filter() const {
return false; return false;
} }
Array AnimationNode::_get_filters() const { Array AnimationNode::_get_filters() const {
Array paths; Array paths;
@ -358,16 +351,15 @@ void AnimationNode::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_filter_enabled", "enable"), &AnimationNode::set_filter_enabled); ClassDB::bind_method(D_METHOD("set_filter_enabled", "enable"), &AnimationNode::set_filter_enabled);
ClassDB::bind_method(D_METHOD("is_filter_enabled"), &AnimationNode::is_filter_enabled); ClassDB::bind_method(D_METHOD("is_filter_enabled"), &AnimationNode::is_filter_enabled);
ClassDB::bind_method(D_METHOD("_set_filters", "filters"), &AnimationNode::_set_filters); ClassDB::bind_method(D_METHOD("_set_filters", "filters"), &AnimationNode::_set_filters);
ClassDB::bind_method(D_METHOD("_get_filters"), &AnimationNode::_get_filters); ClassDB::bind_method(D_METHOD("_get_filters"), &AnimationNode::_get_filters);
ClassDB::bind_method(D_METHOD("blend_animation", "animation", "time", "delta", "seeked", "blend"), &AnimationNode::blend_animation); ClassDB::bind_method(D_METHOD("blend_animation", "animation", "time", "delta", "seeked", "blend"), &AnimationNode::blend_animation);
ClassDB::bind_method(D_METHOD("blend_node", "name","node", "time", "seek", "blend", "filter", "optimize"), &AnimationNode::blend_node, DEFVAL(FILTER_IGNORE), DEFVAL(true)); ClassDB::bind_method(D_METHOD("blend_node", "name", "node", "time", "seek", "blend", "filter", "optimize"), &AnimationNode::blend_node, DEFVAL(FILTER_IGNORE), DEFVAL(true));
ClassDB::bind_method(D_METHOD("blend_input", "input_index", "time", "seek", "blend", "filter", "optimize"), &AnimationNode::blend_input, DEFVAL(FILTER_IGNORE), DEFVAL(true)); ClassDB::bind_method(D_METHOD("blend_input", "input_index", "time", "seek", "blend", "filter", "optimize"), &AnimationNode::blend_input, DEFVAL(FILTER_IGNORE), DEFVAL(true));
ClassDB::bind_method(D_METHOD("set_parameter","name","value"), &AnimationNode::set_parameter); ClassDB::bind_method(D_METHOD("set_parameter", "name", "value"), &AnimationNode::set_parameter);
ClassDB::bind_method(D_METHOD("get_parameter","name"), &AnimationNode::get_parameter); ClassDB::bind_method(D_METHOD("get_parameter", "name"), &AnimationNode::get_parameter);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "filter_enabled", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_filter_enabled", "is_filter_enabled"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "filter_enabled", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_filter_enabled", "is_filter_enabled");
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "filters", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL), "_set_filters", "_get_filters"); ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "filters", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL), "_set_filters", "_get_filters");
@ -398,16 +390,16 @@ AnimationNode::AnimationNode() {
void AnimationTree::set_tree_root(const Ref<AnimationNode> &p_root) { void AnimationTree::set_tree_root(const Ref<AnimationNode> &p_root) {
if (root.is_valid()) { if (root.is_valid()) {
root->disconnect("tree_changed",this,"_tree_changed"); root->disconnect("tree_changed", this, "_tree_changed");
} }
root = p_root; root = p_root;
if (root.is_valid()) { if (root.is_valid()) {
root->connect("tree_changed",this,"_tree_changed"); root->connect("tree_changed", this, "_tree_changed");
} }
properties_dirty=true; properties_dirty = true;
update_configuration_warning(); update_configuration_warning();
} }
@ -738,11 +730,11 @@ void AnimationTree::_process_graph(float p_delta) {
if (started) { if (started) {
//if started, seek //if started, seek
root->_pre_process(SceneStringNames::get_singleton()->parameters_base_path,NULL,&state, 0, true,Vector<StringName>()); root->_pre_process(SceneStringNames::get_singleton()->parameters_base_path, NULL, &state, 0, true, Vector<StringName>());
started = false; started = false;
} }
root->_pre_process(SceneStringNames::get_singleton()->parameters_base_path,NULL,&state, p_delta, false,Vector<StringName>()); root->_pre_process(SceneStringNames::get_singleton()->parameters_base_path, NULL, &state, p_delta, false, Vector<StringName>());
} }
if (!state.valid) { if (!state.valid) {
@ -1284,27 +1276,27 @@ void AnimationTree::_tree_changed() {
} }
call_deferred("_update_properties"); call_deferred("_update_properties");
properties_dirty=true; properties_dirty = true;
} }
void AnimationTree::_update_properties_for_node(const String& p_base_path,Ref<AnimationNode> node) { void AnimationTree::_update_properties_for_node(const String &p_base_path, Ref<AnimationNode> node) {
if (!property_parent_map.has(p_base_path)) { if (!property_parent_map.has(p_base_path)) {
property_parent_map[p_base_path]=HashMap<StringName, StringName>(); property_parent_map[p_base_path] = HashMap<StringName, StringName>();
} }
List<PropertyInfo> plist; List<PropertyInfo> plist;
node->get_parameter_list(&plist); node->get_parameter_list(&plist);
for(List<PropertyInfo>::Element *E=plist.front();E;E=E->next()) { for (List<PropertyInfo>::Element *E = plist.front(); E; E = E->next()) {
PropertyInfo pinfo = E->get(); PropertyInfo pinfo = E->get();
StringName key = pinfo.name; StringName key = pinfo.name;
if (!property_map.has(p_base_path +key)) { if (!property_map.has(p_base_path + key)) {
property_map[p_base_path + key] = node->get_parameter_default_value(key); property_map[p_base_path + key] = node->get_parameter_default_value(key);
} }
property_parent_map[p_base_path][key]=p_base_path+key; property_parent_map[p_base_path][key] = p_base_path + key;
pinfo.name = p_base_path + key; pinfo.name = p_base_path + key;
properties.push_back(pinfo); properties.push_back(pinfo);
@ -1313,8 +1305,8 @@ void AnimationTree::_update_properties_for_node(const String& p_base_path,Ref<An
List<AnimationNode::ChildNode> children; List<AnimationNode::ChildNode> children;
node->get_child_nodes(&children); node->get_child_nodes(&children);
for (List<AnimationNode::ChildNode>::Element *E=children.front();E;E=E->next()) { for (List<AnimationNode::ChildNode>::Element *E = children.front(); E; E = E->next()) {
_update_properties_for_node(p_base_path+E->get().name+"/",E->get().node); _update_properties_for_node(p_base_path + E->get().name + "/", E->get().node);
} }
} }
@ -1327,7 +1319,7 @@ void AnimationTree::_update_properties() {
property_parent_map.clear(); property_parent_map.clear();
if (root.is_valid()) { if (root.is_valid()) {
_update_properties_for_node(SceneStringNames::get_singleton()->parameters_base_path,root); _update_properties_for_node(SceneStringNames::get_singleton()->parameters_base_path, root);
} }
properties_dirty = false; properties_dirty = false;
@ -1341,7 +1333,7 @@ bool AnimationTree::_set(const StringName &p_name, const Variant &p_value) {
} }
if (property_map.has(p_name)) { if (property_map.has(p_name)) {
property_map[p_name]=p_value; property_map[p_name] = p_value;
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
_change_notify(p_name.operator String().utf8().get_data()); _change_notify(p_name.operator String().utf8().get_data());
#endif #endif
@ -1353,39 +1345,38 @@ bool AnimationTree::_set(const StringName &p_name, const Variant &p_value) {
bool AnimationTree::_get(const StringName &p_name, Variant &r_ret) const { bool AnimationTree::_get(const StringName &p_name, Variant &r_ret) const {
if (properties_dirty) { if (properties_dirty) {
const_cast<AnimationTree*>(this)->_update_properties(); const_cast<AnimationTree *>(this)->_update_properties();
} }
if (property_map.has(p_name)) { if (property_map.has(p_name)) {
r_ret=property_map[p_name]; r_ret = property_map[p_name];
return true; return true;
} }
return false; return false;
} }
void AnimationTree::_get_property_list(List<PropertyInfo> *p_list) const { void AnimationTree::_get_property_list(List<PropertyInfo> *p_list) const {
if (properties_dirty) { if (properties_dirty) {
const_cast<AnimationTree*>(this)->_update_properties(); const_cast<AnimationTree *>(this)->_update_properties();
} }
for (const List<PropertyInfo>::Element *E=properties.front();E;E=E->next()) { for (const List<PropertyInfo>::Element *E = properties.front(); E; E = E->next()) {
p_list->push_back(E->get()); p_list->push_back(E->get());
} }
} }
void AnimationTree::rename_parameter(const String& p_base,const String& p_new_base) { void AnimationTree::rename_parameter(const String &p_base, const String &p_new_base) {
//rename values first //rename values first
for (const List<PropertyInfo>::Element *E=properties.front();E;E=E->next()) { for (const List<PropertyInfo>::Element *E = properties.front(); E; E = E->next()) {
if (E->get().name.begins_with(p_base)) { if (E->get().name.begins_with(p_base)) {
String new_name = E->get().name.replace_first(p_base,p_new_base); String new_name = E->get().name.replace_first(p_base, p_new_base);
property_map[new_name]=property_map[E->get().name]; property_map[new_name] = property_map[E->get().name];
} }
} }
//update tree second //update tree second
properties_dirty=true; properties_dirty = true;
_update_properties(); _update_properties();
} }
@ -1410,8 +1401,7 @@ void AnimationTree::_bind_methods() {
ClassDB::bind_method(D_METHOD("_tree_changed"), &AnimationTree::_tree_changed); ClassDB::bind_method(D_METHOD("_tree_changed"), &AnimationTree::_tree_changed);
ClassDB::bind_method(D_METHOD("_update_properties"), &AnimationTree::_update_properties); ClassDB::bind_method(D_METHOD("_update_properties"), &AnimationTree::_update_properties);
ClassDB::bind_method(D_METHOD("rename_parameter","old_name","new_name"), &AnimationTree::rename_parameter); ClassDB::bind_method(D_METHOD("rename_parameter", "old_name", "new_name"), &AnimationTree::rename_parameter);
ClassDB::bind_method(D_METHOD("advance", "delta"), &AnimationTree::advance); ClassDB::bind_method(D_METHOD("advance", "delta"), &AnimationTree::advance);
@ -1440,5 +1430,4 @@ AnimationTree::AnimationTree() {
} }
AnimationTree::~AnimationTree() { AnimationTree::~AnimationTree() {
} }

2
scene/main/node.cpp
View File

@ -240,7 +240,7 @@ void Node::_propagate_enter_tree() {
void Node::_propagate_exit_tree() { void Node::_propagate_exit_tree() {
//block while removing children //block while removing children
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED