Review ALL examples

examples/audio/audio_module_playing.c

@@ -23,25 +23,25 @@ typedef struct {
     Color color;
 } CircleWave;
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);  // NOTE: Try to enable MSAA 4X
-    
+
     InitWindow(screenWidth, screenHeight, "raylib [audio] example - module playing (streaming)");
 
     InitAudioDevice();                  // Initialize audio device
-    
+
     Color colors[14] = { ORANGE, RED, GOLD, LIME, BLUE, VIOLET, BROWN, LIGHTGRAY, PINK,
                          YELLOW, GREEN, SKYBLUE, PURPLE, BEIGE };
-    
+
     // Creates ome circles for visual effect
     CircleWave circles[MAX_CIRCLES];
-    
+
     for (int i = MAX_CIRCLES - 1; i >= 0; i--)
     {
         circles[i].alpha = 0.0f;
@@ -53,7 +53,7 @@ int main()
     }
 
     Music xm = LoadMusicStream("resources/chiptun1.mod");
-    
+
     PlayMusicStream(xm);
 
     float timePlayed = 0.0f;
@@ -68,34 +68,34 @@ int main()
         // Update
         //----------------------------------------------------------------------------------
         UpdateMusicStream(xm);        // Update music buffer with new stream data
-        
+
         // Restart music playing (stop and play)
-        if (IsKeyPressed(KEY_SPACE)) 
+        if (IsKeyPressed(KEY_SPACE))
         {
             StopMusicStream(xm);
             PlayMusicStream(xm);
         }
-        
+
-        // Pause/Resume music playing 
+        // Pause/Resume music playing
         if (IsKeyPressed(KEY_P))
         {
             pause = !pause;
-            
+
             if (pause) PauseMusicStream(xm);
             else ResumeMusicStream(xm);
         }
-        
+
         // Get timePlayed scaled to bar dimensions
         timePlayed = GetMusicTimePlayed(xm)/GetMusicTimeLength(xm)*(screenWidth - 40);
-        
+
         // Color circles animation
         for (int i = MAX_CIRCLES - 1; (i >= 0) && !pause; i--)
         {
             circles[i].alpha += circles[i].speed;
             circles[i].radius += circles[i].speed*10.0f;
-            
+
             if (circles[i].alpha > 1.0f) circles[i].speed *= -1;
-            
+
             if (circles[i].alpha <= 0.0f)
             {
                 circles[i].alpha = 0.0f;
@@ -113,12 +113,12 @@ int main()
         BeginDrawing();
 
             ClearBackground(RAYWHITE);
-            
+
             for (int i = MAX_CIRCLES - 1; i >= 0; i--)
             {
                 DrawCircleV(circles[i].position, circles[i].radius, Fade(circles[i].color, circles[i].alpha));
             }
-            
+
             // Draw time bar
             DrawRectangle(20, screenHeight - 20 - 12, screenWidth - 40, 12, LIGHTGRAY);
             DrawRectangle(20, screenHeight - 20 - 12, (int)timePlayed, 12, MAROON);
@@ -131,7 +131,7 @@ int main()
     // De-Initialization
     //--------------------------------------------------------------------------------------
     UnloadMusicStream(xm);          // Unload music stream buffers from RAM
-    
+
     CloseAudioDevice();     // Close audio device (music streaming is automatically stopped)
 
     CloseWindow();          // Close window and OpenGL context

examples/audio/audio_music_stream.c

@@ -4,7 +4,7 @@
 *
 *   NOTE: This example requires OpenAL Soft library installed
 *
-*   This example has been created using raylib 1.7 (www.raylib.com)
+*   This example has been created using raylib 1.3 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
 *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
@@ -13,19 +13,19 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [audio] example - music playing (streaming)");
 
     InitAudioDevice();              // Initialize audio device
 
     Music music = LoadMusicStream("resources/guitar_noodling.ogg");
-    
+
     PlayMusicStream(music);
 
     float timePlayed = 0.0f;
@@ -39,27 +39,27 @@ int main()
     {
         // Update
         //----------------------------------------------------------------------------------
-        UpdateMusicStream(music);        // Update music buffer with new stream data
+        UpdateMusicStream(music);   // Update music buffer with new stream data
-        
+
         // Restart music playing (stop and play)
-        if (IsKeyPressed(KEY_SPACE)) 
+        if (IsKeyPressed(KEY_SPACE))
         {
             StopMusicStream(music);
             PlayMusicStream(music);
         }
-        
+
-        // Pause/Resume music playing 
+        // Pause/Resume music playing
         if (IsKeyPressed(KEY_P))
         {
             pause = !pause;
-            
+
             if (pause) PauseMusicStream(music);
             else ResumeMusicStream(music);
         }
-        
+
         // Get timePlayed scaled to bar dimensions (400 pixels)
         timePlayed = GetMusicTimePlayed(music)/GetMusicTimeLength(music)*400;
-        
+
         if (timePlayed > 400) StopMusicStream(music);
         //----------------------------------------------------------------------------------
 
@@ -74,7 +74,7 @@ int main()
             DrawRectangle(200, 200, 400, 12, LIGHTGRAY);
             DrawRectangle(200, 200, (int)timePlayed, 12, MAROON);
             DrawRectangleLines(200, 200, 400, 12, GRAY);
-            
+
             DrawText("PRESS SPACE TO RESTART MUSIC", 215, 250, 20, LIGHTGRAY);
             DrawText("PRESS P TO PAUSE/RESUME MUSIC", 208, 280, 20, LIGHTGRAY);
 

examples/audio/audio_raw_stream.c

@@ -20,12 +20,12 @@
 #define MAX_SAMPLES               512
 #define MAX_SAMPLES_PER_UPDATE   4096
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [audio] example - raw audio streaming");
 
@@ -33,30 +33,30 @@ int main()
 
     // Init raw audio stream (sample rate: 22050, sample size: 16bit-short, channels: 1-mono)
     AudioStream stream = InitAudioStream(22050, 16, 1);
-    
+
     // Buffer for the single cycle waveform we are synthesizing
     short *data = (short *)malloc(sizeof(short)*MAX_SAMPLES);
 
     // Frame buffer, describing the waveform when repeated over the course of a frame
     short *writeBuf = (short *)malloc(sizeof(short)*MAX_SAMPLES_PER_UPDATE);
-    
+
     PlayAudioStream(stream);        // Start processing stream buffer (no data loaded currently)
-    
+
     // Position read in to determine next frequency
     Vector2 mousePosition = { -100.0f, -100.0f };
-    
+
     // Cycles per second (hz)
     float frequency = 440.0f;
-    
+
     // Previous value, used to test if sine needs to be rewritten, and to smoothly modulate frequency
     float oldFrequency = 1.0f;
-    
+
     // Cursor to read and copy the samples of the sine wave buffer
     int readCursor = 0;
-    
+
     // Computed size in samples of the sine wave
     int waveLength = 1;
-    
+
     Vector2 position = { 0, 0 };
 
     SetTargetFPS(30);               // Set our game to run at 30 frames-per-second
@@ -67,62 +67,62 @@ int main()
     {
         // Update
         //----------------------------------------------------------------------------------
-        
+
         // Sample mouse input.
         mousePosition = GetMousePosition();
-        
+
-        if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) 
+        if (IsMouseButtonDown(MOUSE_LEFT_BUTTON))
         {
             float fp = (float)(mousePosition.y);
             frequency = 40.0f + (float)(fp);
         }
-        
+
         // Rewrite the sine wave.
         // Compute two cycles to allow the buffer padding, simplifying any modulation, resampling, etc.
-        if (frequency != oldFrequency) 
+        if (frequency != oldFrequency)
         {
             // Compute wavelength. Limit size in both directions.
             int oldWavelength = waveLength;
             waveLength = (int)(22050/frequency);
             if (waveLength > MAX_SAMPLES/2) waveLength = MAX_SAMPLES/2;
             if (waveLength < 1) waveLength = 1;
-            
+
             // Write sine wave.
             for (int i = 0; i < waveLength*2; i++)
             {
                 data[i] = (short)(sinf(((2*PI*(float)i/waveLength)))*32000);
             }
-            
+
             // Scale read cursor's position to minimize transition artifacts
             readCursor = (int)(readCursor * ((float)waveLength / (float)oldWavelength));
             oldFrequency = frequency;
         }
-        
+
         // Refill audio stream if required
-        if (IsAudioBufferProcessed(stream)) 
+        if (IsAudioBufferProcessed(stream))
         {
             // Synthesize a buffer that is exactly the requested size
             int writeCursor = 0;
-            
+
-            while (writeCursor < MAX_SAMPLES_PER_UPDATE) 
+            while (writeCursor < MAX_SAMPLES_PER_UPDATE)
             {
                 // Start by trying to write the whole chunk at once
                 int writeLength = MAX_SAMPLES_PER_UPDATE-writeCursor;
-                
+
                 // Limit to the maximum readable size
                 int readLength = waveLength-readCursor;
-                
+
                 if (writeLength > readLength) writeLength = readLength;
 
                 // Write the slice
                 memcpy(writeBuf + writeCursor, data + readCursor, writeLength*sizeof(short));
-                
+
                 // Update cursors and loop audio
                 readCursor = (readCursor + writeLength) % waveLength;
-                
+
                 writeCursor += writeLength;
             }
-            
+
             // Copy finished frame to audio stream
             UpdateAudioStream(stream, writeBuf, MAX_SAMPLES_PER_UPDATE);
         }
@@ -136,13 +136,13 @@ int main()
 
             DrawText(FormatText("sine frequency: %i",(int)frequency), GetScreenWidth() - 220, 10, 20, RED);
             DrawText("click mouse button to change frequency", 10, 10, 20, DARKGRAY);
-            
+
             // Draw the current buffer state proportionate to the screen
             for (int i = 0; i < screenWidth; i++)
             {
                 position.x = i;
                 position.y = 250 + 50*data[i*MAX_SAMPLES/screenWidth]/32000;
-                
+
                 DrawPixelV(position, RED);
             }
 
@@ -154,7 +154,7 @@ int main()
     //--------------------------------------------------------------------------------------
     free(data);                 // Unload sine wave data
     free(writeBuf);             // Unload write buffer
-    
+
     CloseAudioStream(stream);   // Close raw audio stream and delete buffers from RAM
     CloseAudioDevice();         // Close audio device (music streaming is automatically stopped)
 

examples/audio/audio_sound_loading.c

@@ -4,21 +4,21 @@
 *
 *   NOTE: This example requires OpenAL Soft library installed
 *
-*   This example has been created using raylib 1.3 (www.raylib.com)
+*   This example has been created using raylib 1.0 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
-*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*   Copyright (c) 2014 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [audio] example - sound loading and playing");
 
@@ -26,8 +26,8 @@ int main()
 
     Sound fxWav = LoadSound("resources/sound.wav");         // Load WAV audio file
     Sound fxOgg = LoadSound("resources/tanatana.ogg");      // Load OGG audio file
-    
+
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/core/core_2d_camera.c

@@ -13,21 +13,21 @@
 
 #define MAX_BUILDINGS   100
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [core] example - 2d camera");
-    
+
     Rectangle player = { 400, 280, 40, 40 };
     Rectangle buildings[MAX_BUILDINGS];
     Color buildColors[MAX_BUILDINGS];
-    
+
     int spacing = 0;
-    
+
     for (int i = 0; i < MAX_BUILDINGS; i++)
     {
         buildings[i].width = GetRandomValue(50, 200);
@@ -36,22 +36,22 @@ int main()
         buildings[i].x = -6000 + spacing;
 
         spacing += buildings[i].width;
-        
+
         buildColors[i] = (Color){ GetRandomValue(200, 240), GetRandomValue(200, 240), GetRandomValue(200, 250), 255 };
     }
-    
+
-    Camera2D camera;
+    Camera2D camera = { 0 };
-    
+
     camera.target = (Vector2){ player.x + 20, player.y + 20 };
     camera.offset = (Vector2){ 0, 0 };
     camera.rotation = 0.0f;
     camera.zoom = 1.0f;
-    
+
-    SetTargetFPS(60);
+    SetTargetFPS(60);                   // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop
-    while (!WindowShouldClose())    // Detect window close button or ESC key
+    while (!WindowShouldClose())        // Detect window close button or ESC key
     {
         // Update
         //----------------------------------------------------------------------------------
@@ -65,26 +65,26 @@ int main()
             player.x -= 2;              // Player movement
             camera.offset.x += 2;       // Camera displacement with player movement
         }
-        
+
         // Camera target follows player
         camera.target = (Vector2){ player.x + 20, player.y + 20 };
-        
+
         // Camera rotation controls
         if (IsKeyDown(KEY_A)) camera.rotation--;
         else if (IsKeyDown(KEY_S)) camera.rotation++;
-        
+
         // Limit camera rotation to 80 degrees (-40 to 40)
-        if (camera.rotation > 40) camera.rotation = 40;         
+        if (camera.rotation > 40) camera.rotation = 40;
         else if (camera.rotation < -40) camera.rotation = -40;
-        
+
         // Camera zoom controls
         camera.zoom += ((float)GetMouseWheelMove()*0.05f);
-        
+
         if (camera.zoom > 3.0f) camera.zoom = 3.0f;
         else if (camera.zoom < 0.1f) camera.zoom = 0.1f;
-        
+
         // Camera reset (zoom and rotation)
-        if (IsKeyPressed(KEY_R)) 
+        if (IsKeyPressed(KEY_R))
         {
             camera.zoom = 1.0f;
             camera.rotation = 0.0f;
@@ -94,32 +94,32 @@ int main()
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-        
+
             BeginMode2D(camera);
 
                 DrawRectangle(-6000, 320, 13000, 8000, DARKGRAY);
-                
+
                 for (int i = 0; i < MAX_BUILDINGS; i++) DrawRectangleRec(buildings[i], buildColors[i]);
-                
+
                 DrawRectangleRec(player, RED);
-                
+
                 DrawLine(camera.target.x, -screenHeight*10, camera.target.x, screenHeight*10, GREEN);
                 DrawLine(-screenWidth*10, camera.target.y, screenWidth*10, camera.target.y, GREEN);
-                
+
             EndMode2D();
-            
+
             DrawText("SCREEN AREA", 640, 10, 20, RED);
-            
+
             DrawRectangle(0, 0, screenWidth, 5, RED);
             DrawRectangle(0, 5, 5, screenHeight - 10, RED);
             DrawRectangle(screenWidth - 5, 5, 5, screenHeight - 10, RED);
             DrawRectangle(0, screenHeight - 5, screenWidth, 5, RED);
-            
+
             DrawRectangle( 10, 10, 250, 113, Fade(SKYBLUE, 0.5f));
             DrawRectangleLines( 10, 10, 250, 113, BLUE);
-            
+
             DrawText("Free 2d camera controls:", 20, 20, 10, BLACK);
             DrawText("- Right/Left to move Offset", 40, 40, 10, DARKGRAY);
             DrawText("- Mouse Wheel to Zoom in-out", 40, 60, 10, DARKGRAY);
@@ -131,7 +131,7 @@ int main()
     }
 
     // De-Initialization
-    //--------------------------------------------------------------------------------------   
+    //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 

examples/core/core_3d_camera_first_person.c

@@ -13,15 +13,15 @@
 
 #define MAX_COLUMNS 20
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera first person");
-    
+
     // Define the camera to look into our 3d world (position, target, up vector)
     Camera camera = { 0 };
     camera.position = (Vector3){ 4.0f, 2.0f, 4.0f };
@@ -34,14 +34,14 @@ int main()
     float heights[MAX_COLUMNS];
     Vector3 positions[MAX_COLUMNS];
     Color colors[MAX_COLUMNS];
-    
+
     for (int i = 0; i < MAX_COLUMNS; i++)
     {
         heights[i] = (float)GetRandomValue(1, 12);
         positions[i] = (Vector3){ GetRandomValue(-15, 15), heights[i]/2, GetRandomValue(-15, 15) };
         colors[i] = (Color){ GetRandomValue(20, 255), GetRandomValue(10, 55), 30, 255 };
     }
-    
+
     SetCameraMode(camera, CAMERA_FIRST_PERSON); // Set a first person camera mode
 
     SetTargetFPS(60);                           // Set our game to run at 60 frames-per-second
@@ -67,7 +67,7 @@ int main()
                 DrawCube((Vector3){ -16.0f, 2.5f, 0.0f }, 1.0f, 5.0f, 32.0f, BLUE);     // Draw a blue wall
                 DrawCube((Vector3){ 16.0f, 2.5f, 0.0f }, 1.0f, 5.0f, 32.0f, LIME);      // Draw a green wall
                 DrawCube((Vector3){ 0.0f, 2.5f, 16.0f }, 32.0f, 5.0f, 1.0f, GOLD);      // Draw a yellow wall
-            
+
                 // Draw some cubes around
                 for (int i = 0; i < MAX_COLUMNS; i++)
                 {
@@ -76,7 +76,7 @@ int main()
                 }
 
             EndMode3D();
-            
+
             DrawRectangle( 10, 10, 220, 70, Fade(SKYBLUE, 0.5f));
             DrawRectangleLines( 10, 10, 220, 70, BLUE);
 
@@ -89,7 +89,7 @@ int main()
     }
 
     // De-Initialization
-    //--------------------------------------------------------------------------------------   
+    //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 

examples/core/core_3d_camera_free.c

@@ -11,12 +11,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera free");
 
@@ -27,9 +27,9 @@ int main()
     camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };          // Camera up vector (rotation towards target)
     camera.fovy = 45.0f;                                // Camera field-of-view Y
     camera.type = CAMERA_PERSPECTIVE;                   // Camera mode type
-    
+
     Vector3 cubePosition = { 0.0f, 0.0f, 0.0f };
-    
+
     SetCameraMode(camera, CAMERA_FREE); // Set a free camera mode
 
     SetTargetFPS(60);                   // Set our game to run at 60 frames-per-second
@@ -41,7 +41,7 @@ int main()
         // Update
         //----------------------------------------------------------------------------------
         UpdateCamera(&camera);          // Update camera
-        
+
         if (IsKeyDown('Z')) camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };
         //----------------------------------------------------------------------------------
 
@@ -59,10 +59,10 @@ int main()
                 DrawGrid(10, 1.0f);
 
             EndMode3D();
-            
+
             DrawRectangle( 10, 10, 320, 133, Fade(SKYBLUE, 0.5f));
             DrawRectangleLines( 10, 10, 320, 133, BLUE);
-            
+
             DrawText("Free camera default controls:", 20, 20, 10, BLACK);
             DrawText("- Mouse Wheel to Zoom in-out", 40, 40, 10, DARKGRAY);
             DrawText("- Mouse Wheel Pressed to Pan", 40, 60, 10, DARKGRAY);

examples/core/core_3d_camera_mode.c

@@ -11,7 +11,7 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
@@ -30,7 +30,7 @@ int main()
 
     Vector3 cubePosition = { 0.0f, 0.0f, 0.0f };
 
-    SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/core/core_3d_picking.c

@@ -11,12 +11,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d picking");
 

examples/core/core_basic_window.c

@@ -21,16 +21,16 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window");
-    
+
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop
@@ -54,7 +54,7 @@ int main()
     }
 
     // De-Initialization
-    //--------------------------------------------------------------------------------------   
+    //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 

examples/core/core_custom_logging.c

@@ -19,66 +19,66 @@
 // Custom logging funtion
 void LogCustom(int msgType, const char *text, va_list args)
 {
-	char timeStr[64];
+    char timeStr[64];
-	time_t now = time(NULL);
+    time_t now = time(NULL);
-	struct tm *tm_info = localtime(&now);
+    struct tm *tm_info = localtime(&now);
 
-	strftime(timeStr, sizeof(timeStr), "%Y-%m-%d %H:%M:%S", tm_info);
+    strftime(timeStr, sizeof(timeStr), "%Y-%m-%d %H:%M:%S", tm_info);
-	printf("[%s] ", timeStr);
+    printf("[%s] ", timeStr);
 
-	switch (msgType)
+    switch (msgType)
-	{
+    {
-		case LOG_INFO: printf("[INFO] : "); break;
+        case LOG_INFO: printf("[INFO] : "); break;
-		case LOG_ERROR: printf("[ERROR]: "); break;
+        case LOG_ERROR: printf("[ERROR]: "); break;
-		case LOG_WARNING: printf("[WARN] : "); break;
+        case LOG_WARNING: printf("[WARN] : "); break;
-		case LOG_DEBUG: printf("[DEBUG]: "); break;
+        case LOG_DEBUG: printf("[DEBUG]: "); break;
-		default: break;
+        default: break;
-	}
+    }
-    
+
-	vprintf(text, args);
+    vprintf(text, args);
-	printf("\n");
+    printf("\n");
 }
 
 int main(int argc, char* argv[])
 {
-	// Initialization
+    // Initialization
-	//--------------------------------------------------------------------------------------
+    //--------------------------------------------------------------------------------------
-	int screenWidth = 800;
+    const int screenWidth = 800;
-	int screenHeight = 450;
+    const int screenHeight = 450;
 
-	// First thing we do is setting our custom logger to ensure everything raylib logs
+    // First thing we do is setting our custom logger to ensure everything raylib logs
-	// will use our own logger instead of its internal one
+    // will use our own logger instead of its internal one
-	SetTraceLogCallback(LogCustom);
+    SetTraceLogCallback(LogCustom);
 
-	InitWindow(screenWidth, screenHeight, "raylib [core] example - custom logging");
+    InitWindow(screenWidth, screenHeight, "raylib [core] example - custom logging");
 
-	SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
-	//--------------------------------------------------------------------------------------
+    //--------------------------------------------------------------------------------------
 
-	// Main game loop
+    // Main game loop
-	while (!WindowShouldClose())    // Detect window close button or ESC key
+    while (!WindowShouldClose())    // Detect window close button or ESC key
-	{
+    {
-		// Update
+        // Update
-		//----------------------------------------------------------------------------------
+        //----------------------------------------------------------------------------------
-		// TODO: Update your variables here
+        // TODO: Update your variables here
-		//----------------------------------------------------------------------------------
+        //----------------------------------------------------------------------------------
 
-		// Draw
+        // Draw
-		//----------------------------------------------------------------------------------
+        //----------------------------------------------------------------------------------
-		BeginDrawing();
+        BeginDrawing();
 
-		ClearBackground(RAYWHITE);
+        ClearBackground(RAYWHITE);
 
-		DrawText("Check out the console output to see the custom logger in action!", 60, 200, 20, LIGHTGRAY);
+        DrawText("Check out the console output to see the custom logger in action!", 60, 200, 20, LIGHTGRAY);
 
-		EndDrawing();
+        EndDrawing();
-		//----------------------------------------------------------------------------------
+        //----------------------------------------------------------------------------------
-	}
+    }
 
-	// De-Initialization
+    // De-Initialization
-	//--------------------------------------------------------------------------------------
+    //--------------------------------------------------------------------------------------
-	CloseWindow();        // Close window and OpenGL context
+    CloseWindow();        // Close window and OpenGL context
-	//--------------------------------------------------------------------------------------
+    //--------------------------------------------------------------------------------------
 
-	return 0;
+    return 0;
 }

examples/core/core_drop_files.c

@@ -13,19 +13,19 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [core] example - drop files");
-    
+
     int count = 0;
     char **droppedFiles = { 0 };
-    
+
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop
@@ -49,15 +49,15 @@ int main()
             else
             {
                 DrawText("Dropped files:", 100, 40, 20, DARKGRAY);
-                
+
                 for (int i = 0; i < count; i++)
                 {
                     if (i%2 == 0) DrawRectangle(0, 85 + 40*i, screenWidth, 40, Fade(LIGHTGRAY, 0.5f));
                     else DrawRectangle(0, 85 + 40*i, screenWidth, 40, Fade(LIGHTGRAY, 0.3f));
-                    
+
                     DrawText(droppedFiles[i], 120, 100 + 40*i, 10, GRAY);
                 }
-                
+
                 DrawText("Drop new files...", 100, 110 + 40*count, 20, DARKGRAY);
             }
 
@@ -68,7 +68,7 @@ int main()
     // De-Initialization
     //--------------------------------------------------------------------------------------
     ClearDroppedFiles();    // Clear internal buffers
-    
+
     CloseWindow();          // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 

examples/core/core_input_gamepad.c

@@ -3,15 +3,15 @@
 *   raylib [core] example - Gamepad input
 *
 *   NOTE: This example requires a Gamepad connected to the system
-*         raylib is configured to work with the following gamepads: 
+*         raylib is configured to work with the following gamepads:
 *                - Xbox 360 Controller (Xbox 360, Xbox One)
-*                - PLAYSTATION(R)3 Controller 
+*                - PLAYSTATION(R)3 Controller
 *         Check raylib.h for buttons configuration
 *
-*   This example has been created using raylib 1.6 (www.raylib.com)
+*   This example has been created using raylib 2.5 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
-*   Copyright (c) 2013-2016 Ramon Santamaria (@raysan5)
+*   Copyright (c) 2013-2019 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -26,21 +26,21 @@
     #define PS3_NAME_ID         "PLAYSTATION(R)3 Controller"
 #endif
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
+
+    SetConfigFlags(FLAG_MSAA_4X_HINT);  // Set MSAA 4X hint before windows creation
 
-    SetConfigFlags(FLAG_MSAA_4X_HINT);  // Set MSAA 4X hint before windows creation  
-    
     InitWindow(screenWidth, screenHeight, "raylib [core] example - gamepad input");
-    
+
     Texture2D texPs3Pad = LoadTexture("resources/ps3.png");
     Texture2D texXboxPad = LoadTexture("resources/xbox.png");
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop
@@ -56,7 +56,7 @@ int main()
         BeginDrawing();
 
             ClearBackground(RAYWHITE);
-            
+
             if (IsGamepadAvailable(GAMEPAD_PLAYER1))
             {
                 DrawText(FormatText("GP1: %s", GetGamepadName(GAMEPAD_PLAYER1)), 10, 10, 10, BLACK);
@@ -64,7 +64,7 @@ int main()
                 if (IsGamepadName(GAMEPAD_PLAYER1, XBOX360_NAME_ID))
                 {
                     DrawTexture(texXboxPad, 0, 0, DARKGRAY);
-                    
+
                     // Draw buttons: xbox home
                     if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_BUTTON_MIDDLE)) DrawCircle(394, 89, 19, RED);
 
@@ -75,7 +75,7 @@ int main()
                     if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_BUTTON_RIGHT_FACE_DOWN)) DrawCircle(536, 187, 15, LIME);
                     if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_BUTTON_RIGHT_FACE_RIGHT)) DrawCircle(572, 151, 15, MAROON);
                     if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_BUTTON_RIGHT_FACE_UP)) DrawCircle(536, 115, 15, GOLD);
-                    
+
                     // Draw buttons: d-pad
                     DrawRectangle(317, 202, 19, 71, BLACK);
                     DrawRectangle(293, 228, 69, 19, BLACK);
@@ -83,7 +83,7 @@ int main()
                     if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_BUTTON_LEFT_FACE_DOWN)) DrawRectangle(317, 202 + 45, 19, 26, RED);
                     if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_BUTTON_LEFT_FACE_LEFT)) DrawRectangle(292, 228, 25, 19, RED);
                     if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_BUTTON_LEFT_FACE_RIGHT)) DrawRectangle(292 + 44, 228, 26, 19, RED);
-                    
+
                     // Draw buttons: left-right back
                     if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_BUTTON_LEFT_TRIGGER_1)) DrawCircle(259, 61, 20, RED);
                     if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_BUTTON_RIGHT_TRIGGER_1)) DrawCircle(536, 61, 20, RED);
@@ -91,21 +91,21 @@ int main()
                     // Draw axis: left joystick
                     DrawCircle(259, 152, 39, BLACK);
                     DrawCircle(259, 152, 34, LIGHTGRAY);
-                    DrawCircle(259 + (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_AXIS_LEFT_X)*20), 
+                    DrawCircle(259 + (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_AXIS_LEFT_X)*20),
                                152 - (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_AXIS_LEFT_Y)*20), 25, BLACK);
-                    
+
                     // Draw axis: right joystick
                     DrawCircle(461, 237, 38, BLACK);
                     DrawCircle(461, 237, 33, LIGHTGRAY);
-                    DrawCircle(461 + (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_AXIS_RIGHT_X)*20), 
+                    DrawCircle(461 + (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_AXIS_RIGHT_X)*20),
                                237 - (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_AXIS_RIGHT_Y)*20), 25, BLACK);
 
                     // Draw axis: left-right triggers
                     DrawRectangle(170, 30, 15, 70, GRAY);
-                    DrawRectangle(604, 30, 15, 70, GRAY);              
+                    DrawRectangle(604, 30, 15, 70, GRAY);
                     DrawRectangle(170, 30, 15, (((1.0f + GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_AXIS_LEFT_TRIGGER))/2.0f)*70), RED);
                     DrawRectangle(604, 30, 15, (((1.0f + GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_AXIS_RIGHT_TRIGGER))/2.0f)*70), RED);
-                    
+
                     //DrawText(FormatText("Xbox axis LT: %02.02f", GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_AXIS_LEFT_TRIGGER)), 10, 40, 10, BLACK);
                     //DrawText(FormatText("Xbox axis RT: %02.02f", GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_AXIS_RIGHT_TRIGGER)), 10, 60, 10, BLACK);
                 }
@@ -115,7 +115,7 @@ int main()
 
                     // Draw buttons: ps
                     if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_BUTTON_MIDDLE)) DrawCircle(396, 222, 13, RED);
-                    
+
                     // Draw buttons: basic
                     if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_BUTTON_MIDDLE_LEFT)) DrawRectangle(328, 170, 32, 13, RED);
                     if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_BUTTON_MIDDLE_RIGHT)) DrawTriangle((Vector2){ 436, 168 }, (Vector2){ 436, 185 }, (Vector2){ 464, 177 }, RED);
@@ -131,7 +131,7 @@ int main()
                     if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_BUTTON_LEFT_FACE_DOWN)) DrawRectangle(225, 132 + 54, 24, 30, RED);
                     if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_BUTTON_LEFT_FACE_LEFT)) DrawRectangle(195, 161, 30, 25, RED);
                     if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_BUTTON_LEFT_FACE_RIGHT)) DrawRectangle(195 + 54, 161, 30, 25, RED);
-                    
+
                     // Draw buttons: left-right back buttons
                     if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_BUTTON_LEFT_TRIGGER_1)) DrawCircle(239, 82, 20, RED);
                     if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_BUTTON_RIGHT_TRIGGER_1)) DrawCircle(557, 82, 20, RED);
@@ -139,42 +139,42 @@ int main()
                     // Draw axis: left joystick
                     DrawCircle(319, 255, 35, BLACK);
                     DrawCircle(319, 255, 31, LIGHTGRAY);
-                    DrawCircle(319 + (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_AXIS_LEFT_X)*20), 
+                    DrawCircle(319 + (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_AXIS_LEFT_X)*20),
                                255 + (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_AXIS_LEFT_Y)*20), 25, BLACK);
-                    
+
                     // Draw axis: right joystick
                     DrawCircle(475, 255, 35, BLACK);
                     DrawCircle(475, 255, 31, LIGHTGRAY);
-                    DrawCircle(475 + (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_AXIS_RIGHT_X)*20), 
+                    DrawCircle(475 + (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_AXIS_RIGHT_X)*20),
                                255 + (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_AXIS_RIGHT_Y)*20), 25, BLACK);
 
                     // Draw axis: left-right triggers
                     DrawRectangle(169, 48, 15, 70, GRAY);
-                    DrawRectangle(611, 48, 15, 70, GRAY);              
+                    DrawRectangle(611, 48, 15, 70, GRAY);
                     DrawRectangle(169, 48, 15, (((1.0f - GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_AXIS_LEFT_TRIGGER))/2.0f)*70), RED);
                     DrawRectangle(611, 48, 15, (((1.0f - GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_AXIS_RIGHT_TRIGGER))/2.0f)*70), RED);
                 }
                 else
                 {
                     DrawText("- GENERIC GAMEPAD -", 280, 180, 20, GRAY);
-                    
+
                     // TODO: Draw generic gamepad
                 }
-                
+
-                DrawText(FormatText("DETECTED AXIS [%i]:", GetGamepadAxisCount(GAMEPAD_PLAYER1)), 10, 50, 10, MAROON); 
+                DrawText(FormatText("DETECTED AXIS [%i]:", GetGamepadAxisCount(GAMEPAD_PLAYER1)), 10, 50, 10, MAROON);
-                
+
                 for (int i = 0; i < GetGamepadAxisCount(GAMEPAD_PLAYER1); i++)
                 {
                     DrawText(FormatText("AXIS %i: %.02f", i, GetGamepadAxisMovement(GAMEPAD_PLAYER1, i)), 20, 70 + 20*i, 10, DARKGRAY);
                 }
-                
+
                 if (GetGamepadButtonPressed() != -1) DrawText(FormatText("DETECTED BUTTON: %i", GetGamepadButtonPressed()), 10, 430, 10, RED);
                 else DrawText("DETECTED BUTTON: NONE", 10, 430, 10, GRAY);
             }
             else
             {
                 DrawText("GP1: NOT DETECTED", 10, 10, 10, GRAY);
-                
+
                 DrawTexture(texXboxPad, 0, 0, LIGHTGRAY);
             }
 
@@ -186,7 +186,7 @@ int main()
     //--------------------------------------------------------------------------------------
     UnloadTexture(texPs3Pad);
     UnloadTexture(texXboxPad);
-    
+
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 

examples/core/core_input_gestures.c

@@ -14,27 +14,27 @@
 
 #define MAX_GESTURE_STRINGS   20
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
-    
+
     InitWindow(screenWidth, screenHeight, "raylib [core] example - input gestures");
-    
+
     Vector2 touchPosition = { 0, 0 };
     Rectangle touchArea = { 220, 10, screenWidth - 230, screenHeight - 20 };
-    
+
     int gesturesCount = 0;
     char gestureStrings[MAX_GESTURE_STRINGS][32];
 
     int currentGesture = GESTURE_NONE;
     int lastGesture = GESTURE_NONE;
-    
+
     //SetGesturesEnabled(0b0000000000001001);   // Enable only some gestures to be detected
-    
+
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop
@@ -65,14 +65,14 @@ int main()
                     case GESTURE_PINCH_OUT: strcpy(gestureStrings[gesturesCount], "GESTURE PINCH OUT"); break;
                     default: break;
                 }
-                
+
                 gesturesCount++;
-                
+
                 // Reset gestures strings
                 if (gesturesCount >= MAX_GESTURE_STRINGS)
                 {
                     for (int i = 0; i < MAX_GESTURE_STRINGS; i++) strcpy(gestureStrings[i], "\0");
-                    
+
                     gesturesCount = 0;
                 }
             }
@@ -84,32 +84,32 @@ int main()
         BeginDrawing();
 
             ClearBackground(RAYWHITE);
-            
+
             DrawRectangleRec(touchArea, GRAY);
             DrawRectangle(225, 15, screenWidth - 240, screenHeight - 30, RAYWHITE);
-            
+
             DrawText("GESTURES TEST AREA", screenWidth - 270, screenHeight - 40, 20, Fade(GRAY, 0.5f));
-            
+
             for (int i = 0; i < gesturesCount; i++)
             {
                 if (i%2 == 0) DrawRectangle(10, 30 + 20*i, 200, 20, Fade(LIGHTGRAY, 0.5f));
                 else DrawRectangle(10, 30 + 20*i, 200, 20, Fade(LIGHTGRAY, 0.3f));
-                
+
                 if (i < gesturesCount - 1) DrawText(gestureStrings[i], 35, 36 + 20*i, 10, DARKGRAY);
                 else DrawText(gestureStrings[i], 35, 36 + 20*i, 10, MAROON);
             }
-            
+
             DrawRectangleLines(10, 29, 200, screenHeight - 50, GRAY);
             DrawText("DETECTED GESTURES", 50, 15, 10, GRAY);
-            
+
             if (currentGesture != GESTURE_NONE) DrawCircleV(touchPosition, 30, MAROON);
-            
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
 
     // De-Initialization
-    //--------------------------------------------------------------------------------------   
+    //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 }

examples/core/core_input_keys.c

@@ -11,18 +11,18 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [core] example - keyboard input");
 
     Vector2 ballPosition = { (float)screenWidth/2, (float)screenHeight/2 };
 
-    SetTargetFPS(60);       // Set target frames-per-second
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/core/core_input_mouse.c

@@ -11,19 +11,19 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse input");
 
     Vector2 ballPosition = { -100.0f, -100.0f };
     Color ballColor = DARKBLUE;
-    
+
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //---------------------------------------------------------------------------------------
 
     // Main game loop
@@ -32,7 +32,7 @@ int main()
         // Update
         //----------------------------------------------------------------------------------
         ballPosition = GetMousePosition();
-        
+
         if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) ballColor = MAROON;
         else if (IsMouseButtonPressed(MOUSE_MIDDLE_BUTTON)) ballColor = LIME;
         else if (IsMouseButtonPressed(MOUSE_RIGHT_BUTTON)) ballColor = DARKBLUE;

examples/core/core_input_mouse_wheel.c

@@ -11,19 +11,19 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [core] example - input mouse wheel");
 
     int boxPositionY = screenHeight/2 - 40;
     int scrollSpeed = 4;            // Scrolling speed in pixels
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/core/core_input_multitouch.c

@@ -13,31 +13,31 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [core] example - input multitouch");
 
     Vector2 ballPosition = { -100.0f, -100.0f };
     Color ballColor = BEIGE;
-    
-    int touchCounter = 0;
-    Vector2 touchPosition;
 
-    SetTargetFPS(60);
+    int touchCounter = 0;
+    Vector2 touchPosition = { 0.0f };
+
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //---------------------------------------------------------------------------------------
-  
+
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
         // Update
         //----------------------------------------------------------------------------------
         ballPosition = GetMousePosition();
-        
+
         ballColor = BEIGE;
 
         if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) ballColor = MAROON;
@@ -47,7 +47,7 @@ int main()
         if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) touchCounter = 10;
         if (IsMouseButtonPressed(MOUSE_MIDDLE_BUTTON)) touchCounter = 10;
         if (IsMouseButtonPressed(MOUSE_RIGHT_BUTTON)) touchCounter = 10;
-        
+
         if (touchCounter > 0) touchCounter--;
         //----------------------------------------------------------------------------------
 
@@ -59,15 +59,15 @@ int main()
 
             // Multitouch
             for (int i = 0; i < MAX_TOUCH_POINTS; ++i)
-            {              
+            {
                 touchPosition = GetTouchPosition(i);                    // Get the touch point
-                
+
                 if ((touchPosition.x >= 0) && (touchPosition.y >= 0))   // Make sure point is not (-1,-1) as this means there is no touch for it
                 {
                     // Draw circle and touch index number
                     DrawCircleV(touchPosition, 34, ORANGE);
                     DrawText(FormatText("%d", i), touchPosition.x - 10, touchPosition.y - 70, 40, BLACK);
-                } 
+                }
             }
 
             // Draw the normal mouse location

examples/core/core_loading_thread.c

@@ -2,7 +2,7 @@
 *
 *   raylib example - loading thread
 *
-*   NOTE: This example requires linking with pthreads library, 
+*   NOTE: This example requires linking with pthreads library,
 *   on MinGW, it can be accomplished passing -static parameter to compiler
 *
 *   This example has been created using raylib 2.5 (www.raylib.com)
@@ -27,21 +27,21 @@ static void *LoadDataThread(void *arg);     // Loading data thread function decl
 
 static int dataProgress = 0;                // Data progress accumulator
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [core] example - loading thread");
-    
+
     pthread_t threadId;             // Loading data thread id
 
     enum { STATE_WAITING, STATE_LOADING, STATE_FINISHED } state = STATE_WAITING;
     int framesCounter = 0;
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop
@@ -90,25 +90,25 @@ int main()
         BeginDrawing();
 
             ClearBackground(RAYWHITE);
-            
+
-            switch (state) 
+            switch (state)
             {
                 case STATE_WAITING: DrawText("PRESS ENTER to START LOADING DATA", 150, 170, 20, DARKGRAY); break;
                 case STATE_LOADING:
                 {
                     DrawRectangle(150, 200, dataProgress, 60, SKYBLUE);
                     if ((framesCounter/15)%2) DrawText("LOADING DATA...", 240, 210, 40, DARKBLUE);
-                    
+
                 } break;
                 case STATE_FINISHED:
                 {
                     DrawRectangle(150, 200, 500, 60, LIME);
                     DrawText("DATA LOADED!", 250, 210, 40, GREEN);
-                    
+
                 } break;
                 default: break;
             }
-            
+
             DrawRectangleLines(150, 200, 500, 60, DARKGRAY);
 
         EndDrawing();
@@ -130,11 +130,11 @@ static void *LoadDataThread(void *arg)
     clock_t prevTime = clock();     // Previous time
 
     // We simulate data loading with a time counter for 5 seconds
-    while (timeCounter < 5000) 
+    while (timeCounter < 5000)
     {
         clock_t currentTime = clock() - prevTime;
         timeCounter = currentTime*1000/CLOCKS_PER_SEC;
-        
+
         // We accumulate time over a global variable to be used in
         // main thread as a progress bar
         dataProgress = timeCounter/10;

examples/core/core_random_values.c

@@ -11,20 +11,20 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [core] example - generate random values");
 
-    int framesCounter = 0;  // Variable used to count frames
+    int framesCounter = 0;          // Variable used to count frames
 
     int randValue = GetRandomValue(-8, 5);   // Get a random integer number between -8 and 5 (both included)
 
-    SetTargetFPS(60);       // Set our game to run at 60 frames-per-second
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop