2022-03-15 13:29:32 +01:00
/*************************************************************************/
/* core_bind.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
/* */
/* 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 "core_bind.h"
2022-08-19 16:18:53 +02:00
# include "core/config/project_settings.h"
2022-03-15 13:29:32 +01:00
# include "core/crypto/crypto_core.h"
# include "core/io/file_access_compressed.h"
# include "core/io/file_access_encrypted.h"
# include "core/io/json.h"
# include "core/io/marshalls.h"
# include "core/math/geometry.h"
2022-08-17 13:45:14 +02:00
# include "core/object/method_bind_ext.gen.inc"
2022-03-15 13:29:32 +01:00
# include "core/os/keyboard.h"
# include "core/os/os.h"
/**
* Time constants borrowed from loc_time . h
*/
# define EPOCH_YR 1970 /* EPOCH = Jan 1 1970 00:00:00 */
# define SECS_DAY (24L * 60L * 60L)
# define LEAPYEAR(year) (!((year) % 4) && (((year) % 100) || !((year) % 400)))
# define YEARSIZE(year) (LEAPYEAR(year) ? 366 : 365)
# define SECOND_KEY "second"
# define MINUTE_KEY "minute"
# define HOUR_KEY "hour"
# define DAY_KEY "day"
# define MONTH_KEY "month"
# define YEAR_KEY "year"
# define WEEKDAY_KEY "weekday"
# define DST_KEY "dst"
/// Table of number of days in each month (for regular year and leap year)
static const unsigned int MONTH_DAYS_TABLE [ 2 ] [ 12 ] = {
{ 31 , 28 , 31 , 30 , 31 , 30 , 31 , 31 , 30 , 31 , 30 , 31 } ,
{ 31 , 29 , 31 , 30 , 31 , 30 , 31 , 31 , 30 , 31 , 30 , 31 }
} ;
_ResourceLoader * _ResourceLoader : : singleton = nullptr ;
Ref < ResourceInteractiveLoader > _ResourceLoader : : load_interactive ( const String & p_path , const String & p_type_hint ) {
return ResourceLoader : : load_interactive ( p_path , p_type_hint ) ;
}
RES _ResourceLoader : : load ( const String & p_path , const String & p_type_hint , bool p_no_cache ) {
Error err = OK ;
RES ret = ResourceLoader : : load ( p_path , p_type_hint , p_no_cache , & err ) ;
ERR_FAIL_COND_V_MSG ( err ! = OK , ret , " Error loading resource: ' " + p_path + " '. " ) ;
return ret ;
}
PoolVector < String > _ResourceLoader : : get_recognized_extensions_for_type ( const String & p_type ) {
List < String > exts ;
ResourceLoader : : get_recognized_extensions_for_type ( p_type , & exts ) ;
PoolVector < String > ret ;
for ( List < String > : : Element * E = exts . front ( ) ; E ; E = E - > next ( ) ) {
ret . push_back ( E - > get ( ) ) ;
}
return ret ;
}
void _ResourceLoader : : set_abort_on_missing_resources ( bool p_abort ) {
ResourceLoader : : set_abort_on_missing_resources ( p_abort ) ;
}
PoolStringArray _ResourceLoader : : get_dependencies ( const String & p_path ) {
List < String > deps ;
ResourceLoader : : get_dependencies ( p_path , & deps ) ;
PoolStringArray ret ;
for ( List < String > : : Element * E = deps . front ( ) ; E ; E = E - > next ( ) ) {
ret . push_back ( E - > get ( ) ) ;
}
return ret ;
} ;
# ifndef DISABLE_DEPRECATED
bool _ResourceLoader : : has ( const String & p_path ) {
WARN_PRINT ( " ResourceLoader.has() is deprecated, please replace it with the equivalent has_cached() or the new exists(). " ) ;
return has_cached ( p_path ) ;
}
# endif // DISABLE_DEPRECATED
bool _ResourceLoader : : has_cached ( const String & p_path ) {
String local_path = ProjectSettings : : get_singleton ( ) - > localize_path ( p_path ) ;
return ResourceCache : : has ( local_path ) ;
}
bool _ResourceLoader : : exists ( const String & p_path , const String & p_type_hint ) {
return ResourceLoader : : exists ( p_path , p_type_hint ) ;
}
void _ResourceLoader : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " load_interactive " , " path " , " type_hint " ) , & _ResourceLoader : : load_interactive , DEFVAL ( " " ) ) ;
ClassDB : : bind_method ( D_METHOD ( " load " , " path " , " type_hint " , " no_cache " ) , & _ResourceLoader : : load , DEFVAL ( " " ) , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " get_recognized_extensions_for_type " , " type " ) , & _ResourceLoader : : get_recognized_extensions_for_type ) ;
ClassDB : : bind_method ( D_METHOD ( " set_abort_on_missing_resources " , " abort " ) , & _ResourceLoader : : set_abort_on_missing_resources ) ;
ClassDB : : bind_method ( D_METHOD ( " get_dependencies " , " path " ) , & _ResourceLoader : : get_dependencies ) ;
ClassDB : : bind_method ( D_METHOD ( " has_cached " , " path " ) , & _ResourceLoader : : has_cached ) ;
ClassDB : : bind_method ( D_METHOD ( " exists " , " path " , " type_hint " ) , & _ResourceLoader : : exists , DEFVAL ( " " ) ) ;
# ifndef DISABLE_DEPRECATED
ClassDB : : bind_method ( D_METHOD ( " has " , " path " ) , & _ResourceLoader : : has ) ;
# endif // DISABLE_DEPRECATED
}
_ResourceLoader : : _ResourceLoader ( ) {
singleton = this ;
}
Error _ResourceSaver : : save ( const String & p_path , const RES & p_resource , SaverFlags p_flags ) {
ERR_FAIL_COND_V_MSG ( p_resource . is_null ( ) , ERR_INVALID_PARAMETER , " Can't save empty resource to path ' " + String ( p_path ) + " '. " ) ;
return ResourceSaver : : save ( p_path , p_resource , p_flags ) ;
}
PoolVector < String > _ResourceSaver : : get_recognized_extensions ( const RES & p_resource ) {
ERR_FAIL_COND_V_MSG ( p_resource . is_null ( ) , PoolVector < String > ( ) , " It's not a reference to a valid Resource object. " ) ;
List < String > exts ;
ResourceSaver : : get_recognized_extensions ( p_resource , & exts ) ;
PoolVector < String > ret ;
for ( List < String > : : Element * E = exts . front ( ) ; E ; E = E - > next ( ) ) {
ret . push_back ( E - > get ( ) ) ;
}
return ret ;
}
_ResourceSaver * _ResourceSaver : : singleton = nullptr ;
void _ResourceSaver : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " save " , " path " , " resource " , " flags " ) , & _ResourceSaver : : save , DEFVAL ( 0 ) ) ;
ClassDB : : bind_method ( D_METHOD ( " get_recognized_extensions " , " type " ) , & _ResourceSaver : : get_recognized_extensions ) ;
BIND_ENUM_CONSTANT ( FLAG_RELATIVE_PATHS ) ;
BIND_ENUM_CONSTANT ( FLAG_BUNDLE_RESOURCES ) ;
BIND_ENUM_CONSTANT ( FLAG_CHANGE_PATH ) ;
BIND_ENUM_CONSTANT ( FLAG_OMIT_EDITOR_PROPERTIES ) ;
BIND_ENUM_CONSTANT ( FLAG_SAVE_BIG_ENDIAN ) ;
BIND_ENUM_CONSTANT ( FLAG_COMPRESS ) ;
BIND_ENUM_CONSTANT ( FLAG_REPLACE_SUBRESOURCE_PATHS ) ;
}
_ResourceSaver : : _ResourceSaver ( ) {
singleton = this ;
}
/////////////////OS
void _OS : : global_menu_add_item ( const String & p_menu , const String & p_label , const Variant & p_signal , const Variant & p_meta ) {
OS : : get_singleton ( ) - > global_menu_add_item ( p_menu , p_label , p_signal , p_meta ) ;
}
void _OS : : global_menu_add_separator ( const String & p_menu ) {
OS : : get_singleton ( ) - > global_menu_add_separator ( p_menu ) ;
}
void _OS : : global_menu_remove_item ( const String & p_menu , int p_idx ) {
OS : : get_singleton ( ) - > global_menu_remove_item ( p_menu , p_idx ) ;
}
void _OS : : global_menu_clear ( const String & p_menu ) {
OS : : get_singleton ( ) - > global_menu_clear ( p_menu ) ;
}
Point2 _OS : : get_mouse_position ( ) const {
return OS : : get_singleton ( ) - > get_mouse_position ( ) ;
}
void _OS : : set_window_title ( const String & p_title ) {
OS : : get_singleton ( ) - > set_window_title ( p_title ) ;
}
void _OS : : set_window_mouse_passthrough ( const PoolVector2Array & p_region ) {
OS : : get_singleton ( ) - > set_window_mouse_passthrough ( p_region ) ;
}
int _OS : : get_mouse_button_state ( ) const {
return OS : : get_singleton ( ) - > get_mouse_button_state ( ) ;
}
String _OS : : get_unique_id ( ) const {
return OS : : get_singleton ( ) - > get_unique_id ( ) ;
}
bool _OS : : has_touchscreen_ui_hint ( ) const {
return OS : : get_singleton ( ) - > has_touchscreen_ui_hint ( ) ;
}
void _OS : : set_clipboard ( const String & p_text ) {
OS : : get_singleton ( ) - > set_clipboard ( p_text ) ;
}
String _OS : : get_clipboard ( ) const {
return OS : : get_singleton ( ) - > get_clipboard ( ) ;
}
bool _OS : : has_clipboard ( ) const {
return OS : : get_singleton ( ) - > has_clipboard ( ) ;
}
int _OS : : get_video_driver_count ( ) const {
return OS : : get_singleton ( ) - > get_video_driver_count ( ) ;
}
String _OS : : get_video_driver_name ( VideoDriver p_driver ) const {
return OS : : get_singleton ( ) - > get_video_driver_name ( ( int ) p_driver ) ;
}
_OS : : VideoDriver _OS : : get_current_video_driver ( ) const {
return ( VideoDriver ) OS : : get_singleton ( ) - > get_current_video_driver ( ) ;
}
int _OS : : get_audio_driver_count ( ) const {
return OS : : get_singleton ( ) - > get_audio_driver_count ( ) ;
}
String _OS : : get_audio_driver_name ( int p_driver ) const {
return OS : : get_singleton ( ) - > get_audio_driver_name ( p_driver ) ;
}
PoolStringArray _OS : : get_connected_midi_inputs ( ) {
return OS : : get_singleton ( ) - > get_connected_midi_inputs ( ) ;
}
void _OS : : open_midi_inputs ( ) {
OS : : get_singleton ( ) - > open_midi_inputs ( ) ;
}
void _OS : : close_midi_inputs ( ) {
OS : : get_singleton ( ) - > close_midi_inputs ( ) ;
}
void _OS : : set_video_mode ( const Size2 & p_size , bool p_fullscreen , bool p_resizeable , int p_screen ) {
OS : : VideoMode vm ;
vm . width = p_size . width ;
vm . height = p_size . height ;
vm . fullscreen = p_fullscreen ;
vm . resizable = p_resizeable ;
OS : : get_singleton ( ) - > set_video_mode ( vm , p_screen ) ;
}
Size2 _OS : : get_video_mode ( int p_screen ) const {
OS : : VideoMode vm ;
vm = OS : : get_singleton ( ) - > get_video_mode ( p_screen ) ;
return Size2 ( vm . width , vm . height ) ;
}
bool _OS : : is_video_mode_fullscreen ( int p_screen ) const {
OS : : VideoMode vm ;
vm = OS : : get_singleton ( ) - > get_video_mode ( p_screen ) ;
return vm . fullscreen ;
}
int _OS : : get_screen_count ( ) const {
return OS : : get_singleton ( ) - > get_screen_count ( ) ;
}
int _OS : : get_current_screen ( ) const {
return OS : : get_singleton ( ) - > get_current_screen ( ) ;
}
void _OS : : set_current_screen ( int p_screen ) {
OS : : get_singleton ( ) - > set_current_screen ( p_screen ) ;
}
Point2 _OS : : get_screen_position ( int p_screen ) const {
return OS : : get_singleton ( ) - > get_screen_position ( p_screen ) ;
}
Size2 _OS : : get_screen_size ( int p_screen ) const {
return OS : : get_singleton ( ) - > get_screen_size ( p_screen ) ;
}
int _OS : : get_screen_dpi ( int p_screen ) const {
return OS : : get_singleton ( ) - > get_screen_dpi ( p_screen ) ;
}
float _OS : : get_screen_scale ( int p_screen ) const {
return OS : : get_singleton ( ) - > get_screen_scale ( p_screen ) ;
}
float _OS : : get_screen_max_scale ( ) const {
return OS : : get_singleton ( ) - > get_screen_max_scale ( ) ;
}
float _OS : : get_screen_refresh_rate ( int p_screen ) const {
return OS : : get_singleton ( ) - > get_screen_refresh_rate ( ) ;
}
Point2 _OS : : get_window_position ( ) const {
return OS : : get_singleton ( ) - > get_window_position ( ) ;
}
void _OS : : set_window_position ( const Point2 & p_position ) {
OS : : get_singleton ( ) - > set_window_position ( p_position ) ;
}
Size2 _OS : : get_max_window_size ( ) const {
return OS : : get_singleton ( ) - > get_max_window_size ( ) ;
}
Size2 _OS : : get_min_window_size ( ) const {
return OS : : get_singleton ( ) - > get_min_window_size ( ) ;
}
Size2 _OS : : get_window_size ( ) const {
return OS : : get_singleton ( ) - > get_window_size ( ) ;
}
Size2 _OS : : get_real_window_size ( ) const {
return OS : : get_singleton ( ) - > get_real_window_size ( ) ;
}
void _OS : : set_max_window_size ( const Size2 & p_size ) {
OS : : get_singleton ( ) - > set_max_window_size ( p_size ) ;
}
void _OS : : set_min_window_size ( const Size2 & p_size ) {
OS : : get_singleton ( ) - > set_min_window_size ( p_size ) ;
}
void _OS : : set_window_size ( const Size2 & p_size ) {
OS : : get_singleton ( ) - > set_window_size ( p_size ) ;
}
Rect2 _OS : : get_window_safe_area ( ) const {
return OS : : get_singleton ( ) - > get_window_safe_area ( ) ;
}
2022-07-27 00:21:20 +02:00
Array _OS : : get_display_cutouts ( ) const {
return OS : : get_singleton ( ) - > get_display_cutouts ( ) ;
}
2022-03-15 13:29:32 +01:00
void _OS : : set_window_fullscreen ( bool p_enabled ) {
OS : : get_singleton ( ) - > set_window_fullscreen ( p_enabled ) ;
}
bool _OS : : is_window_fullscreen ( ) const {
return OS : : get_singleton ( ) - > is_window_fullscreen ( ) ;
}
void _OS : : set_window_resizable ( bool p_enabled ) {
OS : : get_singleton ( ) - > set_window_resizable ( p_enabled ) ;
}
bool _OS : : is_window_resizable ( ) const {
return OS : : get_singleton ( ) - > is_window_resizable ( ) ;
}
void _OS : : set_window_minimized ( bool p_enabled ) {
OS : : get_singleton ( ) - > set_window_minimized ( p_enabled ) ;
}
bool _OS : : is_window_minimized ( ) const {
return OS : : get_singleton ( ) - > is_window_minimized ( ) ;
}
void _OS : : set_window_maximized ( bool p_enabled ) {
OS : : get_singleton ( ) - > set_window_maximized ( p_enabled ) ;
}
bool _OS : : is_window_maximized ( ) const {
return OS : : get_singleton ( ) - > is_window_maximized ( ) ;
}
void _OS : : set_window_always_on_top ( bool p_enabled ) {
OS : : get_singleton ( ) - > set_window_always_on_top ( p_enabled ) ;
}
bool _OS : : is_window_always_on_top ( ) const {
return OS : : get_singleton ( ) - > is_window_always_on_top ( ) ;
}
bool _OS : : is_window_focused ( ) const {
return OS : : get_singleton ( ) - > is_window_focused ( ) ;
}
void _OS : : set_borderless_window ( bool p_borderless ) {
OS : : get_singleton ( ) - > set_borderless_window ( p_borderless ) ;
}
bool _OS : : get_window_per_pixel_transparency_enabled ( ) const {
return OS : : get_singleton ( ) - > get_window_per_pixel_transparency_enabled ( ) ;
}
void _OS : : set_window_per_pixel_transparency_enabled ( bool p_enabled ) {
OS : : get_singleton ( ) - > set_window_per_pixel_transparency_enabled ( p_enabled ) ;
}
bool _OS : : get_borderless_window ( ) const {
return OS : : get_singleton ( ) - > get_borderless_window ( ) ;
}
void _OS : : set_ime_active ( const bool p_active ) {
OS : : get_singleton ( ) - > set_ime_active ( p_active ) ;
}
void _OS : : set_ime_position ( const Point2 & p_pos ) {
OS : : get_singleton ( ) - > set_ime_position ( p_pos ) ;
}
Point2 _OS : : get_ime_selection ( ) const {
return OS : : get_singleton ( ) - > get_ime_selection ( ) ;
}
String _OS : : get_ime_text ( ) const {
return OS : : get_singleton ( ) - > get_ime_text ( ) ;
}
void _OS : : set_use_file_access_save_and_swap ( bool p_enable ) {
FileAccess : : set_backup_save ( p_enable ) ;
}
bool _OS : : is_video_mode_resizable ( int p_screen ) const {
OS : : VideoMode vm ;
vm = OS : : get_singleton ( ) - > get_video_mode ( p_screen ) ;
return vm . resizable ;
}
Array _OS : : get_fullscreen_mode_list ( int p_screen ) const {
List < OS : : VideoMode > vmlist ;
OS : : get_singleton ( ) - > get_fullscreen_mode_list ( & vmlist , p_screen ) ;
Array vmarr ;
for ( List < OS : : VideoMode > : : Element * E = vmlist . front ( ) ; E ; E = E - > next ( ) ) {
vmarr . push_back ( Size2 ( E - > get ( ) . width , E - > get ( ) . height ) ) ;
}
return vmarr ;
}
void _OS : : set_low_processor_usage_mode ( bool p_enabled ) {
OS : : get_singleton ( ) - > set_low_processor_usage_mode ( p_enabled ) ;
}
bool _OS : : is_in_low_processor_usage_mode ( ) const {
return OS : : get_singleton ( ) - > is_in_low_processor_usage_mode ( ) ;
}
void _OS : : set_low_processor_usage_mode_sleep_usec ( int p_usec ) {
OS : : get_singleton ( ) - > set_low_processor_usage_mode_sleep_usec ( p_usec ) ;
}
int _OS : : get_low_processor_usage_mode_sleep_usec ( ) const {
return OS : : get_singleton ( ) - > get_low_processor_usage_mode_sleep_usec ( ) ;
}
String _OS : : get_executable_path ( ) const {
return OS : : get_singleton ( ) - > get_executable_path ( ) ;
}
Error _OS : : shell_open ( String p_uri ) {
if ( p_uri . begins_with ( " res:// " ) ) {
2022-03-23 20:46:05 +01:00
WARN_PRINT ( " Attempting to open an URL with the \" res:// \" protocol. Use `ProjectSettings.globalize_path()` to convert a Pandemonium-specific path to a system path before opening it with `OS.shell_open()`. " ) ;
2022-03-15 13:29:32 +01:00
} else if ( p_uri . begins_with ( " user:// " ) ) {
2022-03-23 20:46:05 +01:00
WARN_PRINT ( " Attempting to open an URL with the \" user:// \" protocol. Use `ProjectSettings.globalize_path()` to convert a Pandemonium-specific path to a system path before opening it with `OS.shell_open()`. " ) ;
2022-03-15 13:29:32 +01:00
}
return OS : : get_singleton ( ) - > shell_open ( p_uri ) ;
} ;
int _OS : : execute ( const String & p_path , const Vector < String > & p_arguments , bool p_blocking , Array p_output , bool p_read_stderr , bool p_open_console ) {
OS : : ProcessID pid = - 2 ;
int exitcode = 0 ;
List < String > args ;
for ( int i = 0 ; i < p_arguments . size ( ) ; i + + ) {
args . push_back ( p_arguments [ i ] ) ;
}
String pipe ;
Error err = OS : : get_singleton ( ) - > execute ( p_path , args , p_blocking , & pid , & pipe , & exitcode , p_read_stderr , nullptr , p_open_console ) ;
p_output . clear ( ) ;
p_output . push_back ( pipe ) ;
if ( err ! = OK ) {
return - 1 ;
} else if ( p_blocking ) {
return exitcode ;
} else {
return pid ;
}
}
Error _OS : : kill ( int p_pid ) {
return OS : : get_singleton ( ) - > kill ( p_pid ) ;
}
2022-07-27 14:46:53 +02:00
bool _OS : : is_process_running ( int p_pid ) const {
return OS : : get_singleton ( ) - > is_process_running ( p_pid ) ;
}
2022-03-15 13:29:32 +01:00
int _OS : : get_process_id ( ) const {
return OS : : get_singleton ( ) - > get_process_id ( ) ;
} ;
bool _OS : : has_environment ( const String & p_var ) const {
return OS : : get_singleton ( ) - > has_environment ( p_var ) ;
}
String _OS : : get_environment ( const String & p_var ) const {
return OS : : get_singleton ( ) - > get_environment ( p_var ) ;
}
bool _OS : : set_environment ( const String & p_var , const String & p_value ) const {
return OS : : get_singleton ( ) - > set_environment ( p_var , p_value ) ;
}
String _OS : : get_name ( ) const {
return OS : : get_singleton ( ) - > get_name ( ) ;
}
Vector < String > _OS : : get_cmdline_args ( ) {
List < String > cmdline = OS : : get_singleton ( ) - > get_cmdline_args ( ) ;
Vector < String > cmdlinev ;
for ( List < String > : : Element * E = cmdline . front ( ) ; E ; E = E - > next ( ) ) {
cmdlinev . push_back ( E - > get ( ) ) ;
}
return cmdlinev ;
}
String _OS : : get_locale ( ) const {
return OS : : get_singleton ( ) - > get_locale ( ) ;
}
String _OS : : get_locale_language ( ) const {
return OS : : get_singleton ( ) - > get_locale_language ( ) ;
}
String _OS : : get_latin_keyboard_variant ( ) const {
switch ( OS : : get_singleton ( ) - > get_latin_keyboard_variant ( ) ) {
case OS : : LATIN_KEYBOARD_QWERTY :
return " QWERTY " ;
case OS : : LATIN_KEYBOARD_QWERTZ :
return " QWERTZ " ;
case OS : : LATIN_KEYBOARD_AZERTY :
return " AZERTY " ;
case OS : : LATIN_KEYBOARD_QZERTY :
return " QZERTY " ;
case OS : : LATIN_KEYBOARD_DVORAK :
return " DVORAK " ;
case OS : : LATIN_KEYBOARD_NEO :
return " NEO " ;
case OS : : LATIN_KEYBOARD_COLEMAK :
return " COLEMAK " ;
default :
return " ERROR " ;
}
}
int _OS : : keyboard_get_layout_count ( ) const {
return OS : : get_singleton ( ) - > keyboard_get_layout_count ( ) ;
}
int _OS : : keyboard_get_current_layout ( ) const {
return OS : : get_singleton ( ) - > keyboard_get_current_layout ( ) ;
}
void _OS : : keyboard_set_current_layout ( int p_index ) {
OS : : get_singleton ( ) - > keyboard_set_current_layout ( p_index ) ;
}
String _OS : : keyboard_get_layout_language ( int p_index ) const {
return OS : : get_singleton ( ) - > keyboard_get_layout_language ( p_index ) ;
}
String _OS : : keyboard_get_layout_name ( int p_index ) const {
return OS : : get_singleton ( ) - > keyboard_get_layout_name ( p_index ) ;
}
uint32_t _OS : : keyboard_get_scancode_from_physical ( uint32_t p_scancode ) const {
return OS : : get_singleton ( ) - > keyboard_get_scancode_from_physical ( p_scancode ) ;
}
String _OS : : get_model_name ( ) const {
return OS : : get_singleton ( ) - > get_model_name ( ) ;
}
bool _OS : : is_ok_left_and_cancel_right ( ) const {
return OS : : get_singleton ( ) - > get_swap_ok_cancel ( ) ;
}
Error _OS : : set_thread_name ( const String & p_name ) {
return Thread : : set_name ( p_name ) ;
} ;
void _OS : : set_use_vsync ( bool p_enable ) {
OS : : get_singleton ( ) - > set_use_vsync ( p_enable ) ;
}
bool _OS : : is_vsync_enabled ( ) const {
return OS : : get_singleton ( ) - > is_vsync_enabled ( ) ;
}
void _OS : : set_vsync_via_compositor ( bool p_enable ) {
OS : : get_singleton ( ) - > set_vsync_via_compositor ( p_enable ) ;
}
bool _OS : : is_vsync_via_compositor_enabled ( ) const {
return OS : : get_singleton ( ) - > is_vsync_via_compositor_enabled ( ) ;
}
void _OS : : set_delta_smoothing ( bool p_enabled ) {
OS : : get_singleton ( ) - > set_delta_smoothing ( p_enabled ) ;
}
bool _OS : : is_delta_smoothing_enabled ( ) const {
return OS : : get_singleton ( ) - > is_delta_smoothing_enabled ( ) ;
}
_OS : : PowerState _OS : : get_power_state ( ) {
return _OS : : PowerState ( OS : : get_singleton ( ) - > get_power_state ( ) ) ;
}
int _OS : : get_power_seconds_left ( ) {
return OS : : get_singleton ( ) - > get_power_seconds_left ( ) ;
}
int _OS : : get_power_percent_left ( ) {
return OS : : get_singleton ( ) - > get_power_percent_left ( ) ;
}
Thread : : ID _OS : : get_thread_caller_id ( ) const {
return Thread : : get_caller_id ( ) ;
} ;
Thread : : ID _OS : : get_main_thread_id ( ) const {
return Thread : : get_main_id ( ) ;
} ;
bool _OS : : has_feature ( const String & p_feature ) const {
return OS : : get_singleton ( ) - > has_feature ( p_feature ) ;
}
/*
enum Weekday {
DAY_SUNDAY ,
DAY_MONDAY ,
DAY_TUESDAY ,
DAY_WEDNESDAY ,
DAY_THURSDAY ,
DAY_FRIDAY ,
DAY_SATURDAY
} ;
enum Month {
MONTH_JANUARY ,
MONTH_FEBRUARY ,
MONTH_MARCH ,
MONTH_APRIL ,
MONTH_MAY ,
MONTH_JUNE ,
MONTH_JULY ,
MONTH_AUGUST ,
MONTH_SEPTEMBER ,
MONTH_OCTOBER ,
MONTH_NOVEMBER ,
MONTH_DECEMBER
} ;
*/
/*
struct Date {
int year ;
Month month ;
int day ;
Weekday weekday ;
bool dst ;
} ;
struct Time {
int hour ;
int min ;
int sec ;
} ;
*/
uint64_t _OS : : get_static_memory_usage ( ) const {
return OS : : get_singleton ( ) - > get_static_memory_usage ( ) ;
}
uint64_t _OS : : get_static_memory_peak_usage ( ) const {
return OS : : get_singleton ( ) - > get_static_memory_peak_usage ( ) ;
}
uint64_t _OS : : get_dynamic_memory_usage ( ) const {
return OS : : get_singleton ( ) - > get_dynamic_memory_usage ( ) ;
}
void _OS : : set_native_icon ( const String & p_filename ) {
OS : : get_singleton ( ) - > set_native_icon ( p_filename ) ;
}
void _OS : : set_icon ( const Ref < Image > & p_icon ) {
OS : : get_singleton ( ) - > set_icon ( p_icon ) ;
}
int _OS : : get_exit_code ( ) const {
return OS : : get_singleton ( ) - > get_exit_code ( ) ;
}
void _OS : : set_exit_code ( int p_code ) {
if ( p_code < 0 | | p_code > 125 ) {
WARN_PRINT ( " For portability reasons, the exit code should be set between 0 and 125 (inclusive). " ) ;
}
OS : : get_singleton ( ) - > set_exit_code ( p_code ) ;
}
/**
* Get current datetime with consideration for utc and
* dst
*/
Dictionary _OS : : get_datetime ( bool utc ) const {
Dictionary dated = get_date ( utc ) ;
Dictionary timed = get_time ( utc ) ;
List < Variant > keys ;
timed . get_key_list ( & keys ) ;
for ( int i = 0 ; i < keys . size ( ) ; i + + ) {
dated [ keys [ i ] ] = timed [ keys [ i ] ] ;
}
return dated ;
}
Dictionary _OS : : get_date ( bool utc ) const {
OS : : Date date = OS : : get_singleton ( ) - > get_date ( utc ) ;
Dictionary dated ;
dated [ YEAR_KEY ] = date . year ;
dated [ MONTH_KEY ] = date . month ;
dated [ DAY_KEY ] = date . day ;
dated [ WEEKDAY_KEY ] = date . weekday ;
dated [ DST_KEY ] = date . dst ;
return dated ;
}
Dictionary _OS : : get_time ( bool utc ) const {
OS : : Time time = OS : : get_singleton ( ) - > get_time ( utc ) ;
Dictionary timed ;
timed [ HOUR_KEY ] = time . hour ;
timed [ MINUTE_KEY ] = time . min ;
timed [ SECOND_KEY ] = time . sec ;
return timed ;
}
/**
* Get an epoch time value from a dictionary of time values
* @ p datetime must be populated with the following keys :
* day , hour , minute , month , second , year . ( dst is ignored ) .
*
* You can pass the output from
* get_datetime_from_unix_time directly into this function
*
* @ param datetime dictionary of date and time values to convert
*
* @ return epoch calculated
*/
int64_t _OS : : get_unix_time_from_datetime ( Dictionary datetime ) const {
// if datetime is an empty Dictionary throws an error
ERR_FAIL_COND_V_MSG ( datetime . empty ( ) , 0 , " Invalid datetime Dictionary: Dictionary is empty " ) ;
// Bunch of conversion constants
static const unsigned int SECONDS_PER_MINUTE = 60 ;
static const unsigned int MINUTES_PER_HOUR = 60 ;
static const unsigned int HOURS_PER_DAY = 24 ;
static const unsigned int SECONDS_PER_HOUR = MINUTES_PER_HOUR * SECONDS_PER_MINUTE ;
static const unsigned int SECONDS_PER_DAY = SECONDS_PER_HOUR * HOURS_PER_DAY ;
// Get all time values from the dictionary, set to zero if it doesn't exist.
// Risk incorrect calculation over throwing errors
unsigned int second = ( ( datetime . has ( SECOND_KEY ) ) ? static_cast < unsigned int > ( datetime [ SECOND_KEY ] ) : 0 ) ;
unsigned int minute = ( ( datetime . has ( MINUTE_KEY ) ) ? static_cast < unsigned int > ( datetime [ MINUTE_KEY ] ) : 0 ) ;
unsigned int hour = ( ( datetime . has ( HOUR_KEY ) ) ? static_cast < unsigned int > ( datetime [ HOUR_KEY ] ) : 0 ) ;
unsigned int day = ( ( datetime . has ( DAY_KEY ) ) ? static_cast < unsigned int > ( datetime [ DAY_KEY ] ) : 1 ) ;
unsigned int month = ( ( datetime . has ( MONTH_KEY ) ) ? static_cast < unsigned int > ( datetime [ MONTH_KEY ] ) : 1 ) ;
unsigned int year = ( ( datetime . has ( YEAR_KEY ) ) ? static_cast < unsigned int > ( datetime [ YEAR_KEY ] ) : 1970 ) ;
/// How many days come before each month (0-12)
static const unsigned short int DAYS_PAST_THIS_YEAR_TABLE [ 2 ] [ 13 ] = {
/* Normal years. */
{ 0 , 31 , 59 , 90 , 120 , 151 , 181 , 212 , 243 , 273 , 304 , 334 , 365 } ,
/* Leap years. */
{ 0 , 31 , 60 , 91 , 121 , 152 , 182 , 213 , 244 , 274 , 305 , 335 , 366 }
} ;
ERR_FAIL_COND_V_MSG ( second > 59 , 0 , " Invalid second value of: " + itos ( second ) + " . " ) ;
ERR_FAIL_COND_V_MSG ( minute > 59 , 0 , " Invalid minute value of: " + itos ( minute ) + " . " ) ;
ERR_FAIL_COND_V_MSG ( hour > 23 , 0 , " Invalid hour value of: " + itos ( hour ) + " . " ) ;
ERR_FAIL_COND_V_MSG ( year = = 0 , 0 , " Years before 1 AD are not supported. Value passed: " + itos ( year ) + " . " ) ;
ERR_FAIL_COND_V_MSG ( month > 12 | | month = = 0 , 0 , " Invalid month value of: " + itos ( month ) + " . " ) ;
// Do this check after month is tested as valid
unsigned int days_in_month = MONTH_DAYS_TABLE [ LEAPYEAR ( year ) ] [ month - 1 ] ;
ERR_FAIL_COND_V_MSG ( day = = 0 | | day > days_in_month , 0 , " Invalid day value of: " + itos ( day ) + " . It should be comprised between 1 and " + itos ( days_in_month ) + " for month " + itos ( month ) + " . " ) ;
// Calculate all the seconds from months past in this year
uint64_t SECONDS_FROM_MONTHS_PAST_THIS_YEAR = DAYS_PAST_THIS_YEAR_TABLE [ LEAPYEAR ( year ) ] [ month - 1 ] * SECONDS_PER_DAY ;
int64_t SECONDS_FROM_YEARS_PAST = 0 ;
if ( year > = EPOCH_YR ) {
for ( unsigned int iyear = EPOCH_YR ; iyear < year ; iyear + + ) {
SECONDS_FROM_YEARS_PAST + = YEARSIZE ( iyear ) * SECONDS_PER_DAY ;
}
} else {
for ( unsigned int iyear = EPOCH_YR - 1 ; iyear > = year ; iyear - - ) {
SECONDS_FROM_YEARS_PAST - = YEARSIZE ( iyear ) * SECONDS_PER_DAY ;
}
}
int64_t epoch =
second +
minute * SECONDS_PER_MINUTE +
hour * SECONDS_PER_HOUR +
// Subtract 1 from day, since the current day isn't over yet
// and we cannot count all 24 hours.
( day - 1 ) * SECONDS_PER_DAY +
SECONDS_FROM_MONTHS_PAST_THIS_YEAR +
SECONDS_FROM_YEARS_PAST ;
return epoch ;
}
/**
* Get a dictionary of time values when given epoch time
*
* Dictionary Time values will be a union if values from # get_time
* and # get_date dictionaries ( with the exception of dst =
* day light standard time , as it cannot be determined from epoch )
*
* @ param unix_time_val epoch time to convert
*
* @ return dictionary of date and time values
*/
Dictionary _OS : : get_datetime_from_unix_time ( int64_t unix_time_val ) const {
OS : : Date date ;
OS : : Time time ;
long dayclock , dayno ;
int year = EPOCH_YR ;
if ( unix_time_val > = 0 ) {
dayno = unix_time_val / SECS_DAY ;
dayclock = unix_time_val % SECS_DAY ;
/* day 0 was a thursday */
date . weekday = static_cast < OS : : Weekday > ( ( dayno + 4 ) % 7 ) ;
while ( dayno > = YEARSIZE ( year ) ) {
dayno - = YEARSIZE ( year ) ;
year + + ;
}
} else {
dayno = ( unix_time_val - SECS_DAY + 1 ) / SECS_DAY ;
dayclock = unix_time_val - dayno * SECS_DAY ;
date . weekday = static_cast < OS : : Weekday > ( ( ( dayno % 7 ) + 11 ) % 7 ) ;
do {
year - - ;
dayno + = YEARSIZE ( year ) ;
} while ( dayno < 0 ) ;
}
time . sec = dayclock % 60 ;
time . min = ( dayclock % 3600 ) / 60 ;
time . hour = dayclock / 3600 ;
date . year = year ;
size_t imonth = 0 ;
while ( ( unsigned long ) dayno > = MONTH_DAYS_TABLE [ LEAPYEAR ( year ) ] [ imonth ] ) {
dayno - = MONTH_DAYS_TABLE [ LEAPYEAR ( year ) ] [ imonth ] ;
imonth + + ;
}
/// Add 1 to month to make sure months are indexed starting at 1
date . month = static_cast < OS : : Month > ( imonth + 1 ) ;
date . day = dayno + 1 ;
Dictionary timed ;
timed [ HOUR_KEY ] = time . hour ;
timed [ MINUTE_KEY ] = time . min ;
timed [ SECOND_KEY ] = time . sec ;
timed [ YEAR_KEY ] = date . year ;
timed [ MONTH_KEY ] = date . month ;
timed [ DAY_KEY ] = date . day ;
timed [ WEEKDAY_KEY ] = date . weekday ;
return timed ;
}
Dictionary _OS : : get_time_zone_info ( ) const {
OS : : TimeZoneInfo info = OS : : get_singleton ( ) - > get_time_zone_info ( ) ;
Dictionary infod ;
infod [ " bias " ] = info . bias ;
infod [ " name " ] = info . name ;
return infod ;
}
uint64_t _OS : : get_unix_time ( ) const {
return OS : : get_singleton ( ) - > get_unix_time ( ) ;
}
uint64_t _OS : : get_system_time_secs ( ) const {
return OS : : get_singleton ( ) - > get_system_time_secs ( ) ;
}
uint64_t _OS : : get_system_time_msecs ( ) const {
return OS : : get_singleton ( ) - > get_system_time_msecs ( ) ;
}
/** This method uses a signed argument for better error reporting as it's used from the scripting API. */
void _OS : : delay_usec ( int p_usec ) const {
ERR_FAIL_COND_MSG (
p_usec < 0 ,
vformat ( " Can't sleep for %d microseconds. The delay provided must be greater than or equal to 0 microseconds. " , p_usec ) ) ;
OS : : get_singleton ( ) - > delay_usec ( p_usec ) ;
}
/** This method uses a signed argument for better error reporting as it's used from the scripting API. */
void _OS : : delay_msec ( int p_msec ) const {
ERR_FAIL_COND_MSG (
p_msec < 0 ,
vformat ( " Can't sleep for %d milliseconds. The delay provided must be greater than or equal to 0 milliseconds. " , p_msec ) ) ;
OS : : get_singleton ( ) - > delay_usec ( int64_t ( p_msec ) * 1000 ) ;
}
uint64_t _OS : : get_ticks_msec ( ) const {
return OS : : get_singleton ( ) - > get_ticks_msec ( ) ;
}
uint64_t _OS : : get_ticks_usec ( ) const {
return OS : : get_singleton ( ) - > get_ticks_usec ( ) ;
}
uint32_t _OS : : get_splash_tick_msec ( ) const {
return OS : : get_singleton ( ) - > get_splash_tick_msec ( ) ;
}
bool _OS : : can_use_threads ( ) const {
return OS : : get_singleton ( ) - > can_use_threads ( ) ;
}
bool _OS : : can_draw ( ) const {
return OS : : get_singleton ( ) - > can_draw ( ) ;
}
bool _OS : : is_userfs_persistent ( ) const {
return OS : : get_singleton ( ) - > is_userfs_persistent ( ) ;
}
int _OS : : get_processor_count ( ) const {
return OS : : get_singleton ( ) - > get_processor_count ( ) ;
}
String _OS : : get_processor_name ( ) const {
return OS : : get_singleton ( ) - > get_processor_name ( ) ;
}
bool _OS : : is_stdout_verbose ( ) const {
return OS : : get_singleton ( ) - > is_stdout_verbose ( ) ;
}
void _OS : : dump_memory_to_file ( const String & p_file ) {
OS : : get_singleton ( ) - > dump_memory_to_file ( p_file . utf8 ( ) . get_data ( ) ) ;
}
struct _OSCoreBindImg {
String path ;
Size2 size ;
int fmt ;
ObjectID id ;
int vram ;
bool operator < ( const _OSCoreBindImg & p_img ) const { return vram = = p_img . vram ? id < p_img . id : vram > p_img . vram ; }
} ;
void _OS : : print_all_textures_by_size ( ) {
List < _OSCoreBindImg > imgs ;
uint64_t total = 0 ;
{
List < Ref < Resource > > rsrc ;
ResourceCache : : get_cached_resources ( & rsrc ) ;
for ( List < Ref < Resource > > : : Element * E = rsrc . front ( ) ; E ; E = E - > next ( ) ) {
if ( ! E - > get ( ) - > is_class ( " Texture " ) ) {
continue ;
}
Size2 size = E - > get ( ) - > call ( " get_size " ) ;
int fmt = E - > get ( ) - > call ( " get_format " ) ;
_OSCoreBindImg img ;
img . size = size ;
img . fmt = fmt ;
img . path = E - > get ( ) - > get_path ( ) ;
img . vram = Image : : get_image_data_size ( img . size . width , img . size . height , Image : : Format ( img . fmt ) ) ;
img . id = E - > get ( ) - > get_instance_id ( ) ;
total + = img . vram ;
imgs . push_back ( img ) ;
}
}
imgs . sort ( ) ;
if ( imgs . size ( ) = = 0 ) {
print_line ( " No textures seem used in this project. " ) ;
} else {
print_line ( " Textures currently in use, sorted by VRAM usage: \n "
" Path - VRAM usage (Dimensions) " ) ;
}
for ( List < _OSCoreBindImg > : : Element * E = imgs . front ( ) ; E ; E = E - > next ( ) ) {
print_line ( vformat ( " %s - %s %s " ,
E - > get ( ) . path ,
String : : humanize_size ( E - > get ( ) . vram ) ,
E - > get ( ) . size ) ) ;
}
print_line ( vformat ( " Total VRAM usage: %s. " , String : : humanize_size ( total ) ) ) ;
}
void _OS : : print_resources_by_type ( const Vector < String > & p_types ) {
ERR_FAIL_COND_MSG ( p_types . size ( ) = = 0 ,
" At least one type should be provided to print resources by type. " ) ;
print_line ( vformat ( " Resources currently in use for the following types: %s " , p_types ) ) ;
Map < String , int > type_count ;
List < Ref < Resource > > resources ;
ResourceCache : : get_cached_resources ( & resources ) ;
for ( List < Ref < Resource > > : : Element * E = resources . front ( ) ; E ; E = E - > next ( ) ) {
Ref < Resource > r = E - > get ( ) ;
bool found = false ;
for ( int i = 0 ; i < p_types . size ( ) ; i + + ) {
if ( r - > is_class ( p_types [ i ] ) ) {
found = true ;
}
}
if ( ! found ) {
continue ;
}
if ( ! type_count . has ( r - > get_class ( ) ) ) {
type_count [ r - > get_class ( ) ] = 0 ;
}
type_count [ r - > get_class ( ) ] + + ;
print_line ( vformat ( " %s: %s " , r - > get_class ( ) , r - > get_path ( ) ) ) ;
List < String > metas ;
r - > get_meta_list ( & metas ) ;
for ( List < String > : : Element * F = metas . front ( ) ; F ; F = F - > next ( ) ) {
print_line ( vformat ( " %s: %s " , F - > get ( ) , r - > get_meta ( F - > get ( ) ) ) ) ;
}
}
for ( Map < String , int > : : Element * E = type_count . front ( ) ; E ; E = E - > next ( ) ) {
print_line ( vformat ( " %s count: %d " , E - > key ( ) , E - > get ( ) ) ) ;
}
}
bool _OS : : has_virtual_keyboard ( ) const {
return OS : : get_singleton ( ) - > has_virtual_keyboard ( ) ;
}
2022-08-19 16:18:53 +02:00
void _OS : : show_virtual_keyboard ( const String & p_existing_text , _OS : : VirtualKeyboardType p_type ) {
OS : : get_singleton ( ) - > show_virtual_keyboard ( p_existing_text , Rect2 ( ) , OS : : VirtualKeyboardType ( p_type ) ) ;
2022-03-15 13:29:32 +01:00
}
void _OS : : hide_virtual_keyboard ( ) {
OS : : get_singleton ( ) - > hide_virtual_keyboard ( ) ;
}
int _OS : : get_virtual_keyboard_height ( ) {
return OS : : get_singleton ( ) - > get_virtual_keyboard_height ( ) ;
}
void _OS : : print_all_resources ( const String & p_to_file ) {
OS : : get_singleton ( ) - > print_all_resources ( p_to_file ) ;
}
void _OS : : print_resources_in_use ( bool p_short ) {
OS : : get_singleton ( ) - > print_resources_in_use ( p_short ) ;
}
void _OS : : dump_resources_to_file ( const String & p_file ) {
OS : : get_singleton ( ) - > dump_resources_to_file ( p_file . utf8 ( ) . get_data ( ) ) ;
}
2022-04-26 23:52:20 +02:00
Error _OS : : move_to_trash ( const String & p_path ) const {
return OS : : get_singleton ( ) - > move_to_trash ( p_path ) ;
}
2022-03-15 13:29:32 +01:00
String _OS : : get_user_data_dir ( ) const {
return OS : : get_singleton ( ) - > get_user_data_dir ( ) ;
} ;
Error _OS : : native_video_play ( String p_path , float p_volume , String p_audio_track , String p_subtitle_track ) {
return OS : : get_singleton ( ) - > native_video_play ( p_path , p_volume , p_audio_track , p_subtitle_track ) ;
} ;
bool _OS : : native_video_is_playing ( ) {
return OS : : get_singleton ( ) - > native_video_is_playing ( ) ;
} ;
void _OS : : native_video_pause ( ) {
OS : : get_singleton ( ) - > native_video_pause ( ) ;
} ;
void _OS : : native_video_unpause ( ) {
OS : : get_singleton ( ) - > native_video_unpause ( ) ;
} ;
void _OS : : native_video_stop ( ) {
OS : : get_singleton ( ) - > native_video_stop ( ) ;
} ;
void _OS : : request_attention ( ) {
OS : : get_singleton ( ) - > request_attention ( ) ;
}
void _OS : : center_window ( ) {
OS : : get_singleton ( ) - > center_window ( ) ;
}
void _OS : : move_window_to_foreground ( ) {
OS : : get_singleton ( ) - > move_window_to_foreground ( ) ;
}
int64_t _OS : : get_native_handle ( HandleType p_handle_type ) {
return ( int64_t ) OS : : get_singleton ( ) - > get_native_handle ( p_handle_type ) ;
}
String _OS : : get_config_dir ( ) const {
// Exposed as `get_config_dir()` instead of `get_config_path()` for consistency with other exposed OS methods.
return OS : : get_singleton ( ) - > get_config_path ( ) ;
}
String _OS : : get_data_dir ( ) const {
// Exposed as `get_data_dir()` instead of `get_data_path()` for consistency with other exposed OS methods.
return OS : : get_singleton ( ) - > get_data_path ( ) ;
}
String _OS : : get_cache_dir ( ) const {
// Exposed as `get_cache_dir()` instead of `get_cache_path()` for consistency with other exposed OS methods.
return OS : : get_singleton ( ) - > get_cache_path ( ) ;
}
bool _OS : : is_debug_build ( ) const {
# ifdef DEBUG_ENABLED
return true ;
# else
return false ;
# endif
}
void _OS : : set_screen_orientation ( ScreenOrientation p_orientation ) {
OS : : get_singleton ( ) - > set_screen_orientation ( OS : : ScreenOrientation ( p_orientation ) ) ;
}
_OS : : ScreenOrientation _OS : : get_screen_orientation ( ) const {
return ScreenOrientation ( OS : : get_singleton ( ) - > get_screen_orientation ( ) ) ;
}
void _OS : : set_keep_screen_on ( bool p_enabled ) {
OS : : get_singleton ( ) - > set_keep_screen_on ( p_enabled ) ;
}
bool _OS : : is_keep_screen_on ( ) const {
return OS : : get_singleton ( ) - > is_keep_screen_on ( ) ;
}
String _OS : : get_system_dir ( SystemDir p_dir , bool p_shared_storage ) const {
return OS : : get_singleton ( ) - > get_system_dir ( OS : : SystemDir ( p_dir ) , p_shared_storage ) ;
}
String _OS : : get_scancode_string ( uint32_t p_code ) const {
return keycode_get_string ( p_code ) ;
}
bool _OS : : is_scancode_unicode ( uint32_t p_unicode ) const {
return keycode_has_unicode ( p_unicode ) ;
}
int _OS : : find_scancode_from_string ( const String & p_code ) const {
return find_keycode ( p_code ) ;
}
void _OS : : alert ( const String & p_alert , const String & p_title ) {
OS : : get_singleton ( ) - > alert ( p_alert , p_title ) ;
}
void _OS : : crash ( const String & p_message ) {
CRASH_NOW_MSG ( p_message ) ;
}
bool _OS : : request_permission ( const String & p_name ) {
return OS : : get_singleton ( ) - > request_permission ( p_name ) ;
}
bool _OS : : request_permissions ( ) {
return OS : : get_singleton ( ) - > request_permissions ( ) ;
}
Vector < String > _OS : : get_granted_permissions ( ) const {
return OS : : get_singleton ( ) - > get_granted_permissions ( ) ;
}
int _OS : : get_tablet_driver_count ( ) const {
return OS : : get_singleton ( ) - > get_tablet_driver_count ( ) ;
}
String _OS : : get_tablet_driver_name ( int p_driver ) const {
return OS : : get_singleton ( ) - > get_tablet_driver_name ( p_driver ) ;
}
String _OS : : get_current_tablet_driver ( ) const {
return OS : : get_singleton ( ) - > get_current_tablet_driver ( ) ;
}
void _OS : : set_current_tablet_driver ( const String & p_driver ) {
OS : : get_singleton ( ) - > set_current_tablet_driver ( p_driver ) ;
}
_OS * _OS : : singleton = nullptr ;
void _OS : : _bind_methods ( ) {
//ClassDB::bind_method(D_METHOD("get_mouse_position"),&_OS::get_mouse_position);
//ClassDB::bind_method(D_METHOD("is_mouse_grab_enabled"),&_OS::is_mouse_grab_enabled);
ClassDB : : bind_method ( D_METHOD ( " set_clipboard " , " clipboard " ) , & _OS : : set_clipboard ) ;
ClassDB : : bind_method ( D_METHOD ( " get_clipboard " ) , & _OS : : get_clipboard ) ;
ClassDB : : bind_method ( D_METHOD ( " has_clipboard " ) , & _OS : : has_clipboard ) ;
//will not delete for now, just unexpose
//ClassDB::bind_method(D_METHOD("set_video_mode","size","fullscreen","resizable","screen"),&_OS::set_video_mode,DEFVAL(0));
//ClassDB::bind_method(D_METHOD("get_video_mode_size","screen"),&_OS::get_video_mode,DEFVAL(0));
//ClassDB::bind_method(D_METHOD("is_video_mode_fullscreen","screen"),&_OS::is_video_mode_fullscreen,DEFVAL(0));
//ClassDB::bind_method(D_METHOD("is_video_mode_resizable","screen"),&_OS::is_video_mode_resizable,DEFVAL(0));
//ClassDB::bind_method(D_METHOD("get_fullscreen_mode_list","screen"),&_OS::get_fullscreen_mode_list,DEFVAL(0));
ClassDB : : bind_method ( D_METHOD ( " global_menu_add_item " , " menu " , " label " , " id " , " meta " ) , & _OS : : global_menu_add_item ) ;
ClassDB : : bind_method ( D_METHOD ( " global_menu_add_separator " , " menu " ) , & _OS : : global_menu_add_separator ) ;
ClassDB : : bind_method ( D_METHOD ( " global_menu_remove_item " , " menu " , " idx " ) , & _OS : : global_menu_remove_item ) ;
ClassDB : : bind_method ( D_METHOD ( " global_menu_clear " , " menu " ) , & _OS : : global_menu_clear ) ;
ClassDB : : bind_method ( D_METHOD ( " get_video_driver_count " ) , & _OS : : get_video_driver_count ) ;
ClassDB : : bind_method ( D_METHOD ( " get_video_driver_name " , " driver " ) , & _OS : : get_video_driver_name ) ;
ClassDB : : bind_method ( D_METHOD ( " get_current_video_driver " ) , & _OS : : get_current_video_driver ) ;
ClassDB : : bind_method ( D_METHOD ( " get_audio_driver_count " ) , & _OS : : get_audio_driver_count ) ;
ClassDB : : bind_method ( D_METHOD ( " get_audio_driver_name " , " driver " ) , & _OS : : get_audio_driver_name ) ;
ClassDB : : bind_method ( D_METHOD ( " get_connected_midi_inputs " ) , & _OS : : get_connected_midi_inputs ) ;
ClassDB : : bind_method ( D_METHOD ( " open_midi_inputs " ) , & _OS : : open_midi_inputs ) ;
ClassDB : : bind_method ( D_METHOD ( " close_midi_inputs " ) , & _OS : : close_midi_inputs ) ;
ClassDB : : bind_method ( D_METHOD ( " get_screen_count " ) , & _OS : : get_screen_count ) ;
ClassDB : : bind_method ( D_METHOD ( " get_current_screen " ) , & _OS : : get_current_screen ) ;
ClassDB : : bind_method ( D_METHOD ( " set_current_screen " , " screen " ) , & _OS : : set_current_screen ) ;
ClassDB : : bind_method ( D_METHOD ( " get_screen_position " , " screen " ) , & _OS : : get_screen_position , DEFVAL ( - 1 ) ) ;
ClassDB : : bind_method ( D_METHOD ( " get_screen_size " , " screen " ) , & _OS : : get_screen_size , DEFVAL ( - 1 ) ) ;
ClassDB : : bind_method ( D_METHOD ( " get_screen_dpi " , " screen " ) , & _OS : : get_screen_dpi , DEFVAL ( - 1 ) ) ;
ClassDB : : bind_method ( D_METHOD ( " get_screen_scale " , " screen " ) , & _OS : : get_screen_scale , DEFVAL ( - 1 ) ) ;
ClassDB : : bind_method ( D_METHOD ( " get_screen_max_scale " ) , & _OS : : get_screen_max_scale ) ;
ClassDB : : bind_method ( D_METHOD ( " get_screen_refresh_rate " , " screen " ) , & _OS : : get_screen_refresh_rate , DEFVAL ( - 1 ) ) ;
ClassDB : : bind_method ( D_METHOD ( " get_window_position " ) , & _OS : : get_window_position ) ;
ClassDB : : bind_method ( D_METHOD ( " set_window_position " , " position " ) , & _OS : : set_window_position ) ;
ClassDB : : bind_method ( D_METHOD ( " get_window_size " ) , & _OS : : get_window_size ) ;
ClassDB : : bind_method ( D_METHOD ( " get_max_window_size " ) , & _OS : : get_max_window_size ) ;
ClassDB : : bind_method ( D_METHOD ( " get_min_window_size " ) , & _OS : : get_min_window_size ) ;
ClassDB : : bind_method ( D_METHOD ( " set_max_window_size " , " size " ) , & _OS : : set_max_window_size ) ;
ClassDB : : bind_method ( D_METHOD ( " set_min_window_size " , " size " ) , & _OS : : set_min_window_size ) ;
ClassDB : : bind_method ( D_METHOD ( " set_window_size " , " size " ) , & _OS : : set_window_size ) ;
ClassDB : : bind_method ( D_METHOD ( " get_window_safe_area " ) , & _OS : : get_window_safe_area ) ;
2022-07-27 00:21:20 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_display_cutouts " ) , & _OS : : get_display_cutouts ) ;
2022-03-15 13:29:32 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_window_fullscreen " , " enabled " ) , & _OS : : set_window_fullscreen ) ;
ClassDB : : bind_method ( D_METHOD ( " is_window_fullscreen " ) , & _OS : : is_window_fullscreen ) ;
ClassDB : : bind_method ( D_METHOD ( " set_window_resizable " , " enabled " ) , & _OS : : set_window_resizable ) ;
ClassDB : : bind_method ( D_METHOD ( " is_window_resizable " ) , & _OS : : is_window_resizable ) ;
ClassDB : : bind_method ( D_METHOD ( " set_window_minimized " , " enabled " ) , & _OS : : set_window_minimized ) ;
ClassDB : : bind_method ( D_METHOD ( " is_window_minimized " ) , & _OS : : is_window_minimized ) ;
ClassDB : : bind_method ( D_METHOD ( " set_window_maximized " , " enabled " ) , & _OS : : set_window_maximized ) ;
ClassDB : : bind_method ( D_METHOD ( " is_window_maximized " ) , & _OS : : is_window_maximized ) ;
ClassDB : : bind_method ( D_METHOD ( " set_window_always_on_top " , " enabled " ) , & _OS : : set_window_always_on_top ) ;
ClassDB : : bind_method ( D_METHOD ( " is_window_always_on_top " ) , & _OS : : is_window_always_on_top ) ;
ClassDB : : bind_method ( D_METHOD ( " is_window_focused " ) , & _OS : : is_window_focused ) ;
ClassDB : : bind_method ( D_METHOD ( " request_attention " ) , & _OS : : request_attention ) ;
ClassDB : : bind_method ( D_METHOD ( " get_real_window_size " ) , & _OS : : get_real_window_size ) ;
ClassDB : : bind_method ( D_METHOD ( " center_window " ) , & _OS : : center_window ) ;
ClassDB : : bind_method ( D_METHOD ( " move_window_to_foreground " ) , & _OS : : move_window_to_foreground ) ;
ClassDB : : bind_method ( D_METHOD ( " get_native_handle " , " handle_type " ) , & _OS : : get_native_handle ) ;
ClassDB : : bind_method ( D_METHOD ( " set_borderless_window " , " borderless " ) , & _OS : : set_borderless_window ) ;
ClassDB : : bind_method ( D_METHOD ( " get_borderless_window " ) , & _OS : : get_borderless_window ) ;
ClassDB : : bind_method ( D_METHOD ( " get_window_per_pixel_transparency_enabled " ) , & _OS : : get_window_per_pixel_transparency_enabled ) ;
ClassDB : : bind_method ( D_METHOD ( " set_window_per_pixel_transparency_enabled " , " enabled " ) , & _OS : : set_window_per_pixel_transparency_enabled ) ;
ClassDB : : bind_method ( D_METHOD ( " set_ime_active " , " active " ) , & _OS : : set_ime_active ) ;
ClassDB : : bind_method ( D_METHOD ( " set_ime_position " , " position " ) , & _OS : : set_ime_position ) ;
ClassDB : : bind_method ( D_METHOD ( " get_ime_selection " ) , & _OS : : get_ime_selection ) ;
ClassDB : : bind_method ( D_METHOD ( " get_ime_text " ) , & _OS : : get_ime_text ) ;
ClassDB : : bind_method ( D_METHOD ( " set_screen_orientation " , " orientation " ) , & _OS : : set_screen_orientation ) ;
ClassDB : : bind_method ( D_METHOD ( " get_screen_orientation " ) , & _OS : : get_screen_orientation ) ;
ClassDB : : bind_method ( D_METHOD ( " set_keep_screen_on " , " enabled " ) , & _OS : : set_keep_screen_on ) ;
ClassDB : : bind_method ( D_METHOD ( " is_keep_screen_on " ) , & _OS : : is_keep_screen_on ) ;
ClassDB : : bind_method ( D_METHOD ( " has_touchscreen_ui_hint " ) , & _OS : : has_touchscreen_ui_hint ) ;
ClassDB : : bind_method ( D_METHOD ( " set_window_title " , " title " ) , & _OS : : set_window_title ) ;
ClassDB : : bind_method ( D_METHOD ( " set_window_mouse_passthrough " , " region " ) , & _OS : : set_window_mouse_passthrough ) ;
ClassDB : : bind_method ( D_METHOD ( " set_low_processor_usage_mode " , " enable " ) , & _OS : : set_low_processor_usage_mode ) ;
ClassDB : : bind_method ( D_METHOD ( " is_in_low_processor_usage_mode " ) , & _OS : : is_in_low_processor_usage_mode ) ;
ClassDB : : bind_method ( D_METHOD ( " set_low_processor_usage_mode_sleep_usec " , " usec " ) , & _OS : : set_low_processor_usage_mode_sleep_usec ) ;
ClassDB : : bind_method ( D_METHOD ( " get_low_processor_usage_mode_sleep_usec " ) , & _OS : : get_low_processor_usage_mode_sleep_usec ) ;
ClassDB : : bind_method ( D_METHOD ( " get_processor_count " ) , & _OS : : get_processor_count ) ;
ClassDB : : bind_method ( D_METHOD ( " get_processor_name " ) , & _OS : : get_processor_name ) ;
ClassDB : : bind_method ( D_METHOD ( " get_executable_path " ) , & _OS : : get_executable_path ) ;
ClassDB : : bind_method ( D_METHOD ( " execute " , " path " , " arguments " , " blocking " , " output " , " read_stderr " , " open_console " ) , & _OS : : execute , DEFVAL ( true ) , DEFVAL ( Array ( ) ) , DEFVAL ( false ) , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " kill " , " pid " ) , & _OS : : kill ) ;
ClassDB : : bind_method ( D_METHOD ( " shell_open " , " uri " ) , & _OS : : shell_open ) ;
2022-07-27 14:46:53 +02:00
ClassDB : : bind_method ( D_METHOD ( " is_process_running " , " pid " ) , & _OS : : is_process_running ) ;
2022-03-15 13:29:32 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_process_id " ) , & _OS : : get_process_id ) ;
ClassDB : : bind_method ( D_METHOD ( " get_environment " , " variable " ) , & _OS : : get_environment ) ;
ClassDB : : bind_method ( D_METHOD ( " set_environment " , " variable " , " value " ) , & _OS : : set_environment ) ;
ClassDB : : bind_method ( D_METHOD ( " has_environment " , " variable " ) , & _OS : : has_environment ) ;
ClassDB : : bind_method ( D_METHOD ( " get_name " ) , & _OS : : get_name ) ;
ClassDB : : bind_method ( D_METHOD ( " get_cmdline_args " ) , & _OS : : get_cmdline_args ) ;
ClassDB : : bind_method ( D_METHOD ( " get_datetime " , " utc " ) , & _OS : : get_datetime , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " get_date " , " utc " ) , & _OS : : get_date , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " get_time " , " utc " ) , & _OS : : get_time , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " get_time_zone_info " ) , & _OS : : get_time_zone_info ) ;
ClassDB : : bind_method ( D_METHOD ( " get_unix_time " ) , & _OS : : get_unix_time ) ;
ClassDB : : bind_method ( D_METHOD ( " get_datetime_from_unix_time " , " unix_time_val " ) , & _OS : : get_datetime_from_unix_time ) ;
ClassDB : : bind_method ( D_METHOD ( " get_unix_time_from_datetime " , " datetime " ) , & _OS : : get_unix_time_from_datetime ) ;
ClassDB : : bind_method ( D_METHOD ( " get_system_time_secs " ) , & _OS : : get_system_time_secs ) ;
ClassDB : : bind_method ( D_METHOD ( " get_system_time_msecs " ) , & _OS : : get_system_time_msecs ) ;
ClassDB : : bind_method ( D_METHOD ( " set_native_icon " , " filename " ) , & _OS : : set_native_icon ) ;
ClassDB : : bind_method ( D_METHOD ( " set_icon " , " icon " ) , & _OS : : set_icon ) ;
ClassDB : : bind_method ( D_METHOD ( " get_exit_code " ) , & _OS : : get_exit_code ) ;
ClassDB : : bind_method ( D_METHOD ( " set_exit_code " , " code " ) , & _OS : : set_exit_code ) ;
ClassDB : : bind_method ( D_METHOD ( " delay_usec " , " usec " ) , & _OS : : delay_usec ) ;
ClassDB : : bind_method ( D_METHOD ( " delay_msec " , " msec " ) , & _OS : : delay_msec ) ;
ClassDB : : bind_method ( D_METHOD ( " get_ticks_msec " ) , & _OS : : get_ticks_msec ) ;
ClassDB : : bind_method ( D_METHOD ( " get_ticks_usec " ) , & _OS : : get_ticks_usec ) ;
ClassDB : : bind_method ( D_METHOD ( " get_splash_tick_msec " ) , & _OS : : get_splash_tick_msec ) ;
ClassDB : : bind_method ( D_METHOD ( " get_locale " ) , & _OS : : get_locale ) ;
ClassDB : : bind_method ( D_METHOD ( " get_locale_language " ) , & _OS : : get_locale_language ) ;
ClassDB : : bind_method ( D_METHOD ( " get_latin_keyboard_variant " ) , & _OS : : get_latin_keyboard_variant ) ;
ClassDB : : bind_method ( D_METHOD ( " get_model_name " ) , & _OS : : get_model_name ) ;
ClassDB : : bind_method ( D_METHOD ( " keyboard_get_layout_count " ) , & _OS : : keyboard_get_layout_count ) ;
ClassDB : : bind_method ( D_METHOD ( " keyboard_get_current_layout " ) , & _OS : : keyboard_get_current_layout ) ;
ClassDB : : bind_method ( D_METHOD ( " keyboard_set_current_layout " , " index " ) , & _OS : : keyboard_set_current_layout ) ;
ClassDB : : bind_method ( D_METHOD ( " keyboard_get_layout_language " , " index " ) , & _OS : : keyboard_get_layout_language ) ;
ClassDB : : bind_method ( D_METHOD ( " keyboard_get_layout_name " , " index " ) , & _OS : : keyboard_get_layout_name ) ;
ClassDB : : bind_method ( D_METHOD ( " keyboard_get_scancode_from_physical " , " scancode " ) , & _OS : : keyboard_get_scancode_from_physical ) ;
ClassDB : : bind_method ( D_METHOD ( " can_draw " ) , & _OS : : can_draw ) ;
ClassDB : : bind_method ( D_METHOD ( " is_userfs_persistent " ) , & _OS : : is_userfs_persistent ) ;
ClassDB : : bind_method ( D_METHOD ( " is_stdout_verbose " ) , & _OS : : is_stdout_verbose ) ;
ClassDB : : bind_method ( D_METHOD ( " can_use_threads " ) , & _OS : : can_use_threads ) ;
ClassDB : : bind_method ( D_METHOD ( " is_debug_build " ) , & _OS : : is_debug_build ) ;
//ClassDB::bind_method(D_METHOD("get_mouse_button_state"),&_OS::get_mouse_button_state);
ClassDB : : bind_method ( D_METHOD ( " dump_memory_to_file " , " file " ) , & _OS : : dump_memory_to_file ) ;
ClassDB : : bind_method ( D_METHOD ( " dump_resources_to_file " , " file " ) , & _OS : : dump_resources_to_file ) ;
ClassDB : : bind_method ( D_METHOD ( " has_virtual_keyboard " ) , & _OS : : has_virtual_keyboard ) ;
2022-08-19 16:18:53 +02:00
ClassDB : : bind_method ( D_METHOD ( " show_virtual_keyboard " , " existing_text " , " multiline " ) , & _OS : : _show_virtual_keyboard , DEFVAL ( " " ) , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " show_virtual_keyboard_type " , " existing_text " , " type " ) , & _OS : : show_virtual_keyboard , DEFVAL ( " " ) , DEFVAL ( _OS : : KEYBOARD_TYPE_DEFAULT ) ) ;
2022-03-15 13:29:32 +01:00
ClassDB : : bind_method ( D_METHOD ( " hide_virtual_keyboard " ) , & _OS : : hide_virtual_keyboard ) ;
ClassDB : : bind_method ( D_METHOD ( " get_virtual_keyboard_height " ) , & _OS : : get_virtual_keyboard_height ) ;
ClassDB : : bind_method ( D_METHOD ( " print_resources_in_use " , " short " ) , & _OS : : print_resources_in_use , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " print_all_resources " , " tofile " ) , & _OS : : print_all_resources , DEFVAL ( " " ) ) ;
ClassDB : : bind_method ( D_METHOD ( " get_static_memory_usage " ) , & _OS : : get_static_memory_usage ) ;
ClassDB : : bind_method ( D_METHOD ( " get_static_memory_peak_usage " ) , & _OS : : get_static_memory_peak_usage ) ;
ClassDB : : bind_method ( D_METHOD ( " get_dynamic_memory_usage " ) , & _OS : : get_dynamic_memory_usage ) ;
2022-04-26 23:52:20 +02:00
ClassDB : : bind_method ( D_METHOD ( " move_to_trash " , " path " ) , & _OS : : move_to_trash ) ;
2022-03-15 13:29:32 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_user_data_dir " ) , & _OS : : get_user_data_dir ) ;
ClassDB : : bind_method ( D_METHOD ( " get_system_dir " , " dir " , " shared_storage " ) , & _OS : : get_system_dir , DEFVAL ( true ) ) ;
ClassDB : : bind_method ( D_METHOD ( " get_config_dir " ) , & _OS : : get_config_dir ) ;
ClassDB : : bind_method ( D_METHOD ( " get_data_dir " ) , & _OS : : get_data_dir ) ;
ClassDB : : bind_method ( D_METHOD ( " get_cache_dir " ) , & _OS : : get_cache_dir ) ;
ClassDB : : bind_method ( D_METHOD ( " get_unique_id " ) , & _OS : : get_unique_id ) ;
ClassDB : : bind_method ( D_METHOD ( " is_ok_left_and_cancel_right " ) , & _OS : : is_ok_left_and_cancel_right ) ;
ClassDB : : bind_method ( D_METHOD ( " print_all_textures_by_size " ) , & _OS : : print_all_textures_by_size ) ;
ClassDB : : bind_method ( D_METHOD ( " print_resources_by_type " , " types " ) , & _OS : : print_resources_by_type ) ;
ClassDB : : bind_method ( D_METHOD ( " native_video_play " , " path " , " volume " , " audio_track " , " subtitle_track " ) , & _OS : : native_video_play ) ;
ClassDB : : bind_method ( D_METHOD ( " native_video_is_playing " ) , & _OS : : native_video_is_playing ) ;
ClassDB : : bind_method ( D_METHOD ( " native_video_stop " ) , & _OS : : native_video_stop ) ;
ClassDB : : bind_method ( D_METHOD ( " native_video_pause " ) , & _OS : : native_video_pause ) ;
ClassDB : : bind_method ( D_METHOD ( " native_video_unpause " ) , & _OS : : native_video_unpause ) ;
ClassDB : : bind_method ( D_METHOD ( " get_scancode_string " , " code " ) , & _OS : : get_scancode_string ) ;
ClassDB : : bind_method ( D_METHOD ( " is_scancode_unicode " , " code " ) , & _OS : : is_scancode_unicode ) ;
ClassDB : : bind_method ( D_METHOD ( " find_scancode_from_string " , " string " ) , & _OS : : find_scancode_from_string ) ;
ClassDB : : bind_method ( D_METHOD ( " set_use_file_access_save_and_swap " , " enabled " ) , & _OS : : set_use_file_access_save_and_swap ) ;
ClassDB : : bind_method ( D_METHOD ( " alert " , " text " , " title " ) , & _OS : : alert , DEFVAL ( " Alert! " ) ) ;
ClassDB : : bind_method ( D_METHOD ( " crash " , " message " ) , & _OS : : crash ) ;
ClassDB : : bind_method ( D_METHOD ( " set_thread_name " , " name " ) , & _OS : : set_thread_name ) ;
ClassDB : : bind_method ( D_METHOD ( " get_thread_caller_id " ) , & _OS : : get_thread_caller_id ) ;
ClassDB : : bind_method ( D_METHOD ( " get_main_thread_id " ) , & _OS : : get_main_thread_id ) ;
ClassDB : : bind_method ( D_METHOD ( " set_use_vsync " , " enable " ) , & _OS : : set_use_vsync ) ;
ClassDB : : bind_method ( D_METHOD ( " is_vsync_enabled " ) , & _OS : : is_vsync_enabled ) ;
ClassDB : : bind_method ( D_METHOD ( " set_vsync_via_compositor " , " enable " ) , & _OS : : set_vsync_via_compositor ) ;
ClassDB : : bind_method ( D_METHOD ( " is_vsync_via_compositor_enabled " ) , & _OS : : is_vsync_via_compositor_enabled ) ;
ClassDB : : bind_method ( D_METHOD ( " set_delta_smoothing " , " delta_smoothing_enabled " ) , & _OS : : set_delta_smoothing ) ;
ClassDB : : bind_method ( D_METHOD ( " is_delta_smoothing_enabled " ) , & _OS : : is_delta_smoothing_enabled ) ;
ClassDB : : bind_method ( D_METHOD ( " has_feature " , " tag_name " ) , & _OS : : has_feature ) ;
ClassDB : : bind_method ( D_METHOD ( " get_power_state " ) , & _OS : : get_power_state ) ;
ClassDB : : bind_method ( D_METHOD ( " get_power_seconds_left " ) , & _OS : : get_power_seconds_left ) ;
ClassDB : : bind_method ( D_METHOD ( " get_power_percent_left " ) , & _OS : : get_power_percent_left ) ;
ClassDB : : bind_method ( D_METHOD ( " request_permission " , " name " ) , & _OS : : request_permission ) ;
ClassDB : : bind_method ( D_METHOD ( " request_permissions " ) , & _OS : : request_permissions ) ;
ClassDB : : bind_method ( D_METHOD ( " get_granted_permissions " ) , & _OS : : get_granted_permissions ) ;
ClassDB : : bind_method ( D_METHOD ( " get_tablet_driver_count " ) , & _OS : : get_tablet_driver_count ) ;
ClassDB : : bind_method ( D_METHOD ( " get_tablet_driver_name " , " idx " ) , & _OS : : get_tablet_driver_name ) ;
ClassDB : : bind_method ( D_METHOD ( " get_current_tablet_driver " ) , & _OS : : get_current_tablet_driver ) ;
ClassDB : : bind_method ( D_METHOD ( " set_current_tablet_driver " , " name " ) , & _OS : : set_current_tablet_driver ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : STRING , " tablet_driver " ) , " set_current_tablet_driver " , " get_current_tablet_driver " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : STRING , " clipboard " ) , " set_clipboard " , " get_clipboard " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " current_screen " ) , " set_current_screen " , " get_current_screen " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " exit_code " ) , " set_exit_code " , " get_exit_code " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " vsync_enabled " ) , " set_use_vsync " , " is_vsync_enabled " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " vsync_via_compositor " ) , " set_vsync_via_compositor " , " is_vsync_via_compositor_enabled " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " delta_smoothing " ) , " set_delta_smoothing " , " is_delta_smoothing_enabled " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " low_processor_usage_mode " ) , " set_low_processor_usage_mode " , " is_in_low_processor_usage_mode " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " low_processor_usage_mode_sleep_usec " ) , " set_low_processor_usage_mode_sleep_usec " , " get_low_processor_usage_mode_sleep_usec " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " keep_screen_on " ) , " set_keep_screen_on " , " is_keep_screen_on " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR2 , " min_window_size " ) , " set_min_window_size " , " get_min_window_size " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR2 , " max_window_size " ) , " set_max_window_size " , " get_max_window_size " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " screen_orientation " , PROPERTY_HINT_ENUM , " Landscape,Portrait,Reverse Landscape,Reverse Portrait,Sensor Landscape,Sensor Portrait,Sensor " ) , " set_screen_orientation " , " get_screen_orientation " ) ;
ADD_GROUP ( " Window " , " window_ " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " window_borderless " ) , " set_borderless_window " , " get_borderless_window " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " window_per_pixel_transparency_enabled " ) , " set_window_per_pixel_transparency_enabled " , " get_window_per_pixel_transparency_enabled " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " window_fullscreen " ) , " set_window_fullscreen " , " is_window_fullscreen " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " window_maximized " ) , " set_window_maximized " , " is_window_maximized " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " window_minimized " ) , " set_window_minimized " , " is_window_minimized " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " window_resizable " ) , " set_window_resizable " , " is_window_resizable " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR2 , " window_position " ) , " set_window_position " , " get_window_position " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR2 , " window_size " ) , " set_window_size " , " get_window_size " ) ;
// Those default values need to be specified for the docs generator,
// to avoid using values from the documentation writer's own OS instance.
ADD_PROPERTY_DEFAULT ( " clipboard " , " " ) ;
ADD_PROPERTY_DEFAULT ( " current_screen " , 0 ) ;
ADD_PROPERTY_DEFAULT ( " tablet_driver " , " " ) ;
ADD_PROPERTY_DEFAULT ( " exit_code " , 0 ) ;
ADD_PROPERTY_DEFAULT ( " vsync_enabled " , true ) ;
ADD_PROPERTY_DEFAULT ( " vsync_via_compositor " , false ) ;
ADD_PROPERTY_DEFAULT ( " low_processor_usage_mode " , false ) ;
ADD_PROPERTY_DEFAULT ( " low_processor_usage_mode_sleep_usec " , 6900 ) ;
ADD_PROPERTY_DEFAULT ( " keep_screen_on " , true ) ;
ADD_PROPERTY_DEFAULT ( " min_window_size " , Vector2 ( ) ) ;
ADD_PROPERTY_DEFAULT ( " max_window_size " , Vector2 ( ) ) ;
ADD_PROPERTY_DEFAULT ( " screen_orientation " , 0 ) ;
ADD_PROPERTY_DEFAULT ( " window_borderless " , false ) ;
ADD_PROPERTY_DEFAULT ( " window_per_pixel_transparency_enabled " , false ) ;
ADD_PROPERTY_DEFAULT ( " window_fullscreen " , false ) ;
ADD_PROPERTY_DEFAULT ( " window_maximized " , false ) ;
ADD_PROPERTY_DEFAULT ( " window_minimized " , false ) ;
ADD_PROPERTY_DEFAULT ( " window_resizable " , true ) ;
ADD_PROPERTY_DEFAULT ( " window_position " , Vector2 ( ) ) ;
ADD_PROPERTY_DEFAULT ( " window_size " , Vector2 ( ) ) ;
BIND_ENUM_CONSTANT ( VIDEO_DRIVER_GLES2 ) ;
BIND_ENUM_CONSTANT ( DAY_SUNDAY ) ;
BIND_ENUM_CONSTANT ( DAY_MONDAY ) ;
BIND_ENUM_CONSTANT ( DAY_TUESDAY ) ;
BIND_ENUM_CONSTANT ( DAY_WEDNESDAY ) ;
BIND_ENUM_CONSTANT ( DAY_THURSDAY ) ;
BIND_ENUM_CONSTANT ( DAY_FRIDAY ) ;
BIND_ENUM_CONSTANT ( DAY_SATURDAY ) ;
BIND_ENUM_CONSTANT ( MONTH_JANUARY ) ;
BIND_ENUM_CONSTANT ( MONTH_FEBRUARY ) ;
BIND_ENUM_CONSTANT ( MONTH_MARCH ) ;
BIND_ENUM_CONSTANT ( MONTH_APRIL ) ;
BIND_ENUM_CONSTANT ( MONTH_MAY ) ;
BIND_ENUM_CONSTANT ( MONTH_JUNE ) ;
BIND_ENUM_CONSTANT ( MONTH_JULY ) ;
BIND_ENUM_CONSTANT ( MONTH_AUGUST ) ;
BIND_ENUM_CONSTANT ( MONTH_SEPTEMBER ) ;
BIND_ENUM_CONSTANT ( MONTH_OCTOBER ) ;
BIND_ENUM_CONSTANT ( MONTH_NOVEMBER ) ;
BIND_ENUM_CONSTANT ( MONTH_DECEMBER ) ;
BIND_ENUM_CONSTANT ( APPLICATION_HANDLE ) ;
BIND_ENUM_CONSTANT ( DISPLAY_HANDLE ) ;
BIND_ENUM_CONSTANT ( WINDOW_HANDLE ) ;
BIND_ENUM_CONSTANT ( WINDOW_VIEW ) ;
BIND_ENUM_CONSTANT ( OPENGL_CONTEXT ) ;
BIND_ENUM_CONSTANT ( SCREEN_ORIENTATION_LANDSCAPE ) ;
BIND_ENUM_CONSTANT ( SCREEN_ORIENTATION_PORTRAIT ) ;
BIND_ENUM_CONSTANT ( SCREEN_ORIENTATION_REVERSE_LANDSCAPE ) ;
BIND_ENUM_CONSTANT ( SCREEN_ORIENTATION_REVERSE_PORTRAIT ) ;
BIND_ENUM_CONSTANT ( SCREEN_ORIENTATION_SENSOR_LANDSCAPE ) ;
BIND_ENUM_CONSTANT ( SCREEN_ORIENTATION_SENSOR_PORTRAIT ) ;
BIND_ENUM_CONSTANT ( SCREEN_ORIENTATION_SENSOR ) ;
2022-08-19 16:18:53 +02:00
BIND_ENUM_CONSTANT ( KEYBOARD_TYPE_DEFAULT ) ;
BIND_ENUM_CONSTANT ( KEYBOARD_TYPE_MULTILINE ) ;
BIND_ENUM_CONSTANT ( KEYBOARD_TYPE_NUMBER ) ;
BIND_ENUM_CONSTANT ( KEYBOARD_TYPE_NUMBER_DECIMAL ) ;
BIND_ENUM_CONSTANT ( KEYBOARD_TYPE_PHONE ) ;
BIND_ENUM_CONSTANT ( KEYBOARD_TYPE_EMAIL_ADDRESS ) ;
BIND_ENUM_CONSTANT ( KEYBOARD_TYPE_PASSWORD ) ;
BIND_ENUM_CONSTANT ( KEYBOARD_TYPE_URL ) ;
2022-03-15 13:29:32 +01:00
BIND_ENUM_CONSTANT ( SYSTEM_DIR_DESKTOP ) ;
BIND_ENUM_CONSTANT ( SYSTEM_DIR_DCIM ) ;
BIND_ENUM_CONSTANT ( SYSTEM_DIR_DOCUMENTS ) ;
BIND_ENUM_CONSTANT ( SYSTEM_DIR_DOWNLOADS ) ;
BIND_ENUM_CONSTANT ( SYSTEM_DIR_MOVIES ) ;
BIND_ENUM_CONSTANT ( SYSTEM_DIR_MUSIC ) ;
BIND_ENUM_CONSTANT ( SYSTEM_DIR_PICTURES ) ;
BIND_ENUM_CONSTANT ( SYSTEM_DIR_RINGTONES ) ;
BIND_ENUM_CONSTANT ( POWERSTATE_UNKNOWN ) ;
BIND_ENUM_CONSTANT ( POWERSTATE_ON_BATTERY ) ;
BIND_ENUM_CONSTANT ( POWERSTATE_NO_BATTERY ) ;
BIND_ENUM_CONSTANT ( POWERSTATE_CHARGING ) ;
BIND_ENUM_CONSTANT ( POWERSTATE_CHARGED ) ;
}
_OS : : _OS ( ) {
singleton = this ;
}
///////////////////// GEOMETRY
_Geometry * _Geometry : : singleton = nullptr ;
_Geometry * _Geometry : : get_singleton ( ) {
return singleton ;
}
PoolVector < Plane > _Geometry : : build_box_planes ( const Vector3 & p_extents ) {
return Geometry : : build_box_planes ( p_extents ) ;
}
PoolVector < Plane > _Geometry : : build_cylinder_planes ( float p_radius , float p_height , int p_sides , Vector3 : : Axis p_axis ) {
return Geometry : : build_cylinder_planes ( p_radius , p_height , p_sides , p_axis ) ;
}
PoolVector < Plane > _Geometry : : build_capsule_planes ( float p_radius , float p_height , int p_sides , int p_lats , Vector3 : : Axis p_axis ) {
return Geometry : : build_capsule_planes ( p_radius , p_height , p_sides , p_lats , p_axis ) ;
}
bool _Geometry : : is_point_in_circle ( const Vector2 & p_point , const Vector2 & p_circle_pos , real_t p_circle_radius ) {
return Geometry : : is_point_in_circle ( p_point , p_circle_pos , p_circle_radius ) ;
}
real_t _Geometry : : segment_intersects_circle ( const Vector2 & p_from , const Vector2 & p_to , const Vector2 & p_circle_pos , real_t p_circle_radius ) {
return Geometry : : segment_intersects_circle ( p_from , p_to , p_circle_pos , p_circle_radius ) ;
}
Variant _Geometry : : segment_intersects_segment_2d ( const Vector2 & p_from_a , const Vector2 & p_to_a , const Vector2 & p_from_b , const Vector2 & p_to_b ) {
Vector2 result ;
if ( Geometry : : segment_intersects_segment_2d ( p_from_a , p_to_a , p_from_b , p_to_b , & result ) ) {
return result ;
} else {
return Variant ( ) ;
} ;
} ;
Variant _Geometry : : line_intersects_line_2d ( const Vector2 & p_from_a , const Vector2 & p_dir_a , const Vector2 & p_from_b , const Vector2 & p_dir_b ) {
Vector2 result ;
if ( Geometry : : line_intersects_line_2d ( p_from_a , p_dir_a , p_from_b , p_dir_b , result ) ) {
return result ;
} else {
return Variant ( ) ;
}
}
PoolVector < Vector2 > _Geometry : : get_closest_points_between_segments_2d ( const Vector2 & p1 , const Vector2 & q1 , const Vector2 & p2 , const Vector2 & q2 ) {
Vector2 r1 , r2 ;
Geometry : : get_closest_points_between_segments ( p1 , q1 , p2 , q2 , r1 , r2 ) ;
PoolVector < Vector2 > r ;
r . resize ( 2 ) ;
r . set ( 0 , r1 ) ;
r . set ( 1 , r2 ) ;
return r ;
}
PoolVector < Vector3 > _Geometry : : get_closest_points_between_segments ( const Vector3 & p1 , const Vector3 & p2 , const Vector3 & q1 , const Vector3 & q2 ) {
Vector3 r1 , r2 ;
Geometry : : get_closest_points_between_segments ( p1 , p2 , q1 , q2 , r1 , r2 ) ;
PoolVector < Vector3 > r ;
r . resize ( 2 ) ;
r . set ( 0 , r1 ) ;
r . set ( 1 , r2 ) ;
return r ;
}
Vector2 _Geometry : : get_closest_point_to_segment_2d ( const Vector2 & p_point , const Vector2 & p_a , const Vector2 & p_b ) {
Vector2 s [ 2 ] = { p_a , p_b } ;
return Geometry : : get_closest_point_to_segment_2d ( p_point , s ) ;
}
Vector3 _Geometry : : get_closest_point_to_segment ( const Vector3 & p_point , const Vector3 & p_a , const Vector3 & p_b ) {
Vector3 s [ 2 ] = { p_a , p_b } ;
return Geometry : : get_closest_point_to_segment ( p_point , s ) ;
}
Vector2 _Geometry : : get_closest_point_to_segment_uncapped_2d ( const Vector2 & p_point , const Vector2 & p_a , const Vector2 & p_b ) {
Vector2 s [ 2 ] = { p_a , p_b } ;
return Geometry : : get_closest_point_to_segment_uncapped_2d ( p_point , s ) ;
}
Vector3 _Geometry : : get_closest_point_to_segment_uncapped ( const Vector3 & p_point , const Vector3 & p_a , const Vector3 & p_b ) {
Vector3 s [ 2 ] = { p_a , p_b } ;
return Geometry : : get_closest_point_to_segment_uncapped ( p_point , s ) ;
}
Variant _Geometry : : ray_intersects_triangle ( const Vector3 & p_from , const Vector3 & p_dir , const Vector3 & p_v0 , const Vector3 & p_v1 , const Vector3 & p_v2 ) {
Vector3 res ;
if ( Geometry : : ray_intersects_triangle ( p_from , p_dir , p_v0 , p_v1 , p_v2 , & res ) ) {
return res ;
} else {
return Variant ( ) ;
}
}
Variant _Geometry : : segment_intersects_triangle ( const Vector3 & p_from , const Vector3 & p_to , const Vector3 & p_v0 , const Vector3 & p_v1 , const Vector3 & p_v2 ) {
Vector3 res ;
if ( Geometry : : segment_intersects_triangle ( p_from , p_to , p_v0 , p_v1 , p_v2 , & res ) ) {
return res ;
} else {
return Variant ( ) ;
}
}
bool _Geometry : : point_is_inside_triangle ( const Vector2 & s , const Vector2 & a , const Vector2 & b , const Vector2 & c ) const {
return Geometry : : is_point_in_triangle ( s , a , b , c ) ;
}
PoolVector < Vector3 > _Geometry : : segment_intersects_sphere ( const Vector3 & p_from , const Vector3 & p_to , const Vector3 & p_sphere_pos , real_t p_sphere_radius ) {
PoolVector < Vector3 > r ;
Vector3 res , norm ;
if ( ! Geometry : : segment_intersects_sphere ( p_from , p_to , p_sphere_pos , p_sphere_radius , & res , & norm ) ) {
return r ;
}
r . resize ( 2 ) ;
r . set ( 0 , res ) ;
r . set ( 1 , norm ) ;
return r ;
}
PoolVector < Vector3 > _Geometry : : segment_intersects_cylinder ( const Vector3 & p_from , const Vector3 & p_to , float p_height , float p_radius ) {
PoolVector < Vector3 > r ;
Vector3 res , norm ;
if ( ! Geometry : : segment_intersects_cylinder ( p_from , p_to , p_height , p_radius , & res , & norm ) ) {
return r ;
}
r . resize ( 2 ) ;
r . set ( 0 , res ) ;
r . set ( 1 , norm ) ;
return r ;
}
PoolVector < Vector3 > _Geometry : : segment_intersects_convex ( const Vector3 & p_from , const Vector3 & p_to , const Vector < Plane > & p_planes ) {
PoolVector < Vector3 > r ;
Vector3 res , norm ;
if ( ! Geometry : : segment_intersects_convex ( p_from , p_to , p_planes . ptr ( ) , p_planes . size ( ) , & res , & norm ) ) {
return r ;
}
r . resize ( 2 ) ;
r . set ( 0 , res ) ;
r . set ( 1 , norm ) ;
return r ;
}
bool _Geometry : : is_polygon_clockwise ( const Vector < Vector2 > & p_polygon ) {
return Geometry : : is_polygon_clockwise ( p_polygon ) ;
}
bool _Geometry : : is_point_in_polygon ( const Point2 & p_point , const Vector < Vector2 > & p_polygon ) {
return Geometry : : is_point_in_polygon ( p_point , p_polygon ) ;
}
Vector < int > _Geometry : : triangulate_polygon ( const Vector < Vector2 > & p_polygon ) {
return Geometry : : triangulate_polygon ( p_polygon ) ;
}
Vector < int > _Geometry : : triangulate_delaunay_2d ( const Vector < Vector2 > & p_points ) {
return Geometry : : triangulate_delaunay_2d ( p_points ) ;
}
Vector < Point2 > _Geometry : : convex_hull_2d ( const Vector < Point2 > & p_points ) {
return Geometry : : convex_hull_2d ( p_points ) ;
}
Vector < Vector3 > _Geometry : : clip_polygon ( const Vector < Vector3 > & p_points , const Plane & p_plane ) {
return Geometry : : clip_polygon ( p_points , p_plane ) ;
}
Array _Geometry : : merge_polygons_2d ( const Vector < Vector2 > & p_polygon_a , const Vector < Vector2 > & p_polygon_b ) {
Vector < Vector < Point2 > > polys = Geometry : : merge_polygons_2d ( p_polygon_a , p_polygon_b ) ;
Array ret ;
for ( int i = 0 ; i < polys . size ( ) ; + + i ) {
ret . push_back ( polys [ i ] ) ;
}
return ret ;
}
Array _Geometry : : clip_polygons_2d ( const Vector < Vector2 > & p_polygon_a , const Vector < Vector2 > & p_polygon_b ) {
Vector < Vector < Point2 > > polys = Geometry : : clip_polygons_2d ( p_polygon_a , p_polygon_b ) ;
Array ret ;
for ( int i = 0 ; i < polys . size ( ) ; + + i ) {
ret . push_back ( polys [ i ] ) ;
}
return ret ;
}
Array _Geometry : : intersect_polygons_2d ( const Vector < Vector2 > & p_polygon_a , const Vector < Vector2 > & p_polygon_b ) {
Vector < Vector < Point2 > > polys = Geometry : : intersect_polygons_2d ( p_polygon_a , p_polygon_b ) ;
Array ret ;
for ( int i = 0 ; i < polys . size ( ) ; + + i ) {
ret . push_back ( polys [ i ] ) ;
}
return ret ;
}
Array _Geometry : : exclude_polygons_2d ( const Vector < Vector2 > & p_polygon_a , const Vector < Vector2 > & p_polygon_b ) {
Vector < Vector < Point2 > > polys = Geometry : : exclude_polygons_2d ( p_polygon_a , p_polygon_b ) ;
Array ret ;
for ( int i = 0 ; i < polys . size ( ) ; + + i ) {
ret . push_back ( polys [ i ] ) ;
}
return ret ;
}
Array _Geometry : : clip_polyline_with_polygon_2d ( const Vector < Vector2 > & p_polyline , const Vector < Vector2 > & p_polygon ) {
Vector < Vector < Point2 > > polys = Geometry : : clip_polyline_with_polygon_2d ( p_polyline , p_polygon ) ;
Array ret ;
for ( int i = 0 ; i < polys . size ( ) ; + + i ) {
ret . push_back ( polys [ i ] ) ;
}
return ret ;
}
Array _Geometry : : intersect_polyline_with_polygon_2d ( const Vector < Vector2 > & p_polyline , const Vector < Vector2 > & p_polygon ) {
Vector < Vector < Point2 > > polys = Geometry : : intersect_polyline_with_polygon_2d ( p_polyline , p_polygon ) ;
Array ret ;
for ( int i = 0 ; i < polys . size ( ) ; + + i ) {
ret . push_back ( polys [ i ] ) ;
}
return ret ;
}
Array _Geometry : : offset_polygon_2d ( const Vector < Vector2 > & p_polygon , real_t p_delta , PolyJoinType p_join_type ) {
Vector < Vector < Point2 > > polys = Geometry : : offset_polygon_2d ( p_polygon , p_delta , Geometry : : PolyJoinType ( p_join_type ) ) ;
Array ret ;
for ( int i = 0 ; i < polys . size ( ) ; + + i ) {
ret . push_back ( polys [ i ] ) ;
}
return ret ;
}
Array _Geometry : : offset_polyline_2d ( const Vector < Vector2 > & p_polygon , real_t p_delta , PolyJoinType p_join_type , PolyEndType p_end_type ) {
Vector < Vector < Point2 > > polys = Geometry : : offset_polyline_2d ( p_polygon , p_delta , Geometry : : PolyJoinType ( p_join_type ) , Geometry : : PolyEndType ( p_end_type ) ) ;
Array ret ;
for ( int i = 0 ; i < polys . size ( ) ; + + i ) {
ret . push_back ( polys [ i ] ) ;
}
return ret ;
}
Dictionary _Geometry : : make_atlas ( const Vector < Size2 > & p_rects ) {
Dictionary ret ;
Vector < Size2i > rects ;
for ( int i = 0 ; i < p_rects . size ( ) ; i + + ) {
rects . push_back ( p_rects [ i ] ) ;
} ;
Vector < Point2i > result ;
Size2i size ;
Geometry : : make_atlas ( rects , result , size ) ;
Size2 r_size = size ;
Vector < Point2 > r_result ;
for ( int i = 0 ; i < result . size ( ) ; i + + ) {
r_result . push_back ( result [ i ] ) ;
} ;
ret [ " points " ] = r_result ;
ret [ " size " ] = r_size ;
return ret ;
} ;
int _Geometry : : get_uv84_normal_bit ( const Vector3 & p_vector ) {
return Geometry : : get_uv84_normal_bit ( p_vector ) ;
}
void _Geometry : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " build_box_planes " , " extents " ) , & _Geometry : : build_box_planes ) ;
ClassDB : : bind_method ( D_METHOD ( " build_cylinder_planes " , " radius " , " height " , " sides " , " axis " ) , & _Geometry : : build_cylinder_planes , DEFVAL ( Vector3 : : AXIS_Z ) ) ;
ClassDB : : bind_method ( D_METHOD ( " build_capsule_planes " , " radius " , " height " , " sides " , " lats " , " axis " ) , & _Geometry : : build_capsule_planes , DEFVAL ( Vector3 : : AXIS_Z ) ) ;
ClassDB : : bind_method ( D_METHOD ( " is_point_in_circle " , " point " , " circle_position " , " circle_radius " ) , & _Geometry : : is_point_in_circle ) ;
ClassDB : : bind_method ( D_METHOD ( " segment_intersects_circle " , " segment_from " , " segment_to " , " circle_position " , " circle_radius " ) , & _Geometry : : segment_intersects_circle ) ;
ClassDB : : bind_method ( D_METHOD ( " segment_intersects_segment_2d " , " from_a " , " to_a " , " from_b " , " to_b " ) , & _Geometry : : segment_intersects_segment_2d ) ;
ClassDB : : bind_method ( D_METHOD ( " line_intersects_line_2d " , " from_a " , " dir_a " , " from_b " , " dir_b " ) , & _Geometry : : line_intersects_line_2d ) ;
ClassDB : : bind_method ( D_METHOD ( " get_closest_points_between_segments_2d " , " p1 " , " q1 " , " p2 " , " q2 " ) , & _Geometry : : get_closest_points_between_segments_2d ) ;
ClassDB : : bind_method ( D_METHOD ( " get_closest_points_between_segments " , " p1 " , " p2 " , " q1 " , " q2 " ) , & _Geometry : : get_closest_points_between_segments ) ;
ClassDB : : bind_method ( D_METHOD ( " get_closest_point_to_segment_2d " , " point " , " s1 " , " s2 " ) , & _Geometry : : get_closest_point_to_segment_2d ) ;
ClassDB : : bind_method ( D_METHOD ( " get_closest_point_to_segment " , " point " , " s1 " , " s2 " ) , & _Geometry : : get_closest_point_to_segment ) ;
ClassDB : : bind_method ( D_METHOD ( " get_closest_point_to_segment_uncapped_2d " , " point " , " s1 " , " s2 " ) , & _Geometry : : get_closest_point_to_segment_uncapped_2d ) ;
ClassDB : : bind_method ( D_METHOD ( " get_closest_point_to_segment_uncapped " , " point " , " s1 " , " s2 " ) , & _Geometry : : get_closest_point_to_segment_uncapped ) ;
ClassDB : : bind_method ( D_METHOD ( " get_uv84_normal_bit " , " normal " ) , & _Geometry : : get_uv84_normal_bit ) ;
ClassDB : : bind_method ( D_METHOD ( " ray_intersects_triangle " , " from " , " dir " , " a " , " b " , " c " ) , & _Geometry : : ray_intersects_triangle ) ;
ClassDB : : bind_method ( D_METHOD ( " segment_intersects_triangle " , " from " , " to " , " a " , " b " , " c " ) , & _Geometry : : segment_intersects_triangle ) ;
ClassDB : : bind_method ( D_METHOD ( " segment_intersects_sphere " , " from " , " to " , " sphere_position " , " sphere_radius " ) , & _Geometry : : segment_intersects_sphere ) ;
ClassDB : : bind_method ( D_METHOD ( " segment_intersects_cylinder " , " from " , " to " , " height " , " radius " ) , & _Geometry : : segment_intersects_cylinder ) ;
ClassDB : : bind_method ( D_METHOD ( " segment_intersects_convex " , " from " , " to " , " planes " ) , & _Geometry : : segment_intersects_convex ) ;
ClassDB : : bind_method ( D_METHOD ( " point_is_inside_triangle " , " point " , " a " , " b " , " c " ) , & _Geometry : : point_is_inside_triangle ) ;
ClassDB : : bind_method ( D_METHOD ( " is_polygon_clockwise " , " polygon " ) , & _Geometry : : is_polygon_clockwise ) ;
ClassDB : : bind_method ( D_METHOD ( " is_point_in_polygon " , " point " , " polygon " ) , & _Geometry : : is_point_in_polygon ) ;
ClassDB : : bind_method ( D_METHOD ( " triangulate_polygon " , " polygon " ) , & _Geometry : : triangulate_polygon ) ;
ClassDB : : bind_method ( D_METHOD ( " triangulate_delaunay_2d " , " points " ) , & _Geometry : : triangulate_delaunay_2d ) ;
ClassDB : : bind_method ( D_METHOD ( " convex_hull_2d " , " points " ) , & _Geometry : : convex_hull_2d ) ;
ClassDB : : bind_method ( D_METHOD ( " clip_polygon " , " points " , " plane " ) , & _Geometry : : clip_polygon ) ;
ClassDB : : bind_method ( D_METHOD ( " merge_polygons_2d " , " polygon_a " , " polygon_b " ) , & _Geometry : : merge_polygons_2d ) ;
ClassDB : : bind_method ( D_METHOD ( " clip_polygons_2d " , " polygon_a " , " polygon_b " ) , & _Geometry : : clip_polygons_2d ) ;
ClassDB : : bind_method ( D_METHOD ( " intersect_polygons_2d " , " polygon_a " , " polygon_b " ) , & _Geometry : : intersect_polygons_2d ) ;
ClassDB : : bind_method ( D_METHOD ( " exclude_polygons_2d " , " polygon_a " , " polygon_b " ) , & _Geometry : : exclude_polygons_2d ) ;
ClassDB : : bind_method ( D_METHOD ( " clip_polyline_with_polygon_2d " , " polyline " , " polygon " ) , & _Geometry : : clip_polyline_with_polygon_2d ) ;
ClassDB : : bind_method ( D_METHOD ( " intersect_polyline_with_polygon_2d " , " polyline " , " polygon " ) , & _Geometry : : intersect_polyline_with_polygon_2d ) ;
ClassDB : : bind_method ( D_METHOD ( " offset_polygon_2d " , " polygon " , " delta " , " join_type " ) , & _Geometry : : offset_polygon_2d , DEFVAL ( JOIN_SQUARE ) ) ;
ClassDB : : bind_method ( D_METHOD ( " offset_polyline_2d " , " polyline " , " delta " , " join_type " , " end_type " ) , & _Geometry : : offset_polyline_2d , DEFVAL ( JOIN_SQUARE ) , DEFVAL ( END_SQUARE ) ) ;
ClassDB : : bind_method ( D_METHOD ( " make_atlas " , " sizes " ) , & _Geometry : : make_atlas ) ;
BIND_ENUM_CONSTANT ( OPERATION_UNION ) ;
BIND_ENUM_CONSTANT ( OPERATION_DIFFERENCE ) ;
BIND_ENUM_CONSTANT ( OPERATION_INTERSECTION ) ;
BIND_ENUM_CONSTANT ( OPERATION_XOR ) ;
BIND_ENUM_CONSTANT ( JOIN_SQUARE ) ;
BIND_ENUM_CONSTANT ( JOIN_ROUND ) ;
BIND_ENUM_CONSTANT ( JOIN_MITER ) ;
BIND_ENUM_CONSTANT ( END_POLYGON ) ;
BIND_ENUM_CONSTANT ( END_JOINED ) ;
BIND_ENUM_CONSTANT ( END_BUTT ) ;
BIND_ENUM_CONSTANT ( END_SQUARE ) ;
BIND_ENUM_CONSTANT ( END_ROUND ) ;
}
_Geometry : : _Geometry ( ) {
singleton = this ;
}
///////////////////////// FILE
Error _File : : open_encrypted ( const String & p_path , ModeFlags p_mode_flags , const Vector < uint8_t > & p_key ) {
Error err = open ( p_path , p_mode_flags ) ;
if ( err ) {
return err ;
}
FileAccessEncrypted * fae = memnew ( FileAccessEncrypted ) ;
err = fae - > open_and_parse ( f , p_key , ( p_mode_flags = = WRITE ) ? FileAccessEncrypted : : MODE_WRITE_AES256 : FileAccessEncrypted : : MODE_READ ) ;
if ( err ) {
memdelete ( fae ) ;
close ( ) ;
return err ;
}
f = fae ;
return OK ;
}
Error _File : : open_encrypted_pass ( const String & p_path , ModeFlags p_mode_flags , const String & p_pass ) {
Error err = open ( p_path , p_mode_flags ) ;
if ( err ) {
return err ;
}
FileAccessEncrypted * fae = memnew ( FileAccessEncrypted ) ;
err = fae - > open_and_parse_password ( f , p_pass , ( p_mode_flags = = WRITE ) ? FileAccessEncrypted : : MODE_WRITE_AES256 : FileAccessEncrypted : : MODE_READ ) ;
if ( err ) {
memdelete ( fae ) ;
close ( ) ;
return err ;
}
f = fae ;
return OK ;
}
Error _File : : open_compressed ( const String & p_path , ModeFlags p_mode_flags , CompressionMode p_compress_mode ) {
FileAccessCompressed * fac = memnew ( FileAccessCompressed ) ;
fac - > configure ( " GCPF " , ( Compression : : Mode ) p_compress_mode ) ;
Error err = fac - > _open ( p_path , p_mode_flags ) ;
if ( err ) {
memdelete ( fac ) ;
return err ;
}
f = fac ;
return OK ;
}
Error _File : : open ( const String & p_path , ModeFlags p_mode_flags ) {
close ( ) ;
Error err ;
f = FileAccess : : open ( p_path , p_mode_flags , & err ) ;
if ( f ) {
f - > set_endian_swap ( eswap ) ;
}
return err ;
}
void _File : : flush ( ) {
ERR_FAIL_COND_MSG ( ! f , " File must be opened before flushing. " ) ;
f - > flush ( ) ;
}
void _File : : close ( ) {
if ( f ) {
memdelete ( f ) ;
}
f = nullptr ;
}
bool _File : : is_open ( ) const {
return f ! = nullptr ;
}
String _File : : get_path ( ) const {
ERR_FAIL_COND_V_MSG ( ! f , " " , " File must be opened before use. " ) ;
return f - > get_path ( ) ;
}
String _File : : get_path_absolute ( ) const {
ERR_FAIL_COND_V_MSG ( ! f , " " , " File must be opened before use. " ) ;
return f - > get_path_absolute ( ) ;
}
void _File : : seek ( int64_t p_position ) {
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
ERR_FAIL_COND_MSG ( p_position < 0 , " Seek position must be a positive integer. " ) ;
f - > seek ( p_position ) ;
}
void _File : : seek_end ( int64_t p_position ) {
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
f - > seek_end ( p_position ) ;
}
uint64_t _File : : get_position ( ) const {
ERR_FAIL_COND_V_MSG ( ! f , 0 , " File must be opened before use. " ) ;
return f - > get_position ( ) ;
}
uint64_t _File : : get_len ( ) const {
ERR_FAIL_COND_V_MSG ( ! f , 0 , " File must be opened before use. " ) ;
return f - > get_len ( ) ;
}
bool _File : : eof_reached ( ) const {
ERR_FAIL_COND_V_MSG ( ! f , false , " File must be opened before use. " ) ;
return f - > eof_reached ( ) ;
}
uint8_t _File : : get_8 ( ) const {
ERR_FAIL_COND_V_MSG ( ! f , 0 , " File must be opened before use. " ) ;
return f - > get_8 ( ) ;
}
uint16_t _File : : get_16 ( ) const {
ERR_FAIL_COND_V_MSG ( ! f , 0 , " File must be opened before use. " ) ;
return f - > get_16 ( ) ;
}
uint32_t _File : : get_32 ( ) const {
ERR_FAIL_COND_V_MSG ( ! f , 0 , " File must be opened before use. " ) ;
return f - > get_32 ( ) ;
}
uint64_t _File : : get_64 ( ) const {
ERR_FAIL_COND_V_MSG ( ! f , 0 , " File must be opened before use. " ) ;
return f - > get_64 ( ) ;
}
float _File : : get_float ( ) const {
ERR_FAIL_COND_V_MSG ( ! f , 0 , " File must be opened before use. " ) ;
return f - > get_float ( ) ;
}
double _File : : get_double ( ) const {
ERR_FAIL_COND_V_MSG ( ! f , 0 , " File must be opened before use. " ) ;
return f - > get_double ( ) ;
}
real_t _File : : get_real ( ) const {
ERR_FAIL_COND_V_MSG ( ! f , 0 , " File must be opened before use. " ) ;
return f - > get_real ( ) ;
}
PoolVector < uint8_t > _File : : get_buffer ( int64_t p_length ) const {
PoolVector < uint8_t > data ;
ERR_FAIL_COND_V_MSG ( ! f , data , " File must be opened before use. " ) ;
ERR_FAIL_COND_V_MSG ( p_length < 0 , data , " Length of buffer cannot be smaller than 0. " ) ;
if ( p_length = = 0 ) {
return data ;
}
Error err = data . resize ( p_length ) ;
ERR_FAIL_COND_V_MSG ( err ! = OK , data , " Can't resize data to " + itos ( p_length ) + " elements. " ) ;
PoolVector < uint8_t > : : Write w = data . write ( ) ;
int64_t len = f - > get_buffer ( & w [ 0 ] , p_length ) ;
ERR_FAIL_COND_V ( len < 0 , PoolVector < uint8_t > ( ) ) ;
w . release ( ) ;
if ( len < p_length ) {
data . resize ( p_length ) ;
}
return data ;
}
2022-07-31 18:46:53 +02:00
String _File : : get_as_text ( bool p_skip_cr ) const {
2022-03-15 13:29:32 +01:00
ERR_FAIL_COND_V_MSG ( ! f , String ( ) , " File must be opened before use. " ) ;
uint64_t original_pos = f - > get_position ( ) ;
f - > seek ( 0 ) ;
2022-07-31 18:46:53 +02:00
String text = f - > get_as_utf8_string ( p_skip_cr ) ;
2022-03-15 13:29:32 +01:00
f - > seek ( original_pos ) ;
return text ;
}
String _File : : get_md5 ( const String & p_path ) const {
return FileAccess : : get_md5 ( p_path ) ;
}
String _File : : get_sha256 ( const String & p_path ) const {
return FileAccess : : get_sha256 ( p_path ) ;
}
String _File : : get_line ( ) const {
ERR_FAIL_COND_V_MSG ( ! f , String ( ) , " File must be opened before use. " ) ;
return f - > get_line ( ) ;
}
Vector < String > _File : : get_csv_line ( const String & p_delim ) const {
ERR_FAIL_COND_V_MSG ( ! f , Vector < String > ( ) , " File must be opened before use. " ) ;
return f - > get_csv_line ( p_delim ) ;
}
/**< use this for files WRITTEN in _big_ endian machines (ie, amiga/mac)
* It ' s not about the current CPU type but file formats .
* this flags get reset to false ( little endian ) on each open
*/
void _File : : set_endian_swap ( bool p_swap ) {
eswap = p_swap ;
if ( f ) {
f - > set_endian_swap ( p_swap ) ;
}
}
bool _File : : get_endian_swap ( ) {
return eswap ;
}
Error _File : : get_error ( ) const {
if ( ! f ) {
return ERR_UNCONFIGURED ;
}
return f - > get_error ( ) ;
}
void _File : : store_8 ( uint8_t p_dest ) {
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
f - > store_8 ( p_dest ) ;
}
void _File : : store_16 ( uint16_t p_dest ) {
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
f - > store_16 ( p_dest ) ;
}
void _File : : store_32 ( uint32_t p_dest ) {
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
f - > store_32 ( p_dest ) ;
}
void _File : : store_64 ( uint64_t p_dest ) {
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
f - > store_64 ( p_dest ) ;
}
void _File : : store_float ( float p_dest ) {
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
f - > store_float ( p_dest ) ;
}
void _File : : store_double ( double p_dest ) {
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
f - > store_double ( p_dest ) ;
}
void _File : : store_real ( real_t p_real ) {
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
f - > store_real ( p_real ) ;
}
void _File : : store_string ( const String & p_string ) {
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
f - > store_string ( p_string ) ;
}
void _File : : store_pascal_string ( const String & p_string ) {
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
f - > store_pascal_string ( p_string ) ;
} ;
String _File : : get_pascal_string ( ) {
ERR_FAIL_COND_V_MSG ( ! f , " " , " File must be opened before use. " ) ;
return f - > get_pascal_string ( ) ;
} ;
void _File : : store_line ( const String & p_string ) {
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
f - > store_line ( p_string ) ;
}
void _File : : store_csv_line ( const Vector < String > & p_values , const String & p_delim ) {
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
f - > store_csv_line ( p_values , p_delim ) ;
}
void _File : : store_buffer ( const PoolVector < uint8_t > & p_buffer ) {
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
uint64_t len = p_buffer . size ( ) ;
if ( len = = 0 ) {
return ;
}
PoolVector < uint8_t > : : Read r = p_buffer . read ( ) ;
f - > store_buffer ( & r [ 0 ] , len ) ;
}
bool _File : : file_exists ( const String & p_name ) const {
return FileAccess : : exists ( p_name ) ;
}
void _File : : store_var ( const Variant & p_var , bool p_full_objects ) {
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
int len ;
Error err = encode_variant ( p_var , nullptr , len , p_full_objects ) ;
ERR_FAIL_COND_MSG ( err ! = OK , " Error when trying to encode Variant. " ) ;
PoolVector < uint8_t > buff ;
buff . resize ( len ) ;
PoolVector < uint8_t > : : Write w = buff . write ( ) ;
err = encode_variant ( p_var , & w [ 0 ] , len , p_full_objects ) ;
ERR_FAIL_COND_MSG ( err ! = OK , " Error when trying to encode Variant. " ) ;
w . release ( ) ;
store_32 ( len ) ;
store_buffer ( buff ) ;
}
Variant _File : : get_var ( bool p_allow_objects ) const {
ERR_FAIL_COND_V_MSG ( ! f , Variant ( ) , " File must be opened before use. " ) ;
uint32_t len = get_32 ( ) ;
PoolVector < uint8_t > buff = get_buffer ( len ) ;
ERR_FAIL_COND_V ( ( uint32_t ) buff . size ( ) ! = len , Variant ( ) ) ;
PoolVector < uint8_t > : : Read r = buff . read ( ) ;
Variant v ;
Error err = decode_variant ( v , & r [ 0 ] , len , nullptr , p_allow_objects ) ;
ERR_FAIL_COND_V_MSG ( err ! = OK , Variant ( ) , " Error when trying to encode Variant. " ) ;
return v ;
}
uint64_t _File : : get_modified_time ( const String & p_file ) const {
return FileAccess : : get_modified_time ( p_file ) ;
}
void _File : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " open_encrypted " , " path " , " mode_flags " , " key " ) , & _File : : open_encrypted ) ;
ClassDB : : bind_method ( D_METHOD ( " open_encrypted_with_pass " , " path " , " mode_flags " , " pass " ) , & _File : : open_encrypted_pass ) ;
ClassDB : : bind_method ( D_METHOD ( " open_compressed " , " path " , " mode_flags " , " compression_mode " ) , & _File : : open_compressed , DEFVAL ( 0 ) ) ;
ClassDB : : bind_method ( D_METHOD ( " open " , " path " , " flags " ) , & _File : : open ) ;
ClassDB : : bind_method ( D_METHOD ( " flush " ) , & _File : : flush ) ;
ClassDB : : bind_method ( D_METHOD ( " close " ) , & _File : : close ) ;
ClassDB : : bind_method ( D_METHOD ( " get_path " ) , & _File : : get_path ) ;
ClassDB : : bind_method ( D_METHOD ( " get_path_absolute " ) , & _File : : get_path_absolute ) ;
ClassDB : : bind_method ( D_METHOD ( " is_open " ) , & _File : : is_open ) ;
ClassDB : : bind_method ( D_METHOD ( " seek " , " position " ) , & _File : : seek ) ;
ClassDB : : bind_method ( D_METHOD ( " seek_end " , " position " ) , & _File : : seek_end , DEFVAL ( 0 ) ) ;
ClassDB : : bind_method ( D_METHOD ( " get_position " ) , & _File : : get_position ) ;
ClassDB : : bind_method ( D_METHOD ( " get_len " ) , & _File : : get_len ) ;
ClassDB : : bind_method ( D_METHOD ( " eof_reached " ) , & _File : : eof_reached ) ;
ClassDB : : bind_method ( D_METHOD ( " get_8 " ) , & _File : : get_8 ) ;
ClassDB : : bind_method ( D_METHOD ( " get_16 " ) , & _File : : get_16 ) ;
ClassDB : : bind_method ( D_METHOD ( " get_32 " ) , & _File : : get_32 ) ;
ClassDB : : bind_method ( D_METHOD ( " get_64 " ) , & _File : : get_64 ) ;
ClassDB : : bind_method ( D_METHOD ( " get_float " ) , & _File : : get_float ) ;
ClassDB : : bind_method ( D_METHOD ( " get_double " ) , & _File : : get_double ) ;
ClassDB : : bind_method ( D_METHOD ( " get_real " ) , & _File : : get_real ) ;
ClassDB : : bind_method ( D_METHOD ( " get_buffer " , " len " ) , & _File : : get_buffer ) ;
ClassDB : : bind_method ( D_METHOD ( " get_line " ) , & _File : : get_line ) ;
ClassDB : : bind_method ( D_METHOD ( " get_csv_line " , " delim " ) , & _File : : get_csv_line , DEFVAL ( " , " ) ) ;
2022-07-31 18:46:53 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_as_text " , " skip_cr " ) , & _File : : get_as_text , DEFVAL ( true ) ) ;
2022-03-15 13:29:32 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_md5 " , " path " ) , & _File : : get_md5 ) ;
ClassDB : : bind_method ( D_METHOD ( " get_sha256 " , " path " ) , & _File : : get_sha256 ) ;
ClassDB : : bind_method ( D_METHOD ( " get_endian_swap " ) , & _File : : get_endian_swap ) ;
ClassDB : : bind_method ( D_METHOD ( " set_endian_swap " , " enable " ) , & _File : : set_endian_swap ) ;
ClassDB : : bind_method ( D_METHOD ( " get_error " ) , & _File : : get_error ) ;
ClassDB : : bind_method ( D_METHOD ( " get_var " , " allow_objects " ) , & _File : : get_var , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " store_8 " , " value " ) , & _File : : store_8 ) ;
ClassDB : : bind_method ( D_METHOD ( " store_16 " , " value " ) , & _File : : store_16 ) ;
ClassDB : : bind_method ( D_METHOD ( " store_32 " , " value " ) , & _File : : store_32 ) ;
ClassDB : : bind_method ( D_METHOD ( " store_64 " , " value " ) , & _File : : store_64 ) ;
ClassDB : : bind_method ( D_METHOD ( " store_float " , " value " ) , & _File : : store_float ) ;
ClassDB : : bind_method ( D_METHOD ( " store_double " , " value " ) , & _File : : store_double ) ;
ClassDB : : bind_method ( D_METHOD ( " store_real " , " value " ) , & _File : : store_real ) ;
ClassDB : : bind_method ( D_METHOD ( " store_buffer " , " buffer " ) , & _File : : store_buffer ) ;
ClassDB : : bind_method ( D_METHOD ( " store_line " , " line " ) , & _File : : store_line ) ;
ClassDB : : bind_method ( D_METHOD ( " store_csv_line " , " values " , " delim " ) , & _File : : store_csv_line , DEFVAL ( " , " ) ) ;
ClassDB : : bind_method ( D_METHOD ( " store_string " , " string " ) , & _File : : store_string ) ;
ClassDB : : bind_method ( D_METHOD ( " store_var " , " value " , " full_objects " ) , & _File : : store_var , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " store_pascal_string " , " string " ) , & _File : : store_pascal_string ) ;
ClassDB : : bind_method ( D_METHOD ( " get_pascal_string " ) , & _File : : get_pascal_string ) ;
ClassDB : : bind_method ( D_METHOD ( " file_exists " , " path " ) , & _File : : file_exists ) ;
ClassDB : : bind_method ( D_METHOD ( " get_modified_time " , " file " ) , & _File : : get_modified_time ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " endian_swap " ) , " set_endian_swap " , " get_endian_swap " ) ;
BIND_ENUM_CONSTANT ( READ ) ;
BIND_ENUM_CONSTANT ( WRITE ) ;
BIND_ENUM_CONSTANT ( READ_WRITE ) ;
BIND_ENUM_CONSTANT ( WRITE_READ ) ;
BIND_ENUM_CONSTANT ( COMPRESSION_FASTLZ ) ;
BIND_ENUM_CONSTANT ( COMPRESSION_DEFLATE ) ;
BIND_ENUM_CONSTANT ( COMPRESSION_ZSTD ) ;
BIND_ENUM_CONSTANT ( COMPRESSION_GZIP ) ;
}
_File : : _File ( ) {
f = nullptr ;
eswap = false ;
}
_File : : ~ _File ( ) {
if ( f ) {
memdelete ( f ) ;
}
}
///////////////////////////////////////////////////////
Error _Directory : : open ( const String & p_path ) {
Error err ;
DirAccess * alt = DirAccess : : open ( p_path , & err ) ;
if ( ! alt ) {
return err ;
}
if ( d ) {
memdelete ( d ) ;
}
d = alt ;
return OK ;
}
Error _Directory : : list_dir_begin ( bool p_skip_navigational , bool p_skip_hidden ) {
ERR_FAIL_COND_V_MSG ( ! d , ERR_UNCONFIGURED , " Directory must be opened before use. " ) ;
_list_skip_navigational = p_skip_navigational ;
_list_skip_hidden = p_skip_hidden ;
return d - > list_dir_begin ( ) ;
}
String _Directory : : get_next ( ) {
ERR_FAIL_COND_V_MSG ( ! d , " " , " Directory must be opened before use. " ) ;
String next = d - > get_next ( ) ;
while ( next ! = " " & & ( ( _list_skip_navigational & & ( next = = " . " | | next = = " .. " ) ) | | ( _list_skip_hidden & & d - > current_is_hidden ( ) ) ) ) {
next = d - > get_next ( ) ;
}
return next ;
}
bool _Directory : : current_is_dir ( ) const {
ERR_FAIL_COND_V_MSG ( ! d , false , " Directory must be opened before use. " ) ;
return d - > current_is_dir ( ) ;
}
void _Directory : : list_dir_end ( ) {
ERR_FAIL_COND_MSG ( ! d , " Directory must be opened before use. " ) ;
d - > list_dir_end ( ) ;
}
int _Directory : : get_drive_count ( ) {
ERR_FAIL_COND_V_MSG ( ! d , 0 , " Directory must be opened before use. " ) ;
return d - > get_drive_count ( ) ;
}
String _Directory : : get_drive ( int p_drive ) {
ERR_FAIL_COND_V_MSG ( ! d , " " , " Directory must be opened before use. " ) ;
return d - > get_drive ( p_drive ) ;
}
int _Directory : : get_current_drive ( ) {
ERR_FAIL_COND_V_MSG ( ! d , 0 , " Directory must be opened before use. " ) ;
return d - > get_current_drive ( ) ;
}
Error _Directory : : change_dir ( String p_dir ) {
ERR_FAIL_COND_V_MSG ( ! d , ERR_UNCONFIGURED , " Directory must be opened before use. " ) ;
return d - > change_dir ( p_dir ) ;
}
String _Directory : : get_current_dir ( ) {
ERR_FAIL_COND_V_MSG ( ! d , " " , " Directory must be opened before use. " ) ;
return d - > get_current_dir ( ) ;
}
Error _Directory : : make_dir ( String p_dir ) {
ERR_FAIL_COND_V_MSG ( ! d , ERR_UNCONFIGURED , " Directory must be opened before use. " ) ;
if ( ! p_dir . is_rel_path ( ) ) {
DirAccess * d = DirAccess : : create_for_path ( p_dir ) ;
Error err = d - > make_dir ( p_dir ) ;
memdelete ( d ) ;
return err ;
}
return d - > make_dir ( p_dir ) ;
}
Error _Directory : : make_dir_recursive ( String p_dir ) {
ERR_FAIL_COND_V_MSG ( ! d , ERR_UNCONFIGURED , " Directory must be opened before use. " ) ;
if ( ! p_dir . is_rel_path ( ) ) {
DirAccess * d = DirAccess : : create_for_path ( p_dir ) ;
Error err = d - > make_dir_recursive ( p_dir ) ;
memdelete ( d ) ;
return err ;
}
return d - > make_dir_recursive ( p_dir ) ;
}
bool _Directory : : file_exists ( String p_file ) {
ERR_FAIL_COND_V_MSG ( ! d , false , " Directory must be opened before use. " ) ;
if ( ! p_file . is_rel_path ( ) ) {
return FileAccess : : exists ( p_file ) ;
}
return d - > file_exists ( p_file ) ;
}
bool _Directory : : dir_exists ( String p_dir ) {
ERR_FAIL_COND_V_MSG ( ! d , false , " Directory must be opened before use. " ) ;
if ( ! p_dir . is_rel_path ( ) ) {
DirAccess * d = DirAccess : : create_for_path ( p_dir ) ;
bool exists = d - > dir_exists ( p_dir ) ;
memdelete ( d ) ;
return exists ;
} else {
return d - > dir_exists ( p_dir ) ;
}
}
uint64_t _Directory : : get_space_left ( ) {
ERR_FAIL_COND_V_MSG ( ! d , 0 , " Directory must be opened before use. " ) ;
return d - > get_space_left ( ) / 1024 * 1024 ; // Truncate to closest MiB.
}
Error _Directory : : copy ( String p_from , String p_to ) {
ERR_FAIL_COND_V_MSG ( ! d , ERR_UNCONFIGURED , " Directory must be opened before use. " ) ;
return d - > copy ( p_from , p_to ) ;
}
Error _Directory : : rename ( String p_from , String p_to ) {
ERR_FAIL_COND_V_MSG ( ! d , ERR_UNCONFIGURED , " Directory must be opened before use. " ) ;
ERR_FAIL_COND_V_MSG ( p_from . empty ( ) | | p_from = = " . " | | p_from = = " .. " , ERR_INVALID_PARAMETER , " Invalid path to rename. " ) ;
if ( ! p_from . is_rel_path ( ) ) {
DirAccess * d = DirAccess : : create_for_path ( p_from ) ;
ERR_FAIL_COND_V_MSG ( ! d - > file_exists ( p_from ) & & ! d - > dir_exists ( p_from ) , ERR_DOES_NOT_EXIST , " File or directory does not exist. " ) ;
Error err = d - > rename ( p_from , p_to ) ;
memdelete ( d ) ;
return err ;
}
ERR_FAIL_COND_V_MSG ( ! d - > file_exists ( p_from ) & & ! d - > dir_exists ( p_from ) , ERR_DOES_NOT_EXIST , " File or directory does not exist. " ) ;
return d - > rename ( p_from , p_to ) ;
}
Error _Directory : : remove ( String p_name ) {
ERR_FAIL_COND_V_MSG ( ! d , ERR_UNCONFIGURED , " Directory must be opened before use. " ) ;
if ( ! p_name . is_rel_path ( ) ) {
DirAccess * d = DirAccess : : create_for_path ( p_name ) ;
Error err = d - > remove ( p_name ) ;
memdelete ( d ) ;
return err ;
}
return d - > remove ( p_name ) ;
}
2022-07-03 17:29:52 +02:00
String _Directory : : get_filesystem_abspath_for ( String p_path ) {
ERR_FAIL_COND_V_MSG ( ! d , " " , " Directory must be opened before use. " ) ;
return DirAccess : : get_filesystem_abspath_for ( p_path ) ;
}
2022-03-15 13:29:32 +01:00
void _Directory : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " open " , " path " ) , & _Directory : : open ) ;
ClassDB : : bind_method ( D_METHOD ( " list_dir_begin " , " skip_navigational " , " skip_hidden " ) , & _Directory : : list_dir_begin , DEFVAL ( false ) , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " get_next " ) , & _Directory : : get_next ) ;
ClassDB : : bind_method ( D_METHOD ( " current_is_dir " ) , & _Directory : : current_is_dir ) ;
ClassDB : : bind_method ( D_METHOD ( " list_dir_end " ) , & _Directory : : list_dir_end ) ;
ClassDB : : bind_method ( D_METHOD ( " get_drive_count " ) , & _Directory : : get_drive_count ) ;
ClassDB : : bind_method ( D_METHOD ( " get_drive " , " idx " ) , & _Directory : : get_drive ) ;
ClassDB : : bind_method ( D_METHOD ( " get_current_drive " ) , & _Directory : : get_current_drive ) ;
ClassDB : : bind_method ( D_METHOD ( " change_dir " , " todir " ) , & _Directory : : change_dir ) ;
ClassDB : : bind_method ( D_METHOD ( " get_current_dir " ) , & _Directory : : get_current_dir ) ;
ClassDB : : bind_method ( D_METHOD ( " make_dir " , " path " ) , & _Directory : : make_dir ) ;
ClassDB : : bind_method ( D_METHOD ( " make_dir_recursive " , " path " ) , & _Directory : : make_dir_recursive ) ;
ClassDB : : bind_method ( D_METHOD ( " file_exists " , " path " ) , & _Directory : : file_exists ) ;
ClassDB : : bind_method ( D_METHOD ( " dir_exists " , " path " ) , & _Directory : : dir_exists ) ;
//ClassDB::bind_method(D_METHOD("get_modified_time","file"),&_Directory::get_modified_time);
ClassDB : : bind_method ( D_METHOD ( " get_space_left " ) , & _Directory : : get_space_left ) ;
ClassDB : : bind_method ( D_METHOD ( " copy " , " from " , " to " ) , & _Directory : : copy ) ;
ClassDB : : bind_method ( D_METHOD ( " rename " , " from " , " to " ) , & _Directory : : rename ) ;
ClassDB : : bind_method ( D_METHOD ( " remove " , " path " ) , & _Directory : : remove ) ;
2022-07-03 17:29:52 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_filesystem_abspath_for " , " path " ) , & _Directory : : get_filesystem_abspath_for ) ;
2022-03-15 13:29:32 +01:00
}
_Directory : : _Directory ( ) {
d = DirAccess : : create ( DirAccess : : ACCESS_RESOURCES ) ;
}
_Directory : : ~ _Directory ( ) {
if ( d ) {
memdelete ( d ) ;
}
}
_Marshalls * _Marshalls : : singleton = nullptr ;
_Marshalls * _Marshalls : : get_singleton ( ) {
return singleton ;
}
String _Marshalls : : variant_to_base64 ( const Variant & p_var , bool p_full_objects ) {
int len ;
Error err = encode_variant ( p_var , nullptr , len , p_full_objects ) ;
ERR_FAIL_COND_V_MSG ( err ! = OK , " " , " Error when trying to encode Variant. " ) ;
PoolVector < uint8_t > buff ;
buff . resize ( len ) ;
PoolVector < uint8_t > : : Write w = buff . write ( ) ;
err = encode_variant ( p_var , & w [ 0 ] , len , p_full_objects ) ;
ERR_FAIL_COND_V_MSG ( err ! = OK , " " , " Error when trying to encode Variant. " ) ;
String ret = CryptoCore : : b64_encode_str ( & w [ 0 ] , len ) ;
ERR_FAIL_COND_V ( ret = = " " , ret ) ;
return ret ;
} ;
Variant _Marshalls : : base64_to_variant ( const String & p_str , bool p_allow_objects ) {
int strlen = p_str . length ( ) ;
CharString cstr = p_str . ascii ( ) ;
PoolVector < uint8_t > buf ;
buf . resize ( strlen / 4 * 3 + 1 ) ;
PoolVector < uint8_t > : : Write w = buf . write ( ) ;
size_t len = 0 ;
ERR_FAIL_COND_V ( CryptoCore : : b64_decode ( & w [ 0 ] , buf . size ( ) , & len , ( unsigned char * ) cstr . get_data ( ) , strlen ) ! = OK , Variant ( ) ) ;
Variant v ;
Error err = decode_variant ( v , & w [ 0 ] , len , nullptr , p_allow_objects ) ;
ERR_FAIL_COND_V_MSG ( err ! = OK , Variant ( ) , " Error when trying to decode Variant. " ) ;
return v ;
} ;
String _Marshalls : : raw_to_base64 ( const PoolVector < uint8_t > & p_arr ) {
String ret = CryptoCore : : b64_encode_str ( p_arr . read ( ) . ptr ( ) , p_arr . size ( ) ) ;
ERR_FAIL_COND_V ( ret = = " " , ret ) ;
return ret ;
} ;
PoolVector < uint8_t > _Marshalls : : base64_to_raw ( const String & p_str ) {
int strlen = p_str . length ( ) ;
CharString cstr = p_str . ascii ( ) ;
size_t arr_len = 0 ;
PoolVector < uint8_t > buf ;
{
buf . resize ( strlen / 4 * 3 + 1 ) ;
PoolVector < uint8_t > : : Write w = buf . write ( ) ;
ERR_FAIL_COND_V ( CryptoCore : : b64_decode ( & w [ 0 ] , buf . size ( ) , & arr_len , ( unsigned char * ) cstr . get_data ( ) , strlen ) ! = OK , PoolVector < uint8_t > ( ) ) ;
}
buf . resize ( arr_len ) ;
return buf ;
} ;
String _Marshalls : : utf8_to_base64 ( const String & p_str ) {
CharString cstr = p_str . utf8 ( ) ;
String ret = CryptoCore : : b64_encode_str ( ( unsigned char * ) cstr . get_data ( ) , cstr . length ( ) ) ;
ERR_FAIL_COND_V ( ret = = " " , ret ) ;
return ret ;
} ;
String _Marshalls : : base64_to_utf8 ( const String & p_str ) {
int strlen = p_str . length ( ) ;
CharString cstr = p_str . ascii ( ) ;
PoolVector < uint8_t > buf ;
buf . resize ( strlen / 4 * 3 + 1 + 1 ) ;
PoolVector < uint8_t > : : Write w = buf . write ( ) ;
size_t len = 0 ;
ERR_FAIL_COND_V ( CryptoCore : : b64_decode ( & w [ 0 ] , buf . size ( ) , & len , ( unsigned char * ) cstr . get_data ( ) , strlen ) ! = OK , String ( ) ) ;
w [ len ] = 0 ;
String ret = String : : utf8 ( ( char * ) & w [ 0 ] ) ;
return ret ;
} ;
void _Marshalls : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " variant_to_base64 " , " variant " , " full_objects " ) , & _Marshalls : : variant_to_base64 , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " base64_to_variant " , " base64_str " , " allow_objects " ) , & _Marshalls : : base64_to_variant , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " raw_to_base64 " , " array " ) , & _Marshalls : : raw_to_base64 ) ;
ClassDB : : bind_method ( D_METHOD ( " base64_to_raw " , " base64_str " ) , & _Marshalls : : base64_to_raw ) ;
ClassDB : : bind_method ( D_METHOD ( " utf8_to_base64 " , " utf8_str " ) , & _Marshalls : : utf8_to_base64 ) ;
ClassDB : : bind_method ( D_METHOD ( " base64_to_utf8 " , " base64_str " ) , & _Marshalls : : base64_to_utf8 ) ;
} ;
////////////////
Error _Semaphore : : wait ( ) {
semaphore . wait ( ) ;
return OK ; // Can't fail anymore; keep compat
}
2022-04-25 07:13:55 +02:00
Error _Semaphore : : try_wait ( ) {
return semaphore . try_wait ( ) ? OK : ERR_BUSY ;
}
2022-03-15 13:29:32 +01:00
Error _Semaphore : : post ( ) {
semaphore . post ( ) ;
return OK ; // Can't fail anymore; keep compat
}
void _Semaphore : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " wait " ) , & _Semaphore : : wait ) ;
ClassDB : : bind_method ( D_METHOD ( " post " ) , & _Semaphore : : post ) ;
2022-04-25 07:13:55 +02:00
ClassDB : : bind_method ( D_METHOD ( " try_wait " ) , & _Semaphore : : try_wait ) ;
2022-03-15 13:29:32 +01:00
}
///////////////
void _Mutex : : lock ( ) {
mutex . lock ( ) ;
}
Error _Mutex : : try_lock ( ) {
return mutex . try_lock ( ) ;
}
void _Mutex : : unlock ( ) {
mutex . unlock ( ) ;
}
void _Mutex : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " lock " ) , & _Mutex : : lock ) ;
ClassDB : : bind_method ( D_METHOD ( " try_lock " ) , & _Mutex : : try_lock ) ;
ClassDB : : bind_method ( D_METHOD ( " unlock " ) , & _Mutex : : unlock ) ;
}
///////////////
void _Thread : : _start_func ( void * ud ) {
Ref < _Thread > * tud = ( Ref < _Thread > * ) ud ;
Ref < _Thread > t = * tud ;
memdelete ( tud ) ;
Object * target_instance = ObjectDB : : get_instance ( t - > target_instance_id ) ;
if ( ! target_instance ) {
ERR_FAIL_MSG ( vformat ( " Could not call function '%s' on previously freed instance to start thread %s. " , t - > target_method , t - > get_id ( ) ) ) ;
}
Variant : : CallError ce ;
const Variant * arg [ 1 ] = { & t - > userdata } ;
int argc = 0 ;
if ( arg [ 0 ] - > get_type ( ) ! = Variant : : NIL ) {
// Just pass to the target function whatever came as user data
argc = 1 ;
} else {
// There are two cases of null user data:
// a) The target function has zero parameters and the caller is just honoring that.
// b) The target function has at least one parameter with no default and the caller is
// leveraging the fact that user data defaults to null in Thread.start().
// We care about the case of more than one parameter because, even if a thread
// function can have one at most, out mindset here is to do our best with the
// only/first one and let the call handle any other error conditions, like too
// much arguments.
// We must check if we are in case b).
int target_param_count = 0 ;
int target_default_arg_count = 0 ;
2022-06-27 05:24:04 +02:00
2022-03-15 13:29:32 +01:00
Ref < Script > script = target_instance - > get_script ( ) ;
2022-06-27 05:24:04 +02:00
while ( script . is_valid ( ) ) {
if ( script - > has_method ( t - > target_method ) ) {
MethodInfo mi = script - > get_method_info ( t - > target_method ) ;
target_param_count = mi . arguments . size ( ) ;
target_default_arg_count = mi . default_arguments . size ( ) ;
break ;
}
script = script - > get_base_script ( ) ;
}
if ( script . is_null ( ) ) {
2022-03-15 13:29:32 +01:00
MethodBind * method = ClassDB : : get_method ( target_instance - > get_class_name ( ) , t - > target_method ) ;
if ( method ) {
target_param_count = method - > get_argument_count ( ) ;
target_default_arg_count = method - > get_default_argument_count ( ) ;
}
}
if ( target_param_count > = 1 & & target_default_arg_count < target_param_count ) {
argc = 1 ;
}
}
Thread : : set_name ( t - > target_method ) ;
t - > ret = target_instance - > call ( t - > target_method , arg , argc , ce ) ;
if ( ce . error ! = Variant : : CallError : : CALL_OK ) {
String reason ;
switch ( ce . error ) {
case Variant : : CallError : : CALL_ERROR_INVALID_ARGUMENT : {
reason = " Invalid Argument # " + itos ( ce . argument ) ;
} break ;
case Variant : : CallError : : CALL_ERROR_TOO_MANY_ARGUMENTS : {
reason = " Too Many Arguments " ;
} break ;
case Variant : : CallError : : CALL_ERROR_TOO_FEW_ARGUMENTS : {
reason = " Too Few Arguments " ;
} break ;
case Variant : : CallError : : CALL_ERROR_INVALID_METHOD : {
reason = " Method Not Found " ;
} break ;
default : {
}
}
t - > running . clear ( ) ;
ERR_FAIL_MSG ( " Could not call function ' " + t - > target_method . operator String ( ) + " ' to start thread " + t - > get_id ( ) + " : " + reason + " . " ) ;
}
t - > running . clear ( ) ;
}
Error _Thread : : start ( Object * p_instance , const StringName & p_method , const Variant & p_userdata , Priority p_priority ) {
ERR_FAIL_COND_V_MSG ( is_active ( ) , ERR_ALREADY_IN_USE , " Thread already started. " ) ;
ERR_FAIL_COND_V ( ! p_instance , ERR_INVALID_PARAMETER ) ;
ERR_FAIL_COND_V ( p_method = = StringName ( ) | | ! p_instance - > has_method ( p_method ) , ERR_INVALID_PARAMETER ) ;
ERR_FAIL_INDEX_V ( p_priority , PRIORITY_MAX , ERR_INVALID_PARAMETER ) ;
ret = Variant ( ) ;
target_method = p_method ;
target_instance_id = p_instance - > get_instance_id ( ) ;
userdata = p_userdata ;
running . set ( ) ;
Ref < _Thread > * ud = memnew ( Ref < _Thread > ( this ) ) ;
Thread : : Settings s ;
s . priority = ( Thread : : Priority ) p_priority ;
thread . start ( _start_func , ud , s ) ;
return OK ;
}
String _Thread : : get_id ( ) const {
return itos ( thread . get_id ( ) ) ;
}
bool _Thread : : is_active ( ) const {
return thread . is_started ( ) ;
}
bool _Thread : : is_alive ( ) const {
return running . is_set ( ) ;
}
Variant _Thread : : wait_to_finish ( ) {
ERR_FAIL_COND_V_MSG ( ! is_active ( ) , Variant ( ) , " Thread must have been started to wait for its completion. " ) ;
thread . wait_to_finish ( ) ;
Variant r = ret ;
target_method = StringName ( ) ;
target_instance_id = ObjectID ( ) ;
userdata = Variant ( ) ;
return r ;
}
void _Thread : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " start " , " instance " , " method " , " userdata " , " priority " ) , & _Thread : : start , DEFVAL ( Variant ( ) ) , DEFVAL ( PRIORITY_NORMAL ) ) ;
ClassDB : : bind_method ( D_METHOD ( " get_id " ) , & _Thread : : get_id ) ;
ClassDB : : bind_method ( D_METHOD ( " is_active " ) , & _Thread : : is_active ) ;
ClassDB : : bind_method ( D_METHOD ( " is_alive " ) , & _Thread : : is_alive ) ;
ClassDB : : bind_method ( D_METHOD ( " wait_to_finish " ) , & _Thread : : wait_to_finish ) ;
BIND_ENUM_CONSTANT ( PRIORITY_LOW ) ;
BIND_ENUM_CONSTANT ( PRIORITY_NORMAL ) ;
BIND_ENUM_CONSTANT ( PRIORITY_HIGH ) ;
}
_Thread : : _Thread ( ) {
target_instance_id = ObjectID ( ) ;
}
_Thread : : ~ _Thread ( ) {
ERR_FAIL_COND_MSG ( is_active ( ) , " Reference to a Thread object was lost while the thread is still running... " ) ;
}
/////////////////////////////////////
PoolStringArray _ClassDB : : get_class_list ( ) const {
List < StringName > classes ;
ClassDB : : get_class_list ( & classes ) ;
PoolStringArray ret ;
ret . resize ( classes . size ( ) ) ;
int idx = 0 ;
for ( List < StringName > : : Element * E = classes . front ( ) ; E ; E = E - > next ( ) ) {
ret . set ( idx + + , E - > get ( ) ) ;
}
return ret ;
}
PoolStringArray _ClassDB : : get_inheriters_from_class ( const StringName & p_class ) const {
List < StringName > classes ;
ClassDB : : get_inheriters_from_class ( p_class , & classes ) ;
PoolStringArray ret ;
ret . resize ( classes . size ( ) ) ;
int idx = 0 ;
for ( List < StringName > : : Element * E = classes . front ( ) ; E ; E = E - > next ( ) ) {
ret . set ( idx + + , E - > get ( ) ) ;
}
return ret ;
}
StringName _ClassDB : : get_parent_class ( const StringName & p_class ) const {
return ClassDB : : get_parent_class ( p_class ) ;
}
bool _ClassDB : : class_exists ( const StringName & p_class ) const {
return ClassDB : : class_exists ( p_class ) ;
}
bool _ClassDB : : is_parent_class ( const StringName & p_class , const StringName & p_inherits ) const {
return ClassDB : : is_parent_class ( p_class , p_inherits ) ;
}
bool _ClassDB : : can_instance ( const StringName & p_class ) const {
return ClassDB : : can_instance ( p_class ) ;
}
Variant _ClassDB : : instance ( const StringName & p_class ) const {
Object * obj = ClassDB : : instance ( p_class ) ;
if ( ! obj ) {
return Variant ( ) ;
}
Reference * r = Object : : cast_to < Reference > ( obj ) ;
if ( r ) {
return REF ( r ) ;
} else {
return obj ;
}
}
bool _ClassDB : : has_signal ( StringName p_class , StringName p_signal ) const {
return ClassDB : : has_signal ( p_class , p_signal ) ;
}
Dictionary _ClassDB : : get_signal ( StringName p_class , StringName p_signal ) const {
MethodInfo signal ;
if ( ClassDB : : get_signal ( p_class , p_signal , & signal ) ) {
return signal . operator Dictionary ( ) ;
} else {
return Dictionary ( ) ;
}
}
Array _ClassDB : : get_signal_list ( StringName p_class , bool p_no_inheritance ) const {
List < MethodInfo > signals ;
ClassDB : : get_signal_list ( p_class , & signals , p_no_inheritance ) ;
Array ret ;
for ( List < MethodInfo > : : Element * E = signals . front ( ) ; E ; E = E - > next ( ) ) {
ret . push_back ( E - > get ( ) . operator Dictionary ( ) ) ;
}
return ret ;
}
Array _ClassDB : : get_property_list ( StringName p_class , bool p_no_inheritance ) const {
List < PropertyInfo > plist ;
ClassDB : : get_property_list ( p_class , & plist , p_no_inheritance ) ;
Array ret ;
for ( List < PropertyInfo > : : Element * E = plist . front ( ) ; E ; E = E - > next ( ) ) {
ret . push_back ( E - > get ( ) . operator Dictionary ( ) ) ;
}
return ret ;
}
Variant _ClassDB : : get_property ( Object * p_object , const StringName & p_property ) const {
Variant ret ;
ClassDB : : get_property ( p_object , p_property , ret ) ;
return ret ;
}
Error _ClassDB : : set_property ( Object * p_object , const StringName & p_property , const Variant & p_value ) const {
Variant ret ;
bool valid ;
if ( ! ClassDB : : set_property ( p_object , p_property , p_value , & valid ) ) {
return ERR_UNAVAILABLE ;
} else if ( ! valid ) {
return ERR_INVALID_DATA ;
}
return OK ;
}
bool _ClassDB : : has_method ( StringName p_class , StringName p_method , bool p_no_inheritance ) const {
return ClassDB : : has_method ( p_class , p_method , p_no_inheritance ) ;
}
Array _ClassDB : : get_method_list ( StringName p_class , bool p_no_inheritance ) const {
List < MethodInfo > methods ;
ClassDB : : get_method_list ( p_class , & methods , p_no_inheritance ) ;
Array ret ;
for ( List < MethodInfo > : : Element * E = methods . front ( ) ; E ; E = E - > next ( ) ) {
# ifdef DEBUG_METHODS_ENABLED
ret . push_back ( E - > get ( ) . operator Dictionary ( ) ) ;
# else
Dictionary dict ;
dict [ " name " ] = E - > get ( ) . name ;
ret . push_back ( dict ) ;
# endif
}
return ret ;
}
PoolStringArray _ClassDB : : get_integer_constant_list ( const StringName & p_class , bool p_no_inheritance ) const {
List < String > constants ;
ClassDB : : get_integer_constant_list ( p_class , & constants , p_no_inheritance ) ;
PoolStringArray ret ;
ret . resize ( constants . size ( ) ) ;
int idx = 0 ;
for ( List < String > : : Element * E = constants . front ( ) ; E ; E = E - > next ( ) ) {
ret . set ( idx + + , E - > get ( ) ) ;
}
return ret ;
}
bool _ClassDB : : has_integer_constant ( const StringName & p_class , const StringName & p_name ) const {
bool success ;
ClassDB : : get_integer_constant ( p_class , p_name , & success ) ;
return success ;
}
int _ClassDB : : get_integer_constant ( const StringName & p_class , const StringName & p_name ) const {
bool found ;
int c = ClassDB : : get_integer_constant ( p_class , p_name , & found ) ;
ERR_FAIL_COND_V ( ! found , 0 ) ;
return c ;
}
StringName _ClassDB : : get_category ( const StringName & p_node ) const {
return ClassDB : : get_category ( p_node ) ;
}
bool _ClassDB : : has_enum ( const StringName & p_class , const StringName & p_name , bool p_no_inheritance ) const {
return ClassDB : : has_enum ( p_class , p_name , p_no_inheritance ) ;
}
PoolStringArray _ClassDB : : get_enum_list ( const StringName & p_class , bool p_no_inheritance ) const {
List < StringName > enums ;
ClassDB : : get_enum_list ( p_class , & enums , p_no_inheritance ) ;
PoolStringArray ret ;
ret . resize ( enums . size ( ) ) ;
int idx = 0 ;
for ( List < StringName > : : Element * E = enums . front ( ) ; E ; E = E - > next ( ) ) {
ret . set ( idx + + , E - > get ( ) ) ;
}
return ret ;
}
PoolStringArray _ClassDB : : get_enum_constants ( const StringName & p_class , const StringName & p_enum , bool p_no_inheritance ) const {
List < StringName > constants ;
ClassDB : : get_enum_constants ( p_class , p_enum , & constants , p_no_inheritance ) ;
PoolStringArray ret ;
ret . resize ( constants . size ( ) ) ;
int idx = 0 ;
for ( List < StringName > : : Element * E = constants . front ( ) ; E ; E = E - > next ( ) ) {
ret . set ( idx + + , E - > get ( ) ) ;
}
return ret ;
}
StringName _ClassDB : : get_integer_constant_enum ( const StringName & p_class , const StringName & p_name , bool p_no_inheritance ) const {
return ClassDB : : get_integer_constant_enum ( p_class , p_name , p_no_inheritance ) ;
}
bool _ClassDB : : is_class_enabled ( StringName p_class ) const {
return ClassDB : : is_class_enabled ( p_class ) ;
}
void _ClassDB : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " get_class_list " ) , & _ClassDB : : get_class_list ) ;
ClassDB : : bind_method ( D_METHOD ( " get_inheriters_from_class " , " class " ) , & _ClassDB : : get_inheriters_from_class ) ;
ClassDB : : bind_method ( D_METHOD ( " get_parent_class " , " class " ) , & _ClassDB : : get_parent_class ) ;
ClassDB : : bind_method ( D_METHOD ( " class_exists " , " class " ) , & _ClassDB : : class_exists ) ;
ClassDB : : bind_method ( D_METHOD ( " is_parent_class " , " class " , " inherits " ) , & _ClassDB : : is_parent_class ) ;
ClassDB : : bind_method ( D_METHOD ( " can_instance " , " class " ) , & _ClassDB : : can_instance ) ;
ClassDB : : bind_method ( D_METHOD ( " instance " , " class " ) , & _ClassDB : : instance ) ;
ClassDB : : bind_method ( D_METHOD ( " class_has_signal " , " class " , " signal " ) , & _ClassDB : : has_signal ) ;
ClassDB : : bind_method ( D_METHOD ( " class_get_signal " , " class " , " signal " ) , & _ClassDB : : get_signal ) ;
ClassDB : : bind_method ( D_METHOD ( " class_get_signal_list " , " class " , " no_inheritance " ) , & _ClassDB : : get_signal_list , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " class_get_property_list " , " class " , " no_inheritance " ) , & _ClassDB : : get_property_list , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " class_get_property " , " object " , " property " ) , & _ClassDB : : get_property ) ;
ClassDB : : bind_method ( D_METHOD ( " class_set_property " , " object " , " property " , " value " ) , & _ClassDB : : set_property ) ;
ClassDB : : bind_method ( D_METHOD ( " class_has_method " , " class " , " method " , " no_inheritance " ) , & _ClassDB : : has_method , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " class_get_method_list " , " class " , " no_inheritance " ) , & _ClassDB : : get_method_list , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " class_get_integer_constant_list " , " class " , " no_inheritance " ) , & _ClassDB : : get_integer_constant_list , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " class_has_integer_constant " , " class " , " name " ) , & _ClassDB : : has_integer_constant ) ;
ClassDB : : bind_method ( D_METHOD ( " class_get_integer_constant " , " class " , " name " ) , & _ClassDB : : get_integer_constant ) ;
ClassDB : : bind_method ( D_METHOD ( " class_has_enum " , " class " , " name " , " no_inheritance " ) , & _ClassDB : : has_enum , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " class_get_enum_list " , " class " , " no_inheritance " ) , & _ClassDB : : get_enum_list , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " class_get_enum_constants " , " class " , " enum " , " no_inheritance " ) , & _ClassDB : : get_enum_constants , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " class_get_integer_constant_enum " , " class " , " name " , " no_inheritance " ) , & _ClassDB : : get_integer_constant_enum , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " class_get_category " , " class " ) , & _ClassDB : : get_category ) ;
ClassDB : : bind_method ( D_METHOD ( " is_class_enabled " , " class " ) , & _ClassDB : : is_class_enabled ) ;
}
_ClassDB : : _ClassDB ( ) {
}
_ClassDB : : ~ _ClassDB ( ) {
}
///////////////////////////////
2022-03-24 11:10:56 +01:00
void _Engine : : set_physics_ticks_per_second ( int p_ips ) {
Engine : : get_singleton ( ) - > set_physics_ticks_per_second ( p_ips ) ;
2022-03-15 13:29:32 +01:00
}
2022-03-24 11:10:56 +01:00
int _Engine : : get_physics_ticks_per_second ( ) const {
return Engine : : get_singleton ( ) - > get_physics_ticks_per_second ( ) ;
2022-03-15 13:29:32 +01:00
}
void _Engine : : set_physics_jitter_fix ( float p_threshold ) {
Engine : : get_singleton ( ) - > set_physics_jitter_fix ( p_threshold ) ;
}
float _Engine : : get_physics_jitter_fix ( ) const {
return Engine : : get_singleton ( ) - > get_physics_jitter_fix ( ) ;
}
float _Engine : : get_physics_interpolation_fraction ( ) const {
return Engine : : get_singleton ( ) - > get_physics_interpolation_fraction ( ) ;
}
void _Engine : : set_target_fps ( int p_fps ) {
Engine : : get_singleton ( ) - > set_target_fps ( p_fps ) ;
}
int _Engine : : get_target_fps ( ) const {
return Engine : : get_singleton ( ) - > get_target_fps ( ) ;
}
float _Engine : : get_frames_per_second ( ) const {
return Engine : : get_singleton ( ) - > get_frames_per_second ( ) ;
}
uint64_t _Engine : : get_physics_frames ( ) const {
return Engine : : get_singleton ( ) - > get_physics_frames ( ) ;
}
uint64_t _Engine : : get_idle_frames ( ) const {
return Engine : : get_singleton ( ) - > get_idle_frames ( ) ;
}
void _Engine : : set_time_scale ( float p_scale ) {
Engine : : get_singleton ( ) - > set_time_scale ( p_scale ) ;
}
float _Engine : : get_time_scale ( ) {
return Engine : : get_singleton ( ) - > get_time_scale ( ) ;
}
int _Engine : : get_frames_drawn ( ) {
return Engine : : get_singleton ( ) - > get_frames_drawn ( ) ;
}
MainLoop * _Engine : : get_main_loop ( ) const {
//needs to remain in OS, since it's actually OS that interacts with it, but it's better exposed here
return OS : : get_singleton ( ) - > get_main_loop ( ) ;
}
Dictionary _Engine : : get_version_info ( ) const {
return Engine : : get_singleton ( ) - > get_version_info ( ) ;
}
Dictionary _Engine : : get_author_info ( ) const {
return Engine : : get_singleton ( ) - > get_author_info ( ) ;
}
Array _Engine : : get_copyright_info ( ) const {
return Engine : : get_singleton ( ) - > get_copyright_info ( ) ;
}
Dictionary _Engine : : get_donor_info ( ) const {
return Engine : : get_singleton ( ) - > get_donor_info ( ) ;
}
Dictionary _Engine : : get_license_info ( ) const {
return Engine : : get_singleton ( ) - > get_license_info ( ) ;
}
String _Engine : : get_license_text ( ) const {
return Engine : : get_singleton ( ) - > get_license_text ( ) ;
}
bool _Engine : : is_in_physics_frame ( ) const {
return Engine : : get_singleton ( ) - > is_in_physics_frame ( ) ;
}
bool _Engine : : has_singleton ( const String & p_name ) const {
return Engine : : get_singleton ( ) - > has_singleton ( p_name ) ;
}
Object * _Engine : : get_singleton_object ( const String & p_name ) const {
return Engine : : get_singleton ( ) - > get_singleton_object ( p_name ) ;
}
void _Engine : : set_editor_hint ( bool p_enabled ) {
Engine : : get_singleton ( ) - > set_editor_hint ( p_enabled ) ;
}
bool _Engine : : is_editor_hint ( ) const {
return Engine : : get_singleton ( ) - > is_editor_hint ( ) ;
}
void _Engine : : set_print_error_messages ( bool p_enabled ) {
Engine : : get_singleton ( ) - > set_print_error_messages ( p_enabled ) ;
}
bool _Engine : : is_printing_error_messages ( ) const {
return Engine : : get_singleton ( ) - > is_printing_error_messages ( ) ;
}
void _Engine : : _bind_methods ( ) {
2022-03-24 11:10:56 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_physics_ticks_per_second " , " physics_ticks_per_second " ) , & _Engine : : set_physics_ticks_per_second ) ;
ClassDB : : bind_method ( D_METHOD ( " get_physics_ticks_per_second " ) , & _Engine : : get_physics_ticks_per_second ) ;
2022-03-15 13:29:32 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_physics_jitter_fix " , " physics_jitter_fix " ) , & _Engine : : set_physics_jitter_fix ) ;
ClassDB : : bind_method ( D_METHOD ( " get_physics_jitter_fix " ) , & _Engine : : get_physics_jitter_fix ) ;
ClassDB : : bind_method ( D_METHOD ( " get_physics_interpolation_fraction " ) , & _Engine : : get_physics_interpolation_fraction ) ;
ClassDB : : bind_method ( D_METHOD ( " set_target_fps " , " target_fps " ) , & _Engine : : set_target_fps ) ;
ClassDB : : bind_method ( D_METHOD ( " get_target_fps " ) , & _Engine : : get_target_fps ) ;
ClassDB : : bind_method ( D_METHOD ( " set_time_scale " , " time_scale " ) , & _Engine : : set_time_scale ) ;
ClassDB : : bind_method ( D_METHOD ( " get_time_scale " ) , & _Engine : : get_time_scale ) ;
ClassDB : : bind_method ( D_METHOD ( " get_frames_drawn " ) , & _Engine : : get_frames_drawn ) ;
ClassDB : : bind_method ( D_METHOD ( " get_frames_per_second " ) , & _Engine : : get_frames_per_second ) ;
ClassDB : : bind_method ( D_METHOD ( " get_physics_frames " ) , & _Engine : : get_physics_frames ) ;
ClassDB : : bind_method ( D_METHOD ( " get_idle_frames " ) , & _Engine : : get_idle_frames ) ;
ClassDB : : bind_method ( D_METHOD ( " get_main_loop " ) , & _Engine : : get_main_loop ) ;
ClassDB : : bind_method ( D_METHOD ( " get_version_info " ) , & _Engine : : get_version_info ) ;
ClassDB : : bind_method ( D_METHOD ( " get_author_info " ) , & _Engine : : get_author_info ) ;
ClassDB : : bind_method ( D_METHOD ( " get_copyright_info " ) , & _Engine : : get_copyright_info ) ;
ClassDB : : bind_method ( D_METHOD ( " get_donor_info " ) , & _Engine : : get_donor_info ) ;
ClassDB : : bind_method ( D_METHOD ( " get_license_info " ) , & _Engine : : get_license_info ) ;
ClassDB : : bind_method ( D_METHOD ( " get_license_text " ) , & _Engine : : get_license_text ) ;
ClassDB : : bind_method ( D_METHOD ( " is_in_physics_frame " ) , & _Engine : : is_in_physics_frame ) ;
ClassDB : : bind_method ( D_METHOD ( " has_singleton " , " name " ) , & _Engine : : has_singleton ) ;
ClassDB : : bind_method ( D_METHOD ( " get_singleton " , " name " ) , & _Engine : : get_singleton_object ) ;
ClassDB : : bind_method ( D_METHOD ( " set_editor_hint " , " enabled " ) , & _Engine : : set_editor_hint ) ;
ClassDB : : bind_method ( D_METHOD ( " is_editor_hint " ) , & _Engine : : is_editor_hint ) ;
ClassDB : : bind_method ( D_METHOD ( " set_print_error_messages " , " enabled " ) , & _Engine : : set_print_error_messages ) ;
ClassDB : : bind_method ( D_METHOD ( " is_printing_error_messages " ) , & _Engine : : is_printing_error_messages ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " editor_hint " ) , " set_editor_hint " , " is_editor_hint " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " print_error_messages " ) , " set_print_error_messages " , " is_printing_error_messages " ) ;
2022-03-24 11:10:56 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " physics_ticks_per_second " ) , " set_physics_ticks_per_second " , " get_physics_ticks_per_second " ) ;
2022-03-15 13:29:32 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " target_fps " ) , " set_target_fps " , " get_target_fps " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " time_scale " ) , " set_time_scale " , " get_time_scale " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : REAL , " physics_jitter_fix " ) , " set_physics_jitter_fix " , " get_physics_jitter_fix " ) ;
}
_Engine * _Engine : : singleton = nullptr ;
_Engine : : _Engine ( ) {
singleton = this ;
}
void JSONParseResult : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " get_error " ) , & JSONParseResult : : get_error ) ;
ClassDB : : bind_method ( D_METHOD ( " get_error_string " ) , & JSONParseResult : : get_error_string ) ;
ClassDB : : bind_method ( D_METHOD ( " get_error_line " ) , & JSONParseResult : : get_error_line ) ;
ClassDB : : bind_method ( D_METHOD ( " get_result " ) , & JSONParseResult : : get_result ) ;
ClassDB : : bind_method ( D_METHOD ( " set_error " , " error " ) , & JSONParseResult : : set_error ) ;
ClassDB : : bind_method ( D_METHOD ( " set_error_string " , " error_string " ) , & JSONParseResult : : set_error_string ) ;
ClassDB : : bind_method ( D_METHOD ( " set_error_line " , " error_line " ) , & JSONParseResult : : set_error_line ) ;
ClassDB : : bind_method ( D_METHOD ( " set_result " , " result " ) , & JSONParseResult : : set_result ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : OBJECT , " error " , PROPERTY_HINT_NONE , " Error " , PROPERTY_USAGE_CLASS_IS_ENUM ) , " set_error " , " get_error " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : STRING , " error_string " ) , " set_error_string " , " get_error_string " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " error_line " ) , " set_error_line " , " get_error_line " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : NIL , " result " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_NIL_IS_VARIANT ) , " set_result " , " get_result " ) ;
}
void JSONParseResult : : set_error ( Error p_error ) {
error = p_error ;
}
Error JSONParseResult : : get_error ( ) const {
return error ;
}
void JSONParseResult : : set_error_string ( const String & p_error_string ) {
error_string = p_error_string ;
}
String JSONParseResult : : get_error_string ( ) const {
return error_string ;
}
void JSONParseResult : : set_error_line ( int p_error_line ) {
error_line = p_error_line ;
}
int JSONParseResult : : get_error_line ( ) const {
return error_line ;
}
void JSONParseResult : : set_result ( const Variant & p_result ) {
result = p_result ;
}
Variant JSONParseResult : : get_result ( ) const {
return result ;
}
void _JSON : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " print " , " value " , " indent " , " sort_keys " ) , & _JSON : : print , DEFVAL ( String ( ) ) , DEFVAL ( false ) ) ;
ClassDB : : bind_method ( D_METHOD ( " parse " , " json " ) , & _JSON : : parse ) ;
}
String _JSON : : print ( const Variant & p_value , const String & p_indent , bool p_sort_keys ) {
return JSON : : print ( p_value , p_indent , p_sort_keys ) ;
}
Ref < JSONParseResult > _JSON : : parse ( const String & p_json ) {
Ref < JSONParseResult > result ;
result . instance ( ) ;
result - > error = JSON : : parse ( p_json , result - > result , result - > error_string , result - > error_line ) ;
if ( result - > error ! = OK ) {
ERR_PRINT ( vformat ( " Error parsing JSON at line %s: %s " , result - > error_line , result - > error_string ) ) ;
}
return result ;
}
_JSON * _JSON : : singleton = nullptr ;
_JSON : : _JSON ( ) {
singleton = this ;
}