Replace File/Directory with FileAccess/DirAccess

17 files changed, 366 insertions, 17 deletions

diff --git a/core/io/dir_access.cpp b/core/io/dir_access.cpp
index bed41b8d89..4454f2a100 100644
--- a/core/io/dir_access.cpp
+++ b/core/io/dir_access.cpp
@@ -36,6 +36,8 @@
 #include "core/os/os.h"
 #include "core/templates/local_vector.h"
 
+thread_local Error DirAccess::last_dir_open_error = OK;
+
 String DirAccess::_get_root_path() const {
 	switch (_access_type) {
 		case ACCESS_RESOURCES:
@@ -249,6 +251,16 @@ Ref<DirAccess> DirAccess::open(const String &p_path, Error *r_error) {
 	return da;
 }
 
+Ref<DirAccess> DirAccess::_open(const String &p_path) {
+	Error err = OK;
+	Ref<DirAccess> da = open(p_path, &err);
+	last_dir_open_error = err;
+	if (err) {
+		return Ref<DirAccess>();
+	}
+	return da;
+}
+
 Ref<DirAccess> DirAccess::create(AccessType p_access) {
 	Ref<DirAccess> da = create_func[p_access] ? create_func[p_access]() : nullptr;
 	if (da.is_valid()) {
@@ -266,6 +278,10 @@ Ref<DirAccess> DirAccess::create(AccessType p_access) {
 	return da;
 }
 
+Error DirAccess::get_open_error() {
+	return last_dir_open_error;
+}
+
 String DirAccess::get_full_path(const String &p_path, AccessType p_access) {
 	Ref<DirAccess> d = DirAccess::create(p_access);
 	if (d.is_null()) {
@@ -424,3 +440,84 @@ bool DirAccess::exists(String p_dir) {
 	Ref<DirAccess> da = DirAccess::create_for_path(p_dir);
 	return da->change_dir(p_dir) == OK;
 }
+
+PackedStringArray DirAccess::get_files() {
+	return _get_contents(false);
+}
+
+PackedStringArray DirAccess::get_directories() {
+	return _get_contents(true);
+}
+
+PackedStringArray DirAccess::_get_contents(bool p_directories) {
+	PackedStringArray ret;
+
+	list_dir_begin();
+	String s = _get_next();
+	while (!s.is_empty()) {
+		if (current_is_dir() == p_directories) {
+			ret.append(s);
+		}
+		s = _get_next();
+	}
+
+	ret.sort();
+	return ret;
+}
+
+String DirAccess::_get_next() {
+	String next = get_next();
+	while (!next.is_empty() && ((!include_navigational && (next == "." || next == "..")) || (!include_hidden && current_is_hidden()))) {
+		next = get_next();
+	}
+	return next;
+}
+
+void DirAccess::set_include_navigational(bool p_enable) {
+	include_navigational = p_enable;
+}
+
+bool DirAccess::get_include_navigational() const {
+	return include_navigational;
+}
+
+void DirAccess::set_include_hidden(bool p_enable) {
+	include_hidden = p_enable;
+}
+
+bool DirAccess::get_include_hidden() const {
+	return include_hidden;
+}
+
+void DirAccess::_bind_methods() {
+	ClassDB::bind_static_method("DirAccess", D_METHOD("open", "path"), &DirAccess::_open);
+	ClassDB::bind_static_method("DirAccess", D_METHOD("get_open_error"), &DirAccess::get_open_error);
+
+	ClassDB::bind_method(D_METHOD("list_dir_begin"), &DirAccess::list_dir_begin, DEFVAL(false), DEFVAL(false));
+	ClassDB::bind_method(D_METHOD("get_next"), &DirAccess::_get_next);
+	ClassDB::bind_method(D_METHOD("current_is_dir"), &DirAccess::current_is_dir);
+	ClassDB::bind_method(D_METHOD("list_dir_end"), &DirAccess::list_dir_end);
+	ClassDB::bind_method(D_METHOD("get_files"), &DirAccess::get_files);
+	ClassDB::bind_method(D_METHOD("get_directories"), &DirAccess::get_directories);
+	ClassDB::bind_method(D_METHOD("get_drive_count"), &DirAccess::get_drive_count);
+	ClassDB::bind_method(D_METHOD("get_drive", "idx"), &DirAccess::get_drive);
+	ClassDB::bind_method(D_METHOD("get_current_drive"), &DirAccess::get_current_drive);
+	ClassDB::bind_method(D_METHOD("change_dir", "todir"), &DirAccess::change_dir);
+	ClassDB::bind_method(D_METHOD("get_current_dir", "include_drive"), &DirAccess::get_current_dir, DEFVAL(true));
+	ClassDB::bind_method(D_METHOD("make_dir", "path"), &DirAccess::make_dir);
+	ClassDB::bind_method(D_METHOD("make_dir_recursive", "path"), &DirAccess::make_dir_recursive);
+	ClassDB::bind_method(D_METHOD("file_exists", "path"), &DirAccess::file_exists);
+	ClassDB::bind_method(D_METHOD("dir_exists", "path"), &DirAccess::dir_exists);
+	ClassDB::bind_method(D_METHOD("get_space_left"), &DirAccess::get_space_left);
+	ClassDB::bind_method(D_METHOD("copy", "from", "to", "chmod_flags"), &DirAccess::copy, DEFVAL(-1));
+	ClassDB::bind_method(D_METHOD("rename", "from", "to"), &DirAccess::rename);
+	ClassDB::bind_method(D_METHOD("remove", "path"), &DirAccess::remove);
+
+	ClassDB::bind_method(D_METHOD("set_include_navigational", "enable"), &DirAccess::set_include_navigational);
+	ClassDB::bind_method(D_METHOD("get_include_navigational"), &DirAccess::get_include_navigational);
+	ClassDB::bind_method(D_METHOD("set_include_hidden", "enable"), &DirAccess::set_include_hidden);
+	ClassDB::bind_method(D_METHOD("get_include_hidden"), &DirAccess::get_include_hidden);
+
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "include_navigational"), "set_include_navigational", "get_include_navigational");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "include_hidden"), "set_include_hidden", "get_include_hidden");
+}
diff --git a/core/io/dir_access.h b/core/io/dir_access.h
index 2469c2a080..a694f6388f 100644
--- a/core/io/dir_access.h
+++ b/core/io/dir_access.h
@@ -37,6 +37,8 @@
 
 //@ TODO, excellent candidate for THREAD_SAFE MACRO, should go through all these and add THREAD_SAFE where it applies
 class DirAccess : public RefCounted {
+	GDCLASS(DirAccess, RefCounted);
+
 public:
 	enum AccessType {
 		ACCESS_RESOURCES,
@@ -53,7 +55,13 @@ private:
 
 	Error _copy_dir(Ref<DirAccess> &p_target_da, String p_to, int p_chmod_flags, bool p_copy_links);
 
+	thread_local static Error last_dir_open_error;
+	bool include_navigational = false;
+	bool include_hidden = false;
+
 protected:
+	static void _bind_methods();
+
 	String _get_root_path() const;
 	virtual String _get_root_string() const;
 
@@ -118,6 +126,7 @@ public:
 	static Ref<DirAccess> create_for_path(const String &p_path);
 
 	static Ref<DirAccess> create(AccessType p_access);
+	static Error get_open_error();
 
 	template <class T>
 	static void make_default(AccessType p_access) {
@@ -125,6 +134,17 @@ public:
 	}
 
 	static Ref<DirAccess> open(const String &p_path, Error *r_error = nullptr);
+	static Ref<DirAccess> _open(const String &p_path);
+
+	PackedStringArray get_files();
+	PackedStringArray get_directories();
+	PackedStringArray _get_contents(bool p_directories);
+	String _get_next();
+
+	void set_include_navigational(bool p_enable);
+	bool get_include_navigational() const;
+	void set_include_hidden(bool p_enable);
+	bool get_include_hidden() const;
 
 	DirAccess() {}
 	virtual ~DirAccess() {}
diff --git a/core/io/file_access.cpp b/core/io/file_access.cpp
index 72c00bd678..499f083f51 100644
--- a/core/io/file_access.cpp
+++ b/core/io/file_access.cpp
@@ -32,6 +32,8 @@
 
 #include "core/config/project_settings.h"
 #include "core/crypto/crypto_core.h"
+#include "core/io/file_access_compressed.h"
+#include "core/io/file_access_encrypted.h"
 #include "core/io/file_access_pack.h"
 #include "core/io/marshalls.h"
 #include "core/os/os.h"
@@ -41,6 +43,7 @@ FileAccess::CreateFunc FileAccess::create_func[ACCESS_MAX] = { nullptr, nullptr
 FileAccess::FileCloseFailNotify FileAccess::close_fail_notify = nullptr;
 
 bool FileAccess::backup_save = false;
+thread_local Error FileAccess::last_file_open_error = OK;
 
 Ref<FileAccess> FileAccess::create(AccessType p_access) {
 	ERR_FAIL_INDEX_V(p_access, ACCESS_MAX, nullptr);
@@ -81,7 +84,7 @@ Ref<FileAccess> FileAccess::create_for_path(const String &p_path) {
 }
 
 Error FileAccess::reopen(const String &p_path, int p_mode_flags) {
-	return _open(p_path, p_mode_flags);
+	return open_internal(p_path, p_mode_flags);
 }
 
 Ref<FileAccess> FileAccess::open(const String &p_path, int p_mode_flags, Error *r_error) {
@@ -99,7 +102,7 @@ Ref<FileAccess> FileAccess::open(const String &p_path, int p_mode_flags, Error *
 	}
 
 	ret = create_for_path(p_path);
-	Error err = ret->_open(p_path, p_mode_flags);
+	Error err = ret->open_internal(p_path, p_mode_flags);
 
 	if (r_error) {
 		*r_error = err;
@@ -111,6 +114,66 @@ Ref<FileAccess> FileAccess::open(const String &p_path, int p_mode_flags, Error *
 	return ret;
 }
 
+Ref<FileAccess> FileAccess::_open(const String &p_path, ModeFlags p_mode_flags) {
+	Error err = OK;
+	Ref<FileAccess> fa = open(p_path, p_mode_flags, &err);
+	last_file_open_error = err;
+	if (err) {
+		return Ref<FileAccess>();
+	}
+	return fa;
+}
+
+Ref<FileAccess> FileAccess::open_encrypted(const String &p_path, ModeFlags p_mode_flags, const Vector<uint8_t> &p_key) {
+	Ref<FileAccess> fa = _open(p_path, p_mode_flags);
+	if (fa.is_null()) {
+		return fa;
+	}
+
+	Ref<FileAccessEncrypted> fae;
+	fae.instantiate();
+	Error err = fae->open_and_parse(fa, p_key, (p_mode_flags == WRITE) ? FileAccessEncrypted::MODE_WRITE_AES256 : FileAccessEncrypted::MODE_READ);
+	if (err) {
+		last_file_open_error = err;
+		return Ref<FileAccess>();
+	}
+	return fae;
+}
+
+Ref<FileAccess> FileAccess::open_encrypted_pass(const String &p_path, ModeFlags p_mode_flags, const String &p_pass) {
+	Ref<FileAccess> fa = _open(p_path, p_mode_flags);
+	if (fa.is_null()) {
+		return fa;
+	}
+
+	Ref<FileAccessEncrypted> fae;
+	fae.instantiate();
+	Error err = fae->open_and_parse_password(fa, p_pass, (p_mode_flags == WRITE) ? FileAccessEncrypted::MODE_WRITE_AES256 : FileAccessEncrypted::MODE_READ);
+	if (err) {
+		last_file_open_error = err;
+		return Ref<FileAccess>();
+	}
+	return fae;
+}
+
+Ref<FileAccess> FileAccess::open_compressed(const String &p_path, ModeFlags p_mode_flags, CompressionMode p_compress_mode) {
+	Ref<FileAccessCompressed> fac;
+	fac.instantiate();
+	fac->configure("GCPF", (Compression::Mode)p_compress_mode);
+	Error err = fac->open_internal(p_path, p_mode_flags);
+
+	if (err) {
+		last_file_open_error = err;
+		return Ref<FileAccess>();
+	}
+
+	return fac;
+}
+
+Error FileAccess::get_open_error() {
+	return last_file_open_error;
+}
+
 FileAccess::CreateFunc FileAccess::get_create_func(AccessType p_access) {
 	return create_func[p_access];
 }
@@ -227,6 +290,20 @@ real_t FileAccess::get_real() const {
 	}
 }
 
+Variant FileAccess::get_var(bool p_allow_objects) const {
+	uint32_t len = get_32();
+	Vector<uint8_t> buff = _get_buffer(len);
+	ERR_FAIL_COND_V((uint32_t)buff.size() != len, Variant());
+
+	const uint8_t *r = buff.ptr();
+
+	Variant v;
+	Error err = decode_variant(v, &r[0], len, nullptr, p_allow_objects);
+	ERR_FAIL_COND_V_MSG(err != OK, Variant(), "Error when trying to encode Variant.");
+
+	return v;
+}
+
 double FileAccess::get_double() const {
 	MarshallDouble m;
 	m.l = get_64();
@@ -370,6 +447,17 @@ Vector<String> FileAccess::get_csv_line(const String &p_delim) const {
 	return strings;
 }
 
+String FileAccess::get_as_text(bool p_skip_cr) const {
+	uint64_t original_pos = get_position();
+	const_cast<FileAccess *>(this)->seek(0);
+
+	String text = get_as_utf8_string(p_skip_cr);
+
+	const_cast<FileAccess *>(this)->seek(original_pos);
+
+	return text;
+}
+
 uint64_t FileAccess::get_buffer(uint8_t *p_dst, uint64_t p_length) const {
 	ERR_FAIL_COND_V(!p_dst && p_length > 0, -1);
 
@@ -381,6 +469,27 @@ uint64_t FileAccess::get_buffer(uint8_t *p_dst, uint64_t p_length) const {
 	return i;
 }
 
+Vector<uint8_t> FileAccess::_get_buffer(int64_t p_length) const {
+	Vector<uint8_t> data;
+
+	ERR_FAIL_COND_V_MSG(p_length < 0, data, "Length of buffer cannot be smaller than 0.");
+	if (p_length == 0) {
+		return data;
+	}
+
+	Error err = data.resize(p_length);
+	ERR_FAIL_COND_V_MSG(err != OK, data, "Can't resize data to " + itos(p_length) + " elements.");
+
+	uint8_t *w = data.ptrw();
+	int64_t len = get_buffer(&w[0], p_length);
+
+	if (len < p_length) {
+		data.resize(len);
+	}
+
+	return data;
+}
+
 String FileAccess::get_as_utf8_string(bool p_skip_cr) const {
 	Vector<uint8_t> sourcef;
 	uint64_t len = get_length();
@@ -554,6 +663,33 @@ void FileAccess::store_buffer(const uint8_t *p_src, uint64_t p_length) {
 	}
 }
 
+void FileAccess::_store_buffer(const Vector<uint8_t> &p_buffer) {
+	uint64_t len = p_buffer.size();
+	if (len == 0) {
+		return;
+	}
+
+	const uint8_t *r = p_buffer.ptr();
+
+	store_buffer(&r[0], len);
+}
+
+void FileAccess::store_var(const Variant &p_var, bool p_full_objects) {
+	int len;
+	Error err = encode_variant(p_var, nullptr, len, p_full_objects);
+	ERR_FAIL_COND_MSG(err != OK, "Error when trying to encode Variant.");
+
+	Vector<uint8_t> buff;
+	buff.resize(len);
+
+	uint8_t *w = buff.ptrw();
+	err = encode_variant(p_var, &w[0], len, p_full_objects);
+	ERR_FAIL_COND_MSG(err != OK, "Error when trying to encode Variant.");
+
+	store_32(len);
+	_store_buffer(buff);
+}
+
 Vector<uint8_t> FileAccess::get_file_as_array(const String &p_path, Error *r_error) {
 	Ref<FileAccess> f = FileAccess::open(p_path, READ, r_error);
 	if (f.is_null()) {
@@ -666,3 +802,69 @@ String FileAccess::get_sha256(const String &p_file) {
 
 	return String::hex_encode_buffer(hash, 32);
 }
+
+void FileAccess::_bind_methods() {
+	ClassDB::bind_static_method("FileAccess", D_METHOD("open", "path", "flags"), &FileAccess::_open);
+	ClassDB::bind_static_method("FileAccess", D_METHOD("open_encrypted", "path", "mode_flags", "key"), &FileAccess::open_encrypted);
+	ClassDB::bind_static_method("FileAccess", D_METHOD("open_encrypted_with_pass", "path", "mode_flags", "pass"), &FileAccess::open_encrypted_pass);
+	ClassDB::bind_static_method("FileAccess", D_METHOD("open_compressed", "path", "mode_flags", "compression_mode"), &FileAccess::open_compressed, DEFVAL(0));
+	ClassDB::bind_static_method("FileAccess", D_METHOD("get_open_error"), &FileAccess::get_open_error);
+
+	ClassDB::bind_method(D_METHOD("flush"), &FileAccess::flush);
+	ClassDB::bind_method(D_METHOD("get_path"), &FileAccess::get_path);
+	ClassDB::bind_method(D_METHOD("get_path_absolute"), &FileAccess::get_path_absolute);
+	ClassDB::bind_method(D_METHOD("is_open"), &FileAccess::is_open);
+	ClassDB::bind_method(D_METHOD("seek", "position"), &FileAccess::seek);
+	ClassDB::bind_method(D_METHOD("seek_end", "position"), &FileAccess::seek_end, DEFVAL(0));
+	ClassDB::bind_method(D_METHOD("get_position"), &FileAccess::get_position);
+	ClassDB::bind_method(D_METHOD("get_length"), &FileAccess::get_length);
+	ClassDB::bind_method(D_METHOD("eof_reached"), &FileAccess::eof_reached);
+	ClassDB::bind_method(D_METHOD("get_8"), &FileAccess::get_8);
+	ClassDB::bind_method(D_METHOD("get_16"), &FileAccess::get_16);
+	ClassDB::bind_method(D_METHOD("get_32"), &FileAccess::get_32);
+	ClassDB::bind_method(D_METHOD("get_64"), &FileAccess::get_64);
+	ClassDB::bind_method(D_METHOD("get_float"), &FileAccess::get_float);
+	ClassDB::bind_method(D_METHOD("get_double"), &FileAccess::get_double);
+	ClassDB::bind_method(D_METHOD("get_real"), &FileAccess::get_real);
+	ClassDB::bind_method(D_METHOD("get_buffer", "length"), &FileAccess::_get_buffer);
+	ClassDB::bind_method(D_METHOD("get_line"), &FileAccess::get_line);
+	ClassDB::bind_method(D_METHOD("get_csv_line", "delim"), &FileAccess::get_csv_line, DEFVAL(","));
+	ClassDB::bind_method(D_METHOD("get_as_text", "skip_cr"), &FileAccess::get_as_text, DEFVAL(false));
+	ClassDB::bind_static_method("FileAccess", D_METHOD("get_md5", "path"), &FileAccess::get_md5);
+	ClassDB::bind_static_method("FileAccess", D_METHOD("get_sha256", "path"), &FileAccess::get_sha256);
+	ClassDB::bind_method(D_METHOD("is_big_endian"), &FileAccess::is_big_endian);
+	ClassDB::bind_method(D_METHOD("set_big_endian", "big_endian"), &FileAccess::set_big_endian);
+	ClassDB::bind_method(D_METHOD("get_error"), &FileAccess::get_error);
+	ClassDB::bind_method(D_METHOD("get_var", "allow_objects"), &FileAccess::get_var, DEFVAL(false));
+
+	ClassDB::bind_method(D_METHOD("store_8", "value"), &FileAccess::store_8);
+	ClassDB::bind_method(D_METHOD("store_16", "value"), &FileAccess::store_16);
+	ClassDB::bind_method(D_METHOD("store_32", "value"), &FileAccess::store_32);
+	ClassDB::bind_method(D_METHOD("store_64", "value"), &FileAccess::store_64);
+	ClassDB::bind_method(D_METHOD("store_float", "value"), &FileAccess::store_float);
+	ClassDB::bind_method(D_METHOD("store_double", "value"), &FileAccess::store_double);
+	ClassDB::bind_method(D_METHOD("store_real", "value"), &FileAccess::store_real);
+	ClassDB::bind_method(D_METHOD("store_buffer", "buffer"), &FileAccess::_store_buffer);
+	ClassDB::bind_method(D_METHOD("store_line", "line"), &FileAccess::store_line);
+	ClassDB::bind_method(D_METHOD("store_csv_line", "values", "delim"), &FileAccess::store_csv_line, DEFVAL(","));
+	ClassDB::bind_method(D_METHOD("store_string", "string"), &FileAccess::store_string);
+	ClassDB::bind_method(D_METHOD("store_var", "value", "full_objects"), &FileAccess::store_var, DEFVAL(false));
+
+	ClassDB::bind_method(D_METHOD("store_pascal_string", "string"), &FileAccess::store_pascal_string);
+	ClassDB::bind_method(D_METHOD("get_pascal_string"), &FileAccess::get_pascal_string);
+
+	ClassDB::bind_static_method("FileAccess", D_METHOD("file_exists", "path"), &FileAccess::exists);
+	ClassDB::bind_static_method("FileAccess", D_METHOD("get_modified_time", "file"), &FileAccess::get_modified_time);
+
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "big_endian"), "set_big_endian", "is_big_endian");
+
+	BIND_ENUM_CONSTANT(READ);
+	BIND_ENUM_CONSTANT(WRITE);
+	BIND_ENUM_CONSTANT(READ_WRITE);
+	BIND_ENUM_CONSTANT(WRITE_READ);
+
+	BIND_ENUM_CONSTANT(COMPRESSION_FASTLZ);
+	BIND_ENUM_CONSTANT(COMPRESSION_DEFLATE);
+	BIND_ENUM_CONSTANT(COMPRESSION_ZSTD);
+	BIND_ENUM_CONSTANT(COMPRESSION_GZIP);
+}
diff --git a/core/io/file_access.h b/core/io/file_access.h
index fc0eb95d44..f8c42d3c0d 100644
--- a/core/io/file_access.h
+++ b/core/io/file_access.h
@@ -31,6 +31,7 @@
 #ifndef FILE_ACCESS_H
 #define FILE_ACCESS_H
 
+#include "core/io/compression.h"
 #include "core/math/math_defs.h"
 #include "core/object/ref_counted.h"
 #include "core/os/memory.h"
@@ -42,6 +43,8 @@
  */
 
 class FileAccess : public RefCounted {
+	GDCLASS(FileAccess, RefCounted);
+
 public:
 	enum AccessType {
 		ACCESS_RESOURCES,
@@ -60,15 +63,18 @@ public:
 	virtual Error _set_unix_permissions(const String &p_file, uint32_t p_permissions) = 0;
 
 protected:
+	static void _bind_methods();
+
 	AccessType get_access_type() const;
 	String fix_path(const String &p_path) const;
-	virtual Error _open(const String &p_path, int p_mode_flags) = 0; ///< open a file
+	virtual Error open_internal(const String &p_path, int p_mode_flags) = 0; ///< open a file
 	virtual uint64_t _get_modified_time(const String &p_file) = 0;
 
 	static FileCloseFailNotify close_fail_notify;
 
 private:
 	static bool backup_save;
+	thread_local static Error last_file_open_error;
 
 	AccessType _access_type = ACCESS_FILESYSTEM;
 	static CreateFunc create_func[ACCESS_MAX]; /** default file access creation function for a platform */
@@ -89,6 +95,13 @@ public:
 		WRITE_READ = 7,
 	};
 
+	enum CompressionMode {
+		COMPRESSION_FASTLZ = Compression::MODE_FASTLZ,
+		COMPRESSION_DEFLATE = Compression::MODE_DEFLATE,
+		COMPRESSION_ZSTD = Compression::MODE_ZSTD,
+		COMPRESSION_GZIP = Compression::MODE_GZIP
+	};
+
 	virtual bool is_open() const = 0; ///< true when file is open
 
 	virtual String get_path() const { return ""; } /// returns the path for the current open file
@@ -110,10 +123,14 @@ public:
 	virtual double get_double() const;
 	virtual real_t get_real() const;
 
+	Variant get_var(bool p_allow_objects = false) const;
+
 	virtual uint64_t get_buffer(uint8_t *p_dst, uint64_t p_length) const; ///< get an array of bytes
+	Vector<uint8_t> _get_buffer(int64_t p_length) const;
 	virtual String get_line() const;
 	virtual String get_token() const;
 	virtual Vector<String> get_csv_line(const String &p_delim = ",") const;
+	String get_as_text(bool p_skip_cr = false) const;
 	virtual String get_as_utf8_string(bool p_skip_cr = false) const;
 
 	/**
@@ -144,6 +161,9 @@ public:
 	virtual String get_pascal_string();
 
 	virtual void store_buffer(const uint8_t *p_src, uint64_t p_length); ///< store an array of bytes
+	void _store_buffer(const Vector<uint8_t> &p_buffer);
+
+	void store_var(const Variant &p_var, bool p_full_objects = false);
 
 	virtual bool file_exists(const String &p_name) = 0; ///< return true if a file exists
 
@@ -152,6 +172,13 @@ public:
 	static Ref<FileAccess> create(AccessType p_access); /// Create a file access (for the current platform) this is the only portable way of accessing files.
 	static Ref<FileAccess> create_for_path(const String &p_path);
 	static Ref<FileAccess> open(const String &p_path, int p_mode_flags, Error *r_error = nullptr); /// Create a file access (for the current platform) this is the only portable way of accessing files.
+
+	static Ref<FileAccess> _open(const String &p_path, ModeFlags p_mode_flags);
+	static Ref<FileAccess> open_encrypted(const String &p_path, ModeFlags p_mode_flags, const Vector<uint8_t> &p_key);
+	static Ref<FileAccess> open_encrypted_pass(const String &p_path, ModeFlags p_mode_flags, const String &p_pass);
+	static Ref<FileAccess> open_compressed(const String &p_path, ModeFlags p_mode_flags, CompressionMode p_compress_mode = COMPRESSION_FASTLZ);
+	static Error get_open_error();
+
 	static CreateFunc get_create_func(AccessType p_access);
 	static bool exists(const String &p_name); ///< return true if a file exists
 	static uint64_t get_modified_time(const String &p_file);
@@ -177,4 +204,7 @@ public:
 	virtual ~FileAccess() {}
 };
 
+VARIANT_ENUM_CAST(FileAccess::CompressionMode);
+VARIANT_ENUM_CAST(FileAccess::ModeFlags);
+
 #endif // FILE_ACCESS_H
diff --git a/core/io/file_access_compressed.cpp b/core/io/file_access_compressed.cpp
index 1d0a718166..d2c8a88269 100644
--- a/core/io/file_access_compressed.cpp
+++ b/core/io/file_access_compressed.cpp
@@ -95,7 +95,7 @@ Error FileAccessCompressed::open_after_magic(Ref<FileAccess> p_base) {
 	return ret == -1 ? ERR_FILE_CORRUPT : OK;
 }
 
-Error FileAccessCompressed::_open(const String &p_path, int p_mode_flags) {
+Error FileAccessCompressed::open_internal(const String &p_path, int p_mode_flags) {
 	ERR_FAIL_COND_V(p_mode_flags == READ_WRITE, ERR_UNAVAILABLE);
 	_close();
 
diff --git a/core/io/file_access_compressed.h b/core/io/file_access_compressed.h
index e41491a92c..ee114c2c65 100644
--- a/core/io/file_access_compressed.h
+++ b/core/io/file_access_compressed.h
@@ -70,7 +70,7 @@ public:
 
 	Error open_after_magic(Ref<FileAccess> p_base);
 
-	virtual Error _open(const String &p_path, int p_mode_flags) override; ///< open a file
+	virtual Error open_internal(const String &p_path, int p_mode_flags) override; ///< open a file
 	virtual bool is_open() const override; ///< true when file is open
 
 	virtual void seek(uint64_t p_position) override; ///< seek to a given position
diff --git a/core/io/file_access_encrypted.cpp b/core/io/file_access_encrypted.cpp
index d1b014a0be..be502dacd9 100644
--- a/core/io/file_access_encrypted.cpp
+++ b/core/io/file_access_encrypted.cpp
@@ -111,7 +111,7 @@ Error FileAccessEncrypted::open_and_parse_password(Ref<FileAccess> p_base, const
 	return open_and_parse(p_base, key, p_mode);
 }
 
-Error FileAccessEncrypted::_open(const String &p_path, int p_mode_flags) {
+Error FileAccessEncrypted::open_internal(const String &p_path, int p_mode_flags) {
 	return OK;
 }
 
diff --git a/core/io/file_access_encrypted.h b/core/io/file_access_encrypted.h
index 6200f87a7a..6b4588841d 100644
--- a/core/io/file_access_encrypted.h
+++ b/core/io/file_access_encrypted.h
@@ -60,7 +60,7 @@ public:
 	Error open_and_parse(Ref<FileAccess> p_base, const Vector<uint8_t> &p_key, Mode p_mode, bool p_with_magic = true);
 	Error open_and_parse_password(Ref<FileAccess> p_base, const String &p_key, Mode p_mode);
 
-	virtual Error _open(const String &p_path, int p_mode_flags) override; ///< open a file
+	virtual Error open_internal(const String &p_path, int p_mode_flags) override; ///< open a file
 	virtual bool is_open() const override; ///< true when file is open
 
 	virtual String get_path() const override; /// returns the path for the current open file
diff --git a/core/io/file_access_memory.cpp b/core/io/file_access_memory.cpp
index 499d001234..21ded4247f 100644
--- a/core/io/file_access_memory.cpp
+++ b/core/io/file_access_memory.cpp
@@ -78,7 +78,7 @@ Error FileAccessMemory::open_custom(const uint8_t *p_data, uint64_t p_len) {
 	return OK;
 }
 
-Error FileAccessMemory::_open(const String &p_path, int p_mode_flags) {
+Error FileAccessMemory::open_internal(const String &p_path, int p_mode_flags) {
 	ERR_FAIL_COND_V(!files, ERR_FILE_NOT_FOUND);
 
 	String name = fix_path(p_path);
diff --git a/core/io/file_access_memory.h b/core/io/file_access_memory.h
index f2bd2aa832..b1f408eb98 100644
--- a/core/io/file_access_memory.h
+++ b/core/io/file_access_memory.h
@@ -45,7 +45,7 @@ public:
 	static void cleanup();
 
 	virtual Error open_custom(const uint8_t *p_data, uint64_t p_len); ///< open a file
-	virtual Error _open(const String &p_path, int p_mode_flags) override; ///< open a file
+	virtual Error open_internal(const String &p_path, int p_mode_flags) override; ///< open a file
 	virtual bool is_open() const override; ///< true when file is open
 
 	virtual void seek(uint64_t p_position) override; ///< seek to a given position
diff --git a/core/io/file_access_network.cpp b/core/io/file_access_network.cpp
index 1365b4b593..13730518bf 100644
--- a/core/io/file_access_network.cpp
+++ b/core/io/file_access_network.cpp
@@ -252,7 +252,7 @@ void FileAccessNetwork::_respond(uint64_t p_len, Error p_status) {
 	pages.resize(pc);
 }
 
-Error FileAccessNetwork::_open(const String &p_path, int p_mode_flags) {
+Error FileAccessNetwork::open_internal(const String &p_path, int p_mode_flags) {
 	ERR_FAIL_COND_V(p_mode_flags != READ, ERR_UNAVAILABLE);
 	_close();
 
diff --git a/core/io/file_access_network.h b/core/io/file_access_network.h
index ceadc715a1..ee92d3b9db 100644
--- a/core/io/file_access_network.h
+++ b/core/io/file_access_network.h
@@ -132,7 +132,7 @@ public:
 		RESPONSE_GET_MODTIME,
 	};
 
-	virtual Error _open(const String &p_path, int p_mode_flags) override; ///< open a file
+	virtual Error open_internal(const String &p_path, int p_mode_flags) override; ///< open a file
 	virtual bool is_open() const override; ///< true when file is open
 
 	virtual void seek(uint64_t p_position) override; ///< seek to a given position
diff --git a/core/io/file_access_pack.cpp b/core/io/file_access_pack.cpp
index adae0db0f4..dfcce30ab5 100644
--- a/core/io/file_access_pack.cpp
+++ b/core/io/file_access_pack.cpp
@@ -259,7 +259,7 @@ Ref<FileAccess> PackedSourcePCK::get_file(const String &p_path, PackedData::Pack
 
 //////////////////////////////////////////////////////////////////
 
-Error FileAccessPack::_open(const String &p_path, int p_mode_flags) {
+Error FileAccessPack::open_internal(const String &p_path, int p_mode_flags) {
 	ERR_FAIL_V(ERR_UNAVAILABLE);
 	return ERR_UNAVAILABLE;
 }
diff --git a/core/io/file_access_pack.h b/core/io/file_access_pack.h
index 023758ac0f..4b9b49a161 100644
--- a/core/io/file_access_pack.h
+++ b/core/io/file_access_pack.h
@@ -148,7 +148,7 @@ class FileAccessPack : public FileAccess {
 	uint64_t off;
 
 	Ref<FileAccess> f;
-	virtual Error _open(const String &p_path, int p_mode_flags) override;
+	virtual Error open_internal(const String &p_path, int p_mode_flags) override;
 	virtual uint64_t _get_modified_time(const String &p_file) override { return 0; }
 	virtual uint32_t _get_unix_permissions(const String &p_file) override { return 0; }
 	virtual Error _set_unix_permissions(const String &p_file, uint32_t p_permissions) override { return FAILED; }
diff --git a/core/io/file_access_zip.cpp b/core/io/file_access_zip.cpp
index 17f2335a8e..2af6f370cf 100644
--- a/core/io/file_access_zip.cpp
+++ b/core/io/file_access_zip.cpp
@@ -234,7 +234,7 @@ ZipArchive::~ZipArchive() {
 	packages.clear();
 }
 
-Error FileAccessZip::_open(const String &p_path, int p_mode_flags) {
+Error FileAccessZip::open_internal(const String &p_path, int p_mode_flags) {
 	_close();
 
 	ERR_FAIL_COND_V(p_mode_flags & FileAccess::WRITE, FAILED);
diff --git a/core/io/file_access_zip.h b/core/io/file_access_zip.h
index 74a48192f3..6d61b9a291 100644
--- a/core/io/file_access_zip.h
+++ b/core/io/file_access_zip.h
@@ -85,7 +85,7 @@ class FileAccessZip : public FileAccess {
 	void _close();
 
 public:
-	virtual Error _open(const String &p_path, int p_mode_flags) override; ///< open a file
+	virtual Error open_internal(const String &p_path, int p_mode_flags) override; ///< open a file
 	virtual bool is_open() const override; ///< true when file is open
 
 	virtual void seek(uint64_t p_position) override; ///< seek to a given position
diff --git a/core/io/resource_format_binary.cpp b/core/io/resource_format_binary.cpp
index 4f1204fc48..06649aba5b 100644
--- a/core/io/resource_format_binary.cpp
+++ b/core/io/resource_format_binary.cpp
@@ -1206,7 +1206,7 @@ Error ResourceFormatLoaderBinary::rename_dependencies(const String &p_path, cons
 		Ref<FileAccessCompressed> facw;
 		facw.instantiate();
 		facw->configure("RSCC");
-		err = facw->_open(p_path + ".depren", FileAccess::WRITE);
+		err = facw->open_internal(p_path + ".depren", FileAccess::WRITE);
 		ERR_FAIL_COND_V_MSG(err, ERR_FILE_CORRUPT, "Cannot create file '" + p_path + ".depren'.");
 
 		fw = facw;
@@ -1986,7 +1986,7 @@ Error ResourceFormatSaverBinaryInstance::save(const String &p_path, const Ref<Re
 		fac.instantiate();
 		fac->configure("RSCC");
 		f = fac;
-		err = fac->_open(p_path, FileAccess::WRITE);
+		err = fac->open_internal(p_path, FileAccess::WRITE);
 	} else {
 		f = FileAccess::open(p_path, FileAccess::WRITE, &err);
 	}