Upgrade to raylib 6.0 and simplify with raylib/raymath built-ins

- Update raylib from 5.0/5.5 to 6.0 across all build configs
- Replace custom RLCommon.h utilities with raylib/raymath equivalents:
  lerpF -> Lerp, lerpColor -> ColorLerp, fadeColor -> Fade,
  lerpVector2 -> Vector2Lerp, distance -> Vector2Distance,
  catmullRom -> GetSplinePointCatmullRom, degToRad -> DEG2RAD
- Add raymath.h include to RLCommon.h (available project-wide)
- Use FetchContent fallback in main CMakeLists.txt for portability
- Remove unused ZLIB dependency
- Update CI workflows for raylib 6.0 (macOS builds from source)
- Fix EPSILON macro conflict with raymath.h in RLLinearGauge.cpp
- Update README.md and wasm/README.md with new version info
- Update test_build/ and tools/ CMakeLists.txt

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: andersc

.github/workflows/MacOS.yml

@@ -23,7 +23,13 @@ jobs:
     - uses: actions/checkout@v4
 
     - name: Install raylib
-      run: brew install raylib
+      run: |
+        git clone --branch 6.0 https://github.com/raysan5/raylib.git raylib
+        cd raylib
+        mkdir build && cd build
+        cmake -DBUILD_SHARED_LIBS=ON -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} ..
+        make -j$(sysctl -n hw.ncpu)
+        sudo make install
 
     - name: Configure CMake
       # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.

.github/workflows/ubuntu_x86_64.yml

@@ -25,7 +25,7 @@ jobs:
     - name: Install raylib
       run: |
         sudo apt install libasound2-dev libx11-dev libxrandr-dev libxi-dev libgl1-mesa-dev libglu1-mesa-dev libxcursor-dev libxinerama-dev libwayland-dev libxkbcommon-dev xvfb
-        git clone https://github.com/raysan5/raylib.git raylib
+        git clone --branch 6.0 https://github.com/raysan5/raylib.git raylib
         cd raylib
         mkdir build && cd build
         cmake -DBUILD_SHARED_LIBS=ON ..

.github/workflows/windows.yml

@@ -34,7 +34,7 @@ jobs:
 
     - name: install raylib
       run: |
-        git clone --branch 5.5 https://github.com/raysan5/raylib.git
+        git clone --branch 6.0 https://github.com/raysan5/raylib.git
         cd raylib
         mkdir build
         cd build

CMakeLists.txt

@@ -3,15 +3,25 @@ project(cpp_charts)
 
 set(CMAKE_CXX_STANDARD 20)
 
-find_package (raylib 5.0 REQUIRED)
-find_package (ZLIB REQUIRED)
-find_package (Threads REQUIRED)
-
-message("Including raylib from: " ${raylib_INCLUDE_DIRS})
-message("Including ZLIB from: " ${ZLIB_INCLUDE_DIRS})
+find_package (raylib 6.0 QUIET)
+if (NOT raylib_FOUND)
+    include(FetchContent)
+    FetchContent_Declare(
+        raylib
+        GIT_REPOSITORY https://github.com/raysan5/raylib.git
+        GIT_TAG 6.0
+        GIT_SHALLOW TRUE
+    )
+    set(BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
+    set(BUILD_GAMES OFF CACHE BOOL "" FORCE)
+    FetchContent_MakeAvailable(raylib)
+    message(STATUS "Using FetchContent raylib 6.0")
+else()
+    message(STATUS "Using system raylib: ${raylib_INCLUDE_DIRS}")
+    include_directories(${raylib_INCLUDE_DIRS})
+endif()
 
-include_directories(${raylib_INCLUDE_DIRS})
-include_directories(${ZLIB_INCLUDE_DIRS})
+find_package(Threads REQUIRED)
 
 #gauges header files location
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/src/charts)

README.md

@@ -286,21 +286,24 @@ chart.draw();
 ## 📦 Integration into Your Project
 
 ### You need to have the following dependencies installed:
-- [raylib](https://www.raylib.com/) 5.0 or higher
-- [zlib](https://zlib.net/) (for certain features)
+- [raylib](https://www.raylib.com/) 6.0 or higher (auto-fetched if not found)
 - CMake 3.28 or higher
 
 ### MacOS (using Homebrew):
 
 ```bash
-brew install raylib zlib
+# raylib 6.0 will be fetched automatically by CMake if not installed
+# Or build from source:
+git clone --branch 6.0 https://github.com/raysan5/raylib.git
+cd raylib && mkdir build && cd build
+cmake -DBUILD_SHARED_LIBS=ON .. && make && sudo make install
 ``` 
 ### Ubuntu (using apt):
 
 ```bash
-sudo apt install libasound2-dev libx11-dev libxrandr-dev libxi-dev libgl1-mesa-dev libglu1-mesa-dev libxcursor-dev libxinerama-dev libwayland-dev libxkbcommon-dev zlib1g-dev
+sudo apt install libasound2-dev libx11-dev libxrandr-dev libxi-dev libgl1-mesa-dev libglu1-mesa-dev libxcursor-dev libxinerama-dev libwayland-dev libxkbcommon-dev
 cd (temporary directory or where you want to build raylib)
-git clone --branch 5.5 https://github.com/raysan5/raylib.git raylib
+git clone --branch 6.0 https://github.com/raysan5/raylib.git raylib
 cd raylib
 mkdir build && cd build
 cmake -DBUILD_SHARED_LIBS=ON ..
@@ -316,14 +319,8 @@ See the windows build actions for reference. The below builds the x86_64 binarie
 
 
 ```bash
-cd (temporary directory or where you want to build zlib)
-git clone --branch v1.3.1 https://github.com/madler/zlib.git
-cd zlib
-cmake -S . -DCMAKE_BUILD_TYPE=Release
-cmake --build . --target install --config Release
-
 cd (temporary directory or where you want to build raylib)
-git clone --branch 5.5 https://github.com/raysan5/raylib.git
+git clone --branch 6.0 https://github.com/raysan5/raylib.git
 cd raylib
 mkdir build
 cd build
@@ -344,15 +341,21 @@ project(single_guage)
 
 set(CMAKE_CXX_STANDARD 20)
 
-find_package (raylib 5.0 REQUIRED)
-find_package (ZLIB REQUIRED)
-find_package (Threads REQUIRED)
-
-message("Including raylib from: " ${raylib_INCLUDE_DIRS})
-message("Including ZLIB from: " ${ZLIB_INCLUDE_DIRS})
+find_package(raylib 6.0 QUIET)
+if (NOT raylib_FOUND)
+    include(FetchContent)
+    FetchContent_Declare(
+        raylib
+        GIT_REPOSITORY https://github.com/raysan5/raylib.git
+        GIT_TAG 6.0
+        GIT_SHALLOW TRUE
+    )
+    set(BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
+    set(BUILD_GAMES OFF CACHE BOOL "" FORCE)
+    FetchContent_MakeAvailable(raylib)
+endif()
 
-include_directories(${raylib_INCLUDE_DIRS})
-include_directories(${ZLIB_INCLUDE_DIRS})
+find_package(Threads REQUIRED)
 
 include(FetchContent)
 FetchContent_Declare(
@@ -476,7 +479,7 @@ python3 -m http.server 8080
 - 🎨 Beautiful custom landing page with dark theme
 - ⚡ Fast loading with progress indicator
 - 📱 Fullscreen support
-- 🔧 Self-contained build (fetches raylib 5.5 automatically)
+- 🔧 Self-contained build (fetches raylib 6.0 automatically)
 
 For complete build instructions, prerequisites, and troubleshooting, see **[wasm/README.md](wasm/README.md)**.
 
@@ -602,8 +605,7 @@ CPP_CHARTS_SKIP_RAYLIB=1 ctest --output-on-failure
 
 - **CMake** 3.28 or higher
 - **C++20** compiler
-- **raylib** 5.0 or higher
-- **zlib** (for certain features)
+- **raylib** 6.0 or higher
 
 ---
 

src/RLCommon.h

@@ -1,10 +1,11 @@
 // RLCommon.h
 #pragma once
 #include "raylib.h"
+#include "raymath.h"
 #include <cmath>
 
 // Common utilities for raylib charts
-// All functions are in the RLCharts namespace to avoid conflicts
+// Leverages raylib/raymath built-in functions where possible (raylib 6.0+)
 
 namespace RLCharts {
 
@@ -15,7 +16,7 @@ inline T clamp01(T aValue) {
            (aValue > static_cast<T>(1) ? static_cast<T>(1) : aValue);
 }
 
-// Template for clamping to arbitrary range
+// Template for clamping to arbitrary range (supports int and float)
 template<typename T>
 inline T clamp(T aValue, T aMin, T aMax) {
     return aValue < aMin ? aMin : (aValue > aMax ? aMax : aValue);
@@ -28,28 +29,6 @@ inline T clampIdx(T aValue, T aMaxLimit) {
            (aValue >= aMaxLimit ? aMaxLimit - static_cast<T>(1) : aValue);
 }
 
-// Template for linear interpolation
-template<typename T>
-inline T lerp(T a, T b, float t) {
-    return static_cast<T>(a + (b - a) * t);
-}
-
-// Specialized lerp for floats (explicit to avoid casting overhead)
-inline float lerpF(float a, float b, float t) {
-    return a + (b - a) * t;
-}
-
-// Color interpolation with clamping
-inline Color lerpColor(const Color& a, const Color& b, float t) {
-    t = clamp01(t);
-    Color lResult;
-    lResult.r = (unsigned char)(a.r + (int)((b.r - a.r) * t));
-    lResult.g = (unsigned char)(a.g + (int)((b.g - a.g) * t));
-    lResult.b = (unsigned char)(a.b + (int)((b.b - a.b) * t));
-    lResult.a = (unsigned char)(a.a + (int)((b.a - a.a) * t));
-    return lResult;
-}
-
 // Template for min/max
 template<typename T>
 inline T minVal(T a, T b) {
@@ -61,16 +40,6 @@ inline T maxVal(T a, T b) {
     return a > b ? a : b;
 }
 
-// Degree to radian conversion
-inline float degToRad(float aDeg) {
-    return aDeg * PI / 180.0f;
-}
-
-// Radian to degree conversion
-inline float radToDeg(float aRad) {
-    return aRad * 180.0f / PI;
-}
-
 // Calculate luminance of a color (for auto text color selection)
 inline float colorLuma(const Color& rColor) {
     return 0.2126f * rColor.r + 0.7152f * rColor.g + 0.0722f * rColor.b;
@@ -79,49 +48,13 @@ inline float colorLuma(const Color& rColor) {
 // Smooth approach function for exponential smoothing
 inline float approach(float a, float b, float aSpeedDt) {
     float lDiff = b - a;
-    return a + lDiff * (lDiff * lDiff < 1e-8f ? 1.0f : clamp01(aSpeedDt));
+    return a + lDiff * (lDiff * lDiff < 1e-8f ? 1.0f : Clamp(aSpeedDt, 0.0f, 1.0f));
 }
 
 // Multiply alpha channel by a factor
 inline unsigned char mulAlpha(unsigned char a, float f) {
     float lValue = (float)a * f;
-    if (lValue < 0.0f) lValue = 0.0f;
-    if (lValue > 255.0f) lValue = 255.0f;
-    return (unsigned char)(lValue + 0.5f);
-}
-
-// Create a color with modified alpha (faded)
-inline Color fadeColor(Color aC, float aAlpha) {
-    aC.a = (unsigned char)(aC.a * clamp01(aAlpha));
-    return aC;
-}
-
-// Vector2 linear interpolation
-inline Vector2 lerpVector2(const Vector2& a, const Vector2& b, float t) {
-    return Vector2{ lerpF(a.x, b.x, t), lerpF(a.y, b.y, t) };
-}
-
-// Vector2 distance
-inline float distance(const Vector2& a, const Vector2& b) {
-    float lDx = a.x - b.x;
-    float lDy = a.y - b.y;
-    return sqrtf(lDx * lDx + lDy * lDy);
-}
-
-// Catmull-Rom spline interpolation
-inline Vector2 catmullRom(const Vector2& aP0, const Vector2& aP1,
-                          const Vector2& aP2, const Vector2& aP3, float aT) {
-    float lT2 = aT * aT;
-    float lT3 = lT2 * aT;
-    float lX = 0.5f * ((2.0f * aP1.x) +
-                       (-aP0.x + aP2.x) * aT +
-                       (2 * aP0.x - 5 * aP1.x + 4 * aP2.x - aP3.x) * lT2 +
-                       (-aP0.x + 3 * aP1.x - 3 * aP2.x + aP3.x) * lT3);
-    float lY = 0.5f * ((2.0f * aP1.y) +
-                       (-aP0.y + aP2.y) * aT +
-                       (2 * aP0.y - 5 * aP1.y + 4 * aP2.y - aP3.y) * lT2 +
-                       (-aP0.y + 3 * aP1.y - 3 * aP2.y + aP3.y) * lT3);
-    return { lX, lY };
+    return (unsigned char)Clamp(lValue + 0.5f, 0.0f, 255.0f);
 }
 
 } // namespace RLCharts

src/charts/RLGauge.cpp

@@ -72,7 +72,7 @@ void RLGauge::recomputeGeometry(){
         const float lLen = lMajor ? mStyle.mMajorTickLen : mStyle.mTickLen;
         const float lRadiusStart = lInnerR - lLen;
         const float lRadiusEnd = lInnerR - 2.0f; // small gap from ring
-        const float lAngleRad = RLCharts::degToRad(lAngleDeg);
+        const float lAngleRad = lAngleDeg * DEG2RAD;
         const float lCos = cosf(lAngleRad);
         const float lSin = sinf(lAngleRad);
         Vector2 lP0{ mCenter.x + (lCos * lRadiusStart), mCenter.y + (lSin * lRadiusStart) };
@@ -116,7 +116,7 @@ void RLGauge::draw() const{
     // needle
     if (mStyle.mShowNeedle){
         float lAng = valueToAngle(mValue);
-        float lAngRad = RLCharts::degToRad(lAng);
+        float lAngRad = lAng * DEG2RAD;
         float lNeedleRadius = mRadius * mStyle.mNeedleRadiusScale;
         Vector2 lTip{ mCenter.x + (cosf(lAngRad) * lNeedleRadius), mCenter.y + (sinf(lAngRad) * lNeedleRadius) };
         DrawLineEx(mCenter, lTip, mStyle.mNeedleWidth, mStyle.mNeedleColor);

src/charts/RLHeatMap3D.cpp

@@ -673,7 +673,7 @@ void RLHeatMap3D::rebuildLut() {
         lIdx0 = std::max(lIdx0, 0);
 
         const float lLocalT = lScaled - (float)lIdx0;
-        mLut[i] = RLCharts::lerpColor(mPaletteStops[(size_t)lIdx0], mPaletteStops[(size_t)lIdx1], lLocalT);
+        mLut[i] = ColorLerp(mPaletteStops[(size_t)lIdx0], mPaletteStops[(size_t)lIdx1], lLocalT);
     }
 
     mLutDirty = false;

src/charts/RLLinearGauge.cpp

@@ -10,7 +10,7 @@
 constexpr float HALF = 0.5f;
 constexpr int VALUE_BUFFER_SIZE = 64;
 constexpr float MIN_TRACK_LENGTH = 20.0f;
-constexpr float EPSILON = 1e-6f;
+constexpr float FLOAT_EPSILON = 1e-6f;
 
 RLLinearGauge::RLLinearGauge(Rectangle aBounds, float aMinValue, float aMaxValue,
                              RLLinearGaugeOrientation aOrientation,
@@ -135,7 +135,7 @@ void RLLinearGauge::setChannelValue(int aIndex, float aValue) {
         }
 
         // Detect clipping (value at or near max)
-        if (mChannels[(size_t)aIndex].mValue >= mMaxValue - EPSILON) {
+        if (mChannels[(size_t)aIndex].mValue >= mMaxValue - FLOAT_EPSILON) {
             mClipStates[(size_t)aIndex] = true;
             mClipTimers[(size_t)aIndex] = mStyle.mVuStyle.mClipFlashDuration;
         }
@@ -568,7 +568,7 @@ void RLLinearGauge::drawTitle() const {
 // ============================================================================
 
 float RLLinearGauge::linearToDb(float aLinear) const {
-    if (aLinear <= EPSILON) {
+    if (aLinear <= FLOAT_EPSILON) {
         return mStyle.mVuStyle.mDbMin;
     }
     float lDb = 20.0f * log10f(aLinear);
@@ -659,14 +659,14 @@ void RLLinearGauge::drawVuMeterChannel(int aIndex, Rectangle aBounds) const {
     lNormalized = std::max(0.0f, std::min(1.0f, lNormalized));
 
     // Apply dB scale if enabled
-    if (mStyle.mVuStyle.mUseDbScale && lNormalized > EPSILON) {
+    if (mStyle.mVuStyle.mUseDbScale && lNormalized > FLOAT_EPSILON) {
         float lDb = linearToDb(lNormalized);
         float lDbRange = mStyle.mVuStyle.mDbMax - mStyle.mVuStyle.mDbMin;
         lNormalized = (lDb - mStyle.mVuStyle.mDbMin) / lDbRange;
         lNormalized = std::max(0.0f, std::min(1.0f, lNormalized));
     }
 
-    if (lNormalized <= EPSILON) {
+    if (lNormalized <= FLOAT_EPSILON) {
         return;
     }
 
@@ -756,14 +756,14 @@ void RLLinearGauge::drawVuMeterPeakMarker(int aIndex, Rectangle aBounds) const {
     lNormalized = std::max(0.0f, std::min(1.0f, lNormalized));
 
     // Apply dB scale if enabled
-    if (mStyle.mVuStyle.mUseDbScale && lNormalized > EPSILON) {
+    if (mStyle.mVuStyle.mUseDbScale && lNormalized > FLOAT_EPSILON) {
         float lDb = linearToDb(lNormalized);
         float lDbRange = mStyle.mVuStyle.mDbMax - mStyle.mVuStyle.mDbMin;
         lNormalized = (lDb - mStyle.mVuStyle.mDbMin) / lDbRange;
         lNormalized = std::max(0.0f, std::min(1.0f, lNormalized));
     }
 
-    if (lNormalized <= EPSILON) {
+    if (lNormalized <= FLOAT_EPSILON) {
         return;
     }
 

src/charts/RLLogPlot.cpp

@@ -650,7 +650,7 @@ void RLLogPlot::drawLogTrace(const RLLogPlotTrace& rTrace, Rectangle aPlotRect)
             const Vector2 lUpperPt = mapLogPoint(lLogX, lLogUpper, aPlotRect);
 
             const float lVis = (i < rTrace.mVisibility.size()) ? rTrace.mVisibility[i] : 1.0f;
-            const Color lDrawColor = RLCharts::fadeColor(lConfColor, lVis);
+            const Color lDrawColor = Fade(lConfColor, lVis);
 
             if (rTrace.mStyle.mConfidenceAsBars) {
                 // Error bars
@@ -690,7 +690,7 @@ void RLLogPlot::drawLogTrace(const RLLogPlotTrace& rTrace, Rectangle aPlotRect)
     // Draw connecting lines
     for (size_t i = 0; i < lScreenPoints.size() - 1; ++i) {
         const float lVis = (i < rTrace.mVisibility.size()) ? rTrace.mVisibility[i] : 1.0f;
-        const Color lDrawColor = RLCharts::fadeColor(rTrace.mStyle.mLineColor, lVis);
+        const Color lDrawColor = Fade(rTrace.mStyle.mLineColor, lVis);
         DrawLineEx(lScreenPoints[i], lScreenPoints[i + 1],
                   rTrace.mStyle.mLineThickness, lDrawColor);
     }
@@ -704,7 +704,7 @@ void RLLogPlot::drawLogTrace(const RLLogPlotTrace& rTrace, Rectangle aPlotRect)
 
         for (size_t i = 0; i < lScreenPoints.size(); ++i) {
             const float lVis = (i < rTrace.mVisibility.size()) ? rTrace.mVisibility[i] : 1.0f;
-            const Color lDrawColor = RLCharts::fadeColor(lPointColor, lVis);
+            const Color lDrawColor = Fade(lPointColor, lVis);
             DrawCircleV(lScreenPoints[i], rTrace.mStyle.mPointRadius, lDrawColor);
 
             // Outline for visibility