From 4b0386081037172222d91f0ccca93e5810fed84b Mon Sep 17 00:00:00 2001 From: Reece Mackie <20544390+Rover656@users.noreply.github.com> Date: Thu, 30 Apr 2020 18:48:39 +0100 Subject: [PATCH] UWP rework (#1231) * First draft of UWP rework. * Read desc - Moved UWP specific functions to uwp_events.h - Removed BaseApp. - Implemented example UWP lifecycle. * Added GIF recording and screenshot support. * Character inputs and filesystem stuff * Fix game closing on Xbox when B is pressed. * Fix the gamepad binding hack * Add as many keys as I believe are possible. * Implemented mouse locking of a sort. * Remove rogue todo, the rest are for a game dev using this example. * Implemented touch how I "think" it should work. I cant test this. * Review. --- projects/VS2017.UWP/raylib.App.UWP/App.cpp | 522 ++++++++++++++- projects/VS2017.UWP/raylib.App.UWP/App.h | 51 +- projects/VS2017.UWP/raylib.App.UWP/BaseApp.h | 570 ---------------- .../raylib.App.UWP/raylib.App.UWP.vcxproj | 9 +- .../raylib.App.UWP.vcxproj.filters | 7 +- .../VS2017.UWP/raylib.UWP/packages.config | 4 + .../VS2017.UWP/raylib.UWP/raylib.UWP.vcxproj | 15 +- .../raylib.UWP/raylib.UWP.vcxproj.filters | 4 + src/core.c | 629 +++++++++++++----- src/rlgl.h | 1 + src/utils.c | 73 -- src/utils.h | 59 -- src/uwp_events.h | 119 ++++ 13 files changed, 1162 insertions(+), 901 deletions(-) delete mode 100644 projects/VS2017.UWP/raylib.App.UWP/BaseApp.h create mode 100644 projects/VS2017.UWP/raylib.UWP/packages.config create mode 100644 src/uwp_events.h diff --git a/projects/VS2017.UWP/raylib.App.UWP/App.cpp b/projects/VS2017.UWP/raylib.App.UWP/App.cpp index ad3fdb28f..84eb99e5c 100644 --- a/projects/VS2017.UWP/raylib.App.UWP/App.cpp +++ b/projects/VS2017.UWP/raylib.App.UWP/App.cpp @@ -1,26 +1,190 @@ #include "pch.h" #include "app.h" -#include "raylib.h" +#include + +#include +#include +#include + +#include +#include + +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::Foundation; +using namespace Windows::Foundation::Collections; +using namespace Windows::Gaming::Input; +using namespace Windows::Graphics::Display; +using namespace Microsoft::WRL; +using namespace Platform; using namespace raylibUWP; +// Stand-ins for "core.c" variables +#define MAX_GAMEPADS 4 // Max number of gamepads supported +#define MAX_GAMEPAD_BUTTONS 32 // Max bumber of buttons supported (per gamepad) +#define MAX_GAMEPAD_AXIS 8 // Max number of axis supported (per gamepad) + // The main function creates an IFrameworkViewSource for our app, and runs the app [Platform::MTAThread] int main(Platform::Array^) { - auto appSource = ref new ApplicationSource(); + auto appSource = ref new AppSource(); CoreApplication::Run(appSource); - return 0; } +// App implementation App::App() { - // This does not work... need to fix this. + // Currently, UWP ignores flags... You must implement flag functionality yourself SetConfigFlags(0); +} - Setup(640, 480); +void App::Initialize(Windows::ApplicationModel::Core::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(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 + + CoreApplication::Suspending += ref new Windows::Foundation::EventHandler(this, &App::OnSuspending); + CoreApplication::Resuming += ref new EventHandler(this, &App::OnResuming); + + // Store the app data directory + auto dataPath = Windows::Storage::ApplicationData::Current->LocalFolder->Path; + std::wstring dataPathW(dataPath->Begin()); + static std::string dataPathA(dataPathW.begin(), dataPathW.end()); + UWPSetDataPath(dataPathA.c_str()); +} + +void App::SetWindow(Windows::UI::Core::CoreWindow^ window) +{ + // Hook window events + window->SizeChanged += ref new TypedEventHandler(this, &App::OnWindowSizeChanged); + window->VisibilityChanged += ref new TypedEventHandler(this, &App::OnVisibilityChanged); + + // Hook mouse pointer events + window->PointerPressed += ref new TypedEventHandler(this, &App::OnPointerPressed); + window->PointerReleased += ref new Windows::Foundation::TypedEventHandler(this, &App::OnPointerReleased); + window->PointerWheelChanged += ref new TypedEventHandler(this, &App::OnPointerWheelChanged); + window->PointerMoved += ref new Windows::Foundation::TypedEventHandler(this, &App::OnPointerMoved); + + // Hook keyboard events. + window->KeyDown += ref new TypedEventHandler(this, &App::OnKeyDown); + window->KeyUp += ref new TypedEventHandler(this, &App::OnKeyUp); + window->CharacterReceived += ref new Windows::Foundation::TypedEventHandler(this, &raylibUWP::App::OnCharacterReceived); + + // The CoreWindow has been created, we can pass this to raylib for EGL context creation when it's time + UWPSetCoreWindowPtr((void*)window); + + // Register backrequested event to stop window from being closed (Most noticable on XBox when B is pressed) + auto navigation = SystemNavigationManager::GetForCurrentView(); + navigation->BackRequested += ref new Windows::Foundation::EventHandler(this, &raylibUWP::App::OnBackRequested); +} + +void App::Load(Platform::String ^entryPoint) {} // Ignored for this example + +static bool mouseLocked = false; +void App::Run() +{ + // Set up our UWP implementation + UWPSetQueryTimeFunc([]() + { + static auto timeStart = std::chrono::high_resolution_clock::now(); + auto delta = std::chrono::high_resolution_clock::now() - timeStart; + return (double)std::chrono::duration_cast(delta).count(); + }); + + UWPSetSleepFunc([](double seconds) { std::this_thread::sleep_for(std::chrono::duration(seconds)); }); + + UWPSetDisplaySizeFunc([](int* width, int* height) + { + // Get display dimensions + DisplayInformation^ dInfo = DisplayInformation::GetForCurrentView(); + *width = dInfo->ScreenWidthInRawPixels; + *height = dInfo->ScreenHeightInRawPixels; + }); + + UWPSetMouseHideFunc([]() + { + CoreWindow::GetForCurrentThread()->PointerCursor = nullptr; + }); + + UWPSetMouseShowFunc([]() + { + CoreWindow::GetForCurrentThread()->PointerCursor = ref new CoreCursor(CoreCursorType::Arrow, 0); + }); + + UWPSetMouseLockFunc([]() + { + CoreWindow::GetForCurrentThread()->PointerCursor = nullptr; + mouseLocked = true; + }); + + UWPSetMouseUnlockFunc([]() + { + CoreWindow::GetForCurrentThread()->PointerCursor = ref new CoreCursor(CoreCursorType::Arrow, 0); + mouseLocked = false; + }); + + UWPSetMouseSetPosFunc([](int x, int y) + { + CoreWindow^ window = CoreWindow::GetForCurrentThread(); + Point mousePosScreen = Point(x + window->Bounds.X, y + window->Bounds.Y); + window->PointerPosition = mousePosScreen; + }); + + // Set custom output handle + SetTraceLogCallback([](int logType, const char* text, va_list args) + { + std::string format = text; + + switch (logType) + { + case LOG_TRACE: format = std::string("TRACE: ") + format; break; + case LOG_DEBUG: format = std::string("DEBUG: ") + format; break; + case LOG_INFO: format = std::string("INFO: ") + format; break; + case LOG_WARNING: format = std::string("WARNING: ") + format; break; + case LOG_ERROR: format = std::string("ERROR: ") + format; break; + case LOG_FATAL: format = std::string("FATAL: ") + format; break; + default: break; + } + + char buf[1024]; // TODO: Is this large enough? + vsnprintf(buf, sizeof(buf), format.c_str(), args); + std::string output = std::string(buf) + std::string("\n"); + OutputDebugStringA(output.c_str()); + }); + + // Create window + InitWindow(640, 480, "raylib game example"); + + // Run game loop + while (!WindowShouldClose() && !mSuspended) + { + if (mWindowVisible) + { + PreProcessInputs(); + GameLoop(); + PostProcessInputs(); + CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent); + } else CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessOneAndAllPending); + } + + CloseWindow(); +} + +void App::Uninitialize() +{ + // Do any UWP cleanup here. } static int posX = 100; @@ -28,7 +192,7 @@ static int posY = 100; static int gTime = 0; // This method is called every frame -void App::Update() +void App::GameLoop() { // Update //---------------------------------------------------------------------------------- @@ -76,4 +240,348 @@ void App::Update() EndDrawing(); //---------------------------------------------------------------------------------- -} \ No newline at end of file +} + +struct GamepadBinding +{ + Gamepad^ Gamepad = nullptr; + bool Ready = false; +}; + +static GamepadBinding gGamepadBindings[MAX_GAMEPADS]; + +void App::PreProcessInputs() +{ + // Here, we will see if we have bound gamepads. If we do we check they are still present. If they aren't present we free the binding. + // if anyone does not have a binding but there is a gamepad available, we will bind it to the first player who is missing a controller. + for (auto i = 0; i < MAX_GAMEPADS; i++) + { + // Ensure that the gamepad bindings are still in tact + if (gGamepadBindings[i].Gamepad != nullptr) + { + // Check the gamepad is present + auto found = false; + for (auto j = 0; j < Gamepad::Gamepads->Size; j++) + { + if (gGamepadBindings[i].Gamepad == Gamepad::Gamepads->GetAt(j)) + { + found = true; + break; + } + } + + if (!found) + { + gGamepadBindings[i].Gamepad = nullptr; + gGamepadBindings[i].Ready = false; + } + else gGamepadBindings[i].Ready = true; + } + + // Now we check to find any unbound gamepads we can use + if (gGamepadBindings[i].Gamepad == nullptr) + { + // Loop over all the attached gamepads + Gamepad^ freeGamepad = nullptr; + for (auto j = 0; j < Gamepad::Gamepads->Size; j++) + { + freeGamepad = Gamepad::Gamepads->GetAt(j); + // Loop over existing bindings + for (auto k = 0; k < MAX_GAMEPADS; k++) + { + if (gGamepadBindings[k].Gamepad == freeGamepad) + freeGamepad = nullptr; + } + + // If we passed all 4, this is a free gamepad + if (freeGamepad != nullptr) break; + } + + if (freeGamepad != nullptr) + { + gGamepadBindings[i].Gamepad = freeGamepad; + gGamepadBindings[i].Ready = true; + } + else gGamepadBindings[i].Ready = false; + } + } + + // Send the active gamepads to raylib + for (int i = 0; i < MAX_GAMEPADS; i++) + { + UWPActivateGamepadEvent(i, gGamepadBindings[i].Ready); + } + + // Get current gamepad state + for (int i = 0; i < MAX_GAMEPADS; i++) + { + if (gGamepadBindings[i].Ready) + { + // Get current gamepad state + auto gamepad = gGamepadBindings[i].Gamepad; + auto reading = gamepad->GetCurrentReading(); + + // Register all button presses + UWPRegisterGamepadButton(i, GAMEPAD_BUTTON_RIGHT_FACE_DOWN, ((reading.Buttons & GamepadButtons::A) == GamepadButtons::A)); + UWPRegisterGamepadButton(i, GAMEPAD_BUTTON_RIGHT_FACE_RIGHT, ((reading.Buttons & GamepadButtons::B) == GamepadButtons::B)); + UWPRegisterGamepadButton(i, GAMEPAD_BUTTON_RIGHT_FACE_LEFT, ((reading.Buttons & GamepadButtons::X) == GamepadButtons::X)); + UWPRegisterGamepadButton(i, GAMEPAD_BUTTON_RIGHT_FACE_UP, ((reading.Buttons & GamepadButtons::Y) == GamepadButtons::Y)); + + UWPRegisterGamepadButton(i, GAMEPAD_BUTTON_LEFT_TRIGGER_1, ((reading.Buttons & GamepadButtons::LeftShoulder) == GamepadButtons::LeftShoulder)); + UWPRegisterGamepadButton(i, GAMEPAD_BUTTON_RIGHT_TRIGGER_1, ((reading.Buttons & GamepadButtons::RightShoulder) == GamepadButtons::RightShoulder)); + + UWPRegisterGamepadButton(i, GAMEPAD_BUTTON_MIDDLE_LEFT, ((reading.Buttons & GamepadButtons::View) == GamepadButtons::View)); // Changed for XB1 Controller + UWPRegisterGamepadButton(i, GAMEPAD_BUTTON_MIDDLE_RIGHT, ((reading.Buttons & GamepadButtons::Menu) == GamepadButtons::Menu)); // Changed for XB1 Controller + + UWPRegisterGamepadButton(i, GAMEPAD_BUTTON_LEFT_FACE_UP, ((reading.Buttons & GamepadButtons::DPadUp) == GamepadButtons::DPadUp)); + UWPRegisterGamepadButton(i, GAMEPAD_BUTTON_LEFT_FACE_RIGHT, ((reading.Buttons & GamepadButtons::DPadRight) == GamepadButtons::DPadRight)); + UWPRegisterGamepadButton(i, GAMEPAD_BUTTON_LEFT_FACE_DOWN, ((reading.Buttons & GamepadButtons::DPadDown) == GamepadButtons::DPadDown)); + UWPRegisterGamepadButton(i, GAMEPAD_BUTTON_LEFT_FACE_LEFT, ((reading.Buttons & GamepadButtons::DPadLeft) == GamepadButtons::DPadLeft)); + UWPRegisterGamepadButton(i, GAMEPAD_BUTTON_MIDDLE, false); // Home button not supported by UWP + + // Register buttons for 2nd triggers (because UWP doesn't count these as buttons but rather axis) + UWPRegisterGamepadButton(i, GAMEPAD_BUTTON_LEFT_TRIGGER_2, (bool)(reading.LeftTrigger > 0.1)); + UWPRegisterGamepadButton(i, GAMEPAD_BUTTON_RIGHT_TRIGGER_2, (bool)(reading.RightTrigger > 0.1)); + + // Get current axis state + UWPRegisterGamepadAxis(i, GAMEPAD_AXIS_LEFT_X, (float)reading.LeftThumbstickX); + UWPRegisterGamepadAxis(i, GAMEPAD_AXIS_LEFT_Y, (float)reading.LeftThumbstickY); + UWPRegisterGamepadAxis(i, GAMEPAD_AXIS_RIGHT_X, (float)reading.RightThumbstickX); + UWPRegisterGamepadAxis(i, GAMEPAD_AXIS_RIGHT_Y, (float)reading.RightThumbstickY); + UWPRegisterGamepadAxis(i, GAMEPAD_AXIS_LEFT_TRIGGER, (float)reading.LeftTrigger); + UWPRegisterGamepadAxis(i, GAMEPAD_AXIS_RIGHT_TRIGGER, (float)reading.RightTrigger); + } + } +} + +void App::PostProcessInputs() +{ + /* + * So here's the deal. UWP doesn't officially have mouse locking, so we're doing it ourselves here. + * If anyone has any better ideas on how to implement this feel free! + * This is done after the game loop so getting mouse delta etc. still works. + */ + if (mouseLocked) + { + auto w = GetScreenWidth(); + auto h = GetScreenHeight(); + SetMousePosition(w / 2, h / 2); + } +} + +// Events +void App::OnActivated(Windows::ApplicationModel::Core::CoreApplicationView^ applicationView, Windows::ApplicationModel::Activation::IActivatedEventArgs^ args) +{ + // Run() won't start until the CoreWindow is activated. + CoreWindow::GetForCurrentThread()->Activate(); +} + +void App::OnResuming(Platform::Object^ sender, Platform::Object^ args) +{ + // TODO: In your game, you will need to load your state here + mSuspended = false; +} + +void App::OnSuspending(Platform::Object^ sender, Windows::ApplicationModel::SuspendingEventArgs^ args) +{ + // TODO: In your game, you will need to save your state here + mSuspended = true; +} + +void App::OnWindowSizeChanged(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::WindowSizeChangedEventArgs^ args) +{ + UWPResizeEvent(args->Size.Width, args->Size.Height); + args->Handled = true; +} + +void App::OnVisibilityChanged(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::VisibilityChangedEventArgs^ args) +{ + mWindowVisible = args->Visible; + args->Handled = true; +} + +// Input event handlers +void App::OnPointerPressed(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args) +{ + auto props = args->CurrentPoint->Properties; + auto device = args->CurrentPoint->PointerDevice; + + if (device->PointerDeviceType == Windows::Devices::Input::PointerDeviceType::Mouse) + { + if (props->IsLeftButtonPressed) UWPMouseButtonEvent(MOUSE_LEFT_BUTTON, true); + if (props->IsMiddleButtonPressed) UWPMouseButtonEvent(MOUSE_MIDDLE_BUTTON, true); + if (props->IsRightButtonPressed) UWPMouseButtonEvent(MOUSE_RIGHT_BUTTON, true); + } + else if (device->PointerDeviceType == PointerDeviceType::Touch) + { + auto pos = args->CurrentPoint->Position; + UWPGestureTouch(args->CurrentPoint->PointerId, pos.X, pos.Y, true); + } + + args->Handled = true; +} + +void App::OnPointerReleased(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args) +{ + auto props = args->CurrentPoint->Properties; + auto device = args->CurrentPoint->PointerDevice; + + if (device->PointerDeviceType == PointerDeviceType::Mouse) + { + if (!props->IsLeftButtonPressed) UWPMouseButtonEvent(MOUSE_LEFT_BUTTON, false); + if (!props->IsMiddleButtonPressed) UWPMouseButtonEvent(MOUSE_MIDDLE_BUTTON, false); + if (!props->IsRightButtonPressed) UWPMouseButtonEvent(MOUSE_RIGHT_BUTTON, false); + } + else if (device->PointerDeviceType == PointerDeviceType::Touch) + { + auto pos = args->CurrentPoint->Position; + UWPGestureTouch(args->CurrentPoint->PointerId, pos.X, pos.Y, false); + } + + args->Handled = true; +} + +void App::OnPointerWheelChanged(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args) +{ + UWPMouseWheelEvent(args->CurrentPoint->Properties->MouseWheelDelta); + args->Handled = true; +} + +void App::OnPointerMoved(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args) +{ + auto pos = args->CurrentPoint->Position; + if (args->CurrentPoint->PointerDevice->PointerDeviceType == PointerDeviceType::Mouse) + { + UWPMousePosEvent((double)pos.X, (double)pos.Y); + args->Handled = true; + } + else if (args->CurrentPoint->PointerDevice->PointerDeviceType == PointerDeviceType::Touch) + { + UWPGestureMove(args->CurrentPoint->PointerId, pos.X, pos.Y); + } +} + +int App::GetRaylibKey(Windows::System::VirtualKey kVey) +{ + using VK = Windows::System::VirtualKey; + int actualKey = -1; + switch (kVey) + { + case VK::Back: actualKey = KEY_BACKSPACE; break; + case VK::Space: actualKey = KEY_SPACE; break; + case VK::Escape: actualKey = KEY_ESCAPE; break; + case VK::Enter: actualKey = KEY_ENTER; break; + case VK::Delete: actualKey = KEY_DELETE; break; + case VK::Right: actualKey = KEY_RIGHT; break; + case VK::Left: actualKey = KEY_LEFT; break; + case VK::Down: actualKey = KEY_DOWN; break; + case VK::Up: actualKey = KEY_UP; break; + case VK::F1: actualKey = KEY_F1; break; + case VK::F2: actualKey = KEY_F2; break; + case VK::F3: actualKey = KEY_F3; break; + case VK::F4: actualKey = KEY_F4; break; + case VK::F5: actualKey = KEY_F5; break; + case VK::F6: actualKey = KEY_F6; break; + case VK::F7: actualKey = KEY_F7; break; + case VK::F8: actualKey = KEY_F8; break; + case VK::F9: actualKey = KEY_F9; break; + case VK::F10: actualKey = KEY_F10; break; + case VK::F11: actualKey = KEY_F11; break; + case VK::F12: actualKey = KEY_F12; break; + case VK::LeftShift: actualKey = KEY_LEFT_SHIFT; break; + case VK::LeftControl: actualKey = KEY_LEFT_CONTROL; break; + case VK::LeftMenu: actualKey = KEY_LEFT_ALT; break; + case VK::RightShift: actualKey = KEY_RIGHT_SHIFT; break; + case VK::RightControl: actualKey = KEY_RIGHT_CONTROL; break; + case VK::RightMenu: actualKey = KEY_RIGHT_ALT; break; + case VK::Number0: actualKey = KEY_ZERO; break; + case VK::Number1: actualKey = KEY_ONE; break; + case VK::Number2: actualKey = KEY_TWO; break; + case VK::Number3: actualKey = KEY_THREE; break; + case VK::Number4: actualKey = KEY_FOUR; break; + case VK::Number5: actualKey = KEY_FIVE; break; + case VK::Number6: actualKey = KEY_SIX; break; + case VK::Number7: actualKey = KEY_SEVEN; break; + case VK::Number8: actualKey = KEY_EIGHT; break; + case VK::Number9: actualKey = KEY_NINE; break; + case VK::NumberPad0: actualKey = KEY_KP_0; break; + case VK::NumberPad1: actualKey = KEY_KP_1; break; + case VK::NumberPad2: actualKey = KEY_KP_2; break; + case VK::NumberPad3: actualKey = KEY_KP_3; break; + case VK::NumberPad4: actualKey = KEY_KP_4; break; + case VK::NumberPad5: actualKey = KEY_KP_5; break; + case VK::NumberPad6: actualKey = KEY_KP_6; break; + case VK::NumberPad7: actualKey = KEY_KP_7; break; + case VK::NumberPad8: actualKey = KEY_KP_8; break; + case VK::NumberPad9: actualKey = KEY_KP_9; break; + case VK::Decimal: actualKey = KEY_KP_DECIMAL; break; + case VK::Divide: actualKey = KEY_KP_DIVIDE; break; + case VK::Multiply: actualKey = KEY_KP_MULTIPLY; break; + case VK::Subtract: actualKey = KEY_KP_SUBTRACT; break; + case VK::Add: actualKey = KEY_KP_ADD; break; + // UWP Doesn't have a specific keypad enter or equal... + case VK::A: actualKey = KEY_A; break; + case VK::B: actualKey = KEY_B; break; + case VK::C: actualKey = KEY_C; break; + case VK::D: actualKey = KEY_D; break; + case VK::E: actualKey = KEY_E; break; + case VK::F: actualKey = KEY_F; break; + case VK::G: actualKey = KEY_G; break; + case VK::H: actualKey = KEY_H; break; + case VK::I: actualKey = KEY_I; break; + case VK::J: actualKey = KEY_J; break; + case VK::K: actualKey = KEY_K; break; + case VK::L: actualKey = KEY_L; break; + case VK::M: actualKey = KEY_M; break; + case VK::N: actualKey = KEY_N; break; + case VK::O: actualKey = KEY_O; break; + case VK::P: actualKey = KEY_P; break; + case VK::Q: actualKey = KEY_Q; break; + case VK::R: actualKey = KEY_R; break; + case VK::S: actualKey = KEY_S; break; + case VK::T: actualKey = KEY_T; break; + case VK::U: actualKey = KEY_U; break; + case VK::V: actualKey = KEY_V; break; + case VK::W: actualKey = KEY_W; break; + case VK::X: actualKey = KEY_X; break; + case VK::Y: actualKey = KEY_Y; break; + case VK::Z: actualKey = KEY_Z; break; + // I don't think we can have any more + } + return actualKey; +} + +void App::OnKeyDown(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::KeyEventArgs^ args) +{ + auto k = GetRaylibKey(args->VirtualKey); + auto controlState = (sender->GetKeyState(Windows::System::VirtualKey::Control) & Windows::UI::Core::CoreVirtualKeyStates::Down) == Windows::UI::Core::CoreVirtualKeyStates::Down; + if (k != -1) { + UWPKeyDownEvent(k, true, controlState); + } + args->Handled = true; +} + +void App::OnKeyUp(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::KeyEventArgs^ args) +{ + auto k = GetRaylibKey(args->VirtualKey); + if (k != -1) + UWPKeyDownEvent(k, false, false); + args->Handled = true; +} + +void App::OnCharacterReceived(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::CharacterReceivedEventArgs^ args) +{ + UWPKeyCharEvent(args->KeyCode); +} + +void App::OnBackRequested(Platform::Object^ sender, Windows::UI::Core::BackRequestedEventArgs^ args) +{ + // This simply stops the program from closing. + args->Handled = true; +} + +// AppSource implementation +Windows::ApplicationModel::Core::IFrameworkView ^AppSource::CreateView() +{ + return ref new App(); +} diff --git a/projects/VS2017.UWP/raylib.App.UWP/App.h b/projects/VS2017.UWP/raylib.App.UWP/App.h index 7b96d16e0..6cbeadac7 100644 --- a/projects/VS2017.UWP/raylib.App.UWP/App.h +++ b/projects/VS2017.UWP/raylib.App.UWP/App.h @@ -4,22 +4,49 @@ #include "pch.h" -// Define what header we use for BaseApp.h -#define PCH "pch.h" - -// Enable hold hack -#define HOLDHACK - -#include "BaseApp.h" - namespace raylibUWP { - ref class App sealed : public BaseApp + ref class App sealed : public Windows::ApplicationModel::Core::IFrameworkView { - public: + public: + App(); - App(); + // IFrameworkView methods. + void Initialize(Windows::ApplicationModel::Core::CoreApplicationView^ applicationView) override; + void SetWindow(Windows::UI::Core::CoreWindow^ window) override; + void Load(Platform::String^ entryPoint) override; + void Run() override; + void Uninitialize() override; + private: + bool mWindowVisible = true; + bool mSuspended = false; - void Update() override; + void GameLoop(); + void PreProcessInputs(); + void PostProcessInputs(); + + // Helpers + int GetRaylibKey(Windows::System::VirtualKey kVey); + + // Events + void OnActivated(Windows::ApplicationModel::Core::CoreApplicationView^ applicationView, Windows::ApplicationModel::Activation::IActivatedEventArgs^ args); + void OnSuspending(Platform::Object^ sender, Windows::ApplicationModel::SuspendingEventArgs^ args); + void OnResuming(Platform::Object^ sender, Platform::Object^ args); + void OnWindowSizeChanged(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::WindowSizeChangedEventArgs^ args); + void OnVisibilityChanged(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::VisibilityChangedEventArgs^ args); + void OnPointerPressed(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args); + void OnPointerReleased(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args); + void OnPointerWheelChanged(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args); + void OnPointerMoved(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args); + void OnKeyDown(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::KeyEventArgs^ args); + void OnKeyUp(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::KeyEventArgs^ args); + void OnCharacterReceived(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::CharacterReceivedEventArgs^ args); + void OnBackRequested(Platform::Object^ sender, Windows::UI::Core::BackRequestedEventArgs^ args); + }; + + ref class AppSource sealed : Windows::ApplicationModel::Core::IFrameworkViewSource + { + public: + Windows::ApplicationModel::Core::IFrameworkView^ CreateView() override; }; } diff --git a/projects/VS2017.UWP/raylib.App.UWP/BaseApp.h b/projects/VS2017.UWP/raylib.App.UWP/BaseApp.h deleted file mode 100644 index 87b952e51..000000000 --- a/projects/VS2017.UWP/raylib.App.UWP/BaseApp.h +++ /dev/null @@ -1,570 +0,0 @@ -/********************************************************************************************** -* -* raylib.BaseApp - UWP App generic code for managing interface between C and C++ -* -* LICENSE: zlib/libpng -* -* CONFIGURATION: -* -* #define PCH -* This defines what header is the PCH and needs to be included -* -* #define HOLDHACK -* This enables a hack to fix flickering key presses (Temporary) -* -* Copyright (c) 2013-2020 Ramon Santamaria (@raysan5) -* -* This software is provided "as-is", without any express or implied warranty. In no event -* will the authors be held liable for any damages arising from the use of this software. -* -* Permission is granted to anyone to use this software for any purpose, including commercial -* applications, and to alter it and redistribute it freely, subject to the following restrictions: -* -* 1. The origin of this software must not be misrepresented; you must not claim that you -* wrote the original software. If you use this software in a product, an acknowledgment -* in the product documentation would be appreciated but is not required. -* -* 2. Altered source versions must be plainly marked as such, and must not be misrepresented -* as being the original software. -* -* 3. This notice may not be removed or altered from any source distribution. -* -**********************************************************************************************/ - -#pragma once - -#if defined(PCH) -#include PCH -#endif - -#include -#include -#include - -//EGL -#include - -#include "raylib.h" -#include "utils.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::Foundation; -using namespace Windows::Foundation::Collections; -using namespace Windows::Gaming::Input; -using namespace Windows::Graphics::Display; -using namespace Microsoft::WRL; -using namespace Platform; - -extern "C" { EGLNativeWindowType handle; }; - -/* -TODO list: - - Cache reference to our CoreWindow? - - Implement gestures support -*/ - -// Stand-ins for "core.c" variables -#define MAX_GAMEPADS 4 // Max number of gamepads supported -#define MAX_GAMEPAD_BUTTONS 32 // Max bumber of buttons supported (per gamepad) -#define MAX_GAMEPAD_AXIS 8 // Max number of axis supported (per gamepad) - -//Mouse cursor locking -bool cursorLocked = false; -Vector2 mouseDelta = {0, 0}; - -//Our mouse cursor -CoreCursor ^regularCursor = ref new CoreCursor(CoreCursorType::Arrow, 0); // The "visible arrow" cursor type - -//Base app implementation -ref class BaseApp : public Windows::ApplicationModel::Core::IFrameworkView -{ -public: - - // IFrameworkView Methods. - virtual void Initialize(Windows::ApplicationModel::Core::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(this, &BaseApp::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 - - CoreApplication::Resuming += ref new EventHandler(this, &BaseApp::OnResuming); - } - - virtual void SetWindow(Windows::UI::Core::CoreWindow^ window) - { - window->SizeChanged += ref new TypedEventHandler(this, &BaseApp::OnWindowSizeChanged); - window->VisibilityChanged += ref new TypedEventHandler(this, &BaseApp::OnVisibilityChanged); - window->Closed += ref new TypedEventHandler(this, &BaseApp::OnWindowClosed); - - window->PointerPressed += ref new TypedEventHandler(this, &BaseApp::PointerPressed); - window->PointerWheelChanged += ref new TypedEventHandler(this, &BaseApp::PointerWheelChanged); - window->KeyDown += ref new TypedEventHandler(this, &BaseApp::OnKeyDown); - window->KeyUp += ref new TypedEventHandler(this, &BaseApp::OnKeyUp); - - Windows::Devices::Input::MouseDevice::GetForCurrentView()->MouseMoved += ref new TypedEventHandler(this, &BaseApp::MouseMoved); - - DisplayInformation^ currentDisplayInformation = DisplayInformation::GetForCurrentView(); - currentDisplayInformation->DpiChanged += ref new TypedEventHandler(this, &BaseApp::OnDpiChanged); - currentDisplayInformation->OrientationChanged += ref new TypedEventHandler(this, &BaseApp::OnOrientationChanged); - - // The CoreWindow has been created, so EGL can be initialized. - - handle = (EGLNativeWindowType)window; - - InitWindow(width, height, "raylib game example"); - } - - virtual void Load(Platform::String^ entryPoint) {} - - void Setup(int width, int height) - { - // Set dimensions - this->width = width; - this->height = height; - } - - virtual void Run() - { - // Get display dimensions - DisplayInformation^ dInfo = DisplayInformation::GetForCurrentView(); - Vector2 screenSize = { dInfo->ScreenWidthInRawPixels, dInfo->ScreenHeightInRawPixels }; - - // Send display dimensions - UWPMessage *msg = CreateUWPMessage(); - msg->type = UWP_MSG_SET_DISPLAY_DIMS; - msg->paramVector0 = screenSize; - UWPSendMessage(msg); - - // Send the time to the core - using clock = std::chrono::high_resolution_clock; - auto timeStart = clock::now(); - - // Set fps if 0 - if (GetFPS() <= 0) SetTargetFPS(60); - - while (!mWindowClosed) - { - if (mWindowVisible) - { - // Send time - auto delta = clock::now() - timeStart; - - UWPMessage *timeMsg = CreateUWPMessage(); - timeMsg->type = UWP_MSG_SET_GAME_TIME; - timeMsg->paramDouble0 = std::chrono::duration_cast(delta).count(); - UWPSendMessage(timeMsg); - - // Call update function - Update(); - - PollInput(); - - CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent); - } - else - { - CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessOneAndAllPending); - } - } - - CloseWindow(); - } - - //Called every frame (Maybe add draw) - virtual void Update() {} - - virtual void Uninitialize() {} - -protected: - - // Input polling - void PollInput() - { - // Process Messages - { - // Loop over pending messages - while (UWPHasMessages()) - { - // Get the message - auto msg = UWPGetMessage(); - - // Carry out the command - switch(msg->type) - { - case UWP_MSG_SHOW_MOUSE: // Do the same thing because of how UWP works... - case UWP_MSG_UNLOCK_MOUSE: - { - CoreWindow::GetForCurrentThread()->PointerCursor = regularCursor; - cursorLocked = false; - MoveMouse(GetMousePosition()); - break; - } - case UWP_MSG_HIDE_MOUSE: // Do the same thing because of how UWP works... - case UWP_MSG_LOCK_MOUSE: - { - CoreWindow::GetForCurrentThread()->PointerCursor = nullptr; - cursorLocked = true; - break; - } - case UWP_MSG_SET_MOUSE_LOCATION: - { - MoveMouse(msg->paramVector0); - break; - } - } - - // Delete the message - DeleteUWPMessage(msg); - } - } - - // Process Keyboard - { - for (int k = 0x08; k < 0xA6; k++) { - auto state = CoreWindow::GetForCurrentThread()->GetKeyState((Windows::System::VirtualKey) k); - -#ifdef HOLDHACK - // Super hacky way of waiting three frames to see if we are ready to register the key as deregistered - // This will wait an entire 4 frames before deregistering the key, this makes sure that the key is not flickering - if (KeyboardStateHack[k] == 2) - { - if ((state & CoreVirtualKeyStates::None) == CoreVirtualKeyStates::None) - { - KeyboardStateHack[k] = 3; - } - } - else if (KeyboardStateHack[k] == 3) - { - if ((state & CoreVirtualKeyStates::None) == CoreVirtualKeyStates::None) - { - KeyboardStateHack[k] = 4; - } - } - else if (KeyboardStateHack[k] == 4) - { - if ((state & CoreVirtualKeyStates::None) == CoreVirtualKeyStates::None) - { - //Reset key... - KeyboardStateHack[k] = 0; - - //Tell core - RegisterKey(k, 0); - } - } -#endif - // Left and right alt, KeyUp and KeyDown are not called for it - // No need to hack because this is not a character - - // TODO: Maybe do all other key registrations like this, no more key events? - - if (k == 0xA4 || k == 0xA5) - { - if ((state & CoreVirtualKeyStates::Down) == CoreVirtualKeyStates::Down) - { - RegisterKey(k, 1); - } - else - { - RegisterKey(k, 0); - } - } - } - } - - // Process Mouse - { - - if (CurrentPointerID > -1) - { - auto point = PointerPoint::GetCurrentPoint(CurrentPointerID); - auto props = point->Properties; - - if (props->IsLeftButtonPressed) - { - RegisterClick(MOUSE_LEFT_BUTTON, 1); - } - else - { - RegisterClick(MOUSE_LEFT_BUTTON, 0); - } - - if (props->IsRightButtonPressed) - { - RegisterClick(MOUSE_RIGHT_BUTTON, 1); - } - else - { - RegisterClick(MOUSE_RIGHT_BUTTON, 0); - } - - if (props->IsMiddleButtonPressed) - { - RegisterClick(MOUSE_MIDDLE_BUTTON, 1); - } - else - { - RegisterClick(MOUSE_MIDDLE_BUTTON, 0); - } - } - - CoreWindow ^window = CoreWindow::GetForCurrentThread(); - - if (cursorLocked) - { - // Track cursor movement delta, recenter it on the client - auto curMousePos = GetMousePosition(); - - auto x = curMousePos.x + mouseDelta.x; - auto y = curMousePos.y + mouseDelta.y; - - UpdateMousePosition({ x, y }); - - // Why we're not using UWPSetMousePosition here... - // UWPSetMousePosition changes the "mousePosition" variable to match where the cursor actually is. - // Our cursor is locked to the middle of screen, and we don't want that reflected in "mousePosition" - Vector2 centerClient = { (float)(GetScreenWidth() / 2), (float)(GetScreenHeight() / 2) }; - window->PointerPosition = Point(centerClient.x + window->Bounds.X, centerClient.y + window->Bounds.Y); - } - else - { - // Record the cursor's position relative to the client - auto x = window->PointerPosition.X - window->Bounds.X; - auto y = window->PointerPosition.Y - window->Bounds.Y; - - UpdateMousePosition({ x, y }); - } - - mouseDelta = { 0 ,0 }; - } - - // Process Gamepads - { - // Check if gamepads are ready - for (int i = 0; i < MAX_GAMEPADS; i++) - { - // HACK: UWP keeps a contiguous list of gamepads. For the interest of time I'm just doing a 1:1 mapping of - // connected gamepads with their spot in the list, but this has serious robustness problems - // e.g. player 1, 2, and 3 are playing a game - if player2 disconnects, p3's controller would now be mapped to p2's character since p3 is now second in the list. - - UWPMessage* msg = CreateUWPMessage(); - msg->type = UWP_MSG_SET_GAMEPAD_ACTIVE; - msg->paramInt0 = i; - msg->paramBool0 = i < Gamepad::Gamepads->Size; - UWPSendMessage(msg); - } - - // Get current gamepad state - for (int i = 0; i < MAX_GAMEPADS; i++) - { - if (IsGamepadAvailable(i)) - { - // Get current gamepad state - auto gamepad = Gamepad::Gamepads->GetAt(i); - GamepadReading reading = gamepad->GetCurrentReading(); - - // NOTE: Maybe it would be wiser to redefine the gamepad button mappings in "raylib.h" for the UWP platform instead of remapping them manually - RegisterGamepadButton(i, GAMEPAD_BUTTON_RIGHT_FACE_DOWN, ((reading.Buttons & GamepadButtons::A) == GamepadButtons::A)); - RegisterGamepadButton(i, GAMEPAD_BUTTON_RIGHT_FACE_RIGHT, ((reading.Buttons & GamepadButtons::B) == GamepadButtons::B)); - RegisterGamepadButton(i, GAMEPAD_BUTTON_RIGHT_FACE_LEFT, ((reading.Buttons & GamepadButtons::X) == GamepadButtons::X)); - RegisterGamepadButton(i, GAMEPAD_BUTTON_RIGHT_FACE_UP, ((reading.Buttons & GamepadButtons::Y) == GamepadButtons::Y)); - - RegisterGamepadButton(i, GAMEPAD_BUTTON_LEFT_TRIGGER_1, ((reading.Buttons & GamepadButtons::LeftShoulder) == GamepadButtons::LeftShoulder)); - RegisterGamepadButton(i, GAMEPAD_BUTTON_RIGHT_TRIGGER_1, ((reading.Buttons & GamepadButtons::RightShoulder) == GamepadButtons::RightShoulder)); - - RegisterGamepadButton(i, GAMEPAD_BUTTON_MIDDLE_LEFT, ((reading.Buttons & GamepadButtons::View) == GamepadButtons::View)); // Changed for XB1 Controller - RegisterGamepadButton(i, GAMEPAD_BUTTON_MIDDLE_RIGHT, ((reading.Buttons & GamepadButtons::Menu) == GamepadButtons::Menu)); // Changed for XB1 Controller - - RegisterGamepadButton(i, GAMEPAD_BUTTON_LEFT_FACE_UP, ((reading.Buttons & GamepadButtons::DPadUp) == GamepadButtons::DPadUp)); - RegisterGamepadButton(i, GAMEPAD_BUTTON_LEFT_FACE_RIGHT, ((reading.Buttons & GamepadButtons::DPadRight) == GamepadButtons::DPadRight)); - RegisterGamepadButton(i, GAMEPAD_BUTTON_LEFT_FACE_DOWN, ((reading.Buttons & GamepadButtons::DPadDown) == GamepadButtons::DPadDown)); - RegisterGamepadButton(i, GAMEPAD_BUTTON_LEFT_FACE_LEFT, ((reading.Buttons & GamepadButtons::DPadLeft) == GamepadButtons::DPadLeft)); - RegisterGamepadButton(i, GAMEPAD_BUTTON_MIDDLE, false); // Home button not supported by UWP - - // Get current axis state - RegisterGamepadAxis(i, GAMEPAD_AXIS_LEFT_X, (float)reading.LeftThumbstickX); - RegisterGamepadAxis(i, GAMEPAD_AXIS_LEFT_Y, (float)reading.LeftThumbstickY); - RegisterGamepadAxis(i, GAMEPAD_AXIS_RIGHT_X, (float)reading.RightThumbstickX); - RegisterGamepadAxis(i, GAMEPAD_AXIS_RIGHT_Y, (float)reading.RightThumbstickY); - RegisterGamepadAxis(i, GAMEPAD_AXIS_LEFT_TRIGGER, (float)reading.LeftTrigger); - RegisterGamepadAxis(i, GAMEPAD_AXIS_RIGHT_TRIGGER, (float)reading.RightTrigger); - } - } - } - } - - // Application lifecycle event handlers. - void OnActivated(Windows::ApplicationModel::Core::CoreApplicationView^ applicationView, Windows::ApplicationModel::Activation::IActivatedEventArgs^ args) - { - // Run() won't start until the CoreWindow is activated. - CoreWindow::GetForCurrentThread()->Activate(); - } - - void OnResuming(Platform::Object^ sender, Platform::Object^ args) {} - - // Window event handlers. - void OnWindowSizeChanged(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::WindowSizeChangedEventArgs^ args) - { - UWPMessage* msg = CreateUWPMessage(); - msg->type = UWP_MSG_HANDLE_RESIZE; - UWPSendMessage(msg); - } - - void OnVisibilityChanged(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::VisibilityChangedEventArgs^ args) - { - mWindowVisible = args->Visible; - } - - void OnWindowClosed(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::CoreWindowEventArgs^ args) - { - mWindowClosed = true; - } - - // DisplayInformation event handlers. - void OnDpiChanged(Windows::Graphics::Display::DisplayInformation^ sender, Platform::Object^ args) {} - void OnOrientationChanged(Windows::Graphics::Display::DisplayInformation^ sender, Platform::Object^ args) {} - - // Input event handlers - void PointerPressed(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args) - { - //Get the current active pointer ID for our loop - CurrentPointerID = args->CurrentPoint->PointerId; - args->Handled = true; - } - - void PointerWheelChanged(Windows::UI::Core::CoreWindow ^sender, Windows::UI::Core::PointerEventArgs^ args) - { - UWPMessage* msg = CreateUWPMessage(); - msg->type = UWP_MSG_SCROLL_WHEEL_UPDATE; - msg->paramFloat0 = args->CurrentPoint->Properties->MouseWheelDelta; - UWPSendMessage(msg); - } - - void MouseMoved(Windows::Devices::Input::MouseDevice^ mouseDevice, Windows::Devices::Input::MouseEventArgs^ args) - { - mouseDelta.x += args->MouseDelta.X; - mouseDelta.y += args->MouseDelta.Y; - } - - void OnKeyDown(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::KeyEventArgs ^ args) - { -#ifdef HOLDHACK - // Start the hack - KeyboardStateHack[(int)args->VirtualKey] = 1; -#endif - - RegisterKey((int)args->VirtualKey, 1); - } - - void OnKeyUp(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::KeyEventArgs ^ args) - { -#ifdef HOLDHACK - // The same hack - if (KeyboardStateHack[(int)args->VirtualKey] == 1) - { - KeyboardStateHack[(int)args->VirtualKey] = 2; - } - else if (KeyboardStateHack[(int)args->VirtualKey] == 2) - { - KeyboardStateHack[(int)args->VirtualKey] = 3; - } - else if (KeyboardStateHack[(int)args->VirtualKey] == 3) - { - KeyboardStateHack[(int)args->VirtualKey] = 4; - } - else if (KeyboardStateHack[(int)args->VirtualKey] == 4) - { - RegisterKey((int)args->VirtualKey, 0); - KeyboardStateHack[(int)args->VirtualKey] = 0; - } -#else - // No hack, allow flickers - RegisterKey((int)args->VirtualKey, 0); -#endif - } - -private: - - void RegisterKey(int key, char status) - { - UWPMessage* msg = CreateUWPMessage(); - msg->type = UWPMessageType::UWP_MSG_REGISTER_KEY; - msg->paramInt0 = key; - msg->paramChar0 = status; - UWPSendMessage(msg); - } - - void MoveMouse(Vector2 pos) - { - CoreWindow ^window = CoreWindow::GetForCurrentThread(); - Point mousePosScreen = Point(pos.x + window->Bounds.X, pos.y + window->Bounds.Y); - window->PointerPosition = mousePosScreen; - } - - void RegisterGamepadButton(int gamepad, int button, char status) - { - UWPMessage* msg = CreateUWPMessage(); - msg->type = UWP_MSG_SET_GAMEPAD_BUTTON; - msg->paramInt0 = gamepad; - msg->paramInt1 = button; - msg->paramChar0 = status; - UWPSendMessage(msg); - } - - void RegisterGamepadAxis(int gamepad, int axis, float value) - { - UWPMessage* msg = CreateUWPMessage(); - msg->type = UWP_MSG_SET_GAMEPAD_AXIS; - msg->paramInt0 = gamepad; - msg->paramInt1 = axis; - msg->paramFloat0 = value; - UWPSendMessage(msg); - } - - void UpdateMousePosition(Vector2 pos) - { - UWPMessage* msg = CreateUWPMessage(); - msg->type = UWP_MSG_UPDATE_MOUSE_LOCATION; - msg->paramVector0 = pos; - UWPSendMessage(msg); - } - - void RegisterClick(int button, char status) - { - UWPMessage* msg = CreateUWPMessage(); - msg->type = UWPMessageType::UWP_MSG_REGISTER_CLICK; - msg->paramInt0 = button; - msg->paramChar0 = status; - UWPSendMessage(msg); - } - - bool mWindowClosed = false; - bool mWindowVisible = true; - - int width = 640; - int height = 480; - - int CurrentPointerID = -1; - -#ifdef HOLDHACK - char KeyboardStateHack[0xA6]; // 0xA6 because the highest key we compare against is 0xA5 -#endif -}; - -// Application source for creating the program -template -ref class ApplicationSource sealed : Windows::ApplicationModel::Core::IFrameworkViewSource -{ -public: - virtual Windows::ApplicationModel::Core::IFrameworkView^ CreateView() - { - return ref new AppType(); - } -}; \ No newline at end of file diff --git a/projects/VS2017.UWP/raylib.App.UWP/raylib.App.UWP.vcxproj b/projects/VS2017.UWP/raylib.App.UWP/raylib.App.UWP.vcxproj index f82a352d5..cddbe0dc7 100644 --- a/projects/VS2017.UWP/raylib.App.UWP/raylib.App.UWP.vcxproj +++ b/projects/VS2017.UWP/raylib.App.UWP/raylib.App.UWP.vcxproj @@ -1,4 +1,4 @@ - + @@ -33,7 +33,7 @@ 14.0 true Windows Store - 10.0.17763.0 + 10.0 10.0.17763.0 10.0 raylib.App.UWP @@ -139,7 +139,6 @@ - @@ -152,7 +151,6 @@ Designer - @@ -160,6 +158,9 @@ {ea91e088-7c71-4f32-b761-e054305cd519} + + + diff --git a/projects/VS2017.UWP/raylib.App.UWP/raylib.App.UWP.vcxproj.filters b/projects/VS2017.UWP/raylib.App.UWP/raylib.App.UWP.vcxproj.filters index 1e0fe3621..ce747ba68 100644 --- a/projects/VS2017.UWP/raylib.App.UWP/raylib.App.UWP.vcxproj.filters +++ b/projects/VS2017.UWP/raylib.App.UWP/raylib.App.UWP.vcxproj.filters @@ -6,7 +6,6 @@ - @@ -29,12 +28,12 @@ - - - {cdf72d55-f249-4ad6-9a91-f8a084e64933} + + + \ No newline at end of file diff --git a/projects/VS2017.UWP/raylib.UWP/packages.config b/projects/VS2017.UWP/raylib.UWP/packages.config new file mode 100644 index 000000000..70c3dea0e --- /dev/null +++ b/projects/VS2017.UWP/raylib.UWP/packages.config @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/projects/VS2017.UWP/raylib.UWP/raylib.UWP.vcxproj b/projects/VS2017.UWP/raylib.UWP/raylib.UWP.vcxproj index e6186bf6e..26ae61da0 100644 --- a/projects/VS2017.UWP/raylib.UWP/raylib.UWP.vcxproj +++ b/projects/VS2017.UWP/raylib.UWP/raylib.UWP.vcxproj @@ -42,6 +42,7 @@ + @@ -52,6 +53,9 @@ + + + {ea91e088-7c71-4f32-b761-e054305cd519} StaticLibrary @@ -60,7 +64,7 @@ 14.0 true Windows Store - 10.0.17763.0 + 10.0 10.0.15063.0 10.0 @@ -158,7 +162,7 @@ NotUsing false true - _CRT_SECURE_NO_WARNINGS;GRAPHICS_API_OPENGL_ES2;PLATFORM_UWP;_UNICODE;UNICODE;%(PreprocessorDefinitions) + SUPPORT_GIF_RECORDING;_CRT_SECURE_NO_WARNINGS;GRAPHICS_API_OPENGL_ES2;PLATFORM_UWP;_UNICODE;UNICODE;%(PreprocessorDefinitions) $(SolutionDir)packages\ANGLE.WindowsStore.2.1.13\Include;$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) @@ -239,5 +243,12 @@ + + + + This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}. + + + \ No newline at end of file diff --git a/projects/VS2017.UWP/raylib.UWP/raylib.UWP.vcxproj.filters b/projects/VS2017.UWP/raylib.UWP/raylib.UWP.vcxproj.filters index cbad7c9b5..8050a1ef3 100644 --- a/projects/VS2017.UWP/raylib.UWP/raylib.UWP.vcxproj.filters +++ b/projects/VS2017.UWP/raylib.UWP/raylib.UWP.vcxproj.filters @@ -16,6 +16,7 @@ + @@ -26,4 +27,7 @@ + + + \ No newline at end of file diff --git a/src/core.c b/src/core.c index d7e3a6b4a..d46c085e1 100644 --- a/src/core.c +++ b/src/core.c @@ -255,6 +255,7 @@ #include "EGL/egl.h" // Khronos EGL library - Native platform display device control functions #include "EGL/eglext.h" // Khronos EGL library - Extensions #include "GLES2/gl2.h" // Khronos OpenGL ES 2.0 library + #include "uwp_events.h" // UWP bootstrapping functions #endif #if defined(PLATFORM_WEB) @@ -328,10 +329,6 @@ typedef struct { typedef struct { int x; int y; } Point; typedef struct { unsigned int width; unsigned int height; } Size; -#if defined(PLATFORM_UWP) -extern EGLNativeWindowType handle; // Native window handler for UWP (external, defined in UWP App) -#endif - // Core global state context data typedef struct CoreData { struct { @@ -378,6 +375,11 @@ typedef struct CoreData { const char *internalDataPath; // Android internal data path to write data (/data/data//files) bool contextRebindRequired; // Used to know context rebind required } Android; +#endif +#if defined(PLATFORM_UWP) + struct { + const char* internalDataPath; // UWP App data path + } UWP; #endif struct { #if defined(PLATFORM_RPI) @@ -610,6 +612,14 @@ static void RestoreTerminal(void) // NOTE: data parameter could be used to pass any kind of required data to the initialization void InitWindow(int width, int height, const char *title) { +#if defined(PLATFORM_UWP) + if (!UWPIsConfigured()) + { + TRACELOG(LOG_ERROR, "UWP Functions have not been set yet, please set these before initializing raylib!"); + return; + } +#endif + TRACELOG(LOG_INFO, "Initializing raylib %s", RAYLIB_VERSION); CORE.Window.title = title; @@ -619,6 +629,11 @@ void InitWindow(int width, int height, const char *title) CORE.Input.Mouse.scale = (Vector2){ 1.0f, 1.0f }; CORE.Input.Gamepad.lastButtonPressed = -1; +#if defined(PLATFORM_UWP) + // The axis count is 6 (2 thumbsticks and left and right trigger) + CORE.Input.Gamepad.axisCount = 6; +#endif + #if defined(PLATFORM_ANDROID) CORE.Window.screen.width = width; CORE.Window.screen.height = height; @@ -760,7 +775,7 @@ void CloseWindow(void) glfwTerminate(); #endif -#if !defined(SUPPORT_BUSY_WAIT_LOOP) && defined(_WIN32) +#if !defined(SUPPORT_BUSY_WAIT_LOOP) && defined(_WIN32) && !defined(PLATFORM_UWP) timeEndPeriod(1); // Restore time period #endif @@ -1209,9 +1224,7 @@ void ShowCursor(void) glfwSetInputMode(CORE.Window.handle, GLFW_CURSOR, GLFW_CURSOR_NORMAL); #endif #if defined(PLATFORM_UWP) - UWPMessage *msg = CreateUWPMessage(); - msg->type = UWP_MSG_SHOW_MOUSE; - SendMessageToUWP(msg); + UWPGetMouseShowFunc()(); #endif CORE.Input.Mouse.cursorHidden = false; } @@ -1223,9 +1236,7 @@ void HideCursor(void) glfwSetInputMode(CORE.Window.handle, GLFW_CURSOR, GLFW_CURSOR_HIDDEN); #endif #if defined(PLATFORM_UWP) - UWPMessage *msg = CreateUWPMessage(); - msg->type = UWP_MSG_HIDE_MOUSE; - SendMessageToUWP(msg); + UWPGetMouseHideFunc()(); #endif CORE.Input.Mouse.cursorHidden = true; } @@ -1246,9 +1257,7 @@ void EnableCursor(void) CORE.Input.Mouse.cursorLockRequired = true; #endif #if defined(PLATFORM_UWP) - UWPMessage *msg = CreateUWPMessage(); - msg->type = UWP_MSG_LOCK_MOUSE; - SendMessageToUWP(msg); + UWPGetMouseUnlockFunc()(); #endif CORE.Input.Mouse.cursorHidden = false; } @@ -1263,9 +1272,7 @@ void DisableCursor(void) CORE.Input.Mouse.cursorLockRequired = true; #endif #if defined(PLATFORM_UWP) - UWPMessage *msg = CreateUWPMessage(); - msg->type = UWP_MSG_UNLOCK_MOUSE; - SendMessageToUWP(msg); + UWPGetMouseLockFunc()(); #endif CORE.Input.Mouse.cursorHidden = true; } @@ -1709,8 +1716,7 @@ double GetTime(void) #endif #if defined(PLATFORM_UWP) - // Updated through messages - return CORE.Time.current; + return UWPGetQueryTimeFunc()(); #endif } @@ -1892,6 +1898,10 @@ void TakeScreenshot(const char *fileName) strcpy(path, CORE.Android.internalDataPath); strcat(path, "/"); strcat(path, fileName); +#elif defined(PLATFORM_UWP) + strcpy(path, CORE.UWP.internalDataPath); + strcat(path, "/"); + strcat(path, fileName); #else strcpy(path, fileName); #endif @@ -2225,6 +2235,10 @@ void SaveStorageValue(unsigned int position, int value) strcpy(path, CORE.Android.internalDataPath); strcat(path, "/"); strcat(path, STORAGE_DATA_FILE); +#elif defined(PLATFORM_UWP) + strcpy(path, CORE.UWP.internalDataPath); + strcat(path, "/"); + strcat(path, STORAGE_DATA_FILE); #else strcpy(path, STORAGE_DATA_FILE); #endif @@ -2298,6 +2312,10 @@ int LoadStorageValue(unsigned int position) strcpy(path, CORE.Android.internalDataPath); strcat(path, "/"); strcat(path, STORAGE_DATA_FILE); +#elif defined(PLATFORM_UWP) + strcpy(path, CORE.UWP.internalDataPath); + strcat(path, "/"); + strcat(path, STORAGE_DATA_FILE); #else strcpy(path, STORAGE_DATA_FILE); #endif @@ -2638,11 +2656,7 @@ void SetMousePosition(int x, int y) glfwSetCursorPos(CORE.Window.handle, CORE.Input.Mouse.position.x, CORE.Input.Mouse.position.y); #endif #if defined(PLATFORM_UWP) - UWPMessage *msg = CreateUWPMessage(); - msg->type = UWP_MSG_SET_MOUSE_LOCATION; - msg->paramVector0.x = CORE.Input.Mouse.position.x; - msg->paramVector0.y = CORE.Input.Mouse.position.y; - SendMessageToUWP(msg); + UWPGetMouseSetPosFunc()(x, y); #endif } @@ -2675,7 +2689,7 @@ int GetMouseWheelMove(void) // Returns touch position X for touch point 0 (relative to screen size) int GetTouchX(void) { -#if defined(PLATFORM_ANDROID) || defined(PLATFORM_WEB) +#if defined(PLATFORM_ANDROID) || defined(PLATFORM_WEB) || defined(PLATFORM_UWP) return (int)CORE.Input.Touch.position[0].x; #else // PLATFORM_DESKTOP, PLATFORM_RPI return GetMouseX(); @@ -2685,7 +2699,7 @@ int GetTouchX(void) // Returns touch position Y for touch point 0 (relative to screen size) int GetTouchY(void) { -#if defined(PLATFORM_ANDROID) || defined(PLATFORM_WEB) +#if defined(PLATFORM_ANDROID) || defined(PLATFORM_WEB) || defined(PLATFORM_UWP) return (int)CORE.Input.Touch.position[0].y; #else // PLATFORM_DESKTOP, PLATFORM_RPI return GetMouseY(); @@ -2698,7 +2712,7 @@ Vector2 GetTouchPosition(int index) { Vector2 position = { -1.0f, -1.0f }; -#if defined(PLATFORM_ANDROID) || defined(PLATFORM_WEB) || defined(PLATFORM_RPI) +#if defined(PLATFORM_ANDROID) || defined(PLATFORM_WEB) || defined(PLATFORM_RPI) || defined(PLATFORM_UWP) if (index < MAX_TOUCH_POINTS) position = CORE.Input.Touch.position[index]; else TRACELOG(LOG_WARNING, "INPUT: Required touch point out of range (Max touch points: %i)", MAX_TOUCH_POINTS); @@ -3160,7 +3174,7 @@ static bool InitGraphicsDevice(int width, int height) //https://stackoverflow.com/questions/46550182/how-to-create-eglsurface-using-c-winrt-and-angle //CORE.Window.surface = eglCreateWindowSurface(CORE.Window.device, CORE.Window.config, reinterpret_cast(surfaceCreationProperties), surfaceAttributes); - CORE.Window.surface = eglCreateWindowSurface(CORE.Window.device, CORE.Window.config, handle, surfaceAttributes); + CORE.Window.surface = eglCreateWindowSurface(CORE.Window.device, CORE.Window.config, (EGLNativeWindowType) UWPGetCoreWindowPtr(), surfaceAttributes); if (CORE.Window.surface == EGL_NO_SURFACE) { TRACELOG(LOG_WARNING, "DISPLAY: Failed to create EGL fullscreen surface"); @@ -3175,8 +3189,11 @@ static bool InitGraphicsDevice(int width, int height) } // Get EGL device window size - eglQuerySurface(CORE.Window.device, CORE.Window.surface, EGL_WIDTH, &CORE.Window.display.width); - eglQuerySurface(CORE.Window.device, CORE.Window.surface, EGL_HEIGHT, &CORE.Window.display.height); + eglQuerySurface(CORE.Window.device, CORE.Window.surface, EGL_WIDTH, &CORE.Window.screen.width); + eglQuerySurface(CORE.Window.device, CORE.Window.surface, EGL_HEIGHT, &CORE.Window.screen.height); + + // Get display size + UWPGetDisplaySizeFunc()(&CORE.Window.display.width, &CORE.Window.display.height); #endif // PLATFORM_UWP @@ -3289,8 +3306,13 @@ static bool InitGraphicsDevice(int width, int height) else { // Grab the width and height of the surface +#if defined(PLATFORM_UWP) + CORE.Window.render.width = CORE.Window.screen.width; + CORE.Window.render.height = CORE.Window.screen.height; +#else CORE.Window.render.width = CORE.Window.display.width; CORE.Window.render.height = CORE.Window.display.height; +#endif TRACELOG(LOG_INFO, "DISPLAY: Device initialized successfully"); TRACELOG(LOG_INFO, " > Display size: %i x %i", CORE.Window.display.width, CORE.Window.display.height); @@ -3325,7 +3347,7 @@ static bool InitGraphicsDevice(int width, int height) ClearBackground(RAYWHITE); // Default background color for raylib games :P -#if defined(PLATFORM_ANDROID) +#if defined(PLATFORM_ANDROID) || defined(PLATFORM_UWP) CORE.Window.ready = true; #endif return true; @@ -3430,7 +3452,7 @@ static void InitTimer(void) { srand((unsigned int)time(NULL)); // Initialize random seed -#if !defined(SUPPORT_BUSY_WAIT_LOOP) && defined(_WIN32) +#if !defined(SUPPORT_BUSY_WAIT_LOOP) && defined(_WIN32) && !defined(PLATFORM_UWP) timeBeginPeriod(1); // Setup high-resolution timer to 1ms (granularity of 1-2 ms) #endif @@ -3454,7 +3476,9 @@ static void InitTimer(void) // Ref: http://www.geisswerks.com/ryan/FAQS/timing.html --> All about timming on Win32! static void Wait(float ms) { -#if defined(SUPPORT_BUSY_WAIT_LOOP) && !defined(PLATFORM_UWP) +#if defined(PLATFORM_UWP) + UWPGetSleepFunc()(ms / 1000); +#elif defined(SUPPORT_BUSY_WAIT_LOOP) double prevTime = GetTime(); double nextTime = 0.0; @@ -3482,7 +3506,7 @@ static void Wait(float ms) usleep(ms*1000.0f); #endif - #if defined(SUPPORT_HALFBUSY_WAIT_LOOP) + #if defined(SUPPORT_HALFBUSY_WAIT_LOOP)// && !defined(PLATFORM_UWP) while (GetTime() < destTime) { } #endif #endif @@ -3639,142 +3663,6 @@ static void PollInputEvents(void) CORE.Input.Mouse.currentWheelMove = 0; for (int i = 0; i < 3; i++) CORE.Input.Mouse.previousButtonState[i] = CORE.Input.Mouse.currentButtonState[i]; - - // Loop over pending messages - while (HasMessageFromUWP()) - { - UWPMessage *msg = GetMessageFromUWP(); - - switch (msg->type) - { - case UWP_MSG_REGISTER_KEY: - { - // Convert from virtualKey - int actualKey = -1; - - switch (msg->paramInt0) - { - case 0x08: actualKey = KEY_BACKSPACE; break; - case 0x20: actualKey = KEY_SPACE; break; - case 0x1B: actualKey = KEY_ESCAPE; break; - case 0x0D: actualKey = KEY_ENTER; break; - case 0x2E: actualKey = KEY_DELETE; break; - case 0x27: actualKey = KEY_RIGHT; break; - case 0x25: actualKey = KEY_LEFT; break; - case 0x28: actualKey = KEY_DOWN; break; - case 0x26: actualKey = KEY_UP; break; - case 0x70: actualKey = KEY_F1; break; - case 0x71: actualKey = KEY_F2; break; - case 0x72: actualKey = KEY_F3; break; - case 0x73: actualKey = KEY_F4; break; - case 0x74: actualKey = KEY_F5; break; - case 0x75: actualKey = KEY_F6; break; - case 0x76: actualKey = KEY_F7; break; - case 0x77: actualKey = KEY_F8; break; - case 0x78: actualKey = KEY_F9; break; - case 0x79: actualKey = KEY_F10; break; - case 0x7A: actualKey = KEY_F11; break; - case 0x7B: actualKey = KEY_F12; break; - case 0xA0: actualKey = KEY_LEFT_SHIFT; break; - case 0xA2: actualKey = KEY_LEFT_CONTROL; break; - case 0xA4: actualKey = KEY_LEFT_ALT; break; - case 0xA1: actualKey = KEY_RIGHT_SHIFT; break; - case 0xA3: actualKey = KEY_RIGHT_CONTROL; break; - case 0xA5: actualKey = KEY_RIGHT_ALT; break; - case 0x30: actualKey = KEY_ZERO; break; - case 0x31: actualKey = KEY_ONE; break; - case 0x32: actualKey = KEY_TWO; break; - case 0x33: actualKey = KEY_THREE; break; - case 0x34: actualKey = KEY_FOUR; break; - case 0x35: actualKey = KEY_FIVE; break; - case 0x36: actualKey = KEY_SIX; break; - case 0x37: actualKey = KEY_SEVEN; break; - case 0x38: actualKey = KEY_EIGHT; break; - case 0x39: actualKey = KEY_NINE; break; - case 0x41: actualKey = KEY_A; break; - case 0x42: actualKey = KEY_B; break; - case 0x43: actualKey = KEY_C; break; - case 0x44: actualKey = KEY_D; break; - case 0x45: actualKey = KEY_E; break; - case 0x46: actualKey = KEY_F; break; - case 0x47: actualKey = KEY_G; break; - case 0x48: actualKey = KEY_H; break; - case 0x49: actualKey = KEY_I; break; - case 0x4A: actualKey = KEY_J; break; - case 0x4B: actualKey = KEY_K; break; - case 0x4C: actualKey = KEY_L; break; - case 0x4D: actualKey = KEY_M; break; - case 0x4E: actualKey = KEY_N; break; - case 0x4F: actualKey = KEY_O; break; - case 0x50: actualKey = KEY_P; break; - case 0x51: actualKey = KEY_Q; break; - case 0x52: actualKey = KEY_R; break; - case 0x53: actualKey = KEY_S; break; - case 0x54: actualKey = KEY_T; break; - case 0x55: actualKey = KEY_U; break; - case 0x56: actualKey = KEY_V; break; - case 0x57: actualKey = KEY_W; break; - case 0x58: actualKey = KEY_X; break; - case 0x59: actualKey = KEY_Y; break; - case 0x5A: actualKey = KEY_Z; break; - default: break; - } - - if (actualKey > -1) CORE.Input.Keyboard.currentKeyState[actualKey] = msg->paramChar0; - - } break; - case UWP_MSG_REGISTER_CLICK: CORE.Input.Mouse.currentButtonState[msg->paramInt0] = msg->paramChar0; break; - case UWP_MSG_SCROLL_WHEEL_UPDATE: CORE.Input.Mouse.currentWheelMove += msg->paramInt0; break; - case UWP_MSG_UPDATE_MOUSE_LOCATION: CORE.Input.Mouse.position = msg->paramVector0; break; - case UWP_MSG_SET_GAMEPAD_ACTIVE: if (msg->paramInt0 < MAX_GAMEPADS) CORE.Input.Gamepad.ready[msg->paramInt0] = msg->paramBool0; break; - case UWP_MSG_SET_GAMEPAD_BUTTON: - { - if ((msg->paramInt0 < MAX_GAMEPADS) && (msg->paramInt1 < MAX_GAMEPAD_BUTTONS)) CORE.Input.Gamepad.currentState[msg->paramInt0][msg->paramInt1] = msg->paramChar0; - } break; - case UWP_MSG_SET_GAMEPAD_AXIS: - { - if ((msg->paramInt0 < MAX_GAMEPADS) && (msg->paramInt1 < MAX_GAMEPAD_AXIS)) CORE.Input.Gamepad.axisState[msg->paramInt0][msg->paramInt1] = msg->paramFloat0; - - // Register buttons for 2nd triggers - CORE.Input.Gamepad.currentState[msg->paramInt0][GAMEPAD_BUTTON_LEFT_TRIGGER_2] = (char)(CORE.Input.Gamepad.axisState[msg->paramInt0][GAMEPAD_AXIS_LEFT_TRIGGER] > 0.1); - CORE.Input.Gamepad.currentState[msg->paramInt0][GAMEPAD_BUTTON_RIGHT_TRIGGER_2] = (char)(CORE.Input.Gamepad.axisState[msg->paramInt0][GAMEPAD_AXIS_RIGHT_TRIGGER] > 0.1); - } break; - case UWP_MSG_SET_DISPLAY_DIMS: - { - CORE.Window.display.width = msg->paramVector0.x; - CORE.Window.display.height = msg->paramVector0.y; - } break; - case UWP_MSG_HANDLE_RESIZE: - { - eglQuerySurface(CORE.Window.device, CORE.Window.surface, EGL_WIDTH, &CORE.Window.screen.width); - eglQuerySurface(CORE.Window.device, CORE.Window.surface, EGL_HEIGHT, &CORE.Window.screen.height); - - // If window is resized, viewport and projection matrix needs to be re-calculated - rlViewport(0, 0, CORE.Window.screen.width, CORE.Window.screen.height); // Set viewport width and height - rlMatrixMode(RL_PROJECTION); // Switch to projection matrix - rlLoadIdentity(); // Reset current matrix (projection) - rlOrtho(0, CORE.Window.screen.width, CORE.Window.screen.height, 0, 0.0f, 1.0f); // Orthographic projection mode with top-left corner at (0,0) - rlMatrixMode(RL_MODELVIEW); // Switch back to modelview matrix - rlLoadIdentity(); // Reset current matrix (modelview) - rlClearScreenBuffers(); // Clear screen buffers (color and depth) - - // Window size must be updated to be used on 3D mode to get new aspect ratio (BeginMode3D()) - // NOTE: Be careful! GLFW3 will choose the closest fullscreen resolution supported by current monitor, - // for example, if reescaling back to 800x450 (desired), it could set 720x480 (closest fullscreen supported) - CORE.Window.currentFbo.width = CORE.Window.screen.width; - CORE.Window.currentFbo.height = CORE.Window.screen.height; - - // NOTE: Postprocessing texture is not scaled to new size - - CORE.Window.resized = true; - - } break; - case UWP_MSG_SET_GAME_TIME: CORE.Time.current = msg->paramDouble0; break; - default: break; - } - - DeleteUWPMessage(msg); //Delete, we are done - } #endif // PLATFORM_UWP #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB) @@ -5260,3 +5148,404 @@ static void *GamepadThread(void *arg) return NULL; } #endif // PLATFORM_RPI + +#if defined(PLATFORM_UWP) + +static UWPQueryTimeFunc uwpQueryTimeFunc = NULL; +static UWPSleepFunc uwpSleepFunc = NULL; +static UWPDisplaySizeFunc uwpDisplaySizeFunc = NULL; +static UWPMouseFunc uwpMouseLockFunc = NULL; +static UWPMouseFunc uwpMouseUnlockFunc = NULL; +static UWPMouseFunc uwpMouseShowFunc = NULL; +static UWPMouseFunc uwpMouseHideFunc = NULL; +static UWPMouseSetPosFunc uwpMouseSetPosFunc = NULL; +static void* uwpCoreWindow = NULL; + +bool UWPIsConfigured() +{ + bool pass = true; + if (uwpQueryTimeFunc == NULL) + { + TRACELOG(LOG_ERROR, "You must call UWPSetQueryTimeFunc with a valid function before calling InitWindow()"); + pass = false; + } + + if (uwpSleepFunc == NULL) + { + TRACELOG(LOG_ERROR, "You must call UWPSetSleepFunc with a valid function before calling InitWindow()"); + pass = false; + } + + if (uwpDisplaySizeFunc == NULL) + { + TRACELOG(LOG_ERROR, "You must call UWPSetDisplaySizeFunc with a valid function before calling InitWindow()"); + pass = false; + } + + if (uwpMouseLockFunc == NULL) + { + TRACELOG(LOG_ERROR, "You must call UWPSetMouseLockFunc with a valid function before calling InitWindow()"); + pass = false; + } + + if (uwpMouseUnlockFunc == NULL) + { + TRACELOG(LOG_ERROR, "You must call UWPSetMouseUnlockFunc with a valid function before calling InitWindow()"); + pass = false; + } + + if (uwpMouseShowFunc == NULL) + { + TRACELOG(LOG_ERROR, "You must call UWPSetMouseShowFunc with a valid function before calling InitWindow()"); + pass = false; + } + + if (uwpMouseHideFunc == NULL) + { + TRACELOG(LOG_ERROR, "You must call UWPSetMouseHideFunc with a valid function before calling InitWindow()"); + pass = false; + } + + if (uwpMouseSetPosFunc == NULL) + { + TRACELOG(LOG_ERROR, "You must call UWPSetMouseSetPosFunc with a valid function before calling InitWindow()"); + pass = false; + } + + if (uwpCoreWindow == NULL) + { + TRACELOG(LOG_ERROR, "You must set a pointer to the UWP core window before calling InitWindow()"); + pass = false; + } + return pass; +} +void UWPSetDataPath(const char* path) +{ + CORE.UWP.internalDataPath = path; +} + +UWPQueryTimeFunc UWPGetQueryTimeFunc(void) +{ + return uwpQueryTimeFunc; +} + +void UWPSetQueryTimeFunc(UWPQueryTimeFunc func) +{ + uwpQueryTimeFunc = func; +} + +UWPSleepFunc UWPGetSleepFunc(void) +{ + return uwpSleepFunc; +} + +void UWPSetSleepFunc(UWPSleepFunc func) +{ + uwpSleepFunc = func; +} + +UWPDisplaySizeFunc UWPGetDisplaySizeFunc(void) +{ + return uwpDisplaySizeFunc; +} + +void UWPSetDisplaySizeFunc(UWPDisplaySizeFunc func) +{ + uwpDisplaySizeFunc = func; +} + +UWPMouseFunc UWPGetMouseLockFunc() +{ + return uwpMouseLockFunc; +} + +void UWPSetMouseLockFunc(UWPMouseFunc func) +{ + uwpMouseLockFunc = func; +} + +UWPMouseFunc UWPGetMouseUnlockFunc() +{ + return uwpMouseUnlockFunc; +} + +void UWPSetMouseUnlockFunc(UWPMouseFunc func) +{ + uwpMouseUnlockFunc = func; +} + +UWPMouseFunc UWPGetMouseShowFunc() +{ + return uwpMouseShowFunc; +} + +void UWPSetMouseShowFunc(UWPMouseFunc func) +{ + uwpMouseShowFunc = func; +} + +UWPMouseFunc UWPGetMouseHideFunc() +{ + return uwpMouseHideFunc; +} + +void UWPSetMouseHideFunc(UWPMouseFunc func) +{ + uwpMouseHideFunc = func; +} + +UWPMouseSetPosFunc UWPGetMouseSetPosFunc() +{ + return uwpMouseSetPosFunc; +} + +void UWPSetMouseSetPosFunc(UWPMouseSetPosFunc func) +{ + uwpMouseSetPosFunc = func; +} + +void* UWPGetCoreWindowPtr() +{ + return uwpCoreWindow; +} + +void UWPSetCoreWindowPtr(void* ptr) +{ + uwpCoreWindow = ptr; +} + +void UWPMouseWheelEvent(int deltaY) +{ + CORE.Input.Mouse.currentWheelMove = (int)deltaY; +} + +void UWPKeyDownEvent(int key, bool down, bool controlKey) +{ + if (key == CORE.Input.Keyboard.exitKey && down) + { + // Time to close the window. + CORE.Window.shouldClose = true; + } + else if (key == KEY_F12 && down) + { +#if defined(SUPPORT_GIF_RECORDING) + if (controlKey) + { + if (gifRecording) + { + GifEnd(); + gifRecording = false; + +#if defined(PLATFORM_WEB) + // Download file from MEMFS (emscripten memory filesystem) + // saveFileFromMEMFSToDisk() function is defined in raylib/templates/web_shel/shell.html + emscripten_run_script(TextFormat("saveFileFromMEMFSToDisk('%s','%s')", TextFormat("screenrec%03i.gif", screenshotCounter - 1), TextFormat("screenrec%03i.gif", screenshotCounter - 1))); +#endif + + TRACELOG(LOG_INFO, "SYSTEM: Finish animated GIF recording"); + } + else + { + gifRecording = true; + gifFramesCounter = 0; + + char path[512] = { 0 }; +#if defined(PLATFORM_ANDROID) + strcpy(path, CORE.Android.internalDataPath); + strcat(path, TextFormat("./screenrec%03i.gif", screenshotCounter)); +#elif defined(PLATFORM_UWP) + strcpy(path, CORE.UWP.internalDataPath); + strcat(path, TextFormat("./screenrec%03i.gif", screenshotCounter)); +#else + strcpy(path, TextFormat("./screenrec%03i.gif", screenshotCounter)); +#endif + + // NOTE: delay represents the time between frames in the gif, if we capture a gif frame every + // 10 game frames and each frame trakes 16.6ms (60fps), delay between gif frames should be ~16.6*10. + GifBegin(path, CORE.Window.screen.width, CORE.Window.screen.height, (int)(GetFrameTime() * 10.0f), 8, false); + screenshotCounter++; + + TRACELOG(LOG_INFO, "SYSTEM: Start animated GIF recording: %s", TextFormat("screenrec%03i.gif", screenshotCounter)); + } + } + else +#endif // SUPPORT_GIF_RECORDING +#if defined(SUPPORT_SCREEN_CAPTURE) + { + TakeScreenshot(TextFormat("screenshot%03i.png", screenshotCounter)); + screenshotCounter++; + } +#endif // SUPPORT_SCREEN_CAPTURE + } + else + { + CORE.Input.Keyboard.currentKeyState[key] = down; + } +} + +void UWPKeyCharEvent(int key) +{ + if (CORE.Input.Keyboard.keyPressedQueueCount < MAX_CHARS_QUEUE) + { + // Add character to the queue + CORE.Input.Keyboard.keyPressedQueue[CORE.Input.Keyboard.keyPressedQueueCount] = key; + CORE.Input.Keyboard.keyPressedQueueCount++; + } +} + +void UWPMouseButtonEvent(int button, bool down) +{ + CORE.Input.Mouse.currentButtonState[button] = down; + +#if defined(SUPPORT_GESTURES_SYSTEM) && defined(SUPPORT_MOUSE_GESTURES) + // Process mouse events as touches to be able to use mouse-gestures + GestureEvent gestureEvent = { 0 }; + + // Register touch actions + if ((CORE.Input.Mouse.currentButtonState[button] == 1) && (CORE.Input.Mouse.previousButtonState[button] == 0)) gestureEvent.touchAction = TOUCH_DOWN; + else if ((CORE.Input.Mouse.currentButtonState[button] == 0) && (CORE.Input.Mouse.previousButtonState[button] == 1)) gestureEvent.touchAction = TOUCH_UP; + + // NOTE: TOUCH_MOVE event is registered in MouseCursorPosCallback() + + // Assign a pointer ID + gestureEvent.pointerId[0] = 0; + + // Register touch points count + gestureEvent.pointCount = 1; + + // Register touch points position, only one point registered + gestureEvent.position[0] = GetMousePosition(); + + // Normalize gestureEvent.position[0] for CORE.Window.screen.width and CORE.Window.screen.height + gestureEvent.position[0].x /= (float)GetScreenWidth(); + gestureEvent.position[0].y /= (float)GetScreenHeight(); + + // Gesture data is sent to gestures system for processing + ProcessGestureEvent(gestureEvent); +#endif +} + +void UWPMousePosEvent(double x, double y) +{ + CORE.Input.Mouse.position.x = (float)x; + CORE.Input.Mouse.position.y = (float)y; + CORE.Input.Touch.position[0] = CORE.Input.Mouse.position; + +#if defined(SUPPORT_GESTURES_SYSTEM) && defined(SUPPORT_MOUSE_GESTURES) + // Process mouse events as touches to be able to use mouse-gestures + GestureEvent gestureEvent = { 0 }; + + gestureEvent.touchAction = TOUCH_MOVE; + + // Assign a pointer ID + gestureEvent.pointerId[0] = 0; + + // Register touch points count + gestureEvent.pointCount = 1; + + // Register touch points position, only one point registered + gestureEvent.position[0] = CORE.Input.Mouse.position; + + // Normalize gestureEvent.position[0] for CORE.Window.screen.width and CORE.Window.screen.height + gestureEvent.position[0].x /= (float)GetScreenWidth(); + gestureEvent.position[0].y /= (float)GetScreenHeight(); + + // Gesture data is sent to gestures system for processing + ProcessGestureEvent(gestureEvent); +#endif +} + +void UWPResizeEvent(int width, int height) +{ + SetupViewport(width, height); // Reset viewport and projection matrix for new size + + // Set current screen size + CORE.Window.screen.width = width; + CORE.Window.screen.height = height; + CORE.Window.currentFbo.width = width; + CORE.Window.currentFbo.height = height; + + // NOTE: Postprocessing texture is not scaled to new size + + CORE.Window.resized = true; +} + +void UWPActivateGamepadEvent(int gamepad, bool active) +{ + if (gamepad < MAX_GAMEPADS) { + CORE.Input.Gamepad.ready[gamepad] = active; + } +} + +void UWPRegisterGamepadButton(int gamepad, int button, bool down) +{ + if (gamepad < MAX_GAMEPADS) { + if (button < MAX_GAMEPAD_BUTTONS) { + CORE.Input.Gamepad.currentState[gamepad][button] = down; + CORE.Input.Gamepad.lastButtonPressed = button; + } + } +} + +void UWPRegisterGamepadAxis(int gamepad, int axis, float value) +{ + if (gamepad < MAX_GAMEPADS) + { + if (axis < MAX_GAMEPAD_AXIS) + { + CORE.Input.Gamepad.axisState[gamepad][axis] = value; + } + } +} + +void UWPGestureMove(int pointer, float x, float y) +{ +#if defined(SUPPORT_GESTURES_SYSTEM) + GestureEvent gestureEvent = { 0 }; + + // Assign the pointer ID and touch action + gestureEvent.pointerId[0] = pointer; + gestureEvent.touchAction = TOUCH_MOVE; + + // Register touch points count + gestureEvent.pointCount = 1; + + // Register touch points position, only one point registered + gestureEvent.position[0].x = x; + gestureEvent.position[0].y = y; + + // Normalize gestureEvent.position[0] for CORE.Window.screen.width and CORE.Window.screen.height + gestureEvent.position[0].x /= (float)GetScreenWidth(); + gestureEvent.position[0].y /= (float)GetScreenHeight(); + + // Gesture data is sent to gestures system for processing + ProcessGestureEvent(gestureEvent); +#endif +} + +void UWPGestureTouch(int pointer, float x, float y, bool touch) +{ +#if defined(SUPPORT_GESTURES_SYSTEM) + GestureEvent gestureEvent = { 0 }; + + // Assign the pointer ID and touch action + gestureEvent.pointerId[0] = pointer; + gestureEvent.touchAction = touch ? TOUCH_DOWN : TOUCH_UP; + + // Register touch points count + gestureEvent.pointCount = 1; + + // Register touch points position, only one point registered + gestureEvent.position[0].x = x; + gestureEvent.position[0].y = y; + + // Normalize gestureEvent.position[0] for CORE.Window.screen.width and CORE.Window.screen.height + gestureEvent.position[0].x /= (float)GetScreenWidth(); + gestureEvent.position[0].y /= (float)GetScreenHeight(); + + // Gesture data is sent to gestures system for processing + ProcessGestureEvent(gestureEvent); +#endif +} + +#endif // PLATFORM_UWP diff --git a/src/rlgl.h b/src/rlgl.h index 72a6e3986..0960afeab 100644 --- a/src/rlgl.h +++ b/src/rlgl.h @@ -663,6 +663,7 @@ RLAPI int GetPixelDataSize(int width, int height, int format);// Get pixel data #endif #if defined(GRAPHICS_API_OPENGL_ES2) + #define GL_GLEXT_PROTOTYPES #include // EGL library #include // OpenGL ES 2.0 library #include // OpenGL ES 2.0 extensions library diff --git a/src/utils.c b/src/utils.c index 02a53abce..74b33b501 100644 --- a/src/utils.c +++ b/src/utils.c @@ -68,13 +68,6 @@ static AAssetManager *assetManager = NULL; // Android assets manage static const char *internalDataPath = NULL; // Android internal data path #endif -#if defined(PLATFORM_UWP) -static int UWPOutMessageId = -1; // Last index of output message -static UWPMessage *UWPOutMessages[MAX_UWP_MESSAGES]; // Messages out to UWP -static int UWPInMessageId = -1; // Last index of input message -static UWPMessage *UWPInMessages[MAX_UWP_MESSAGES]; // Messages in from UWP -#endif - //---------------------------------------------------------------------------------- // Module specific Functions Declaration //---------------------------------------------------------------------------------- @@ -361,69 +354,3 @@ static int android_close(void *cookie) return 0; } #endif // PLATFORM_ANDROID - -#if defined(PLATFORM_UWP) -UWPMessage *CreateUWPMessage(void) -{ - UWPMessage *msg = (UWPMessage *)RL_MALLOC(sizeof(UWPMessage)); - msg->type = UWP_MSG_NONE; - Vector2 v0 = { 0, 0 }; - msg->paramVector0 = v0; - msg->paramInt0 = 0; - msg->paramInt1 = 0; - msg->paramChar0 = 0; - msg->paramFloat0 = 0; - msg->paramDouble0 = 0; - msg->paramBool0 = false; - return msg; -} - -void DeleteUWPMessage(UWPMessage *msg) -{ - RL_FREE(msg); -} - -bool UWPHasMessages(void) -{ - return (UWPOutMessageId > -1); -} - -UWPMessage *UWPGetMessage(void) -{ - if (UWPHasMessages()) return UWPOutMessages[UWPOutMessageId--]; - - return NULL; -} - -void UWPSendMessage(UWPMessage *msg) -{ - if ((UWPInMessageId + 1) < MAX_UWP_MESSAGES) - { - UWPInMessageId++; - UWPInMessages[UWPInMessageId] = msg; - } - else TRACELOG(LOG_WARNING, "UWP: Not enough array space to register new inbound message"); -} - -void SendMessageToUWP(UWPMessage *msg) -{ - if ((UWPOutMessageId + 1) < MAX_UWP_MESSAGES) - { - UWPOutMessageId++; - UWPOutMessages[UWPOutMessageId] = msg; - } - else TRACELOG(LOG_WARNING, "UWP: Not enough array space to register new outward message"); -} - -bool HasMessageFromUWP(void) -{ - return UWPInMessageId > -1; -} - -UWPMessage *GetMessageFromUWP(void) -{ - if (HasMessageFromUWP()) return UWPInMessages[UWPInMessageId--]; - - return NULL; -} -#endif // PLATFORM_UWP diff --git a/src/utils.h b/src/utils.h index 675f43b84..40ee53a48 100644 --- a/src/utils.h +++ b/src/utils.h @@ -72,65 +72,6 @@ void InitAssetManager(AAssetManager *manager, const char *dataPath); // Initia FILE *android_fopen(const char *fileName, const char *mode); // Replacement for fopen() -> Read-only! #endif -#if defined(PLATFORM_UWP) -// UWP Messages System -typedef enum { - UWP_MSG_NONE = 0, - - // Send - UWP_MSG_SHOW_MOUSE, - UWP_MSG_HIDE_MOUSE, - UWP_MSG_LOCK_MOUSE, - UWP_MSG_UNLOCK_MOUSE, - UWP_MSG_SET_MOUSE_LOCATION, // paramVector0 (pos) - - // Receive (Into C) - UWP_MSG_REGISTER_KEY, // paramInt0 (key), paramChar0 (status) - UWP_MSG_REGISTER_CLICK, // paramInt0 (button), paramChar0 (status) - UWP_MSG_SCROLL_WHEEL_UPDATE, // paramInt0 (delta) - UWP_MSG_UPDATE_MOUSE_LOCATION, // paramVector0 (pos) - UWP_MSG_SET_GAMEPAD_ACTIVE, // paramInt0 (gamepad), paramBool0 (active or not) - UWP_MSG_SET_GAMEPAD_BUTTON, // paramInt0 (gamepad), paramInt1 (button), paramChar0 (status) - UWP_MSG_SET_GAMEPAD_AXIS, // paramInt0 (gamepad), int1 (axis), paramFloat0 (value) - UWP_MSG_SET_DISPLAY_DIMS, // paramVector0 (display dimensions) - UWP_MSG_HANDLE_RESIZE, // paramVector0 (new dimensions) - Onresized event - UWP_MSG_SET_GAME_TIME, // paramInt0 -} UWPMessageType; - -typedef struct UWPMessage { - UWPMessageType type; // Message type - - Vector2 paramVector0; // Vector parameters - int paramInt0; // Int parameter - int paramInt1; // Int parameter - char paramChar0; // Char parameters - float paramFloat0; // Float parameters - double paramDouble0; // Double parameters - bool paramBool0; // Bool parameters - - // More parameters can be added and fed to functions -} UWPMessage; - -// Allocate UWP Message -RLAPI UWPMessage* CreateUWPMessage(void); - -// Free UWP Message -RLAPI void DeleteUWPMessage(UWPMessage* msg); - -// Get messages into C++ -RLAPI bool UWPHasMessages(void); -RLAPI UWPMessage* UWPGetMessage(void); -RLAPI void UWPSendMessage(UWPMessage* msg); - -// For C to call -#ifndef __cplusplus // Hide from C++ code -void SendMessageToUWP(UWPMessage* msg); -bool HasMessageFromUWP(void); -UWPMessage* GetMessageFromUWP(void); -#endif - -#endif //defined(PLATFORM_UWP) - #ifdef __cplusplus } #endif diff --git a/src/uwp_events.h b/src/uwp_events.h new file mode 100644 index 000000000..2c403fd36 --- /dev/null +++ b/src/uwp_events.h @@ -0,0 +1,119 @@ +/********************************************************************************************** +* +* raylib.uwp_events - Functions for bootstrapping UWP functionality within raylib's core. +* +* +* LICENSE: zlib/libpng +* +* Copyright (c) 2020-2020 Reece Mackie (@Rover656) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ + +#ifndef UWP_EVENTS_H +#define UWP_EVENTS_H + +#if defined(__cplusplus) +extern "C" { +#endif + +#if defined(PLATFORM_UWP) + +// Determine if UWP functions are set and ready for raylib's use. +bool UWPIsConfigured(); + +// Call this to set the UWP data path you wish for saving and loading. +void UWPSetDataPath(const char* path); + +// Function for getting program time. +typedef double(*UWPQueryTimeFunc)(); +UWPQueryTimeFunc UWPGetQueryTimeFunc(void); +void UWPSetQueryTimeFunc(UWPQueryTimeFunc func); + +// Function for sleeping the current thread +typedef void (*UWPSleepFunc)(double sleepUntil); +UWPSleepFunc UWPGetSleepFunc(void); +void UWPSetSleepFunc(UWPSleepFunc func); + +// Function for querying the display size +typedef void(*UWPDisplaySizeFunc)(int* width, int* height); +UWPDisplaySizeFunc UWPGetDisplaySizeFunc(void); +void UWPSetDisplaySizeFunc(UWPDisplaySizeFunc func); + +// Functions for mouse cursor control +typedef void(*UWPMouseFunc)(void); +UWPMouseFunc UWPGetMouseLockFunc(); +void UWPSetMouseLockFunc(UWPMouseFunc func); +UWPMouseFunc UWPGetMouseUnlockFunc(); +void UWPSetMouseUnlockFunc(UWPMouseFunc func); +UWPMouseFunc UWPGetMouseShowFunc(); +void UWPSetMouseShowFunc(UWPMouseFunc func); +UWPMouseFunc UWPGetMouseHideFunc(); +void UWPSetMouseHideFunc(UWPMouseFunc func); + +// Function for setting mouse cursor position. +typedef void (*UWPMouseSetPosFunc)(int x, int y); +UWPMouseSetPosFunc UWPGetMouseSetPosFunc(); +void UWPSetMouseSetPosFunc(UWPMouseSetPosFunc func); + +// The below functions are implemented in core.c but are placed here so they can be called by user code. +// This choice is made as platform-specific code is preferred to be kept away from raylib.h + +// Call this when a Key is pressed or released. +void UWPKeyDownEvent(int key, bool down, bool controlKey); + +// Call this on the CoreWindow::CharacterRecieved event +void UWPKeyCharEvent(int key); + +// Call when a mouse button state changes +void UWPMouseButtonEvent(int button, bool down); + +// Call when the mouse cursor moves +void UWPMousePosEvent(double x, double y); + +// Call when the mouse wheel moves +void UWPMouseWheelEvent(int deltaY); + +// Call when the window resizes +void UWPResizeEvent(int width, int height); + +// Call when a gamepad is made active +void UWPActivateGamepadEvent(int gamepad, bool active); + +// Call when a gamepad button state changes +void UWPRegisterGamepadButton(int gamepad, int button, bool down); + +// Call when a gamepad axis state changes +void UWPRegisterGamepadAxis(int gamepad, int axis, float value); + +// Call when the touch point moves +void UWPGestureMove(int pointer, float x, float y); + +// Call when there is a touch down or up +void UWPGestureTouch(int pointer, float x, float y, bool touch); + +// Set the core window pointer so that we can pass it to EGL. +void* UWPGetCoreWindowPtr(); +void UWPSetCoreWindowPtr(void* ptr); + +#if defined(__cplusplus) +} +#endif + +#endif // PLATFORM_UWP + +#endif // UWP_EVENTS_H