2016-06-18 14:46:12 +02:00
/*************************************************************************/
/* core_bind.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
2017-08-27 14:16:55 +02:00
/* https://godotengine.org */
2016-06-18 14:46:12 +02:00
/*************************************************************************/
2020-01-01 11:16:22 +01:00
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
2016-06-18 14:46:12 +02:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
2018-01-05 00:50:27 +01:00
2014-02-10 02:10:30 +01:00
# include "core_bind.h"
2017-04-28 18:29:15 +02:00
2019-07-11 15:21:47 +02:00
# include "core/crypto/crypto_core.h"
2018-09-11 18:13:45 +02:00
# 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"
# include "core/os/keyboard.h"
# include "core/os/os.h"
2017-07-19 22:00:46 +02:00
# include "core/project_settings.h"
2016-03-04 07:31:27 +01:00
/**
* Time constants borrowed from loc_time . h
*/
2017-03-05 16:44:50 +01:00
# 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)
2016-03-16 05:17:10 +01:00
# 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 }
} ;
2016-03-04 07:31:27 +01:00
2017-03-05 16:44:50 +01:00
_ResourceLoader * _ResourceLoader : : singleton = NULL ;
2014-02-10 02:10:30 +01:00
2020-02-28 12:27:04 +01:00
Error _ResourceLoader : : load_threaded_request ( const String & p_path , const String & p_type_hint , bool p_use_sub_threads ) {
return ResourceLoader : : load_threaded_request ( p_path , p_type_hint , p_use_sub_threads ) ;
}
_ResourceLoader : : ThreadLoadStatus _ResourceLoader : : load_threaded_get_status ( const String & p_path , Array r_progress ) {
float progress = 0 ;
ResourceLoader : : ThreadLoadStatus tls = ResourceLoader : : load_threaded_get_status ( p_path , & progress ) ;
r_progress . resize ( 1 ) ;
r_progress [ 0 ] = progress ;
return ( ThreadLoadStatus ) tls ;
}
RES _ResourceLoader : : load_threaded_get ( const String & p_path ) {
Error error ;
RES res = ResourceLoader : : load_threaded_get ( p_path , & error ) ;
return res ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
RES _ResourceLoader : : load ( const String & p_path , const String & p_type_hint , bool p_no_cache ) {
2014-02-10 02:10:30 +01:00
2018-01-05 21:35:48 +01:00
Error err = OK ;
RES ret = ResourceLoader : : load ( p_path , p_type_hint , p_no_cache , & err ) ;
2019-08-15 04:57:49 +02:00
ERR_FAIL_COND_V_MSG ( err ! = OK , ret , " Error loading resource: ' " + p_path + " '. " ) ;
2014-02-10 02:10:30 +01:00
return ret ;
}
2020-02-17 22:06:54 +01:00
Vector < String > _ResourceLoader : : get_recognized_extensions_for_type ( const String & p_type ) {
2014-02-10 02:10:30 +01:00
List < String > exts ;
2017-03-05 16:44:50 +01:00
ResourceLoader : : get_recognized_extensions_for_type ( p_type , & exts ) ;
2020-02-17 22:06:54 +01:00
Vector < String > ret ;
2017-03-05 16:44:50 +01:00
for ( List < String > : : Element * E = exts . front ( ) ; E ; E = E - > next ( ) ) {
2014-02-10 02:10:30 +01:00
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 ) ;
}
2020-02-17 22:06:54 +01:00
PackedStringArray _ResourceLoader : : get_dependencies ( const String & p_path ) {
2014-02-10 02:10:30 +01:00
List < String > deps ;
ResourceLoader : : get_dependencies ( p_path , & deps ) ;
2020-02-17 22:06:54 +01:00
PackedStringArray ret ;
2017-03-05 16:44:50 +01:00
for ( List < String > : : Element * E = deps . front ( ) ; E ; E = E - > next ( ) ) {
2014-02-10 02:10:30 +01:00
ret . push_back ( E - > get ( ) ) ;
}
return ret ;
} ;
2018-08-10 20:57:43 +02:00
bool _ResourceLoader : : has_cached ( const String & p_path ) {
2014-02-10 02:10:30 +01:00
2017-07-19 22:00:46 +02:00
String local_path = ProjectSettings : : get_singleton ( ) - > localize_path ( p_path ) ;
2014-02-10 02:10:30 +01:00
return ResourceCache : : has ( local_path ) ;
2018-08-10 20:57:43 +02:00
}
bool _ResourceLoader : : exists ( const String & p_path , const String & p_type_hint ) {
return ResourceLoader : : exists ( p_path , p_type_hint ) ;
}
2014-02-10 02:10:30 +01:00
void _ResourceLoader : : _bind_methods ( ) {
2020-02-28 12:27:04 +01:00
ClassDB : : bind_method ( D_METHOD ( " load_threaded_request " , " path " , " type_hint " , " use_sub_threads " ) , & _ResourceLoader : : load_threaded_request , DEFVAL ( " " ) , DEFVAL ( false ) ) ;
2020-02-29 14:22:57 +01:00
ClassDB : : bind_method ( D_METHOD ( " load_threaded_get_status " , " path " , " progress " ) , & _ResourceLoader : : load_threaded_get_status , DEFVAL ( Array ( ) ) ) ;
2020-02-28 12:27:04 +01:00
ClassDB : : bind_method ( D_METHOD ( " load_threaded_get " , " path " ) , & _ResourceLoader : : load_threaded_get ) ;
2018-12-27 11:10:09 +01:00
ClassDB : : bind_method ( D_METHOD ( " load " , " path " , " type_hint " , " no_cache " ) , & _ResourceLoader : : load , DEFVAL ( " " ) , DEFVAL ( false ) ) ;
2017-03-05 16:44:50 +01:00
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 ) ;
2018-08-10 20:57:43 +02:00
ClassDB : : bind_method ( D_METHOD ( " has_cached " , " path " ) , & _ResourceLoader : : has_cached ) ;
ClassDB : : bind_method ( D_METHOD ( " exists " , " path " , " type_hint " ) , & _ResourceLoader : : exists , DEFVAL ( " " ) ) ;
2020-02-28 12:27:04 +01:00
BIND_ENUM_CONSTANT ( THREAD_LOAD_INVALID_RESOURCE ) ;
BIND_ENUM_CONSTANT ( THREAD_LOAD_IN_PROGRESS ) ;
BIND_ENUM_CONSTANT ( THREAD_LOAD_FAILED ) ;
BIND_ENUM_CONSTANT ( THREAD_LOAD_LOADED ) ;
2014-02-10 02:10:30 +01:00
}
_ResourceLoader : : _ResourceLoader ( ) {
2017-03-05 16:44:50 +01:00
singleton = this ;
2014-02-10 02:10:30 +01:00
}
2019-04-07 18:52:39 +02:00
Error _ResourceSaver : : save ( const String & p_path , const RES & p_resource , SaverFlags p_flags ) {
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( p_resource . is_null ( ) , ERR_INVALID_PARAMETER , " Can't save empty resource to path ' " + String ( p_path ) + " '. " ) ;
2017-03-05 16:44:50 +01:00
return ResourceSaver : : save ( p_path , p_resource , p_flags ) ;
2014-02-10 02:10:30 +01:00
}
2020-02-17 22:06:54 +01:00
Vector < String > _ResourceSaver : : get_recognized_extensions ( const RES & p_resource ) {
2014-02-10 02:10:30 +01:00
2020-02-17 22:06:54 +01:00
ERR_FAIL_COND_V_MSG ( p_resource . is_null ( ) , Vector < String > ( ) , " It's not a reference to a valid Resource object. " ) ;
2014-02-10 02:10:30 +01:00
List < String > exts ;
2017-03-05 16:44:50 +01:00
ResourceSaver : : get_recognized_extensions ( p_resource , & exts ) ;
2020-02-17 22:06:54 +01:00
Vector < String > ret ;
2017-03-05 16:44:50 +01:00
for ( List < String > : : Element * E = exts . front ( ) ; E ; E = E - > next ( ) ) {
2014-02-10 02:10:30 +01:00
ret . push_back ( E - > get ( ) ) ;
}
return ret ;
}
2017-03-05 16:44:50 +01:00
_ResourceSaver * _ResourceSaver : : singleton = NULL ;
2014-02-10 02:10:30 +01:00
void _ResourceSaver : : _bind_methods ( ) {
2017-08-09 13:19:41 +02:00
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 ) ;
2014-05-24 06:35:47 +02:00
2017-08-20 17:45:01 +02:00
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 ) ;
2018-10-18 16:58:44 +02:00
BIND_ENUM_CONSTANT ( FLAG_REPLACE_SUBRESOURCE_PATHS ) ;
2014-02-10 02:10:30 +01:00
}
_ResourceSaver : : _ResourceSaver ( ) {
2017-03-05 16:44:50 +01:00
singleton = this ;
2014-02-10 02:10:30 +01:00
}
2020-02-17 22:06:54 +01:00
PackedStringArray _OS : : get_connected_midi_inputs ( ) {
2018-07-14 14:11:28 +02:00
return OS : : get_singleton ( ) - > get_connected_midi_inputs ( ) ;
}
2018-08-04 02:17:33 +02:00
void _OS : : open_midi_inputs ( ) {
2019-07-01 12:59:42 +02:00
OS : : get_singleton ( ) - > open_midi_inputs ( ) ;
2018-08-04 02:17:33 +02:00
}
void _OS : : close_midi_inputs ( ) {
2019-07-01 12:59:42 +02:00
OS : : get_singleton ( ) - > close_midi_inputs ( ) ;
2018-08-04 02:17:33 +02:00
}
2014-08-02 03:10:38 +02:00
void _OS : : set_use_file_access_save_and_swap ( bool p_enable ) {
FileAccess : : set_backup_save ( p_enable ) ;
}
2014-02-10 02:10:30 +01:00
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 ( ) ;
}
2019-11-08 18:36:06 +01:00
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 ( ) ;
}
2014-02-10 02:10:30 +01:00
String _OS : : get_executable_path ( ) const {
return OS : : get_singleton ( ) - > get_executable_path ( ) ;
}
Error _OS : : shell_open ( String p_uri ) {
return OS : : get_singleton ( ) - > shell_open ( p_uri ) ;
} ;
2019-03-01 23:51:53 +01:00
int _OS : : execute ( const String & p_path , const Vector < String > & p_arguments , bool p_blocking , Array p_output , bool p_read_stderr ) {
2014-02-10 02:10:30 +01:00
2018-05-30 12:18:01 +02:00
OS : : ProcessID pid = - 2 ;
2019-09-07 19:39:24 +02:00
int exitcode = 0 ;
2014-02-10 02:10:30 +01:00
List < String > args ;
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < p_arguments . size ( ) ; i + + )
2014-02-10 02:10:30 +01:00
args . push_back ( p_arguments [ i ] ) ;
String pipe ;
2019-09-07 19:39:24 +02:00
Error err = OS : : get_singleton ( ) - > execute ( p_path , args , p_blocking , & pid , & pipe , & exitcode , p_read_stderr ) ;
2014-06-30 04:24:05 +02:00
p_output . clear ( ) ;
p_output . push_back ( pipe ) ;
2014-02-10 02:10:30 +01:00
if ( err ! = OK )
return - 1 ;
2019-09-07 19:39:24 +02:00
else if ( p_blocking )
return exitcode ;
2014-02-10 02:10:30 +01:00
else
return pid ;
}
2018-05-30 12:18:01 +02:00
2014-02-10 02:10:30 +01:00
Error _OS : : kill ( int p_pid ) {
return OS : : get_singleton ( ) - > kill ( p_pid ) ;
}
2017-08-07 12:17:31 +02:00
int _OS : : get_process_id ( ) const {
2014-04-05 17:39:30 +02:00
2017-08-07 12:17:31 +02:00
return OS : : get_singleton ( ) - > get_process_id ( ) ;
2014-04-05 17:39:30 +02:00
} ;
2017-03-05 16:44:50 +01:00
bool _OS : : has_environment ( const String & p_var ) const {
2014-02-10 02:10:30 +01:00
return OS : : get_singleton ( ) - > has_environment ( p_var ) ;
}
2017-03-05 16:44:50 +01:00
String _OS : : get_environment ( const String & p_var ) const {
2014-02-10 02:10:30 +01:00
return OS : : get_singleton ( ) - > get_environment ( p_var ) ;
}
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 ;
2017-03-05 16:44:50 +01:00
for ( List < String > : : Element * E = cmdline . front ( ) ; E ; E = E - > next ( ) ) {
2014-02-10 02:10:30 +01:00
cmdlinev . push_back ( E - > get ( ) ) ;
}
return cmdlinev ;
}
String _OS : : get_locale ( ) const {
return OS : : get_singleton ( ) - > get_locale ( ) ;
}
String _OS : : get_model_name ( ) const {
2017-01-14 17:01:43 +01:00
return OS : : get_singleton ( ) - > get_model_name ( ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
Error _OS : : set_thread_name ( const String & p_name ) {
2016-02-01 00:22:38 +01:00
return Thread : : set_name ( p_name ) ;
} ;
2017-10-02 21:38:39 +02:00
bool _OS : : has_feature ( const String & p_feature ) const {
return OS : : get_singleton ( ) - > has_feature ( p_feature ) ;
}
2014-02-10 02:10:30 +01:00
/*
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 ;
} ;
*/
2019-01-30 19:07:46 +01:00
uint64_t _OS : : get_static_memory_usage ( ) const {
2014-02-10 02:10:30 +01:00
return OS : : get_singleton ( ) - > get_static_memory_usage ( ) ;
}
2019-01-30 19:07:46 +01:00
uint64_t _OS : : get_static_memory_peak_usage ( ) const {
2014-02-10 02:10:30 +01:00
return OS : : get_singleton ( ) - > get_static_memory_peak_usage ( ) ;
}
2017-01-07 18:55:48 +01:00
int _OS : : get_exit_code ( ) const {
return OS : : get_singleton ( ) - > get_exit_code ( ) ;
}
void _OS : : set_exit_code ( int p_code ) {
2019-12-29 16:55:16 +01:00
if ( p_code < 0 | | p_code > 125 ) {
WARN_PRINT ( " For portability reasons, the exit code should be set between 0 and 125 (inclusive). " ) ;
}
2017-01-07 18:55:48 +01:00
OS : : get_singleton ( ) - > set_exit_code ( p_code ) ;
}
2016-03-16 05:17:10 +01:00
/**
2016-05-21 15:29:25 +02:00
* Get current datetime with consideration for utc and
2016-03-16 05:17:10 +01:00
* dst
2016-05-21 15:29:25 +02:00
*/
2016-03-16 05:17:10 +01:00
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 ) ;
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < keys . size ( ) ; i + + ) {
2016-03-16 05:17:10 +01:00
dated [ keys [ i ] ] = timed [ keys [ i ] ] ;
}
return dated ;
}
2015-06-06 03:40:56 +02:00
Dictionary _OS : : get_date ( bool utc ) const {
2014-02-10 02:10:30 +01:00
2015-06-06 03:40:56 +02:00
OS : : Date date = OS : : get_singleton ( ) - > get_date ( utc ) ;
2014-02-10 02:10:30 +01:00
Dictionary dated ;
2017-03-05 16:44:50 +01:00
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 ;
2014-02-10 02:10:30 +01:00
return dated ;
}
2016-03-04 07:31:27 +01:00
2015-06-06 03:40:56 +02:00
Dictionary _OS : : get_time ( bool utc ) const {
2014-02-10 02:10:30 +01:00
2015-06-06 03:40:56 +02:00
OS : : Time time = OS : : get_singleton ( ) - > get_time ( utc ) ;
2014-02-10 02:10:30 +01:00
Dictionary timed ;
2017-03-05 16:44:50 +01:00
timed [ HOUR_KEY ] = time . hour ;
timed [ MINUTE_KEY ] = time . min ;
timed [ SECOND_KEY ] = time . sec ;
2014-02-10 02:10:30 +01:00
return timed ;
2016-03-04 07:31:27 +01:00
}
2016-03-16 05:17:10 +01:00
/**
2017-09-02 16:19:06 +02:00
* Get an epoch time value from a dictionary of time values
2016-03-16 05:17:10 +01:00
* @ 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
*/
2018-08-09 08:19:19 +02:00
int64_t _OS : : get_unix_time_from_datetime ( Dictionary datetime ) const {
2016-03-16 05:17:10 +01:00
// 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 ;
2017-01-14 17:55:06 +01:00
static const unsigned int SECONDS_PER_HOUR = MINUTES_PER_HOUR * SECONDS_PER_MINUTE ;
2016-03-16 05:17:10 +01:00
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
2017-03-05 16:44:50 +01:00
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 ) ;
2018-04-16 11:15:17 +02:00
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 ) ;
2017-03-05 16:44:50 +01:00
unsigned int year = ( ( datetime . has ( YEAR_KEY ) ) ? static_cast < unsigned int > ( datetime [ YEAR_KEY ] ) : 0 ) ;
2016-03-16 05:17:10 +01:00
/// How many days come before each month (0-12)
2017-01-14 17:51:21 +01:00
static const unsigned short int DAYS_PAST_THIS_YEAR_TABLE [ 2 ] [ 13 ] = {
2016-03-16 05:17:10 +01:00
/* 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 }
} ;
2019-08-15 04:57:49 +02:00
ERR_FAIL_COND_V_MSG ( second > 59 , 0 , " Invalid second value of: " + itos ( second ) + " . " ) ;
2016-03-16 05:17:10 +01:00
2019-08-15 04:57:49 +02:00
ERR_FAIL_COND_V_MSG ( minute > 59 , 0 , " Invalid minute value of: " + itos ( minute ) + " . " ) ;
2016-03-16 05:17:10 +01:00
2019-08-15 04:57:49 +02:00
ERR_FAIL_COND_V_MSG ( hour > 23 , 0 , " Invalid hour value of: " + itos ( hour ) + " . " ) ;
2016-03-16 05:17:10 +01:00
2019-08-15 04:57:49 +02:00
ERR_FAIL_COND_V_MSG ( month > 12 | | month = = 0 , 0 , " Invalid month value of: " + itos ( month ) + " . " ) ;
2016-03-16 05:17:10 +01:00
// Do this check after month is tested as valid
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( day > MONTH_DAYS_TABLE [ LEAPYEAR ( year ) ] [ month - 1 ] | | day = = 0 , 0 , " Invalid day value of ' " + itos ( day ) + " ' which is larger than ' " + itos ( MONTH_DAYS_TABLE [ LEAPYEAR ( year ) ] [ month - 1 ] ) + " ' or 0. " ) ;
2016-03-16 05:17:10 +01:00
// Calculate all the seconds from months past in this year
2018-04-16 11:15:17 +02:00
uint64_t SECONDS_FROM_MONTHS_PAST_THIS_YEAR = DAYS_PAST_THIS_YEAR_TABLE [ LEAPYEAR ( year ) ] [ month - 1 ] * SECONDS_PER_DAY ;
2016-03-16 05:17:10 +01:00
2018-08-09 08:19:19 +02:00
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 ;
}
2016-03-16 05:17:10 +01:00
}
2018-08-09 08:19:19 +02:00
int64_t epoch =
2017-03-05 16:44:50 +01:00
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 ;
2016-03-16 05:17:10 +01:00
return epoch ;
}
2016-03-04 07:31:27 +01:00
/**
2016-03-13 03:13:57 +01:00
* Get a dictionary of time values when given epoch time
2016-03-04 07:31:27 +01:00
*
* Dictionary Time values will be a union if values from # get_time
2016-05-21 15:29:25 +02:00
* and # get_date dictionaries ( with the exception of dst =
2016-03-13 03:13:57 +01:00
* day light standard time , as it cannot be determined from epoch )
2016-03-16 05:17:10 +01:00
*
* @ param unix_time_val epoch time to convert
*
* @ return dictionary of date and time values
2016-03-04 07:31:27 +01:00
*/
2018-08-09 08:19:19 +02:00
Dictionary _OS : : get_datetime_from_unix_time ( int64_t unix_time_val ) const {
2016-03-04 07:31:27 +01:00
OS : : Date date ;
OS : : Time time ;
2018-08-09 08:19:19 +02:00
long dayclock , dayno ;
2016-03-04 07:31:27 +01:00
int year = EPOCH_YR ;
2018-08-09 08:19:19 +02:00
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 - 3 ) % 7 + 7 ) ;
do {
year - - ;
dayno + = YEARSIZE ( year ) ;
} while ( dayno < 0 ) ;
}
2016-03-04 07:31:27 +01:00
time . sec = dayclock % 60 ;
time . min = ( dayclock % 3600 ) / 60 ;
time . hour = dayclock / 3600 ;
2016-05-21 15:29:25 +02:00
date . year = year ;
2016-03-04 07:31:27 +01:00
size_t imonth = 0 ;
2019-02-27 10:07:30 +01:00
while ( ( unsigned long ) dayno > = MONTH_DAYS_TABLE [ LEAPYEAR ( year ) ] [ imonth ] ) {
2016-03-16 05:17:10 +01:00
dayno - = MONTH_DAYS_TABLE [ LEAPYEAR ( year ) ] [ imonth ] ;
2016-03-04 07:31:27 +01:00
imonth + + ;
}
2016-03-13 03:13:57 +01:00
/// Add 1 to month to make sure months are indexed starting at 1
2017-03-05 16:44:50 +01:00
date . month = static_cast < OS : : Month > ( imonth + 1 ) ;
2016-03-04 07:31:27 +01:00
date . day = dayno + 1 ;
Dictionary timed ;
2017-03-05 16:44:50 +01:00
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 ;
2016-03-04 07:31:27 +01:00
return timed ;
2014-02-10 02:10:30 +01:00
}
2015-06-06 05:35:38 +02:00
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 ;
}
2014-02-10 02:10:30 +01:00
uint64_t _OS : : get_unix_time ( ) const {
return OS : : get_singleton ( ) - > get_unix_time ( ) ;
2016-03-16 05:17:10 +01:00
}
2014-02-10 02:10:30 +01:00
2016-01-10 22:24:55 +01:00
uint64_t _OS : : get_system_time_secs ( ) const {
return OS : : get_singleton ( ) - > get_system_time_secs ( ) ;
2015-08-06 19:29:33 +02:00
}
2018-12-19 22:18:52 +01:00
uint64_t _OS : : get_system_time_msecs ( ) const {
return OS : : get_singleton ( ) - > get_system_time_msecs ( ) ;
}
2014-02-10 02:10:30 +01:00
void _OS : : delay_usec ( uint32_t p_usec ) const {
OS : : get_singleton ( ) - > delay_usec ( p_usec ) ;
}
void _OS : : delay_msec ( uint32_t p_msec ) const {
2017-03-05 16:44:50 +01:00
OS : : get_singleton ( ) - > delay_usec ( int64_t ( p_msec ) * 1000 ) ;
2014-02-10 02:10:30 +01:00
}
uint32_t _OS : : get_ticks_msec ( ) const {
return OS : : get_singleton ( ) - > get_ticks_msec ( ) ;
}
2018-06-17 18:10:41 +02:00
uint64_t _OS : : get_ticks_usec ( ) const {
return OS : : get_singleton ( ) - > get_ticks_usec ( ) ;
}
2015-04-12 22:55:01 +02:00
uint32_t _OS : : get_splash_tick_msec ( ) const {
return OS : : get_singleton ( ) - > get_splash_tick_msec ( ) ;
}
2014-03-14 02:57:24 +01:00
bool _OS : : can_use_threads ( ) const {
return OS : : get_singleton ( ) - > can_use_threads ( ) ;
}
2017-10-02 16:09:24 +02:00
bool _OS : : is_userfs_persistent ( ) const {
return OS : : get_singleton ( ) - > is_userfs_persistent ( ) ;
}
2014-02-10 02:10:30 +01:00
int _OS : : get_processor_count ( ) const {
return OS : : get_singleton ( ) - > get_processor_count ( ) ;
}
bool _OS : : is_stdout_verbose ( ) const {
return OS : : get_singleton ( ) - > is_stdout_verbose ( ) ;
}
2017-03-05 16:44:50 +01:00
void _OS : : dump_memory_to_file ( const String & p_file ) {
2014-02-10 02:10:30 +01:00
OS : : get_singleton ( ) - > dump_memory_to_file ( p_file . utf8 ( ) . get_data ( ) ) ;
}
2014-02-26 14:08:17 +01:00
struct _OSCoreBindImg {
String path ;
Size2 size ;
int fmt ;
ObjectID id ;
int vram ;
2017-03-05 16:44:50 +01:00
bool operator < ( const _OSCoreBindImg & p_img ) const { return vram = = p_img . vram ? id < p_img . id : vram > p_img . vram ; }
2014-02-26 14:08:17 +01:00
} ;
void _OS : : print_all_textures_by_size ( ) {
List < _OSCoreBindImg > imgs ;
2017-03-05 16:44:50 +01:00
int total = 0 ;
2014-02-26 14:08:17 +01:00
{
2020-03-17 07:33:00 +01:00
List < Ref < Resource > > rsrc ;
2014-02-26 14:08:17 +01:00
ResourceCache : : get_cached_resources ( & rsrc ) ;
2020-03-17 07:33:00 +01:00
for ( List < Ref < Resource > > : : Element * E = rsrc . front ( ) ; E ; E = E - > next ( ) ) {
2014-02-26 14:08:17 +01:00
2017-01-03 03:03:46 +01:00
if ( ! E - > get ( ) - > is_class ( " ImageTexture " ) )
2014-02-26 14:08:17 +01:00
continue ;
Size2 size = E - > get ( ) - > call ( " get_size " ) ;
int fmt = E - > get ( ) - > call ( " get_format " ) ;
_OSCoreBindImg img ;
2017-03-05 16:44:50 +01:00
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 ) ) ;
2017-08-07 12:17:31 +02:00
img . id = E - > get ( ) - > get_instance_id ( ) ;
2017-03-05 16:44:50 +01:00
total + = img . vram ;
2014-02-26 14:08:17 +01:00
imgs . push_back ( img ) ;
}
}
imgs . sort ( ) ;
2017-03-05 16:44:50 +01:00
for ( List < _OSCoreBindImg > : : Element * E = imgs . front ( ) ; E ; E = E - > next ( ) ) {
2014-02-26 14:08:17 +01:00
2017-03-05 16:44:50 +01:00
total - = E - > get ( ) . vram ;
2014-02-26 14:08:17 +01:00
}
2014-05-14 06:22:15 +02:00
}
2014-02-26 14:08:17 +01:00
2017-03-05 16:44:50 +01:00
void _OS : : print_resources_by_type ( const Vector < String > & p_types ) {
2014-02-26 14:08:17 +01:00
2017-03-05 16:44:50 +01:00
Map < String , int > type_count ;
2014-05-14 06:22:15 +02:00
2020-03-17 07:33:00 +01:00
List < Ref < Resource > > resources ;
2014-05-14 06:22:15 +02:00
ResourceCache : : get_cached_resources ( & resources ) ;
2020-03-17 07:33:00 +01:00
List < Ref < Resource > > rsrc ;
2014-05-14 06:22:15 +02:00
ResourceCache : : get_cached_resources ( & rsrc ) ;
2020-03-17 07:33:00 +01:00
for ( List < Ref < Resource > > : : Element * E = rsrc . front ( ) ; E ; E = E - > next ( ) ) {
2014-05-14 06:22:15 +02:00
Ref < Resource > r = E - > get ( ) ;
bool found = false ;
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < p_types . size ( ) ; i + + ) {
2017-01-03 03:03:46 +01:00
if ( r - > is_class ( p_types [ i ] ) )
2014-05-14 06:22:15 +02:00
found = true ;
}
if ( ! found )
continue ;
2017-01-03 03:03:46 +01:00
if ( ! type_count . has ( r - > get_class ( ) ) ) {
2017-03-05 16:44:50 +01:00
type_count [ r - > get_class ( ) ] = 0 ;
2014-05-14 06:22:15 +02:00
}
2017-01-03 03:03:46 +01:00
type_count [ r - > get_class ( ) ] + + ;
2014-05-14 06:22:15 +02:00
}
} ;
2014-02-26 14:08:17 +01:00
2017-03-05 16:44:50 +01:00
void _OS : : print_all_resources ( const String & p_to_file ) {
2014-02-10 02:10:30 +01:00
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 ) ;
}
2017-03-05 16:44:50 +01:00
void _OS : : dump_resources_to_file ( const String & p_file ) {
2014-02-10 02:10:30 +01:00
OS : : get_singleton ( ) - > dump_resources_to_file ( p_file . utf8 ( ) . get_data ( ) ) ;
}
2017-11-17 15:25:22 +01:00
String _OS : : get_user_data_dir ( ) const {
2014-02-10 02:10:30 +01:00
2017-11-17 15:25:22 +01:00
return OS : : get_singleton ( ) - > get_user_data_dir ( ) ;
2014-02-10 02:10:30 +01:00
} ;
2014-11-02 15:31:01 +01:00
bool _OS : : is_debug_build ( ) const {
2014-03-14 02:57:24 +01:00
2014-11-02 15:31:01 +01:00
# ifdef DEBUG_ENABLED
return true ;
# else
return false ;
# endif
}
2014-12-02 18:02:41 +01:00
String _OS : : get_system_dir ( SystemDir p_dir ) const {
return OS : : get_singleton ( ) - > get_system_dir ( OS : : SystemDir ( p_dir ) ) ;
}
2018-04-05 19:59:35 +02:00
String _OS : : get_keycode_string ( uint32_t p_code ) const {
2015-05-17 18:11:55 +02:00
return keycode_get_string ( p_code ) ;
}
2018-04-05 19:59:35 +02:00
bool _OS : : is_keycode_unicode ( uint32_t p_unicode ) const {
2015-05-17 18:11:55 +02:00
return keycode_has_unicode ( p_unicode ) ;
}
2018-04-05 19:59:35 +02:00
int _OS : : find_keycode_from_string ( const String & p_code ) const {
2015-05-17 18:11:55 +02:00
return find_keycode ( p_code ) ;
}
2019-03-05 03:06:37 +01:00
bool _OS : : request_permission ( const String & p_name ) {
return OS : : get_singleton ( ) - > request_permission ( p_name ) ;
}
2019-10-06 20:17:44 +02:00
bool _OS : : request_permissions ( ) {
return OS : : get_singleton ( ) - > request_permissions ( ) ;
}
Vector < String > _OS : : get_granted_permissions ( ) const {
return OS : : get_singleton ( ) - > get_granted_permissions ( ) ;
}
2020-03-03 14:36:29 +01:00
String _OS : : get_unique_id ( ) const {
return OS : : get_singleton ( ) - > get_unique_id ( ) ;
}
2017-03-05 16:44:50 +01:00
_OS * _OS : : singleton = NULL ;
2014-02-10 02:10:30 +01:00
void _OS : : _bind_methods ( ) {
2018-07-14 14:11:28 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_connected_midi_inputs " ) , & _OS : : get_connected_midi_inputs ) ;
2018-08-04 02:17:33 +02:00
ClassDB : : bind_method ( D_METHOD ( " open_midi_inputs " ) , & _OS : : open_midi_inputs ) ;
ClassDB : : bind_method ( D_METHOD ( " close_midi_inputs " ) , & _OS : : close_midi_inputs ) ;
2018-03-04 18:18:05 +01:00
2017-03-05 16:44:50 +01:00
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 ) ;
2017-02-13 12:47:24 +01:00
2019-11-08 18:36:06 +01:00
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 ) ;
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_processor_count " ) , & _OS : : get_processor_count ) ;
2017-02-13 12:47:24 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_executable_path " ) , & _OS : : get_executable_path ) ;
2020-01-23 01:25:47 +01:00
ClassDB : : bind_method ( D_METHOD ( " execute " , " path " , " arguments " , " blocking " , " output " , " read_stderr " ) , & _OS : : execute , DEFVAL ( true ) , DEFVAL ( Array ( ) ) , DEFVAL ( false ) ) ;
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " kill " , " pid " ) , & _OS : : kill ) ;
ClassDB : : bind_method ( D_METHOD ( " shell_open " , " uri " ) , & _OS : : shell_open ) ;
2017-08-07 12:17:31 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_process_id " ) , & _OS : : get_process_id ) ;
2017-02-13 12:47:24 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_environment " , " environment " ) , & _OS : : get_environment ) ;
ClassDB : : bind_method ( D_METHOD ( " has_environment " , " environment " ) , & _OS : : has_environment ) ;
2017-02-13 12:47:24 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_name " ) , & _OS : : get_name ) ;
ClassDB : : bind_method ( D_METHOD ( " get_cmdline_args " ) , & _OS : : get_cmdline_args ) ;
2017-02-13 12:47:24 +01:00
2017-03-05 16:44:50 +01:00
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 ) ;
2017-09-10 15:37:49 +02:00
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 ) ;
2017-02-13 12:47:24 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_system_time_secs " ) , & _OS : : get_system_time_secs ) ;
2018-12-19 22:18:52 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_system_time_msecs " ) , & _OS : : get_system_time_msecs ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
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 ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
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 ) ;
2018-06-17 18:10:41 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_ticks_usec " ) , & _OS : : get_ticks_usec ) ;
2017-03-05 16:44:50 +01:00
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_model_name " ) , & _OS : : get_model_name ) ;
2014-02-10 02:10:30 +01:00
2017-10-02 16:09:24 +02:00
ClassDB : : bind_method ( D_METHOD ( " is_userfs_persistent " ) , & _OS : : is_userfs_persistent ) ;
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " is_stdout_verbose " ) , & _OS : : is_stdout_verbose ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " can_use_threads " ) , & _OS : : can_use_threads ) ;
2014-03-14 02:57:24 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " is_debug_build " ) , & _OS : : is_debug_build ) ;
2014-11-02 15:31:01 +01:00
2017-02-13 12:47:24 +01:00
//ClassDB::bind_method(D_METHOD("get_mouse_button_state"),&_OS::get_mouse_button_state);
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
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 ( " 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 ) ;
2017-11-17 15:25:22 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_user_data_dir " ) , & _OS : : get_user_data_dir ) ;
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_system_dir " , " dir " ) , & _OS : : get_system_dir ) ;
2017-08-07 12:17:31 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_unique_id " ) , & _OS : : get_unique_id ) ;
2017-03-05 16:44:50 +01:00
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 ) ;
2018-04-05 19:59:35 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_keycode_string " , " code " ) , & _OS : : get_keycode_string ) ;
ClassDB : : bind_method ( D_METHOD ( " is_keycode_unicode " , " code " ) , & _OS : : is_keycode_unicode ) ;
ClassDB : : bind_method ( D_METHOD ( " find_keycode_from_string " , " string " ) , & _OS : : find_keycode_from_string ) ;
2017-03-05 16:44:50 +01:00
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 ( " set_thread_name " , " name " ) , & _OS : : set_thread_name ) ;
2017-10-02 21:38:39 +02:00
ClassDB : : bind_method ( D_METHOD ( " has_feature " , " tag_name " ) , & _OS : : has_feature ) ;
2019-03-05 03:06:37 +01:00
ClassDB : : bind_method ( D_METHOD ( " request_permission " , " name " ) , & _OS : : request_permission ) ;
2019-10-06 20:17:44 +02:00
ClassDB : : bind_method ( D_METHOD ( " request_permissions " ) , & _OS : : request_permissions ) ;
ClassDB : : bind_method ( D_METHOD ( " get_granted_permissions " ) , & _OS : : get_granted_permissions ) ;
2019-03-05 03:06:37 +01:00
2018-01-11 23:35:12 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " exit_code " ) , " set_exit_code " , " get_exit_code " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " low_processor_usage_mode " ) , " set_low_processor_usage_mode " , " is_in_low_processor_usage_mode " ) ;
2019-11-08 18:36:06 +01:00
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 " ) ;
2018-01-11 23:35:12 +01:00
2019-06-30 13:19:00 +02:00
// 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 ( " exit_code " , 0 ) ;
ADD_PROPERTY_DEFAULT ( " low_processor_usage_mode " , false ) ;
2019-11-08 18:36:06 +01:00
ADD_PROPERTY_DEFAULT ( " low_processor_usage_mode_sleep_usec " , 6900 ) ;
2019-06-30 13:19:00 +02:00
2019-02-16 14:40:52 +01:00
BIND_ENUM_CONSTANT ( VIDEO_DRIVER_GLES2 ) ;
2020-02-13 10:08:52 +01:00
BIND_ENUM_CONSTANT ( VIDEO_DRIVER_VULKAN ) ;
2019-02-16 14:40:52 +01:00
2017-08-20 17:45:01 +02:00
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 ( 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 ) ;
2014-02-10 02:10:30 +01:00
}
_OS : : _OS ( ) {
2017-03-05 16:44:50 +01:00
singleton = this ;
2014-02-10 02:10:30 +01:00
}
///////////////////// GEOMETRY
2017-03-05 16:44:50 +01:00
_Geometry * _Geometry : : singleton = NULL ;
2014-02-10 02:10:30 +01:00
_Geometry * _Geometry : : get_singleton ( ) {
return singleton ;
}
2020-02-17 22:06:54 +01:00
Vector < Plane > _Geometry : : build_box_planes ( const Vector3 & p_extents ) {
2014-02-10 02:10:30 +01:00
return Geometry : : build_box_planes ( p_extents ) ;
}
2020-02-17 22:06:54 +01:00
Vector < Plane > _Geometry : : build_cylinder_planes ( float p_radius , float p_height , int p_sides , Vector3 : : Axis p_axis ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
return Geometry : : build_cylinder_planes ( p_radius , p_height , p_sides , p_axis ) ;
2014-02-10 02:10:30 +01:00
}
2020-02-17 22:06:54 +01:00
Vector < Plane > _Geometry : : build_capsule_planes ( float p_radius , float p_height , int p_sides , int p_lats , Vector3 : : Axis p_axis ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
return Geometry : : build_capsule_planes ( p_radius , p_height , p_sides , p_lats , p_axis ) ;
2014-02-10 02:10:30 +01:00
}
2019-08-25 23:02:16 +02:00
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 ) ;
}
2017-03-05 16:44:50 +01:00
real_t _Geometry : : segment_intersects_circle ( const Vector2 & p_from , const Vector2 & p_to , const Vector2 & p_circle_pos , real_t p_circle_radius ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
return Geometry : : segment_intersects_circle ( p_from , p_to , p_circle_pos , p_circle_radius ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
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 ) {
2014-02-10 02:10:30 +01:00
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 ( ) ;
} ;
} ;
2018-01-21 09:21:02 +01:00
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 ( ) ;
}
}
2020-02-17 22:06:54 +01:00
Vector < Vector2 > _Geometry : : get_closest_points_between_segments_2d ( const Vector2 & p1 , const Vector2 & q1 , const Vector2 & p2 , const Vector2 & q2 ) {
2014-02-10 02:10:30 +01:00
Vector2 r1 , r2 ;
2017-03-05 16:44:50 +01:00
Geometry : : get_closest_points_between_segments ( p1 , q1 , p2 , q2 , r1 , r2 ) ;
2020-02-17 22:06:54 +01:00
Vector < Vector2 > r ;
2014-02-10 02:10:30 +01:00
r . resize ( 2 ) ;
2017-03-05 16:44:50 +01:00
r . set ( 0 , r1 ) ;
r . set ( 1 , r2 ) ;
2014-02-10 02:10:30 +01:00
return r ;
}
2020-02-17 22:06:54 +01:00
Vector < Vector3 > _Geometry : : get_closest_points_between_segments ( const Vector3 & p1 , const Vector3 & p2 , const Vector3 & q1 , const Vector3 & q2 ) {
2014-02-10 02:10:30 +01:00
Vector3 r1 , r2 ;
2017-03-05 16:44:50 +01:00
Geometry : : get_closest_points_between_segments ( p1 , p2 , q1 , q2 , r1 , r2 ) ;
2020-02-17 22:06:54 +01:00
Vector < Vector3 > r ;
2014-02-10 02:10:30 +01:00
r . resize ( 2 ) ;
2017-03-05 16:44:50 +01:00
r . set ( 0 , r1 ) ;
r . set ( 1 , r2 ) ;
2014-02-10 02:10:30 +01:00
return r ;
}
2017-03-05 16:44:50 +01:00
Vector2 _Geometry : : get_closest_point_to_segment_2d ( const Vector2 & p_point , const Vector2 & p_a , const Vector2 & p_b ) {
2017-03-04 01:55:12 +01:00
2017-03-05 16:44:50 +01:00
Vector2 s [ 2 ] = { p_a , p_b } ;
return Geometry : : get_closest_point_to_segment_2d ( p_point , s ) ;
2017-03-04 01:55:12 +01:00
}
2017-03-05 16:44:50 +01:00
Vector3 _Geometry : : get_closest_point_to_segment ( const Vector3 & p_point , const Vector3 & p_a , const Vector3 & p_b ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
Vector3 s [ 2 ] = { p_a , p_b } ;
return Geometry : : get_closest_point_to_segment ( p_point , s ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
Vector2 _Geometry : : get_closest_point_to_segment_uncapped_2d ( const Vector2 & p_point , const Vector2 & p_a , const Vector2 & p_b ) {
2017-03-04 23:02:27 +01:00
2017-03-05 16:44:50 +01:00
Vector2 s [ 2 ] = { p_a , p_b } ;
return Geometry : : get_closest_point_to_segment_uncapped_2d ( p_point , s ) ;
2017-03-04 23:02:27 +01:00
}
2017-03-05 16:44:50 +01:00
Vector3 _Geometry : : get_closest_point_to_segment_uncapped ( const Vector3 & p_point , const Vector3 & p_a , const Vector3 & p_b ) {
2017-03-04 23:02:27 +01:00
2017-03-05 16:44:50 +01:00
Vector3 s [ 2 ] = { p_a , p_b } ;
return Geometry : : get_closest_point_to_segment_uncapped ( p_point , s ) ;
2017-03-04 23:02:27 +01:00
}
2017-03-05 16:44:50 +01:00
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 ) {
2014-02-10 02:10:30 +01:00
Vector3 res ;
2017-03-05 16:44:50 +01:00
if ( Geometry : : ray_intersects_triangle ( p_from , p_dir , p_v0 , p_v1 , p_v2 , & res ) )
2014-02-10 02:10:30 +01:00
return res ;
else
return Variant ( ) ;
}
2017-03-05 16:44:50 +01:00
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 ) {
2014-02-10 02:10:30 +01:00
Vector3 res ;
2017-03-05 16:44:50 +01:00
if ( Geometry : : segment_intersects_triangle ( p_from , p_to , p_v0 , p_v1 , p_v2 , & res ) )
2014-02-10 02:10:30 +01:00
return res ;
else
return Variant ( ) ;
}
2015-02-14 16:09:52 +01:00
2017-03-05 16:44:50 +01:00
bool _Geometry : : point_is_inside_triangle ( const Vector2 & s , const Vector2 & a , const Vector2 & b , const Vector2 & c ) const {
2015-02-14 16:09:52 +01:00
2017-03-05 16:44:50 +01:00
return Geometry : : is_point_in_triangle ( s , a , b , c ) ;
2015-02-14 16:09:52 +01:00
}
2020-02-17 22:06:54 +01:00
Vector < Vector3 > _Geometry : : segment_intersects_sphere ( const Vector3 & p_from , const Vector3 & p_to , const Vector3 & p_sphere_pos , real_t p_sphere_radius ) {
2014-02-10 02:10:30 +01:00
2020-02-17 22:06:54 +01:00
Vector < Vector3 > r ;
2017-03-05 16:44:50 +01:00
Vector3 res , norm ;
if ( ! Geometry : : segment_intersects_sphere ( p_from , p_to , p_sphere_pos , p_sphere_radius , & res , & norm ) )
2014-02-10 02:10:30 +01:00
return r ;
r . resize ( 2 ) ;
2017-03-05 16:44:50 +01:00
r . set ( 0 , res ) ;
r . set ( 1 , norm ) ;
2014-02-10 02:10:30 +01:00
return r ;
}
2020-02-17 22:06:54 +01:00
Vector < Vector3 > _Geometry : : segment_intersects_cylinder ( const Vector3 & p_from , const Vector3 & p_to , float p_height , float p_radius ) {
2014-02-10 02:10:30 +01:00
2020-02-17 22:06:54 +01:00
Vector < Vector3 > r ;
2017-03-05 16:44:50 +01:00
Vector3 res , norm ;
if ( ! Geometry : : segment_intersects_cylinder ( p_from , p_to , p_height , p_radius , & res , & norm ) )
2014-02-10 02:10:30 +01:00
return r ;
r . resize ( 2 ) ;
2017-03-05 16:44:50 +01:00
r . set ( 0 , res ) ;
r . set ( 1 , norm ) ;
2014-02-10 02:10:30 +01:00
return r ;
}
2020-02-17 22:06:54 +01:00
Vector < Vector3 > _Geometry : : segment_intersects_convex ( const Vector3 & p_from , const Vector3 & p_to , const Vector < Plane > & p_planes ) {
2014-02-10 02:10:30 +01:00
2020-02-17 22:06:54 +01:00
Vector < Vector3 > r ;
2017-03-05 16:44:50 +01:00
Vector3 res , norm ;
if ( ! Geometry : : segment_intersects_convex ( p_from , p_to , p_planes . ptr ( ) , p_planes . size ( ) , & res , & norm ) )
2014-02-10 02:10:30 +01:00
return r ;
r . resize ( 2 ) ;
2017-03-05 16:44:50 +01:00
r . set ( 0 , res ) ;
r . set ( 1 , norm ) ;
2014-02-10 02:10:30 +01:00
return r ;
}
Expose 2D polygon boolean operations in Geometry singleton
Clipper 6.4.2 is used internally to perform polypaths clipping, as well
as inflating/deflating polypaths. The following methods were added:
```
Geometry.merge_polygons_2d(poly_a, poly_b) # union
Geometry.clip_polygons_2d(poly_a, poly_b) # difference
Geometry.intersect_polygons_2d(poly_a, poly_b) # intersection
Geometry.exclude_polygons_2d(poly_a, poly_b) # xor
Geometry.clip_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.intersect_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.offset_polygon_2d(polygon, delta) # inflate/deflate
Geometry.offset_polyline_2d(polyline, delta) # returns polygons
// This one helps to implement CSG-like behaviour:
Geometry.transform_points_2d(points, transform)
```
All the methods return an array of polygons/polylines. The resulting
polygons could possibly be holes which could be checked with
`Geometry.is_polygon_clockwise()` which was exposed to scripting as well.
2019-05-18 19:01:42 +02:00
bool _Geometry : : is_polygon_clockwise ( const Vector < Vector2 > & p_polygon ) {
return Geometry : : is_polygon_clockwise ( p_polygon ) ;
}
2019-06-26 23:20:22 +02:00
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 ) ;
}
2017-03-05 16:44:50 +01:00
Vector < int > _Geometry : : triangulate_polygon ( const Vector < Vector2 > & p_polygon ) {
2014-02-10 02:10:30 +01:00
return Geometry : : triangulate_polygon ( p_polygon ) ;
}
2019-05-23 15:53:53 +02:00
Vector < int > _Geometry : : triangulate_delaunay_2d ( const Vector < Vector2 > & p_points ) {
return Geometry : : triangulate_delaunay_2d ( p_points ) ;
}
2017-11-05 00:46:32 +01:00
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 ) ;
}
Expose 2D polygon boolean operations in Geometry singleton
Clipper 6.4.2 is used internally to perform polypaths clipping, as well
as inflating/deflating polypaths. The following methods were added:
```
Geometry.merge_polygons_2d(poly_a, poly_b) # union
Geometry.clip_polygons_2d(poly_a, poly_b) # difference
Geometry.intersect_polygons_2d(poly_a, poly_b) # intersection
Geometry.exclude_polygons_2d(poly_a, poly_b) # xor
Geometry.clip_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.intersect_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.offset_polygon_2d(polygon, delta) # inflate/deflate
Geometry.offset_polyline_2d(polyline, delta) # returns polygons
// This one helps to implement CSG-like behaviour:
Geometry.transform_points_2d(points, transform)
```
All the methods return an array of polygons/polylines. The resulting
polygons could possibly be holes which could be checked with
`Geometry.is_polygon_clockwise()` which was exposed to scripting as well.
2019-05-18 19:01:42 +02:00
Array _Geometry : : merge_polygons_2d ( const Vector < Vector2 > & p_polygon_a , const Vector < Vector2 > & p_polygon_b ) {
2020-03-17 07:33:00 +01:00
Vector < Vector < Point2 > > polys = Geometry : : merge_polygons_2d ( p_polygon_a , p_polygon_b ) ;
Expose 2D polygon boolean operations in Geometry singleton
Clipper 6.4.2 is used internally to perform polypaths clipping, as well
as inflating/deflating polypaths. The following methods were added:
```
Geometry.merge_polygons_2d(poly_a, poly_b) # union
Geometry.clip_polygons_2d(poly_a, poly_b) # difference
Geometry.intersect_polygons_2d(poly_a, poly_b) # intersection
Geometry.exclude_polygons_2d(poly_a, poly_b) # xor
Geometry.clip_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.intersect_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.offset_polygon_2d(polygon, delta) # inflate/deflate
Geometry.offset_polyline_2d(polyline, delta) # returns polygons
// This one helps to implement CSG-like behaviour:
Geometry.transform_points_2d(points, transform)
```
All the methods return an array of polygons/polylines. The resulting
polygons could possibly be holes which could be checked with
`Geometry.is_polygon_clockwise()` which was exposed to scripting as well.
2019-05-18 19:01:42 +02:00
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 ) {
2020-03-17 07:33:00 +01:00
Vector < Vector < Point2 > > polys = Geometry : : clip_polygons_2d ( p_polygon_a , p_polygon_b ) ;
Expose 2D polygon boolean operations in Geometry singleton
Clipper 6.4.2 is used internally to perform polypaths clipping, as well
as inflating/deflating polypaths. The following methods were added:
```
Geometry.merge_polygons_2d(poly_a, poly_b) # union
Geometry.clip_polygons_2d(poly_a, poly_b) # difference
Geometry.intersect_polygons_2d(poly_a, poly_b) # intersection
Geometry.exclude_polygons_2d(poly_a, poly_b) # xor
Geometry.clip_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.intersect_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.offset_polygon_2d(polygon, delta) # inflate/deflate
Geometry.offset_polyline_2d(polyline, delta) # returns polygons
// This one helps to implement CSG-like behaviour:
Geometry.transform_points_2d(points, transform)
```
All the methods return an array of polygons/polylines. The resulting
polygons could possibly be holes which could be checked with
`Geometry.is_polygon_clockwise()` which was exposed to scripting as well.
2019-05-18 19:01:42 +02:00
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 ) {
2020-03-17 07:33:00 +01:00
Vector < Vector < Point2 > > polys = Geometry : : intersect_polygons_2d ( p_polygon_a , p_polygon_b ) ;
Expose 2D polygon boolean operations in Geometry singleton
Clipper 6.4.2 is used internally to perform polypaths clipping, as well
as inflating/deflating polypaths. The following methods were added:
```
Geometry.merge_polygons_2d(poly_a, poly_b) # union
Geometry.clip_polygons_2d(poly_a, poly_b) # difference
Geometry.intersect_polygons_2d(poly_a, poly_b) # intersection
Geometry.exclude_polygons_2d(poly_a, poly_b) # xor
Geometry.clip_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.intersect_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.offset_polygon_2d(polygon, delta) # inflate/deflate
Geometry.offset_polyline_2d(polyline, delta) # returns polygons
// This one helps to implement CSG-like behaviour:
Geometry.transform_points_2d(points, transform)
```
All the methods return an array of polygons/polylines. The resulting
polygons could possibly be holes which could be checked with
`Geometry.is_polygon_clockwise()` which was exposed to scripting as well.
2019-05-18 19:01:42 +02:00
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 ) {
2020-03-17 07:33:00 +01:00
Vector < Vector < Point2 > > polys = Geometry : : exclude_polygons_2d ( p_polygon_a , p_polygon_b ) ;
Expose 2D polygon boolean operations in Geometry singleton
Clipper 6.4.2 is used internally to perform polypaths clipping, as well
as inflating/deflating polypaths. The following methods were added:
```
Geometry.merge_polygons_2d(poly_a, poly_b) # union
Geometry.clip_polygons_2d(poly_a, poly_b) # difference
Geometry.intersect_polygons_2d(poly_a, poly_b) # intersection
Geometry.exclude_polygons_2d(poly_a, poly_b) # xor
Geometry.clip_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.intersect_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.offset_polygon_2d(polygon, delta) # inflate/deflate
Geometry.offset_polyline_2d(polyline, delta) # returns polygons
// This one helps to implement CSG-like behaviour:
Geometry.transform_points_2d(points, transform)
```
All the methods return an array of polygons/polylines. The resulting
polygons could possibly be holes which could be checked with
`Geometry.is_polygon_clockwise()` which was exposed to scripting as well.
2019-05-18 19:01:42 +02:00
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 ) {
2020-03-17 07:33:00 +01:00
Vector < Vector < Point2 > > polys = Geometry : : clip_polyline_with_polygon_2d ( p_polyline , p_polygon ) ;
Expose 2D polygon boolean operations in Geometry singleton
Clipper 6.4.2 is used internally to perform polypaths clipping, as well
as inflating/deflating polypaths. The following methods were added:
```
Geometry.merge_polygons_2d(poly_a, poly_b) # union
Geometry.clip_polygons_2d(poly_a, poly_b) # difference
Geometry.intersect_polygons_2d(poly_a, poly_b) # intersection
Geometry.exclude_polygons_2d(poly_a, poly_b) # xor
Geometry.clip_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.intersect_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.offset_polygon_2d(polygon, delta) # inflate/deflate
Geometry.offset_polyline_2d(polyline, delta) # returns polygons
// This one helps to implement CSG-like behaviour:
Geometry.transform_points_2d(points, transform)
```
All the methods return an array of polygons/polylines. The resulting
polygons could possibly be holes which could be checked with
`Geometry.is_polygon_clockwise()` which was exposed to scripting as well.
2019-05-18 19:01:42 +02:00
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 ) {
2020-03-17 07:33:00 +01:00
Vector < Vector < Point2 > > polys = Geometry : : intersect_polyline_with_polygon_2d ( p_polyline , p_polygon ) ;
Expose 2D polygon boolean operations in Geometry singleton
Clipper 6.4.2 is used internally to perform polypaths clipping, as well
as inflating/deflating polypaths. The following methods were added:
```
Geometry.merge_polygons_2d(poly_a, poly_b) # union
Geometry.clip_polygons_2d(poly_a, poly_b) # difference
Geometry.intersect_polygons_2d(poly_a, poly_b) # intersection
Geometry.exclude_polygons_2d(poly_a, poly_b) # xor
Geometry.clip_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.intersect_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.offset_polygon_2d(polygon, delta) # inflate/deflate
Geometry.offset_polyline_2d(polyline, delta) # returns polygons
// This one helps to implement CSG-like behaviour:
Geometry.transform_points_2d(points, transform)
```
All the methods return an array of polygons/polylines. The resulting
polygons could possibly be holes which could be checked with
`Geometry.is_polygon_clockwise()` which was exposed to scripting as well.
2019-05-18 19:01:42 +02:00
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 ) {
2020-03-17 07:33:00 +01:00
Vector < Vector < Point2 > > polys = Geometry : : offset_polygon_2d ( p_polygon , p_delta , Geometry : : PolyJoinType ( p_join_type ) ) ;
Expose 2D polygon boolean operations in Geometry singleton
Clipper 6.4.2 is used internally to perform polypaths clipping, as well
as inflating/deflating polypaths. The following methods were added:
```
Geometry.merge_polygons_2d(poly_a, poly_b) # union
Geometry.clip_polygons_2d(poly_a, poly_b) # difference
Geometry.intersect_polygons_2d(poly_a, poly_b) # intersection
Geometry.exclude_polygons_2d(poly_a, poly_b) # xor
Geometry.clip_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.intersect_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.offset_polygon_2d(polygon, delta) # inflate/deflate
Geometry.offset_polyline_2d(polyline, delta) # returns polygons
// This one helps to implement CSG-like behaviour:
Geometry.transform_points_2d(points, transform)
```
All the methods return an array of polygons/polylines. The resulting
polygons could possibly be holes which could be checked with
`Geometry.is_polygon_clockwise()` which was exposed to scripting as well.
2019-05-18 19:01:42 +02:00
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 ) {
2020-03-17 07:33:00 +01:00
Vector < Vector < Point2 > > polys = Geometry : : offset_polyline_2d ( p_polygon , p_delta , Geometry : : PolyJoinType ( p_join_type ) , Geometry : : PolyEndType ( p_end_type ) ) ;
Expose 2D polygon boolean operations in Geometry singleton
Clipper 6.4.2 is used internally to perform polypaths clipping, as well
as inflating/deflating polypaths. The following methods were added:
```
Geometry.merge_polygons_2d(poly_a, poly_b) # union
Geometry.clip_polygons_2d(poly_a, poly_b) # difference
Geometry.intersect_polygons_2d(poly_a, poly_b) # intersection
Geometry.exclude_polygons_2d(poly_a, poly_b) # xor
Geometry.clip_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.intersect_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.offset_polygon_2d(polygon, delta) # inflate/deflate
Geometry.offset_polyline_2d(polyline, delta) # returns polygons
// This one helps to implement CSG-like behaviour:
Geometry.transform_points_2d(points, transform)
```
All the methods return an array of polygons/polylines. The resulting
polygons could possibly be holes which could be checked with
`Geometry.is_polygon_clockwise()` which was exposed to scripting as well.
2019-05-18 19:01:42 +02:00
Array ret ;
for ( int i = 0 ; i < polys . size ( ) ; + + i ) {
ret . push_back ( polys [ i ] ) ;
}
return ret ;
}
2017-03-05 16:44:50 +01:00
Dictionary _Geometry : : make_atlas ( const Vector < Size2 > & p_rects ) {
2014-10-03 05:10:51 +02:00
Dictionary ret ;
Vector < Size2i > rects ;
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < p_rects . size ( ) ; i + + ) {
2014-10-03 05:10:51 +02:00
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 ;
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < result . size ( ) ; i + + ) {
2014-10-03 05:10:51 +02:00
r_result . push_back ( result [ i ] ) ;
} ;
ret [ " points " ] = r_result ;
ret [ " size " ] = r_size ;
return ret ;
} ;
2017-03-05 16:44:50 +01:00
int _Geometry : : get_uv84_normal_bit ( const Vector3 & p_vector ) {
2014-10-07 06:31:49 +02:00
return Geometry : : get_uv84_normal_bit ( p_vector ) ;
}
2014-02-10 02:10:30 +01:00
void _Geometry : : _bind_methods ( ) {
2017-03-05 16:44:50 +01:00
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 ) ) ;
2019-08-25 23:02:16 +02:00
ClassDB : : bind_method ( D_METHOD ( " is_point_in_circle " , " point " , " circle_position " , " circle_radius " ) , & _Geometry : : is_point_in_circle ) ;
2017-09-10 15:37:49 +02:00
ClassDB : : bind_method ( D_METHOD ( " segment_intersects_circle " , " segment_from " , " segment_to " , " circle_position " , " circle_radius " ) , & _Geometry : : segment_intersects_circle ) ;
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " segment_intersects_segment_2d " , " from_a " , " to_a " , " from_b " , " to_b " ) , & _Geometry : : segment_intersects_segment_2d ) ;
2018-01-21 09:21:02 +01:00
ClassDB : : bind_method ( D_METHOD ( " line_intersects_line_2d " , " from_a " , " dir_a " , " from_b " , " dir_b " ) , & _Geometry : : line_intersects_line_2d ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
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 ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
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 ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
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 ) ;
2017-03-04 23:02:27 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_uv84_normal_bit " , " normal " ) , & _Geometry : : get_uv84_normal_bit ) ;
2014-10-07 06:31:49 +02:00
2017-03-05 16:44:50 +01:00
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 ) ;
2017-09-10 15:37:49 +02:00
ClassDB : : bind_method ( D_METHOD ( " segment_intersects_sphere " , " from " , " to " , " sphere_position " , " sphere_radius " ) , & _Geometry : : segment_intersects_sphere ) ;
2017-03-05 16:44:50 +01:00
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 ) ;
2014-02-10 02:10:30 +01:00
Expose 2D polygon boolean operations in Geometry singleton
Clipper 6.4.2 is used internally to perform polypaths clipping, as well
as inflating/deflating polypaths. The following methods were added:
```
Geometry.merge_polygons_2d(poly_a, poly_b) # union
Geometry.clip_polygons_2d(poly_a, poly_b) # difference
Geometry.intersect_polygons_2d(poly_a, poly_b) # intersection
Geometry.exclude_polygons_2d(poly_a, poly_b) # xor
Geometry.clip_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.intersect_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.offset_polygon_2d(polygon, delta) # inflate/deflate
Geometry.offset_polyline_2d(polyline, delta) # returns polygons
// This one helps to implement CSG-like behaviour:
Geometry.transform_points_2d(points, transform)
```
All the methods return an array of polygons/polylines. The resulting
polygons could possibly be holes which could be checked with
`Geometry.is_polygon_clockwise()` which was exposed to scripting as well.
2019-05-18 19:01:42 +02:00
ClassDB : : bind_method ( D_METHOD ( " is_polygon_clockwise " , " polygon " ) , & _Geometry : : is_polygon_clockwise ) ;
2019-06-26 23:20:22 +02:00
ClassDB : : bind_method ( D_METHOD ( " is_point_in_polygon " , " point " , " polygon " ) , & _Geometry : : is_point_in_polygon ) ;
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " triangulate_polygon " , " polygon " ) , & _Geometry : : triangulate_polygon ) ;
2019-05-23 15:53:53 +02:00
ClassDB : : bind_method ( D_METHOD ( " triangulate_delaunay_2d " , " points " ) , & _Geometry : : triangulate_delaunay_2d ) ;
2017-11-05 00:46:32 +01:00
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 ) ;
2014-02-10 02:10:30 +01:00
Expose 2D polygon boolean operations in Geometry singleton
Clipper 6.4.2 is used internally to perform polypaths clipping, as well
as inflating/deflating polypaths. The following methods were added:
```
Geometry.merge_polygons_2d(poly_a, poly_b) # union
Geometry.clip_polygons_2d(poly_a, poly_b) # difference
Geometry.intersect_polygons_2d(poly_a, poly_b) # intersection
Geometry.exclude_polygons_2d(poly_a, poly_b) # xor
Geometry.clip_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.intersect_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.offset_polygon_2d(polygon, delta) # inflate/deflate
Geometry.offset_polyline_2d(polyline, delta) # returns polygons
// This one helps to implement CSG-like behaviour:
Geometry.transform_points_2d(points, transform)
```
All the methods return an array of polygons/polylines. The resulting
polygons could possibly be holes which could be checked with
`Geometry.is_polygon_clockwise()` which was exposed to scripting as well.
2019-05-18 19:01:42 +02:00
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 ) ) ;
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " make_atlas " , " sizes " ) , & _Geometry : : make_atlas ) ;
Expose 2D polygon boolean operations in Geometry singleton
Clipper 6.4.2 is used internally to perform polypaths clipping, as well
as inflating/deflating polypaths. The following methods were added:
```
Geometry.merge_polygons_2d(poly_a, poly_b) # union
Geometry.clip_polygons_2d(poly_a, poly_b) # difference
Geometry.intersect_polygons_2d(poly_a, poly_b) # intersection
Geometry.exclude_polygons_2d(poly_a, poly_b) # xor
Geometry.clip_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.intersect_polyline_with_polygon_2d(poly_a, poly_b)
Geometry.offset_polygon_2d(polygon, delta) # inflate/deflate
Geometry.offset_polyline_2d(polyline, delta) # returns polygons
// This one helps to implement CSG-like behaviour:
Geometry.transform_points_2d(points, transform)
```
All the methods return an array of polygons/polylines. The resulting
polygons could possibly be holes which could be checked with
`Geometry.is_polygon_clockwise()` which was exposed to scripting as well.
2019-05-18 19:01:42 +02:00
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 ) ;
2014-02-10 02:10:30 +01:00
}
_Geometry : : _Geometry ( ) {
2017-03-05 16:44:50 +01:00
singleton = this ;
2014-02-10 02:10:30 +01:00
}
///////////////////////// FILE
2019-04-07 18:52:39 +02:00
Error _File : : open_encrypted ( const String & p_path , ModeFlags p_mode_flags , const Vector < uint8_t > & p_key ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
Error err = open ( p_path , p_mode_flags ) ;
2014-04-15 03:43:44 +02:00
if ( err )
return err ;
2017-03-05 16:44:50 +01:00
FileAccessEncrypted * fae = memnew ( FileAccessEncrypted ) ;
err = fae - > open_and_parse ( f , p_key , ( p_mode_flags = = WRITE ) ? FileAccessEncrypted : : MODE_WRITE_AES256 : FileAccessEncrypted : : MODE_READ ) ;
2014-04-15 03:43:44 +02:00
if ( err ) {
memdelete ( fae ) ;
close ( ) ;
return err ;
}
2017-03-05 16:44:50 +01:00
f = fae ;
2014-04-15 03:43:44 +02:00
return OK ;
}
2019-04-07 18:52:39 +02:00
Error _File : : open_encrypted_pass ( const String & p_path , ModeFlags p_mode_flags , const String & p_pass ) {
2014-04-15 03:43:44 +02:00
2017-03-05 16:44:50 +01:00
Error err = open ( p_path , p_mode_flags ) ;
2014-04-15 03:43:44 +02:00
if ( err )
return err ;
2017-03-05 16:44:50 +01:00
FileAccessEncrypted * fae = memnew ( FileAccessEncrypted ) ;
err = fae - > open_and_parse_password ( f , p_pass , ( p_mode_flags = = WRITE ) ? FileAccessEncrypted : : MODE_WRITE_AES256 : FileAccessEncrypted : : MODE_READ ) ;
2014-04-15 03:43:44 +02:00
if ( err ) {
memdelete ( fae ) ;
close ( ) ;
return err ;
}
2017-03-05 16:44:50 +01:00
f = fae ;
2014-04-15 03:43:44 +02:00
return OK ;
}
2019-04-07 18:52:39 +02:00
Error _File : : open_compressed ( const String & p_path , ModeFlags p_mode_flags , CompressionMode p_compress_mode ) {
2017-06-19 18:28:00 +02:00
FileAccessCompressed * fac = memnew ( FileAccessCompressed ) ;
fac - > configure ( " GCPF " , ( Compression : : Mode ) p_compress_mode ) ;
2017-08-21 21:15:36 +02:00
Error err = fac - > _open ( p_path , p_mode_flags ) ;
2017-06-19 18:28:00 +02:00
if ( err ) {
memdelete ( fac ) ;
return err ;
}
f = fac ;
return OK ;
}
2019-04-07 18:52:39 +02:00
Error _File : : open ( const String & p_path , ModeFlags p_mode_flags ) {
2014-02-10 02:10:30 +01:00
close ( ) ;
Error err ;
2017-03-05 16:44:50 +01:00
f = FileAccess : : open ( p_path , p_mode_flags , & err ) ;
2014-02-10 02:10:30 +01:00
if ( f )
f - > set_endian_swap ( eswap ) ;
return err ;
}
2017-03-05 16:44:50 +01:00
void _File : : close ( ) {
2014-02-10 02:10:30 +01:00
if ( f )
memdelete ( f ) ;
2017-03-05 16:44:50 +01:00
f = NULL ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
bool _File : : is_open ( ) const {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
return f ! = NULL ;
2014-02-10 02:10:30 +01:00
}
2018-03-09 15:45:21 +01:00
String _File : : get_path ( ) const {
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! f , " " , " File must be opened before use. " ) ;
2018-03-09 15:45:21 +01:00
return f - > get_path ( ) ;
}
String _File : : get_path_absolute ( ) const {
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! f , " " , " File must be opened before use. " ) ;
2018-03-09 15:45:21 +01:00
return f - > get_path_absolute ( ) ;
}
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
void _File : : seek ( int64_t p_position ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
f - > seek ( p_position ) ;
}
2017-03-05 16:44:50 +01:00
void _File : : seek_end ( int64_t p_position ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
f - > seek_end ( p_position ) ;
}
2017-09-10 15:37:49 +02:00
int64_t _File : : get_position ( ) const {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! f , 0 , " File must be opened before use. " ) ;
2017-09-10 15:37:49 +02:00
return f - > get_position ( ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
int64_t _File : : get_len ( ) const {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! f , 0 , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
return f - > get_len ( ) ;
}
2017-03-05 16:44:50 +01:00
bool _File : : eof_reached ( ) const {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! f , false , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
return f - > eof_reached ( ) ;
}
2017-03-05 16:44:50 +01:00
uint8_t _File : : get_8 ( ) const {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! f , 0 , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
return f - > get_8 ( ) ;
}
2017-03-05 16:44:50 +01:00
uint16_t _File : : get_16 ( ) const {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! f , 0 , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
return f - > get_16 ( ) ;
}
2017-03-05 16:44:50 +01:00
uint32_t _File : : get_32 ( ) const {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! f , 0 , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
return f - > get_32 ( ) ;
}
2017-03-05 16:44:50 +01:00
uint64_t _File : : get_64 ( ) const {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! f , 0 , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
return f - > get_64 ( ) ;
}
2017-03-05 16:44:50 +01:00
float _File : : get_float ( ) const {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! f , 0 , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
return f - > get_float ( ) ;
}
2017-03-05 16:44:50 +01:00
double _File : : get_double ( ) const {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! f , 0 , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
return f - > get_double ( ) ;
}
2017-03-05 16:44:50 +01:00
real_t _File : : get_real ( ) const {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! f , 0 , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
return f - > get_real ( ) ;
}
2020-02-17 22:06:54 +01:00
Vector < uint8_t > _File : : get_buffer ( int p_length ) const {
2014-02-10 02:10:30 +01:00
2020-02-17 22:06:54 +01:00
Vector < uint8_t > data ;
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! f , data , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( p_length < 0 , data , " Length of buffer cannot be smaller than 0. " ) ;
2017-03-05 16:44:50 +01:00
if ( p_length = = 0 )
2014-02-10 02:10:30 +01:00
return data ;
2019-07-05 19:08:43 +02:00
2014-02-10 02:10:30 +01:00
Error err = data . resize ( p_length ) ;
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( err ! = OK , data , " Can't resize data to " + itos ( p_length ) + " elements. " ) ;
2019-07-05 19:08:43 +02:00
2020-02-17 22:06:54 +01:00
uint8_t * w = data . ptrw ( ) ;
2017-03-05 16:44:50 +01:00
int len = f - > get_buffer ( & w [ 0 ] , p_length ) ;
2020-02-17 22:06:54 +01:00
ERR_FAIL_COND_V ( len < 0 , Vector < uint8_t > ( ) ) ;
2014-02-10 02:10:30 +01:00
if ( len < p_length )
data . resize ( p_length ) ;
return data ;
}
String _File : : get_as_text ( ) const {
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! f , String ( ) , " File must be opened before use. " ) ;
2016-06-20 23:39:37 +02:00
2014-02-10 02:10:30 +01:00
String text ;
2017-09-10 15:37:49 +02:00
size_t original_pos = f - > get_position ( ) ;
2016-06-20 23:39:37 +02:00
f - > seek ( 0 ) ;
2014-02-10 02:10:30 +01:00
String l = get_line ( ) ;
2017-03-05 16:44:50 +01:00
while ( ! eof_reached ( ) ) {
text + = l + " \n " ;
2014-02-10 02:10:30 +01:00
l = get_line ( ) ;
}
2017-03-05 16:44:50 +01:00
text + = l ;
2014-02-10 02:10:30 +01:00
2016-06-20 23:39:37 +02:00
f - > seek ( original_pos ) ;
2014-02-10 02:10:30 +01:00
return text ;
}
2016-02-25 19:25:29 +01:00
2017-03-05 16:44:50 +01:00
String _File : : get_md5 ( const String & p_path ) const {
2016-02-25 19:25:29 +01:00
return FileAccess : : get_md5 ( p_path ) ;
}
2017-03-05 16:44:50 +01:00
String _File : : get_sha256 ( const String & p_path ) const {
2016-06-17 09:55:16 +02:00
return FileAccess : : get_sha256 ( p_path ) ;
}
2017-03-05 16:44:50 +01:00
String _File : : get_line ( ) const {
2016-02-25 19:25:29 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! f , String ( ) , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
return f - > get_line ( ) ;
}
2018-11-13 12:53:24 +01:00
Vector < String > _File : : get_csv_line ( const String & p_delim ) const {
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! f , Vector < String > ( ) , " File must be opened before use. " ) ;
2018-11-13 12:53:24 +01:00
return f - > get_csv_line ( p_delim ) ;
2014-02-10 02:10:30 +01:00
}
/**< 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
*/
2017-03-05 16:44:50 +01:00
void _File : : set_endian_swap ( bool p_swap ) {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
eswap = p_swap ;
2014-02-10 02:10:30 +01:00
if ( f )
f - > set_endian_swap ( p_swap ) ;
}
2017-03-05 16:44:50 +01:00
bool _File : : get_endian_swap ( ) {
2014-02-10 02:10:30 +01:00
return eswap ;
}
2017-03-05 16:44:50 +01:00
Error _File : : get_error ( ) const {
2014-02-10 02:10:30 +01:00
if ( ! f )
return ERR_UNCONFIGURED ;
return f - > get_error ( ) ;
}
2017-03-05 16:44:50 +01:00
void _File : : store_8 ( uint8_t p_dest ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
f - > store_8 ( p_dest ) ;
}
2017-03-05 16:44:50 +01:00
void _File : : store_16 ( uint16_t p_dest ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
f - > store_16 ( p_dest ) ;
}
2017-03-05 16:44:50 +01:00
void _File : : store_32 ( uint32_t p_dest ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
f - > store_32 ( p_dest ) ;
}
2017-03-05 16:44:50 +01:00
void _File : : store_64 ( uint64_t p_dest ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
f - > store_64 ( p_dest ) ;
}
2017-03-05 16:44:50 +01:00
void _File : : store_float ( float p_dest ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
f - > store_float ( p_dest ) ;
}
2017-03-05 16:44:50 +01:00
void _File : : store_double ( double p_dest ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
f - > store_double ( p_dest ) ;
}
2017-03-05 16:44:50 +01:00
void _File : : store_real ( real_t p_real ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
f - > store_real ( p_real ) ;
}
2017-03-05 16:44:50 +01:00
void _File : : store_string ( const String & p_string ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
f - > store_string ( p_string ) ;
}
2017-03-05 16:44:50 +01:00
void _File : : store_pascal_string ( const String & p_string ) {
2014-03-14 02:57:24 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
2014-03-14 02:57:24 +01:00
f - > store_pascal_string ( p_string ) ;
} ;
String _File : : get_pascal_string ( ) {
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! f , " " , " File must be opened before use. " ) ;
2014-03-14 02:57:24 +01:00
return f - > get_pascal_string ( ) ;
} ;
2017-03-05 16:44:50 +01:00
void _File : : store_line ( const String & p_string ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
f - > store_line ( p_string ) ;
}
2018-11-13 12:53:24 +01:00
void _File : : store_csv_line ( const Vector < String > & p_values , const String & p_delim ) {
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
2018-11-13 12:53:24 +01:00
f - > store_csv_line ( p_values , p_delim ) ;
}
2020-02-17 22:06:54 +01:00
void _File : : store_buffer ( const Vector < uint8_t > & p_buffer ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
int len = p_buffer . size ( ) ;
2017-03-05 16:44:50 +01:00
if ( len = = 0 )
2014-02-10 02:10:30 +01:00
return ;
2020-02-17 22:06:54 +01:00
const uint8_t * r = p_buffer . ptr ( ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
f - > store_buffer ( & r [ 0 ] , len ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
bool _File : : file_exists ( const String & p_name ) const {
2014-02-10 02:10:30 +01:00
return FileAccess : : exists ( p_name ) ;
}
2019-03-26 16:52:42 +01:00
void _File : : store_var ( const Variant & p_var , bool p_full_objects ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_MSG ( ! f , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
int len ;
2019-03-26 16:52:42 +01:00
Error err = encode_variant ( p_var , NULL , len , p_full_objects ) ;
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_MSG ( err ! = OK , " Error when trying to encode Variant. " ) ;
2014-02-10 02:10:30 +01:00
2020-02-17 22:06:54 +01:00
Vector < uint8_t > buff ;
2014-02-10 02:10:30 +01:00
buff . resize ( len ) ;
2020-02-17 22:06:54 +01:00
uint8_t * w = buff . ptrw ( ) ;
2019-03-26 16:52:42 +01:00
err = encode_variant ( p_var , & w [ 0 ] , len , p_full_objects ) ;
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_MSG ( err ! = OK , " Error when trying to encode Variant. " ) ;
2014-02-10 02:10:30 +01:00
store_32 ( len ) ;
store_buffer ( buff ) ;
}
2019-03-26 16:52:42 +01:00
Variant _File : : get_var ( bool p_allow_objects ) const {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! f , Variant ( ) , " File must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
uint32_t len = get_32 ( ) ;
2020-02-17 22:06:54 +01:00
Vector < uint8_t > buff = get_buffer ( len ) ;
2017-08-31 23:30:35 +02:00
ERR_FAIL_COND_V ( ( uint32_t ) buff . size ( ) ! = len , Variant ( ) ) ;
2014-02-10 02:10:30 +01:00
2020-02-17 22:06:54 +01:00
const uint8_t * r = buff . ptr ( ) ;
2014-02-10 02:10:30 +01:00
Variant v ;
2019-03-26 16:52:42 +01:00
Error err = decode_variant ( v , & r [ 0 ] , len , NULL , p_allow_objects ) ;
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( err ! = OK , Variant ( ) , " Error when trying to encode Variant. " ) ;
2014-02-10 02:10:30 +01:00
return v ;
}
2017-01-23 22:33:02 +01:00
uint64_t _File : : get_modified_time ( const String & p_file ) const {
return FileAccess : : get_modified_time ( p_file ) ;
}
2014-02-10 02:10:30 +01:00
void _File : : _bind_methods ( ) {
2017-03-05 16:44:50 +01:00
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 ) ;
2017-06-19 18:28:00 +02:00
ClassDB : : bind_method ( D_METHOD ( " open_compressed " , " path " , " mode_flags " , " compression_mode " ) , & _File : : open_compressed , DEFVAL ( 0 ) ) ;
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " open " , " path " , " flags " ) , & _File : : open ) ;
ClassDB : : bind_method ( D_METHOD ( " close " ) , & _File : : close ) ;
2018-03-09 15:45:21 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_path " ) , & _File : : get_path ) ;
ClassDB : : bind_method ( D_METHOD ( " get_path_absolute " ) , & _File : : get_path_absolute ) ;
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " is_open " ) , & _File : : is_open ) ;
2017-09-10 15:37:49 +02:00
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 ) ;
2017-03-05 16:44:50 +01:00
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 ) ;
2018-11-13 12:53:24 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_csv_line " , " delim " ) , & _File : : get_csv_line , DEFVAL ( " , " ) ) ;
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_as_text " ) , & _File : : get_as_text ) ;
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 ) ;
2017-08-09 13:19:41 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_error " ) , & _File : : get_error ) ;
2019-03-26 16:52:42 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_var " , " allow_objects " ) , & _File : : get_var , DEFVAL ( false ) ) ;
2017-03-05 16:44:50 +01:00
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 ) ;
2018-11-13 12:53:24 +01:00
ClassDB : : bind_method ( D_METHOD ( " store_csv_line " , " values " , " delim " ) , & _File : : store_csv_line , DEFVAL ( " , " ) ) ;
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " store_string " , " string " ) , & _File : : store_string ) ;
2019-03-26 16:52:42 +01:00
ClassDB : : bind_method ( D_METHOD ( " store_var " , " value " , " full_objects " ) , & _File : : store_var , DEFVAL ( false ) ) ;
2017-03-05 16:44:50 +01:00
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 ) ;
2018-01-11 23:35:12 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " endian_swap " ) , " set_endian_swap " , " get_endian_swap " ) ;
2017-08-20 17:45:01 +02:00
BIND_ENUM_CONSTANT ( READ ) ;
BIND_ENUM_CONSTANT ( WRITE ) ;
BIND_ENUM_CONSTANT ( READ_WRITE ) ;
BIND_ENUM_CONSTANT ( WRITE_READ ) ;
2017-06-19 18:28:00 +02:00
2017-08-20 17:45:01 +02:00
BIND_ENUM_CONSTANT ( COMPRESSION_FASTLZ ) ;
BIND_ENUM_CONSTANT ( COMPRESSION_DEFLATE ) ;
BIND_ENUM_CONSTANT ( COMPRESSION_ZSTD ) ;
BIND_ENUM_CONSTANT ( COMPRESSION_GZIP ) ;
2017-03-05 16:44:50 +01:00
}
_File : : _File ( ) {
2014-02-10 02:10:30 +01:00
f = NULL ;
2017-03-05 16:44:50 +01:00
eswap = false ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
_File : : ~ _File ( ) {
2014-02-10 02:10:30 +01:00
if ( f )
memdelete ( f ) ;
}
///////////////////////////////////////////////////////
2017-03-05 16:44:50 +01:00
Error _Directory : : open ( const String & p_path ) {
2014-02-10 02:10:30 +01:00
Error err ;
2017-03-05 16:44:50 +01:00
DirAccess * alt = DirAccess : : open ( p_path , & err ) ;
2014-02-10 02:10:30 +01:00
if ( ! alt )
return err ;
if ( d )
memdelete ( d ) ;
2017-03-05 16:44:50 +01:00
d = alt ;
2014-02-10 02:10:30 +01:00
return OK ;
}
2017-01-16 23:19:43 +01:00
Error _Directory : : list_dir_begin ( bool p_skip_navigational , bool p_skip_hidden ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! d , ERR_UNCONFIGURED , " Directory must be opened before use. " ) ;
2017-01-16 23:19:43 +01:00
_list_skip_navigational = p_skip_navigational ;
_list_skip_hidden = p_skip_hidden ;
2014-02-10 02:10:30 +01:00
return d - > list_dir_begin ( ) ;
}
2017-03-05 16:44:50 +01:00
String _Directory : : get_next ( ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! d , " " , " Directory must be opened before use. " ) ;
2017-01-16 23:19:43 +01:00
String next = d - > get_next ( ) ;
2017-03-05 16:44:50 +01:00
while ( next ! = " " & & ( ( _list_skip_navigational & & ( next = = " . " | | next = = " .. " ) ) | | ( _list_skip_hidden & & d - > current_is_hidden ( ) ) ) ) {
2017-01-16 23:19:43 +01:00
next = d - > get_next ( ) ;
}
return next ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
bool _Directory : : current_is_dir ( ) const {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! d , false , " Directory must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
return d - > current_is_dir ( ) ;
}
2017-03-05 16:44:50 +01:00
void _Directory : : list_dir_end ( ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_MSG ( ! d , " Directory must be opened before use. " ) ;
2019-07-01 12:59:42 +02:00
d - > list_dir_end ( ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
int _Directory : : get_drive_count ( ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! d , 0 , " Directory must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
return d - > get_drive_count ( ) ;
}
2017-03-05 16:44:50 +01:00
String _Directory : : get_drive ( int p_drive ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! d , " " , " Directory must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
return d - > get_drive ( p_drive ) ;
}
2017-01-14 17:01:43 +01:00
int _Directory : : get_current_drive ( ) {
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! d , 0 , " Directory must be opened before use. " ) ;
2017-01-14 17:01:43 +01:00
return d - > get_current_drive ( ) ;
}
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
Error _Directory : : change_dir ( String p_dir ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! d , ERR_UNCONFIGURED , " Directory must be opened before use. " ) ;
2014-02-10 02:10:30 +01:00
return d - > change_dir ( p_dir ) ;
}
2020-03-17 14:32:03 +01:00
String _Directory : : get_current_dir ( ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! d , " " , " Directory must be opened before use. " ) ;
2020-03-17 14:32:03 +01:00
return d - > get_current_dir ( ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
Error _Directory : : make_dir ( String p_dir ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! d , ERR_UNCONFIGURED , " Directory must be opened before use. " ) ;
2016-06-18 17:11:48 +02:00
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 ;
}
2014-02-10 02:10:30 +01:00
return d - > make_dir ( p_dir ) ;
}
2017-03-05 16:44:50 +01:00
Error _Directory : : make_dir_recursive ( String p_dir ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! d , ERR_UNCONFIGURED , " Directory must be opened before use. " ) ;
2016-08-08 23:20:16 +02:00
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 ;
}
2014-02-10 02:10:30 +01:00
return d - > make_dir_recursive ( p_dir ) ;
}
2017-03-05 16:44:50 +01:00
bool _Directory : : file_exists ( String p_file ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! d , false , " Directory must be opened before use. " ) ;
2016-06-18 17:11:48 +02:00
if ( ! p_file . is_rel_path ( ) ) {
return FileAccess : : exists ( p_file ) ;
}
2014-02-10 02:10:30 +01:00
return d - > file_exists ( p_file ) ;
}
2014-05-25 05:34:51 +02:00
bool _Directory : : dir_exists ( String p_dir ) {
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! d , false , " Directory must be opened before use. " ) ;
2016-06-18 17:11:48 +02:00
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 ) ;
}
2014-05-25 05:34:51 +02:00
}
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
int _Directory : : get_space_left ( ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! d , 0 , " Directory must be opened before use. " ) ;
2017-03-05 16:44:50 +01:00
return d - > get_space_left ( ) / 1024 * 1024 ; //return value in megabytes, given binding is int
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
Error _Directory : : copy ( String p_from , String p_to ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! d , ERR_UNCONFIGURED , " Directory must be opened before use. " ) ;
2017-03-05 16:44:50 +01:00
return d - > copy ( p_from , p_to ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
Error _Directory : : rename ( String p_from , String p_to ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! d , ERR_UNCONFIGURED , " Directory must be opened before use. " ) ;
2016-06-18 17:11:48 +02:00
if ( ! p_from . is_rel_path ( ) ) {
DirAccess * d = DirAccess : : create_for_path ( p_from ) ;
2017-03-05 16:44:50 +01:00
Error err = d - > rename ( p_from , p_to ) ;
2016-06-18 17:11:48 +02:00
memdelete ( d ) ;
return err ;
}
2017-03-05 16:44:50 +01:00
return d - > rename ( p_from , p_to ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
Error _Directory : : remove ( String p_name ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! d , ERR_UNCONFIGURED , " Directory must be opened before use. " ) ;
2016-06-18 17:11:48 +02:00
if ( ! p_name . is_rel_path ( ) ) {
DirAccess * d = DirAccess : : create_for_path ( p_name ) ;
Error err = d - > remove ( p_name ) ;
memdelete ( d ) ;
return err ;
}
2014-02-10 02:10:30 +01:00
return d - > remove ( p_name ) ;
}
void _Directory : : _bind_methods ( ) {
2017-08-09 13:19:41 +02:00
ClassDB : : bind_method ( D_METHOD ( " open " , " path " ) , & _Directory : : open ) ;
2017-02-13 12:47:24 +01:00
ClassDB : : bind_method ( D_METHOD ( " list_dir_begin " , " skip_navigational " , " skip_hidden " ) , & _Directory : : list_dir_begin , DEFVAL ( false ) , DEFVAL ( false ) ) ;
2017-03-05 16:44:50 +01:00
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 ) ;
2017-08-09 13:19:41 +02:00
ClassDB : : bind_method ( D_METHOD ( " change_dir " , " todir " ) , & _Directory : : change_dir ) ;
2020-03-18 09:14:39 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_current_dir " ) , & _Directory : : get_current_dir ) ;
2017-08-09 13:19:41 +02:00
ClassDB : : bind_method ( D_METHOD ( " make_dir " , " path " ) , & _Directory : : make_dir ) ;
ClassDB : : bind_method ( D_METHOD ( " make_dir_recursive " , " path " ) , & _Directory : : make_dir_recursive ) ;
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " file_exists " , " path " ) , & _Directory : : file_exists ) ;
ClassDB : : bind_method ( D_METHOD ( " dir_exists " , " path " ) , & _Directory : : dir_exists ) ;
2017-02-13 12:47:24 +01:00
//ClassDB::bind_method(D_METHOD("get_modified_time","file"),&_Directory::get_modified_time);
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_space_left " ) , & _Directory : : get_space_left ) ;
2017-08-09 13:19:41 +02:00
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 ) ;
2014-02-10 02:10:30 +01:00
}
_Directory : : _Directory ( ) {
d = DirAccess : : create ( DirAccess : : ACCESS_RESOURCES ) ;
}
_Directory : : ~ _Directory ( ) {
if ( d )
memdelete ( d ) ;
}
2017-03-05 16:44:50 +01:00
_Marshalls * _Marshalls : : singleton = NULL ;
2016-11-05 17:13:04 +01:00
2017-03-05 16:44:50 +01:00
_Marshalls * _Marshalls : : get_singleton ( ) {
2016-11-05 17:13:04 +01:00
return singleton ;
}
2019-03-26 16:52:42 +01:00
String _Marshalls : : variant_to_base64 ( const Variant & p_var , bool p_full_objects ) {
2014-02-10 02:10:30 +01:00
int len ;
2019-03-26 16:52:42 +01:00
Error err = encode_variant ( p_var , NULL , len , p_full_objects ) ;
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( err ! = OK , " " , " Error when trying to encode Variant. " ) ;
2014-02-10 02:10:30 +01:00
2020-02-17 22:06:54 +01:00
Vector < uint8_t > buff ;
2014-02-10 02:10:30 +01:00
buff . resize ( len ) ;
2020-02-17 22:06:54 +01:00
uint8_t * w = buff . ptrw ( ) ;
2014-02-10 02:10:30 +01:00
2019-03-26 16:52:42 +01:00
err = encode_variant ( p_var , & w [ 0 ] , len , p_full_objects ) ;
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( err ! = OK , " " , " Error when trying to encode Variant. " ) ;
2014-02-10 02:10:30 +01:00
2019-07-02 17:47:34 +02:00
String ret = CryptoCore : : b64_encode_str ( & w [ 0 ] , len ) ;
ERR_FAIL_COND_V ( ret = = " " , ret ) ;
2014-02-10 02:10:30 +01:00
return ret ;
} ;
2019-03-26 16:52:42 +01:00
Variant _Marshalls : : base64_to_variant ( const String & p_str , bool p_allow_objects ) {
2014-02-10 02:10:30 +01:00
int strlen = p_str . length ( ) ;
CharString cstr = p_str . ascii ( ) ;
2020-02-17 22:06:54 +01:00
Vector < uint8_t > buf ;
2014-06-11 15:41:03 +02:00
buf . resize ( strlen / 4 * 3 + 1 ) ;
2020-02-17 22:06:54 +01:00
uint8_t * w = buf . ptrw ( ) ;
2014-02-10 02:10:30 +01:00
2019-07-02 03:06:52 +02:00
size_t len = 0 ;
ERR_FAIL_COND_V ( CryptoCore : : b64_decode ( & w [ 0 ] , buf . size ( ) , & len , ( unsigned char * ) cstr . get_data ( ) , strlen ) ! = OK , Variant ( ) ) ;
2014-02-10 02:10:30 +01:00
Variant v ;
2019-03-26 16:52:42 +01:00
Error err = decode_variant ( v , & w [ 0 ] , len , NULL , p_allow_objects ) ;
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( err ! = OK , Variant ( ) , " Error when trying to decode Variant. " ) ;
2014-02-10 02:10:30 +01:00
return v ;
} ;
2020-02-17 22:06:54 +01:00
String _Marshalls : : raw_to_base64 ( const Vector < uint8_t > & p_arr ) {
2015-07-28 12:50:52 +02:00
2020-02-17 22:06:54 +01:00
String ret = CryptoCore : : b64_encode_str ( p_arr . ptr ( ) , p_arr . size ( ) ) ;
2019-07-02 17:47:34 +02:00
ERR_FAIL_COND_V ( ret = = " " , ret ) ;
2015-07-28 12:50:52 +02:00
return ret ;
} ;
2020-02-17 22:06:54 +01:00
Vector < uint8_t > _Marshalls : : base64_to_raw ( const String & p_str ) {
2015-07-28 12:50:52 +02:00
int strlen = p_str . length ( ) ;
CharString cstr = p_str . ascii ( ) ;
2019-07-02 03:06:52 +02:00
size_t arr_len = 0 ;
2020-02-17 22:06:54 +01:00
Vector < uint8_t > buf ;
2015-07-28 12:50:52 +02:00
{
buf . resize ( strlen / 4 * 3 + 1 ) ;
2020-02-17 22:06:54 +01:00
uint8_t * w = buf . ptrw ( ) ;
2015-07-28 12:50:52 +02:00
2020-02-17 22:06:54 +01:00
ERR_FAIL_COND_V ( CryptoCore : : b64_decode ( & w [ 0 ] , buf . size ( ) , & arr_len , ( unsigned char * ) cstr . get_data ( ) , strlen ) ! = OK , Vector < uint8_t > ( ) ) ;
2019-07-02 03:06:52 +02:00
}
2015-07-28 12:50:52 +02:00
buf . resize ( arr_len ) ;
return buf ;
} ;
2017-03-05 16:44:50 +01:00
String _Marshalls : : utf8_to_base64 ( const String & p_str ) {
2015-07-28 12:50:52 +02:00
CharString cstr = p_str . utf8 ( ) ;
2019-07-02 17:47:34 +02:00
String ret = CryptoCore : : b64_encode_str ( ( unsigned char * ) cstr . get_data ( ) , cstr . length ( ) ) ;
ERR_FAIL_COND_V ( ret = = " " , ret ) ;
2015-07-28 12:50:52 +02:00
return ret ;
} ;
2017-03-05 16:44:50 +01:00
String _Marshalls : : base64_to_utf8 ( const String & p_str ) {
2015-07-28 12:50:52 +02:00
int strlen = p_str . length ( ) ;
CharString cstr = p_str . ascii ( ) ;
2020-02-17 22:06:54 +01:00
Vector < uint8_t > buf ;
2015-07-28 12:50:52 +02:00
buf . resize ( strlen / 4 * 3 + 1 + 1 ) ;
2020-02-17 22:06:54 +01:00
uint8_t * w = buf . ptrw ( ) ;
2015-07-28 12:50:52 +02:00
2019-07-02 03:06:52 +02:00
size_t len = 0 ;
ERR_FAIL_COND_V ( CryptoCore : : b64_decode ( & w [ 0 ] , buf . size ( ) , & len , ( unsigned char * ) cstr . get_data ( ) , strlen ) ! = OK , String ( ) ) ;
2015-07-28 12:50:52 +02:00
w [ len ] = 0 ;
2017-03-05 16:44:50 +01:00
String ret = String : : utf8 ( ( char * ) & w [ 0 ] ) ;
2015-07-28 12:50:52 +02:00
return ret ;
} ;
2014-02-10 02:10:30 +01:00
void _Marshalls : : _bind_methods ( ) {
2019-03-26 16:52:42 +01:00
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 ) ) ;
2015-07-28 12:50:52 +02:00
2017-08-09 13:19:41 +02:00
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 ) ;
2015-07-28 12:50:52 +02:00
2017-08-09 13:19:41 +02:00
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 ) ;
2014-02-10 02:10:30 +01:00
} ;
////////////////
2020-03-03 09:26:42 +01:00
void _Semaphore : : wait ( ) {
2014-02-10 02:10:30 +01:00
2020-03-03 09:26:42 +01:00
semaphore . wait ( ) ;
2014-02-10 02:10:30 +01:00
}
2020-03-03 09:26:42 +01:00
Error _Semaphore : : try_wait ( ) {
2014-02-10 02:10:30 +01:00
2020-03-03 09:26:42 +01:00
return semaphore . try_wait ( ) ? OK : ERR_BUSY ;
2014-02-10 02:10:30 +01:00
}
2020-03-03 09:26:42 +01:00
void _Semaphore : : post ( ) {
2014-02-10 02:10:30 +01:00
2020-03-03 09:26:42 +01:00
semaphore . post ( ) ;
2014-02-10 02:10:30 +01:00
}
2020-03-03 09:26:42 +01:00
void _Semaphore : : _bind_methods ( ) {
2014-02-10 02:10:30 +01:00
2020-03-03 09:26:42 +01:00
ClassDB : : bind_method ( D_METHOD ( " wait " ) , & _Semaphore : : wait ) ;
ClassDB : : bind_method ( D_METHOD ( " try_wait " ) , & _Semaphore : : try_wait ) ;
ClassDB : : bind_method ( D_METHOD ( " post " ) , & _Semaphore : : post ) ;
2014-02-10 02:10:30 +01:00
}
///////////////
void _Mutex : : lock ( ) {
2020-02-26 11:28:13 +01:00
mutex . lock ( ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
Error _Mutex : : try_lock ( ) {
2014-02-10 02:10:30 +01:00
2020-02-26 11:28:13 +01:00
return mutex . try_lock ( ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
void _Mutex : : unlock ( ) {
2014-02-10 02:10:30 +01:00
2020-02-26 11:28:13 +01:00
mutex . unlock ( ) ;
2014-02-10 02:10:30 +01:00
}
void _Mutex : : _bind_methods ( ) {
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " lock " ) , & _Mutex : : lock ) ;
2017-08-09 13:19:41 +02:00
ClassDB : : bind_method ( D_METHOD ( " try_lock " ) , & _Mutex : : try_lock ) ;
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " unlock " ) , & _Mutex : : unlock ) ;
2014-02-10 02:10:30 +01:00
}
///////////////
void _Thread : : _start_func ( void * ud ) {
2017-03-05 16:44:50 +01:00
Ref < _Thread > * tud = ( Ref < _Thread > * ) ud ;
Ref < _Thread > t = * tud ;
2015-05-18 17:45:53 +02:00
memdelete ( tud ) ;
2020-02-19 20:27:19 +01:00
Callable : : CallError ce ;
2017-03-05 16:44:50 +01:00
const Variant * arg [ 1 ] = { & t - > userdata } ;
2015-06-29 05:29:49 +02:00
2016-02-01 00:22:38 +01:00
Thread : : set_name ( t - > target_method ) ;
2015-12-18 07:06:51 +01:00
2017-03-05 16:44:50 +01:00
t - > ret = t - > target_instance - > call ( t - > target_method , arg , 1 , ce ) ;
2020-02-19 20:27:19 +01:00
if ( ce . error ! = Callable : : CallError : : CALL_OK ) {
2014-02-10 02:10:30 +01:00
String reason ;
2017-03-05 16:44:50 +01:00
switch ( ce . error ) {
2020-02-19 20:27:19 +01:00
case Callable : : CallError : : CALL_ERROR_INVALID_ARGUMENT : {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
reason = " Invalid Argument # " + itos ( ce . argument ) ;
2014-02-10 02:10:30 +01:00
} break ;
2020-02-19 20:27:19 +01:00
case Callable : : CallError : : CALL_ERROR_TOO_MANY_ARGUMENTS : {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
reason = " Too Many Arguments " ;
2014-02-10 02:10:30 +01:00
} break ;
2020-02-19 20:27:19 +01:00
case Callable : : CallError : : CALL_ERROR_TOO_FEW_ARGUMENTS : {
2014-02-10 02:10:30 +01:00
2019-01-11 04:12:13 +01:00
reason = " Too Few Arguments " ;
2014-02-10 02:10:30 +01:00
} break ;
2020-02-19 20:27:19 +01:00
case Callable : : CallError : : CALL_ERROR_INVALID_METHOD : {
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
reason = " Method Not Found " ;
2014-02-10 02:10:30 +01:00
} break ;
2019-04-09 17:08:36 +02:00
default : {
}
2014-02-10 02:10:30 +01:00
}
2019-09-25 10:28:50 +02:00
ERR_FAIL_MSG ( " Could not call function ' " + t - > target_method . operator String ( ) + " ' to start thread " + t - > get_id ( ) + " : " + reason + " . " ) ;
2014-02-10 02:10:30 +01:00
}
}
2019-04-07 18:52:39 +02:00
Error _Thread : : start ( Object * p_instance , const StringName & p_method , const Variant & p_userdata , Priority p_priority ) {
2014-02-10 02:10:30 +01:00
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( active , ERR_ALREADY_IN_USE , " Thread already started. " ) ;
2017-03-05 16:44:50 +01:00
ERR_FAIL_COND_V ( ! p_instance , ERR_INVALID_PARAMETER ) ;
ERR_FAIL_COND_V ( p_method = = StringName ( ) , ERR_INVALID_PARAMETER ) ;
2019-04-07 18:52:39 +02:00
ERR_FAIL_INDEX_V ( p_priority , PRIORITY_MAX , ERR_INVALID_PARAMETER ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
ret = Variant ( ) ;
target_method = p_method ;
target_instance = p_instance ;
userdata = p_userdata ;
active = true ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
Ref < _Thread > * ud = memnew ( Ref < _Thread > ( this ) ) ;
2015-05-18 17:45:53 +02:00
2014-02-10 02:10:30 +01:00
Thread : : Settings s ;
2017-03-05 16:44:50 +01:00
s . priority = ( Thread : : Priority ) p_priority ;
thread = Thread : : create ( _start_func , ud , s ) ;
2014-02-10 02:10:30 +01:00
if ( ! thread ) {
2017-03-05 16:44:50 +01:00
active = false ;
target_method = StringName ( ) ;
target_instance = NULL ;
userdata = Variant ( ) ;
2014-02-10 02:10:30 +01:00
return ERR_CANT_CREATE ;
}
return OK ;
}
String _Thread : : get_id ( ) const {
if ( ! thread )
return String ( ) ;
2017-08-07 12:17:31 +02:00
return itos ( thread - > get_id ( ) ) ;
2014-02-10 02:10:30 +01:00
}
bool _Thread : : is_active ( ) const {
return active ;
}
Variant _Thread : : wait_to_finish ( ) {
2019-09-25 10:28:50 +02:00
ERR_FAIL_COND_V_MSG ( ! thread , Variant ( ) , " Thread must exist to wait for its completion. " ) ;
ERR_FAIL_COND_V_MSG ( ! active , Variant ( ) , " Thread must be active to wait for its completion. " ) ;
2014-02-10 02:10:30 +01:00
Thread : : wait_to_finish ( thread ) ;
Variant r = ret ;
2017-03-05 16:44:50 +01:00
active = false ;
target_method = StringName ( ) ;
target_instance = NULL ;
userdata = Variant ( ) ;
2019-07-01 15:07:06 +02:00
if ( thread )
memdelete ( thread ) ;
2017-03-05 16:44:50 +01:00
thread = NULL ;
2014-02-10 02:10:30 +01:00
return r ;
}
void _Thread : : _bind_methods ( ) {
2017-08-09 13:19:41 +02:00
ClassDB : : bind_method ( D_METHOD ( " start " , " instance " , " method " , " userdata " , " priority " ) , & _Thread : : start , DEFVAL ( Variant ( ) ) , DEFVAL ( PRIORITY_NORMAL ) ) ;
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_id " ) , & _Thread : : get_id ) ;
ClassDB : : bind_method ( D_METHOD ( " is_active " ) , & _Thread : : is_active ) ;
2017-08-09 13:19:41 +02:00
ClassDB : : bind_method ( D_METHOD ( " wait_to_finish " ) , & _Thread : : wait_to_finish ) ;
2014-02-10 02:10:30 +01:00
2017-08-20 17:45:01 +02:00
BIND_ENUM_CONSTANT ( PRIORITY_LOW ) ;
BIND_ENUM_CONSTANT ( PRIORITY_NORMAL ) ;
BIND_ENUM_CONSTANT ( PRIORITY_HIGH ) ;
2014-02-10 02:10:30 +01:00
}
_Thread : : _Thread ( ) {
2017-03-05 16:44:50 +01:00
active = false ;
thread = NULL ;
target_instance = NULL ;
2014-02-10 02:10:30 +01:00
}
_Thread : : ~ _Thread ( ) {
2020-01-22 11:17:20 +01:00
ERR_FAIL_COND_MSG ( active , " Reference to a Thread object was lost while the thread is still running... " ) ;
2014-02-10 02:10:30 +01:00
}
2020-01-22 11:17:20 +01:00
2017-01-03 03:03:46 +01:00
/////////////////////////////////////
2020-02-17 22:06:54 +01:00
PackedStringArray _ClassDB : : get_class_list ( ) const {
2017-01-03 03:03:46 +01:00
List < StringName > classes ;
ClassDB : : get_class_list ( & classes ) ;
2020-02-17 22:06:54 +01:00
PackedStringArray ret ;
2017-01-03 03:03:46 +01:00
ret . resize ( classes . size ( ) ) ;
2017-03-05 16:44:50 +01:00
int idx = 0 ;
for ( List < StringName > : : Element * E = classes . front ( ) ; E ; E = E - > next ( ) ) {
ret . set ( idx + + , E - > get ( ) ) ;
2017-01-03 03:03:46 +01:00
}
return ret ;
}
2020-02-17 22:06:54 +01:00
PackedStringArray _ClassDB : : get_inheriters_from_class ( const StringName & p_class ) const {
2017-01-03 03:03:46 +01:00
List < StringName > classes ;
2017-03-05 16:44:50 +01:00
ClassDB : : get_inheriters_from_class ( p_class , & classes ) ;
2017-01-03 03:03:46 +01:00
2020-02-17 22:06:54 +01:00
PackedStringArray ret ;
2017-01-03 03:03:46 +01:00
ret . resize ( classes . size ( ) ) ;
2017-03-05 16:44:50 +01:00
int idx = 0 ;
for ( List < StringName > : : Element * E = classes . front ( ) ; E ; E = E - > next ( ) ) {
ret . set ( idx + + , E - > get ( ) ) ;
2017-01-03 03:03:46 +01:00
}
return ret ;
}
2017-03-05 16:44:50 +01:00
StringName _ClassDB : : get_parent_class ( const StringName & p_class ) const {
2017-01-03 03:03:46 +01:00
return ClassDB : : get_parent_class ( p_class ) ;
}
bool _ClassDB : : class_exists ( const StringName & p_class ) const {
return ClassDB : : class_exists ( p_class ) ;
}
2017-03-05 16:44:50 +01:00
bool _ClassDB : : is_parent_class ( const StringName & p_class , const StringName & p_inherits ) const {
2017-01-03 03:03:46 +01:00
2017-03-05 16:44:50 +01:00
return ClassDB : : is_parent_class ( p_class , p_inherits ) ;
2017-01-03 03:03:46 +01:00
}
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 ( ) ;
2017-08-24 22:58:51 +02:00
Reference * r = Object : : cast_to < Reference > ( obj ) ;
2017-01-03 03:03:46 +01:00
if ( r ) {
return REF ( r ) ;
} else {
return obj ;
}
}
2017-03-05 16:44:50 +01:00
bool _ClassDB : : has_signal ( StringName p_class , StringName p_signal ) const {
2017-01-03 03:03:46 +01:00
2017-03-05 16:44:50 +01:00
return ClassDB : : has_signal ( p_class , p_signal ) ;
2017-01-03 03:03:46 +01:00
}
2017-03-05 16:44:50 +01:00
Dictionary _ClassDB : : get_signal ( StringName p_class , StringName p_signal ) const {
2017-01-03 03:03:46 +01:00
MethodInfo signal ;
2017-03-05 16:44:50 +01:00
if ( ClassDB : : get_signal ( p_class , p_signal , & signal ) ) {
2017-01-03 03:03:46 +01:00
return signal . operator Dictionary ( ) ;
} else {
return Dictionary ( ) ;
}
}
2017-03-05 16:44:50 +01:00
Array _ClassDB : : get_signal_list ( StringName p_class , bool p_no_inheritance ) const {
2017-01-03 03:03:46 +01:00
List < MethodInfo > signals ;
2017-03-05 16:44:50 +01:00
ClassDB : : get_signal_list ( p_class , & signals , p_no_inheritance ) ;
2017-01-03 03:03:46 +01:00
Array ret ;
2017-03-05 16:44:50 +01:00
for ( List < MethodInfo > : : Element * E = signals . front ( ) ; E ; E = E - > next ( ) ) {
2017-01-03 03:03:46 +01:00
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 ;
2017-03-05 16:44:50 +01:00
ClassDB : : get_property_list ( p_class , & plist , p_no_inheritance ) ;
2017-01-03 03:03:46 +01:00
Array ret ;
2017-03-05 16:44:50 +01:00
for ( List < PropertyInfo > : : Element * E = plist . front ( ) ; E ; E = E - > next ( ) ) {
2017-01-03 03:03:46 +01:00
ret . push_back ( E - > get ( ) . operator Dictionary ( ) ) ;
}
return ret ;
}
2017-04-09 13:26:48 +02:00
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 ;
}
2017-03-05 16:44:50 +01:00
bool _ClassDB : : has_method ( StringName p_class , StringName p_method , bool p_no_inheritance ) const {
2017-01-03 03:03:46 +01:00
2017-03-05 16:44:50 +01:00
return ClassDB : : has_method ( p_class , p_method , p_no_inheritance ) ;
2017-01-03 03:03:46 +01:00
}
2017-03-05 16:44:50 +01:00
Array _ClassDB : : get_method_list ( StringName p_class , bool p_no_inheritance ) const {
2017-01-03 03:03:46 +01:00
List < MethodInfo > methods ;
2017-03-05 16:44:50 +01:00
ClassDB : : get_method_list ( p_class , & methods , p_no_inheritance ) ;
2017-01-03 03:03:46 +01:00
Array ret ;
2017-03-05 16:44:50 +01:00
for ( List < MethodInfo > : : Element * E = methods . front ( ) ; E ; E = E - > next ( ) ) {
2018-01-04 19:04:05 +01:00
# ifdef DEBUG_METHODS_ENABLED
2017-01-03 03:03:46 +01:00
ret . push_back ( E - > get ( ) . operator Dictionary ( ) ) ;
2018-01-04 19:04:05 +01:00
# else
Dictionary dict ;
dict [ " name " ] = E - > get ( ) . name ;
ret . push_back ( dict ) ;
# endif
2017-01-03 03:03:46 +01:00
}
return ret ;
}
2020-02-17 22:06:54 +01:00
PackedStringArray _ClassDB : : get_integer_constant_list ( const StringName & p_class , bool p_no_inheritance ) const {
2017-01-03 03:03:46 +01:00
List < String > constants ;
2017-03-05 16:44:50 +01:00
ClassDB : : get_integer_constant_list ( p_class , & constants , p_no_inheritance ) ;
2017-01-03 03:03:46 +01:00
2020-02-17 22:06:54 +01:00
PackedStringArray ret ;
2017-01-03 03:03:46 +01:00
ret . resize ( constants . size ( ) ) ;
2017-03-05 16:44:50 +01:00
int idx = 0 ;
for ( List < String > : : Element * E = constants . front ( ) ; E ; E = E - > next ( ) ) {
ret . set ( idx + + , E - > get ( ) ) ;
2017-01-03 03:03:46 +01:00
}
return ret ;
}
2017-03-05 16:44:50 +01:00
bool _ClassDB : : has_integer_constant ( const StringName & p_class , const StringName & p_name ) const {
2017-01-03 03:03:46 +01:00
bool success ;
2017-03-05 16:44:50 +01:00
ClassDB : : get_integer_constant ( p_class , p_name , & success ) ;
2017-01-03 03:03:46 +01:00
return success ;
}
2017-03-05 16:44:50 +01:00
int _ClassDB : : get_integer_constant ( const StringName & p_class , const StringName & p_name ) const {
2017-01-03 03:03:46 +01:00
bool found ;
2017-03-05 16:44:50 +01:00
int c = ClassDB : : get_integer_constant ( p_class , p_name , & found ) ;
ERR_FAIL_COND_V ( ! found , 0 ) ;
2017-01-03 03:03:46 +01:00
return c ;
}
2017-03-05 16:44:50 +01:00
StringName _ClassDB : : get_category ( const StringName & p_node ) const {
2017-01-03 03:03:46 +01:00
return ClassDB : : get_category ( p_node ) ;
}
bool _ClassDB : : is_class_enabled ( StringName p_class ) const {
return ClassDB : : is_class_enabled ( p_class ) ;
}
void _ClassDB : : _bind_methods ( ) {
2017-03-05 16:44:50 +01:00
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 ) ;
2017-08-09 13:19:41 +02:00
ClassDB : : bind_method ( D_METHOD ( " instance " , " class " ) , & _ClassDB : : instance ) ;
2017-01-03 03:03:46 +01:00
2017-03-05 16:44:50 +01:00
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 ) ) ;
2017-01-03 03:03:46 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " class_get_property_list " , " class " , " no_inheritance " ) , & _ClassDB : : get_property_list , DEFVAL ( false ) ) ;
2017-08-09 13:19:41 +02:00
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 ) ;
2017-01-03 03:03:46 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " class_has_method " , " class " , " method " , " no_inheritance " ) , & _ClassDB : : has_method , DEFVAL ( false ) ) ;
2017-01-03 03:03:46 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " class_get_method_list " , " class " , " no_inheritance " ) , & _ClassDB : : get_method_list , DEFVAL ( false ) ) ;
2017-01-03 03:03:46 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " class_get_integer_constant_list " , " class " , " no_inheritance " ) , & _ClassDB : : get_integer_constant_list , DEFVAL ( false ) ) ;
2017-01-03 03:03:46 +01:00
2017-03-05 16:44:50 +01:00
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 ) ;
2017-01-03 03:03:46 +01:00
2017-03-05 16:44:50 +01:00
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 ) ;
2017-01-03 03:03:46 +01:00
}
2017-03-05 16:44:50 +01:00
_ClassDB : : _ClassDB ( ) {
2017-01-03 03:03:46 +01:00
}
2017-03-05 16:44:50 +01:00
_ClassDB : : ~ _ClassDB ( ) {
2017-01-03 03:03:46 +01:00
}
2017-01-13 16:51:14 +01:00
///////////////////////////////
void _Engine : : set_iterations_per_second ( int p_ips ) {
Engine : : get_singleton ( ) - > set_iterations_per_second ( p_ips ) ;
}
int _Engine : : get_iterations_per_second ( ) const {
return Engine : : get_singleton ( ) - > get_iterations_per_second ( ) ;
}
Add hysteresis to physics timestep count per frame
Add new class _TimerSync to manage timestep calculations.
The new class handles the decisions about simulation progression
previously handled by main::iteration(). It is fed the current timer
ticks and determines how many physics updates are to be run and what
the delta argument to the _process() functions should be.
The new class tries to keep the number of physics updates per frame as
constant as possible from frame to frame. Ideally, it would be N steps
every render frame, but even with perfectly regular rendering, the
general case is that N or N+1 steps are required per frame, for some
fixed N. The best guess for N is stored in typical_physics_steps.
When determining the number of steps to take, no restrictions are
imposed between the choice of typical_physics_steps and
typical_physics_steps+1 steps. Should more or less steps than that be
required, the accumulated remaining time (as before, stored in
time_accum) needs to surpass its boundaries by some minimal threshold.
Once surpassed, typical_physics_steps is updated to allow the new step
count for future updates.
Care is taken that the modified calculation of the number of physics
steps is not observable from game code that only checks the delta
parameters to the _process and _physics_process functions; in addition
to modifying the number of steps, the _process argument is modified as
well to stay in expected bounds. Extra care is taken that the accumulated
steps still sum up to roughly the real elapsed time, up to a maximum
tolerated difference.
To allow the hysteresis code to work correctly on higher refresh
monitors, the number of typical physics steps is not only recorded and
kept consistent for single render frames, but for groups of them.
Currently, up to 12 frames are grouped that way.
The engine parameter physics_jitter_fix controls both the maximum
tolerated difference between wall clock time and summed up _process
arguments and the threshold for changing typical_physics_steps. It is
given in units of the real physics frame slice 1/physics_fps. Set
physics_jitter_fix to 0 to disable the effects of the new code here.
It starts to be effective against the random physics jitter at around
0.02 to 0.05. at values greater than 1 it starts having ill effects on
the engine's ability to react sensibly to dropped frames and framerate
changes.
2018-02-11 00:03:31 +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 ( ) ;
}
2019-07-01 18:42:02 +02:00
float _Engine : : get_physics_interpolation_fraction ( ) const {
return Engine : : get_singleton ( ) - > get_physics_interpolation_fraction ( ) ;
}
2017-01-13 16:51:14 +01:00
void _Engine : : set_target_fps ( int p_fps ) {
Engine : : get_singleton ( ) - > set_target_fps ( p_fps ) ;
}
2018-01-12 14:26:21 +01:00
int _Engine : : get_target_fps ( ) const {
2017-01-13 16:51:14 +01:00
return Engine : : get_singleton ( ) - > get_target_fps ( ) ;
}
float _Engine : : get_frames_per_second ( ) const {
return Engine : : get_singleton ( ) - > get_frames_per_second ( ) ;
}
2020-01-13 17:53:10 +01:00
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 ( ) ;
}
2017-01-13 16:51:14 +01:00
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 ( ) ;
}
2017-03-05 16:44:50 +01:00
int _Engine : : get_frames_drawn ( ) {
2017-01-13 16:51:14 +01:00
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 ( ) ;
}
2017-01-13 18:25:43 +01:00
Dictionary _Engine : : get_version_info ( ) const {
2017-01-13 16:51:14 +01:00
2017-01-13 18:25:43 +01:00
return Engine : : get_singleton ( ) - > get_version_info ( ) ;
2017-01-13 16:51:14 +01:00
}
2018-05-16 06:54:22 +02:00
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 ( ) ;
}
2017-09-30 16:19:07 +02:00
bool _Engine : : is_in_physics_frame ( ) const {
return Engine : : get_singleton ( ) - > is_in_physics_frame ( ) ;
2017-06-13 17:49:28 +02:00
}
2017-11-13 21:46:57 +01:00
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 ) ;
}
2017-08-13 16:21:45 +02:00
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 ( ) ;
}
2017-01-13 16:51:14 +01:00
void _Engine : : _bind_methods ( ) {
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " set_iterations_per_second " , " iterations_per_second " ) , & _Engine : : set_iterations_per_second ) ;
ClassDB : : bind_method ( D_METHOD ( " get_iterations_per_second " ) , & _Engine : : get_iterations_per_second ) ;
Add hysteresis to physics timestep count per frame
Add new class _TimerSync to manage timestep calculations.
The new class handles the decisions about simulation progression
previously handled by main::iteration(). It is fed the current timer
ticks and determines how many physics updates are to be run and what
the delta argument to the _process() functions should be.
The new class tries to keep the number of physics updates per frame as
constant as possible from frame to frame. Ideally, it would be N steps
every render frame, but even with perfectly regular rendering, the
general case is that N or N+1 steps are required per frame, for some
fixed N. The best guess for N is stored in typical_physics_steps.
When determining the number of steps to take, no restrictions are
imposed between the choice of typical_physics_steps and
typical_physics_steps+1 steps. Should more or less steps than that be
required, the accumulated remaining time (as before, stored in
time_accum) needs to surpass its boundaries by some minimal threshold.
Once surpassed, typical_physics_steps is updated to allow the new step
count for future updates.
Care is taken that the modified calculation of the number of physics
steps is not observable from game code that only checks the delta
parameters to the _process and _physics_process functions; in addition
to modifying the number of steps, the _process argument is modified as
well to stay in expected bounds. Extra care is taken that the accumulated
steps still sum up to roughly the real elapsed time, up to a maximum
tolerated difference.
To allow the hysteresis code to work correctly on higher refresh
monitors, the number of typical physics steps is not only recorded and
kept consistent for single render frames, but for groups of them.
Currently, up to 12 frames are grouped that way.
The engine parameter physics_jitter_fix controls both the maximum
tolerated difference between wall clock time and summed up _process
arguments and the threshold for changing typical_physics_steps. It is
given in units of the real physics frame slice 1/physics_fps. Set
physics_jitter_fix to 0 to disable the effects of the new code here.
It starts to be effective against the random physics jitter at around
0.02 to 0.05. at values greater than 1 it starts having ill effects on
the engine's ability to react sensibly to dropped frames and framerate
changes.
2018-02-11 00:03:31 +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 ) ;
2019-07-01 18:42:02 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_physics_interpolation_fraction " ) , & _Engine : : get_physics_interpolation_fraction ) ;
2017-03-05 16:44:50 +01:00
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 ) ;
2017-01-13 16:51:14 +01:00
2017-03-05 16:44:50 +01:00
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 ) ;
2017-01-13 16:51:14 +01:00
2017-03-05 16:44:50 +01:00
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 ) ;
2020-01-13 17:53:10 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_physics_frames " ) , & _Engine : : get_physics_frames ) ;
ClassDB : : bind_method ( D_METHOD ( " get_idle_frames " ) , & _Engine : : get_idle_frames ) ;
2017-01-13 16:51:14 +01:00
2017-08-09 13:19:41 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_main_loop " ) , & _Engine : : get_main_loop ) ;
2017-01-13 16:51:14 +01:00
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " get_version_info " ) , & _Engine : : get_version_info ) ;
2018-05-16 06:54:22 +02:00
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 ) ;
2017-06-13 17:49:28 +02:00
2017-09-30 16:19:07 +02:00
ClassDB : : bind_method ( D_METHOD ( " is_in_physics_frame " ) , & _Engine : : is_in_physics_frame ) ;
2017-08-13 16:21:45 +02:00
2017-11-13 21:46:57 +01:00
ClassDB : : bind_method ( D_METHOD ( " has_singleton " , " name " ) , & _Engine : : has_singleton ) ;
ClassDB : : bind_method ( D_METHOD ( " get_singleton " , " name " ) , & _Engine : : get_singleton_object ) ;
2017-08-13 16:21:45 +02:00
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 ) ;
2018-01-11 23:35:12 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " editor_hint " ) , " set_editor_hint " , " is_editor_hint " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " iterations_per_second " ) , " set_iterations_per_second " , " get_iterations_per_second " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " target_fps " ) , " set_target_fps " , " get_target_fps " ) ;
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
ADD_PROPERTY ( PropertyInfo ( Variant : : FLOAT , " time_scale " ) , " set_time_scale " , " get_time_scale " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : FLOAT , " physics_jitter_fix " ) , " set_physics_jitter_fix " , " get_physics_jitter_fix " ) ;
2017-01-13 16:51:14 +01:00
}
_Engine * _Engine : : singleton = NULL ;
_Engine : : _Engine ( ) {
2017-03-05 16:44:50 +01:00
singleton = this ;
2017-01-13 16:51:14 +01:00
}
2017-09-15 15:40:27 +02:00
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 ) ;
2018-11-08 15:30:02 +01:00
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 " ) ;
2017-09-15 15:40:27 +02:00
}
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 ( ) {
2017-11-03 08:32:58 +01:00
ClassDB : : bind_method ( D_METHOD ( " print " , " value " , " indent " , " sort_keys " ) , & _JSON : : print , DEFVAL ( String ( ) ) , DEFVAL ( false ) ) ;
2017-09-15 15:40:27 +02:00
ClassDB : : bind_method ( D_METHOD ( " parse " , " json " ) , & _JSON : : parse ) ;
}
2017-11-03 08:32:58 +01:00
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 ) ;
2017-09-15 15:40:27 +02:00
}
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 ) ;
2019-10-31 12:15:44 +01:00
if ( result - > error ! = OK ) {
2019-11-06 17:03:04 +01:00
ERR_PRINT ( vformat ( " Error parsing JSON at line %s: %s " , result - > error_line , result - > error_string ) ) ;
2019-10-31 12:15:44 +01:00
}
2017-09-15 15:40:27 +02:00
return result ;
}
_JSON * _JSON : : singleton = NULL ;
_JSON : : _JSON ( ) {
singleton = this ;
}