ARG_TYPE_MASK = (1 << 16) - 1

};

struct MethodInfo {

bool _static = false;

bool _call_method(JavaObject *p_instance, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error, Variant &ret);

friend class JavaClassWrapper;

jclass _class;

#endif

GDCLASS(JavaClassWrapper, Object);

#ifdef ANDROID_ENABLED

friend class JavaClass;

jclass activityClass;

jmethodID findClass;

};

jobject instance;

#endif

public:

virtual Variant callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) override {

#ifdef ANDROID_ENABLED

// Check the method we're looking for is in the JNISingleton map and that

// the arguments match.

if env["target"].startswith("release"):

if env["optimize"] == "speed": # optimize for speed (default)

elif env["optimize"] == "size": # optimize for size

env.Append(CCFLAGS=["-Os"])

env.Append(LINKFLAGS=["-Os"])

return ERR_FILE_BAD_PATH;

}

if (ep.step(TTR("Creating APK..."), 0)) {

return ERR_SKIP;

int ret = unzGoToFirstFile(pkg);

String tmp_unaligned_path = EditorPaths::get_singleton()->get_cache_dir().plus_file("tmpexport-unaligned." + uitos(OS::get_singleton()->get_unix_time()) + ".apk");

ret = unzGoToFirstFile(tmp_unaligned);

zipFile final_apk = zipOpen2(p_path.utf8().get_data(), APPEND_STATUS_CREATE, nullptr, &io2);

// Take files from the unaligned APK and write them out to the aligned one

r_features->push_back("android");

}

}

EditorExportPlatformAndroid::EditorExportPlatformAndroid() {

virtual void get_platform_features(List<String> *r_features) override;

EditorExportPlatformAndroid();

#include "thread_jandroid.h"

bool JavaClass::_call_method(JavaObject *p_instance, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error, Variant &ret) {

if (!M) {

return false;

}

ERR_FAIL_COND_V(env == nullptr, false);

MethodInfo *method = nullptr;

if (!p_instance && !E._static) {

r_error.error = Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL;

continue;

jmethodID TTS_Android::_resume_speaking = 0;

jmethodID TTS_Android::_stop_speaking = 0;

void TTS_Android::setup(jobject p_tts) {

JNIEnv *env = get_jni_env();

}

void TTS_Android::stop() {

}

ids.clear();

static jmethodID _resume_speaking;

static jmethodID _stop_speaking;

public:

static void setup(jobject p_tts);

if env["target"].startswith("release"):

env.Append(CPPDEFINES=["NDEBUG", ("NS_BLOCK_ASSERTIONS", 1)])

if env["optimize"] == "speed": # optimize for speed (default)

elif env["optimize"] == "size": # optimize for size

env.Append(CCFLAGS=["-Os", "-ftree-vectorize"])

env.Append(LINKFLAGS=["-Os"])

r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "plugins/" + found_plugins[i].name), false));

}

for (int i = 0; i < found_plugins.size(); i++) {

// Editable plugin plist values

PluginConfigIOS plugin = found_plugins[i];

case PluginConfigIOS::PlistItemType::STRING_INPUT: {

if (!plist_keys.has(preset_name)) {

plist_keys.insert(preset_name);

}

} break;

Vector<String> added_embedded_dependenciy_names;

HashMap<String, String> plist_values;

Error err;

// Plist

// Using hash map container to remove duplicates

String value;

// Updating `Info.plist`

{

if (key.is_empty() || value.is_empty()) {

continue;

// Update Linker Flag Values

{

String result_linker_flags = " ";

const String &flag = E->get();

if (flag.length() == 0) {

bool found_library = false;

const String project_file = "godot_ios.xcodeproj/project.pbxproj";

files_to_parse.insert("godot_ios/godot_ios-Info.plist");

files_to_parse.insert(project_file);

files_to_parse.insert("godot_ios/export_options.plist");

ERR_FAIL_COND_V(tmp_app_path.is_null(), ERR_CANT_CREATE);

print_line("Unzipping...");

unzFile src_pkg_zip = unzOpen2(src_pkg_name.utf8().get_data(), &io);

if (!src_pkg_zip) {

EditorNode::add_io_error("Could not open export template (not a zip file?):\n" + src_pkg_name);

r_features->push_back("ios");

}

}

EditorExportPlatformIOS();

NSDictionary *hapticDict = @{

CHHapticPatternKeyPattern : @[

@{CHHapticPatternKeyEvent : @{

CHHapticPatternKeyTime : @(CHHapticTimeImmediate),

CHHapticPatternKeyEventDuration : @(p_duration_seconds)

},

#ifndef TTS_IOS_H

#define TTS_IOS_H

#include "core/string/ustring.h"

#include "core/templates/list.h"

#include "core/variant/array.h"

#include "servers/display_server.h"

@interface TTS_IOS : NSObject <AVSpeechSynthesizerDelegate> {

bool speaking;

AVSpeechSynthesizer *av_synth;

List<DisplayServer::TTSUtterance> queue;

}

String resource_path = ProjectSettings::get_singleton()->get_resource_path();

// Name the downloaded ZIP file to contain the project name and download date for easier organization.

// Replace characters not allowed (or risky) in Windows file names with safe characters.

void JavaScriptToolsEditorPlugin::_zip_recursive(String p_path, String p_base_path, zipFile p_zip) {

Ref<DirAccess> dir = DirAccess::open(p_path);

WARN_PRINT("Unable to open directory for zipping: " + p_path);

return;

}

}

void DisplayServerJavaScript::tts_stop() {

}

utterance_ids.clear();

godot_js_tts_stop();

EMSCRIPTEN_WEBGL_CONTEXT_HANDLE webgl_ctx = 0;

#endif

WindowMode window_mode = WINDOW_MODE_WINDOWED;

ObjectID window_attached_instance_id = {};

#include "core/config/project_settings.h"

Error EditorExportPlatformJavaScript::_extract_template(const String &p_template, const String &p_dir, const String &p_name, bool pwa) {

unzFile pkg = unzOpen2(p_template.utf8().get_data(), &io);

if (!pkg) {

return OK;

}

String str_template = String::utf8(reinterpret_cast<const char *>(r_template.ptr()), r_template.size());

String out;

Vector<String> lines = str_template.split("\n");

// Replaces HTML string

const String str_config = Variant(config).to_json_string();

const String custom_head_include = p_preset->get("html/head_include");

replaces["$GODOT_URL"] = p_name + ".js";

replaces["$GODOT_PROJECT_NAME"] = ProjectSettings::get_singleton()->get_setting("application/config/name");

replaces["$GODOT_HEAD_INCLUDE"] = head_include + custom_head_include;

const String dir = p_path.get_base_dir();

const String name = p_path.get_file().get_basename();

const ExportMode mode = (ExportMode)(int)p_preset->get("variant/export_type");

replaces["@GODOT_VERSION@"] = String::num_int64(OS::get_singleton()->get_unix_time()) + "|" + String::num_int64(OS::get_singleton()->get_ticks_usec());

replaces["@GODOT_NAME@"] = proj_name.substr(0, 16);

replaces["@GODOT_OFFLINE_PAGE@"] = name + ".offline.html";

}

Error _extract_template(const String &p_template, const String &p_dir, const String &p_name, bool pwa);

void _fix_html(Vector<uint8_t> &p_html, const Ref<EditorExportPreset> &p_preset, const String &p_name, bool p_debug, int p_flags, const Vector<SharedObject> p_shared_objects, const Dictionary &p_file_sizes);

Error _add_manifest_icon(const String &p_path, const String &p_icon, int p_size, Array &r_arr);

Error _build_pwa(const Ref<EditorExportPreset> &p_preset, const String p_path, const Vector<SharedObject> &p_shared_objects);

r_features->push_back(get_os_name().to_lower());

}

}

String get_debug_protocol() const override { return "ws://"; }

class EditorHTTPServer : public RefCounted {

private:

Ref<TCPServer> server;

Ref<StreamPeerTCP> tcp;

Ref<StreamPeerSSL> ssl;

Ref<StreamPeer> peer;

godot_js_os_hw_concurrency_get__sig: 'i',

godot_js_os_hw_concurrency_get: function () {

},

godot_js_os_download_buffer__sig: 'viiii',

/*************************************************************************/

#include <alloca.h>

_THREAD_SAFE_METHOD_

if (p_cursor.is_valid()) {

if (cursor_c) {

cursor_set_shape(p_shape);

return;

}

}

if (XIMaskIsSet(raw_event->valuators.mask, VALUATOR_PRESSURE)) {

if (pen_pressure) {

if (pen_pressure_range != Vector2()) {

xi.pressure_supported = true;

xi.pressure = (*values - pen_pressure_range[0]) /

}

if (XIMaskIsSet(raw_event->valuators.mask, VALUATOR_TILTX)) {

if (pen_tilt_x) {

if (pen_tilt_x_range[0] != 0 && *values < 0) {

xi.tilt.x = *values / -pen_tilt_x_range[0];

} else if (pen_tilt_x_range[1] != 0) {

}

if (XIMaskIsSet(raw_event->valuators.mask, VALUATOR_TILTY)) {

if (pen_tilt_y) {

if (pen_tilt_y_range[0] != 0 && *values < 0) {

xi.tilt.y = *values / -pen_tilt_y_range[0];

} else if (pen_tilt_y_range[1] != 0) {

xi.raw_pos.x = rel_x;

xi.raw_pos.y = rel_y;

if (abs_info) {

// Absolute mode device

xi.relative_motion.x += (xi.raw_pos.x - xi.old_raw_pos.x) * mult.x;

xi.relative_motion.y += (xi.raw_pos.y - xi.old_raw_pos.y) * mult.y;

} break;

case XI_TouchUpdate: {

if (!curr_pos_elem) { // Defensive

break;

}

Ref<InputEventScreenDrag> sd;

sd.instantiate();

sd->set_window_id(window_id);

sd->set_index(index);

sd->set_position(pos);

Input::get_singleton()->parse_input_event(sd);

}

} break;

#endif

void DisplayServerX11::release_rendering_thread() {

#if defined(GLES3_ENABLED)

#endif

}

void DisplayServerX11::make_rendering_thread() {

#if defined(GLES3_ENABLED)

#endif

}

Callable drop_files_callback;

WindowID transient_parent = INVALID_WINDOW_ID;

ObjectID instance_id;

unsigned int focus_order = 0;

};

unsigned int last_mouse_monitor_mask = 0;

Vector2i last_mouse_monitor_pos;

struct {

int opcode;

Vector<int> touch_devices;

XIEventMask all_event_mask;

double pressure;

bool pressure_supported;

Vector2 tilt;

Cursor cursors[CURSOR_MAX];

Cursor null_cursor;

CursorShape current_cursor = CURSOR_ARROW;

bool layered_window = false;

#include "scene/resources/texture.h"

class EditorExportPlatformLinuxBSD : public EditorExportPlatformPC {

Error _export_debug_script(const Ref<EditorExportPreset> &p_preset, const String &p_app_name, const String &p_pkg_name, const String &p_path);

public:

#include "core/os/thread_safe.h"

#include "core/string/ustring.h"

#include "core/templates/list.h"

#include "core/variant/array.h"

#include "servers/display_server.h"

bool speaking = false;

bool paused = false;

int last_msg_id = -1;

Thread init_thread;

#include <errno.h>

String DirAccessOSX::fix_unicode_name(const char *p_name) const {

String fname;

#include "platform/osx/vulkan_context_osx.h"

#endif // VULKAN_ENABLED

#undef BitMap

#undef CursorShape

WindowID transient_parent = INVALID_WINDOW_ID;

bool exclusive = false;

bool layered_window = false;

bool fullscreen = false;

NSMenu *apple_menu = nullptr;

NSMenu *dock_menu = nullptr;

struct WarpEvent {

NSTimeInterval timestamp;

CursorShape cursor_shape = CURSOR_ARROW;

NSCursor *cursors[CURSOR_MAX];

const NSMenu *_get_menu_root(const String &p_menu_root) const;

NSMenu *_get_menu_root(const String &p_menu_root);

#include "main/main.h"

#include "scene/resources/texture.h"

#if defined(GLES3_ENABLED)

#include "drivers/gles3/rasterizer_gles3.h"

[wd.window_object setTabbingMode:NSWindowTabbingModeDisallowed];

}

if (layer) {

layer.contentsScale = scale;

}

wd.size.width = contentRect.size.width * scale;

wd.size.height = contentRect.size.height * scale;

if (layer) {

layer.contentsScale = scale;

}

if (borderless_full) {

// If the window covers up the screen set the level to above the main menu and hide on deactivate.

} else {

// Reset these when our window is not a borderless window that covers up the screen.

if (p_wd.on_top && !p_wd.fullscreen) {

} else {

}

}

}

[wd.window_object setBackgroundColor:[NSColor clearColor]];

[wd.window_object setOpaque:NO];

[wd.window_object setHasShadow:NO];

if (layer) {

[layer setBackgroundColor:[NSColor clearColor].CGColor];

[layer setOpaque:NO];

[wd.window_object setBackgroundColor:[NSColor colorWithCalibratedWhite:1 alpha:1]];

[wd.window_object setOpaque:YES];

[wd.window_object setHasShadow:YES];

if (layer) {

[layer setBackgroundColor:[NSColor colorWithCalibratedWhite:1 alpha:1].CGColor];

[layer setOpaque:YES];

if (menu_item) {

const NSMenu *sub_menu = [menu_item submenu];

if (sub_menu) {

}

}

}

_THREAD_SAFE_METHOD_

Vector<int> ret;

}

return ret;

}

} break;

case WINDOW_MODE_EXCLUSIVE_FULLSCREEN:

case WINDOW_MODE_FULLSCREEN: {

_set_window_per_pixel_transparency_enabled(true, p_window);

if (wd.resize_disabled) { // Restore resize disabled.

[wd.window_object setStyleMask:[wd.window_object styleMask] & ~NSWindowStyleMaskResizable];

return;

}

if (p_enabled) {

} else {

}

} break;

case WINDOW_FLAG_TRANSPARENT: {

if (wd.fullscreen) {

return wd.on_top;

} else {

}

} break;

case WINDOW_FLAG_TRANSPARENT: {

bool DisplayServerOSX::can_any_window_draw() const {

_THREAD_SAFE_METHOD_

return true;

}

}

position /= screen_get_max_scale();

NSInteger wnum = [NSWindow windowNumberAtPoint:NSMakePoint(position.x, position.y) belowWindowWithWindowNumber:0 /*topmost*/];

}

}

return INVALID_WINDOW_ID;

_THREAD_SAFE_METHOD_

if (p_cursor.is_valid()) {

if (cursor_c) {

cursor_set_shape(p_shape);

return;

}

Input::get_singleton()->flush_buffered_events();

}

if (wd.mpath.size() > 0) {

update_mouse_pos(wd, [wd.window_object mouseLocationOutsideOfEventStream]);

if (Geometry2D::is_point_in_polygon(wd.mouse_pos, wd.mpath)) {

DisplayServerOSX::~DisplayServerOSX() {

// Destroy all windows.

}

// Destroy drivers.

r_features->push_back("64");

}

// These options are not supported by built-in codesign, used on non macOS host.

if (!OS::get_singleton()->has_feature("macos")) {

if (p_option == "codesign/identity" || p_option == "codesign/timestamp" || p_option == "codesign/hardened_runtime" || p_option == "codesign/custom_options" || p_option.begins_with("notarization/")) {

return ERR_FILE_BAD_PATH;

}

if (ep.step(TTR("Creating app bundle"), 0)) {

return ERR_SKIP;

OS::get_singleton()->move_to_trash(p_path);

}

zipFile zip = zipOpen2(p_path.utf8().get_data(), APPEND_STATUS_CREATE, nullptr, &io_dst);

_zip_folder_recursive(zip, tmp_base_path_name, "", pkg_name);

protected:

virtual void get_preset_features(const Ref<EditorExportPreset> &p_preset, List<String> *r_features) override;

virtual void get_export_options(List<ExportOption> *r_options) override;

public:

virtual String get_name() const override { return "macOS"; }

r_features->push_back("macos");

}

}

EditorExportPlatformOSX();

} break;

case PList::PLNodeType::PL_NODE_TYPE_DICT: {

size_t size = 0;

size += 1 + _asn1_size_len(p_len_octets); // Sequence.

}

return size;

} break;

case PList::PLNodeType::PL_NODE_TYPE_DICT: {

p_stream.push_back(0x31); // Set.

store_asn1_size(p_stream, p_len_octets);

uint32_t size = cs.length();

// Sequence.

p_stream.push_back(0x30);

if (p_len_octets > 1) {

p_stream.push_back(0x80 + p_len_octets);

}

p_stream.push_back(cs[i]);

}

// Value.

}

} break;

}

case PList::PLNodeType::PL_NODE_TYPE_DICT: {

p_stream += String("\t").repeat(p_indent);

p_stream += "<dict>\n";

p_stream += String("\t").repeat(p_indent + 1);

p_stream += "<key>";

p_stream += "</key>\n";

}

p_stream += String("\t").repeat(p_indent);

p_stream += "</dict>\n";

CharString data_string;

Vector<Ref<PListNode>> data_array;

union {

int32_t data_int;

bool data_bool;

#include "core/templates/local_vector.h"

#include "servers/display_server.h"

class GLManager_OSX {

public:

NSOpenGLContext *context = nullptr;

};

NSOpenGLContext *shared_context = nullptr;

DisplayServer::WindowID current_window = DisplayServer::INVALID_WINDOW_ID;

}

void GLManager_OSX::swap_buffers() {

}

}

#define JOYPADOSX_H

#ifdef MACOS_10_0_4

#else

#endif

#include "core/input/input.h"

#include "key_mapping_osx.h"

bool KeyMappingOSX::is_numpad_key(unsigned int key) {

static const unsigned int table[] = {

#include "core/string/ustring.h"

#include "core/templates/list.h"

#include "core/variant/array.h"

#include "servers/display_server.h"

@interface TTS_OSX : NSObject <AVSpeechSynthesizerDelegate> {

// AVSpeechSynthesizer

bool speaking;

// NSSpeechSynthesizer

bool paused;

#define VULKAN_DEVICE_OSX_H

#include "drivers/vulkan/vulkan_context.h"

class VulkanContextOSX : public VulkanContext {

virtual const char *_get_platform_surface_extension() const;

tmp_file->store_string("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");

tmp_file->store_string("<Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\">");

for (int i = 0; i < file_metadata.size(); i++) {

String ext = file_metadata[i].name.get_extension().to_lower();

String progress_task;

Ref<FileAccess> package;

Vector<FileMeta> file_metadata;

AppxPackager packager;

packager.init(fa_pack);

if (ep.step("Creating package...", 0)) {

return ERR_SKIP;

r_features->push_back("uwp");

}

}

EditorExportPlatformUWP::EditorExportPlatformUWP() {

virtual void get_platform_features(List<String> *r_features) override;

EditorExportPlatformUWP();

};

"dwmapi",

]

env.Append(LINKFLAGS=[p + env["LIBSUFFIX"] for p in LIBS])

_update_window_style(p_id);

}

SetForegroundWindow(wd.hWnd); // Slightly higher priority.

SetFocus(wd.hWnd); // Set keyboard focus.

}

_THREAD_SAFE_METHOD_

if (p_cursor.is_valid()) {

if (cursor_c) {

if (cursor_c->get()[0] == p_cursor && cursor_c->get()[1] == p_hotspot) {

void DisplayServerWindows::swap_buffers() {

#if defined(GLES3_ENABLED)

#endif

}

void DisplayServerWindows::window_set_vsync_mode(DisplayServer::VSyncMode p_vsync_mode, WindowID p_window) {

_THREAD_SAFE_METHOD_

#if defined(VULKAN_ENABLED)

#endif

}

DisplayServer::VSyncMode DisplayServerWindows::window_get_vsync_mode(WindowID p_window) const {

_THREAD_SAFE_METHOD_

#if defined(VULKAN_ENABLED)

#endif

return DisplayServer::VSYNC_ENABLED;

}

}

void DisplayServerWindows::_drag_event(WindowID p_window, float p_x, float p_y, int idx) {

if (!curr) {

return;

}

return ::CallNextHookEx(mouse_monitor, code, wParam, lParam);

}

// See: https://docs.microsoft.com/en-us/windows/win32/winmsg/window-procedures

LRESULT DisplayServerWindows::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {

if (drop_events) {

WindowID window_id = INVALID_WINDOW_ID;

bool window_created = false;

for (const KeyValue<WindowID, WindowData> &E : windows) {

if (E.value.hWnd == hWnd) {

window_id = E.key;

}

}

if (!window_created) {

}

// Process window messages.

WindowRect.top,

WindowRect.right - WindowRect.left,

WindowRect.bottom - WindowRect.top,

if (!wd.hWnd) {

MessageBoxW(nullptr, L"Window Creation Error.", L"ERROR", MB_OK | MB_ICONEXCLAMATION);

windows.erase(id);

}

if (p_mode != WINDOW_MODE_FULLSCREEN && p_mode != WINDOW_MODE_EXCLUSIVE_FULLSCREEN) {

wd.pre_fs_valid = true;

#ifdef GLES3_ENABLED

if (gl_manager) {

Error err = gl_manager->window_create(id, wd.hWnd, hInstance, WindowRect.right - WindowRect.left, WindowRect.bottom - WindowRect.top);

}

#endif

ImmReleaseContext(wd.hWnd, wd.im_himc);

wd.im_position = Vector2();

wd.last_pos = p_rect.position;

wd.width = p_rect.size.width;

wd.height = p_rect.size.height;

#ifdef GLES3_ENABLED

// destroy windows .. NYI?

#endif

if (windows.has(MAIN_WINDOW_ID)) {

RenderingDeviceVulkan *rendering_device_vulkan = nullptr;

#endif

int pressrc;

HINSTANCE hInstance; // Holds The Instance Of The Application

Callable drop_files_callback;

WindowID transient_parent = INVALID_WINDOW_ID;

bool is_popup = false;

Rect2i parent_safe_rect;

WindowID _create_window(WindowMode p_mode, VSyncMode p_vsync_mode, uint32_t p_flags, const Rect2i &p_rect);

WindowID window_id_counter = MAIN_WINDOW_ID;

WindowID last_focused_window = INVALID_WINDOW_ID;

HCURSOR cursors[CURSOR_MAX] = { nullptr };

CursorShape cursor_shape = CursorShape::CURSOR_ARROW;

void _drag_event(WindowID p_window, float p_x, float p_y, int idx);

void _touch_event(WindowID p_window, bool p_pressed, float p_x, float p_y, int idx);

static void _dispatch_input_events(const Ref<InputEvent> &p_event);

void _dispatch_input_event(const Ref<InputEvent> &p_event);

public:

LRESULT WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

LRESULT MouseProc(int code, WPARAM wParam, LPARAM lParam);

return list;

}

// This option is not supported by "osslsigncode", used on non-Windows host.

if (!OS::get_singleton()->has_feature("windows") && p_option == "codesign/identity_type") {

return false;

virtual Error sign_shared_object(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path) override;

virtual List<String> get_binary_extensions(const Ref<EditorExportPreset> &p_preset) const override;

virtual void get_export_options(List<ExportOption> *r_options) override;

virtual bool can_export(const Ref<EditorExportPreset> &p_preset, String &r_error, bool &r_missing_templates) const override;

virtual String get_template_file_name(const String &p_target, const String &p_arch) const override;

virtual Error fixup_embedded_pck(const String &p_path, int64_t p_embedded_start, int64_t p_embedded_size) const override;

typedef HGLRC(APIENTRY *PFNWGLCREATECONTEXTATTRIBSARBPROC)(HDC, HGLRC, const int *);

int GLManager_Windows::_find_or_create_display(GLWindow &win) {

// find display NYI, only 1 supported so far

if (_displays.size()) {

return new_display_id;

}

static PIXELFORMATDESCRIPTOR pfd = {

sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor

1,

0, 0, 0 // Layer Masks Ignored

};

int pixel_format = ChoosePixelFormat(hDC, &pfd);

if (!pixel_format) // Did Windows Find A Matching Pixel Format?

{

return ERR_CANT_CREATE; // Return FALSE

}

if (!gl_display.hRC) // Are We Able To Get A Rendering Context?

{

return ERR_CANT_CREATE; // Return FALSE

}

int attribs[] = {

WGL_CONTEXT_MAJOR_VERSION_ARB, 3, //we want a 3.3 context

return ERR_CANT_CREATE;

}

if (!new_hRC) {

wglDeleteContext(gl_display.hRC);

gl_display.hRC = 0;

}

wglDeleteContext(gl_display.hRC);

gl_display.hRC = new_hRC;

{

wglDeleteContext(gl_display.hRC);

gl_display.hRC = 0;

}

return OK;

}

Error GLManager_Windows::window_create(DisplayServer::WindowID p_window_id, HWND p_hwnd, HINSTANCE p_hinstance, int p_width, int p_height) {

}

}

win.width = p_width;

win.height = p_height;

win.hwnd = p_hwnd;

win.gldisplay_id = _find_or_create_display(win);

if (win.gldisplay_id == -1) {

return FAILED;

}

// make current

return OK;

}

void GLManager_Windows::window_destroy(DisplayServer::WindowID p_window_id) {

GLWindow &win = get_window(p_window_id);

if (_current_window == &win) {

_current_window = nullptr;

}

}

void GLManager_Windows::release_current() {

return;

}

}

void GLManager_Windows::window_make_current(DisplayServer::WindowID p_window_id) {

return;

}

GLWindow &win = _windows[p_window_id];

// noop

if (&win == _current_window) {

}

const GLDisplay &disp = get_display(win.gldisplay_id);

_internal_set_current_window(&win);

}

if (!_current_window) {

return;

}

const GLDisplay &disp = get_current_display();

}

void GLManager_Windows::swap_buffers() {

}

}

Error GLManager_Windows::initialize() {

private:

// any data specific to the window

struct GLWindow {

int width = 0;

int height = 0;

HGLRC hRC;

};

LocalVector<GLDisplay> _displays;

GLWindow *_current_window = nullptr;

SetConsoleCtrlHandler(HandlerRoutine, TRUE);

}

void OS_Windows::initialize() {

crash_handler.initialize();

#ifndef WINDOWS_SUBSYSTEM_CONSOLE

RedirectIOToConsole();

#endif

// long as the windows scheduler resolution (~16-30ms) even for calls like Sleep(1)

timeBeginPeriod(1);

// Add current Godot PID to the list of known PIDs

ProcessInfo current_pi = {};

memdelete(process_map);

NetSocketPosix::cleanup();

}

Error OS_Windows::get_entropy(uint8_t *r_buffer, int p_bytes) {

#include <windows.h>

#include <windowsx.h>

class JoypadWindows;

class OS_Windows : public OS {

#ifdef STDOUT_FILE

CrashHandler crash_handler;

bool force_quit;

HWND main_window;

STARTUPINFO si;

PROCESS_INFORMATION pi;

};

public:

virtual void alert(const String &p_alert, const String &p_title = "ALERT!") override;

#include "core/string/ustring.h"

#include "core/templates/list.h"

#include "core/variant/array.h"

#include "servers/display_server.h"

int offset;

int id;

};

static void __stdcall speech_event_callback(WPARAM wParam, LPARAM lParam);

void _update_tts();

/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */

/*************************************************************************/

#include "vulkan_context_win.h"

#ifdef USE_VOLK

#include <volk.h>

VulkanContextWindows::~VulkanContextWindows() {

}