Enforce variable case

.clang-tidy

@@ -14,6 +14,7 @@ Checks: >
 CheckOptions:
   - { key: readability-identifier-naming.ClassCase,           value: CamelCase }
   - { key: readability-identifier-naming.FunctionCase,        value: camelBack }
+  - { key: readability-identifier-naming.VariableCase,        value: camelBack }
   - { key: readability-identifier-naming.ParameterCase,       value: camelBack }
 HeaderFilterRegex: '.*'
 WarningsAsErrors: '*'

.github/workflows/ci.yml

@@ -144,7 +144,7 @@ jobs:
       fail-fast: false
       matrix:
         platform:
-        - { name: Linux, os: ubuntu-latest }
+        - { name: Linux, os: ubuntu-22.04 }
         - { name: macOS, os: macos-12 }
 
     steps:

CMakeLists.txt

@@ -537,7 +537,7 @@ add_custom_target(format
     COMMAND ${CMAKE_COMMAND} -DCLANG_FORMAT_EXECUTABLE=${CLANG_FORMAT_EXECUTABLE} -P ./cmake/Format.cmake
     WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} VERBATIM)
 
-sfml_set_option(CLANG_TIDY_EXECUTABLE clang-tidy STRING "Override clang-tidy executable, requires minimum version 12")
+sfml_set_option(CLANG_TIDY_EXECUTABLE clang-tidy STRING "Override clang-tidy executable, requires minimum version 14")
 add_custom_target(tidy
     COMMAND ${CMAKE_COMMAND} -DCLANG_TIDY_EXECUTABLE=${CLANG_TIDY_EXECUTABLE} -DPROJECT_BINARY_DIR=${PROJECT_BINARY_DIR} -P ./cmake/Tidy.cmake
     WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} VERBATIM)

cmake/Tidy.cmake

@@ -13,7 +13,7 @@ endif()
 execute_process(COMMAND ${CLANG_TIDY_EXECUTABLE} --version OUTPUT_VARIABLE CLANG_TIDY_VERSION)
 string(REGEX MATCH "version ([0-9]+)" CLANG_TIDY_VERSION ${CLANG_TIDY_VERSION})
 unset(CLANG_TIDY_VERSION)
-if(CMAKE_MATCH_1 GREATER_EQUAL 12)
+if(CMAKE_MATCH_1 GREATER_EQUAL 14)
     message(STATUS "Using clang-tidy version ${CMAKE_MATCH_1}")
 else()
     message(FATAL_ERROR "clang-tidy version ${CMAKE_MATCH_1} is too low")

examples/shader/Effect.hpp

@@ -77,6 +77,7 @@ private:
     std::string m_name;
     bool        m_isLoaded;
 
+    // NOLINTNEXTLINE(readability-identifier-naming)
     static const sf::Font* s_font;
 };
 

examples/shader/Shader.cpp

@@ -135,19 +135,19 @@ public:
 
     bool onLoad() override
     {
-        std::uniform_real_distribution<float>        x_distribution(0, 800);
+        std::uniform_real_distribution<float>        xDistribution(0, 800);
-        std::uniform_real_distribution<float>        y_distribution(0, 600);
+        std::uniform_real_distribution<float>        yDistribution(0, 600);
-        std::uniform_int_distribution<std::uint16_t> color_distribution(0, 255);
+        std::uniform_int_distribution<std::uint16_t> colorDistribution(0, 255);
 
         // Create the points
         m_points.setPrimitiveType(sf::PrimitiveType::Points);
         for (int i = 0; i < 40000; ++i)
         {
-            auto x = x_distribution(rng);
+            auto x = xDistribution(rng);
-            auto y = y_distribution(rng);
+            auto y = yDistribution(rng);
-            auto r = static_cast<std::uint8_t>(color_distribution(rng));
+            auto r = static_cast<std::uint8_t>(colorDistribution(rng));
-            auto g = static_cast<std::uint8_t>(color_distribution(rng));
+            auto g = static_cast<std::uint8_t>(colorDistribution(rng));
-            auto b = static_cast<std::uint8_t>(color_distribution(rng));
+            auto b = static_cast<std::uint8_t>(colorDistribution(rng));
             m_points.append(sf::Vertex(sf::Vector2f(x, y), sf::Color(r, g, b)));
         }
 

examples/tennis/Tennis.cpp

@@ -100,8 +100,8 @@ int main()
 #endif
 
     // Define the paddles properties
-    sf::Clock      AITimer;
+    sf::Clock      aiTimer;
-    const sf::Time AITime           = sf::seconds(0.1f);
+    const sf::Time aiTime           = sf::seconds(0.1f);
     const float    paddleSpeed      = 400.f;
     float          rightPaddleSpeed = 0.f;
     const float    ballSpeed        = 400.f;
@@ -186,9 +186,9 @@ int main()
             }
 
             // Update the computer's paddle direction according to the ball position
-            if (AITimer.getElapsedTime() > AITime)
+            if (aiTimer.getElapsedTime() > aiTime)
             {
-                AITimer.restart();
+                aiTimer.restart();
                 if (ball.getPosition().y + ballRadius > rightPaddle.getPosition().y + paddleSize.y / 2)
                     rightPaddleSpeed = paddleSpeed;
                 else if (ball.getPosition().y - ballRadius < rightPaddle.getPosition().y - paddleSize.y / 2)

include/SFML/Audio/SoundFileFactory.hpp

@@ -153,8 +153,10 @@ private:
     ////////////////////////////////////////////////////////////
     // Static member data
     ////////////////////////////////////////////////////////////
+    // NOLINTBEGIN(readability-identifier-naming)
     static ReaderFactoryArray s_readers; //!< List of all registered readers
     static WriterFactoryArray s_writers; //!< List of all registered writers
+    // NOLINTEND(readability-identifier-naming)
 };
 
 } // namespace sf

include/SFML/Graphics/BlendMode.hpp

@@ -152,12 +152,14 @@ SFML_GRAPHICS_API bool operator!=(const BlendMode& left, const BlendMode& right)
 ////////////////////////////////////////////////////////////
 // Commonly used blending modes
 ////////////////////////////////////////////////////////////
+// NOLINTBEGIN(readability-identifier-naming)
 SFML_GRAPHICS_API extern const BlendMode BlendAlpha;    //!< Blend source and dest according to dest alpha
 SFML_GRAPHICS_API extern const BlendMode BlendAdd;      //!< Add source to dest
 SFML_GRAPHICS_API extern const BlendMode BlendMultiply; //!< Multiply source and dest
 SFML_GRAPHICS_API extern const BlendMode BlendMin;      //!< Take minimum between source and dest
 SFML_GRAPHICS_API extern const BlendMode BlendMax;      //!< Take maximum between source and dest
 SFML_GRAPHICS_API extern const BlendMode BlendNone;     //!< Overwrite dest with source
+// NOLINTEND(readability-identifier-naming)
 
 } // namespace sf
 

include/SFML/Graphics/Color.hpp

@@ -81,6 +81,7 @@ public:
     ////////////////////////////////////////////////////////////
     // Static member data
     ////////////////////////////////////////////////////////////
+    // NOLINTBEGIN(readability-identifier-naming)
     static const Color Black;       //!< Black predefined color
     static const Color White;       //!< White predefined color
     static const Color Red;         //!< Red predefined color
@@ -90,6 +91,7 @@ public:
     static const Color Magenta;     //!< Magenta predefined color
     static const Color Cyan;        //!< Cyan predefined color
     static const Color Transparent; //!< Transparent (black) predefined color
+    // NOLINTEND(readability-identifier-naming)
 
     ////////////////////////////////////////////////////////////
     // Member data

include/SFML/Graphics/RenderStates.hpp

@@ -106,6 +106,7 @@ public:
     ////////////////////////////////////////////////////////////
     // Static member data
     ////////////////////////////////////////////////////////////
+    // NOLINTNEXTLINE(readability-identifier-naming)
     static const RenderStates Default; //!< Special instance holding the default render states
 
     ////////////////////////////////////////////////////////////

include/SFML/Graphics/Shader.hpp

@@ -82,6 +82,7 @@ public:
     /// \see setUniform(const std::string&, CurrentTextureType)
     ///
     ////////////////////////////////////////////////////////////
+    // NOLINTNEXTLINE(readability-identifier-naming)
     static CurrentTextureType CurrentTexture;
 
 public:

include/SFML/Graphics/Transform.hpp

@@ -259,6 +259,7 @@ public:
     ////////////////////////////////////////////////////////////
     // Static member data
     ////////////////////////////////////////////////////////////
+    // NOLINTNEXTLINE(readability-identifier-naming)
     static const Transform Identity; //!< The identity transform (does nothing)
 
 private:

include/SFML/Network/IpAddress.hpp

@@ -161,9 +161,11 @@ public:
     ////////////////////////////////////////////////////////////
     // Static member data
     ////////////////////////////////////////////////////////////
+    // NOLINTBEGIN(readability-identifier-naming)
     static const IpAddress Any;       //!< Value representing any address (0.0.0.0)
     static const IpAddress LocalHost; //!< The "localhost" address (for connecting a computer to itself locally)
     static const IpAddress Broadcast; //!< The "broadcast" address (for sending UDP messages to everyone on a local network)
+    // NOLINTEND(readability-identifier-naming)
 
 private:
     friend SFML_NETWORK_API bool operator<(const IpAddress& left, const IpAddress& right);

include/SFML/System/Angle.hpp

@@ -139,6 +139,7 @@ public:
     ////////////////////////////////////////////////////////////
     // Static member data
     ////////////////////////////////////////////////////////////
+    // NOLINTNEXTLINE(readability-identifier-naming)
     static const Angle Zero; //!< Predefined 0 degree angle value
 
 private:

include/SFML/System/String.hpp

@@ -56,8 +56,10 @@ public:
     ////////////////////////////////////////////////////////////
     // Static member data
     ////////////////////////////////////////////////////////////
+    // NOLINTBEGIN(readability-identifier-naming)
     /// Represents an invalid position in the string
     static inline const std::size_t InvalidPos{std::basic_string<std::uint32_t>::npos};
+    // NOLINTEND(readability-identifier-naming)
 
     ////////////////////////////////////////////////////////////
     /// \brief Default constructor

include/SFML/System/Time.hpp

@@ -108,6 +108,7 @@ public:
     ////////////////////////////////////////////////////////////
     // Static member data
     ////////////////////////////////////////////////////////////
+    // NOLINTNEXTLINE(readability-identifier-naming)
     static const Time Zero; //!< Predefined "zero" time value
 
 private:

include/SFML/System/Vector2.hpp

@@ -217,8 +217,10 @@ public:
     ////////////////////////////////////////////////////////////
     // Static member data
     ////////////////////////////////////////////////////////////
+    // NOLINTBEGIN(readability-identifier-naming)
     static const Vector2 UnitX; //!< The X unit vector (1, 0), usually facing right
     static const Vector2 UnitY; //!< The Y unit vector (0, 1), usually facing down
+    // NOLINTEND(readability-identifier-naming)
 };
 
 // Define the most common types

src/SFML/Graphics/Image.cpp

@@ -225,16 +225,15 @@ void Image::createMaskFromColor(const Color& color, std::uint8_t alpha)
                 std::uint8_t*       dst = dstPixels + j * 4;
 
                 // Interpolate RGBA components using the alpha values of the destination and source pixels
-                std::uint8_t src_alpha = src[3];
+                std::uint8_t srcAlpha = src[3];
-                std::uint8_t dst_alpha = dst[3];
+                std::uint8_t dstAlpha = dst[3];
-                std::uint8_t out_alpha = static_cast<std::uint8_t>(src_alpha + dst_alpha - src_alpha * dst_alpha / 255);
+                std::uint8_t outAlpha = static_cast<std::uint8_t>(srcAlpha + dstAlpha - srcAlpha * dstAlpha / 255);
 
-                dst[3] = out_alpha;
+                dst[3] = outAlpha;
 
-                if (out_alpha)
+                if (outAlpha)
                     for (int k = 0; k < 3; k++)
-                        dst[k] = static_cast<std::uint8_t>(
+                        dst[k] = static_cast<std::uint8_t>((src[k] * srcAlpha + dst[k] * (outAlpha - srcAlpha)) / outAlpha);
-                            (src[k] * src_alpha + dst[k] * (out_alpha - src_alpha)) / out_alpha);
                 else
                     for (int k = 0; k < 3; k++)
                         dst[k] = src[k];

src/SFML/Graphics/ImageLoader.cpp

@@ -78,9 +78,9 @@ namespace priv
 ////////////////////////////////////////////////////////////
 ImageLoader& ImageLoader::getInstance()
 {
-    static ImageLoader Instance;
+    static ImageLoader instance;
 
-    return Instance;
+    return instance;
 }
 
 

src/SFML/Window/OSX/HIDJoystickManager.cpp

@@ -36,7 +36,7 @@ namespace
 {
 // Using a custom run loop mode solve some issues that appears when SFML
 // is used with Cocoa.
-const CFStringRef RunLoopMode = CFSTR("SFML_RUN_LOOP_MODE");
+const CFStringRef runLoopMode = CFSTR("SFML_RUN_LOOP_MODE");
 } // namespace
 
 
@@ -92,7 +92,7 @@ HIDJoystickManager::HIDJoystickManager() : m_manager(0), m_joystickCount(0)
     IOHIDManagerRegisterDeviceMatchingCallback(m_manager, pluggedIn, this);
     IOHIDManagerRegisterDeviceRemovalCallback(m_manager, pluggedOut, this);
 
-    IOHIDManagerScheduleWithRunLoop(m_manager, CFRunLoopGetCurrent(), RunLoopMode);
+    IOHIDManagerScheduleWithRunLoop(m_manager, CFRunLoopGetCurrent(), runLoopMode);
 
     IOHIDManagerOpen(m_manager, kIOHIDOptionsTypeNone);
 }
@@ -101,7 +101,7 @@ HIDJoystickManager::HIDJoystickManager() : m_manager(0), m_joystickCount(0)
 ////////////////////////////////////////////////////////////
 HIDJoystickManager::~HIDJoystickManager()
 {
-    IOHIDManagerUnscheduleFromRunLoop(m_manager, CFRunLoopGetCurrent(), RunLoopMode);
+    IOHIDManagerUnscheduleFromRunLoop(m_manager, CFRunLoopGetCurrent(), runLoopMode);
 
     IOHIDManagerRegisterDeviceMatchingCallback(m_manager, nullptr, 0);
     IOHIDManagerRegisterDeviceRemovalCallback(m_manager, nullptr, 0);
@@ -117,7 +117,7 @@ void HIDJoystickManager::update()
 
     while (status == kCFRunLoopRunHandledSource)
     {
-        status = CFRunLoopRunInMode(RunLoopMode, 0, true);
+        status = CFRunLoopRunInMode(runLoopMode, 0, true);
     }
 }
 

src/SFML/Window/OSX/JoystickImpl.hpp

@@ -124,6 +124,7 @@ private:
     unsigned int             m_index;          ///< SFML index
     Joystick::Identification m_identification; ///< Joystick identification
 
+    // NOLINTNEXTLINE(readability-identifier-naming)
     static Location m_locationIDs[sf::Joystick::Count]; ///< Global Joystick register
     /// For a corresponding SFML index, m_locationIDs is either some USB
     /// location or 0 if there isn't currently a connected joystick device

src/SFML/Window/Unix/VulkanImplX11.cpp

@@ -144,22 +144,22 @@ bool VulkanImplX11::isAvailable(bool requireGraphics)
             wrapper.vkEnumerateInstanceExtensionProperties(0, &extensionCount, extensionProperties.data());
 
             // Check if the necessary extensions are available
-            bool has_VK_KHR_surface          = false;
+            bool hasVkKhrSurface         = false;
-            bool has_VK_KHR_platform_surface = false;
+            bool hasVkKhrPlatformSurface = false;
 
             for (const VkExtensionProperties& properties : extensionProperties)
             {
                 if (!std::strcmp(properties.extensionName, VK_KHR_SURFACE_EXTENSION_NAME))
                 {
-                    has_VK_KHR_surface = true;
+                    hasVkKhrSurface = true;
                 }
                 else if (!std::strcmp(properties.extensionName, VK_KHR_XLIB_SURFACE_EXTENSION_NAME))
                 {
-                    has_VK_KHR_platform_surface = true;
+                    hasVkKhrPlatformSurface = true;
                 }
             }
 
-            if (!has_VK_KHR_surface || !has_VK_KHR_platform_surface)
+            if (!hasVkKhrSurface || !hasVkKhrPlatformSurface)
                 graphicsAvailable = false;
         }
     }

src/SFML/Window/Unix/WindowImplX11.cpp

@@ -632,9 +632,12 @@ m_lastInputTime(0)
     // change our window's decorations and functions according to the requested style)
     if (!m_fullscreen)
     {
-        Atom WMHintsAtom = getAtom("_MOTIF_WM_HINTS", false);
+        Atom wmHintsAtom = getAtom("_MOTIF_WM_HINTS", false);
-        if (WMHintsAtom)
+        if (wmHintsAtom)
         {
+            // NOLINTBEGIN(readability-identifier-naming)
+            // Disable naming check so these better match the contents of the Motif library
+            // https://sourceforge.net/p/motif/code/ci/master/tree/lib/Xm/MwmUtil.h
             constexpr unsigned long MWM_HINTS_FUNCTIONS   = 1 << 0;
             constexpr unsigned long MWM_HINTS_DECORATIONS = 1 << 1;
 
@@ -652,6 +655,7 @@ m_lastInputTime(0)
             constexpr unsigned long MWM_FUNC_MINIMIZE = 1 << 3;
             constexpr unsigned long MWM_FUNC_MAXIMIZE = 1 << 4;
             constexpr unsigned long MWM_FUNC_CLOSE    = 1 << 5;
+            // NOLINTEND(readability-identifier-naming)
 
             struct WMHints
             {
@@ -685,8 +689,8 @@ m_lastInputTime(0)
 
             XChangeProperty(m_display,
                             m_window,
-                            WMHintsAtom,
+                            wmHintsAtom,
-                            WMHintsAtom,
+                            wmHintsAtom,
                             32,
                             PropModeReplace,
                             reinterpret_cast<const unsigned char*>(&hints),

test/Graphics/Transformable.test.cpp

@@ -65,23 +65,23 @@ TEST_CASE("[Graphics] sf::Transformable")
         CHECK(transformable.getTransform().getMatrix()[14] == Approx(transform.getMatrix()[14]));
         CHECK(transformable.getTransform().getMatrix()[15] == Approx(transform.getMatrix()[15]));
 
-        const sf::Transform inverse_transform = transform.getInverse();
+        const sf::Transform inverseTransform = transform.getInverse();
-        CHECK(transformable.getInverseTransform().getMatrix()[0] == Approx(inverse_transform.getMatrix()[0]));
+        CHECK(transformable.getInverseTransform().getMatrix()[0] == Approx(inverseTransform.getMatrix()[0]));
-        CHECK(transformable.getInverseTransform().getMatrix()[1] == Approx(inverse_transform.getMatrix()[1]));
+        CHECK(transformable.getInverseTransform().getMatrix()[1] == Approx(inverseTransform.getMatrix()[1]));
-        CHECK(transformable.getInverseTransform().getMatrix()[2] == Approx(inverse_transform.getMatrix()[2]));
+        CHECK(transformable.getInverseTransform().getMatrix()[2] == Approx(inverseTransform.getMatrix()[2]));
-        CHECK(transformable.getInverseTransform().getMatrix()[3] == Approx(inverse_transform.getMatrix()[3]));
+        CHECK(transformable.getInverseTransform().getMatrix()[3] == Approx(inverseTransform.getMatrix()[3]));
-        CHECK(transformable.getInverseTransform().getMatrix()[4] == Approx(inverse_transform.getMatrix()[4]));
+        CHECK(transformable.getInverseTransform().getMatrix()[4] == Approx(inverseTransform.getMatrix()[4]));
-        CHECK(transformable.getInverseTransform().getMatrix()[5] == Approx(inverse_transform.getMatrix()[5]));
+        CHECK(transformable.getInverseTransform().getMatrix()[5] == Approx(inverseTransform.getMatrix()[5]));
-        CHECK(transformable.getInverseTransform().getMatrix()[6] == Approx(inverse_transform.getMatrix()[6]));
+        CHECK(transformable.getInverseTransform().getMatrix()[6] == Approx(inverseTransform.getMatrix()[6]));
-        CHECK(transformable.getInverseTransform().getMatrix()[7] == Approx(inverse_transform.getMatrix()[7]));
+        CHECK(transformable.getInverseTransform().getMatrix()[7] == Approx(inverseTransform.getMatrix()[7]));
-        CHECK(transformable.getInverseTransform().getMatrix()[8] == Approx(inverse_transform.getMatrix()[8]));
+        CHECK(transformable.getInverseTransform().getMatrix()[8] == Approx(inverseTransform.getMatrix()[8]));
-        CHECK(transformable.getInverseTransform().getMatrix()[9] == Approx(inverse_transform.getMatrix()[9]));
+        CHECK(transformable.getInverseTransform().getMatrix()[9] == Approx(inverseTransform.getMatrix()[9]));
-        CHECK(transformable.getInverseTransform().getMatrix()[10] == Approx(inverse_transform.getMatrix()[10]));
+        CHECK(transformable.getInverseTransform().getMatrix()[10] == Approx(inverseTransform.getMatrix()[10]));
-        CHECK(transformable.getInverseTransform().getMatrix()[11] == Approx(inverse_transform.getMatrix()[11]));
+        CHECK(transformable.getInverseTransform().getMatrix()[11] == Approx(inverseTransform.getMatrix()[11]));
-        CHECK(transformable.getInverseTransform().getMatrix()[12] == Approx(inverse_transform.getMatrix()[12]));
+        CHECK(transformable.getInverseTransform().getMatrix()[12] == Approx(inverseTransform.getMatrix()[12]));
-        CHECK(transformable.getInverseTransform().getMatrix()[13] == Approx(inverse_transform.getMatrix()[13]));
+        CHECK(transformable.getInverseTransform().getMatrix()[13] == Approx(inverseTransform.getMatrix()[13]));
-        CHECK(transformable.getInverseTransform().getMatrix()[14] == Approx(inverse_transform.getMatrix()[14]));
+        CHECK(transformable.getInverseTransform().getMatrix()[14] == Approx(inverseTransform.getMatrix()[14]));
-        CHECK(transformable.getInverseTransform().getMatrix()[15] == Approx(inverse_transform.getMatrix()[15]));
+        CHECK(transformable.getInverseTransform().getMatrix()[15] == Approx(inverseTransform.getMatrix()[15]));
     }
 
     SUBCASE("move()")