Review ALL examples

16 files changed, 194 insertions, 198 deletions

diff --git a/examples/models/models_animation.c b/examples/models/models_animation.c
index a75241b3..294b07a5 100644
--- a/examples/models/models_animation.c
+++ b/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");
 
@@ -32,7 +32,7 @@ int main()
     Model model = LoadModel("resources/guy/guy.iqm");               // Load the animated model mesh and basic data
     Texture2D texture = LoadTexture("resources/guy/guytex.png");    // Load model texture and set material
     SetMaterialTexture(&model.materials[0], MAP_DIFFUSE, texture);  // Set model material map texture
-    
+
     Vector3 position = { 0.0f, 0.0f, 0.0f };            // Set model position
 
     // Load animation data
@@ -91,7 +91,7 @@ int main()
     //--------------------------------------------------------------------------------------
     // Unload model animations data
     for (int i = 0; i < animsCount; i++) UnloadModelAnimation(anims[i]);
-    
+
     UnloadModel(model);         // Unload model
 
     CloseWindow();              // Close window and OpenGL context
diff --git a/examples/models/models_billboard.c b/examples/models/models_billboard.c
index 59655714..597e9a60 100644
--- a/examples/models/models_billboard.c
+++ b/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");
 
@@ -27,10 +27,10 @@ int main()
     camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
     camera.fovy = 45.0f;
     camera.type = CAMERA_PERSPECTIVE;
-    
+
     Texture2D bill = LoadTexture("resources/billboard.png");     // Our texture billboard
     Vector3 billPosition = { 0.0f, 2.0f, 0.0f };                 // Position where draw billboard
-    
+
     SetCameraMode(camera, CAMERA_ORBITAL);  // Set an orbital camera mode
 
     SetTargetFPS(60);                       // Set our game to run at 60 frames-per-second
@@ -51,11 +51,11 @@ int main()
             ClearBackground(RAYWHITE);
 
             BeginMode3D(camera);
-                
+
                 DrawGrid(10, 1.0f);        // Draw a grid
-                
+
                 DrawBillboard(camera, bill, billPosition, 2.0f, WHITE);
-                
+
             EndMode3D();
 
             DrawFPS(10, 10);
diff --git a/examples/models/models_box_collisions.c b/examples/models/models_box_collisions.c
index 41f6056c..0dd0710e 100644
--- a/examples/models/models_box_collisions.c
+++ b/examples/models/models_box_collisions.c
@@ -11,31 +11,31 @@
 
 #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");
 
     // 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 }, 45.0f, 0 };
-    
+
     Vector3 playerPosition = { 0.0f, 1.0f, 2.0f };
     Vector3 playerSize = { 1.0f, 2.0f, 1.0f };
     Color playerColor = GREEN;
-    
+
     Vector3 enemyBoxPos = { -4.0f, 1.0f, 0.0f };
     Vector3 enemyBoxSize = { 2.0f, 2.0f, 2.0f };
-    
+
     Vector3 enemySpherePos = { 4.0f, 0.0f, 0.0f };
     float enemySphereSize = 1.5f;
-    
+
     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
@@ -43,40 +43,40 @@ int main()
     {
         // Update
         //----------------------------------------------------------------------------------
-        
+
         // Move player
         if (IsKeyDown(KEY_RIGHT)) playerPosition.x += 0.2f;
         else if (IsKeyDown(KEY_LEFT)) playerPosition.x -= 0.2f;
         else if (IsKeyDown(KEY_DOWN)) playerPosition.z += 0.2f;
         else if (IsKeyDown(KEY_UP)) playerPosition.z -= 0.2f;
-        
+
         collision = false;
-        
+
         // Check collisions player vs enemy-box
         if (CheckCollisionBoxes(
-            (BoundingBox){(Vector3){ playerPosition.x - playerSize.x/2, 
-                                     playerPosition.y - playerSize.y/2, 
-                                     playerPosition.z - playerSize.z/2 }, 
+            (BoundingBox){(Vector3){ playerPosition.x - playerSize.x/2,
+                                     playerPosition.y - playerSize.y/2,
+                                     playerPosition.z - playerSize.z/2 },
                           (Vector3){ playerPosition.x + playerSize.x/2,
-                                     playerPosition.y + playerSize.y/2, 
+                                     playerPosition.y + playerSize.y/2,
                                      playerPosition.z + playerSize.z/2 }},
-            (BoundingBox){(Vector3){ enemyBoxPos.x - enemyBoxSize.x/2, 
-                                     enemyBoxPos.y - enemyBoxSize.y/2, 
-                                     enemyBoxPos.z - enemyBoxSize.z/2 }, 
+            (BoundingBox){(Vector3){ enemyBoxPos.x - enemyBoxSize.x/2,
+                                     enemyBoxPos.y - enemyBoxSize.y/2,
+                                     enemyBoxPos.z - enemyBoxSize.z/2 },
                           (Vector3){ enemyBoxPos.x + enemyBoxSize.x/2,
-                                     enemyBoxPos.y + enemyBoxSize.y/2, 
+                                     enemyBoxPos.y + enemyBoxSize.y/2,
                                      enemyBoxPos.z + enemyBoxSize.z/2 }})) collision = true;
-        
+
         // Check collisions player vs enemy-sphere
         if (CheckCollisionBoxSphere(
-            (BoundingBox){(Vector3){ playerPosition.x - playerSize.x/2, 
-                                     playerPosition.y - playerSize.y/2, 
-                                     playerPosition.z - playerSize.z/2 }, 
+            (BoundingBox){(Vector3){ playerPosition.x - playerSize.x/2,
+                                     playerPosition.y - playerSize.y/2,
+                                     playerPosition.z - playerSize.z/2 },
                           (Vector3){ playerPosition.x + playerSize.x/2,
-                                     playerPosition.y + playerSize.y/2, 
-                                     playerPosition.z + playerSize.z/2 }}, 
+                                     playerPosition.y + playerSize.y/2,
+                                     playerPosition.z + playerSize.z/2 }},
             enemySpherePos, enemySphereSize)) collision = true;
-        
+
         if (collision) playerColor = RED;
         else playerColor = GREEN;
         //----------------------------------------------------------------------------------
@@ -92,18 +92,18 @@ int main()
                 // Draw enemy-box
                 DrawCube(enemyBoxPos, enemyBoxSize.x, enemyBoxSize.y, enemyBoxSize.z, GRAY);
                 DrawCubeWires(enemyBoxPos, enemyBoxSize.x, enemyBoxSize.y, enemyBoxSize.z, DARKGRAY);
-                
+
                 // Draw enemy-sphere
                 DrawSphere(enemySpherePos, enemySphereSize, GRAY);
                 DrawSphereWires(enemySpherePos, enemySphereSize, 16, 16, DARKGRAY);
-                
+
                 // Draw player
                 DrawCubeV(playerPosition, playerSize, playerColor);
 
                 DrawGrid(10, 1.0f);        // Draw a grid
 
             EndMode3D();
-            
+
             DrawText("Move player with cursors to collide", 220, 40, 20, GRAY);
 
             DrawFPS(10, 10);
diff --git a/examples/models/models_cubicmap.c b/examples/models/models_cubicmap.c
index ac24188e..f399a56e 100644
--- a/examples/models/models_cubicmap.c
+++ b/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");
 
@@ -25,18 +25,18 @@ int main()
 
     Image image = LoadImage("resources/cubicmap.png");      // Load cubicmap image (RAM)
     Texture2D cubicmap = LoadTextureFromImage(image);       // Convert image to texture to display (VRAM)
-    
+
     Mesh mesh = GenMeshCubicmap(image, (Vector3){ 1.0f, 1.0f, 1.0f });
     Model model = LoadModelFromMesh(mesh);
-    
+
     // NOTE: By default each cube is mapped to one part of texture atlas
     Texture2D texture = LoadTexture("resources/cubicmap_atlas.png");    // Load map texture
     model.materials[0].maps[MAP_DIFFUSE].texture = texture;             // Set map diffuse texture
-    
+
     Vector3 mapPosition = { -16.0f, 0.0f, -8.0f };          // Set model position
 
     UnloadImage(image);     // Unload cubesmap image from RAM, already uploaded to VRAM
-    
+
     SetCameraMode(camera, CAMERA_ORBITAL);  // Set an orbital camera mode
 
     SetTargetFPS(60);                       // Set our game to run at 60 frames-per-second
@@ -61,10 +61,10 @@ int main()
                 DrawModel(model, mapPosition, 1.0f, WHITE);
 
             EndMode3D();
-            
+
             DrawTextureEx(cubicmap, (Vector2){ screenWidth - cubicmap.width*4 - 20, 20 }, 0.0f, 4.0f, WHITE);
             DrawRectangleLines(screenWidth - cubicmap.width*4 - 20, 20, cubicmap.width*4, cubicmap.height*4, GREEN);
-            
+
             DrawText("cubicmap image used to", 658, 90, 10, GRAY);
             DrawText("generate map 3d model", 658, 104, 10, GRAY);
 
diff --git a/examples/models/models_first_person_maze.c b/examples/models/models_first_person_maze.c
index 093334ba..42363747 100644
--- a/examples/models/models_first_person_maze.c
+++ b/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");
 
@@ -29,18 +29,18 @@ int main()
     Texture2D cubicmap = LoadTextureFromImage(imMap);       // Convert image to texture to display (VRAM)
     Mesh mesh = GenMeshCubicmap(imMap, (Vector3){ 1.0f, 1.0f, 1.0f });
     Model model = LoadModelFromMesh(mesh);
-    
+
     // NOTE: By default each cube is mapped to one part of texture atlas
     Texture2D texture = LoadTexture("resources/cubicmap_atlas.png");    // Load map texture
     model.materials[0].maps[MAP_DIFFUSE].texture = texture;             // Set map diffuse texture
-    
+
     // Get map image data to be used for collision detection
     Color *mapPixels = GetImageData(imMap);
     UnloadImage(imMap);             // Unload image from RAM
-    
+
     Vector3 mapPosition = { -16.0f, 0.0f, -8.0f };  // Set model position
     Vector3 playerPosition = camera.position;       // Set player position
-    
+
     SetCameraMode(camera, CAMERA_FIRST_PERSON);     // Set camera mode
 
     SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
@@ -52,23 +52,23 @@ int main()
         // Update
         //----------------------------------------------------------------------------------
         Vector3 oldCamPos = camera.position;    // Store old camera position
-        
+
         UpdateCamera(&camera);      // Update camera
-        
+
         // Check player collision (we simplify to 2D collision detection)
         Vector2 playerPos = { camera.position.x, camera.position.z };
         float playerRadius = 0.1f;  // Collision radius (player is modelled as a cilinder for collision)
-        
+
         int playerCellX = (int)(playerPos.x - mapPosition.x + 0.5f);
         int playerCellY = (int)(playerPos.y - mapPosition.z + 0.5f);
-        
+
         // Out-of-limits security check
         if (playerCellX < 0) playerCellX = 0;
         else if (playerCellX >= cubicmap.width) playerCellX = cubicmap.width - 1;
-        
+
         if (playerCellY < 0) playerCellY = 0;
         else if (playerCellY >= cubicmap.height) playerCellY = cubicmap.height - 1;
-        
+
         // Check map collisions using image data and player position
         // TODO: Improvement: Just check player surrounding cells for collision
         for (int y = 0; y < cubicmap.height; y++)
@@ -76,7 +76,7 @@ int main()
             for (int x = 0; x < cubicmap.width; x++)
             {
                 if ((mapPixels[y*cubicmap.width + x].r == 255) &&       // Collision: white pixel, only check R channel
-                    (CheckCollisionCircleRec(playerPos, playerRadius, 
+                    (CheckCollisionCircleRec(playerPos, playerRadius,
                     (Rectangle){ mapPosition.x - 0.5f + x*1.0f, mapPosition.z - 0.5f + y*1.0f, 1.0f, 1.0f })))
                 {
                     // Collision detected, reset camera position
@@ -98,10 +98,10 @@ int main()
                 //DrawCubeV(playerPosition, (Vector3){ 0.2f, 0.4f, 0.2f }, RED);  // Draw player
 
             EndMode3D();
-            
+
             DrawTextureEx(cubicmap, (Vector2){ GetScreenWidth() - cubicmap.width*4 - 20, 20 }, 0.0f, 4.0f, WHITE);
             DrawRectangleLines(GetScreenWidth() - cubicmap.width*4 - 20, 20, cubicmap.width*4, cubicmap.height*4, GREEN);
-            
+
             // Draw player position radar
             DrawRectangle(GetScreenWidth() - cubicmap.width*4 - 20 + playerCellX*4, 20 + playerCellY*4, 4, 4, RED);
 
@@ -114,7 +114,7 @@ int main()
     // De-Initialization
     //--------------------------------------------------------------------------------------
     free(mapPixels);            // Unload color array
-    
+
     UnloadTexture(cubicmap);    // Unload cubicmap texture
     UnloadTexture(texture);     // Unload map texture
     UnloadModel(model);         // Unload map model
diff --git a/examples/models/models_geometric_shapes.c b/examples/models/models_geometric_shapes.c
index 82ca4c60..39477927 100644
--- a/examples/models/models_geometric_shapes.c
+++ b/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
diff --git a/examples/models/models_heightmap.c b/examples/models/models_heightmap.c
index e0475f18..e242db16 100644
--- a/examples/models/models_heightmap.c
+++ b/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");
 
@@ -25,7 +25,7 @@ int main()
 
     Image image = LoadImage("resources/heightmap.png");             // Load heightmap image (RAM)
     Texture2D texture = LoadTextureFromImage(image);                // Convert image to texture (VRAM)
-    
+
     Mesh mesh = GenMeshHeightmap(image, (Vector3){ 16, 8, 16 });    // Generate heightmap mesh (RAM and VRAM)
     Model model = LoadModelFromMesh(mesh);                          // Load model from generated mesh
 
@@ -33,7 +33,7 @@ int main()
     Vector3 mapPosition = { -8.0f, 0.0f, -8.0f };                   // Define model position
 
     UnloadImage(image);                     // Unload heightmap image from RAM, already uploaded to VRAM
-    
+
     SetCameraMode(camera, CAMERA_ORBITAL);  // Set an orbital camera mode
 
     SetTargetFPS(60);                       // Set our game to run at 60 frames-per-second
@@ -60,7 +60,7 @@ int main()
                 DrawGrid(20, 1.0f);
 
             EndMode3D();
-            
+
             DrawTexture(texture, screenWidth - texture.width - 20, 20, WHITE);
             DrawRectangleLines(screenWidth - texture.width - 20, 20, texture.width, texture.height, GREEN);
 
diff --git a/examples/models/models_material_pbr.c b/examples/models/models_material_pbr.c
index af2fc5b9..8d51eefd 100644
--- a/examples/models/models_material_pbr.c
+++ b/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");
@@ -45,7 +45,7 @@ int main()
 
     // Load model and PBR material
     Model model = LoadModel("resources/pbr/trooper.obj");
-    
+
     // Mesh tangents are generated... and uploaded to GPU
     // NOTE: New VBO for tangents is generated at default location and also binded to mesh VAO
     MeshTangents(&model.meshes[0]);
@@ -54,13 +54,13 @@ int main()
 
     // Define lights attributes
     // NOTE: Shader is passed to every light on creation to define shader bindings internally
-    Light lights[MAX_LIGHTS] = { 
+    Light lights[MAX_LIGHTS] = {
         CreateLight(LIGHT_POINT, (Vector3){ LIGHT_DISTANCE, LIGHT_HEIGHT, 0.0f }, (Vector3){ 0.0f, 0.0f, 0.0f }, (Color){ 255, 0, 0, 255 }, model.materials[0].shader),
         CreateLight(LIGHT_POINT, (Vector3){ 0.0f, LIGHT_HEIGHT, LIGHT_DISTANCE }, (Vector3){ 0.0f, 0.0f, 0.0f }, (Color){ 0, 255, 0, 255 }, model.materials[0].shader),
         CreateLight(LIGHT_POINT, (Vector3){ -LIGHT_DISTANCE, LIGHT_HEIGHT, 0.0f }, (Vector3){ 0.0f, 0.0f, 0.0f }, (Color){ 0, 0, 255, 255 }, model.materials[0].shader),
-        CreateLight(LIGHT_DIRECTIONAL, (Vector3){ 0.0f, LIGHT_HEIGHT*2.0f, -LIGHT_DISTANCE }, (Vector3){ 0.0f, 0.0f, 0.0f }, (Color){ 255, 0, 255, 255 }, model.materials[0].shader) 
+        CreateLight(LIGHT_DIRECTIONAL, (Vector3){ 0.0f, LIGHT_HEIGHT*2.0f, -LIGHT_DISTANCE }, (Vector3){ 0.0f, 0.0f, 0.0f }, (Color){ 255, 0, 255, 255 }, model.materials[0].shader)
     };
-    
+
     SetCameraMode(camera, CAMERA_ORBITAL);  // Set an orbital camera mode
 
     SetTargetFPS(60);                       // Set our game to run at 60 frames-per-second
@@ -72,7 +72,7 @@ int main()
         // Update
         //----------------------------------------------------------------------------------
         UpdateCamera(&camera);              // Update camera
-        
+
         // Send to material PBR shader camera view position
         float cameraPos[3] = { camera.position.x, camera.position.y, camera.position.z };
         SetShaderValue(model.materials[0].shader, model.materials[0].shader.locs[LOC_VECTOR_VIEW], cameraPos, UNIFORM_VEC3);
@@ -87,7 +87,7 @@ int main()
             BeginMode3D(camera);
 
                 DrawModel(model, Vector3Zero(), 1.0f, WHITE);
-                
+
                 DrawGrid(10, 1.0f);
 
             EndMode3D();
@@ -137,7 +137,7 @@ static Material LoadMaterialPBR(Color albedo, float metalness, float roughness)
     mat.shader.locs[LOC_MATRIX_MODEL] = GetShaderLocation(mat.shader, "matModel");
     mat.shader.locs[LOC_MATRIX_VIEW] = GetShaderLocation(mat.shader, "view");
     mat.shader.locs[LOC_VECTOR_VIEW] = GetShaderLocation(mat.shader, "viewPos");
-    
+
     // Set PBR standard maps
     mat.maps[MAP_ALBEDO].texture = LoadTexture("resources/pbr/trooper_albedo.png");
     mat.maps[MAP_NORMAL].texture = LoadTexture("resources/pbr/trooper_normals.png");
@@ -185,27 +185,27 @@ static Material LoadMaterialPBR(Color albedo, float metalness, float roughness)
     mat.maps[MAP_BRDF].texture = GenTextureBRDF(shdrBRDF, BRDF_SIZE);
     UnloadTexture(cubemap);
     UnloadTexture(texHDR);
-    
+
     // Unload already used shaders (to create specific textures)
     UnloadShader(shdrCubemap);
     UnloadShader(shdrIrradiance);
     UnloadShader(shdrPrefilter);
     UnloadShader(shdrBRDF);
-    
+
     // Set textures filtering for better quality
     SetTextureFilter(mat.maps[MAP_ALBEDO].texture, FILTER_BILINEAR);
     SetTextureFilter(mat.maps[MAP_NORMAL].texture, FILTER_BILINEAR);
     SetTextureFilter(mat.maps[MAP_METALNESS].texture, FILTER_BILINEAR);
     SetTextureFilter(mat.maps[MAP_ROUGHNESS].texture, FILTER_BILINEAR);
     SetTextureFilter(mat.maps[MAP_OCCLUSION].texture, FILTER_BILINEAR);
-    
+
     // Enable sample usage in shader for assigned textures
     SetShaderValue(mat.shader, GetShaderLocation(mat.shader, "albedo.useSampler"), (int[1]){ 1 }, UNIFORM_INT);
     SetShaderValue(mat.shader, GetShaderLocation(mat.shader, "normals.useSampler"), (int[1]){ 1 }, UNIFORM_INT);
     SetShaderValue(mat.shader, GetShaderLocation(mat.shader, "metalness.useSampler"), (int[1]){ 1 }, UNIFORM_INT);
     SetShaderValue(mat.shader, GetShaderLocation(mat.shader, "roughness.useSampler"), (int[1]){ 1 }, UNIFORM_INT);
     SetShaderValue(mat.shader, GetShaderLocation(mat.shader, "occlusion.useSampler"), (int[1]){ 1 }, UNIFORM_INT);
-    
+
     int renderModeLoc = GetShaderLocation(mat.shader, "renderMode");
     SetShaderValue(mat.shader, renderModeLoc, (int[1]){ 0 }, UNIFORM_INT);
 
diff --git a/examples/models/models_mesh_generation.c b/examples/models/models_mesh_generation.c
index 2b4b75ab..cfc3bdd6 100644
--- a/examples/models/models_mesh_generation.c
+++ b/examples/models/models_mesh_generation.c
@@ -11,24 +11,24 @@
 
 #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");
-    
+
     // We generate a checked image for texturing
     Image checked = GenImageChecked(2, 2, 1, 1, RED, GREEN);
     Texture2D texture = LoadTextureFromImage(checked);
     UnloadImage(checked);
-    
+
     Model models[NUM_MODELS];
-    
+
     models[0] = LoadModelFromMesh(GenMeshPlane(2, 2, 5, 5));
     models[1] = LoadModelFromMesh(GenMeshCube(2.0f, 1.0f, 2.0f));
     models[2] = LoadModelFromMesh(GenMeshSphere(2, 32, 32));
@@ -37,7 +37,7 @@ int main()
     models[5] = LoadModelFromMesh(GenMeshTorus(0.25f, 4.0f, 16, 32));
     models[6] = LoadModelFromMesh(GenMeshKnot(1.0f, 2.0f, 16, 128));
     models[7] = LoadModelFromMesh(GenMeshPoly(5, 2.0f));
-    
+
     // Set checked texture as default diffuse component for all models material
     for (int i = 0; i < NUM_MODELS; i++) models[i].materials[0].maps[MAP_DIFFUSE].texture = texture;
 
@@ -46,12 +46,12 @@ int main()
 
     // Model drawing position
     Vector3 position = { 0.0f, 0.0f, 0.0f };
-    
+
     int currentModel = 0;
-    
+
     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
@@ -60,14 +60,14 @@ int main()
         // Update
         //----------------------------------------------------------------------------------
         UpdateCamera(&camera);      // Update internal camera and our camera
-        
+
         if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
         {
             currentModel = (currentModel + 1)%NUM_MODELS; // Cycle between the textures
         }
-        
+
         if (IsKeyPressed(KEY_RIGHT))
-        { 
+        {
             currentModel++;
             if (currentModel >= NUM_MODELS) currentModel = 0;
         }
@@ -91,11 +91,11 @@ int main()
                 DrawGrid(10, 1.0);
 
             EndMode3D();
-            
+
             DrawRectangle(30, 400, 310, 30, Fade(SKYBLUE, 0.5f));
             DrawRectangleLines(30, 400, 310, 30, Fade(DARKBLUE, 0.5f));
             DrawText("MOUSE LEFT BUTTON to CYCLE PROCEDURAL MODELS", 40, 410, 10, BLUE);
-            
+
             switch(currentModel)
             {
                 case 0: DrawText("PLANE", 680, 10, 20, DARKBLUE); break;
@@ -115,10 +115,10 @@ int main()
 
     // De-Initialization
     //--------------------------------------------------------------------------------------
-    
+
     // Unload models data (GPU VRAM)
     for (int i = 0; i < NUM_MODELS; i++) UnloadModel(models[i]);
-    
+
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
diff --git a/examples/models/models_mesh_picking.c b/examples/models/models_mesh_picking.c
index 42028829..26d9fa7e 100644
--- a/examples/models/models_mesh_picking.c
+++ b/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");
 
@@ -33,22 +33,22 @@ int main()
     camera.type = CAMERA_PERSPECTIVE;                   // Camera mode type
 
     Ray ray = { 0 };        // Picking ray
-    
+
     Model tower = LoadModel("resources/models/turret.obj");                 // Load OBJ model
     Texture2D texture = LoadTexture("resources/models/turret_diffuse.png"); // Load model texture
     tower.materials[0].maps[MAP_DIFFUSE].texture = texture;                 // Set model diffuse texture
-    
+
     Vector3 towerPos = { 0.0f, 0.0f, 0.0f };                    // Set model position
     BoundingBox towerBBox = MeshBoundingBox(tower.meshes[0]);   // Get mesh bounding box
     bool hitMeshBBox = false;
     bool hitTriangle = false;
 
     // Test triangle
-    Vector3 ta = (Vector3){ -25.0, 0.5, 0.0 };    
+    Vector3 ta = (Vector3){ -25.0, 0.5, 0.0 };
     Vector3 tb = (Vector3){ -4.0, 2.5, 1.0 };
     Vector3 tc = (Vector3){ -8.0, 6.5, 0.0 };
 
-    Vector3 bary = { 0.0f, 0.0f, 0.0f }; 
+    Vector3 bary = { 0.0f, 0.0f, 0.0f };
 
     SetCameraMode(camera, CAMERA_FREE); // Set a free camera mode
 
@@ -60,7 +60,7 @@ int main()
         // Update
         //----------------------------------------------------------------------------------
         UpdateCamera(&camera);          // Update camera
-        
+
         // Display information about closest hit
         RayHitInfo nearestHit = { 0 };
         char *hitObjectName = "None";
@@ -70,10 +70,10 @@ int main()
 
         // Get ray and test against ground, triangle, and mesh
         ray = GetMouseRay(GetMousePosition(), camera);
-        
+
         // Check ray collision aginst ground plane
         RayHitInfo groundHitInfo = GetCollisionRayGround(ray, 0.0f);
-        
+
         if ((groundHitInfo.hit) && (groundHitInfo.distance < nearestHit.distance))
         {
             nearestHit = groundHitInfo;
@@ -83,8 +83,8 @@ int main()
 
         // Check ray collision against test triangle
         RayHitInfo triHitInfo = GetCollisionRayTriangle(ray, ta, tb, tc);
-        
-        if ((triHitInfo.hit) && (triHitInfo.distance < nearestHit.distance)) 
+
+        if ((triHitInfo.hit) && (triHitInfo.distance < nearestHit.distance))
         {
             nearestHit = triHitInfo;
             cursorColor = PURPLE;
@@ -92,32 +92,31 @@ int main()
 
             bary = Vector3Barycenter(nearestHit.position, ta, tb, tc);
             hitTriangle = true;
-        } 
+        }
         else hitTriangle = false;
 
         RayHitInfo meshHitInfo = { 0 };
 
         // Check ray collision against bounding box first, before trying the full ray-mesh test
-        if (CheckCollisionRayBox(ray, towerBBox)) 
+        if (CheckCollisionRayBox(ray, towerBBox))
         {
             hitMeshBBox = true;
-            
+
             // Check ray collision against model
             // NOTE: It considers model.transform matrix!
-            meshHitInfo = GetCollisionRayModel(ray, &tower);   
-            
-            if ((meshHitInfo.hit) && (meshHitInfo.distance < nearestHit.distance)) 
+            meshHitInfo = GetCollisionRayModel(ray, &tower);
+
+            if ((meshHitInfo.hit) && (meshHitInfo.distance < nearestHit.distance))
             {
                 nearestHit = meshHitInfo;
                 cursorColor = ORANGE;
                 hitObjectName = "Mesh";
             }
-            
-        } 
-        
-        hitMeshBBox = false; 
+        }
+
+        hitMeshBBox = false;
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
@@ -127,10 +126,10 @@ int main()
             BeginMode3D(camera);
 
                 // Draw the tower
-                // WARNING: If scale is different than 1.0f, 
+                // WARNING: If scale is different than 1.0f,
                 // not considered by GetCollisionRayModel()
                 DrawModel(tower, towerPos, 1.0f, WHITE);
-                
+
                 // Draw the test triangle
                 DrawLine3D(ta, tb, PURPLE);
                 DrawLine3D(tb, tc, PURPLE);
@@ -140,7 +139,7 @@ int main()
                 if (hitMeshBBox) DrawBoundingBox(towerBBox, LIME);
 
                 // If we hit something, draw the cursor at the hit point
-                if (nearestHit.hit) 
+                if (nearestHit.hit)
                 {
                     DrawCube(nearestHit.position, 0.3, 0.3, 0.3, cursorColor);
                     DrawCubeWires(nearestHit.position, 0.3, 0.3, 0.3, RED);
@@ -149,40 +148,40 @@ int main()
                     normalEnd.x = nearestHit.position.x + nearestHit.normal.x;
                     normalEnd.y = nearestHit.position.y + nearestHit.normal.y;
                     normalEnd.z = nearestHit.position.z + nearestHit.normal.z;
-                    
+
                     DrawLine3D(nearestHit.position, normalEnd, RED);
                 }
 
                 DrawRay(ray, MAROON);
-                
+
                 DrawGrid(10, 10.0f);
 
             EndMode3D();
-            
+
             // Draw some debug GUI text
             DrawText(FormatText("Hit Object: %s", hitObjectName), 10, 50, 10, BLACK);
 
-            if (nearestHit.hit) 
+            if (nearestHit.hit)
             {
                 int ypos = 70;
 
                 DrawText(FormatText("Distance: %3.2f", nearestHit.distance), 10, ypos, 10, BLACK);
-                
-                DrawText(FormatText("Hit Pos: %3.2f %3.2f %3.2f", 
-                                    nearestHit.position.x, 
-                                    nearestHit.position.y, 
+
+                DrawText(FormatText("Hit Pos: %3.2f %3.2f %3.2f",
+                                    nearestHit.position.x,
+                                    nearestHit.position.y,
                                     nearestHit.position.z), 10, ypos + 15, 10, BLACK);
-                                    
-                DrawText(FormatText("Hit Norm: %3.2f %3.2f %3.2f", 
-                                    nearestHit.normal.x, 
-                                    nearestHit.normal.y, 
+
+                DrawText(FormatText("Hit Norm: %3.2f %3.2f %3.2f",
+                                    nearestHit.normal.x,
+                                    nearestHit.normal.y,
                                     nearestHit.normal.z), 10, ypos + 30, 10, BLACK);
 
                 if (hitTriangle) DrawText(FormatText("Barycenter: %3.2f %3.2f %3.2f",  bary.x, bary.y, bary.z), 10, ypos + 45, 10, BLACK);
             }
 
             DrawText("Use Mouse to Move Camera", 10, 430, 10, GRAY);
-            
+
             DrawText("(c) Turret 3D model by Alberto Cano", screenWidth - 200, screenHeight - 20, 10, GRAY);
 
             DrawFPS(10, 10);
@@ -195,7 +194,7 @@ int main()
     //--------------------------------------------------------------------------------------
     UnloadModel(tower);         // Unload model
     UnloadTexture(texture);     // Unload texture
-    
+
     CloseWindow();              // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
diff --git a/examples/models/models_obj_loading.c b/examples/models/models_obj_loading.c
index 74e7d08a..51578bc1 100644
--- a/examples/models/models_obj_loading.c
+++ b/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
diff --git a/examples/models/models_obj_viewer.c b/examples/models/models_obj_viewer.c
index 7d387441..dc6787e7 100644
--- a/examples/models/models_obj_viewer.c
+++ b/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
diff --git a/examples/models/models_orthographic_projection.c b/examples/models/models_orthographic_projection.c
index 3ad32b60..ca9d83c9 100644
--- a/examples/models/models_orthographic_projection.c
+++ b/examples/models/models_orthographic_projection.c
@@ -1,6 +1,6 @@
 /*******************************************************************************************
 *
-*   raylib [models] example - Show the difference between perspective and orthographic projection 
+*   raylib [models] example - Show the difference between perspective and orthographic projection
 *
 *   This program is heavily based on the geometric objects example
 *
@@ -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
@@ -38,14 +38,14 @@ int main()
     {
         // Update
         //----------------------------------------------------------------------------------
-        if (IsKeyPressed(KEY_SPACE)) 
+        if (IsKeyPressed(KEY_SPACE))
         {
-            if (camera.type == CAMERA_PERSPECTIVE) 
+            if (camera.type == CAMERA_PERSPECTIVE)
             {
                 camera.fovy = WIDTH_ORTHOGRAPHIC;
                 camera.type = CAMERA_ORTHOGRAPHIC;
-            } 
-            else 
+            }
+            else
             {
                 camera.fovy = FOVY_PERSPECTIVE;
                 camera.type = CAMERA_PERSPECTIVE;
diff --git a/examples/models/models_rlgl_solar_system.c b/examples/models/models_rlgl_solar_system.c
index 7193d6f8..cb9289ad 100644
--- a/examples/models/models_rlgl_solar_system.c
+++ b/examples/models/models_rlgl_solar_system.c
@@ -22,13 +22,13 @@ void DrawSphereBasic(Color color);      // Draw sphere without any matrix transf
 //------------------------------------------------------------------------------------
 // Program main entry point
 //------------------------------------------------------------------------------------
-int main()
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
     const int screenWidth = 800;
     const int screenHeight = 450;
-    
+
     const float sunRadius = 4.0f;
     const float earthRadius = 0.6f;
     const float earthOrbitRadius = 8.0f;
@@ -44,26 +44,26 @@ int main()
     camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
     camera.fovy = 45.0f;
     camera.type = CAMERA_PERSPECTIVE;
-    
+
     SetCameraMode(camera, CAMERA_FREE);
-       
+
     float rotationSpeed = 0.2f;         // General system rotation speed
-    
+
     float earthRotation = 0.0f;         // Rotation of earth around itself (days) in degrees
     float earthOrbitRotation = 0.0f;    // Rotation of earth around the Sun (years) in degrees
     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
         //----------------------------------------------------------------------------------
         UpdateCamera(&camera);
-        
+
         earthRotation += (5.0f*rotationSpeed);
         earthOrbitRotation += (365/360.0f*(5.0f*rotationSpeed)*rotationSpeed);
         moonRotation += (2.0f*rotationSpeed);
@@ -77,12 +77,12 @@ int main()
             ClearBackground(RAYWHITE);
 
             BeginMode3D(camera);
-            
+
                 rlPushMatrix();
                     rlScalef(sunRadius, sunRadius, sunRadius);          // Scale Sun
                     DrawSphereBasic(GOLD);                              // Draw the Sun
                 rlPopMatrix();
-                
+
                 rlPushMatrix();
                     rlRotatef(earthOrbitRotation, 0.0f, 1.0f, 0.0f);    // Rotation for Earth orbit around Sun
                     rlTranslatef(earthOrbitRadius, 0.0f, 0.0f);         // Translation for Earth orbit
@@ -91,19 +91,19 @@ int main()
                     rlPushMatrix();
                         rlRotatef(earthRotation, 0.25, 1.0, 0.0);       // Rotation for Earth itself
                         rlScalef(earthRadius, earthRadius, earthRadius);// Scale Earth
-                        
+
                         DrawSphereBasic(BLUE);                          // Draw the Earth
                     rlPopMatrix();
-                    
+
                     rlRotatef(moonOrbitRotation, 0.0f, 1.0f, 0.0f);     // Rotation for Moon orbit around Earth
                     rlTranslatef(moonOrbitRadius, 0.0f, 0.0f);          // Translation for Moon orbit
                     rlRotatef(-moonOrbitRotation, 0.0f, 1.0f, 0.0f);    // Rotation for Moon orbit around Earth inverted
                     rlRotatef(moonRotation, 0.0f, 1.0f, 0.0f);          // Rotation for Moon itself
                     rlScalef(moonRadius, moonRadius, moonRadius);       // Scale Moon
-                    
+
                     DrawSphereBasic(LIGHTGRAY);                         // Draw the Moon
                 rlPopMatrix();
-                
+
                 // Some reference elements (not affected by previous matrix transformations)
                 DrawCircle3D((Vector3){ 0.0f, 0.0f, 0.0f }, earthOrbitRadius, (Vector3){ 1, 0, 0 }, 90.0f, Fade(RED, 0.5f));
                 DrawGrid(20, 1.0f);
@@ -135,7 +135,7 @@ void DrawSphereBasic(Color color)
 {
     int rings = 16;
     int slices = 16;
-    
+
     rlBegin(RL_TRIANGLES);
         rlColor4ub(color.r, color.g, color.b, color.a);
 
diff --git a/examples/models/models_skybox.c b/examples/models/models_skybox.c
index d3369b70..1693d9bc 100644
--- a/examples/models/models_skybox.c
+++ b/examples/models/models_skybox.c
@@ -11,22 +11,22 @@
 
 #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");
 
     // Define the camera to look into our 3d world
     Camera camera = {{ 1.0f, 1.0f, 1.0f }, { 4.0f, 1.0f, 4.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f, 0 };
 
-    // Load skybox model   
+    // Load skybox model
     Mesh cube = GenMeshCube(1.0f, 1.0f, 1.0f);
     Model skybox = LoadModelFromMesh(cube);
-    
+
     // Load skybox shader and set required locations
     // NOTE: Some locations are automatically set at shader loading
 #if defined(PLATFORM_DESKTOP)
@@ -43,17 +43,17 @@ int main()
     Shader shdrCubemap = LoadShader("resources/shaders/glsl100/cubemap.vs", "resources/shaders/glsl100/cubemap.fs");
 #endif
     SetShaderValue(shdrCubemap, GetShaderLocation(shdrCubemap, "equirectangularMap"), (int[1]){ 0 }, UNIFORM_INT);
-    
+
     // Load HDR panorama (sphere) texture
     Texture2D texHDR = LoadTexture("resources/dresden_square.hdr");
-    
+
     // Generate cubemap (texture with 6 quads-cube-mapping) from panorama HDR texture
     // NOTE: New texture is generated rendering to texture, shader computes the sphre->cube coordinates mapping
     skybox.materials[0].maps[MAP_CUBEMAP].texture = GenTextureCubemap(shdrCubemap, texHDR, 512);
-    
+
     UnloadTexture(texHDR);      // Texture not required anymore, cubemap already generated
     UnloadShader(shdrCubemap);  // Unload cubemap generation shader, not required anymore
-    
+
     SetCameraMode(camera, CAMERA_FIRST_PERSON);  // Set a first person camera mode
 
     SetTargetFPS(60);                       // Set our game to run at 60 frames-per-second
@@ -76,7 +76,7 @@ int main()
             BeginMode3D(camera);
 
                 DrawModel(skybox, (Vector3){0, 0, 0}, 1.0f, WHITE);
-                
+
                 DrawGrid(10, 1.0f);
 
             EndMode3D();
diff --git a/examples/models/models_yaw_pitch_roll.c b/examples/models/models_yaw_pitch_roll.c
index 658be084..0931c00e 100644
--- a/examples/models/models_yaw_pitch_roll.c
+++ b/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