REVIEWED: examples: Replace TABS and Remove trailing spaces

examples/audio/audio_fft_spectrum_visualizer.c

@@ -86,7 +86,7 @@ int main(void)
     Vector2 iResolution = { (float)screenWidth, (float)screenHeight };
 
     Shader shader = LoadShader(0, TextFormat("resources/shaders/glsl%i/fft.fs", GLSL_VERSION));
-    
+
     int iResolutionLocation = GetShaderLocation(shader, "iResolution");
     int iChannel0Location = GetShaderLocation(shader, "iChannel0");
     SetShaderValue(shader, iResolutionLocation, &iResolution, SHADER_UNIFORM_VEC2);
@@ -153,16 +153,16 @@ int main(void)
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-            
+
             BeginShaderMode(shader);
                 SetShaderValueTexture(shader, iChannel0Location, fftTexture);
                 DrawTextureRec(bufferA.texture,
                     (Rectangle){ 0, 0, (float)screenWidth, (float)-screenHeight },
                     (Vector2){ 0, 0 }, WHITE);
             EndShaderMode();
-            
+
         EndDrawing();
         //------------------------------------------------------------------------------
     }

examples/core/core_compute_hash.c

@@ -64,7 +64,7 @@ int main(void)
 
             // Encode data to Base64 string (includes NULL terminator), memory must be MemFree()
             base64Text = EncodeDataBase64((unsigned char *)textInput, textInputLen, &base64TextSize);
-            
+
             hashCRC32 = ComputeCRC32((unsigned char *)textInput, textInputLen);     // Compute CRC32 hash code (4 bytes)
             hashMD5 = ComputeMD5((unsigned char *)textInput, textInputLen);         // Compute MD5 hash code, returns static int[4] (16 bytes)
             hashSHA1 = ComputeSHA1((unsigned char *)textInput, textInputLen);       // Compute SHA1 hash code, returns static int[5] (20 bytes)

examples/core/core_delta_time.c

@@ -59,7 +59,7 @@ int main(void)
         // GetFrameTime() returns the time it took to draw the last frame, in seconds (usually called delta time)
         // Uses the delta time to make the circle look like it's moving at a "consistent" speed regardless of FPS
 
-        // Multiply by 6.0 (an arbitrary value) in order to make the speed 
+        // Multiply by 6.0 (an arbitrary value) in order to make the speed
         // visually closer to the other circle (at 60 fps), for comparison
         deltaCircle.x += GetFrameTime()*6.0f*speed;
         // This circle can move faster or slower visually depending on the FPS
@@ -68,7 +68,7 @@ int main(void)
         // If either circle is off the screen, reset it back to the start
         if (deltaCircle.x > screenWidth) deltaCircle.x = 0;
         if (frameCircle.x > screenWidth) frameCircle.x = 0;
-        
+
         // Reset both circles positions
         if (IsKeyPressed(KEY_R))
         {

examples/core/core_input_actions.c

@@ -17,7 +17,7 @@
 
 // Simple example for decoding input as actions, allowing remapping of input to different keys or gamepad buttons
 // For example instead of using `IsKeyDown(KEY_LEFT)`, you can use `IsActionDown(ACTION_LEFT)`
-// which can be reassigned to e.g. KEY_A and also assigned to a gamepad button. the action will trigger with either gamepad or keys 
+// which can be reassigned to e.g. KEY_A and also assigned to a gamepad button. the action will trigger with either gamepad or keys
 
 #include "raylib.h"
 
@@ -44,7 +44,7 @@ typedef struct ActionInput {
 // Global Variables Definition
 //----------------------------------------------------------------------------------
 static int gamepadIndex = 0; // Gamepad default index
-static ActionInput actionInputs[MAX_ACTION] = { 0 }; 
+static ActionInput actionInputs[MAX_ACTION] = { 0 };
 
 //----------------------------------------------------------------------------------
 // Module Functions Declaration
@@ -67,15 +67,15 @@ int main(void)
     const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [core] example - input actions");
-    
-    // Set default actions 
+
+    // Set default actions
     char actionSet = 0;
     SetActionsDefault();
     bool releaseAction = false;
 
     Vector2 position = (Vector2){ 400.0f, 200.0f };
     Vector2 size = (Vector2){ 40.0f, 40.0f };
-    
+
     SetTargetFPS(60);
     //--------------------------------------------------------------------------------------
 
@@ -85,7 +85,7 @@ int main(void)
         // Update
         //----------------------------------------------------------------------------------
         gamepadIndex = 0; //  Set gamepad being checked
-        
+
         if (IsActionDown(ACTION_UP)) position.y -= 2;
         if (IsActionDown(ACTION_DOWN)) position.y += 2;
         if (IsActionDown(ACTION_LEFT)) position.x -= 2;
@@ -95,12 +95,12 @@ int main(void)
             position.x = (screenWidth-size.x)/2;
             position.y = (screenHeight-size.y)/2;
         }
-        
+
         // Register release action for one frame
         releaseAction = false;
         if (IsActionReleased(ACTION_FIRE)) releaseAction = true;
 
-        // Switch control scheme by pressing TAB 
+        // Switch control scheme by pressing TAB
         if (IsKeyPressed(KEY_TAB))
         {
             actionSet = !actionSet;
@@ -116,7 +116,7 @@ int main(void)
             ClearBackground(GRAY);
 
             DrawRectangleV(position, size, releaseAction? BLUE : RED);
-            
+
             DrawText((actionSet == 0)? "Current input set: WASD (default)" : "Current input set: Cursor", 10, 10, 20, WHITE);
             DrawText("Use TAB key to toggles Actions keyset", 10, 50, 20, GREEN);
 
@@ -140,9 +140,9 @@ int main(void)
 static bool IsActionPressed(int action)
 {
     bool result = false;
-    
+
     if (action < MAX_ACTION) result = (IsKeyPressed(actionInputs[action].key) || IsGamepadButtonPressed(gamepadIndex, actionInputs[action].button));
-    
+
     return result;
 }
 
@@ -151,20 +151,20 @@ static bool IsActionPressed(int action)
 static bool IsActionReleased(int action)
 {
     bool result = false;
-    
+
     if (action < MAX_ACTION) result = (IsKeyReleased(actionInputs[action].key) || IsGamepadButtonReleased(gamepadIndex, actionInputs[action].button));
-    
+
     return result;
 }
 
 // Check action key/button down
 // NOTE: Combines key down and gamepad button down in one action
-static bool IsActionDown(int action) 
+static bool IsActionDown(int action)
 {
     bool result = false;
-    
+
     if (action < MAX_ACTION) result = (IsKeyDown(actionInputs[action].key) || IsGamepadButtonDown(gamepadIndex, actionInputs[action].button));
-    
+
     return result;
 }
 

examples/core/core_input_gamepad.c

@@ -50,7 +50,7 @@ int main(void)
     const float rightStickDeadzoneY = 0.1f;
     const float leftTriggerDeadzone = -0.9f;
     const float rightTriggerDeadzone = -0.9f;
-    
+
     Rectangle vibrateButton = { 0 };
 
     SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
@@ -97,7 +97,7 @@ int main(void)
                 if (leftTrigger < leftTriggerDeadzone) leftTrigger = -1.0f;
                 if (rightTrigger < rightTriggerDeadzone) rightTrigger = -1.0f;
 
-                if ((TextFindIndex(TextToLower(GetGamepadName(gamepad)), XBOX_ALIAS_1) > -1) || 
+                if ((TextFindIndex(TextToLower(GetGamepadName(gamepad)), XBOX_ALIAS_1) > -1) ||
                     (TextFindIndex(TextToLower(GetGamepadName(gamepad)), XBOX_ALIAS_2) > -1))
                 {
                     DrawTexture(texXboxPad, 0, 0, DARKGRAY);

examples/core/core_input_gestures.c

@@ -118,6 +118,6 @@ int main(void)
     //--------------------------------------------------------------------------------------
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
-    
+
     return 0;
 }

examples/core/core_input_virtual_controls.c

@@ -6,7 +6,7 @@
 *
 *   Example originally created with raylib 5.0, last time updated with raylib 5.0
 *
-*   Example contributed by GreenSnakeLinux (@GreenSnakeLinux), 
+*   Example contributed by GreenSnakeLinux (@GreenSnakeLinux),
 *   reviewed by Ramon Santamaria (@raysan5), oblerion (@oblerion) and danilwhale (@danilwhale)
 *
 *   Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
@@ -86,7 +86,7 @@ int main(void)
         pressedButton = BUTTON_NONE;
 
         // Make sure user is pressing left mouse button if they're from desktop
-        if ((GetTouchPointCount() > 0) || 
+        if ((GetTouchPointCount() > 0) ||
             ((GetTouchPointCount() == 0) && IsMouseButtonDown(MOUSE_BUTTON_LEFT)))
         {
             // Find nearest D-Pad button to the input position
@@ -113,7 +113,7 @@ int main(void)
             default: break;
         };
         //--------------------------------------------------------------------------
-        
+
         // Draw
         //--------------------------------------------------------------------------
         BeginDrawing();

examples/core/core_monitor_detector.c

@@ -66,25 +66,25 @@ int main(void)
         for (int i = 0; i < monitorCount; i++)
         {
             monitors[i] = (MonitorInfo){
-                GetMonitorPosition(i), 
-                GetMonitorName(i), 
+                GetMonitorPosition(i),
+                GetMonitorName(i),
                 GetMonitorWidth(i),
                 GetMonitorHeight(i),
                 GetMonitorPhysicalWidth(i),
                 GetMonitorPhysicalHeight(i),
                 GetMonitorRefreshRate(i)
             };
-            
+
             if (monitors[i].position.x < monitorOffsetX) monitorOffsetX = -(int)monitors[i].position.x;
 
             const int width = (int)monitors[i].position.x + monitors[i].width;
             const int height = (int)monitors[i].position.y + monitors[i].height;
-            
+
             if (maxWidth < width) maxWidth = width;
             if (maxHeight < height) maxHeight = height;
         }
 
-        if (IsKeyPressed(KEY_ENTER) && (monitorCount > 1)) 
+        if (IsKeyPressed(KEY_ENTER) && (monitorCount > 1))
         {
             currentMonitorIndex += 1;
 
@@ -95,8 +95,8 @@ int main(void)
         }
         else currentMonitorIndex = GetCurrentMonitor(); // Get currentMonitorIndex if manually moved
 
-        float monitorScale = 0.6f; 
-        
+        float monitorScale = 0.6f;
+
         if (maxHeight > (maxWidth + monitorOffsetX)) monitorScale *= ((float)screenHeight/(float)maxHeight);
         else monitorScale *= ((float)screenWidth/(float)(maxWidth + monitorOffsetX));
         //----------------------------------------------------------------------------------
@@ -125,9 +125,9 @@ int main(void)
                 // Draw monitor name and information inside the rectangle
                 DrawText(TextFormat("[%i] %s", i, monitors[i].name), (int)rec.x + 10, (int)rec.y + (int)(100*monitorScale), (int)(120*monitorScale), BLUE);
                 DrawText(
-                    TextFormat("Resolution: [%ipx x %ipx]\nRefreshRate: [%ihz]\nPhysical Size: [%imm x %imm]\nPosition: %3.0f x %3.0f", 
-                        monitors[i].width, 
-                        monitors[i].height, 
+                    TextFormat("Resolution: [%ipx x %ipx]\nRefreshRate: [%ihz]\nPhysical Size: [%imm x %imm]\nPosition: %3.0f x %3.0f",
+                        monitors[i].width,
+                        monitors[i].height,
                         monitors[i].refreshRate,
                         monitors[i].physicalWidth,
                         monitors[i].physicalHeight,

examples/core/core_undo_redo.c

@@ -22,7 +22,7 @@
 
 #define MAX_UNDO_STATES             26      // Maximum undo states supported for the ring buffer
 
-#define GRID_CELL_SIZE              24      
+#define GRID_CELL_SIZE              24
 #define MAX_GRID_CELLS_X            30
 #define MAX_GRID_CELLS_Y            13
 
@@ -57,7 +57,7 @@ int main(void)
     //--------------------------------------------------------------------------------------
     const int screenWidth = 800;
     const int screenHeight = 450;
-    
+
     // We have multiple options to implement an Undo/Redo system
     // Probably the most professional one is using the Command pattern to
     // define Actions and store those actions into an array as the events happen,

examples/core/core_viewport_scaling.c

@@ -20,7 +20,7 @@
 // For itteration purposes and teaching example
 #define RESOLUTION_COUNT 4
 
-enum ViewportType 
+enum ViewportType
 {
     // Only upscale, useful for pixel art
     KEEP_ASPECT_INTEGER,
@@ -113,7 +113,7 @@ int main(void)
         }
         Vector2 mousePosition = GetMousePosition();
         bool mousePressed = IsMouseButtonPressed(MOUSE_BUTTON_LEFT);
-        
+
         // Check buttons and rescale
         if (CheckCollisionPointRec(mousePosition, decreaseResolutionButton) && mousePressed){
             resolutionIndex = (resolutionIndex + RESOLUTION_COUNT - 1) % RESOLUTION_COUNT;

examples/models/models_directional_billboard.c

@@ -62,7 +62,7 @@ int main(void)
         anim_timer += GetFrameTime();
 
         // Update frame index after a certain amount of time (half a second)
-        if (anim_timer > 0.5f) 
+        if (anim_timer > 0.5f)
         {
             anim_timer = 0.0f;
             anim += 1;

examples/models/models_loading_vox.c

@@ -35,122 +35,122 @@
 //------------------------------------------------------------------------------------
 int main(void)
 {
-	// Initialization
-	//--------------------------------------------------------------------------------------
-	const int screenWidth = 800;
-	const int screenHeight = 450;
-
-	const char *voxFileNames[] = {
-		"resources/models/vox/chr_knight.vox",
-		"resources/models/vox/chr_sword.vox",
-		"resources/models/vox/monu9.vox",
-		"resources/models/vox/fez.vox"
-	};
-
-	InitWindow(screenWidth, screenHeight, "raylib [models] example - loading vox");
-
-	// Define the camera to look into our 3d world
-	Camera camera = { 0 };
-	camera.position = (Vector3){ 10.0f, 10.0f, 10.0f }; // Camera position
-	camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };      // Camera looking at point
-	camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };          // Camera up vector (rotation towards target)
-	camera.fovy = 45.0f;                                // Camera field-of-view Y
-	camera.projection = CAMERA_PERSPECTIVE;             // Camera projection type
-
-	// Load MagicaVoxel files
-	Model models[MAX_VOX_FILES] = { 0 };
-
-	for (int i = 0; i < MAX_VOX_FILES; i++)
-	{
-		// Load VOX file and measure time
-		double t0 = GetTime()*1000.0;
-		models[i] = LoadModel(voxFileNames[i]);
-		double t1 = GetTime()*1000.0;
-
-		TraceLog(LOG_INFO, TextFormat("[%s] Model file loaded in %.3f ms", voxFileNames[i], t1 - t0));
-
-		// Compute model translation matrix to center model on draw position (0, 0 , 0)
-		BoundingBox bb = GetModelBoundingBox(models[i]);
-		Vector3 center = { 0 };
-		center.x = bb.min.x + (((bb.max.x - bb.min.x)/2));
-		center.z = bb.min.z + (((bb.max.z - bb.min.z)/2));
-
-		Matrix matTranslate = MatrixTranslate(-center.x, 0, -center.z);
-		models[i].transform = matTranslate;
-	}
-
-	int currentModel = 0;
-	Vector3 modelpos = { 0 };
-	Vector3 camerarot = { 0 };
-
-	// Load voxel shader
-	Shader shader = LoadShader(TextFormat("resources/shaders/glsl%i/voxel_lighting.vs", GLSL_VERSION),
-		TextFormat("resources/shaders/glsl%i/voxel_lighting.fs", GLSL_VERSION));
-
-	// Get some required shader locations
-	shader.locs[SHADER_LOC_VECTOR_VIEW] = GetShaderLocation(shader, "viewPos");
-	// NOTE: "matModel" location name is automatically assigned on shader loading,
-	// no need to get the location again if using that uniform name
-	//shader.locs[SHADER_LOC_MATRIX_MODEL] = GetShaderLocation(shader, "matModel");
-
-	// Ambient light level (some basic lighting)
-	int ambientLoc = GetShaderLocation(shader, "ambient");
-	SetShaderValue(shader, ambientLoc, (float[4]) { 0.1f, 0.1f, 0.1f, 1.0f }, SHADER_UNIFORM_VEC4);
-
-	// Assign out lighting shader to model
-	for (int i = 0; i < MAX_VOX_FILES; i++)
-	{
-		for (int j = 0; j < models[i].materialCount; j++) models[i].materials[j].shader = shader;
-	}
-
-	// Create lights
-	Light lights[MAX_LIGHTS] = { 0 };
-	lights[0] = CreateLight(LIGHT_POINT, (Vector3) { -20, 20, -20 }, Vector3Zero(), GRAY, shader);
-	lights[1] = CreateLight(LIGHT_POINT, (Vector3) { 20, -20, 20 }, Vector3Zero(), GRAY, shader);
-	lights[2] = CreateLight(LIGHT_POINT, (Vector3) { -20, 20, 20 }, Vector3Zero(), GRAY, shader);
-	lights[3] = CreateLight(LIGHT_POINT, (Vector3) { 20, -20, -20 }, Vector3Zero(), GRAY, shader);
-
-	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
-		//----------------------------------------------------------------------------------
-		if (IsMouseButtonDown(MOUSE_BUTTON_MIDDLE))
-		{
-			const Vector2 mouseDelta = GetMouseDelta();
-			camerarot.x = mouseDelta.x*0.05f;
-			camerarot.y = mouseDelta.y*0.05f;
-		}
-		else
-		{
-			camerarot.x = 0;
-			camerarot.y = 0;
-		}
-
-		UpdateCameraPro(&camera,
-			(Vector3){ (IsKeyDown(KEY_W) || IsKeyDown(KEY_UP))*0.1f - (IsKeyDown(KEY_S) || IsKeyDown(KEY_DOWN))*0.1f, // Move forward-backward
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    const int screenWidth = 800;
+    const int screenHeight = 450;
+
+    const char *voxFileNames[] = {
+        "resources/models/vox/chr_knight.vox",
+        "resources/models/vox/chr_sword.vox",
+        "resources/models/vox/monu9.vox",
+        "resources/models/vox/fez.vox"
+    };
+
+    InitWindow(screenWidth, screenHeight, "raylib [models] example - loading vox");
+
+    // Define the camera to look into our 3d world
+    Camera camera = { 0 };
+    camera.position = (Vector3){ 10.0f, 10.0f, 10.0f }; // Camera position
+    camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };      // Camera looking at point
+    camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };          // Camera up vector (rotation towards target)
+    camera.fovy = 45.0f;                                // Camera field-of-view Y
+    camera.projection = CAMERA_PERSPECTIVE;             // Camera projection type
+
+    // Load MagicaVoxel files
+    Model models[MAX_VOX_FILES] = { 0 };
+
+    for (int i = 0; i < MAX_VOX_FILES; i++)
+    {
+        // Load VOX file and measure time
+        double t0 = GetTime()*1000.0;
+        models[i] = LoadModel(voxFileNames[i]);
+        double t1 = GetTime()*1000.0;
+
+        TraceLog(LOG_INFO, TextFormat("[%s] Model file loaded in %.3f ms", voxFileNames[i], t1 - t0));
+
+        // Compute model translation matrix to center model on draw position (0, 0 , 0)
+        BoundingBox bb = GetModelBoundingBox(models[i]);
+        Vector3 center = { 0 };
+        center.x = bb.min.x + (((bb.max.x - bb.min.x)/2));
+        center.z = bb.min.z + (((bb.max.z - bb.min.z)/2));
+
+        Matrix matTranslate = MatrixTranslate(-center.x, 0, -center.z);
+        models[i].transform = matTranslate;
+    }
+
+    int currentModel = 0;
+    Vector3 modelpos = { 0 };
+    Vector3 camerarot = { 0 };
+
+    // Load voxel shader
+    Shader shader = LoadShader(TextFormat("resources/shaders/glsl%i/voxel_lighting.vs", GLSL_VERSION),
+        TextFormat("resources/shaders/glsl%i/voxel_lighting.fs", GLSL_VERSION));
+
+    // Get some required shader locations
+    shader.locs[SHADER_LOC_VECTOR_VIEW] = GetShaderLocation(shader, "viewPos");
+    // NOTE: "matModel" location name is automatically assigned on shader loading,
+    // no need to get the location again if using that uniform name
+    //shader.locs[SHADER_LOC_MATRIX_MODEL] = GetShaderLocation(shader, "matModel");
+
+    // Ambient light level (some basic lighting)
+    int ambientLoc = GetShaderLocation(shader, "ambient");
+    SetShaderValue(shader, ambientLoc, (float[4]) { 0.1f, 0.1f, 0.1f, 1.0f }, SHADER_UNIFORM_VEC4);
+
+    // Assign out lighting shader to model
+    for (int i = 0; i < MAX_VOX_FILES; i++)
+    {
+        for (int j = 0; j < models[i].materialCount; j++) models[i].materials[j].shader = shader;
+    }
+
+    // Create lights
+    Light lights[MAX_LIGHTS] = { 0 };
+    lights[0] = CreateLight(LIGHT_POINT, (Vector3) { -20, 20, -20 }, Vector3Zero(), GRAY, shader);
+    lights[1] = CreateLight(LIGHT_POINT, (Vector3) { 20, -20, 20 }, Vector3Zero(), GRAY, shader);
+    lights[2] = CreateLight(LIGHT_POINT, (Vector3) { -20, 20, 20 }, Vector3Zero(), GRAY, shader);
+    lights[3] = CreateLight(LIGHT_POINT, (Vector3) { 20, -20, -20 }, Vector3Zero(), GRAY, shader);
+
+    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
+        //----------------------------------------------------------------------------------
+        if (IsMouseButtonDown(MOUSE_BUTTON_MIDDLE))
+        {
+            const Vector2 mouseDelta = GetMouseDelta();
+            camerarot.x = mouseDelta.x*0.05f;
+            camerarot.y = mouseDelta.y*0.05f;
+        }
+        else
+        {
+            camerarot.x = 0;
+            camerarot.y = 0;
+        }
+
+        UpdateCameraPro(&camera,
+            (Vector3){ (IsKeyDown(KEY_W) || IsKeyDown(KEY_UP))*0.1f - (IsKeyDown(KEY_S) || IsKeyDown(KEY_DOWN))*0.1f, // Move forward-backward
                        (IsKeyDown(KEY_D) || IsKeyDown(KEY_RIGHT))*0.1f - (IsKeyDown(KEY_A) || IsKeyDown(KEY_LEFT))*0.1f, // Move right-left
                        0.0f }, // Move up-down
-			camerarot, // Camera rotation
-			GetMouseWheelMove()*-2.0f); // Move to target (zoom)
+            camerarot, // Camera rotation
+            GetMouseWheelMove()*-2.0f); // Move to target (zoom)
 
-		// Cycle between models on mouse click
-		if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT)) currentModel = (currentModel + 1) % MAX_VOX_FILES;
+        // Cycle between models on mouse click
+        if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT)) currentModel = (currentModel + 1) % MAX_VOX_FILES;
 
-		// Update the shader with the camera view vector (points towards { 0.0f, 0.0f, 0.0f })
-		float cameraPos[3] = { camera.position.x, camera.position.y, camera.position.z };
-		SetShaderValue(shader, shader.locs[SHADER_LOC_VECTOR_VIEW], cameraPos, SHADER_UNIFORM_VEC3);
+        // Update the shader with the camera view vector (points towards { 0.0f, 0.0f, 0.0f })
+        float cameraPos[3] = { camera.position.x, camera.position.y, camera.position.z };
+        SetShaderValue(shader, shader.locs[SHADER_LOC_VECTOR_VIEW], cameraPos, SHADER_UNIFORM_VEC3);
 
-		// Update light values (actually, only enable/disable them)
-		for (int i = 0; i < MAX_LIGHTS; i++) UpdateLightValues(shader, lights[i]);
-		//----------------------------------------------------------------------------------
-        
-		// Draw
-		//----------------------------------------------------------------------------------
-		BeginDrawing();
+        // Update light values (actually, only enable/disable them)
+        for (int i = 0; i < MAX_LIGHTS; i++) UpdateLightValues(shader, lights[i]);
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
 
             ClearBackground(RAYWHITE);
 
@@ -175,17 +175,17 @@ int main(void)
             DrawText("- UP-DOWN-LEFT-RIGHT KEYS: MOVE CAMERA", 20, 90, 10, BLUE);
             DrawText(TextFormat("Model file: %s", GetFileName(voxFileNames[currentModel])), 10, 10, 20, GRAY);
 
-		EndDrawing();
-		//----------------------------------------------------------------------------------
-	}
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
 
-	// De-Initialization
-	//--------------------------------------------------------------------------------------
-	// Unload models data (GPU VRAM)
-	for (int i = 0; i < MAX_VOX_FILES; i++) UnloadModel(models[i]);
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    // Unload models data (GPU VRAM)
+    for (int i = 0; i < MAX_VOX_FILES; i++) UnloadModel(models[i]);
 
-	CloseWindow();          // Close window and OpenGL context
-	//--------------------------------------------------------------------------------------
+    CloseWindow();          // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
 
-	return 0;
+    return 0;
 }

examples/models/models_rotating_cube.c

@@ -5,7 +5,7 @@
 *   Example complexity rating: [★☆☆☆] 1/4
 *
 *   Example originally created with raylib 5.6-dev, last time updated with raylib 5.6-dev
-*   
+*
 *   Example contributed by Jopestpe (@jopestpe)
 *
 *   Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
@@ -48,7 +48,7 @@ int main(void)
     model.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = texture;
 
     float rotation = 0.0f;
-    
+
     SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
@@ -59,7 +59,7 @@ int main(void)
         //----------------------------------------------------------------------------------
         rotation += 1.0f;
         //----------------------------------------------------------------------------------
-        
+
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
@@ -67,13 +67,13 @@ int main(void)
             ClearBackground(RAYWHITE);
 
             BeginMode3D(camera);
-            
-                // Draw model defining: position, size, rotation-axis, rotation (degrees), size, and tint-color 
-                DrawModelEx(model, (Vector3){ 0.0f, 0.0f, 0.0f }, (Vector3){ 0.5f, 1.0f, 0.0f }, 
+
+                // Draw model defining: position, size, rotation-axis, rotation (degrees), size, and tint-color
+                DrawModelEx(model, (Vector3){ 0.0f, 0.0f, 0.0f }, (Vector3){ 0.5f, 1.0f, 0.0f },
                     rotation, (Vector3){ 1.0f, 1.0f, 1.0f }, WHITE);
-                    
+
                 DrawGrid(10, 1.0f);
-                
+
             EndMode3D();
 
             DrawFPS(10, 10);

examples/others/easings_testbed.c

@@ -221,7 +221,7 @@ int main(void)
 }
 
 
-// NoEase function, used when "no easing" is selected for any axis 
+// NoEase function, used when "no easing" is selected for any axis
 // It just ignores all parameters besides b
 static float NoEase(float t, float b, float c, float d)
 {

examples/shaders/shaders_ascii_rendering.c

@@ -87,15 +87,15 @@ int main(void)
             DrawTexture(fudesumi, 500, -30, WHITE);
             DrawTextureV(raysan, circlePos, WHITE);
         EndTextureMode();
-        
+
         BeginDrawing();
             ClearBackground(RAYWHITE);
 
             BeginShaderMode(shader);
                 // Draw the scene texture (that we rendered earlier) to the screen
                 // The shader will process every pixel of this texture
-                DrawTextureRec(target.texture, 
-                    (Rectangle){ 0, 0, (float)target.texture.width, (float)-target.texture.height }, 
+                DrawTextureRec(target.texture,
+                    (Rectangle){ 0, 0, (float)target.texture.width, (float)-target.texture.height },
                     (Vector2){ 0, 0 }, WHITE);
             EndShaderMode();
 

examples/shaders/shaders_basic_pbr.c

@@ -242,7 +242,7 @@ int main(void)
                 SetShaderValue(shader, emissiveColorLoc, &carEmissiveColor, SHADER_UNIFORM_VEC4);
                 float emissiveIntensity = 0.01f;
                 SetShaderValue(shader, emissiveIntensityLoc, &emissiveIntensity, SHADER_UNIFORM_FLOAT);
-		
+
                 // Set old car metallic and roughness values
                 SetShaderValue(shader, metallicValueLoc, &car.materials[0].maps[MATERIAL_MAP_METALNESS].value, SHADER_UNIFORM_FLOAT);
                 SetShaderValue(shader, roughnessValueLoc, &car.materials[0].maps[MATERIAL_MAP_ROUGHNESS].value, SHADER_UNIFORM_FLOAT);
@@ -252,7 +252,7 @@ int main(void)
                 // Draw spheres to show the lights positions
                 for (int i = 0; i < MAX_LIGHTS; i++)
                 {
-                    Color lightColor = (Color){ 
+                    Color lightColor = (Color){
                         (unsigned char)(lights[i].color[0]*255),
                         (unsigned char)(lights[i].color[1] * 255),
                         (unsigned char)(lights[i].color[2] * 255),

examples/shaders/shaders_lightmap_rendering.c

@@ -124,7 +124,7 @@ int main(void)
             );
         BeginBlendMode(BLEND_ALPHA);
     EndTextureMode();
-    
+
     // NOTE: To enable trilinear filtering we need mipmaps available for texture
     GenTextureMipmaps(&lightmap.texture);
     SetTextureFilter(lightmap.texture, TEXTURE_FILTER_TRILINEAR);
@@ -143,7 +143,7 @@ int main(void)
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
 
             BeginMode3D(camera);
@@ -155,7 +155,7 @@ int main(void)
                 (Vector2){ 0.0, 0.0 }, 0.0, WHITE);
 
             DrawText(TextFormat("LIGHTMAP: %ix%i pixels", MAP_SIZE, MAP_SIZE), GetRenderWidth() - 130, 20 + MAP_SIZE*8, 10, GREEN);
-            
+
             DrawFPS(10, 10);
 
         EndDrawing();

examples/shaders/shaders_shadowmap_rendering.c

@@ -45,7 +45,7 @@ int main(void)
     // Shadows are a HUGE topic, and this example shows an extremely simple implementation of the shadowmapping algorithm,
     // which is the industry standard for shadows. This algorithm can be extended in a ridiculous number of ways to improve
     // realism and also adapt it for different scenes. This is pretty much the simplest possible implementation
-    
+
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "raylib [shaders] example - shadowmap rendering");
 
@@ -59,7 +59,7 @@ int main(void)
     Shader shadowShader = LoadShader(TextFormat("resources/shaders/glsl%i/shadowmap.vs", GLSL_VERSION),
                                      TextFormat("resources/shaders/glsl%i/shadowmap.fs", GLSL_VERSION));
     shadowShader.locs[SHADER_LOC_VECTOR_VIEW] = GetShaderLocation(shadowShader, "viewPos");
-    
+
     Vector3 lightDir = Vector3Normalize((Vector3){ 0.35f, -1.0f, -0.35f });
     Color lightColor = WHITE;
     Vector4 lightColorNormalized = ColorNormalize(lightColor);
@@ -83,7 +83,7 @@ int main(void)
     ModelAnimation *robotAnimations = LoadModelAnimations("resources/models/robot.glb", &animCount);
 
     RenderTexture2D shadowMap = LoadShadowmapRenderTexture(SHADOWMAP_RESOLUTION, SHADOWMAP_RESOLUTION);
-    
+
     // For the shadowmapping algorithm, we will be rendering everything from the light's point of view
     Camera3D lightCamera = { 0 };
     lightCamera.position = Vector3Scale(lightDir, -15.0f);
@@ -91,9 +91,9 @@ int main(void)
     lightCamera.projection = CAMERA_ORTHOGRAPHIC; // Use an orthographic projection for directional lights
     lightCamera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
     lightCamera.fovy = 20.0f;
-    
+
     int frameCounter = 0;
-    
+
     // Store the light matrices
     Matrix lightView = { 0 };
     Matrix lightProj = { 0 };
@@ -136,7 +136,7 @@ int main(void)
         {
             if (lightDir.z > -0.6f) lightDir.z -= cameraSpeed*60.0f*deltaTime;
         }
-        
+
         lightDir = Vector3Normalize(lightDir);
         lightCamera.position = Vector3Scale(lightDir, -15.0f);
         SetShaderValue(shadowShader, lightDirLoc, &lightDir, SHADER_UNIFORM_VEC3);
@@ -151,13 +151,13 @@ int main(void)
         // to determine whether a given point is "visible" to the light
         BeginTextureMode(shadowMap);
             ClearBackground(WHITE);
-            
+
             BeginMode3D(lightCamera);
                 lightView = rlGetMatrixModelview();
                 lightProj = rlGetMatrixProjection();
                 DrawScene(cube, robot);
             EndMode3D();
-            
+
         EndTextureMode();
         lightViewProj = MatrixMultiply(lightView, lightProj);
 
@@ -167,7 +167,7 @@ int main(void)
 
             SetShaderValueMatrix(shadowShader, lightVPLoc, lightViewProj);
             rlEnableShader(shadowShader.id);
-            
+
             rlActiveTextureSlot(textureActiveSlot);
             rlEnableTexture(shadowMap.depth.id);
             rlSetUniform(shadowMapLoc, &textureActiveSlot, SHADER_UNIFORM_INT, 1);
@@ -178,7 +178,7 @@ int main(void)
 
             DrawText("Use the arrow keys to rotate the light!", 10, 10, 30, RED);
             DrawText("Shadows in raylib using the shadowmapping algorithm!", screenWidth - 280, screenHeight - 20, 10, GRAY);
-            
+
         EndDrawing();
 
         if (IsKeyPressed(KEY_F)) TakeScreenshot("shaders_shadowmap.png");
@@ -200,7 +200,7 @@ int main(void)
 }
 
 // Load render texture for shadowmap projection
-// NOTE: Load framebuffer with only a texture depth attachment, 
+// NOTE: Load framebuffer with only a texture depth attachment,
 // no color attachment required for shadowmap
 static RenderTexture2D LoadShadowmapRenderTexture(int width, int height)
 {

examples/shaders/shaders_spotlight_rendering.c

@@ -239,7 +239,7 @@ int main(void)
 static void ResetStar(Star *star)
 {
     star->position = (Vector2){ GetScreenWidth()/2.0f, GetScreenHeight()/2.0f };
-    
+
     star->speed.x = (float)GetRandomValue(-1000, 1000)/100.0f;
     star->speed.y = (float)GetRandomValue(-1000, 1000)/100.0f;
 
@@ -247,7 +247,7 @@ static void ResetStar(Star *star)
     {
         star->speed.x = (float)GetRandomValue(-1000, 1000)/100.0f;
         star->speed.y = (float)GetRandomValue(-1000, 1000)/100.0f;
-    } 
+    }
 
     star->position = Vector2Add(star->position, Vector2Multiply(star->speed, (Vector2){ 8.0f, 8.0f }));
 }

examples/shapes/shapes_bouncing_ball.c

@@ -7,7 +7,7 @@
 *   Example originally created with raylib 2.5, last time updated with raylib 2.5
 *
 *   Example contributed by Ramon Santamaria (@raysan5), reviewed by Jopestpe (@jopestpe)
-* 
+*
 *   Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
 *   BSD-like license that allows static linking with closed source software
 *
@@ -49,14 +49,14 @@ int main(void)
         //-----------------------------------------------------
         if (IsKeyPressed(KEY_G)) useGravity = !useGravity;
         if (IsKeyPressed(KEY_SPACE)) pause = !pause;
-        
+
         if (!pause)
         {
             ballPosition.x += ballSpeed.x;
             ballPosition.y += ballSpeed.y;
 
             if (useGravity) ballSpeed.y += gravity;
-            
+
             // Check walls collision for bouncing
             if ((ballPosition.x >= (GetScreenWidth() - ballRadius)) || (ballPosition.x <= ballRadius)) ballSpeed.x *= -1.0f;
             if ((ballPosition.y >= (GetScreenHeight() - ballRadius)) || (ballPosition.y <= ballRadius)) ballSpeed.y *= -0.95f;
@@ -72,7 +72,7 @@ int main(void)
 
             DrawCircleV(ballPosition, (float)ballRadius, MAROON);
             DrawText("PRESS SPACE to PAUSE BALL MOVEMENT", 10, GetScreenHeight() - 25, 20, LIGHTGRAY);
-            
+
             if (useGravity) DrawText("GRAVITY: ON (Press G to disable)", 10, GetScreenHeight() - 50, 20, DARKGREEN);
             else DrawText("GRAVITY: OFF (Press G to enable)", 10, GetScreenHeight() - 50, 20, RED);
 
@@ -80,7 +80,7 @@ int main(void)
             if (pause && ((framesCounter/30)%2)) DrawText("PAUSED", 350, 200, 30, GRAY);
 
             DrawFPS(10, 10);
-            
+
         EndDrawing();
         //-----------------------------------------------------
     }

examples/shapes/shapes_clock_of_clocks.c

@@ -35,14 +35,14 @@ int main(void)
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - clock of clocks");
-    
+
     const Color bgColor = ColorLerp(DARKBLUE, BLACK, 0.75f);
     const Color handsColor = ColorLerp(YELLOW, RAYWHITE, .25f);
-    
+
     const float clockFaceSize = 24;
     const float clockFaceSpacing = 8.0f;
     const float sectionSpacing = 16.0f;
-    
+
     const Vector2 TL = (Vector2){   0.0f,  90.0f }; // Top-left corner
     const Vector2 TR = (Vector2){  90.0f, 180.0f }; // Top-right corner
     const Vector2 BR = (Vector2){ 180.0f, 270.0f }; // Bottom-right corner
@@ -50,7 +50,7 @@ int main(void)
     const Vector2 HH = (Vector2){   0.0f, 180.0f }; // Horizontal line
     const Vector2 VV = (Vector2){  90.0f, 270.0f }; // Vertical line
     const Vector2 ZZ = (Vector2){ 135.0f, 135.0f }; // Not relevant
-    
+
     const Vector2 digitAngles[10][24] = {
         /* 0 */ { TL,HH,HH,TR, /* */ VV,TL,TR,VV,/* */ VV,VV,VV,VV,/* */ VV,VV,VV,VV,/* */ VV,BL,BR,VV,/* */ BL,HH,HH,BR },
         /* 1 */ { TL,HH,TR,ZZ, /* */ BL,TR,VV,ZZ,/* */ ZZ,VV,VV,ZZ,/* */ ZZ,VV,VV,ZZ,/* */ TL,BR,BL,TR,/* */ BL,HH,HH,BR },
@@ -65,21 +65,21 @@ int main(void)
     };
     // Time for the hands to move to the new position (in seconds); this must be <1s
     const float handsMoveDuration = .5f;
-    
+
     // We store the previous seconds value so we can see if the time has changed
     int prevSeconds = -1;
-    
+
     // This represents the real position where the hands are right now
     Vector2 currentAngles[6][24] = { 0 };
-    
+
     // This is the position where the hands were moving from
     Vector2 srcAngles[6][24] = { 0 };
     // This is the position where the hands are moving to
     Vector2 dstAngles[6][24] = { 0 };
-    
+
     // Current animation timer
     float handsMoveTimer = 0.0f;
-    
+
     // 12 or 24 hour mode
     int hourMode = 24;
 
@@ -91,32 +91,32 @@ int main(void)
     {
         // Update
         //----------------------------------------------------------------------------------
-        
+
         // Get the current time
         time_t rawtime;
         struct tm *timeinfo;
 
         time(&rawtime);
         timeinfo = localtime(&rawtime);
-        
+
         if (timeinfo->tm_sec != prevSeconds) {
             // The time has changed, so we need to move the hands to the new positions
             prevSeconds = timeinfo->tm_sec;
-        
+
             // Format the current time so we can access the individual digits
             const char *clockDigits = TextFormat("%02d%02d%02d", timeinfo->tm_hour % hourMode, timeinfo->tm_min, timeinfo->tm_sec);
-        
+
             // Fetch where we want all the hands to be
             for (int digit = 0; digit < 6; digit++) {
                 for (int cell = 0; cell < 24; cell++) {
                     srcAngles[digit][cell] = currentAngles[digit][cell];
                     dstAngles[digit][cell] = digitAngles[ clockDigits[digit] - '0' ][cell];
-                    
+
                     // Quick exception for 12h mode
                     if (digit == 0 && hourMode == 12 && clockDigits[0] == '0') {
                         dstAngles[digit][cell] = ZZ;
                     }
-                    
+
                     if (srcAngles[digit][cell].x > dstAngles[digit][cell].x) {
                         srcAngles[digit][cell].x -= 360.0f;
                     }
@@ -125,43 +125,43 @@ int main(void)
                     }
                 }
             }
-            
+
             // Reset the timer
             handsMoveTimer = -GetFrameTime();
         }
-        
+
         // Now let's animate all the hands if we need to
         if (handsMoveTimer < handsMoveDuration) {
             // Increase the timer but don't go above the maximum
             handsMoveTimer = Clamp(handsMoveTimer + GetFrameTime(), 0, handsMoveDuration);
-            
+
             // Calculate the % completion of the animation
             float t = handsMoveTimer / handsMoveDuration;
-            
+
             // A little cheeky smoothstep
             t = t * t * (3.0f - 2.0f * t);
-            
+
             for (int digit = 0; digit < 6; digit++) {
                 for (int cell = 0; cell < 24; cell++) {
                     currentAngles[digit][cell].x = Lerp(srcAngles[digit][cell].x, dstAngles[digit][cell].x, t);
                     currentAngles[digit][cell].y = Lerp(srcAngles[digit][cell].y, dstAngles[digit][cell].y, t);
                 }
             }
-            
+
             if (handsMoveTimer == handsMoveDuration) {
                 // The animation has now finished
             }
         }
-        
+
         // Handle input
-        
+
         // Toggle between 12 and 24 hour mode with space
         if (IsKeyPressed(KEY_SPACE)) {
             hourMode = 36 - hourMode;
         }
-        
-        
-        
+
+
+
         //----------------------------------------------------------------------------------
 
         // Draw
@@ -169,13 +169,13 @@ int main(void)
         BeginDrawing();
 
             ClearBackground(bgColor);
-            
+
             DrawText(TextFormat("%d-h mode, space to change", hourMode), 10, 30, 20, RAYWHITE);
-            
+
             float xOffset = 4.0f;
-            
+
             for (int digit = 0; digit < 6; digit++) {
-            
+
                 for (int row = 0; row < 6; row++) {
                     for (int col = 0; col < 4; col++) {
                         Vector2 centre = (Vector2){
@@ -183,7 +183,7 @@ int main(void)
                             100 + row*(clockFaceSize+clockFaceSpacing) + clockFaceSize * .5f
                         };
                         DrawRing(centre, clockFaceSize * 0.5f - 2.0f, clockFaceSize * 0.5f, 0, 360, 24, DARKGRAY);
-                        
+
                         // Big hand
                         DrawRectanglePro(
                             (Rectangle){centre.x, centre.y, clockFaceSize*.5f+4.0f, 4.0f},
@@ -191,7 +191,7 @@ int main(void)
                             currentAngles[digit][row*4+col].x,
                             handsColor
                         );
-                        
+
                         // Little hand
                         DrawRectanglePro(
                             (Rectangle){centre.x, centre.y, clockFaceSize*.5f+2.0f, 4.0f},
@@ -201,20 +201,20 @@ int main(void)
                         );
                     }
                 }
-                
+
                 xOffset += (clockFaceSize+clockFaceSpacing) * 4;
                 if (digit % 2 == 1) {
-                    
+
                     DrawRing((Vector2){xOffset + 4.0f, 160.0f}, 6.0f, 8.0f, 0.0f, 360.0f, 24, handsColor);
                     DrawRing((Vector2){xOffset + 4.0f, 225.0f}, 6.0f, 8.0f, 0.0f, 360.0f, 24, handsColor);
-                    
+
                     xOffset += sectionSpacing;
-                    
+
                 }
             }
-            
+
             DrawFPS(10, 10);
-            
+
 
         EndDrawing();
         //----------------------------------------------------------------------------------

examples/shapes/shapes_digital_clock.c

@@ -116,7 +116,7 @@ int main(void)
             ClearBackground(RAYWHITE);
 
             // Draw clock in selected mode
-            if (clockMode == CLOCK_ANALOG) DrawClockAnalog(clock, (Vector2){ 400, 240 }); 
+            if (clockMode == CLOCK_ANALOG) DrawClockAnalog(clock, (Vector2){ 400, 240 });
             else if (clockMode == CLOCK_DIGITAL)
             {
                 DrawClockDigital(clock, (Vector2){ 30, 60 });
@@ -128,7 +128,7 @@ int main(void)
                 DrawText(clockTime, GetScreenWidth()/2 - MeasureText(clockTime, 150)/2, 300, 150, BLACK);
             }
 
-            DrawText(TextFormat("Press [SPACE] to switch clock mode: %s", 
+            DrawText(TextFormat("Press [SPACE] to switch clock mode: %s",
                 (clockMode == CLOCK_DIGITAL)? "DIGITAL CLOCK" : "ANALOGUE CLOCK"), 10, 10, 20, DARKGRAY);
 
         EndDrawing();
@@ -183,13 +183,13 @@ static void DrawClockAnalog(Clock clock, Vector2 position)
         // Draw clock minutes/seconds lines
         for (int i = 0; i < 60; i++)
         {
-            DrawLineEx((Vector2){ position.x + (clock.second.length + ((i%5)? 10 : 6))*cosf((6.0f*i - 90.0f)*DEG2RAD), 
-                position.y + (clock.second.length + ((i%5)? 10 : 6))*sinf((6.0f*i - 90.0f)*DEG2RAD) }, 
-                (Vector2){ position.x + (clock.second.length + 20)*cosf((6.0f*i - 90.0f)*DEG2RAD), 
+            DrawLineEx((Vector2){ position.x + (clock.second.length + ((i%5)? 10 : 6))*cosf((6.0f*i - 90.0f)*DEG2RAD),
+                position.y + (clock.second.length + ((i%5)? 10 : 6))*sinf((6.0f*i - 90.0f)*DEG2RAD) },
+                (Vector2){ position.x + (clock.second.length + 20)*cosf((6.0f*i - 90.0f)*DEG2RAD),
                 position.y + (clock.second.length + 20)*sinf((6.0f*i - 90.0f)*DEG2RAD) }, ((i%5)? 1.0f : 3.0f), DARKGRAY);
-            
+
             // Draw seconds numbers
-            //DrawText(TextFormat("%02i", i), centerPosition.x + (clock.second.length + 50)*cosf((6.0f*i - 90.0f)*DEG2RAD) - 10/2, 
+            //DrawText(TextFormat("%02i", i), centerPosition.x + (clock.second.length + 50)*cosf((6.0f*i - 90.0f)*DEG2RAD) - 10/2,
             //    centerPosition.y + (clock.second.length + 50)*sinf((6.0f*i - 90.0f)*DEG2RAD) - 10/2, 10, GRAY);
         }
 
@@ -256,25 +256,25 @@ static void Draw7SDisplay(Vector2 position, char segments, Color colorOn, Color
     float offsetYAdjust = segmentThick*0.3f; // HACK: Adjust gap space between segment limits
 
     // Segment A
-    DrawDisplaySegment((Vector2){ position.x + segmentThick + segmentLen/2.0f, position.y + segmentThick }, 
+    DrawDisplaySegment((Vector2){ position.x + segmentThick + segmentLen/2.0f, position.y + segmentThick },
         segmentLen, segmentThick, false, (segments & 0b00000001)? colorOn : colorOff);
     // Segment B
-    DrawDisplaySegment((Vector2){ position.x + segmentThick + segmentLen + segmentThick/2.0f, position.y + 2*segmentThick + segmentLen/2.0f - offsetYAdjust }, 
+    DrawDisplaySegment((Vector2){ position.x + segmentThick + segmentLen + segmentThick/2.0f, position.y + 2*segmentThick + segmentLen/2.0f - offsetYAdjust },
         segmentLen, segmentThick, true, (segments & 0b00000010)? colorOn : colorOff);
     // Segment C
-    DrawDisplaySegment((Vector2){ position.x + segmentThick + segmentLen + segmentThick/2.0f, position.y + 4*segmentThick + segmentLen + segmentLen/2.0f - 3*offsetYAdjust }, 
+    DrawDisplaySegment((Vector2){ position.x + segmentThick + segmentLen + segmentThick/2.0f, position.y + 4*segmentThick + segmentLen + segmentLen/2.0f - 3*offsetYAdjust },
         segmentLen, segmentThick, true, (segments & 0b00000100)? colorOn : colorOff);
     // Segment D
-    DrawDisplaySegment((Vector2){ position.x + segmentThick + segmentLen/2.0f, position.y + 5*segmentThick + 2*segmentLen - 4*offsetYAdjust }, 
+    DrawDisplaySegment((Vector2){ position.x + segmentThick + segmentLen/2.0f, position.y + 5*segmentThick + 2*segmentLen - 4*offsetYAdjust },
         segmentLen, segmentThick, false, (segments & 0b00001000)? colorOn : colorOff);
     // Segment E
-    DrawDisplaySegment((Vector2){ position.x + segmentThick/2.0f, position.y + 4*segmentThick + segmentLen + segmentLen/2.0f - 3*offsetYAdjust }, 
+    DrawDisplaySegment((Vector2){ position.x + segmentThick/2.0f, position.y + 4*segmentThick + segmentLen + segmentLen/2.0f - 3*offsetYAdjust },
         segmentLen, segmentThick, true, (segments & 0b00010000)? colorOn : colorOff);
     // Segment F
-    DrawDisplaySegment((Vector2){ position.x + segmentThick/2.0f, position.y + 2*segmentThick + segmentLen/2.0f - offsetYAdjust }, 
+    DrawDisplaySegment((Vector2){ position.x + segmentThick/2.0f, position.y + 2*segmentThick + segmentLen/2.0f - offsetYAdjust },
         segmentLen, segmentThick, true, (segments & 0b00100000)? colorOn : colorOff);
     // Segment G
-    DrawDisplaySegment((Vector2){ position.x + segmentThick + segmentLen/2.0f, position.y + 3*segmentThick + segmentLen - 2*offsetYAdjust }, 
+    DrawDisplaySegment((Vector2){ position.x + segmentThick + segmentLen/2.0f, position.y + 3*segmentThick + segmentLen - 2*offsetYAdjust },
         segmentLen, segmentThick, false, (segments & 0b01000000)? colorOn : colorOff);
 }
 

examples/shapes/shapes_kaleidoscope.c

@@ -51,13 +51,13 @@ int main(void)
     Vector2 prevMousePos = { 0 };
     Vector2 scaleVector = { 1.0f, -1.0f };
     Vector2 offset = { (float)screenWidth/2.0f, (float)screenHeight/2.0f };
-    
+
     Camera2D camera = { 0 };
     camera.target = (Vector2){ 0 };
     camera.offset = offset;
     camera.rotation = 0.0f;
     camera.zoom = 1.0f;
-    
+
     int lineCounter = 0;
 
     SetTargetFPS(20);
@@ -70,10 +70,10 @@ int main(void)
         //----------------------------------------------------------------------------------
         prevMousePos = mousePos;
         mousePos = GetMousePosition();
-        
+
         Vector2 lineStart = Vector2Subtract(mousePos, offset);
         Vector2 lineEnd = Vector2Subtract(prevMousePos, offset);
-        
+
         if (IsMouseButtonDown(MOUSE_LEFT_BUTTON))
         {
             for (int s = 0; (s < symmetry) && (lineCounter < (MAX_DRAW_LINES - 1)); s++)
@@ -88,7 +88,7 @@ int main(void)
                 // Store reflective line
                 lines[lineCounter + 1].start = Vector2Multiply(lineStart, scaleVector);
                 lines[lineCounter + 1].end = Vector2Multiply(lineEnd, scaleVector);
-                
+
                 lineCounter += 2;
             }
         }
@@ -97,9 +97,9 @@ int main(void)
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
-    
+
             BeginMode2D(camera);
                 for (int s = 0; s < symmetry; s++)
                 {
@@ -110,10 +110,10 @@ int main(void)
                     }
                 }
             EndMode2D();
-            
+
             DrawText(TextFormat("LINES: %i/%i", lineCounter, MAX_DRAW_LINES), 10, screenHeight - 30, 20, MAROON);
             DrawFPS(10, 10);
-            
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }

examples/shapes/shapes_lines_drawing.c

@@ -16,6 +16,7 @@
 ********************************************************************************************/
 
 #include "raylib.h"
+
 #include "raymath.h"
 
 //------------------------------------------------------------------------------------
@@ -23,122 +24,114 @@
 //------------------------------------------------------------------------------------
 int main(void)
 {
-	// Initialization
-	//--------------------------------------------------------------------------------------
-	const int screenWidth = 800;
-	const int screenHeight = 450;
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
-	InitWindow(screenWidth, screenHeight, "raylib [shapes] example - lines drawing");
+    InitWindow(screenWidth, screenHeight, "raylib [shapes] example - lines drawing");
 
-	// Hint text that shows before you click the screen
-	bool startText = true;
+    // Hint text that shows before you click the screen
+    bool startText = true;
 
-	// The mouse's position on the previous frame
-	Vector2 mousePositionPrevious = GetMousePosition();
+    // The mouse's position on the previous frame
+    Vector2 mousePositionPrevious = GetMousePosition();
 
-	// The canvas to draw lines on
-	RenderTexture canvas = LoadRenderTexture(screenWidth, screenHeight);
+    // The canvas to draw lines on
+    RenderTexture canvas = LoadRenderTexture(screenWidth, screenHeight);
 
-	// The background color of the canvas
-	const Color backgroundColor = RAYWHITE;
+    // The line's thickness
+    float lineThickness = 8.0f;
+    // The lines hue (in HSV, from 0-360)
+    float lineHue = 0.0f;
 
-	// The line's thickness
-	float lineThickness = 8.0f;
-	// The lines hue (in HSV, from 0-360)
-	float lineHue = 0.0f;
+    // Clear the canvas to the background color
+    BeginTextureMode(canvas);
+        ClearBackground(RAYWHITE);
+    EndTextureMode();
 
-	// Clear the canvas to the background color
-	BeginTextureMode(canvas);
-		ClearBackground(backgroundColor);
-	EndTextureMode();
-    
     SetTargetFPS(60);
-	//--------------------------------------------------------------------------------------
-
-	// Main game loop
-	while (!WindowShouldClose())    // Detect window close button or ESC key
-	{
-		// Update
-		//----------------------------------------------------------------------------------
-		// Disable the hint text once the user clicks
-		if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT) && startText) startText = false;
-
-		// Clear the canvas when the user middle-clicks
-		if (IsMouseButtonPressed(MOUSE_BUTTON_MIDDLE))
-		{
-			BeginTextureMode(canvas);
-				ClearBackground(backgroundColor);
-			EndTextureMode();
-		}
-
-		// Store whether the left and right buttons are down
-		bool leftButtonDown = IsMouseButtonDown(MOUSE_BUTTON_LEFT);
-		bool rightButtonDown = IsMouseButtonDown(MOUSE_BUTTON_RIGHT);
-
-		if (leftButtonDown || rightButtonDown)
-		{
-			// The color for the line
-			Color drawColor = WHITE;
-
-			if (leftButtonDown)
-			{
-				// Increase the hue value by the distance our cursor has moved since the last frame (divided by 3)
-				lineHue += Vector2Distance(mousePositionPrevious, GetMousePosition())/3.0f;
-
-				// While the hue is >=360, subtract it to bring it down into the range 0-360
-				// This is more visually accurate than resetting to zero
-				while (lineHue >= 360.0f) lineHue -= 360.0f;
-
-				// Create the final color
-				drawColor = ColorFromHSV(lineHue, 1.0f, 1.0f);
-			}
-			else if (rightButtonDown) 
-			{
-				// Use the background color as an "eraser"
-				drawColor = backgroundColor;
-			}
-
-			// Draw the line onto the canvas
-			BeginTextureMode(canvas);
-            
-				// Circles act as "caps", smoothing corners
-				DrawCircleV(mousePositionPrevious, lineThickness/2.0f, drawColor);
-				DrawCircleV(GetMousePosition(), lineThickness/2.0f, drawColor);
-				DrawLineEx(mousePositionPrevious, GetMousePosition(), lineThickness, drawColor);
-                
-			EndTextureMode();
-		}
-
-		// Update line thickness based on mousewheel
-		lineThickness += GetMouseWheelMove();
-		lineThickness = Clamp(lineThickness, 1.0, 500.0f);
-
-		// Update mouse's previous position
-		mousePositionPrevious = GetMousePosition();
-		//----------------------------------------------------------------------------------
-
-		// Draw
-		//----------------------------------------------------------------------------------
-		BeginDrawing();
-			// Draw the render texture to the screen, flipped vertically to make it appear top-side up
-			DrawTextureRec(canvas.texture, (Rectangle){ 0.0f, 0.0f, (float)canvas.texture.width,(float)-canvas.texture.height }, Vector2Zero(), WHITE);
-
-			// Draw the preview circle
-			if (!leftButtonDown) DrawCircleLinesV(GetMousePosition(), lineThickness/2.0f, (Color){ 127, 127, 127, 127 });
-
-			// Draw the hint text
-			if (startText) DrawText("try clicking and dragging!", 275, 215, 20, LIGHTGRAY);
-		EndDrawing();
-		//----------------------------------------------------------------------------------
-	}
-
-	// De-Initialization
-	//--------------------------------------------------------------------------------------
-	// Unload the canvas render texture
-	UnloadRenderTexture(canvas);
-
-	CloseWindow();        // Close window and OpenGL context
-	//--------------------------------------------------------------------------------------
-
-	return 0;
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        // Disable the hint text once the user clicks
+        if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT) && startText) startText = false;
+
+        // Clear the canvas when the user middle-clicks
+        if (IsMouseButtonPressed(MOUSE_BUTTON_MIDDLE))
+        {
+            BeginTextureMode(canvas);
+                ClearBackground(RAYWHITE);
+            EndTextureMode();
+        }
+
+        // Store whether the left and right buttons are down
+        bool leftButtonDown = IsMouseButtonDown(MOUSE_BUTTON_LEFT);
+        bool rightButtonDown = IsMouseButtonDown(MOUSE_BUTTON_RIGHT);
+
+        if (leftButtonDown || rightButtonDown)
+        {
+            // The color for the line
+            Color drawColor = WHITE;
+
+            if (leftButtonDown)
+            {
+                // Increase the hue value by the distance our cursor has moved since the last frame (divided by 3)
+                lineHue += Vector2Distance(mousePositionPrevious, GetMousePosition())/3.0f;
+
+                // While the hue is >=360, subtract it to bring it down into the range 0-360
+                // This is more visually accurate than resetting to zero
+                while (lineHue >= 360.0f) lineHue -= 360.0f;
+
+                // Create the final color
+                drawColor = ColorFromHSV(lineHue, 1.0f, 1.0f);
+            }
+            else if (rightButtonDown) drawColor = RAYWHITE; // Use the background color as an "eraser"
+
+            // Draw the line onto the canvas
+            BeginTextureMode(canvas);
+                // Circles act as "caps", smoothing corners
+                DrawCircleV(mousePositionPrevious, lineThickness/2.0f, drawColor);
+                DrawCircleV(GetMousePosition(), lineThickness/2.0f, drawColor);
+                DrawLineEx(mousePositionPrevious, GetMousePosition(), lineThickness, drawColor);
+            EndTextureMode();
+        }
+
+        // Update line thickness based on mousewheel
+        lineThickness += GetMouseWheelMove();
+        lineThickness = Clamp(lineThickness, 1.0, 500.0f);
+
+        // Update mouse's previous position
+        mousePositionPrevious = GetMousePosition();
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            // Draw the render texture to the screen, flipped vertically to make it appear top-side up
+            DrawTextureRec(canvas.texture, (Rectangle){ 0.0f, 0.0f, (float)canvas.texture.width,(float)-canvas.texture.height }, Vector2Zero(), WHITE);
+
+            // Draw the preview circle
+            if (!leftButtonDown) DrawCircleLinesV(GetMousePosition(), lineThickness/2.0f, (Color){ 127, 127, 127, 127 });
+
+            // Draw the hint text
+            if (startText) DrawText("try clicking and dragging!", 275, 215, 20, LIGHTGRAY);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadRenderTexture(canvas); // Unload the canvas render texture
+
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
 }

examples/shapes/shapes_math_sine_cosine.c

@@ -35,7 +35,7 @@ int main(void)
     const int screenWidth = 800;
     const int screenHeight = 450;
 
-    SetConfigFlags(FLAG_MSAA_4X_HINT); 
+    SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - math sine cosine");
 
     Vector2 sinePoints[WAVE_POINTS];
@@ -97,7 +97,7 @@ int main(void)
 
             // Base circle and axes
             DrawCircleLinesV(center, radius, GRAY);
-            DrawLineEx((Vector2){ center.x, limitMin.y }, (Vector2){ center.x, limitMax.y }, 1.0f, GRAY);      
+            DrawLineEx((Vector2){ center.x, limitMin.y }, (Vector2){ center.x, limitMax.y }, 1.0f, GRAY);
             DrawLineEx((Vector2){ limitMin.x, center.y }, (Vector2){ limitMax.x, center.y }, 1.f, GRAY);
 
             // Wave graph axes
@@ -110,17 +110,17 @@ int main(void)
             DrawText("0", start.x - 8,  start.y + start.height/2 - 6, 6, GRAY);
             DrawText("-1", start.x - 12, start.y + start.height - 8, 6, GRAY);
             DrawText("0", start.x - 2,  start.y + start.height + 4, 6, GRAY);
-            DrawText("360", start.x + start.width - 8,  start.y + start.height + 4, 6, GRAY);  
+            DrawText("360", start.x + start.width - 8,  start.y + start.height + 4, 6, GRAY);
 
             // Sine (red - vertical)
-            DrawLineEx((Vector2){ center.x, center.y }, (Vector2){ center.x, point.y }, 2.0f, RED);  
+            DrawLineEx((Vector2){ center.x, center.y }, (Vector2){ center.x, point.y }, 2.0f, RED);
             DrawLineDashed((Vector2){ point.x, center.y }, (Vector2){ point.x, point.y }, 10.0f, 4.0f, RED);
             DrawText(TextFormat("Sine %.2f", sinRad), 640, 190, 6, RED);
             DrawCircleV((Vector2){ start.x + (angle/360.0f)*start.width, start.y + ((-sinRad + 1)*start.height/2.0f) }, 4.0f, RED);
             DrawSplineLinear(sinePoints, WAVE_POINTS, 1.0f, RED);
 
             // Cosine (blue - horizontal)
-            DrawLineEx((Vector2){ center.x, center.y }, (Vector2){ point.x, center.y }, 2.0f, BLUE);         
+            DrawLineEx((Vector2){ center.x, center.y }, (Vector2){ point.x, center.y }, 2.0f, BLUE);
             DrawLineDashed((Vector2){ center.x , point.y }, (Vector2){ point.x, point.y }, 10.0f, 4.0f, BLUE);
             DrawText(TextFormat("Cosine %.2f", cosRad), 640, 210, 6, BLUE);
             DrawCircleV((Vector2){ start.x + (angle/360.0f)*start.width, start.y + ((-cosRad + 1)*start.height/2.0f) }, 4.0f, BLUE);
@@ -135,7 +135,7 @@ int main(void)
             DrawText(TextFormat("Cotangent %.2f", cotangent), 640, 250, 6, ORANGE);
 
             // Complementary angle (beige)
-            DrawCircleSectorLines(center, radius*0.6f , -angle, -90.f , 36.0f, BEIGE); 
+            DrawCircleSectorLines(center, radius*0.6f , -angle, -90.f , 36.0f, BEIGE);
             DrawText(TextFormat("Complementary  %0.f°",complementary), 640, 150, 6, BEIGE);
 
             // Supplementary angle (darkblue)
@@ -147,19 +147,19 @@ int main(void)
             DrawText(TextFormat("Explementary  %0.f°",explementary), 640, 170, 6, PINK);
 
             // Current angle - arc (lime), radius (black), endpoint (black)
-            DrawCircleSectorLines(center, radius*0.7f , -angle, 0.f, 36.0f, LIME); 
+            DrawCircleSectorLines(center, radius*0.7f , -angle, 0.f, 36.0f, LIME);
             DrawLineEx((Vector2){ center.x , center.y }, point, 2.0f, BLACK);
             DrawCircleV(point, 4.0f, BLACK);
 
             // Draw GUI controls
             //------------------------------------------------------------------------------
             GuiSetStyle(LABEL, TEXT_COLOR_NORMAL, ColorToInt(GRAY));
-            GuiToggle((Rectangle){ 640, 70, 120, 20}, TextFormat("Pause"), &pause);   
+            GuiToggle((Rectangle){ 640, 70, 120, 20}, TextFormat("Pause"), &pause);
             GuiSetStyle(LABEL, TEXT_COLOR_NORMAL, ColorToInt(LIME));
             GuiSliderBar((Rectangle){ 640, 40, 120, 20}, "Angle", TextFormat("%.0f°", angle), &angle, 0.0f, 360.f);
 
             // Angle values panel
-            GuiGroupBox((Rectangle){ 620, 110, 140, 170}, "Angle Values"); 
+            GuiGroupBox((Rectangle){ 620, 110, 140, 170}, "Angle Values");
             //------------------------------------------------------------------------------
             DrawFPS(10, 10);
 

examples/shapes/shapes_mouse_trail.c

@@ -35,7 +35,7 @@ int main(void)
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - mouse trail");
 
     // Array to store the history of mouse positions (our fixed-size queue)
-    Vector2 trailPositions[MAX_TRAIL_LENGTH] = { 0 }; 
+    Vector2 trailPositions[MAX_TRAIL_LENGTH] = { 0 };
 
     SetTargetFPS(60);
     //--------------------------------------------------------------------------------------
@@ -62,8 +62,8 @@ int main(void)
         //----------------------------------------------------------------------------------
         BeginDrawing();
 
-            ClearBackground(BLACK); 
-            
+            ClearBackground(BLACK);
+
             // Draw the trail by looping through the history array
             for (int i = 0; i < MAX_TRAIL_LENGTH; i++)
             {
@@ -71,22 +71,22 @@ int main(void)
                 if ((trailPositions[i].x != 0.0f) || (trailPositions[i].y != 0.0f))
                 {
                     // Calculate relative trail strength (ratio is near 1.0 for new, near 0.0 for old)
-                    float ratio = (float)(MAX_TRAIL_LENGTH - i) / MAX_TRAIL_LENGTH; 
-                    
+                    float ratio = (float)(MAX_TRAIL_LENGTH - i) / MAX_TRAIL_LENGTH;
+
                     // Fade effect: oldest positions are more transparent
                     // Fade (color, alpha) - alpha is 0.5 to 1.0 based on ratio
-                    Color trailColor = Fade(SKYBLUE, ratio*0.5f + 0.5f); 
-                    
+                    Color trailColor = Fade(SKYBLUE, ratio*0.5f + 0.5f);
+
                     // Size effect: oldest positions are smaller
-                    float trailRadius = 15.0f*ratio; 
-                    
+                    float trailRadius = 15.0f*ratio;
+
                     DrawCircleV(trailPositions[i], trailRadius, trailColor);
                 }
             }
 
             // Draw a distinct white circle for the current mouse position (Index 0)
             DrawCircleV(mousePosition, 15.0f, WHITE);
-            
+
             DrawText("Move the mouse to see the trail effect!", 10, screenHeight - 30, 20, LIGHTGRAY);
 
         EndDrawing();

examples/shapes/shapes_pie_chart.c

@@ -67,7 +67,7 @@ int main(void)
     const Rectangle panelRect = {
         panelPos.x, panelPos.y,
         (float)panelWidth,
-        (float)screenHeight - 2.0f*panelMargin 
+        (float)screenHeight - 2.0f*panelMargin
     };
 
     // Pie chart geometry
@@ -108,13 +108,13 @@ int main(void)
                 for (int i = 0; i < sliceCount; i++)
                 {
                     float sweep = (totalValue > 0)? (values[i]/totalValue)*360.0f : 0.0f;
-                    
+
                     if ((angle >= currentAngle) && (angle < (currentAngle + sweep)))
                     {
                         hoveredSlice = i;
                         break;
                     }
-                    
+
                     currentAngle += sweep;
                 }
             }
@@ -182,11 +182,11 @@ int main(void)
             GuiLine((Rectangle){ panelPos.x + 10, (float)panelPos.y + 12 + 170, panelRect.width - 20, 1 }, NULL);
 
             // Scrollable area for slice editors
-            scrollPanelBounds = (Rectangle){ 
-                panelPos.x + panelMargin, 
-                (float)panelPos.y + 12 + 190, 
-                panelRect.width - panelMargin*2, 
-                panelRect.y + panelRect.height - panelPos.y + 12 + 190 - panelMargin 
+            scrollPanelBounds = (Rectangle){
+                panelPos.x + panelMargin,
+                (float)panelPos.y + 12 + 190,
+                panelRect.width - panelMargin*2,
+                panelRect.y + panelRect.height - panelPos.y + 12 + 190 - panelMargin
             };
             int contentHeight = sliceCount*35;
 

examples/shapes/shapes_recursive_tree.c

@@ -45,7 +45,7 @@ int main(void)
 
     Vector2 start = { (screenWidth/2.0f) - 125.0f, (float)screenHeight };
     float angle = 40.0f;
-    float thick = 1.0f;   
+    float thick = 1.0f;
     float treeDepth = 10.0f;
     float branchDecay = 0.66f;
     float length = 120.0f;
@@ -67,21 +67,21 @@ int main(void)
         Vector2 initialEnd = { start.x + length*sinf(0.0f), start.y - length*cosf(0.0f) };
         branches[count++] = (Branch){start, initialEnd, 0.0f, length};
 
-        for (int i = 0; i < count; i++) 
+        for (int i = 0; i < count; i++)
         {
             Branch branch = branches[i];
             if (branch.length < 2) continue;
 
             float nextLength = branch.length*branchDecay;
 
-            if (count < maxBranches && nextLength >= 2) 
+            if (count < maxBranches && nextLength >= 2)
             {
                 Vector2 branchStart = branch.end;
 
                 float angle1 = branch.angle + theta;
                 Vector2 branchEnd1 = { branchStart.x + nextLength*sinf(angle1), branchStart.y - nextLength*cosf(angle1) };
                 branches[count++] = (Branch){branchStart, branchEnd1, angle1, nextLength};
-                
+
                 float angle2 = branch.angle - theta;
                 Vector2 branchEnd2 = { branchStart.x + nextLength*sinf(angle2), branchStart.y - nextLength*cosf(angle2) };
                 branches[count++] = (Branch){branchStart, branchEnd2, angle2, nextLength};
@@ -94,10 +94,10 @@ int main(void)
 
             ClearBackground(RAYWHITE);
 
-            for (int i = 0; i < count; i++) 
+            for (int i = 0; i < count; i++)
             {
                 Branch branch = branches[i];
-                if (branch.length >= 2) 
+                if (branch.length >= 2)
                 {
                     if (bezier) DrawLineBezier(branch.start, branch.end, thick, RED);
                     else DrawLineEx(branch.start, branch.end, thick, RED);

examples/shapes/shapes_rlgl_triangle.c

@@ -50,7 +50,7 @@ int main(void)
         // Update
         //----------------------------------------------------------------------------------
         if (IsKeyPressed(KEY_SPACE)) linesMode = !linesMode;
-        
+
         // Check selected vertex
         for (unsigned int i = 0; i < 3; i++)
         {
@@ -72,7 +72,7 @@ int main(void)
             position->x += mouseDelta.x;
             position->y += mouseDelta.y;
         }
-        
+
         // Reset index on release
         if (IsMouseButtonReleased(MOUSE_BUTTON_LEFT)) triangleIndex = -1;
 
@@ -139,15 +139,15 @@ int main(void)
             // Render the vertex handles, reacting to mouse movement/input
             for (unsigned int i = 0; i < 3; i++)
             {
-                // Draw handle fill focused by mouse                
+                // Draw handle fill focused by mouse
                 if (CheckCollisionPointCircle(GetMousePosition(), trianglePositions[i], handleRadius))
                     DrawCircleV(trianglePositions[i], handleRadius, ColorAlpha(DARKGRAY, 0.5f));
-                
+
                 // Draw handle fill selected
                 if (i == triangleIndex) DrawCircleV(trianglePositions[i], handleRadius, DARKGRAY);
-                
+
                 // Draw handle outline
-                DrawCircleLinesV(trianglePositions[i], handleRadius, BLACK); 
+                DrawCircleLinesV(trianglePositions[i], handleRadius, BLACK);
             }
 
             // Draw controls

examples/shapes/shapes_simple_particles.c

@@ -36,7 +36,7 @@ static const char particleTypeNames[3][10] = { "WATER", "SMOKE", "FIRE" };
 typedef struct Particle {
     ParticleType type;      // Particle type (WATER, SMOKE, FIRE)
     Vector2 position;       // Particle position on screen
-	Vector2 velocity;       // Particle current speed and direction
+    Vector2 velocity;       // Particle current speed and direction
     float radius;           // Particle radius
     Color color;            // Particle color
 
@@ -45,9 +45,9 @@ typedef struct Particle {
 } Particle;
 
 typedef struct CircularBuffer {
-	int head;               // Index for the next write
-	int tail;               // Index for the next read
-	Particle *buffer;       // Particle buffer array
+    int head;               // Index for the next write
+    int tail;               // Index for the next read
+    Particle *buffer;       // Particle buffer array
 } CircularBuffer;
 
 //----------------------------------------------------------------------------------
@@ -73,12 +73,12 @@ int main(void)
 
     // Definition of particles
     Particle *particles = (Particle*)RL_CALLOC(MAX_PARTICLES, sizeof(Particle)); // Particle array
-	CircularBuffer circularBuffer = { 0, 0, particles };
+    CircularBuffer circularBuffer = { 0, 0, particles };
 
-	// Particle emitter parameters
+    // Particle emitter parameters
     int emissionRate = -2;          // Negative: on average every -X frames. Positive: particles per frame
-	ParticleType currentType = WATER;
-	Vector2 emitterPosition = { screenWidth/2.0f, screenHeight/2.0f };
+    ParticleType currentType = WATER;
+    Vector2 emitterPosition = { screenWidth/2.0f, screenHeight/2.0f };
 
     SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
@@ -88,7 +88,7 @@ int main(void)
     {
         // Update
         //----------------------------------------------------------------------------------
-		// Emit new particles: when emissionRate is 1, emit every frame
+        // Emit new particles: when emissionRate is 1, emit every frame
         if (emissionRate < 0)
         {
             if (rand()%(-emissionRate) == 0) EmitParticle(&circularBuffer, emitterPosition, currentType);
@@ -96,9 +96,9 @@ int main(void)
         else
         {
             for (int i = 0; i <= emissionRate; ++i) EmitParticle(&circularBuffer, emitterPosition, currentType);
-		}
+        }
 
-		// Update the parameters of each particle
+        // Update the parameters of each particle
         UpdateParticles(&circularBuffer, screenWidth, screenHeight);
 
         // Remove dead particles from the circular buffer
@@ -112,7 +112,7 @@ int main(void)
         if (IsKeyPressed(KEY_RIGHT)) (currentType == FIRE)? (currentType = WATER) : currentType++;
         if (IsKeyPressed(KEY_LEFT)) (currentType == WATER)? (currentType = FIRE) : currentType--;
 
-		if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) emitterPosition = GetMousePosition();
+        if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) emitterPosition = GetMousePosition();
         //----------------------------------------------------------------------------------
 
         // Draw
@@ -121,7 +121,7 @@ int main(void)
 
             ClearBackground(RAYWHITE);
 
-		    // Call the function with a loop to draw all particles
+            // Call the function with a loop to draw all particles
             DrawParticles(&circularBuffer);
 
             // Draw UI and Instructions
@@ -133,7 +133,7 @@ int main(void)
             DrawText("LEFT/RIGHT: Change Particle Type (Water, Smoke, Fire)", 15, 55, 10, BLACK);
 
             if (emissionRate < 0) DrawText(TextFormat("Particles every %d frames | Type: %s", -emissionRate, particleTypeNames[currentType]), 15, 95, 10, DARKGRAY);
-		    else DrawText(TextFormat("%d Particles per frame | Type: %s", emissionRate + 1, particleTypeNames[currentType]), 15, 95, 10, DARKGRAY);
+            else DrawText(TextFormat("%d Particles per frame | Type: %s", emissionRate + 1, particleTypeNames[currentType]), 15, 95, 10, DARKGRAY);
 
             DrawFPS(screenWidth - 80, 10);
 
@@ -200,12 +200,12 @@ static Particle *AddToCircularBuffer(CircularBuffer *circularBuffer)
     // Check if buffer full
     if (((circularBuffer->head + 1)%MAX_PARTICLES) != circularBuffer->tail)
     {
-		// Add new particle to the head position and advance head
+        // Add new particle to the head position and advance head
         particle = &circularBuffer->buffer[circularBuffer->head];
         circularBuffer->head = (circularBuffer->head + 1)%MAX_PARTICLES;
     }
 
-	return particle;
+    return particle;
 }
 
 static void UpdateParticles(CircularBuffer *circularBuffer, int screenWidth, int screenHeight)
@@ -213,7 +213,7 @@ static void UpdateParticles(CircularBuffer *circularBuffer, int screenWidth, int
     for (int i = circularBuffer->tail; i != circularBuffer->head; i = (i + 1)%MAX_PARTICLES)
     {
         // Update particle life and positions
-		circularBuffer->buffer[i].lifeTime += 1.0f/60.0f; // 60 FPS -> 1/60 seconds per frame
+        circularBuffer->buffer[i].lifeTime += 1.0f/60.0f; // 60 FPS -> 1/60 seconds per frame
 
         switch (circularBuffer->buffer[i].type)
         {
@@ -226,32 +226,32 @@ static void UpdateParticles(CircularBuffer *circularBuffer, int screenWidth, int
             case SMOKE:
             {
                 circularBuffer->buffer[i].position.x += circularBuffer->buffer[i].velocity.x;
-				circularBuffer->buffer[i].velocity.y -= 0.05f;  // Upwards
+                circularBuffer->buffer[i].velocity.y -= 0.05f;  // Upwards
                 circularBuffer->buffer[i].position.y += circularBuffer->buffer[i].velocity.y;
                 circularBuffer->buffer[i].radius += 0.5f;       // Increment radius: smoke expands
-				circularBuffer->buffer[i].color.a -= 4;         // Decrement alpha: smoke fades
-				
+                circularBuffer->buffer[i].color.a -= 4;         // Decrement alpha: smoke fades
+
                 // If alpha transparent, particle dies
                 if (circularBuffer->buffer[i].color.a < 4) circularBuffer->buffer[i].alive = false;
             } break;
             case FIRE:
             {
-				// Add a little horizontal oscillation to fire particles
+                // Add a little horizontal oscillation to fire particles
                 circularBuffer->buffer[i].position.x += circularBuffer->buffer[i].velocity.x + cosf(circularBuffer->buffer[i].lifeTime*215.0f);
                 circularBuffer->buffer[i].velocity.y -= 0.05f;  // Upwards
                 circularBuffer->buffer[i].position.y += circularBuffer->buffer[i].velocity.y;
-				circularBuffer->buffer[i].radius -= 0.15f;      // Decrement radius: fire shrinks
-				circularBuffer->buffer[i].color.g -= 3;         // Decrement green: fire turns reddish starting from yellow
-				
+                circularBuffer->buffer[i].radius -= 0.15f;      // Decrement radius: fire shrinks
+                circularBuffer->buffer[i].color.g -= 3;         // Decrement green: fire turns reddish starting from yellow
+
                 // If radius too small, particle dies
                 if (circularBuffer->buffer[i].radius <= 0.02f) circularBuffer->buffer[i].alive = false;
             } break;
             default: break;
         }
 
-		// Disable particle when out of screen
+        // Disable particle when out of screen
         Vector2 center = circularBuffer->buffer[i].position;
-		float radius = circularBuffer->buffer[i].radius;
+        float radius = circularBuffer->buffer[i].radius;
 
         if ((center.x < -radius) || (center.x > (screenWidth + radius)) ||
             (center.y < -radius) || (center.y > (screenHeight + radius)))
@@ -267,7 +267,7 @@ static void UpdateCircularBuffer(CircularBuffer *circularBuffer)
     while ((circularBuffer->tail != circularBuffer->head) && !circularBuffer->buffer[circularBuffer->tail].alive)
     {
         circularBuffer->tail = (circularBuffer->tail + 1)%MAX_PARTICLES;
-	}
+    }
 }
 
 static void DrawParticles(CircularBuffer *circularBuffer)

examples/shapes/shapes_triangle_strip.c

@@ -39,7 +39,7 @@ int main(void)
     float insideRadius = 100.0f;
     float outsideRadius = 150.0f;
     bool outline = true;
-    
+
     SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
@@ -79,14 +79,14 @@ int main(void)
                 float angle1 = i*angleStep;
                 DrawTriangle(c, b, a, ColorFromHSV(angle1*RAD2DEG, 1.0f, 1.0f));
                 DrawTriangle(d, b, c, ColorFromHSV((angle1 + angleStep/2)*RAD2DEG, 1.0f, 1.0f));
-                
+
                 if (outline)
                 {
                     DrawTriangleLines(a, b, c, BLACK);
                     DrawTriangleLines(c, b, d, BLACK);
                 }
             }
- 
+
             DrawLine(580, 0, 580, GetScreenHeight(), (Color){ 218, 218, 218, 255 });
             DrawRectangle(580, 0, GetScreenWidth(), GetScreenHeight(), (Color){ 232, 232, 232, 255 });
 

examples/shapes/shapes_vector_angle.c

@@ -25,7 +25,7 @@ int main(void)
     // Initialization
     //--------------------------------------------------------------------------------------
     const int screenWidth = 800;
-    
+
     const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - vector angle");

examples/text/text_inline_styling.c

@@ -36,11 +36,11 @@ int main(void)
     const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [text] example - inline styling");
-    
+
     Vector2 textSize = { 0 };   // Measure text box for provided font and text
     Color colRandom = RED;      // Random color used on text
     int frameCounter = 0;       // Used to generate a new random color every certain frames
-    
+
     SetTargetFPS(60);           // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
 
@@ -50,7 +50,7 @@ int main(void)
         // Update
         //----------------------------------------------------------------------------------
         frameCounter++;
-        
+
         if ((frameCounter%20) == 0)
         {
             colRandom.r = (unsigned char)GetRandomValue(0, 255);
@@ -67,12 +67,12 @@ int main(void)
             ClearBackground(RAYWHITE);
 
             // Text inline styling strategy used: [ ] delimiters for format
-            // - Define foreground color:      [cRRGGBBAA] 
+            // - Define foreground color:      [cRRGGBBAA]
             // - Define background color:      [bRRGGBBAA]
             // - Reset formating:              [r]
             // Example: [bAA00AAFF][cFF0000FF]red text on gray background[r] normal text
-    
-            DrawTextStyled(GetFontDefault(), "This changes the [cFF0000FF]foreground color[r] of provided text!!!", 
+
+            DrawTextStyled(GetFontDefault(), "This changes the [cFF0000FF]foreground color[r] of provided text!!!",
                 (Vector2){ 100, 80 }, 20.0f, 2.0f, BLACK);
 
             DrawTextStyled(GetFontDefault(), "This changes the [bFF00FFFF]background color[r] of provided text!!!",
@@ -80,11 +80,11 @@ int main(void)
 
             DrawTextStyled(GetFontDefault(), "This changes the [c00ff00ff][bff0000ff]foreground and background colors[r]!!!",
                 (Vector2){ 100, 160 }, 20.0f, 2.0f, BLACK);
-                
+
             // Get pointer to formated text
             const char *text = TextFormat("Let's be [c%02x%02x%02xFF]CREATIVE[r] !!!", colRandom.r, colRandom.g, colRandom.b);
             DrawTextStyled(GetFontDefault(), text, (Vector2){ 100, 220 }, 40.0f, 2.0f, BLACK);
-                
+
             textSize = MeasureTextStyled(GetFontDefault(), text, 40.0f, 2.0f);
             DrawRectangleLines(100, 220, (int)textSize.x, (int)textSize.y, GREEN);
 
@@ -108,13 +108,13 @@ int main(void)
 static void DrawTextStyled(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color color)
 {
     // Text inline styling strategy used: [ ] delimiters for format
-    // - Define foreground color:      [cRRGGBBAA] 
+    // - Define foreground color:      [cRRGGBBAA]
     // - Define background color:      [bRRGGBBAA]
     // - Reset formating:              [r]
     // Example: [bAA00AAFF][cFF0000FF]red text on gray background[r] normal text
-    
+
     if (font.texture.id == 0) font = GetFontDefault();
-    
+
     int textLen = TextLength(text);
 
     Color colFront = color;
@@ -144,14 +144,14 @@ static void DrawTextStyled(Font font, const char *text, Vector2 position, float
                 {
                     colFront = color;
                     colBack = BLANK;
-                    
+
                     i += 3;     // Skip "[r]"
                     continue;   // Do not draw characters
                 }
                 else if (((i + 1) < textLen) && ((text[i + 1] == 'c') || (text[i + 1] == 'b')))
                 {
                     i += 2;     // Skip "[c" or "[b" to start parsing color
-                    
+
                     // Parse following color
                     char colHexText[9] = { 0 };
                     const char *textPtr = &text[i]; // Color should start here, let's see...
@@ -168,12 +168,12 @@ static void DrawTextStyled(Font font, const char *text, Vector2 position, float
                         }
                         else break; // Only affects while loop
                     }
-                    
+
                     // Convert hex color text into actual Color
                     unsigned int colHexValue = strtoul(colHexText, NULL, 16);
                     if (text[i - 1] == 'c') colFront = GetColor(colHexValue);
                     else if (text[i - 1] == 'b') colBack = GetColor(colHexValue);
-                    
+
                     i += (colHexCount + 1); // Skip color value retrieved and ']'
                     continue;   // Do not draw characters
                 }
@@ -249,7 +249,7 @@ static Vector2 MeasureTextStyled(Font font, const char *text, float fontSize, fl
                     }
                     else break; // Only affects while loop
                 }
-                
+
                 i += (colHexCount + 1); // Skip color value retrieved and ']'
                 continue;   // Do not measure characters
             }
@@ -260,7 +260,7 @@ static Vector2 MeasureTextStyled(Font font, const char *text, float fontSize, fl
 
             if (font.glyphs[index].advanceX > 0) textWidth += font.glyphs[index].advanceX;
             else textWidth += (font.recs[index].width + font.glyphs[index].offsetX);
-            
+
             validCodepointCounter++;
             i += codepointByteCount;
         }

examples/text/text_unicode_ranges.c

@@ -58,7 +58,7 @@ int main(void)
 
             // Load font with default Unicode range: Basic ASCII [32-127]
             font = LoadFont("resources/NotoSansTC-Regular.ttf");
-            
+
             // Add required ranges to loaded font
             switch (unicodeRange)
             {
@@ -128,11 +128,11 @@ int main(void)
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
-        
+
             ClearBackground(RAYWHITE);
 
             DrawText("ADD CODEPOINTS: [1][2][3][4]", 20, 20, 20, MAROON);
-            
+
             // Render test strings in different languages
             DrawTextEx(font, "> English: Hello World!", (Vector2){ 50, 70 }, 32, 1, DARKGRAY); // English
             DrawTextEx(font, "> Español: Hola mundo!", (Vector2){ 50, 120 }, 32, 1, DARKGRAY); // Spanish
@@ -141,7 +141,7 @@ int main(void)
             DrawTextEx(font, "> 中文: 你好世界!", (Vector2){ 50, 270 }, 32, 1, DARKGRAY);        // Chinese
             DrawTextEx(font, "> 日本語: こんにちは世界!", (Vector2){ 50, 320 }, 32, 1, DARKGRAY); // Japanese
             //DrawTextEx(font, "देवनागरी: होला मुंडो!", (Vector2){ 50, 350 }, 32, 1, DARKGRAY);     // Devanagari (glyphs not available in font)
-            
+
             // Draw font texture scaled to screen
             float atlasScale = 380.0f/font.texture.width;
             DrawRectangleRec((Rectangle) { 400.0f, 16.0f, font.texture.width* atlasScale, font.texture.height* atlasScale }, BLACK);
@@ -161,7 +161,7 @@ int main(void)
                 DrawRectangle(0, 125, screenWidth, 200, GRAY);
                 DrawText("GENERATING FONT ATLAS...", 120, 210, 40, BLACK);
             }
-            
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
@@ -184,10 +184,10 @@ static void AddCodepointRange(Font *font, const char *fontPath, int start, int s
 {
     int rangeSize = stop - start + 1;
     int currentRangeSize = font->glyphCount;
-    
+
     // TODO: Load glyphs from provided vector font (if available),
     // add them to existing font, regenerating font image and texture
-    
+
     int updatedCodepointCount = currentRangeSize + rangeSize;
     int *updatedCodepoints = (int *)RL_CALLOC(updatedCodepointCount, sizeof(int));
 

examples/text/text_words_alignment.c

@@ -39,25 +39,25 @@ int main(void)
     const int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [text] example - words alignment");
-    
+
     // Define the rectangle we will draw the text in
     Rectangle textContainerRect = (Rectangle){ screenWidth/2-screenWidth/4, screenHeight/2-screenHeight/3, screenWidth/2, screenHeight*2/3 };
 
     // Some text to display the current alignment
     const char *textAlignNameH[] = { "Left", "Centre", "Right" };
     const char *textAlignNameV[] = { "Top", "Middle", "Bottom" };
-    
+
     // Define the text we're going to draw in the rectangle
     int wordIndex = 0;
     int wordCount = 0;
     char **words = TextSplit("raylib is a simple and easy-to-use library to enjoy videogames programming", ' ', &wordCount);
-    
+
     // Initialize the font size we're going to use
     int fontSize = 40;
-    
+
     // And of course the font...
     Font font = GetFontDefault();
-    
+
     // Intialize the alignment variables
     TextAlignment hAlign = TEXT_ALIGN_CENTRE;
     TextAlignment vAlign = TEXT_ALIGN_MIDDLE;
@@ -70,7 +70,7 @@ int main(void)
     {
         // Update
         //----------------------------------------------------------------------------------
-        
+
         if (IsKeyPressed(KEY_LEFT)) {
             hAlign = hAlign - 1;
             if (hAlign < 0) hAlign = 0;
@@ -87,10 +87,10 @@ int main(void)
             vAlign = vAlign + 1;
             if (vAlign > 2) vAlign = 2;
         }
-        
+
         // One word per second
         wordIndex = (int)GetTime() % wordCount;
-        
+
         //----------------------------------------------------------------------------------
 
         // Draw
@@ -103,16 +103,16 @@ int main(void)
             DrawText(TextFormat("Alignment: Horizontal = %s, Vertical = %s", textAlignNameH[hAlign], textAlignNameV[vAlign]), 20, 40, 20, LIGHTGRAY);
 
             DrawRectangleRec(textContainerRect, BLUE);
-            
+
             // Get the size of the text to draw
             Vector2 textSize = MeasureTextEx(font, words[wordIndex], fontSize, fontSize*.1f);
-            
+
             // Calculate the top-left text position based on the rectangle and alignment
             Vector2 textPos = (Vector2) {
                 textContainerRect.x + Lerp(0.0f, textContainerRect.width  - textSize.x, ((float)hAlign) * 0.5f),
                 textContainerRect.y + Lerp(0.0f, textContainerRect.height - textSize.y, ((float)vAlign) * 0.5f)
             };
-            
+
             // Draw the text
             DrawTextEx(font, words[wordIndex], textPos, fontSize, fontSize*.1f, RAYWHITE);
 

examples/textures/textures_screen_buffer.c

@@ -45,7 +45,7 @@ int main(void)
     Color palette[MAX_COLORS] = {0};
     unsigned char indexBuffer[INDEX_BUFFER_SIZE] = {0};
     unsigned char flameRootBuffer[FLAME_WIDTH] = {0};
-    
+
     Image screenImage = GenImageColor(imageWidth, imageHeight, BLACK);
     Texture screenTexture = LoadTextureFromImage(screenImage);
     GeneretePalette(palette);
@@ -74,7 +74,7 @@ int main(void)
             int i = x + (imageHeight - 1) * imageWidth;
             indexBuffer[i] = flameRootBuffer[x];
         }
-        
+
         // Clear top row, because it can't move any higher
         for (int x = 0; x < imageWidth; ++x)
         {
@@ -90,7 +90,7 @@ int main(void)
                 unsigned i = x + y * imageWidth;
                 unsigned char colorIndex = indexBuffer[i];
                 if (colorIndex == 0) continue;
-                
+
                 // Move pixel a row above
                 indexBuffer[i] = 0;
                 int moveX = GetRandomValue(0, 2) - 1;
@@ -115,7 +115,7 @@ int main(void)
                 ImageDrawPixel(&screenImage, x, y, col);
             }
         }
-        
+
         UpdateTexture(screenTexture, screenImage.data);
         // Draw
         //----------------------------------------------------------------------------------