Remove trail spaces

6 files changed, 75 insertions, 75 deletions

diff --git a/examples/core/core_2d_camera.c b/examples/core/core_2d_camera.c
index 0b4754f7..7336bbbd 100644
--- a/examples/core/core_2d_camera.c
+++ b/examples/core/core_2d_camera.c
@@ -54,7 +54,7 @@ int main(void)
     {
         // Update
         //----------------------------------------------------------------------------------
-        
+
         // Player movement
         if (IsKeyDown(KEY_RIGHT)) player.x += 2;
         else if (IsKeyDown(KEY_LEFT)) player.x -= 2;
diff --git a/examples/core/core_2d_camera_platformer.c b/examples/core/core_2d_camera_platformer.c
index db8c9f45..9ab20492 100644
--- a/examples/core/core_2d_camera_platformer.c
+++ b/examples/core/core_2d_camera_platformer.c
@@ -46,7 +46,7 @@ int main(void)
     //--------------------------------------------------------------------------------------
     const int screenWidth = 800;
     const int screenHeight = 450;
-    
+
     InitWindow(screenWidth, screenHeight, "raylib [core] example - 2d camera");
 
     Player player = { 0 };
@@ -60,7 +60,7 @@ int main(void)
         {{ 250, 300, 100, 10 }, 1, GRAY },
         {{ 650, 300, 100, 10 }, 1, GRAY }
     };
-    
+
     int envItemsLength = sizeof(envItems)/sizeof(envItems[0]);
 
     Camera2D camera = { 0 };
@@ -77,10 +77,10 @@ int main(void)
         UpdateCameraEvenOutOnLanding,
         UpdateCameraPlayerBoundsPush
     };
-    
+
     int cameraOption = 0;
     int cameraUpdatersLength = sizeof(cameraUpdaters)/sizeof(cameraUpdaters[0]);
-    
+
     char *cameraDescriptions[] = {
         "Follow player center",
         "Follow player center, but clamp to map edges",
@@ -88,25 +88,25 @@ int main(void)
         "Follow player center horizontally; updateplayer center vertically after landing",
         "Player push camera on getting too close to screen edge"
     };
-    
+
     SetTargetFPS(60);
     //--------------------------------------------------------------------------------------
 
     // Main game loop
-    while (!WindowShouldClose()) 
+    while (!WindowShouldClose())
     {
         // Update
         //----------------------------------------------------------------------------------
         float deltaTime = GetFrameTime();
-        
+
         UpdatePlayer(&player, envItems, envItemsLength, deltaTime);
 
         camera.zoom += ((float)GetMouseWheelMove()*0.05f);
-        
+
         if (camera.zoom > 3.0f) camera.zoom = 3.0f;
         else if (camera.zoom < 0.25f) camera.zoom = 0.25f;
-        
-        if (IsKeyPressed(KEY_R)) 
+
+        if (IsKeyPressed(KEY_R))
         {
             camera.zoom = 1.0f;
             player.position = (Vector2){ 400, 280 };
@@ -125,12 +125,12 @@ int main(void)
             ClearBackground(LIGHTGRAY);
 
             BeginMode2D(camera);
-           
+
                 for (int i = 0; i < envItemsLength; i++) DrawRectangleRec(envItems[i].rect, envItems[i].color);
 
                 Rectangle playerRect = { player.position.x - 20, player.position.y - 40, 40, 40 };
                 DrawRectangleRec(playerRect, RED);
-               
+
             EndMode2D();
 
             DrawText("Controls:", 20, 20, 10, BLACK);
@@ -140,7 +140,7 @@ int main(void)
             DrawText("- C to change camera mode", 40, 100, 10, DARKGRAY);
             DrawText("Current camera mode:", 20, 120, 10, BLACK);
             DrawText(cameraDescriptions[cameraOption], 40, 140, 10, DARKGRAY);
-            
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
@@ -157,35 +157,35 @@ void UpdatePlayer(Player *player, EnvItem *envItems, int envItemsLength, float d
 {
     if (IsKeyDown(KEY_LEFT)) player->position.x -= PLAYER_HOR_SPD*delta;
     if (IsKeyDown(KEY_RIGHT)) player->position.x += PLAYER_HOR_SPD*delta;
-    if (IsKeyDown(KEY_SPACE) && player->canJump) 
+    if (IsKeyDown(KEY_SPACE) && player->canJump)
     {
         player->speed = -PLAYER_JUMP_SPD;
         player->canJump = false;
     }
 
     int hitObstacle = 0;
-    for (int i = 0; i < envItemsLength; i++) 
+    for (int i = 0; i < envItemsLength; i++)
     {
         EnvItem *ei = envItems + i;
         Vector2 *p = &(player->position);
         if (ei->blocking &&
-            ei->rect.x <= p->x && 
+            ei->rect.x <= p->x &&
             ei->rect.x + ei->rect.width >= p->x &&
             ei->rect.y >= p->y &&
-            ei->rect.y < p->y + player->speed*delta) 
+            ei->rect.y < p->y + player->speed*delta)
         {
             hitObstacle = 1;
             player->speed = 0.0f;
             p->y = ei->rect.y;
         }
     }
-    
-    if (!hitObstacle) 
+
+    if (!hitObstacle)
     {
         player->position.y += player->speed*delta;
         player->speed += G*delta;
         player->canJump = false;
-    } 
+    }
     else player->canJump = true;
 }
 
@@ -200,7 +200,7 @@ void UpdateCameraCenterInsideMap(Camera2D *camera, Player *player, EnvItem *envI
     camera->target = player->position;
     camera->offset = (Vector2){ width/2.0f, height/2.0f };
     float minX = 1000, minY = 1000, maxX = -1000, maxY = -1000;
-    
+
     for (int i = 0; i < envItemsLength; i++)
     {
         EnvItem *ei = envItems + i;
@@ -209,10 +209,10 @@ void UpdateCameraCenterInsideMap(Camera2D *camera, Player *player, EnvItem *envI
         minY = fminf(ei->rect.y, minY);
         maxY = fmaxf(ei->rect.y + ei->rect.height, maxY);
     }
-    
+
     Vector2 max = GetWorldToScreen2D((Vector2){ maxX, maxY }, *camera);
     Vector2 min = GetWorldToScreen2D((Vector2){ minX, minY }, *camera);
-    
+
     if (max.x < width) camera->offset.x = width - (max.x - width/2);
     if (max.y < height) camera->offset.y = height - (max.y - height/2);
     if (min.x > 0) camera->offset.x = width/2 - min.x;
@@ -224,11 +224,11 @@ void UpdateCameraCenterSmoothFollow(Camera2D *camera, Player *player, EnvItem *e
     static float minSpeed = 30;
     static float minEffectLength = 10;
     static float fractionSpeed = 0.8f;
-    
+
     camera->offset = (Vector2){ width/2.0f, height/2.0f };
     Vector2 diff = Vector2Subtract(player->position, camera->target);
     float length = Vector2Length(diff);
-    
+
     if (length > minEffectLength)
     {
         float speed = fmaxf(fractionSpeed*length, minSpeed);
@@ -241,34 +241,34 @@ void UpdateCameraEvenOutOnLanding(Camera2D *camera, Player *player, EnvItem *env
     static float evenOutSpeed = 700;
     static int eveningOut = false;
     static float evenOutTarget;
-    
+
     camera->offset = (Vector2){ width/2.0f, height/2.0f };
     camera->target.x = player->position.x;
-    
+
     if (eveningOut)
     {
-        if (evenOutTarget > camera->target.y) 
+        if (evenOutTarget > camera->target.y)
         {
             camera->target.y += evenOutSpeed*delta;
-            
-            if (camera->target.y > evenOutTarget) 
+
+            if (camera->target.y > evenOutTarget)
             {
                 camera->target.y = evenOutTarget;
                 eveningOut = 0;
             }
-        } 
-        else 
+        }
+        else
         {
             camera->target.y -= evenOutSpeed*delta;
-            
-            if (camera->target.y < evenOutTarget) 
+
+            if (camera->target.y < evenOutTarget)
             {
                 camera->target.y = evenOutTarget;
                 eveningOut = 0;
             }
         }
-    } 
-    else 
+    }
+    else
     {
         if (player->canJump && (player->speed == 0) && (player->position.y != camera->target.y))
         {
@@ -278,7 +278,7 @@ void UpdateCameraEvenOutOnLanding(Camera2D *camera, Player *player, EnvItem *env
     }
 }
 
-void UpdateCameraPlayerBoundsPush(Camera2D *camera, Player *player, EnvItem *envItems, int envItemsLength, float delta, int width, int height) 
+void UpdateCameraPlayerBoundsPush(Camera2D *camera, Player *player, EnvItem *envItems, int envItemsLength, float delta, int width, int height)
 {
     static Vector2 bbox = { 0.2f, 0.2f };
 
diff --git a/examples/core/core_basic_window_web.c b/examples/core/core_basic_window_web.c
index 1ecb22f3..8ce1922a 100644
--- a/examples/core/core_basic_window_web.c
+++ b/examples/core/core_basic_window_web.c
@@ -46,7 +46,7 @@ int main()
 #else
     SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
-    
+
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
diff --git a/examples/core/core_quat_conversion.c b/examples/core/core_quat_conversion.c
index a7ea8247..cca6f01e 100644
--- a/examples/core/core_quat_conversion.c
+++ b/examples/core/core_quat_conversion.c
@@ -26,7 +26,7 @@ int main(void)
     const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [core] example - quat conversions");
-    
+
     Camera3D camera = { 0 };
     camera.position = (Vector3){ 0.0f, 10.0f, 10.0f };  // Camera position
     camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };      // Camera looking at point
@@ -34,9 +34,9 @@ int main(void)
     camera.fovy = 45.0f;                                // Camera field-of-view Y
     camera.projection = CAMERA_PERSPECTIVE;                   // Camera mode type
 
-    Mesh mesh = GenMeshCylinder(0.2f, 1.0f, 32); 
+    Mesh mesh = GenMeshCylinder(0.2f, 1.0f, 32);
     Model model = LoadModelFromMesh(mesh);
-    
+
     // Some required variables
     Quaternion q1 = { 0 };
     Matrix m1 = { 0 }, m2 = { 0 }, m3 = { 0 }, m4 = { 0 };
@@ -44,7 +44,7 @@ int main(void)
 
     SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
-   
+
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
@@ -60,28 +60,28 @@ int main(void)
         if (v1.x > PI*2) v1.x -= PI*2;
         if (v1.y > PI*2) v1.y -= PI*2;
         if (v1.z > PI*2) v1.z -= PI*2;
-        
+
         q1 = QuaternionFromEuler(v1.x, v1.y, v1.z);
         m1 = MatrixRotateZYX(v1);
         m2 = QuaternionToMatrix(q1);
 
         q1 = QuaternionFromMatrix(m1);
         m3 = QuaternionToMatrix(q1);
-        
-        v2 = QuaternionToEuler(q1);       
-        v2.x *= DEG2RAD; 
-        v2.y *= DEG2RAD; 
-        v2.z *= DEG2RAD; 
-        
+
+        v2 = QuaternionToEuler(q1);
+        v2.x *= DEG2RAD;
+        v2.y *= DEG2RAD;
+        v2.z *= DEG2RAD;
+
         m4 = MatrixRotateZYX(v2);
         //--------------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
 
             ClearBackground(RAYWHITE);
-            
+
             BeginMode3D(camera);
 
                 model.transform = m1;
@@ -94,19 +94,19 @@ int main(void)
                 DrawModel(model, (Vector3){ 0, 0, -1 }, 1.0f, RED);
 
                 DrawGrid(10, 1.0f);
- 
+
             EndMode3D();
-        
+
             if (v2.x < 0) v2.x += PI*2;
             if (v2.y < 0) v2.y += PI*2;
             if (v2.z < 0) v2.z += PI*2;
-            
+
             Color cx,cy,cz;
             cx = cy = cz = BLACK;
             if (v1.x == v2.x) cx = GREEN;
             if (v1.y == v2.y) cy = GREEN;
             if (v1.z == v2.z) cz = GREEN;
-            
+
             DrawText(TextFormat("%2.3f", v1.x), 20, 20, 20, cx);
             DrawText(TextFormat("%2.3f", v1.y), 20, 40, 20, cy);
             DrawText(TextFormat("%2.3f", v1.z), 20, 60, 20, cz);
@@ -122,7 +122,7 @@ int main(void)
     // De-Initialization
     //--------------------------------------------------------------------------------------
     UnloadModel(model);   // Unload model data (mesh and materials)
-    
+
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
diff --git a/examples/core/core_vr_simulator.c b/examples/core/core_vr_simulator.c
index b57e1f7f..bba90b82 100644
--- a/examples/core/core_vr_simulator.c
+++ b/examples/core/core_vr_simulator.c
@@ -38,9 +38,9 @@ int main(void)
         .eyeToScreenDistance = 0.041f,       // Distance between eye and display in meters
         .lensSeparationDistance = 0.07f,     // Lens separation distance in meters
         .interpupillaryDistance = 0.07f,     // IPD (distance between pupils) in meters
-    
+
         // NOTE: CV1 uses fresnel-hybrid-asymmetric lenses with specific compute shaders
-        // Following parameters are just an approximation to CV1 distortion stereo rendering 
+        // Following parameters are just an approximation to CV1 distortion stereo rendering
         .lensDistortionValues[0] = 1.0f,     // Lens distortion constant parameter 0
         .lensDistortionValues[1] = 0.22f,    // Lens distortion constant parameter 1
         .lensDistortionValues[2] = 0.24f,    // Lens distortion constant parameter 2
@@ -50,32 +50,32 @@ int main(void)
         .chromaAbCorrection[2] = 1.014f,     // Chromatic aberration correction parameter 2
         .chromaAbCorrection[3] = 0.0f,       // Chromatic aberration correction parameter 3
     };
-    
+
     // Load VR stereo config for VR device parameteres (Oculus Rift CV1 parameters)
     VrStereoConfig config = LoadVrStereoConfig(device);
 
     // Distortion shader (uses device lens distortion and chroma)
     Shader distortion = LoadShader(0, TextFormat("resources/distortion%i.fs", GLSL_VERSION));
-    
+
     // Update distortion shader with lens and distortion-scale parameters
-    SetShaderValue(distortion, GetShaderLocation(distortion, "leftLensCenter"), 
+    SetShaderValue(distortion, GetShaderLocation(distortion, "leftLensCenter"),
                    config.leftLensCenter, SHADER_UNIFORM_VEC2);
-    SetShaderValue(distortion, GetShaderLocation(distortion, "rightLensCenter"), 
+    SetShaderValue(distortion, GetShaderLocation(distortion, "rightLensCenter"),
                    config.rightLensCenter, SHADER_UNIFORM_VEC2);
-    SetShaderValue(distortion, GetShaderLocation(distortion, "leftScreenCenter"), 
+    SetShaderValue(distortion, GetShaderLocation(distortion, "leftScreenCenter"),
                    config.leftScreenCenter, SHADER_UNIFORM_VEC2);
-    SetShaderValue(distortion, GetShaderLocation(distortion, "rightScreenCenter"), 
+    SetShaderValue(distortion, GetShaderLocation(distortion, "rightScreenCenter"),
                    config.rightScreenCenter, SHADER_UNIFORM_VEC2);
 
-    SetShaderValue(distortion, GetShaderLocation(distortion, "scale"), 
+    SetShaderValue(distortion, GetShaderLocation(distortion, "scale"),
                    config.scale, SHADER_UNIFORM_VEC2);
-    SetShaderValue(distortion, GetShaderLocation(distortion, "scaleIn"), 
+    SetShaderValue(distortion, GetShaderLocation(distortion, "scaleIn"),
                    config.scaleIn, SHADER_UNIFORM_VEC2);
-    SetShaderValue(distortion, GetShaderLocation(distortion, "deviceWarpParam"), 
+    SetShaderValue(distortion, GetShaderLocation(distortion, "deviceWarpParam"),
                    device.lensDistortionValues, SHADER_UNIFORM_VEC4);
     SetShaderValue(distortion, GetShaderLocation(distortion, "chromaAbParam"),
                    device.chromaAbCorrection, SHADER_UNIFORM_VEC4);
-    
+
     // Initialize framebuffer for stereo rendering
     // NOTE: Screen size should match HMD aspect ratio
     RenderTexture2D target = LoadRenderTexture(GetScreenWidth(), GetScreenHeight());
@@ -121,9 +121,9 @@ int main(void)
                     EndMode3D();
                 EndVrStereoMode();
             EndTextureMode();
-            
+
             BeginShaderMode(distortion);
-                DrawTextureRec(target.texture, (Rectangle){ 0, 0, (float)target.texture.width, 
+                DrawTextureRec(target.texture, (Rectangle){ 0, 0, (float)target.texture.width,
                               (float)-target.texture.height }, (Vector2){ 0.0f, 0.0f }, WHITE);
             EndShaderMode();
 
@@ -136,7 +136,7 @@ int main(void)
     // De-Initialization
     //--------------------------------------------------------------------------------------
     UnloadVrStereoConfig(config);   // Unload stereo config
-    
+
     UnloadRenderTexture(target);    // Unload stereo render fbo
     UnloadShader(distortion);       // Unload distortion shader
 
diff --git a/examples/core/core_window_letterbox.c b/examples/core/core_window_letterbox.c
index c37e7560..dca70d9a 100644
--- a/examples/core/core_window_letterbox.c
+++ b/examples/core/core_window_letterbox.c
@@ -64,13 +64,13 @@ int main(void)
             // Recalculate random colors for the bars
             for (int i = 0; i < 10; i++) colors[i] = (Color){ GetRandomValue(100, 250), GetRandomValue(50, 150), GetRandomValue(10, 100), 255 };
         }
-        
+
         // Update virtual mouse (clamped mouse value behind game screen)
         Vector2 mouse = GetMousePosition();
         Vector2 virtualMouse = { 0 };
         virtualMouse.x = (mouse.x - (GetScreenWidth() - (gameScreenWidth*scale))*0.5f)/scale;
         virtualMouse.y = (mouse.y - (GetScreenHeight() - (gameScreenHeight*scale))*0.5f)/scale;
-        virtualMouse = ClampValue(virtualMouse, (Vector2){ 0, 0 }, (Vector2){ gameScreenWidth, gameScreenHeight }); 
+        virtualMouse = ClampValue(virtualMouse, (Vector2){ 0, 0 }, (Vector2){ gameScreenWidth, gameScreenHeight });
 
         // Apply the same transformation as the virtual mouse to the real mouse (i.e. to work with raygui)
         //SetMouseOffset(-(GetScreenWidth() - (gameScreenWidth*scale))*0.5f, -(GetScreenHeight() - (gameScreenHeight*scale))*0.5f);
@@ -90,7 +90,7 @@ int main(void)
                 for (int i = 0; i < 10; i++) DrawRectangle(0, (gameScreenHeight/10)*i, gameScreenWidth, gameScreenHeight/10, colors[i]);
 
                 DrawText("If executed inside a window,\nyou can resize the window,\nand see the screen scaling!", 10, 25, 20, WHITE);
-                
+
                 DrawText(TextFormat("Default Mouse: [%i , %i]", (int)mouse.x, (int)mouse.y), 350, 25, 20, GREEN);
                 DrawText(TextFormat("Virtual Mouse: [%i , %i]", (int)virtualMouse.x, (int)virtualMouse.y), 350, 55, 20, YELLOW);