asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
virtualx-engine/scene/animation/animation_node_state_machine.h

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

348 lines
13 KiB
C++
Raw Normal View History

One Copyright Update to rule them all As many open source projects have started doing it, we're removing the current year from the copyright notice, so that we don't need to bump it every year. It seems like only the first year of publication is technically relevant for copyright notices, and even that seems to be something that many companies stopped listing altogether (in a version controlled codebase, the commits are a much better source of date of publication than a hardcoded copyright statement). We also now list Godot Engine contributors first as we're collectively the current maintainers of the project, and we clarify that the "exclusive" copyright of the co-founders covers the timespan before opensourcing (their further contributions are included as part of Godot Engine contributors). Also fixed "cf." Frenchism - it's meant as "refer to / see".
2023-01-05 13:25:55 +01:00
/**************************************************************************/
/* animation_node_state_machine.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
Add missing copyright headers
2018-08-29 22:38:13 +02:00
State machine animation node
2018-06-25 21:21:57 +02:00
#ifndef ANIMATION_NODE_STATE_MACHINE_H
#define ANIMATION_NODE_STATE_MACHINE_H
Add AnimationTree Advance Expressions Allows specifying an expression as a condition for state machine transitions. This gives much greater flexibility for creating complex state machines. By directly interfacing with the script code, it is possible to create complex animation advance condition for switching between states. Ensure assigning AnimationTreeStateMachineTransition base expression node in editor is relative to current AnimationTree node. Allow setting an expression base node on the AnimationTree itself. Co-Authored-By: reduz <reduzio@gmail.com>
2022-04-20 12:36:54 +02:00
#include "core/math/expression.h"
renamed AnimationGraphPlayer to AnimationTree
2018-06-25 23:40:24 +02:00
#include "scene/animation/animation_tree.h"
State machine animation node
2018-06-25 21:21:57 +02:00
class AnimationNodeStateMachineTransition : public Resource {
Made use of semicolons more consitent, fixed formatting
2019-03-19 19:35:57 +01:00
GDCLASS(AnimationNodeStateMachineTransition, Resource);
State machine animation node
2018-06-25 21:21:57 +02:00
public:
enum SwitchMode {
SWITCH_MODE_IMMEDIATE,
SWITCH_MODE_SYNC,
SWITCH_MODE_AT_END,
};
Change auto_advance flag to advance_mode enum and unify with disabled flag. Expressions and conditions now require auto mode to be set to auto. Adds a toggle button to the state machine editor for whether new transitions advance settings should default to auto mode or not.
2022-10-06 17:44:59 +02:00
enum AdvanceMode {
ADVANCE_MODE_DISABLED,
ADVANCE_MODE_ENABLED,
ADVANCE_MODE_AUTO,
};
State machine animation node
2018-06-25 21:21:57 +02:00
private:
Initialize class variables with default values in scene/ [1/2]
2021-02-07 22:29:31 +01:00
SwitchMode switch_mode = SWITCH_MODE_IMMEDIATE;
Change auto_advance flag to advance_mode enum and unify with disabled flag. Expressions and conditions now require auto mode to be set to auto. Adds a toggle button to the state machine editor for whether new transitions advance settings should default to auto mode or not.
2022-10-06 17:44:59 +02:00
AdvanceMode advance_mode = ADVANCE_MODE_ENABLED;
Massive rewrite to AnimationTree. Many APIs changed in order to: -Reuse resources -Expose properties in AnimationTree
2018-08-20 18:38:18 +02:00
StringName advance_condition;
StringName advance_condition_name;
added Curve in animation node transition for better control over cros… Co-authored-by: jeronimo-schreyer <jeronimo.schreyer@gmail.com>
2022-07-28 10:31:23 +02:00
float xfade_time = 0.0;
Ref<Curve> xfade_curve;
Add next/reset function to AnimationStateMachine
2023-01-10 10:15:16 +01:00
bool reset = true;
Initialize class variables with default values in scene/ [1/2]
2021-02-07 22:29:31 +01:00
int priority = 1;
Add AnimationTree Advance Expressions Allows specifying an expression as a condition for state machine transitions. This gives much greater flexibility for creating complex state machines. By directly interfacing with the script code, it is possible to create complex animation advance condition for switching between states. Ensure assigning AnimationTreeStateMachineTransition base expression node in editor is relative to current AnimationTree node. Allow setting an expression base node on the AnimationTree itself. Co-Authored-By: reduz <reduzio@gmail.com>
2022-04-20 12:36:54 +02:00
String advance_expression;
friend class AnimationNodeStateMachinePlayback;
Ref<Expression> expression;
State machine animation node
2018-06-25 21:21:57 +02:00
protected:
static void _bind_methods();
public:
void set_switch_mode(SwitchMode p_mode);
SwitchMode get_switch_mode() const;
Change auto_advance flag to advance_mode enum and unify with disabled flag. Expressions and conditions now require auto mode to be set to auto. Adds a toggle button to the state machine editor for whether new transitions advance settings should default to auto mode or not.
2022-10-06 17:44:59 +02:00
void set_advance_mode(AdvanceMode p_mode);
AdvanceMode get_advance_mode() const;
State machine animation node
2018-06-25 21:21:57 +02:00
Massive rewrite to AnimationTree. Many APIs changed in order to: -Reuse resources -Expose properties in AnimationTree
2018-08-20 18:38:18 +02:00
void set_advance_condition(const StringName &p_condition);
StringName get_advance_condition() const;
StringName get_advance_condition_name() const;
Add AnimationTree Advance Expressions Allows specifying an expression as a condition for state machine transitions. This gives much greater flexibility for creating complex state machines. By directly interfacing with the script code, it is possible to create complex animation advance condition for switching between states. Ensure assigning AnimationTreeStateMachineTransition base expression node in editor is relative to current AnimationTree node. Allow setting an expression base node on the AnimationTree itself. Co-Authored-By: reduz <reduzio@gmail.com>
2022-04-20 12:36:54 +02:00
void set_advance_expression(const String &p_expression);
String get_advance_expression() const;
State machine animation node
2018-06-25 21:21:57 +02:00
void set_xfade_time(float p_xfade);
float get_xfade_time() const;
Add next/reset function to AnimationStateMachine
2023-01-10 10:15:16 +01:00
void set_reset(bool p_reset);
bool is_reset() const;
added Curve in animation node transition for better control over cros… Co-authored-by: jeronimo-schreyer <jeronimo.schreyer@gmail.com>
2022-07-28 10:31:23 +02:00
void set_xfade_curve(const Ref<Curve> &p_curve);
Ref<Curve> get_xfade_curve() const;
State machine animation node
2018-06-25 21:21:57 +02:00
void set_priority(int p_priority);
int get_priority() const;
AnimationNodeStateMachineTransition();
};
VARIANT_ENUM_CAST(AnimationNodeStateMachineTransition::SwitchMode)
Change auto_advance flag to advance_mode enum and unify with disabled flag. Expressions and conditions now require auto mode to be set to auto. Adds a toggle button to the state machine editor for whether new transitions advance settings should default to auto mode or not.
2022-10-06 17:44:59 +02:00
VARIANT_ENUM_CAST(AnimationNodeStateMachineTransition::AdvanceMode)
State machine animation node
2018-06-25 21:21:57 +02:00
Rework StateMachine and nested StateMachine process Breaking compatibility: If a StateMachineTransition is connected to a nested StateMachine prior to this, it is removed. Also, there was a feature to connect another StateMachine as the End of a StateMachine, which is also removed to avoid reference confusion. It was like a GoTo Statement, also further passing the same reference to the blending process, causing the blending calculation to break or causing some StateMachines to not work.
2023-02-18 03:02:28 +01:00
class AnimationNodeStateMachinePlayback;
Massive rewrite to AnimationTree. Many APIs changed in order to: -Reuse resources -Expose properties in AnimationTree
2018-08-20 18:38:18 +02:00
class AnimationNodeStateMachine : public AnimationRootNode {
GDCLASS(AnimationNodeStateMachine, AnimationRootNode);
Rework StateMachine and nested StateMachine process Breaking compatibility: If a StateMachineTransition is connected to a nested StateMachine prior to this, it is removed. Also, there was a feature to connect another StateMachine as the End of a StateMachine, which is also removed to avoid reference confusion. It was like a GoTo Statement, also further passing the same reference to the blending process, causing the blending calculation to break or causing some StateMachines to not work.
2023-02-18 03:02:28 +01:00
public:
enum StateMachineType {
STATE_MACHINE_TYPE_ROOT,
STATE_MACHINE_TYPE_NESTED,
STATE_MACHINE_TYPE_GROUPED,
};
Massive rewrite to AnimationTree. Many APIs changed in order to: -Reuse resources -Expose properties in AnimationTree
2018-08-20 18:38:18 +02:00
private:
friend class AnimationNodeStateMachinePlayback;
Rework StateMachine and nested StateMachine process Breaking compatibility: If a StateMachineTransition is connected to a nested StateMachine prior to this, it is removed. Also, there was a feature to connect another StateMachine as the End of a StateMachine, which is also removed to avoid reference confusion. It was like a GoTo Statement, also further passing the same reference to the blending process, causing the blending calculation to break or causing some StateMachines to not work.
2023-02-18 03:02:28 +01:00
StateMachineType state_machine_type = STATE_MACHINE_TYPE_ROOT;
Massive rewrite to AnimationTree. Many APIs changed in order to: -Reuse resources -Expose properties in AnimationTree
2018-08-20 18:38:18 +02:00
struct State {
Ref<AnimationRootNode> node;
Vector2 position;
};
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
HashMap<StringName, State> states;
Make restart in NodeStateMachine / NodeTransition optional
2023-01-31 13:17:29 +01:00
bool allow_transition_to_self = false;
Rework StateMachine and nested StateMachine process Breaking compatibility: If a StateMachineTransition is connected to a nested StateMachine prior to this, it is removed. Also, there was a feature to connect another StateMachine as the End of a StateMachine, which is also removed to avoid reference confusion. It was like a GoTo Statement, also further passing the same reference to the blending process, causing the blending calculation to break or causing some StateMachines to not work.
2023-02-18 03:02:28 +01:00
bool reset_ends = false;
Massive rewrite to AnimationTree. Many APIs changed in order to: -Reuse resources -Expose properties in AnimationTree
2018-08-20 18:38:18 +02:00
struct Transition {
StringName from;
StringName to;
Ref<AnimationNodeStateMachineTransition> transition;
};
Vector<Transition> transitions;
Initialize class variables with default values in scene/ [1/2]
2021-02-07 22:29:31 +01:00
StringName playback = "playback";
Improvements of state machine - Open the menu to add new animation nodes by dragging the transitions to empty areas and automatically connecting them. - Adds box selection to the state machine. - Add feature to group/ungroup selected nodes in a "sub" state machine. - Add start/end node by default. In addition, add new color to these nodes to differentiate then. - Add tooltip for transitions to show the connection "from -> to". - Add new "type" of transition line when multiple transitions are grouped. - Add popup to connect nodes in sub state machine. - Add dialog to select which nodes can be deleted when they are grouped. - Add classes: AnimationNodeStartState AnimationNodeEndState EditorAnimationMultiTransitionEdit - Implements disabled transition API Changes: - Now it's posible to add transitions between state machines, `AnimationNodeStateMachine::add_transition` will works with relative path, this means you can use it like this `add_transition("Idle", "Walk", tr)` or `add_transition("Idle", "StateMachine/Shoot)`.
2018-12-16 15:43:20 +01:00
bool updating_transitions = false;
Massive rewrite to AnimationTree. Many APIs changed in order to: -Reuse resources -Expose properties in AnimationTree
2018-08-20 18:38:18 +02:00
Vector2 graph_offset;
Improvements of state machine - Open the menu to add new animation nodes by dragging the transitions to empty areas and automatically connecting them. - Adds box selection to the state machine. - Add feature to group/ungroup selected nodes in a "sub" state machine. - Add start/end node by default. In addition, add new color to these nodes to differentiate then. - Add tooltip for transitions to show the connection "from -> to". - Add new "type" of transition line when multiple transitions are grouped. - Add popup to connect nodes in sub state machine. - Add dialog to select which nodes can be deleted when they are grouped. - Add classes: AnimationNodeStartState AnimationNodeEndState EditorAnimationMultiTransitionEdit - Implements disabled transition API Changes: - Now it's posible to add transitions between state machines, `AnimationNodeStateMachine::add_transition` will works with relative path, this means you can use it like this `add_transition("Idle", "Walk", tr)` or `add_transition("Idle", "StateMachine/Shoot)`.
2018-12-16 15:43:20 +01:00
void _remove_transition(const Ref<AnimationNodeStateMachineTransition> p_transition);
Fix AnimationNodeStateMachine::rename_node
2022-07-31 23:47:19 +02:00
void _rename_transitions(const StringName &p_name, const StringName &p_new_name);
Rework StateMachine and nested StateMachine process Breaking compatibility: If a StateMachineTransition is connected to a nested StateMachine prior to this, it is removed. Also, there was a feature to connect another StateMachine as the End of a StateMachine, which is also removed to avoid reference confusion. It was like a GoTo Statement, also further passing the same reference to the blending process, causing the blending calculation to break or causing some StateMachines to not work.
2023-02-18 03:02:28 +01:00
bool _can_connect(const StringName &p_name);
Massive rewrite to AnimationTree. Many APIs changed in order to: -Reuse resources -Expose properties in AnimationTree
2018-08-20 18:38:18 +02:00
State machine animation node
2018-06-25 21:21:57 +02:00
protected:
static void _bind_methods();
bool _set(const StringName &p_name, const Variant &p_value);
bool _get(const StringName &p_name, Variant &r_ret) const;
void _get_property_list(List<PropertyInfo> *p_list) const;
Rework StateMachine and nested StateMachine process Breaking compatibility: If a StateMachineTransition is connected to a nested StateMachine prior to this, it is removed. Also, there was a feature to connect another StateMachine as the End of a StateMachine, which is also removed to avoid reference confusion. It was like a GoTo Statement, also further passing the same reference to the blending process, causing the blending calculation to break or causing some StateMachines to not work.
2023-02-18 03:02:28 +01:00
void _validate_property(PropertyInfo &p_property) const;
Improvements of state machine - Open the menu to add new animation nodes by dragging the transitions to empty areas and automatically connecting them. - Adds box selection to the state machine. - Add feature to group/ungroup selected nodes in a "sub" state machine. - Add start/end node by default. In addition, add new color to these nodes to differentiate then. - Add tooltip for transitions to show the connection "from -> to". - Add new "type" of transition line when multiple transitions are grouped. - Add popup to connect nodes in sub state machine. - Add dialog to select which nodes can be deleted when they are grouped. - Add classes: AnimationNodeStartState AnimationNodeEndState EditorAnimationMultiTransitionEdit - Implements disabled transition API Changes: - Now it's posible to add transitions between state machines, `AnimationNodeStateMachine::add_transition` will works with relative path, this means you can use it like this `add_transition("Idle", "Walk", tr)` or `add_transition("Idle", "StateMachine/Shoot)`.
2018-12-16 15:43:20 +01:00
bool _check_advance_condition(const Ref<AnimationNodeStateMachine> p_state_machine, const Ref<AnimationNodeStateMachineTransition> p_transition) const;
State machine animation node
2018-06-25 21:21:57 +02:00
Fix NodeTransition initialization and AnimationNode remapping method
2023-02-04 16:29:34 +01:00
virtual void _tree_changed() override;
virtual void _animation_node_renamed(const ObjectID &p_oid, const String &p_old_name, const String &p_new_name) override;
virtual void _animation_node_removed(const ObjectID &p_oid, const StringName &p_node) override;
Improve resource load cache -Added a new method in Resource: reset_state , used for reloading the same resource from disk -Added a new cache mode "replace" in ResourceLoader, which reuses existing loaded sub-resources but resets their data from disk (or replaces them if they chaged type) -Because the correct sub-resource paths are always loaded now, this fixes bugs with subresource folding or subresource ordering when saving.
2021-02-11 18:18:45 +01:00
virtual void reset_state() override;
State machine animation node
2018-06-25 21:21:57 +02:00
public:
Improvements of state machine - Open the menu to add new animation nodes by dragging the transitions to empty areas and automatically connecting them. - Adds box selection to the state machine. - Add feature to group/ungroup selected nodes in a "sub" state machine. - Add start/end node by default. In addition, add new color to these nodes to differentiate then. - Add tooltip for transitions to show the connection "from -> to". - Add new "type" of transition line when multiple transitions are grouped. - Add popup to connect nodes in sub state machine. - Add dialog to select which nodes can be deleted when they are grouped. - Add classes: AnimationNodeStartState AnimationNodeEndState EditorAnimationMultiTransitionEdit - Implements disabled transition API Changes: - Now it's posible to add transitions between state machines, `AnimationNodeStateMachine::add_transition` will works with relative path, this means you can use it like this `add_transition("Idle", "Walk", tr)` or `add_transition("Idle", "StateMachine/Shoot)`.
2018-12-16 15:43:20 +01:00
StringName start_node = "Start";
StringName end_node = "End";
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void get_parameter_list(List<PropertyInfo> *r_list) const override;
virtual Variant get_parameter_default_value(const StringName &p_parameter) const override;
Rework StateMachine and nested StateMachine process Breaking compatibility: If a StateMachineTransition is connected to a nested StateMachine prior to this, it is removed. Also, there was a feature to connect another StateMachine as the End of a StateMachine, which is also removed to avoid reference confusion. It was like a GoTo Statement, also further passing the same reference to the blending process, causing the blending calculation to break or causing some StateMachines to not work.
2023-02-18 03:02:28 +01:00
virtual bool is_parameter_read_only(const StringName &p_parameter) const override;
Massive rewrite to AnimationTree. Many APIs changed in order to: -Reuse resources -Expose properties in AnimationTree
2018-08-20 18:38:18 +02:00
void add_node(const StringName &p_name, Ref<AnimationNode> p_node, const Vector2 &p_position = Vector2());
Added new method to replace an already added node to the animation state machine
2020-03-16 17:42:29 +01:00
void replace_node(const StringName &p_name, Ref<AnimationNode> p_node);
State machine animation node
2018-06-25 21:21:57 +02:00
Ref<AnimationNode> get_node(const StringName &p_name) const;
void remove_node(const StringName &p_name);
void rename_node(const StringName &p_name, const StringName &p_new_name);
bool has_node(const StringName &p_name) const;
StringName get_node_name(const Ref<AnimationNode> &p_node) const;
void get_node_list(List<StringName> *r_nodes) const;
Massive rewrite to AnimationTree. Many APIs changed in order to: -Reuse resources -Expose properties in AnimationTree
2018-08-20 18:38:18 +02:00
void set_node_position(const StringName &p_name, const Vector2 &p_position);
Vector2 get_node_position(const StringName &p_name) const;
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void get_child_nodes(List<ChildNode> *r_child_nodes) override;
Massive rewrite to AnimationTree. Many APIs changed in order to: -Reuse resources -Expose properties in AnimationTree
2018-08-20 18:38:18 +02:00
State machine animation node
2018-06-25 21:21:57 +02:00
bool has_transition(const StringName &p_from, const StringName &p_to) const;
Rework StateMachine and nested StateMachine process Breaking compatibility: If a StateMachineTransition is connected to a nested StateMachine prior to this, it is removed. Also, there was a feature to connect another StateMachine as the End of a StateMachine, which is also removed to avoid reference confusion. It was like a GoTo Statement, also further passing the same reference to the blending process, causing the blending calculation to break or causing some StateMachines to not work.
2023-02-18 03:02:28 +01:00
bool has_transition_from(const StringName &p_from) const;
bool has_transition_to(const StringName &p_to) const;
State machine animation node
2018-06-25 21:21:57 +02:00
int find_transition(const StringName &p_from, const StringName &p_to) const;
Rework StateMachine and nested StateMachine process Breaking compatibility: If a StateMachineTransition is connected to a nested StateMachine prior to this, it is removed. Also, there was a feature to connect another StateMachine as the End of a StateMachine, which is also removed to avoid reference confusion. It was like a GoTo Statement, also further passing the same reference to the blending process, causing the blending calculation to break or causing some StateMachines to not work.
2023-02-18 03:02:28 +01:00
Vector<int> find_transition_from(const StringName &p_from) const;
Vector<int> find_transition_to(const StringName &p_to) const;
State machine animation node
2018-06-25 21:21:57 +02:00
void add_transition(const StringName &p_from, const StringName &p_to, const Ref<AnimationNodeStateMachineTransition> &p_transition);
Ref<AnimationNodeStateMachineTransition> get_transition(int p_transition) const;
StringName get_transition_from(int p_transition) const;
StringName get_transition_to(int p_transition) const;
int get_transition_count() const;
Rework StateMachine and nested StateMachine process Breaking compatibility: If a StateMachineTransition is connected to a nested StateMachine prior to this, it is removed. Also, there was a feature to connect another StateMachine as the End of a StateMachine, which is also removed to avoid reference confusion. It was like a GoTo Statement, also further passing the same reference to the blending process, causing the blending calculation to break or causing some StateMachines to not work.
2023-02-18 03:02:28 +01:00
bool is_transition_across_group(int p_transition) const;
Improvements of state machine - Open the menu to add new animation nodes by dragging the transitions to empty areas and automatically connecting them. - Adds box selection to the state machine. - Add feature to group/ungroup selected nodes in a "sub" state machine. - Add start/end node by default. In addition, add new color to these nodes to differentiate then. - Add tooltip for transitions to show the connection "from -> to". - Add new "type" of transition line when multiple transitions are grouped. - Add popup to connect nodes in sub state machine. - Add dialog to select which nodes can be deleted when they are grouped. - Add classes: AnimationNodeStartState AnimationNodeEndState EditorAnimationMultiTransitionEdit - Implements disabled transition API Changes: - Now it's posible to add transitions between state machines, `AnimationNodeStateMachine::add_transition` will works with relative path, this means you can use it like this `add_transition("Idle", "Walk", tr)` or `add_transition("Idle", "StateMachine/Shoot)`.
2018-12-16 15:43:20 +01:00
void remove_transition_by_index(const int p_transition);
State machine animation node
2018-06-25 21:21:57 +02:00
void remove_transition(const StringName &p_from, const StringName &p_to);
Rework StateMachine and nested StateMachine process Breaking compatibility: If a StateMachineTransition is connected to a nested StateMachine prior to this, it is removed. Also, there was a feature to connect another StateMachine as the End of a StateMachine, which is also removed to avoid reference confusion. It was like a GoTo Statement, also further passing the same reference to the blending process, causing the blending calculation to break or causing some StateMachines to not work.
2023-02-18 03:02:28 +01:00
void set_state_machine_type(StateMachineType p_state_machine_type);
StateMachineType get_state_machine_type() const;
Make restart in NodeStateMachine / NodeTransition optional
2023-01-31 13:17:29 +01:00
void set_allow_transition_to_self(bool p_enable);
bool is_allow_transition_to_self() const;
Rework StateMachine and nested StateMachine process Breaking compatibility: If a StateMachineTransition is connected to a nested StateMachine prior to this, it is removed. Also, there was a feature to connect another StateMachine as the End of a StateMachine, which is also removed to avoid reference confusion. It was like a GoTo Statement, also further passing the same reference to the blending process, causing the blending calculation to break or causing some StateMachines to not work.
2023-02-18 03:02:28 +01:00
void set_reset_ends(bool p_enable);
bool are_ends_reset() const;
State machine animation node
2018-06-25 21:21:57 +02:00
Rework StateMachine and nested StateMachine process Breaking compatibility: If a StateMachineTransition is connected to a nested StateMachine prior to this, it is removed. Also, there was a feature to connect another StateMachine as the End of a StateMachine, which is also removed to avoid reference confusion. It was like a GoTo Statement, also further passing the same reference to the blending process, causing the blending calculation to break or causing some StateMachines to not work.
2023-02-18 03:02:28 +01:00
bool can_edit_node(const StringName &p_name) const;
State machine animation node
2018-06-25 21:21:57 +02:00
void set_graph_offset(const Vector2 &p_offset);
Vector2 get_graph_offset() const;
Implement AnimationManager the base class of AnimationPlayer/Tree
2023-07-20 17:34:06 +02:00
virtual double _process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only = false) override;
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual String get_caption() const override;
State machine animation node
2018-06-25 21:21:57 +02:00
Rework StateMachine and nested StateMachine process Breaking compatibility: If a StateMachineTransition is connected to a nested StateMachine prior to this, it is removed. Also, there was a feature to connect another StateMachine as the End of a StateMachine, which is also removed to avoid reference confusion. It was like a GoTo Statement, also further passing the same reference to the blending process, causing the blending calculation to break or causing some StateMachines to not work.
2023-02-18 03:02:28 +01:00
virtual Ref<AnimationNode> get_child_by_name(const StringName &p_name) const override;
State machine animation node
2018-06-25 21:21:57 +02:00
AnimationNodeStateMachine();
};
Rework StateMachine and nested StateMachine process Breaking compatibility: If a StateMachineTransition is connected to a nested StateMachine prior to this, it is removed. Also, there was a feature to connect another StateMachine as the End of a StateMachine, which is also removed to avoid reference confusion. It was like a GoTo Statement, also further passing the same reference to the blending process, causing the blending calculation to break or causing some StateMachines to not work.
2023-02-18 03:02:28 +01:00
VARIANT_ENUM_CAST(AnimationNodeStateMachine::StateMachineType);
class AnimationNodeStateMachinePlayback : public Resource {
GDCLASS(AnimationNodeStateMachinePlayback, Resource);
friend class AnimationNodeStateMachine;
struct AStarCost {
float distance = 0.0;
StringName prev;
};
struct TransitionInfo {
StringName from;
StringName to;
StringName next;
};
struct NextInfo {
StringName node;
double xfade;
Ref<Curve> curve;
AnimationNodeStateMachineTransition::SwitchMode switch_mode;
bool is_reset;
};
struct ChildStateMachineInfo {
Ref<AnimationNodeStateMachinePlayback> playback;
Vector<StringName> path;
bool is_reset = false;
};
Ref<AnimationNodeStateMachineTransition> default_transition;
String base_path;
double len_fade_from = 0.0;
double pos_fade_from = 0.0;
double len_current = 0.0;
double pos_current = 0.0;
StringName current;
Ref<Curve> current_curve;
Ref<AnimationNodeStateMachineTransition> group_start_transition;
Ref<AnimationNodeStateMachineTransition> group_end_transition;
StringName fading_from;
float fading_time = 0.0;
float fading_pos = 0.0;
Vector<StringName> path;
bool playing = false;
StringName start_request;
StringName travel_request;
bool reset_request = false;
bool reset_request_on_teleport = false;
bool _reset_request_for_fading_from = false;
bool next_request = false;
bool stop_request = false;
bool teleport_request = false;
bool is_grouped = false;
void _travel_main(const StringName &p_state, bool p_reset_on_teleport = true);
void _start_main(const StringName &p_state, bool p_reset = true);
void _next_main();
void _stop_main();
bool _make_travel_path(AnimationTree *p_tree, AnimationNodeStateMachine *p_state_machine, bool p_is_allow_transition_to_self, Vector<StringName> &r_path, bool p_test_only);
String _validate_path(AnimationNodeStateMachine *p_state_machine, const String &p_path);
bool _travel(AnimationTree *p_tree, AnimationNodeStateMachine *p_state_machine, bool p_is_allow_transition_to_self, bool p_test_only);
void _start(AnimationNodeStateMachine *p_state_machine);
void _clear_path_children(AnimationTree *p_tree, AnimationNodeStateMachine *p_state_machine, bool p_test_only);
bool _travel_children(AnimationTree *p_tree, AnimationNodeStateMachine *p_state_machine, const String &p_path, bool p_is_allow_transition_to_self, bool p_is_parent_same_state, bool p_test_only);
void _start_children(AnimationTree *p_tree, AnimationNodeStateMachine *p_state_machine, const String &p_path, bool p_test_only);
Implement AnimationManager the base class of AnimationPlayer/Tree
2023-07-20 17:34:06 +02:00
double process(const String &p_base_path, AnimationNodeStateMachine *p_state_machine, const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only);
double _process(const String &p_base_path, AnimationNodeStateMachine *p_state_machine, const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only);
Rework StateMachine and nested StateMachine process Breaking compatibility: If a StateMachineTransition is connected to a nested StateMachine prior to this, it is removed. Also, there was a feature to connect another StateMachine as the End of a StateMachine, which is also removed to avoid reference confusion. It was like a GoTo Statement, also further passing the same reference to the blending process, causing the blending calculation to break or causing some StateMachines to not work.
2023-02-18 03:02:28 +01:00
bool _check_advance_condition(const Ref<AnimationNodeStateMachine> p_state_machine, const Ref<AnimationNodeStateMachineTransition> p_transition) const;
bool _transition_to_next_recursive(AnimationTree *p_tree, AnimationNodeStateMachine *p_state_machine, bool p_test_only);
NextInfo _find_next(AnimationTree *p_tree, AnimationNodeStateMachine *p_state_machine) const;
Ref<AnimationNodeStateMachineTransition> _check_group_transition(AnimationTree *p_tree, AnimationNodeStateMachine *p_state_machine, const AnimationNodeStateMachine::Transition &p_transition, Ref<AnimationNodeStateMachine> &r_state_machine, bool &r_bypass) const;
bool _can_transition_to_next(AnimationTree *p_tree, AnimationNodeStateMachine *p_state_machine, NextInfo p_next, bool p_test_only);
void _set_current(AnimationNodeStateMachine *p_state_machine, const StringName &p_state);
void _set_grouped(bool p_is_grouped);
void _set_base_path(const String &p_base_path);
Ref<AnimationNodeStateMachinePlayback> _get_parent_playback(AnimationTree *p_tree) const;
Ref<AnimationNodeStateMachine> _get_parent_state_machine(AnimationTree *p_tree) const;
Ref<AnimationNodeStateMachineTransition> _get_group_start_transition() const;
Ref<AnimationNodeStateMachineTransition> _get_group_end_transition() const;
Add ValidatedCall to MethodBind * This should optimize GDScript function calling _enormously_. * It also should simplify the GDScript VM considerably. NOTE: GDExtension calling performance has most likely been affected until going via ptrcall is fixed.
2023-04-25 00:21:32 +02:00
TypedArray<StringName> _get_travel_path() const;
Rework StateMachine and nested StateMachine process Breaking compatibility: If a StateMachineTransition is connected to a nested StateMachine prior to this, it is removed. Also, there was a feature to connect another StateMachine as the End of a StateMachine, which is also removed to avoid reference confusion. It was like a GoTo Statement, also further passing the same reference to the blending process, causing the blending calculation to break or causing some StateMachines to not work.
2023-02-18 03:02:28 +01:00
protected:
static void _bind_methods();
public:
void travel(const StringName &p_state, bool p_reset_on_teleport = true);
void start(const StringName &p_state, bool p_reset = true);
void next();
void stop();
bool is_playing() const;
bool is_end() const;
StringName get_current_node() const;
StringName get_fading_from_node() const;
Vector<StringName> get_travel_path() const;
float get_current_play_pos() const;
float get_current_length() const;
float get_fade_from_play_pos() const;
float get_fade_from_length() const;
float get_fading_time() const;
float get_fading_pos() const;
void clear_path();
void push_path(const StringName &p_state);
AnimationNodeStateMachinePlayback();
};
State machine animation node
2018-06-25 21:21:57 +02:00
#endif // ANIMATION_NODE_STATE_MACHINE_H
Reference in a new issue Copy permalink