Review ALL examples

examples/audio/audio_module_playing.c

@@ -23,12 +23,12 @@ typedef struct {
     Color color;
 } CircleWave;
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);  // NOTE: Try to enable MSAA 4X
 

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,12 +13,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [audio] example - music playing (streaming)");
 
@@ -39,7 +39,7 @@ 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))

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;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [audio] example - raw audio streaming");
 

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;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [audio] example - sound loading and playing");
 
@@ -27,7 +27,7 @@ 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,12 +13,12 @@
 
 #define MAX_BUILDINGS   100
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [core] example - 2d camera");
 
@@ -40,18 +40,18 @@ int main()
         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
         //----------------------------------------------------------------------------------

examples/core/core_3d_camera_first_person.c

@@ -13,12 +13,12 @@
 
 #define MAX_COLUMNS 20
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera first person");
 

examples/core/core_3d_camera_free.c

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

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;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    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;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    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

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];
-	time_t now = time(NULL);
-	struct tm *tm_info = localtime(&now);
+    char timeStr[64];
+    time_t now = time(NULL);
+    struct tm *tm_info = localtime(&now);
 
-	strftime(timeStr, sizeof(timeStr), "%Y-%m-%d %H:%M:%S", tm_info);
-	printf("[%s] ", timeStr);
+    strftime(timeStr, sizeof(timeStr), "%Y-%m-%d %H:%M:%S", tm_info);
+    printf("[%s] ", timeStr);
 
-	switch (msgType)
-	{
-		case LOG_INFO: printf("[INFO] : "); break;
-		case LOG_ERROR: printf("[ERROR]: "); break;
-		case LOG_WARNING: printf("[WARN] : "); break;
-		case LOG_DEBUG: printf("[DEBUG]: "); break;
-		default: break;
-	}
+    switch (msgType)
+    {
+        case LOG_INFO: printf("[INFO] : "); break;
+        case LOG_ERROR: printf("[ERROR]: "); break;
+        case LOG_WARNING: printf("[WARN] : "); break;
+        case LOG_DEBUG: printf("[DEBUG]: "); break;
+        default: break;
+    }
 
-	vprintf(text, args);
-	printf("\n");
+    vprintf(text, args);
+    printf("\n");
 }
 
 int main(int argc, char* argv[])
 {
-	// Initialization
-	//--------------------------------------------------------------------------------------
-	int screenWidth = 800;
-	int screenHeight = 450;
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
-	// First thing we do is setting our custom logger to ensure everything raylib logs
-	// will use our own logger instead of its internal one
-	SetTraceLogCallback(LogCustom);
+    // First thing we do is setting our custom logger to ensure everything raylib logs
+    // will use our own logger instead of its internal one
+    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
-	while (!WindowShouldClose())    // Detect window close button or ESC key
-	{
-		// Update
-		//----------------------------------------------------------------------------------
-		// TODO: Update your variables here
-		//----------------------------------------------------------------------------------
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        // TODO: Update your variables here
+        //----------------------------------------------------------------------------------
 
-		// Draw
-		//----------------------------------------------------------------------------------
-		BeginDrawing();
+        // Draw
+        //----------------------------------------------------------------------------------
+        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
-	//--------------------------------------------------------------------------------------
-	CloseWindow();        // Close window and OpenGL context
-	//--------------------------------------------------------------------------------------
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    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;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    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

examples/core/core_input_gamepad.c

@@ -8,10 +8,10 @@
 *                - 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,12 +26,12 @@
     #define PS3_NAME_ID         "PLAYSTATION(R)3 Controller"
 #endif
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);  // Set MSAA 4X hint before windows creation
 
@@ -40,7 +40,7 @@ int main()
     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

examples/core/core_input_gestures.c

@@ -14,12 +14,12 @@
 
 #define MAX_GESTURE_STRINGS   20
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [core] example - input gestures");
 
@@ -34,7 +34,7 @@ int main()
 
     //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

examples/core/core_input_keys.c

@@ -11,18 +11,18 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    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;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    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

examples/core/core_input_mouse_wheel.c

@@ -11,19 +11,19 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    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,12 +13,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [core] example - input multitouch");
 
@@ -26,9 +26,9 @@ int main()
     Color ballColor = BEIGE;
 
     int touchCounter = 0;
-    Vector2 touchPosition;
+    Vector2 touchPosition = { 0.0f };
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //---------------------------------------------------------------------------------------
 
     // Main game loop

examples/core/core_loading_thread.c

@@ -27,12 +27,12 @@ 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;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [core] example - loading thread");
 
@@ -41,7 +41,7 @@ int main()
     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

examples/core/core_random_values.c

@@ -11,20 +11,20 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    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

examples/core/core_storage_values.c

@@ -14,21 +14,20 @@
 // NOTE: Storage positions must start with 0, directly related to file memory layout
 typedef enum { STORAGE_SCORE = 0, STORAGE_HISCORE } StorageData;
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [core] example - storage save/load values");
 
     int score = 0;
     int hiscore = 0;
-    
     int framesCounter = 0;
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/core/core_vr_simulator.c

@@ -17,12 +17,12 @@
     #define GLSL_VERSION            100
 #endif
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 1080;
-    int screenHeight = 600;
+    const int screenWidth = 1080;
+    const int screenHeight = 600;
 
     // NOTE: screenWidth/screenHeight should match VR device aspect ratio
 

examples/core/core_window_letterbox.c

@@ -16,7 +16,7 @@
 #define max(a, b) ((a)>(b)? (a) : (b))
 #define min(a, b) ((a)<(b)? (a) : (b))
 
-int main()
+int main(void)
 {
     const int windowWidth = 800;
     const int windowHeight = 450;
@@ -36,11 +36,11 @@ int main()
     Color colors[10] = { 0 };
     for (int i = 0; i < 10; i++) colors[i] = (Color){ GetRandomValue(100, 250), GetRandomValue(50, 150), GetRandomValue(10, 100), 255 };
 
-    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
         //----------------------------------------------------------------------------------

examples/core/core_world_screen.c

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

examples/models/models_animation.c

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

examples/models/models_billboard.c

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

examples/models/models_box_collisions.c

@@ -11,12 +11,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - box collisions");
 
@@ -35,7 +35,7 @@ int main()
 
     bool collision = false;
 
-    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/models/models_cubicmap.c

@@ -11,12 +11,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - cubesmap loading and drawing");
 

examples/models/models_first_person_maze.c

@@ -13,12 +13,12 @@
 
 #include <stdlib.h>           // Required for: free()
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - first person maze");
 

examples/models/models_geometric_shapes.c

@@ -11,12 +11,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - geometric shapes");
 
@@ -28,7 +28,7 @@ int main()
     camera.fovy = 45.0f;
     camera.type = CAMERA_PERSPECTIVE;
 
-    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/models/models_heightmap.c

@@ -11,12 +11,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - heightmap loading and drawing");
 

examples/models/models_material_pbr.c

@@ -25,12 +25,12 @@
 // PBR material loading
 static Material LoadMaterialPBR(Color albedo, float metalness, float roughness);
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);  // Enable Multi Sampling Anti Aliasing 4x (if available)
     InitWindow(screenWidth, screenHeight, "raylib [models] example - pbr material");

examples/models/models_mesh_generation.c

@@ -11,14 +11,14 @@
 
 #include "raylib.h"
 
-#define NUM_MODELS  8      // We generate 8 parametric 3d shapes
+#define NUM_MODELS  8      // Parametric 3d shapes to generate
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - mesh generation");
 
@@ -51,7 +51,7 @@ int main()
 
     SetCameraMode(camera, CAMERA_ORBITAL);  // Set a orbital camera mode
 
-    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/models/models_mesh_picking.c

@@ -15,12 +15,12 @@
 
 #define FLT_MAX     340282346638528859811704183484516925440.0f     // Maximum value of a float, from bit pattern 01111111011111111111111111111111
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - mesh picking");
 
@@ -112,7 +112,6 @@ int main()
                 cursorColor = ORANGE;
                 hitObjectName = "Mesh";
             }
-            
         }
 
         hitMeshBBox = false;

examples/models/models_obj_loading.c

@@ -11,12 +11,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - obj model loading");
 
@@ -33,7 +33,7 @@ int main()
     model.materials[0].maps[MAP_DIFFUSE].texture = texture;                 // Set map diffuse texture
     Vector3 position = { 0.0f, 0.0f, 0.0f };                                // Set model position
 
-    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/models/models_obj_viewer.c

@@ -13,12 +13,12 @@
 
 #include <string.h>        // Required for: strcpy()
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib example - obj viewer");
 
@@ -37,7 +37,7 @@ int main()
 
     char objFilename[64] = "turret.obj";
 
-    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/models/models_orthographic_projection.c

@@ -18,19 +18,19 @@
 #define FOVY_PERSPECTIVE    45.0f
 #define WIDTH_ORTHOGRAPHIC  10.0f
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - geometric shapes");
 
     // Define the camera to look into our 3d world
     Camera camera = {{ 0.0f, 10.0f, 10.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, FOVY_PERSPECTIVE, CAMERA_PERSPECTIVE };
 
-    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/models/models_rlgl_solar_system.c

@@ -22,7 +22,7 @@ void DrawSphereBasic(Color color);      // Draw sphere without any matrix transf
 //------------------------------------------------------------------------------------
 // Program main entry point
 //------------------------------------------------------------------------------------
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
@@ -54,11 +54,11 @@ int main()
     float moonRotation = 0.0f;          // Rotation of moon around itself
     float moonOrbitRotation = 0.0f;     // Rotation of moon around earth in degrees
 
-    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
-    while (!WindowShouldClose())    // Detect window close button or ESC key
+    while (!WindowShouldClose())        // Detect window close button or ESC key
     {
         // Update
         //----------------------------------------------------------------------------------

examples/models/models_skybox.c

@@ -11,12 +11,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - skybox loading and drawing");
 

examples/models/models_yaw_pitch_roll.c

@@ -17,10 +17,7 @@
 // Draw angle gauge controls
 void DrawAngleGauge(Texture2D angleGauge, int x, int y, float angle, char title[], Color color);
 
-//----------------------------------------------------------------------------------
-// Main entry point
-//----------------------------------------------------------------------------------
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
@@ -53,10 +50,10 @@ int main()
     float roll = 0.0f;
     float yaw = 0.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
     {
         // Update

examples/physac/physics_demo.c

@@ -21,12 +21,12 @@
 #define PHYSAC_NO_THREADS
 #include "physac.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "Physac [raylib] - Physics demo");
@@ -41,13 +41,13 @@ int main()
 
     // Create floor rectangle physics body
     PhysicsBody floor = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2, screenHeight }, 500, 100, 10);
-    floor->enabled = false; // Disable body state to convert it to static (no dynamics, but collisions)
+    floor->enabled = false;         // Disable body state to convert it to static (no dynamics, but collisions)
 
     // Create obstacle circle physics body
     PhysicsBody circle = CreatePhysicsBodyCircle((Vector2){ screenWidth/2, screenHeight/2 }, 45, 10);
-    circle->enabled = false; // Disable body state to convert it to static (no dynamics, but collisions)
+    circle->enabled = false;        // Disable body state to convert it to static (no dynamics, but collisions)
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/physac/physics_friction.c

@@ -21,12 +21,12 @@
 #define PHYSAC_NO_THREADS
 #include "physac.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "Physac [raylib] - Physics friction");
@@ -65,7 +65,7 @@ int main()
     bodyB->dynamicFriction = 1;
     SetPhysicsBodyRotation(bodyB, 330*DEG2RAD);
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/physac/physics_movement.c

@@ -23,12 +23,12 @@
 
 #define VELOCITY    0.5f
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "Physac [raylib] - Physics movement");
@@ -56,9 +56,9 @@ int main()
 
     // Create movement physics body
     PhysicsBody body = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2, screenHeight/2 }, 50, 50, 1);
-    body->freezeOrient = true;  // Constrain body rotation to avoid little collision torque amounts
+    body->freezeOrient = true;      // Constrain body rotation to avoid little collision torque amounts
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/physac/physics_restitution.c

@@ -21,12 +21,12 @@
 #define PHYSAC_NO_THREADS
 #include "physac.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "Physac [raylib] - Physics restitution");
@@ -51,10 +51,10 @@ int main()
     PhysicsBody circleC = CreatePhysicsBodyCircle((Vector2){ screenWidth*0.75f, screenHeight/2 }, 30, 10);
     circleC->restitution = 1;
 
-    SetTargetFPS(60);
-
     // Restitution demo needs a very tiny physics time step for a proper simulation
-    SetPhysicsTimeStep(1.0/60.0/100 * 1000);
+    SetPhysicsTimeStep(1.0/60.0/100*1000);
+    
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/physac/physics_shatter.c

@@ -21,12 +21,12 @@
 #define PHYSAC_NO_THREADS
 #include "physac.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "Physac [raylib] - Body shatter");
@@ -43,7 +43,7 @@ int main()
     // Create random polygon physics body to shatter
     CreatePhysicsBodyPolygon((Vector2){ screenWidth/2, screenHeight/2 }, GetRandomValue(80, 200), GetRandomValue(3, 8), 10);
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/shaders/shaders_custom_uniform.c

@@ -24,12 +24,12 @@
     #define GLSL_VERSION            100
 #endif
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);      // Enable Multi Sampling Anti Aliasing 4x (if available)
 

examples/shaders/shaders_eratosthenes.c

@@ -31,7 +31,7 @@
     #define GLSL_VERSION            100
 #endif
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
@@ -46,11 +46,11 @@ int main()
     // NOTE: Defining 0 (NULL) for vertex shader forces usage of internal default vertex shader
     Shader shader = LoadShader(0, FormatText("resources/shaders/glsl%i/eratosthenes.fs", GLSL_VERSION));
 
-    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
         //----------------------------------------------------------------------------------
@@ -64,7 +64,7 @@ int main()
             ClearBackground(RAYWHITE);
 
             BeginTextureMode(target);   // Enable drawing to texture
-                ClearBackground(BLACK);     // Clear the render texture
+                ClearBackground(BLACK); // Clear the render texture
 
                 // Draw a rectangle in shader mode to be used as shader canvas
                 // NOTE: Rectangle uses font white character texture coordinates,

examples/shaders/shaders_julia_set.c

@@ -35,7 +35,7 @@ const float POINTS_OF_INTEREST[6][2] =
     { -0.70176, -0.3842 },
 };
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
@@ -64,7 +64,7 @@ int main()
     int offsetLoc = GetShaderLocation(shader, "offset");
 
     // Tell the shader what the screen dimensions, zoom, offset and c are
-    float screenDims[2] = { (float)GetScreenWidth(), (float)GetScreenHeight() };
+    float screenDims[2] = { (float)screenWidth, (float)screenHeight };
     SetShaderValue(shader, GetShaderLocation(shader, "screenDims"), screenDims, UNIFORM_VEC2);
 
     SetShaderValue(shader, cLoc, c, UNIFORM_VEC2);
@@ -74,19 +74,18 @@ int main()
     // Create a RenderTexture2D to be used for render to texture
     RenderTexture2D target = LoadRenderTexture(screenWidth, screenHeight);
 
-    int incrementSpeed = 0;     // Multiplier of speed to change c value
-    bool showControls = true;   // Show controls
-    bool pause = false;         // Pause animation
+    int incrementSpeed = 0;         // Multiplier of speed to change c value
+    bool showControls = true;       // Show controls
+    bool pause = false;             // Pause animation
 
-    SetTargetFPS(60);                       // Set the window to run at 60 frames-per-second
+    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
         //----------------------------------------------------------------------------------
-
         // Press [1 - 6] to reset c to a point of interest
         if (IsKeyPressed(KEY_ONE) ||
             IsKeyPressed(KEY_TWO) ||

examples/shaders/shaders_model_shader.c

@@ -24,12 +24,12 @@
     #define GLSL_VERSION            100
 #endif
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);      // Enable Multi Sampling Anti Aliasing 4x (if available)
 
@@ -84,9 +84,6 @@ int main()
 
             DrawText("(c) Watermill 3D model by Alberto Cano", screenWidth - 210, screenHeight - 20, 10, GRAY);
 
-            DrawText(FormatText("Camera position: (%.2f, %.2f, %.2f)", camera.position.x, camera.position.y, camera.position.z), 600, 20, 10, BLACK);
-            DrawText(FormatText("Camera target: (%.2f, %.2f, %.2f)", camera.target.x, camera.target.y, camera.target.z), 600, 40, 10, GRAY);
-
             DrawFPS(10, 10);
 
         EndDrawing();

examples/shaders/shaders_palette_switch.c

@@ -69,12 +69,12 @@ static const char *paletteText[] = {
     "RKBV (2-strip film)"
 };
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shaders] example - color palette switch");
 

examples/shaders/shaders_postprocessing.c

@@ -58,12 +58,12 @@ static const char *postproShaderText[] = {
     //"FXAA"
 };
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);      // Enable Multi Sampling Anti Aliasing 4x (if available)
 

examples/shaders/shaders_raymarching.c

@@ -24,12 +24,12 @@
     #define GLSL_VERSION            100
 #endif
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shaders] example - raymarching shapes");
 

examples/shaders/shaders_shapes_textures.c

@@ -24,12 +24,12 @@
     #define GLSL_VERSION            100
 #endif
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shaders] example - shapes and texture shaders");
 
@@ -40,7 +40,7 @@ int main()
     // NOTE 2: Defining 0 (NULL) for vertex shader forces usage of internal default vertex shader
     Shader shader = LoadShader(0, FormatText("resources/shaders/glsl%i/grayscale.fs", GLSL_VERSION));
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/shaders/shaders_texture_drawing.c

@@ -21,12 +21,12 @@
     #define GLSL_VERSION            100
 #endif
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shaders] example - texture drawing");
 
@@ -41,10 +41,11 @@ int main()
     int timeLoc = GetShaderLocation(shader, "uTime");
     SetShaderValue(shader, timeLoc, &time, UNIFORM_FLOAT);
 
-    SetTargetFPS(60);
-    //--------------------------------------------------------------------------------------
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
+    // -------------------------------------------------------------------------------------------------------------
 
-    while (!WindowShouldClose())
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
     {
         // Update
         //----------------------------------------------------------------------------------

examples/shaders/shaders_texture_waves.c

@@ -26,10 +26,7 @@
     #define GLSL_VERSION            100
 #endif
 
-// -------------------------------------------------------------------------------------------------------------
-// Main Entry point
-// -------------------------------------------------------------------------------------------------------------
-int main() 
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
@@ -69,13 +66,13 @@ int main()
 	SetShaderValue(shader, speedXLoc, &speedX, UNIFORM_FLOAT);
 	SetShaderValue(shader, speedYLoc, &speedY, UNIFORM_FLOAT);
 
-	float seconds = 0.0f;
+    float seconds = 0.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
         //----------------------------------------------------------------------------------
@@ -86,9 +83,9 @@ int main()
 
         // Draw
         //----------------------------------------------------------------------------------
-		BeginDrawing();
+        BeginDrawing();
 
-			ClearBackground(RAYWHITE);
+            ClearBackground(RAYWHITE);
 
 			BeginShaderMode(shader);
             
@@ -97,7 +94,7 @@ int main()
                 
 			EndShaderMode();
 
-		EndDrawing();
+        EndDrawing();
         //----------------------------------------------------------------------------------
     }
 
@@ -109,5 +106,5 @@ int main()
     CloseWindow();              // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
-	return 0;
+    return 0;
 }

examples/shapes/shapes_basic_shapes.c

@@ -11,16 +11,16 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - basic shapes drawing");
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/shapes/shapes_bouncing_ball.c

@@ -11,7 +11,7 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //---------------------------------------------------------
@@ -20,14 +20,14 @@ int main()
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - bouncing ball");
 
-	Vector2 ballPosition = { GetScreenWidth()/2, GetScreenHeight()/2 };
-	Vector2 ballSpeed = { 5.0f, 4.0f };
-	int ballRadius = 20;
+    Vector2 ballPosition = { GetScreenWidth()/2, GetScreenHeight()/2 };
+    Vector2 ballSpeed = { 5.0f, 4.0f };
+    int ballRadius = 20;
 
     bool pause = 0;
     int framesCounter = 0;
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //----------------------------------------------------------
 
     // Main game loop

examples/shapes/shapes_collision_area.c

@@ -12,30 +12,30 @@
 #include "raylib.h"
 #include <stdlib.h>     // Required for abs()
 
-int main()
+int main(void)
 {
     // Initialization
     //---------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - collision area");
 
     // Box A: Moving box
     Rectangle boxA = { 10, GetScreenHeight()/2 - 50, 200, 100 };
-	int boxASpeedX = 4;
+    int boxASpeedX = 4;
 
     // Box B: Mouse moved box
     Rectangle boxB = { GetScreenWidth()/2 - 30, GetScreenHeight()/2 - 30, 60, 60 };
 
-    Rectangle boxCollision = { 0 };       // Collision rectangle
+    Rectangle boxCollision = { 0 }; // Collision rectangle
 
     int screenUpperLimit = 40;      // Top menu limits
 
-	bool pause = false;             // Movement pause
-	bool collision = false;         // Collision detection
+    bool pause = false;             // Movement pause
+    bool collision = false;         // Collision detection
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //----------------------------------------------------------
 
     // Main game loop
@@ -44,30 +44,30 @@ int main()
         // Update
         //-----------------------------------------------------
         // Move box if not paused
-		if (!pause) boxA.x += boxASpeedX;
+        if (!pause) boxA.x += boxASpeedX;
 
         // Bounce box on x screen limits
-		if (((boxA.x + boxA.width) >= GetScreenWidth()) || (boxA.x <= 0)) boxASpeedX *= -1;
+        if (((boxA.x + boxA.width) >= GetScreenWidth()) || (boxA.x <= 0)) boxASpeedX *= -1;
 
-		// Update player-controlled-box (box02)
-		boxB.x = GetMouseX() - boxB.width/2;
-		boxB.y = GetMouseY() - boxB.height/2;
+        // Update player-controlled-box (box02)
+        boxB.x = GetMouseX() - boxB.width/2;
+        boxB.y = GetMouseY() - boxB.height/2;
 
         // Make sure Box B does not go out of move area limits
-		if ((boxB.x + boxB.width) >= GetScreenWidth()) boxB.x = GetScreenWidth() - boxB.width;
-		else if (boxB.x <= 0) boxB.x = 0;
+        if ((boxB.x + boxB.width) >= GetScreenWidth()) boxB.x = GetScreenWidth() - boxB.width;
+        else if (boxB.x <= 0) boxB.x = 0;
 
-		if ((boxB.y + boxB.height) >= GetScreenHeight()) boxB.y = GetScreenHeight() - boxB.height;
-		else if (boxB.y <= screenUpperLimit) boxB.y = screenUpperLimit;
+        if ((boxB.y + boxB.height) >= GetScreenHeight()) boxB.y = GetScreenHeight() - boxB.height;
+        else if (boxB.y <= screenUpperLimit) boxB.y = screenUpperLimit;
 
         // Check boxes collision
         collision = CheckCollisionRecs(boxA, boxB);
 
-		// Get collision rectangle (only on collision)
-		if (collision) boxCollision = GetCollisionRec(boxA, boxB);
+        // Get collision rectangle (only on collision)
+        if (collision) boxCollision = GetCollisionRec(boxA, boxB);
 
         // Pause Box A movement
-		if (IsKeyPressed(KEY_SPACE)) pause = !pause;
+        if (IsKeyPressed(KEY_SPACE)) pause = !pause;
         //-----------------------------------------------------
 
         // Draw

examples/shapes/shapes_colors_palette.c

@@ -13,7 +13,7 @@
 
 #define MAX_COLORS_COUNT    21          // Number of colors available
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------

examples/shapes/shapes_draw_circle_sector.c

@@ -16,7 +16,7 @@
 #define RAYGUI_IMPLEMENTATION
 #include "raygui.h"                 // Required for GUI controls
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
@@ -32,7 +32,7 @@ int main()
     int endAngle = 180;
     int segments = 0;
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/shapes/shapes_draw_rectangle_rounded.c

@@ -35,7 +35,7 @@ int main(void)
     bool drawRoundedRect = true;
     bool drawRoundedLines = false;
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/shapes/shapes_draw_ring.c

@@ -16,7 +16,7 @@
 #define RAYGUI_IMPLEMENTATION
 #include "raygui.h"                 // Required for GUI controls
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
@@ -38,7 +38,7 @@ int main()
     bool drawRingLines = false;
     bool drawCircleLines = false;
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/shapes/shapes_easings_ball_anim.c

@@ -11,9 +11,9 @@
 
 #include "raylib.h"
 
-#include "easings.h"            // Required for easing functions
+#include "easings.h"                // Required for easing functions
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
@@ -30,7 +30,7 @@ int main()
     int state = 0;
     int framesCounter = 0;
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/shapes/shapes_easings_box_anim.c

@@ -13,7 +13,7 @@
 
 #include "easings.h"            // Required for easing functions
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
@@ -30,7 +30,7 @@ int main()
     int state = 0;
     int framesCounter = 0;
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/shapes/shapes_easings_rectangle_array.c

@@ -24,12 +24,12 @@
 
 #define PLAY_TIME_IN_FRAMES     240                 // At 60 fps = 4 seconds
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - easings rectangle array");
 
@@ -50,7 +50,7 @@ int main()
     int framesCounter = 0;
     int state = 0;                  // Rectangles animation state: 0-Playing, 1-Finished
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/shapes/shapes_following_eyes.c

@@ -13,7 +13,7 @@
 
 #include <math.h>       // Required for: atan2f()
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
@@ -30,10 +30,10 @@ int main()
     Vector2 irisRightPosition = { GetScreenWidth()/2 + 100, GetScreenHeight()/2};
     float irisRadius = 24;
 
-    float angle;  
-    float dx, dy, dxx, dyy; 
+    float angle = 0.0f;
+    float dx = 0.0f, dy = 0.0f, dxx = 0.0f, dyy = 0.0f;
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/shapes/shapes_lines_bezier.c

@@ -11,12 +11,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - cubic-bezier lines");
@@ -24,7 +24,7 @@ int main()
     Vector2 start = { 0, 0 };
     Vector2 end = { screenWidth, screenHeight };
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/shapes/shapes_logo_raylib.c

@@ -11,16 +11,16 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib logo using shapes");
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/shapes/shapes_logo_raylib_anim.c

@@ -11,12 +11,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib logo animation");
 
@@ -35,7 +35,7 @@ int main()
     int state = 0;                  // Tracking animation states (State Machine)
     float alpha = 1.0f;             // Useful for fading
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/shapes/shapes_rectangle_scaling.c

@@ -15,12 +15,12 @@
 
 #define MOUSE_SCALE_MARK_SIZE   12
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - rectangle scaling mouse");
 
@@ -31,7 +31,7 @@ int main()
     bool mouseScaleReady = false;
     bool mouseScaleMode = false;
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/text/text_bmfont_ttf.c

@@ -11,12 +11,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [text] example - bmfont and ttf sprite fonts loading");
 
@@ -35,7 +35,7 @@ int main()
 
     bool useTtf = false;
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/text/text_font_sdf.c

@@ -17,12 +17,12 @@
     #define GLSL_VERSION            100
 #endif
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [text] example - SDF fonts");
 
@@ -59,9 +59,9 @@ int main()
     Vector2 fontPosition = { 40, screenHeight/2 - 50 };
     Vector2 textSize = { 0.0f };
     float fontSize = 16.0f;
-    int currentFont = 0;    // 0 - fontDefault, 1 - fontSDF
+    int currentFont = 0;            // 0 - fontDefault, 1 - fontSDF
     
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/text/text_format_text.c

@@ -11,12 +11,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [text] example - text formatting");
 
@@ -24,7 +24,7 @@ int main()
     int hiscore = 200450;
     int lives = 5;
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/text/text_input_box.c

@@ -13,12 +13,12 @@
 
 #define MAX_INPUT_CHARS     9
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [text] example - input box");
 
@@ -30,7 +30,7 @@ int main()
 
     int framesCounter = 0;
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/text/text_raylib_fonts.c

@@ -16,12 +16,12 @@
 
 #define MAX_FONTS   8
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [text] example - raylib fonts");
 
@@ -62,6 +62,8 @@ int main()
     positions[7].y -= 8;
 
     Color colors[MAX_FONTS] = { MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, LIME, GOLD, RED };
+    
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/text/text_rectangle_bounds.c

@@ -13,18 +13,18 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [text] example - draw text inside a rectangle");
 
     char text[] = "Text cannot escape\tthis container\t...word wrap also works when active so here's\
-	a long text for testing.\n\nLorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod\
-	tempor incididunt ut labore et dolore magna aliqua. Nec ullamcorper sit amet risus nullam eget felis eget.";
+    a long text for testing.\n\nLorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod\
+    tempor incididunt ut labore et dolore magna aliqua. Nec ullamcorper sit amet risus nullam eget felis eget.";
 
     bool resizing = false;
     bool wordWrap = true;
@@ -42,7 +42,7 @@ int main()
     Color borderColor = MAROON;     // Container border color
     Font font = GetFontDefault();   // Get default system font
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/text/text_sprite_fonts.c

@@ -11,12 +11,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [text] example - sprite fonts usage");
 
@@ -40,6 +40,7 @@ int main()
     fontPosition3.x = screenWidth/2 - MeasureTextEx(font3, msg3, font3.baseSize, 2).x/2;
     fontPosition3.y = screenHeight/2 - font3.baseSize/2 + 50;
 
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/text/text_ttf_loading.c

@@ -11,12 +11,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [text] example - ttf loading");
 
@@ -35,16 +35,11 @@ int main()
     Vector2 fontPosition = { 40, screenHeight/2 - 80 };
     Vector2 textSize;
 
+    // Setup texture scaling filter
     SetTextureFilter(font.texture, FILTER_POINT);
     int currentFontFilter = 0;      // FILTER_POINT
 
-    // NOTE: Drag and drop support only available for desktop platforms: Windows, Linux, OSX
-#if defined(PLATFORM_DESKTOP)
-    int count = 0;
-    char **droppedFiles;
-#endif
-    
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop
@@ -77,11 +72,11 @@ int main()
         if (IsKeyDown(KEY_LEFT)) fontPosition.x -= 10;
         else if (IsKeyDown(KEY_RIGHT)) fontPosition.x += 10;
 
-#if defined(PLATFORM_DESKTOP)
         // Load a dropped TTF file dynamically (at current fontSize)
         if (IsFileDropped())
         {
-            droppedFiles = GetDroppedFiles(&count);
+            int count = 0;
+            char **droppedFiles = GetDroppedFiles(&count);
 
             if (count == 1) // Only support one ttf file dropped
             {
@@ -90,7 +85,6 @@ int main()
                 ClearDroppedFiles();
             }
         }
-#endif
         //----------------------------------------------------------------------------------
 
         // Draw
@@ -124,10 +118,9 @@ int main()
 
     // De-Initialization
     //--------------------------------------------------------------------------------------
-#if defined(PLATFORM_DESKTOP)
     ClearDroppedFiles();        // Clear internal buffers
-#endif
-    UnloadFont(font);     // Font unloading
+
+    UnloadFont(font);           // Font unloading
 
     CloseWindow();              // Close window and OpenGL context
     //--------------------------------------------------------------------------------------

examples/text/text_unicode.c

@@ -145,9 +145,6 @@ struct {
 
 static int hovered = -1, selected = -1;
 
-//--------------------------------------------------------------------------------------
-// Main entry point
-//--------------------------------------------------------------------------------------
 int main(int argc, char **argv)
 {
     // Initialization
@@ -171,11 +168,11 @@ int main(int argc, char **argv)
     // Set a random set of emojis when starting up
     RandomizeEmoji();
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main loop
-    while (!WindowShouldClose())
+    while (!WindowShouldClose())    // Detect window close button or ESC key
     {
         // Update
         //----------------------------------------------------------------------------------
@@ -286,9 +283,9 @@ int main(int argc, char **argv)
             DrawText("These emojis have something to tell you, click each to find out!", (screenWidth - 650)/2, screenHeight - 40, 20, GRAY);
             DrawText("Each emoji is a unicode character from a font, not a texture... Press [SPACEBAR] to refresh", (screenWidth - 484)/2, screenHeight - 16, 10, GRAY);
 
-		EndDrawing();
+        EndDrawing();
         //----------------------------------------------------------------------------------
-	}
+    }
 
     // De-Initialization
     //--------------------------------------------------------------------------------------
@@ -296,10 +293,10 @@ int main(int argc, char **argv)
     UnloadFont(fontAsian);      // Unload font resource
     UnloadFont(fontEmoji);      // Unload font resource
 
-	CloseWindow();              // Close window and OpenGL context
+    CloseWindow();              // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
-	return 0;
+    return 0;
 }
 
 // Fills the emoji array with random emoji (only those emojis present in fontEmoji)

examples/text/text_writing_anim.c

@@ -11,12 +11,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [text] example - text writing anim");
 
@@ -24,7 +24,7 @@ int main()
 
     int framesCounter = 0;
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/textures/textures_background_scrolling.c

@@ -11,12 +11,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [textures] example - background scrolling");
 
@@ -30,7 +30,7 @@ int main()
     float scrollingMid = 0;
     float scrollingFore = 0;
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/textures/textures_bunnymark.c

@@ -25,7 +25,7 @@ typedef struct Bunny {
     Color color;
 } Bunny;
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
@@ -34,13 +34,14 @@ int main()
 
     InitWindow(screenWidth, screenHeight, "raylib [textures] example - bunnymark");
 
+    // Load bunny texture
     Texture2D texBunny = LoadTexture("resources/wabbit_alpha.png");
 
-    Bunny *bunnies = (Bunny *)malloc(MAX_BUNNIES*sizeof(Bunny));          // Bunnies array
+    Bunny *bunnies = (Bunny *)malloc(MAX_BUNNIES*sizeof(Bunny));    // Bunnies array
 
-    int bunniesCount = 0;    // Bunnies counter
+    int bunniesCount = 0;           // Bunnies counter
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/textures/textures_image_drawing.c

@@ -13,12 +13,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [textures] example - image drawing");
 

examples/textures/textures_image_generation.c

@@ -13,12 +13,12 @@
 
 #define NUM_TEXTURES  7      // Currently we have 7 generation algorithms
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [textures] example - procedural images generation");
 

examples/textures/textures_image_loading.c

@@ -13,12 +13,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [textures] example - image loading");
 

examples/textures/textures_image_processing.c

@@ -13,7 +13,7 @@
 
 #include "raylib.h"
 
-#include <stdlib.h>     // Required for: free()
+#include <stdlib.h>             // Required for: free()
 
 #define NUM_PROCESSES    8
 
@@ -39,12 +39,12 @@ static const char *processText[] = {
     "FLIP HORIZONTAL"
 };
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [textures] example - image processing");
 

examples/textures/textures_image_text.c

@@ -11,20 +11,20 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [texture] example - image text drawing");
     
+    Image parrots = LoadImage("resources/parrots.png"); // Load image in CPU memory (RAM)
+
     // TTF Font loading with custom generation parameters
     Font font = LoadFontEx("resources/KAISG.ttf", 64, 0, 0);
 
-    Image parrots = LoadImage("resources/parrots.png"); // Load image in CPU memory (RAM)
-
     // Draw over image using custom font
     ImageDrawTextEx(&parrots, (Vector2){ 20.0f, 20.0f }, font, "[Parrots font drawing]", (float)font.baseSize, 0.0f, RED);
 
@@ -74,7 +74,7 @@ int main()
     //--------------------------------------------------------------------------------------
     UnloadTexture(texture);     // Texture unloading
 
-    UnloadFont(font);     // Unload custom spritefont
+    UnloadFont(font);           // Unload custom spritefont
 
     CloseWindow();              // Close window and OpenGL context
     //--------------------------------------------------------------------------------------

examples/textures/textures_logo_raylib.c

@@ -11,12 +11,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [textures] example - texture loading and drawing");
 

examples/textures/textures_npatch_drawing.c

@@ -15,12 +15,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [textures] example - N-patch drawing");
 

examples/textures/textures_particles_blending.c

@@ -23,12 +23,12 @@ typedef struct {
     bool active;        // NOTE: Use it to activate/deactive particle
 } Particle;
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [textures] example - particles blending");
 

examples/textures/textures_raw_data.c

@@ -13,14 +13,14 @@
 
 #include "raylib.h"
 
-#include <stdlib.h>     // Required for malloc() and free()
+#include <stdlib.h>         // Required for: malloc() and free()
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [textures] example - texture from raw data");
 
@@ -28,8 +28,8 @@ int main()
 
     // Load RAW image data (512x512, 32bit RGBA, no file header)
     Image fudesumiRaw = LoadImageRaw("resources/fudesumi.raw", 384, 512, UNCOMPRESSED_R8G8B8A8, 0);
-    Texture2D fudesumi = LoadTextureFromImage(fudesumiRaw);   // Upload CPU (RAM) image to GPU (VRAM)
-    UnloadImage(fudesumiRaw);                              // Unload CPU (RAM) image data
+    Texture2D fudesumi = LoadTextureFromImage(fudesumiRaw);  // Upload CPU (RAM) image to GPU (VRAM)
+    UnloadImage(fudesumiRaw);                                // Unload CPU (RAM) image data
 
     // Generate a checked texture by code (1024x1024 pixels)
     int width = 960;
@@ -50,10 +50,10 @@ int main()
     // Load pixels data into an image structure and create texture
     Image checkedIm = LoadImageEx(pixels, width, height);
     Texture2D checked = LoadTextureFromImage(checkedIm);
-    UnloadImage(checkedIm);     // Unload CPU (RAM) image data
+    UnloadImage(checkedIm);         // Unload CPU (RAM) image data
 
     // Dynamic memory must be freed after using it
-    free(pixels);               // Unload CPU (RAM) pixels data
+    free(pixels);                   // Unload CPU (RAM) pixels data
     //---------------------------------------------------------------------------------------
 
     // Main game loop

examples/textures/textures_rectangle.c

@@ -14,12 +14,12 @@
 #define MAX_FRAME_SPEED     15
 #define MIN_FRAME_SPEED      1
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [texture] example - texture rectangle");
 
@@ -31,7 +31,7 @@ int main()
     int currentFrame = 0;
 
     int framesCounter = 0;
-    int framesSpeed = 8;           // Number of spritesheet frames shown by second
+    int framesSpeed = 8;            // Number of spritesheet frames shown by second
 
     SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------

examples/textures/textures_sprite_button.c

@@ -13,7 +13,7 @@
 
 #define NUM_FRAMES  3       // Number of frames (rectangles) for the button sprite texture
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------

examples/textures/textures_sprite_explosion.c

@@ -11,10 +11,10 @@
 
 #include "raylib.h"
 
-#define NUM_FRAMES  8
-#define NUM_LINES   6
+#define NUM_FRAMES      8
+#define NUM_LINES       6
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
@@ -109,7 +109,7 @@ int main()
     // De-Initialization
     //--------------------------------------------------------------------------------------
     UnloadTexture(explosion);   // Unload texture
-    UnloadSound(fxBoom);          // Unload sound
+    UnloadSound(fxBoom);        // Unload sound
 
     CloseAudioDevice();
 

examples/textures/textures_srcrec_dstrec.c

@@ -11,28 +11,29 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [textures] examples - texture source and destination rectangles");
 
     // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+    
     Texture2D scarfy = LoadTexture("resources/scarfy.png");        // Texture loading
 
     int frameWidth = scarfy.width/6;
     int frameHeight = scarfy.height;
 
-    // NOTE: Source rectangle (part of the texture to use for drawing)
+    // Source rectangle (part of the texture to use for drawing)
     Rectangle sourceRec = { 0.0f, 0.0f, frameWidth, frameHeight };
 
-    // NOTE: Destination rectangle (screen rectangle where drawing part of texture)
+    // Destination rectangle (screen rectangle where drawing part of texture)
     Rectangle destRec = { screenWidth/2, screenHeight/2, frameWidth*2, frameHeight*2 };
 
-    // NOTE: Origin of the texture (rotation/scale point), it's relative to destination rectangle size
+    // Origin of the texture (rotation/scale point), it's relative to destination rectangle size
     Vector2 origin = { frameWidth, frameHeight };
 
     int rotation = 0;

examples/textures/textures_to_image.c

@@ -13,12 +13,12 @@
 
 #include "raylib.h"
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [textures] example - texture to image");