Implemented a ton more things, added BaseApp.h to provide common code to UWP apps.
This commit is contained in:
Reece Mackie
parent
66293622f9
commit
98e1097364
|
|
@ -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<Platform::String^>^)
|
||||
{
|
||||
auto simpleApplicationSource = ref new SimpleApplicationSource();
|
||||
CoreApplication::Run(simpleApplicationSource);
|
||||
auto appSource = ref new ApplicationSource<App>();
|
||||
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<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::Resuming += ref new EventHandler<Platform::Object^>(this, &App::OnResuming);
|
||||
}
|
||||
|
||||
// Called when the CoreWindow object is created (or re-created).
|
||||
void App::SetWindow(CoreWindow^ window)
|
||||
{
|
||||
window->SizeChanged += ref new TypedEventHandler<CoreWindow^, WindowSizeChangedEventArgs^>(this, &App::OnWindowSizeChanged);
|
||||
window->VisibilityChanged += ref new TypedEventHandler<CoreWindow^, VisibilityChangedEventArgs^>(this, &App::OnVisibilityChanged);
|
||||
window->Closed += ref new TypedEventHandler<CoreWindow^, CoreWindowEventArgs^>(this, &App::OnWindowClosed);
|
||||
|
||||
window->PointerPressed += ref new TypedEventHandler<CoreWindow^, PointerEventArgs^>(this, &App::PointerPressed);
|
||||
window->PointerReleased += ref new TypedEventHandler<CoreWindow^, PointerEventArgs^>(this, &App::PointerReleased);
|
||||
window->PointerWheelChanged += ref new TypedEventHandler<CoreWindow^, PointerEventArgs^>(this, &App::PointerWheelChanged);
|
||||
window->KeyDown += ref new TypedEventHandler<CoreWindow ^, KeyEventArgs ^>(this, &App::OnKeyDown);
|
||||
window->KeyUp += ref new TypedEventHandler<CoreWindow ^, KeyEventArgs ^>(this, &App::OnKeyUp);
|
||||
|
||||
Windows::Devices::Input::MouseDevice::GetForCurrentView()->MouseMoved += ref new TypedEventHandler<MouseDevice^, MouseEventArgs^>(this, &App::MouseMoved);
|
||||
|
||||
DisplayInformation^ currentDisplayInformation = DisplayInformation::GetForCurrentView();
|
||||
currentDisplayInformation->DpiChanged += ref new TypedEventHandler<DisplayInformation^, Object^>(this, &App::OnDpiChanged);
|
||||
currentDisplayInformation->OrientationChanged += ref new TypedEventHandler<DisplayInformation^, Object^>(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);
|
||||
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);
|
||||
//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);
|
||||
|
||||
DrawCircle(mousePosition.x, mousePosition.y, 40, BLUE);
|
||||
auto mPos = GetMousePosition();
|
||||
|
||||
if (IsKeyDown(KEY_S)) DrawCircle(100, 100, 100, BLUE);
|
||||
DrawCircle(mPos.x, mPos.y, 40, BLUE);
|
||||
|
||||
if (IsKeyPressed(KEY_A))
|
||||
{
|
||||
posX -= 50;
|
||||
UWPEnableCursor();
|
||||
}
|
||||
if (IsKeyDown(KEY_S)) DrawCircle(100, 100, 100, BLUE);
|
||||
|
||||
if (IsKeyPressed(KEY_D))
|
||||
{
|
||||
posX += 50;
|
||||
UWPDisableCursor();
|
||||
}
|
||||
if (IsKeyPressed(KEY_A))
|
||||
{
|
||||
posX -= 50;
|
||||
//UWPEnableCursor();
|
||||
}
|
||||
|
||||
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 (IsKeyPressed(KEY_D))
|
||||
{
|
||||
posX += 50;
|
||||
//UWPDisableCursor();
|
||||
}
|
||||
|
||||
static int pos = 0;
|
||||
pos -= currentMouseWheelY;
|
||||
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);
|
||||
|
||||
DrawRectangle(280, pos + 50, 20, 20, BLACK);
|
||||
DrawRectangle(250, 280 + (time++ % 60), 10, 10, PURPLE);
|
||||
static int pos = 0;
|
||||
pos -= GetMouseWheelMove();
|
||||
|
||||
EndDrawing();
|
||||
DrawRectangle(280, pos + 50, 20, 20, BLACK);
|
||||
DrawRectangle(250, 280 + (time++ % 60), 10, 10, PURPLE);
|
||||
|
||||
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();
|
||||
}
|
||||
|
|
@ -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;
|
||||
};
|
||||
}
|
||||
|
|
|
|||
372
projects/VS2017.UWP/raylib.App.UWP/BaseApp.h
Normal file
372
projects/VS2017.UWP/raylib.App.UWP/BaseApp.h
Normal file
|
|
@ -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 <memory>
|
||||
#include <wrl.h>
|
||||
|
||||
//EGL
|
||||
#include <EGL/eglplatform.h>
|
||||
|
||||
#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<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->PointerReleased += ref new TypedEventHandler<CoreWindow^, PointerEventArgs^>(this, &BaseApp::PointerReleased);
|
||||
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.
|
||||
|
||||
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<typename AppType>
|
||||
ref class ApplicationSource sealed : Windows::ApplicationModel::Core::IFrameworkViewSource
|
||||
{
|
||||
public:
|
||||
virtual Windows::ApplicationModel::Core::IFrameworkView^ CreateView()
|
||||
{
|
||||
return ref new AppType();
|
||||
}
|
||||
};
|
||||
}
|
||||
|
|
@ -117,6 +117,7 @@
|
|||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="App.h" />
|
||||
<ClInclude Include="BaseApp.h" />
|
||||
<ClInclude Include="pch.h" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
|
|
|
|||
|
|
@ -257,6 +257,7 @@ void SetCameraMode(Camera camera, int mode)
|
|||
|
||||
playerEyesPosition = camera.position.y;
|
||||
|
||||
|
||||
// Lock cursor for first person and third person cameras
|
||||
if ((mode == CAMERA_FIRST_PERSON) || (mode == CAMERA_THIRD_PERSON)) DisableCursor();
|
||||
else EnableCursor();
|
||||
|
|
|
|||
14
src/core.c
14
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) {
|
||||
|
|
|
|||
|
|
@ -915,20 +915,24 @@ RLAPI void SetClipboardText(const char *text); // Set clipboa
|
|||
|
||||
// UWP-related functions
|
||||
#if defined(PLATFORM_UWP)
|
||||
RLAPI void UWPRegisterKey(int key, int action);
|
||||
|
||||
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?
|
||||
|
||||
#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)
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user