feat: godot-engine-source-4.3-stable

engine/drivers/windows/SCsub

@@ -0,0 +1,5 @@
+#!/usr/bin/env python
+
+Import("env")
+
+env.add_source_files(env.drivers_sources, "*.cpp")

engine/drivers/windows/dir_access_windows.cpp

@@ -0,0 +1,483 @@
+/**************************************************************************/
+/*  dir_access_windows.cpp                                                */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* 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.                 */
+/**************************************************************************/
+
+#if defined(WINDOWS_ENABLED)
+
+#include "dir_access_windows.h"
+#include "file_access_windows.h"
+
+#include "core/config/project_settings.h"
+#include "core/os/memory.h"
+#include "core/string/print_string.h"
+
+#include <stdio.h>
+#include <wchar.h>
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+typedef struct _NT_IO_STATUS_BLOCK {
+	union {
+		LONG Status;
+		PVOID Pointer;
+	} DUMMY;
+	ULONG_PTR Information;
+} NT_IO_STATUS_BLOCK;
+
+typedef struct _NT_FILE_CASE_SENSITIVE_INFO {
+	ULONG Flags;
+} NT_FILE_CASE_SENSITIVE_INFO;
+
+typedef enum _NT_FILE_INFORMATION_CLASS {
+	FileCaseSensitiveInformation = 71,
+} NT_FILE_INFORMATION_CLASS;
+
+#define NT_FILE_CS_FLAG_CASE_SENSITIVE_DIR 0x00000001
+
+extern "C" NTSYSAPI LONG NTAPI NtQueryInformationFile(HANDLE FileHandle, NT_IO_STATUS_BLOCK *IoStatusBlock, PVOID FileInformation, ULONG Length, NT_FILE_INFORMATION_CLASS FileInformationClass);
+
+struct DirAccessWindowsPrivate {
+	HANDLE h; // handle for FindFirstFile.
+	WIN32_FIND_DATA f;
+	WIN32_FIND_DATAW fu; // Unicode version.
+};
+
+String DirAccessWindows::fix_path(const String &p_path) const {
+	String r_path = DirAccess::fix_path(p_path);
+	if (r_path.is_absolute_path() && !r_path.is_network_share_path() && r_path.length() > MAX_PATH) {
+		r_path = "\\\\?\\" + r_path.replace("/", "\\");
+	}
+	return r_path;
+}
+
+// CreateFolderAsync
+
+Error DirAccessWindows::list_dir_begin() {
+	_cisdir = false;
+	_cishidden = false;
+
+	list_dir_end();
+	p->h = FindFirstFileExW((LPCWSTR)(String(current_dir + "\\*").utf16().get_data()), FindExInfoStandard, &p->fu, FindExSearchNameMatch, nullptr, 0);
+
+	if (p->h == INVALID_HANDLE_VALUE) {
+		return ERR_CANT_OPEN;
+	}
+
+	return OK;
+}
+
+String DirAccessWindows::get_next() {
+	if (p->h == INVALID_HANDLE_VALUE) {
+		return "";
+	}
+
+	_cisdir = (p->fu.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
+	_cishidden = (p->fu.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN);
+
+	String name = String::utf16((const char16_t *)(p->fu.cFileName));
+
+	if (FindNextFileW(p->h, &p->fu) == 0) {
+		FindClose(p->h);
+		p->h = INVALID_HANDLE_VALUE;
+	}
+
+	return name;
+}
+
+bool DirAccessWindows::current_is_dir() const {
+	return _cisdir;
+}
+
+bool DirAccessWindows::current_is_hidden() const {
+	return _cishidden;
+}
+
+void DirAccessWindows::list_dir_end() {
+	if (p->h != INVALID_HANDLE_VALUE) {
+		FindClose(p->h);
+		p->h = INVALID_HANDLE_VALUE;
+	}
+}
+
+int DirAccessWindows::get_drive_count() {
+	return drive_count;
+}
+
+String DirAccessWindows::get_drive(int p_drive) {
+	if (p_drive < 0 || p_drive >= drive_count) {
+		return "";
+	}
+
+	return String::chr(drives[p_drive]) + ":";
+}
+
+Error DirAccessWindows::change_dir(String p_dir) {
+	GLOBAL_LOCK_FUNCTION
+
+	p_dir = fix_path(p_dir);
+
+	WCHAR real_current_dir_name[2048];
+	GetCurrentDirectoryW(2048, real_current_dir_name);
+	String prev_dir = String::utf16((const char16_t *)real_current_dir_name);
+
+	SetCurrentDirectoryW((LPCWSTR)(current_dir.utf16().get_data()));
+	bool worked = (SetCurrentDirectoryW((LPCWSTR)(p_dir.utf16().get_data())) != 0);
+
+	String base = _get_root_path();
+	if (!base.is_empty()) {
+		GetCurrentDirectoryW(2048, real_current_dir_name);
+		String new_dir = String::utf16((const char16_t *)real_current_dir_name).replace("\\", "/");
+		if (!new_dir.begins_with(base)) {
+			worked = false;
+		}
+	}
+
+	if (worked) {
+		GetCurrentDirectoryW(2048, real_current_dir_name);
+		current_dir = String::utf16((const char16_t *)real_current_dir_name);
+		current_dir = current_dir.replace("\\", "/");
+	}
+
+	SetCurrentDirectoryW((LPCWSTR)(prev_dir.utf16().get_data()));
+
+	return worked ? OK : ERR_INVALID_PARAMETER;
+}
+
+Error DirAccessWindows::make_dir(String p_dir) {
+	GLOBAL_LOCK_FUNCTION
+
+	p_dir = fix_path(p_dir);
+	if (p_dir.is_relative_path()) {
+		p_dir = current_dir.path_join(p_dir);
+		p_dir = fix_path(p_dir);
+	}
+
+	if (FileAccessWindows::is_path_invalid(p_dir)) {
+#ifdef DEBUG_ENABLED
+		WARN_PRINT("The path :" + p_dir + " is a reserved Windows system pipe, so it can't be used for creating directories.");
+#endif
+		return ERR_INVALID_PARAMETER;
+	}
+
+	p_dir = p_dir.simplify_path().replace("/", "\\");
+
+	bool success;
+	int err;
+
+	success = CreateDirectoryW((LPCWSTR)(p_dir.utf16().get_data()), nullptr);
+	err = GetLastError();
+
+	if (success) {
+		return OK;
+	}
+
+	if (err == ERROR_ALREADY_EXISTS || err == ERROR_ACCESS_DENIED) {
+		return ERR_ALREADY_EXISTS;
+	}
+
+	return ERR_CANT_CREATE;
+}
+
+String DirAccessWindows::get_current_dir(bool p_include_drive) const {
+	String base = _get_root_path();
+	if (!base.is_empty()) {
+		String bd = current_dir.replace("\\", "/").replace_first(base, "");
+		if (bd.begins_with("/")) {
+			return _get_root_string() + bd.substr(1, bd.length());
+		} else {
+			return _get_root_string() + bd;
+		}
+	}
+
+	if (p_include_drive) {
+		return current_dir;
+	} else {
+		if (_get_root_string().is_empty()) {
+			int pos = current_dir.find(":");
+			if (pos != -1) {
+				return current_dir.substr(pos + 1);
+			}
+		}
+		return current_dir;
+	}
+}
+
+bool DirAccessWindows::file_exists(String p_file) {
+	GLOBAL_LOCK_FUNCTION
+
+	if (!p_file.is_absolute_path()) {
+		p_file = get_current_dir().path_join(p_file);
+	}
+
+	p_file = fix_path(p_file);
+
+	DWORD fileAttr;
+
+	fileAttr = GetFileAttributesW((LPCWSTR)(p_file.utf16().get_data()));
+	if (INVALID_FILE_ATTRIBUTES == fileAttr) {
+		return false;
+	}
+
+	return !(fileAttr & FILE_ATTRIBUTE_DIRECTORY);
+}
+
+bool DirAccessWindows::dir_exists(String p_dir) {
+	GLOBAL_LOCK_FUNCTION
+
+	if (p_dir.is_relative_path()) {
+		p_dir = get_current_dir().path_join(p_dir);
+	}
+
+	p_dir = fix_path(p_dir);
+
+	DWORD fileAttr;
+	fileAttr = GetFileAttributesW((LPCWSTR)(p_dir.utf16().get_data()));
+	if (INVALID_FILE_ATTRIBUTES == fileAttr) {
+		return false;
+	}
+	return (fileAttr & FILE_ATTRIBUTE_DIRECTORY);
+}
+
+Error DirAccessWindows::rename(String p_path, String p_new_path) {
+	if (p_path.is_relative_path()) {
+		p_path = get_current_dir().path_join(p_path);
+	}
+
+	p_path = fix_path(p_path);
+
+	if (p_new_path.is_relative_path()) {
+		p_new_path = get_current_dir().path_join(p_new_path);
+	}
+
+	p_new_path = fix_path(p_new_path);
+
+	// If we're only changing file name case we need to do a little juggling
+	if (p_path.to_lower() == p_new_path.to_lower()) {
+		if (dir_exists(p_path)) {
+			// The path is a dir; just rename
+			return ::_wrename((LPCWSTR)(p_path.utf16().get_data()), (LPCWSTR)(p_new_path.utf16().get_data())) == 0 ? OK : FAILED;
+		}
+		// The path is a file; juggle
+		WCHAR tmpfile[MAX_PATH];
+
+		if (!GetTempFileNameW((LPCWSTR)(fix_path(get_current_dir()).utf16().get_data()), nullptr, 0, tmpfile)) {
+			return FAILED;
+		}
+
+		if (!::ReplaceFileW(tmpfile, (LPCWSTR)(p_path.utf16().get_data()), nullptr, 0, nullptr, nullptr)) {
+			DeleteFileW(tmpfile);
+			return FAILED;
+		}
+
+		return ::_wrename(tmpfile, (LPCWSTR)(p_new_path.utf16().get_data())) == 0 ? OK : FAILED;
+
+	} else {
+		if (file_exists(p_new_path)) {
+			if (remove(p_new_path) != OK) {
+				return FAILED;
+			}
+		}
+
+		return ::_wrename((LPCWSTR)(p_path.utf16().get_data()), (LPCWSTR)(p_new_path.utf16().get_data())) == 0 ? OK : FAILED;
+	}
+}
+
+Error DirAccessWindows::remove(String p_path) {
+	if (p_path.is_relative_path()) {
+		p_path = get_current_dir().path_join(p_path);
+	}
+
+	p_path = fix_path(p_path);
+
+	DWORD fileAttr;
+
+	fileAttr = GetFileAttributesW((LPCWSTR)(p_path.utf16().get_data()));
+	if (INVALID_FILE_ATTRIBUTES == fileAttr) {
+		return FAILED;
+	}
+	if ((fileAttr & FILE_ATTRIBUTE_DIRECTORY)) {
+		return ::_wrmdir((LPCWSTR)(p_path.utf16().get_data())) == 0 ? OK : FAILED;
+	} else {
+		return ::_wunlink((LPCWSTR)(p_path.utf16().get_data())) == 0 ? OK : FAILED;
+	}
+}
+
+uint64_t DirAccessWindows::get_space_left() {
+	uint64_t bytes = 0;
+	if (!GetDiskFreeSpaceEx(nullptr, (PULARGE_INTEGER)&bytes, nullptr, nullptr)) {
+		return 0;
+	}
+
+	// This is either 0 or a value in bytes.
+	return bytes;
+}
+
+String DirAccessWindows::get_filesystem_type() const {
+	String path = fix_path(const_cast<DirAccessWindows *>(this)->get_current_dir());
+
+	int unit_end = path.find(":");
+	ERR_FAIL_COND_V(unit_end == -1, String());
+	String unit = path.substr(0, unit_end + 1) + "\\";
+
+	if (path.is_network_share_path()) {
+		return "Network Share";
+	}
+
+	WCHAR szVolumeName[100];
+	WCHAR szFileSystemName[10];
+	DWORD dwSerialNumber = 0;
+	DWORD dwMaxFileNameLength = 0;
+	DWORD dwFileSystemFlags = 0;
+
+	if (::GetVolumeInformationW((LPCWSTR)(unit.utf16().get_data()),
+				szVolumeName,
+				sizeof(szVolumeName),
+				&dwSerialNumber,
+				&dwMaxFileNameLength,
+				&dwFileSystemFlags,
+				szFileSystemName,
+				sizeof(szFileSystemName)) == TRUE) {
+		return String::utf16((const char16_t *)szFileSystemName);
+	}
+
+	ERR_FAIL_V("");
+}
+
+bool DirAccessWindows::is_case_sensitive(const String &p_path) const {
+	String f = p_path;
+	if (!f.is_absolute_path()) {
+		f = get_current_dir().path_join(f);
+	}
+	f = fix_path(f);
+
+	HANDLE h_file = ::CreateFileW((LPCWSTR)(f.utf16().get_data()), 0,
+			FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+			nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr);
+
+	if (h_file == INVALID_HANDLE_VALUE) {
+		return false;
+	}
+
+	NT_IO_STATUS_BLOCK io_status_block;
+	NT_FILE_CASE_SENSITIVE_INFO file_info;
+	LONG out = NtQueryInformationFile(h_file, &io_status_block, &file_info, sizeof(NT_FILE_CASE_SENSITIVE_INFO), FileCaseSensitiveInformation);
+	::CloseHandle(h_file);
+
+	if (out >= 0) {
+		return file_info.Flags & NT_FILE_CS_FLAG_CASE_SENSITIVE_DIR;
+	} else {
+		return false;
+	}
+}
+
+bool DirAccessWindows::is_link(String p_file) {
+	String f = p_file;
+
+	if (!f.is_absolute_path()) {
+		f = get_current_dir().path_join(f);
+	}
+	f = fix_path(f);
+
+	DWORD attr = GetFileAttributesW((LPCWSTR)(f.utf16().get_data()));
+	if (attr == INVALID_FILE_ATTRIBUTES) {
+		return false;
+	}
+
+	return (attr & FILE_ATTRIBUTE_REPARSE_POINT);
+}
+
+String DirAccessWindows::read_link(String p_file) {
+	String f = p_file;
+
+	if (!f.is_absolute_path()) {
+		f = get_current_dir().path_join(f);
+	}
+	f = fix_path(f);
+
+	HANDLE hfile = CreateFileW((LPCWSTR)(f.utf16().get_data()), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr);
+	if (hfile == INVALID_HANDLE_VALUE) {
+		return f;
+	}
+
+	DWORD ret = GetFinalPathNameByHandleW(hfile, nullptr, 0, VOLUME_NAME_DOS | FILE_NAME_NORMALIZED);
+	if (ret == 0) {
+		return f;
+	}
+	Char16String cs;
+	cs.resize(ret + 1);
+	GetFinalPathNameByHandleW(hfile, (LPWSTR)cs.ptrw(), ret, VOLUME_NAME_DOS | FILE_NAME_NORMALIZED);
+	CloseHandle(hfile);
+
+	return String::utf16((const char16_t *)cs.ptr(), ret).trim_prefix(R"(\\?\)");
+}
+
+Error DirAccessWindows::create_link(String p_source, String p_target) {
+	if (p_target.is_relative_path()) {
+		p_target = get_current_dir().path_join(p_target);
+	}
+
+	p_source = fix_path(p_source);
+	p_target = fix_path(p_target);
+
+	DWORD file_attr = GetFileAttributesW((LPCWSTR)(p_source.utf16().get_data()));
+	bool is_dir = (file_attr & FILE_ATTRIBUTE_DIRECTORY);
+
+	DWORD flags = ((is_dir) ? SYMBOLIC_LINK_FLAG_DIRECTORY : 0) | SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE;
+	if (CreateSymbolicLinkW((LPCWSTR)p_target.utf16().get_data(), (LPCWSTR)p_source.utf16().get_data(), flags) != 0) {
+		return OK;
+	} else {
+		return FAILED;
+	}
+}
+
+DirAccessWindows::DirAccessWindows() {
+	p = memnew(DirAccessWindowsPrivate);
+	p->h = INVALID_HANDLE_VALUE;
+	current_dir = ".";
+
+	DWORD mask = GetLogicalDrives();
+
+	for (int i = 0; i < MAX_DRIVES; i++) {
+		if (mask & (1 << i)) { //DRIVE EXISTS
+
+			drives[drive_count] = 'A' + i;
+			drive_count++;
+		}
+	}
+
+	change_dir(".");
+}
+
+DirAccessWindows::~DirAccessWindows() {
+	list_dir_end();
+
+	memdelete(p);
+}
+
+#endif // WINDOWS_ENABLED

engine/drivers/windows/dir_access_windows.h

@@ -0,0 +1,95 @@
+/**************************************************************************/
+/*  dir_access_windows.h                                                  */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* 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.                 */
+/**************************************************************************/
+
+#ifndef DIR_ACCESS_WINDOWS_H
+#define DIR_ACCESS_WINDOWS_H
+
+#ifdef WINDOWS_ENABLED
+
+#include "core/io/dir_access.h"
+
+struct DirAccessWindowsPrivate;
+
+class DirAccessWindows : public DirAccess {
+	enum {
+		MAX_DRIVES = 26
+	};
+
+	DirAccessWindowsPrivate *p = nullptr;
+	/* Windows stuff */
+
+	char drives[MAX_DRIVES] = { 0 }; // a-z:
+	int drive_count = 0;
+
+	String current_dir;
+
+	bool _cisdir = false;
+	bool _cishidden = false;
+
+protected:
+	virtual String fix_path(const String &p_path) const override;
+
+public:
+	virtual Error list_dir_begin() override; ///< This starts dir listing
+	virtual String get_next() override;
+	virtual bool current_is_dir() const override;
+	virtual bool current_is_hidden() const override;
+	virtual void list_dir_end() override; ///<
+
+	virtual int get_drive_count() override;
+	virtual String get_drive(int p_drive) override;
+
+	virtual Error change_dir(String p_dir) override; ///< can be relative or absolute, return false on success
+	virtual String get_current_dir(bool p_include_drive = true) const override; ///< return current dir location
+
+	virtual bool file_exists(String p_file) override;
+	virtual bool dir_exists(String p_dir) override;
+
+	virtual Error make_dir(String p_dir) override;
+
+	virtual Error rename(String p_path, String p_new_path) override;
+	virtual Error remove(String p_path) override;
+
+	virtual bool is_link(String p_file) override;
+	virtual String read_link(String p_file) override;
+	virtual Error create_link(String p_source, String p_target) override;
+
+	uint64_t get_space_left() override;
+
+	virtual String get_filesystem_type() const override;
+	virtual bool is_case_sensitive(const String &p_path) const override;
+
+	DirAccessWindows();
+	~DirAccessWindows();
+};
+
+#endif // WINDOWS_ENABLED
+
+#endif // DIR_ACCESS_WINDOWS_H

engine/drivers/windows/file_access_windows.cpp

@@ -0,0 +1,648 @@
+/**************************************************************************/
+/*  file_access_windows.cpp                                               */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* 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.                 */
+/**************************************************************************/
+
+#ifdef WINDOWS_ENABLED
+
+#include "file_access_windows.h"
+
+#include "core/config/project_settings.h"
+#include "core/os/os.h"
+#include "core/string/print_string.h"
+
+#include <share.h> // _SH_DENYNO
+#include <shlwapi.h>
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+#include <errno.h>
+#include <io.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <tchar.h>
+#include <wchar.h>
+
+#ifdef _MSC_VER
+#define S_ISREG(m) ((m) & _S_IFREG)
+#endif
+
+void FileAccessWindows::check_errors() const {
+	ERR_FAIL_NULL(f);
+
+	if (feof(f)) {
+		last_error = ERR_FILE_EOF;
+	}
+}
+
+bool FileAccessWindows::is_path_invalid(const String &p_path) {
+	// Check for invalid operating system file.
+	String fname = p_path.get_file().to_lower();
+
+	int dot = fname.find(".");
+	if (dot != -1) {
+		fname = fname.substr(0, dot);
+	}
+	return invalid_files.has(fname);
+}
+
+String FileAccessWindows::fix_path(const String &p_path) const {
+	String r_path = FileAccess::fix_path(p_path);
+	if (r_path.is_absolute_path() && !r_path.is_network_share_path() && r_path.length() > MAX_PATH) {
+		r_path = "\\\\?\\" + r_path.replace("/", "\\");
+	}
+	return r_path;
+}
+
+Error FileAccessWindows::open_internal(const String &p_path, int p_mode_flags) {
+	if (is_path_invalid(p_path)) {
+#ifdef DEBUG_ENABLED
+		if (p_mode_flags != READ) {
+			WARN_PRINT("The path :" + p_path + " is a reserved Windows system pipe, so it can't be used for creating files.");
+		}
+#endif
+		return ERR_INVALID_PARAMETER;
+	}
+
+	_close();
+
+	path_src = p_path;
+	path = fix_path(p_path);
+
+	const WCHAR *mode_string;
+
+	if (p_mode_flags == READ) {
+		mode_string = L"rb";
+	} else if (p_mode_flags == WRITE) {
+		mode_string = L"wb";
+	} else if (p_mode_flags == READ_WRITE) {
+		mode_string = L"rb+";
+	} else if (p_mode_flags == WRITE_READ) {
+		mode_string = L"wb+";
+	} else {
+		return ERR_INVALID_PARAMETER;
+	}
+
+	/* Pretty much every implementation that uses fopen as primary
+	   backend supports utf8 encoding. */
+
+	struct _stat st;
+	if (_wstat((LPCWSTR)(path.utf16().get_data()), &st) == 0) {
+		if (!S_ISREG(st.st_mode)) {
+			return ERR_FILE_CANT_OPEN;
+		}
+	}
+
+#ifdef TOOLS_ENABLED
+	// Windows is case insensitive, but all other platforms are sensitive to it
+	// To ease cross-platform development, we issue a warning if users try to access
+	// a file using the wrong case (which *works* on Windows, but won't on other
+	// platforms), we only check for relative paths, or paths in res:// or user://,
+	// other paths aren't likely to be portable anyway.
+	if (p_mode_flags == READ && (p_path.is_relative_path() || get_access_type() != ACCESS_FILESYSTEM)) {
+		String base_path = path;
+		String working_path;
+		String proper_path;
+
+		if (get_access_type() == ACCESS_RESOURCES) {
+			if (ProjectSettings::get_singleton()) {
+				working_path = ProjectSettings::get_singleton()->get_resource_path();
+				if (!working_path.is_empty()) {
+					base_path = working_path.path_to_file(base_path);
+				}
+			}
+			proper_path = "res://";
+		} else if (get_access_type() == ACCESS_USERDATA) {
+			working_path = OS::get_singleton()->get_user_data_dir();
+			if (!working_path.is_empty()) {
+				base_path = working_path.path_to_file(base_path);
+			}
+			proper_path = "user://";
+		}
+
+		WIN32_FIND_DATAW d;
+		Vector<String> parts = base_path.split("/");
+
+		bool mismatch = false;
+
+		for (const String &part : parts) {
+			working_path = working_path.path_join(part);
+
+			// Skip if relative.
+			if (part == "." || part == "..") {
+				proper_path = proper_path.path_join(part);
+				continue;
+			}
+
+			HANDLE fnd = FindFirstFileW((LPCWSTR)(working_path.utf16().get_data()), &d);
+
+			if (fnd == INVALID_HANDLE_VALUE) {
+				mismatch = false;
+				break;
+			}
+
+			const String fname = String::utf16((const char16_t *)(d.cFileName));
+
+			FindClose(fnd);
+
+			if (!mismatch) {
+				mismatch = (part != fname && part.findn(fname) == 0);
+			}
+
+			proper_path = proper_path.path_join(fname);
+		}
+
+		if (mismatch) {
+			WARN_PRINT("Case mismatch opening requested file '" + p_path + "', stored as '" + proper_path + "' in the filesystem. This file will not open when exported to other case-sensitive platforms.");
+		}
+	}
+#endif
+
+	if (is_backup_save_enabled() && p_mode_flags == WRITE) {
+		save_path = path;
+		// Create a temporary file in the same directory as the target file.
+		WCHAR tmpFileName[MAX_PATH];
+		if (GetTempFileNameW((LPCWSTR)(path.get_base_dir().utf16().get_data()), (LPCWSTR)(path.get_file().utf16().get_data()), 0, tmpFileName) == 0) {
+			last_error = ERR_FILE_CANT_OPEN;
+			return last_error;
+		}
+		path = tmpFileName;
+	}
+
+	f = _wfsopen((LPCWSTR)(path.utf16().get_data()), mode_string, is_backup_save_enabled() ? _SH_SECURE : _SH_DENYNO);
+
+	if (f == nullptr) {
+		switch (errno) {
+			case ENOENT: {
+				last_error = ERR_FILE_NOT_FOUND;
+			} break;
+			default: {
+				last_error = ERR_FILE_CANT_OPEN;
+			} break;
+		}
+		return last_error;
+	} else {
+		last_error = OK;
+		flags = p_mode_flags;
+		return OK;
+	}
+}
+
+void FileAccessWindows::_close() {
+	if (!f) {
+		return;
+	}
+
+	fclose(f);
+	f = nullptr;
+
+	if (!save_path.is_empty()) {
+		// This workaround of trying multiple times is added to deal with paranoid Windows
+		// antiviruses that love reading just written files even if they are not executable, thus
+		// locking the file and preventing renaming from happening.
+
+		bool rename_error = true;
+		const Char16String &path_utf16 = path.utf16();
+		const Char16String &save_path_utf16 = save_path.utf16();
+		for (int i = 0; i < 1000; i++) {
+			if (ReplaceFileW((LPCWSTR)(save_path_utf16.get_data()), (LPCWSTR)(path_utf16.get_data()), nullptr, REPLACEFILE_IGNORE_MERGE_ERRORS | REPLACEFILE_IGNORE_ACL_ERRORS, nullptr, nullptr)) {
+				rename_error = false;
+			} else {
+				// Either the target exists and is locked (temporarily, hopefully)
+				// or it doesn't exist; let's assume the latter before re-trying.
+				rename_error = _wrename((LPCWSTR)(path_utf16.get_data()), (LPCWSTR)(save_path_utf16.get_data())) != 0;
+			}
+
+			if (!rename_error) {
+				break;
+			}
+
+			OS::get_singleton()->delay_usec(1000);
+		}
+
+		if (rename_error) {
+			if (close_fail_notify) {
+				close_fail_notify(save_path);
+			}
+		}
+
+		save_path = "";
+
+		ERR_FAIL_COND_MSG(rename_error, "Safe save failed. This may be a permissions problem, but also may happen because you are running a paranoid antivirus. If this is the case, please switch to Windows Defender or disable the 'safe save' option in editor settings. This makes it work, but increases the risk of file corruption in a crash.");
+	}
+}
+
+String FileAccessWindows::get_path() const {
+	return path_src;
+}
+
+String FileAccessWindows::get_path_absolute() const {
+	return path;
+}
+
+bool FileAccessWindows::is_open() const {
+	return (f != nullptr);
+}
+
+void FileAccessWindows::seek(uint64_t p_position) {
+	ERR_FAIL_NULL(f);
+
+	last_error = OK;
+	if (_fseeki64(f, p_position, SEEK_SET)) {
+		check_errors();
+	}
+	prev_op = 0;
+}
+
+void FileAccessWindows::seek_end(int64_t p_position) {
+	ERR_FAIL_NULL(f);
+
+	if (_fseeki64(f, p_position, SEEK_END)) {
+		check_errors();
+	}
+	prev_op = 0;
+}
+
+uint64_t FileAccessWindows::get_position() const {
+	int64_t aux_position = _ftelli64(f);
+	if (aux_position < 0) {
+		check_errors();
+	}
+	return aux_position;
+}
+
+uint64_t FileAccessWindows::get_length() const {
+	ERR_FAIL_NULL_V(f, 0);
+
+	uint64_t pos = get_position();
+	_fseeki64(f, 0, SEEK_END);
+	uint64_t size = get_position();
+	_fseeki64(f, pos, SEEK_SET);
+
+	return size;
+}
+
+bool FileAccessWindows::eof_reached() const {
+	check_errors();
+	return last_error == ERR_FILE_EOF;
+}
+
+uint8_t FileAccessWindows::get_8() const {
+	ERR_FAIL_NULL_V(f, 0);
+
+	if (flags == READ_WRITE || flags == WRITE_READ) {
+		if (prev_op == WRITE) {
+			fflush(f);
+		}
+		prev_op = READ;
+	}
+	uint8_t b;
+	if (fread(&b, 1, 1, f) == 0) {
+		check_errors();
+		b = '\0';
+	}
+
+	return b;
+}
+
+uint16_t FileAccessWindows::get_16() const {
+	ERR_FAIL_NULL_V(f, 0);
+
+	if (flags == READ_WRITE || flags == WRITE_READ) {
+		if (prev_op == WRITE) {
+			fflush(f);
+		}
+		prev_op = READ;
+	}
+
+	uint16_t b = 0;
+	if (fread(&b, 1, 2, f) != 2) {
+		check_errors();
+	}
+
+	if (big_endian) {
+		b = BSWAP16(b);
+	}
+
+	return b;
+}
+
+uint32_t FileAccessWindows::get_32() const {
+	ERR_FAIL_NULL_V(f, 0);
+
+	if (flags == READ_WRITE || flags == WRITE_READ) {
+		if (prev_op == WRITE) {
+			fflush(f);
+		}
+		prev_op = READ;
+	}
+
+	uint32_t b = 0;
+	if (fread(&b, 1, 4, f) != 4) {
+		check_errors();
+	}
+
+	if (big_endian) {
+		b = BSWAP32(b);
+	}
+
+	return b;
+}
+
+uint64_t FileAccessWindows::get_64() const {
+	ERR_FAIL_NULL_V(f, 0);
+
+	if (flags == READ_WRITE || flags == WRITE_READ) {
+		if (prev_op == WRITE) {
+			fflush(f);
+		}
+		prev_op = READ;
+	}
+
+	uint64_t b = 0;
+	if (fread(&b, 1, 8, f) != 8) {
+		check_errors();
+	}
+
+	if (big_endian) {
+		b = BSWAP64(b);
+	}
+
+	return b;
+}
+
+uint64_t FileAccessWindows::get_buffer(uint8_t *p_dst, uint64_t p_length) const {
+	ERR_FAIL_COND_V(!p_dst && p_length > 0, -1);
+	ERR_FAIL_NULL_V(f, -1);
+
+	if (flags == READ_WRITE || flags == WRITE_READ) {
+		if (prev_op == WRITE) {
+			fflush(f);
+		}
+		prev_op = READ;
+	}
+	uint64_t read = fread(p_dst, 1, p_length, f);
+	check_errors();
+	return read;
+}
+
+Error FileAccessWindows::get_error() const {
+	return last_error;
+}
+
+Error FileAccessWindows::resize(int64_t p_length) {
+	ERR_FAIL_NULL_V_MSG(f, FAILED, "File must be opened before use.");
+	errno_t res = _chsize_s(_fileno(f), p_length);
+	switch (res) {
+		case 0:
+			return OK;
+		case EACCES:
+		case EBADF:
+			return ERR_FILE_CANT_OPEN;
+		case ENOSPC:
+			return ERR_OUT_OF_MEMORY;
+		case EINVAL:
+			return ERR_INVALID_PARAMETER;
+		default:
+			return FAILED;
+	}
+}
+
+void FileAccessWindows::flush() {
+	ERR_FAIL_NULL(f);
+
+	fflush(f);
+	if (prev_op == WRITE) {
+		prev_op = 0;
+	}
+}
+
+void FileAccessWindows::store_8(uint8_t p_dest) {
+	ERR_FAIL_NULL(f);
+
+	if (flags == READ_WRITE || flags == WRITE_READ) {
+		if (prev_op == READ) {
+			if (last_error != ERR_FILE_EOF) {
+				fseek(f, 0, SEEK_CUR);
+			}
+		}
+		prev_op = WRITE;
+	}
+	fwrite(&p_dest, 1, 1, f);
+}
+
+void FileAccessWindows::store_16(uint16_t p_dest) {
+	ERR_FAIL_NULL(f);
+
+	if (flags == READ_WRITE || flags == WRITE_READ) {
+		if (prev_op == READ) {
+			if (last_error != ERR_FILE_EOF) {
+				fseek(f, 0, SEEK_CUR);
+			}
+		}
+		prev_op = WRITE;
+	}
+
+	if (big_endian) {
+		p_dest = BSWAP16(p_dest);
+	}
+
+	fwrite(&p_dest, 1, 2, f);
+}
+
+void FileAccessWindows::store_32(uint32_t p_dest) {
+	ERR_FAIL_NULL(f);
+
+	if (flags == READ_WRITE || flags == WRITE_READ) {
+		if (prev_op == READ) {
+			if (last_error != ERR_FILE_EOF) {
+				fseek(f, 0, SEEK_CUR);
+			}
+		}
+		prev_op = WRITE;
+	}
+
+	if (big_endian) {
+		p_dest = BSWAP32(p_dest);
+	}
+
+	fwrite(&p_dest, 1, 4, f);
+}
+
+void FileAccessWindows::store_64(uint64_t p_dest) {
+	ERR_FAIL_NULL(f);
+
+	if (flags == READ_WRITE || flags == WRITE_READ) {
+		if (prev_op == READ) {
+			if (last_error != ERR_FILE_EOF) {
+				fseek(f, 0, SEEK_CUR);
+			}
+		}
+		prev_op = WRITE;
+	}
+
+	if (big_endian) {
+		p_dest = BSWAP64(p_dest);
+	}
+
+	fwrite(&p_dest, 1, 8, f);
+}
+
+void FileAccessWindows::store_buffer(const uint8_t *p_src, uint64_t p_length) {
+	ERR_FAIL_NULL(f);
+	ERR_FAIL_COND(!p_src && p_length > 0);
+
+	if (flags == READ_WRITE || flags == WRITE_READ) {
+		if (prev_op == READ) {
+			if (last_error != ERR_FILE_EOF) {
+				fseek(f, 0, SEEK_CUR);
+			}
+		}
+		prev_op = WRITE;
+	}
+	ERR_FAIL_COND(fwrite(p_src, 1, p_length, f) != (size_t)p_length);
+}
+
+bool FileAccessWindows::file_exists(const String &p_name) {
+	if (is_path_invalid(p_name)) {
+		return false;
+	}
+
+	String filename = fix_path(p_name);
+	FILE *g = _wfsopen((LPCWSTR)(filename.utf16().get_data()), L"rb", _SH_DENYNO);
+	if (g == nullptr) {
+		return false;
+	} else {
+		fclose(g);
+		return true;
+	}
+}
+
+uint64_t FileAccessWindows::_get_modified_time(const String &p_file) {
+	if (is_path_invalid(p_file)) {
+		return 0;
+	}
+
+	String file = fix_path(p_file);
+	if (file.ends_with("/") && file != "/") {
+		file = file.substr(0, file.length() - 1);
+	}
+
+	struct _stat st;
+	int rv = _wstat((LPCWSTR)(file.utf16().get_data()), &st);
+
+	if (rv == 0) {
+		return st.st_mtime;
+	} else {
+		print_verbose("Failed to get modified time for: " + p_file + "");
+		return 0;
+	}
+}
+
+BitField<FileAccess::UnixPermissionFlags> FileAccessWindows::_get_unix_permissions(const String &p_file) {
+	return 0;
+}
+
+Error FileAccessWindows::_set_unix_permissions(const String &p_file, BitField<FileAccess::UnixPermissionFlags> p_permissions) {
+	return ERR_UNAVAILABLE;
+}
+
+bool FileAccessWindows::_get_hidden_attribute(const String &p_file) {
+	String file = fix_path(p_file);
+
+	DWORD attrib = GetFileAttributesW((LPCWSTR)file.utf16().get_data());
+	ERR_FAIL_COND_V_MSG(attrib == INVALID_FILE_ATTRIBUTES, false, "Failed to get attributes for: " + p_file);
+	return (attrib & FILE_ATTRIBUTE_HIDDEN);
+}
+
+Error FileAccessWindows::_set_hidden_attribute(const String &p_file, bool p_hidden) {
+	String file = fix_path(p_file);
+
+	DWORD attrib = GetFileAttributesW((LPCWSTR)file.utf16().get_data());
+	ERR_FAIL_COND_V_MSG(attrib == INVALID_FILE_ATTRIBUTES, FAILED, "Failed to get attributes for: " + p_file);
+	BOOL ok;
+	if (p_hidden) {
+		ok = SetFileAttributesW((LPCWSTR)file.utf16().get_data(), attrib | FILE_ATTRIBUTE_HIDDEN);
+	} else {
+		ok = SetFileAttributesW((LPCWSTR)file.utf16().get_data(), attrib & ~FILE_ATTRIBUTE_HIDDEN);
+	}
+	ERR_FAIL_COND_V_MSG(!ok, FAILED, "Failed to set attributes for: " + p_file);
+
+	return OK;
+}
+
+bool FileAccessWindows::_get_read_only_attribute(const String &p_file) {
+	String file = fix_path(p_file);
+
+	DWORD attrib = GetFileAttributesW((LPCWSTR)file.utf16().get_data());
+	ERR_FAIL_COND_V_MSG(attrib == INVALID_FILE_ATTRIBUTES, false, "Failed to get attributes for: " + p_file);
+	return (attrib & FILE_ATTRIBUTE_READONLY);
+}
+
+Error FileAccessWindows::_set_read_only_attribute(const String &p_file, bool p_ro) {
+	String file = fix_path(p_file);
+
+	DWORD attrib = GetFileAttributesW((LPCWSTR)file.utf16().get_data());
+	ERR_FAIL_COND_V_MSG(attrib == INVALID_FILE_ATTRIBUTES, FAILED, "Failed to get attributes for: " + p_file);
+	BOOL ok;
+	if (p_ro) {
+		ok = SetFileAttributesW((LPCWSTR)file.utf16().get_data(), attrib | FILE_ATTRIBUTE_READONLY);
+	} else {
+		ok = SetFileAttributesW((LPCWSTR)file.utf16().get_data(), attrib & ~FILE_ATTRIBUTE_READONLY);
+	}
+	ERR_FAIL_COND_V_MSG(!ok, FAILED, "Failed to set attributes for: " + p_file);
+
+	return OK;
+}
+
+void FileAccessWindows::close() {
+	_close();
+}
+
+FileAccessWindows::~FileAccessWindows() {
+	_close();
+}
+
+HashSet<String> FileAccessWindows::invalid_files;
+
+void FileAccessWindows::initialize() {
+	static const char *reserved_files[]{
+		"con", "prn", "aux", "nul", "com0", "com1", "com2", "com3", "com4", "com5", "com6", "com7", "com8", "com9", "lpt0", "lpt1", "lpt2", "lpt3", "lpt4", "lpt5", "lpt6", "lpt7", "lpt8", "lpt9", nullptr
+	};
+	int reserved_file_index = 0;
+	while (reserved_files[reserved_file_index] != nullptr) {
+		invalid_files.insert(reserved_files[reserved_file_index]);
+		reserved_file_index++;
+	}
+}
+
+void FileAccessWindows::finalize() {
+	invalid_files.clear();
+}
+
+#endif // WINDOWS_ENABLED

engine/drivers/windows/file_access_windows.h

@@ -0,0 +1,110 @@
+/**************************************************************************/
+/*  file_access_windows.h                                                 */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* 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.                 */
+/**************************************************************************/
+
+#ifndef FILE_ACCESS_WINDOWS_H
+#define FILE_ACCESS_WINDOWS_H
+
+#ifdef WINDOWS_ENABLED
+
+#include "core/io/file_access.h"
+#include "core/os/memory.h"
+
+#include <stdio.h>
+
+class FileAccessWindows : public FileAccess {
+	FILE *f = nullptr;
+	int flags = 0;
+	void check_errors() const;
+	mutable int prev_op = 0;
+	mutable Error last_error = OK;
+	String path;
+	String path_src;
+	String save_path;
+
+	void _close();
+
+	static HashSet<String> invalid_files;
+
+public:
+	static bool is_path_invalid(const String &p_path);
+
+	virtual String fix_path(const String &p_path) const override;
+	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
+	virtual String get_path_absolute() const override; /// returns the absolute path for the current open file
+
+	virtual void seek(uint64_t p_position) override; ///< seek to a given position
+	virtual void seek_end(int64_t p_position = 0) override; ///< seek from the end of file
+	virtual uint64_t get_position() const override; ///< get position in the file
+	virtual uint64_t get_length() const override; ///< get size of the file
+
+	virtual bool eof_reached() const override; ///< reading passed EOF
+
+	virtual uint8_t get_8() const override; ///< get a byte
+	virtual uint16_t get_16() const override;
+	virtual uint32_t get_32() const override;
+	virtual uint64_t get_64() const override;
+	virtual uint64_t get_buffer(uint8_t *p_dst, uint64_t p_length) const override;
+
+	virtual Error get_error() const override; ///< get last error
+
+	virtual Error resize(int64_t p_length) override;
+	virtual void flush() override;
+	virtual void store_8(uint8_t p_dest) override; ///< store a byte
+	virtual void store_16(uint16_t p_dest) override;
+	virtual void store_32(uint32_t p_dest) override;
+	virtual void store_64(uint64_t p_dest) override;
+	virtual void store_buffer(const uint8_t *p_src, uint64_t p_length) override; ///< store an array of bytes
+
+	virtual bool file_exists(const String &p_name) override; ///< return true if a file exists
+
+	uint64_t _get_modified_time(const String &p_file) override;
+	virtual BitField<FileAccess::UnixPermissionFlags> _get_unix_permissions(const String &p_file) override;
+	virtual Error _set_unix_permissions(const String &p_file, BitField<FileAccess::UnixPermissionFlags> p_permissions) override;
+
+	virtual bool _get_hidden_attribute(const String &p_file) override;
+	virtual Error _set_hidden_attribute(const String &p_file, bool p_hidden) override;
+	virtual bool _get_read_only_attribute(const String &p_file) override;
+	virtual Error _set_read_only_attribute(const String &p_file, bool p_ro) override;
+
+	virtual void close() override;
+
+	static void initialize();
+	static void finalize();
+
+	FileAccessWindows() {}
+	virtual ~FileAccessWindows();
+};
+
+#endif // WINDOWS_ENABLED
+
+#endif // FILE_ACCESS_WINDOWS_H

engine/drivers/windows/file_access_windows_pipe.cpp

@@ -0,0 +1,159 @@
+/**************************************************************************/
+/*  file_access_windows_pipe.cpp                                          */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* 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.                 */
+/**************************************************************************/
+
+#ifdef WINDOWS_ENABLED
+
+#include "file_access_windows_pipe.h"
+
+#include "core/os/os.h"
+#include "core/string/print_string.h"
+
+Error FileAccessWindowsPipe::open_existing(HANDLE p_rfd, HANDLE p_wfd) {
+	// Open pipe using handles created by CreatePipe(rfd, wfd, NULL, 4096) call in the OS.execute_with_pipe.
+	_close();
+
+	path_src = String();
+	ERR_FAIL_COND_V_MSG(fd[0] != 0 || fd[1] != 0, ERR_ALREADY_IN_USE, "Pipe is already in use.");
+	fd[0] = p_rfd;
+	fd[1] = p_wfd;
+
+	last_error = OK;
+	return OK;
+}
+
+Error FileAccessWindowsPipe::open_internal(const String &p_path, int p_mode_flags) {
+	_close();
+
+	path_src = p_path;
+	ERR_FAIL_COND_V_MSG(fd[0] != 0 || fd[1] != 0, ERR_ALREADY_IN_USE, "Pipe is already in use.");
+
+	path = String("\\\\.\\pipe\\LOCAL\\") + p_path.replace("pipe://", "").replace("/", "_");
+
+	HANDLE h = CreateFileW((LPCWSTR)path.utf16().get_data(), GENERIC_READ | GENERIC_WRITE, 0, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+	if (h == INVALID_HANDLE_VALUE) {
+		h = CreateNamedPipeW((LPCWSTR)path.utf16().get_data(), PIPE_ACCESS_DUPLEX, PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT, 1, 4096, 4096, 0, nullptr);
+		if (h == INVALID_HANDLE_VALUE) {
+			last_error = ERR_FILE_CANT_OPEN;
+			return last_error;
+		}
+		ConnectNamedPipe(h, NULL);
+	}
+	fd[0] = h;
+	fd[1] = h;
+
+	last_error = OK;
+	return OK;
+}
+
+void FileAccessWindowsPipe::_close() {
+	if (fd[0] == 0) {
+		return;
+	}
+	if (fd[1] != fd[0]) {
+		CloseHandle(fd[1]);
+	}
+	CloseHandle(fd[0]);
+	fd[0] = 0;
+	fd[1] = 0;
+}
+
+bool FileAccessWindowsPipe::is_open() const {
+	return (fd[0] != 0 || fd[1] != 0);
+}
+
+String FileAccessWindowsPipe::get_path() const {
+	return path_src;
+}
+
+String FileAccessWindowsPipe::get_path_absolute() const {
+	return path_src;
+}
+
+uint8_t FileAccessWindowsPipe::get_8() const {
+	ERR_FAIL_COND_V_MSG(fd[0] == 0, 0, "Pipe must be opened before use.");
+
+	uint8_t b;
+	if (!ReadFile(fd[0], &b, 1, nullptr, nullptr)) {
+		last_error = ERR_FILE_CANT_READ;
+		b = '\0';
+	} else {
+		last_error = OK;
+	}
+	return b;
+}
+
+uint64_t FileAccessWindowsPipe::get_buffer(uint8_t *p_dst, uint64_t p_length) const {
+	ERR_FAIL_COND_V(!p_dst && p_length > 0, -1);
+	ERR_FAIL_COND_V_MSG(fd[0] == 0, -1, "Pipe must be opened before use.");
+
+	DWORD read = -1;
+	if (!ReadFile(fd[0], p_dst, p_length, &read, nullptr) || read != p_length) {
+		last_error = ERR_FILE_CANT_READ;
+	} else {
+		last_error = OK;
+	}
+	return read;
+}
+
+Error FileAccessWindowsPipe::get_error() const {
+	return last_error;
+}
+
+void FileAccessWindowsPipe::store_8(uint8_t p_src) {
+	ERR_FAIL_COND_MSG(fd[1] == 0, "Pipe must be opened before use.");
+	if (!WriteFile(fd[1], &p_src, 1, nullptr, nullptr)) {
+		last_error = ERR_FILE_CANT_WRITE;
+	} else {
+		last_error = OK;
+	}
+}
+
+void FileAccessWindowsPipe::store_buffer(const uint8_t *p_src, uint64_t p_length) {
+	ERR_FAIL_COND_MSG(fd[1] == 0, "Pipe must be opened before use.");
+	ERR_FAIL_COND(!p_src && p_length > 0);
+
+	DWORD read = -1;
+	bool ok = WriteFile(fd[1], p_src, p_length, &read, nullptr);
+	if (!ok || read != p_length) {
+		last_error = ERR_FILE_CANT_WRITE;
+	} else {
+		last_error = OK;
+	}
+}
+
+void FileAccessWindowsPipe::close() {
+	_close();
+}
+
+FileAccessWindowsPipe::~FileAccessWindowsPipe() {
+	_close();
+}
+
+#endif // WINDOWS_ENABLED

engine/drivers/windows/file_access_windows_pipe.h

@@ -0,0 +1,96 @@
+/**************************************************************************/
+/*  file_access_windows_pipe.h                                            */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* 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.                 */
+/**************************************************************************/
+
+#ifndef FILE_ACCESS_WINDOWS_PIPE_H
+#define FILE_ACCESS_WINDOWS_PIPE_H
+
+#ifdef WINDOWS_ENABLED
+
+#include "core/io/file_access.h"
+#include "core/os/memory.h"
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+class FileAccessWindowsPipe : public FileAccess {
+	HANDLE fd[2] = { 0, 0 };
+
+	mutable Error last_error = OK;
+
+	String path;
+	String path_src;
+
+	void _close();
+
+public:
+	Error open_existing(HANDLE p_rfd, HANDLE p_wfd);
+
+	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
+	virtual String get_path_absolute() const override; /// returns the absolute path for the current open file
+
+	virtual void seek(uint64_t p_position) override {}
+	virtual void seek_end(int64_t p_position = 0) override {}
+	virtual uint64_t get_position() const override { return 0; }
+	virtual uint64_t get_length() const override { return 0; }
+
+	virtual bool eof_reached() const override { return false; }
+
+	virtual uint8_t get_8() const override; ///< get a byte
+	virtual uint64_t get_buffer(uint8_t *p_dst, uint64_t p_length) const override;
+
+	virtual Error get_error() const override; ///< get last error
+
+	virtual Error resize(int64_t p_length) override { return ERR_UNAVAILABLE; }
+	virtual void flush() override {}
+	virtual void store_8(uint8_t p_src) override; ///< store a byte
+	virtual void store_buffer(const uint8_t *p_src, uint64_t p_length) override; ///< store an array of bytes
+
+	virtual bool file_exists(const String &p_name) override { return false; }
+
+	uint64_t _get_modified_time(const String &p_file) override { return 0; }
+	virtual BitField<FileAccess::UnixPermissionFlags> _get_unix_permissions(const String &p_file) override { return 0; }
+	virtual Error _set_unix_permissions(const String &p_file, BitField<FileAccess::UnixPermissionFlags> p_permissions) override { return ERR_UNAVAILABLE; }
+
+	virtual bool _get_hidden_attribute(const String &p_file) override { return false; }
+	virtual Error _set_hidden_attribute(const String &p_file, bool p_hidden) override { return ERR_UNAVAILABLE; }
+	virtual bool _get_read_only_attribute(const String &p_file) override { return false; }
+	virtual Error _set_read_only_attribute(const String &p_file, bool p_ro) override { return ERR_UNAVAILABLE; }
+
+	virtual void close() override;
+
+	FileAccessWindowsPipe() {}
+	virtual ~FileAccessWindowsPipe();
+};
+
+#endif // WINDOWS_ENABLED
+
+#endif // FILE_ACCESS_WINDOWS_PIPE_H