1 /*************************************************************************/
2 /* os_winrt.cpp */
3 /*************************************************************************/
4 /* This file is part of: */
5 /* GODOT ENGINE */
6 /* https://godotengine.org */
7 /*************************************************************************/
8 /* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */
9 /* */
10 /* Permission is hereby granted, free of charge, to any person obtaining */
11 /* a copy of this software and associated documentation files (the */
12 /* "Software"), to deal in the Software without restriction, including */
13 /* without limitation the rights to use, copy, modify, merge, publish, */
14 /* distribute, sublicense, and/or sell copies of the Software, and to */
15 /* permit persons to whom the Software is furnished to do so, subject to */
16 /* the following conditions: */
17 /* */
18 /* The above copyright notice and this permission notice shall be */
19 /* included in all copies or substantial portions of the Software. */
20 /* */
21 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
22 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
23 /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
24 /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
25 /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
26 /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
27 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
28 /*************************************************************************/
29 #include "drivers/gles2/rasterizer_gles2.h"
30
31 #include "drivers/unix/memory_pool_static_malloc.h"
32 #include "drivers/windows/dir_access_windows.h"
33 #include "drivers/windows/file_access_windows.h"
34 #include "drivers/windows/mutex_windows.h"
35 #include "drivers/windows/semaphore_windows.h"
36 #include "main/main.h"
37 #include "os/memory_pool_dynamic_static.h"
38 #include "os_winrt.h"
39 #include "thread_winrt.h"
40
41 #include "servers/audio/audio_server_sw.h"
42 #include "servers/visual/visual_server_raster.h"
43 #include "servers/visual/visual_server_wrap_mt.h"
44
45 #include "globals.h"
46 #include "io/marshalls.h"
47 #include "os/memory_pool_dynamic_prealloc.h"
48
49 #include "drivers/unix/ip_unix.h"
50 #include "platform/windows/packet_peer_udp_winsock.h"
51 #include "platform/windows/stream_peer_winsock.h"
52 #include "platform/windows/tcp_server_winsock.h"
53
54 #include <ppltasks.h>
55 #include <wrl.h>
56
57 using namespace Windows::ApplicationModel::Core;
58 using namespace Windows::ApplicationModel::Activation;
59 using namespace Windows::UI::Core;
60 using namespace Windows::UI::Input;
61 using namespace Windows::UI::Popups;
62 using namespace Windows::Foundation;
63 using namespace Windows::Graphics::Display;
64 using namespace Microsoft::WRL;
65 using namespace Windows::UI::ViewManagement;
66 using namespace Windows::Devices::Input;
67 using namespace Windows::Devices::Sensors;
68 using namespace Windows::ApplicationModel::DataTransfer;
69 using namespace concurrency;
70
get_video_driver_count() const71 int OSWinrt::get_video_driver_count() const {
72
73 return 1;
74 }
get_video_driver_name(int p_driver) const75 const char *OSWinrt::get_video_driver_name(int p_driver) const {
76
77 return "GLES2";
78 }
79
get_default_video_mode() const80 OS::VideoMode OSWinrt::get_default_video_mode() const {
81
82 return video_mode;
83 }
84
get_window_size() const85 Size2 OSWinrt::get_window_size() const {
86 Size2 size;
87 size.width = video_mode.width;
88 size.height = video_mode.height;
89 return size;
90 }
91
set_window_size(const Size2 p_size)92 void OSWinrt::set_window_size(const Size2 p_size) {
93
94 Windows::Foundation::Size new_size;
95 new_size.Width = p_size.width;
96 new_size.Height = p_size.height;
97
98 ApplicationView ^ view = ApplicationView::GetForCurrentView();
99
100 if (view->TryResizeView(new_size)) {
101
102 video_mode.width = p_size.width;
103 video_mode.height = p_size.height;
104 }
105 }
106
set_window_fullscreen(bool p_enabled)107 void OSWinrt::set_window_fullscreen(bool p_enabled) {
108
109 ApplicationView ^ view = ApplicationView::GetForCurrentView();
110
111 video_mode.fullscreen = view->IsFullScreenMode;
112
113 if (video_mode.fullscreen == p_enabled)
114 return;
115
116 if (p_enabled) {
117
118 video_mode.fullscreen = view->TryEnterFullScreenMode();
119
120 } else {
121
122 view->ExitFullScreenMode();
123 video_mode.fullscreen = false;
124 }
125 }
126
is_window_fullscreen() const127 bool OSWinrt::is_window_fullscreen() const {
128
129 return ApplicationView::GetForCurrentView()->IsFullScreenMode;
130 }
131
set_keep_screen_on(bool p_enabled)132 void OSWinrt::set_keep_screen_on(bool p_enabled) {
133
134 if (is_keep_screen_on() == p_enabled) return;
135
136 if (p_enabled)
137 display_request->RequestActive();
138 else
139 display_request->RequestRelease();
140
141 OS::set_keep_screen_on(p_enabled);
142 }
143
get_audio_driver_count() const144 int OSWinrt::get_audio_driver_count() const {
145
146 return AudioDriverManagerSW::get_driver_count();
147 }
get_audio_driver_name(int p_driver) const148 const char *OSWinrt::get_audio_driver_name(int p_driver) const {
149
150 AudioDriverSW *driver = AudioDriverManagerSW::get_driver(p_driver);
151 ERR_FAIL_COND_V(!driver, "");
152 return AudioDriverManagerSW::get_driver(p_driver)->get_name();
153 }
154
155 static MemoryPoolStatic *mempool_static = NULL;
156 static MemoryPoolDynamic *mempool_dynamic = NULL;
157
initialize_core()158 void OSWinrt::initialize_core() {
159
160 last_button_state = 0;
161
162 //RedirectIOToConsole();
163
164 ThreadWinrt::make_default();
165 SemaphoreWindows::make_default();
166 MutexWindows::make_default();
167
168 FileAccess::make_default<FileAccessWindows>(FileAccess::ACCESS_RESOURCES);
169 FileAccess::make_default<FileAccessWindows>(FileAccess::ACCESS_USERDATA);
170 FileAccess::make_default<FileAccessWindows>(FileAccess::ACCESS_FILESYSTEM);
171 //FileAccessBufferedFA<FileAccessWindows>::make_default();
172 DirAccess::make_default<DirAccessWindows>(DirAccess::ACCESS_RESOURCES);
173 DirAccess::make_default<DirAccessWindows>(DirAccess::ACCESS_USERDATA);
174 DirAccess::make_default<DirAccessWindows>(DirAccess::ACCESS_FILESYSTEM);
175
176 //TCPServerWinsock::make_default();
177 //StreamPeerWinsock::make_default();
178
179 TCPServerWinsock::make_default();
180 StreamPeerWinsock::make_default();
181 PacketPeerUDPWinsock::make_default();
182
183 mempool_static = new MemoryPoolStaticMalloc;
184 #if 1
185 mempool_dynamic = memnew(MemoryPoolDynamicStatic);
186 #else
187 #define DYNPOOL_SIZE 4 * 1024 * 1024
188 void *buffer = malloc(DYNPOOL_SIZE);
189 mempool_dynamic = memnew(MemoryPoolDynamicPrealloc(buffer, DYNPOOL_SIZE));
190
191 #endif
192
193 // We need to know how often the clock is updated
194 if (!QueryPerformanceFrequency((LARGE_INTEGER *)&ticks_per_second))
195 ticks_per_second = 1000;
196 // If timeAtGameStart is 0 then we get the time since
197 // the start of the computer when we call GetGameTime()
198 ticks_start = 0;
199 ticks_start = get_ticks_usec();
200
201 IP_Unix::make_default();
202
203 cursor_shape = CURSOR_ARROW;
204 }
205
can_draw() const206 bool OSWinrt::can_draw() const {
207
208 return !minimized;
209 };
210
set_gl_context(ContextEGL * p_context)211 void OSWinrt::set_gl_context(ContextEGL *p_context) {
212
213 gl_context = p_context;
214 };
215
screen_size_changed()216 void OSWinrt::screen_size_changed() {
217
218 gl_context->reset();
219 };
220
initialize(const VideoMode & p_desired,int p_video_driver,int p_audio_driver)221 void OSWinrt::initialize(const VideoMode &p_desired, int p_video_driver, int p_audio_driver) {
222
223 main_loop = NULL;
224 outside = true;
225
226 gl_context->initialize();
227 VideoMode vm;
228 vm.width = gl_context->get_window_width();
229 vm.height = gl_context->get_window_height();
230 vm.resizable = false;
231
232 ApplicationView ^ view = ApplicationView::GetForCurrentView();
233 vm.fullscreen = view->IsFullScreenMode;
234
235 view->SetDesiredBoundsMode(ApplicationViewBoundsMode::UseVisible);
236 view->PreferredLaunchWindowingMode = ApplicationViewWindowingMode::PreferredLaunchViewSize;
237
238 if (p_desired.fullscreen != view->IsFullScreenMode) {
239 if (p_desired.fullscreen) {
240
241 vm.fullscreen = view->TryEnterFullScreenMode();
242
243 } else {
244
245 view->ExitFullScreenMode();
246 vm.fullscreen = false;
247 }
248 }
249
250 Windows::Foundation::Size desired;
251 desired.Width = p_desired.width;
252 desired.Height = p_desired.height;
253
254 view->PreferredLaunchViewSize = desired;
255
256 if (view->TryResizeView(desired)) {
257
258 vm.width = view->VisibleBounds.Width;
259 vm.height = view->VisibleBounds.Height;
260 }
261
262 set_video_mode(vm);
263
264 gl_context->make_current();
265 rasterizer = memnew(RasterizerGLES2);
266
267 visual_server = memnew(VisualServerRaster(rasterizer));
268 if (get_render_thread_mode() != RENDER_THREAD_UNSAFE) {
269
270 visual_server = memnew(VisualServerWrapMT(visual_server, get_render_thread_mode() == RENDER_SEPARATE_THREAD));
271 }
272
273 //
274 physics_server = memnew(PhysicsServerSW);
275 physics_server->init();
276
277 physics_2d_server = memnew(Physics2DServerSW);
278 physics_2d_server->init();
279
280 visual_server->init();
281
282 input = memnew(InputDefault);
283
284 joystick = ref new JoystickWinrt(input);
285 joystick->register_events();
286
287 AudioDriverManagerSW::get_driver(p_audio_driver)->set_singleton();
288
289 if (AudioDriverManagerSW::get_driver(p_audio_driver)->init() != OK) {
290
291 ERR_PRINT("Initializing audio failed.");
292 }
293
294 sample_manager = memnew(SampleManagerMallocSW);
295 audio_server = memnew(AudioServerSW(sample_manager));
296
297 audio_server->init();
298
299 spatial_sound_server = memnew(SpatialSoundServerSW);
300 spatial_sound_server->init();
301 spatial_sound_2d_server = memnew(SpatialSound2DServerSW);
302 spatial_sound_2d_server->init();
303
304 managed_object->update_clipboard();
305
306 Clipboard::ContentChanged += ref new EventHandler<Platform::Object ^>(managed_object, &ManagedType::on_clipboard_changed);
307
308 accelerometer = Accelerometer::GetDefault();
309 if (accelerometer != nullptr) {
310 // 60 FPS
311 accelerometer->ReportInterval = (1.0f / 60.0f) * 1000;
312 accelerometer->ReadingChanged +=
313 ref new TypedEventHandler<Accelerometer ^, AccelerometerReadingChangedEventArgs ^>(managed_object, &ManagedType::on_accelerometer_reading_changed);
314 }
315
316 magnetometer = Magnetometer::GetDefault();
317 if (magnetometer != nullptr) {
318 // 60 FPS
319 magnetometer->ReportInterval = (1.0f / 60.0f) * 1000;
320 magnetometer->ReadingChanged +=
321 ref new TypedEventHandler<Magnetometer ^, MagnetometerReadingChangedEventArgs ^>(managed_object, &ManagedType::on_magnetometer_reading_changed);
322 }
323
324 gyrometer = Gyrometer::GetDefault();
325 if (gyrometer != nullptr) {
326 // 60 FPS
327 gyrometer->ReportInterval = (1.0f / 60.0f) * 1000;
328 gyrometer->ReadingChanged +=
329 ref new TypedEventHandler<Gyrometer ^, GyrometerReadingChangedEventArgs ^>(managed_object, &ManagedType::on_gyroscope_reading_changed);
330 }
331
332 _ensure_data_dir();
333
334 if (is_keep_screen_on())
335 display_request->RequestActive();
336
337 set_keep_screen_on(GLOBAL_DEF("display/keep_screen_on", true));
338 }
339
set_clipboard(const String & p_text)340 void OSWinrt::set_clipboard(const String &p_text) {
341
342 DataPackage ^ clip = ref new DataPackage();
343 clip->RequestedOperation = DataPackageOperation::Copy;
344 clip->SetText(ref new Platform::String((const wchar_t *)p_text.c_str()));
345
346 Clipboard::SetContent(clip);
347 };
348
get_clipboard() const349 String OSWinrt::get_clipboard() const {
350
351 if (managed_object->clipboard != nullptr)
352 return managed_object->clipboard->Data();
353 else
354 return "";
355 };
356
input_event(InputEvent & p_event)357 void OSWinrt::input_event(InputEvent &p_event) {
358
359 p_event.ID = ++last_id;
360
361 input->parse_input_event(p_event);
362
363 if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.pressed && p_event.mouse_button.button_index > 3) {
364
365 //send release for mouse wheel
366 p_event.mouse_button.pressed = false;
367 p_event.ID = ++last_id;
368 input->parse_input_event(p_event);
369 }
370 };
371
delete_main_loop()372 void OSWinrt::delete_main_loop() {
373
374 if (main_loop)
375 memdelete(main_loop);
376 main_loop = NULL;
377 }
378
set_main_loop(MainLoop * p_main_loop)379 void OSWinrt::set_main_loop(MainLoop *p_main_loop) {
380
381 input->set_main_loop(p_main_loop);
382 main_loop = p_main_loop;
383 }
384
finalize()385 void OSWinrt::finalize() {
386
387 if (main_loop)
388 memdelete(main_loop);
389
390 main_loop = NULL;
391
392 visual_server->finish();
393 memdelete(visual_server);
394 #ifdef OPENGL_ENABLED
395 if (gl_context)
396 memdelete(gl_context);
397 #endif
398 if (rasterizer)
399 memdelete(rasterizer);
400
401 spatial_sound_server->finish();
402 memdelete(spatial_sound_server);
403 spatial_sound_2d_server->finish();
404 memdelete(spatial_sound_2d_server);
405
406 //if (debugger_connection_console) {
407 // memdelete(debugger_connection_console);
408 //}
409
410 memdelete(sample_manager);
411
412 audio_server->finish();
413 memdelete(audio_server);
414
415 memdelete(input);
416
417 physics_server->finish();
418 memdelete(physics_server);
419
420 physics_2d_server->finish();
421 memdelete(physics_2d_server);
422
423 joystick = nullptr;
424 }
finalize_core()425 void OSWinrt::finalize_core() {
426
427 if (mempool_dynamic)
428 memdelete(mempool_dynamic);
429 delete mempool_static;
430 }
431
vprint(const char * p_format,va_list p_list,bool p_stderr)432 void OSWinrt::vprint(const char *p_format, va_list p_list, bool p_stderr) {
433
434 char buf[16384 + 1];
435 int len = vsnprintf(buf, 16384, p_format, p_list);
436 if (len <= 0)
437 return;
438 buf[len] = 0;
439
440 int wlen = MultiByteToWideChar(CP_UTF8, 0, buf, len, NULL, 0);
441 if (wlen < 0)
442 return;
443
444 wchar_t *wbuf = (wchar_t *)malloc((len + 1) * sizeof(wchar_t));
445 MultiByteToWideChar(CP_UTF8, 0, buf, len, wbuf, wlen);
446 wbuf[wlen] = 0;
447
448 if (p_stderr)
449 fwprintf(stderr, L"%s", wbuf);
450 else
451 wprintf(L"%s", wbuf);
452
453 free(wbuf);
454
455 fflush(stdout);
456 };
457
alert(const String & p_alert,const String & p_title)458 void OSWinrt::alert(const String &p_alert, const String &p_title) {
459
460 Platform::String ^ alert = ref new Platform::String(p_alert.c_str());
461 Platform::String ^ title = ref new Platform::String(p_title.c_str());
462
463 MessageDialog ^ msg = ref new MessageDialog(alert, title);
464
465 UICommand ^ close = ref new UICommand("Close", ref new UICommandInvokedHandler(managed_object, &OSWinrt::ManagedType::alert_close));
466 msg->Commands->Append(close);
467 msg->DefaultCommandIndex = 0;
468
469 managed_object->alert_close_handle = true;
470
471 msg->ShowAsync();
472 }
473
474 void OSWinrt::ManagedType::alert_close(IUICommand ^ command) {
475
476 alert_close_handle = false;
477 }
478
479 void OSWinrt::ManagedType::on_clipboard_changed(Platform::Object ^ sender, Platform::Object ^ ev) {
480
481 update_clipboard();
482 }
483
update_clipboard()484 void OSWinrt::ManagedType::update_clipboard() {
485
486 DataPackageView ^ data = Clipboard::GetContent();
487
488 if (data->Contains(StandardDataFormats::Text)) {
489
490 create_task(data->GetTextAsync()).then([this](Platform::String ^ clipboard_content) {
491 this->clipboard = clipboard_content;
492 });
493 }
494 }
495
496 void OSWinrt::ManagedType::on_accelerometer_reading_changed(Accelerometer ^ sender, AccelerometerReadingChangedEventArgs ^ args) {
497
498 AccelerometerReading ^ reading = args->Reading;
499
500 os->input->set_accelerometer(Vector3(
501 reading->AccelerationX,
502 reading->AccelerationY,
503 reading->AccelerationZ));
504 }
505
506 void OSWinrt::ManagedType::on_magnetometer_reading_changed(Magnetometer ^ sender, MagnetometerReadingChangedEventArgs ^ args) {
507
508 MagnetometerReading ^ reading = args->Reading;
509
510 os->input->set_magnetometer(Vector3(
511 reading->MagneticFieldX,
512 reading->MagneticFieldY,
513 reading->MagneticFieldZ));
514 }
515
516 void OSWinrt::ManagedType::on_gyroscope_reading_changed(Gyrometer ^ sender, GyrometerReadingChangedEventArgs ^ args) {
517
518 GyrometerReading ^ reading = args->Reading;
519
520 os->input->set_magnetometer(Vector3(
521 reading->AngularVelocityX,
522 reading->AngularVelocityY,
523 reading->AngularVelocityZ));
524 }
525
set_mouse_mode(MouseMode p_mode)526 void OSWinrt::set_mouse_mode(MouseMode p_mode) {
527
528 if (p_mode == MouseMode::MOUSE_MODE_CAPTURED) {
529
530 CoreWindow::GetForCurrentThread()->SetPointerCapture();
531
532 } else {
533
534 CoreWindow::GetForCurrentThread()->ReleasePointerCapture();
535 }
536
537 if (p_mode == MouseMode::MOUSE_MODE_CAPTURED || p_mode == MouseMode::MOUSE_MODE_HIDDEN) {
538
539 CoreWindow::GetForCurrentThread()->PointerCursor = nullptr;
540
541 } else {
542
543 CoreWindow::GetForCurrentThread()->PointerCursor = ref new CoreCursor(CoreCursorType::Arrow, 0);
544 }
545
546 mouse_mode = p_mode;
547
548 SetEvent(mouse_mode_changed);
549 }
550
get_mouse_mode() const551 OSWinrt::MouseMode OSWinrt::get_mouse_mode() const {
552
553 return mouse_mode;
554 }
555
get_mouse_pos() const556 Point2 OSWinrt::get_mouse_pos() const {
557
558 return Point2(old_x, old_y);
559 }
560
get_mouse_button_state() const561 int OSWinrt::get_mouse_button_state() const {
562
563 return last_button_state;
564 }
565
set_window_title(const String & p_title)566 void OSWinrt::set_window_title(const String &p_title) {
567 }
568
set_video_mode(const VideoMode & p_video_mode,int p_screen)569 void OSWinrt::set_video_mode(const VideoMode &p_video_mode, int p_screen) {
570
571 video_mode = p_video_mode;
572 }
get_video_mode(int p_screen) const573 OS::VideoMode OSWinrt::get_video_mode(int p_screen) const {
574
575 return video_mode;
576 }
get_fullscreen_mode_list(List<VideoMode> * p_list,int p_screen) const577 void OSWinrt::get_fullscreen_mode_list(List<VideoMode> *p_list, int p_screen) const {
578 }
579
print_error(const char * p_function,const char * p_file,int p_line,const char * p_code,const char * p_rationale,ErrorType p_type)580 void OSWinrt::print_error(const char *p_function, const char *p_file, int p_line, const char *p_code, const char *p_rationale, ErrorType p_type) {
581
582 const char *err_details;
583 if (p_rationale && p_rationale[0])
584 err_details = p_rationale;
585 else
586 err_details = p_code;
587
588 switch (p_type) {
589 case ERR_ERROR:
590 print("ERROR: %s: %s\n", p_function, err_details);
591 print(" At: %s:%i\n", p_file, p_line);
592 break;
593 case ERR_WARNING:
594 print("WARNING: %s: %s\n", p_function, err_details);
595 print(" At: %s:%i\n", p_file, p_line);
596 break;
597 case ERR_SCRIPT:
598 print("SCRIPT ERROR: %s: %s\n", p_function, err_details);
599 print(" At: %s:%i\n", p_file, p_line);
600 break;
601 }
602 }
603
get_name()604 String OSWinrt::get_name() {
605
606 return "WinRT";
607 }
608
get_date(bool utc) const609 OS::Date OSWinrt::get_date(bool utc) const {
610
611 SYSTEMTIME systemtime;
612 if (utc)
613 GetSystemTime(&systemtime);
614 else
615 GetLocalTime(&systemtime);
616
617 Date date;
618 date.day = systemtime.wDay;
619 date.month = Month(systemtime.wMonth);
620 date.weekday = Weekday(systemtime.wDayOfWeek);
621 date.year = systemtime.wYear;
622 date.dst = false;
623 return date;
624 }
get_time(bool utc) const625 OS::Time OSWinrt::get_time(bool utc) const {
626
627 SYSTEMTIME systemtime;
628 if (utc)
629 GetSystemTime(&systemtime);
630 else
631 GetLocalTime(&systemtime);
632
633 Time time;
634 time.hour = systemtime.wHour;
635 time.min = systemtime.wMinute;
636 time.sec = systemtime.wSecond;
637 return time;
638 }
639
get_time_zone_info() const640 OS::TimeZoneInfo OSWinrt::get_time_zone_info() const {
641 TIME_ZONE_INFORMATION info;
642 bool daylight = false;
643 if (GetTimeZoneInformation(&info) == TIME_ZONE_ID_DAYLIGHT)
644 daylight = true;
645
646 TimeZoneInfo ret;
647 if (daylight) {
648 ret.name = info.DaylightName;
649 } else {
650 ret.name = info.StandardName;
651 }
652
653 ret.bias = info.Bias;
654 return ret;
655 }
656
get_unix_time() const657 uint64_t OSWinrt::get_unix_time() const {
658
659 FILETIME ft;
660 SYSTEMTIME st;
661 GetSystemTime(&st);
662 SystemTimeToFileTime(&st, &ft);
663
664 SYSTEMTIME ep;
665 ep.wYear = 1970;
666 ep.wMonth = 1;
667 ep.wDayOfWeek = 4;
668 ep.wDay = 1;
669 ep.wHour = 0;
670 ep.wMinute = 0;
671 ep.wSecond = 0;
672 ep.wMilliseconds = 0;
673 FILETIME fep;
674 SystemTimeToFileTime(&ep, &fep);
675
676 return (*(uint64_t *)&ft - *(uint64_t *)&fep) / 10000000;
677 };
678
delay_usec(uint32_t p_usec) const679 void OSWinrt::delay_usec(uint32_t p_usec) const {
680
681 int msec = p_usec < 1000 ? 1 : p_usec / 1000;
682
683 // no Sleep()
684 WaitForSingleObjectEx(GetCurrentThread(), msec, false);
685 }
get_ticks_usec() const686 uint64_t OSWinrt::get_ticks_usec() const {
687
688 uint64_t ticks;
689 uint64_t time;
690 // This is the number of clock ticks since start
691 QueryPerformanceCounter((LARGE_INTEGER *)&ticks);
692 // Divide by frequency to get the time in seconds
693 time = ticks * 1000000L / ticks_per_second;
694 // Subtract the time at game start to get
695 // the time since the game started
696 time -= ticks_start;
697 return time;
698 }
699
process_events()700 void OSWinrt::process_events() {
701 last_id = joystick->process_controllers(last_id);
702 process_key_events();
703 }
704
process_key_events()705 void OSWinrt::process_key_events() {
706
707 for (int i = 0; i < key_event_pos; i++) {
708
709 KeyEvent &kev = key_event_buffer[i];
710 InputEvent iev;
711
712 iev.type = InputEvent::KEY;
713 iev.key.mod = kev.mod_state;
714 iev.key.echo = kev.echo;
715 iev.key.scancode = kev.scancode;
716 iev.key.unicode = kev.unicode;
717 iev.key.pressed = kev.pressed;
718
719 input_event(iev);
720 }
721 key_event_pos = 0;
722 }
723
queue_key_event(KeyEvent & p_event)724 void OSWinrt::queue_key_event(KeyEvent &p_event) {
725 // This merges Char events with the previous Key event, so
726 // the unicode can be retrieved without sending duplicate events.
727 if (p_event.type == KeyEvent::MessageType::CHAR_EVENT_MESSAGE && key_event_pos > 0) {
728
729 KeyEvent &old = key_event_buffer[key_event_pos - 1];
730 ERR_FAIL_COND(old.type != KeyEvent::MessageType::KEY_EVENT_MESSAGE);
731
732 key_event_buffer[key_event_pos - 1].unicode = p_event.unicode;
733 return;
734 }
735
736 ERR_FAIL_COND(key_event_pos >= KEY_EVENT_BUFFER_SIZE);
737
738 key_event_buffer[key_event_pos++] = p_event;
739 }
740
set_cursor_shape(CursorShape p_shape)741 void OSWinrt::set_cursor_shape(CursorShape p_shape) {
742
743 ERR_FAIL_INDEX(p_shape, CURSOR_MAX);
744
745 if (cursor_shape == p_shape)
746 return;
747
748 static const CoreCursorType uwp_cursors[CURSOR_MAX] = {
749 CoreCursorType::Arrow,
750 CoreCursorType::IBeam,
751 CoreCursorType::Hand,
752 CoreCursorType::Cross,
753 CoreCursorType::Wait,
754 CoreCursorType::Wait,
755 CoreCursorType::Arrow,
756 CoreCursorType::Arrow,
757 CoreCursorType::UniversalNo,
758 CoreCursorType::SizeNorthSouth,
759 CoreCursorType::SizeWestEast,
760 CoreCursorType::SizeNortheastSouthwest,
761 CoreCursorType::SizeNorthwestSoutheast,
762 CoreCursorType::SizeAll,
763 CoreCursorType::SizeNorthSouth,
764 CoreCursorType::SizeWestEast,
765 CoreCursorType::Help
766 };
767
768 CoreWindow::GetForCurrentThread()->PointerCursor = ref new CoreCursor(uwp_cursors[p_shape], 0);
769
770 cursor_shape = p_shape;
771 }
772
set_custom_mouse_cursor(const RES & p_cursor,CursorShape p_shape,const Vector2 & p_hotspot)773 void OSWinrt::set_custom_mouse_cursor(const RES &p_cursor, CursorShape p_shape, const Vector2 &p_hotspot) {
774
775 // FIXME:
776 // Not implemented, some work needs to be done for this one
777 // Might be a good source: https://stackoverflow.com/questions/43793745/set-custom-mouse-cursor-on-windows-10-universal-app-uwp
778 }
779
execute(const String & p_path,const List<String> & p_arguments,bool p_blocking,ProcessID * r_child_id,String * r_pipe,int * r_exitcode,bool read_stderr)780 Error OSWinrt::execute(const String &p_path, const List<String> &p_arguments, bool p_blocking, ProcessID *r_child_id, String *r_pipe, int *r_exitcode, bool read_stderr) {
781
782 return FAILED;
783 };
784
kill(const ProcessID & p_pid)785 Error OSWinrt::kill(const ProcessID &p_pid) {
786
787 return FAILED;
788 };
789
set_cwd(const String & p_cwd)790 Error OSWinrt::set_cwd(const String &p_cwd) {
791
792 return FAILED;
793 }
794
get_executable_path() const795 String OSWinrt::get_executable_path() const {
796
797 return "";
798 }
799
set_icon(const Image & p_icon)800 void OSWinrt::set_icon(const Image &p_icon) {
801 }
802
has_environment(const String & p_var) const803 bool OSWinrt::has_environment(const String &p_var) const {
804
805 return false;
806 };
807
get_environment(const String & p_var) const808 String OSWinrt::get_environment(const String &p_var) const {
809
810 return "";
811 };
812
get_stdin_string(bool p_block)813 String OSWinrt::get_stdin_string(bool p_block) {
814
815 return String();
816 }
817
move_window_to_foreground()818 void OSWinrt::move_window_to_foreground() {
819 }
820
shell_open(String p_uri)821 Error OSWinrt::shell_open(String p_uri) {
822
823 return FAILED;
824 }
825
get_locale() const826 String OSWinrt::get_locale() const {
827
828 #if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP // this should work on phone 8.1, but it doesn't
829 return "en";
830 #else
831 Platform::String ^ language = Windows::Globalization::Language::CurrentInputMethodLanguageTag;
832 return String(language->Data()).replace("-", "_");
833 #endif
834 }
835
release_rendering_thread()836 void OSWinrt::release_rendering_thread() {
837
838 gl_context->release_current();
839 }
840
make_rendering_thread()841 void OSWinrt::make_rendering_thread() {
842
843 gl_context->make_current();
844 }
845
swap_buffers()846 void OSWinrt::swap_buffers() {
847
848 gl_context->swap_buffers();
849 }
850
has_touchscreen_ui_hint() const851 bool OSWinrt::has_touchscreen_ui_hint() const {
852
853 TouchCapabilities ^ tc = ref new TouchCapabilities();
854 return tc->TouchPresent != 0 || UIViewSettings::GetForCurrentView()->UserInteractionMode == UserInteractionMode::Touch;
855 }
856
has_virtual_keyboard() const857 bool OSWinrt::has_virtual_keyboard() const {
858
859 return UIViewSettings::GetForCurrentView()->UserInteractionMode == UserInteractionMode::Touch;
860 }
861
show_virtual_keyboard(const String & p_existing_text,const Rect2 & p_screen_rect)862 void OSWinrt::show_virtual_keyboard(const String &p_existing_text, const Rect2 &p_screen_rect) {
863
864 InputPane ^ pane = InputPane::GetForCurrentView();
865 pane->TryShow();
866 }
867
hide_virtual_keyboard()868 void OSWinrt::hide_virtual_keyboard() {
869
870 InputPane ^ pane = InputPane::GetForCurrentView();
871 pane->TryHide();
872 }
873
run()874 void OSWinrt::run() {
875
876 if (!main_loop)
877 return;
878
879 main_loop->init();
880
881 uint64_t last_ticks = get_ticks_usec();
882
883 int frames = 0;
884 uint64_t frame = 0;
885
886 while (!force_quit) {
887
888 CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent);
889 if (managed_object->alert_close_handle) continue;
890 process_events(); // get rid of pending events
891 if (Main::iteration() == true)
892 break;
893 };
894
895 main_loop->finish();
896 }
897
get_main_loop() const898 MainLoop *OSWinrt::get_main_loop() const {
899
900 return main_loop;
901 }
902
get_data_dir() const903 String OSWinrt::get_data_dir() const {
904
905 Windows::Storage::StorageFolder ^ data_folder = Windows::Storage::ApplicationData::Current->LocalFolder;
906
907 return String(data_folder->Path->Data()).replace("\\", "/");
908 }
909
OSWinrt()910 OSWinrt::OSWinrt() {
911
912 key_event_pos = 0;
913 force_quit = false;
914 alt_mem = false;
915 gr_mem = false;
916 shift_mem = false;
917 control_mem = false;
918 meta_mem = false;
919 minimized = false;
920
921 pressrc = 0;
922 old_invalid = true;
923 last_id = 0;
924 mouse_mode = MOUSE_MODE_VISIBLE;
925 #ifdef STDOUT_FILE
926 stdo = fopen("stdout.txt", "wb");
927 #endif
928
929 gl_context = NULL;
930
931 display_request = ref new Windows::System::Display::DisplayRequest();
932
933 managed_object = ref new ManagedType;
934 managed_object->os = this;
935
936 mouse_mode_changed = CreateEvent(NULL, TRUE, FALSE, L"os_mouse_mode_changed");
937
938 AudioDriverManagerSW::add_driver(&audio_driver);
939 }
940
~OSWinrt()941 OSWinrt::~OSWinrt() {
942 #ifdef STDOUT_FILE
943 fclose(stdo);
944 #endif
945 }
946