Reorganized project templates folder

projects/Builder/README.md

@@ -0,0 +1,26 @@
+# Builder project template
+
+This is a project template to be used with [GNOME Builder](https://raw.githubusercontent.com/jubalh/raymario/master/meson.build).
+We use the [meson](https://raw.githubusercontent.com/jubalh/raymario/master/meson.build) build system here.
+
+We can compile our project via the command line:
+```
+meson build
+cd build
+ninja
+ninja install
+```
+
+Or can simply click on the `meson.build` file to open it with Builder.
+Alternatively you can open Builder first and click on the `open` button and the left top.
+
+We added comments to the file to give you an idea which values you should edit.
+For a full overview of options please check the [meson manual](http://mesonbuild.com/Manual.html).
+
+In the provided file we assume that the build file is located at the root folder of your project, and that all your sources are in a `src` subfolder.
+
+Check out the `examples` directory for a simple example on how to use this template.
+You can also look at [raymario](https://github.com/jubalh/raymario) for a slightly more complex example which also installs resource files.
+
+# Notice
+The files provided link against glfw3 and openAL because the latest stable version of raylib is version 1.8, which still needs this. For later versions these two dependencies are not necessary anymore.

projects/Builder/examples/README.md

@@ -0,0 +1 @@
+Open `meson.build` with Builder or run `meson build; cd build; ninja; ./core_basic_window` on the commandline to launch the example.

projects/Builder/examples/meson.build

@@ -0,0 +1,27 @@
+# This file should be in the main folder of your project
+
+# Replace 'projectname' with the name of your project
+# Replace '1.0' with its version
+project('core_basic_window', 'c', version: '1.0',
+        meson_version: '>= 0.39.1')
+
+# We want a C Compiler to be present
+cc = meson.get_compiler('c')
+
+# Find dependencies
+glfw_dep = dependency('glfw3')
+gl_dep = dependency('gl')
+openal_dep = dependency('openal')
+m_dep = cc.find_library('m', required : false)
+raylib_dep = cc.find_library('raylib', required : false)
+
+# List your source files here
+source_c = [
+  '../../../examples/core/core_basic_window.c',
+]
+
+# Build executable
+core_basic_window = executable('core_basic_window',
+  source_c,
+  dependencies : [ raylib_dep, glfw_dep, gl_dep, openal_dep, m_dep ],
+  install : true)

projects/Builder/meson.build

@@ -0,0 +1,28 @@
+# This file should be in the main folder of your project
+
+# Replace 'projectname' with the name of your project
+# Replace '1.0' with its version
+project('projectname', 'c', version: '1.0',
+        meson_version: '>= 0.39.1')
+
+# We want a C Compiler to be present
+cc = meson.get_compiler('c')
+
+# Find dependencies
+# glfw3 and openal are not needed for raylib > 1.8.0
+glfw_dep = dependency('glfw3')
+gl_dep = dependency('gl')
+openal_dep = dependency('openal')
+m_dep = cc.find_library('m', required : false)
+raylib_dep = cc.find_library('raylib', required : false)
+
+# List your source files here
+source_c = [
+  'src/main.c',
+]
+
+# Build executable
+projectname = executable('projectname',
+  source_c,
+  dependencies : [ raylib_dep, glfw_dep, gl_dep, openal_dep, m_dep ],
+  install : true)

projects/Notepad++/README.md

@@ -0,0 +1,19 @@
+### Notepad++ raylib config files
+
+This folder includes some useful files to config Notepad++ for raylib.
+
+#### raylib functions autocomplete - c_raylib.xml
+
+Autocomplete information for Notepad++. The contents of this file should be copied inside raylib\Notepad++\plugins\APIs\c.xml file.
+
+This file has been automatically generated using the provided tool: `raylib_npp_parser`
+
+This simple tool basically parses raylib.h header for functions starting by RLAPI, extracts all required information and generates de Notepad++ autocomplete XML equivalent.
+
+To use the tool, just drag and drop raylib.h over raylib_npp_parser program.
+
+#### Notepad++ NppExec compilation scripts - npes_saved.txt
+
+A series of scripts for Notepad++ NppExec plugin to compile raylib library and examples.
+
+

projects/Notepad++/raylib_npp_parser/raylib_npp_parser.c

@@ -0,0 +1,148 @@
+/**********************************************************************************************
+
+    raylib_npp_parser - raylib header parser to generate Notepad++ autocompletion data
+
+    This parser scans raylib.h for functions that start with RLAPI and generates Notepad++
+    autocompletion xml equivalent for function and parameters.
+
+    Converts:
+    RLAPI Color Fade(Color color, float alpha); // Color fade-in or fade-out, alpha goes from 0.0f to 1.0f
+
+    To:
+    <KeyWord name="Fade" func="yes">
+        <Overload retVal="Color" descr="Color fade-in or fade-out, alpha goes from 0.0 to 1.0">
+            <Param name="Color color" />
+            <Param name="float alpha" />
+        </Overload>
+    </KeyWord>
+    
+    NOTE: Generated XML text should be copied inside raylib\Notepad++\plugins\APIs\c.xml
+
+    LICENSE: zlib/libpng
+
+    raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified,
+    BSD-like license that allows static linking with closed source software:
+
+    Copyright (c) 2018 Ramon Santamaria (@raysan5)
+
+**********************************************************************************************/
+
+#include <stdio.h>
+#include <string.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+#define MAX_BUFFER_SIZE     512
+
+int main(int argc, char *argv[])
+{
+    if (argc > 1)
+    {
+        FILE *rFile = fopen(argv[1], "rt");
+        FILE *rxmlFile = fopen("raylib_npp.xml", "wt");
+        
+        if ((rFile == NULL) || (rxmlFile == NULL))
+        {
+            printf("File could not be opened.\n");
+            return 0;
+        }
+        
+        char *buffer = (char *)calloc(MAX_BUFFER_SIZE, 1);
+        int count = 0;
+
+        while (!feof(rFile))
+        {
+            // Read one full line
+            fgets(buffer, MAX_BUFFER_SIZE, rFile);
+            
+            if (buffer[0] == '/') fprintf(rxmlFile, "        <!--%.*s -->\n", strlen(buffer) - 3, buffer + 2);
+            else if (buffer[0] == '\n') fprintf(rxmlFile, "%s", buffer);      // Direct copy of code comments
+            else if (strncmp(buffer, "RLAPI", 5) == 0)      // raylib function declaration
+            {
+                char funcType[64];
+                char funcTypeAux[64];
+                char funcName[64];
+                char funcDesc[256];
+                
+                char params[128];
+                char paramType[8][16];
+                char paramName[8][32];
+                
+                int index = 0;
+                char *ptr = NULL;
+                
+                sscanf(buffer, "RLAPI %s %[^(]s", funcType, funcName);
+                
+                if (strcmp(funcType, "const") == 0)
+                {            
+                    sscanf(buffer, "RLAPI %s %s %[^(]s", funcType, funcTypeAux, funcName);
+                    strcat(funcType, " ");
+                    strcat(funcType, funcTypeAux);
+                }
+                
+                ptr = strchr(buffer, '/');
+                index = (int)(ptr - buffer);
+                
+                sscanf(buffer + index, "%[^\n]s", funcDesc);        // Read function comment after declaration
+                
+                ptr = strchr(buffer, '(');
+                
+                if (ptr != NULL) index = (int)(ptr - buffer);
+                else printf("Character not found!\n");
+                
+                sscanf(buffer + (index + 1), "%[^)]s", params);     // Read what's inside '(' and ')'
+
+                // Scan params string for number of func params, type and name
+                char *paramPtr[16];         // Allocate 16 pointers for possible parameters
+                int paramsCount = 0;
+                paramPtr[paramsCount] = strtok(params, ",");
+
+                if ((funcName[0] == '*') && (funcName[1] == '*')) fprintf(rxmlFile, "        <KeyWord name=\"%s\" func=\"yes\">\n", funcName + 2);
+                else if (funcName[0] == '*') fprintf(rxmlFile, "        <KeyWord name=\"%s\" func=\"yes\">\n", funcName + 1);
+                else fprintf(rxmlFile, "        <KeyWord name=\"%s\" func=\"yes\">\n", funcName);
+                
+                fprintf(rxmlFile, "            <Overload retVal=\"%s\" descr=\"%s\">", funcType, funcDesc + 3);
+                 
+                bool paramsVoid = false;
+                
+                char paramConst[8][16];
+
+                while (paramPtr[paramsCount] != NULL)
+                {
+                    sscanf(paramPtr[paramsCount], "%s %s\n", paramType[paramsCount], paramName[paramsCount]);
+                      
+                    if (strcmp(paramType[paramsCount], "void") == 0)
+                    {
+                        paramsVoid = true;
+                        break;
+                    }
+                    
+                    if ((strcmp(paramType[paramsCount], "const") == 0) || (strcmp(paramType[paramsCount], "unsigned") == 0))
+                    {
+                        sscanf(paramPtr[paramsCount], "%s %s %s\n", paramConst[paramsCount], paramType[paramsCount], paramName[paramsCount]);
+                        fprintf(rxmlFile, "\n                <Param name=\"%s %s %s\" />", paramConst[paramsCount], paramType[paramsCount], paramName[paramsCount]);
+                    }
+                    else if (strcmp(paramType[paramsCount], "...") == 0) fprintf(rxmlFile, "\n                <Param name=\"...\" />");
+                    else fprintf(rxmlFile, "\n                <Param name=\"%s %s\" />", paramType[paramsCount], paramName[paramsCount]);
+
+                    paramsCount++;
+                    paramPtr[paramsCount] = strtok(NULL, ",");
+                }
+                
+                fprintf(rxmlFile, "%s</Overload>\n", paramsVoid ? "" : "\n            ");
+                fprintf(rxmlFile, "        </KeyWord>\n");
+
+                count++;
+                printf("Function processed %02i: %s\n", count, funcName);
+                
+                memset(buffer, 0, MAX_BUFFER_SIZE);
+            }
+        }
+        
+        free(buffer);
+        fclose(rFile);
+        fclose(rxmlFile);
+    }
+
+    return 0;
+}

projects/Notepad++/raylib_npp_parser/raylib_to_parse.h

@@ -0,0 +1,459 @@
+//------------------------------------------------------------------------------------
+// Window and Graphics Device Functions (Module: core)
+//------------------------------------------------------------------------------------
+
+// Window-related functions
+RLAPI void InitWindow(int width, int height, const char *title);  // Initialize window and OpenGL context
+RLAPI void CloseWindow(void);                                     // Close window and unload OpenGL context
+RLAPI bool IsWindowReady(void);                                   // Check if window has been initialized successfully
+RLAPI bool WindowShouldClose(void);                               // Check if KEY_ESCAPE pressed or Close icon pressed
+RLAPI bool IsWindowMinimized(void);                               // Check if window has been minimized (or lost focus)
+RLAPI void ToggleFullscreen(void);                                // Toggle fullscreen mode (only PLATFORM_DESKTOP)
+RLAPI void SetWindowIcon(Image image);                            // Set icon for window (only PLATFORM_DESKTOP)
+RLAPI void SetWindowTitle(const char *title);                     // Set title for window (only PLATFORM_DESKTOP)
+RLAPI void SetWindowPosition(int x, int y);                       // Set window position on screen (only PLATFORM_DESKTOP)
+RLAPI void SetWindowMonitor(int monitor);                         // Set monitor for the current window (fullscreen mode)
+RLAPI void SetWindowMinSize(int width, int height);               // Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE)
+RLAPI void SetWindowSize(int width, int height);                  // Set window dimensions
+RLAPI int GetScreenWidth(void);                                   // Get current screen width
+RLAPI int GetScreenHeight(void);                                  // Get current screen height
+
+// Cursor-related functions
+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)
+
+// Drawing-related functions
+RLAPI void ClearBackground(Color color);                          // Set background color (framebuffer clear color)
+RLAPI void BeginDrawing(void);                                    // Setup canvas (framebuffer) to start drawing
+RLAPI void EndDrawing(void);                                      // End canvas drawing and swap buffers (double buffering)
+RLAPI void BeginMode2D(Camera2D camera);                          // Initialize 2D mode with custom camera (2D)
+RLAPI void EndMode2D(void);                                       // Ends 2D mode with custom camera
+RLAPI void BeginMode3D(Camera3D camera);                          // Initializes 3D mode with custom camera (3D)
+RLAPI void EndMode3D(void);                                       // Ends 3D mode and returns to default 2D orthographic mode
+RLAPI void BeginTextureMode(RenderTexture2D target);              // Initializes render texture for drawing
+RLAPI void EndTextureMode(void);                                  // Ends drawing to render texture
+
+// Screen-space-related functions
+RLAPI Ray GetMouseRay(Vector2 mousePosition, Camera camera);      // Returns a ray trace from mouse position
+RLAPI Vector2 GetWorldToScreen(Vector3 position, Camera camera);  // Returns the screen space position for a 3d world space position
+RLAPI Matrix GetCameraMatrix(Camera camera);                      // Returns camera transform matrix (view matrix)
+
+// Timming-related functions
+RLAPI void SetTargetFPS(int fps);                                 // Set target FPS (maximum)
+RLAPI int GetFPS(void);                                           // Returns current FPS
+RLAPI float GetFrameTime(void);                                   // Returns time in seconds for last frame drawn
+RLAPI double GetTime(void);                                       // Returns elapsed time in seconds since InitWindow()
+
+// Color-related functions
+RLAPI int ColorToInt(Color color);                                // Returns hexadecimal value for a Color
+RLAPI Vector4 ColorNormalize(Color color);                        // Returns color normalized as float [0..1]
+RLAPI Vector3 ColorToHSV(Color color);                            // Returns HSV values for a Color
+RLAPI Color GetColor(int hexValue);                               // Returns a Color struct from hexadecimal value
+RLAPI Color Fade(Color color, float alpha);                       // Color fade-in or fade-out, alpha goes from 0.0f to 1.0f
+
+// Misc. functions
+RLAPI void ShowLogo(void);                                        // Activate raylib logo at startup (can be done with flags)
+RLAPI void SetConfigFlags(unsigned char flags);                   // Setup window configuration flags (view FLAGS)
+RLAPI void SetTraceLog(unsigned char types);                      // Enable trace log message types (bit flags based)
+RLAPI void TraceLog(int logType, const char *text, ...);          // Show trace log messages (LOG_INFO, LOG_WARNING, LOG_ERROR, LOG_DEBUG)
+RLAPI void TakeScreenshot(const char *fileName);                  // Takes a screenshot of current screen (saved a .png)
+RLAPI int GetRandomValue(int min, int max);                       // Returns a random value between min and max (both included)
+
+// Files management functions
+RLAPI bool IsFileExtension(const char *fileName, const char *ext);// Check file extension
+RLAPI const char *GetExtension(const char *fileName);             // Get pointer to extension for a filename string
+RLAPI const char *GetFileName(const char *filePath);              // Get pointer to filename for a path string
+RLAPI const char *GetDirectoryPath(const char *fileName);         // Get full path for a given fileName (uses static string)
+RLAPI const char *GetWorkingDirectory(void);                      // Get current working directory (uses static string)
+RLAPI bool ChangeDirectory(const char *dir);                      // Change working directory, returns true if success
+RLAPI bool IsFileDropped(void);                                   // Check if a file has been dropped into window
+RLAPI char **GetDroppedFiles(int *count);                         // Get dropped files names
+RLAPI void ClearDroppedFiles(void);                               // Clear dropped files paths buffer
+
+// Persistent storage management
+RLAPI void StorageSaveValue(int position, int value);             // Save integer value to storage file (to defined position)
+RLAPI int StorageLoadValue(int position);                         // Load integer value from storage file (from defined position)
+
+//------------------------------------------------------------------------------------
+// Input Handling Functions (Module: core)
+//------------------------------------------------------------------------------------
+
+// Input-related functions: keyboard
+RLAPI bool IsKeyPressed(int key);                             // Detect if a key has been pressed once
+RLAPI bool IsKeyDown(int key);                                // Detect if a key is being pressed
+RLAPI bool IsKeyReleased(int key);                            // Detect if a key has been released once
+RLAPI bool IsKeyUp(int key);                                  // Detect if a key is NOT being pressed
+RLAPI int GetKeyPressed(void);                                // Get latest key pressed
+RLAPI void SetExitKey(int key);                               // Set a custom key to exit program (default is ESC)
+
+// Input-related functions: gamepads
+RLAPI bool IsGamepadAvailable(int gamepad);                   // Detect if a gamepad is available
+RLAPI bool IsGamepadName(int gamepad, const char *name);      // Check gamepad name (if available)
+RLAPI const char *GetGamepadName(int gamepad);                // Return gamepad internal name id
+RLAPI bool IsGamepadButtonPressed(int gamepad, int button);   // Detect if a gamepad button has been pressed once
+RLAPI bool IsGamepadButtonDown(int gamepad, int button);      // Detect if a gamepad button is being pressed
+RLAPI bool IsGamepadButtonReleased(int gamepad, int button);  // Detect if a gamepad button has been released once
+RLAPI bool IsGamepadButtonUp(int gamepad, int button);        // Detect if a gamepad button is NOT being pressed
+RLAPI int GetGamepadButtonPressed(void);                      // Get the last gamepad button pressed
+RLAPI int GetGamepadAxisCount(int gamepad);                   // Return gamepad axis count for a gamepad
+RLAPI float GetGamepadAxisMovement(int gamepad, int axis);    // Return axis movement value for a gamepad axis
+
+// Input-related functions: mouse
+RLAPI bool IsMouseButtonPressed(int button);                  // Detect if a mouse button has been pressed once
+RLAPI bool IsMouseButtonDown(int button);                     // Detect if a mouse button is being pressed
+RLAPI bool IsMouseButtonReleased(int button);                 // Detect if a mouse button has been released once
+RLAPI bool IsMouseButtonUp(int button);                       // Detect if a mouse button is NOT being pressed
+RLAPI int GetMouseX(void);                                    // Returns mouse position X
+RLAPI int GetMouseY(void);                                    // Returns mouse position Y
+RLAPI Vector2 GetMousePosition(void);                         // Returns mouse position XY
+RLAPI void SetMousePosition(Vector2 position);                // Set mouse position XY
+RLAPI void SetMouseScale(float scale);                        // Set mouse scaling
+RLAPI int GetMouseWheelMove(void);                            // Returns mouse wheel movement Y
+
+// Input-related functions: touch
+RLAPI int GetTouchX(void);                                    // Returns touch position X for touch point 0 (relative to screen size)
+RLAPI int GetTouchY(void);                                    // Returns touch position Y for touch point 0 (relative to screen size)
+RLAPI Vector2 GetTouchPosition(int index);                    // Returns touch position XY for a touch point index (relative to screen size)
+
+//------------------------------------------------------------------------------------
+// Gestures and Touch Handling Functions (Module: gestures)
+//------------------------------------------------------------------------------------
+RLAPI void SetGesturesEnabled(unsigned int gestureFlags);     // Enable a set of gestures using flags
+RLAPI bool IsGestureDetected(int gesture);                    // Check if a gesture have been detected
+RLAPI int GetGestureDetected(void);                           // Get latest detected gesture
+RLAPI int GetTouchPointsCount(void);                          // Get touch points count
+RLAPI float GetGestureHoldDuration(void);                     // Get gesture hold time in milliseconds
+RLAPI Vector2 GetGestureDragVector(void);                     // Get gesture drag vector
+RLAPI float GetGestureDragAngle(void);                        // Get gesture drag angle
+RLAPI Vector2 GetGesturePinchVector(void);                    // Get gesture pinch delta
+RLAPI float GetGesturePinchAngle(void);                       // Get gesture pinch angle
+
+//------------------------------------------------------------------------------------
+// Camera System Functions (Module: camera)
+//------------------------------------------------------------------------------------
+RLAPI void SetCameraMode(Camera camera, int mode);                // Set camera mode (multiple camera modes available)
+RLAPI void UpdateCamera(Camera *camera);                          // Update camera position for selected mode
+
+RLAPI void SetCameraPanControl(int panKey);                       // Set camera pan key to combine with mouse movement (free camera)
+RLAPI void SetCameraAltControl(int altKey);                       // Set camera alt key to combine with mouse movement (free camera)
+RLAPI void SetCameraSmoothZoomControl(int szKey);                 // Set camera smooth zoom key to combine with mouse (free camera)
+RLAPI void SetCameraMoveControls(int frontKey, int backKey, int rightKey, int leftKey, int upKey, int downKey); // Set camera move controls (1st person and 3rd person cameras)
+
+//------------------------------------------------------------------------------------
+// Basic Shapes Drawing Functions (Module: shapes)
+//------------------------------------------------------------------------------------
+
+// Basic shapes drawing functions
+RLAPI void DrawPixel(int posX, int posY, Color color);                                                   // Draw a pixel
+RLAPI void DrawPixelV(Vector2 position, Color color);                                                    // Draw a pixel (Vector version)
+RLAPI void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, Color color);                // Draw a line
+RLAPI void DrawLineV(Vector2 startPos, Vector2 endPos, Color color);                                     // Draw a line (Vector version)
+RLAPI void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color);                       // Draw a line defining thickness
+RLAPI void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color);                   // Draw a line using cubic-bezier curves in-out
+RLAPI void DrawCircle(int centerX, int centerY, float radius, Color color);                              // Draw a color-filled circle
+RLAPI void DrawCircleGradient(int centerX, int centerY, float radius, Color color1, Color color2);       // Draw a gradient-filled circle
+RLAPI void DrawCircleV(Vector2 center, float radius, Color color);                                       // Draw a color-filled circle (Vector version)
+RLAPI void DrawCircleLines(int centerX, int centerY, float radius, Color color);                         // Draw circle outline
+RLAPI void DrawRectangle(int posX, int posY, int width, int height, Color color);                        // Draw a color-filled rectangle
+RLAPI void DrawRectangleV(Vector2 position, Vector2 size, Color color);                                  // Draw a color-filled rectangle (Vector version)
+RLAPI void DrawRectangleRec(Rectangle rec, Color color);                                                 // Draw a color-filled rectangle
+RLAPI void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color);                 // Draw a color-filled rectangle with pro parameters
+RLAPI void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a vertical-gradient-filled rectangle
+RLAPI void DrawRectangleGradientH(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a horizontal-gradient-filled rectangle
+RLAPI void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4);       // Draw a gradient-filled rectangle with custom vertex colors
+RLAPI void DrawRectangleLines(int posX, int posY, int width, int height, Color color);                   // Draw rectangle outline
+RLAPI void DrawRectangleLinesEx(Rectangle rec, int lineThick, Color color);                              // Draw rectangle outline with extended parameters
+RLAPI void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color);                                // Draw a color-filled triangle
+RLAPI void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color);                           // Draw triangle outline
+RLAPI void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color);               // Draw a regular polygon (Vector version)
+RLAPI void DrawPolyEx(Vector2 *points, int numPoints, Color color);                                      // Draw a closed polygon defined by points
+RLAPI void DrawPolyExLines(Vector2 *points, int numPoints, Color color);                                 // Draw polygon lines
+
+// Basic shapes collision detection functions
+RLAPI bool CheckCollisionRecs(Rectangle rec1, Rectangle rec2);                                           // Check collision between two rectangles
+RLAPI bool CheckCollisionCircles(Vector2 center1, float radius1, Vector2 center2, float radius2);        // Check collision between two circles
+RLAPI bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec);                         // Check collision between circle and rectangle
+RLAPI Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2);                                         // Get collision rectangle for two rectangles collision
+RLAPI bool CheckCollisionPointRec(Vector2 point, Rectangle rec);                                         // Check if point is inside rectangle
+RLAPI bool CheckCollisionPointCircle(Vector2 point, Vector2 center, float radius);                       // Check if point is inside circle
+RLAPI bool CheckCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3);               // Check if point is inside a triangle
+
+//------------------------------------------------------------------------------------
+// Texture Loading and Drawing Functions (Module: textures)
+//------------------------------------------------------------------------------------
+
+// Image/Texture2D data loading/unloading/saving functions
+RLAPI Image LoadImage(const char *fileName);                                                             // Load image from file into CPU memory (RAM)
+RLAPI Image LoadImageEx(Color *pixels, int width, int height);                                           // Load image from Color array data (RGBA - 32bit)
+RLAPI Image LoadImagePro(void *data, int width, int height, int format);                                 // Load image from raw data with parameters
+RLAPI Image LoadImageRaw(const char *fileName, int width, int height, int format, int headerSize);       // Load image from RAW file data
+RLAPI void ExportImage(const char *fileName, Image image);                                               // Export image as a PNG file
+RLAPI Texture2D LoadTexture(const char *fileName);                                                       // Load texture from file into GPU memory (VRAM)
+RLAPI Texture2D LoadTextureFromImage(Image image);                                                       // Load texture from image data
+RLAPI RenderTexture2D LoadRenderTexture(int width, int height);                                          // Load texture for rendering (framebuffer)
+RLAPI void UnloadImage(Image image);                                                                     // Unload image from CPU memory (RAM)
+RLAPI void UnloadTexture(Texture2D texture);                                                             // Unload texture from GPU memory (VRAM)
+RLAPI void UnloadRenderTexture(RenderTexture2D target);                                                  // Unload render texture from GPU memory (VRAM)
+RLAPI Color *GetImageData(Image image);                                                                  // Get pixel data from image as a Color struct array
+RLAPI int GetPixelDataSize(int width, int height, int format);                                           // Get pixel data size in bytes (image or texture)
+RLAPI Image GetTextureData(Texture2D texture);                                                           // Get pixel data from GPU texture and return an Image
+RLAPI void UpdateTexture(Texture2D texture, const void *pixels);                                         // Update GPU texture with new data
+
+// Image manipulation functions
+RLAPI Image ImageCopy(Image image);                                                                      // Create an image duplicate (useful for transformations)
+RLAPI void ImageToPOT(Image *image, Color fillColor);                                                    // Convert image to POT (power-of-two)
+RLAPI void ImageFormat(Image *image, int newFormat);                                                     // Convert image data to desired format
+RLAPI void ImageAlphaMask(Image *image, Image alphaMask);                                                // Apply alpha mask to image
+RLAPI void ImageAlphaClear(Image *image, Color color, float threshold);                                  // Clear alpha channel to desired color
+RLAPI void ImageAlphaCrop(Image *image, float threshold);                                                // Crop image depending on alpha value
+RLAPI void ImageAlphaPremultiply(Image *image);                                                          // Premultiply alpha channel
+RLAPI void ImageCrop(Image *image, Rectangle crop);                                                      // Crop an image to a defined rectangle
+RLAPI void ImageResize(Image *image, int newWidth, int newHeight);                                       // Resize and image (bilinear filtering)
+RLAPI void ImageResizeNN(Image *image,int newWidth,int newHeight);                                       // Resize and image (Nearest-Neighbor scaling algorithm)
+RLAPI void ImageMipmaps(Image *image);                                                                   // Generate all mipmap levels for a provided image
+RLAPI void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp);                            // Dither image data to 16bpp or lower (Floyd-Steinberg dithering)
+RLAPI Image ImageText(const char *text, int fontSize, Color color);                                      // Create an image from text (default font)
+RLAPI Image ImageTextEx(Font font, const char *text, float fontSize, float spacing, Color tint);     // Create an image from text (custom sprite font)
+RLAPI void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec);                         // Draw a source image within a destination image
+RLAPI void ImageDrawRectangle(Image *dst, Vector2 position, Rectangle rec, Color color);                 // Draw rectangle within an image
+RLAPI void ImageDrawText(Image *dst, Vector2 position, const char *text, int fontSize, Color color);     // Draw text (default font) within an image (destination)
+RLAPI void ImageDrawTextEx(Image *dst, Vector2 position, Font font, const char *text, float fontSize, float spacing, Color color); // Draw text (custom sprite font) within an image (destination)
+RLAPI void ImageFlipVertical(Image *image);                                                              // Flip image vertically
+RLAPI void ImageFlipHorizontal(Image *image);                                                            // Flip image horizontally
+RLAPI void ImageColorTint(Image *image, Color color);                                                    // Modify image color: tint
+RLAPI void ImageColorInvert(Image *image);                                                               // Modify image color: invert
+RLAPI void ImageColorGrayscale(Image *image);                                                            // Modify image color: grayscale
+RLAPI void ImageColorContrast(Image *image, float contrast);                                             // Modify image color: contrast (-100 to 100)
+RLAPI void ImageColorBrightness(Image *image, int brightness);                                           // Modify image color: brightness (-255 to 255)
+
+// Image generation functions
+RLAPI Image GenImageColor(int width, int height, Color color);                                           // Generate image: plain color
+RLAPI Image GenImageGradientV(int width, int height, Color top, Color bottom);                           // Generate image: vertical gradient
+RLAPI Image GenImageGradientH(int width, int height, Color left, Color right);                           // Generate image: horizontal gradient
+RLAPI Image GenImageGradientRadial(int width, int height, float density, Color inner, Color outer);      // Generate image: radial gradient
+RLAPI Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2);    // Generate image: checked
+RLAPI Image GenImageWhiteNoise(int width, int height, float factor);                                     // Generate image: white noise
+RLAPI Image GenImagePerlinNoise(int width, int height, int offsetX, int offsetY, float scale);           // Generate image: perlin noise
+RLAPI Image GenImageCellular(int width, int height, int tileSize);                                       // Generate image: cellular algorithm. Bigger tileSize means bigger cells
+
+// Texture2D configuration functions
+RLAPI void GenTextureMipmaps(Texture2D *texture);                                                        // Generate GPU mipmaps for a texture
+RLAPI void SetTextureFilter(Texture2D texture, int filterMode);                                          // Set texture scaling filter mode
+RLAPI void SetTextureWrap(Texture2D texture, int wrapMode);                                              // Set texture wrapping mode
+
+// Texture2D drawing functions
+RLAPI void DrawTexture(Texture2D texture, int posX, int posY, Color tint);                               // Draw a Texture2D
+RLAPI void DrawTextureV(Texture2D texture, Vector2 position, Color tint);                                // Draw a Texture2D with position defined as Vector2
+RLAPI void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint);  // Draw a Texture2D with extended parameters
+RLAPI void DrawTextureRec(Texture2D texture, Rectangle sourceRec, Vector2 position, Color tint);         // Draw a part of a texture defined by a rectangle
+RLAPI void DrawTexturePro(Texture2D texture, Rectangle sourceRec, Rectangle destRec, Vector2 origin, float rotation, Color tint); // Draw a part of a texture defined by a rectangle with 'pro' parameters
+                    
+
+//------------------------------------------------------------------------------------
+// Font Loading and Text Drawing Functions (Module: text)
+//------------------------------------------------------------------------------------
+
+// Font loading/unloading functions
+RLAPI Font GetDefaultFont(void);                                                                   // Get the default Font
+RLAPI Font LoadFont(const char *fileName);                                                   // Load Font from file into GPU memory (VRAM)
+RLAPI Font LoadFontEx(const char *fileName, int fontSize, int charsCount, int *fontChars);   // Load Font from file with extended parameters
+RLAPI void UnloadFont(Font font);                                                            // Unload Font from GPU memory (VRAM)
+
+// Text drawing functions
+RLAPI void DrawFPS(int posX, int posY);                                                                  // Shows current FPS
+RLAPI void DrawText(const char *text, int posX, int posY, int fontSize, Color color);                    // Draw text (using default font)
+RLAPI void DrawTextEx(Font font, const char* text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text using Font and additional parameters
+
+// Text misc. functions
+RLAPI int MeasureText(const char *text, int fontSize);                                                   // Measure string width for default font
+RLAPI Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing);           // Measure string size for Font
+RLAPI const char *FormatText(const char *text, ...);                                                     // Formatting of text with variables to 'embed'
+RLAPI const char *SubText(const char *text, int position, int length);                                   // Get a piece of a text string
+RLAPI int GetGlyphIndex(Font font, int character);                                                 // Returns index position for a unicode character on sprite font
+
+//------------------------------------------------------------------------------------
+// Basic 3d Shapes Drawing Functions (Module: models)
+//------------------------------------------------------------------------------------
+
+// Basic geometric 3D shapes drawing functions
+RLAPI void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color);                                    // Draw a line in 3D world space
+RLAPI void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color); // Draw a circle in 3D world space
+RLAPI void DrawCube(Vector3 position, float width, float height, float length, Color color);             // Draw cube
+RLAPI void DrawCubeV(Vector3 position, Vector3 size, Color color);                                       // Draw cube (Vector version)
+RLAPI void DrawCubeWires(Vector3 position, float width, float height, float length, Color color);        // Draw cube wires
+RLAPI void DrawCubeTexture(Texture2D texture, Vector3 position, float width, float height, float length, Color color); // Draw cube textured
+RLAPI void DrawSphere(Vector3 centerPos, float radius, Color color);                                     // Draw sphere
+RLAPI void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color);            // Draw sphere with extended parameters
+RLAPI void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color);         // Draw sphere wires
+RLAPI void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone
+RLAPI void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone wires
+RLAPI void DrawPlane(Vector3 centerPos, Vector2 size, Color color);                                      // Draw a plane XZ
+RLAPI void DrawRay(Ray ray, Color color);                                                                // Draw a ray line
+RLAPI void DrawGrid(int slices, float spacing);                                                          // Draw a grid (centered at (0, 0, 0))
+RLAPI void DrawGizmo(Vector3 position);                                                                  // Draw simple gizmo
+//DrawTorus(), DrawTeapot() could be useful?
+
+//------------------------------------------------------------------------------------
+// Model 3d Loading and Drawing Functions (Module: models)
+//------------------------------------------------------------------------------------
+
+// Model loading/unloading functions
+RLAPI Model LoadModel(const char *fileName);                                                            // Load model from files (mesh and material)
+RLAPI Model LoadModelFromMesh(Mesh mesh);                                                               // Load model from generated mesh
+RLAPI void UnloadModel(Model model);                                                                    // Unload model from memory (RAM and/or VRAM)
+
+// Mesh loading/unloading functions
+RLAPI Mesh LoadMesh(const char *fileName);                                                              // Load mesh from file
+RLAPI void UnloadMesh(Mesh *mesh);                                                                      // Unload mesh from memory (RAM and/or VRAM)
+RLAPI void ExportMesh(const char *fileName, Mesh mesh);                                                 // Export mesh as an OBJ file
+
+// Mesh manipulation functions
+RLAPI BoundingBox MeshBoundingBox(Mesh mesh);                                                           // Compute mesh bounding box limits
+RLAPI void MeshTangents(Mesh *mesh);                                                                    // Compute mesh tangents 
+RLAPI void MeshBinormals(Mesh *mesh);                                                                   // Compute mesh binormals
+
+// Mesh generation functions
+RLAPI Mesh GenMeshPlane(float width, float length, int resX, int resZ);                                 // Generate plane mesh (with subdivisions)
+RLAPI Mesh GenMeshCube(float width, float height, float length);                                        // Generate cuboid mesh
+RLAPI Mesh GenMeshSphere(float radius, int rings, int slices);                                          // Generate sphere mesh (standard sphere)
+RLAPI Mesh GenMeshHemiSphere(float radius, int rings, int slices);                                      // Generate half-sphere mesh (no bottom cap)
+RLAPI Mesh GenMeshCylinder(float radius, float height, int slices);                                     // Generate cylinder mesh
+RLAPI Mesh GenMeshTorus(float radius, float size, int radSeg, int sides);                               // Generate torus mesh
+RLAPI Mesh GenMeshKnot(float radius, float size, int radSeg, int sides);                                // Generate trefoil knot mesh
+RLAPI Mesh GenMeshHeightmap(Image heightmap, Vector3 size);                                             // Generate heightmap mesh from image data
+RLAPI Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize);                                           // Generate cubes-based map mesh from image data
+
+// Material loading/unloading functions
+RLAPI Material LoadMaterial(const char *fileName);                                                      // Load material from file
+RLAPI Material LoadMaterialDefault(void);                                                               // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps)
+RLAPI void UnloadMaterial(Material material);                                                           // Unload material from GPU memory (VRAM)
+
+// Model drawing functions
+RLAPI void DrawModel(Model model, Vector3 position, float scale, Color tint);                           // Draw a model (with texture if set)
+RLAPI void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model with extended parameters
+RLAPI void DrawModelWires(Model model, Vector3 position, float scale, Color tint);                      // Draw a model wires (with texture if set)
+RLAPI void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model wires (with texture if set) with extended parameters
+RLAPI void DrawBoundingBox(BoundingBox box, Color color);                                               // Draw bounding box (wires)
+RLAPI void DrawBillboard(Camera camera, Texture2D texture, Vector3 center, float size, Color tint);     // Draw a billboard texture
+RLAPI void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle sourceRec, Vector3 center, float size, Color tint); // Draw a billboard texture defined by sourceRec
+
+// Collision detection functions
+RLAPI bool CheckCollisionSpheres(Vector3 centerA, float radiusA, Vector3 centerB, float radiusB);       // Detect collision between two spheres
+RLAPI bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2);                                     // Detect collision between two bounding boxes
+RLAPI bool CheckCollisionBoxSphere(BoundingBox box, Vector3 centerSphere, float radiusSphere);          // Detect collision between box and sphere
+RLAPI bool CheckCollisionRaySphere(Ray ray, Vector3 spherePosition, float sphereRadius);                // Detect collision between ray and sphere
+RLAPI bool CheckCollisionRaySphereEx(Ray ray, Vector3 spherePosition, float sphereRadius, Vector3 *collisionPoint); // Detect collision between ray and sphere, returns collision point
+RLAPI bool CheckCollisionRayBox(Ray ray, BoundingBox box);                                              // Detect collision between ray and box
+RLAPI RayHitInfo GetCollisionRayModel(Ray ray, Model *model);                                           // Get collision info between ray and model
+RLAPI RayHitInfo GetCollisionRayTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3);                  // Get collision info between ray and triangle
+RLAPI RayHitInfo GetCollisionRayGround(Ray ray, float groundHeight);                                    // Get collision info between ray and ground plane (Y-normal plane)
+
+//------------------------------------------------------------------------------------
+// Shaders System Functions (Module: rlgl)
+// NOTE: This functions are useless when using OpenGL 1.1
+//------------------------------------------------------------------------------------
+
+// Shader loading/unloading functions
+RLAPI char *LoadText(const char *fileName);                               // Load chars array from text file
+RLAPI Shader LoadShader(const char *vsFileName, const char *fsFileName);  // Load shader from files and bind default locations
+RLAPI Shader LoadShaderCode(char *vsCode, char *fsCode);                  // Load shader from code strings and bind default locations
+RLAPI void UnloadShader(Shader shader);                                   // Unload shader from GPU memory (VRAM)
+
+RLAPI Shader GetShaderDefault(void);                                      // Get default shader
+RLAPI Texture2D GetTextureDefault(void);                                  // Get default texture
+
+// Shader configuration functions
+RLAPI int GetShaderLocation(Shader shader, const char *uniformName);              // Get shader uniform location
+RLAPI void SetShaderValue(Shader shader, int uniformLoc, const float *value, int size); // Set shader uniform value (float)
+RLAPI void SetShaderValuei(Shader shader, int uniformLoc, const int *value, int size);  // Set shader uniform value (int)
+RLAPI void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat);       // Set shader uniform value (matrix 4x4)
+RLAPI void SetMatrixProjection(Matrix proj);                              // Set a custom projection matrix (replaces internal projection matrix)
+RLAPI void SetMatrixModelview(Matrix view);                               // Set a custom modelview matrix (replaces internal modelview matrix)
+RLAPI Matrix GetMatrixModelview();                                        // Get internal modelview matrix
+
+// Texture maps generation (PBR)
+// NOTE: Required shaders should be provided
+RLAPI Texture2D GenTextureCubemap(Shader shader, Texture2D skyHDR, int size);       // Generate cubemap texture from HDR texture
+RLAPI Texture2D GenTextureIrradiance(Shader shader, Texture2D cubemap, int size);   // Generate irradiance texture using cubemap data
+RLAPI Texture2D GenTexturePrefilter(Shader shader, Texture2D cubemap, int size);    // Generate prefilter texture using cubemap data
+RLAPI Texture2D GenTextureBRDF(Shader shader, Texture2D cubemap, int size);         // Generate BRDF texture using cubemap data
+
+// Shading begin/end functions
+RLAPI void BeginShaderMode(Shader shader);                                // Begin custom shader drawing
+RLAPI void EndShaderMode(void);                                           // End custom shader drawing (use default shader)
+RLAPI void BeginBlendMode(int mode);                                      // Begin blending mode (alpha, additive, multiplied)
+RLAPI void EndBlendMode(void);                                            // End blending mode (reset to default: alpha blending)
+
+// VR control functions
+RLAPI VrDeviceInfo GetVrDeviceInfo(int vrDeviceType);   // Get VR device information for some standard devices
+RLAPI void InitVrSimulator(VrDeviceInfo info);          // Init VR simulator for selected device parameters
+RLAPI void CloseVrSimulator(void);                      // Close VR simulator for current device
+RLAPI bool IsVrSimulatorReady(void);                    // Detect if VR simulator is ready
+RLAPI void SetVrDistortionShader(Shader shader);        // Set VR distortion shader for stereoscopic rendering
+RLAPI void UpdateVrTracking(Camera *camera);            // Update VR tracking (position and orientation) and camera
+RLAPI void ToggleVrMode(void);                          // Enable/Disable VR experience
+RLAPI void BeginVrDrawing(void);                        // Begin VR simulator stereo rendering
+RLAPI void EndVrDrawing(void);                          // End VR simulator stereo rendering
+
+//------------------------------------------------------------------------------------
+// Audio Loading and Playing Functions (Module: audio)
+//------------------------------------------------------------------------------------
+
+// Audio device management functions
+RLAPI void InitAudioDevice(void);                                     // Initialize audio device and context
+RLAPI void CloseAudioDevice(void);                                    // Close the audio device and context
+RLAPI bool IsAudioDeviceReady(void);                                  // Check if audio device has been initialized successfully
+RLAPI void SetMasterVolume(float volume);                             // Set master volume (listener)
+
+// Wave/Sound loading/unloading functions
+RLAPI Wave LoadWave(const char *fileName);                            // Load wave data from file
+RLAPI Wave LoadWaveEx(void *data, int sampleCount, int sampleRate, int sampleSize, int channels); // Load wave data from raw array data
+RLAPI Sound LoadSound(const char *fileName);                          // Load sound from file
+RLAPI Sound LoadSoundFromWave(Wave wave);                             // Load sound from wave data
+RLAPI void UpdateSound(Sound sound, const void *data, int samplesCount);// Update sound buffer with new data
+RLAPI void UnloadWave(Wave wave);                                     // Unload wave data
+RLAPI void UnloadSound(Sound sound);                                  // Unload sound
+
+// Wave/Sound management functions
+RLAPI void PlaySound(Sound sound);                                    // Play a sound
+RLAPI void PauseSound(Sound sound);                                   // Pause a sound
+RLAPI void ResumeSound(Sound sound);                                  // Resume a paused sound
+RLAPI void StopSound(Sound sound);                                    // Stop playing a sound
+RLAPI bool IsSoundPlaying(Sound sound);                               // Check if a sound is currently playing
+RLAPI void SetSoundVolume(Sound sound, float volume);                 // Set volume for a sound (1.0 is max level)
+RLAPI void SetSoundPitch(Sound sound, float pitch);                   // Set pitch for a sound (1.0 is base level)
+RLAPI void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels);  // Convert wave data to desired format
+RLAPI Wave WaveCopy(Wave wave);                                       // Copy a wave to a new wave
+RLAPI void WaveCrop(Wave *wave, int initSample, int finalSample);     // Crop a wave to defined samples range
+RLAPI float *GetWaveData(Wave wave);                                  // Get samples data from wave as a floats array
+
+// Music management functions
+RLAPI Music LoadMusicStream(const char *fileName);                    // Load music stream from file
+RLAPI void UnloadMusicStream(Music music);                            // Unload music stream
+RLAPI void PlayMusicStream(Music music);                              // Start music playing
+RLAPI void UpdateMusicStream(Music music);                            // Updates buffers for music streaming
+RLAPI void StopMusicStream(Music music);                              // Stop music playing
+RLAPI void PauseMusicStream(Music music);                             // Pause music playing
+RLAPI void ResumeMusicStream(Music music);                            // Resume playing paused music
+RLAPI bool IsMusicPlaying(Music music);                               // Check if music is playing
+RLAPI void SetMusicVolume(Music music, float volume);                 // Set volume for music (1.0 is max level)
+RLAPI void SetMusicPitch(Music music, float pitch);                   // Set pitch for a music (1.0 is base level)
+RLAPI void SetMusicLoopCount(Music music, int count);                 // Set music loop count (loop repeats)
+RLAPI float GetMusicTimeLength(Music music);                          // Get music time length (in seconds)
+RLAPI float GetMusicTimePlayed(Music music);                          // Get current music time played (in seconds)
+
+// AudioStream management functions
+RLAPI AudioStream InitAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels); // Init audio stream (to stream raw audio pcm data)
+RLAPI void UpdateAudioStream(AudioStream stream, const void *data, int samplesCount); // Update audio stream buffers with data
+RLAPI void CloseAudioStream(AudioStream stream);                      // Close audio stream and free memory
+RLAPI bool IsAudioBufferProcessed(AudioStream stream);                // Check if any audio stream buffers requires refill
+RLAPI void PlayAudioStream(AudioStream stream);                       // Play audio stream
+RLAPI void PauseAudioStream(AudioStream stream);                      // Pause audio stream
+RLAPI void ResumeAudioStream(AudioStream stream);                     // Resume audio stream
+RLAPI bool IsAudioStreamPlaying(AudioStream stream);                  // Check if audio stream is playing
+RLAPI void StopAudioStream(AudioStream stream);                       // Stop audio stream
+RLAPI void SetAudioStreamVolume(AudioStream stream, float volume);    // Set volume for audio stream (1.0 is max level)
+RLAPI void SetAudioStreamPitch(AudioStream stream, float pitch);      // Set pitch for audio stream (1.0 is base level)

projects/VS2015.UWP/raylib.App.UWP/App.cpp

@@ -0,0 +1,558 @@
+#include "pch.h"
+#include "app.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;
+
+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)
+	{
+		currentMouseState[MOUSE_LEFT_BUTTON] = 1;
+	}
+	if (args->CurrentPoint->Properties->IsRightButtonPressed)
+	{
+		currentMouseState[MOUSE_RIGHT_BUTTON] = 1;
+	}
+	if (args->CurrentPoint->Properties->IsMiddleButtonPressed)
+	{
+		currentMouseState[MOUSE_MIDDLE_BUTTON] = 1;
+	}
+}
+
+void App::PointerReleased(CoreWindow ^window, PointerEventArgs^ args)
+{
+	if (!(args->CurrentPoint->Properties->IsLeftButtonPressed))
+	{
+		currentMouseState[MOUSE_LEFT_BUTTON] = 0;
+	}
+	if (!(args->CurrentPoint->Properties->IsRightButtonPressed))
+	{
+		currentMouseState[MOUSE_RIGHT_BUTTON] = 0;
+	}
+	if (!(args->CurrentPoint->Properties->IsMiddleButtonPressed))
+	{
+		currentMouseState[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);
+}
+
+void App::OnKeyUp(CoreWindow ^ sender, KeyEventArgs ^ args)
+{
+	ProcessKeyEvent(args->VirtualKey, 0);
+}
+
+/* REIMPLEMENTED FROM CORE.C */
+// Get one key state
+static bool GetKeyStatus(int key)
+{
+	return currentKeyState[key];
+}
+
+// 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;
+}
+
+// Get one mouse button state
+static bool UWPGetMouseButtonStatus(int button)
+{
+	return currentMouseState[button];
+}
+
+// Poll (store) all input events
+void UWP_PollInput()
+{
+	// Register previous keyboard state
+	for (int k = 0; k < 512; k++) previousKeyState[k] = currentKeyState[k];
+
+	// 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;
+			}
+		}
+	}
+
+}
+
+// The following functions were ripped from core.c and have *no additional work done on them*
+// Detect if a key has been pressed once
+bool UWPIsKeyPressed(int key)
+{
+	bool pressed = false;
+	
+	if ((currentKeyState[key] != previousKeyState[key]) && (currentKeyState[key] == 1)) pressed = true;
+	else pressed = false;
+
+	return pressed;
+}
+
+// Detect if a key is being pressed (key held down)
+bool UWPIsKeyDown(int key)
+{
+	if (GetKeyStatus(key) == 1) return true;
+	else return false;
+}
+
+// Detect if a key has been released once
+bool UWPIsKeyReleased(int key)
+{
+	bool released = false;
+
+	if ((currentKeyState[key] != previousKeyState[key]) && (currentKeyState[key] == 0)) released = true;
+	else released = false;
+
+	return released;
+}
+
+// Detect if a key is NOT being pressed (key not held down)
+bool UWPIsKeyUp(int key)
+{
+	if (GetKeyStatus(key) == 0) return true;
+	else return false;
+}
+
+/* OTHER CODE */
+
+// Helper to convert a length in device-independent pixels (DIPs) to a length in physical pixels.
+inline float ConvertDipsToPixels(float dips, float dpi)
+{
+    static const float dipsPerInch = 96.0f;
+    return floor(dips * dpi / dipsPerInch + 0.5f); // Round to nearest integer.
+}
+
+// Implementation of the IFrameworkViewSource interface, necessary to run our app.
+ref class 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);
+
+    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()
+}
+
+static int posX = 100;
+static int posY = 100;
+static int time = 0;
+// This method is called after the window becomes active.
+void App::Run()
+{
+    while (!mWindowClosed)
+    {
+        if (mWindowVisible)
+        {
+			// Draw
+			BeginDrawing();
+
+				ClearBackground(RAYWHITE);
+				
+				posX += gamepadAxisState[GAMEPAD_PLAYER1][GAMEPAD_XBOX_AXIS_LEFT_X] * 5;
+				posY += gamepadAxisState[GAMEPAD_PLAYER1][GAMEPAD_XBOX_AXIS_LEFT_Y] * -5;
+				DrawRectangle(posX, posY, 400, 100, RED);
+
+				DrawLine(0, 0, GetScreenWidth(), GetScreenHeight(), BLUE);
+
+				DrawCircle(mousePosition.x, mousePosition.y, 40, BLUE);
+
+				if (UWPIsKeyDown(KEY_S)) DrawCircle(100, 100, 100, BLUE);
+
+				if (UWPIsKeyPressed(KEY_A))
+				{
+					posX -= 50;
+					UWPEnableCursor();
+				}
+
+				if (UWPIsKeyPressed(KEY_D))
+				{
+					posX += 50;
+					UWPDisableCursor();
+				}
+
+				if (currentKeyState[KEY_LEFT_ALT]) DrawRectangle(250, 250, 20, 20, BLACK);
+				if (currentKeyState[KEY_BACKSPACE]) DrawRectangle(280, 250, 20, 20, BLACK);
+				if (currentMouseState[MOUSE_LEFT_BUTTON]) DrawRectangle(280, 250, 20, 20, BLACK);
+
+				static int pos = 0;
+				pos -= currentMouseWheelY;
+
+				DrawRectangle(280, pos + 50, 20, 20, BLACK);
+				DrawRectangle(250, 280 + (time++ % 60), 10, 10, PURPLE);
+
+		    EndDrawing();
+
+			UWP_PollInput();
+
+			CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent);
+        }
+        else
+        {
+            CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessOneAndAllPending);
+        }
+    }
+
+	CloseWindow();
+}
+
+// Terminate events do not cause Uninitialize to be called. It will be called if your IFrameworkView
+// class is torn down while the app is in the foreground.
+void App::Uninitialize()
+{
+	// CloseWindow();
+}
+
+// Application lifecycle event handler.
+void App::OnActivated(CoreApplicationView^ applicationView, IActivatedEventArgs^ args)
+{
+    // Run() won't start until the CoreWindow is activated.
+    CoreWindow::GetForCurrentThread()->Activate();
+}
+
+void App::OnResuming(Object^ sender, Object^ args)
+{
+	// Restore any data or state that was unloaded on suspend. By default, data
+	// and state are persisted when resuming from suspend. Note that this event
+	// does not occur if the app was previously terminated.
+}
+
+void App::OnWindowSizeChanged(CoreWindow^ sender, WindowSizeChangedEventArgs^ args)
+{
+	// TODO: Update window and render area size
+	//m_deviceResources->SetLogicalSize(Size(sender->Bounds.Width, sender->Bounds.Height));
+	//m_main->UpdateForWindowSizeChange();
+}
+
+// Window event handlers.
+void App::OnVisibilityChanged(CoreWindow^ sender, VisibilityChangedEventArgs^ args)
+{
+    mWindowVisible = args->Visible;
+
+	// raylib core has the variable windowMinimized to register state,
+	// it should be modifyed by this event...
+}
+
+void App::OnWindowClosed(CoreWindow^ sender, CoreWindowEventArgs^ args)
+{
+    mWindowClosed = true;
+
+	// raylib core has the variable windowShouldClose to register state,
+	// it should be modifyed by this event...
+}
+
+void App::OnDpiChanged(DisplayInformation^ sender, Object^ args)
+{
+	//m_deviceResources->SetDpi(sender->LogicalDpi);
+	//m_main->UpdateForWindowSizeChange();
+}
+
+void App::OnOrientationChanged(DisplayInformation^ sender, Object^ args)
+{
+	//m_deviceResources->SetCurrentOrientation(sender->CurrentOrientation);
+	//m_main->UpdateForWindowSizeChange();
+}

projects/VS2015.UWP/raylib.App.UWP/App.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <string>
+
+#include "pch.h"
+
+namespace raylibUWP
+{
+    ref class App sealed : public Windows::ApplicationModel::Core::IFrameworkView
+    {
+    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;
+    };
+}

projects/VS2015.UWP/raylib.App.UWP/Package.appxmanifest

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Package xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10" xmlns:mp="http://schemas.microsoft.com/appx/2014/phone/manifest" xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10" IgnorableNamespaces="uap mp">
+  <Identity Name="b842558c-c034-4e4b-9457-a286f26e83cc" Publisher="CN=Alumno" Version="1.0.0.0" />
+  <mp:PhoneIdentity PhoneProductId="56d2ca94-c361-4e9f-9a33-bacd751552fa" PhonePublisherId="00000000-0000-0000-0000-000000000000" />
+  <Properties>
+    <DisplayName>raylibUWP</DisplayName>
+    <PublisherDisplayName>raysan5</PublisherDisplayName>
+    <Logo>Assets\StoreLogo.png</Logo>
+  </Properties>
+  <Dependencies>
+    <TargetDeviceFamily Name="Windows.Universal" MinVersion="10.0.0.0" MaxVersionTested="10.0.0.0" />
+  </Dependencies>
+  <Resources>
+    <Resource Language="x-generate" />
+  </Resources>
+  <Applications>
+    <Application Id="App" Executable="$targetnametoken$.exe" EntryPoint="raylibUWP.App">
+      <uap:VisualElements DisplayName="raylibUWP" Square150x150Logo="Assets\Logo.png" Square44x44Logo="Assets\SmallLogo.png" Description="raylib UWP game" BackgroundColor="#464646">
+        <uap:SplashScreen Image="Assets\SplashScreen.png" />
+      </uap:VisualElements>
+    </Application>
+  </Applications>
+  <Capabilities>
+    <Capability Name="internetClient" />
+  </Capabilities>
+</Package>

projects/VS2015.UWP/raylib.App.UWP/packages.config

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

projects/VS2015.UWP/raylib.App.UWP/pch.cpp

@@ -0,0 +1 @@
+#include "pch.h"

projects/VS2015.UWP/raylib.App.UWP/pch.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <memory>
+#include <wrl.h>
+
+// OpenGL ES includes
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+
+// EGL includes
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <EGL/eglplatform.h>
+
+// ANGLE include for Windows Store
+#include <angle_windowsstore.h>

projects/VS2015.UWP/raylib.App.UWP/raylib.App.UWP.filters

@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="App.cpp" />
+    <ClCompile Include="pch.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="App.h" />
+    <ClInclude Include="pch.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <Image Include="Assets\SmallLogo.scale-100.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\SplashScreen.scale-100.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\StoreLogo.scale-100.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\WideLogo.scale-100.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\Logo.scale-100.png">
+      <Filter>Assets</Filter>
+    </Image>
+  </ItemGroup>
+  <ItemGroup>
+    <AppxManifest Include="Package.appxmanifest" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="UWP_OpenGLES2_TemporaryKey.pfx" />
+    <None Include="packages.config" />
+    <None Include="$(angle-BinPath)\libEGL.dll" />
+    <None Include="$(angle-BinPath)\libGLESv2.dll" />
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="Assets">
+      <UniqueIdentifier>{d16954bb-de54-472b-ac10-ecab10d3fdc8}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+</Project>

projects/VS2015.UWP/raylib.App.UWP/raylib.App.UWP.user

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup />
+</Project>

projects/VS2017/raylib.App.UWP/App.cpp

@@ -0,0 +1,558 @@
+#include "pch.h"
+#include "app.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;
+
+using namespace raylibUWP;
+
+/*
+To-do list
+	- Cache reference to our CoreWindow?
+	- Implement gestures
+*/
+
+/* 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)
+	{
+		currentMouseState[MOUSE_LEFT_BUTTON] = 1;
+	}
+	if (args->CurrentPoint->Properties->IsRightButtonPressed)
+	{
+		currentMouseState[MOUSE_RIGHT_BUTTON] = 1;
+	}
+	if (args->CurrentPoint->Properties->IsMiddleButtonPressed)
+	{
+		currentMouseState[MOUSE_MIDDLE_BUTTON] = 1;
+	}
+}
+
+void App::PointerReleased(CoreWindow ^window, PointerEventArgs^ args)
+{
+	if (!(args->CurrentPoint->Properties->IsLeftButtonPressed))
+	{
+		currentMouseState[MOUSE_LEFT_BUTTON] = 0;
+	}
+	if (!(args->CurrentPoint->Properties->IsRightButtonPressed))
+	{
+		currentMouseState[MOUSE_RIGHT_BUTTON] = 0;
+	}
+	if (!(args->CurrentPoint->Properties->IsMiddleButtonPressed))
+	{
+		currentMouseState[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);
+}
+
+void App::OnKeyUp(CoreWindow ^ sender, KeyEventArgs ^ args)
+{
+	ProcessKeyEvent(args->VirtualKey, 0);
+}
+
+/* REIMPLEMENTED FROM CORE.C */
+// Get one key state
+static bool GetKeyStatus(int key)
+{
+	return currentKeyState[key];
+}
+
+// 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;
+}
+
+// Get one mouse button state
+static bool UWPGetMouseButtonStatus(int button)
+{
+	return currentMouseState[button];
+}
+
+// Poll (store) all input events
+void UWP_PollInput()
+{
+	// Register previous keyboard state
+	for (int k = 0; k < 512; k++) previousKeyState[k] = currentKeyState[k];
+
+	// 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;
+			}
+		}
+	}
+
+}
+
+// The following functions were ripped from core.c and have *no additional work done on them*
+// Detect if a key has been pressed once
+bool UWPIsKeyPressed(int key)
+{
+	bool pressed = false;
+	
+	if ((currentKeyState[key] != previousKeyState[key]) && (currentKeyState[key] == 1))
+		pressed = true;
+	else pressed = false;
+
+	return pressed;
+}
+
+// Detect if a key is being pressed (key held down)
+bool UWPIsKeyDown(int key)
+{
+	if (GetKeyStatus(key) == 1) return true;
+	else return false;
+}
+
+// Detect if a key has been released once
+bool UWPIsKeyReleased(int key)
+{
+	bool released = false;
+
+	if ((currentKeyState[key] != previousKeyState[key]) && (currentKeyState[key] == 0)) released = true;
+	else released = false;
+
+	return released;
+}
+
+// Detect if a key is NOT being pressed (key not held down)
+bool UWPIsKeyUp(int key)
+{
+	if (GetKeyStatus(key) == 0) return true;
+	else return false;
+}
+
+/* OTHER CODE */
+
+// Helper to convert a length in device-independent pixels (DIPs) to a length in physical pixels.
+inline float ConvertDipsToPixels(float dips, float dpi)
+{
+    static const float dipsPerInch = 96.0f;
+    return floor(dips * dpi / dipsPerInch + 0.5f); // Round to nearest integer.
+}
+
+// Implementation of the IFrameworkViewSource interface, necessary to run our app.
+ref class 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);
+
+    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.
+	InitWindow(800, 450, (EGLNativeWindowType)window);
+}
+
+// Initializes scene resources
+void App::Load(Platform::String^ entryPoint)
+{
+    // InitWindow() --> rlglInit()
+}
+
+static int posX = 100;
+static int posY = 100;
+static int time = 0;
+// This method is called after the window becomes active.
+void App::Run()
+{
+    while (!mWindowClosed)
+    {
+        if (mWindowVisible)
+        {
+			// Draw
+			BeginDrawing();
+
+				ClearBackground(RAYWHITE);
+				
+				
+				posX += gamepadAxisState[GAMEPAD_PLAYER1][GAMEPAD_XBOX_AXIS_LEFT_X] * 5;
+				posY += gamepadAxisState[GAMEPAD_PLAYER1][GAMEPAD_XBOX_AXIS_LEFT_Y] * -5;
+				DrawRectangle(posX, posY, 400, 100, RED);
+
+				DrawLine(0, 0, GetScreenWidth(), GetScreenHeight(), BLUE);
+
+				DrawCircle(mousePosition.x, mousePosition.y, 40, BLUE);
+
+				if(UWPIsKeyDown(KEY_S))
+				{
+					DrawCircle(100, 100, 100, BLUE);
+				}
+
+				if(UWPIsKeyPressed(KEY_A))
+				{
+					posX -= 50;
+					UWPEnableCursor();
+				}
+				if (UWPIsKeyPressed(KEY_D))
+				{
+					posX += 50;
+
+					UWPDisableCursor();
+				}
+
+				if(currentKeyState[KEY_LEFT_ALT])
+					DrawRectangle(250, 250, 20, 20, BLACK);
+				if (currentKeyState[KEY_BACKSPACE])
+					DrawRectangle(280, 250, 20, 20, BLACK);
+
+				if (currentMouseState[MOUSE_LEFT_BUTTON])
+					DrawRectangle(280, 250, 20, 20, BLACK);
+
+				static int pos = 0;
+				pos -= currentMouseWheelY;
+				DrawRectangle(280, pos + 50, 20, 20, BLACK);
+
+				DrawRectangle(250, 280 + (time++ % 60), 10, 10, PURPLE);
+
+		    EndDrawing();
+			UWP_PollInput();
+
+			CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent);
+        }
+        else
+        {
+            CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessOneAndAllPending);
+        }
+    }
+
+	CloseWindow();
+}
+
+// Terminate events do not cause Uninitialize to be called. It will be called if your IFrameworkView
+// class is torn down while the app is in the foreground.
+void App::Uninitialize()
+{
+	// CloseWindow();
+}
+
+// Application lifecycle event handler.
+void App::OnActivated(CoreApplicationView^ applicationView, IActivatedEventArgs^ args)
+{
+    // Run() won't start until the CoreWindow is activated.
+    CoreWindow::GetForCurrentThread()->Activate();
+}
+
+void App::OnResuming(Object^ sender, Object^ args)
+{
+	// Restore any data or state that was unloaded on suspend. By default, data
+	// and state are persisted when resuming from suspend. Note that this event
+	// does not occur if the app was previously terminated.
+}
+
+void App::OnWindowSizeChanged(CoreWindow^ sender, WindowSizeChangedEventArgs^ args)
+{
+	// TODO: Update window and render area size
+	//m_deviceResources->SetLogicalSize(Size(sender->Bounds.Width, sender->Bounds.Height));
+	//m_main->UpdateForWindowSizeChange();
+}
+
+// Window event handlers.
+void App::OnVisibilityChanged(CoreWindow^ sender, VisibilityChangedEventArgs^ args)
+{
+    mWindowVisible = args->Visible;
+
+	// raylib core has the variable windowMinimized to register state,
+	// it should be modifyed by this event...
+}
+
+void App::OnWindowClosed(CoreWindow^ sender, CoreWindowEventArgs^ args)
+{
+    mWindowClosed = true;
+
+	// raylib core has the variable windowShouldClose to register state,
+	// it should be modifyed by this event...
+}
+
+void App::OnDpiChanged(DisplayInformation^ sender, Object^ args)
+{
+	//m_deviceResources->SetDpi(sender->LogicalDpi);
+	//m_main->UpdateForWindowSizeChange();
+}
+
+void App::OnOrientationChanged(DisplayInformation^ sender, Object^ args)
+{
+	//m_deviceResources->SetCurrentOrientation(sender->CurrentOrientation);
+	//m_main->UpdateForWindowSizeChange();
+}

projects/VS2017/raylib.App.UWP/App.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <string>
+
+#include "pch.h"
+
+namespace raylibUWP
+{
+    ref class App sealed : public Windows::ApplicationModel::Core::IFrameworkView
+    {
+    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;
+    };
+}

projects/VS2017/raylib.App.UWP/Package.appxmanifest

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Package xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10" xmlns:mp="http://schemas.microsoft.com/appx/2014/phone/manifest" xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10" IgnorableNamespaces="uap mp">
+  <Identity Name="b842558c-c034-4e4b-9457-a286f26e83cc" Publisher="CN=Alumno" Version="1.0.0.0" />
+  <mp:PhoneIdentity PhoneProductId="56d2ca94-c361-4e9f-9a33-bacd751552fa" PhonePublisherId="00000000-0000-0000-0000-000000000000" />
+  <Properties>
+    <DisplayName>raylibUWP</DisplayName>
+    <PublisherDisplayName>Alumno</PublisherDisplayName>
+    <Logo>Assets\StoreLogo.png</Logo>
+  </Properties>
+  <Dependencies>
+    <TargetDeviceFamily Name="Windows.Universal" MinVersion="10.0.0.0" MaxVersionTested="10.0.0.0" />
+  </Dependencies>
+  <Resources>
+    <Resource Language="x-generate" />
+  </Resources>
+  <Applications>
+    <Application Id="App" Executable="$targetnametoken$.exe" EntryPoint="raylibUWP.App">
+      <uap:VisualElements DisplayName="raylibUWP" Square150x150Logo="Assets\Logo.png" Square44x44Logo="Assets\SmallLogo.png" Description="raylib UWP game" BackgroundColor="#464646">
+        <uap:SplashScreen Image="Assets\SplashScreen.png" />
+      </uap:VisualElements>
+    </Application>
+  </Applications>
+  <Capabilities>
+    <Capability Name="internetClient" />
+  </Capabilities>
+</Package>

projects/VS2017/raylib.App.UWP/packages.config

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

projects/VS2017/raylib.App.UWP/pch.cpp

@@ -0,0 +1 @@
+#include "pch.h"

projects/VS2017/raylib.App.UWP/pch.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <memory>
+#include <wrl.h>
+
+// OpenGL ES includes
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+
+// EGL includes
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <EGL/eglplatform.h>
+
+// ANGLE include for Windows Store
+#include <angle_windowsstore.h>

projects/VS2017/raylib.App.UWP/raylib.App.UWP.filters

@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="App.cpp" />
+    <ClCompile Include="pch.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="App.h" />
+    <ClInclude Include="pch.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <Image Include="Assets\SmallLogo.scale-100.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\SplashScreen.scale-100.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\StoreLogo.scale-100.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\WideLogo.scale-100.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\Logo.scale-100.png">
+      <Filter>Assets</Filter>
+    </Image>
+  </ItemGroup>
+  <ItemGroup>
+    <AppxManifest Include="Package.appxmanifest" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="UWP_OpenGLES2_TemporaryKey.pfx" />
+    <None Include="packages.config" />
+    <None Include="$(angle-BinPath)\libEGL.dll" />
+    <None Include="$(angle-BinPath)\libGLESv2.dll" />
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="Assets">
+      <UniqueIdentifier>{d16954bb-de54-472b-ac10-ecab10d3fdc8}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+</Project>

projects/VS2017/raylib.App.UWP/raylib.App.UWP.user

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup />
+</Project>