Add BlendSpace BlendPoint weight velocity limiting

Author: ZeEndy

doc/classes/AnimationNodeBlendSpace1D.xml

@@ -75,6 +75,12 @@
 		<member name="min_space" type="float" setter="set_min_space" getter="get_min_space" default="-1.0">
 			The blend space's axis's lower limit for the points' position. See [method add_blend_point].
 		</member>
+		<member name="smooth" type="bool" setter="set_use_smooth" getter="is_using_smooth" default="false">
+			If [code]true[/code], while [member sync] is [code]true[/code] a blend point's weight is applied over time using [member smooth_speed].
+		</member>
+		<member name="smooth_speed" type="float" setter="set_smooth_speed" getter="get_smooth_speed" default="1.0">
+			Controls the blend point smoothing speed.
+		</member>
 		<member name="snap" type="float" setter="set_snap" getter="get_snap" default="0.1">
 			Position increment to snap to when moving a point on the axis.
 		</member>

doc/classes/AnimationNodeBlendSpace2D.xml

@@ -110,6 +110,12 @@
 		<member name="min_space" type="Vector2" setter="set_min_space" getter="get_min_space" default="Vector2(-1, -1)">
 			The blend space's X and Y axes' lower limit for the points' position. See [method add_blend_point].
 		</member>
+		<member name="smooth" type="bool" setter="set_use_smooth" getter="is_using_smooth" default="false">
+			If [code]true[/code], while [member sync] is [code]true[/code] a blend point's weight is applied over time using [member smooth_speed].
+		</member>
+		<member name="smooth_speed" type="float" setter="set_smooth_speed" getter="get_smooth_speed" default="1.0">
+			Controls the blend point smoothing speed.
+		</member>
 		<member name="snap" type="Vector2" setter="set_snap" getter="get_snap" default="Vector2(0.1, 0.1)">
 			Position increment to snap to when moving a point.
 		</member>

editor/plugins/animation_blend_space_1d_editor.cpp

@@ -36,6 +36,7 @@
 #include "editor/editor_string_names.h"
 #include "editor/editor_undo_redo_manager.h"
 #include "editor/gui/editor_file_dialog.h"
+#include "editor/inspector_dock.h"
 #include "editor/themes/editor_scale.h"
 #include "scene/animation/animation_blend_tree.h"
 #include "scene/gui/button.h"
@@ -133,9 +134,9 @@ void AnimationNodeBlendSpace1DEditor::_blend_space_gui_input(const Ref<InputEven
 		for (int i = 0; i < points.size(); i++) {
 			if (Math::abs(float(points[i] - mb->get_position().x)) < 10 * EDSCALE) {
 				selected_point = i;
-
 				Ref<AnimationNode> node = blend_space->get_blend_point_node(i);
-				EditorNode::get_singleton()->push_item(node.ptr(), "", true);
+				current_blend_point_editor->setup(blend_space, selected_point, node);
+				InspectorDock::get_inspector_singleton()->edit(current_blend_point_editor.ptr());
 				dragging_selected_attempt = true;
 				drag_from = mb->get_position();
 				_update_tool_erase();
@@ -336,6 +337,8 @@ void AnimationNodeBlendSpace1DEditor::_update_space() {
 
 	sync->set_pressed(blend_space->is_using_sync());
 	interpolation->select(blend_space->get_blend_mode());
+	use_velocity_limit->set_pressed(blend_space->get_use_velocity_limit());
+	default_velocity_limit->set_value(blend_space->get_velocity_limit());
 
 	label_value->set_text(blend_space->get_value_label());
 
@@ -364,6 +367,11 @@ void AnimationNodeBlendSpace1DEditor::_config_changed(double) {
 	undo_redo->add_undo_method(blend_space.ptr(), "set_use_sync", blend_space->is_using_sync());
 	undo_redo->add_do_method(blend_space.ptr(), "set_blend_mode", interpolation->get_selected());
 	undo_redo->add_undo_method(blend_space.ptr(), "set_blend_mode", blend_space->get_blend_mode());
+	blending_hb->set_visible(sync->is_pressed());
+	undo_redo->add_do_method(blend_space.ptr(), "set_use_velocity_limit", use_velocity_limit->is_pressed());
+	undo_redo->add_undo_method(blend_space.ptr(), "set_use_velocity_limit", blend_space->get_use_velocity_limit());
+	undo_redo->add_do_method(blend_space.ptr(), "set_velocity_limit", default_velocity_limit->get_value());
+	undo_redo->add_undo_method(blend_space.ptr(), "set_velocity_limit", blend_space->get_velocity_limit());
 	undo_redo->add_do_method(this, "_update_space");
 	undo_redo->add_undo_method(this, "_update_space");
 	undo_redo->commit_action();
@@ -617,6 +625,82 @@ void AnimationNodeBlendSpace1DEditor::_notification(int p_what) {
 		} break;
 	}
 }
+void BlendPointEditor1D::setup(Ref<AnimationNodeBlendSpace1D> p_blend_space, int p_idx, Ref<AnimationNode> p_anim_node) {
+	blend_space = p_blend_space;
+	selected_point = p_idx;
+	anim_node = p_anim_node;
+}
+
+void BlendPointEditor1D::set_velocity_limit(float p_value) {
+	if (blend_space.is_valid()) {
+		if (updating) {
+			return;
+		}
+		updating = true;
+		EditorUndoRedoManager *undo_redo = EditorUndoRedoManager::get_singleton();
+		undo_redo->create_action(TTR("Change Node Velocity Limit"));
+		undo_redo->add_do_method(blend_space.ptr(), "set_blend_point_vl", selected_point, p_value);
+		undo_redo->add_undo_method(blend_space.ptr(), "set_blend_point_vl", selected_point, blend_space->get_blend_point_vl(selected_point));
+		undo_redo->commit_action();
+		updating = false;
+	}
+}
+double BlendPointEditor1D::get_velocity_limit() const {
+	return (blend_space.is_valid()) ? blend_space->get_blend_point_vl(selected_point) : 0.0;
+}
+
+Ref<AnimationNode> BlendPointEditor1D::get_anim_node() const {
+	return anim_node;
+}
+void BlendPointEditor1D::set_velocity_limit_ease(float const p_ease) {
+	if (blend_space.is_valid()) {
+		updating = true;
+		EditorUndoRedoManager *undo_redo = EditorUndoRedoManager::get_singleton();
+		undo_redo->create_action(TTR("Change Blendspace Velocity Limit Ease"));
+		undo_redo->add_do_method(blend_space.ptr(), "set_velocity_limit_ease", p_ease);
+		undo_redo->add_undo_method(blend_space.ptr(), "set_velocity_limit_ease", blend_space->get_velocity_limit_ease());
+		undo_redo->commit_action();
+		updating = false;
+	}
+}
+float BlendPointEditor1D::get_velocity_limit_ease() const {
+	return (blend_space.is_valid()) ? blend_space->get_velocity_limit_ease() : 1.0;
+}
+
+void BlendPointEditor1D::set_override_velocity_limit(bool const p_ovl) {
+	if (blend_space.is_valid()) {
+		updating = true;
+		EditorUndoRedoManager *undo_redo = EditorUndoRedoManager::get_singleton();
+		undo_redo->create_action(TTR("Change Node Override Velocity Limit"));
+		undo_redo->add_do_method(blend_space.ptr(), "set_blend_point_ovl", selected_point, p_ovl);
+		undo_redo->add_undo_method(blend_space.ptr(), "set_blend_point_ovl", selected_point, blend_space->get_blend_point_ovl(selected_point));
+		undo_redo->commit_action();
+		updating = false;
+	}
+}
+bool BlendPointEditor1D::get_override_velocity_limit() const {
+	return (blend_space.is_valid()) ? blend_space->get_blend_point_ovl(selected_point) : false;
+}
+
+void BlendPointEditor1D::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_velocity_limit", "value"), &BlendPointEditor1D::set_velocity_limit);
+	ClassDB::bind_method(D_METHOD("get_velocity_limit"), &BlendPointEditor1D::get_velocity_limit);
+	ClassDB::bind_method(D_METHOD("_dont_undo_redo"), &BlendPointEditor1D::_dont_undo_redo);
+	ClassDB::bind_method(D_METHOD("_hide_script_from_inspector"), &BlendPointEditor1D::_hide_script_from_inspector);
+	ClassDB::bind_method(D_METHOD("_hide_metadata_from_inspector"), &BlendPointEditor1D::_hide_metadata_from_inspector);
+
+	ClassDB::bind_method(D_METHOD("get_velocity_limit_ease"), &BlendPointEditor1D::get_velocity_limit_ease);
+	ClassDB::bind_method(D_METHOD("set_velocity_limit_ease"), &BlendPointEditor1D::set_velocity_limit_ease);
+
+	ClassDB::bind_method(D_METHOD("set_override_velocity_limit"), &BlendPointEditor1D::set_override_velocity_limit);
+	ClassDB::bind_method(D_METHOD("get_override_velocity_limit"), &BlendPointEditor1D::get_override_velocity_limit);
+
+	ClassDB::bind_method(D_METHOD("get_anim_node"), &BlendPointEditor1D::get_anim_node);
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "velocity_limit_ease", PROPERTY_HINT_EXP_EASING), "set_velocity_limit_ease", "get_velocity_limit_ease");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "override_velocity_limit", PROPERTY_HINT_NONE), "set_override_velocity_limit", "get_override_velocity_limit");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "velocity_limit", PROPERTY_HINT_NONE, "0,60,0.01,or_greater,suffix:/s"), "set_velocity_limit", "get_velocity_limit");
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "animation_node", PROPERTY_HINT_RESOURCE_TYPE, "AnimationNode"), "", "get_anim_node");
+}
 
 void AnimationNodeBlendSpace1DEditor::_bind_methods() {
 	ClassDB::bind_method("_update_space", &AnimationNodeBlendSpace1DEditor::_update_space);
@@ -646,6 +730,8 @@ void AnimationNodeBlendSpace1DEditor::edit(const Ref<AnimationNode> &p_node) {
 	min_value->set_editable(!read_only);
 	max_value->set_editable(!read_only);
 	sync->set_disabled(read_only);
+	default_velocity_limit->set_editable(!read_only);
+	use_velocity_limit->set_disabled(read_only);
 	interpolation->set_disabled(read_only);
 }
 
@@ -728,6 +814,26 @@ AnimationNodeBlendSpace1DEditor::AnimationNodeBlendSpace1DEditor() {
 	top_hb->add_child(interpolation);
 	interpolation->connect(SceneStringName(item_selected), callable_mp(this, &AnimationNodeBlendSpace1DEditor::_config_changed));
 
+	blending_hb = memnew(HBoxContainer);
+	top_hb->add_child(blending_hb);
+	blending_hb->add_child(memnew(VSeparator));
+
+	blending_hb->add_child(memnew(Label(TTR("Use Velocity Limit:"))));
+	use_velocity_limit = memnew(CheckBox);
+	blending_hb->add_child(use_velocity_limit);
+	use_velocity_limit->connect(SceneStringName(toggled), callable_mp(this, &AnimationNodeBlendSpace1DEditor::_config_changed));
+
+	blending_hb->add_child(memnew(Label(TTR("Default Velocity limit:"))));
+	default_velocity_limit = memnew(SpinBox);
+	blending_hb->add_child(default_velocity_limit);
+	default_velocity_limit->set_min(0.0);
+	default_velocity_limit->set_step(0.01);
+	default_velocity_limit->set_max(60.0);
+	default_velocity_limit->set_suffix("/s");
+	default_velocity_limit->connect(SceneStringName(value_changed), callable_mp(this, &AnimationNodeBlendSpace1DEditor::_config_changed));
+
+	current_blend_point_editor.instantiate();
+
 	edit_hb = memnew(HBoxContainer);
 	top_hb->add_child(edit_hb);
 	edit_hb->add_child(memnew(VSeparator));

editor/plugins/animation_blend_space_1d_editor.h

@@ -43,6 +43,7 @@ class PanelContainer;
 class SpinBox;
 class VSeparator;
 
+class BlendPointEditor1D;
 class AnimationNodeBlendSpace1DEditor : public AnimationTreeNodeEditorPlugin {
 	GDCLASS(AnimationNodeBlendSpace1DEditor, AnimationTreeNodeEditorPlugin);
 
@@ -68,6 +69,11 @@ class AnimationNodeBlendSpace1DEditor : public AnimationTreeNodeEditorPlugin {
 	CheckBox *sync = nullptr;
 	OptionButton *interpolation = nullptr;
 
+	HBoxContainer *blending_hb = nullptr;
+	CheckBox *use_velocity_limit = nullptr;
+	SpinBox *default_velocity_limit = nullptr;
+	Ref<BlendPointEditor1D> current_blend_point_editor;
+
 	HBoxContainer *edit_hb = nullptr;
 	SpinBox *edit_value = nullptr;
 	Button *open_editor = nullptr;
@@ -135,3 +141,33 @@ class AnimationNodeBlendSpace1DEditor : public AnimationTreeNodeEditorPlugin {
 	virtual void edit(const Ref<AnimationNode> &p_node) override;
 	AnimationNodeBlendSpace1DEditor();
 };
+
+class BlendPointEditor1D : public RefCounted {
+	GDCLASS(BlendPointEditor1D, RefCounted);
+
+private:
+	Ref<AnimationNodeBlendSpace1D> blend_space;
+	Ref<AnimationNode> anim_node;
+	float velocity_limit_ease;
+	int selected_point = -1;
+	float velocity_limit = 0.0;
+	bool override_velocity_limit = false;
+	bool updating = false;
+
+public:
+	void setup(Ref<AnimationNodeBlendSpace1D> p_blend_space, int idx, Ref<AnimationNode> p_anim_node);
+
+	void set_velocity_limit(float p_value);
+	double get_velocity_limit() const;
+	void set_override_velocity_limit(bool const p_ovl);
+	bool get_override_velocity_limit() const;
+
+	Ref<AnimationNode> get_anim_node() const;
+	void set_velocity_limit_ease(float const p_ease);
+	float get_velocity_limit_ease() const;
+	bool _hide_script_from_inspector() { return true; }
+	bool _hide_metadata_from_inspector() { return true; }
+	bool _dont_undo_redo() { return true; }
+
+	static void _bind_methods();
+};