2014-02-10 02:10:30 +01:00
|
|
|
/*************************************************************************/
|
|
|
|
/* node.h */
|
|
|
|
/*************************************************************************/
|
|
|
|
/* This file is part of: */
|
|
|
|
/* GODOT ENGINE */
|
|
|
|
/* http://www.godotengine.org */
|
|
|
|
/*************************************************************************/
|
2016-01-01 14:50:53 +01:00
|
|
|
/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */
|
2014-02-10 02:10:30 +01:00
|
|
|
/* */
|
|
|
|
/* 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. */
|
|
|
|
/*************************************************************************/
|
|
|
|
#ifndef NODE_H
|
|
|
|
#define NODE_H
|
|
|
|
|
|
|
|
#include "object.h"
|
|
|
|
#include "path_db.h"
|
|
|
|
#include "map.h"
|
|
|
|
#include "object_type_db.h"
|
|
|
|
#include "script_language.h"
|
|
|
|
#include "scene/main/scene_main_loop.h"
|
|
|
|
|
|
|
|
|
2014-04-10 05:18:27 +02:00
|
|
|
class Viewport;
|
2015-10-10 14:09:09 +02:00
|
|
|
class SceneState;
|
2014-02-10 02:10:30 +01:00
|
|
|
class Node : public Object {
|
|
|
|
|
|
|
|
OBJ_TYPE( Node, Object );
|
|
|
|
OBJ_CATEGORY("Nodes");
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
public:
|
|
|
|
|
|
|
|
enum PauseMode {
|
|
|
|
|
|
|
|
PAUSE_MODE_INHERIT,
|
|
|
|
PAUSE_MODE_STOP,
|
|
|
|
PAUSE_MODE_PROCESS
|
|
|
|
};
|
|
|
|
|
2016-08-14 23:49:50 +02:00
|
|
|
enum NetworkMode {
|
|
|
|
|
|
|
|
NETWORK_MODE_INHERIT,
|
|
|
|
NETWORK_MODE_MASTER,
|
|
|
|
NETWORK_MODE_SLAVE
|
|
|
|
};
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2016-08-19 21:48:08 +02:00
|
|
|
enum RPCMode {
|
|
|
|
|
|
|
|
RPC_MODE_DISABLED, //no rpc for this method, calls to this will be blocked (default)
|
|
|
|
RPC_MODE_REMOTE, // using rpc() on it will call method / set property in all other peers
|
|
|
|
RPC_MODE_SYNC, // using rpc() on it will call method / set property in all other peers and locally
|
|
|
|
RPC_MODE_MASTER, // usinc rpc() on it will call method on wherever the master is, be it local or remote
|
|
|
|
RPC_MODE_SLAVE, // usinc rpc() on it will call method for all slaves, be it local or remote
|
|
|
|
};
|
|
|
|
|
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); }
|
|
|
|
};
|
|
|
|
|
2016-03-09 00:00:52 +01:00
|
|
|
private:
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
struct GroupData {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
|
|
|
bool persistent;
|
2016-06-08 03:08:12 +02:00
|
|
|
SceneTree::Group *group;
|
2014-02-10 02:10:30 +01:00
|
|
|
GroupData() { persistent=false; }
|
|
|
|
};
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2016-08-14 23:49:50 +02:00
|
|
|
|
2016-08-19 21:48:08 +02:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
struct Data {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
String filename;
|
2015-10-10 14:09:09 +02:00
|
|
|
Ref<SceneState> instance_state;
|
|
|
|
Ref<SceneState> inherited_state;
|
|
|
|
|
|
|
|
HashMap<NodePath,int> editable_instances;
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
Node *parent;
|
|
|
|
Node *owner;
|
|
|
|
Vector<Node*> children; // list of children
|
|
|
|
int pos;
|
|
|
|
int depth;
|
|
|
|
int blocked; // safeguard that throws an error when attempting to modify the tree in a harmful way while being traversed.
|
|
|
|
StringName name;
|
2014-11-06 01:20:42 +01:00
|
|
|
SceneTree *tree;
|
|
|
|
bool inside_tree;
|
2014-06-19 07:23:03 +02:00
|
|
|
#ifdef TOOLS_ENABLED
|
|
|
|
NodePath import_path; //path used when imported, used by scene editors to keep tracking
|
|
|
|
#endif
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-04-10 05:18:27 +02:00
|
|
|
Viewport *viewport;
|
|
|
|
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2016-06-08 03:08:12 +02:00
|
|
|
Map< StringName, GroupData> grouped;
|
2014-02-10 02:10:30 +01:00
|
|
|
List<Node*>::Element *OW; // owned element
|
|
|
|
List<Node*> owned;
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
PauseMode pause_mode;
|
|
|
|
Node *pause_owner;
|
2016-08-14 23:49:50 +02:00
|
|
|
|
|
|
|
NetworkMode network_mode;
|
|
|
|
Node *network_owner;
|
2016-08-19 21:48:08 +02:00
|
|
|
Map<StringName,RPCMode> rpc_methods;
|
|
|
|
Map<StringName,RPCMode> rpc_properties;
|
2016-08-14 23:49:50 +02:00
|
|
|
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
// variables used to properly sort the node when processing, ignored otherwise
|
2015-10-10 14:09:09 +02:00
|
|
|
//should move all the stuff below to bits
|
2014-02-10 02:10:30 +01:00
|
|
|
bool fixed_process;
|
|
|
|
bool idle_process;
|
|
|
|
|
|
|
|
bool input;
|
|
|
|
bool unhandled_input;
|
2014-04-10 05:18:27 +02:00
|
|
|
bool unhandled_key_input;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
bool parent_owned;
|
|
|
|
bool in_constructor;
|
2015-10-17 00:11:23 +02:00
|
|
|
bool use_placeholder;
|
|
|
|
|
2016-06-28 18:10:15 +02:00
|
|
|
bool display_folded;
|
2015-10-10 14:09:09 +02:00
|
|
|
|
2016-08-14 23:49:50 +02:00
|
|
|
mutable NodePath *path_cache;
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
} data;
|
|
|
|
|
2016-03-09 00:00:52 +01:00
|
|
|
|
|
|
|
void _print_tree(const Node *p_node);
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
virtual bool _use_builtin_script() const { return true; }
|
|
|
|
Node *_get_node(const NodePath& p_path) const;
|
2015-10-10 14:09:09 +02:00
|
|
|
Node *_get_child_by_name(const StringName& p_name) const;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2016-06-09 16:24:12 +02:00
|
|
|
void _replace_connections_target(Node* p_new_target);
|
2015-06-08 05:33:10 +02:00
|
|
|
|
2015-12-08 15:21:12 +01:00
|
|
|
void _validate_child_name(Node *p_name, bool p_force_human_readable=false);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2016-03-09 00:00:52 +01:00
|
|
|
void _propagate_reverse_notification(int p_notification);
|
2014-02-10 02:10:30 +01:00
|
|
|
void _propagate_deferred_notification(int p_notification, bool p_reverse);
|
2014-11-06 01:20:42 +01:00
|
|
|
void _propagate_enter_tree();
|
2014-02-10 02:10:30 +01:00
|
|
|
void _propagate_ready();
|
2014-11-06 01:20:42 +01:00
|
|
|
void _propagate_exit_tree();
|
2014-02-10 02:10:30 +01:00
|
|
|
void _propagate_validate_owner();
|
|
|
|
void _print_stray_nodes();
|
|
|
|
void _propagate_pause_owner(Node*p_owner);
|
2016-08-14 23:49:50 +02:00
|
|
|
void _propagate_network_owner(Node*p_owner);
|
2014-02-10 02:10:30 +01:00
|
|
|
Array _get_node_and_resource(const NodePath& p_path);
|
|
|
|
|
2015-05-10 20:45:33 +02:00
|
|
|
void _duplicate_signals(const Node* p_original,Node* p_copy) const;
|
2014-02-10 02:10:30 +01:00
|
|
|
void _duplicate_and_reown(Node* p_new_parent, const Map<Node*,Node*>& p_reown_map) const;
|
2016-07-07 02:43:31 +02:00
|
|
|
Node *_duplicate(bool p_use_instancing) const;
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
Array _get_children() const;
|
2014-06-16 15:22:26 +02:00
|
|
|
Array _get_groups() const;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2016-08-19 21:48:08 +02:00
|
|
|
Variant _rpc_bind(const Variant** p_args, int p_argcount, Variant::CallError& r_error);
|
|
|
|
Variant _rpc_unreliable_bind(const Variant** p_args, int p_argcount, Variant::CallError& r_error);
|
|
|
|
Variant _rpc_id_bind(const Variant** p_args, int p_argcount, Variant::CallError& r_error);
|
|
|
|
Variant _rpc_unreliable_id_bind(const Variant** p_args, int p_argcount, Variant::CallError& r_error);
|
2016-08-14 23:49:50 +02:00
|
|
|
|
2014-11-06 01:20:42 +01:00
|
|
|
friend class SceneTree;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-11-06 01:20:42 +01:00
|
|
|
void _set_tree(SceneTree *p_tree);
|
2014-02-10 02:10:30 +01:00
|
|
|
protected:
|
|
|
|
|
|
|
|
void _block() { data.blocked++; }
|
|
|
|
void _unblock() { data.blocked--; }
|
|
|
|
|
2016-03-09 00:00:52 +01:00
|
|
|
void _notification(int p_notification);
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
virtual void add_child_notify(Node *p_child);
|
|
|
|
virtual void remove_child_notify(Node *p_child);
|
2014-12-03 05:17:23 +01:00
|
|
|
virtual void move_child_notify(Node *p_child);
|
2015-04-09 05:49:48 +02:00
|
|
|
//void remove_and_delete_child(Node *p_child);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
|
|
|
void _propagate_replace_owner(Node *p_owner,Node* p_by_owner);
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
static void _bind_methods();
|
|
|
|
|
2015-10-10 14:09:09 +02:00
|
|
|
friend class SceneState;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
void _add_child_nocheck(Node* p_child,const StringName& p_name);
|
|
|
|
void _set_owner_nocheck(Node* p_owner);
|
|
|
|
void _set_name_nocheck(const StringName& p_name);
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
|
|
|
enum {
|
|
|
|
// you can make your own, but don't use the same numbers as other notifications in other nodes
|
2014-11-06 01:20:42 +01:00
|
|
|
NOTIFICATION_ENTER_TREE=10,
|
|
|
|
NOTIFICATION_EXIT_TREE =11,
|
2014-02-10 02:10:30 +01:00
|
|
|
NOTIFICATION_MOVED_IN_PARENT =12,
|
|
|
|
NOTIFICATION_READY=13,
|
|
|
|
//NOTIFICATION_PARENT_DECONFIGURED =15, - it's confusing, it's going away
|
|
|
|
NOTIFICATION_PAUSED=14,
|
|
|
|
NOTIFICATION_UNPAUSED=15,
|
|
|
|
NOTIFICATION_FIXED_PROCESS = 16,
|
|
|
|
NOTIFICATION_PROCESS = 17,
|
|
|
|
NOTIFICATION_PARENTED=18,
|
|
|
|
NOTIFICATION_UNPARENTED=19,
|
2015-05-04 23:30:57 +02:00
|
|
|
NOTIFICATION_INSTANCED=20,
|
2016-05-11 16:46:08 +02:00
|
|
|
NOTIFICATION_DRAG_BEGIN=21,
|
|
|
|
NOTIFICATION_DRAG_END=22,
|
2016-08-14 23:49:50 +02:00
|
|
|
NOTIFICATION_PATH_CHANGED=23,
|
2014-02-10 02:10:30 +01:00
|
|
|
};
|
2016-03-09 00:00:52 +01:00
|
|
|
|
|
|
|
/* NODE/TREE */
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
StringName get_name() const;
|
|
|
|
void set_name(const String& p_name);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2015-12-08 15:21:12 +01:00
|
|
|
void add_child(Node *p_child,bool p_legible_unique_name=false);
|
2016-05-13 18:09:49 +02:00
|
|
|
void add_child_below_node(Node *p_node, Node *p_child, bool p_legible_unique_name=false);
|
2014-02-10 02:10:30 +01:00
|
|
|
void remove_child(Node *p_child);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
int get_child_count() const;
|
|
|
|
Node *get_child(int p_index) const;
|
|
|
|
bool has_node(const NodePath& p_path) const;
|
|
|
|
Node *get_node(const NodePath& p_path) const;
|
2015-06-08 05:33:10 +02:00
|
|
|
Node* find_node(const String& p_mask,bool p_recursive=true,bool p_owned=true) const;
|
2014-02-10 02:10:30 +01:00
|
|
|
bool has_node_and_resource(const NodePath& p_path) const;
|
|
|
|
Node *get_node_and_resource(const NodePath& p_path,RES& r_res) const;
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
Node *get_parent() const;
|
2014-11-06 01:20:42 +01:00
|
|
|
_FORCE_INLINE_ SceneTree *get_tree() const { ERR_FAIL_COND_V( !data.tree, NULL ); return data.tree; }
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-11-06 01:20:42 +01:00
|
|
|
_FORCE_INLINE_ bool is_inside_tree() const { return data.inside_tree; }
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
bool is_a_parent_of(const Node *p_node) const;
|
|
|
|
bool is_greater_than(const Node *p_node) const;
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
NodePath get_path() const;
|
|
|
|
NodePath get_path_to(const Node *p_node) const;
|
2016-07-20 01:04:06 +02:00
|
|
|
Node* find_common_parent_with(const Node *p_node) const;
|
2016-03-09 00:00:52 +01:00
|
|
|
|
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;
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
struct GroupInfo {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2015-10-10 14:09:09 +02:00
|
|
|
StringName name;
|
2014-02-10 02:10:30 +01:00
|
|
|
bool persistent;
|
|
|
|
};
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
void get_groups(List<GroupInfo> *p_groups) const;
|
2016-06-04 18:17:56 +02:00
|
|
|
bool has_persistent_groups() const;
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
void move_child(Node *p_child,int p_pos);
|
|
|
|
void raise();
|
2016-03-09 00:00:52 +01:00
|
|
|
|
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);
|
|
|
|
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
void remove_and_skip();
|
|
|
|
int get_index() const;
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
void print_tree();
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
void set_filename(const String& p_filename);
|
|
|
|
String get_filename() const;
|
2015-10-10 14:09:09 +02:00
|
|
|
|
|
|
|
void set_editable_instance(Node* p_node,bool p_editable);
|
|
|
|
bool is_editable_instance(Node* p_node) const;
|
2016-04-12 18:21:37 +02:00
|
|
|
void set_editable_instances(const HashMap<NodePath,int>& p_editable_instances);
|
|
|
|
HashMap<NodePath,int> get_editable_instances() const;
|
2015-10-10 14:09:09 +02:00
|
|
|
|
2015-10-17 00:11:23 +02:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
/* NOTIFICATIONS */
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
void propagate_notification(int p_notification);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
/* PROCESSING */
|
|
|
|
void set_fixed_process(bool p_process);
|
|
|
|
float get_fixed_process_delta_time() const;
|
|
|
|
bool is_fixed_processing() const;
|
|
|
|
|
|
|
|
void set_process(bool p_process);
|
|
|
|
float get_process_delta_time() const;
|
|
|
|
bool is_processing() const;
|
|
|
|
|
|
|
|
|
|
|
|
void set_process_input(bool p_enable);
|
|
|
|
bool is_processing_input() const;
|
|
|
|
|
|
|
|
void set_process_unhandled_input(bool p_enable);
|
|
|
|
bool is_processing_unhandled_input() const;
|
|
|
|
|
2014-04-10 05:18:27 +02:00
|
|
|
void set_process_unhandled_key_input(bool p_enable);
|
|
|
|
bool is_processing_unhandled_key_input() const;
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
int get_position_in_parent() const;
|
|
|
|
|
2015-08-02 17:29:37 +02:00
|
|
|
Node *duplicate(bool p_use_instancing=false) const;
|
2014-02-10 02:10:30 +01:00
|
|
|
Node *duplicate_and_reown(const Map<Node*,Node*>& p_reown_map) const;
|
2015-08-02 17:29:37 +02:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
//Node *clone_tree() const;
|
|
|
|
|
|
|
|
// used by editors, to save what has changed only
|
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;
|
|
|
|
|
2015-10-17 00:11:23 +02:00
|
|
|
void set_scene_instance_load_placeholder(bool p_enable);
|
|
|
|
bool get_scene_instance_load_placeholder() const;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
static Vector<Variant> make_binds(VARIANT_ARG_LIST);
|
|
|
|
|
|
|
|
void replace_by(Node* p_node,bool p_keep_data=false);
|
|
|
|
|
|
|
|
void set_pause_mode(PauseMode p_mode);
|
|
|
|
PauseMode get_pause_mode() const;
|
|
|
|
bool can_process() const;
|
|
|
|
|
|
|
|
static void print_stray_nodes();
|
|
|
|
|
2015-08-02 17:29:37 +02:00
|
|
|
String validate_child_name(const String& p_name) const;
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
void queue_delete();
|
|
|
|
|
2014-06-19 07:23:03 +02:00
|
|
|
//shitty hacks for speed
|
2014-02-23 00:28:19 +01:00
|
|
|
static void set_human_readable_collision_renaming(bool p_enabled);
|
|
|
|
static void init_node_hrcr();
|
|
|
|
|
2014-04-05 17:39:30 +02:00
|
|
|
void force_parent_owned() { data.parent_owned=true; } //hack to avoid duplicate nodes
|
|
|
|
|
2014-06-19 07:23:03 +02:00
|
|
|
#ifdef TOOLS_ENABLED
|
|
|
|
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;
|
|
|
|
#endif
|
|
|
|
|
2016-06-21 03:57:07 +02:00
|
|
|
bool is_owned_by_parent() const;
|
|
|
|
|
2014-12-17 02:31:57 +01:00
|
|
|
void get_argument_options(const StringName& p_function,int p_idx,List<String>*r_options) const;
|
2014-06-19 07:23:03 +02:00
|
|
|
|
2015-06-22 05:03:19 +02:00
|
|
|
void clear_internal_tree_resource_paths();
|
|
|
|
|
2014-04-10 05:18:27 +02:00
|
|
|
_FORCE_INLINE_ Viewport *get_viewport() const { return data.viewport; }
|
|
|
|
|
2016-05-17 23:27:15 +02:00
|
|
|
virtual String get_configuration_warning() const;
|
|
|
|
|
|
|
|
void update_configuration_warning();
|
|
|
|
|
2016-06-28 18:10:15 +02:00
|
|
|
void set_display_folded(bool p_folded);
|
|
|
|
bool is_displayed_folded() const;
|
2016-08-14 23:49:50 +02:00
|
|
|
/* NETWORK */
|
|
|
|
|
|
|
|
void set_network_mode(NetworkMode p_mode);
|
|
|
|
NetworkMode get_network_mode() const;
|
|
|
|
bool is_network_master() const;
|
|
|
|
|
2016-08-19 21:48:08 +02:00
|
|
|
void rpc_config(const StringName& p_method,RPCMode p_mode); // config a local method for RPC
|
|
|
|
void rset_config(const StringName& p_property,RPCMode p_mode); // config a local property for RPC
|
|
|
|
|
|
|
|
void rpc(const StringName& p_method,VARIANT_ARG_LIST); //rpc call, honors RPCMode
|
|
|
|
void rpc_unreliable(const StringName& p_method,VARIANT_ARG_LIST); //rpc call, honors RPCMode
|
|
|
|
void rpc_id(int p_peer_id,const StringName& p_method,VARIANT_ARG_LIST); //rpc call, honors RPCMode
|
|
|
|
void rpc_unreliable_id(int p_peer_id,const StringName& p_method,VARIANT_ARG_LIST); //rpc call, honors RPCMode
|
2016-08-14 23:49:50 +02:00
|
|
|
|
2016-08-19 21:48:08 +02:00
|
|
|
void rpcp(int p_peer_id,bool p_unreliable,const StringName& p_method,const Variant** p_arg,int p_argcount);
|
2016-08-14 23:49:50 +02:00
|
|
|
|
2016-08-19 21:48:08 +02:00
|
|
|
void rset(const StringName& p_property, const Variant& p_value); //remote set call, honors RPCMode
|
|
|
|
void rset_unreliable(const StringName& p_property,const Variant& p_value); //remote set call, honors RPCMode
|
|
|
|
void rset_id(int p_peer_id,const StringName& p_property,const Variant& p_value); //remote set call, honors RPCMode
|
|
|
|
void rset_unreliable_id(int p_peer_id,const StringName& p_property,const Variant& p_value); //remote set call, honors RPCMode
|
2016-08-14 23:49:50 +02:00
|
|
|
|
2016-08-19 21:48:08 +02:00
|
|
|
void rsetp(int p_peer_id,bool p_unreliable,const StringName& p_property,const Variant& p_value);
|
2016-08-14 23:49:50 +02:00
|
|
|
|
2016-08-19 21:48:08 +02:00
|
|
|
bool can_call_rpc(const StringName& p_method) const;
|
|
|
|
bool can_call_rset(const StringName& p_property) const;
|
2016-08-14 23:49:50 +02:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
Node();
|
|
|
|
~Node();
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
typedef Set<Node*,Node::Comparator> NodeSet;
|
|
|
|
|
|
|
|
|
|
|
|
#endif
|