From 98e1097364abd8164c064a8b0dff8d2235c738e2 Mon Sep 17 00:00:00 2001 From: Reece Mackie <20544390+Rover656@users.noreply.github.com> Date: Thu, 25 Apr 2019 18:08:42 +0100 Subject: [PATCH] Implemented a ton more things, added BaseApp.h to provide common code to UWP apps. --- projects/VS2017.UWP/raylib.App.UWP/App.cpp | 503 ++---------------- projects/VS2017.UWP/raylib.App.UWP/App.h | 39 +- projects/VS2017.UWP/raylib.App.UWP/BaseApp.h | 372 +++++++++++++ .../raylib.App.UWP/raylib.App.UWP.vcxproj | 1 + src/camera.h | 1 + src/core.c | 14 +- src/raylib.h | 12 +- 7 files changed, 437 insertions(+), 505 deletions(-) create mode 100644 projects/VS2017.UWP/raylib.App.UWP/BaseApp.h diff --git a/projects/VS2017.UWP/raylib.App.UWP/App.cpp b/projects/VS2017.UWP/raylib.App.UWP/App.cpp index 09d0a3c9f..845d2f809 100644 --- a/projects/VS2017.UWP/raylib.App.UWP/App.cpp +++ b/projects/VS2017.UWP/raylib.App.UWP/App.cpp @@ -17,299 +17,9 @@ using namespace Platform; using namespace raylibUWP; -/* -TODO list: - - Cache reference to our CoreWindow? - - Implement gestures support -*/ - -// Declare uwpWindow as exter to be used by raylib internals -// NOTE: It should be properly assigned before calling InitWindow() -extern "C" { EGLNativeWindowType uwpWindow; }; - -/* INPUT CODE */ -// 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) - -static bool gamepadReady[MAX_GAMEPADS] = { false }; // Flag to know if gamepad is ready -static float gamepadAxisState[MAX_GAMEPADS][MAX_GAMEPAD_AXIS]; // Gamepad axis state -static char previousGamepadState[MAX_GAMEPADS][MAX_GAMEPAD_BUTTONS]; // Previous gamepad buttons state -static char currentGamepadState[MAX_GAMEPADS][MAX_GAMEPAD_BUTTONS]; // Current gamepad buttons state - -static char previousKeyState[512] = { 0 }; // Contains previous frame keyboard state -static char currentKeyState[512] = { 0 }; // Contains current frame keyboard state - -static char previousMouseState[3] = { 0 }; // Registers previous mouse button state -static char currentMouseState[3] = { 0 }; // Registers current mouse button state -static int previousMouseWheelY = 0; // Registers previous mouse wheel variation -static int currentMouseWheelY = 0; // Registers current mouse wheel variation - -static bool cursorOnScreen = false; // Tracks if cursor is inside client area -static bool cursorHidden = false; // Track if cursor is hidden - -static Vector2 mousePosition; -static Vector2 mouseDelta; // NOTE: Added to keep track of mouse movement while the cursor is locked - no equivalent in "core.c" -static bool toggleCursorLock; - -CoreCursor ^regularCursor = ref new CoreCursor(CoreCursorType::Arrow, 0); // The "visible arrow" cursor type - -// Helper to process key events -void ProcessKeyEvent(Windows::System::VirtualKey key, int action) -{ - using Windows::System::VirtualKey; - switch (key) - { - case VirtualKey::Space: currentKeyState[KEY_SPACE] = action; break; - case VirtualKey::Escape: currentKeyState[KEY_ESCAPE] = action; break; - case VirtualKey::Enter: currentKeyState[KEY_ENTER] = action; break; - case VirtualKey::Delete: currentKeyState[KEY_BACKSPACE] = action; break; - case VirtualKey::Right: currentKeyState[KEY_RIGHT] = action; break; - case VirtualKey::Left: currentKeyState[KEY_LEFT] = action; break; - case VirtualKey::Down: currentKeyState[KEY_DOWN] = action; break; - case VirtualKey::Up: currentKeyState[KEY_UP] = action; break; - case VirtualKey::F1: currentKeyState[KEY_F1] = action; break; - case VirtualKey::F2: currentKeyState[KEY_F2] = action; break; - case VirtualKey::F3: currentKeyState[KEY_F4] = action; break; - case VirtualKey::F4: currentKeyState[KEY_F5] = action; break; - case VirtualKey::F5: currentKeyState[KEY_F6] = action; break; - case VirtualKey::F6: currentKeyState[KEY_F7] = action; break; - case VirtualKey::F7: currentKeyState[KEY_F8] = action; break; - case VirtualKey::F8: currentKeyState[KEY_F9] = action; break; - case VirtualKey::F9: currentKeyState[KEY_F10] = action; break; - case VirtualKey::F10: currentKeyState[KEY_F11] = action; break; - case VirtualKey::F11: currentKeyState[KEY_F12] = action; break; - case VirtualKey::LeftShift: currentKeyState[KEY_LEFT_SHIFT] = action; break; - case VirtualKey::LeftControl: currentKeyState[KEY_LEFT_CONTROL] = action; break; - case VirtualKey::LeftMenu: currentKeyState[KEY_LEFT_ALT] = action; break; // NOTE: Potential UWP bug with Alt key: https://social.msdn.microsoft.com/Forums/windowsapps/en-US/9bebfb0a-7637-400e-8bda-e55620091407/unexpected-behavior-in-windowscoreuicorephysicalkeystatusismenukeydown - case VirtualKey::RightShift: currentKeyState[KEY_RIGHT_SHIFT] = action; break; - case VirtualKey::RightControl: currentKeyState[KEY_RIGHT_CONTROL] = action; break; - case VirtualKey::RightMenu: currentKeyState[KEY_RIGHT_ALT] = action; break; - case VirtualKey::Number0: currentKeyState[KEY_ZERO] = action; break; - case VirtualKey::Number1: currentKeyState[KEY_ONE] = action; break; - case VirtualKey::Number2: currentKeyState[KEY_TWO] = action; break; - case VirtualKey::Number3: currentKeyState[KEY_THREE] = action; break; - case VirtualKey::Number4: currentKeyState[KEY_FOUR] = action; break; - case VirtualKey::Number5: currentKeyState[KEY_FIVE] = action; break; - case VirtualKey::Number6: currentKeyState[KEY_SIX] = action; break; - case VirtualKey::Number7: currentKeyState[KEY_SEVEN] = action; break; - case VirtualKey::Number8: currentKeyState[KEY_EIGHT] = action; break; - case VirtualKey::Number9: currentKeyState[KEY_NINE] = action; break; - case VirtualKey::A: currentKeyState[KEY_A] = action; break; - case VirtualKey::B: currentKeyState[KEY_B] = action; break; - case VirtualKey::C: currentKeyState[KEY_C] = action; break; - case VirtualKey::D: currentKeyState[KEY_D] = action; break; - case VirtualKey::E: currentKeyState[KEY_E] = action; break; - case VirtualKey::F: currentKeyState[KEY_F] = action; break; - case VirtualKey::G: currentKeyState[KEY_G] = action; break; - case VirtualKey::H: currentKeyState[KEY_H] = action; break; - case VirtualKey::I: currentKeyState[KEY_I] = action; break; - case VirtualKey::J: currentKeyState[KEY_J] = action; break; - case VirtualKey::K: currentKeyState[KEY_K] = action; break; - case VirtualKey::L: currentKeyState[KEY_L] = action; break; - case VirtualKey::M: currentKeyState[KEY_M] = action; break; - case VirtualKey::N: currentKeyState[KEY_N] = action; break; - case VirtualKey::O: currentKeyState[KEY_O] = action; break; - case VirtualKey::P: currentKeyState[KEY_P] = action; break; - case VirtualKey::Q: currentKeyState[KEY_Q] = action; break; - case VirtualKey::R: currentKeyState[KEY_R] = action; break; - case VirtualKey::S: currentKeyState[KEY_S] = action; break; - case VirtualKey::T: currentKeyState[KEY_T] = action; break; - case VirtualKey::U: currentKeyState[KEY_U] = action; break; - case VirtualKey::V: currentKeyState[KEY_V] = action; break; - case VirtualKey::W: currentKeyState[KEY_W] = action; break; - case VirtualKey::X: currentKeyState[KEY_X] = action; break; - case VirtualKey::Y: currentKeyState[KEY_Y] = action; break; - case VirtualKey::Z: currentKeyState[KEY_Z] = action; break; - - } -} - -// Callbacks -void App::PointerPressed(CoreWindow^ window, PointerEventArgs^ args) -{ - if (args->CurrentPoint->Properties->IsLeftButtonPressed) - { - UWPRegisterClick(MOUSE_LEFT_BUTTON, 1); - } - if (args->CurrentPoint->Properties->IsRightButtonPressed) - { - UWPRegisterClick(MOUSE_RIGHT_BUTTON, 1); - } - if (args->CurrentPoint->Properties->IsMiddleButtonPressed) - { - UWPRegisterClick(MOUSE_MIDDLE_BUTTON, 1); - } -} - -void App::PointerReleased(CoreWindow ^window, PointerEventArgs^ args) -{ - if (!(args->CurrentPoint->Properties->IsLeftButtonPressed)) - { - UWPRegisterClick(MOUSE_LEFT_BUTTON, 0); - } - if (!(args->CurrentPoint->Properties->IsRightButtonPressed)) - { - UWPRegisterClick(MOUSE_RIGHT_BUTTON, 0); - } - if (!(args->CurrentPoint->Properties->IsMiddleButtonPressed)) - { - UWPRegisterClick(MOUSE_MIDDLE_BUTTON, 0); - } -} - -void App::PointerWheelChanged(CoreWindow ^window, PointerEventArgs^ args) -{ - // TODO: Scale the MouseWheelDelta to match GLFW's mouse wheel sensitivity. - currentMouseWheelY += args->CurrentPoint->Properties->MouseWheelDelta; -} - -void App::MouseMoved(Windows::Devices::Input::MouseDevice^ mouseDevice, Windows::Devices::Input::MouseEventArgs^ args) -{ - mouseDelta.x += args->MouseDelta.X; - mouseDelta.y += args->MouseDelta.Y; -} - -void App::OnKeyDown(CoreWindow ^ sender, KeyEventArgs ^ args) -{ - //ProcessKeyEvent(args->VirtualKey, 1); - - UWPRegisterKey((int)args->VirtualKey, 1); -} - -void App::OnKeyUp(CoreWindow ^ sender, KeyEventArgs ^ args) -{ - //ProcessKeyEvent(args->VirtualKey, 0); - - UWPRegisterKey((int)args->VirtualKey, 0); -} - -// Show mouse cursor -void UWPShowCursor() -{ - CoreWindow::GetForCurrentThread()->PointerCursor = regularCursor; - cursorHidden = false; -} - -// Hides mouse cursor -void UWPHideCursor() -{ - CoreWindow::GetForCurrentThread()->PointerCursor = nullptr; - cursorHidden = true; -} - -// Set mouse position XY -void UWPSetMousePosition(Vector2 position) -{ - CoreWindow ^window = CoreWindow::GetForCurrentThread(); - Point mousePosScreen = Point(position.x + window->Bounds.X, position.y + window->Bounds.Y); - window->PointerPosition = mousePosScreen; - mousePosition = position; -} - -// Enables cursor (unlock cursor) -void UWPEnableCursor() -{ - UWPShowCursor(); - UWPSetMousePosition(mousePosition); // The mouse is hidden in the center of the screen - move it to where it should appear - toggleCursorLock = false; -} - -// Disables cursor (lock cursor) -void UWPDisableCursor() -{ - UWPHideCursor(); - toggleCursorLock = true; -} - -// Poll (store) all input events -void UWP_PollInput() -{ - // Process Mouse - { - // Register previous mouse states - for (int i = 0; i < 3; i++) previousMouseState[i] = currentMouseState[i]; - previousMouseWheelY = currentMouseWheelY; - currentMouseWheelY = 0; - - CoreWindow ^window = CoreWindow::GetForCurrentThread(); - if (toggleCursorLock) - { - // Track cursor movement delta, recenter it on the client - mousePosition.x += mouseDelta.x; - mousePosition.y += mouseDelta.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 - mousePosition.x = window->PointerPosition.X - window->Bounds.X; - mousePosition.y = window->PointerPosition.Y - window->Bounds.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. - - gamepadReady[i] = (i < Gamepad::Gamepads->Size); - } - - // Get current gamepad state - for (int i = 0; i < MAX_GAMEPADS; i++) - { - if (gamepadReady[i]) - { - // Register previous gamepad states - for (int k = 0; k < MAX_GAMEPAD_BUTTONS; k++) previousGamepadState[i][k] = currentGamepadState[i][k]; - - // 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 - currentGamepadState[i][GAMEPAD_XBOX_BUTTON_A] = ((reading.Buttons & GamepadButtons::A) == GamepadButtons::A); - currentGamepadState[i][GAMEPAD_XBOX_BUTTON_B] = ((reading.Buttons & GamepadButtons::B) == GamepadButtons::B); - currentGamepadState[i][GAMEPAD_XBOX_BUTTON_X] = ((reading.Buttons & GamepadButtons::X) == GamepadButtons::X); - currentGamepadState[i][GAMEPAD_XBOX_BUTTON_Y] = ((reading.Buttons & GamepadButtons::Y) == GamepadButtons::Y); - currentGamepadState[i][GAMEPAD_XBOX_BUTTON_LB] = ((reading.Buttons & GamepadButtons::LeftShoulder) == GamepadButtons::LeftShoulder); - currentGamepadState[i][GAMEPAD_XBOX_BUTTON_RB] = ((reading.Buttons & GamepadButtons::RightShoulder) == GamepadButtons::RightShoulder); - currentGamepadState[i][GAMEPAD_XBOX_BUTTON_SELECT] = ((reading.Buttons & GamepadButtons::View) == GamepadButtons::View); // Changed for XB1 Controller - currentGamepadState[i][GAMEPAD_XBOX_BUTTON_START] = ((reading.Buttons & GamepadButtons::Menu) == GamepadButtons::Menu); // Changed for XB1 Controller - currentGamepadState[i][GAMEPAD_XBOX_BUTTON_UP] = ((reading.Buttons & GamepadButtons::DPadUp) == GamepadButtons::DPadUp); - currentGamepadState[i][GAMEPAD_XBOX_BUTTON_RIGHT] = ((reading.Buttons & GamepadButtons::DPadRight) == GamepadButtons::DPadRight); - currentGamepadState[i][GAMEPAD_XBOX_BUTTON_DOWN] = ((reading.Buttons & GamepadButtons::DPadLeft) == GamepadButtons::DPadDown); - currentGamepadState[i][GAMEPAD_XBOX_BUTTON_LEFT] = ((reading.Buttons & GamepadButtons::DPadDown) == GamepadButtons::DPadLeft); - currentGamepadState[i][GAMEPAD_XBOX_BUTTON_HOME] = false; // Home button not supported by UWP - - // Get current axis state - gamepadAxisState[i][GAMEPAD_XBOX_AXIS_LEFT_X] = reading.LeftThumbstickX; - gamepadAxisState[i][GAMEPAD_XBOX_AXIS_LEFT_Y] = reading.LeftThumbstickY; - gamepadAxisState[i][GAMEPAD_XBOX_AXIS_RIGHT_X] = reading.RightThumbstickX; - gamepadAxisState[i][GAMEPAD_XBOX_AXIS_RIGHT_Y] = reading.RightThumbstickY; - gamepadAxisState[i][GAMEPAD_XBOX_AXIS_LT] = reading.LeftTrigger; - gamepadAxisState[i][GAMEPAD_XBOX_AXIS_RT] = reading.RightTrigger; - } - } - } - -} - /* OTHER CODE */ +//TODO: Remove or not... // Helper to convert a length in device-independent pixels (DIPs) to a length in physical pixels. inline float ConvertDipsToPixels(float dips, float dpi) { @@ -317,196 +27,65 @@ inline float ConvertDipsToPixels(float dips, float dpi) return floor(dips * dpi / dipsPerInch + 0.5f); // Round to nearest integer. } -// Implementation of the IFrameworkViewSource interface, necessary to run our app. -ref class SimpleApplicationSource 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^) { - auto simpleApplicationSource = ref new SimpleApplicationSource(); - CoreApplication::Run(simpleApplicationSource); + auto appSource = ref new ApplicationSource(); + CoreApplication::Run(appSource); return 0; } -App::App() : - mWindowClosed(false), - mWindowVisible(true) -{ -} - -// 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(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::Resuming += ref new EventHandler(this, &App::OnResuming); -} - -// Called when the CoreWindow object is created (or re-created). -void App::SetWindow(CoreWindow^ window) -{ - window->SizeChanged += ref new TypedEventHandler(this, &App::OnWindowSizeChanged); - window->VisibilityChanged += ref new TypedEventHandler(this, &App::OnVisibilityChanged); - window->Closed += ref new TypedEventHandler(this, &App::OnWindowClosed); - - window->PointerPressed += ref new TypedEventHandler(this, &App::PointerPressed); - window->PointerReleased += ref new TypedEventHandler(this, &App::PointerReleased); - window->PointerWheelChanged += ref new TypedEventHandler(this, &App::PointerWheelChanged); - window->KeyDown += ref new TypedEventHandler(this, &App::OnKeyDown); - window->KeyUp += ref new TypedEventHandler(this, &App::OnKeyUp); - - Windows::Devices::Input::MouseDevice::GetForCurrentView()->MouseMoved += ref new TypedEventHandler(this, &App::MouseMoved); - - DisplayInformation^ currentDisplayInformation = DisplayInformation::GetForCurrentView(); - currentDisplayInformation->DpiChanged += ref new TypedEventHandler(this, &App::OnDpiChanged); - currentDisplayInformation->OrientationChanged += ref new TypedEventHandler(this, &App::OnOrientationChanged); - - // The CoreWindow has been created, so EGL can be initialized. - - uwpWindow = (EGLNativeWindowType)window; - - InitWindow(800, 450, NULL); -} - -// Initializes scene resources -void App::Load(Platform::String^ entryPoint) -{ - // InitWindow() --> rlglInit() -} +App::App() {} static int posX = 100; static int posY = 100; static int time = 0; // This method is called after the window becomes active. -void App::Run() +void App::Update() { - while (!mWindowClosed) - { - if (mWindowVisible) - { - // Draw - BeginDrawing(); + // Draw + BeginDrawing(); + + ClearBackground(RAYWHITE); + + //posX += gamepadAxisState[GAMEPAD_PLAYER1][GAMEPAD_XBOX_AXIS_LEFT_X] * 5; + //posY += gamepadAxisState[GAMEPAD_PLAYER1][GAMEPAD_XBOX_AXIS_LEFT_Y] * -5; + DrawRectangle(posX, posY, 400, 100, RED); - ClearBackground(RAYWHITE); - - posX += gamepadAxisState[GAMEPAD_PLAYER1][GAMEPAD_XBOX_AXIS_LEFT_X] * 5; - posY += gamepadAxisState[GAMEPAD_PLAYER1][GAMEPAD_XBOX_AXIS_LEFT_Y] * -5; - DrawRectangle(posX, posY, 400, 100, RED); + DrawLine(0, 0, GetScreenWidth(), GetScreenHeight(), BLUE); - DrawLine(0, 0, GetScreenWidth(), GetScreenHeight(), BLUE); + auto mPos = GetMousePosition(); - DrawCircle(mousePosition.x, mousePosition.y, 40, BLUE); + DrawCircle(mPos.x, mPos.y, 40, BLUE); - if (IsKeyDown(KEY_S)) DrawCircle(100, 100, 100, BLUE); + if (IsKeyDown(KEY_S)) DrawCircle(100, 100, 100, BLUE); - if (IsKeyPressed(KEY_A)) - { - posX -= 50; - UWPEnableCursor(); - } + if (IsKeyPressed(KEY_A)) + { + posX -= 50; + //UWPEnableCursor(); + } + + if (IsKeyPressed(KEY_D)) + { + posX += 50; + //UWPDisableCursor(); + } - if (IsKeyPressed(KEY_D)) - { - posX += 50; - UWPDisableCursor(); - } + if (IsKeyDown(KEY_LEFT_ALT)) //Unable to get working on my PC + DrawRectangle(250, 250, 20, 20, BLACK); + if (IsKeyDown(KEY_BACKSPACE)) + DrawRectangle(280, 250, 20, 20, BLACK); + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) + DrawRectangle(280, 250, 20, 20, BLACK); - if (IsKeyDown(KEY_LEFT_ALT)) //Unable to get working on my PC - DrawRectangle(250, 250, 20, 20, BLACK); - if (IsKeyDown(KEY_BACKSPACE)) - DrawRectangle(280, 250, 20, 20, BLACK); - if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) - DrawRectangle(280, 250, 20, 20, BLACK); + static int pos = 0; + pos -= GetMouseWheelMove(); + + DrawRectangle(280, pos + 50, 20, 20, BLACK); + DrawRectangle(250, 280 + (time++ % 60), 10, 10, PURPLE); - static int pos = 0; - pos -= currentMouseWheelY; - - DrawRectangle(280, pos + 50, 20, 20, BLACK); - DrawRectangle(250, 280 + (time++ % 60), 10, 10, PURPLE); - - EndDrawing(); - - UWP_PollInput(); - - CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent); - } - else - { - CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessOneAndAllPending); - } - } - - CloseWindow(); -} - -// 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() -{ - // CloseWindow(); -} - -// Application lifecycle event handler. -void App::OnActivated(CoreApplicationView^ applicationView, IActivatedEventArgs^ args) -{ - // Run() won't start until the CoreWindow is activated. - CoreWindow::GetForCurrentThread()->Activate(); -} - -void App::OnResuming(Object^ sender, Object^ args) -{ - // Restore any data or state that was unloaded on suspend. By default, data - // and state are persisted when resuming from suspend. Note that this event - // does not occur if the app was previously terminated. -} - -void App::OnWindowSizeChanged(CoreWindow^ sender, WindowSizeChangedEventArgs^ args) -{ - // TODO: Update window and render area size - //m_deviceResources->SetLogicalSize(Size(sender->Bounds.Width, sender->Bounds.Height)); - //m_main->UpdateForWindowSizeChange(); -} - -// Window event handlers. -void App::OnVisibilityChanged(CoreWindow^ sender, VisibilityChangedEventArgs^ args) -{ - mWindowVisible = args->Visible; - - // raylib core has the variable windowMinimized to register state, - // it should be modifyed by this event... -} - -void App::OnWindowClosed(CoreWindow^ sender, CoreWindowEventArgs^ args) -{ - mWindowClosed = true; - - // raylib core has the variable windowShouldClose to register state, - // it should be modifyed by this event... -} - -void App::OnDpiChanged(DisplayInformation^ sender, Object^ args) -{ - //m_deviceResources->SetDpi(sender->LogicalDpi); - //m_main->UpdateForWindowSizeChange(); -} - -void App::OnOrientationChanged(DisplayInformation^ sender, Object^ args) -{ - //m_deviceResources->SetCurrentOrientation(sender->CurrentOrientation); - //m_main->UpdateForWindowSizeChange(); -} + EndDrawing(); +} \ No newline at end of file diff --git a/projects/VS2017.UWP/raylib.App.UWP/App.h b/projects/VS2017.UWP/raylib.App.UWP/App.h index 5b58528ba..edd21f263 100644 --- a/projects/VS2017.UWP/raylib.App.UWP/App.h +++ b/projects/VS2017.UWP/raylib.App.UWP/App.h @@ -4,46 +4,17 @@ #include "pch.h" +#define PCH "pch.h" +#include "BaseApp.h" + namespace raylibUWP { - ref class App sealed : public Windows::ApplicationModel::Core::IFrameworkView + ref class App sealed : public BaseApp { public: App(); // IFrameworkView Methods. - virtual void Initialize(Windows::ApplicationModel::Core::CoreApplicationView^ applicationView); - virtual void SetWindow(Windows::UI::Core::CoreWindow^ window); - virtual void Load(Platform::String^ entryPoint); - virtual void Run(); - virtual void Uninitialize(); - - protected: - - // Application lifecycle event handlers. - void OnActivated(Windows::ApplicationModel::Core::CoreApplicationView^ applicationView, Windows::ApplicationModel::Activation::IActivatedEventArgs^ args); - void OnResuming(Platform::Object^ sender, Platform::Object^ args); - - // Window event handlers. - 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 OnWindowClosed(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::CoreWindowEventArgs^ args); - - // 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); - void PointerReleased(Windows::UI::Core::CoreWindow ^sender, Windows::UI::Core::PointerEventArgs^ args); - void PointerWheelChanged(Windows::UI::Core::CoreWindow ^sender, Windows::UI::Core::PointerEventArgs^ args); - void MouseMoved(Windows::Devices::Input::MouseDevice^ mouseDevice, Windows::Devices::Input::MouseEventArgs^ 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); - - private: - - bool mWindowClosed; - bool mWindowVisible; + void Update() override; }; } diff --git a/projects/VS2017.UWP/raylib.App.UWP/BaseApp.h b/projects/VS2017.UWP/raylib.App.UWP/BaseApp.h new file mode 100644 index 000000000..7d1207182 --- /dev/null +++ b/projects/VS2017.UWP/raylib.App.UWP/BaseApp.h @@ -0,0 +1,372 @@ +/********************************************************************************************** +* +* 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 +* +* Copyright (c) 2013-2019 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 + +//EGL +#include + +#include "raylib.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; + +/* +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) +//static bool gamepadReady[MAX_GAMEPADS] = { false }; // Flag to know if gamepad is ready +//static float gamepadAxisState[MAX_GAMEPADS][MAX_GAMEPAD_AXIS]; // Gamepad axis state +//static char previousGamepadState[MAX_GAMEPADS][MAX_GAMEPAD_BUTTONS]; // Previous gamepad buttons state +//static char currentGamepadState[MAX_GAMEPADS][MAX_GAMEPAD_BUTTONS]; // Current gamepad buttons state + +CoreCursor ^regularCursor = ref new CoreCursor(CoreCursorType::Arrow, 0); // The "visible arrow" cursor type + +extern "C" { EGLNativeWindowType uwpWindow; }; + +bool isCursorHidden = false; + +void ShowCursor() +{ + CoreWindow::GetForCurrentThread()->PointerCursor = regularCursor; + isCursorHidden = false; +} + +void HideCursor() +{ + CoreWindow::GetForCurrentThread()->PointerCursor = nullptr; + isCursorHidden = true; +} + +bool IsCursorHidden() +{ + return isCursorHidden; +} + +void SetMousePosition(Vector2 position) +{ + CoreWindow ^window = CoreWindow::GetForCurrentThread(); + Point mousePosScreen = Point(position.x + window->Bounds.X, position.y + window->Bounds.Y); + window->PointerPosition = mousePosScreen; + UWPMousePosition(position.x, position.y); +} + +// Enables cursor (unlock cursor) +/*void UWPEnableCursor() +{ + UWPShowCursor(); + UWPSetMousePosition(GetMousePosition()); // The mouse is hidden in the center of the screen - move it to where it should appear + toggleCursorLock = false; +}*/ + +// Disables cursor (lock cursor) +/*void UWPDisableCursor() +{ + UWPHideCursor(); + toggleCursorLock = true; +}*/ + +namespace raylibUWP +{ + 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->PointerReleased += ref new TypedEventHandler(this, &BaseApp::PointerReleased); + 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. + + uwpWindow = (EGLNativeWindowType)window; + + InitWindow(800, 450, NULL); + } + + virtual void Load(Platform::String^ entryPoint) {} + + virtual void Run() + { + while (!mWindowClosed) + { + if (mWindowVisible) + { + //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 Mouse + { + CoreWindow ^window = CoreWindow::GetForCurrentThread(); + + //TODO: Mouse locking logic (Library wide??) + + /*if (toggleCursorLock) + { + // Track cursor movement delta, recenter it on the client + mousePosition.x += mouseDelta.x; + mousePosition.y += mouseDelta.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; + + UWPMousePosition(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. + + gamepadReady[i] = (i < Gamepad::Gamepads->Size); + } + + // Get current gamepad state + for (int i = 0; i < MAX_GAMEPADS; i++) + { + if (gamepadReady[i]) + { + // Register previous gamepad states + for (int k = 0; k < MAX_GAMEPAD_BUTTONS; k++) previousGamepadState[i][k] = currentGamepadState[i][k]; + + // 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 + currentGamepadState[i][GAMEPAD_XBOX_BUTTON_A] = ((reading.Buttons & GamepadButtons::A) == GamepadButtons::A); + currentGamepadState[i][GAMEPAD_XBOX_BUTTON_B] = ((reading.Buttons & GamepadButtons::B) == GamepadButtons::B); + currentGamepadState[i][GAMEPAD_XBOX_BUTTON_X] = ((reading.Buttons & GamepadButtons::X) == GamepadButtons::X); + currentGamepadState[i][GAMEPAD_XBOX_BUTTON_Y] = ((reading.Buttons & GamepadButtons::Y) == GamepadButtons::Y); + currentGamepadState[i][GAMEPAD_XBOX_BUTTON_LB] = ((reading.Buttons & GamepadButtons::LeftShoulder) == GamepadButtons::LeftShoulder); + currentGamepadState[i][GAMEPAD_XBOX_BUTTON_RB] = ((reading.Buttons & GamepadButtons::RightShoulder) == GamepadButtons::RightShoulder); + currentGamepadState[i][GAMEPAD_XBOX_BUTTON_SELECT] = ((reading.Buttons & GamepadButtons::View) == GamepadButtons::View); // Changed for XB1 Controller + currentGamepadState[i][GAMEPAD_XBOX_BUTTON_START] = ((reading.Buttons & GamepadButtons::Menu) == GamepadButtons::Menu); // Changed for XB1 Controller + currentGamepadState[i][GAMEPAD_XBOX_BUTTON_UP] = ((reading.Buttons & GamepadButtons::DPadUp) == GamepadButtons::DPadUp); + currentGamepadState[i][GAMEPAD_XBOX_BUTTON_RIGHT] = ((reading.Buttons & GamepadButtons::DPadRight) == GamepadButtons::DPadRight); + currentGamepadState[i][GAMEPAD_XBOX_BUTTON_DOWN] = ((reading.Buttons & GamepadButtons::DPadLeft) == GamepadButtons::DPadDown); + currentGamepadState[i][GAMEPAD_XBOX_BUTTON_LEFT] = ((reading.Buttons & GamepadButtons::DPadDown) == GamepadButtons::DPadLeft); + currentGamepadState[i][GAMEPAD_XBOX_BUTTON_HOME] = false; // Home button not supported by UWP + + // Get current axis state + gamepadAxisState[i][GAMEPAD_XBOX_AXIS_LEFT_X] = reading.LeftThumbstickX; + gamepadAxisState[i][GAMEPAD_XBOX_AXIS_LEFT_Y] = reading.LeftThumbstickY; + gamepadAxisState[i][GAMEPAD_XBOX_AXIS_RIGHT_X] = reading.RightThumbstickX; + gamepadAxisState[i][GAMEPAD_XBOX_AXIS_RIGHT_Y] = reading.RightThumbstickY; + gamepadAxisState[i][GAMEPAD_XBOX_AXIS_LT] = reading.LeftTrigger; + gamepadAxisState[i][GAMEPAD_XBOX_AXIS_RT] = 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) {} + + 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) + { + if (args->CurrentPoint->Properties->IsLeftButtonPressed) + { + UWPRegisterClick(MOUSE_LEFT_BUTTON, 1); + } + if (args->CurrentPoint->Properties->IsRightButtonPressed) + { + UWPRegisterClick(MOUSE_RIGHT_BUTTON, 1); + } + if (args->CurrentPoint->Properties->IsMiddleButtonPressed) + { + UWPRegisterClick(MOUSE_MIDDLE_BUTTON, 1); + } + } + + void PointerReleased(Windows::UI::Core::CoreWindow ^sender, Windows::UI::Core::PointerEventArgs^ args) + { + if (!(args->CurrentPoint->Properties->IsLeftButtonPressed)) + { + UWPRegisterClick(MOUSE_LEFT_BUTTON, 0); + } + if (!(args->CurrentPoint->Properties->IsRightButtonPressed)) + { + UWPRegisterClick(MOUSE_RIGHT_BUTTON, 0); + } + if (!(args->CurrentPoint->Properties->IsMiddleButtonPressed)) + { + UWPRegisterClick(MOUSE_MIDDLE_BUTTON, 0); + } + } + + void PointerWheelChanged(Windows::UI::Core::CoreWindow ^sender, Windows::UI::Core::PointerEventArgs^ args) + { + UWPScrollWheel(args->CurrentPoint->Properties->MouseWheelDelta); + } + + //For mouse delta? + //void MouseMoved(Windows::Devices::Input::MouseDevice^ mouseDevice, Windows::Devices::Input::MouseEventArgs^ args); + + void OnKeyDown(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::KeyEventArgs ^ args) + { + UWPRegisterKey((int)args->VirtualKey, 1); + } + + void OnKeyUp(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::KeyEventArgs ^ args) + { + //TODO: Fix hold errors + UWPRegisterKey((int)args->VirtualKey, 0); + } + + private: + + bool mWindowClosed = false; + bool mWindowVisible = true; + }; + + + 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 6dc1c2cad..421d72094 100644 --- a/projects/VS2017.UWP/raylib.App.UWP/raylib.App.UWP.vcxproj +++ b/projects/VS2017.UWP/raylib.App.UWP/raylib.App.UWP.vcxproj @@ -117,6 +117,7 @@ + diff --git a/src/camera.h b/src/camera.h index e103b2935..8c4ecb5a2 100644 --- a/src/camera.h +++ b/src/camera.h @@ -256,6 +256,7 @@ void SetCameraMode(Camera camera, int mode) //cameraAngle.y = -60.0f*DEG2RAD; // Camera angle in plane XY (0 aligned with X, move positive CW) playerEyesPosition = camera.position.y; + // Lock cursor for first person and third person cameras if ((mode == CAMERA_FIRST_PERSON) || (mode == CAMERA_THIRD_PERSON)) DisableCursor(); diff --git a/src/core.c b/src/core.c index 42c07774c..863f844f1 100644 --- a/src/core.c +++ b/src/core.c @@ -1018,6 +1018,8 @@ void SetClipboardText(const char *text) #endif } +#if !defined(PLATFORM_UWP) + // Show mouse cursor void ShowCursor(void) { @@ -1066,6 +1068,8 @@ void DisableCursor(void) cursorHidden = true; } +#endif + // Set background color (framebuffer clear color) void ClearBackground(Color color) { @@ -3090,7 +3094,7 @@ static void PollInputEvents(void) #if defined(PLATFORM_UWP) // Register previous keys states - for (int i = 0; i < 512; i++)previousKeyState[i] = currentKeyState[i]; + for (int i = 0; i < 512; i++) previousKeyState[i] = currentKeyState[i]; // Register previous mouse states previousMouseWheelY = currentMouseWheelY; @@ -4589,7 +4593,7 @@ static void *GamepadThread(void *arg) #if defined(PLATFORM_UWP) -void UWPRegisterKey(int key, int action) { +void UWPRegisterKey(int key, char action) { //Convert from virtualKey int actualKey = -1; @@ -4672,9 +4676,9 @@ void UWPScrollWheel(int delta) { currentMouseWheelY += delta; } -void UWPMouseMovement(float x, float y) { - mousePosition.x += x; - mousePosition.y += y; +void UWPMousePosition(float x, float y) { + mousePosition.x = x; + mousePosition.y = y; } void UWPMarkCursor(bool hidden) { diff --git a/src/raylib.h b/src/raylib.h index 03fede705..2e3d08cf6 100644 --- a/src/raylib.h +++ b/src/raylib.h @@ -914,21 +914,25 @@ RLAPI const char *GetClipboardText(void); // Get clipboa RLAPI void SetClipboardText(const char *text); // Set clipboard text content // UWP-related functions -#if defined(PLATFORM_UWP) -RLAPI void UWPRegisterKey(int key, int action); +#if defined(PLATFORM_UWP) + +RLAPI void UWPRegisterKey(int key, char action); RLAPI void UWPRegisterClick(int btn, char action); RLAPI void UWPScrollWheel(int delta); -RLAPI void UWPMouseMovement(float x, float y); +RLAPI void UWPMousePosition(float x, float y); RLAPI void UWPMarkCursor(bool hidden); -//Gamepad functionality? +//Gamepad functionality? + #endif // Cursor-related functions +#if !defined(PLATFORM_UWP) //These are implemented by BaseApp.h RLAPI void ShowCursor(void); // Shows cursor RLAPI void HideCursor(void); // Hides cursor RLAPI bool IsCursorHidden(void); // Check if cursor is not visible RLAPI void EnableCursor(void); // Enables cursor (unlock cursor) RLAPI void DisableCursor(void); // Disables cursor (lock cursor) +#endif // Drawing-related functions RLAPI void ClearBackground(Color color); // Set background color (framebuffer clear color)