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

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");
 

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");
 
@@ -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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [core] example - 2d camera");
 
@@ -40,14 +40,14 @@ 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

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

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

examples/core/core_custom_logging.c

@@ -43,8 +43,8 @@ int main(int argc, char* argv[])
 {
     // 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
     // will use our own logger instead of its internal one
@@ -52,7 +52,7 @@ int main(int argc, char* argv[])
 
     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

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

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

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,12 +13,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 - 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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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,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 - generate random values");
 

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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 1080;
-    int screenHeight = 600;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - box collisions");
 

examples/models/models_cubicmap.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 [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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - geometric shapes");
 

examples/models/models_heightmap.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 [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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - mesh generation");
 

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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - obj model loading");
 

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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib example - obj viewer");
 

examples/models/models_orthographic_projection.c

@@ -18,12 +18,12 @@
 #define FOVY_PERSPECTIVE    45.0f
 #define WIDTH_ORTHOGRAPHIC  10.0f
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - geometric shapes");
 

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
     //--------------------------------------------------------------------------------------

examples/models/models_skybox.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 [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);
 
-//----------------------------------------------------------------------------------
+int main(void)
-// Main entry point
-//----------------------------------------------------------------------------------
-int main()
 {
     // 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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "Physac [raylib] - Physics demo");
@@ -47,7 +47,7 @@ int main()
     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)
 
-    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "Physac [raylib] - Physics movement");
@@ -58,7 +58,7 @@ int main()
     PhysicsBody body = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2, screenHeight/2 }, 50, 50, 1);
     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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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,7 +46,7 @@ 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

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);
@@ -78,7 +78,7 @@ int main()
     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
@@ -86,7 +86,6 @@ int main()
     {
         // 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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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
 
-// -------------------------------------------------------------------------------------------------------------
+int main(void)
-// Main Entry point
-// -------------------------------------------------------------------------------------------------------------
-int main() 
 {
     // Initialization
     //--------------------------------------------------------------------------------------
@@ -71,7 +68,7 @@ int main()
 
     float seconds = 0.0f;
 
-    SetTargetFPS(60);
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     // -------------------------------------------------------------------------------------------------------------
 
     // Main game loop

examples/shapes/shapes_basic_shapes.c

@@ -11,16 +11,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 [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
     //---------------------------------------------------------
@@ -27,7 +27,7 @@ int main()
     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,12 +12,12 @@
 #include "raylib.h"
 #include <stdlib.h>     // Required for abs()
 
-int main()
+int main(void)
 {
     // Initialization
     //---------------------------------------------------------
-    int screenWidth = 800;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - collision area");
 
@@ -35,7 +35,7 @@ int main()
     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

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

@@ -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_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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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 angle = 0.0f;
-    float dx, dy, dxx, dyy; 
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [text] example - SDF fonts");
 
@@ -61,7 +61,7 @@ int main()
     float fontSize = 16.0f;
     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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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,12 +13,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 [text] example - draw text inside a rectangle");
 
@@ -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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
-#if defined(PLATFORM_DESKTOP)
-    int count = 0;
-    char **droppedFiles;
-#endif
-    
-    SetTargetFPS(60);
     //--------------------------------------------------------------------------------------
 
     // 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,9 +118,8 @@ int main()
 
     // De-Initialization
     //--------------------------------------------------------------------------------------
-#if defined(PLATFORM_DESKTOP)
     ClearDroppedFiles();        // Clear internal buffers
-#endif
+
     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
         //----------------------------------------------------------------------------------

examples/text/text_writing_anim.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 [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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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
 
     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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [textures] example - image loading");
 

examples/textures/textures_image_processing.c

@@ -39,12 +39,12 @@ static const char *processText[] = {
     "FLIP HORIZONTAL"
 };
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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);
 

examples/textures/textures_logo_raylib.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 [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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [textures] example - texture from raw data");
 

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

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

@@ -14,7 +14,7 @@
 #define NUM_FRAMES      8
 #define NUM_LINES       6
 
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------

examples/textures/textures_srcrec_dstrec.c

@@ -11,28 +11,29 @@
 
 #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 [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;
+    const int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [textures] example - texture to image");