godot/platform/uwp/app.cpp

/*************************************************************************/
/*  app.cpp                                                              */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                      https://godotengine.org                          */
/*************************************************************************/
/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
/*                                                                       */
/* 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.                */
/*************************************************************************/

//
// This file demonstrates how to initialize EGL in a Windows Store app, using ICoreWindow.
//

#include "app.h"

#include "core/os/dir_access.h"
#include "core/os/file_access.h"
#include "core/os/keyboard.h"
#include "main/main.h"

#include "platform/windows/key_mapping_win.h"

#include <collection.h>

using namespace Windows::ApplicationModel::Core;
using namespace Windows::ApplicationModel::Activation;
using namespace Windows::UI::Core;
using namespace Windows::UI::Input;
using namespace Windows::Devices::Input;
using namespace Windows::UI::Xaml::Input;
using namespace Windows::Foundation;
using namespace Windows::Graphics::Display;
using namespace Windows::System;
using namespace Windows::System::Threading::Core;
using namespace Microsoft::WRL;

using namespace GodotUWP;

// Helper to convert a length in device-independent pixels (DIPs) to a length in physical pixels.
inline float ConvertDipsToPixels(float dips, float dpi) {
	static const float dipsPerInch = 96.0f;
	return floor(dips * dpi / dipsPerInch + 0.5f); // Round to nearest integer.
}

// Implementation of the IFrameworkViewSource interface, necessary to run our app.
ref class GodotUWPViewSource sealed : Windows::ApplicationModel::Core::IFrameworkViewSource {
public:
	virtual Windows::ApplicationModel::Core::IFrameworkView ^ CreateView() {
		return ref new App();
	}
};

// The main function creates an IFrameworkViewSource for our app, and runs the app.
[Platform::MTAThread] int main(Platform::Array<Platform::String ^> ^) {
	auto godotApplicationSource = ref new GodotUWPViewSource();
	CoreApplication::Run(godotApplicationSource);
	return 0;
}

App::App() :
		mWindowClosed(false),
		mWindowVisible(true),
		mWindowWidth(0),
		mWindowHeight(0),
		mEglDisplay(EGL_NO_DISPLAY),
		mEglContext(EGL_NO_CONTEXT),
		mEglSurface(EGL_NO_SURFACE) {
}

// The first method called when the IFrameworkView is being created.
void App::Initialize(CoreApplicationView ^ applicationView) {
	// Register event handlers for app lifecycle. This example includes Activated, so that we
	// can make the CoreWindow active and start rendering on the window.
	applicationView->Activated +=
			ref new TypedEventHandler<CoreApplicationView ^, IActivatedEventArgs ^>(this, &App::OnActivated);

	// Logic for other event handlers could go here.
	// Information about the Suspending and Resuming event handlers can be found here:
	// http://msdn.microsoft.com/en-us/library/windows/apps/xaml/hh994930.aspx

	os = new OSUWP;
}

// Called when the CoreWindow object is created (or re-created).
void App::SetWindow(CoreWindow ^ p_window) {
	window = p_window;
	window->VisibilityChanged +=
			ref new TypedEventHandler<CoreWindow ^, VisibilityChangedEventArgs ^>(this, &App::OnVisibilityChanged);

	window->Closed +=
			ref new TypedEventHandler<CoreWindow ^, CoreWindowEventArgs ^>(this, &App::OnWindowClosed);

	window->SizeChanged +=
			ref new TypedEventHandler<CoreWindow ^, WindowSizeChangedEventArgs ^>(this, &App::OnWindowSizeChanged);

#if !(WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP)
	// Disable all pointer visual feedback for better performance when touching.
	// This is not supported on Windows Phone applications.
	auto pointerVisualizationSettings = PointerVisualizationSettings::GetForCurrentView();
	pointerVisualizationSettings->IsContactFeedbackEnabled = false;
	pointerVisualizationSettings->IsBarrelButtonFeedbackEnabled = false;
#endif

	window->PointerPressed +=
			ref new TypedEventHandler<CoreWindow ^, PointerEventArgs ^>(this, &App::OnPointerPressed);
	window->PointerMoved +=
			ref new TypedEventHandler<CoreWindow ^, PointerEventArgs ^>(this, &App::OnPointerMoved);
	window->PointerReleased +=
			ref new TypedEventHandler<CoreWindow ^, PointerEventArgs ^>(this, &App::OnPointerReleased);
	window->PointerWheelChanged +=
			ref new TypedEventHandler<CoreWindow ^, PointerEventArgs ^>(this, &App::OnPointerWheelChanged);

	mouseChangedNotifier = SignalNotifier::AttachToEvent(L"os_mouse_mode_changed", ref new SignalHandler(
																						   this, &App::OnMouseModeChanged));

	mouseChangedNotifier->Enable();

	window->CharacterReceived +=
			ref new TypedEventHandler<CoreWindow ^, CharacterReceivedEventArgs ^>(this, &App::OnCharacterReceived);
	window->KeyDown +=
			ref new TypedEventHandler<CoreWindow ^, KeyEventArgs ^>(this, &App::OnKeyDown);
	window->KeyUp +=
			ref new TypedEventHandler<CoreWindow ^, KeyEventArgs ^>(this, &App::OnKeyUp);

	unsigned int argc;
	char **argv = get_command_line(&argc);

	Main::setup("uwp", argc, argv, false);

	// The CoreWindow has been created, so EGL can be initialized.
	ContextEGL *context = memnew(ContextEGL(window));
	os->set_gl_context(context);
	UpdateWindowSize(Size(window->Bounds.Width, window->Bounds.Height));

	Main::setup2();
}

static int _get_button(Windows::UI::Input::PointerPoint ^ pt) {

	using namespace Windows::UI::Input;

#if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
	return BUTTON_LEFT;
#else
	switch (pt->Properties->PointerUpdateKind) {
		case PointerUpdateKind::LeftButtonPressed:
		case PointerUpdateKind::LeftButtonReleased:
			return BUTTON_LEFT;

		case PointerUpdateKind::RightButtonPressed:
		case PointerUpdateKind::RightButtonReleased:
			return BUTTON_RIGHT;

		case PointerUpdateKind::MiddleButtonPressed:
		case PointerUpdateKind::MiddleButtonReleased:
			return BUTTON_MIDDLE;

		case PointerUpdateKind::XButton1Pressed:
		case PointerUpdateKind::XButton1Released:
			return BUTTON_WHEEL_UP;

		case PointerUpdateKind::XButton2Pressed:
		case PointerUpdateKind::XButton2Released:
			return BUTTON_WHEEL_DOWN;

		default:
			break;
	}
#endif

	return 0;
};

static bool _is_touch(Windows::UI::Input::PointerPoint ^ pointerPoint) {
#if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
	return true;
#else
	using namespace Windows::Devices::Input;
	switch (pointerPoint->PointerDevice->PointerDeviceType) {
		case PointerDeviceType::Touch:
		case PointerDeviceType::Pen:
			return true;
		default:
			return false;
	}
#endif
}

static Windows::Foundation::Point _get_pixel_position(CoreWindow ^ window, Windows::Foundation::Point rawPosition, OS *os) {

	Windows::Foundation::Point outputPosition;

// Compute coordinates normalized from 0..1.
// If the coordinates need to be sized to the SDL window,
// we'll do that after.
#if 1 || WINAPI_FAMILY != WINAPI_FAMILY_PHONE_APP
	outputPosition.X = rawPosition.X / window->Bounds.Width;
	outputPosition.Y = rawPosition.Y / window->Bounds.Height;
#else
	switch (DisplayProperties::CurrentOrientation) {
		case DisplayOrientations::Portrait:
			outputPosition.X = rawPosition.X / window->Bounds.Width;
			outputPosition.Y = rawPosition.Y / window->Bounds.Height;
			break;
		case DisplayOrientations::PortraitFlipped:
			outputPosition.X = 1.0f - (rawPosition.X / window->Bounds.Width);
			outputPosition.Y = 1.0f - (rawPosition.Y / window->Bounds.Height);
			break;
		case DisplayOrientations::Landscape:
			outputPosition.X = rawPosition.Y / window->Bounds.Height;
			outputPosition.Y = 1.0f - (rawPosition.X / window->Bounds.Width);
			break;
		case DisplayOrientations::LandscapeFlipped:
			outputPosition.X = 1.0f - (rawPosition.Y / window->Bounds.Height);
			outputPosition.Y = rawPosition.X / window->Bounds.Width;
			break;
		default:
			break;
	}
#endif

	OS::VideoMode vm = os->get_video_mode();
	outputPosition.X *= vm.width;
	outputPosition.Y *= vm.height;

	return outputPosition;
};

static int _get_finger(uint32_t p_touch_id) {

	return p_touch_id % 31; // for now
};

void App::pointer_event(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::PointerEventArgs ^ args, bool p_pressed, bool p_is_wheel) {

	Windows::UI::Input::PointerPoint ^ point = args->CurrentPoint;
	Windows::Foundation::Point pos = _get_pixel_position(window, point->Position, os);
	int but = _get_button(point);
	if (_is_touch(point)) {

		Ref<InputEventScreenTouch> screen_touch;
		screen_touch.instance();
		screen_touch->set_device(0);
		screen_touch->set_pressed(p_pressed);
		screen_touch->set_position(Vector2(pos.X, pos.Y));
		screen_touch->set_index(_get_finger(point->PointerId));

		last_touch_x[screen_touch->get_index()] = pos.X;
		last_touch_y[screen_touch->get_index()] = pos.Y;

		os->input_event(screen_touch);
	} else {

		Ref<InputEventMouseButton> mouse_button;
		mouse_button.instance();
		mouse_button->set_device(0);
		mouse_button->set_pressed(p_pressed);
		mouse_button->set_button_index(but);
		mouse_button->set_position(Vector2(pos.X, pos.Y));
		mouse_button->set_global_position(Vector2(pos.X, pos.Y));

		if (p_is_wheel) {
			if (point->Properties->MouseWheelDelta > 0) {
				mouse_button->set_button_index(point->Properties->IsHorizontalMouseWheel ? BUTTON_WHEEL_RIGHT : BUTTON_WHEEL_UP);
			} else if (point->Properties->MouseWheelDelta < 0) {
				mouse_button->set_button_index(point->Properties->IsHorizontalMouseWheel ? BUTTON_WHEEL_LEFT : BUTTON_WHEEL_DOWN);
			}
		}

		last_touch_x[31] = pos.X;
		last_touch_y[31] = pos.Y;

		os->input_event(mouse_button);

		if (p_is_wheel) {
			// Send release for mouse wheel
			mouse_button->set_pressed(false);
			os->input_event(mouse_button);
		}
	}
};

void App::OnPointerPressed(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::PointerEventArgs ^ args) {

	pointer_event(sender, args, true);
};

void App::OnPointerReleased(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::PointerEventArgs ^ args) {

	pointer_event(sender, args, false);
};

void App::OnPointerWheelChanged(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::PointerEventArgs ^ args) {

	pointer_event(sender, args, true, true);
}

void App::OnMouseModeChanged(Windows::System::Threading::Core::SignalNotifier ^ signalNotifier, bool timedOut) {

	OS::MouseMode mode = os->get_mouse_mode();
	SignalNotifier ^ notifier = mouseChangedNotifier;

	window->Dispatcher->RunAsync(
			CoreDispatcherPriority::High,
			ref new DispatchedHandler(
					[mode, notifier, this]() {
						if (mode == OS::MOUSE_MODE_CAPTURED) {

							this->MouseMovedToken = MouseDevice::GetForCurrentView()->MouseMoved +=
									ref new TypedEventHandler<MouseDevice ^, MouseEventArgs ^>(this, &App::OnMouseMoved);

						} else {

							MouseDevice::GetForCurrentView()->MouseMoved -= MouseMovedToken;
						}

						notifier->Enable();
					}));

	ResetEvent(os->mouse_mode_changed);
}

void App::OnPointerMoved(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::PointerEventArgs ^ args) {

	Windows::UI::Input::PointerPoint ^ point = args->CurrentPoint;
	Windows::Foundation::Point pos = _get_pixel_position(window, point->Position, os);

	if (_is_touch(point)) {

		Ref<InputEventScreenDrag> screen_drag;
		screen_drag.instance();
		screen_drag->set_device(0);
		screen_drag->set_position(Vector2(pos.X, pos.Y));
		screen_drag->set_index(_get_finger(point->PointerId));
		screen_drag->set_relative(Vector2(screen_drag->get_position().x - last_touch_x[screen_drag->get_index()], screen_drag->get_position().y - last_touch_y[screen_drag->get_index()]));

		os->input_event(screen_drag);
	} else {

		// In case the mouse grabbed, MouseMoved will handle this
		if (os->get_mouse_mode() == OS::MouseMode::MOUSE_MODE_CAPTURED)
			return;

		Ref<InputEventMouseMotion> mouse_motion;
		mouse_motion.instance();
		mouse_motion->set_device(0);
		mouse_motion->set_position(Vector2(pos.X, pos.Y));
		mouse_motion->set_global_position(Vector2(pos.X, pos.Y));
		mouse_motion->set_relative(Vector2(pos.X - last_touch_x[31], pos.Y - last_touch_y[31]));

		last_mouse_pos = pos;

		os->input_event(mouse_motion);
	}
}

void App::OnMouseMoved(MouseDevice ^ mouse_device, MouseEventArgs ^ args) {

	// In case the mouse isn't grabbed, PointerMoved will handle this
	if (os->get_mouse_mode() != OS::MouseMode::MOUSE_MODE_CAPTURED)
		return;

	Windows::Foundation::Point pos;
	pos.X = last_mouse_pos.X + args->MouseDelta.X;
	pos.Y = last_mouse_pos.Y + args->MouseDelta.Y;

	Ref<InputEventMouseMotion> mouse_motion;
	mouse_motion.instance();
	mouse_motion->set_device(0);
	mouse_motion->set_position(Vector2(pos.X, pos.Y));
	mouse_motion->set_global_position(Vector2(pos.X, pos.Y));
	mouse_motion->set_relative(Vector2(args->MouseDelta.X, args->MouseDelta.Y));

	last_mouse_pos = pos;

	os->input_event(mouse_motion);
}

void App::key_event(Windows::UI::Core::CoreWindow ^ sender, bool p_pressed, Windows::UI::Core::KeyEventArgs ^ key_args, Windows::UI::Core::CharacterReceivedEventArgs ^ char_args) {

	OSUWP::KeyEvent ke;

	ke.control = sender->GetAsyncKeyState(VirtualKey::Control) == CoreVirtualKeyStates::Down;
	ke.alt = sender->GetAsyncKeyState(VirtualKey::Menu) == CoreVirtualKeyStates::Down;
	ke.shift = sender->GetAsyncKeyState(VirtualKey::Shift) == CoreVirtualKeyStates::Down;

	ke.pressed = p_pressed;

	if (key_args != nullptr) {

		ke.type = OSUWP::KeyEvent::MessageType::KEY_EVENT_MESSAGE;
		ke.unicode = 0;
		ke.scancode = KeyMappingWindows::get_keysym((unsigned int)key_args->VirtualKey);
		ke.echo = (!p_pressed && !key_args->KeyStatus.IsKeyReleased) || (p_pressed && key_args->KeyStatus.WasKeyDown);

	} else {

		ke.type = OSUWP::KeyEvent::MessageType::CHAR_EVENT_MESSAGE;
		ke.unicode = char_args->KeyCode;
		ke.scancode = 0;
		ke.echo = (!p_pressed && !char_args->KeyStatus.IsKeyReleased) || (p_pressed && char_args->KeyStatus.WasKeyDown);
	}

	os->queue_key_event(ke);
}
void App::OnKeyDown(CoreWindow ^ sender, KeyEventArgs ^ args) {
	key_event(sender, true, args);
}

void App::OnKeyUp(CoreWindow ^ sender, KeyEventArgs ^ args) {
	key_event(sender, false, args);
}

void App::OnCharacterReceived(CoreWindow ^ sender, CharacterReceivedEventArgs ^ args) {
	key_event(sender, true, nullptr, args);
}

// Initializes scene resources
void App::Load(Platform::String ^ entryPoint) {
}

// This method is called after the window becomes active.
void App::Run() {
	if (Main::start())
		os->run();
}

// Terminate events do not cause Uninitialize to be called. It will be called if your IFrameworkView
// class is torn down while the app is in the foreground.
void App::Uninitialize() {
	Main::cleanup();
	delete os;
}

// Application lifecycle event handler.
void App::OnActivated(CoreApplicationView ^ applicationView, IActivatedEventArgs ^ args) {
	// Run() won't start until the CoreWindow is activated.
	CoreWindow::GetForCurrentThread()->Activate();
}

// Window event handlers.
void App::OnVisibilityChanged(CoreWindow ^ sender, VisibilityChangedEventArgs ^ args) {
	mWindowVisible = args->Visible;
}

void App::OnWindowClosed(CoreWindow ^ sender, CoreWindowEventArgs ^ args) {
	mWindowClosed = true;
}

void App::OnWindowSizeChanged(CoreWindow ^ sender, WindowSizeChangedEventArgs ^ args) {
#if (WINAPI_FAMILY == WINAPI_FAMILY_PC_APP)
	// On Windows 8.1, apps are resized when they are snapped alongside other apps, or when the device is rotated.
	// The default framebuffer will be automatically resized when either of these occur.
	// In particular, on a 90 degree rotation, the default framebuffer's width and height will switch.
	UpdateWindowSize(args->Size);
#else if (WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP)
	// On Windows Phone 8.1, the window size changes when the device is rotated.
	// The default framebuffer will not be automatically resized when this occurs.
	// It is therefore up to the app to handle rotation-specific logic in its rendering code.
	//os->screen_size_changed();
	UpdateWindowSize(args->Size);
#endif
}

void App::UpdateWindowSize(Size size) {
	float dpi;
#if (WINAPI_FAMILY == WINAPI_FAMILY_PC_APP)
	DisplayInformation ^ currentDisplayInformation = DisplayInformation::GetForCurrentView();
	dpi = currentDisplayInformation->LogicalDpi;
#else if (WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP)
	dpi = DisplayProperties::LogicalDpi;
#endif
	Size pixelSize(ConvertDipsToPixels(size.Width, dpi), ConvertDipsToPixels(size.Height, dpi));

	mWindowWidth = static_cast<GLsizei>(pixelSize.Width);
	mWindowHeight = static_cast<GLsizei>(pixelSize.Height);

	OS::VideoMode vm;
	vm.width = mWindowWidth;
	vm.height = mWindowHeight;
	vm.fullscreen = true;
	vm.resizable = false;
	os->set_video_mode(vm);
}

char **App::get_command_line(unsigned int *out_argc) {

	static char *fail_cl[] = { "--path", "game", NULL };
	*out_argc = 2;

	FILE *f = _wfopen(L"__cl__.cl", L"rb");

	if (f == NULL) {

		wprintf(L"Couldn't open command line file.");
		return fail_cl;
	}

#define READ_LE_4(v) ((int)(##v[3] & 0xFF) << 24) | ((int)(##v[2] & 0xFF) << 16) | ((int)(##v[1] & 0xFF) << 8) | ((int)(##v[0] & 0xFF))
#define CMD_MAX_LEN 65535

	uint8_t len[4];
	int r = fread(len, sizeof(uint8_t), 4, f);

	Platform::Collections::Vector<Platform::String ^> cl;

	if (r < 4) {
		fclose(f);
		wprintf(L"Wrong cmdline length.");
		return (fail_cl);
	}

	int argc = READ_LE_4(len);

	for (int i = 0; i < argc; i++) {

		r = fread(len, sizeof(uint8_t), 4, f);

		if (r < 4) {
			fclose(f);
			wprintf(L"Wrong cmdline param length.");
			return (fail_cl);
		}

		int strlen = READ_LE_4(len);

		if (strlen > CMD_MAX_LEN) {
			fclose(f);
			wprintf(L"Wrong command length.");
			return (fail_cl);
		}

		char *arg = new char[strlen + 1];
		r = fread(arg, sizeof(char), strlen, f);
		arg[strlen] = '\0';

		if (r == strlen) {

			int warg_size = MultiByteToWideChar(CP_UTF8, 0, arg, -1, NULL, 0);
			wchar_t *warg = new wchar_t[warg_size];

			MultiByteToWideChar(CP_UTF8, 0, arg, -1, warg, warg_size);

			cl.Append(ref new Platform::String(warg, warg_size));

		} else {

			delete[] arg;
			fclose(f);
			wprintf(L"Error reading command.");
			return (fail_cl);
		}
	}

#undef READ_LE_4
#undef CMD_MAX_LEN

	fclose(f);

	char **ret = new char *[cl.Size + 1];

	for (int i = 0; i < cl.Size; i++) {

		int arg_size = WideCharToMultiByte(CP_UTF8, 0, cl.GetAt(i)->Data(), -1, NULL, 0, NULL, NULL);
		char *arg = new char[arg_size];

		WideCharToMultiByte(CP_UTF8, 0, cl.GetAt(i)->Data(), -1, arg, arg_size, NULL, NULL);

		ret[i] = arg;
	}
	ret[cl.Size] = NULL;
	*out_argc = cl.Size;

	return ret;
}