2014-02-10 02:10:30 +01:00
/*************************************************************************/
/* scene_main_loop.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
2016-01-01 14:50:53 +01:00
/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */
2014-02-10 02:10:30 +01:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
# include "scene_main_loop.h"
# include "print_string.h"
# include "os/os.h"
# include "message_queue.h"
# include "node.h"
# include "globals.h"
# include <stdio.h>
# include "os/keyboard.h"
# include "servers/spatial_sound_2d_server.h"
# include "servers/physics_2d_server.h"
# include "servers/physics_server.h"
# include "scene/scene_string_names.h"
# include "io/resource_loader.h"
# include "viewport.h"
2015-05-17 21:33:35 +02:00
# include "scene/resources/packed_scene.h"
2015-09-20 18:03:46 +02:00
# include "scene/resources/material.h"
# include "scene/resources/mesh.h"
2014-02-10 02:10:30 +01:00
2014-11-06 01:20:42 +01:00
void SceneTree : : tree_changed ( ) {
2014-02-10 02:10:30 +01:00
tree_version + + ;
emit_signal ( tree_changed_name ) ;
}
2014-11-06 01:20:42 +01:00
void SceneTree : : node_removed ( Node * p_node ) {
2014-02-10 02:10:30 +01:00
2015-05-17 21:33:35 +02:00
if ( current_scene = = p_node ) {
current_scene = NULL ;
}
2014-02-10 02:10:30 +01:00
emit_signal ( node_removed_name , p_node ) ;
if ( call_lock > 0 )
call_skip . insert ( p_node ) ;
}
2014-11-06 01:20:42 +01:00
void SceneTree : : add_to_group ( const StringName & p_group , Node * p_node ) {
2014-02-10 02:10:30 +01:00
Map < StringName , Group > : : Element * E = group_map . find ( p_group ) ;
if ( ! E ) {
E = group_map . insert ( p_group , Group ( ) ) ;
}
if ( E - > get ( ) . nodes . find ( p_node ) ! = - 1 ) {
ERR_EXPLAIN ( " Already in group: " + p_group ) ;
ERR_FAIL ( ) ;
}
E - > get ( ) . nodes . push_back ( p_node ) ;
E - > get ( ) . last_tree_version = 0 ;
}
2014-11-06 01:20:42 +01:00
void SceneTree : : remove_from_group ( const StringName & p_group , Node * p_node ) {
2014-02-10 02:10:30 +01:00
Map < StringName , Group > : : Element * E = group_map . find ( p_group ) ;
ERR_FAIL_COND ( ! E ) ;
E - > get ( ) . nodes . erase ( p_node ) ;
if ( E - > get ( ) . nodes . empty ( ) )
group_map . erase ( E ) ;
}
2014-11-06 01:20:42 +01:00
void SceneTree : : _flush_transform_notifications ( ) {
2014-02-10 02:10:30 +01:00
SelfList < Node > * n = xform_change_list . first ( ) ;
while ( n ) {
Node * node = n - > self ( ) ;
SelfList < Node > * nx = n - > next ( ) ;
xform_change_list . remove ( n ) ;
n = nx ;
node - > notification ( NOTIFICATION_TRANSFORM_CHANGED ) ;
}
}
2014-11-06 01:20:42 +01:00
void SceneTree : : _flush_ugc ( ) {
2014-02-10 02:10:30 +01:00
ugc_locked = true ;
while ( unique_group_calls . size ( ) ) {
Map < UGCall , Vector < Variant > > : : Element * E = unique_group_calls . front ( ) ;
Variant v [ VARIANT_ARG_MAX ] ;
for ( int i = 0 ; i < E - > get ( ) . size ( ) ; i + + )
v [ i ] = E - > get ( ) [ i ] ;
call_group ( GROUP_CALL_REALTIME , E - > key ( ) . group , E - > key ( ) . call , v [ 0 ] , v [ 1 ] , v [ 2 ] , v [ 3 ] , v [ 4 ] ) ;
unique_group_calls . erase ( E ) ;
}
ugc_locked = false ;
}
2014-11-06 01:20:42 +01:00
void SceneTree : : _update_group_order ( Group & g ) {
2014-02-10 02:10:30 +01:00
if ( g . last_tree_version = = tree_version )
return ;
if ( g . nodes . empty ( ) )
return ;
Node * * nodes = & g . nodes [ 0 ] ;
int node_count = g . nodes . size ( ) ;
SortArray < Node * , Node : : Comparator > node_sort ;
node_sort . sort ( nodes , node_count ) ;
g . last_tree_version = tree_version ;
}
2014-11-06 01:20:42 +01:00
void SceneTree : : call_group ( uint32_t p_call_flags , const StringName & p_group , const StringName & p_function , VARIANT_ARG_DECLARE ) {
2014-02-10 02:10:30 +01:00
Map < StringName , Group > : : Element * E = group_map . find ( p_group ) ;
if ( ! E )
return ;
Group & g = E - > get ( ) ;
if ( g . nodes . empty ( ) )
return ;
_update_group_order ( g ) ;
if ( p_call_flags & GROUP_CALL_UNIQUE & & ! ( p_call_flags & GROUP_CALL_REALTIME ) ) {
ERR_FAIL_COND ( ugc_locked ) ;
UGCall ug ;
ug . call = p_function ;
ug . group = p_group ;
if ( unique_group_calls . has ( ug ) )
return ;
VARIANT_ARGPTRS ;
Vector < Variant > args ;
for ( int i = 0 ; i < VARIANT_ARG_MAX ; i + + ) {
if ( argptr [ i ] - > get_type ( ) = = Variant : : NIL )
break ;
args . push_back ( * argptr [ i ] ) ;
}
unique_group_calls [ ug ] = args ;
return ;
}
Vector < Node * > nodes_copy = g . nodes ;
Node * * nodes = & nodes_copy [ 0 ] ;
int node_count = nodes_copy . size ( ) ;
call_lock + + ;
if ( p_call_flags & GROUP_CALL_REVERSE ) {
for ( int i = node_count - 1 ; i > = 0 ; i - - ) {
if ( call_lock & & call_skip . has ( nodes [ i ] ) )
continue ;
if ( p_call_flags & GROUP_CALL_REALTIME ) {
if ( p_call_flags & GROUP_CALL_MULIILEVEL )
nodes [ i ] - > call_multilevel ( p_function , VARIANT_ARG_PASS ) ;
else
nodes [ i ] - > call ( p_function , VARIANT_ARG_PASS ) ;
} else
MessageQueue : : get_singleton ( ) - > push_call ( nodes [ i ] , p_function , VARIANT_ARG_PASS ) ;
}
} else {
for ( int i = 0 ; i < node_count ; i + + ) {
if ( call_lock & & call_skip . has ( nodes [ i ] ) )
continue ;
if ( p_call_flags & GROUP_CALL_REALTIME ) {
if ( p_call_flags & GROUP_CALL_MULIILEVEL )
nodes [ i ] - > call_multilevel ( p_function , VARIANT_ARG_PASS ) ;
else
nodes [ i ] - > call ( p_function , VARIANT_ARG_PASS ) ;
} else
MessageQueue : : get_singleton ( ) - > push_call ( nodes [ i ] , p_function , VARIANT_ARG_PASS ) ;
}
}
call_lock - - ;
if ( call_lock = = 0 )
call_skip . clear ( ) ;
}
2014-11-06 01:20:42 +01:00
void SceneTree : : notify_group ( uint32_t p_call_flags , const StringName & p_group , int p_notification ) {
2014-02-10 02:10:30 +01:00
Map < StringName , Group > : : Element * E = group_map . find ( p_group ) ;
if ( ! E )
return ;
Group & g = E - > get ( ) ;
if ( g . nodes . empty ( ) )
return ;
_update_group_order ( g ) ;
Vector < Node * > nodes_copy = g . nodes ;
Node * * nodes = & nodes_copy [ 0 ] ;
int node_count = nodes_copy . size ( ) ;
call_lock + + ;
if ( p_call_flags & GROUP_CALL_REVERSE ) {
for ( int i = node_count - 1 ; i > = 0 ; i - - ) {
if ( call_lock & & call_skip . has ( nodes [ i ] ) )
continue ;
if ( p_call_flags & GROUP_CALL_REALTIME )
nodes [ i ] - > notification ( p_notification ) ;
else
MessageQueue : : get_singleton ( ) - > push_notification ( nodes [ i ] , p_notification ) ;
}
} else {
for ( int i = 0 ; i < node_count ; i + + ) {
if ( call_lock & & call_skip . has ( nodes [ i ] ) )
continue ;
if ( p_call_flags & GROUP_CALL_REALTIME )
nodes [ i ] - > notification ( p_notification ) ;
else
MessageQueue : : get_singleton ( ) - > push_notification ( nodes [ i ] , p_notification ) ;
}
}
call_lock - - ;
if ( call_lock = = 0 )
call_skip . clear ( ) ;
}
2014-11-06 01:20:42 +01:00
void SceneTree : : set_group ( uint32_t p_call_flags , const StringName & p_group , const String & p_name , const Variant & p_value ) {
2014-02-10 02:10:30 +01:00
Map < StringName , Group > : : Element * E = group_map . find ( p_group ) ;
if ( ! E )
return ;
Group & g = E - > get ( ) ;
if ( g . nodes . empty ( ) )
return ;
_update_group_order ( g ) ;
Vector < Node * > nodes_copy = g . nodes ;
Node * * nodes = & nodes_copy [ 0 ] ;
int node_count = nodes_copy . size ( ) ;
call_lock + + ;
if ( p_call_flags & GROUP_CALL_REVERSE ) {
for ( int i = node_count - 1 ; i > = 0 ; i - - ) {
if ( call_lock & & call_skip . has ( nodes [ i ] ) )
continue ;
if ( p_call_flags & GROUP_CALL_REALTIME )
nodes [ i ] - > set ( p_name , p_value ) ;
else
MessageQueue : : get_singleton ( ) - > push_set ( nodes [ i ] , p_name , p_value ) ;
}
} else {
for ( int i = 0 ; i < node_count ; i + + ) {
if ( call_lock & & call_skip . has ( nodes [ i ] ) )
continue ;
if ( p_call_flags & GROUP_CALL_REALTIME )
nodes [ i ] - > set ( p_name , p_value ) ;
else
MessageQueue : : get_singleton ( ) - > push_set ( nodes [ i ] , p_name , p_value ) ;
}
}
call_lock - - ;
if ( call_lock = = 0 )
call_skip . clear ( ) ;
}
2014-11-06 01:20:42 +01:00
void SceneTree : : set_input_as_handled ( ) {
2014-02-10 02:10:30 +01:00
input_handled = true ;
}
2014-11-06 01:20:42 +01:00
void SceneTree : : input_text ( const String & p_text ) {
2014-02-10 02:10:30 +01:00
root_lock + + ;
call_group ( GROUP_CALL_REALTIME | GROUP_CALL_MULIILEVEL , " input " , p_text ) ;
root_lock - - ;
}
2014-11-06 01:20:42 +01:00
void SceneTree : : input_event ( const InputEvent & p_event ) {
2014-02-10 02:10:30 +01:00
2014-12-07 06:04:20 +01:00
if ( is_editor_hint ( ) & & ( p_event . type = = InputEvent : : JOYSTICK_MOTION | | p_event . type = = InputEvent : : JOYSTICK_BUTTON ) )
return ; //avoid joy input on editor
2014-02-10 02:10:30 +01:00
root_lock + + ;
2014-11-06 01:20:42 +01:00
//last_id=p_event.ID;
2014-02-10 02:10:30 +01:00
input_handled = false ;
InputEvent ev = p_event ;
2014-11-06 01:20:42 +01:00
ev . ID = + + last_id ; //this should work better
2014-04-10 05:18:27 +02:00
#if 0
2014-02-10 02:10:30 +01:00
switch ( ev . type ) {
case InputEvent : : MOUSE_BUTTON : {
Matrix32 ai = root - > get_final_transform ( ) . affine_inverse ( ) ;
Vector2 g = ai . xform ( Vector2 ( ev . mouse_button . global_x , ev . mouse_button . global_y ) ) ;
Vector2 l = ai . xform ( Vector2 ( ev . mouse_button . x , ev . mouse_button . y ) ) ;
ev . mouse_button . x = l . x ;
ev . mouse_button . y = l . y ;
ev . mouse_button . global_x = g . x ;
ev . mouse_button . global_y = g . y ;
} break ;
case InputEvent : : MOUSE_MOTION : {
Matrix32 ai = root - > get_final_transform ( ) . affine_inverse ( ) ;
Vector2 g = ai . xform ( Vector2 ( ev . mouse_motion . global_x , ev . mouse_motion . global_y ) ) ;
Vector2 l = ai . xform ( Vector2 ( ev . mouse_motion . x , ev . mouse_motion . y ) ) ;
Vector2 r = ai . xform ( Vector2 ( ev . mouse_motion . relative_x , ev . mouse_motion . relative_y ) ) ;
ev . mouse_motion . x = l . x ;
ev . mouse_motion . y = l . y ;
ev . mouse_motion . global_x = g . x ;
ev . mouse_motion . global_y = g . y ;
ev . mouse_motion . relative_x = r . x ;
ev . mouse_motion . relative_y = r . y ;
} break ;
case InputEvent : : SCREEN_TOUCH : {
Matrix32 ai = root - > get_final_transform ( ) . affine_inverse ( ) ;
Vector2 t = ai . xform ( Vector2 ( ev . screen_touch . x , ev . screen_touch . y ) ) ;
ev . screen_touch . x = t . x ;
ev . screen_touch . y = t . y ;
} break ;
case InputEvent : : SCREEN_DRAG : {
Matrix32 ai = root - > get_final_transform ( ) . affine_inverse ( ) ;
Vector2 t = ai . xform ( Vector2 ( ev . screen_drag . x , ev . screen_drag . y ) ) ;
Vector2 r = ai . xform ( Vector2 ( ev . screen_drag . relative_x , ev . screen_drag . relative_y ) ) ;
Vector2 s = ai . xform ( Vector2 ( ev . screen_drag . speed_x , ev . screen_drag . speed_y ) ) ;
ev . screen_drag . x = t . x ;
ev . screen_drag . y = t . y ;
ev . screen_drag . relative_x = r . x ;
ev . screen_drag . relative_y = r . y ;
ev . screen_drag . speed_x = s . x ;
ev . screen_drag . speed_y = s . y ;
} break ;
}
2014-04-10 05:18:27 +02:00
# endif
2014-02-10 02:10:30 +01:00
2014-11-06 01:20:42 +01:00
MainLoop : : input_event ( ev ) ;
2014-04-10 05:18:27 +02:00
#if 0
2014-02-10 02:10:30 +01:00
_call_input_pause ( " input " , " _input " , ev ) ;
call_group ( GROUP_CALL_REVERSE | GROUP_CALL_REALTIME | GROUP_CALL_MULIILEVEL , " _gui_input " , " _gui_input " , p_event ) ; //special one for GUI, as controls use their own process check
//call_group(GROUP_CALL_REVERSE|GROUP_CALL_REALTIME|GROUP_CALL_MULIILEVEL,"input","_input",ev);
/*if (ev.type==InputEvent::KEY && ev.key.pressed && !ev.key.echo && ev.key.scancode==KEY_F12) {
print_line ( " RAM: " + itos ( Memory : : get_static_mem_usage ( ) ) ) ;
print_line ( " DRAM: " + itos ( Memory : : get_dynamic_mem_usage ( ) ) ) ;
}
*/
//if (ev.type==InputEvent::KEY && ev.key.pressed && !ev.key.echo && ev.key.scancode==KEY_F11) {
// Memory::dump_static_mem_to_file("memdump.txt");
//}
//transform for the rest
2014-04-10 05:18:27 +02:00
# else
2014-11-06 01:20:42 +01:00
call_group ( GROUP_CALL_REALTIME , " _viewports " , " _vp_input " , ev ) ; //special one for GUI, as controls use their own process check
2014-02-10 02:10:30 +01:00
2014-04-10 05:18:27 +02:00
# endif
2014-02-10 02:10:30 +01:00
if ( ScriptDebugger : : get_singleton ( ) & & ScriptDebugger : : get_singleton ( ) - > is_remote ( ) & & ev . type = = InputEvent : : KEY & & ev . key . pressed & & ! ev . key . echo & & ev . key . scancode = = KEY_F8 ) {
ScriptDebugger : : get_singleton ( ) - > request_quit ( ) ;
}
_flush_ugc ( ) ;
root_lock - - ;
MessageQueue : : get_singleton ( ) - > flush ( ) ; //small little hack
root_lock + + ;
if ( ! input_handled ) {
2014-04-10 05:18:27 +02:00
#if 0
2014-02-10 02:10:30 +01:00
_call_input_pause ( " unhandled_input " , " _unhandled_input " , ev ) ;
//call_group(GROUP_CALL_REVERSE|GROUP_CALL_REALTIME|GROUP_CALL_MULIILEVEL,"unhandled_input","_unhandled_input",ev);
if ( ! input_handled & & ev . type = = InputEvent : : KEY ) {
_call_input_pause ( " unhandled_key_input " , " _unhandled_key_input " , ev ) ;
//call_group(GROUP_CALL_REVERSE|GROUP_CALL_REALTIME|GROUP_CALL_MULIILEVEL,"unhandled_key_input","_unhandled_key_input",ev);
}
2014-04-10 05:18:27 +02:00
# else
2014-11-06 01:20:42 +01:00
call_group ( GROUP_CALL_REALTIME , " _viewports " , " _vp_unhandled_input " , ev ) ; //special one for GUI, as controls use their own process check
2014-02-10 02:10:30 +01:00
2014-04-10 05:18:27 +02:00
# endif
2014-02-10 02:10:30 +01:00
input_handled = true ;
_flush_ugc ( ) ;
root_lock - - ;
MessageQueue : : get_singleton ( ) - > flush ( ) ; //small little hack
} else {
input_handled = true ;
root_lock - - ;
}
}
2014-11-06 01:20:42 +01:00
void SceneTree : : init ( ) {
2014-02-10 02:10:30 +01:00
//_quit=false;
accept_quit = true ;
initialized = true ;
input_handled = false ;
pause = false ;
2014-11-06 01:20:42 +01:00
root - > _set_tree ( this ) ;
2014-02-10 02:10:30 +01:00
MainLoop : : init ( ) ;
}
2014-11-06 01:20:42 +01:00
bool SceneTree : : iteration ( float p_time ) {
2014-02-10 02:10:30 +01:00
root_lock + + ;
current_frame + + ;
_flush_transform_notifications ( ) ;
MainLoop : : iteration ( p_time ) ;
fixed_process_time = p_time ;
2014-09-15 16:33:30 +02:00
emit_signal ( " fixed_frame " ) ;
2014-02-10 02:10:30 +01:00
_notify_group_pause ( " fixed_process " , Node : : NOTIFICATION_FIXED_PROCESS ) ;
_flush_ugc ( ) ;
_flush_transform_notifications ( ) ;
call_group ( GROUP_CALL_REALTIME , " _viewports " , " update_worlds " ) ;
root_lock - - ;
_flush_delete_queue ( ) ;
return _quit ;
}
2014-11-06 01:20:42 +01:00
bool SceneTree : : idle ( float p_time ) {
2014-02-10 02:10:30 +01: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)));
root_lock + + ;
MainLoop : : idle ( p_time ) ;
idle_process_time = p_time ;
2014-09-15 16:33:30 +02:00
emit_signal ( " idle_frame " ) ;
2014-02-10 02:10:30 +01:00
_flush_transform_notifications ( ) ;
_notify_group_pause ( " idle_process " , Node : : NOTIFICATION_PROCESS ) ;
Size2 win_size = Size2 ( OS : : get_singleton ( ) - > get_video_mode ( ) . width , OS : : get_singleton ( ) - > get_video_mode ( ) . height ) ;
if ( win_size ! = last_screen_size ) {
last_screen_size = win_size ;
2014-04-15 03:43:44 +02:00
_update_root_rect ( ) ;
2014-02-10 02:10:30 +01:00
emit_signal ( " screen_resized " ) ;
}
_flush_ugc ( ) ;
_flush_transform_notifications ( ) ; //transforms after world update, to avoid unnecesary enter/exit notifications
call_group ( GROUP_CALL_REALTIME , " _viewports " , " update_worlds " ) ;
root_lock - - ;
_flush_delete_queue ( ) ;
return _quit ;
}
2014-11-06 01:20:42 +01:00
void SceneTree : : finish ( ) {
2014-02-10 02:10:30 +01:00
_flush_delete_queue ( ) ;
_flush_ugc ( ) ;
initialized = false ;
MainLoop : : finish ( ) ;
if ( root ) {
2014-11-06 01:20:42 +01:00
root - > _set_tree ( NULL ) ;
2014-02-10 02:10:30 +01:00
memdelete ( root ) ; //delete root
}
}
2014-11-06 01:20:42 +01:00
void SceneTree : : quit ( ) {
2014-02-10 02:10:30 +01:00
_quit = true ;
}
2014-11-06 01:20:42 +01:00
void SceneTree : : _notification ( int p_notification ) {
2014-02-10 02:10:30 +01:00
switch ( p_notification ) {
case NOTIFICATION_WM_QUIT_REQUEST : {
get_root ( ) - > propagate_notification ( p_notification ) ;
if ( accept_quit ) {
_quit = true ;
break ;
}
} break ;
2014-08-02 03:10:38 +02:00
case NOTIFICATION_OS_MEMORY_WARNING :
2014-02-10 02:10:30 +01:00
case NOTIFICATION_WM_FOCUS_IN :
case NOTIFICATION_WM_FOCUS_OUT : {
get_root ( ) - > propagate_notification ( p_notification ) ;
} break ;
case NOTIFICATION_WM_UNFOCUS_REQUEST : {
notify_group ( GROUP_CALL_REALTIME | GROUP_CALL_MULIILEVEL , " input " , NOTIFICATION_WM_UNFOCUS_REQUEST ) ;
} break ;
default :
break ;
} ;
} ;
2014-11-06 01:20:42 +01:00
void SceneTree : : set_auto_accept_quit ( bool p_enable ) {
2014-02-10 02:10:30 +01:00
accept_quit = p_enable ;
}
2014-11-06 01:20:42 +01:00
void SceneTree : : set_editor_hint ( bool p_enabled ) {
2014-02-10 02:10:30 +01:00
editor_hint = p_enabled ;
}
2016-01-02 21:18:45 +01:00
bool SceneTree : : is_node_being_edited ( const Node * p_node ) const {
2016-01-05 16:02:59 +01:00
# ifdef TOOLS_ENABLED
2016-01-02 21:18:45 +01:00
return editor_hint & & edited_scene_root & & edited_scene_root - > is_a_parent_of ( p_node ) ;
2016-01-05 16:02:59 +01:00
# else
return false ;
# endif
2016-01-02 21:18:45 +01:00
}
2014-11-06 01:20:42 +01:00
bool SceneTree : : is_editor_hint ( ) const {
2014-02-10 02:10:30 +01:00
return editor_hint ;
}
2015-09-19 04:10:58 +02:00
void SceneTree : : set_debug_collisions_hint ( bool p_enabled ) {
debug_collisions_hint = p_enabled ;
}
bool SceneTree : : is_debugging_collisions_hint ( ) const {
return debug_collisions_hint ;
}
2015-09-20 18:03:46 +02:00
void SceneTree : : set_debug_navigation_hint ( bool p_enabled ) {
debug_navigation_hint = p_enabled ;
}
bool SceneTree : : is_debugging_navigation_hint ( ) const {
return debug_navigation_hint ;
}
void SceneTree : : set_debug_collisions_color ( const Color & p_color ) {
debug_collisions_color = p_color ;
}
Color SceneTree : : get_debug_collisions_color ( ) const {
return debug_collisions_color ;
}
void SceneTree : : set_debug_collision_contact_color ( const Color & p_color ) {
debug_collision_contact_color = p_color ;
}
Color SceneTree : : get_debug_collision_contact_color ( ) const {
return debug_collision_contact_color ;
}
void SceneTree : : set_debug_navigation_color ( const Color & p_color ) {
debug_navigation_color = p_color ;
}
Color SceneTree : : get_debug_navigation_color ( ) const {
return debug_navigation_color ;
}
void SceneTree : : set_debug_navigation_disabled_color ( const Color & p_color ) {
debug_navigation_disabled_color = p_color ;
}
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 ;
Ref < FixedMaterial > line_material = Ref < FixedMaterial > ( memnew ( FixedMaterial ) ) ;
line_material - > set_flag ( Material : : FLAG_UNSHADED , true ) ;
line_material - > set_line_width ( 3.0 ) ;
line_material - > set_fixed_flag ( FixedMaterial : : FLAG_USE_ALPHA , true ) ;
line_material - > set_fixed_flag ( FixedMaterial : : FLAG_USE_COLOR_ARRAY , true ) ;
line_material - > set_parameter ( FixedMaterial : : PARAM_DIFFUSE , get_debug_navigation_color ( ) ) ;
navigation_material = line_material ;
return navigation_material ;
}
Ref < Material > SceneTree : : get_debug_navigation_disabled_material ( ) {
if ( navigation_disabled_material . is_valid ( ) )
return navigation_disabled_material ;
Ref < FixedMaterial > line_material = Ref < FixedMaterial > ( memnew ( FixedMaterial ) ) ;
line_material - > set_flag ( Material : : FLAG_UNSHADED , true ) ;
line_material - > set_line_width ( 3.0 ) ;
line_material - > set_fixed_flag ( FixedMaterial : : FLAG_USE_ALPHA , true ) ;
line_material - > set_fixed_flag ( FixedMaterial : : FLAG_USE_COLOR_ARRAY , true ) ;
line_material - > set_parameter ( FixedMaterial : : PARAM_DIFFUSE , get_debug_navigation_disabled_color ( ) ) ;
navigation_disabled_material = line_material ;
return navigation_disabled_material ;
}
Ref < Material > SceneTree : : get_debug_collision_material ( ) {
if ( collision_material . is_valid ( ) )
return collision_material ;
Ref < FixedMaterial > line_material = Ref < FixedMaterial > ( memnew ( FixedMaterial ) ) ;
line_material - > set_flag ( Material : : FLAG_UNSHADED , true ) ;
line_material - > set_line_width ( 3.0 ) ;
line_material - > set_fixed_flag ( FixedMaterial : : FLAG_USE_ALPHA , true ) ;
line_material - > set_fixed_flag ( FixedMaterial : : FLAG_USE_COLOR_ARRAY , true ) ;
line_material - > set_parameter ( FixedMaterial : : PARAM_DIFFUSE , get_debug_collisions_color ( ) ) ;
collision_material = line_material ;
return collision_material ;
}
Ref < Mesh > SceneTree : : get_debug_contact_mesh ( ) {
if ( debug_contact_mesh . is_valid ( ) )
return debug_contact_mesh ;
debug_contact_mesh = Ref < Mesh > ( memnew ( Mesh ) ) ;
Ref < FixedMaterial > mat = memnew ( FixedMaterial ) ;
mat - > set_flag ( Material : : FLAG_UNSHADED , true ) ;
mat - > set_flag ( Material : : FLAG_DOUBLE_SIDED , true ) ;
mat - > set_fixed_flag ( FixedMaterial : : FLAG_USE_ALPHA , true ) ;
mat - > set_parameter ( FixedMaterial : : PARAM_DIFFUSE , get_debug_collision_contact_color ( ) ) ;
Vector3 diamond [ 6 ] = {
Vector3 ( - 1 , 0 , 0 ) ,
Vector3 ( 1 , 0 , 0 ) ,
Vector3 ( 0 , - 1 , 0 ) ,
Vector3 ( 0 , 1 , 0 ) ,
Vector3 ( 0 , 0 , - 1 ) ,
Vector3 ( 0 , 0 , 1 )
} ;
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 ,
} ;
DVector < int > indices ;
for ( int i = 0 ; i < 8 * 3 ; i + + )
indices . push_back ( diamond_faces [ i ] ) ;
DVector < Vector3 > vertices ;
for ( int i = 0 ; i < 6 ; i + + )
vertices . push_back ( diamond [ i ] * 0.1 ) ;
Array arr ;
arr . resize ( Mesh : : ARRAY_MAX ) ;
arr [ Mesh : : ARRAY_VERTEX ] = vertices ;
arr [ Mesh : : ARRAY_INDEX ] = indices ;
debug_contact_mesh - > add_surface ( Mesh : : PRIMITIVE_TRIANGLES , arr ) ;
debug_contact_mesh - > surface_set_material ( 0 , mat ) ;
return debug_contact_mesh ;
}
2014-11-06 01:20:42 +01:00
void SceneTree : : set_pause ( bool p_enabled ) {
2014-02-10 02:10:30 +01:00
if ( p_enabled = = pause )
return ;
pause = p_enabled ;
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 01:20:42 +01:00
bool SceneTree : : is_paused ( ) const {
2014-02-10 02:10:30 +01:00
return pause ;
}
2014-11-06 01:20:42 +01:00
void SceneTree : : _call_input_pause ( const StringName & p_group , const StringName & p_method , const InputEvent & p_input ) {
2014-02-10 02:10:30 +01:00
Map < StringName , Group > : : Element * E = group_map . find ( p_group ) ;
if ( ! E )
return ;
Group & g = E - > get ( ) ;
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.
Vector < Node * > nodes_copy = g . nodes ;
int node_count = nodes_copy . size ( ) ;
Node * * nodes = & nodes_copy [ 0 ] ;
Variant arg = p_input ;
const Variant * v [ 1 ] = { & arg } ;
call_lock + + ;
for ( int i = node_count - 1 ; i > = 0 ; i - - ) {
if ( input_handled )
break ;
Node * n = nodes [ i ] ;
if ( call_lock & & call_skip . has ( n ) )
continue ;
if ( ! n - > can_process ( ) )
continue ;
Variant : : CallError ce ;
n - > call_multilevel ( p_method , ( const Variant * * ) v , 1 ) ;
//ERR_FAIL_COND(node_count != g.nodes.size());
}
call_lock - - ;
if ( call_lock = = 0 )
call_skip . clear ( ) ;
}
2014-11-06 01:20:42 +01:00
void SceneTree : : _notify_group_pause ( const StringName & p_group , int p_notification ) {
2014-02-10 02:10:30 +01:00
Map < StringName , Group > : : Element * E = group_map . find ( p_group ) ;
if ( ! E )
return ;
Group & g = E - > get ( ) ;
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.
Vector < Node * > nodes_copy = g . nodes ;
int node_count = nodes_copy . size ( ) ;
Node * * nodes = & nodes_copy [ 0 ] ;
call_lock + + ;
for ( int i = 0 ; i < node_count ; i + + ) {
Node * n = nodes [ i ] ;
if ( call_lock & & call_skip . has ( n ) )
continue ;
if ( ! n - > can_process ( ) )
continue ;
n - > notification ( p_notification ) ;
//ERR_FAIL_COND(node_count != g.nodes.size());
}
call_lock - - ;
if ( call_lock = = 0 )
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 ( ) ) ;
}
}
*/
2014-11-06 01:20:42 +01:00
uint32_t SceneTree : : get_last_event_id ( ) const {
2014-02-10 02:10:30 +01:00
return last_id ;
}
2014-11-06 01:20:42 +01:00
Variant SceneTree : : _call_group ( const Variant * * p_args , int p_argcount , Variant : : CallError & r_error ) {
2014-02-10 02:10:30 +01:00
r_error . error = Variant : : CallError : : CALL_OK ;
ERR_FAIL_COND_V ( p_argcount < 3 , Variant ( ) ) ;
ERR_FAIL_COND_V ( ! p_args [ 0 ] - > is_num ( ) , Variant ( ) ) ;
ERR_FAIL_COND_V ( p_args [ 1 ] - > get_type ( ) ! = Variant : : STRING , Variant ( ) ) ;
ERR_FAIL_COND_V ( p_args [ 2 ] - > get_type ( ) ! = Variant : : STRING , Variant ( ) ) ;
int flags = * p_args [ 0 ] ;
StringName group = * p_args [ 1 ] ;
StringName method = * p_args [ 2 ] ;
Variant v [ VARIANT_ARG_MAX ] ;
for ( int i = 0 ; i < MIN ( p_argcount - 3 , 5 ) ; i + + ) {
v [ i ] = * p_args [ i + 3 ] ;
}
call_group ( flags , group , method , v [ 0 ] , v [ 1 ] , v [ 2 ] , v [ 3 ] , v [ 4 ] ) ;
return Variant ( ) ;
}
2014-11-06 01:20:42 +01:00
int64_t SceneTree : : get_frame ( ) const {
2014-02-10 02:10:30 +01:00
return current_frame ;
}
2014-11-06 01:20:42 +01:00
Array SceneTree : : _get_nodes_in_group ( const StringName & p_group ) {
2014-02-10 02:10:30 +01:00
Array ret ;
Map < StringName , Group > : : Element * E = group_map . find ( p_group ) ;
if ( ! E )
return ret ;
_update_group_order ( E - > get ( ) ) ; //update order just in case
int nc = E - > get ( ) . nodes . size ( ) ;
if ( nc = = 0 )
return ret ;
ret . resize ( nc ) ;
Node * * ptr = E - > get ( ) . nodes . ptr ( ) ;
for ( int i = 0 ; i < nc ; i + + ) {
ret [ i ] = ptr [ i ] ;
}
return ret ;
}
2016-01-02 21:18:45 +01:00
bool SceneTree : : has_group ( const StringName & p_identifier ) const {
return group_map . has ( p_identifier ) ;
}
2014-11-06 01:20:42 +01:00
void SceneTree : : get_nodes_in_group ( const StringName & p_group , List < Node * > * p_list ) {
2014-02-10 02:10:30 +01:00
Map < StringName , Group > : : Element * E = group_map . find ( p_group ) ;
if ( ! E )
return ;
_update_group_order ( E - > get ( ) ) ; //update order just in case
int nc = E - > get ( ) . nodes . size ( ) ;
if ( nc = = 0 )
return ;
Node * * ptr = E - > get ( ) . nodes . ptr ( ) ;
for ( int i = 0 ; i < nc ; i + + ) {
p_list - > push_back ( ptr [ i ] ) ;
}
}
static void _fill_array ( Node * p_node , Array & array , int p_level ) {
array . push_back ( p_level ) ;
array . push_back ( p_node - > get_name ( ) ) ;
array . push_back ( p_node - > get_type ( ) ) ;
for ( int i = 0 ; i < p_node - > get_child_count ( ) ; i + + ) {
_fill_array ( p_node - > get_child ( i ) , array , p_level + 1 ) ;
}
}
2014-11-06 01:20:42 +01:00
void SceneTree : : _debugger_request_tree ( void * self ) {
2014-02-10 02:10:30 +01:00
2014-11-06 01:20:42 +01:00
SceneTree * sml = ( SceneTree * ) self ;
2014-02-10 02:10:30 +01:00
Array arr ;
_fill_array ( sml - > root , arr , 0 ) ;
ScriptDebugger : : get_singleton ( ) - > send_message ( " scene_tree " , arr ) ;
}
2014-11-06 01:20:42 +01:00
void SceneTree : : _flush_delete_queue ( ) {
2014-02-10 02:10:30 +01:00
_THREAD_SAFE_METHOD_
while ( delete_queue . size ( ) ) {
Object * obj = ObjectDB : : get_instance ( delete_queue . front ( ) - > get ( ) ) ;
if ( obj ) {
memdelete ( obj ) ;
}
delete_queue . pop_front ( ) ;
}
}
2014-11-06 01:20:42 +01:00
void SceneTree : : queue_delete ( Object * p_object ) {
2014-02-10 02:10:30 +01:00
_THREAD_SAFE_METHOD_
ERR_FAIL_NULL ( p_object ) ;
2015-03-28 18:34:28 +01:00
p_object - > _is_queued_for_deletion = true ;
2014-02-10 02:10:30 +01:00
delete_queue . push_back ( p_object - > get_instance_ID ( ) ) ;
}
2014-11-06 01:20:42 +01:00
int SceneTree : : get_node_count ( ) const {
2014-02-10 02:10:30 +01:00
return node_count ;
}
2014-04-15 03:43:44 +02:00
2014-11-06 01:20:42 +01:00
void SceneTree : : _update_root_rect ( ) {
2014-04-15 03:43:44 +02:00
if ( stretch_mode = = STRETCH_MODE_DISABLED ) {
root - > set_rect ( Rect2 ( Point2 ( ) , last_screen_size ) ) ;
return ; //user will take care
}
//actual screen video mode
Size2 video_mode = Size2 ( OS : : get_singleton ( ) - > get_video_mode ( ) . width , OS : : get_singleton ( ) - > get_video_mode ( ) . height ) ;
Size2 desired_res = stretch_min ;
Size2 viewport_size ;
Size2 screen_size ;
float viewport_aspect = desired_res . get_aspect ( ) ;
float video_mode_aspect = video_mode . get_aspect ( ) ;
if ( stretch_aspect = = STRETCH_ASPECT_IGNORE | | ABS ( viewport_aspect - video_mode_aspect ) < CMP_EPSILON ) {
//same aspect or ignore aspect
viewport_size = desired_res ;
screen_size = video_mode ;
} else if ( viewport_aspect < video_mode_aspect ) {
// screen ratio is smaller vertically
if ( stretch_aspect = = STRETCH_ASPECT_KEEP_HEIGHT ) {
//will stretch horizontally
viewport_size . x = desired_res . y * video_mode_aspect ;
viewport_size . y = desired_res . y ;
screen_size = video_mode ;
} else {
//will need black bars
viewport_size = desired_res ;
screen_size . x = video_mode . y * viewport_aspect ;
screen_size . y = video_mode . y ;
}
} else {
//screen ratio is smaller horizontally
if ( stretch_aspect = = STRETCH_ASPECT_KEEP_WIDTH ) {
//will stretch horizontally
viewport_size . x = desired_res . x ;
viewport_size . y = desired_res . x / video_mode_aspect ;
screen_size = video_mode ;
} else {
//will need black bars
viewport_size = desired_res ;
screen_size . x = video_mode . x ;
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
if ( screen_size . x < video_mode . x ) {
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 ) ;
offset . x = Math : : round ( margin . x * viewport_size . y / screen_size . y ) ;
} else if ( screen_size . y < video_mode . y ) {
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 ) ;
offset . y = Math : : round ( margin . y * viewport_size . x / screen_size . x ) ;
} else {
VisualServer : : get_singleton ( ) - > black_bars_set_margins ( 0 , 0 , 0 , 0 ) ;
}
// print_line("VP SIZE: "+viewport_size+" OFFSET: "+offset+" = "+(offset*2+viewport_size));
// print_line("SS: "+video_mode);
switch ( stretch_mode ) {
case STRETCH_MODE_2D : {
// root->set_rect(Rect2(Point2(),video_mode));
root - > set_as_render_target ( false ) ;
root - > set_rect ( Rect2 ( margin , screen_size ) ) ;
root - > set_size_override_stretch ( true ) ;
root - > set_size_override ( true , viewport_size ) ;
} break ;
case STRETCH_MODE_VIEWPORT : {
root - > set_rect ( Rect2 ( Point2 ( ) , viewport_size ) ) ;
root - > set_size_override_stretch ( false ) ;
root - > set_size_override ( false , Size2 ( ) ) ;
root - > set_as_render_target ( true ) ;
root - > set_render_target_update_mode ( Viewport : : RENDER_TARGET_UPDATE_ALWAYS ) ;
root - > set_render_target_to_screen_rect ( Rect2 ( margin , screen_size ) ) ;
} break ;
}
}
2014-11-06 01:20:42 +01:00
void SceneTree : : set_screen_stretch ( StretchMode p_mode , StretchAspect p_aspect , const Size2 p_minsize ) {
2014-04-15 03:43:44 +02:00
stretch_mode = p_mode ;
stretch_aspect = p_aspect ;
stretch_min = p_minsize ;
_update_root_rect ( ) ;
}
2014-10-12 07:13:22 +02:00
# ifdef TOOLS_ENABLED
2014-11-06 01:20:42 +01:00
void SceneTree : : set_edited_scene_root ( Node * p_node ) {
2014-10-12 07:13:22 +02:00
edited_scene_root = p_node ;
}
2014-11-06 01:20:42 +01:00
Node * SceneTree : : get_edited_scene_root ( ) const {
2014-10-12 07:13:22 +02:00
return edited_scene_root ;
}
# endif
2015-05-17 21:33:35 +02:00
void SceneTree : : set_current_scene ( Node * p_scene ) {
ERR_FAIL_COND ( p_scene & & p_scene - > get_parent ( ) ! = root ) ;
current_scene = p_scene ;
}
Node * SceneTree : : get_current_scene ( ) const {
return current_scene ;
}
void SceneTree : : _change_scene ( Node * p_to ) {
if ( current_scene ) {
memdelete ( current_scene ) ;
current_scene = NULL ;
}
if ( p_to ) {
current_scene = p_to ;
root - > add_child ( p_to ) ;
}
}
Error SceneTree : : change_scene ( const String & p_path ) {
Ref < PackedScene > new_scene = ResourceLoader : : load ( p_path ) ;
if ( new_scene . is_null ( ) )
return ERR_CANT_OPEN ;
return change_scene_to ( new_scene ) ;
}
Error SceneTree : : change_scene_to ( const Ref < PackedScene > & p_scene ) {
Node * new_scene = NULL ;
if ( p_scene . is_valid ( ) ) {
new_scene = p_scene - > instance ( ) ;
ERR_FAIL_COND_V ( ! new_scene , ERR_CANT_CREATE ) ;
}
call_deferred ( " _change_scene " , new_scene ) ;
return OK ;
}
Error SceneTree : : reload_current_scene ( ) {
ERR_FAIL_COND_V ( ! current_scene , ERR_UNCONFIGURED ) ;
String fname = current_scene - > get_filename ( ) ;
return change_scene ( fname ) ;
}
void SceneTree : : add_current_scene ( Node * p_current ) {
current_scene = p_current ;
root - > add_child ( p_current ) ;
}
2015-08-02 17:29:37 +02:00
# ifdef DEBUG_ENABLED
2014-10-12 07:13:22 +02:00
2015-08-02 17:29:37 +02:00
void SceneTree : : _live_edit_node_path_func ( const NodePath & p_path , int p_id ) {
live_edit_node_path_cache [ p_id ] = p_path ;
}
void SceneTree : : _live_edit_res_path_func ( const String & p_path , int p_id ) {
live_edit_resource_cache [ p_id ] = p_path ;
}
void SceneTree : : _live_edit_node_set_func ( int p_id , const StringName & p_prop , const Variant & p_value ) {
if ( ! live_edit_node_path_cache . has ( p_id ) )
return ;
NodePath np = live_edit_node_path_cache [ p_id ] ;
Node * base = NULL ;
if ( root - > has_node ( live_edit_root ) )
base = root - > get_node ( live_edit_root ) ;
Map < String , Set < Node * > > : : Element * E = live_scene_edit_cache . find ( live_edit_scene ) ;
if ( ! E )
return ; //scene not editable
for ( Set < Node * > : : Element * F = E - > get ( ) . front ( ) ; F ; F = F - > next ( ) ) {
Node * n = F - > get ( ) ;
if ( base & & ! base - > is_a_parent_of ( n ) )
continue ;
if ( ! n - > has_node ( np ) )
continue ;
Node * n2 = n - > get_node ( np ) ;
n2 - > set ( p_prop , p_value ) ;
}
}
void SceneTree : : _live_edit_node_set_res_func ( int p_id , const StringName & p_prop , const String & p_value ) {
RES r = ResourceLoader : : load ( p_value ) ;
if ( ! r . is_valid ( ) )
return ;
_live_edit_node_set_func ( p_id , p_prop , r ) ;
}
void SceneTree : : _live_edit_node_call_func ( int p_id , const StringName & p_method , VARIANT_ARG_DECLARE ) {
if ( ! live_edit_node_path_cache . has ( p_id ) )
return ;
NodePath np = live_edit_node_path_cache [ p_id ] ;
Node * base = NULL ;
if ( root - > has_node ( live_edit_root ) )
base = root - > get_node ( live_edit_root ) ;
Map < String , Set < Node * > > : : Element * E = live_scene_edit_cache . find ( live_edit_scene ) ;
if ( ! E )
return ; //scene not editable
for ( Set < Node * > : : Element * F = E - > get ( ) . front ( ) ; F ; F = F - > next ( ) ) {
Node * n = F - > get ( ) ;
if ( base & & ! base - > is_a_parent_of ( n ) )
continue ;
if ( ! n - > has_node ( np ) )
continue ;
Node * n2 = n - > get_node ( np ) ;
n2 - > call ( p_method , VARIANT_ARG_PASS ) ;
}
}
void SceneTree : : _live_edit_res_set_func ( int p_id , const StringName & p_prop , const Variant & p_value ) {
if ( ! live_edit_resource_cache . has ( p_id ) )
return ;
String resp = live_edit_resource_cache [ p_id ] ;
if ( ! ResourceCache : : has ( resp ) )
return ;
RES r = ResourceCache : : get ( resp ) ;
if ( ! r . is_valid ( ) )
return ;
r - > set ( p_prop , p_value ) ;
}
void SceneTree : : _live_edit_res_set_res_func ( int p_id , const StringName & p_prop , const String & p_value ) {
RES r = ResourceLoader : : load ( p_value ) ;
if ( ! r . is_valid ( ) )
return ;
_live_edit_res_set_func ( p_id , p_prop , r ) ;
}
void SceneTree : : _live_edit_res_call_func ( int p_id , const StringName & p_method , VARIANT_ARG_DECLARE ) {
if ( ! live_edit_resource_cache . has ( p_id ) )
return ;
String resp = live_edit_resource_cache [ p_id ] ;
if ( ! ResourceCache : : has ( resp ) )
return ;
RES r = ResourceCache : : get ( resp ) ;
if ( ! r . is_valid ( ) )
return ;
r - > call ( p_method , VARIANT_ARG_PASS ) ;
}
void SceneTree : : _live_edit_root_func ( const NodePath & p_scene_path , const String & p_scene_from ) {
live_edit_root = p_scene_path ;
live_edit_scene = p_scene_from ;
}
void SceneTree : : _live_edit_create_node_func ( const NodePath & p_parent , const String & p_type , const String & p_name ) {
Node * base = NULL ;
if ( root - > has_node ( live_edit_root ) )
base = root - > get_node ( live_edit_root ) ;
Map < String , Set < Node * > > : : Element * E = live_scene_edit_cache . find ( live_edit_scene ) ;
if ( ! E )
return ; //scene not editable
for ( Set < Node * > : : Element * F = E - > get ( ) . front ( ) ; F ; F = F - > next ( ) ) {
Node * n = F - > get ( ) ;
if ( base & & ! base - > is_a_parent_of ( n ) )
continue ;
if ( ! n - > has_node ( p_parent ) )
continue ;
Node * n2 = n - > get_node ( p_parent ) ;
Object * o = ObjectTypeDB : : instance ( p_type ) ;
if ( ! o )
continue ;
Node * no = o - > cast_to < Node > ( ) ;
no - > set_name ( p_name ) ;
n2 - > add_child ( no ) ;
}
}
void SceneTree : : _live_edit_instance_node_func ( const NodePath & p_parent , const String & p_path , const String & p_name ) {
Ref < PackedScene > ps = ResourceLoader : : load ( p_path ) ;
2015-08-03 01:28:10 +02:00
2015-08-02 17:29:37 +02:00
if ( ! ps . is_valid ( ) )
return ;
Node * base = NULL ;
if ( root - > has_node ( live_edit_root ) )
base = root - > get_node ( live_edit_root ) ;
Map < String , Set < Node * > > : : Element * E = live_scene_edit_cache . find ( live_edit_scene ) ;
if ( ! E )
return ; //scene not editable
for ( Set < Node * > : : Element * F = E - > get ( ) . front ( ) ; F ; F = F - > next ( ) ) {
Node * n = F - > get ( ) ;
if ( base & & ! base - > is_a_parent_of ( n ) )
continue ;
if ( ! n - > has_node ( p_parent ) )
continue ;
Node * n2 = n - > get_node ( p_parent ) ;
Node * no = ps - > instance ( ) ;
no - > set_name ( p_name ) ;
n2 - > add_child ( no ) ;
}
}
void SceneTree : : _live_edit_remove_node_func ( const NodePath & p_at ) {
Node * base = NULL ;
if ( root - > has_node ( live_edit_root ) )
base = root - > get_node ( live_edit_root ) ;
Map < String , Set < Node * > > : : Element * E = live_scene_edit_cache . find ( live_edit_scene ) ;
if ( ! E )
return ; //scene not editable
for ( Set < Node * > : : Element * F = E - > get ( ) . front ( ) ; F ; ) {
Set < Node * > : : Element * N = F - > next ( ) ;
Node * n = F - > get ( ) ;
if ( base & & ! base - > is_a_parent_of ( n ) )
continue ;
if ( ! n - > has_node ( p_at ) )
continue ;
Node * n2 = n - > get_node ( p_at ) ;
memdelete ( n2 ) ;
F = N ;
}
}
void SceneTree : : _live_edit_remove_and_keep_node_func ( const NodePath & p_at , ObjectID p_keep_id ) {
2015-08-03 01:28:10 +02:00
Node * base = NULL ;
if ( root - > has_node ( live_edit_root ) )
base = root - > get_node ( live_edit_root ) ;
Map < String , Set < Node * > > : : Element * E = live_scene_edit_cache . find ( live_edit_scene ) ;
if ( ! E )
return ; //scene not editable
for ( Set < Node * > : : Element * F = E - > get ( ) . front ( ) ; F ; ) {
Set < Node * > : : Element * N = F - > next ( ) ;
Node * n = F - > get ( ) ;
2015-08-02 17:29:37 +02:00
2015-08-03 01:28:10 +02:00
if ( base & & ! base - > is_a_parent_of ( n ) )
continue ;
if ( ! n - > has_node ( p_at ) )
continue ;
Node * n2 = n - > get_node ( p_at ) ;
n2 - > get_parent ( ) - > remove_child ( n2 ) ;
live_edit_remove_list [ n ] [ p_keep_id ] = n2 ;
F = N ;
}
2015-08-02 17:29:37 +02:00
}
void SceneTree : : _live_edit_restore_node_func ( ObjectID p_id , const NodePath & p_at , int p_at_pos ) {
2015-08-03 01:28:10 +02:00
Node * base = NULL ;
if ( root - > has_node ( live_edit_root ) )
base = root - > get_node ( live_edit_root ) ;
Map < String , Set < Node * > > : : Element * E = live_scene_edit_cache . find ( live_edit_scene ) ;
if ( ! E )
return ; //scene not editable
for ( Set < Node * > : : Element * F = E - > get ( ) . front ( ) ; F ; ) {
Set < Node * > : : Element * N = F - > next ( ) ;
Node * n = F - > get ( ) ;
if ( base & & ! base - > is_a_parent_of ( n ) )
continue ;
if ( ! n - > has_node ( p_at ) )
continue ;
Node * n2 = n - > get_node ( p_at ) ;
Map < Node * , Map < ObjectID , Node * > > : : Element * EN = live_edit_remove_list . find ( n ) ;
if ( ! EN )
continue ;
Map < ObjectID , Node * > : : Element * FN = EN - > get ( ) . find ( p_id ) ;
if ( ! FN )
continue ;
n2 - > add_child ( FN - > get ( ) ) ;
EN - > get ( ) . erase ( FN ) ;
if ( EN - > get ( ) . size ( ) = = 0 ) {
live_edit_remove_list . erase ( EN ) ;
}
F = N ;
}
2015-08-02 17:29:37 +02:00
}
void SceneTree : : _live_edit_duplicate_node_func ( const NodePath & p_at , const String & p_new_name ) {
Node * base = NULL ;
if ( root - > has_node ( live_edit_root ) )
base = root - > get_node ( live_edit_root ) ;
Map < String , Set < Node * > > : : Element * E = live_scene_edit_cache . find ( live_edit_scene ) ;
if ( ! E )
return ; //scene not editable
for ( Set < Node * > : : Element * F = E - > get ( ) . front ( ) ; F ; F = F - > next ( ) ) {
Node * n = F - > get ( ) ;
if ( base & & ! base - > is_a_parent_of ( n ) )
continue ;
if ( ! n - > has_node ( p_at ) )
continue ;
Node * n2 = n - > get_node ( p_at ) ;
Node * dup = n2 - > duplicate ( true ) ;
if ( ! dup )
continue ;
dup - > set_name ( p_new_name ) ;
n2 - > get_parent ( ) - > add_child ( dup ) ;
}
}
2015-08-03 01:28:10 +02:00
void SceneTree : : _live_edit_reparent_node_func ( const NodePath & p_at , const NodePath & p_new_place , const String & p_new_name , int p_at_pos ) {
2015-08-02 17:29:37 +02:00
Node * base = NULL ;
if ( root - > has_node ( live_edit_root ) )
base = root - > get_node ( live_edit_root ) ;
Map < String , Set < Node * > > : : Element * E = live_scene_edit_cache . find ( live_edit_scene ) ;
if ( ! E )
return ; //scene not editable
for ( Set < Node * > : : Element * F = E - > get ( ) . front ( ) ; F ; F = F - > next ( ) ) {
Node * n = F - > get ( ) ;
if ( base & & ! base - > is_a_parent_of ( n ) )
continue ;
if ( ! n - > has_node ( p_at ) )
continue ;
Node * nfrom = n - > get_node ( p_at ) ;
if ( ! n - > has_node ( p_new_place ) )
continue ;
Node * nto = n - > get_node ( p_new_place ) ;
nfrom - > get_parent ( ) - > remove_child ( nfrom ) ;
nfrom - > set_name ( p_new_name ) ;
nto - > add_child ( nfrom ) ;
2015-08-03 01:28:10 +02:00
if ( p_at_pos > = 0 )
nto - > move_child ( nfrom , p_at_pos ) ;
2015-08-02 17:29:37 +02:00
}
}
# endif
2014-11-06 01:20:42 +01:00
void SceneTree : : _bind_methods ( ) {
2014-02-10 02:10:30 +01:00
//ObjectTypeDB::bind_method(_MD("call_group","call_flags","group","method","arg1","arg2"),&SceneMainLoop::_call_group,DEFVAL(Variant()),DEFVAL(Variant()));
2014-11-06 01:20:42 +01:00
ObjectTypeDB : : bind_method ( _MD ( " notify_group " , " call_flags " , " group " , " notification " ) , & SceneTree : : notify_group ) ;
ObjectTypeDB : : bind_method ( _MD ( " set_group " , " call_flags " , " group " , " property " , " value " ) , & SceneTree : : set_group ) ;
2014-02-10 02:10:30 +01:00
2015-12-28 02:13:05 +01:00
ObjectTypeDB : : bind_method ( _MD ( " get_nodes_in_group " , " group " ) , & SceneTree : : _get_nodes_in_group ) ;
2014-02-10 02:10:30 +01:00
2014-11-06 01:20:42 +01:00
ObjectTypeDB : : bind_method ( _MD ( " get_root:Viewport " ) , & SceneTree : : get_root ) ;
2016-01-02 21:18:45 +01:00
ObjectTypeDB : : bind_method ( _MD ( " has_group " , " name " ) , & SceneTree : : has_group ) ;
2014-02-10 02:10:30 +01:00
2014-11-06 01:20:42 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_auto_accept_quit " , " enabled " ) , & SceneTree : : set_auto_accept_quit ) ;
2014-02-10 02:10:30 +01:00
2014-11-06 01:20:42 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_editor_hint " , " enable " ) , & SceneTree : : set_editor_hint ) ;
ObjectTypeDB : : bind_method ( _MD ( " is_editor_hint " ) , & SceneTree : : is_editor_hint ) ;
2015-09-19 04:10:58 +02:00
ObjectTypeDB : : bind_method ( _MD ( " set_debug_collisions_hint " , " enable " ) , & SceneTree : : set_debug_collisions_hint ) ;
ObjectTypeDB : : bind_method ( _MD ( " is_debugging_collisions_hint " ) , & SceneTree : : is_debugging_collisions_hint ) ;
2015-09-20 18:03:46 +02:00
ObjectTypeDB : : bind_method ( _MD ( " set_debug_navigation_hint " , " enable " ) , & SceneTree : : set_debug_navigation_hint ) ;
ObjectTypeDB : : bind_method ( _MD ( " is_debugging_navigation_hint " ) , & SceneTree : : is_debugging_navigation_hint ) ;
2014-10-12 07:13:22 +02:00
# ifdef TOOLS_ENABLED
2014-11-06 01:20:42 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_edited_scene_root " , " scene " ) , & SceneTree : : set_edited_scene_root ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_edited_scene_root " ) , & SceneTree : : get_edited_scene_root ) ;
2014-10-12 07:13:22 +02:00
# endif
2014-02-10 02:10:30 +01:00
2014-11-06 01:20:42 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_pause " , " enable " ) , & SceneTree : : set_pause ) ;
ObjectTypeDB : : bind_method ( _MD ( " is_paused " ) , & SceneTree : : is_paused ) ;
ObjectTypeDB : : bind_method ( _MD ( " set_input_as_handled " ) , & SceneTree : : set_input_as_handled ) ;
2014-02-10 02:10:30 +01:00
2014-11-06 01:20:42 +01:00
ObjectTypeDB : : bind_method ( _MD ( " get_node_count " ) , & SceneTree : : get_node_count ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_frame " ) , & SceneTree : : get_frame ) ;
ObjectTypeDB : : bind_method ( _MD ( " quit " ) , & SceneTree : : quit ) ;
2014-02-10 02:10:30 +01:00
2014-11-06 01:20:42 +01:00
ObjectTypeDB : : bind_method ( _MD ( " set_screen_stretch " , " mode " , " aspect " , " minsize " ) , & SceneTree : : set_screen_stretch ) ;
2014-04-15 03:43:44 +02:00
2014-11-06 01:20:42 +01:00
ObjectTypeDB : : bind_method ( _MD ( " queue_delete " , " obj " ) , & SceneTree : : queue_delete ) ;
2014-02-10 02:10:30 +01:00
2015-05-17 21:33:35 +02:00
2014-02-10 02:10:30 +01:00
MethodInfo mi ;
mi . name = " call_group " ;
mi . arguments . push_back ( PropertyInfo ( Variant : : INT , " flags " ) ) ;
mi . arguments . push_back ( PropertyInfo ( Variant : : STRING , " group " ) ) ;
mi . arguments . push_back ( PropertyInfo ( Variant : : STRING , " method " ) ) ;
Vector < Variant > defargs ;
for ( int i = 0 ; i < VARIANT_ARG_MAX ; i + + ) {
mi . arguments . push_back ( PropertyInfo ( Variant : : NIL , " arg " + itos ( i ) ) ) ;
defargs . push_back ( Variant ( ) ) ;
}
2014-11-06 01:20:42 +01:00
ObjectTypeDB : : bind_native_method ( METHOD_FLAGS_DEFAULT , " call_group " , & SceneTree : : _call_group , mi , defargs ) ;
2014-02-10 02:10:30 +01:00
2015-05-17 22:19:12 +02:00
ObjectTypeDB : : bind_method ( _MD ( " set_current_scene " , " child_node:Node " ) , & SceneTree : : set_current_scene ) ;
ObjectTypeDB : : bind_method ( _MD ( " get_current_scene:Node " ) , & SceneTree : : get_current_scene ) ;
2015-05-17 21:33:35 +02:00
ObjectTypeDB : : bind_method ( _MD ( " change_scene " , " path " ) , & SceneTree : : change_scene ) ;
2015-05-17 22:19:12 +02:00
ObjectTypeDB : : bind_method ( _MD ( " change_scene_to " , " packed_scene:PackedScene " ) , & SceneTree : : change_scene_to ) ;
2015-05-17 21:33:35 +02:00
ObjectTypeDB : : bind_method ( _MD ( " reload_current_scene " ) , & SceneTree : : reload_current_scene ) ;
ObjectTypeDB : : bind_method ( _MD ( " _change_scene " ) , & SceneTree : : _change_scene ) ;
2014-02-10 02:10:30 +01:00
ADD_SIGNAL ( MethodInfo ( " tree_changed " ) ) ;
ADD_SIGNAL ( MethodInfo ( " node_removed " , PropertyInfo ( Variant : : OBJECT , " node " ) ) ) ;
ADD_SIGNAL ( MethodInfo ( " screen_resized " ) ) ;
2015-06-12 18:53:18 +02:00
ADD_SIGNAL ( MethodInfo ( " idle_frame " ) ) ;
ADD_SIGNAL ( MethodInfo ( " fixed_frame " ) ) ;
2014-02-10 02:10:30 +01:00
BIND_CONSTANT ( GROUP_CALL_DEFAULT ) ;
BIND_CONSTANT ( GROUP_CALL_REVERSE ) ;
BIND_CONSTANT ( GROUP_CALL_REALTIME ) ;
BIND_CONSTANT ( GROUP_CALL_UNIQUE ) ;
2014-04-15 03:43:44 +02:00
BIND_CONSTANT ( STRETCH_MODE_DISABLED ) ;
BIND_CONSTANT ( STRETCH_MODE_2D ) ;
BIND_CONSTANT ( STRETCH_MODE_VIEWPORT ) ;
BIND_CONSTANT ( STRETCH_ASPECT_IGNORE ) ;
BIND_CONSTANT ( STRETCH_ASPECT_KEEP ) ;
BIND_CONSTANT ( STRETCH_ASPECT_KEEP_WIDTH ) ;
BIND_CONSTANT ( STRETCH_ASPECT_KEEP_HEIGHT ) ;
2014-02-10 02:10:30 +01:00
}
2015-09-20 18:03:46 +02:00
SceneTree * SceneTree : : singleton = NULL ;
2014-11-06 01:20:42 +01:00
SceneTree : : SceneTree ( ) {
2014-02-10 02:10:30 +01:00
2015-09-20 18:03:46 +02:00
singleton = this ;
2014-02-10 02:10:30 +01:00
_quit = false ;
initialized = false ;
2015-09-20 18:03:46 +02:00
editor_hint = false ;
debug_collisions_hint = false ;
debug_navigation_hint = false ;
debug_collisions_color = GLOBAL_DEF ( " debug/collision_shape_color " , Color ( 0.0 , 0.6 , 0.7 , 0.5 ) ) ;
debug_collision_contact_color = GLOBAL_DEF ( " debug/collision_contact_color " , Color ( 1.0 , 0.2 , 0.1 , 0.8 ) ) ;
debug_navigation_color = GLOBAL_DEF ( " debug/navigation_geometry_color " , Color ( 0.1 , 1.0 , 0.7 , 0.4 ) ) ;
debug_navigation_disabled_color = GLOBAL_DEF ( " debug/navigation_disabled_geometry_color " , Color ( 1.0 , 0.7 , 0.1 , 0.4 ) ) ;
collision_debug_contacts = GLOBAL_DEF ( " debug/collision_max_contacts_displayed " , 10000 ) ;
2014-02-10 02:10:30 +01:00
tree_version = 1 ;
fixed_process_time = 1 ;
idle_process_time = 1 ;
2014-11-06 01:20:42 +01:00
last_id = 1 ;
2014-02-10 02:10:30 +01:00
root = NULL ;
current_frame = 0 ;
tree_changed_name = " tree_changed " ;
node_removed_name = " node_removed " ;
ugc_locked = false ;
call_lock = 0 ;
root_lock = 0 ;
node_count = 0 ;
//create with mainloop
root = memnew ( Viewport ) ;
root - > set_name ( " root " ) ;
root - > set_world ( Ref < World > ( memnew ( World ) ) ) ;
//root->set_world_2d( Ref<World2D>( memnew( World2D )));
root - > set_as_audio_listener ( true ) ;
root - > set_as_audio_listener_2d ( true ) ;
2015-05-17 21:33:35 +02:00
current_scene = NULL ;
2014-02-10 02:10:30 +01:00
2014-04-15 03:43:44 +02:00
stretch_mode = STRETCH_MODE_DISABLED ;
stretch_aspect = STRETCH_ASPECT_IGNORE ;
2014-02-10 02:10:30 +01:00
last_screen_size = Size2 ( OS : : get_singleton ( ) - > get_video_mode ( ) . width , OS : : get_singleton ( ) - > get_video_mode ( ) . height ) ;
root - > set_rect ( Rect2 ( Point2 ( ) , last_screen_size ) ) ;
if ( ScriptDebugger : : get_singleton ( ) ) {
ScriptDebugger : : get_singleton ( ) - > set_request_scene_tree_message_func ( _debugger_request_tree , this ) ;
}
2014-09-15 16:33:30 +02:00
root - > set_physics_object_picking ( GLOBAL_DEF ( " physics/enable_object_picking " , true ) ) ;
2014-10-14 06:01:25 +02:00
# ifdef TOOLS_ENABLED
2014-10-12 07:13:22 +02:00
edited_scene_root = NULL ;
2014-10-14 06:01:25 +02:00
# endif
2014-10-12 07:13:22 +02:00
2015-08-02 17:29:37 +02:00
# ifdef DEBUG_ENABLED
live_edit_funcs . udata = this ;
live_edit_funcs . node_path_func = _live_edit_node_path_funcs ;
live_edit_funcs . res_path_func = _live_edit_res_path_funcs ;
live_edit_funcs . node_set_func = _live_edit_node_set_funcs ;
live_edit_funcs . node_set_res_func = _live_edit_node_set_res_funcs ;
live_edit_funcs . node_call_func = _live_edit_node_call_funcs ;
live_edit_funcs . res_set_func = _live_edit_res_set_funcs ;
live_edit_funcs . res_set_res_func = _live_edit_res_set_res_funcs ;
live_edit_funcs . res_call_func = _live_edit_res_call_funcs ;
live_edit_funcs . root_func = _live_edit_root_funcs ;
live_edit_funcs . tree_create_node_func = _live_edit_create_node_funcs ;
live_edit_funcs . tree_instance_node_func = _live_edit_instance_node_funcs ;
live_edit_funcs . tree_remove_node_func = _live_edit_remove_node_funcs ;
live_edit_funcs . tree_remove_and_keep_node_func = _live_edit_remove_and_keep_node_funcs ;
live_edit_funcs . tree_restore_node_func = _live_edit_restore_node_funcs ;
live_edit_funcs . tree_duplicate_node_func = _live_edit_duplicate_node_funcs ;
live_edit_funcs . tree_reparent_node_func = _live_edit_reparent_node_funcs ;
if ( ScriptDebugger : : get_singleton ( ) ) {
ScriptDebugger : : get_singleton ( ) - > set_live_edit_funcs ( & live_edit_funcs ) ;
}
live_edit_root = NodePath ( " /root " ) ;
# endif
2015-06-12 18:53:18 +02:00
2014-09-15 16:33:30 +02:00
2014-02-10 02:10:30 +01:00
}
2014-11-06 01:20:42 +01:00
SceneTree : : ~ SceneTree ( ) {
2014-02-10 02:10:30 +01:00
}