1 files changed, 385 insertions, 385 deletions
diff --git a/platform/winrt/app.cpp b/platform/winrt/app.cpp
index 662229b04e..263cd684c4 100644
--- a/platform/winrt/app.cpp
+++ b/platform/winrt/app.cpp
@@ -1,385 +1,385 @@
-//
-// This file demonstrates how to initialize EGL in a Windows Store app, using ICoreWindow.
-//
-
-#include "app.h"
-
-#include "main/main.h"
-#include "core/os/dir_access.h"
-#include "core/os/file_access.h"
-
-using namespace Windows::ApplicationModel::Core;
-using namespace Windows::ApplicationModel::Activation;
-using namespace Windows::UI::Core;
-using namespace Windows::UI::Input;
-using namespace Windows::Foundation;
-using namespace Windows::Graphics::Display;
-using namespace Microsoft::WRL;
-using namespace Platform;
-
-using namespace $ext_safeprojectname$;
-
-// 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 HelloTriangleApplicationSource 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 helloTriangleApplicationSource = ref new HelloTriangleApplicationSource();
-    CoreApplication::Run(helloTriangleApplicationSource);
-    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 OSWinrt;
-}
-
-// 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);
-
-
-
-	char* args[] = {"-path", "game", NULL};
-	Main::setup("winrt", 2, args, 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) {
-
-	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)) {
-
-		InputEvent event;
-		event.type = InputEvent::SCREEN_TOUCH;
-		event.device = 0;
-		event.screen_touch.pressed = p_pressed;
-		event.screen_touch.x = pos.X;
-		event.screen_touch.y = pos.Y;
-		event.screen_touch.index = _get_finger(point->PointerId);
-
-		last_touch_x[event.screen_touch.index] = pos.X;
-		last_touch_y[event.screen_touch.index] = pos.Y;
-
-		os->input_event(event);
-		if (event.screen_touch.index != 0)
-			return;
-
-	}; // fallthrought of sorts
-
-	InputEvent event;
-	event.type = InputEvent::MOUSE_BUTTON;
-	event.device = 0;
-	event.mouse_button.pressed = p_pressed;
-	event.mouse_button.button_index = but;
-	event.mouse_button.x = pos.X;
-	event.mouse_button.y = pos.Y;
-	event.mouse_button.global_x = pos.X;
-	event.mouse_button.global_y = pos.Y;
-
-	last_touch_x[31] = pos.X;
-	last_touch_y[31] = pos.Y;
-
-	os->input_event(event);
-};
-
-
-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::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)) {
-
-		InputEvent event;
-		event.type = InputEvent::SCREEN_DRAG;
-		event.device = 0;
-		event.screen_drag.x = pos.X;
-		event.screen_drag.y = pos.Y;
-		event.screen_drag.index = _get_finger(point->PointerId);
-		event.screen_drag.relative_x = event.screen_drag.x - last_touch_x[event.screen_drag.index];
-		event.screen_drag.relative_y = event.screen_drag.y - last_touch_y[event.screen_drag.index];
-
-		os->input_event(event);
-		if (event.screen_drag.index != 0)
-			return;
-
-	}; // fallthrought of sorts
-
-	InputEvent event;
-	event.type = InputEvent::MOUSE_MOTION;
-	event.device = 0;
-	event.mouse_motion.x = pos.X;
-	event.mouse_motion.y = pos.Y;
-	event.mouse_motion.global_x = pos.X;
-	event.mouse_motion.global_y = pos.Y;
-	event.mouse_motion.relative_x = pos.X - last_touch_x[31];
-	event.mouse_motion.relative_y = pos.Y - last_touch_y[31];
-
-	os->input_event(event);
-
-};
-
-
-// Initializes scene resources
-void App::Load(Platform::String^ entryPoint)
-{
-	//char* args[] = {"-test", "render", NULL};
-	//Main::setup("winrt", 2, args);
-}
-
-// 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);
-}
+//
+// This file demonstrates how to initialize EGL in a Windows Store app, using ICoreWindow.
+//
+
+#include "app.h"
+
+#include "main/main.h"
+#include "core/os/dir_access.h"
+#include "core/os/file_access.h"
+
+using namespace Windows::ApplicationModel::Core;
+using namespace Windows::ApplicationModel::Activation;
+using namespace Windows::UI::Core;
+using namespace Windows::UI::Input;
+using namespace Windows::Foundation;
+using namespace Windows::Graphics::Display;
+using namespace Microsoft::WRL;
+using namespace Platform;
+
+using namespace $ext_safeprojectname$;
+
+// 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 HelloTriangleApplicationSource 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 helloTriangleApplicationSource = ref new HelloTriangleApplicationSource();
+    CoreApplication::Run(helloTriangleApplicationSource);
+    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 OSWinrt;
+}
+
+// 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);
+
+
+
+	char* args[] = {"-path", "game", NULL};
+	Main::setup("winrt", 2, args, 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) {
+
+	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)) {
+
+		InputEvent event;
+		event.type = InputEvent::SCREEN_TOUCH;
+		event.device = 0;
+		event.screen_touch.pressed = p_pressed;
+		event.screen_touch.x = pos.X;
+		event.screen_touch.y = pos.Y;
+		event.screen_touch.index = _get_finger(point->PointerId);
+
+		last_touch_x[event.screen_touch.index] = pos.X;
+		last_touch_y[event.screen_touch.index] = pos.Y;
+
+		os->input_event(event);
+		if (event.screen_touch.index != 0)
+			return;
+
+	}; // fallthrought of sorts
+
+	InputEvent event;
+	event.type = InputEvent::MOUSE_BUTTON;
+	event.device = 0;
+	event.mouse_button.pressed = p_pressed;
+	event.mouse_button.button_index = but;
+	event.mouse_button.x = pos.X;
+	event.mouse_button.y = pos.Y;
+	event.mouse_button.global_x = pos.X;
+	event.mouse_button.global_y = pos.Y;
+
+	last_touch_x[31] = pos.X;
+	last_touch_y[31] = pos.Y;
+
+	os->input_event(event);
+};
+
+
+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::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)) {
+
+		InputEvent event;
+		event.type = InputEvent::SCREEN_DRAG;
+		event.device = 0;
+		event.screen_drag.x = pos.X;
+		event.screen_drag.y = pos.Y;
+		event.screen_drag.index = _get_finger(point->PointerId);
+		event.screen_drag.relative_x = event.screen_drag.x - last_touch_x[event.screen_drag.index];
+		event.screen_drag.relative_y = event.screen_drag.y - last_touch_y[event.screen_drag.index];
+
+		os->input_event(event);
+		if (event.screen_drag.index != 0)
+			return;
+
+	}; // fallthrought of sorts
+
+	InputEvent event;
+	event.type = InputEvent::MOUSE_MOTION;
+	event.device = 0;
+	event.mouse_motion.x = pos.X;
+	event.mouse_motion.y = pos.Y;
+	event.mouse_motion.global_x = pos.X;
+	event.mouse_motion.global_y = pos.Y;
+	event.mouse_motion.relative_x = pos.X - last_touch_x[31];
+	event.mouse_motion.relative_y = pos.Y - last_touch_y[31];
+
+	os->input_event(event);
+
+};
+
+
+// Initializes scene resources
+void App::Load(Platform::String^ entryPoint)
+{
+	//char* args[] = {"-test", "render", NULL};
+	//Main::setup("winrt", 2, args);
+}
+
+// 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);
+}