godot/scene/main/scene_tree.cpp

/**************************************************************************/
/*  scene_tree.cpp                                                        */
/**************************************************************************/
/*                         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.                 */
/**************************************************************************/

#include "scene_tree.h"

#include "core/config/project_settings.h"
#include "core/debugger/engine_debugger.h"
#include "core/input/input.h"
#include "core/io/dir_access.h"
#include "core/io/image_loader.h"
#include "core/io/marshalls.h"
#include "core/io/resource_loader.h"
#include "core/object/message_queue.h"
#include "core/object/worker_thread_pool.h"
#include "core/os/keyboard.h"
#include "core/os/os.h"
#include "core/string/print_string.h"
#include "node.h"
#include "scene/animation/tween.h"
#include "scene/debugger/scene_debugger.h"
#include "scene/gui/control.h"
#include "scene/main/multiplayer_api.h"
#include "scene/main/viewport.h"
#include "scene/resources/environment.h"
#include "scene/resources/font.h"
#include "scene/resources/image_texture.h"
#include "scene/resources/material.h"
#include "scene/resources/mesh.h"
#include "scene/resources/packed_scene.h"
#include "scene/resources/world_2d.h"
#include "servers/display_server.h"
#include "servers/navigation_server_3d.h"
#include "servers/physics_server_2d.h"
#ifndef _3D_DISABLED
#include "scene/3d/node_3d.h"
#include "scene/resources/3d/world_3d.h"
#include "servers/physics_server_3d.h"
#endif // _3D_DISABLED
#include "window.h"
#include <stdio.h>
#include <stdlib.h>

void SceneTreeTimer::_bind_methods() {}

void SceneTreeTimer::set_time_left(double p_time) {}

double SceneTreeTimer::get_time_left() const {}

void SceneTreeTimer::set_process_always(bool p_process_always) {}

bool SceneTreeTimer::is_process_always() {}

void SceneTreeTimer::set_process_in_physics(bool p_process_in_physics) {}

bool SceneTreeTimer::is_process_in_physics() {}

void SceneTreeTimer::set_ignore_time_scale(bool p_ignore) {}

bool SceneTreeTimer::is_ignore_time_scale() {}

void SceneTreeTimer::release_connections() {}

SceneTreeTimer::SceneTreeTimer() {}

#ifndef _3D_DISABLED
// This should be called once per physics tick, to make sure the transform previous and current
// is kept up to date on the few Node3Ds that are using client side physics interpolation.
void SceneTree::ClientPhysicsInterpolation::physics_process() {}
#endif

void SceneTree::tree_changed() {}

void SceneTree::node_added(Node *p_node) {}

void SceneTree::node_removed(Node *p_node) {}

void SceneTree::node_renamed(Node *p_node) {}

SceneTree::Group *SceneTree::add_to_group(const StringName &p_group, Node *p_node) {}

void SceneTree::remove_from_group(const StringName &p_group, Node *p_node) {}

void SceneTree::make_group_changed(const StringName &p_group) {}

void SceneTree::flush_transform_notifications() {}

void SceneTree::_flush_ugc() {}

void SceneTree::_update_group_order(Group &g) {}

void SceneTree::call_group_flagsp(uint32_t p_call_flags, const StringName &p_group, const StringName &p_function, const Variant **p_args, int p_argcount) {}

void SceneTree::notify_group_flags(uint32_t p_call_flags, const StringName &p_group, int p_notification) {}

void SceneTree::set_group_flags(uint32_t p_call_flags, const StringName &p_group, const String &p_name, const Variant &p_value) {}

void SceneTree::notify_group(const StringName &p_group, int p_notification) {}

void SceneTree::set_group(const StringName &p_group, const String &p_name, const Variant &p_value) {}

void SceneTree::initialize() {}

void SceneTree::set_physics_interpolation_enabled(bool p_enabled) {}

bool SceneTree::is_physics_interpolation_enabled() const {}

#ifndef _3D_DISABLED
void SceneTree::client_physics_interpolation_add_node_3d(SelfList<Node3D> *p_elem) {}

void SceneTree::client_physics_interpolation_remove_node_3d(SelfList<Node3D> *p_elem) {}
#endif

void SceneTree::iteration_prepare() {}

bool SceneTree::physics_process(double p_time) {}

void SceneTree::iteration_end() {}

bool SceneTree::process(double p_time) {}

void SceneTree::process_timers(double p_delta, bool p_physics_frame) {}

void SceneTree::process_tweens(double p_delta, bool p_physics) {}

void SceneTree::finalize() {}

void SceneTree::quit(int p_exit_code) {}

void SceneTree::_main_window_close() {}

void SceneTree::_main_window_go_back() {}

void SceneTree::_main_window_focus_in() {}

void SceneTree::_notification(int p_notification) {}

bool SceneTree::is_auto_accept_quit() const {}

void SceneTree::set_auto_accept_quit(bool p_enable) {}

bool SceneTree::is_quit_on_go_back() const {}

void SceneTree::set_quit_on_go_back(bool p_enable) {}

#ifdef DEBUG_ENABLED
void SceneTree::set_debug_collisions_hint(bool p_enabled) {}

bool SceneTree::is_debugging_collisions_hint() const {}

void SceneTree::set_debug_paths_hint(bool p_enabled) {}

bool SceneTree::is_debugging_paths_hint() const {}

void SceneTree::set_debug_navigation_hint(bool p_enabled) {}

bool SceneTree::is_debugging_navigation_hint() const {}
#endif

void SceneTree::set_debug_collisions_color(const Color &p_color) {}

Color SceneTree::get_debug_collisions_color() const {}

void SceneTree::set_debug_collision_contact_color(const Color &p_color) {}

Color SceneTree::get_debug_collision_contact_color() const {}

void SceneTree::set_debug_paths_color(const Color &p_color) {}

Color SceneTree::get_debug_paths_color() const {}

void SceneTree::set_debug_paths_width(float p_width) {}

float SceneTree::get_debug_paths_width() const {}

Ref<Material> SceneTree::get_debug_paths_material() {}

Ref<Material> SceneTree::get_debug_collision_material() {}

Ref<ArrayMesh> SceneTree::get_debug_contact_mesh() {}

void SceneTree::set_pause(bool p_enabled) {}

bool SceneTree::is_paused() const {}

void SceneTree::_process_group(ProcessGroup *p_group, bool p_physics) {}

void SceneTree::_process_groups_thread(uint32_t p_index, bool p_physics) {}

void SceneTree::_process(bool p_physics) {}

bool SceneTree::ProcessGroupSort::operator()(const ProcessGroup *p_left, const ProcessGroup *p_right) const {}

void SceneTree::_remove_process_group(Node *p_node) {}

void SceneTree::_add_process_group(Node *p_node) {}

void SceneTree::_remove_node_from_process_group(Node *p_node, Node *p_owner) {}

void SceneTree::_add_node_to_process_group(Node *p_node, Node *p_owner) {}

void SceneTree::_call_input_pause(const StringName &p_group, CallInputType p_call_type, const Ref<InputEvent> &p_input, Viewport *p_viewport) {}

void SceneTree::_call_group_flags(const Variant **p_args, int p_argcount, Callable::CallError &r_error) {}

void SceneTree::_call_group(const Variant **p_args, int p_argcount, Callable::CallError &r_error) {}

int64_t SceneTree::get_frame() const {}

TypedArray<Node> SceneTree::_get_nodes_in_group(const StringName &p_group) {}

bool SceneTree::has_group(const StringName &p_identifier) const {}

int SceneTree::get_node_count_in_group(const StringName &p_group) const {}

Node *SceneTree::get_first_node_in_group(const StringName &p_group) {}

void SceneTree::get_nodes_in_group(const StringName &p_group, List<Node *> *p_list) {}

void SceneTree::_flush_delete_queue() {}

void SceneTree::queue_delete(Object *p_object) {}

int SceneTree::get_node_count() const {}

void SceneTree::set_edited_scene_root(Node *p_node) {}

Node *SceneTree::get_edited_scene_root() const {}

void SceneTree::set_current_scene(Node *p_scene) {}

Node *SceneTree::get_current_scene() const {}

void SceneTree::_flush_scene_change() {}

Error SceneTree::change_scene_to_file(const String &p_path) {}

Error SceneTree::change_scene_to_packed(const Ref<PackedScene> &p_scene) {}

Error SceneTree::reload_current_scene() {}

void SceneTree::unload_current_scene() {}

void SceneTree::add_current_scene(Node *p_current) {}

Ref<SceneTreeTimer> SceneTree::create_timer(double p_delay_sec, bool p_process_always, bool p_process_in_physics, bool p_ignore_time_scale) {}

Ref<Tween> SceneTree::create_tween() {}

TypedArray<Tween> SceneTree::get_processed_tweens() {}

Ref<MultiplayerAPI> SceneTree::get_multiplayer(const NodePath &p_for_path) const {}

void SceneTree::set_multiplayer(Ref<MultiplayerAPI> p_multiplayer, const NodePath &p_root_path) {}

void SceneTree::set_multiplayer_poll_enabled(bool p_enabled) {}

bool SceneTree::is_multiplayer_poll_enabled() const {}

void SceneTree::_bind_methods() {}

SceneTree *SceneTree::singleton =;

SceneTree::IdleCallback SceneTree::idle_callbacks[SceneTree::MAX_IDLE_CALLBACKS];
int SceneTree::idle_callback_count =;

void SceneTree::_call_idle_callbacks() {}

void SceneTree::add_idle_callback(IdleCallback p_callback) {}

#ifdef TOOLS_ENABLED
void SceneTree::get_argument_options(const StringName &p_function, int p_idx, List<String> *r_options) const {}
#endif

void SceneTree::set_disable_node_threading(bool p_disable) {}

SceneTree::SceneTree() {}

SceneTree::~SceneTree() {}