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
|
|
|
/*************************************************************************/
|
2018-01-01 14:40:08 +01:00
|
|
|
/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. */
|
|
|
|
/* Copyright (c) 2014-2018 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
|
|
|
|
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
|
|
|
|
2017-04-28 18:29:15 +02:00
|
|
|
#include "thirdparty/misc/base64.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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Ref<ResourceInteractiveLoader> _ResourceLoader::load_interactive(const String &p_path, const String &p_type_hint) {
|
|
|
|
return ResourceLoader::load_interactive(p_path, p_type_hint);
|
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);
|
|
|
|
|
|
|
|
if (err != OK) {
|
|
|
|
ERR_EXPLAIN("Error loading resource: '" + p_path + "'");
|
|
|
|
ERR_FAIL_COND_V(err != OK, ret);
|
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
PoolVector<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);
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<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);
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
PoolStringArray _ResourceLoader::get_dependencies(const String &p_path) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
List<String> deps;
|
|
|
|
ResourceLoader::get_dependencies(p_path, &deps);
|
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
PoolStringArray 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-12 12:44:38 +02:00
|
|
|
#ifndef DISABLE_DEPRECATED
|
|
|
|
bool _ResourceLoader::has(const String &p_path) {
|
|
|
|
WARN_PRINTS("ResourceLoader.has() is deprecated, please replace it with the equivalent has_cached() or the new exists().");
|
|
|
|
return has_cached(p_path);
|
|
|
|
}
|
|
|
|
#endif // DISABLE_DEPRECATED
|
|
|
|
|
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() {
|
|
|
|
|
2017-08-09 13:19:41 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("load_interactive", "path", "type_hint"), &_ResourceLoader::load_interactive, DEFVAL(""));
|
|
|
|
ClassDB::bind_method(D_METHOD("load", "path", "type_hint", "p_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(""));
|
2018-08-12 12:44:38 +02:00
|
|
|
#ifndef DISABLE_DEPRECATED
|
|
|
|
ClassDB::bind_method(D_METHOD("has", "path"), &_ResourceLoader::has);
|
|
|
|
#endif // DISABLE_DEPRECATED
|
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
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Error _ResourceSaver::save(const String &p_path, const RES &p_resource, uint32_t p_flags) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(p_resource.is_null(), ERR_INVALID_PARAMETER);
|
|
|
|
return ResourceSaver::save(p_path, p_resource, p_flags);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
PoolVector<String> _ResourceSaver::get_recognized_extensions(const RES &p_resource) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(p_resource.is_null(), PoolVector<String>());
|
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);
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<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
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////OS
|
|
|
|
|
2017-03-29 17:29:38 +02:00
|
|
|
Point2 _OS::get_mouse_position() const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-29 17:29:38 +02:00
|
|
|
return OS::get_singleton()->get_mouse_position();
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2017-03-05 16:44:50 +01:00
|
|
|
void _OS::set_window_title(const String &p_title) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
OS::get_singleton()->set_window_title(p_title);
|
|
|
|
}
|
|
|
|
|
|
|
|
int _OS::get_mouse_button_state() const {
|
|
|
|
|
|
|
|
return OS::get_singleton()->get_mouse_button_state();
|
|
|
|
}
|
|
|
|
|
2017-08-07 12:17:31 +02:00
|
|
|
String _OS::get_unique_id() const {
|
|
|
|
return OS::get_singleton()->get_unique_id();
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
bool _OS::has_touchscreen_ui_hint() const {
|
|
|
|
|
|
|
|
return OS::get_singleton()->has_touchscreen_ui_hint();
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void _OS::set_clipboard(const String &p_text) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
OS::get_singleton()->set_clipboard(p_text);
|
|
|
|
}
|
|
|
|
String _OS::get_clipboard() const {
|
|
|
|
|
|
|
|
return OS::get_singleton()->get_clipboard();
|
|
|
|
}
|
|
|
|
|
2018-03-04 18:18:05 +01:00
|
|
|
int _OS::get_video_driver_count() const {
|
|
|
|
return OS::get_singleton()->get_video_driver_count();
|
|
|
|
}
|
|
|
|
|
|
|
|
String _OS::get_video_driver_name(int p_driver) const {
|
|
|
|
return OS::get_singleton()->get_video_driver_name(p_driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
int _OS::get_audio_driver_count() const {
|
|
|
|
return OS::get_singleton()->get_audio_driver_count();
|
|
|
|
}
|
|
|
|
|
|
|
|
String _OS::get_audio_driver_name(int p_driver) const {
|
|
|
|
return OS::get_singleton()->get_audio_driver_name(p_driver);
|
|
|
|
}
|
|
|
|
|
2018-07-14 14:11:28 +02:00
|
|
|
PoolStringArray _OS::get_connected_midi_inputs() {
|
|
|
|
return OS::get_singleton()->get_connected_midi_inputs();
|
|
|
|
}
|
|
|
|
|
2018-08-04 02:17:33 +02:00
|
|
|
void _OS::open_midi_inputs() {
|
|
|
|
return OS::get_singleton()->open_midi_inputs();
|
|
|
|
}
|
|
|
|
|
|
|
|
void _OS::close_midi_inputs() {
|
|
|
|
return OS::get_singleton()->close_midi_inputs();
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void _OS::set_video_mode(const Size2 &p_size, bool p_fullscreen, bool p_resizeable, int p_screen) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
OS::VideoMode vm;
|
2017-03-05 16:44:50 +01:00
|
|
|
vm.width = p_size.width;
|
|
|
|
vm.height = p_size.height;
|
|
|
|
vm.fullscreen = p_fullscreen;
|
|
|
|
vm.resizable = p_resizeable;
|
|
|
|
OS::get_singleton()->set_video_mode(vm, p_screen);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
Size2 _OS::get_video_mode(int p_screen) const {
|
|
|
|
|
|
|
|
OS::VideoMode vm;
|
|
|
|
vm = OS::get_singleton()->get_video_mode(p_screen);
|
2017-03-05 16:44:50 +01:00
|
|
|
return Size2(vm.width, vm.height);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
bool _OS::is_video_mode_fullscreen(int p_screen) const {
|
|
|
|
|
|
|
|
OS::VideoMode vm;
|
|
|
|
vm = OS::get_singleton()->get_video_mode(p_screen);
|
|
|
|
return vm.fullscreen;
|
|
|
|
}
|
|
|
|
|
2015-01-11 11:52:42 +01:00
|
|
|
int _OS::get_screen_count() const {
|
|
|
|
return OS::get_singleton()->get_screen_count();
|
|
|
|
}
|
|
|
|
|
2015-03-22 23:00:50 +01:00
|
|
|
int _OS::get_current_screen() const {
|
|
|
|
return OS::get_singleton()->get_current_screen();
|
2015-01-14 05:02:59 +01:00
|
|
|
}
|
|
|
|
|
2015-03-22 23:00:50 +01:00
|
|
|
void _OS::set_current_screen(int p_screen) {
|
|
|
|
OS::get_singleton()->set_current_screen(p_screen);
|
2015-01-14 05:02:59 +01:00
|
|
|
}
|
|
|
|
|
2015-01-13 10:25:50 +01:00
|
|
|
Point2 _OS::get_screen_position(int p_screen) const {
|
|
|
|
return OS::get_singleton()->get_screen_position(p_screen);
|
|
|
|
}
|
|
|
|
|
2015-01-11 12:35:53 +01:00
|
|
|
Size2 _OS::get_screen_size(int p_screen) const {
|
|
|
|
return OS::get_singleton()->get_screen_size(p_screen);
|
|
|
|
}
|
|
|
|
|
2016-05-29 18:40:00 +02:00
|
|
|
int _OS::get_screen_dpi(int p_screen) const {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
return OS::get_singleton()->get_screen_dpi(p_screen);
|
2016-05-29 18:40:00 +02:00
|
|
|
}
|
|
|
|
|
2015-01-11 08:47:27 +01:00
|
|
|
Point2 _OS::get_window_position() const {
|
|
|
|
return OS::get_singleton()->get_window_position();
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void _OS::set_window_position(const Point2 &p_position) {
|
2015-01-11 08:47:27 +01:00
|
|
|
OS::get_singleton()->set_window_position(p_position);
|
|
|
|
}
|
|
|
|
|
2015-01-11 10:36:56 +01:00
|
|
|
Size2 _OS::get_window_size() const {
|
|
|
|
return OS::get_singleton()->get_window_size();
|
|
|
|
}
|
|
|
|
|
2018-02-12 18:17:29 +01:00
|
|
|
Size2 _OS::get_real_window_size() const {
|
|
|
|
return OS::get_singleton()->get_real_window_size();
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void _OS::set_window_size(const Size2 &p_size) {
|
2015-01-11 10:36:56 +01:00
|
|
|
OS::get_singleton()->set_window_size(p_size);
|
|
|
|
}
|
|
|
|
|
2018-04-10 12:35:30 +02:00
|
|
|
Rect2 _OS::get_window_safe_area() const {
|
|
|
|
return OS::get_singleton()->get_window_safe_area();
|
|
|
|
}
|
|
|
|
|
2015-03-22 23:00:50 +01:00
|
|
|
void _OS::set_window_fullscreen(bool p_enabled) {
|
|
|
|
OS::get_singleton()->set_window_fullscreen(p_enabled);
|
2015-01-10 08:47:34 +01:00
|
|
|
}
|
|
|
|
|
2015-03-22 23:00:50 +01:00
|
|
|
bool _OS::is_window_fullscreen() const {
|
|
|
|
return OS::get_singleton()->is_window_fullscreen();
|
2015-01-10 08:47:34 +01:00
|
|
|
}
|
2015-01-15 14:50:23 +01:00
|
|
|
|
2015-03-22 23:00:50 +01:00
|
|
|
void _OS::set_window_resizable(bool p_enabled) {
|
|
|
|
OS::get_singleton()->set_window_resizable(p_enabled);
|
2015-01-15 14:50:23 +01:00
|
|
|
}
|
|
|
|
|
2015-03-22 23:00:50 +01:00
|
|
|
bool _OS::is_window_resizable() const {
|
|
|
|
return OS::get_singleton()->is_window_resizable();
|
2015-01-15 14:50:23 +01:00
|
|
|
}
|
2015-01-16 16:18:45 +01:00
|
|
|
|
2015-03-22 23:00:50 +01:00
|
|
|
void _OS::set_window_minimized(bool p_enabled) {
|
|
|
|
OS::get_singleton()->set_window_minimized(p_enabled);
|
2015-01-16 16:18:45 +01:00
|
|
|
}
|
|
|
|
|
2015-03-22 23:00:50 +01:00
|
|
|
bool _OS::is_window_minimized() const {
|
|
|
|
return OS::get_singleton()->is_window_minimized();
|
2015-01-16 16:18:45 +01:00
|
|
|
}
|
|
|
|
|
2015-03-22 23:00:50 +01:00
|
|
|
void _OS::set_window_maximized(bool p_enabled) {
|
|
|
|
OS::get_singleton()->set_window_maximized(p_enabled);
|
2015-01-16 16:18:45 +01:00
|
|
|
}
|
|
|
|
|
2015-03-22 23:00:50 +01:00
|
|
|
bool _OS::is_window_maximized() const {
|
|
|
|
return OS::get_singleton()->is_window_maximized();
|
2015-01-16 16:18:45 +01:00
|
|
|
}
|
2015-03-22 23:00:50 +01:00
|
|
|
|
2017-12-27 20:51:19 +01:00
|
|
|
void _OS::set_window_always_on_top(bool p_enabled) {
|
|
|
|
OS::get_singleton()->set_window_always_on_top(p_enabled);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool _OS::is_window_always_on_top() const {
|
|
|
|
return OS::get_singleton()->is_window_always_on_top();
|
|
|
|
}
|
|
|
|
|
2016-01-03 05:18:28 +01:00
|
|
|
void _OS::set_borderless_window(bool p_borderless) {
|
|
|
|
OS::get_singleton()->set_borderless_window(p_borderless);
|
|
|
|
}
|
|
|
|
|
2017-12-10 19:38:26 +01:00
|
|
|
bool _OS::get_window_per_pixel_transparency_enabled() const {
|
|
|
|
return OS::get_singleton()->get_window_per_pixel_transparency_enabled();
|
|
|
|
}
|
|
|
|
|
|
|
|
void _OS::set_window_per_pixel_transparency_enabled(bool p_enabled) {
|
|
|
|
OS::get_singleton()->set_window_per_pixel_transparency_enabled(p_enabled);
|
|
|
|
}
|
|
|
|
|
2016-01-03 05:18:28 +01:00
|
|
|
bool _OS::get_borderless_window() const {
|
|
|
|
return OS::get_singleton()->get_borderless_window();
|
|
|
|
}
|
2015-01-10 08:47:34 +01:00
|
|
|
|
2018-06-07 22:16:57 +02:00
|
|
|
void _OS::set_ime_active(const bool p_active) {
|
|
|
|
|
2018-11-23 13:07:48 +01:00
|
|
|
OS::get_singleton()->set_ime_active(p_active);
|
2018-06-07 22:16:57 +02:00
|
|
|
}
|
|
|
|
|
2017-06-25 17:50:45 +02:00
|
|
|
void _OS::set_ime_position(const Point2 &p_pos) {
|
|
|
|
|
2018-11-23 13:07:48 +01:00
|
|
|
OS::get_singleton()->set_ime_position(p_pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
Point2 _OS::get_ime_selection() const {
|
|
|
|
return OS::get_singleton()->get_ime_selection();
|
|
|
|
}
|
|
|
|
|
|
|
|
String _OS::get_ime_text() const {
|
|
|
|
return OS::get_singleton()->get_ime_text();
|
2017-06-25 17:50:45 +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
|
|
|
bool _OS::is_video_mode_resizable(int p_screen) const {
|
|
|
|
|
|
|
|
OS::VideoMode vm;
|
|
|
|
vm = OS::get_singleton()->get_video_mode(p_screen);
|
|
|
|
return vm.resizable;
|
|
|
|
}
|
|
|
|
|
|
|
|
Array _OS::get_fullscreen_mode_list(int p_screen) const {
|
|
|
|
|
|
|
|
List<OS::VideoMode> vmlist;
|
2017-03-05 16:44:50 +01:00
|
|
|
OS::get_singleton()->get_fullscreen_mode_list(&vmlist, p_screen);
|
2014-02-10 02:10:30 +01:00
|
|
|
Array vmarr;
|
2017-03-05 16:44:50 +01:00
|
|
|
for (List<OS::VideoMode>::Element *E = vmlist.front(); E; E = E->next()) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
vmarr.push_back(Size2(E->get().width, E->get().height));
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return vmarr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void _OS::set_low_processor_usage_mode(bool p_enabled) {
|
|
|
|
|
|
|
|
OS::get_singleton()->set_low_processor_usage_mode(p_enabled);
|
|
|
|
}
|
|
|
|
bool _OS::is_in_low_processor_usage_mode() const {
|
|
|
|
|
|
|
|
return OS::get_singleton()->is_in_low_processor_usage_mode();
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
};
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int _OS::execute(const String &p_path, const Vector<String> &p_arguments, bool p_blocking, Array p_output) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2018-05-30 12:18:01 +02:00
|
|
|
OS::ProcessID pid = -2;
|
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;
|
2017-03-05 16:44:50 +01:00
|
|
|
Error err = OS::get_singleton()->execute(p_path, args, p_blocking, &pid, &pipe);
|
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;
|
|
|
|
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();
|
|
|
|
}
|
|
|
|
|
2016-07-02 20:52:36 +02:00
|
|
|
String _OS::get_latin_keyboard_variant() const {
|
2017-03-05 16:44:50 +01:00
|
|
|
switch (OS::get_singleton()->get_latin_keyboard_variant()) {
|
2016-07-02 20:52:36 +02:00
|
|
|
case OS::LATIN_KEYBOARD_QWERTY: return "QWERTY";
|
|
|
|
case OS::LATIN_KEYBOARD_QWERTZ: return "QWERTZ";
|
|
|
|
case OS::LATIN_KEYBOARD_AZERTY: return "AZERTY";
|
|
|
|
case OS::LATIN_KEYBOARD_QZERTY: return "QZERTY";
|
|
|
|
case OS::LATIN_KEYBOARD_DVORAK: return "DVORAK";
|
2017-03-05 16:44:50 +01:00
|
|
|
case OS::LATIN_KEYBOARD_NEO: return "NEO";
|
2017-10-24 19:32:40 +02:00
|
|
|
case OS::LATIN_KEYBOARD_COLEMAK: return "COLEMAK";
|
2016-07-02 20:52:36 +02:00
|
|
|
default: return "ERROR";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2015-02-15 05:19:46 +01:00
|
|
|
bool _OS::is_ok_left_and_cancel_right() const {
|
|
|
|
|
|
|
|
return OS::get_singleton()->get_swap_ok_cancel();
|
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
};
|
|
|
|
|
2016-06-06 00:14:33 +02:00
|
|
|
void _OS::set_use_vsync(bool p_enable) {
|
|
|
|
OS::get_singleton()->set_use_vsync(p_enable);
|
|
|
|
}
|
|
|
|
|
2016-11-08 15:06:57 +01:00
|
|
|
bool _OS::is_vsync_enabled() const {
|
2016-06-06 00:14:33 +02:00
|
|
|
|
2016-11-08 15:06:57 +01:00
|
|
|
return OS::get_singleton()->is_vsync_enabled();
|
2016-06-06 00:14:33 +02:00
|
|
|
}
|
|
|
|
|
2017-09-16 12:28:23 +02:00
|
|
|
_OS::PowerState _OS::get_power_state() {
|
|
|
|
return _OS::PowerState(OS::get_singleton()->get_power_state());
|
2016-07-23 13:15:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int _OS::get_power_seconds_left() {
|
|
|
|
return OS::get_singleton()->get_power_seconds_left();
|
|
|
|
}
|
|
|
|
|
|
|
|
int _OS::get_power_percent_left() {
|
|
|
|
return OS::get_singleton()->get_power_percent_left();
|
|
|
|
}
|
2016-02-01 00:22:38 +01:00
|
|
|
|
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;
|
|
|
|
};
|
|
|
|
*/
|
|
|
|
|
|
|
|
int _OS::get_static_memory_usage() const {
|
|
|
|
|
|
|
|
return OS::get_singleton()->get_static_memory_usage();
|
|
|
|
}
|
|
|
|
|
|
|
|
int _OS::get_static_memory_peak_usage() const {
|
|
|
|
|
|
|
|
return OS::get_singleton()->get_static_memory_peak_usage();
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int _OS::get_dynamic_memory_usage() const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
return OS::get_singleton()->get_dynamic_memory_usage();
|
|
|
|
}
|
|
|
|
|
2017-05-17 12:36:47 +02:00
|
|
|
void _OS::set_icon(const Ref<Image> &p_icon) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
OS::get_singleton()->set_icon(p_icon);
|
|
|
|
}
|
|
|
|
|
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) {
|
|
|
|
|
|
|
|
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 }
|
|
|
|
};
|
|
|
|
|
|
|
|
ERR_EXPLAIN("Invalid second value of: " + itos(second));
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(second > 59, 0);
|
2016-03-16 05:17:10 +01:00
|
|
|
|
|
|
|
ERR_EXPLAIN("Invalid minute value of: " + itos(minute));
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(minute > 59, 0);
|
2016-03-16 05:17:10 +01:00
|
|
|
|
|
|
|
ERR_EXPLAIN("Invalid hour value of: " + itos(hour));
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(hour > 23, 0);
|
2016-03-16 05:17:10 +01:00
|
|
|
|
2018-04-16 11:15:17 +02:00
|
|
|
ERR_EXPLAIN("Invalid month value of: " + itos(month));
|
|
|
|
ERR_FAIL_COND_V(month > 12 || month == 0, 0);
|
2016-03-16 05:17:10 +01:00
|
|
|
|
|
|
|
// Do this check after month is tested as valid
|
2018-04-16 11:15:17 +02:00
|
|
|
ERR_EXPLAIN("Invalid day value of: " + itos(day) + " which is larger than " + itos(MONTH_DAYS_TABLE[LEAPYEAR(year)][month - 1]) + " or 0");
|
|
|
|
ERR_FAIL_COND_V(day > MONTH_DAYS_TABLE[LEAPYEAR(year)][month - 1] || day == 0, 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;
|
|
|
|
|
2016-03-16 05:17:10 +01:00
|
|
|
while (dayno >= MONTH_DAYS_TABLE[LEAPYEAR(year)][imonth]) {
|
|
|
|
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
|
|
|
}
|
|
|
|
|
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();
|
|
|
|
}
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
bool _OS::can_draw() const {
|
|
|
|
|
|
|
|
return OS::get_singleton()->can_draw();
|
|
|
|
}
|
|
|
|
|
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
|
|
|
{
|
|
|
|
List<Ref<Resource> > rsrc;
|
|
|
|
ResourceCache::get_cached_resources(&rsrc);
|
|
|
|
|
2017-03-05 16:44:50 +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
|
|
|
|
|
|
|
List<Ref<Resource> > resources;
|
|
|
|
ResourceCache::get_cached_resources(&resources);
|
|
|
|
|
|
|
|
List<Ref<Resource> > rsrc;
|
|
|
|
ResourceCache::get_cached_resources(&rsrc);
|
|
|
|
|
2017-03-05 16:44:50 +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
|
|
|
|
2016-07-21 23:58:58 +02:00
|
|
|
bool _OS::has_virtual_keyboard() const {
|
|
|
|
return OS::get_singleton()->has_virtual_keyboard();
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void _OS::show_virtual_keyboard(const String &p_existing_text) {
|
2016-07-21 23:58:58 +02:00
|
|
|
OS::get_singleton()->show_virtual_keyboard(p_existing_text, Rect2());
|
|
|
|
}
|
|
|
|
|
|
|
|
void _OS::hide_virtual_keyboard() {
|
|
|
|
OS::get_singleton()->hide_virtual_keyboard();
|
|
|
|
}
|
2014-02-26 14:08:17 +01:00
|
|
|
|
2017-10-04 10:39:31 +02:00
|
|
|
int _OS::get_virtual_keyboard_height() {
|
|
|
|
return OS::get_singleton()->get_virtual_keyboard_height();
|
|
|
|
}
|
|
|
|
|
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-17 11:46:11 +01:00
|
|
|
Error _OS::native_video_play(String p_path, float p_volume, String p_audio_track, String p_subtitle_track) {
|
2014-03-14 02:57:24 +01:00
|
|
|
|
2014-11-17 11:46:11 +01:00
|
|
|
return OS::get_singleton()->native_video_play(p_path, p_volume, p_audio_track, p_subtitle_track);
|
2014-03-14 02:57:24 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
bool _OS::native_video_is_playing() {
|
|
|
|
|
|
|
|
return OS::get_singleton()->native_video_is_playing();
|
|
|
|
};
|
|
|
|
|
|
|
|
void _OS::native_video_pause() {
|
|
|
|
|
|
|
|
OS::get_singleton()->native_video_pause();
|
|
|
|
};
|
|
|
|
|
2016-02-19 05:09:06 +01:00
|
|
|
void _OS::native_video_unpause() {
|
|
|
|
OS::get_singleton()->native_video_unpause();
|
|
|
|
};
|
|
|
|
|
2014-03-14 02:57:24 +01:00
|
|
|
void _OS::native_video_stop() {
|
|
|
|
|
|
|
|
OS::get_singleton()->native_video_stop();
|
|
|
|
};
|
|
|
|
|
2016-07-05 17:29:08 +02:00
|
|
|
void _OS::request_attention() {
|
|
|
|
|
|
|
|
OS::get_singleton()->request_attention();
|
|
|
|
}
|
|
|
|
|
2018-02-12 18:17:29 +01:00
|
|
|
void _OS::center_window() {
|
|
|
|
|
|
|
|
OS::get_singleton()->center_window();
|
|
|
|
}
|
|
|
|
|
2018-11-07 15:13:02 +01:00
|
|
|
void _OS::move_window_to_foreground() {
|
|
|
|
|
|
|
|
OS::get_singleton()->move_window_to_foreground();
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
2015-08-04 23:09:51 +02:00
|
|
|
void _OS::set_screen_orientation(ScreenOrientation p_orientation) {
|
|
|
|
|
|
|
|
OS::get_singleton()->set_screen_orientation(OS::ScreenOrientation(p_orientation));
|
|
|
|
}
|
|
|
|
|
|
|
|
_OS::ScreenOrientation _OS::get_screen_orientation() const {
|
|
|
|
|
|
|
|
return ScreenOrientation(OS::get_singleton()->get_screen_orientation());
|
|
|
|
}
|
|
|
|
|
2015-11-27 15:40:04 +01:00
|
|
|
void _OS::set_keep_screen_on(bool p_enabled) {
|
|
|
|
|
|
|
|
OS::get_singleton()->set_keep_screen_on(p_enabled);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool _OS::is_keep_screen_on() const {
|
|
|
|
|
|
|
|
return OS::get_singleton()->is_keep_screen_on();
|
|
|
|
}
|
2015-08-04 23:09:51 +02:00
|
|
|
|
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));
|
|
|
|
}
|
|
|
|
|
2015-05-17 18:11:55 +02:00
|
|
|
String _OS::get_scancode_string(uint32_t p_code) const {
|
|
|
|
|
|
|
|
return keycode_get_string(p_code);
|
|
|
|
}
|
|
|
|
bool _OS::is_scancode_unicode(uint32_t p_unicode) const {
|
|
|
|
|
|
|
|
return keycode_has_unicode(p_unicode);
|
|
|
|
}
|
2017-03-05 16:44:50 +01:00
|
|
|
int _OS::find_scancode_from_string(const String &p_code) const {
|
2015-05-17 18:11:55 +02:00
|
|
|
|
|
|
|
return find_keycode(p_code);
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void _OS::alert(const String &p_alert, const String &p_title) {
|
2015-09-21 14:39:46 +02:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
OS::get_singleton()->alert(p_alert, p_title);
|
2015-09-21 14:39:46 +02:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
_OS *_OS::singleton = NULL;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
void _OS::_bind_methods() {
|
|
|
|
|
2017-03-29 17:29:38 +02:00
|
|
|
//ClassDB::bind_method(D_METHOD("get_mouse_position"),&_OS::get_mouse_position);
|
2017-02-13 12:47:24 +01:00
|
|
|
//ClassDB::bind_method(D_METHOD("is_mouse_grab_enabled"),&_OS::is_mouse_grab_enabled);
|
2017-01-03 03:03:46 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("set_clipboard", "clipboard"), &_OS::set_clipboard);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_clipboard"), &_OS::get_clipboard);
|
2017-01-03 03:03:46 +01:00
|
|
|
|
2017-01-14 14:06:15 +01:00
|
|
|
//will not delete for now, just unexpose
|
2017-02-13 12:47:24 +01:00
|
|
|
//ClassDB::bind_method(D_METHOD("set_video_mode","size","fullscreen","resizable","screen"),&_OS::set_video_mode,DEFVAL(0));
|
|
|
|
//ClassDB::bind_method(D_METHOD("get_video_mode_size","screen"),&_OS::get_video_mode,DEFVAL(0));
|
|
|
|
//ClassDB::bind_method(D_METHOD("is_video_mode_fullscreen","screen"),&_OS::is_video_mode_fullscreen,DEFVAL(0));
|
|
|
|
//ClassDB::bind_method(D_METHOD("is_video_mode_resizable","screen"),&_OS::is_video_mode_resizable,DEFVAL(0));
|
|
|
|
//ClassDB::bind_method(D_METHOD("get_fullscreen_mode_list","screen"),&_OS::get_fullscreen_mode_list,DEFVAL(0));
|
|
|
|
|
2018-03-04 18:18:05 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("get_video_driver_count"), &_OS::get_video_driver_count);
|
2018-03-23 18:57:58 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("get_video_driver_name", "driver"), &_OS::get_video_driver_name);
|
2018-03-04 18:18:05 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("get_audio_driver_count"), &_OS::get_audio_driver_count);
|
2018-03-23 18:57:58 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("get_audio_driver_name", "driver"), &_OS::get_audio_driver_name);
|
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("get_screen_count"), &_OS::get_screen_count);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_current_screen"), &_OS::get_current_screen);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_current_screen", "screen"), &_OS::set_current_screen);
|
2017-08-20 21:12:29 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("get_screen_position", "screen"), &_OS::get_screen_position, DEFVAL(-1));
|
|
|
|
ClassDB::bind_method(D_METHOD("get_screen_size", "screen"), &_OS::get_screen_size, DEFVAL(-1));
|
|
|
|
ClassDB::bind_method(D_METHOD("get_screen_dpi", "screen"), &_OS::get_screen_dpi, DEFVAL(-1));
|
2017-03-05 16:44:50 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("get_window_position"), &_OS::get_window_position);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_window_position", "position"), &_OS::set_window_position);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_window_size"), &_OS::get_window_size);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_window_size", "size"), &_OS::set_window_size);
|
2018-04-10 12:35:30 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("get_window_safe_area"), &_OS::get_window_safe_area);
|
2017-03-05 16:44:50 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("set_window_fullscreen", "enabled"), &_OS::set_window_fullscreen);
|
|
|
|
ClassDB::bind_method(D_METHOD("is_window_fullscreen"), &_OS::is_window_fullscreen);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_window_resizable", "enabled"), &_OS::set_window_resizable);
|
|
|
|
ClassDB::bind_method(D_METHOD("is_window_resizable"), &_OS::is_window_resizable);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_window_minimized", "enabled"), &_OS::set_window_minimized);
|
|
|
|
ClassDB::bind_method(D_METHOD("is_window_minimized"), &_OS::is_window_minimized);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_window_maximized", "enabled"), &_OS::set_window_maximized);
|
|
|
|
ClassDB::bind_method(D_METHOD("is_window_maximized"), &_OS::is_window_maximized);
|
2017-12-27 20:51:19 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("set_window_always_on_top", "enabled"), &_OS::set_window_always_on_top);
|
|
|
|
ClassDB::bind_method(D_METHOD("is_window_always_on_top"), &_OS::is_window_always_on_top);
|
2017-02-13 12:47:24 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("request_attention"), &_OS::request_attention);
|
2018-02-12 18:17:29 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("get_real_window_size"), &_OS::get_real_window_size);
|
|
|
|
ClassDB::bind_method(D_METHOD("center_window"), &_OS::center_window);
|
2018-11-07 15:13:02 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("move_window_to_foreground"), &_OS::move_window_to_foreground);
|
2017-02-13 12:47:24 +01:00
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_borderless_window", "borderless"), &_OS::set_borderless_window);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_borderless_window"), &_OS::get_borderless_window);
|
|
|
|
|
2017-12-10 19:38:26 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("get_window_per_pixel_transparency_enabled"), &_OS::get_window_per_pixel_transparency_enabled);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_window_per_pixel_transparency_enabled", "enabled"), &_OS::set_window_per_pixel_transparency_enabled);
|
|
|
|
|
2018-11-23 13:07:48 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("set_ime_active", "active"), &_OS::set_ime_active);
|
2017-07-22 12:11:42 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("set_ime_position", "position"), &_OS::set_ime_position);
|
2018-11-23 13:07:48 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("get_ime_selection"), &_OS::get_ime_selection);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_ime_text"), &_OS::get_ime_text);
|
2017-06-25 17:50:45 +02:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("set_screen_orientation", "orientation"), &_OS::set_screen_orientation);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_screen_orientation"), &_OS::get_screen_orientation);
|
2017-02-13 12:47:24 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("set_keep_screen_on", "enabled"), &_OS::set_keep_screen_on);
|
|
|
|
ClassDB::bind_method(D_METHOD("is_keep_screen_on"), &_OS::is_keep_screen_on);
|
2017-02-13 12:47:24 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("has_touchscreen_ui_hint"), &_OS::has_touchscreen_ui_hint);
|
2017-02-13 12:47:24 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("set_window_title", "title"), &_OS::set_window_title);
|
2017-02-13 12:47:24 +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
|
|
|
|
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);
|
|
|
|
ClassDB::bind_method(D_METHOD("execute", "path", "arguments", "blocking", "output"), &_OS::execute, DEFVAL(Array()));
|
|
|
|
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);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-08-09 13:19:41 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("set_icon", "icon"), &_OS::set_icon);
|
2017-01-07 18:55:48 +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_latin_keyboard_variant"), &_OS::get_latin_keyboard_variant);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_model_name"), &_OS::get_model_name);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("can_draw"), &_OS::can_draw);
|
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("has_virtual_keyboard"), &_OS::has_virtual_keyboard);
|
|
|
|
ClassDB::bind_method(D_METHOD("show_virtual_keyboard", "existing_text"), &_OS::show_virtual_keyboard, DEFVAL(""));
|
|
|
|
ClassDB::bind_method(D_METHOD("hide_virtual_keyboard"), &_OS::hide_virtual_keyboard);
|
2017-10-04 10:39:31 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("get_virtual_keyboard_height"), &_OS::get_virtual_keyboard_height);
|
2017-03-05 16:44:50 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("print_resources_in_use", "short"), &_OS::print_resources_in_use, DEFVAL(false));
|
|
|
|
ClassDB::bind_method(D_METHOD("print_all_resources", "tofile"), &_OS::print_all_resources, DEFVAL(""));
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_static_memory_usage"), &_OS::get_static_memory_usage);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_static_memory_peak_usage"), &_OS::get_static_memory_peak_usage);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_dynamic_memory_usage"), &_OS::get_dynamic_memory_usage);
|
|
|
|
|
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("is_ok_left_and_cancel_right"), &_OS::is_ok_left_and_cancel_right);
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("print_all_textures_by_size"), &_OS::print_all_textures_by_size);
|
|
|
|
ClassDB::bind_method(D_METHOD("print_resources_by_type", "types"), &_OS::print_resources_by_type);
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("native_video_play", "path", "volume", "audio_track", "subtitle_track"), &_OS::native_video_play);
|
|
|
|
ClassDB::bind_method(D_METHOD("native_video_is_playing"), &_OS::native_video_is_playing);
|
|
|
|
ClassDB::bind_method(D_METHOD("native_video_stop"), &_OS::native_video_stop);
|
|
|
|
ClassDB::bind_method(D_METHOD("native_video_pause"), &_OS::native_video_pause);
|
|
|
|
ClassDB::bind_method(D_METHOD("native_video_unpause"), &_OS::native_video_unpause);
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_scancode_string", "code"), &_OS::get_scancode_string);
|
|
|
|
ClassDB::bind_method(D_METHOD("is_scancode_unicode", "code"), &_OS::is_scancode_unicode);
|
|
|
|
ClassDB::bind_method(D_METHOD("find_scancode_from_string", "string"), &_OS::find_scancode_from_string);
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_use_file_access_save_and_swap", "enabled"), &_OS::set_use_file_access_save_and_swap);
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("alert", "text", "title"), &_OS::alert, DEFVAL("Alert!"));
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_thread_name", "name"), &_OS::set_thread_name);
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_use_vsync", "enable"), &_OS::set_use_vsync);
|
|
|
|
ClassDB::bind_method(D_METHOD("is_vsync_enabled"), &_OS::is_vsync_enabled);
|
|
|
|
|
2017-10-02 21:38:39 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("has_feature", "tag_name"), &_OS::has_feature);
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("get_power_state"), &_OS::get_power_state);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_power_seconds_left"), &_OS::get_power_seconds_left);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_power_percent_left"), &_OS::get_power_percent_left);
|
|
|
|
|
2018-01-11 23:35:12 +01:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::STRING, "clipboard"), "set_clipboard", "get_clipboard");
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "current_screen"), "set_current_screen", "get_current_screen");
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "exit_code"), "set_exit_code", "get_exit_code");
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "vsync_enabled"), "set_use_vsync", "is_vsync_enabled");
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "low_processor_usage_mode"), "set_low_processor_usage_mode", "is_in_low_processor_usage_mode");
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "keep_screen_on"), "set_keep_screen_on", "is_keep_screen_on");
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "screen_orientation", PROPERTY_HINT_ENUM, "Landscape,Portrait,Reverse Landscape,Reverse Portrait,Sensor Landscape,Sensor Portrait,Sensor"), "set_screen_orientation", "get_screen_orientation");
|
|
|
|
ADD_GROUP("Window", "window_");
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "window_borderless"), "set_borderless_window", "get_borderless_window");
|
2017-12-10 19:38:26 +01:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "window_per_pixel_transparency_enabled"), "set_window_per_pixel_transparency_enabled", "get_window_per_pixel_transparency_enabled");
|
2018-01-11 23:35:12 +01:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "window_fullscreen"), "set_window_fullscreen", "is_window_fullscreen");
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "window_maximized"), "set_window_maximized", "is_window_maximized");
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "window_minimized"), "set_window_minimized", "is_window_minimized");
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "window_resizable"), "set_window_resizable", "is_window_resizable");
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "window_position"), "set_window_position", "get_window_position");
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "window_size"), "set_window_size", "get_window_size");
|
|
|
|
|
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(SCREEN_ORIENTATION_LANDSCAPE);
|
|
|
|
BIND_ENUM_CONSTANT(SCREEN_ORIENTATION_PORTRAIT);
|
|
|
|
BIND_ENUM_CONSTANT(SCREEN_ORIENTATION_REVERSE_LANDSCAPE);
|
|
|
|
BIND_ENUM_CONSTANT(SCREEN_ORIENTATION_REVERSE_PORTRAIT);
|
|
|
|
BIND_ENUM_CONSTANT(SCREEN_ORIENTATION_SENSOR_LANDSCAPE);
|
|
|
|
BIND_ENUM_CONSTANT(SCREEN_ORIENTATION_SENSOR_PORTRAIT);
|
|
|
|
BIND_ENUM_CONSTANT(SCREEN_ORIENTATION_SENSOR);
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
2017-09-16 12:28:23 +02:00
|
|
|
BIND_ENUM_CONSTANT(POWERSTATE_UNKNOWN);
|
|
|
|
BIND_ENUM_CONSTANT(POWERSTATE_ON_BATTERY);
|
|
|
|
BIND_ENUM_CONSTANT(POWERSTATE_NO_BATTERY);
|
|
|
|
BIND_ENUM_CONSTANT(POWERSTATE_CHARGING);
|
|
|
|
BIND_ENUM_CONSTANT(POWERSTATE_CHARGED);
|
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;
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
PoolVector<Plane> _Geometry::build_box_planes(const Vector3 &p_extents) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
return Geometry::build_box_planes(p_extents);
|
|
|
|
}
|
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<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
|
|
|
}
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<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
|
|
|
}
|
|
|
|
|
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();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
PoolVector<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);
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<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;
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
PoolVector<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);
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<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
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
PoolVector<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
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<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;
|
|
|
|
}
|
2017-03-05 16:44:50 +01:00
|
|
|
PoolVector<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
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<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;
|
|
|
|
}
|
2017-03-05 16:44:50 +01:00
|
|
|
PoolVector<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
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<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;
|
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
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));
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("triangulate_polygon", "polygon"), &_Geometry::triangulate_polygon);
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("make_atlas", "sizes"), &_Geometry::make_atlas);
|
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
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Error _File::open_encrypted(const String &p_path, int 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;
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Error _File::open_encrypted_pass(const String &p_path, int 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;
|
|
|
|
}
|
|
|
|
|
2017-06-19 18:28:00 +02:00
|
|
|
Error _File::open_compressed(const String &p_path, int p_mode_flags, int p_compress_mode) {
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Error _File::open(const String &p_path, int 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 {
|
|
|
|
|
|
|
|
ERR_FAIL_COND_V(!f, "");
|
|
|
|
return f->get_path();
|
|
|
|
}
|
|
|
|
|
|
|
|
String _File::get_path_absolute() const {
|
|
|
|
|
|
|
|
ERR_FAIL_COND_V(!f, "");
|
|
|
|
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
|
|
|
|
|
|
|
ERR_FAIL_COND(!f);
|
|
|
|
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
|
|
|
|
|
|
|
ERR_FAIL_COND(!f);
|
|
|
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!f, 0);
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!f, 0);
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!f, false);
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!f, 0);
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!f, 0);
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!f, 0);
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!f, 0);
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!f, 0);
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!f, 0);
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!f, 0);
|
2014-02-10 02:10:30 +01:00
|
|
|
return f->get_real();
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
PoolVector<uint8_t> _File::get_buffer(int p_length) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t> data;
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!f, data);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(p_length < 0, data);
|
|
|
|
if (p_length == 0)
|
2014-02-10 02:10:30 +01:00
|
|
|
return data;
|
|
|
|
Error err = data.resize(p_length);
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(err != OK, data);
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t>::Write w = data.write();
|
2017-03-05 16:44:50 +01:00
|
|
|
int len = f->get_buffer(&w[0], p_length);
|
|
|
|
ERR_FAIL_COND_V(len < 0, PoolVector<uint8_t>());
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
w = PoolVector<uint8_t>::Write();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (len < p_length)
|
|
|
|
data.resize(p_length);
|
|
|
|
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
|
|
|
String _File::get_as_text() const {
|
|
|
|
|
2016-06-20 23:39:37 +02:00
|
|
|
ERR_FAIL_COND_V(!f, String());
|
|
|
|
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!f, String());
|
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 {
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!f, Vector<String>());
|
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
|
|
|
|
|
|
|
ERR_FAIL_COND(!f);
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
ERR_FAIL_COND(!f);
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
ERR_FAIL_COND(!f);
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
ERR_FAIL_COND(!f);
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
ERR_FAIL_COND(!f);
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
ERR_FAIL_COND(!f);
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
ERR_FAIL_COND(!f);
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
ERR_FAIL_COND(!f);
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
ERR_FAIL_COND(!f);
|
|
|
|
|
|
|
|
f->store_pascal_string(p_string);
|
|
|
|
};
|
|
|
|
|
|
|
|
String _File::get_pascal_string() {
|
|
|
|
|
|
|
|
ERR_FAIL_COND_V(!f, "");
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
ERR_FAIL_COND(!f);
|
|
|
|
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) {
|
|
|
|
ERR_FAIL_COND(!f);
|
|
|
|
f->store_csv_line(p_values, p_delim);
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void _File::store_buffer(const PoolVector<uint8_t> &p_buffer) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
ERR_FAIL_COND(!f);
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t>::Read r = p_buffer.read();
|
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);
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void _File::store_var(const Variant &p_var) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
ERR_FAIL_COND(!f);
|
|
|
|
int len;
|
2017-03-05 16:44:50 +01:00
|
|
|
Error err = encode_variant(p_var, NULL, len);
|
|
|
|
ERR_FAIL_COND(err != OK);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t> buff;
|
2014-02-10 02:10:30 +01:00
|
|
|
buff.resize(len);
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t>::Write w = buff.write();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
err = encode_variant(p_var, &w[0], len);
|
|
|
|
ERR_FAIL_COND(err != OK);
|
|
|
|
w = PoolVector<uint8_t>::Write();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
store_32(len);
|
|
|
|
store_buffer(buff);
|
|
|
|
}
|
|
|
|
|
|
|
|
Variant _File::get_var() const {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!f, Variant());
|
2014-02-10 02:10:30 +01:00
|
|
|
uint32_t len = get_32();
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<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
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t>::Read r = buff.read();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
Variant v;
|
2017-03-05 16:44:50 +01:00
|
|
|
Error err = decode_variant(v, &r[0], len);
|
|
|
|
ERR_FAIL_COND_V(err != OK, 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);
|
2017-03-05 16:44:50 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("get_var"), &_File::get_var);
|
|
|
|
|
|
|
|
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);
|
|
|
|
ClassDB::bind_method(D_METHOD("store_var", "value"), &_File::store_var);
|
|
|
|
|
|
|
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!d, ERR_UNCONFIGURED);
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!d, "");
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!d, false);
|
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
|
|
|
|
|
|
|
ERR_FAIL_COND(!d);
|
|
|
|
return d->list_dir_end();
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int _Directory::get_drive_count() {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!d, 0);
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!d, "");
|
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() {
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!d, 0);
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!d, ERR_UNCONFIGURED);
|
2014-02-10 02:10:30 +01:00
|
|
|
return d->change_dir(p_dir);
|
|
|
|
}
|
|
|
|
String _Directory::get_current_dir() {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!d, "");
|
2014-02-10 02:10:30 +01:00
|
|
|
return d->get_current_dir();
|
|
|
|
}
|
2017-03-05 16:44:50 +01:00
|
|
|
Error _Directory::make_dir(String p_dir) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!d, ERR_UNCONFIGURED);
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!d, ERR_UNCONFIGURED);
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!d, false);
|
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) {
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!d, false);
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!d, 0);
|
|
|
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!d, ERR_UNCONFIGURED);
|
|
|
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!d, ERR_UNCONFIGURED);
|
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
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!d, ERR_UNCONFIGURED);
|
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);
|
2017-03-05 16:44:50 +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;
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
String _Marshalls::variant_to_base64(const Variant &p_var) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
int len;
|
2017-03-05 16:44:50 +01:00
|
|
|
Error err = encode_variant(p_var, NULL, len);
|
|
|
|
ERR_FAIL_COND_V(err != OK, "");
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t> buff;
|
2014-02-10 02:10:30 +01:00
|
|
|
buff.resize(len);
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t>::Write w = buff.write();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
err = encode_variant(p_var, &w[0], len);
|
|
|
|
ERR_FAIL_COND_V(err != OK, "");
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-06-11 15:41:03 +02:00
|
|
|
int b64len = len / 3 * 4 + 4 + 1;
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t> b64buff;
|
2014-02-10 02:10:30 +01:00
|
|
|
b64buff.resize(b64len);
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t>::Write w64 = b64buff.write();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int strlen = base64_encode((char *)(&w64[0]), (char *)(&w[0]), len);
|
2014-02-10 02:10:30 +01:00
|
|
|
//OS::get_singleton()->print("len is %i, vector size is %i\n", b64len, strlen);
|
|
|
|
w64[strlen] = 0;
|
2017-03-05 16:44:50 +01:00
|
|
|
String ret = (char *)&w64[0];
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
};
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Variant _Marshalls::base64_to_variant(const String &p_str) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
int strlen = p_str.length();
|
|
|
|
CharString cstr = p_str.ascii();
|
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t> buf;
|
2014-06-11 15:41:03 +02:00
|
|
|
buf.resize(strlen / 4 * 3 + 1);
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t>::Write w = buf.write();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int len = base64_decode((char *)(&w[0]), (char *)cstr.get_data(), strlen);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
Variant v;
|
|
|
|
Error err = decode_variant(v, &w[0], len);
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(err != OK, Variant());
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
return v;
|
|
|
|
};
|
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
String _Marshalls::raw_to_base64(const PoolVector<uint8_t> &p_arr) {
|
2015-07-28 12:50:52 +02:00
|
|
|
|
|
|
|
int len = p_arr.size();
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t>::Read r = p_arr.read();
|
2015-07-28 12:50:52 +02:00
|
|
|
|
|
|
|
int b64len = len / 3 * 4 + 4 + 1;
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t> b64buff;
|
2015-07-28 12:50:52 +02:00
|
|
|
b64buff.resize(b64len);
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t>::Write w64 = b64buff.write();
|
2015-07-28 12:50:52 +02:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int strlen = base64_encode((char *)(&w64[0]), (char *)(&r[0]), len);
|
2015-07-28 12:50:52 +02:00
|
|
|
w64[strlen] = 0;
|
2017-03-05 16:44:50 +01:00
|
|
|
String ret = (char *)&w64[0];
|
2015-07-28 12:50:52 +02:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
};
|
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<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();
|
|
|
|
|
|
|
|
int arr_len;
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t> buf;
|
2015-07-28 12:50:52 +02:00
|
|
|
{
|
|
|
|
buf.resize(strlen / 4 * 3 + 1);
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t>::Write w = buf.write();
|
2015-07-28 12:50:52 +02:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
arr_len = base64_decode((char *)(&w[0]), (char *)cstr.get_data(), strlen);
|
2015-07-28 12:50:52 +02:00
|
|
|
};
|
|
|
|
buf.resize(arr_len);
|
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
// conversion from PoolVector<uint8_t> to raw array?
|
2015-07-28 12:50:52 +02:00
|
|
|
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();
|
|
|
|
int len = cstr.length();
|
|
|
|
|
|
|
|
int b64len = len / 3 * 4 + 4 + 1;
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t> b64buff;
|
2015-07-28 12:50:52 +02:00
|
|
|
b64buff.resize(b64len);
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t>::Write w64 = b64buff.write();
|
2015-07-28 12:50:52 +02:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int strlen = base64_encode((char *)(&w64[0]), (char *)cstr.get_data(), len);
|
2015-07-28 12:50:52 +02:00
|
|
|
|
|
|
|
w64[strlen] = 0;
|
2017-03-05 16:44:50 +01:00
|
|
|
String ret = (char *)&w64[0];
|
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();
|
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t> buf;
|
2015-07-28 12:50:52 +02:00
|
|
|
buf.resize(strlen / 4 * 3 + 1 + 1);
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t>::Write w = buf.write();
|
2015-07-28 12:50:52 +02:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int len = base64_decode((char *)(&w[0]), (char *)cstr.get_data(), strlen);
|
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() {
|
|
|
|
|
2017-08-09 13:19:41 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("variant_to_base64", "variant"), &_Marshalls::variant_to_base64);
|
|
|
|
ClassDB::bind_method(D_METHOD("base64_to_variant", "base64_str"), &_Marshalls::base64_to_variant);
|
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
|
|
|
};
|
|
|
|
|
|
|
|
////////////////
|
|
|
|
|
|
|
|
Error _Semaphore::wait() {
|
|
|
|
|
|
|
|
return semaphore->wait();
|
|
|
|
}
|
|
|
|
|
|
|
|
Error _Semaphore::post() {
|
|
|
|
|
|
|
|
return semaphore->post();
|
|
|
|
}
|
|
|
|
|
|
|
|
void _Semaphore::_bind_methods() {
|
|
|
|
|
2017-08-09 13:19:41 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("wait"), &_Semaphore::wait);
|
|
|
|
ClassDB::bind_method(D_METHOD("post"), &_Semaphore::post);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
_Semaphore::_Semaphore() {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
semaphore = Semaphore::create();
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
_Semaphore::~_Semaphore() {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
memdelete(semaphore);
|
|
|
|
}
|
|
|
|
|
|
|
|
///////////////
|
|
|
|
|
|
|
|
void _Mutex::lock() {
|
|
|
|
|
|
|
|
mutex->lock();
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Error _Mutex::try_lock() {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
return mutex->try_lock();
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void _Mutex::unlock() {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
mutex->unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
_Mutex::_Mutex() {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
mutex = Mutex::create();
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
_Mutex::~_Mutex() {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
memdelete(mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
///////////////
|
|
|
|
|
|
|
|
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);
|
2014-02-10 02:10:30 +01:00
|
|
|
Variant::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);
|
|
|
|
if (ce.error != Variant::CallError::CALL_OK) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
String reason;
|
2017-03-05 16:44:50 +01:00
|
|
|
switch (ce.error) {
|
2014-02-10 02:10:30 +01:00
|
|
|
case Variant::CallError::CALL_ERROR_INVALID_ARGUMENT: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
reason = "Invalid Argument #" + itos(ce.argument);
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
|
|
|
case Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
reason = "Too Many Arguments";
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
|
|
|
case Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
reason = "Too Many Arguments";
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
|
|
|
case Variant::CallError::CALL_ERROR_INVALID_METHOD: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
reason = "Method Not Found";
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
|
|
|
default: {}
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_EXPLAIN("Could not call function '" + t->target_method.operator String() + "'' starting thread ID: " + t->get_id() + " Reason: " + reason);
|
2014-02-10 02:10:30 +01:00
|
|
|
ERR_FAIL();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Error _Thread::start(Object *p_instance, const StringName &p_method, const Variant &p_userdata, int p_priority) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(active, ERR_ALREADY_IN_USE);
|
|
|
|
ERR_FAIL_COND_V(!p_instance, ERR_INVALID_PARAMETER);
|
|
|
|
ERR_FAIL_COND_V(p_method == StringName(), ERR_INVALID_PARAMETER);
|
|
|
|
ERR_FAIL_INDEX_V(p_priority, 3, 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() {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!thread, Variant());
|
|
|
|
ERR_FAIL_COND_V(!active, Variant());
|
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();
|
|
|
|
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() {
|
|
|
|
|
2015-05-18 17:45:53 +02:00
|
|
|
if (active) {
|
2018-04-22 19:36:01 +02:00
|
|
|
ERR_EXPLAIN("Reference to a Thread object object was lost while the thread is still running...");
|
2015-05-18 17:45:53 +02:00
|
|
|
}
|
2018-10-03 19:40:37 +02:00
|
|
|
ERR_FAIL_COND(active);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2017-01-03 03:03:46 +01:00
|
|
|
/////////////////////////////////////
|
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
PoolStringArray _ClassDB::get_class_list() const {
|
2017-01-03 03:03:46 +01:00
|
|
|
|
|
|
|
List<StringName> classes;
|
|
|
|
ClassDB::get_class_list(&classes);
|
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
PoolStringArray 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
|
|
|
PoolStringArray _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
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
PoolStringArray 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;
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
PoolStringArray _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
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
PoolStringArray 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();
|
|
|
|
}
|
|
|
|
|
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();
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
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);
|
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");
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL, "time_scale"), "set_time_scale", "get_time_scale");
|
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
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL, "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);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
_JSON *_JSON::singleton = NULL;
|
|
|
|
|
|
|
|
_JSON::_JSON() {
|
|
|
|
singleton = this;
|
|
|
|
}
|