UnrealXR/raylib
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

UWP rework (#1231)

Browse source 
* 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.
This commit is contained in:
Reece Mackie 2020-04-30 18:48:39 +01:00 • committed by GitHub
parent 2f454aa4b0
commit 4b03860810
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
13 changed files with 1162 additions and 901 deletions
Download patch file Download diff file Expand all files Collapse all files

522
projects/VS2017.UWP/raylib.App.UWP/App.cpp
View file

@ -1,26 +1,190 @@
#include "pch.h"
#include "app.h"
#include "raylib.h"
#include <Windows.h>
#include <raylib.h>
#include <uwp_events.h>
#include <gestures.h>
#include <chrono>
#include <thread>
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<Platform::String^>^)
{
auto appSource = ref new ApplicationSource<App>();
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<CoreApplicationView^, IActivatedEventArgs^>(this, &App::OnActivated);
// Logic for other event handlers could go here.
// Information about the Suspending and Resuming event handlers can be found here:
// http://msdn.microsoft.com/en-us/library/windows/apps/xaml/hh994930.aspx
CoreApplication::Suspending += ref new Windows::Foundation::EventHandler<Windows::ApplicationModel::SuspendingEventArgs^>(this, &App::OnSuspending);
CoreApplication::Resuming += ref new EventHandler<Platform::Object^>(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<CoreWindow^, WindowSizeChangedEventArgs^>(this, &App::OnWindowSizeChanged);
window->VisibilityChanged += ref new TypedEventHandler<CoreWindow^, VisibilityChangedEventArgs^>(this, &App::OnVisibilityChanged);
// Hook mouse pointer events
window->PointerPressed += ref new TypedEventHandler<CoreWindow^, PointerEventArgs^>(this, &App::OnPointerPressed);
window->PointerReleased += ref new Windows::Foundation::TypedEventHandler<Windows::UI::Core::CoreWindow^, Windows::UI::Core::PointerEventArgs^>(this, &App::OnPointerReleased);
window->PointerWheelChanged += ref new TypedEventHandler<CoreWindow^, PointerEventArgs^>(this, &App::OnPointerWheelChanged);
window->PointerMoved += ref new Windows::Foundation::TypedEventHandler<Windows::UI::Core::CoreWindow^, Windows::UI::Core::PointerEventArgs^>(this, &App::OnPointerMoved);
// Hook keyboard events.
window->KeyDown += ref new TypedEventHandler<CoreWindow^, KeyEventArgs^>(this, &App::OnKeyDown);
window->KeyUp += ref new TypedEventHandler<CoreWindow^, KeyEventArgs^>(this, &App::OnKeyUp);
window->CharacterReceived += ref new Windows::Foundation::TypedEventHandler<Windows::UI::Core::CoreWindow^, Windows::UI::Core::CharacterReceivedEventArgs^>(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<Windows::UI::Core::BackRequestedEventArgs^>(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<std::chrono::seconds>(delta).count();
});
UWPSetSleepFunc([](double seconds) { std::this_thread::sleep_for(std::chrono::duration<double>(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();
//----------------------------------------------------------------------------------
}
}
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();
}

51
projects/VS2017.UWP/raylib.App.UWP/App.h
View file

@ -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;
};
}

570
projects/VS2017.UWP/raylib.App.UWP/BaseApp.h
View file

@ -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 <chrono>
#include <memory>
#include <wrl.h>
//EGL
#include <EGL/eglplatform.h>
#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<CoreApplicationView^, IActivatedEventArgs^>(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<Platform::Object^>(this, &BaseApp::OnResuming);
}
virtual void SetWindow(Windows::UI::Core::CoreWindow^ window)
{
window->SizeChanged += ref new TypedEventHandler<CoreWindow^, WindowSizeChangedEventArgs^>(this, &BaseApp::OnWindowSizeChanged);
window->VisibilityChanged += ref new TypedEventHandler<CoreWindow^, VisibilityChangedEventArgs^>(this, &BaseApp::OnVisibilityChanged);
window->Closed += ref new TypedEventHandler<CoreWindow^, CoreWindowEventArgs^>(this, &BaseApp::OnWindowClosed);
window->PointerPressed += ref new TypedEventHandler<CoreWindow^, PointerEventArgs^>(this, &BaseApp::PointerPressed);
window->PointerWheelChanged += ref new TypedEventHandler<CoreWindow^, PointerEventArgs^>(this, &BaseApp::PointerWheelChanged);
window->KeyDown += ref new TypedEventHandler<CoreWindow ^, KeyEventArgs ^>(this, &BaseApp::OnKeyDown);
window->KeyUp += ref new TypedEventHandler<CoreWindow ^, KeyEventArgs ^>(this, &BaseApp::OnKeyUp);
Windows::Devices::Input::MouseDevice::GetForCurrentView()->MouseMoved += ref new TypedEventHandler<MouseDevice^, MouseEventArgs^>(this, &BaseApp::MouseMoved);
DisplayInformation^ currentDisplayInformation = DisplayInformation::GetForCurrentView();
currentDisplayInformation->DpiChanged += ref new TypedEventHandler<DisplayInformation^, Object^>(this, &BaseApp::OnDpiChanged);
currentDisplayInformation->OrientationChanged += ref new TypedEventHandler<DisplayInformation^, Object^>(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<std::chrono::seconds>(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<typename AppType>
ref class ApplicationSource sealed : Windows::ApplicationModel::Core::IFrameworkViewSource
{
public:
virtual Windows::ApplicationModel::Core::IFrameworkView^ CreateView()
{
return ref new AppType();
}
};

9
projects/VS2017.UWP/raylib.App.UWP/raylib.App.UWP.vcxproj
View file

@ -1,4 +1,4 @@
<?xml version="1.0" encoding="utf-8"?>
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
@ -33,7 +33,7 @@
<MinimumVisualStudioVersion>14.0</MinimumVisualStudioVersion>
<AppContainerApplication>true</AppContainerApplication>
<ApplicationType>Windows Store</ApplicationType>
<WindowsTargetPlatformVersion>10.0.17763.0</WindowsTargetPlatformVersion>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
<WindowsTargetPlatformMinVersion>10.0.17763.0</WindowsTargetPlatformMinVersion>
<ApplicationTypeRevision>10.0</ApplicationTypeRevision>
<ProjectName>raylib.App.UWP</ProjectName>
@ -139,7 +139,6 @@
</ItemGroup>
<ItemGroup>
<ClInclude Include="App.h" />
<ClInclude Include="BaseApp.h" />
<ClInclude Include="pch.h" />
</ItemGroup>
<ItemGroup>
@ -152,7 +151,6 @@
<AppxManifest Include="Package.appxmanifest">
<SubType>Designer</SubType>
</AppxManifest>
<None Include="packages.config" />
<None Include="raylib.App.UWP.TemporaryKey.pfx" />
</ItemGroup>
<ItemGroup>
@ -160,6 +158,9 @@
<Project>{ea91e088-7c71-4f32-b761-e054305cd519}</Project>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<None Include="packages.config" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
<Import Project="..\packages\ANGLE.WindowsStore.2.1.13\build\native\ANGLE.WindowsStore.targets" Condition="Exists('..\packages\ANGLE.WindowsStore.2.1.13\build\native\ANGLE.WindowsStore.targets')" />

7
projects/VS2017.UWP/raylib.App.UWP/raylib.App.UWP.vcxproj.filters
View file

@ -6,7 +6,6 @@
</ItemGroup>
<ItemGroup>
<ClInclude Include="App.h" />
<ClInclude Include="BaseApp.h" />
<ClInclude Include="pch.h" />
</ItemGroup>
<ItemGroup>
@ -29,12 +28,12 @@
<ItemGroup>
<AppxManifest Include="Package.appxmanifest" />
</ItemGroup>
<ItemGroup>
<None Include="packages.config" />
</ItemGroup>
<ItemGroup>
<Filter Include="Logo">
<UniqueIdentifier>{cdf72d55-f249-4ad6-9a91-f8a084e64933}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<None Include="packages.config" />
</ItemGroup>
</Project>

4
projects/VS2017.UWP/raylib.UWP/packages.config Normal file
View file

@ -0,0 +1,4 @@
<?xml version="1.0" encoding="utf-8"?>
<packages>
<package id="ANGLE.WindowsStore" version="2.1.13" targetFramework="native" />
</packages>

15
projects/VS2017.UWP/raylib.UWP/raylib.UWP.vcxproj
View file

@ -42,6 +42,7 @@
<ClInclude Include="..\..\..\src\raymath.h" />
<ClInclude Include="..\..\..\src\rlgl.h" />
<ClInclude Include="..\..\..\src\utils.h" />
<ClInclude Include="..\..\..\src\uwp_events.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\..\..\src\core.c" />
@ -52,6 +53,9 @@
<ClCompile Include="..\..\..\src\textures.c" />
<ClCompile Include="..\..\..\src\utils.c" />
</ItemGroup>
<ItemGroup>
<None Include="packages.config" />
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{ea91e088-7c71-4f32-b761-e054305cd519}</ProjectGuid>
<Keyword>StaticLibrary</Keyword>
@ -60,7 +64,7 @@
<MinimumVisualStudioVersion>14.0</MinimumVisualStudioVersion>
<AppContainerApplication>true</AppContainerApplication>
<ApplicationType>Windows Store</ApplicationType>
<WindowsTargetPlatformVersion>10.0.17763.0</WindowsTargetPlatformVersion>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
<WindowsTargetPlatformMinVersion>10.0.15063.0</WindowsTargetPlatformMinVersion>
<ApplicationTypeRevision>10.0</ApplicationTypeRevision>
</PropertyGroup>
@ -158,7 +162,7 @@
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<CompileAsWinRT>false</CompileAsWinRT>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;GRAPHICS_API_OPENGL_ES2;PLATFORM_UWP;_UNICODE;UNICODE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions>SUPPORT_GIF_RECORDING;_CRT_SECURE_NO_WARNINGS;GRAPHICS_API_OPENGL_ES2;PLATFORM_UWP;_UNICODE;UNICODE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>$(SolutionDir)packages\ANGLE.WindowsStore.2.1.13\Include;$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
</ClCompile>
<Link>
@ -239,5 +243,12 @@
</ItemDefinitionGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
<Import Project="..\packages\ANGLE.WindowsStore.2.1.13\build\native\ANGLE.WindowsStore.targets" Condition="Exists('..\packages\ANGLE.WindowsStore.2.1.13\build\native\ANGLE.WindowsStore.targets')" />
</ImportGroup>
<Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
<PropertyGroup>
<ErrorText>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}.</ErrorText>
</PropertyGroup>
<Error Condition="!Exists('..\packages\ANGLE.WindowsStore.2.1.13\build\native\ANGLE.WindowsStore.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\ANGLE.WindowsStore.2.1.13\build\native\ANGLE.WindowsStore.targets'))" />
</Target>
</Project>

4
projects/VS2017.UWP/raylib.UWP/raylib.UWP.vcxproj.filters
View file

@ -16,6 +16,7 @@
<ClInclude Include="..\..\..\src\external\stb_rect_pack.h" />
<ClInclude Include="..\..\..\src\external\stb_truetype.h" />
<ClInclude Include="..\..\..\src\external\stb_vorbis.h" />
<ClInclude Include="..\..\..\src\uwp_events.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\..\..\src\core.c" />
@ -26,4 +27,7 @@
<ClCompile Include="..\..\..\src\textures.c" />
<ClCompile Include="..\..\..\src\utils.c" />
</ItemGroup>
<ItemGroup>
<None Include="packages.config" />
</ItemGroup>
</Project>

629
src/core.c
View file

@ -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/<package>/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<IInspectable*>(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

1
src/rlgl.h
View file

@ -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/egl.h> // EGL library
#include <GLES2/gl2.h> // OpenGL ES 2.0 library
#include <GLES2/gl2ext.h> // OpenGL ES 2.0 extensions library

73
src/utils.c
View file

@ -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

59
src/utils.h
View file

@ -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

119
src/uwp_events.h Normal file
View file

@ -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