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

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

748 lines
29 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
/**************************************************************************/
/* node.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 and fix formatting Using `misc/scripts/fix_headers.py` on all Godot files. Some missing header guards were added, and the header inclusion order was fixed in the Bullet module.
2018-01-05 00:50:27 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
#ifndef NODE_H
#define NODE_H
Reorganized core/ directory, it was too fatty already -Removed FuncRef, since Callable makes it obsolete -Removed int_types.h as its obsolete in c++11+ -Changed color names code
2020-11-07 23:33:38 +01:00
#include "core/string/node_path.h"
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
#include "core/templates/rb_map.h"
Reorganized core/ directory, it was too fatty already -Removed FuncRef, since Callable makes it obsolete -Removed int_types.h as its obsolete in c++11+ -Changed color names code
2020-11-07 23:33:38 +01:00
#include "core/variant/typed_array.h"
-Fixed SCREEN_TEXTURE and other related 2D shader parameters. -Fixded BackBuffercopy object
2017-06-27 03:58:03 +02:00
#include "scene/main/scene_tree.h"
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
-Fixed a few bugs in Viewport -Made a few demos using Viewport to show it's true power! -Fixed some start-up error messages.
2014-04-10 05:18:27 +02:00
class Viewport;
Add Node::get_window() method.
2023-01-10 08:40:44 +01:00
class Window;
Large improvements on scene packing and management -Ability to edit and keep changes of instanced scenes and sub-scenes -Ability to inherit from other scenes
2015-10-10 14:09:09 +02:00
class SceneState;
Complete rewrite of Tweens * Tweens were changed from Node to RefCounted. New API is inspired by DOTween. * Tweens are created and managed by SceneTree, similar to SceneTreeTimer, which makes them ultra cheap to use a lot. * Animating with Tweens is done by creating sequences of Tweeners. You create them from code and they autostart by default (fire-and-forget). * There are 4 Tweeners that cover the former Tween functionality: PropertyTweener, IntervalTweener, CallbackTweener and MethodTweener. * The methods were simplified a lot. Long argument lists are replaced with chained calls on Tweens and Tweeners. * Tweeners by default execute in sequence, so it's easy to create complex chained animations. * You can bind a Tween to a node. Tween will be removed automatically when the bound node is freed.
2020-09-05 03:05:30 +02:00
class Tween;
class PropertyTweener;
Optimize threading-sensitive node data for single-threaded processing
2023-05-17 01:44:41 +02:00
SAFE_FLAG_TYPE_PUN_GUARANTEES
SAFE_NUMERIC_TYPE_PUN_GUARANTEES(uint32_t)
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
class Node : public Object {
ObjectTypeDB was renamed to ClassDB. Types are meant to be more generic to Variant. All usages of "type" to refer to classes were renamed to "class" ClassDB has been exposed to GDScript. OBJ_TYPE() macro is now GDCLASS()
2017-01-03 03:03:46 +01:00
GDCLASS(Node, Object);
remove trailing whitespace
2016-03-09 00:00:52 +01:00
Optimize threading-sensitive node data for single-threaded processing
2023-05-17 01:44:41 +02:00
protected:
// During group processing, these are thread-safe.
// Outside group processing, these avoid the cost of sync by working as plain primitive types.
union MTFlag {
SafeFlag mt{};
bool st;
};
template <class T>
union MTNumeric {
SafeNumeric<T> mt{};
T st;
};
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
public:
Refactor Process Mode Implements https://github.com/godotengine/godot-proposals/issues/1835#issuecomment-727186192 * PauseMode is now ProcessMode, containing the following states: ``` PROCESS_MODE_INHERIT, // same as parent node PROCESS_MODE_NORMAL, // process only if not paused PROCESS_MODE_PAUSE_ONLY, // process only if paused PROCESS_MODE_ALWAYS, // process always PROCESS_MODE_DISABLED, // never process ``` * NOTIFICATION_PAUSED and NOTIFICATION_UNPAUSED are received effectively when the node is paused and unpaused (not any longer when pause mode is set in SceneTree). * Renamed some nodes that used ProcessMode/process_mode to specify a callback type to ProcessCallback to avoid clashes.
2021-02-18 19:52:29 +01:00
enum ProcessMode {
PROCESS_MODE_INHERIT, // same as parent node
PROCESS_MODE_PAUSABLE, // process only if not paused
PROCESS_MODE_WHEN_PAUSED, // process only if paused
PROCESS_MODE_ALWAYS, // process always
PROCESS_MODE_DISABLED, // never process
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
};
Refactor Node Processing * Node processing works on the concept of process groups. * A node group can be inherited, run on main thread, or a sub-thread. * Groups can be ordered. * Process priority is now present for physics. This is the first steps towards implementing https://github.com/godotengine/godot-proposals/issues/6424. No threading or thread guards exist yet in most of the scene code other than Node. That will have to be added later.
2023-04-10 18:45:53 +02:00
enum ProcessThreadGroup {
PROCESS_THREAD_GROUP_INHERIT,
PROCESS_THREAD_GROUP_MAIN_THREAD,
PROCESS_THREAD_GROUP_SUB_THREAD,
};
enum ProcessThreadMessages {
FLAG_PROCESS_THREAD_MESSAGES = 1,
FLAG_PROCESS_THREAD_MESSAGES_PHYSICS = 2,
FLAG_PROCESS_THREAD_MESSAGES_ALL = 3,
};
Add more options to Node.duplicate() to decide whether signals, groups and/or scripts should be set in the copied nodes or not; it's default value makes the method include everything, as usual
2017-02-20 20:05:01 +01:00
enum DuplicateFlags {
DUPLICATE_SIGNALS = 1,
DUPLICATE_GROUPS = 2,
DUPLICATE_SCRIPTS = 4,
Remove more instances of 'instance' being used as a verb
2022-11-16 00:13:39 +01:00
DUPLICATE_USE_INSTANTIATION = 8,
Let SceneTreeDock duplicate nodes via Node::duplicate() Helps with #11182.
2017-11-19 14:32:10 +01:00
#ifdef TOOLS_ENABLED
DUPLICATE_FROM_EDITOR = 16,
#endif
Add more options to Node.duplicate() to decide whether signals, groups and/or scripts should be set in the copied nodes or not; it's default value makes the method include everything, as usual
2017-02-20 20:05:01 +01:00
};
Name nodes added from drag & drop by `name_casing`
2021-07-29 06:26:34 +02:00
enum NameCasing {
NAME_CASING_PASCAL_CASE,
NAME_CASING_CAMEL_CASE,
NAME_CASING_SNAKE_CASE
};
Add support for internal nodes
2021-08-25 15:49:30 +02:00
enum InternalMode {
INTERNAL_MODE_DISABLED,
INTERNAL_MODE_FRONT,
INTERNAL_MODE_BACK,
};
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
struct Comparator {
bool operator()(const Node *p_a, const Node *p_b) const { return p_b->is_greater_than(p_a); }
};
Add a monitor for the orphan nodes - Allow the user to keep track of the nodes that might leak - Possible fix for #27103
2019-04-17 22:46:21 +02:00
static int orphan_node_count;
Refactor Node Processing * Node processing works on the concept of process groups. * A node group can be inherited, run on main thread, or a sub-thread. * Groups can be ordered. * Process priority is now present for physics. This is the first steps towards implementing https://github.com/godotengine/godot-proposals/issues/6424. No threading or thread guards exist yet in most of the scene code other than Node. That will have to be added later.
2023-04-10 18:45:53 +02:00
void _update_process(bool p_enable, bool p_for_children);
remove trailing whitespace
2016-03-09 00:00:52 +01:00
private:
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
struct GroupData {
Static analyzer fixes: Removes unused code in OS. Fixes return types. Fixes few typos.
2020-12-08 19:58:49 +01:00
bool persistent = false;
SceneTree::Group *group = nullptr;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
};
remove trailing whitespace
2016-03-09 00:00:52 +01:00
Optimize Node children management * Adding and removing child nodes is now constant time, speed up should be huge. * Searching for node paths as in ("path/to/node") should be far faster too. This changes the children management and makes it a hashmap, optimizing most StringName based operations. Most operations should be severe speed up without breaking compatibility. This should fix many issues regarding to node access performance, and may also speed up editor start/end, but benchmarks are needed. So if you want to test, please make some benchmarks! Further performance improvements will be done in the future by removing NOTIFICATION_MOVED_IN_PARENT and replacing by something less laborious.
2023-04-03 22:31:47 +02:00
struct ComparatorByIndex {
bool operator()(const Node *p_left, const Node *p_right) const {
static const uint32_t order[3] = { 1, 0, 2 };
uint32_t order_left = order[p_left->data.internal_mode];
uint32_t order_right = order[p_right->data.internal_mode];
if (order_left == order_right) {
return p_left->data.index < p_right->data.index;
}
return order_left < order_right;
}
};
Refactor Node Processing * Node processing works on the concept of process groups. * A node group can be inherited, run on main thread, or a sub-thread. * Groups can be ordered. * Process priority is now present for physics. This is the first steps towards implementing https://github.com/godotengine/godot-proposals/issues/6424. No threading or thread guards exist yet in most of the scene code other than Node. That will have to be added later.
2023-04-10 18:45:53 +02:00
struct ComparatorWithPriority {
bool operator()(const Node *p_a, const Node *p_b) const { return p_b->data.process_priority == p_a->data.process_priority ? p_b->is_greater_than(p_a) : p_b->data.process_priority > p_a->data.process_priority; }
};
struct ComparatorWithPhysicsPriority {
bool operator()(const Node *p_a, const Node *p_b) const { return p_b->data.physics_process_priority == p_a->data.physics_process_priority ? p_b->is_greater_than(p_a) : p_b->data.physics_process_priority > p_a->data.physics_process_priority; }
};
Comment not to remove `data` structs in some Nodes
2022-10-13 15:30:23 +02:00
// This Data struct is to avoid namespace pollution in derived classes.
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
struct Data {
Rename Node's `filename` property to `scene_file_path` for clarity
2021-09-30 16:30:55 +02:00
String scene_file_path;
Large improvements on scene packing and management -Ability to edit and keep changes of instanced scenes and sub-scenes -Ability to inherit from other scenes
2015-10-10 14:09:09 +02:00
Ref<SceneState> instance_state;
Ref<SceneState> inherited_state;
Move initialization of some classes to headers
2020-12-11 15:54:03 +01:00
Node *parent = nullptr;
Node *owner = nullptr;
Optimize Node children management * Adding and removing child nodes is now constant time, speed up should be huge. * Searching for node paths as in ("path/to/node") should be far faster too. This changes the children management and makes it a hashmap, optimizing most StringName based operations. Most operations should be severe speed up without breaking compatibility. This should fix many issues regarding to node access performance, and may also speed up editor start/end, but benchmarks are needed. So if you want to test, please make some benchmarks! Further performance improvements will be done in the future by removing NOTIFICATION_MOVED_IN_PARENT and replacing by something less laborious.
2023-04-03 22:31:47 +02:00
HashMap<StringName, Node *> children;
mutable bool children_cache_dirty = true;
mutable LocalVector<Node *> children_cache;
Implement Scene Unique Nodes Implements https://github.com/godotengine/godot-proposals/issues/4096 * Nodes can be marked unique to the scene in the editor (or via code). * Unique nodes can be accessed via the **%** prefix at any point in the path. From that point in the path (depending on whether the scene of the path is), the unique node will be fetched. * Implementation is very optimal, as these nodes are cached.
2022-04-16 12:23:32 +02:00
HashMap<StringName, Node *> owned_unique_nodes;
bool unique_name_in_owner = false;
Optimize Node children management * Adding and removing child nodes is now constant time, speed up should be huge. * Searching for node paths as in ("path/to/node") should be far faster too. This changes the children management and makes it a hashmap, optimizing most StringName based operations. Most operations should be severe speed up without breaking compatibility. This should fix many issues regarding to node access performance, and may also speed up editor start/end, but benchmarks are needed. So if you want to test, please make some benchmarks! Further performance improvements will be done in the future by removing NOTIFICATION_MOVED_IN_PARENT and replacing by something less laborious.
2023-04-03 22:31:47 +02:00
InternalMode internal_mode = INTERNAL_MODE_DISABLED;
mutable int internal_children_front_count_cache = 0;
mutable int internal_children_back_count_cache = 0;
mutable int external_children_count_cache = 0;
mutable int index = -1; // relative to front, normal or back.
Move initialization of some classes to headers
2020-12-11 15:54:03 +01:00
int depth = -1;
int blocked = 0; // Safeguard that throws an error when attempting to modify the tree in a harmful way while being traversed.
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
StringName name;
Move initialization of some classes to headers
2020-12-11 15:54:03 +01:00
SceneTree *tree = nullptr;
bool inside_tree = false;
bool ready_notified = false; // This is a small hack, so if a node is added during _ready() to the tree, it correctly gets the _ready() notification.
bool ready_first = true;
Import 3D Scene Improvements -=-=-=-=-=-=-=-=-=-=-=-=-=-=- -If re-importing from the "dependency changed" dialog, edited scene will keep the local changes. -Imported scene will keep track of changes in the source asset -Geometry changes in source geometry or nodes with a different transform will be updated. -Materials will be kept if changed locally. -New nodes added will be kept -If nodes were reparented or renamed, they will still keep track -Deleted notes will be restored, use the -noimp option to avoid this. -In general, you can trust that if you do local modifications to the imported scene, they will not be erased after re-import. -Erasing your changes is done by re-importing from the "Re-Import" menu, re-opening the "Import 3D Scene" dialog. This wil re-import fresh. Overall, This should allow you to work on a scene and see changes made to 3D assets in real-time. So Please test!!
2014-06-19 07:23:03 +02:00
#ifdef TOOLS_ENABLED
Move initialization of some classes to headers
2020-12-11 15:54:03 +01:00
NodePath import_path; // Path used when imported, used by scene editors to keep tracking.
Import 3D Scene Improvements -=-=-=-=-=-=-=-=-=-=-=-=-=-=- -If re-importing from the "dependency changed" dialog, edited scene will keep the local changes. -Imported scene will keep track of changes in the source asset -Geometry changes in source geometry or nodes with a different transform will be updated. -Materials will be kept if changed locally. -New nodes added will be kept -If nodes were reparented or renamed, they will still keep track -Deleted notes will be restored, use the -noimp option to avoid this. -In general, you can trust that if you do local modifications to the imported scene, they will not be erased after re-import. -Erasing your changes is done by re-importing from the "Re-Import" menu, re-opening the "Import 3D Scene" dialog. This wil re-import fresh. Overall, This should allow you to work on a scene and see changes made to 3D assets in real-time. So Please test!!
2014-06-19 07:23:03 +02:00
#endif
Refactor Process Mode Implements https://github.com/godotengine/godot-proposals/issues/1835#issuecomment-727186192 * PauseMode is now ProcessMode, containing the following states: ``` PROCESS_MODE_INHERIT, // same as parent node PROCESS_MODE_NORMAL, // process only if not paused PROCESS_MODE_PAUSE_ONLY, // process only if paused PROCESS_MODE_ALWAYS, // process always PROCESS_MODE_DISABLED, // never process ``` * NOTIFICATION_PAUSED and NOTIFICATION_UNPAUSED are received effectively when the node is paused and unpaused (not any longer when pause mode is set in SceneTree). * Renamed some nodes that used ProcessMode/process_mode to specify a callback type to ProcessCallback to avoid clashes.
2021-02-18 19:52:29 +01:00
String editor_description;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Move initialization of some classes to headers
2020-12-11 15:54:03 +01:00
Viewport *viewport = nullptr;
-Fixed a few bugs in Viewport -Made a few demos using Viewport to show it's true power! -Fixed some start-up error messages.
2014-04-10 05:18:27 +02:00
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, GroupData> grouped;
Move initialization of some classes to headers
2020-12-11 15:54:03 +01:00
List<Node *>::Element *OW = nullptr; // Owned element.
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
List<Node *> owned;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
Refactor Process Mode Implements https://github.com/godotengine/godot-proposals/issues/1835#issuecomment-727186192 * PauseMode is now ProcessMode, containing the following states: ``` PROCESS_MODE_INHERIT, // same as parent node PROCESS_MODE_NORMAL, // process only if not paused PROCESS_MODE_PAUSE_ONLY, // process only if paused PROCESS_MODE_ALWAYS, // process always PROCESS_MODE_DISABLED, // never process ``` * NOTIFICATION_PAUSED and NOTIFICATION_UNPAUSED are received effectively when the node is paused and unpaused (not any longer when pause mode is set in SceneTree). * Renamed some nodes that used ProcessMode/process_mode to specify a callback type to ProcessCallback to avoid clashes.
2021-02-18 19:52:29 +01:00
ProcessMode process_mode = PROCESS_MODE_INHERIT;
Node *process_owner = nullptr;
Refactor Node Processing * Node processing works on the concept of process groups. * A node group can be inherited, run on main thread, or a sub-thread. * Groups can be ordered. * Process priority is now present for physics. This is the first steps towards implementing https://github.com/godotengine/godot-proposals/issues/6424. No threading or thread guards exist yet in most of the scene code other than Node. That will have to be added later.
2023-04-10 18:45:53 +02:00
ProcessThreadGroup process_thread_group = PROCESS_THREAD_GROUP_INHERIT;
Node *process_thread_group_owner = nullptr;
int process_thread_group_order = 0;
BitField<ProcessThreadMessages> process_thread_messages;
void *process_group = nullptr; // to avoid cyclic dependency
Added high level networked multiplayer to Godot. It's complete, but absolutely and completely untested, undocumented and NSFW. Have fun :-)
2016-08-14 23:49:50 +02:00
Multiplayer networking renames/simplification Removes _networking_ prefix from some methods and members, now that multiplayer has been largely moved out of Node and SceneTree and is seperated into its own set of classes.
2021-09-07 23:35:19 +02:00
int multiplayer_authority = 1; // Server by default.
[Net] Modularize multiplayer, expose MultiplayerAPI to extensions. - RPC configurations are now dictionaries. - Script.get_rpc_methods renamed to Script.get_rpc_config. - Node.rpc[_id] and Callable.rpc now return an Error. - Refactor MultiplayerAPI to allow extension. - New MultiplayerAPI.rpc method with Array argument (for scripts). - Move the default MultiplayerAPI implementation to a module.
2022-07-12 23:12:42 +02:00
Variant rpc_config;
Added high level networked multiplayer to Godot. It's complete, but absolutely and completely untested, undocumented and NSFW. Have fun :-)
2016-08-14 23:49:50 +02:00
Move initialization of some classes to headers
2020-12-11 15:54:03 +01:00
// Variables used to properly sort the node when processing, ignored otherwise.
// TODO: Should move all the stuff below to bits.
bool physics_process = false;
Rename MainLoop methods to match Node methods
2020-12-22 10:50:29 +01:00
bool process = false;
Move initialization of some classes to headers
2020-12-11 15:54:03 +01:00
int process_priority = 0;
Refactor Node Processing * Node processing works on the concept of process groups. * A node group can be inherited, run on main thread, or a sub-thread. * Groups can be ordered. * Process priority is now present for physics. This is the first steps towards implementing https://github.com/godotengine/godot-proposals/issues/6424. No threading or thread guards exist yet in most of the scene code other than Node. That will have to be added later.
2023-04-10 18:45:53 +02:00
int physics_process_priority = 0;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Move initialization of some classes to headers
2020-12-11 15:54:03 +01:00
bool physics_process_internal = false;
Rename MainLoop methods to match Node methods
2020-12-22 10:50:29 +01:00
bool process_internal = false;
- _ready() callback only happens once now, if you want to receive it again, use request_ready() - C++ Nodes mostly do an internal process callback, so it does not conflict with users willing to use their own process callbacks - callbacks such as _input, _process, _fixed_process _unhandled_input, _unhandled_key_input do not requiere calling a function to enable them. They are enabled automatically if found on the script.
2017-01-10 22:02:19 +01:00
Move initialization of some classes to headers
2020-12-11 15:54:03 +01:00
bool input = false;
[Input] Add extra `shortcut_input` input processing step to process Unicode character input with Alt / Ctrl modifiers, after processing of shortcuts.
2022-01-11 14:59:52 +01:00
bool shortcut_input = false;
Move initialization of some classes to headers
2020-12-11 15:54:03 +01:00
bool unhandled_input = false;
bool unhandled_key_input = false;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Move initialization of some classes to headers
2020-12-11 15:54:03 +01:00
bool parent_owned = false;
bool in_constructor = true;
bool use_placeholder = false;
-fixes and more fixes to new scene system, seems stable now.. BUT DONT TRUST ME IT MAY STILL BREAK, USE WITH CARE!!
2015-10-17 00:11:23 +02:00
Move initialization of some classes to headers
2020-12-11 15:54:03 +01:00
bool display_folded = false;
Change how editable children data is stored Co-authored-by: hilfazer <az13337@gmail.com>
2021-01-17 23:37:40 +01:00
bool editable_instance = false;
Large improvements on scene packing and management -Ability to edit and keep changes of instanced scenes and sub-scenes -Ability to inherit from other scenes
2015-10-10 14:09:09 +02:00
Move initialization of some classes to headers
2020-12-11 15:54:03 +01:00
mutable NodePath *path_cache = nullptr;
Added high level networked multiplayer to Godot. It's complete, but absolutely and completely untested, undocumented and NSFW. Have fun :-)
2016-08-14 23:49:50 +02:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} data;
Rename multiplayer_api to just multiplayer. Only the class name retain the MultiplayerAPI name
2018-05-08 10:51:04 +02:00
Ref<MultiplayerAPI> multiplayer;
Use MultiplayerAPI class for high level networking Remove networking related logic from Node and SceneTree. SceneTree now simply relay all networking related stuff to MultiplayerAPI for compatibility
2018-03-03 18:30:11 +01:00
Use reference to constant in functions
2019-07-10 11:54:12 +02:00
void _print_tree_pretty(const String &prefix, const bool last);
remove trailing whitespace
2016-03-09 00:00:52 +01:00
void _print_tree(const Node *p_node);
Large improvements on scene packing and management -Ability to edit and keep changes of instanced scenes and sub-scenes -Ability to inherit from other scenes
2015-10-10 14:09:09 +02:00
Node *_get_child_by_name(const StringName &p_name) const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Preserve signal connections when replacing the target node
2016-06-09 16:24:12 +02:00
void _replace_connections_target(Node *p_new_target);
Added Node.find_node(mask) function by popular request
2015-06-08 05:33:10 +02:00
Refactor node naming APIs used by editor Make 'name_num_separator' a project setting Make all node operations separator-aware
2016-10-07 20:25:29 +02:00
void _validate_child_name(Node *p_child, bool p_force_human_readable = false);
Rewrote rename logic to be less buggy and more efficient, fixes #23803 and probably many recent bugs using GraphEdit
2019-01-10 22:52:47 +01:00
void _generate_serial_child_name(const Node *p_child, StringName &name) const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
remove trailing whitespace
2016-03-09 00:00:52 +01:00
void _propagate_reverse_notification(int p_notification);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
void _propagate_deferred_notification(int p_notification, bool p_reverse);
SceneMainLoop -> SceneTree -=-=-=-=-=-=-=-=-=-=-=-=-=- *YOUR SOURCE MIGHT NOT WORK* For mor information on fix: https://github.com/okamstudio/godot/wiki/devel_scene_tree Other stuff: -Shower of bullets demo -Fixes all around
2014-11-06 01:20:42 +01:00
void _propagate_enter_tree();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
void _propagate_ready();
SceneMainLoop -> SceneTree -=-=-=-=-=-=-=-=-=-=-=-=-=- *YOUR SOURCE MIGHT NOT WORK* For mor information on fix: https://github.com/okamstudio/godot/wiki/devel_scene_tree Other stuff: -Shower of bullets demo -Fixes all around
2014-11-06 01:20:42 +01:00
void _propagate_exit_tree();
Ensure that tree_exited signal really happens after tree exited, fixes #19641
2018-09-07 20:31:19 +02:00
void _propagate_after_exit_tree();
Add support for controlling physics nodes' behavior when disabled New property disable_mode to set different behaviors: Remove: remove from physics simulation MakeStatic: change body mode to static (doesn't affect area and soft body) KeepActive: do nothing Extra change: Handle disable/enable node state with specific notifications, in order to differentiate global pause from disabled nodes.
2021-06-18 03:09:40 +02:00
void _propagate_process_owner(Node *p_owner, int p_pause_notification, int p_enabled_notification);
Mark node groups as dirty for every children if parent is moved
2022-05-31 20:28:04 +02:00
void _propagate_groups_dirty();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Array _get_node_and_resource(const NodePath &p_path);
-convert to subscene keeps signal connections, fixes #1863
2015-05-10 20:45:33 +02:00
void _duplicate_signals(const Node *p_original, Node *p_copy) const;
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
Node *_duplicate(int p_flags, HashMap<const Node *, Node *> *r_duplimap = nullptr) const;
Fix several bugs related to node duplication and signals, closes #5405
2016-07-07 02:43:31 +02:00
Replace Array return types with TypedArray 2
2022-08-05 20:35:08 +02:00
TypedArray<StringName> _get_groups() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
[Net] Modularize multiplayer, expose MultiplayerAPI to extensions. - RPC configurations are now dictionaries. - Script.get_rpc_methods renamed to Script.get_rpc_config. - Node.rpc[_id] and Callable.rpc now return an Error. - Refactor MultiplayerAPI to allow extension. - New MultiplayerAPI.rpc method with Array argument (for scripts). - Move the default MultiplayerAPI implementation to a module.
2022-07-12 23:12:42 +02:00
Error _rpc_bind(const Variant **p_args, int p_argcount, Callable::CallError &r_error);
Error _rpc_id_bind(const Variant **p_args, int p_argcount, Callable::CallError &r_error);
Added high level networked multiplayer to Godot. It's complete, but absolutely and completely untested, undocumented and NSFW. Have fun :-)
2016-08-14 23:49:50 +02:00
SceneMainLoop -> SceneTree -=-=-=-=-=-=-=-=-=-=-=-=-=- *YOUR SOURCE MIGHT NOT WORK* For mor information on fix: https://github.com/okamstudio/godot/wiki/devel_scene_tree Other stuff: -Shower of bullets demo -Fixes all around
2014-11-06 01:20:42 +01:00
friend class SceneTree;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
SceneMainLoop -> SceneTree -=-=-=-=-=-=-=-=-=-=-=-=-=- *YOUR SOURCE MIGHT NOT WORK* For mor information on fix: https://github.com/okamstudio/godot/wiki/devel_scene_tree Other stuff: -Shower of bullets demo -Fixes all around
2014-11-06 01:20:42 +01:00
void _set_tree(SceneTree *p_tree);
Refactor Process Mode Implements https://github.com/godotengine/godot-proposals/issues/1835#issuecomment-727186192 * PauseMode is now ProcessMode, containing the following states: ``` PROCESS_MODE_INHERIT, // same as parent node PROCESS_MODE_NORMAL, // process only if not paused PROCESS_MODE_PAUSE_ONLY, // process only if paused PROCESS_MODE_ALWAYS, // process always PROCESS_MODE_DISABLED, // never process ``` * NOTIFICATION_PAUSED and NOTIFICATION_UNPAUSED are received effectively when the node is paused and unpaused (not any longer when pause mode is set in SceneTree). * Renamed some nodes that used ProcessMode/process_mode to specify a callback type to ProcessCallback to avoid clashes.
2021-02-18 19:52:29 +01:00
void _propagate_pause_notification(bool p_enable);
_FORCE_INLINE_ bool _can_process(bool p_paused) const;
Add support for controlling physics nodes' behavior when disabled New property disable_mode to set different behaviors: Remove: remove from physics simulation MakeStatic: change body mode to static (doesn't affect area and soft body) KeepActive: do nothing Extra change: Handle disable/enable node state with specific notifications, in order to differentiate global pause from disabled nodes.
2021-06-18 03:09:40 +02:00
_FORCE_INLINE_ bool _is_enabled() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implement Scene Unique Nodes Implements https://github.com/godotengine/godot-proposals/issues/4096 * Nodes can be marked unique to the scene in the editor (or via code). * Unique nodes can be accessed via the **%** prefix at any point in the path. From that point in the path (depending on whether the scene of the path is), the unique node will be fetched. * Implementation is very optimal, as these nodes are cached.
2022-04-16 12:23:32 +02:00
void _release_unique_name_in_owner();
void _acquire_unique_name_in_owner();
Avoid crash when adjusting a node tree that is not in the tree When node tree `A` is not in the tree, `remove_child(B)` will not automatically clean up the owners of `B` and `B`'s child nodes. This is convenient for implementing operations like `replace_by()`, but may have hidden dangers when manipulating the rest of the tree `A`. This commit makes it safe to manipulate the rest of `A` after freeing `B`.
2023-02-27 09:16:51 +01:00
void _clean_up_owner();
Optimize Node children management * Adding and removing child nodes is now constant time, speed up should be huge. * Searching for node paths as in ("path/to/node") should be far faster too. This changes the children management and makes it a hashmap, optimizing most StringName based operations. Most operations should be severe speed up without breaking compatibility. This should fix many issues regarding to node access performance, and may also speed up editor start/end, but benchmarks are needed. So if you want to test, please make some benchmarks! Further performance improvements will be done in the future by removing NOTIFICATION_MOVED_IN_PARENT and replacing by something less laborious.
2023-04-03 22:31:47 +02:00
_FORCE_INLINE_ void _update_children_cache() const {
if (unlikely(data.children_cache_dirty)) {
_update_children_cache_impl();
}
}
void _update_children_cache_impl() const;
Refactor Node Processing * Node processing works on the concept of process groups. * A node group can be inherited, run on main thread, or a sub-thread. * Groups can be ordered. * Process priority is now present for physics. This is the first steps towards implementing https://github.com/godotengine/godot-proposals/issues/6424. No threading or thread guards exist yet in most of the scene code other than Node. That will have to be added later.
2023-04-10 18:45:53 +02:00
// Process group management
void _add_process_group();
void _remove_process_group();
void _add_to_process_thread_group();
void _remove_from_process_thread_group();
void _remove_tree_from_process_thread_group();
void _add_tree_to_process_thread_group(Node *p_owner);
static thread_local Node *current_process_thread_group;
Variant _call_deferred_thread_group_bind(const Variant **p_args, int p_argcount, Callable::CallError &r_error);
Variant _call_thread_safe_bind(const Variant **p_args, int p_argcount, Callable::CallError &r_error);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
protected:
void _block() { data.blocked++; }
void _unblock() { data.blocked--; }
remove trailing whitespace
2016-03-09 00:00:52 +01:00
void _notification(int p_notification);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
virtual void add_child_notify(Node *p_child);
virtual void remove_child_notify(Node *p_child);
Add move_child_notify method in Node class
2014-12-03 05:17:23 +01:00
virtual void move_child_notify(Node *p_child);
Fix editor-only visibility for lights * Update visibility again for editor-only lights if owner changes. Fixes #26399, supersedes #52327
2022-06-23 08:19:18 +02:00
virtual void owner_changed_notify();
remove trailing whitespace
2016-03-09 00:00:52 +01:00
void _propagate_replace_owner(Node *p_owner, Node *p_by_owner);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
static void _bind_methods();
Refactor node naming APIs used by editor Make 'name_num_separator' a project setting Make all node operations separator-aware
2016-10-07 20:25:29 +02:00
static String _get_name_num_separator();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Large improvements on scene packing and management -Ability to edit and keep changes of instanced scenes and sub-scenes -Ability to inherit from other scenes
2015-10-10 14:09:09 +02:00
friend class SceneState;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Optimize Node children management * Adding and removing child nodes is now constant time, speed up should be huge. * Searching for node paths as in ("path/to/node") should be far faster too. This changes the children management and makes it a hashmap, optimizing most StringName based operations. Most operations should be severe speed up without breaking compatibility. This should fix many issues regarding to node access performance, and may also speed up editor start/end, but benchmarks are needed. So if you want to test, please make some benchmarks! Further performance improvements will be done in the future by removing NOTIFICATION_MOVED_IN_PARENT and replacing by something less laborious.
2023-04-03 22:31:47 +02:00
void _add_child_nocheck(Node *p_child, const StringName &p_name, InternalMode p_internal_mode = INTERNAL_MODE_DISABLED);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
void _set_owner_nocheck(Node *p_owner);
void _set_name_nocheck(const StringName &p_name);
Entirely removes BIND_VMETHOD in favor of GDVIRTUAL * `_gui_input`, `_input`, `_unhandled_input` and `_unhandled_key_input` are now regular C++ virutal functions. * Everything else converted to GDVIRTUAL * BIND_VMETHOD is gone, always use the new syntax from now on. Creating `_gui_input` method and using the binder to register events will no longer work, simply override the virtual function now.
2021-08-22 17:37:22 +02:00
//call from SceneTree
void _call_input(const Ref<InputEvent> &p_event);
[Input] Add extra `shortcut_input` input processing step to process Unicode character input with Alt / Ctrl modifiers, after processing of shortcuts.
2022-01-11 14:59:52 +01:00
void _call_shortcut_input(const Ref<InputEvent> &p_event);
Entirely removes BIND_VMETHOD in favor of GDVIRTUAL * `_gui_input`, `_input`, `_unhandled_input` and `_unhandled_key_input` are now regular C++ virutal functions. * Everything else converted to GDVIRTUAL * BIND_VMETHOD is gone, always use the new syntax from now on. Creating `_gui_input` method and using the binder to register events will no longer work, simply override the virtual function now.
2021-08-22 17:37:22 +02:00
void _call_unhandled_input(const Ref<InputEvent> &p_event);
void _call_unhandled_key_input(const Ref<InputEvent> &p_event);
Refactor Node Processing * Node processing works on the concept of process groups. * A node group can be inherited, run on main thread, or a sub-thread. * Groups can be ordered. * Process priority is now present for physics. This is the first steps towards implementing https://github.com/godotengine/godot-proposals/issues/6424. No threading or thread guards exist yet in most of the scene code other than Node. That will have to be added later.
2023-04-10 18:45:53 +02:00
void _validate_property(PropertyInfo &p_property) const;
Entirely removes BIND_VMETHOD in favor of GDVIRTUAL * `_gui_input`, `_input`, `_unhandled_input` and `_unhandled_key_input` are now regular C++ virutal functions. * Everything else converted to GDVIRTUAL * BIND_VMETHOD is gone, always use the new syntax from now on. Creating `_gui_input` method and using the binder to register events will no longer work, simply override the virtual function now.
2021-08-22 17:37:22 +02:00
protected:
virtual void input(const Ref<InputEvent> &p_event);
[Input] Add extra `shortcut_input` input processing step to process Unicode character input with Alt / Ctrl modifiers, after processing of shortcuts.
2022-01-11 14:59:52 +01:00
virtual void shortcut_input(const Ref<InputEvent> &p_key_event);
Entirely removes BIND_VMETHOD in favor of GDVIRTUAL * `_gui_input`, `_input`, `_unhandled_input` and `_unhandled_key_input` are now regular C++ virutal functions. * Everything else converted to GDVIRTUAL * BIND_VMETHOD is gone, always use the new syntax from now on. Creating `_gui_input` method and using the binder to register events will no longer work, simply override the virtual function now.
2021-08-22 17:37:22 +02:00
virtual void unhandled_input(const Ref<InputEvent> &p_event);
virtual void unhandled_key_input(const Ref<InputEvent> &p_key_event);
Replace BIND_VMETHOD by new GDVIRTUAL syntax * New syntax is type safe. * New syntax allows for type safe virtuals in native extensions. * New syntax permits extremely fast calling. Note: Everything was replaced where possible except for `_gui_input` `_input` and `_unhandled_input`. These will require API rework on a separate PR as they work different than the rest of the functions. Added a new method flag METHOD_FLAG_OBJECT_CORE, used internally. Allows to not dump the core virtuals like `_notification` to the json API, since each language will implement those as it is best fits.
2021-08-22 03:52:44 +02:00
GDVIRTUAL1(_process, double)
GDVIRTUAL1(_physics_process, double)
GDVIRTUAL0(_enter_tree)
GDVIRTUAL0(_exit_tree)
GDVIRTUAL0(_ready)
GDVIRTUAL0RC(Vector<String>, _get_configuration_warnings)
Entirely removes BIND_VMETHOD in favor of GDVIRTUAL * `_gui_input`, `_input`, `_unhandled_input` and `_unhandled_key_input` are now regular C++ virutal functions. * Everything else converted to GDVIRTUAL * BIND_VMETHOD is gone, always use the new syntax from now on. Creating `_gui_input` method and using the binder to register events will no longer work, simply override the virtual function now.
2021-08-22 17:37:22 +02:00
GDVIRTUAL1(_input, Ref<InputEvent>)
[Input] Add extra `shortcut_input` input processing step to process Unicode character input with Alt / Ctrl modifiers, after processing of shortcuts.
2022-01-11 14:59:52 +01:00
GDVIRTUAL1(_shortcut_input, Ref<InputEvent>)
Entirely removes BIND_VMETHOD in favor of GDVIRTUAL * `_gui_input`, `_input`, `_unhandled_input` and `_unhandled_key_input` are now regular C++ virutal functions. * Everything else converted to GDVIRTUAL * BIND_VMETHOD is gone, always use the new syntax from now on. Creating `_gui_input` method and using the binder to register events will no longer work, simply override the virtual function now.
2021-08-22 17:37:22 +02:00
GDVIRTUAL1(_unhandled_input, Ref<InputEvent>)
GDVIRTUAL1(_unhandled_key_input, Ref<InputEvent>)
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
public:
enum {
// you can make your own, but don't use the same numbers as other notifications in other nodes
SceneMainLoop -> SceneTree -=-=-=-=-=-=-=-=-=-=-=-=-=- *YOUR SOURCE MIGHT NOT WORK* For mor information on fix: https://github.com/okamstudio/godot/wiki/devel_scene_tree Other stuff: -Shower of bullets demo -Fixes all around
2014-11-06 01:20:42 +01:00
NOTIFICATION_ENTER_TREE = 10,
NOTIFICATION_EXIT_TREE = 11,
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
NOTIFICATION_MOVED_IN_PARENT = 12,
NOTIFICATION_READY = 13,
NOTIFICATION_PAUSED = 14,
NOTIFICATION_UNPAUSED = 15,
Renamed fixed_process to physics_process
2017-09-30 16:19:07 +02:00
NOTIFICATION_PHYSICS_PROCESS = 16,
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
NOTIFICATION_PROCESS = 17,
NOTIFICATION_PARENTED = 18,
NOTIFICATION_UNPARENTED = 19,
Rename NOTIFICATION_INSTANCED to NOTIFICATION_SCENE_INSTANTIATED
2022-08-15 00:50:31 +02:00
NOTIFICATION_SCENE_INSTANTIATED = 20,
-begun implementing drag & drop editor wide -filesystem dock dnd support -property list dnd support -scene tree dnd support
2016-05-11 16:46:08 +02:00
NOTIFICATION_DRAG_BEGIN = 21,
NOTIFICATION_DRAG_END = 22,
Rename Node's `NOTIFICATION_PATH_CHANGED` to `NOTIFICATION_PATH_RENAMED` The new name is less misleading, as the notification is only emitted when the node name (or one of its parents' names) is changed.
2021-09-04 00:12:37 +02:00
NOTIFICATION_PATH_RENAMED = 23,
Remove NOTIFICATION_MOVED_IN_PARENT * This notification makes node children management very inefficient. * Replaced by a NOTIFICATION_CHILDREN_CHANGED (and children_changed signal). * Changed Canvas code (and similar) to use the above signal, to perform more efficiently. This PR breaks compatibility (although this notification was very rarely used, even within the engine), but provides an alternate way to do the same. It is required for the changes in #75627 to be entirely effective.
2023-04-05 18:53:32 +02:00
NOTIFICATION_CHILD_ORDER_CHANGED = 24,
- _ready() callback only happens once now, if you want to receive it again, use request_ready() - C++ Nodes mostly do an internal process callback, so it does not conflict with users willing to use their own process callbacks - callbacks such as _input, _process, _fixed_process _unhandled_input, _unhandled_key_input do not requiere calling a function to enable them. They are enabled automatically if found on the script.
2017-01-10 22:02:19 +01:00
NOTIFICATION_INTERNAL_PROCESS = 25,
Renamed fixed_process to physics_process
2017-09-30 16:19:07 +02:00
NOTIFICATION_INTERNAL_PHYSICS_PROCESS = 26,
-New inspector. -Changed UI resizing code, gained huge amount of speed. -Reorganized timer sync to clean up behavior (sorry forgot commit this before) -
2018-05-15 22:12:35 +02:00
NOTIFICATION_POST_ENTER_TREE = 27,
Add support for controlling physics nodes' behavior when disabled New property disable_mode to set different behaviors: Remove: remove from physics simulation MakeStatic: change body mode to static (doesn't affect area and soft body) KeepActive: do nothing Extra change: Handle disable/enable node state with specific notifications, in order to differentiate global pause from disabled nodes.
2021-06-18 03:09:40 +02:00
NOTIFICATION_DISABLED = 28,
NOTIFICATION_ENABLED = 29,
Update instances of scenes which have been reimported.
2022-01-30 22:31:32 +01:00
NOTIFICATION_NODE_RECACHE_REQUESTED = 30,
Clean up notifications and merge Node and MainLoop ones for clarity, closes #27614
2019-04-04 15:34:03 +02:00
//keep these linked to node
Refactored input, goes all via windows now. Also renamed Input to InputFilter because all it does is filter events.
2020-03-04 17:36:09 +01:00
NOTIFICATION_WM_MOUSE_ENTER = 1002,
NOTIFICATION_WM_MOUSE_EXIT = 1003,
Add a separate application focus/in notification out from Window focus notification.
2020-06-30 01:47:18 +02:00
NOTIFICATION_WM_WINDOW_FOCUS_IN = 1004,
NOTIFICATION_WM_WINDOW_FOCUS_OUT = 1005,
Refactored input, goes all via windows now. Also renamed Input to InputFilter because all it does is filter events.
2020-03-04 17:36:09 +01:00
NOTIFICATION_WM_CLOSE_REQUEST = 1006,
NOTIFICATION_WM_GO_BACK_REQUEST = 1007,
Working multiple window support, including editor
2020-03-06 18:00:16 +01:00
NOTIFICATION_WM_SIZE_CHANGED = 1008,
Add macOS DisplayServer implementation. Change global menu to use Callable, add support for check items and submenus.
2020-03-07 17:02:54 +01:00
NOTIFICATION_WM_DPI_CHANGE = 1009,
Connect notifications from Container to Viewport mouse enter+exit
2022-02-15 22:14:39 +01:00
NOTIFICATION_VP_MOUSE_ENTER = 1010,
NOTIFICATION_VP_MOUSE_EXIT = 1011,
Refactored input, goes all via windows now. Also renamed Input to InputFilter because all it does is filter events.
2020-03-04 17:36:09 +01:00
Clean up notifications and merge Node and MainLoop ones for clarity, closes #27614
2019-04-04 15:34:03 +02:00
NOTIFICATION_OS_MEMORY_WARNING = MainLoop::NOTIFICATION_OS_MEMORY_WARNING,
NOTIFICATION_TRANSLATION_CHANGED = MainLoop::NOTIFICATION_TRANSLATION_CHANGED,
NOTIFICATION_WM_ABOUT = MainLoop::NOTIFICATION_WM_ABOUT,
NOTIFICATION_CRASH = MainLoop::NOTIFICATION_CRASH,
Add new events and accompanying logic to notify when the app is paused and resumed on Android devices.
2019-09-09 23:42:17 +02:00
NOTIFICATION_OS_IME_UPDATE = MainLoop::NOTIFICATION_OS_IME_UPDATE,
Add a separate application focus/in notification out from Window focus notification.
2020-06-30 01:47:18 +02:00
NOTIFICATION_APPLICATION_RESUMED = MainLoop::NOTIFICATION_APPLICATION_RESUMED,
NOTIFICATION_APPLICATION_PAUSED = MainLoop::NOTIFICATION_APPLICATION_PAUSED,
NOTIFICATION_APPLICATION_FOCUS_IN = MainLoop::NOTIFICATION_APPLICATION_FOCUS_IN,
[Complex Text Layouts] Refactor Font class, default themes and controls to use Text Server interface. Implement interface mirroring. Add TextLine and TextParagraph classes. Handle UTF-16 input on macOS and Windows.
2020-09-03 13:22:16 +02:00
NOTIFICATION_APPLICATION_FOCUS_OUT = MainLoop::NOTIFICATION_APPLICATION_FOCUS_OUT,
NOTIFICATION_TEXT_SERVER_CHANGED = MainLoop::NOTIFICATION_TEXT_SERVER_CHANGED,
New and improved IK system for Skeleton2D This PR and commit adds a new IK system for 2D with the Skeleton2D node that adds several new IK solvers, a way to control bones in a Skeleton2D node similar to that in Skeleton3D. It also adds additional changes and functionality. This work was sponsored by GSoC 2020 and TwistedTwigleg. Full list of changes: * Adds a SkeletonModifier2D resource * This resource is the base where all IK code is written and executed * Has a function for clamping angles, since it is so commonly used * Modifiers are unique when duplicated so it works with instancing * Adds a SkeletonModifierStack2D resource * This resource manages a series of SkeletonModification2Ds * This is what the Skeleton2D directly interfaces with to make IK possible * Adds SkeletonModifier2D resources for LookAt, CCDIK, FABRIK, Jiggle, and TwoBoneIK * Each modification is in its own file * There is also a SkeletonModifier2D resource that acts as a stack for using multiple stacks together * Adds a PhysicalBone2D node * Works similar to the PhysicalBone3D node, but uses a RigidBody2D node * Changes to Skeleton2D listed below: * Skeleton2D now holds a single SkeletonModificationStack2D for IK * Skeleton2D now has a local_pose_override, which overrides the Bone2D position similar to how the overrides work in Skeleton3D * Changes to Bone2D listed below: * The default_length property has been changed to length. Length is the length of the bone to its child bone node * New bone_angle property, which is the angle the bone has to its first child bone node * Bone2D caches its transform when not modified by IK for IK interpolation purposes * Bone2D draws its own editor gizmo, though this is stated to change in the future * Changes to CanvasItemEditor listed below: * Bone2D gizmo drawing code removed * The 2D IK code is removed. Now Bone2D is the only bone system for 2D * Transform2D now has a looking_at function for rotating to face a position * Two new node notifications: NOTIFICATION_EDITOR_PRE_SAVE and NOTIFICATION_EDITOR_POST_SAVE * These notifications only are called in the editor right before and after saving a scene * Needed for not saving the IK position when executing IK in the editor * Documentation for all the changes listed above.
2020-08-03 20:02:24 +02:00
// Editor specific node notifications
NOTIFICATION_EDITOR_PRE_SAVE = 9001,
NOTIFICATION_EDITOR_POST_SAVE = 9002,
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
};
remove trailing whitespace
2016-03-09 00:00:52 +01:00
/* NODE/TREE */
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
StringName get_name() const;
void set_name(const String &p_name);
remove trailing whitespace
2016-03-09 00:00:52 +01:00
Rename `legible_unique_name` param to `force_readable_name` With the introduction of Scene Unique Nodes, `is_unique_in_owner`, "Unique Name in Scene" and other descriptions related to the feature, the second parameter of add_child() and add_simbling() could be misunderstood to be related, at first glance.
2022-08-15 19:55:38 +02:00
void add_child(Node *p_child, bool p_force_readable_name = false, InternalMode p_internal = INTERNAL_MODE_DISABLED);
void add_sibling(Node *p_sibling, bool p_force_readable_name = false);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
void remove_child(Node *p_child);
remove trailing whitespace
2016-03-09 00:00:52 +01:00
Add support for internal nodes
2021-08-25 15:49:30 +02:00
int get_child_count(bool p_include_internal = true) const;
Node *get_child(int p_index, bool p_include_internal = true) const;
Make `Node::get_children()` public
2022-11-08 03:27:50 +01:00
TypedArray<Node> get_children(bool p_include_internal = true) const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
bool has_node(const NodePath &p_path) const;
Node *get_node(const NodePath &p_path) const;
Add check in folding to see if the nodepath exists to avoid message spam.
2019-01-29 17:15:34 +01:00
Node *get_node_or_null(const NodePath &p_path) const;
Node: Re-add `find_node` as `find_child`, improve docs The new name contrasts it better with `find_parent`, and makes it clear that it only matches child/descendant nodes. Also rename `find_nodes` to `find_children` accordingly.
2022-04-25 15:16:44 +02:00
Node *find_child(const String &p_pattern, bool p_recursive = true, bool p_owned = true) const;
TypedArray<Node> find_children(const String &p_pattern, const String &p_type = "", bool p_recursive = true, bool p_owned = true) const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
bool has_node_and_resource(const NodePath &p_path) const;
Remove `RES` and `REF` typedefs in favor of spelled out `Ref<>` These typedefs don't save much typing compared to the full `Ref<Resource>` and `Ref<RefCounted>`, yet they sometimes introduce confusion among new contributors.
2022-05-03 01:43:50 +02:00
Node *get_node_and_resource(const NodePath &p_path, Ref<Resource> &r_res, Vector<StringName> &r_leftover_subpath, bool p_last_is_property = true) const;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
Add methods for node reparenting
2020-02-17 18:29:14 +01:00
virtual void reparent(Node *p_parent, bool p_keep_global_transform = true);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Node *get_parent() const;
Node: Re-add `find_node` as `find_child`, improve docs The new name contrasts it better with `find_parent`, and makes it clear that it only matches child/descendant nodes. Also rename `find_nodes` to `find_children` accordingly.
2022-04-25 15:16:44 +02:00
Node *find_parent(const String &p_pattern) const;
Added find_parent method to node class
2018-09-15 18:22:06 +02:00
Add Node::get_window() method.
2023-01-10 08:40:44 +01:00
Window *get_window() const;
Expose dialog parent-and-popup logic to the API
2023-04-20 15:13:21 +02:00
Window *get_last_exclusive_window() const;
Add Node::get_window() method.
2023-01-10 08:40:44 +01:00
SceneMainLoop -> SceneTree -=-=-=-=-=-=-=-=-=-=-=-=-=- *YOUR SOURCE MIGHT NOT WORK* For mor information on fix: https://github.com/okamstudio/godot/wiki/devel_scene_tree Other stuff: -Shower of bullets demo -Fixes all around
2014-11-06 01:20:42 +01:00
_FORCE_INLINE_ SceneTree *get_tree() const {
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
ERR_FAIL_COND_V(!data.tree, nullptr);
SceneMainLoop -> SceneTree -=-=-=-=-=-=-=-=-=-=-=-=-=- *YOUR SOURCE MIGHT NOT WORK* For mor information on fix: https://github.com/okamstudio/godot/wiki/devel_scene_tree Other stuff: -Shower of bullets demo -Fixes all around
2014-11-06 01:20:42 +01:00
return data.tree;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
SceneMainLoop -> SceneTree -=-=-=-=-=-=-=-=-=-=-=-=-=- *YOUR SOURCE MIGHT NOT WORK* For mor information on fix: https://github.com/okamstudio/godot/wiki/devel_scene_tree Other stuff: -Shower of bullets demo -Fixes all around
2014-11-06 01:20:42 +01:00
_FORCE_INLINE_ bool is_inside_tree() const { return data.inside_tree; }
remove trailing whitespace
2016-03-09 00:00:52 +01:00
Rename `is_a_parent_of()` to `is_ancestor_of()`
2021-06-19 00:02:50 +02:00
bool is_ancestor_of(const Node *p_node) const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
bool is_greater_than(const Node *p_node) const;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
NodePath get_path() const;
Add option to get_path_to() to get the shortest path with unique name
2022-11-18 23:23:38 +01:00
NodePath get_path_to(const Node *p_node, bool p_use_unique_path = false) const;
WIP bugfix for existing connections
2016-07-20 01:04:06 +02:00
Node *find_common_parent_with(const Node *p_node) const;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
void add_to_group(const StringName &p_identifier, bool p_persistent = false);
void remove_from_group(const StringName &p_identifier);
bool is_in_group(const StringName &p_identifier) const;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
struct GroupInfo {
Large improvements on scene packing and management -Ability to edit and keep changes of instanced scenes and sub-scenes -Ability to inherit from other scenes
2015-10-10 14:09:09 +02:00
StringName name;
Initialize class variables with default values in scene/ [2/2]
2021-02-09 18:24:36 +01:00
bool persistent = false;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
};
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
void get_groups(List<GroupInfo> *p_groups) const;
Improve the scene tree signals/groups tooltip The tooltip now displays the number of connections and groups that are assigned to the hovered node.
2019-08-16 22:30:31 +02:00
int get_persistent_group_count() const;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
Rename pos -> index on Node
2022-10-14 20:21:41 +02:00
void move_child(Node *p_child, int p_index);
void _move_child(Node *p_child, int p_index, bool p_ignore_end = false);
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
void set_owner(Node *p_owner);
Node *get_owner() const;
void get_owned_by(Node *p_by, List<Node *> *p_owned);
remove trailing whitespace
2016-03-09 00:00:52 +01:00
Implement Scene Unique Nodes Implements https://github.com/godotengine/godot-proposals/issues/4096 * Nodes can be marked unique to the scene in the editor (or via code). * Unique nodes can be accessed via the **%** prefix at any point in the path. From that point in the path (depending on whether the scene of the path is), the unique node will be fetched. * Implementation is very optimal, as these nodes are cached.
2022-04-16 12:23:32 +02:00
void set_unique_name_in_owner(bool p_enabled);
bool is_unique_name_in_owner() const;
Optimize Node children management * Adding and removing child nodes is now constant time, speed up should be huge. * Searching for node paths as in ("path/to/node") should be far faster too. This changes the children management and makes it a hashmap, optimizing most StringName based operations. Most operations should be severe speed up without breaking compatibility. This should fix many issues regarding to node access performance, and may also speed up editor start/end, but benchmarks are needed. So if you want to test, please make some benchmarks! Further performance improvements will be done in the future by removing NOTIFICATION_MOVED_IN_PARENT and replacing by something less laborious.
2023-04-03 22:31:47 +02:00
_FORCE_INLINE_ int get_index(bool p_include_internal = true) const {
// p_include_internal = false doesn't make sense if the node is internal.
ERR_FAIL_COND_V_MSG(!p_include_internal && data.internal_mode != INTERNAL_MODE_DISABLED, -1, "Node is internal. Can't get index with 'include_internal' being false.");
if (!data.parent) {
return data.index;
}
data.parent->_update_children_cache();
if (!p_include_internal) {
return data.index;
} else {
switch (data.internal_mode) {
case INTERNAL_MODE_DISABLED: {
return data.parent->data.internal_children_front_count_cache + data.index;
} break;
case INTERNAL_MODE_FRONT: {
return data.index;
} break;
case INTERNAL_MODE_BACK: {
return data.parent->data.internal_children_front_count_cache + data.parent->data.external_children_count_cache + data.index;
} break;
}
return -1;
}
}
remove trailing whitespace
2016-03-09 00:00:52 +01:00
Complete rewrite of Tweens * Tweens were changed from Node to RefCounted. New API is inspired by DOTween. * Tweens are created and managed by SceneTree, similar to SceneTreeTimer, which makes them ultra cheap to use a lot. * Animating with Tweens is done by creating sequences of Tweeners. You create them from code and they autostart by default (fire-and-forget). * There are 4 Tweeners that cover the former Tween functionality: PropertyTweener, IntervalTweener, CallbackTweener and MethodTweener. * The methods were simplified a lot. Long argument lists are replaced with chained calls on Tweens and Tweeners. * Tweeners by default execute in sequence, so it's easy to create complex chained animations. * You can bind a Tween to a node. Tween will be removed automatically when the bound node is freed.
2020-09-05 03:05:30 +02:00
Ref<Tween> create_tween();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
void print_tree();
Made print_tree_pretty() function which displays scene tree graphically
2018-02-28 10:12:06 +01:00
void print_tree_pretty();
remove trailing whitespace
2016-03-09 00:00:52 +01:00
Rename Node's `filename` property to `scene_file_path` for clarity
2021-09-30 16:30:55 +02:00
void set_scene_file_path(const String &p_scene_file_path);
String get_scene_file_path() const;
Large improvements on scene packing and management -Ability to edit and keep changes of instanced scenes and sub-scenes -Ability to inherit from other scenes
2015-10-10 14:09:09 +02:00
Add an `editor_description` property to Node for documentation purposes It is implemented using editor-only metadata, in a way similar to edit locking or Position2D gizmo extents. This closes #2082.
2019-08-15 14:50:26 +02:00
void set_editor_description(const String &p_editor_description);
String get_editor_description() const;
Large improvements on scene packing and management -Ability to edit and keep changes of instanced scenes and sub-scenes -Ability to inherit from other scenes
2015-10-10 14:09:09 +02:00
void set_editable_instance(Node *p_node, bool p_editable);
Moved folding outside the resource files, now saved outside the project.
2018-10-29 20:36:31 +01:00
bool is_editable_instance(const Node *p_node) const;
Prevent selecting hidden nodes in 3D and Canvas Item editors
2021-02-21 09:19:48 +01:00
Node *get_deepest_editable_node(Node *p_start_node) const;
-fixes and more fixes to new scene system, seems stable now.. BUT DONT TRUST ME IT MAY STILL BREAK, USE WITH CARE!!
2015-10-17 00:11:23 +02:00
Add property value pinning
2021-10-26 21:12:25 +02:00
#ifdef TOOLS_ENABLED
void set_property_pinned(const String &p_property, bool p_pinned);
bool is_property_pinned(const StringName &p_property) const;
virtual StringName get_property_store_alias(const StringName &p_property) const;
Fix auto-translations in editor
2023-03-17 01:58:30 +01:00
bool is_part_of_edited_scene() const;
Add property value pinning
2021-10-26 21:12:25 +02:00
#endif
Add a new HashSet template * Intended to replace RBSet in most cases. * Optimized for iteration speed
2022-05-19 17:00:06 +02:00
void get_storable_properties(HashSet<StringName> &r_storable_properties) const;
Add property value pinning
2021-10-26 21:12:25 +02:00
Added Node name to print() when printing Nodes.
2021-07-11 16:40:18 +02:00
virtual String to_string() override;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/* NOTIFICATIONS */
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
void propagate_notification(int p_notification);
remove trailing whitespace
2016-03-09 00:00:52 +01:00
add "propagate_call" method to Node It is possible to propagate a notification down the Node tree by using `propagate_notification`, but there was no such method for doing the same but with method calls. This commit adds the `propagate_call` method, which calls a method on a node and all child nodes. An optional paramter `parent_first` determines whether the parent node gets called before or after the children have been visited. It defaults to false, so the parent gets called last.
2017-08-19 15:17:06 +02:00
void propagate_call(const StringName &p_method, const Array &p_args = Array(), const bool p_parent_first = false);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/* PROCESSING */
Renamed fixed_process to physics_process
2017-09-30 16:19:07 +02:00
void set_physics_process(bool p_process);
Use doubles for time in many other places
2021-02-02 03:16:37 +01:00
double get_physics_process_delta_time() const;
Renamed fixed_process to physics_process
2017-09-30 16:19:07 +02:00
bool is_physics_processing() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Rename MainLoop methods to match Node methods
2020-12-22 10:50:29 +01:00
void set_process(bool p_process);
Use doubles for time in many other places
2021-02-02 03:16:37 +01:00
double get_process_delta_time() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
bool is_processing() const;
Renamed fixed_process to physics_process
2017-09-30 16:19:07 +02:00
void set_physics_process_internal(bool p_process_internal);
bool is_physics_processing_internal() const;
- _ready() callback only happens once now, if you want to receive it again, use request_ready() - C++ Nodes mostly do an internal process callback, so it does not conflict with users willing to use their own process callbacks - callbacks such as _input, _process, _fixed_process _unhandled_input, _unhandled_key_input do not requiere calling a function to enable them. They are enabled automatically if found on the script.
2017-01-10 22:02:19 +01:00
Rename MainLoop methods to match Node methods
2020-12-22 10:50:29 +01:00
void set_process_internal(bool p_process_internal);
- _ready() callback only happens once now, if you want to receive it again, use request_ready() - C++ Nodes mostly do an internal process callback, so it does not conflict with users willing to use their own process callbacks - callbacks such as _input, _process, _fixed_process _unhandled_input, _unhandled_key_input do not requiere calling a function to enable them. They are enabled automatically if found on the script.
2017-01-10 22:02:19 +01:00
bool is_processing_internal() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implemented proceses priority
2018-07-02 07:30:40 +02:00
void set_process_priority(int p_priority);
Implement `Node::get_process_priority()` and its associated property This closes #33660.
2019-11-16 22:07:02 +01:00
int get_process_priority() const;
Implemented proceses priority
2018-07-02 07:30:40 +02:00
Refactor Node Processing * Node processing works on the concept of process groups. * A node group can be inherited, run on main thread, or a sub-thread. * Groups can be ordered. * Process priority is now present for physics. This is the first steps towards implementing https://github.com/godotengine/godot-proposals/issues/6424. No threading or thread guards exist yet in most of the scene code other than Node. That will have to be added later.
2023-04-10 18:45:53 +02:00
void set_process_thread_group_order(int p_order);
int get_process_thread_group_order() const;
void set_physics_process_priority(int p_priority);
int get_physics_process_priority() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
void set_process_input(bool p_enable);
bool is_processing_input() const;
[Input] Add extra `shortcut_input` input processing step to process Unicode character input with Alt / Ctrl modifiers, after processing of shortcuts.
2022-01-11 14:59:52 +01:00
void set_process_shortcut_input(bool p_enable);
bool is_processing_shortcut_input() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
void set_process_unhandled_input(bool p_enable);
bool is_processing_unhandled_input() const;
-Fixed a few bugs in Viewport -Made a few demos using Viewport to show it's true power! -Fixed some start-up error messages.
2014-04-10 05:18:27 +02:00
void set_process_unhandled_key_input(bool p_enable);
bool is_processing_unhandled_key_input() const;
Refactor Node Processing * Node processing works on the concept of process groups. * A node group can be inherited, run on main thread, or a sub-thread. * Groups can be ordered. * Process priority is now present for physics. This is the first steps towards implementing https://github.com/godotengine/godot-proposals/issues/6424. No threading or thread guards exist yet in most of the scene code other than Node. That will have to be added later.
2023-04-10 18:45:53 +02:00
_FORCE_INLINE_ bool _is_any_processing() const {
return data.process || data.process_internal || data.physics_process || data.physics_process_internal;
}
_FORCE_INLINE_ bool is_accessible_from_caller_thread() const {
if (current_process_thread_group == nullptr) {
// Not thread processing. Only accessible if node is outside the scene tree,
Let calls through thread guards in resource loading contexts
2023-05-17 00:39:13 +02:00
// if accessing from the main thread or being loaded.
return !data.inside_tree || Thread::is_main_thread() || ResourceLoader::is_within_load();
Refactor Node Processing * Node processing works on the concept of process groups. * A node group can be inherited, run on main thread, or a sub-thread. * Groups can be ordered. * Process priority is now present for physics. This is the first steps towards implementing https://github.com/godotengine/godot-proposals/issues/6424. No threading or thread guards exist yet in most of the scene code other than Node. That will have to be added later.
2023-04-10 18:45:53 +02:00
} else {
// Thread processing
return current_process_thread_group == data.process_thread_group_owner;
}
}
Make more base nodes thread safe Ongoing work to make more of the base nodes thread safe.
2023-05-12 13:53:15 +02:00
_FORCE_INLINE_ bool is_readable_from_caller_thread() const {
if (current_process_thread_group == nullptr) {
Let calls through thread guards in resource loading contexts
2023-05-17 00:39:13 +02:00
return Thread::is_main_thread() || ResourceLoader::is_within_load();
Make more base nodes thread safe Ongoing work to make more of the base nodes thread safe.
2023-05-12 13:53:15 +02:00
} else {
return true;
}
}
Optimize threading-sensitive node data for single-threaded processing
2023-05-17 01:44:41 +02:00
_FORCE_INLINE_ static bool is_group_processing() { return current_process_thread_group; }
Refactor Node Processing * Node processing works on the concept of process groups. * A node group can be inherited, run on main thread, or a sub-thread. * Groups can be ordered. * Process priority is now present for physics. This is the first steps towards implementing https://github.com/godotengine/godot-proposals/issues/6424. No threading or thread guards exist yet in most of the scene code other than Node. That will have to be added later.
2023-04-10 18:45:53 +02:00
void set_process_thread_messages(BitField<ProcessThreadMessages> p_flags);
BitField<ProcessThreadMessages> get_process_thread_messages() const;
Add more options to Node.duplicate() to decide whether signals, groups and/or scripts should be set in the copied nodes or not; it's default value makes the method include everything, as usual
2017-02-20 20:05:01 +01:00
Node *duplicate(int p_flags = DUPLICATE_GROUPS | DUPLICATE_SIGNALS | DUPLICATE_SCRIPTS) const;
Let SceneTreeDock duplicate nodes via Node::duplicate() Helps with #11182.
2017-11-19 14:32:10 +01:00
#ifdef TOOLS_ENABLED
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
Node *duplicate_from_editor(HashMap<const Node *, Node *> &r_duplimap) const;
Node *duplicate_from_editor(HashMap<const Node *, Node *> &r_duplimap, const HashMap<Ref<Resource>, Ref<Resource>> &p_resource_remap) const;
void remap_node_resources(Node *p_node, const HashMap<Ref<Resource>, Ref<Resource>> &p_resource_remap) const;
void remap_nested_resources(Ref<Resource> p_resource, const HashMap<Ref<Resource>, Ref<Resource>> &p_resource_remap) const;
Let SceneTreeDock duplicate nodes via Node::duplicate() Helps with #11182.
2017-11-19 14:32:10 +01:00
#endif
Live edit WORK IN PROGRESS 1) press the heart while the game is running 2) select a scene to live edit from the opened scenes 3) edit/add/remove nodes or resources, change their properties, etc. 4) watch changes reflected in running game, in all places this scene is edited 5) It's not perfect obviously, but the aim of it is to try to reflect your changes as best as possible in the running game.
2015-08-02 17:29:37 +02:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
// used by editors, to save what has changed only
Large improvements on scene packing and management -Ability to edit and keep changes of instanced scenes and sub-scenes -Ability to inherit from other scenes
2015-10-10 14:09:09 +02:00
void set_scene_instance_state(const Ref<SceneState> &p_state);
Ref<SceneState> get_scene_instance_state() const;
void set_scene_inherited_state(const Ref<SceneState> &p_state);
Ref<SceneState> get_scene_inherited_state() const;
-fixes and more fixes to new scene system, seems stable now.. BUT DONT TRUST ME IT MAY STILL BREAK, USE WITH CARE!!
2015-10-17 00:11:23 +02:00
void set_scene_instance_load_placeholder(bool p_enable);
bool get_scene_instance_load_placeholder() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Remove VARIANT_ARG* macros * Very old macros from the time Godot was created. * Limited arguments to 5 (then later changed to 8) in many places. * They were replaced by C++11 Variadic Templates. * Renamed methods that take argument pointers to have a "p" suffix. This was used in some places and not in others, so made it standard. * Also added a dereference check for Variant*. Helped catch a couple of bugs.
2022-03-09 14:58:40 +01:00
template <typename... VarArgs>
Vector<Variant> make_binds(VarArgs... p_args) {
Vector<Variant> binds = { p_args... };
return binds;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
void replace_by(Node *p_node, bool p_keep_data = false);
Refactor Process Mode Implements https://github.com/godotengine/godot-proposals/issues/1835#issuecomment-727186192 * PauseMode is now ProcessMode, containing the following states: ``` PROCESS_MODE_INHERIT, // same as parent node PROCESS_MODE_NORMAL, // process only if not paused PROCESS_MODE_PAUSE_ONLY, // process only if paused PROCESS_MODE_ALWAYS, // process always PROCESS_MODE_DISABLED, // never process ``` * NOTIFICATION_PAUSED and NOTIFICATION_UNPAUSED are received effectively when the node is paused and unpaused (not any longer when pause mode is set in SceneTree). * Renamed some nodes that used ProcessMode/process_mode to specify a callback type to ProcessCallback to avoid clashes.
2021-02-18 19:52:29 +01:00
void set_process_mode(ProcessMode p_mode);
ProcessMode get_process_mode() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
bool can_process() const;
Ensure process notification is received only if really enabled, fixes #7894
2018-07-30 02:20:41 +02:00
bool can_process_notification(int p_what) const;
Add support for controlling physics nodes' behavior when disabled New property disable_mode to set different behaviors: Remove: remove from physics simulation MakeStatic: change body mode to static (doesn't affect area and soft body) KeepActive: do nothing Extra change: Handle disable/enable node state with specific notifications, in order to differentiate global pause from disabled nodes.
2021-06-18 03:09:40 +02:00
bool is_enabled() const;
Prevent errors when using ViewportTexture
2023-04-06 14:47:49 +02:00
bool is_ready() const;
Refactor Node Processing * Node processing works on the concept of process groups. * A node group can be inherited, run on main thread, or a sub-thread. * Groups can be ordered. * Process priority is now present for physics. This is the first steps towards implementing https://github.com/godotengine/godot-proposals/issues/6424. No threading or thread guards exist yet in most of the scene code other than Node. That will have to be added later.
2023-04-10 18:45:53 +02:00
- _ready() callback only happens once now, if you want to receive it again, use request_ready() - C++ Nodes mostly do an internal process callback, so it does not conflict with users willing to use their own process callbacks - callbacks such as _input, _process, _fixed_process _unhandled_input, _unhandled_key_input do not requiere calling a function to enable them. They are enabled automatically if found on the script.
2017-01-10 22:02:19 +01:00
void request_ready();
Refactor Node Processing * Node processing works on the concept of process groups. * A node group can be inherited, run on main thread, or a sub-thread. * Groups can be ordered. * Process priority is now present for physics. This is the first steps towards implementing https://github.com/godotengine/godot-proposals/issues/6424. No threading or thread guards exist yet in most of the scene code other than Node. That will have to be added later.
2023-04-10 18:45:53 +02:00
void set_process_thread_group(ProcessThreadGroup p_mode);
ProcessThreadGroup get_process_thread_group() const;
Rename `Node.print_stray_nodes()` to `Node.print_orphan_nodes()` The "orphan" terminology is already used elsewhere.
2022-03-27 19:30:49 +02:00
static void print_orphan_nodes();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Refactor node naming APIs used by editor Make 'name_num_separator' a project setting Make all node operations separator-aware
2016-10-07 20:25:29 +02:00
#ifdef TOOLS_ENABLED
String validate_child_name(Node *p_child);
#endif
Unify node casing adjustment
2022-08-18 13:47:05 +02:00
static String adjust_name_casing(const String &p_name);
Live edit WORK IN PROGRESS 1) press the heart while the game is running 2) select a scene to live edit from the opened scenes 3) edit/add/remove nodes or resources, change their properties, etc. 4) watch changes reflected in running game, in all places this scene is edited 5) It's not perfect obviously, but the aim of it is to try to reflect your changes as best as possible in the running game.
2015-08-02 17:29:37 +02:00
Rename queue_delete => queue_free # Conflicts: # editor/plugins/tiles/tiles_editor_plugin.cpp
2022-10-24 23:07:02 +02:00
void queue_free();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Clean up some bad words from code comments
2018-02-17 14:00:39 +01:00
//hacks for speed
-added kinematic body -added kinematic body demos
2014-02-23 00:28:19 +01:00
static void init_node_hrcr();
-Support for changing fonts -Detect when free() might crash the project and throw error -fixed 2D Bounce in physics (3d still broken) -renamed “on_top” property to “behind_parent”, which makes more sense, old on_top remains there for compatibility but is invisible. -large amount of fixes
2014-04-05 17:39:30 +02:00
void force_parent_owned() { data.parent_owned = true; } //hack to avoid duplicate nodes
Import 3D Scene Improvements -=-=-=-=-=-=-=-=-=-=-=-=-=-=- -If re-importing from the "dependency changed" dialog, edited scene will keep the local changes. -Imported scene will keep track of changes in the source asset -Geometry changes in source geometry or nodes with a different transform will be updated. -Materials will be kept if changed locally. -New nodes added will be kept -If nodes were reparented or renamed, they will still keep track -Deleted notes will be restored, use the -noimp option to avoid this. -In general, you can trust that if you do local modifications to the imported scene, they will not be erased after re-import. -Erasing your changes is done by re-importing from the "Re-Import" menu, re-opening the "Import 3D Scene" dialog. This wil re-import fresh. Overall, This should allow you to work on a scene and see changes made to 3D assets in real-time. So Please test!!
2014-06-19 07:23:03 +02:00
void set_import_path(const NodePath &p_import_path); //path used when imported, used by scene editors to keep tracking
NodePath get_import_path() const;
property remove parent owned nodes when using replace, fixes #4128
2016-06-21 03:57:07 +02:00
bool is_owned_by_parent() const;
Add override keywords.
2020-07-10 12:34:39 +02:00
void get_argument_options(const StringName &p_function, int p_idx, List<String> *r_options) const override;
Import 3D Scene Improvements -=-=-=-=-=-=-=-=-=-=-=-=-=-=- -If re-importing from the "dependency changed" dialog, edited scene will keep the local changes. -Imported scene will keep track of changes in the source asset -Geometry changes in source geometry or nodes with a different transform will be updated. -Materials will be kept if changed locally. -New nodes added will be kept -If nodes were reparented or renamed, they will still keep track -Deleted notes will be restored, use the -noimp option to avoid this. -In general, you can trust that if you do local modifications to the imported scene, they will not be erased after re-import. -Erasing your changes is done by re-importing from the "Re-Import" menu, re-opening the "Import 3D Scene" dialog. This wil re-import fresh. Overall, This should allow you to work on a scene and see changes made to 3D assets in real-time. So Please test!!
2014-06-19 07:23:03 +02:00
Multiple scene editing *POTENTIALLY UNSTABLE* -ability to edit multiple scenes at the same time -resource internal IDs are now persistent, this makes multiple scene editing possible but maaaaay result in file corruption bugs (tested and could not find anything but possibility exists because core code changed, report immediately if you find this). -properly save settings, layout, etc when edited -script editing is independent from scene editing now -show a yellow box when a script belongs to the scene
2015-06-22 05:03:19 +02:00
void clear_internal_tree_resource_paths();
-Fixed a few bugs in Viewport -Made a few demos using Viewport to show it's true power! -Fixed some start-up error messages.
2014-04-10 05:18:27 +02:00
_FORCE_INLINE_ Viewport *get_viewport() const { return data.viewport; }
Change return type of `get_configuration_warnings` to `PackedStringArray`
2022-09-19 17:43:15 +02:00
virtual PackedStringArray get_configuration_warnings() const;
Use Array for node configuration warnings Previously, the warnings were passed as a string and delimitation of which were hard coded at each implementation.
2020-10-29 11:01:28 +01:00
String get_configuration_warnings_as_string() const;
-Added configuration warning system for nodes -Added a new "add" and "instance" buttons for scene tree -Added a vformat() function to ease translation work
2016-05-17 23:27:15 +02:00
Use Array for node configuration warnings Previously, the warnings were passed as a string and delimitation of which were hard coded at each implementation.
2020-10-29 11:01:28 +01:00
void update_configuration_warnings();
-Added configuration warning system for nodes -Added a new "add" and "instance" buttons for scene tree -Added a vformat() function to ease translation work
2016-05-17 23:27:15 +02:00
Change method of storing folding, solves problems with inheritance, closes #3395
2016-06-28 18:10:15 +02:00
void set_display_folded(bool p_folded);
bool is_displayed_folded() const;
Added high level networked multiplayer to Godot. It's complete, but absolutely and completely untested, undocumented and NSFW. Have fun :-)
2016-08-14 23:49:50 +02:00
/* NETWORK */
[Net] New replication interface, spawner and synchronizer nodes. Initial implementation of the MultiplayerReplicationInterface and its default implementation (SceneReplicationInterface). New MultiplayerSpawner node helps dealing with instantiation of scenes on remote peers (e.g. clients). It supports both custom spawns via a `_spawn_custom` virtual function, and optional auto-spawn of known scenes via a TypedArray<PackedScenes> property. New MultiplayerSynchornizer helps synchronizing states between the local and remote peers, supports both sync and spawn properties and is configured via a `SceneReplicationConfig` resource. It can also sync via path (i.e. without being spawned by a MultiplayerSpawner if both peers has it in tree, but will not send the spawn state in that case, only the sync one.
2021-10-08 14:13:06 +02:00
virtual void set_multiplayer_authority(int p_peer_id, bool p_recursive = true);
Multiplayer networking renames/simplification Removes _networking_ prefix from some methods and members, now that multiplayer has been largely moved out of Node and SceneTree and is seperated into its own set of classes.
2021-09-07 23:35:19 +02:00
int get_multiplayer_authority() const;
bool is_multiplayer_authority() const;
Added high level networked multiplayer to Godot. It's complete, but absolutely and completely untested, undocumented and NSFW. Have fun :-)
2016-08-14 23:49:50 +02:00
[Net] Modularize multiplayer, expose MultiplayerAPI to extensions. - RPC configurations are now dictionaries. - Script.get_rpc_methods renamed to Script.get_rpc_config. - Node.rpc[_id] and Callable.rpc now return an Error. - Refactor MultiplayerAPI to allow extension. - New MultiplayerAPI.rpc method with Array argument (for scripts). - Move the default MultiplayerAPI implementation to a module.
2022-07-12 23:12:42 +02:00
void rpc_config(const StringName &p_method, const Variant &p_config); // config a local method for RPC
const Variant get_node_rpc_config() const;
Added high level networked multiplayer to Godot. It's complete, but absolutely and completely untested, undocumented and NSFW. Have fun :-)
2016-08-14 23:49:50 +02:00
Remove VARIANT_ARG* macros * Very old macros from the time Godot was created. * Limited arguments to 5 (then later changed to 8) in many places. * They were replaced by C++11 Variadic Templates. * Renamed methods that take argument pointers to have a "p" suffix. This was used in some places and not in others, so made it standard. * Also added a dereference check for Variant*. Helped catch a couple of bugs.
2022-03-09 14:58:40 +01:00
template <typename... VarArgs>
[Net] Modularize multiplayer, expose MultiplayerAPI to extensions. - RPC configurations are now dictionaries. - Script.get_rpc_methods renamed to Script.get_rpc_config. - Node.rpc[_id] and Callable.rpc now return an Error. - Refactor MultiplayerAPI to allow extension. - New MultiplayerAPI.rpc method with Array argument (for scripts). - Move the default MultiplayerAPI implementation to a module.
2022-07-12 23:12:42 +02:00
Error rpc(const StringName &p_method, VarArgs... p_args);
Remove VARIANT_ARG* macros * Very old macros from the time Godot was created. * Limited arguments to 5 (then later changed to 8) in many places. * They were replaced by C++11 Variadic Templates. * Renamed methods that take argument pointers to have a "p" suffix. This was used in some places and not in others, so made it standard. * Also added a dereference check for Variant*. Helped catch a couple of bugs.
2022-03-09 14:58:40 +01:00
template <typename... VarArgs>
[Net] Modularize multiplayer, expose MultiplayerAPI to extensions. - RPC configurations are now dictionaries. - Script.get_rpc_methods renamed to Script.get_rpc_config. - Node.rpc[_id] and Callable.rpc now return an Error. - Refactor MultiplayerAPI to allow extension. - New MultiplayerAPI.rpc method with Array argument (for scripts). - Move the default MultiplayerAPI implementation to a module.
2022-07-12 23:12:42 +02:00
Error rpc_id(int p_peer_id, const StringName &p_method, VarArgs... p_args);
Remove VARIANT_ARG* macros * Very old macros from the time Godot was created. * Limited arguments to 5 (then later changed to 8) in many places. * They were replaced by C++11 Variadic Templates. * Renamed methods that take argument pointers to have a "p" suffix. This was used in some places and not in others, so made it standard. * Also added a dereference check for Variant*. Helped catch a couple of bugs.
2022-03-09 14:58:40 +01:00
[Net] Modularize multiplayer, expose MultiplayerAPI to extensions. - RPC configurations are now dictionaries. - Script.get_rpc_methods renamed to Script.get_rpc_config. - Node.rpc[_id] and Callable.rpc now return an Error. - Refactor MultiplayerAPI to allow extension. - New MultiplayerAPI.rpc method with Array argument (for scripts). - Move the default MultiplayerAPI implementation to a module.
2022-07-12 23:12:42 +02:00
Error rpcp(int p_peer_id, const StringName &p_method, const Variant **p_arg, int p_argcount);
Added high level networked multiplayer to Godot. It's complete, but absolutely and completely untested, undocumented and NSFW. Have fun :-)
2016-08-14 23:49:50 +02:00
Rename multiplayer_api to just multiplayer. Only the class name retain the MultiplayerAPI name
2018-05-08 10:51:04 +02:00
Ref<MultiplayerAPI> get_multiplayer() const;
Optmized data sent during RPC and RSet calls. - Now is sent the method ID rather the full function name. - The passed IDs (Node and Method) are compressed so to use less possible space. - The variant (INT and BOOL) is now encoded and compressed so to use much less data. - Optimized RPCMode retrieval for GDScript functions. - Added checksum to assert the methods are the same across peers. This work has been kindly sponsored by IMVU.
2020-02-12 11:51:50 +01:00
Refactor Node Processing * Node processing works on the concept of process groups. * A node group can be inherited, run on main thread, or a sub-thread. * Groups can be ordered. * Process priority is now present for physics. This is the first steps towards implementing https://github.com/godotengine/godot-proposals/issues/6424. No threading or thread guards exist yet in most of the scene code other than Node. That will have to be added later.
2023-04-10 18:45:53 +02:00
void call_deferred_thread_groupp(const StringName &p_method, const Variant **p_args, int p_argcount, bool p_show_error = false);
template <typename... VarArgs>
void call_deferred_thread_group(const StringName &p_method, VarArgs... p_args) {
Variant args[sizeof...(p_args) + 1] = { p_args..., Variant() }; // +1 makes sure zero sized arrays are also supported.
const Variant *argptrs[sizeof...(p_args) + 1];
for (uint32_t i = 0; i < sizeof...(p_args); i++) {
argptrs[i] = &args[i];
}
call_deferred_thread_groupp(p_method, sizeof...(p_args) == 0 ? nullptr : (const Variant **)argptrs, sizeof...(p_args));
}
void set_deferred_thread_group(const StringName &p_property, const Variant &p_value);
void notify_deferred_thread_group(int p_notification);
void call_thread_safep(const StringName &p_method, const Variant **p_args, int p_argcount, bool p_show_error = false);
template <typename... VarArgs>
void call_thread_safe(const StringName &p_method, VarArgs... p_args) {
Variant args[sizeof...(p_args) + 1] = { p_args..., Variant() }; // +1 makes sure zero sized arrays are also supported.
const Variant *argptrs[sizeof...(p_args) + 1];
for (uint32_t i = 0; i < sizeof...(p_args); i++) {
argptrs[i] = &args[i];
}
call_deferred_thread_groupp(p_method, sizeof...(p_args) == 0 ? nullptr : (const Variant **)argptrs, sizeof...(p_args));
}
void set_thread_safe(const StringName &p_property, const Variant &p_value);
void notify_thread_safe(int p_notification);
Make more base nodes thread safe Ongoing work to make more of the base nodes thread safe.
2023-05-12 13:53:15 +02:00
// These inherited functions need proper multithread locking when overridden in Node.
#ifdef DEBUG_ENABLED
virtual void set_script(const Variant &p_script) override;
virtual Variant get_script() const override;
virtual bool has_meta(const StringName &p_name) const override;
virtual void set_meta(const StringName &p_name, const Variant &p_value) override;
virtual void remove_meta(const StringName &p_name) override;
virtual Variant get_meta(const StringName &p_name, const Variant &p_default = Variant()) const override;
virtual void get_meta_list(List<StringName> *p_list) const override;
virtual Error emit_signalp(const StringName &p_name, const Variant **p_args, int p_argcount) override;
virtual bool has_signal(const StringName &p_name) const override;
virtual void get_signal_list(List<MethodInfo> *p_signals) const override;
virtual void get_signal_connection_list(const StringName &p_signal, List<Connection> *p_connections) const override;
virtual void get_all_signal_connections(List<Connection> *p_connections) const override;
virtual int get_persistent_signal_connection_count() const override;
virtual void get_signals_connected_to_this(List<Connection> *p_connections) const override;
virtual Error connect(const StringName &p_signal, const Callable &p_callable, uint32_t p_flags = 0) override;
virtual void disconnect(const StringName &p_signal, const Callable &p_callable) override;
virtual bool is_connected(const StringName &p_signal, const Callable &p_callable) const override;
#endif
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Node();
~Node();
};
ClassDB: Provide the enum name of integer constants
2017-08-20 17:45:01 +02:00
VARIANT_ENUM_CAST(Node::DuplicateFlags);
Add a new HashSet template * Intended to replace RBSet in most cases. * Optimized for iteration speed
2022-05-19 17:00:06 +02:00
typedef HashSet<Node *, Node::Comparator> NodeSet;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
move rpc and rpc_id implementations back to header StackOverflow on why this is needed: https://stackoverflow.com/questions/495021/why-can-templates-only-be-implemented-in-the-header-file Minor mistake in commit ca7d572908c58c587214b8f65bdd4078d0185ab2
2022-08-02 12:47:16 +02:00
// Template definitions must be in the header so they are always fully initialized before their usage.
// See this StackOverflow question for more information: https://stackoverflow.com/questions/495021/why-can-templates-only-be-implemented-in-the-header-file
template <typename... VarArgs>
Error Node::rpc(const StringName &p_method, VarArgs... p_args) {
return rpc_id(0, p_method, p_args...);
}
template <typename... VarArgs>
Error Node::rpc_id(int p_peer_id, const StringName &p_method, VarArgs... p_args) {
Variant args[sizeof...(p_args) + 1] = { p_args..., Variant() }; // +1 makes sure zero sized arrays are also supported.
const Variant *argptrs[sizeof...(p_args) + 1];
for (uint32_t i = 0; i < sizeof...(p_args); i++) {
argptrs[i] = &args[i];
}
return rpcp(p_peer_id, p_method, sizeof...(p_args) == 0 ? nullptr : (const Variant **)argptrs, sizeof...(p_args));
}
Refactor Node Processing * Node processing works on the concept of process groups. * A node group can be inherited, run on main thread, or a sub-thread. * Groups can be ordered. * Process priority is now present for physics. This is the first steps towards implementing https://github.com/godotengine/godot-proposals/issues/6424. No threading or thread guards exist yet in most of the scene code other than Node. That will have to be added later.
2023-04-10 18:45:53 +02:00
#ifdef DEBUG_ENABLED
#define ERR_THREAD_GUARD ERR_FAIL_COND_MSG(!is_accessible_from_caller_thread(), "Caller thread can't call this function in this node. Use call_deferred() or call_thread_group() instead.");
#define ERR_THREAD_GUARD_V(m_ret) ERR_FAIL_COND_V_MSG(!is_accessible_from_caller_thread(), (m_ret), "Caller thread can't call this function in this node. Use call_deferred() or call_thread_group() instead.")
#define ERR_MAIN_THREAD_GUARD ERR_FAIL_COND_MSG(is_inside_tree() && !Thread::is_main_thread(), "This function in this node can only be accessed from the main thread. Use call_deferred() instead.");
#define ERR_MAIN_THREAD_GUARD_V(m_ret) ERR_FAIL_COND_V_MSG(is_inside_tree() && !Thread::is_main_thread(), (m_ret), "This function in this node can only be accessed from the main thread. Use call_deferred() instead.")
Make more base nodes thread safe Ongoing work to make more of the base nodes thread safe.
2023-05-12 13:53:15 +02:00
#define ERR_READ_THREAD_GUARD ERR_FAIL_COND_MSG(!is_readable_from_caller_thread(), "This function in this node can only be accessed from either the main thread or a thread group. Use call_deferred() instead.")
#define ERR_READ_THREAD_GUARD_V(m_ret) ERR_FAIL_COND_V_MSG(!is_readable_from_caller_thread(), (m_ret), "This function in this node can only be accessed from either the main thread or a thread group. Use call_deferred() instead.")
Refactor Node Processing * Node processing works on the concept of process groups. * A node group can be inherited, run on main thread, or a sub-thread. * Groups can be ordered. * Process priority is now present for physics. This is the first steps towards implementing https://github.com/godotengine/godot-proposals/issues/6424. No threading or thread guards exist yet in most of the scene code other than Node. That will have to be added later.
2023-04-10 18:45:53 +02:00
#else
#define ERR_THREAD_GUARD
#define ERR_THREAD_GUARD_V(m_ret)
#define ERR_MAIN_THREAD_GUARD
#define ERR_MAIN_THREAD_GUARD_V(m_ret)
Make more base nodes thread safe Ongoing work to make more of the base nodes thread safe.
2023-05-12 13:53:15 +02:00
#define ERR_READ_THREAD_GUARD
#define ERR_READ_THREAD_GUARD_V(m_ret)
Refactor Node Processing * Node processing works on the concept of process groups. * A node group can be inherited, run on main thread, or a sub-thread. * Groups can be ordered. * Process priority is now present for physics. This is the first steps towards implementing https://github.com/godotengine/godot-proposals/issues/6424. No threading or thread guards exist yet in most of the scene code other than Node. That will have to be added later.
2023-04-10 18:45:53 +02:00
#endif
Add ability to flag classes as experimental or deprecated.
2022-08-28 08:17:25 +02:00
// Add these macro to your class's 'get_configuration_warnings' function to have warnings show up in the scene tree inspector.
#define DEPRECATED_NODE_WARNING warnings.push_back(RTR("This node is marked as deprecated and will be removed in future versions.\nPlease check the Godot documentation for information about migration."));
#define EXPERIMENTAL_NODE_WARNING warnings.push_back(RTR("This node is marked as experimental and may be subject to removal or major changes in future versions."));
Code quality: Fix header guards consistency Adds `header_guards.sh` bash script, used in CI to validate future changes. Can be run locally to fix invalid header guards.
2022-07-23 23:41:51 +02:00
#endif // NODE_H
Reference in a new issue Copy permalink