2014-02-10 01:10:30 +00:00
/*************************************************************************/
2017-09-01 14:07:55 +00:00
/* scene_tree.cpp */
2014-02-10 01:10:30 +00:00
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
2017-08-27 12:16:55 +00:00
/* https://godotengine.org */
2014-02-10 01:10:30 +00:00
/*************************************************************************/
2020-01-01 10:16:22 +00:00
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
2014-02-10 01:10:30 +00: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. */
/*************************************************************************/
2018-01-04 23:50:27 +00:00
2017-06-27 01:58:03 +00:00
# include "scene_tree.h"
2014-02-10 01:10:30 +00:00
2018-09-11 16:13:45 +00:00
# include "core/io/marshalls.h"
# include "core/io/resource_loader.h"
# include "core/message_queue.h"
2019-03-09 02:05:59 +00:00
# include "core/os/dir_access.h"
2018-09-11 16:13:45 +00:00
# include "core/os/keyboard.h"
# include "core/os/os.h"
# include "core/print_string.h"
# include "core/project_settings.h"
2020-02-07 01:52:05 +00:00
# include "core/script_debugger_remote.h"
2018-02-24 02:04:30 +00:00
# include "main/input_default.h"
2014-02-10 01:10:30 +00:00
# include "node.h"
2020-02-07 01:52:05 +00:00
# include "scene/debugger/scene_debugger.h"
2017-12-19 21:48:30 +00:00
# include "scene/resources/dynamic_font.h"
2015-09-20 16:03:46 +00:00
# include "scene/resources/material.h"
# include "scene/resources/mesh.h"
2017-03-05 15:44:50 +00:00
# include "scene/resources/packed_scene.h"
# include "scene/scene_string_names.h"
2020-01-10 11:22:34 +00:00
# include "servers/navigation_server.h"
2017-03-05 15:44:50 +00:00
# include "servers/physics_2d_server.h"
# include "servers/physics_server.h"
# include "viewport.h"
2016-08-07 00:39:50 +00:00
2017-08-27 19:07:15 +00:00
# include <stdio.h>
2016-08-07 00:39:50 +00:00
void SceneTreeTimer : : _bind_methods ( ) {
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_time_left " , " time " ) , & SceneTreeTimer : : set_time_left ) ;
ClassDB : : bind_method ( D_METHOD ( " get_time_left " ) , & SceneTreeTimer : : get_time_left ) ;
2016-08-07 00:39:50 +00:00
2018-01-11 22:35:12 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " time_left " ) , " set_time_left " , " get_time_left " ) ;
2016-08-07 00:39:50 +00:00
ADD_SIGNAL ( MethodInfo ( " timeout " ) ) ;
}
void SceneTreeTimer : : set_time_left ( float p_time ) {
2017-03-05 15:44:50 +00:00
time_left = p_time ;
2016-08-07 00:39:50 +00:00
}
float SceneTreeTimer : : get_time_left ( ) const {
return time_left ;
}
2017-02-13 23:34:33 +00:00
void SceneTreeTimer : : set_pause_mode_process ( bool p_pause_mode_process ) {
2019-10-14 09:40:55 +00:00
process_pause = p_pause_mode_process ;
2017-02-13 23:34:33 +00:00
}
bool SceneTreeTimer : : is_pause_mode_process ( ) {
return process_pause ;
}
2016-08-07 00:39:50 +00:00
2019-10-19 16:45:17 +00:00
void SceneTreeTimer : : release_connections ( ) {
List < Connection > connections ;
get_all_signal_connections ( & connections ) ;
for ( List < Connection > : : Element * E = connections . front ( ) ; E ; E = E - > next ( ) ) {
Connection const & connection = E - > get ( ) ;
2020-02-19 19:27:19 +00:00
disconnect_compat ( connection . signal . get_name ( ) , connection . callable . get_object ( ) , connection . callable . get_method ( ) ) ;
2019-10-19 16:45:17 +00:00
}
}
2016-08-07 00:39:50 +00:00
SceneTreeTimer : : SceneTreeTimer ( ) {
2017-03-05 15:44:50 +00:00
time_left = 0 ;
2017-02-13 23:34:33 +00:00
process_pause = true ;
2016-08-07 00:39:50 +00:00
}
2014-11-06 00:20:42 +00:00
void SceneTree : : tree_changed ( ) {
2014-02-10 01:10:30 +00:00
tree_version + + ;
emit_signal ( tree_changed_name ) ;
}
2017-10-19 00:30:27 +00:00
void SceneTree : : node_added ( Node * p_node ) {
emit_signal ( node_added_name , p_node ) ;
}
2014-11-06 00:20:42 +00:00
void SceneTree : : node_removed ( Node * p_node ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
if ( current_scene = = p_node ) {
current_scene = NULL ;
2015-05-17 19:33:35 +00:00
}
2017-03-05 15:44:50 +00:00
emit_signal ( node_removed_name , p_node ) ;
if ( call_lock > 0 )
2014-02-10 01:10:30 +00:00
call_skip . insert ( p_node ) ;
}
2019-05-24 13:27:22 +00:00
void SceneTree : : node_renamed ( Node * p_node ) {
emit_signal ( node_renamed_name , p_node ) ;
}
2017-03-05 15:44:50 +00:00
SceneTree : : Group * SceneTree : : add_to_group ( const StringName & p_group , Node * p_node ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
Map < StringName , Group > : : Element * E = group_map . find ( p_group ) ;
2014-02-10 01:10:30 +00:00
if ( ! E ) {
2017-03-05 15:44:50 +00:00
E = group_map . insert ( p_group , Group ( ) ) ;
2014-02-10 01:10:30 +00:00
}
2019-08-08 20:11:48 +00:00
ERR_FAIL_COND_V_MSG ( E - > get ( ) . nodes . find ( p_node ) ! = - 1 , & E - > get ( ) , " Already in group: " + p_group + " . " ) ;
2014-02-10 01:10:30 +00:00
E - > get ( ) . nodes . push_back ( p_node ) ;
2016-06-08 01:08:12 +00:00
//E->get().last_tree_version=0;
2017-03-05 15:44:50 +00:00
E - > get ( ) . changed = true ;
2016-06-08 01:08:12 +00:00
return & E - > get ( ) ;
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
void SceneTree : : remove_from_group ( const StringName & p_group , Node * p_node ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
Map < StringName , Group > : : Element * E = group_map . find ( p_group ) ;
2014-02-10 01:10:30 +00:00
ERR_FAIL_COND ( ! E ) ;
E - > get ( ) . nodes . erase ( p_node ) ;
if ( E - > get ( ) . nodes . empty ( ) )
group_map . erase ( E ) ;
}
2018-07-02 05:30:40 +00:00
void SceneTree : : make_group_changed ( const StringName & p_group ) {
Map < StringName , Group > : : Element * E = group_map . find ( p_group ) ;
if ( E )
E - > get ( ) . changed = true ;
}
2017-10-30 18:43:19 +00:00
void SceneTree : : flush_transform_notifications ( ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
SelfList < Node > * n = xform_change_list . first ( ) ;
while ( n ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
Node * node = n - > self ( ) ;
SelfList < Node > * nx = n - > next ( ) ;
2014-02-10 01:10:30 +00:00
xform_change_list . remove ( n ) ;
2017-03-05 15:44:50 +00:00
n = nx ;
2014-02-10 01:10:30 +00:00
node - > notification ( NOTIFICATION_TRANSFORM_CHANGED ) ;
}
}
2014-11-06 00:20:42 +00:00
void SceneTree : : _flush_ugc ( ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
ugc_locked = true ;
2014-02-10 01:10:30 +00:00
while ( unique_group_calls . size ( ) ) {
2017-03-05 15:44:50 +00:00
Map < UGCall , Vector < Variant > > : : Element * E = unique_group_calls . front ( ) ;
2014-02-10 01:10:30 +00:00
Variant v [ VARIANT_ARG_MAX ] ;
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < E - > get ( ) . size ( ) ; i + + )
v [ i ] = E - > get ( ) [ i ] ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
call_group_flags ( GROUP_CALL_REALTIME , E - > key ( ) . group , E - > key ( ) . call , v [ 0 ] , v [ 1 ] , v [ 2 ] , v [ 3 ] , v [ 4 ] ) ;
2014-02-10 01:10:30 +00:00
unique_group_calls . erase ( E ) ;
}
2017-03-05 15:44:50 +00:00
ugc_locked = false ;
2014-02-10 01:10:30 +00:00
}
2018-07-02 05:30:40 +00:00
void SceneTree : : _update_group_order ( Group & g , bool p_use_priority ) {
2014-02-10 01:10:30 +00:00
2016-06-08 01:08:12 +00:00
if ( ! g . changed )
2014-02-10 01:10:30 +00:00
return ;
if ( g . nodes . empty ( ) )
return ;
2018-07-25 01:11:03 +00:00
Node * * nodes = g . nodes . ptrw ( ) ;
2017-03-05 15:44:50 +00:00
int node_count = g . nodes . size ( ) ;
2016-06-08 01:08:12 +00:00
2018-07-02 05:30:40 +00:00
if ( p_use_priority ) {
SortArray < Node * , Node : : ComparatorWithPriority > node_sort ;
node_sort . sort ( nodes , node_count ) ;
} else {
SortArray < Node * , Node : : Comparator > node_sort ;
node_sort . sort ( nodes , node_count ) ;
}
2017-03-05 15:44:50 +00:00
g . changed = false ;
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
void SceneTree : : call_group_flags ( uint32_t p_call_flags , const StringName & p_group , const StringName & p_function , VARIANT_ARG_DECLARE ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
Map < StringName , Group > : : Element * E = group_map . find ( p_group ) ;
2014-02-10 01:10:30 +00:00
if ( ! E )
return ;
2017-03-05 15:44:50 +00:00
Group & g = E - > get ( ) ;
2014-02-10 01:10:30 +00:00
if ( g . nodes . empty ( ) )
return ;
2017-03-05 15:44:50 +00:00
if ( p_call_flags & GROUP_CALL_UNIQUE & & ! ( p_call_flags & GROUP_CALL_REALTIME ) ) {
2014-02-10 01:10:30 +00:00
ERR_FAIL_COND ( ugc_locked ) ;
UGCall ug ;
2017-03-05 15:44:50 +00:00
ug . call = p_function ;
ug . group = p_group ;
2014-02-10 01:10:30 +00:00
if ( unique_group_calls . has ( ug ) )
return ;
VARIANT_ARGPTRS ;
Vector < Variant > args ;
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < VARIANT_ARG_MAX ; i + + ) {
if ( argptr [ i ] - > get_type ( ) = = Variant : : NIL )
2014-02-10 01:10:30 +00:00
break ;
args . push_back ( * argptr [ i ] ) ;
}
2017-03-05 15:44:50 +00:00
unique_group_calls [ ug ] = args ;
2014-02-10 01:10:30 +00:00
return ;
}
2016-06-08 01:08:12 +00:00
_update_group_order ( g ) ;
2017-03-05 15:44:50 +00:00
Vector < Node * > nodes_copy = g . nodes ;
2018-07-25 01:11:03 +00:00
Node * * nodes = nodes_copy . ptrw ( ) ;
2017-03-05 15:44:50 +00:00
int node_count = nodes_copy . size ( ) ;
2014-02-10 01:10:30 +00:00
call_lock + + ;
2017-03-05 15:44:50 +00:00
if ( p_call_flags & GROUP_CALL_REVERSE ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
for ( int i = node_count - 1 ; i > = 0 ; i - - ) {
2014-02-10 01:10:30 +00:00
if ( call_lock & & call_skip . has ( nodes [ i ] ) )
continue ;
2017-03-05 15:44:50 +00:00
if ( p_call_flags & GROUP_CALL_REALTIME ) {
if ( p_call_flags & GROUP_CALL_MULTILEVEL )
nodes [ i ] - > call_multilevel ( p_function , VARIANT_ARG_PASS ) ;
2014-02-10 01:10:30 +00:00
else
2017-03-05 15:44:50 +00:00
nodes [ i ] - > call ( p_function , VARIANT_ARG_PASS ) ;
2014-02-10 01:10:30 +00:00
} else
2017-03-05 15:44:50 +00:00
MessageQueue : : get_singleton ( ) - > push_call ( nodes [ i ] , p_function , VARIANT_ARG_PASS ) ;
2014-02-10 01:10:30 +00:00
}
} else {
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < node_count ; i + + ) {
2014-02-10 01:10:30 +00:00
if ( call_lock & & call_skip . has ( nodes [ i ] ) )
continue ;
2017-03-05 15:44:50 +00:00
if ( p_call_flags & GROUP_CALL_REALTIME ) {
if ( p_call_flags & GROUP_CALL_MULTILEVEL )
nodes [ i ] - > call_multilevel ( p_function , VARIANT_ARG_PASS ) ;
2014-02-10 01:10:30 +00:00
else
2017-03-05 15:44:50 +00:00
nodes [ i ] - > call ( p_function , VARIANT_ARG_PASS ) ;
2014-02-10 01:10:30 +00:00
} else
2017-03-05 15:44:50 +00:00
MessageQueue : : get_singleton ( ) - > push_call ( nodes [ i ] , p_function , VARIANT_ARG_PASS ) ;
2014-02-10 01:10:30 +00:00
}
}
call_lock - - ;
2017-03-05 15:44:50 +00:00
if ( call_lock = = 0 )
2014-02-10 01:10:30 +00:00
call_skip . clear ( ) ;
}
2017-03-05 15:44:50 +00:00
void SceneTree : : notify_group_flags ( uint32_t p_call_flags , const StringName & p_group , int p_notification ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
Map < StringName , Group > : : Element * E = group_map . find ( p_group ) ;
2014-02-10 01:10:30 +00:00
if ( ! E )
return ;
2017-03-05 15:44:50 +00:00
Group & g = E - > get ( ) ;
2014-02-10 01:10:30 +00:00
if ( g . nodes . empty ( ) )
return ;
_update_group_order ( g ) ;
2017-03-05 15:44:50 +00:00
Vector < Node * > nodes_copy = g . nodes ;
2018-07-25 01:11:03 +00:00
Node * * nodes = nodes_copy . ptrw ( ) ;
2017-03-05 15:44:50 +00:00
int node_count = nodes_copy . size ( ) ;
2014-02-10 01:10:30 +00:00
call_lock + + ;
2017-03-05 15:44:50 +00:00
if ( p_call_flags & GROUP_CALL_REVERSE ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
for ( int i = node_count - 1 ; i > = 0 ; i - - ) {
2014-02-10 01:10:30 +00:00
if ( call_lock & & call_skip . has ( nodes [ i ] ) )
continue ;
2017-03-05 15:44:50 +00:00
if ( p_call_flags & GROUP_CALL_REALTIME )
2014-02-10 01:10:30 +00:00
nodes [ i ] - > notification ( p_notification ) ;
else
2017-03-05 15:44:50 +00:00
MessageQueue : : get_singleton ( ) - > push_notification ( nodes [ i ] , p_notification ) ;
2014-02-10 01:10:30 +00:00
}
} else {
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < node_count ; i + + ) {
2014-02-10 01:10:30 +00:00
if ( call_lock & & call_skip . has ( nodes [ i ] ) )
continue ;
2017-03-05 15:44:50 +00:00
if ( p_call_flags & GROUP_CALL_REALTIME )
2014-02-10 01:10:30 +00:00
nodes [ i ] - > notification ( p_notification ) ;
else
2017-03-05 15:44:50 +00:00
MessageQueue : : get_singleton ( ) - > push_notification ( nodes [ i ] , p_notification ) ;
2014-02-10 01:10:30 +00:00
}
}
call_lock - - ;
2017-03-05 15:44:50 +00:00
if ( call_lock = = 0 )
2014-02-10 01:10:30 +00:00
call_skip . clear ( ) ;
}
2017-03-05 15:44:50 +00:00
void SceneTree : : set_group_flags ( uint32_t p_call_flags , const StringName & p_group , const String & p_name , const Variant & p_value ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
Map < StringName , Group > : : Element * E = group_map . find ( p_group ) ;
2014-02-10 01:10:30 +00:00
if ( ! E )
return ;
2017-03-05 15:44:50 +00:00
Group & g = E - > get ( ) ;
2014-02-10 01:10:30 +00:00
if ( g . nodes . empty ( ) )
return ;
_update_group_order ( g ) ;
2017-03-05 15:44:50 +00:00
Vector < Node * > nodes_copy = g . nodes ;
2018-07-25 01:11:03 +00:00
Node * * nodes = nodes_copy . ptrw ( ) ;
2017-03-05 15:44:50 +00:00
int node_count = nodes_copy . size ( ) ;
2014-02-10 01:10:30 +00:00
call_lock + + ;
2017-03-05 15:44:50 +00:00
if ( p_call_flags & GROUP_CALL_REVERSE ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
for ( int i = node_count - 1 ; i > = 0 ; i - - ) {
2014-02-10 01:10:30 +00:00
if ( call_lock & & call_skip . has ( nodes [ i ] ) )
continue ;
2017-03-05 15:44:50 +00:00
if ( p_call_flags & GROUP_CALL_REALTIME )
nodes [ i ] - > set ( p_name , p_value ) ;
2014-02-10 01:10:30 +00:00
else
2017-03-05 15:44:50 +00:00
MessageQueue : : get_singleton ( ) - > push_set ( nodes [ i ] , p_name , p_value ) ;
2014-02-10 01:10:30 +00:00
}
} else {
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < node_count ; i + + ) {
2014-02-10 01:10:30 +00:00
if ( call_lock & & call_skip . has ( nodes [ i ] ) )
continue ;
2017-03-05 15:44:50 +00:00
if ( p_call_flags & GROUP_CALL_REALTIME )
nodes [ i ] - > set ( p_name , p_value ) ;
2014-02-10 01:10:30 +00:00
else
2017-03-05 15:44:50 +00:00
MessageQueue : : get_singleton ( ) - > push_set ( nodes [ i ] , p_name , p_value ) ;
2014-02-10 01:10:30 +00:00
}
}
call_lock - - ;
2017-03-05 15:44:50 +00:00
if ( call_lock = = 0 )
2014-02-10 01:10:30 +00:00
call_skip . clear ( ) ;
}
2017-03-05 15:44:50 +00:00
void SceneTree : : call_group ( const StringName & p_group , const StringName & p_function , VARIANT_ARG_DECLARE ) {
2019-04-07 04:19:52 +00:00
call_group_flags ( 0 , p_group , p_function , VARIANT_ARG_PASS ) ;
2017-01-14 13:03:53 +00:00
}
2017-03-05 15:44:50 +00:00
void SceneTree : : notify_group ( const StringName & p_group , int p_notification ) {
2017-01-14 13:03:53 +00:00
2017-03-05 15:44:50 +00:00
notify_group_flags ( 0 , p_group , p_notification ) ;
2017-01-14 13:03:53 +00:00
}
2017-03-05 15:44:50 +00:00
void SceneTree : : set_group ( const StringName & p_group , const String & p_name , const Variant & p_value ) {
2017-01-14 13:03:53 +00:00
2017-03-05 15:44:50 +00:00
set_group_flags ( 0 , p_group , p_name , p_value ) ;
2017-01-14 13:03:53 +00:00
}
2014-11-06 00:20:42 +00:00
void SceneTree : : set_input_as_handled ( ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
input_handled = true ;
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
void SceneTree : : input_text ( const String & p_text ) {
2014-02-10 01:10:30 +00:00
root_lock + + ;
2017-03-05 15:44:50 +00:00
call_group_flags ( GROUP_CALL_REALTIME , " _viewports " , " _vp_input_text " , p_text ) ; //special one for GUI, as controls use their own process check
2016-01-17 01:41:10 +00:00
2014-02-10 01:10:30 +00:00
root_lock - - ;
}
2017-03-16 16:52:50 +00:00
bool SceneTree : : is_input_handled ( ) {
return input_handled ;
}
2017-05-20 15:38:03 +00:00
void SceneTree : : input_event ( const Ref < InputEvent > & p_event ) {
2014-02-10 01:10:30 +00:00
2017-08-24 20:58:51 +00:00
if ( Engine : : get_singleton ( ) - > is_editor_hint ( ) & & ( Object : : cast_to < InputEventJoypadButton > ( p_event . ptr ( ) ) | | Object : : cast_to < InputEventJoypadMotion > ( * p_event ) ) )
2014-12-07 05:04:20 +00:00
return ; //avoid joy input on editor
2017-12-26 12:48:50 +00:00
current_event + + ;
2014-02-10 01:10:30 +00:00
root_lock + + ;
2017-03-05 15:44:50 +00:00
input_handled = false ;
2014-02-10 01:10:30 +00:00
2020-01-17 11:47:23 +00:00
// Don't make const ref unless you can find and fix what caused GH-34691.
Ref < InputEvent > ev = p_event ;
2014-02-10 01:10:30 +00:00
2014-11-06 00:20:42 +00:00
MainLoop : : input_event ( ev ) ;
2014-04-10 03:18:27 +00:00
2017-03-05 15:44:50 +00:00
call_group_flags ( GROUP_CALL_REALTIME , " _viewports " , " _vp_input " , ev ) ; //special one for GUI, as controls use their own process check
2014-02-10 01:10:30 +00:00
2017-05-20 15:38:03 +00:00
if ( ScriptDebugger : : get_singleton ( ) & & ScriptDebugger : : get_singleton ( ) - > is_remote ( ) ) {
//quit from game window using F8
Ref < InputEventKey > k = ev ;
2018-04-05 17:59:35 +00:00
if ( k . is_valid ( ) & & k - > is_pressed ( ) & & ! k - > is_echo ( ) & & k - > get_keycode ( ) = = KEY_F8 ) {
2017-05-20 15:38:03 +00:00
ScriptDebugger : : get_singleton ( ) - > request_quit ( ) ;
}
2014-02-10 01:10:30 +00:00
}
2016-03-08 23:00:52 +00:00
_flush_ugc ( ) ;
2014-02-10 01:10:30 +00:00
root_lock - - ;
2017-08-19 02:01:27 +00:00
//MessageQueue::get_singleton()->flush(); //flushing here causes UI and other places slowness
2014-02-10 01:10:30 +00:00
root_lock + + ;
if ( ! input_handled ) {
2017-03-05 15:44:50 +00:00
call_group_flags ( GROUP_CALL_REALTIME , " _viewports " , " _vp_unhandled_input " , ev ) ; //special one for GUI, as controls use their own process check
2014-02-10 01:10:30 +00:00
_flush_ugc ( ) ;
2017-12-04 20:35:58 +00:00
// input_handled = true; - no reason to set this as handled
2014-02-10 01:10:30 +00:00
root_lock - - ;
2017-08-19 02:01:27 +00:00
//MessageQueue::get_singleton()->flush(); //flushing here causes UI and other places slowness
2014-02-10 01:10:30 +00:00
} else {
2017-12-04 20:35:58 +00:00
// input_handled = true; - no reason to set this as handled
2014-02-10 01:10:30 +00:00
root_lock - - ;
}
2016-10-27 14:50:26 +00:00
_call_idle_callbacks ( ) ;
2014-02-10 01:10:30 +00:00
}
2014-11-06 00:20:42 +00:00
void SceneTree : : init ( ) {
2017-03-05 15:44:50 +00:00
initialized = true ;
2014-11-06 00:20:42 +00:00
root - > _set_tree ( this ) ;
2014-02-10 01:10:30 +00:00
MainLoop : : init ( ) ;
}
2014-11-06 00:20:42 +00:00
bool SceneTree : : iteration ( float p_time ) {
2014-02-10 01:10:30 +00:00
root_lock + + ;
current_frame + + ;
2017-10-30 18:43:19 +00:00
flush_transform_notifications ( ) ;
2014-02-10 01:10:30 +00:00
MainLoop : : iteration ( p_time ) ;
2017-09-30 14:19:07 +00:00
physics_process_time = p_time ;
2014-09-15 14:33:30 +00:00
2017-09-30 14:19:07 +00:00
emit_signal ( " physics_frame " ) ;
2014-09-15 14:33:30 +00:00
2017-09-30 14:19:07 +00:00
_notify_group_pause ( " physics_process_internal " , Node : : NOTIFICATION_INTERNAL_PHYSICS_PROCESS ) ;
_notify_group_pause ( " physics_process " , Node : : NOTIFICATION_PHYSICS_PROCESS ) ;
2014-02-10 01:10:30 +00:00
_flush_ugc ( ) ;
2017-08-08 01:18:12 +00:00
MessageQueue : : get_singleton ( ) - > flush ( ) ; //small little hack
2017-10-30 18:43:19 +00:00
flush_transform_notifications ( ) ;
2017-03-05 15:44:50 +00:00
call_group_flags ( GROUP_CALL_REALTIME , " _viewports " , " update_worlds " ) ;
2014-02-10 01:10:30 +00:00
root_lock - - ;
_flush_delete_queue ( ) ;
2016-10-27 14:50:26 +00:00
_call_idle_callbacks ( ) ;
2014-02-10 01:10:30 +00:00
return _quit ;
}
2019-01-26 17:56:22 +00:00
void SceneTree : : _update_font_oversampling ( float p_ratio ) {
if ( use_font_oversampling ) {
DynamicFontAtSize : : font_oversampling = p_ratio ;
DynamicFont : : update_oversampling ( ) ;
}
}
2017-03-05 15:44:50 +00:00
bool SceneTree : : idle ( float p_time ) {
2014-02-10 01:10:30 +00:00
2017-01-14 11:26:56 +00:00
//print_line("ram: "+itos(OS::get_singleton()->get_static_memory_usage())+" sram: "+itos(OS::get_singleton()->get_dynamic_memory_usage()));
//print_line("node count: "+itos(get_node_count()));
//print_line("TEXTURE RAM: "+itos(VS::get_singleton()->get_render_info(VS::INFO_TEXTURE_MEM_USED)));
2014-02-10 01:10:30 +00:00
root_lock + + ;
MainLoop : : idle ( p_time ) ;
2017-03-05 15:44:50 +00:00
idle_process_time = p_time ;
2014-02-10 01:10:30 +00:00
2018-06-02 12:32:30 +00:00
if ( multiplayer_poll ) {
multiplayer - > poll ( ) ;
}
2016-08-14 21:49:50 +00:00
2014-09-15 14:33:30 +00:00
emit_signal ( " idle_frame " ) ;
2017-08-08 01:18:12 +00:00
MessageQueue : : get_singleton ( ) - > flush ( ) ; //small little hack
2017-10-30 18:43:19 +00:00
flush_transform_notifications ( ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
_notify_group_pause ( " idle_process_internal " , Node : : NOTIFICATION_INTERNAL_PROCESS ) ;
_notify_group_pause ( " idle_process " , Node : : NOTIFICATION_PROCESS ) ;
2014-02-10 01:10:30 +00:00
2018-07-03 21:52:23 +00:00
Size2 win_size = Size2 ( OS : : get_singleton ( ) - > get_window_size ( ) . width , OS : : get_singleton ( ) - > get_window_size ( ) . height ) ;
2017-03-05 15:44:50 +00:00
if ( win_size ! = last_screen_size ) {
2014-02-10 01:10:30 +00:00
2018-03-19 13:44:26 +00:00
last_screen_size = win_size ;
_update_root_rect ( ) ;
2014-02-10 01:10:30 +00:00
emit_signal ( " screen_resized " ) ;
}
_flush_ugc ( ) ;
2017-08-08 01:18:12 +00:00
MessageQueue : : get_singleton ( ) - > flush ( ) ; //small little hack
2017-10-30 18:43:19 +00:00
flush_transform_notifications ( ) ; //transforms after world update, to avoid unnecessary enter/exit notifications
2017-03-05 15:44:50 +00:00
call_group_flags ( GROUP_CALL_REALTIME , " _viewports " , " update_worlds " ) ;
2014-02-10 01:10:30 +00:00
root_lock - - ;
_flush_delete_queue ( ) ;
2016-08-07 00:39:50 +00:00
//go through timers
2018-11-13 23:11:22 +00:00
List < Ref < SceneTreeTimer > > : : Element * L = timers . back ( ) ; //last element
2017-03-05 15:44:50 +00:00
for ( List < Ref < SceneTreeTimer > > : : Element * E = timers . front ( ) ; E ; ) {
2016-08-07 00:39:50 +00:00
List < Ref < SceneTreeTimer > > : : Element * N = E - > next ( ) ;
2017-02-13 23:34:33 +00:00
if ( pause & & ! E - > get ( ) - > is_pause_mode_process ( ) ) {
2018-11-13 23:11:22 +00:00
if ( E = = L ) {
break ; //break on last, so if new timers were added during list traversal, ignore them.
}
2017-03-05 15:44:50 +00:00
E = N ;
2017-02-13 23:34:33 +00:00
continue ;
}
2016-08-07 00:39:50 +00:00
float time_left = E - > get ( ) - > get_time_left ( ) ;
2017-03-05 15:44:50 +00:00
time_left - = p_time ;
2016-08-07 00:39:50 +00:00
E - > get ( ) - > set_time_left ( time_left ) ;
2017-03-05 15:44:50 +00:00
if ( time_left < 0 ) {
2016-08-07 00:39:50 +00:00
E - > get ( ) - > emit_signal ( " timeout " ) ;
timers . erase ( E ) ;
}
2018-11-13 23:11:22 +00:00
if ( E = = L ) {
break ; //break on last, so if new timers were added during list traversal, ignore them.
}
2017-03-05 15:44:50 +00:00
E = N ;
2016-08-07 00:39:50 +00:00
}
2019-07-29 10:33:38 +00:00
flush_transform_notifications ( ) ; //additional transforms after timers update
2016-10-27 14:50:26 +00:00
_call_idle_callbacks ( ) ;
2017-05-29 00:46:48 +00:00
# ifdef TOOLS_ENABLED
2017-08-18 23:02:56 +00:00
if ( Engine : : get_singleton ( ) - > is_editor_hint ( ) ) {
2017-05-29 00:46:48 +00:00
//simple hack to reload fallback environment if it changed from editor
2017-07-19 20:00:46 +00:00
String env_path = ProjectSettings : : get_singleton ( ) - > get ( " rendering/environment/default_environment " ) ;
2017-05-29 00:46:48 +00:00
env_path = env_path . strip_edges ( ) ; //user may have added a space or two
String cpath ;
Ref < Environment > fallback = get_root ( ) - > get_world ( ) - > get_fallback_environment ( ) ;
if ( fallback . is_valid ( ) ) {
cpath = fallback - > get_path ( ) ;
}
if ( cpath ! = env_path ) {
if ( env_path ! = String ( ) ) {
fallback = ResourceLoader : : load ( env_path ) ;
2017-08-31 11:55:20 +00:00
if ( fallback . is_null ( ) ) {
//could not load fallback, set as empty
ProjectSettings : : get_singleton ( ) - > set ( " rendering/environment/default_environment " , " " ) ;
}
2017-05-29 00:46:48 +00:00
} else {
fallback . unref ( ) ;
}
get_root ( ) - > get_world ( ) - > set_fallback_environment ( fallback ) ;
}
}
# endif
2014-02-10 01:10:30 +00:00
return _quit ;
}
2014-11-06 00:20:42 +00:00
void SceneTree : : finish ( ) {
2014-02-10 01:10:30 +00:00
_flush_delete_queue ( ) ;
_flush_ugc ( ) ;
2017-03-05 15:44:50 +00:00
initialized = false ;
2014-02-10 01:10:30 +00:00
MainLoop : : finish ( ) ;
if ( root ) {
2014-11-06 00:20:42 +00:00
root - > _set_tree ( NULL ) ;
2018-09-07 18:31:19 +00:00
root - > _propagate_after_exit_tree ( ) ;
2014-02-10 01:10:30 +00:00
memdelete ( root ) ; //delete root
2019-06-01 13:42:22 +00:00
root = NULL ;
2014-02-10 01:10:30 +00:00
}
2019-10-19 16:45:17 +00:00
// cleanup timers
for ( List < Ref < SceneTreeTimer > > : : Element * E = timers . front ( ) ; E ; E = E - > next ( ) ) {
E - > get ( ) - > release_connections ( ) ;
}
timers . clear ( ) ;
2014-02-10 01:10:30 +00:00
}
2019-12-29 15:39:24 +00:00
void SceneTree : : quit ( int p_exit_code ) {
if ( p_exit_code > = 0 ) {
// Override the exit code if a positive argument is given (the default is `-1`).
// This is a shorthand for calling `set_exit_code()` on the OS singleton then quitting.
OS : : get_singleton ( ) - > set_exit_code ( p_exit_code ) ;
}
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
_quit = true ;
2014-02-10 01:10:30 +00:00
}
2014-11-06 00:20:42 +00:00
void SceneTree : : _notification ( int p_notification ) {
2014-02-10 01:10:30 +00:00
switch ( p_notification ) {
case NOTIFICATION_WM_QUIT_REQUEST : {
get_root ( ) - > propagate_notification ( p_notification ) ;
if ( accept_quit ) {
2017-03-05 15:44:50 +00:00
_quit = true ;
2014-02-10 01:10:30 +00:00
break ;
}
} break ;
2019-09-09 21:42:17 +00:00
2017-01-11 19:34:32 +00:00
case NOTIFICATION_WM_GO_BACK_REQUEST : {
get_root ( ) - > propagate_notification ( p_notification ) ;
if ( quit_on_go_back ) {
2017-03-05 15:44:50 +00:00
_quit = true ;
2017-01-11 19:34:32 +00:00
break ;
}
} break ;
2014-02-10 01:10:30 +00:00
2019-09-09 21:42:17 +00:00
case NOTIFICATION_WM_FOCUS_IN : {
InputDefault * id = Object : : cast_to < InputDefault > ( Input : : get_singleton ( ) ) ;
if ( id ) {
id - > ensure_touch_mouse_raised ( ) ;
2018-02-24 02:04:30 +00:00
}
2014-02-10 01:10:30 +00:00
get_root ( ) - > propagate_notification ( p_notification ) ;
} break ;
2019-09-09 21:42:17 +00:00
2017-01-09 19:43:44 +00:00
case NOTIFICATION_TRANSLATION_CHANGED : {
2017-08-18 23:02:56 +00:00
if ( ! Engine : : get_singleton ( ) - > is_editor_hint ( ) ) {
2019-04-04 13:34:03 +00:00
get_root ( ) - > propagate_notification ( p_notification ) ;
2017-06-28 20:00:18 +00:00
}
2017-01-09 19:43:44 +00:00
} break ;
2019-09-09 21:42:17 +00:00
2014-02-10 01:10:30 +00:00
case NOTIFICATION_WM_UNFOCUS_REQUEST : {
2017-03-05 15:44:50 +00:00
notify_group_flags ( GROUP_CALL_REALTIME | GROUP_CALL_MULTILEVEL , " input " , NOTIFICATION_WM_UNFOCUS_REQUEST ) ;
2014-02-10 01:10:30 +00:00
2019-04-04 13:34:03 +00:00
get_root ( ) - > propagate_notification ( p_notification ) ;
2014-02-10 01:10:30 +00:00
} break ;
2019-09-09 21:42:17 +00:00
case NOTIFICATION_OS_MEMORY_WARNING :
case NOTIFICATION_OS_IME_UPDATE :
case NOTIFICATION_WM_MOUSE_ENTER :
case NOTIFICATION_WM_MOUSE_EXIT :
case NOTIFICATION_WM_FOCUS_OUT :
case NOTIFICATION_WM_ABOUT :
case NOTIFICATION_CRASH :
case NOTIFICATION_APP_RESUMED :
case NOTIFICATION_APP_PAUSED : {
2018-07-02 19:18:58 +00:00
get_root ( ) - > propagate_notification ( p_notification ) ;
} break ;
2014-02-10 01:10:30 +00:00
default :
break ;
} ;
} ;
2014-11-06 00:20:42 +00:00
void SceneTree : : set_auto_accept_quit ( bool p_enable ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
accept_quit = p_enable ;
2014-02-10 01:10:30 +00:00
}
2017-01-11 19:34:32 +00:00
void SceneTree : : set_quit_on_go_back ( bool p_enable ) {
2017-03-05 15:44:50 +00:00
quit_on_go_back = p_enable ;
2017-01-11 19:34:32 +00:00
}
2017-04-07 14:17:16 +00:00
# ifdef TOOLS_ENABLED
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
bool SceneTree : : is_node_being_edited ( const Node * p_node ) const {
2017-04-07 14:17:16 +00:00
2017-09-24 15:10:17 +00:00
return Engine : : get_singleton ( ) - > is_editor_hint ( ) & & edited_scene_root & & ( edited_scene_root - > is_a_parent_of ( p_node ) | | edited_scene_root = = p_node ) ;
2014-02-10 01:10:30 +00:00
}
2017-04-07 14:17:16 +00:00
# endif
2014-02-10 01:10:30 +00:00
2017-04-07 14:17:16 +00:00
# ifdef DEBUG_ENABLED
2015-09-19 02:10:58 +00:00
void SceneTree : : set_debug_collisions_hint ( bool p_enabled ) {
2017-03-05 15:44:50 +00:00
debug_collisions_hint = p_enabled ;
2015-09-19 02:10:58 +00:00
}
bool SceneTree : : is_debugging_collisions_hint ( ) const {
return debug_collisions_hint ;
}
2015-09-20 16:03:46 +00:00
void SceneTree : : set_debug_navigation_hint ( bool p_enabled ) {
2017-03-05 15:44:50 +00:00
debug_navigation_hint = p_enabled ;
2015-09-20 16:03:46 +00:00
}
bool SceneTree : : is_debugging_navigation_hint ( ) const {
return debug_navigation_hint ;
}
2017-04-07 14:17:16 +00:00
# endif
2015-09-20 16:03:46 +00:00
2017-03-05 15:44:50 +00:00
void SceneTree : : set_debug_collisions_color ( const Color & p_color ) {
2015-09-20 16:03:46 +00:00
2017-03-05 15:44:50 +00:00
debug_collisions_color = p_color ;
2015-09-20 16:03:46 +00:00
}
Color SceneTree : : get_debug_collisions_color ( ) const {
return debug_collisions_color ;
}
2017-03-05 15:44:50 +00:00
void SceneTree : : set_debug_collision_contact_color ( const Color & p_color ) {
2015-09-20 16:03:46 +00:00
2017-03-05 15:44:50 +00:00
debug_collision_contact_color = p_color ;
2015-09-20 16:03:46 +00:00
}
Color SceneTree : : get_debug_collision_contact_color ( ) const {
return debug_collision_contact_color ;
}
2017-03-05 15:44:50 +00:00
void SceneTree : : set_debug_navigation_color ( const Color & p_color ) {
2015-09-20 16:03:46 +00:00
2017-03-05 15:44:50 +00:00
debug_navigation_color = p_color ;
2015-09-20 16:03:46 +00:00
}
Color SceneTree : : get_debug_navigation_color ( ) const {
return debug_navigation_color ;
}
2017-03-05 15:44:50 +00:00
void SceneTree : : set_debug_navigation_disabled_color ( const Color & p_color ) {
2015-09-20 16:03:46 +00:00
2017-03-05 15:44:50 +00:00
debug_navigation_disabled_color = p_color ;
2015-09-20 16:03:46 +00:00
}
Color SceneTree : : get_debug_navigation_disabled_color ( ) const {
return debug_navigation_disabled_color ;
}
Ref < Material > SceneTree : : get_debug_navigation_material ( ) {
if ( navigation_material . is_valid ( ) )
return navigation_material ;
2019-09-15 04:01:52 +00:00
Ref < StandardMaterial3D > line_material = Ref < StandardMaterial3D > ( memnew ( StandardMaterial3D ) ) ;
line_material - > set_shading_mode ( StandardMaterial3D : : SHADING_MODE_UNSHADED ) ;
line_material - > set_transparency ( StandardMaterial3D : : TRANSPARENCY_ALPHA ) ;
line_material - > set_flag ( StandardMaterial3D : : FLAG_SRGB_VERTEX_COLOR , true ) ;
line_material - > set_flag ( StandardMaterial3D : : FLAG_ALBEDO_FROM_VERTEX_COLOR , true ) ;
2017-08-15 20:21:05 +00:00
line_material - > set_albedo ( get_debug_navigation_color ( ) ) ;
2015-09-20 16:03:46 +00:00
2017-03-05 15:44:50 +00:00
navigation_material = line_material ;
2015-09-20 16:03:46 +00:00
return navigation_material ;
}
2017-03-05 15:44:50 +00:00
Ref < Material > SceneTree : : get_debug_navigation_disabled_material ( ) {
2015-09-20 16:03:46 +00:00
if ( navigation_disabled_material . is_valid ( ) )
return navigation_disabled_material ;
2019-09-15 04:01:52 +00:00
Ref < StandardMaterial3D > line_material = Ref < StandardMaterial3D > ( memnew ( StandardMaterial3D ) ) ;
line_material - > set_shading_mode ( StandardMaterial3D : : SHADING_MODE_UNSHADED ) ;
line_material - > set_transparency ( StandardMaterial3D : : TRANSPARENCY_ALPHA ) ;
line_material - > set_flag ( StandardMaterial3D : : FLAG_SRGB_VERTEX_COLOR , true ) ;
line_material - > set_flag ( StandardMaterial3D : : FLAG_ALBEDO_FROM_VERTEX_COLOR , true ) ;
2017-08-15 20:21:05 +00:00
line_material - > set_albedo ( get_debug_navigation_disabled_color ( ) ) ;
2015-09-20 16:03:46 +00:00
2017-03-05 15:44:50 +00:00
navigation_disabled_material = line_material ;
2015-09-20 16:03:46 +00:00
return navigation_disabled_material ;
}
Ref < Material > SceneTree : : get_debug_collision_material ( ) {
if ( collision_material . is_valid ( ) )
return collision_material ;
2019-09-15 04:01:52 +00:00
Ref < StandardMaterial3D > line_material = Ref < StandardMaterial3D > ( memnew ( StandardMaterial3D ) ) ;
line_material - > set_shading_mode ( StandardMaterial3D : : SHADING_MODE_UNSHADED ) ;
line_material - > set_transparency ( StandardMaterial3D : : TRANSPARENCY_ALPHA ) ;
line_material - > set_flag ( StandardMaterial3D : : FLAG_SRGB_VERTEX_COLOR , true ) ;
line_material - > set_flag ( StandardMaterial3D : : FLAG_ALBEDO_FROM_VERTEX_COLOR , true ) ;
2017-08-15 20:21:05 +00:00
line_material - > set_albedo ( get_debug_collisions_color ( ) ) ;
2015-09-20 16:03:46 +00:00
2017-03-05 15:44:50 +00:00
collision_material = line_material ;
2015-09-20 16:03:46 +00:00
return collision_material ;
}
2017-06-07 21:18:55 +00:00
Ref < ArrayMesh > SceneTree : : get_debug_contact_mesh ( ) {
2015-09-20 16:03:46 +00:00
if ( debug_contact_mesh . is_valid ( ) )
return debug_contact_mesh ;
2017-06-07 21:18:55 +00:00
debug_contact_mesh = Ref < ArrayMesh > ( memnew ( ArrayMesh ) ) ;
2015-09-20 16:03:46 +00:00
2019-09-15 04:01:52 +00:00
Ref < StandardMaterial3D > mat = Ref < StandardMaterial3D > ( memnew ( StandardMaterial3D ) ) ;
mat - > set_shading_mode ( StandardMaterial3D : : SHADING_MODE_UNSHADED ) ;
mat - > set_transparency ( StandardMaterial3D : : TRANSPARENCY_ALPHA ) ;
mat - > set_flag ( StandardMaterial3D : : FLAG_SRGB_VERTEX_COLOR , true ) ;
mat - > set_flag ( StandardMaterial3D : : FLAG_ALBEDO_FROM_VERTEX_COLOR , true ) ;
2017-08-15 20:21:05 +00:00
mat - > set_albedo ( get_debug_collision_contact_color ( ) ) ;
2015-09-20 16:03:46 +00:00
2017-03-05 15:44:50 +00:00
Vector3 diamond [ 6 ] = {
2015-09-20 16:03:46 +00:00
Vector3 ( - 1 , 0 , 0 ) ,
2017-03-05 15:44:50 +00:00
Vector3 ( 1 , 0 , 0 ) ,
Vector3 ( 0 , - 1 , 0 ) ,
Vector3 ( 0 , 1 , 0 ) ,
Vector3 ( 0 , 0 , - 1 ) ,
Vector3 ( 0 , 0 , 1 )
2015-09-20 16:03:46 +00:00
} ;
2017-12-06 20:36:34 +00:00
/* clang-format off */
2017-03-05 15:44:50 +00:00
int diamond_faces [ 8 * 3 ] = {
0 , 2 , 4 ,
0 , 3 , 4 ,
1 , 2 , 4 ,
1 , 3 , 4 ,
0 , 2 , 5 ,
0 , 3 , 5 ,
1 , 2 , 5 ,
1 , 3 , 5 ,
2015-09-20 16:03:46 +00:00
} ;
2017-12-06 20:36:34 +00:00
/* clang-format on */
2015-09-20 16:03:46 +00:00
2020-02-17 21:06:54 +00:00
Vector < int > indices ;
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < 8 * 3 ; i + + )
2015-09-20 16:03:46 +00:00
indices . push_back ( diamond_faces [ i ] ) ;
2020-02-17 21:06:54 +00:00
Vector < Vector3 > vertices ;
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < 6 ; i + + )
vertices . push_back ( diamond [ i ] * 0.1 ) ;
2015-09-20 16:03:46 +00:00
Array arr ;
arr . resize ( Mesh : : ARRAY_MAX ) ;
2017-03-05 15:44:50 +00:00
arr [ Mesh : : ARRAY_VERTEX ] = vertices ;
arr [ Mesh : : ARRAY_INDEX ] = indices ;
2015-09-20 16:03:46 +00:00
2017-03-05 15:44:50 +00:00
debug_contact_mesh - > add_surface_from_arrays ( Mesh : : PRIMITIVE_TRIANGLES , arr ) ;
debug_contact_mesh - > surface_set_material ( 0 , mat ) ;
2015-09-20 16:03:46 +00:00
return debug_contact_mesh ;
}
2014-11-06 00:20:42 +00:00
void SceneTree : : set_pause ( bool p_enabled ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
if ( p_enabled = = pause )
2014-02-10 01:10:30 +00:00
return ;
2017-03-05 15:44:50 +00:00
pause = p_enabled ;
2020-01-10 11:22:34 +00:00
NavigationServer : : get_singleton ( ) - > set_active ( ! p_enabled ) ;
2014-02-10 01:10:30 +00:00
PhysicsServer : : get_singleton ( ) - > set_active ( ! p_enabled ) ;
Physics2DServer : : get_singleton ( ) - > set_active ( ! p_enabled ) ;
if ( get_root ( ) )
get_root ( ) - > propagate_notification ( p_enabled ? Node : : NOTIFICATION_PAUSED : Node : : NOTIFICATION_UNPAUSED ) ;
}
2014-11-06 00:20:42 +00:00
bool SceneTree : : is_paused ( ) const {
2014-02-10 01:10:30 +00:00
return pause ;
}
2017-05-20 15:38:03 +00:00
void SceneTree : : _call_input_pause ( const StringName & p_group , const StringName & p_method , const Ref < InputEvent > & p_input ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
Map < StringName , Group > : : Element * E = group_map . find ( p_group ) ;
2014-02-10 01:10:30 +00:00
if ( ! E )
return ;
2017-03-05 15:44:50 +00:00
Group & g = E - > get ( ) ;
2014-02-10 01:10:30 +00:00
if ( g . nodes . empty ( ) )
return ;
_update_group_order ( g ) ;
//copy, so copy on write happens in case something is removed from process while being called
//performance is not lost because only if something is added/removed the vector is copied.
2017-03-05 15:44:50 +00:00
Vector < Node * > nodes_copy = g . nodes ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
int node_count = nodes_copy . size ( ) ;
2018-07-25 01:11:03 +00:00
Node * * nodes = nodes_copy . ptrw ( ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
Variant arg = p_input ;
const Variant * v [ 1 ] = { & arg } ;
2014-02-10 01:10:30 +00:00
call_lock + + ;
2017-03-05 15:44:50 +00:00
for ( int i = node_count - 1 ; i > = 0 ; i - - ) {
2014-02-10 01:10:30 +00:00
if ( input_handled )
break ;
Node * n = nodes [ i ] ;
if ( call_lock & & call_skip . has ( n ) )
continue ;
if ( ! n - > can_process ( ) )
continue ;
2017-03-05 15:44:50 +00:00
n - > call_multilevel ( p_method , ( const Variant * * ) v , 1 ) ;
2014-02-10 01:10:30 +00:00
//ERR_FAIL_COND(node_count != g.nodes.size());
}
call_lock - - ;
2017-03-05 15:44:50 +00:00
if ( call_lock = = 0 )
2014-02-10 01:10:30 +00:00
call_skip . clear ( ) ;
}
2017-03-05 15:44:50 +00:00
void SceneTree : : _notify_group_pause ( const StringName & p_group , int p_notification ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
Map < StringName , Group > : : Element * E = group_map . find ( p_group ) ;
2014-02-10 01:10:30 +00:00
if ( ! E )
return ;
2017-03-05 15:44:50 +00:00
Group & g = E - > get ( ) ;
2014-02-10 01:10:30 +00:00
if ( g . nodes . empty ( ) )
return ;
2018-07-02 05:30:40 +00:00
_update_group_order ( g , p_notification = = Node : : NOTIFICATION_PROCESS | | p_notification = = Node : : NOTIFICATION_INTERNAL_PROCESS | | p_notification = = Node : : NOTIFICATION_PHYSICS_PROCESS | | p_notification = = Node : : NOTIFICATION_INTERNAL_PHYSICS_PROCESS ) ;
2014-02-10 01:10:30 +00:00
//copy, so copy on write happens in case something is removed from process while being called
//performance is not lost because only if something is added/removed the vector is copied.
2017-03-05 15:44:50 +00:00
Vector < Node * > nodes_copy = g . nodes ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
int node_count = nodes_copy . size ( ) ;
2018-07-25 01:11:03 +00:00
Node * * nodes = nodes_copy . ptrw ( ) ;
2014-02-10 01:10:30 +00:00
call_lock + + ;
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < node_count ; i + + ) {
2014-02-10 01:10:30 +00:00
Node * n = nodes [ i ] ;
if ( call_lock & & call_skip . has ( n ) )
continue ;
if ( ! n - > can_process ( ) )
continue ;
2018-07-30 00:20:41 +00:00
if ( ! n - > can_process_notification ( p_notification ) )
continue ;
2014-02-10 01:10:30 +00:00
n - > notification ( p_notification ) ;
//ERR_FAIL_COND(node_count != g.nodes.size());
}
call_lock - - ;
2017-03-05 15:44:50 +00:00
if ( call_lock = = 0 )
2014-02-10 01:10:30 +00:00
call_skip . clear ( ) ;
}
/*
void SceneMainLoop : : _update_listener_2d ( ) {
if ( listener_2d . is_valid ( ) ) {
SpatialSound2DServer : : get_singleton ( ) - > listener_set_space ( listener_2d , world_2d - > get_sound_space ( ) ) ;
}
}
*/
2020-02-19 19:27:19 +00:00
Variant SceneTree : : _call_group_flags ( const Variant * * p_args , int p_argcount , Callable : : CallError & r_error ) {
2014-02-10 01:10:30 +00:00
2020-02-19 19:27:19 +00:00
r_error . error = Callable : : CallError : : CALL_OK ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND_V ( p_argcount < 3 , Variant ( ) ) ;
ERR_FAIL_COND_V ( ! p_args [ 0 ] - > is_num ( ) , Variant ( ) ) ;
2020-02-20 21:58:05 +00:00
ERR_FAIL_COND_V ( p_args [ 1 ] - > get_type ( ) ! = Variant : : STRING_NAME & & p_args [ 1 ] - > get_type ( ) ! = Variant : : STRING , Variant ( ) ) ;
ERR_FAIL_COND_V ( p_args [ 2 ] - > get_type ( ) ! = Variant : : STRING_NAME & & p_args [ 2 ] - > get_type ( ) ! = Variant : : STRING , Variant ( ) ) ;
2014-02-10 01:10:30 +00:00
int flags = * p_args [ 0 ] ;
StringName group = * p_args [ 1 ] ;
StringName method = * p_args [ 2 ] ;
Variant v [ VARIANT_ARG_MAX ] ;
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < MIN ( p_argcount - 3 , 5 ) ; i + + ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
v [ i ] = * p_args [ i + 3 ] ;
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
call_group_flags ( flags , group , method , v [ 0 ] , v [ 1 ] , v [ 2 ] , v [ 3 ] , v [ 4 ] ) ;
2014-02-10 01:10:30 +00:00
return Variant ( ) ;
}
2020-02-19 19:27:19 +00:00
Variant SceneTree : : _call_group ( const Variant * * p_args , int p_argcount , Callable : : CallError & r_error ) {
2014-02-10 01:10:30 +00:00
2020-02-19 19:27:19 +00:00
r_error . error = Callable : : CallError : : CALL_OK ;
2017-01-14 13:03:53 +00:00
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND_V ( p_argcount < 2 , Variant ( ) ) ;
2020-02-20 21:58:05 +00:00
ERR_FAIL_COND_V ( p_args [ 0 ] - > get_type ( ) ! = Variant : : STRING_NAME & & p_args [ 0 ] - > get_type ( ) ! = Variant : : STRING , Variant ( ) ) ;
ERR_FAIL_COND_V ( p_args [ 1 ] - > get_type ( ) ! = Variant : : STRING_NAME & & p_args [ 1 ] - > get_type ( ) ! = Variant : : STRING , Variant ( ) ) ;
2017-01-14 13:03:53 +00:00
StringName group = * p_args [ 0 ] ;
StringName method = * p_args [ 1 ] ;
Variant v [ VARIANT_ARG_MAX ] ;
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < MIN ( p_argcount - 2 , 5 ) ; i + + ) {
2017-01-14 13:03:53 +00:00
2017-03-05 15:44:50 +00:00
v [ i ] = * p_args [ i + 2 ] ;
2017-01-14 13:03:53 +00:00
}
2017-03-05 15:44:50 +00:00
call_group_flags ( 0 , group , method , v [ 0 ] , v [ 1 ] , v [ 2 ] , v [ 3 ] , v [ 4 ] ) ;
2017-01-14 13:03:53 +00:00
return Variant ( ) ;
}
2014-11-06 00:20:42 +00:00
int64_t SceneTree : : get_frame ( ) const {
2014-02-10 01:10:30 +00:00
return current_frame ;
}
2017-12-26 12:48:50 +00:00
int64_t SceneTree : : get_event_count ( ) const {
return current_event ;
}
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
Array SceneTree : : _get_nodes_in_group ( const StringName & p_group ) {
2014-02-10 01:10:30 +00:00
Array ret ;
2017-03-05 15:44:50 +00:00
Map < StringName , Group > : : Element * E = group_map . find ( p_group ) ;
2014-02-10 01:10:30 +00:00
if ( ! E )
return ret ;
_update_group_order ( E - > get ( ) ) ; //update order just in case
int nc = E - > get ( ) . nodes . size ( ) ;
2017-03-05 15:44:50 +00:00
if ( nc = = 0 )
2014-02-10 01:10:30 +00:00
return ret ;
ret . resize ( nc ) ;
2017-11-25 03:07:54 +00:00
Node * * ptr = E - > get ( ) . nodes . ptrw ( ) ;
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < nc ; i + + ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
ret [ i ] = ptr [ i ] ;
2014-02-10 01:10:30 +00:00
}
return ret ;
}
2017-03-05 15:44:50 +00:00
bool SceneTree : : has_group ( const StringName & p_identifier ) const {
2016-01-02 20:18:45 +00:00
return group_map . has ( p_identifier ) ;
}
2017-03-05 15:44:50 +00:00
void SceneTree : : get_nodes_in_group ( const StringName & p_group , List < Node * > * p_list ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
Map < StringName , Group > : : Element * E = group_map . find ( p_group ) ;
2014-02-10 01:10:30 +00:00
if ( ! E )
return ;
_update_group_order ( E - > get ( ) ) ; //update order just in case
int nc = E - > get ( ) . nodes . size ( ) ;
2017-03-05 15:44:50 +00:00
if ( nc = = 0 )
2014-02-10 01:10:30 +00:00
return ;
2017-11-25 03:07:54 +00:00
Node * * ptr = E - > get ( ) . nodes . ptrw ( ) ;
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < nc ; i + + ) {
2014-02-10 01:10:30 +00:00
p_list - > push_back ( ptr [ i ] ) ;
}
}
2014-11-06 00:20:42 +00:00
void SceneTree : : _flush_delete_queue ( ) {
2014-02-10 01:10:30 +00:00
_THREAD_SAFE_METHOD_
2017-03-05 15:44:50 +00:00
while ( delete_queue . size ( ) ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
Object * obj = ObjectDB : : get_instance ( delete_queue . front ( ) - > get ( ) ) ;
2014-02-10 01:10:30 +00:00
if ( obj ) {
2017-03-05 15:44:50 +00:00
memdelete ( obj ) ;
2014-02-10 01:10:30 +00:00
}
delete_queue . pop_front ( ) ;
}
}
2014-11-06 00:20:42 +00:00
void SceneTree : : queue_delete ( Object * p_object ) {
2014-02-10 01:10:30 +00:00
_THREAD_SAFE_METHOD_
ERR_FAIL_NULL ( p_object ) ;
2015-03-28 17:34:28 +00:00
p_object - > _is_queued_for_deletion = true ;
2017-08-07 10:17:31 +00:00
delete_queue . push_back ( p_object - > get_instance_id ( ) ) ;
2014-02-10 01:10:30 +00:00
}
2014-11-06 00:20:42 +00:00
int SceneTree : : get_node_count ( ) const {
2014-02-10 01:10:30 +00:00
return node_count ;
}
2014-11-06 00:20:42 +00:00
void SceneTree : : _update_root_rect ( ) {
2014-04-15 01:43:44 +00:00
2017-03-05 15:44:50 +00:00
if ( stretch_mode = = STRETCH_MODE_DISABLED ) {
2014-04-15 01:43:44 +00:00
2019-01-26 17:56:22 +00:00
_update_font_oversampling ( 1.0 ) ;
2017-07-22 17:07:38 +00:00
root - > set_size ( ( last_screen_size / stretch_shrink ) . floor ( ) ) ;
2017-03-05 15:44:50 +00:00
root - > set_attach_to_screen_rect ( Rect2 ( Point2 ( ) , last_screen_size ) ) ;
2016-10-03 19:33:42 +00:00
root - > set_size_override_stretch ( false ) ;
2017-03-05 15:44:50 +00:00
root - > set_size_override ( false , Size2 ( ) ) ;
2019-01-26 17:56:22 +00:00
root - > update_canvas_items ( ) ;
2014-04-15 01:43:44 +00:00
return ; //user will take care
}
//actual screen video mode
2018-07-03 21:52:23 +00:00
Size2 video_mode = Size2 ( OS : : get_singleton ( ) - > get_window_size ( ) . width , OS : : get_singleton ( ) - > get_window_size ( ) . height ) ;
2014-04-15 01:43:44 +00:00
Size2 desired_res = stretch_min ;
Size2 viewport_size ;
Size2 screen_size ;
2017-01-13 23:00:43 +00:00
float viewport_aspect = desired_res . aspect ( ) ;
float video_mode_aspect = video_mode . aspect ( ) ;
2014-04-15 01:43:44 +00:00
2019-01-31 18:49:10 +00:00
if ( use_font_oversampling & & stretch_aspect = = STRETCH_ASPECT_IGNORE ) {
WARN_PRINT ( " Font oversampling only works with the resize modes 'Keep Width', 'Keep Height', and 'Expand'. " ) ;
}
2019-01-16 15:42:53 +00:00
if ( stretch_aspect = = STRETCH_ASPECT_IGNORE | | Math : : is_equal_approx ( viewport_aspect , video_mode_aspect ) ) {
2014-04-15 01:43:44 +00:00
//same aspect or ignore aspect
2017-03-05 15:44:50 +00:00
viewport_size = desired_res ;
screen_size = video_mode ;
2014-04-15 01:43:44 +00:00
} else if ( viewport_aspect < video_mode_aspect ) {
// screen ratio is smaller vertically
2017-08-09 07:53:38 +00:00
if ( stretch_aspect = = STRETCH_ASPECT_KEEP_HEIGHT | | stretch_aspect = = STRETCH_ASPECT_EXPAND ) {
2014-04-15 01:43:44 +00:00
//will stretch horizontally
2017-03-05 15:44:50 +00:00
viewport_size . x = desired_res . y * video_mode_aspect ;
viewport_size . y = desired_res . y ;
screen_size = video_mode ;
2014-04-15 01:43:44 +00:00
} else {
//will need black bars
2017-03-05 15:44:50 +00:00
viewport_size = desired_res ;
2014-04-15 01:43:44 +00:00
screen_size . x = video_mode . y * viewport_aspect ;
2017-03-05 15:44:50 +00:00
screen_size . y = video_mode . y ;
2014-04-15 01:43:44 +00:00
}
} else {
//screen ratio is smaller horizontally
2017-08-09 07:53:38 +00:00
if ( stretch_aspect = = STRETCH_ASPECT_KEEP_WIDTH | | stretch_aspect = = STRETCH_ASPECT_EXPAND ) {
2014-04-15 01:43:44 +00:00
//will stretch horizontally
2017-03-05 15:44:50 +00:00
viewport_size . x = desired_res . x ;
viewport_size . y = desired_res . x / video_mode_aspect ;
screen_size = video_mode ;
2014-04-15 01:43:44 +00:00
} else {
//will need black bars
2017-03-05 15:44:50 +00:00
viewport_size = desired_res ;
screen_size . x = video_mode . x ;
2014-04-15 01:43:44 +00:00
screen_size . y = video_mode . x / viewport_aspect ;
}
}
screen_size = screen_size . floor ( ) ;
viewport_size = viewport_size . floor ( ) ;
Size2 margin ;
Size2 offset ;
//black bars and margin
2017-08-09 07:53:38 +00:00
if ( stretch_aspect ! = STRETCH_ASPECT_EXPAND & & screen_size . x < video_mode . x ) {
2017-03-05 15:44:50 +00:00
margin . x = Math : : round ( ( video_mode . x - screen_size . x ) / 2.0 ) ;
VisualServer : : get_singleton ( ) - > black_bars_set_margins ( margin . x , 0 , margin . x , 0 ) ;
2014-04-15 01:43:44 +00:00
offset . x = Math : : round ( margin . x * viewport_size . y / screen_size . y ) ;
2017-08-09 07:53:38 +00:00
} else if ( stretch_aspect ! = STRETCH_ASPECT_EXPAND & & screen_size . y < video_mode . y ) {
2017-03-05 15:44:50 +00:00
margin . y = Math : : round ( ( video_mode . y - screen_size . y ) / 2.0 ) ;
VisualServer : : get_singleton ( ) - > black_bars_set_margins ( 0 , margin . y , 0 , margin . y ) ;
2014-04-15 01:43:44 +00:00
offset . y = Math : : round ( margin . y * viewport_size . x / screen_size . x ) ;
} else {
2017-03-05 15:44:50 +00:00
VisualServer : : get_singleton ( ) - > black_bars_set_margins ( 0 , 0 , 0 , 0 ) ;
2014-04-15 01:43:44 +00:00
}
switch ( stretch_mode ) {
2018-09-26 11:13:56 +00:00
case STRETCH_MODE_DISABLED : {
// Already handled above
2019-01-26 17:56:22 +00:00
_update_font_oversampling ( 1.0 ) ;
2018-09-26 11:13:56 +00:00
} break ;
2014-04-15 01:43:44 +00:00
case STRETCH_MODE_2D : {
2019-01-26 17:56:22 +00:00
_update_font_oversampling ( screen_size . x / viewport_size . x ) ; //screen / viewport radio drives oversampling
2017-07-22 17:07:38 +00:00
root - > set_size ( ( screen_size / stretch_shrink ) . floor ( ) ) ;
2017-03-05 15:44:50 +00:00
root - > set_attach_to_screen_rect ( Rect2 ( margin , screen_size ) ) ;
2014-04-15 01:43:44 +00:00
root - > set_size_override_stretch ( true ) ;
2017-07-22 17:07:38 +00:00
root - > set_size_override ( true , ( viewport_size / stretch_shrink ) . floor ( ) ) ;
2019-01-26 17:56:22 +00:00
root - > update_canvas_items ( ) ; //force them to update just in case
2014-04-15 01:43:44 +00:00
} break ;
case STRETCH_MODE_VIEWPORT : {
2019-01-26 17:56:22 +00:00
_update_font_oversampling ( 1.0 ) ;
2017-07-22 17:07:38 +00:00
root - > set_size ( ( viewport_size / stretch_shrink ) . floor ( ) ) ;
2017-03-05 15:44:50 +00:00
root - > set_attach_to_screen_rect ( Rect2 ( margin , screen_size ) ) ;
2014-04-15 01:43:44 +00:00
root - > set_size_override_stretch ( false ) ;
2017-03-05 15:44:50 +00:00
root - > set_size_override ( false , Size2 ( ) ) ;
2019-01-26 17:56:22 +00:00
root - > update_canvas_items ( ) ; //force them to update just in case
if ( use_font_oversampling ) {
2019-06-11 12:49:34 +00:00
WARN_PRINT ( " Font oversampling does not work in 'Viewport' stretch mode, only '2D'. " ) ;
2019-01-26 17:56:22 +00:00
}
2014-04-15 01:43:44 +00:00
} break ;
}
}
2019-07-10 09:54:12 +00:00
void SceneTree : : set_screen_stretch ( StretchMode p_mode , StretchAspect p_aspect , const Size2 & p_minsize , real_t p_shrink ) {
2014-04-15 01:43:44 +00:00
2017-03-05 15:44:50 +00:00
stretch_mode = p_mode ;
stretch_aspect = p_aspect ;
stretch_min = p_minsize ;
2017-07-22 17:07:38 +00:00
stretch_shrink = p_shrink ;
2014-04-15 01:43:44 +00:00
_update_root_rect ( ) ;
}
2014-11-06 00:20:42 +00:00
void SceneTree : : set_edited_scene_root ( Node * p_node ) {
2018-04-29 17:49:26 +00:00
# ifdef TOOLS_ENABLED
2017-03-05 15:44:50 +00:00
edited_scene_root = p_node ;
2018-04-29 17:49:26 +00:00
# endif
2014-10-12 05:13:22 +00:00
}
2014-11-06 00:20:42 +00:00
Node * SceneTree : : get_edited_scene_root ( ) const {
2014-10-12 05:13:22 +00:00
2018-04-29 17:49:26 +00:00
# ifdef TOOLS_ENABLED
2014-10-12 05:13:22 +00:00
return edited_scene_root ;
2018-04-29 17:49:26 +00:00
# else
return NULL ;
2014-10-12 05:13:22 +00:00
# endif
2018-04-29 17:49:26 +00:00
}
2014-10-12 05:13:22 +00:00
2017-03-05 15:44:50 +00:00
void SceneTree : : set_current_scene ( Node * p_scene ) {
2015-05-17 19:33:35 +00:00
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( p_scene & & p_scene - > get_parent ( ) ! = root ) ;
current_scene = p_scene ;
2015-05-17 19:33:35 +00:00
}
2017-03-05 15:44:50 +00:00
Node * SceneTree : : get_current_scene ( ) const {
2015-05-17 19:33:35 +00:00
return current_scene ;
}
2017-03-05 15:44:50 +00:00
void SceneTree : : _change_scene ( Node * p_to ) {
2015-05-17 19:33:35 +00:00
if ( current_scene ) {
2017-03-05 15:44:50 +00:00
memdelete ( current_scene ) ;
current_scene = NULL ;
2015-05-17 19:33:35 +00:00
}
2020-01-19 21:06:26 +00:00
// If we're quitting, abort.
if ( unlikely ( _quit ) ) {
if ( p_to ) { // Prevent memory leak.
memdelete ( p_to ) ;
}
return ;
}
2015-05-17 19:33:35 +00:00
if ( p_to ) {
2017-03-05 15:44:50 +00:00
current_scene = p_to ;
2015-05-17 19:33:35 +00:00
root - > add_child ( p_to ) ;
}
}
2017-03-05 15:44:50 +00:00
Error SceneTree : : change_scene ( const String & p_path ) {
2015-05-17 19:33:35 +00:00
Ref < PackedScene > new_scene = ResourceLoader : : load ( p_path ) ;
if ( new_scene . is_null ( ) )
return ERR_CANT_OPEN ;
return change_scene_to ( new_scene ) ;
}
2020-01-19 21:06:26 +00:00
Error SceneTree : : change_scene_to ( const Ref < PackedScene > & p_scene ) {
2017-03-05 15:44:50 +00:00
Node * new_scene = NULL ;
2015-05-17 19:33:35 +00:00
if ( p_scene . is_valid ( ) ) {
new_scene = p_scene - > instance ( ) ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND_V ( ! new_scene , ERR_CANT_CREATE ) ;
2015-05-17 19:33:35 +00:00
}
2017-03-05 15:44:50 +00:00
call_deferred ( " _change_scene " , new_scene ) ;
2015-05-17 19:33:35 +00:00
return OK ;
}
2020-01-19 21:06:26 +00:00
Error SceneTree : : reload_current_scene ( ) {
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND_V ( ! current_scene , ERR_UNCONFIGURED ) ;
2015-05-17 19:33:35 +00:00
String fname = current_scene - > get_filename ( ) ;
return change_scene ( fname ) ;
}
2017-03-05 15:44:50 +00:00
void SceneTree : : add_current_scene ( Node * p_current ) {
2015-05-17 19:33:35 +00:00
2017-03-05 15:44:50 +00:00
current_scene = p_current ;
2015-05-17 19:33:35 +00:00
root - > add_child ( p_current ) ;
}
2020-01-19 21:06:26 +00:00
2017-03-05 15:44:50 +00:00
void SceneTree : : drop_files ( const Vector < String > & p_files , int p_from_screen ) {
2016-05-27 17:18:40 +00:00
2017-03-05 15:44:50 +00:00
emit_signal ( " files_dropped " , p_files , p_from_screen ) ;
MainLoop : : drop_files ( p_files , p_from_screen ) ;
2016-05-27 17:18:40 +00:00
}
2019-02-06 13:57:06 +00:00
void SceneTree : : global_menu_action ( const Variant & p_id , const Variant & p_meta ) {
emit_signal ( " global_menu_action " , p_id , p_meta ) ;
MainLoop : : global_menu_action ( p_id , p_meta ) ;
}
2017-02-13 23:34:33 +00:00
Ref < SceneTreeTimer > SceneTree : : create_timer ( float p_delay_sec , bool p_process_pause ) {
2016-08-07 00:39:50 +00:00
Ref < SceneTreeTimer > stt ;
stt . instance ( ) ;
2017-02-13 23:34:33 +00:00
stt - > set_pause_mode_process ( p_process_pause ) ;
2016-08-07 00:39:50 +00:00
stt - > set_time_left ( p_delay_sec ) ;
timers . push_back ( stt ) ;
return stt ;
}
2016-08-19 19:48:08 +00:00
void SceneTree : : _network_peer_connected ( int p_id ) {
2016-08-14 21:49:50 +00:00
2017-03-05 15:44:50 +00:00
emit_signal ( " network_peer_connected " , p_id ) ;
2016-08-14 21:49:50 +00:00
}
2016-08-19 19:48:08 +00:00
void SceneTree : : _network_peer_disconnected ( int p_id ) {
2016-08-14 21:49:50 +00:00
2017-03-05 15:44:50 +00:00
emit_signal ( " network_peer_disconnected " , p_id ) ;
2016-08-14 21:49:50 +00:00
}
2016-08-19 19:48:08 +00:00
void SceneTree : : _connected_to_server ( ) {
emit_signal ( " connected_to_server " ) ;
}
void SceneTree : : _connection_failed ( ) {
emit_signal ( " connection_failed " ) ;
}
void SceneTree : : _server_disconnected ( ) {
emit_signal ( " server_disconnected " ) ;
}
2018-05-08 08:51:04 +00:00
Ref < MultiplayerAPI > SceneTree : : get_multiplayer ( ) const {
return multiplayer ;
2018-03-03 17:30:11 +00:00
}
2018-06-02 12:32:30 +00:00
void SceneTree : : set_multiplayer_poll_enabled ( bool p_enabled ) {
multiplayer_poll = p_enabled ;
}
bool SceneTree : : is_multiplayer_poll_enabled ( ) const {
return multiplayer_poll ;
}
2018-05-08 08:51:04 +00:00
void SceneTree : : set_multiplayer ( Ref < MultiplayerAPI > p_multiplayer ) {
ERR_FAIL_COND ( ! p_multiplayer . is_valid ( ) ) ;
2018-03-03 17:30:11 +00:00
2018-05-08 08:51:04 +00:00
if ( multiplayer . is_valid ( ) ) {
2020-02-19 19:27:19 +00:00
multiplayer - > disconnect_compat ( " network_peer_connected " , this , " _network_peer_connected " ) ;
multiplayer - > disconnect_compat ( " network_peer_disconnected " , this , " _network_peer_disconnected " ) ;
multiplayer - > disconnect_compat ( " connected_to_server " , this , " _connected_to_server " ) ;
multiplayer - > disconnect_compat ( " connection_failed " , this , " _connection_failed " ) ;
multiplayer - > disconnect_compat ( " server_disconnected " , this , " _server_disconnected " ) ;
2016-08-14 21:49:50 +00:00
}
2018-05-08 08:51:04 +00:00
multiplayer = p_multiplayer ;
multiplayer - > set_root_node ( root ) ;
2016-08-14 21:49:50 +00:00
2020-02-19 19:27:19 +00:00
multiplayer - > connect_compat ( " network_peer_connected " , this , " _network_peer_connected " ) ;
multiplayer - > connect_compat ( " network_peer_disconnected " , this , " _network_peer_disconnected " ) ;
multiplayer - > connect_compat ( " connected_to_server " , this , " _connected_to_server " ) ;
multiplayer - > connect_compat ( " connection_failed " , this , " _connection_failed " ) ;
multiplayer - > connect_compat ( " server_disconnected " , this , " _server_disconnected " ) ;
2018-03-03 17:30:11 +00:00
}
2016-08-14 21:49:50 +00:00
2018-03-03 17:30:11 +00:00
void SceneTree : : set_network_peer ( const Ref < NetworkedMultiplayerPeer > & p_network_peer ) {
2018-05-08 08:51:04 +00:00
multiplayer - > set_network_peer ( p_network_peer ) ;
2016-08-14 21:49:50 +00:00
}
2018-01-11 22:35:12 +00:00
Ref < NetworkedMultiplayerPeer > SceneTree : : get_network_peer ( ) const {
2018-05-08 08:51:04 +00:00
return multiplayer - > get_network_peer ( ) ;
2018-01-11 22:35:12 +00:00
}
2016-08-14 21:49:50 +00:00
bool SceneTree : : is_network_server ( ) const {
2018-05-08 08:51:04 +00:00
return multiplayer - > is_network_server ( ) ;
2016-08-14 21:49:50 +00:00
}
2017-03-04 10:35:44 +00:00
bool SceneTree : : has_network_peer ( ) const {
2018-05-08 08:51:04 +00:00
return multiplayer - > has_network_peer ( ) ;
2017-03-04 10:35:44 +00:00
}
2016-08-19 19:48:08 +00:00
int SceneTree : : get_network_unique_id ( ) const {
2018-05-08 08:51:04 +00:00
return multiplayer - > get_network_unique_id ( ) ;
2016-08-19 19:48:08 +00:00
}
2017-07-03 13:44:45 +00:00
Vector < int > SceneTree : : get_network_connected_peers ( ) const {
2018-05-08 08:51:04 +00:00
return multiplayer - > get_network_connected_peers ( ) ;
2017-07-03 13:44:45 +00:00
}
2017-08-23 08:43:25 +00:00
int SceneTree : : get_rpc_sender_id ( ) const {
2018-05-08 08:51:04 +00:00
return multiplayer - > get_rpc_sender_id ( ) ;
2017-08-23 08:43:25 +00:00
}
2016-08-19 19:48:08 +00:00
void SceneTree : : set_refuse_new_network_connections ( bool p_refuse ) {
2018-05-08 08:51:04 +00:00
multiplayer - > set_refuse_new_network_connections ( p_refuse ) ;
2016-08-19 19:48:08 +00:00
}
bool SceneTree : : is_refusing_new_network_connections ( ) const {
2018-05-08 08:51:04 +00:00
return multiplayer - > is_refusing_new_network_connections ( ) ;
2016-08-14 21:49:50 +00:00
}
2014-11-06 00:20:42 +00:00
void SceneTree : : _bind_methods ( ) {
2014-02-10 01:10:30 +00:00
2017-08-09 11:19:41 +00:00
ClassDB : : bind_method ( D_METHOD ( " get_root " ) , & SceneTree : : get_root ) ;
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " has_group " , " name " ) , & SceneTree : : has_group ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_auto_accept_quit " , " enabled " ) , & SceneTree : : set_auto_accept_quit ) ;
2017-12-30 12:15:17 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_quit_on_go_back " , " enabled " ) , & SceneTree : : set_quit_on_go_back ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_debug_collisions_hint " , " enable " ) , & SceneTree : : set_debug_collisions_hint ) ;
ClassDB : : bind_method ( D_METHOD ( " is_debugging_collisions_hint " ) , & SceneTree : : is_debugging_collisions_hint ) ;
ClassDB : : bind_method ( D_METHOD ( " set_debug_navigation_hint " , " enable " ) , & SceneTree : : set_debug_navigation_hint ) ;
ClassDB : : bind_method ( D_METHOD ( " is_debugging_navigation_hint " ) , & SceneTree : : is_debugging_navigation_hint ) ;
2015-09-20 16:03:46 +00:00
2017-08-09 11:19:41 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_edited_scene_root " , " scene " ) , & SceneTree : : set_edited_scene_root ) ;
ClassDB : : bind_method ( D_METHOD ( " get_edited_scene_root " ) , & SceneTree : : get_edited_scene_root ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_pause " , " enable " ) , & SceneTree : : set_pause ) ;
ClassDB : : bind_method ( D_METHOD ( " is_paused " ) , & SceneTree : : is_paused ) ;
ClassDB : : bind_method ( D_METHOD ( " set_input_as_handled " ) , & SceneTree : : set_input_as_handled ) ;
2017-03-16 16:52:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " is_input_handled " ) , & SceneTree : : is_input_handled ) ;
2014-02-10 01:10:30 +00:00
2017-08-09 11:19:41 +00:00
ClassDB : : bind_method ( D_METHOD ( " create_timer " , " time_sec " , " pause_mode_process " ) , & SceneTree : : create_timer , DEFVAL ( true ) ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " get_node_count " ) , & SceneTree : : get_node_count ) ;
ClassDB : : bind_method ( D_METHOD ( " get_frame " ) , & SceneTree : : get_frame ) ;
2019-12-29 15:39:24 +00:00
ClassDB : : bind_method ( D_METHOD ( " quit " , " exit_code " ) , & SceneTree : : quit , DEFVAL ( - 1 ) ) ;
2014-02-10 01:10:30 +00:00
2017-07-22 17:07:38 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_screen_stretch " , " mode " , " aspect " , " minsize " , " shrink " ) , & SceneTree : : set_screen_stretch , DEFVAL ( 1 ) ) ;
2015-05-17 19:33:35 +00:00
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " queue_delete " , " obj " ) , & SceneTree : : queue_delete ) ;
2015-05-17 19:33:35 +00:00
2014-02-10 01:10:30 +00:00
MethodInfo mi ;
2017-03-05 15:44:50 +00:00
mi . name = " call_group_flags " ;
mi . arguments . push_back ( PropertyInfo ( Variant : : INT , " flags " ) ) ;
2020-02-20 21:58:05 +00:00
mi . arguments . push_back ( PropertyInfo ( Variant : : STRING_NAME , " group " ) ) ;
mi . arguments . push_back ( PropertyInfo ( Variant : : STRING_NAME , " method " ) ) ;
2016-09-07 22:39:02 +00:00
2017-03-05 15:44:50 +00:00
ClassDB : : bind_vararg_method ( METHOD_FLAGS_DEFAULT , " call_group_flags " , & SceneTree : : _call_group_flags , mi ) ;
2017-01-14 13:03:53 +00:00
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " notify_group_flags " , " call_flags " , " group " , " notification " ) , & SceneTree : : notify_group_flags ) ;
ClassDB : : bind_method ( D_METHOD ( " set_group_flags " , " call_flags " , " group " , " property " , " value " ) , & SceneTree : : set_group_flags ) ;
2017-01-14 13:03:53 +00:00
MethodInfo mi2 ;
2017-03-05 15:44:50 +00:00
mi2 . name = " call_group " ;
2020-02-20 21:58:05 +00:00
mi2 . arguments . push_back ( PropertyInfo ( Variant : : STRING_NAME , " group " ) ) ;
mi2 . arguments . push_back ( PropertyInfo ( Variant : : STRING_NAME , " method " ) ) ;
2017-01-14 13:03:53 +00:00
2017-03-05 15:44:50 +00:00
ClassDB : : bind_vararg_method ( METHOD_FLAGS_DEFAULT , " call_group " , & SceneTree : : _call_group , mi2 ) ;
2014-02-10 01:10:30 +00:00
2017-08-09 11:54:55 +00:00
ClassDB : : bind_method ( D_METHOD ( " notify_group " , " group " , " notification " ) , & SceneTree : : notify_group ) ;
ClassDB : : bind_method ( D_METHOD ( " set_group " , " group " , " property " , " value " ) , & SceneTree : : set_group ) ;
2015-05-17 19:33:35 +00:00
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " get_nodes_in_group " , " group " ) , & SceneTree : : _get_nodes_in_group ) ;
2015-05-17 19:33:35 +00:00
2017-08-09 11:19:41 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_current_scene " , " child_node " ) , & SceneTree : : set_current_scene ) ;
ClassDB : : bind_method ( D_METHOD ( " get_current_scene " ) , & SceneTree : : get_current_scene ) ;
2015-05-17 19:33:35 +00:00
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " change_scene " , " path " ) , & SceneTree : : change_scene ) ;
2017-08-09 11:19:41 +00:00
ClassDB : : bind_method ( D_METHOD ( " change_scene_to " , " packed_scene " ) , & SceneTree : : change_scene_to ) ;
2015-05-17 19:33:35 +00:00
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " reload_current_scene " ) , & SceneTree : : reload_current_scene ) ;
2016-08-14 21:49:50 +00:00
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " _change_scene " ) , & SceneTree : : _change_scene ) ;
2016-08-14 21:49:50 +00:00
2018-05-08 08:51:04 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_multiplayer " , " multiplayer " ) , & SceneTree : : set_multiplayer ) ;
ClassDB : : bind_method ( D_METHOD ( " get_multiplayer " ) , & SceneTree : : get_multiplayer ) ;
2018-06-02 12:32:30 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_multiplayer_poll_enabled " , " enabled " ) , & SceneTree : : set_multiplayer_poll_enabled ) ;
ClassDB : : bind_method ( D_METHOD ( " is_multiplayer_poll_enabled " ) , & SceneTree : : is_multiplayer_poll_enabled ) ;
2017-08-09 11:19:41 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_network_peer " , " peer " ) , & SceneTree : : set_network_peer ) ;
2018-01-11 22:35:12 +00:00
ClassDB : : bind_method ( D_METHOD ( " get_network_peer " ) , & SceneTree : : get_network_peer ) ;
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " is_network_server " ) , & SceneTree : : is_network_server ) ;
ClassDB : : bind_method ( D_METHOD ( " has_network_peer " ) , & SceneTree : : has_network_peer ) ;
2017-07-03 13:44:45 +00:00
ClassDB : : bind_method ( D_METHOD ( " get_network_connected_peers " ) , & SceneTree : : get_network_connected_peers ) ;
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " get_network_unique_id " ) , & SceneTree : : get_network_unique_id ) ;
2017-08-23 08:43:25 +00:00
ClassDB : : bind_method ( D_METHOD ( " get_rpc_sender_id " ) , & SceneTree : : get_rpc_sender_id ) ;
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_refuse_new_network_connections " , " refuse " ) , & SceneTree : : set_refuse_new_network_connections ) ;
ClassDB : : bind_method ( D_METHOD ( " is_refusing_new_network_connections " ) , & SceneTree : : is_refusing_new_network_connections ) ;
ClassDB : : bind_method ( D_METHOD ( " _network_peer_connected " ) , & SceneTree : : _network_peer_connected ) ;
ClassDB : : bind_method ( D_METHOD ( " _network_peer_disconnected " ) , & SceneTree : : _network_peer_disconnected ) ;
ClassDB : : bind_method ( D_METHOD ( " _connected_to_server " ) , & SceneTree : : _connected_to_server ) ;
ClassDB : : bind_method ( D_METHOD ( " _connection_failed " ) , & SceneTree : : _connection_failed ) ;
ClassDB : : bind_method ( D_METHOD ( " _server_disconnected " ) , & SceneTree : : _server_disconnected ) ;
2014-02-10 01:10:30 +00:00
2017-12-19 21:48:30 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_use_font_oversampling " , " enable " ) , & SceneTree : : set_use_font_oversampling ) ;
ClassDB : : bind_method ( D_METHOD ( " is_using_font_oversampling " ) , & SceneTree : : is_using_font_oversampling ) ;
2018-01-11 22:35:12 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " debug_collisions_hint " ) , " set_debug_collisions_hint " , " is_debugging_collisions_hint " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " debug_navigation_hint " ) , " set_debug_navigation_hint " , " is_debugging_navigation_hint " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " paused " ) , " set_pause " , " is_paused " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " refuse_new_network_connections " ) , " set_refuse_new_network_connections " , " is_refusing_new_network_connections " ) ;
2019-06-01 13:42:22 +00:00
ADD_PROPERTY_DEFAULT ( " refuse_new_network_connections " , false ) ;
2018-01-11 22:35:12 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " use_font_oversampling " ) , " set_use_font_oversampling " , " is_using_font_oversampling " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : OBJECT , " edited_scene_root " , PROPERTY_HINT_RESOURCE_TYPE , " Node " , 0 ) , " set_edited_scene_root " , " get_edited_scene_root " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : OBJECT , " current_scene " , PROPERTY_HINT_RESOURCE_TYPE , " Node " , 0 ) , " set_current_scene " , " get_current_scene " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : OBJECT , " network_peer " , PROPERTY_HINT_RESOURCE_TYPE , " NetworkedMultiplayerPeer " , 0 ) , " set_network_peer " , " get_network_peer " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : OBJECT , " root " , PROPERTY_HINT_RESOURCE_TYPE , " Node " , 0 ) , " " , " get_root " ) ;
2018-05-08 08:51:04 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : OBJECT , " multiplayer " , PROPERTY_HINT_RESOURCE_TYPE , " MultiplayerAPI " , 0 ) , " set_multiplayer " , " get_multiplayer " ) ;
2018-06-02 12:32:30 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " multiplayer_poll " ) , " set_multiplayer_poll_enabled " , " is_multiplayer_poll_enabled " ) ;
2018-01-11 22:35:12 +00:00
2017-03-05 15:44:50 +00:00
ADD_SIGNAL ( MethodInfo ( " tree_changed " ) ) ;
2018-09-01 10:05:51 +00:00
ADD_SIGNAL ( MethodInfo ( " node_added " , PropertyInfo ( Variant : : OBJECT , " node " , PROPERTY_HINT_RESOURCE_TYPE , " Node " ) ) ) ;
ADD_SIGNAL ( MethodInfo ( " node_removed " , PropertyInfo ( Variant : : OBJECT , " node " , PROPERTY_HINT_RESOURCE_TYPE , " Node " ) ) ) ;
2019-05-24 13:27:22 +00:00
ADD_SIGNAL ( MethodInfo ( " node_renamed " , PropertyInfo ( Variant : : OBJECT , " node " , PROPERTY_HINT_RESOURCE_TYPE , " Node " ) ) ) ;
2017-03-05 15:44:50 +00:00
ADD_SIGNAL ( MethodInfo ( " screen_resized " ) ) ;
2018-09-01 10:05:51 +00:00
ADD_SIGNAL ( MethodInfo ( " node_configuration_warning_changed " , PropertyInfo ( Variant : : OBJECT , " node " , PROPERTY_HINT_RESOURCE_TYPE , " Node " ) ) ) ;
2015-06-12 16:53:18 +00:00
2017-03-05 15:44:50 +00:00
ADD_SIGNAL ( MethodInfo ( " idle_frame " ) ) ;
2017-09-30 14:19:07 +00:00
ADD_SIGNAL ( MethodInfo ( " physics_frame " ) ) ;
2016-05-27 17:18:40 +00:00
2020-02-17 21:06:54 +00:00
ADD_SIGNAL ( MethodInfo ( " files_dropped " , PropertyInfo ( Variant : : PACKED_STRING_ARRAY , " files " ) , PropertyInfo ( Variant : : INT , " screen " ) ) ) ;
2019-02-06 13:57:06 +00:00
ADD_SIGNAL ( MethodInfo ( " global_menu_action " , PropertyInfo ( Variant : : NIL , " id " ) , PropertyInfo ( Variant : : NIL , " meta " ) ) ) ;
2017-03-05 15:44:50 +00:00
ADD_SIGNAL ( MethodInfo ( " network_peer_connected " , PropertyInfo ( Variant : : INT , " id " ) ) ) ;
ADD_SIGNAL ( MethodInfo ( " network_peer_disconnected " , PropertyInfo ( Variant : : INT , " id " ) ) ) ;
ADD_SIGNAL ( MethodInfo ( " connected_to_server " ) ) ;
ADD_SIGNAL ( MethodInfo ( " connection_failed " ) ) ;
ADD_SIGNAL ( MethodInfo ( " server_disconnected " ) ) ;
2014-02-10 01:10:30 +00:00
2017-08-20 15:45:01 +00:00
BIND_ENUM_CONSTANT ( GROUP_CALL_DEFAULT ) ;
BIND_ENUM_CONSTANT ( GROUP_CALL_REVERSE ) ;
BIND_ENUM_CONSTANT ( GROUP_CALL_REALTIME ) ;
BIND_ENUM_CONSTANT ( GROUP_CALL_UNIQUE ) ;
BIND_ENUM_CONSTANT ( STRETCH_MODE_DISABLED ) ;
BIND_ENUM_CONSTANT ( STRETCH_MODE_2D ) ;
BIND_ENUM_CONSTANT ( STRETCH_MODE_VIEWPORT ) ;
BIND_ENUM_CONSTANT ( STRETCH_ASPECT_IGNORE ) ;
BIND_ENUM_CONSTANT ( STRETCH_ASPECT_KEEP ) ;
BIND_ENUM_CONSTANT ( STRETCH_ASPECT_KEEP_WIDTH ) ;
BIND_ENUM_CONSTANT ( STRETCH_ASPECT_KEEP_HEIGHT ) ;
2017-09-24 18:29:18 +00:00
BIND_ENUM_CONSTANT ( STRETCH_ASPECT_EXPAND ) ;
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
SceneTree * SceneTree : : singleton = NULL ;
2016-10-27 14:50:26 +00:00
SceneTree : : IdleCallback SceneTree : : idle_callbacks [ SceneTree : : MAX_IDLE_CALLBACKS ] ;
2017-03-05 15:44:50 +00:00
int SceneTree : : idle_callback_count = 0 ;
2016-10-27 14:50:26 +00:00
void SceneTree : : _call_idle_callbacks ( ) {
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < idle_callback_count ; i + + ) {
2016-10-27 14:50:26 +00:00
idle_callbacks [ i ] ( ) ;
}
}
void SceneTree : : add_idle_callback ( IdleCallback p_callback ) {
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( idle_callback_count > = MAX_IDLE_CALLBACKS ) ;
idle_callbacks [ idle_callback_count + + ] = p_callback ;
2016-10-27 14:50:26 +00:00
}
2017-12-19 21:48:30 +00:00
void SceneTree : : set_use_font_oversampling ( bool p_oversampling ) {
2019-01-26 18:41:26 +00:00
if ( use_font_oversampling = = p_oversampling )
return ;
2017-12-19 21:48:30 +00:00
use_font_oversampling = p_oversampling ;
2019-01-26 18:41:26 +00:00
_update_root_rect ( ) ;
2017-12-19 21:48:30 +00:00
}
bool SceneTree : : is_using_font_oversampling ( ) const {
return use_font_oversampling ;
}
2019-03-09 02:05:59 +00:00
void SceneTree : : get_argument_options ( const StringName & p_function , int p_idx , List < String > * r_options ) const {
if ( p_function = = " change_scene " ) {
DirAccessRef dir_access = DirAccess : : create ( DirAccess : : ACCESS_RESOURCES ) ;
List < String > directories ;
directories . push_back ( dir_access - > get_current_dir ( ) ) ;
while ( ! directories . empty ( ) ) {
dir_access - > change_dir ( directories . back ( ) - > get ( ) ) ;
directories . pop_back ( ) ;
dir_access - > list_dir_begin ( ) ;
String filename = dir_access - > get_next ( ) ;
while ( filename ! = " " ) {
if ( filename = = " . " | | filename = = " .. " ) {
filename = dir_access - > get_next ( ) ;
continue ;
}
if ( dir_access - > dir_exists ( filename ) ) {
directories . push_back ( dir_access - > get_current_dir ( ) . plus_file ( filename ) ) ;
} else if ( filename . ends_with ( " .tscn " ) | | filename . ends_with ( " .scn " ) ) {
r_options - > push_back ( " \" " + dir_access - > get_current_dir ( ) . plus_file ( filename ) + " \" " ) ;
}
filename = dir_access - > get_next ( ) ;
}
}
}
}
2014-11-06 00:20:42 +00:00
SceneTree : : SceneTree ( ) {
2014-02-10 01:10:30 +00:00
2019-06-01 13:42:22 +00:00
if ( singleton = = NULL ) singleton = this ;
2017-03-05 15:44:50 +00:00
_quit = false ;
2017-04-25 11:05:22 +00:00
accept_quit = true ;
quit_on_go_back = true ;
2017-03-05 15:44:50 +00:00
initialized = false ;
2019-01-26 18:41:26 +00:00
use_font_oversampling = false ;
2017-04-07 14:17:16 +00:00
# ifdef DEBUG_ENABLED
2017-03-05 15:44:50 +00:00
debug_collisions_hint = false ;
debug_navigation_hint = false ;
2017-04-07 14:17:16 +00:00
# endif
2017-07-18 00:05:38 +00:00
debug_collisions_color = GLOBAL_DEF ( " debug/shapes/collision/shape_color " , Color ( 0.0 , 0.6 , 0.7 , 0.5 ) ) ;
debug_collision_contact_color = GLOBAL_DEF ( " debug/shapes/collision/contact_color " , Color ( 1.0 , 0.2 , 0.1 , 0.8 ) ) ;
debug_navigation_color = GLOBAL_DEF ( " debug/shapes/navigation/geometry_color " , Color ( 0.1 , 1.0 , 0.7 , 0.4 ) ) ;
debug_navigation_disabled_color = GLOBAL_DEF ( " debug/shapes/navigation/disabled_geometry_color " , Color ( 1.0 , 0.7 , 0.1 , 0.4 ) ) ;
collision_debug_contacts = GLOBAL_DEF ( " debug/shapes/collision/max_contacts_displayed " , 10000 ) ;
2018-10-05 16:43:53 +00:00
ProjectSettings : : get_singleton ( ) - > set_custom_property_info ( " debug/shapes/collision/max_contacts_displayed " , PropertyInfo ( Variant : : INT , " debug/shapes/collision/max_contacts_displayed " , PROPERTY_HINT_RANGE , " 0,20000,1 " ) ) ; // No negative
2017-03-05 15:44:50 +00:00
tree_version = 1 ;
2017-09-30 14:19:07 +00:00
physics_process_time = 1 ;
2017-03-05 15:44:50 +00:00
idle_process_time = 1 ;
2017-12-26 12:48:50 +00:00
2017-03-05 15:44:50 +00:00
root = NULL ;
2019-07-02 14:23:54 +00:00
input_handled = false ;
pause = false ;
2017-03-05 15:44:50 +00:00
current_frame = 0 ;
2017-12-26 12:48:50 +00:00
current_event = 0 ;
2017-03-05 15:44:50 +00:00
tree_changed_name = " tree_changed " ;
2017-10-19 00:30:27 +00:00
node_added_name = " node_added " ;
2017-03-05 15:44:50 +00:00
node_removed_name = " node_removed " ;
2019-05-24 13:27:22 +00:00
node_renamed_name = " node_renamed " ;
2017-03-05 15:44:50 +00:00
ugc_locked = false ;
call_lock = 0 ;
root_lock = 0 ;
node_count = 0 ;
2014-02-10 01:10:30 +00:00
//create with mainloop
2017-03-05 15:44:50 +00:00
root = memnew ( Viewport ) ;
2014-02-10 01:10:30 +00:00
root - > set_name ( " root " ) ;
2018-11-15 16:54:26 +00:00
root - > set_handle_input_locally ( false ) ;
2017-05-29 00:46:48 +00:00
if ( ! root - > get_world ( ) . is_valid ( ) )
root - > set_world ( Ref < World > ( memnew ( World ) ) ) ;
2018-03-03 17:30:11 +00:00
// Initialize network state
2018-06-02 12:32:30 +00:00
multiplayer_poll = true ;
2018-05-08 08:51:04 +00:00
set_multiplayer ( Ref < MultiplayerAPI > ( memnew ( MultiplayerAPI ) ) ) ;
2018-03-03 17:30:11 +00:00
2014-02-10 01:10:30 +00:00
//root->set_world_2d( Ref<World2D>( memnew( World2D )));
root - > set_as_audio_listener ( true ) ;
root - > set_as_audio_listener_2d ( true ) ;
2017-03-05 15:44:50 +00:00
current_scene = NULL ;
2014-02-10 01:10:30 +00:00
2017-07-18 00:05:38 +00:00
int msaa_mode = GLOBAL_DEF ( " rendering/quality/filters/msaa " , 0 ) ;
2019-11-16 14:36:43 +00:00
ProjectSettings : : get_singleton ( ) - > set_custom_property_info ( " rendering/quality/filters/msaa " , PropertyInfo ( Variant : : INT , " rendering/quality/filters/msaa " , PROPERTY_HINT_ENUM , " Disabled,2x,4x,8x,16x,AndroidVR 2x,AndroidVR 4x " ) ) ;
2017-01-02 01:16:52 +00:00
root - > set_msaa ( Viewport : : MSAA ( msaa_mode ) ) ;
2017-07-19 20:00:46 +00:00
2017-05-29 00:46:48 +00:00
{ //load default fallback environment
//get possible extensions
List < String > exts ;
ResourceLoader : : get_recognized_extensions_for_type ( " Environment " , & exts ) ;
String ext_hint ;
for ( List < String > : : Element * E = exts . front ( ) ; E ; E = E - > next ( ) ) {
if ( ext_hint ! = String ( ) )
ext_hint + = " , " ;
ext_hint + = " *. " + E - > get ( ) ;
}
//get path
2017-07-18 00:05:38 +00:00
String env_path = GLOBAL_DEF ( " rendering/environment/default_environment " , " " ) ;
2017-05-29 00:46:48 +00:00
//setup property
2017-07-19 20:00:46 +00:00
ProjectSettings : : get_singleton ( ) - > set_custom_property_info ( " rendering/environment/default_environment " , PropertyInfo ( Variant : : STRING , " rendering/viewport/default_environment " , PROPERTY_HINT_FILE , ext_hint ) ) ;
2017-05-29 00:46:48 +00:00
env_path = env_path . strip_edges ( ) ;
if ( env_path ! = String ( ) ) {
Ref < Environment > env = ResourceLoader : : load ( env_path ) ;
if ( env . is_valid ( ) ) {
root - > get_world ( ) - > set_fallback_environment ( env ) ;
} else {
2017-08-18 23:02:56 +00:00
if ( Engine : : get_singleton ( ) - > is_editor_hint ( ) ) {
2017-05-29 00:46:48 +00:00
//file was erased, clear the field.
2017-07-19 20:00:46 +00:00
ProjectSettings : : get_singleton ( ) - > set ( " rendering/environment/default_environment " , " " ) ;
2017-05-29 00:46:48 +00:00
} else {
//file was erased, notify user.
2019-11-06 16:03:04 +00:00
ERR_PRINT ( RTR ( " Default Environment as specified in Project Settings (Rendering -> Environment -> Default Environment) could not be loaded. " ) ) ;
2017-05-29 00:46:48 +00:00
}
}
}
}
2017-03-05 15:44:50 +00:00
stretch_mode = STRETCH_MODE_DISABLED ;
stretch_aspect = STRETCH_ASPECT_IGNORE ;
2017-07-22 17:07:38 +00:00
stretch_shrink = 1 ;
2014-04-15 01:43:44 +00:00
2018-07-03 21:52:23 +00:00
last_screen_size = Size2 ( OS : : get_singleton ( ) - > get_window_size ( ) . width , OS : : get_singleton ( ) - > get_window_size ( ) . height ) ;
2017-04-09 23:40:48 +00:00
_update_root_rect ( ) ;
2014-02-10 01:10:30 +00:00
if ( ScriptDebugger : : get_singleton ( ) ) {
2019-09-01 16:38:58 +00:00
ScriptDebugger : : get_singleton ( ) - > set_multiplayer ( multiplayer ) ;
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
root - > set_physics_object_picking ( GLOBAL_DEF ( " physics/common/enable_object_picking " , true ) ) ;
2014-09-15 14:33:30 +00:00
2014-10-14 04:01:25 +00:00
# ifdef TOOLS_ENABLED
2017-03-05 15:44:50 +00:00
edited_scene_root = NULL ;
2014-10-14 04:01:25 +00:00
# endif
2014-02-10 01:10:30 +00:00
}
2014-11-06 00:20:42 +00:00
SceneTree : : ~ SceneTree ( ) {
2019-06-01 13:42:22 +00:00
if ( root ) {
root - > _set_tree ( NULL ) ;
root - > _propagate_after_exit_tree ( ) ;
memdelete ( root ) ;
}
if ( singleton = = this ) singleton = NULL ;
2014-02-10 01:10:30 +00:00
}