Replace File/Directory with FileAccess/DirAccess

20 files changed, 368 insertions, 802 deletions

diff --git a/core/core_bind.cpp b/core/core_bind.cpp
index ba48adff6a..3127365338 100644
--- a/core/core_bind.cpp
+++ b/core/core_bind.cpp
@@ -992,636 +992,6 @@ void Geometry3D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("clip_polygon", "points", "plane"), &Geometry3D::clip_polygon);
 }
 
-////// File //////
-
-Error File::open_encrypted(const String &p_path, ModeFlags p_mode_flags, const Vector<uint8_t> &p_key) {
-	Error err = open(p_path, p_mode_flags);
-	if (err) {
-		return err;
-	}
-
-	Ref<FileAccessEncrypted> fae;
-	fae.instantiate();
-	err = fae->open_and_parse(f, p_key, (p_mode_flags == WRITE) ? FileAccessEncrypted::MODE_WRITE_AES256 : FileAccessEncrypted::MODE_READ);
-	if (err) {
-		close();
-		return err;
-	}
-	f = fae;
-	return OK;
-}
-
-Error File::open_encrypted_pass(const String &p_path, ModeFlags p_mode_flags, const String &p_pass) {
-	Error err = open(p_path, p_mode_flags);
-	if (err) {
-		return err;
-	}
-
-	Ref<FileAccessEncrypted> fae;
-	fae.instantiate();
-	err = fae->open_and_parse_password(f, p_pass, (p_mode_flags == WRITE) ? FileAccessEncrypted::MODE_WRITE_AES256 : FileAccessEncrypted::MODE_READ);
-	if (err) {
-		close();
-		return err;
-	}
-
-	f = fae;
-	return OK;
-}
-
-Error File::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(p_path, p_mode_flags);
-
-	if (err) {
-		return err;
-	}
-
-	f = fac;
-	return OK;
-}
-
-Error File::open(const String &p_path, ModeFlags p_mode_flags) {
-	Error err;
-	f = FileAccess::open(p_path, p_mode_flags, &err);
-	if (f.is_valid()) {
-		f->set_big_endian(big_endian);
-	}
-	return err;
-}
-
-void File::flush() {
-	ERR_FAIL_COND_MSG(f.is_null(), "File must be opened before flushing.");
-	f->flush();
-}
-
-void File::close() {
-	ERR_FAIL_COND_MSG(f.is_null(), "File must be opened.");
-	f.unref();
-}
-
-bool File::is_open() const {
-	return f != nullptr;
-}
-
-String File::get_path() const {
-	ERR_FAIL_COND_V_MSG(f.is_null(), "", "File must be opened before use, or is lacking read-write permission.");
-	return f->get_path();
-}
-
-String File::get_path_absolute() const {
-	ERR_FAIL_COND_V_MSG(f.is_null(), "", "File must be opened before use, or is lacking read-write permission.");
-	return f->get_path_absolute();
-}
-
-void File::seek(int64_t p_position) {
-	ERR_FAIL_COND_MSG(f.is_null(), "File must be opened before use, or is lacking read-write permission.");
-	ERR_FAIL_COND_MSG(p_position < 0, "Seek position must be a positive integer.");
-	f->seek(p_position);
-}
-
-void File::seek_end(int64_t p_position) {
-	ERR_FAIL_COND_MSG(f.is_null(), "File must be opened before use, or is lacking read-write permission.");
-	f->seek_end(p_position);
-}
-
-uint64_t File::get_position() const {
-	ERR_FAIL_COND_V_MSG(f.is_null(), 0, "File must be opened before use, or is lacking read-write permission.");
-	return f->get_position();
-}
-
-uint64_t File::get_length() const {
-	ERR_FAIL_COND_V_MSG(f.is_null(), 0, "File must be opened before use, or is lacking read-write permission.");
-	return f->get_length();
-}
-
-bool File::eof_reached() const {
-	ERR_FAIL_COND_V_MSG(f.is_null(), false, "File must be opened before use, or is lacking read-write permission.");
-	return f->eof_reached();
-}
-
-uint8_t File::get_8() const {
-	ERR_FAIL_COND_V_MSG(f.is_null(), 0, "File must be opened before use, or is lacking read-write permission.");
-	return f->get_8();
-}
-
-uint16_t File::get_16() const {
-	ERR_FAIL_COND_V_MSG(f.is_null(), 0, "File must be opened before use, or is lacking read-write permission.");
-	return f->get_16();
-}
-
-uint32_t File::get_32() const {
-	ERR_FAIL_COND_V_MSG(f.is_null(), 0, "File must be opened before use, or is lacking read-write permission.");
-	return f->get_32();
-}
-
-uint64_t File::get_64() const {
-	ERR_FAIL_COND_V_MSG(f.is_null(), 0, "File must be opened before use, or is lacking read-write permission.");
-	return f->get_64();
-}
-
-float File::get_float() const {
-	ERR_FAIL_COND_V_MSG(f.is_null(), 0, "File must be opened before use, or is lacking read-write permission.");
-	return f->get_float();
-}
-
-double File::get_double() const {
-	ERR_FAIL_COND_V_MSG(f.is_null(), 0, "File must be opened before use, or is lacking read-write permission.");
-	return f->get_double();
-}
-
-real_t File::get_real() const {
-	ERR_FAIL_COND_V_MSG(f.is_null(), 0, "File must be opened before use, or is lacking read-write permission.");
-	return f->get_real();
-}
-
-Vector<uint8_t> File::get_buffer(int64_t p_length) const {
-	Vector<uint8_t> data;
-	ERR_FAIL_COND_V_MSG(f.is_null(), data, "File must be opened before use, or is lacking read-write permission.");
-
-	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 = f->get_buffer(&w[0], p_length);
-
-	if (len < p_length) {
-		data.resize(len);
-	}
-
-	return data;
-}
-
-String File::get_as_text(bool p_skip_cr) const {
-	ERR_FAIL_COND_V_MSG(f.is_null(), String(), "File must be opened before use, or is lacking read-write permission.");
-
-	uint64_t original_pos = f->get_position();
-	const_cast<FileAccess *>(*f)->seek(0);
-
-	String text = f->get_as_utf8_string(p_skip_cr);
-
-	const_cast<FileAccess *>(*f)->seek(original_pos);
-
-	return text;
-}
-
-String File::get_md5(const String &p_path) const {
-	return FileAccess::get_md5(p_path);
-}
-
-String File::get_sha256(const String &p_path) const {
-	return FileAccess::get_sha256(p_path);
-}
-
-String File::get_line() const {
-	ERR_FAIL_COND_V_MSG(f.is_null(), String(), "File must be opened before use, or is lacking read-write permission.");
-	return f->get_line();
-}
-
-Vector<String> File::get_csv_line(const String &p_delim) const {
-	ERR_FAIL_COND_V_MSG(f.is_null(), Vector<String>(), "File must be opened before use, or is lacking read-write permission.");
-	return f->get_csv_line(p_delim);
-}
-
-/**< use this for files WRITTEN in _big_ endian machines (i.e. amiga/mac)
- * It's not about the current CPU type but file formats.
- * These flags get reset to false (little endian) on each open
- */
-
-void File::set_big_endian(bool p_big_endian) {
-	big_endian = p_big_endian;
-	if (f.is_valid()) {
-		f->set_big_endian(p_big_endian);
-	}
-}
-
-bool File::is_big_endian() {
-	return big_endian;
-}
-
-Error File::get_error() const {
-	if (f.is_null()) {
-		return ERR_UNCONFIGURED;
-	}
-	return f->get_error();
-}
-
-void File::store_8(uint8_t p_dest) {
-	ERR_FAIL_COND_MSG(f.is_null(), "File must be opened before use, or is lacking read-write permission.");
-
-	f->store_8(p_dest);
-}
-
-void File::store_16(uint16_t p_dest) {
-	ERR_FAIL_COND_MSG(f.is_null(), "File must be opened before use, or is lacking read-write permission.");
-
-	f->store_16(p_dest);
-}
-
-void File::store_32(uint32_t p_dest) {
-	ERR_FAIL_COND_MSG(f.is_null(), "File must be opened before use, or is lacking read-write permission.");
-
-	f->store_32(p_dest);
-}
-
-void File::store_64(uint64_t p_dest) {
-	ERR_FAIL_COND_MSG(f.is_null(), "File must be opened before use, or is lacking read-write permission.");
-
-	f->store_64(p_dest);
-}
-
-void File::store_float(float p_dest) {
-	ERR_FAIL_COND_MSG(f.is_null(), "File must be opened before use, or is lacking read-write permission.");
-
-	f->store_float(p_dest);
-}
-
-void File::store_double(double p_dest) {
-	ERR_FAIL_COND_MSG(f.is_null(), "File must be opened before use, or is lacking read-write permission.");
-
-	f->store_double(p_dest);
-}
-
-void File::store_real(real_t p_real) {
-	ERR_FAIL_COND_MSG(f.is_null(), "File must be opened before use, or is lacking read-write permission.");
-
-	f->store_real(p_real);
-}
-
-void File::store_string(const String &p_string) {
-	ERR_FAIL_COND_MSG(f.is_null(), "File must be opened before use, or is lacking read-write permission.");
-
-	f->store_string(p_string);
-}
-
-void File::store_pascal_string(const String &p_string) {
-	ERR_FAIL_COND_MSG(f.is_null(), "File must be opened before use, or is lacking read-write permission.");
-
-	f->store_pascal_string(p_string);
-}
-
-String File::get_pascal_string() {
-	ERR_FAIL_COND_V_MSG(f.is_null(), "", "File must be opened before use, or is lacking read-write permission.");
-
-	return f->get_pascal_string();
-}
-
-void File::store_line(const String &p_string) {
-	ERR_FAIL_COND_MSG(f.is_null(), "File must be opened before use, or is lacking read-write permission.");
-	f->store_line(p_string);
-}
-
-void File::store_csv_line(const Vector<String> &p_values, const String &p_delim) {
-	ERR_FAIL_COND_MSG(f.is_null(), "File must be opened before use, or is lacking read-write permission.");
-	f->store_csv_line(p_values, p_delim);
-}
-
-void File::store_buffer(const Vector<uint8_t> &p_buffer) {
-	ERR_FAIL_COND_MSG(f.is_null(), "File must be opened before use, or is lacking read-write permission.");
-
-	uint64_t len = p_buffer.size();
-	if (len == 0) {
-		return;
-	}
-
-	const uint8_t *r = p_buffer.ptr();
-
-	f->store_buffer(&r[0], len);
-}
-
-bool File::file_exists(const String &p_name) {
-	return FileAccess::exists(p_name);
-}
-
-void File::store_var(const Variant &p_var, bool p_full_objects) {
-	ERR_FAIL_COND_MSG(f.is_null(), "File must be opened before use, or is lacking read-write permission.");
-	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);
-}
-
-Variant File::get_var(bool p_allow_objects) const {
-	ERR_FAIL_COND_V_MSG(f.is_null(), Variant(), "File must be opened before use, or is lacking read-write permission.");
-	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;
-}
-
-uint64_t File::get_modified_time(const String &p_file) const {
-	return FileAccess::get_modified_time(p_file);
-}
-
-void File::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("open_encrypted", "path", "mode_flags", "key"), &File::open_encrypted);
-	ClassDB::bind_method(D_METHOD("open_encrypted_with_pass", "path", "mode_flags", "pass"), &File::open_encrypted_pass);
-	ClassDB::bind_method(D_METHOD("open_compressed", "path", "mode_flags", "compression_mode"), &File::open_compressed, DEFVAL(0));
-
-	ClassDB::bind_method(D_METHOD("open", "path", "flags"), &File::open);
-	ClassDB::bind_method(D_METHOD("flush"), &File::flush);
-	ClassDB::bind_method(D_METHOD("close"), &File::close);
-	ClassDB::bind_method(D_METHOD("get_path"), &File::get_path);
-	ClassDB::bind_method(D_METHOD("get_path_absolute"), &File::get_path_absolute);
-	ClassDB::bind_method(D_METHOD("is_open"), &File::is_open);
-	ClassDB::bind_method(D_METHOD("seek", "position"), &File::seek);
-	ClassDB::bind_method(D_METHOD("seek_end", "position"), &File::seek_end, DEFVAL(0));
-	ClassDB::bind_method(D_METHOD("get_position"), &File::get_position);
-	ClassDB::bind_method(D_METHOD("get_length"), &File::get_length);
-	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", "length"), &File::get_buffer);
-	ClassDB::bind_method(D_METHOD("get_line"), &File::get_line);
-	ClassDB::bind_method(D_METHOD("get_csv_line", "delim"), &File::get_csv_line, DEFVAL(","));
-	ClassDB::bind_method(D_METHOD("get_as_text", "skip_cr"), &File::get_as_text, DEFVAL(false));
-	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("is_big_endian"), &File::is_big_endian);
-	ClassDB::bind_method(D_METHOD("set_big_endian", "big_endian"), &File::set_big_endian);
-	ClassDB::bind_method(D_METHOD("get_error"), &File::get_error);
-	ClassDB::bind_method(D_METHOD("get_var", "allow_objects"), &File::get_var, DEFVAL(false));
-
-	ClassDB::bind_method(D_METHOD("store_8", "value"), &File::store_8);
-	ClassDB::bind_method(D_METHOD("store_16", "value"), &File::store_16);
-	ClassDB::bind_method(D_METHOD("store_32", "value"), &File::store_32);
-	ClassDB::bind_method(D_METHOD("store_64", "value"), &File::store_64);
-	ClassDB::bind_method(D_METHOD("store_float", "value"), &File::store_float);
-	ClassDB::bind_method(D_METHOD("store_double", "value"), &File::store_double);
-	ClassDB::bind_method(D_METHOD("store_real", "value"), &File::store_real);
-	ClassDB::bind_method(D_METHOD("store_buffer", "buffer"), &File::store_buffer);
-	ClassDB::bind_method(D_METHOD("store_line", "line"), &File::store_line);
-	ClassDB::bind_method(D_METHOD("store_csv_line", "values", "delim"), &File::store_csv_line, DEFVAL(","));
-	ClassDB::bind_method(D_METHOD("store_string", "string"), &File::store_string);
-	ClassDB::bind_method(D_METHOD("store_var", "value", "full_objects"), &File::store_var, DEFVAL(false));
-
-	ClassDB::bind_method(D_METHOD("store_pascal_string", "string"), &File::store_pascal_string);
-	ClassDB::bind_method(D_METHOD("get_pascal_string"), &File::get_pascal_string);
-
-	ClassDB::bind_static_method("File", D_METHOD("file_exists", "path"), &File::file_exists);
-	ClassDB::bind_method(D_METHOD("get_modified_time", "file"), &File::get_modified_time);
-
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "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);
-}
-
-////// Directory //////
-
-Error Directory::open(const String &p_path) {
-	Error err;
-	Ref<DirAccess> alt = DirAccess::open(p_path, &err);
-	if (alt.is_null()) {
-		return err;
-	}
-	d = alt;
-	dir_open = true;
-
-	return OK;
-}
-
-bool Directory::is_open() const {
-	return d.is_valid() && dir_open;
-}
-
-Error Directory::list_dir_begin() {
-	ERR_FAIL_COND_V_MSG(!is_open(), ERR_UNCONFIGURED, "Directory must be opened before use.");
-	return d->list_dir_begin();
-}
-
-String Directory::get_next() {
-	ERR_FAIL_COND_V_MSG(!is_open(), "", "Directory must be opened before use.");
-
-	String next = d->get_next();
-	while (!next.is_empty() && ((!include_navigational && (next == "." || next == "..")) || (!include_hidden && d->current_is_hidden()))) {
-		next = d->get_next();
-	}
-	return next;
-}
-
-bool Directory::current_is_dir() const {
-	ERR_FAIL_COND_V_MSG(!is_open(), false, "Directory must be opened before use.");
-	return d->current_is_dir();
-}
-
-void Directory::list_dir_end() {
-	ERR_FAIL_COND_MSG(!is_open(), "Directory must be opened before use.");
-	d->list_dir_end();
-}
-
-PackedStringArray Directory::get_files() {
-	return _get_contents(false);
-}
-
-PackedStringArray Directory::get_directories() {
-	return _get_contents(true);
-}
-
-PackedStringArray Directory::_get_contents(bool p_directories) {
-	PackedStringArray ret;
-	ERR_FAIL_COND_V_MSG(!is_open(), ret, "Directory must be opened before use.");
-
-	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;
-}
-
-void Directory::set_include_navigational(bool p_enable) {
-	include_navigational = p_enable;
-}
-
-bool Directory::get_include_navigational() const {
-	return include_navigational;
-}
-
-void Directory::set_include_hidden(bool p_enable) {
-	include_hidden = p_enable;
-}
-
-bool Directory::get_include_hidden() const {
-	return include_hidden;
-}
-
-int Directory::get_drive_count() {
-	ERR_FAIL_COND_V_MSG(!is_open(), 0, "Directory must be opened before use.");
-	return d->get_drive_count();
-}
-
-String Directory::get_drive(int p_drive) {
-	ERR_FAIL_COND_V_MSG(!is_open(), "", "Directory must be opened before use.");
-	return d->get_drive(p_drive);
-}
-
-int Directory::get_current_drive() {
-	ERR_FAIL_COND_V_MSG(!is_open(), 0, "Directory must be opened before use.");
-	return d->get_current_drive();
-}
-
-Error Directory::change_dir(String p_dir) {
-	ERR_FAIL_COND_V_MSG(d.is_null(), ERR_UNCONFIGURED, "Directory is not configured properly.");
-	Error err = d->change_dir(p_dir);
-
-	if (err != OK) {
-		return err;
-	}
-	dir_open = true;
-
-	return OK;
-}
-
-String Directory::get_current_dir() {
-	ERR_FAIL_COND_V_MSG(!is_open(), "", "Directory must be opened before use.");
-	return d->get_current_dir();
-}
-
-Error Directory::make_dir(String p_dir) {
-	ERR_FAIL_COND_V_MSG(d.is_null(), ERR_UNCONFIGURED, "Directory is not configured properly.");
-	if (!p_dir.is_relative_path()) {
-		Ref<DirAccess> da = DirAccess::create_for_path(p_dir);
-		return da->make_dir(p_dir);
-	}
-	return d->make_dir(p_dir);
-}
-
-Error Directory::make_dir_recursive(String p_dir) {
-	ERR_FAIL_COND_V_MSG(d.is_null(), ERR_UNCONFIGURED, "Directory is not configured properly.");
-	if (!p_dir.is_relative_path()) {
-		Ref<DirAccess> da = DirAccess::create_for_path(p_dir);
-		return da->make_dir_recursive(p_dir);
-	}
-	return d->make_dir_recursive(p_dir);
-}
-
-bool Directory::file_exists(String p_file) {
-	ERR_FAIL_COND_V_MSG(d.is_null(), false, "Directory is not configured properly.");
-	if (!p_file.is_relative_path()) {
-		return FileAccess::exists(p_file);
-	}
-	return d->file_exists(p_file);
-}
-
-bool Directory::dir_exists(String p_dir) {
-	ERR_FAIL_COND_V_MSG(d.is_null(), false, "Directory is not configured properly.");
-	if (!p_dir.is_relative_path()) {
-		return DirAccess::exists(p_dir);
-	}
-	return d->dir_exists(p_dir);
-}
-
-uint64_t Directory::get_space_left() {
-	ERR_FAIL_COND_V_MSG(d.is_null(), 0, "Directory must be opened before use.");
-	return d->get_space_left() / 1024 * 1024; // Truncate to closest MiB.
-}
-
-Error Directory::copy(String p_from, String p_to) {
-	ERR_FAIL_COND_V_MSG(!is_open(), ERR_UNCONFIGURED, "Directory must be opened before use.");
-	return d->copy(p_from, p_to);
-}
-
-Error Directory::rename(String p_from, String p_to) {
-	ERR_FAIL_COND_V_MSG(!is_open(), ERR_UNCONFIGURED, "Directory must be opened before use.");
-	ERR_FAIL_COND_V_MSG(p_from.is_empty() || p_from == "." || p_from == "..", ERR_INVALID_PARAMETER, "Invalid path to rename.");
-
-	if (!p_from.is_relative_path()) {
-		Ref<DirAccess> da = DirAccess::create_for_path(p_from);
-		ERR_FAIL_COND_V_MSG(!da->file_exists(p_from) && !da->dir_exists(p_from), ERR_DOES_NOT_EXIST, "File or directory does not exist.");
-		return da->rename(p_from, p_to);
-	}
-
-	ERR_FAIL_COND_V_MSG(!d->file_exists(p_from) && !d->dir_exists(p_from), ERR_DOES_NOT_EXIST, "File or directory does not exist.");
-	return d->rename(p_from, p_to);
-}
-
-Error Directory::remove(String p_name) {
-	ERR_FAIL_COND_V_MSG(!is_open(), ERR_UNCONFIGURED, "Directory must be opened before use.");
-	if (!p_name.is_relative_path()) {
-		Ref<DirAccess> da = DirAccess::create_for_path(p_name);
-		return da->remove(p_name);
-	}
-
-	return d->remove(p_name);
-}
-
-void Directory::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("open", "path"), &Directory::open);
-	ClassDB::bind_method(D_METHOD("list_dir_begin"), &Directory::list_dir_begin, DEFVAL(false), DEFVAL(false));
-	ClassDB::bind_method(D_METHOD("get_next"), &Directory::get_next);
-	ClassDB::bind_method(D_METHOD("current_is_dir"), &Directory::current_is_dir);
-	ClassDB::bind_method(D_METHOD("list_dir_end"), &Directory::list_dir_end);
-	ClassDB::bind_method(D_METHOD("get_files"), &Directory::get_files);
-	ClassDB::bind_method(D_METHOD("get_directories"), &Directory::get_directories);
-	ClassDB::bind_method(D_METHOD("get_drive_count"), &Directory::get_drive_count);
-	ClassDB::bind_method(D_METHOD("get_drive", "idx"), &Directory::get_drive);
-	ClassDB::bind_method(D_METHOD("get_current_drive"), &Directory::get_current_drive);
-	ClassDB::bind_method(D_METHOD("change_dir", "todir"), &Directory::change_dir);
-	ClassDB::bind_method(D_METHOD("get_current_dir"), &Directory::get_current_dir);
-	ClassDB::bind_method(D_METHOD("make_dir", "path"), &Directory::make_dir);
-	ClassDB::bind_method(D_METHOD("make_dir_recursive", "path"), &Directory::make_dir_recursive);
-	ClassDB::bind_method(D_METHOD("file_exists", "path"), &Directory::file_exists);
-	ClassDB::bind_method(D_METHOD("dir_exists", "path"), &Directory::dir_exists);
-	ClassDB::bind_method(D_METHOD("get_space_left"), &Directory::get_space_left);
-	ClassDB::bind_method(D_METHOD("copy", "from", "to"), &Directory::copy);
-	ClassDB::bind_method(D_METHOD("rename", "from", "to"), &Directory::rename);
-	ClassDB::bind_method(D_METHOD("remove", "path"), &Directory::remove);
-
-	ClassDB::bind_method(D_METHOD("set_include_navigational", "enable"), &Directory::set_include_navigational);
-	ClassDB::bind_method(D_METHOD("get_include_navigational"), &Directory::get_include_navigational);
-	ClassDB::bind_method(D_METHOD("set_include_hidden", "enable"), &Directory::set_include_hidden);
-	ClassDB::bind_method(D_METHOD("get_include_hidden"), &Directory::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");
-}
-
-Directory::Directory() {
-	d = DirAccess::create(DirAccess::ACCESS_RESOURCES);
-}
-
 ////// Marshalls //////
 
 Marshalls *Marshalls::singleton = nullptr;
diff --git a/core/core_bind.h b/core/core_bind.h
index 0f85e473a5..345c517b99 100644
--- a/core/core_bind.h
+++ b/core/core_bind.h
@@ -355,156 +355,6 @@ public:
 	Geometry3D() { singleton = this; }
 };
 
-class File : public RefCounted {
-	GDCLASS(File, RefCounted);
-
-	Ref<FileAccess> f;
-	bool big_endian = false;
-
-protected:
-	static void _bind_methods();
-
-public:
-	enum ModeFlags {
-		READ = 1,
-		WRITE = 2,
-		READ_WRITE = 3,
-		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
-	};
-
-	Error open_encrypted(const String &p_path, ModeFlags p_mode_flags, const Vector<uint8_t> &p_key);
-	Error open_encrypted_pass(const String &p_path, ModeFlags p_mode_flags, const String &p_pass);
-	Error open_compressed(const String &p_path, ModeFlags p_mode_flags, CompressionMode p_compress_mode = COMPRESSION_FASTLZ);
-
-	Error open(const String &p_path, ModeFlags p_mode_flags); // open a file.
-	void flush(); // Flush a file (write its buffer to disk).
-	void close(); // Close a file.
-	bool is_open() const; // True when file is open.
-
-	String get_path() const; // Returns the path for the current open file.
-	String get_path_absolute() const; // Returns the absolute path for the current open file.
-
-	void seek(int64_t p_position); // Seek to a given position.
-	void seek_end(int64_t p_position = 0); // Seek from the end of file.
-	uint64_t get_position() const; // Get position in the file.
-	uint64_t get_length() const; // Get size of the file.
-
-	bool eof_reached() const; // Reading passed EOF.
-
-	uint8_t get_8() const; // Get a byte.
-	uint16_t get_16() const; // Get 16 bits uint.
-	uint32_t get_32() const; // Get 32 bits uint.
-	uint64_t get_64() const; // Get 64 bits uint.
-
-	float get_float() const;
-	double get_double() const;
-	real_t get_real() const;
-
-	Variant get_var(bool p_allow_objects = false) const;
-
-	Vector<uint8_t> get_buffer(int64_t p_length) const; // Get an array of bytes.
-	String get_line() const;
-	Vector<String> get_csv_line(const String &p_delim = ",") const;
-	String get_as_text(bool p_skip_cr = false) const;
-	String get_md5(const String &p_path) const;
-	String get_sha256(const String &p_path) const;
-
-	/*
-	 * Use this for files WRITTEN in _big_ endian machines (ie, amiga/mac).
-	 * It's not about the current CPU type but file formats.
-	 * This flag gets reset to `false` (little endian) on each open.
-	 */
-	void set_big_endian(bool p_big_endian);
-	bool is_big_endian();
-
-	Error get_error() const; // Get last error.
-
-	void store_8(uint8_t p_dest); // Store a byte.
-	void store_16(uint16_t p_dest); // Store 16 bits uint.
-	void store_32(uint32_t p_dest); // Store 32 bits uint.
-	void store_64(uint64_t p_dest); // Store 64 bits uint.
-
-	void store_float(float p_dest);
-	void store_double(double p_dest);
-	void store_real(real_t p_real);
-
-	void store_string(const String &p_string);
-	void store_line(const String &p_string);
-	void store_csv_line(const Vector<String> &p_values, const String &p_delim = ",");
-
-	virtual void store_pascal_string(const String &p_string);
-	virtual String get_pascal_string();
-
-	void store_buffer(const Vector<uint8_t> &p_buffer); // Store an array of bytes.
-
-	void store_var(const Variant &p_var, bool p_full_objects = false);
-
-	static bool file_exists(const String &p_name); // Return true if a file exists.
-
-	uint64_t get_modified_time(const String &p_file) const;
-
-	File() {}
-};
-
-class Directory : public RefCounted {
-	GDCLASS(Directory, RefCounted);
-	Ref<DirAccess> d;
-
-	bool dir_open = false;
-	bool include_navigational = false;
-	bool include_hidden = false;
-
-protected:
-	static void _bind_methods();
-
-public:
-	Error open(const String &p_path);
-
-	bool is_open() const;
-
-	Error list_dir_begin();
-	String get_next();
-	bool current_is_dir() const;
-	void list_dir_end();
-
-	PackedStringArray get_files();
-	PackedStringArray get_directories();
-	PackedStringArray _get_contents(bool p_directories);
-
-	void set_include_navigational(bool p_enable);
-	bool get_include_navigational() const;
-	void set_include_hidden(bool p_enable);
-	bool get_include_hidden() const;
-
-	int get_drive_count();
-	String get_drive(int p_drive);
-	int get_current_drive();
-
-	Error change_dir(String p_dir); // Can be relative or absolute, return false on success.
-	String get_current_dir(); // Return current dir location.
-
-	Error make_dir(String p_dir);
-	Error make_dir_recursive(String p_dir);
-
-	bool file_exists(String p_file);
-	bool dir_exists(String p_dir);
-
-	uint64_t get_space_left();
-
-	Error copy(String p_from, String p_to);
-	Error rename(String p_from, String p_to);
-	Error remove(String p_name);
-
-	Directory();
-};
-
 class Marshalls : public Object {
 	GDCLASS(Marshalls, Object);
 
@@ -738,9 +588,6 @@ VARIANT_ENUM_CAST(core_bind::Geometry2D::PolyBooleanOperation);
 VARIANT_ENUM_CAST(core_bind::Geometry2D::PolyJoinType);
 VARIANT_ENUM_CAST(core_bind::Geometry2D::PolyEndType);
 
-VARIANT_ENUM_CAST(core_bind::File::ModeFlags);
-VARIANT_ENUM_CAST(core_bind::File::CompressionMode);
-
 VARIANT_ENUM_CAST(core_bind::Thread::Priority);
 
 #endif // CORE_BIND_H
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);
 	}
diff --git a/core/register_core_types.cpp b/core/register_core_types.cpp
index 6dfb0f82e0..0233afe199 100644
--- a/core/register_core_types.cpp
+++ b/core/register_core_types.cpp
@@ -228,8 +228,8 @@ void register_core_types() {
 	GDREGISTER_CLASS(ResourceFormatLoader);
 	GDREGISTER_CLASS(ResourceFormatSaver);
 
-	GDREGISTER_CLASS(core_bind::File);
-	GDREGISTER_CLASS(core_bind::Directory);
+	GDREGISTER_ABSTRACT_CLASS(FileAccess);
+	GDREGISTER_ABSTRACT_CLASS(DirAccess);
 	GDREGISTER_CLASS(core_bind::Thread);
 	GDREGISTER_CLASS(core_bind::Mutex);
 	GDREGISTER_CLASS(core_bind::Semaphore);