CoCalc -- animation_blend

GitHub Repository: godotengine/godot
Path: blob/master/scene/animation/animation_blend_tree.h
⁹⁸⁹⁶ views
1
/**************************************************************************/
2
/*  animation_blend_tree.h                                                */
3
/**************************************************************************/
4
/*                         This file is part of:                          */
5
/*                             GODOT ENGINE                               */
6
/*                        https://godotengine.org                         */
7
/**************************************************************************/
8
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
9
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
10
/*                                                                        */
11
/* Permission is hereby granted, free of charge, to any person obtaining  */
12
/* a copy of this software and associated documentation files (the        */
13
/* "Software"), to deal in the Software without restriction, including    */
14
/* without limitation the rights to use, copy, modify, merge, publish,    */
15
/* distribute, sublicense, and/or sell copies of the Software, and to     */
16
/* permit persons to whom the Software is furnished to do so, subject to  */
17
/* the following conditions:                                              */
18
/*                                                                        */
19
/* The above copyright notice and this permission notice shall be         */
20
/* included in all copies or substantial portions of the Software.        */
21
/*                                                                        */
22
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
23
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
24
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
25
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
26
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
27
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
28
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
29
/**************************************************************************/
30

31
#pragma once
32

33
#include "scene/animation/animation_tree.h"
34

35
class AnimationNodeAnimation : public AnimationRootNode {
36
	GDCLASS(AnimationNodeAnimation, AnimationRootNode);
37

38
	StringName backward = "backward"; // Only used by pingpong animation.
39

40
	StringName animation;
41

42
	bool advance_on_start = false;
43

44
	bool use_custom_timeline = false;
45
	double timeline_length = 1.0;
46
	Animation::LoopMode loop_mode = Animation::LOOP_NONE;
47
	bool stretch_time_scale = true;
48
	double start_offset = 0.0;
49

50
	uint64_t last_version = 0;
51
	bool skip = false;
52

53
public:
54
	enum PlayMode {
55
		PLAY_MODE_FORWARD,
56
		PLAY_MODE_BACKWARD
57
	};
58

59
	void get_parameter_list(List<PropertyInfo> *r_list) const override;
60
	virtual Variant get_parameter_default_value(const StringName &p_parameter) const override;
61

62
	virtual NodeTimeInfo get_node_time_info() const override; // Wrapper of get_parameter().
63

64
	static Vector<String> (*get_editable_animation_list)();
65

66
	virtual String get_caption() const override;
67
	virtual NodeTimeInfo process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only = false) override;
68
	virtual NodeTimeInfo _process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only = false) override;
69

70
	void set_animation(const StringName &p_name);
71
	StringName get_animation() const;
72

73
	void set_play_mode(PlayMode p_play_mode);
74
	PlayMode get_play_mode() const;
75

76
	void set_backward(bool p_backward);
77
	bool is_backward() const;
78

79
	void set_advance_on_start(bool p_advance_on_start);
80
	bool is_advance_on_start() const;
81

82
	void set_use_custom_timeline(bool p_use_custom_timeline);
83
	bool is_using_custom_timeline() const;
84

85
	void set_timeline_length(double p_length);
86
	double get_timeline_length() const;
87

88
	void set_stretch_time_scale(bool p_stretch_time_scale);
89
	bool is_stretching_time_scale() const;
90

91
	void set_start_offset(double p_offset);
92
	double get_start_offset() const;
93

94
	void set_loop_mode(Animation::LoopMode p_loop_mode);
95
	Animation::LoopMode get_loop_mode() const;
96

97
	AnimationNodeAnimation();
98

99
protected:
100
	void _validate_property(PropertyInfo &p_property) const;
101
	static void _bind_methods();
102

103
private:
104
	PlayMode play_mode = PLAY_MODE_FORWARD;
105
};
106

107
VARIANT_ENUM_CAST(AnimationNodeAnimation::PlayMode)
108

109
class AnimationNodeSync : public AnimationNode {
110
	GDCLASS(AnimationNodeSync, AnimationNode);
111

112
protected:
113
	bool sync = false;
114

115
	static void _bind_methods();
116

117
public:
118
	void set_use_sync(bool p_sync);
119
	bool is_using_sync() const;
120

121
	AnimationNodeSync();
122
};
123

124
class AnimationNodeOneShot : public AnimationNodeSync {
125
	GDCLASS(AnimationNodeOneShot, AnimationNodeSync);
126

127
public:
128
	enum OneShotRequest {
129
		ONE_SHOT_REQUEST_NONE,
130
		ONE_SHOT_REQUEST_FIRE,
131
		ONE_SHOT_REQUEST_ABORT,
132
		ONE_SHOT_REQUEST_FADE_OUT,
133
	};
134

135
	enum MixMode {
136
		MIX_MODE_BLEND,
137
		MIX_MODE_ADD
138
	};
139

140
private:
141
	double fade_in = 0.0;
142
	Ref<Curve> fade_in_curve;
143
	double fade_out = 0.0;
144
	Ref<Curve> fade_out_curve;
145

146
	bool auto_restart = false;
147
	double auto_restart_delay = 1.0;
148
	double auto_restart_random_delay = 0.0;
149
	MixMode mix = MIX_MODE_BLEND;
150
	bool break_loop_at_end = false;
151

152
	StringName request = PNAME("request");
153
	StringName active = PNAME("active");
154
	StringName internal_active = PNAME("internal_active");
155
	StringName fade_in_remaining = "fade_in_remaining";
156
	StringName fade_out_remaining = "fade_out_remaining";
157
	StringName time_to_restart = "time_to_restart";
158

159
protected:
160
	static void _bind_methods();
161

162
public:
163
	virtual void get_parameter_list(List<PropertyInfo> *r_list) const override;
164
	virtual Variant get_parameter_default_value(const StringName &p_parameter) const override;
165
	virtual bool is_parameter_read_only(const StringName &p_parameter) const override;
166

167
	virtual String get_caption() const override;
168

169
	void set_fade_in_time(double p_time);
170
	double get_fade_in_time() const;
171

172
	void set_fade_in_curve(const Ref<Curve> &p_curve);
173
	Ref<Curve> get_fade_in_curve() const;
174

175
	void set_fade_out_time(double p_time);
176
	double get_fade_out_time() const;
177

178
	void set_fade_out_curve(const Ref<Curve> &p_curve);
179
	Ref<Curve> get_fade_out_curve() const;
180

181
	void set_auto_restart_enabled(bool p_enabled);
182
	void set_auto_restart_delay(double p_time);
183
	void set_auto_restart_random_delay(double p_time);
184

185
	bool is_auto_restart_enabled() const;
186
	double get_auto_restart_delay() const;
187
	double get_auto_restart_random_delay() const;
188

189
	void set_mix_mode(MixMode p_mix);
190
	MixMode get_mix_mode() const;
191

192
	void set_break_loop_at_end(bool p_enable);
193
	bool is_loop_broken_at_end() const;
194

195
	virtual bool has_filter() const override;
196
	virtual NodeTimeInfo _process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only = false) override;
197

198
	AnimationNodeOneShot();
199
};
200

201
VARIANT_ENUM_CAST(AnimationNodeOneShot::OneShotRequest)
202
VARIANT_ENUM_CAST(AnimationNodeOneShot::MixMode)
203

204
class AnimationNodeAdd2 : public AnimationNodeSync {
205
	GDCLASS(AnimationNodeAdd2, AnimationNodeSync);
206

207
	StringName add_amount = PNAME("add_amount");
208

209
public:
210
	void get_parameter_list(List<PropertyInfo> *r_list) const override;
211
	virtual Variant get_parameter_default_value(const StringName &p_parameter) const override;
212

213
	virtual String get_caption() const override;
214

215
	virtual bool has_filter() const override;
216
	virtual NodeTimeInfo _process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only = false) override;
217

218
	AnimationNodeAdd2();
219
};
220

221
class AnimationNodeAdd3 : public AnimationNodeSync {
222
	GDCLASS(AnimationNodeAdd3, AnimationNodeSync);
223

224
	StringName add_amount = PNAME("add_amount");
225

226
public:
227
	void get_parameter_list(List<PropertyInfo> *r_list) const override;
228
	virtual Variant get_parameter_default_value(const StringName &p_parameter) const override;
229

230
	virtual String get_caption() const override;
231

232
	virtual bool has_filter() const override;
233
	virtual NodeTimeInfo _process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only = false) override;
234

235
	AnimationNodeAdd3();
236
};
237

238
class AnimationNodeBlend2 : public AnimationNodeSync {
239
	GDCLASS(AnimationNodeBlend2, AnimationNodeSync);
240

241
	StringName blend_amount = PNAME("blend_amount");
242

243
public:
244
	virtual void get_parameter_list(List<PropertyInfo> *r_list) const override;
245
	virtual Variant get_parameter_default_value(const StringName &p_parameter) const override;
246

247
	virtual String get_caption() const override;
248
	virtual NodeTimeInfo _process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only = false) override;
249

250
	virtual bool has_filter() const override;
251
	AnimationNodeBlend2();
252
};
253

254
class AnimationNodeBlend3 : public AnimationNodeSync {
255
	GDCLASS(AnimationNodeBlend3, AnimationNodeSync);
256

257
	StringName blend_amount = PNAME("blend_amount");
258

259
public:
260
	virtual void get_parameter_list(List<PropertyInfo> *r_list) const override;
261
	virtual Variant get_parameter_default_value(const StringName &p_parameter) const override;
262

263
	virtual String get_caption() const override;
264

265
	virtual NodeTimeInfo _process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only = false) override;
266
	AnimationNodeBlend3();
267
};
268

269
class AnimationNodeSub2 : public AnimationNodeSync {
270
	GDCLASS(AnimationNodeSub2, AnimationNodeSync);
271

272
	StringName sub_amount = PNAME("sub_amount");
273

274
public:
275
	void get_parameter_list(List<PropertyInfo> *r_list) const override;
276
	virtual Variant get_parameter_default_value(const StringName &p_parameter) const override;
277

278
	virtual String get_caption() const override;
279

280
	virtual bool has_filter() const override;
281
	virtual NodeTimeInfo _process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only = false) override;
282

283
	AnimationNodeSub2();
284
};
285

286
class AnimationNodeTimeScale : public AnimationNode {
287
	GDCLASS(AnimationNodeTimeScale, AnimationNode);
288

289
	StringName scale = PNAME("scale");
290

291
public:
292
	virtual void get_parameter_list(List<PropertyInfo> *r_list) const override;
293
	virtual Variant get_parameter_default_value(const StringName &p_parameter) const override;
294

295
	virtual String get_caption() const override;
296

297
	virtual NodeTimeInfo _process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only = false) override;
298

299
	AnimationNodeTimeScale();
300
};
301

302
class AnimationNodeTimeSeek : public AnimationNode {
303
	GDCLASS(AnimationNodeTimeSeek, AnimationNode);
304

305
	StringName seek_pos_request = PNAME("seek_request");
306
	bool explicit_elapse = true;
307

308
protected:
309
	static void _bind_methods();
310

311
public:
312
	virtual void get_parameter_list(List<PropertyInfo> *r_list) const override;
313
	virtual Variant get_parameter_default_value(const StringName &p_parameter) const override;
314

315
	virtual String get_caption() const override;
316

317
	virtual NodeTimeInfo _process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only = false) override;
318

319
	void set_explicit_elapse(bool p_enable);
320
	bool is_explicit_elapse() const;
321

322
	AnimationNodeTimeSeek();
323
};
324

325
class AnimationNodeTransition : public AnimationNodeSync {
326
	GDCLASS(AnimationNodeTransition, AnimationNodeSync);
327

328
	struct InputData {
329
		bool auto_advance = false;
330
		bool break_loop_at_end = false;
331
		bool reset = true;
332
	};
333
	LocalVector<InputData> input_data;
334

335
	StringName prev_xfading = "prev_xfading";
336
	StringName prev_index = "prev_index";
337
	StringName current_index = PNAME("current_index");
338
	StringName current_state = PNAME("current_state");
339
	StringName transition_request = PNAME("transition_request");
340

341
	StringName prev_frame_current = "pf_current";
342
	StringName prev_frame_current_idx = "pf_current_idx";
343

344
	double xfade_time = 0.0;
345
	Ref<Curve> xfade_curve;
346
	bool allow_transition_to_self = false;
347

348
	bool pending_update = false;
349

350
protected:
351
	bool _get(const StringName &p_path, Variant &r_ret) const;
352
	bool _set(const StringName &p_path, const Variant &p_value);
353
	static void _bind_methods();
354
	void _get_property_list(List<PropertyInfo> *p_list) const;
355

356
public:
357
	virtual void get_parameter_list(List<PropertyInfo> *r_list) const override;
358
	virtual Variant get_parameter_default_value(const StringName &p_parameter) const override;
359
	virtual bool is_parameter_read_only(const StringName &p_parameter) const override;
360

361
	virtual String get_caption() const override;
362

363
	void set_input_count(int p_inputs);
364

365
	virtual bool add_input(const String &p_name) override;
366
	virtual void remove_input(int p_index) override;
367
	virtual bool set_input_name(int p_input, const String &p_name) override;
368

369
	void set_input_as_auto_advance(int p_input, bool p_enable);
370
	bool is_input_set_as_auto_advance(int p_input) const;
371

372
	void set_input_break_loop_at_end(int p_input, bool p_enable);
373
	bool is_input_loop_broken_at_end(int p_input) const;
374

375
	void set_input_reset(int p_input, bool p_enable);
376
	bool is_input_reset(int p_input) const;
377

378
	void set_xfade_time(double p_fade);
379
	double get_xfade_time() const;
380

381
	void set_xfade_curve(const Ref<Curve> &p_curve);
382
	Ref<Curve> get_xfade_curve() const;
383

384
	void set_allow_transition_to_self(bool p_enable);
385
	bool is_allow_transition_to_self() const;
386

387
	virtual NodeTimeInfo _process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only = false) override;
388

389
	AnimationNodeTransition();
390
};
391

392
class AnimationNodeOutput : public AnimationNode {
393
	GDCLASS(AnimationNodeOutput, AnimationNode);
394

395
public:
396
	virtual String get_caption() const override;
397
	virtual NodeTimeInfo _process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only = false) override;
398
	AnimationNodeOutput();
399
};
400

401
/////
402

403
class AnimationNodeBlendTree : public AnimationRootNode {
404
	GDCLASS(AnimationNodeBlendTree, AnimationRootNode);
405

406
	struct Node {
407
		Ref<AnimationNode> node;
408
		Vector2 position;
409
		Vector<StringName> connections;
410
	};
411

412
	AHashMap<StringName, Node> nodes;
413

414
	Vector2 graph_offset;
415

416
	void _node_changed(const StringName &p_node);
417

418
	void _initialize_node_tree();
419

420
protected:
421
	static void _bind_methods();
422
	bool _set(const StringName &p_name, const Variant &p_value);
423
	bool _get(const StringName &p_name, Variant &r_ret) const;
424
	void _get_property_list(List<PropertyInfo> *p_list) const;
425

426
	virtual void _tree_changed() override;
427
	virtual void _animation_node_renamed(const ObjectID &p_oid, const String &p_old_name, const String &p_new_name) override;
428
	virtual void _animation_node_removed(const ObjectID &p_oid, const StringName &p_node) override;
429

430
	virtual void reset_state() override;
431

432
public:
433
	enum ConnectionError {
434
		CONNECTION_OK,
435
		CONNECTION_ERROR_NO_INPUT,
436
		CONNECTION_ERROR_NO_INPUT_INDEX,
437
		CONNECTION_ERROR_NO_OUTPUT,
438
		CONNECTION_ERROR_SAME_NODE,
439
		CONNECTION_ERROR_CONNECTION_EXISTS,
440
		//no need to check for cycles due to tree topology
441
	};
442

443
	void add_node(const StringName &p_name, Ref<AnimationNode> p_node, const Vector2 &p_position = Vector2());
444
	Ref<AnimationNode> get_node(const StringName &p_name) const;
445
	void remove_node(const StringName &p_name);
446
	void rename_node(const StringName &p_name, const StringName &p_new_name);
447
	bool has_node(const StringName &p_name) const;
448
	StringName get_node_name(const Ref<AnimationNode> &p_node) const;
449
	Vector<StringName> get_node_connection_array(const StringName &p_name) const;
450

451
	void set_node_position(const StringName &p_node, const Vector2 &p_position);
452
	Vector2 get_node_position(const StringName &p_node) const;
453

454
	virtual void get_child_nodes(List<ChildNode> *r_child_nodes) override;
455

456
	void connect_node(const StringName &p_input_node, int p_input_index, const StringName &p_output_node);
457
	void disconnect_node(const StringName &p_node, int p_input_index);
458

459
	struct NodeConnection {
460
		StringName input_node;
461
		int input_index = 0;
462
		StringName output_node;
463
	};
464

465
	ConnectionError can_connect_node(const StringName &p_input_node, int p_input_index, const StringName &p_output_node) const;
466
	void get_node_connections(List<NodeConnection> *r_connections) const;
467

468
	virtual String get_caption() const override;
469
	virtual NodeTimeInfo _process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only = false) override;
470

471
	LocalVector<StringName> get_node_list() const;
472
	TypedArray<StringName> get_node_list_as_typed_array() const;
473

474
	void set_graph_offset(const Vector2 &p_graph_offset);
475
	Vector2 get_graph_offset() const;
476

477
	virtual Ref<AnimationNode> get_child_by_name(const StringName &p_name) const override;
478

479
#ifdef TOOLS_ENABLED
480
	virtual void get_argument_options(const StringName &p_function, int p_idx, List<String> *r_options) const override;
481
#endif
482

483
	AnimationNodeBlendTree();
484
	~AnimationNodeBlendTree();
485
};
486

487
VARIANT_ENUM_CAST(AnimationNodeBlendTree::ConnectionError)
488

489
Product

Resources

Company
