Replaced tab by 4 spaces and adjust text

1 files changed, 325 insertions, 325 deletions

diff --git a/src/core.c b/src/core.c
index c835cb5b..a784f4bb 100644
--- a/src/core.c
+++ b/src/core.c
@@ -1,41 +1,41 @@
 /*********************************************************************************************
 *
-*	raylib.core
+*   raylib.core
 *
-*	Basic functions to manage Windows, OpenGL context and Input
-*	
-*	Uses external lib:	
-*		GLFW3 - Window, context and Input management (static lib version)
+*   Basic functions to manage Windows, OpenGL context and Input
+*    
+*   Uses external lib:    
+*       GLFW3 - Window, context and Input management (static lib version)
 *
-*	Copyright (c) 2013 Ramon Santamaria (Ray San - raysan@raysanweb.com)
-*	
-*	This software is provided "as-is", without any express or implied warranty. In no event 
-*	will the authors be held liable for any damages arising from the use of this software.
+*   Copyright (c) 2013 Ramon Santamaria (Ray San - raysan@raysanweb.com)
+*    
+*   This software is provided "as-is", without any express or implied warranty. In no event 
+*   will the authors be held liable for any damages arising from the use of this software.
 *
-*	Permission is granted to anyone to use this software for any purpose, including commercial 
-*	applications, and to alter it and redistribute it freely, subject to the following restrictions:
+*   Permission is granted to anyone to use this software for any purpose, including commercial 
+*   applications, and to alter it and redistribute it freely, subject to the following restrictions:
 *
-*	  1. The origin of this software must not be misrepresented; you must not claim that you 
-*	  wrote the original software. If you use this software in a product, an acknowledgment 
-*	  in the product documentation would be appreciated but is not required.
+*     1. The origin of this software must not be misrepresented; you must not claim that you 
+*     wrote the original software. If you use this software in a product, an acknowledgment 
+*     in the product documentation would be appreciated but is not required.
 *
-*	  2. Altered source versions must be plainly marked as such, and must not be misrepresented
-*	  as being the original software.
+*     2. Altered source versions must be plainly marked as such, and must not be misrepresented
+*     as being the original software.
 *
-*	  3. This notice may not be removed or altered from any source distribution.
+*     3. This notice may not be removed or altered from any source distribution.
 *
 **********************************************************************************************/
 
 #include "raylib.h"
 
-#include <GLFW/glfw3.h>		// GLFW3 lib: Windows, OpenGL context and Input management
-//#include <GL/gl.h>		// OpenGL functions (GLFW3 already includes gl.h)
-#include <stdio.h>			// Standard input / output lib
-#include <stdlib.h>			// Declares malloc() and free() for memory management
-#include <math.h>			// Math related functions, tan() on SetPerspective
-#include "vector3.h"		// Basic Vector3 functions
+#include <GLFW/glfw3.h>     // GLFW3 lib: Windows, OpenGL context and Input management
+//#include <GL/gl.h>        // OpenGL functions (GLFW3 already includes gl.h)
+#include <stdio.h>          // Standard input / output lib
+#include <stdlib.h>         // Declares malloc() and free() for memory management
+#include <math.h>           // Math related functions, tan() on SetPerspective
+#include "vector3.h"        // Basic Vector3 functions
 
-//#define GLFW_DLL			// Using GLFW DLL on Windows -> No, we use static version!
+//#define GLFW_DLL          // Using GLFW DLL on Windows -> No, we use static version!
 
 //----------------------------------------------------------------------------------
 // Defines and Macros
@@ -50,34 +50,34 @@ typedef Color pixel;
 //----------------------------------------------------------------------------------
 // Global Variables Definition
 //----------------------------------------------------------------------------------
-static GLFWwindow* window;					// Main window
-static bool fullscreen;						// Fullscreen mode track
+static GLFWwindow* window;                  // Main window
+static bool fullscreen;                     // Fullscreen mode track
 
-static double currentTime, previousTime;	// Used to track timmings
-static double updateTime, drawTime;			// Time measures for update and draw
-static double frameTime;					// Time measure for one frame
-static double targetTime = 0;				// Desired time for one frame, if 0 not applied
+static double currentTime, previousTime;    // Used to track timmings
+static double updateTime, drawTime;         // Time measures for update and draw
+static double frameTime;                    // Time measure for one frame
+static double targetTime = 0;               // Desired time for one frame, if 0 not applied
 
-static int windowWidth, windowHeight;		// Required to switch between windowed/fullscren mode (F11)
-static char *windowTitle;					// Required to switch between windowed/fullscren mode (F11)
+static int windowWidth, windowHeight;       // Required to switch between windowed/fullscren mode (F11)
+static char *windowTitle;                   // Required to switch between windowed/fullscren mode (F11)
 
 //----------------------------------------------------------------------------------
 // Other Modules Functions Declaration (required by core)
 //----------------------------------------------------------------------------------
-extern void LoadDefaultFont();				// [Module: text] Loads default font on InitWindow()
-extern void UnloadDefaultFont();			// [Module: text] Unloads default font from GPU memory
-extern void WriteBitmap(const char *fileName, const pixel *imgDataPixel, int width, int height);	// [Module: textures] Writes a bitmap (BMP) file
+extern void LoadDefaultFont();               // [Module: text] Loads default font on InitWindow()
+extern void UnloadDefaultFont();             // [Module: text] Unloads default font from GPU memory
+extern void WriteBitmap(const char *fileName, const pixel *imgDataPixel, int width, int height);    // [Module: textures] Writes a bitmap (BMP) file
 
 //----------------------------------------------------------------------------------
 // Module specific Functions Declaration
 //----------------------------------------------------------------------------------
-static void InitGraphicsDevice();															// Initialize Graphics Device (OpenGL stuff)
-static void ErrorCallback(int error, const char *description);								// GLFW3 Error Callback, runs on GLFW3 error
-static void KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods);	// GLFW3 Keyboard Callback, runs on key pressed
-static void WindowSizeCallback(GLFWwindow* window, int width, int height);					// GLFW3 WindowSize Callback, runs when window is resized
-static void CameraLookAt(Vector3 position, Vector3 target, Vector3 up);						// Setup camera view (updates MODELVIEW matrix)
-static void SetPerspective(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar);	// Setup view projection (updates PROJECTION matrix)
-static void TakeScreenshot();																// Takes a bitmap (BMP) screenshot and saves it in the same folder as executable
+static void InitGraphicsDevice();                                                          // Initialize Graphics Device (OpenGL stuff)
+static void ErrorCallback(int error, const char *description);                             // GLFW3 Error Callback, runs on GLFW3 error
+static void KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods);  // GLFW3 Keyboard Callback, runs on key pressed
+static void WindowSizeCallback(GLFWwindow* window, int width, int height);                 // GLFW3 WindowSize Callback, runs when window is resized
+static void CameraLookAt(Vector3 position, Vector3 target, Vector3 up);                    // Setup camera view (updates MODELVIEW matrix)
+static void SetPerspective(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar); // Setup view projection (updates PROJECTION matrix)
+static void TakeScreenshot();                                                              // Takes a bitmap (BMP) screenshot and saves it in the same folder as executable
 
 //----------------------------------------------------------------------------------
 // Module Functions Definition - Window and OpenGL Context Functions
@@ -87,202 +87,202 @@ static void TakeScreenshot();																// Takes a bitmap (BMP) screenshot
 void InitWindow(int width, int height, char* title)
 {
     glfwSetErrorCallback(ErrorCallback);
-	
+    
     if (!glfwInit()) exit(1);
-	
-	//glfwWindowHint(GLFW_SAMPLES, 4);	// If called before windows creation, enables multisampling x4 (MSAA), default is 0
-		
+    
+    //glfwWindowHint(GLFW_SAMPLES, 4);    // If called before windows creation, enables multisampling x4 (MSAA), default is 0
+        
     window = glfwCreateWindow(width, height, title, NULL, NULL);
-	
-	windowWidth = width;
-	windowHeight = height;
-	windowTitle = title;
-	
+    
+    windowWidth = width;
+    windowHeight = height;
+    windowTitle = title;
+    
     if (!window)
     {
         glfwTerminate();
         exit(1);
     }
-	
-	glfwSetWindowSizeCallback(window, WindowSizeCallback);
-	
-	glfwMakeContextCurrent(window);
-	glfwSetKeyCallback(window, KeyCallback);
-	glfwSwapInterval(0);			// Disables GPU v-sync (if set), so frames are not limited to screen refresh rate (60Hz -> 60 FPS)
-									// If not set, swap interval uses GPU v-sync configuration
-									// Framerate can be setup using SetTargetFPS()
-	InitGraphicsDevice();
-	
-	previousTime = glfwGetTime();
-
-	LoadDefaultFont();
+    
+    glfwSetWindowSizeCallback(window, WindowSizeCallback);
+    
+    glfwMakeContextCurrent(window);
+    glfwSetKeyCallback(window, KeyCallback);
+    glfwSwapInterval(0);            // Disables GPU v-sync (if set), so frames are not limited to screen refresh rate (60Hz -> 60 FPS)
+                                    // If not set, swap interval uses GPU v-sync configuration
+                                    // Framerate can be setup using SetTargetFPS()
+    InitGraphicsDevice();
+    
+    previousTime = glfwGetTime();
+
+    LoadDefaultFont();
 }
 
 // Close Window and Terminate Context
 void CloseWindow()
 {
-	UnloadDefaultFont();
+    UnloadDefaultFont();
 
     glfwDestroyWindow(window);
-	glfwTerminate();
+    glfwTerminate();
 }
 
 // Detect if KEY_ESCAPE pressed or Close icon pressed
 bool WindowShouldClose()
 {
-	return (glfwWindowShouldClose(window));
+    return (glfwWindowShouldClose(window));
 }
 
 // Fullscreen toggle (by default F11)
 void ToggleFullscreen()
 {
-	if (glfwGetKey(window, GLFW_KEY_F11)) 
-	{
-		fullscreen = !fullscreen;			// Toggle fullscreen flag
-
-		glfwDestroyWindow(window);			// Destroy the current window (we will recreate it!)
-
-		// NOTE: Window aspect ratio is always windowWidth / windowHeight
-		if (fullscreen) window = glfwCreateWindow(windowWidth, windowHeight, windowTitle, glfwGetPrimaryMonitor(), NULL);	// Fullscreen mode
-		else window = glfwCreateWindow(windowWidth, windowHeight, windowTitle, NULL, NULL);
-	
-		if (!window)
-		{
-			glfwTerminate();
-			exit(1);
-		}
-		
-		glfwMakeContextCurrent(window);
-		glfwSetKeyCallback(window, KeyCallback);
-
-		InitGraphicsDevice();
-	}
+    if (glfwGetKey(window, GLFW_KEY_F11)) 
+    {
+        fullscreen = !fullscreen;          // Toggle fullscreen flag
+
+        glfwDestroyWindow(window);         // Destroy the current window (we will recreate it!)
+
+        // NOTE: Window aspect ratio is always windowWidth / windowHeight
+        if (fullscreen) window = glfwCreateWindow(windowWidth, windowHeight, windowTitle, glfwGetPrimaryMonitor(), NULL);    // Fullscreen mode
+        else window = glfwCreateWindow(windowWidth, windowHeight, windowTitle, NULL, NULL);
+    
+        if (!window)
+        {
+            glfwTerminate();
+            exit(1);
+        }
+        
+        glfwMakeContextCurrent(window);
+        glfwSetKeyCallback(window, KeyCallback);
+
+        InitGraphicsDevice();
+    }
 }
 
 // Sets Background Color
 void ClearBackground(Color color)
 {
-	// Color values clamp to 0.0f(0) and 1.0f(255)
-	float r = (float)color.r / 255;
-	float g = (float)color.g / 255;
-	float b = (float)color.b / 255;
-	float a = (float)color.a / 255;
-	
-	glClearColor(r, g, b, a);
+    // Color values clamp to 0.0f(0) and 1.0f(255)
+    float r = (float)color.r / 255;
+    float g = (float)color.g / 255;
+    float b = (float)color.b / 255;
+    float a = (float)color.a / 255;
+    
+    glClearColor(r, g, b, a);
 }
 
 // Setup drawing canvas to start drawing
 void BeginDrawing()
 {
-	currentTime = glfwGetTime();		// glfwGetTime() returns a 'double' containing the number of elapsed seconds since glfwInit() was called
-	updateTime = currentTime - previousTime;
-	previousTime = currentTime;
+    currentTime = glfwGetTime();        // glfwGetTime() returns a 'double' containing the number of elapsed seconds since glfwInit() was called
+    updateTime = currentTime - previousTime;
+    previousTime = currentTime;
 
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 	// Clear used buffers, Depth Buffer is used for 3D
-	
-	glLoadIdentity();					// Reset current matrix (MODELVIEW)
-	
-	glTranslatef(0.375, 0.375, 0);		// HACK to have 2D pixel-perfect drawing on OpenGL
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);     // Clear used buffers, Depth Buffer is used for 3D
+    
+    glLoadIdentity();                   // Reset current matrix (MODELVIEW)
+    
+    glTranslatef(0.375, 0.375, 0);      // HACK to have 2D pixel-perfect drawing on OpenGL
 }
 
 // End canvas drawing and Swap Buffers (Double Buffering)
 void EndDrawing()
 {
-    glfwSwapBuffers(window);			// Swap back and front buffers
-    glfwPollEvents();					// Register keyboard/mouse events
-	
-	currentTime = glfwGetTime();
-	drawTime = currentTime - previousTime;
-	previousTime = currentTime;
-	
-	frameTime = updateTime + drawTime;
-	
-	double extraTime = 0;
-
-	while (frameTime < targetTime)
-	{
-		// Implement a delay
-		currentTime = glfwGetTime();
-		extraTime = currentTime - previousTime;
-		previousTime = currentTime;
-		frameTime += extraTime;
-	}
+    glfwSwapBuffers(window);            // Swap back and front buffers
+    glfwPollEvents();                   // Register keyboard/mouse events
+    
+    currentTime = glfwGetTime();
+    drawTime = currentTime - previousTime;
+    previousTime = currentTime;
+    
+    frameTime = updateTime + drawTime;
+    
+    double extraTime = 0;
+
+    while (frameTime < targetTime)
+    {
+        // Implement a delay
+        currentTime = glfwGetTime();
+        extraTime = currentTime - previousTime;
+        previousTime = currentTime;
+        frameTime += extraTime;
+    }
 }
 
 // Initializes 3D mode for drawing (Camera setup)
 void Begin3dMode(Camera camera)
 {
-	//glEnable(GL_LIGHTING);			// TODO: Setup proper lighting system (raylib 1.x)
-	
-	glMatrixMode(GL_PROJECTION);		// Switch to projection matrix
-	
-	glPushMatrix();						// Save previous matrix, which contains the settings for the 2d ortho projection
-	glLoadIdentity();					// Reset current matrix (PROJECTION)
-	
-	SetPerspective(45.0f, (GLfloat)windowWidth/(GLfloat)windowHeight, 0.1f, 100.0f);	// Setup perspective projection
-
-	glMatrixMode(GL_MODELVIEW);			// Switch back to modelview matrix
-	glLoadIdentity();					// Reset current matrix (MODELVIEW)
-	
-	CameraLookAt(camera.position, camera.target, camera.up);		// Setup Camera view
+    //glEnable(GL_LIGHTING);            // TODO: Setup proper lighting system (raylib 1.x)
+    
+    glMatrixMode(GL_PROJECTION);        // Switch to projection matrix
+    
+    glPushMatrix();                     // Save previous matrix, which contains the settings for the 2d ortho projection
+    glLoadIdentity();                   // Reset current matrix (PROJECTION)
+    
+    SetPerspective(45.0f, (GLfloat)windowWidth/(GLfloat)windowHeight, 0.1f, 100.0f);    // Setup perspective projection
+
+    glMatrixMode(GL_MODELVIEW);         // Switch back to modelview matrix
+    glLoadIdentity();                   // Reset current matrix (MODELVIEW)
+    
+    CameraLookAt(camera.position, camera.target, camera.up);        // Setup Camera view
 }
 
 // Ends 3D mode and returns to default 2D orthographic mode
 void End3dMode()
 {
-	glMatrixMode(GL_PROJECTION);		// Switch to projection matrix
-	glPopMatrix();						// Restore previous matrix (PROJECTION) from matrix stack
-	
-	glMatrixMode(GL_MODELVIEW);			// Get back to modelview matrix
-	glLoadIdentity();					// Reset current matrix (MODELVIEW)
-	
-	glTranslatef(0.375, 0.375, 0);		// HACK to ensure pixel-perfect drawing on OpenGL (after exiting 3D mode)
-		
-	//glDisable(GL_LIGHTING);			// TODO: Setup proper lighting system (raylib 1.x)
+    glMatrixMode(GL_PROJECTION);        // Switch to projection matrix
+    glPopMatrix();                      // Restore previous matrix (PROJECTION) from matrix stack
+    
+    glMatrixMode(GL_MODELVIEW);         // Get back to modelview matrix
+    glLoadIdentity();                   // Reset current matrix (MODELVIEW)
+    
+    glTranslatef(0.375, 0.375, 0);      // HACK to ensure pixel-perfect drawing on OpenGL (after exiting 3D mode)
+        
+    //glDisable(GL_LIGHTING);           // TODO: Setup proper lighting system (raylib 1.x)
 }
 
 // Set target FPS for the game
 void SetTargetFPS(int fps)
 {
-	targetTime = 1 / (float)fps;
-	
-	printf("TargetTime per Frame: %f seconds\n", (float)targetTime);
+    targetTime = 1 / (float)fps;
+    
+    printf("TargetTime per Frame: %f seconds\n", (float)targetTime);
 }
 
 // Returns current FPS
 float GetFPS()
 {
-	return (1/(float)frameTime);
+    return (1/(float)frameTime);
 }
 
 // Returns time in seconds for one frame
 float GetFrameTime()
 {
-	// As we are operating quite a lot with frameTime, it could be no stable
-	// so we round it before before passing around to be used
-	// NOTE: There are still problems with high framerates (>500fps)
-	double roundedFrameTime =  round(frameTime*10000) / 10000;
-	
-	return (float)roundedFrameTime;	// Time in seconds to run a frame
+    // As we are operating quite a lot with frameTime, it could be no stable
+    // so we round it before before passing around to be used
+    // NOTE: There are still problems with high framerates (>500fps)
+    double roundedFrameTime =  round(frameTime*10000) / 10000;
+    
+    return (float)roundedFrameTime;    // Time in seconds to run a frame
 }
 
 // Returns a Color struct from hexadecimal value
 Color GetColor(int hexValue)
 {
-	Color color;
+    Color color;
 
-	color.r = (unsigned char)(hexValue >> 24) & 0xFF;
-	color.g = (unsigned char)(hexValue >> 16) & 0xFF;
-	color.b = (unsigned char)(hexValue >> 8) & 0xFF;
-	color.a = (unsigned char)hexValue & 0xFF;
-	
-	return color;
+    color.r = (unsigned char)(hexValue >> 24) & 0xFF;
+    color.g = (unsigned char)(hexValue >> 16) & 0xFF;
+    color.b = (unsigned char)(hexValue >> 8) & 0xFF;
+    color.a = (unsigned char)hexValue & 0xFF;
+    
+    return color;
 }
 
 // Returns hexadecimal value for a Color
 int GetHexValue(Color color)
 {
-	return ((color.a << 24) + (color.r << 16) + (color.g << 8) + color.b);
+    return ((color.a << 24) + (color.r << 16) + (color.g << 8) + color.b);
 }
 
 //----------------------------------------------------------------------------------
@@ -292,125 +292,125 @@ int GetHexValue(Color color)
 // Detect if a key is being pressed (key held down)
 bool IsKeyPressed(int key)
 {
-	if (glfwGetKey(window, key) == GLFW_PRESS) return true;
-	else return false;
+    if (glfwGetKey(window, key) == GLFW_PRESS) return true;
+    else return false;
 }
 
 // Detect if a key is NOT being pressed (key not held down)
 bool IsKeyReleased(int key)
 {
-	if (glfwGetKey(window, key) == GLFW_RELEASE) return true;
-	else return false;
+    if (glfwGetKey(window, key) == GLFW_RELEASE) return true;
+    else return false;
 }
 
 // Detect if a mouse button is being pressed
 bool IsMouseButtonPressed(int button)
 {
-	if (glfwGetMouseButton(window, button) == GLFW_PRESS) return true;
-	else return false;
+    if (glfwGetMouseButton(window, button) == GLFW_PRESS) return true;
+    else return false;
 }
 
 // Detect if a mouse button is NOT being pressed
 bool IsMouseButtonReleased(int button)
 {
-	if (glfwGetMouseButton(window, button) == GLFW_RELEASE) return true;
-	else return false;
+    if (glfwGetMouseButton(window, button) == GLFW_RELEASE) return true;
+    else return false;
 }
 
 // Returns mouse position X
 int GetMouseX()
 {
-	double mouseX;
-	double mouseY;
-	
-	glfwGetCursorPos(window, &mouseX, &mouseY);
+    double mouseX;
+    double mouseY;
+    
+    glfwGetCursorPos(window, &mouseX, &mouseY);
 
-	return (int)mouseX;
+    return (int)mouseX;
 }
 
 // Returns mouse position Y
 int GetMouseY()
 {
-	double mouseX;
-	double mouseY;
-	
-	glfwGetCursorPos(window, &mouseX, &mouseY);
+    double mouseX;
+    double mouseY;
+    
+    glfwGetCursorPos(window, &mouseX, &mouseY);
 
-	return (int)mouseY;
+    return (int)mouseY;
 }
 
 // Returns mouse position XY
 Vector2 GetMousePosition()
 {
-	double mouseX;
-	double mouseY;
-	
-	glfwGetCursorPos(window, &mouseX, &mouseY);
-	
-	Vector2 position = { (float)mouseX, (float)mouseY };
+    double mouseX;
+    double mouseY;
+    
+    glfwGetCursorPos(window, &mouseX, &mouseY);
+    
+    Vector2 position = { (float)mouseX, (float)mouseY };
 
-	return position;
+    return position;
 }
 
 // Detect if a gamepad is available
 bool IsGamepadAvailable(int gamepad)
 {
-	int result = glfwJoystickPresent(gamepad);
-	
-	if (result == 1) return true;
-	else return false;
+    int result = glfwJoystickPresent(gamepad);
+    
+    if (result == 1) return true;
+    else return false;
 }
 
 // Return axis movement vector for a gamepad
 Vector2 GetGamepadMovement(int gamepad)
 {
-	Vector2 vec = { 0, 0 };
-	
-	const float *axes;
+    Vector2 vec = { 0, 0 };
+    
+    const float *axes;
     int axisCount;
-	
-	axes = glfwGetJoystickAxes(gamepad, &axisCount);
-	
-	if (axisCount >= 2)
-	{
-		vec.x = axes[0];	// Left joystick X	
-		vec.y = axes[1];	// Left joystick Y
-		
-		//vec.x = axes[2];	// Right joystick X
-		//vec.x = axes[3];	// Right joystick Y
-	}		
-
-	return vec;
+    
+    axes = glfwGetJoystickAxes(gamepad, &axisCount);
+    
+    if (axisCount >= 2)
+    {
+        vec.x = axes[0];    // Left joystick X    
+        vec.y = axes[1];    // Left joystick Y
+        
+        //vec.x = axes[2];    // Right joystick X
+        //vec.x = axes[3];    // Right joystick Y
+    }        
+
+    return vec;
 }
 
 // Detect if a gamepad button is being pressed
 bool IsGamepadButtonPressed(int gamepad, int button)
 {
-	const unsigned char* buttons;
-	int buttonsCount;
-	
-	buttons = glfwGetJoystickButtons(gamepad, &buttonsCount);
-	
-	if (buttons[button] == GLFW_PRESS)
-	{
-		return true;
-	}
-	else return false;
+    const unsigned char* buttons;
+    int buttonsCount;
+    
+    buttons = glfwGetJoystickButtons(gamepad, &buttonsCount);
+    
+    if (buttons[button] == GLFW_PRESS)
+    {
+        return true;
+    }
+    else return false;
 }
 
 // Detect if a gamepad button is NOT being pressed
 bool IsGamepadButtonReleased(int gamepad, int button)
 {
-	const unsigned char* buttons;
-	int buttonsCount;
-	
-	buttons = glfwGetJoystickButtons(gamepad, &buttonsCount);
-	
-	if (buttons[button] == GLFW_RELEASE)
-	{
-		return true;
-	}
-	else return false;
+    const unsigned char* buttons;
+    int buttonsCount;
+    
+    buttons = glfwGetJoystickButtons(gamepad, &buttonsCount);
+    
+    if (buttons[button] == GLFW_RELEASE)
+    {
+        return true;
+    }
+    else return false;
 }
 
 //----------------------------------------------------------------------------------
@@ -421,112 +421,112 @@ bool IsGamepadButtonReleased(int gamepad, int button)
 static void ErrorCallback(int error, const char *description)
 {
     printf(description);
-	//fprintf(stderr, description);
+    //fprintf(stderr, description);
 }
 
 // GLFW3 Keyboard Callback, runs on key pressed
 static void KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods)
 {
     if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
-	{
-		glfwSetWindowShouldClose(window, GL_TRUE);
-		
-		// NOTE: Before closing window, while loop must be left!
-	}
-	else if (key == GLFW_KEY_F11 && action == GLFW_PRESS)
-	{
-		ToggleFullscreen();
-	}
-	else if (key == GLFW_KEY_F12 && action == GLFW_PRESS)
-	{
-		TakeScreenshot();
-	}
+    {
+        glfwSetWindowShouldClose(window, GL_TRUE);
+        
+        // NOTE: Before closing window, while loop must be left!
+    }
+    else if (key == GLFW_KEY_F11 && action == GLFW_PRESS)
+    {
+        ToggleFullscreen();
+    }
+    else if (key == GLFW_KEY_F12 && action == GLFW_PRESS)
+    {
+        TakeScreenshot();
+    }
 }
 
 // GLFW3 WindowSize Callback, runs when window is resized
 static void WindowSizeCallback(GLFWwindow* window, int width, int height)
 {
-	InitGraphicsDevice();	// If window is resized, graphics device is re-initialized
-							// NOTE: Aspect ratio does not change, so, image can be deformed
+    InitGraphicsDevice();   // If window is resized, graphics device is re-initialized
+                            // NOTE: Aspect ratio does not change, so, image can be deformed
 }
 
 // Initialize Graphics Device (OpenGL stuff)
 static void InitGraphicsDevice()
 {
-	int fbWidth, fbHeight;
-	
-	glfwGetFramebufferSize(window, &fbWidth, &fbHeight);	// Get framebuffer size of current window
-
-	glViewport(0, 0, fbWidth, fbHeight);					// Set viewport width and height
-
-	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 	// Clear used buffers, depth buffer is used for 3D
-	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);					// Set background color (black)
-	glClearDepth(1.0f);										// Clear depth buffer
-	
-	glEnable(GL_DEPTH_TEST);								// Enables depth testing (required for 3D)
-	glDepthFunc(GL_LEQUAL);									// Type of depth testing to apply
-	
-	glEnable(GL_BLEND);										// Enable color blending (required to work with transparencies)
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);		// Color blending function (how colors are mixed)
-	
-	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);		// Improve quality of color and texture coordinate interpolation (Deprecated in OGL 3.0)
-															// Other options: GL_FASTEST, GL_DONT_CARE (default)
-	
-	glMatrixMode(GL_PROJECTION);				// Switch to PROJECTION matrix
-	glLoadIdentity();							// Reset current matrix (PROJECTION)
-	glOrtho(0, fbWidth, fbHeight, 0, 0, 1);		// Config orthographic mode: top-left corner --> (0,0)
-	glMatrixMode(GL_MODELVIEW);					// Switch back to MODELVIEW matrix
-	glLoadIdentity();							// Reset current matrix (MODELVIEW)
-	
-	glDisable(GL_LIGHTING);						// Lighting Disabled...
-	
-	// TODO: Create an efficient Lighting System with proper functions (raylib 1.x)
-/*	
-	glEnable(GL_COLOR_MATERIAL);						// Enable materials, causes some glMaterial atributes to track the current color (glColor)...
-	glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);	// Material types and where to apply them
-														// NOTE: ONLY works with lighting; defines how light interacts with material
-														
-	glLightfv(GL_LIGHT1, GL_AMBIENT, lightAmbient);		// Define ambient light color property
-	glLightfv(GL_LIGHT1, GL_DIFFUSE, lightDiffuse); 	// Define diffuse light color property
-	glLightfv(GL_LIGHT1, GL_POSITION, lightPosition); 	// Define light position
-	
-	glEnable(GL_LIGHTING);
-	glEnable(GL_LIGHT1); 								// Enable light one (8 lights available at the same time)
-*/	
-	// TODO: Review all shapes/models are drawn CCW and enable backface culling
-
-	//glEnable(GL_CULL_FACE);		// Enable backface culling (Disabled by default)
-	//glCullFace(GL_BACK);			// Cull the Back face (default)
-	//glFrontFace(GL_CCW);			// Front face are defined counter clockwise (default)
-	
-	glShadeModel(GL_SMOOTH);		// Smooth shading between vertex (vertex colors interpolation)
-									// Possible options: GL_SMOOTH (Color interpolation) or GL_FLAT (no interpolation)
+    int fbWidth, fbHeight;
+    
+    glfwGetFramebufferSize(window, &fbWidth, &fbHeight);    // Get framebuffer size of current window
+
+    glViewport(0, 0, fbWidth, fbHeight);                    // Set viewport width and height
+
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);     // Clear used buffers, depth buffer is used for 3D
+    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);                   // Set background color (black)
+    glClearDepth(1.0f);                                     // Clear depth buffer
+    
+    glEnable(GL_DEPTH_TEST);                                // Enables depth testing (required for 3D)
+    glDepthFunc(GL_LEQUAL);                                 // Type of depth testing to apply
+    
+    glEnable(GL_BLEND);                                     // Enable color blending (required to work with transparencies)
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);      // Color blending function (how colors are mixed)
+    
+    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);      // Improve quality of color and texture coordinate interpolation (Deprecated in OGL 3.0)
+                                                            // Other options: GL_FASTEST, GL_DONT_CARE (default)
+    
+    glMatrixMode(GL_PROJECTION);                // Switch to PROJECTION matrix
+    glLoadIdentity();                           // Reset current matrix (PROJECTION)
+    glOrtho(0, fbWidth, fbHeight, 0, 0, 1);     // Config orthographic mode: top-left corner --> (0,0)
+    glMatrixMode(GL_MODELVIEW);                 // Switch back to MODELVIEW matrix
+    glLoadIdentity();                           // Reset current matrix (MODELVIEW)
+    
+    glDisable(GL_LIGHTING);                     // Lighting Disabled...
+    
+    // TODO: Create an efficient Lighting System with proper functions (raylib 1.x)
+/*    
+    glEnable(GL_COLOR_MATERIAL);                        // Enable materials, causes some glMaterial atributes to track the current color (glColor)...
+    glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);  // Material types and where to apply them
+                                                        // NOTE: ONLY works with lighting; defines how light interacts with material
+                                                        
+    glLightfv(GL_LIGHT1, GL_AMBIENT, lightAmbient);     // Define ambient light color property
+    glLightfv(GL_LIGHT1, GL_DIFFUSE, lightDiffuse);     // Define diffuse light color property
+    glLightfv(GL_LIGHT1, GL_POSITION, lightPosition);   // Define light position
+    
+    glEnable(GL_LIGHTING);
+    glEnable(GL_LIGHT1);                                // Enable light one (8 lights available at the same time)
+*/    
+    // TODO: Review all shapes/models are drawn CCW and enable backface culling
+
+    //glEnable(GL_CULL_FACE);       // Enable backface culling (Disabled by default)
+    //glCullFace(GL_BACK);          // Cull the Back face (default)
+    //glFrontFace(GL_CCW);          // Front face are defined counter clockwise (default)
+    
+    glShadeModel(GL_SMOOTH);        // Smooth shading between vertex (vertex colors interpolation)
+                                    // Possible options: GL_SMOOTH (Color interpolation) or GL_FLAT (no interpolation)
 }
 
 // Setup camera view (updates MODELVIEW matrix)
 static void CameraLookAt(Vector3 position, Vector3 target, Vector3 up)
 {
-    float rotMatrix[16];			// Matrix to store camera rotation
+    float rotMatrix[16];            // Matrix to store camera rotation
     
-	Vector3 rotX, rotY, rotZ;				// Vectors to calculate camera rotations X, Y, Z (Euler)
+    Vector3 rotX, rotY, rotZ;                // Vectors to calculate camera rotations X, Y, Z (Euler)
     
     // Construct rotation matrix from vectors
-	rotZ = VectorSubtract(position, target);
-	VectorNormalize(&rotZ);
-    rotY = up;	    						// Y rotation vector
-	rotX = VectorCrossProduct(rotY, rotZ);	// X rotation vector = Y cross Z
-    rotY = VectorCrossProduct(rotZ, rotX);	// Recompute Y rotation = Z cross X
-    VectorNormalize(&rotX);					// X rotation vector normalization
-    VectorNormalize(&rotY);					// Y rotation vector normalization
+    rotZ = VectorSubtract(position, target);
+    VectorNormalize(&rotZ);
+    rotY = up;                                // Y rotation vector
+    rotX = VectorCrossProduct(rotY, rotZ);    // X rotation vector = Y cross Z
+    rotY = VectorCrossProduct(rotZ, rotX);    // Recompute Y rotation = Z cross X
+    VectorNormalize(&rotX);                   // X rotation vector normalization
+    VectorNormalize(&rotY);                   // Y rotation vector normalization
     
     rotMatrix[0] = rotX.x;
-	rotMatrix[1] = rotY.x;
-    rotMatrix[2] = rotZ.x;	
-    rotMatrix[3] = 0.0f;	
+    rotMatrix[1] = rotY.x;
+    rotMatrix[2] = rotZ.x;    
+    rotMatrix[3] = 0.0f;    
     rotMatrix[4] = rotX.y;
-    rotMatrix[5] = rotY.y;	
+    rotMatrix[5] = rotY.y;    
     rotMatrix[6] = rotZ.y;
-    rotMatrix[7] = 0.0f;	
+    rotMatrix[7] = 0.0f;    
     rotMatrix[8] = rotX.z;
     rotMatrix[9] = rotY.z;
     rotMatrix[10] = rotZ.z;
@@ -536,9 +536,9 @@ static void CameraLookAt(Vector3 position, Vector3 target, Vector3 up)
     rotMatrix[14] = 0.0f;
     rotMatrix[15] = 1.0f;
 
-    glMultMatrixf(rotMatrix);	// Multiply MODELVIEW matrix by rotation matrix
+    glMultMatrixf(rotMatrix);    // Multiply MODELVIEW matrix by rotation matrix
     
-    glTranslatef(-position.x, -position.y, -position.z);	// Translate eye to position
+    glTranslatef(-position.x, -position.y, -position.z);    // Translate eye to position
 }
 
 // Setup view projection (updates PROJECTION matrix)
@@ -557,26 +557,26 @@ static void SetPerspective(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdou
 // Takes a bitmap (BMP) screenshot and saves it in the same folder as executable
 static void TakeScreenshot()
 {
-	static int shotNum = 0;		// Screenshot number, increments every screenshot take during program execution
-		
-	char buffer[20];			// Buffer to store file name
-	int fbWidth, fbHeight;
-	
-	Color *imgDataPixel; 		// Pixel image data array
+    static int shotNum = 0;     // Screenshot number, increments every screenshot take during program execution
+        
+    char buffer[20];            // Buffer to store file name
+    int fbWidth, fbHeight;
+    
+    Color *imgDataPixel;        // Pixel image data array
 
-	glfwGetFramebufferSize(window, &fbWidth, &fbHeight);	// Get framebuffer size of current window
+    glfwGetFramebufferSize(window, &fbWidth, &fbHeight);    // Get framebuffer size of current window
 
-	imgDataPixel = (Color *)malloc(fbWidth * fbHeight * sizeof(Color));
+    imgDataPixel = (Color *)malloc(fbWidth * fbHeight * sizeof(Color));
 
-	// NOTE: glReadPixels returns image flipped vertically -> (0,0) is the bottom left corner of the framebuffer
-	glReadPixels(0, 0, fbWidth, fbHeight, GL_RGBA, GL_UNSIGNED_BYTE, imgDataPixel);
-	
-	sprintf(buffer, "screenshot%03i.bmp", shotNum);
+    // NOTE: glReadPixels returns image flipped vertically -> (0,0) is the bottom left corner of the framebuffer
+    glReadPixels(0, 0, fbWidth, fbHeight, GL_RGBA, GL_UNSIGNED_BYTE, imgDataPixel);
+    
+    sprintf(buffer, "screenshot%03i.bmp", shotNum);
 
-	// NOTE: BMP directly stores data flipped vertically
-	WriteBitmap(buffer, imgDataPixel, fbWidth, fbHeight);	// Writes pixel data array into a bitmap (BMP) file
-	
-	free(imgDataPixel);
-	
-	shotNum++;
+    // NOTE: BMP directly stores data flipped vertically
+    WriteBitmap(buffer, imgDataPixel, fbWidth, fbHeight);    // Writes pixel data array into a bitmap (BMP) file
+    
+    free(imgDataPixel);
+    
+    shotNum++;
 }
\ No newline at end of file