Code cleaning, removed useless spaces

examples/audio_music_stream.c

@@ -19,59 +19,59 @@ int main()
     //--------------------------------------------------------------------------------------
     int screenWidth = 800;
     int screenHeight = 450;
-    
+
     InitWindow(screenWidth, screenHeight, "raylib [audio] example - music playing (streaming)");
-    
+
     InitAudioDevice();              // Initialize audio device
-    
+
     PlayMusicStream("resources/audio/guitar_noodling.ogg");         // Play music stream
-    
+
     int framesCounter = 0;
     float volume = 1.0;
     float timePlayed = 0;
-    
+
     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
         //----------------------------------------------------------------------------------
         framesCounter++;
-        
+
         // Testing music fading from one file to another
 /*
         if (framesCounter > 600)    // Wait for 10 seconds (600 frames)
         {
             volume -= 0.01;         // Decrement music volume level
-            
+
-            // When music volume level equal or lower than 0, 
+            // When music volume level equal or lower than 0,
             // restore volume level and init another music file
-            if (volume <= 0)        
+            if (volume <= 0)
             {
                 volume = 1.0;
                 framesCounter = 0;
                 PlayMusicStream("resources/audio/another_file.ogg");
             }
-            
+
             SetMusicVolume(volume);
         }
 */
         timePlayed = GetMusicTimePlayed() / GetMusicTimeLength() * 100 * 4; // We scale by 4 to fit 400 pixels
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-            
+
             DrawText("MUSIC SHOULD BE PLAYING!", 255, 200, 20, LIGHTGRAY);
-            
+
             DrawRectangle(200, 250, 400, 12, LIGHTGRAY);
             DrawRectangle(200, 250, (int)timePlayed, 12, MAROON);
-        
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
@@ -79,9 +79,9 @@ int main()
     // De-Initialization
     //--------------------------------------------------------------------------------------
     CloseAudioDevice();     // Close audio device (music streaming is automatically stopped)
-    
+
     CloseWindow();          // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
-    
+
     return 0;
 }

examples/audio_sound_loading.c

@@ -19,15 +19,15 @@ int main()
     //--------------------------------------------------------------------------------------
     int screenWidth = 800;
     int screenHeight = 450;
-    
+
     InitWindow(screenWidth, screenHeight, "raylib [audio] example - sound loading and playing");
-    
+
     InitAudioDevice();      // Initialize audio device
-    
+
     Sound fxWav = LoadSound("resources/audio/weird.wav");         // Load WAV audio file
     Sound fxOgg = LoadSound("resources/audio/tanatana.ogg");      // Load OGG audio file
     //--------------------------------------------------------------------------------------
-    
+
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
@@ -37,17 +37,17 @@ int main()
 
         if (IsKeyPressed(KEY_ENTER)) PlaySound(fxOgg);      // Play OGG sound
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-            
+
             DrawText("Press SPACE to PLAY the WAV sound!", 200, 180, 20, LIGHTGRAY);
 
             DrawText("Press ENTER to PLAY the OGG sound!", 200, 220, 20, LIGHTGRAY);
-        
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
@@ -56,11 +56,11 @@ int main()
     //--------------------------------------------------------------------------------------
     UnloadSound(fxWav);     // Unload sound data
     UnloadSound(fxOgg);     // Unload sound data
-    
+
     CloseAudioDevice();     // Close audio device
-    
+
     CloseWindow();          // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
-    
+
     return 0;
 }

examples/core_3d_mode.c

@@ -27,7 +27,7 @@ int main()
 
     //SetTargetFPS(60);   // Set our game to run at 60 frames-per-second, but not now...
     //--------------------------------------------------------------------------------------
-    
+
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
@@ -35,26 +35,26 @@ int main()
         //----------------------------------------------------------------------------------
         // TODO: Update your variables here
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(WHITE);
-            
+
             Begin3dMode(camera);
-            
+
                 DrawCube(cubePosition, 2, 2, 2, RED);
                 DrawCubeWires(cubePosition, 2, 2, 2, MAROON);
 
                 DrawGrid(10.0, 1.0);
-                
+
             End3dMode();
-            
+
             DrawText("Welcome to the third dimension!", 10, 40, 20, DARKGRAY);
-            
+
             DrawFPS(10, 10);
-        
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
@@ -63,6 +63,6 @@ int main()
     //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
-    
+
     return 0;
 }

examples/core_basic_window.c

@@ -17,10 +17,10 @@ int main()
     //--------------------------------------------------------------------------------------
     int screenWidth = 800;
     int screenHeight = 450;
-    
+
     InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window");
     //--------------------------------------------------------------------------------------
-    
+
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
@@ -28,15 +28,15 @@ int main()
         //----------------------------------------------------------------------------------
         // TODO: Update your variables here
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-            
+
             DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY);
-        
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
@@ -45,6 +45,6 @@ int main()
     //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
-    
+
     return 0;
 }

examples/core_color_select.c

@@ -19,13 +19,13 @@ int main()
     int screenHeight = 400;
 
     InitWindow(screenWidth, screenHeight, "raylib [core] example - color selection (collision detection)");
-    
+
     Color colors[21] = { DARKGRAY, MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, DARKBROWN,
                          GRAY, RED, GOLD, LIME, BLUE, VIOLET, BROWN, LIGHTGRAY, PINK, YELLOW,
                          GREEN, SKYBLUE, PURPLE, BEIGE };
-    
+
     Rectangle colorsRecs[21];             // Rectangles array
-    
+
     // Fills colorsRecs data (for every rectangle)
     for (int i = 0; i < 21; i++)
     {
@@ -34,43 +34,43 @@ int main()
         colorsRecs[i].width = 100;
         colorsRecs[i].height = 100;
     }
-    
+
     bool selected[21] = { false };  // Selected rectangles indicator
-    
+
     Vector2 mousePoint;
-    
+
     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
         //----------------------------------------------------------------------------------
         mousePoint = GetMousePosition();
-        
+
         for (int i = 0; i < 21; i++)    // Iterate along all the rectangles
         {
             if (CheckCollisionPointRec(mousePoint, colorsRecs[i]))
-            {   
+            {
                 colors[i].a = 120;
-                
+
                 if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) selected[i] = !selected[i];
             }
             else colors[i].a = 255;
         }
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-            
+
             for (int i = 0; i < 21; i++)    // Draw all rectangles
             {
                 DrawRectangleRec(colorsRecs[i], colors[i]);
-                
+
                 // Draw four rectangles around selected rectangle
                 if (selected[i])
                 {
@@ -80,15 +80,15 @@ int main()
                     DrawRectangle(colorsRecs[i].x, colorsRecs[i].y + 90, 100, 10, RAYWHITE);   // Square bottom rectangle
                 }
             }
-       
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
 
     // De-Initialization
-    //--------------------------------------------------------------------------------------  
+    //--------------------------------------------------------------------------------------
     CloseWindow();                // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
-    
+
     return 0;
 }

examples/core_input_gamepad.c

@@ -20,15 +20,15 @@ int main()
     //--------------------------------------------------------------------------------------
     int screenWidth = 800;
     int screenHeight = 450;
-    
+
     InitWindow(screenWidth, screenHeight, "raylib [core] example - gamepad input");
-    
+
     Vector2 ballPosition = { screenWidth/2, screenHeight/2 };
     Vector2 gamepadMovement = { 0, 0 };
 
     SetTargetFPS(60);               // Set target frames-per-second
     //--------------------------------------------------------------------------------------
-    
+
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
@@ -37,10 +37,10 @@ int main()
         if (IsGamepadAvailable(GAMEPAD_PLAYER1))
         {
             gamepadMovement = GetGamepadMovement(GAMEPAD_PLAYER1);
-            
+
             ballPosition.x += gamepadMovement.x;
             ballPosition.y -= gamepadMovement.y;
-        
+
             if (IsGamepadButtonPressed(GAMEPAD_PLAYER1, GAMEPAD_BUTTON_A))
             {
                 ballPosition.x = screenWidth/2;
@@ -48,17 +48,17 @@ int main()
             }
         }
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-            
+
             DrawText("move the ball with gamepad", 10, 10, 20, DARKGRAY);
-            
+
             DrawCircleV(ballPosition, 50, MAROON);
-        
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
@@ -67,6 +67,6 @@ int main()
     //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
-    
+
     return 0;
 }

examples/core_input_keys.c

@@ -1,6 +1,6 @@
 /*******************************************************************************************
 *
-*   raylib [core] example - Keyboard input 
+*   raylib [core] example - Keyboard input
 *
 *   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)
@@ -12,19 +12,19 @@
 #include "raylib.h"
 
 int main()
-{    
+{
     // Initialization
     //--------------------------------------------------------------------------------------
     int screenWidth = 800;
     int screenHeight = 450;
-    
+
     InitWindow(screenWidth, screenHeight, "raylib [core] example - keyboard input");
 
-    Vector2 ballPosition = { screenWidth/2, screenHeight/2 };    
+    Vector2 ballPosition = { screenWidth/2, screenHeight/2 };
 
     SetTargetFPS(60);       // Set target frames-per-second
     //--------------------------------------------------------------------------------------
-    
+
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
@@ -35,17 +35,17 @@ int main()
         if (IsKeyDown(KEY_UP)) ballPosition.y -= 0.8;
         if (IsKeyDown(KEY_DOWN)) ballPosition.y += 0.8;
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-            
+
             DrawText("move the ball with arrow keys", 10, 10, 20, DARKGRAY);
-            
+
             DrawCircleV(ballPosition, 50, MAROON);
-        
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
@@ -54,6 +54,6 @@ int main()
     //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
-    
+
     return 0;
 }

examples/core_input_mouse.c

@@ -1,6 +1,6 @@
 /*******************************************************************************************
 *
-*   raylib [core] example - Mouse input 
+*   raylib [core] example - Mouse input
 *
 *   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)
@@ -17,13 +17,13 @@ int main()
     //--------------------------------------------------------------------------------------
     int screenWidth = 800;
     int screenHeight = 450;
-    
+
-    InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse input");    
+    InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse input");
-    
+
     int mouseX, mouseY;
     Vector2 ballPosition = { -100.0, -100.0 };
     //---------------------------------------------------------------------------------------
-    
+
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
@@ -33,22 +33,22 @@ int main()
         {
             mouseX = GetMouseX();
             mouseY = GetMouseY();
-            
+
             ballPosition.x = (float)mouseX;
             ballPosition.y = (float)mouseY;
         }
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-            
+
             DrawCircleV(ballPosition, 40, GOLD);
-            
+
             DrawText("mouse click to draw the ball", 10, 10, 20, DARKGRAY);
-        
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
@@ -57,6 +57,6 @@ int main()
     //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
-    
+
     return 0;
 }

examples/core_mouse_wheel.c

@@ -17,15 +17,15 @@ int main()
     //--------------------------------------------------------------------------------------
     int screenWidth = 800;
     int screenHeight = 450;
-    
+
     InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse wheel");
-    
+
     int boxPositionY = screenHeight/2 - 40;
     int scrollSpeed = 4;            // Scrolling speed in pixels
-    
+
     SetTargetFPS(60);
     //--------------------------------------------------------------------------------------
-    
+
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
@@ -33,16 +33,16 @@ int main()
         //----------------------------------------------------------------------------------
         boxPositionY -= (GetMouseWheelMove()*scrollSpeed);
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-            
+
             DrawRectangle(screenWidth/2 - 40, boxPositionY, 80, 80, MAROON);
-            
+
-            DrawText("Use mouse wheel to move the cube up and down!", 10, 10, 20, GRAY);            
+            DrawText("Use mouse wheel to move the cube up and down!", 10, 10, 20, GRAY);
             DrawText(FormatText("Box position Y: %03i", boxPositionY), 10, 40, 20, LIGHTGRAY);
 
         EndDrawing();
@@ -53,6 +53,6 @@ int main()
     //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
-    
+
     return 0;
 }

examples/core_random_values.c

@@ -18,40 +18,40 @@ int main()
     int screenWidth = 800;
     int screenHeight = 450;
 
-    InitWindow(screenWidth, screenHeight, "raylib [core] example - generate random values");    
+    InitWindow(screenWidth, screenHeight, "raylib [core] example - generate random values");
-    
+
     int framesCounter = 0;  // Variable used to count frames
 
     int randValue = GetRandomValue(-8,5);   // Get a random integer number between -8 and 5 (both included)
-    
+
     SetTargetFPS(60);       // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
-    
+
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
         // Update
         //----------------------------------------------------------------------------------
         framesCounter++;
-        
+
         // Every two seconds (120 frames) a new random value is generated
         if (((framesCounter/120)%2) == 1)
-        {   
+        {
             randValue = GetRandomValue(-8,5);
             framesCounter = 0;
         }
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
 
             DrawText("Every 2 seconds a new random value is generated:", 130, 100, 20, MAROON);
 
             DrawText(FormatText("%i", randValue), 360, 180, 80, LIGHTGRAY);
-        
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
@@ -60,6 +60,6 @@ int main()
     //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
-    
+
     return 0;
 }

examples/models_billboard.c

@@ -19,7 +19,7 @@ int main()
     int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - drawing billboards");
-    
+
     // Define the camera to look into our 3d world
     Camera camera = {{ 10.0, 8.0, 10.0 }, { 0.0, 0.0, 0.0 }, { 0.0, 1.0, 0.0 }};
 
@@ -29,7 +29,7 @@ int main()
 
     SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
-    
+
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
@@ -40,24 +40,24 @@ int main()
         if (IsKeyDown(KEY_UP)) camera.position.y -= 0.2;
         if (IsKeyDown(KEY_DOWN)) camera.position.y += 0.2;
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-            
+
             Begin3dMode(camera);
-            
+
                 //DrawBillboard(camera, lena, billPosition, 1.0, WHITE);
                 DrawBillboardRec(camera, lena, eyesRec, billPosition, 4.0, WHITE);
-            
+
                 DrawGrid(10.0, 1.0);        // Draw a grid
-                
+
             End3dMode();
-            
+
             DrawFPS(10, 10);
-        
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
@@ -65,9 +65,9 @@ int main()
     // De-Initialization
     //--------------------------------------------------------------------------------------
     UnloadTexture(lena);        // Unload texture
-    
+
     CloseWindow();              // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
-    
+
     return 0;
 }

examples/models_cubesmap.c

@@ -19,10 +19,10 @@ int main()
     int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - cubesmap loading and drawing");
-    
+
     // Define the camera to look into our 3d world
     Camera camera = {{ 7.0, 7.0, 7.0 }, { 0.0, 0.0, 0.0 }, { 0.0, 1.0, 0.0 }};
-    
+
     Image img = LoadImage("resources/cubesmap.png");    // Load cubesmap image (RAM)
     Texture2D texture = CreateTexture(img, false);      // Convert image to texture (VRAM)
     Model map = LoadCubesmap(img);                      // Load cubesmap model
@@ -30,10 +30,10 @@ int main()
     Vector3 mapPosition = { -1, 0.0, -1 };              // Set model position
 
     UnloadImage(img);       // Unload cubesmap image from RAM, already uploaded to VRAM
-    
+
     SetTargetFPS(60);       // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
-    
+
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
@@ -41,29 +41,29 @@ int main()
         //----------------------------------------------------------------------------------
         if (IsKeyDown(KEY_UP)) camera.position.y += 0.2f;
         else if (IsKeyDown(KEY_DOWN)) camera.position.y -= 0.2f;
-        
+
         if (IsKeyDown(KEY_RIGHT)) camera.position.z += 0.2f;
         else if (IsKeyDown(KEY_LEFT)) camera.position.z -= 0.2f;
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-            
+
             Begin3dMode(camera);
-            
+
                 DrawModel(map, mapPosition, 1.0f, MAROON);
-                
+
                 DrawGrid(10.0, 1.0);
-                
+
-                DrawGizmo(mapPosition); 
+                DrawGizmo(mapPosition);
-                
+
             End3dMode();
-            
+
             DrawFPS(10, 10);
-        
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
@@ -72,9 +72,9 @@ int main()
     //--------------------------------------------------------------------------------------
     UnloadTexture(texture);     // Unload texture
     UnloadModel(map);           // Unload model
-    
+
     CloseWindow();              // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
-    
+
     return 0;
 }

examples/models_geometric_shapes.c

@@ -22,10 +22,10 @@ int main()
 
     // Define the camera to look into our 3d world
     Camera camera = {{ 0.0, 10.0, 10.0 }, { 0.0, 0.0, 0.0 }, { 0.0, 1.0, 0.0 }};
-    
+
     SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
-    
+
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
@@ -33,35 +33,35 @@ int main()
         //----------------------------------------------------------------------------------
         // TODO: Update your variables here
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-            
+
             Begin3dMode(camera);
-            
+
                 DrawCube((Vector3){-4, 0, 2}, 2, 5, 2, RED);
                 DrawCubeWires((Vector3){-4, 0, 2}, 2, 5, 2, GOLD);
                 DrawCubeWires((Vector3){-4, 0, -2}, 3, 6, 2, MAROON);
-                
+
-                DrawSphere((Vector3){-1, 0, -2}, 1, GREEN);     
+                DrawSphere((Vector3){-1, 0, -2}, 1, GREEN);
                 DrawSphereWires((Vector3){1, 0, 2}, 2, 16, 16, LIME);
-                
+
                 DrawCylinder((Vector3){4, 0, -2}, 1, 2, 3, 4, SKYBLUE);
                 DrawCylinderWires((Vector3){4, 0, -2}, 1, 2, 3, 4, DARKBLUE);
                 DrawCylinderWires((Vector3){4.5, -1, 2}, 1, 1, 2, 6, BROWN);
-                
+
                 DrawCylinder((Vector3){1, 0, -4}, 0, 1.5, 3, 8, GOLD);
                 DrawCylinderWires((Vector3){1, 0, -4}, 0, 1.5, 3, 8, PINK);
 
                 DrawGrid(10.0, 1.0);        // Draw a grid
-                
+
             End3dMode();
-            
+
             DrawFPS(10, 10);
-        
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
@@ -70,6 +70,6 @@ int main()
     //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
-    
+
     return 0;
 }

examples/models_heightmap.c

@@ -30,10 +30,10 @@ int main()
     Vector3 mapPosition = { -4, 0.0, -4 };              // Set model position
 
     UnloadImage(img);       // Unload heightmap image from RAM, already uploaded to VRAM
-    
+
     SetTargetFPS(60);       // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
-    
+
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
@@ -41,25 +41,25 @@ int main()
         //----------------------------------------------------------------------------------
         // ...
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-            
+
             Begin3dMode(camera);
-            
+
                 DrawModel(map, mapPosition, 0.5f, MAROON);
-                
+
                 DrawGrid(10.0, 1.0);
-                
+
-                DrawGizmo(mapPosition); 
+                DrawGizmo(mapPosition);
-                
+
             End3dMode();
-            
+
             DrawFPS(10, 10);
-        
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
@@ -68,9 +68,9 @@ int main()
     //--------------------------------------------------------------------------------------
     UnloadTexture(texture);     // Unload texture
     UnloadModel(map);           // Unload model
-    
+
     CloseWindow();              // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
-    
+
     return 0;
 }

examples/models_obj_loading.c

@@ -28,9 +28,9 @@ int main()
     SetModelTexture(&cat, texture);                             // Bind texture to model
     Vector3 catPosition = { 0.0, 0.0, 0.0 };                    // 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
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
@@ -41,25 +41,25 @@ int main()
         if (IsKeyDown(KEY_UP)) catPosition.z -= 0.2;
         if (IsKeyDown(KEY_DOWN)) catPosition.z += 0.2;
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-            
+
             Begin3dMode(camera);
-            
+
                 DrawModel(cat, catPosition, 0.1f, WHITE);   // Draw 3d model with texture
 
                 DrawGrid(10.0, 1.0);        // Draw a grid
-                
+
                 DrawGizmo(catPosition);     // Draw gizmo
-                
+
             End3dMode();
-            
+
             DrawFPS(10, 10);
-        
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
@@ -68,9 +68,9 @@ int main()
     //--------------------------------------------------------------------------------------
     UnloadTexture(texture);     // Unload texture
     UnloadModel(cat);           // Unload model
-    
+
     CloseWindow();              // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
-    
+
     return 0;
 }

examples/models_planes.c

@@ -25,7 +25,7 @@ int main()
 
     SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
-    
+
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
@@ -33,24 +33,24 @@ int main()
         //----------------------------------------------------------------------------------
         // TODO: Update your variables here
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-            
+
             Begin3dMode(camera);
-            
+
                 DrawPlane((Vector3){ 0, 0, 0 }, (Vector2){ 4, 4 }, (Vector3){ 0, 45, 0 }, RED);
                 //DrawPlaneEx((Vector3){ 0, 8, 0 }, (Vector2){ 2, 1 }, (Vector3){ 0, 0, 0 }, 4, 4, SKYBLUE);
 
                 DrawGrid(10.0, 1.0);
-                
+
             End3dMode();
-            
+
             DrawFPS(10, 10);
-        
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
@@ -59,6 +59,6 @@ int main()
     //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
-    
+
     return 0;
 }

examples/shapes_basic_shapes.c

@@ -20,7 +20,7 @@ int main()
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - basic shapes drawing");
     //--------------------------------------------------------------------------------------
-    
+
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
@@ -28,13 +28,13 @@ int main()
         //----------------------------------------------------------------------------------
         // TODO: Update your variables here
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-            
+
             DrawText("some basic shapes available on raylib", 20, 20, 20, DARKGRAY);
 
             DrawLine(18, 42, screenWidth - 18, 42, BLACK);
@@ -47,16 +47,16 @@ int main()
             DrawRectangleGradient(screenWidth/4*2 - 90, 170, 180, 130, MAROON, GOLD);
             DrawRectangleLines(screenWidth/4*2 - 40, 320, 80, 60, ORANGE);
 
-            DrawTriangle((Vector2){screenWidth/4*3, 80}, 
+            DrawTriangle((Vector2){screenWidth/4*3, 80},
-                         (Vector2){screenWidth/4*3 - 60, 150}, 
+                         (Vector2){screenWidth/4*3 - 60, 150},
                          (Vector2){screenWidth/4*3 + 60, 150}, VIOLET);
-                         
+
-            DrawTriangleLines((Vector2){screenWidth/4*3, 160}, 
+            DrawTriangleLines((Vector2){screenWidth/4*3, 160},
-                              (Vector2){screenWidth/4*3 - 20, 230}, 
+                              (Vector2){screenWidth/4*3 - 20, 230},
                               (Vector2){screenWidth/4*3 + 20, 230}, DARKBLUE);
-                              
+
             DrawPoly((Vector2){screenWidth/4*3, 320}, 6, 80, 0, BROWN);
-                    
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
@@ -65,6 +65,6 @@ int main()
     //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
-    
+
     return 0;
 }

examples/shapes_colors_palette.c

@@ -17,10 +17,10 @@ int main()
     //--------------------------------------------------------------------------------------
     int screenWidth = 800;
     int screenHeight = 450;
-    
+
-    InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib colors palette");
+    InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib color palette");
     //--------------------------------------------------------------------------------------
-    
+
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
@@ -28,15 +28,15 @@ int main()
         //----------------------------------------------------------------------------------
         // TODO: Update your variables here
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-            
+
             DrawText("raylib color palette", 28, 42, 20, BLACK);
-            
+
             DrawRectangle(26, 80, 100, 100, DARKGRAY);
             DrawRectangle(26, 188, 100, 100, GRAY);
             DrawRectangle(26, 296, 100, 100, LIGHTGRAY);
@@ -59,7 +59,7 @@ int main()
             DrawRectangle(674, 188, 100, 100, BROWN);
             DrawRectangle(674, 296, 100, 100, BEIGE);
 
-            
+
             DrawText("DARKGRAY", 65, 166, 10, BLACK);
             DrawText("GRAY", 93, 274, 10, BLACK);
             DrawText("LIGHTGRAY", 61, 382, 10, BLACK);
@@ -81,7 +81,7 @@ int main()
             DrawText("DARKBROWN", 705, 166, 10, BLACK);
             DrawText("BROWN", 733, 274, 10, BLACK);
             DrawText("BEIGE", 737, 382, 10, BLACK);
-        
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
@@ -90,6 +90,6 @@ int main()
     //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
-    
+
     return 0;
-}
+}

examples/shapes_logo_raylib.c

@@ -17,10 +17,10 @@ int main()
     //--------------------------------------------------------------------------------------
     int screenWidth = 800;
     int screenHeight = 450;
-    
+
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib logo using shapes");
     //--------------------------------------------------------------------------------------
-    
+
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
@@ -28,19 +28,19 @@ int main()
         //----------------------------------------------------------------------------------
         // TODO: Update your variables here
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-            
+
             DrawRectangle(screenWidth/2 - 128, screenHeight/2 - 128, 256, 256, BLACK);
             DrawRectangle(screenWidth/2 - 112, screenHeight/2 - 112, 224, 224, RAYWHITE);
             DrawText("raylib", screenWidth/2 - 44, screenHeight/2 + 48, 50, BLACK);
-            
+
             DrawText("this is NOT a texture!", 350, 370, 10, GRAY);
-        
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
@@ -49,6 +49,6 @@ int main()
     //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
-    
+
     return 0;
 }

examples/shapes_logo_raylib_anim.c

@@ -17,31 +17,31 @@ int main()
     //--------------------------------------------------------------------------------------
     int screenWidth = 800;
     int screenHeight = 450;
-    
+
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib logo animation");
-    
+
     int logoPositionX = screenWidth/2 - 128;
     int logoPositionY = screenHeight/2 - 128;
-    
+
     int framesCounter = 0;
     int lettersCount = 0;
-    
+
     int topSideRecWidth = 16;
     int leftSideRecHeight = 16;
-    
+
     int bottomSideRecWidth = 16;
     int rightSideRecHeight = 16;
-    
+
     char raylib[8] = "       \0";   // raylib text array, max 8 letters
-    
+
     int state = 0;                  // Tracking animation states (State Machine)
 
     float alpha = 1.0;              // Useful for fading
 
-    
+
     SetTargetFPS(60);
     //--------------------------------------------------------------------------------------
-    
+
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
@@ -50,9 +50,9 @@ int main()
         if (state == 0)                 // State 0: Small box blinking
         {
             framesCounter++;
-        
+
             if (framesCounter == 120)
-            {                
+            {
                 state = 1;
                 framesCounter = 0;      // Reset counter... will be used later...
             }
@@ -61,26 +61,26 @@ int main()
         {
             topSideRecWidth += 4;
             leftSideRecHeight += 4;
-            
+
             if (topSideRecWidth == 256) state = 2;
         }
         else if (state == 2)            // State 2: Bottom and right bars growing
         {
             bottomSideRecWidth += 4;
             rightSideRecHeight += 4;
-            
+
             if (bottomSideRecWidth == 256) state = 3;
         }
         else if (state == 3)            // State 3: Letters appearing (one by one)
         {
             framesCounter++;
-            
+
             if (framesCounter/12)       // Every 12 frames, one more letter!
-            {    
+            {
                 lettersCount++;
                 framesCounter = 0;
             }
-            
+
             switch (lettersCount)
             {
                 case 1: raylib[0] = 'r'; break;
@@ -91,11 +91,11 @@ int main()
                 case 6: raylib[5] = 'b'; break;
                 default: break;
             }
-            
+
             if (lettersCount >= 10)     // When all letters have appeared, just fade out everything
             {
                 alpha -= 0.02;
-                
+
                 if (alpha <= 0)
                 {
                     alpha = 0;
@@ -109,13 +109,13 @@ int main()
             {
                 framesCounter = 0;
                 lettersCount = 0;
-    
+
                 topSideRecWidth = 16;
                 leftSideRecHeight = 16;
-    
+
                 bottomSideRecWidth = 16;
                 rightSideRecHeight = 16;
-    
+
                 for (int i = 0; i < 7; i++) raylib[i] = ' ';
 
                 raylib[7] = '\0';   // Last character is end-of-line
@@ -126,13 +126,13 @@ int main()
             }
         }
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-            
+
             if (state == 0)
             {
                 if ((framesCounter/15)%2) DrawRectangle(logoPositionX, logoPositionY, 16, 16, BLACK);
@@ -146,7 +146,7 @@ int main()
             {
                 DrawRectangle(logoPositionX, logoPositionY, topSideRecWidth, 16, BLACK);
                 DrawRectangle(logoPositionX, logoPositionY, 16, leftSideRecHeight, BLACK);
-                
+
                 DrawRectangle(logoPositionX + 240, logoPositionY, 16, rightSideRecHeight, BLACK);
                 DrawRectangle(logoPositionX, logoPositionY + 240, bottomSideRecWidth, 16, BLACK);
             }
@@ -166,7 +166,7 @@ int main()
             {
                 DrawText("[R] REPLAY", 340, 200, 20, GRAY);
             }
-        
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
@@ -175,6 +175,6 @@ int main()
     //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
-    
+
     return 0;
 }