Add more sfKeyboard tests

This change allows now having these variables as array sizes that
are not Variable Length Arrays like in structs for example.

To note however that this changes the type from unsigned int to an
implementation defined type which usually `int` which is signed and
not unsigned.

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+github: SFML
+open_collective: sfml

.github/workflows/ci.yml

@@ -6,6 +6,9 @@ concurrency:
   group: environment-${{github.ref}}
   cancel-in-progress: true
 
+env:
+  SFML_VERSION: 3.0.0
+
 defaults:
   run:
     shell: bash
@@ -43,13 +46,13 @@ jobs:
 
     - name: Install Linux Dependencies
       if: runner.os == 'Linux'
-      run: sudo apt-get update && sudo apt-get install libxrandr-dev libxcursor-dev libxi-dev libudev-dev libflac-dev libvorbis-dev libgl1-mesa-dev libegl1-mesa-dev
+      run: sudo apt-get update && sudo apt-get install libxrandr-dev libxcursor-dev libxi-dev libudev-dev libflac-dev libvorbis-dev libgl1-mesa-dev libegl1-mesa-dev libfreetype-dev
 
     - name: Checkout SFML
       uses: actions/checkout@v4
       with:
         repository: SFML/SFML
-        ref: master
+        ref: ${{env.SFML_VERSION}}
         path: SFML
 
     - name: Configure SFML CMake
@@ -74,14 +77,17 @@ jobs:
 
   format:
     name: Formatting
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
 
     steps:
+    - name: Install Clang Format
+      run: sudo apt-get install clang-format-17
+
     - name: Checkout Code
       uses: actions/checkout@v4
 
     - name: Format Code
-      run: cmake -DCLANG_FORMAT_EXECUTABLE=clang-format-14 -P cmake/Format.cmake
+      run: cmake -DCLANG_FORMAT_EXECUTABLE=clang-format-17 -P cmake/Format.cmake
 
     - name: Check Formatting
       run: git diff --exit-code
@@ -101,7 +107,7 @@ jobs:
       uses: actions/checkout@v4
       with:
         repository: SFML/SFML
-        ref: master
+        ref: ${{env.SFML_VERSION}}
         path: SFML
 
     - name: Configure SFML CMake
@@ -135,7 +141,7 @@ jobs:
       uses: actions/checkout@v4
       with:
         repository: SFML/SFML
-        ref: master
+        ref: ${{env.SFML_VERSION}}
         path: SFML
 
     - name: Configure SFML

CMakeLists.txt

@@ -46,7 +46,7 @@ csfml_set_option(CSFML_LINK_SFML_STATICALLY ${LINK_STATICALLY_DEFAULT} BOOL "ON
 
 # define an option for choosing between static and dynamic C runtime (Windows only)
 if(SFML_OS_WINDOWS)
-    set(STATIC_STD_LIBS OFF CACHE BOOL "ON to statically link to the standard libraries, OFF to use them as DLLs")
+    csfml_set_option(CSFML_USE_STATIC_STD_LIBS OFF BOOL "ON to statically link to the standard libraries, OFF to use them as DLLs")
 endif()
 
 # find SFML libraries (C++)
@@ -121,7 +121,7 @@ if(CSFML_BUILD_TEST_SUITE)
     add_subdirectory(test)
 endif()
 
-csfml_set_option(CLANG_FORMAT_EXECUTABLE clang-format STRING "Override clang-format executable, requires version 14")
+csfml_set_option(CLANG_FORMAT_EXECUTABLE clang-format STRING "Override clang-format executable, requires version 17")
 add_custom_target(format
     COMMAND ${CMAKE_COMMAND} -DCLANG_FORMAT_EXECUTABLE=${CLANG_FORMAT_EXECUTABLE} -P ./cmake/Format.cmake
     WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} VERBATIM)

cmake/Format.cmake

@@ -13,8 +13,8 @@ endif()
 execute_process(COMMAND ${CLANG_FORMAT_EXECUTABLE} --version OUTPUT_VARIABLE CLANG_FORMAT_VERSION)
 string(REGEX MATCH "clang-format version ([0-9]+)" CLANG_FORMAT_VERSION ${CLANG_FORMAT_VERSION})
 unset(CLANG_FORMAT_VERSION)
-if(NOT CMAKE_MATCH_1 EQUAL 14)
-    message(FATAL_ERROR "clang-format version ${CMAKE_MATCH_1} not supported. Must use version 14")
+if(NOT CMAKE_MATCH_1 EQUAL 17)
+    message(FATAL_ERROR "clang-format version ${CMAKE_MATCH_1} not supported. Must use version 17")
 endif()
 
 # Run

cmake/Macros.cmake

@@ -46,7 +46,7 @@ macro(csfml_add_library target)
         set_target_properties(${target} PROPERTIES MINSIZEREL_POSTFIX -s)
         set_target_properties(${target} PROPERTIES RELWITHDEBINFO_POSTFIX -s)
 
-        if(STATIC_STD_LIBS)
+        if(CSFML_USE_STATIC_STD_LIBS)
             set_property(TARGET ${target} PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
         endif()
     endif()
@@ -58,11 +58,11 @@ macro(csfml_add_library target)
     # set the target's folder (for IDEs that support it, e.g. Visual Studio)
     set_target_properties(${target} PROPERTIES FOLDER "CSFML")
 
-    # apply the SFML_USE_STATIC_STD_LIBS option if it is enabled
+    # apply the CSFML_USE_STATIC_STD_LIBS option if it is enabled
     if(SFML_OS_WINDOWS AND SFML_COMPILER_GCC)
-        if(SFML_USE_STATIC_STD_LIBS AND NOT SFML_COMPILER_GCC_TDM)
+        if(CSFML_USE_STATIC_STD_LIBS AND NOT SFML_COMPILER_GCC_TDM)
             set_target_properties(${target} PROPERTIES LINK_FLAGS "-static-libgcc -static-libstdc++")
-        elseif(NOT SFML_USE_STATIC_STD_LIBS AND SFML_COMPILER_GCC_TDM)
+        elseif(NOT CSFML_USE_STATIC_STD_LIBS AND SFML_COMPILER_GCC_TDM)
             set_target_properties(${target} PROPERTIES LINK_FLAGS "-shared-libgcc -shared-libstdc++")
         endif()
     endif()

include/CSFML/Audio/Music.h

@@ -175,7 +175,7 @@ CSFML_AUDIO_API sfTime sfMusic_getDuration(const sfMusic* music);
 CSFML_AUDIO_API sfTimeSpan sfMusic_getLoopPoints(const sfMusic* music);
 
 ////////////////////////////////////////////////////////////
-/// \brief Sets the beginning and end of the sound's looping sequence using sf::Time
+/// \brief Sets the beginning and end of the sound's looping sequence using sfTime
 ///
 /// Loop points allow one to specify a pair of positions such that, when the music
 /// is enabled for looping, it will seamlessly seek to the beginning whenever it

include/CSFML/Audio/SoundRecorder.h

@@ -129,7 +129,7 @@ CSFML_AUDIO_API bool sfSoundRecorder_isAvailable(void);
 /// \return An array of strings containing the names
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API const char** sfSoundRecorder_getAvailableDevices(size_t* count);
+CSFML_AUDIO_API const char* const* sfSoundRecorder_getAvailableDevices(size_t* count);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the name of the default audio capture device

include/CSFML/Graphics/CoordinateType.h

@@ -0,0 +1,35 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+//    you must not claim that you wrote the original software.
+//    If you use this software in a product, an acknowledgment
+//    in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+//    and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#pragma once
+
+////////////////////////////////////////////////////////////
+/// \brief Types of texture coordinates that can be used for rendering.
+///
+////////////////////////////////////////////////////////////
+typedef enum
+{
+    sfCoordinateTypeNormalized, ///< sfTexture coordinates in range [0 .. 1].
+    sfCoordinateTypePixels      ///< sfTexture coordinates in range [0 .. size].
+} sfCoordinateType;

include/CSFML/Graphics/PrimitiveType.h

@@ -31,7 +31,7 @@
 
 
 ////////////////////////////////////////////////////////////
-/// \brief Types of primitives that a sf::VertexArray can render
+/// \brief Types of primitives that an sfVertexArray can render
 ///
 /// Points and lines have no area, therefore their thickness
 /// will always be 1 pixel, regardless the current transform

include/CSFML/Graphics/RenderStates.h

@@ -30,6 +30,8 @@
 #include <CSFML/Graphics/Export.h>
 
 #include <CSFML/Graphics/BlendMode.h>
+#include <CSFML/Graphics/CoordinateType.h>
+#include <CSFML/Graphics/StencilMode.h>
 #include <CSFML/Graphics/Transform.h>
 #include <CSFML/Graphics/Types.h>
 
@@ -40,10 +42,12 @@
 ////////////////////////////////////////////////////////////
 typedef struct
 {
-    sfBlendMode      blendMode; ///< Blending mode
-    sfTransform      transform; ///< Transform
-    const sfTexture* texture;   ///< Texture
-    const sfShader*  shader;    ///< Shader
+    sfBlendMode      blendMode;      ///< Blending mode
+    sfStencilMode    stencilMode;    //!< Stencil mode
+    sfTransform      transform;      ///< Transform
+    sfCoordinateType coordinateType; //!< Texture coordinate type
+    const sfTexture* texture;        ///< Texture
+    const sfShader*  shader;         ///< Shader
 } sfRenderStates;
 
 ////////////////////////////////////////////////////////////

include/CSFML/Graphics/Texture.h

@@ -29,6 +29,7 @@
 ////////////////////////////////////////////////////////////
 #include <CSFML/Graphics/Export.h>
 
+#include <CSFML/Graphics/CoordinateType.h>
 #include <CSFML/Graphics/Rect.h>
 #include <CSFML/Graphics/Types.h>
 #include <CSFML/System/InputStream.h>
@@ -37,16 +38,6 @@
 
 #include <stddef.h>
 
-////////////////////////////////////////////////////////////
-/// \brief Types of texture coordinates that can be used for rendering.
-///
-////////////////////////////////////////////////////////////
-typedef enum
-{
-    sfTextureNormalized, ///< sfTexture coordinates in range [0 .. 1].
-    sfTexturePixels      ///< sfTexture coordinates in range [0 .. size].
-} sfTextureCoordinateType;
-
 ////////////////////////////////////////////////////////////
 /// \brief Create a new texture
 ///
@@ -400,7 +391,7 @@ CSFML_GRAPHICS_API unsigned int sfTexture_getNativeHandle(const sfTexture* textu
 /// \param type    Type of texture coordinates to use
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTexture_bind(const sfTexture* texture, sfTextureCoordinateType type);
+CSFML_GRAPHICS_API void sfTexture_bind(const sfTexture* texture, sfCoordinateType type);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the maximum texture size allowed

include/CSFML/Graphics/VertexArray.h

@@ -150,7 +150,7 @@ CSFML_GRAPHICS_API void sfVertexArray_setPrimitiveType(sfVertexArray* vertexArra
 /// \return Primitive type
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfPrimitiveType sfVertexArray_getPrimitiveType(sfVertexArray* vertexArray);
+CSFML_GRAPHICS_API sfPrimitiveType sfVertexArray_getPrimitiveType(const sfVertexArray* vertexArray);
 
 ////////////////////////////////////////////////////////////
 /// \brief Compute the bounding rectangle of a vertex array
@@ -163,4 +163,4 @@ CSFML_GRAPHICS_API sfPrimitiveType sfVertexArray_getPrimitiveType(sfVertexArray*
 /// \return Bounding rectangle of the vertex array
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfFloatRect sfVertexArray_getBounds(sfVertexArray* vertexArray);
+CSFML_GRAPHICS_API sfFloatRect sfVertexArray_getBounds(const sfVertexArray* vertexArray);

include/CSFML/Graphics/VertexBuffer.h

@@ -69,7 +69,7 @@ typedef enum
 /// \return A new sfVertexBuffer object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfVertexBuffer* sfVertexBuffer_create(unsigned int vertexCount, sfPrimitiveType type, sfVertexBufferUsage usage);
+CSFML_GRAPHICS_API sfVertexBuffer* sfVertexBuffer_create(size_t vertexCount, sfPrimitiveType type, sfVertexBufferUsage usage);
 
 ////////////////////////////////////////////////////////////
 /// \brief Copy an existing vertex buffer
@@ -166,7 +166,7 @@ CSFML_GRAPHICS_API void sfVertexBuffer_swap(sfVertexBuffer* left, sfVertexBuffer
 /// \return OpenGL handle of the vertex buffer or 0 if not yet created
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API unsigned int sfVertexBuffer_getNativeHandle(sfVertexBuffer* vertexBuffer);
+CSFML_GRAPHICS_API unsigned int sfVertexBuffer_getNativeHandle(const sfVertexBuffer* vertexBuffer);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the type of primitives to draw
@@ -174,7 +174,7 @@ CSFML_GRAPHICS_API unsigned int sfVertexBuffer_getNativeHandle(sfVertexBuffer* v
 /// This function defines how the vertices must be interpreted
 /// when it's time to draw them.
 ///
-/// The default primitive type is sf::Points.
+/// The default primitive type is sfPoints.
 ///
 /// \param vertexBuffer Vertex buffer object
 /// \param type Type of primitive
@@ -248,7 +248,7 @@ CSFML_GRAPHICS_API void sfVertexBuffer_bind(const sfVertexBuffer* vertexBuffer);
 ///
 /// This function should always be called before using
 /// the vertex buffer features. If it returns false, then
-/// any attempt to use sf::VertexBuffer will fail.
+/// any attempt to use sfVertexBuffer will fail.
 ///
 /// \return True if vertex buffers are supported, false otherwise
 ///

include/CSFML/Graphics/View.h

@@ -191,7 +191,7 @@ CSFML_GRAPHICS_API sfFloatRect sfView_getViewport(const sfView* view);
 CSFML_GRAPHICS_API sfFloatRect sfView_getScissor(const sfView* view);
 
 ////////////////////////////////////////////////////////////
-/// \brief Move a view relatively to its current position
+/// \brief Move a view relative to its current position
 ///
 /// \param view   View object
 /// \param offset Offset
@@ -200,7 +200,7 @@ CSFML_GRAPHICS_API sfFloatRect sfView_getScissor(const sfView* view);
 CSFML_GRAPHICS_API void sfView_move(sfView* view, sfVector2f offset);
 
 ////////////////////////////////////////////////////////////
-/// \brief Rotate a view relatively to its current orientation
+/// \brief Rotate a view relative to its current orientation
 ///
 /// \param view  View object
 /// \param angle Angle to rotate, in degrees
@@ -209,7 +209,7 @@ CSFML_GRAPHICS_API void sfView_move(sfView* view, sfVector2f offset);
 CSFML_GRAPHICS_API void sfView_rotate(sfView* view, float angle);
 
 ////////////////////////////////////////////////////////////
-/// \brief Resize a view rectangle relatively to its current size
+/// \brief Resize a view rectangle relative to its current size
 ///
 /// Resizing the view simulates a zoom, as the zone displayed on
 /// screen grows or shrinks.

include/CSFML/Network/Ftp.h

@@ -225,7 +225,7 @@ CSFML_NETWORK_API const char* sfFtpDirectoryResponse_getMessage(const sfFtpDirec
 ///
 /// \param ftpDirectoryResponse Ftp directory response
 ///
-/// \return Directory name
+/// \return Directory name or NULL if it failed
 ///
 ////////////////////////////////////////////////////////////
 CSFML_NETWORK_API const char* sfFtpDirectoryResponse_getDirectory(const sfFtpDirectoryResponse* ftpDirectoryResponse);
@@ -239,7 +239,7 @@ CSFML_NETWORK_API const char* sfFtpDirectoryResponse_getDirectory(const sfFtpDir
 ///
 /// \param ftpDirectoryResponse Ftp directory response
 ///
-/// \return Directory name
+/// \return Directory name or NULL if it failed
 ///
 ////////////////////////////////////////////////////////////
 CSFML_NETWORK_API const sfChar32* sfFtpDirectoryResponse_getDirectoryUnicode(const sfFtpDirectoryResponse* ftpDirectoryResponse);

include/CSFML/Network/IpAddress.h

@@ -132,7 +132,7 @@ CSFML_NETWORK_API void sfIpAddress_toString(sfIpAddress address, char* string);
 /// address, and should be used for optimization purposes only
 /// (like sending the address through a socket).
 /// The integer produced by this function can then be converted
-/// back to a sfIpAddress with sfIpAddress_FromInteger.
+/// back to a sfIpAddress with sfIpAddress_fromInteger.
 ///
 /// \param address Address object
 ///

include/CSFML/Network/Packet.h

@@ -75,6 +75,8 @@ CSFML_NETWORK_API void sfPacket_append(sfPacket* packet, const void* data, size_
 ///
 /// The next read operation will read data from this position
 ///
+/// \param packet Packet object
+///
 /// \return The byte offset of the current read position
 ///
 /// \see append
@@ -163,6 +165,8 @@ CSFML_NETWORK_API int16_t  sfPacket_readInt16(sfPacket* packet);
 CSFML_NETWORK_API uint16_t sfPacket_readUint16(sfPacket* packet);
 CSFML_NETWORK_API int32_t  sfPacket_readInt32(sfPacket* packet);
 CSFML_NETWORK_API uint32_t sfPacket_readUint32(sfPacket* packet);
+CSFML_NETWORK_API int64_t  sfPacket_readInt64(sfPacket* packet);
+CSFML_NETWORK_API uint64_t sfPacket_readUint64(sfPacket* packet);
 CSFML_NETWORK_API float    sfPacket_readFloat(sfPacket* packet);
 CSFML_NETWORK_API double   sfPacket_readDouble(sfPacket* packet);
 CSFML_NETWORK_API void     sfPacket_readString(sfPacket* packet, char* string);
@@ -181,6 +185,8 @@ CSFML_NETWORK_API void sfPacket_writeInt16(sfPacket* packet, int16_t);
 CSFML_NETWORK_API void sfPacket_writeUint16(sfPacket* packet, uint16_t);
 CSFML_NETWORK_API void sfPacket_writeInt32(sfPacket* packet, int32_t);
 CSFML_NETWORK_API void sfPacket_writeUint32(sfPacket* packet, uint32_t);
+CSFML_NETWORK_API void sfPacket_writeInt64(sfPacket* packet, int64_t);
+CSFML_NETWORK_API void sfPacket_writeUint64(sfPacket* packet, uint64_t);
 CSFML_NETWORK_API void sfPacket_writeFloat(sfPacket* packet, float);
 CSFML_NETWORK_API void sfPacket_writeDouble(sfPacket* packet, double);
 CSFML_NETWORK_API void sfPacket_writeString(sfPacket* packet, const char* string);

include/CSFML/Network/TcpListener.h

@@ -99,6 +99,10 @@ CSFML_NETWORK_API unsigned short sfTcpListener_getLocalPort(const sfTcpListener*
 /// If the socket was previously listening to another port,
 /// it will be stopped first and bound to the new port.
 ///
+/// When providing `sfTcpListener_anyPort()` as port, the listener
+/// will request an available port from the system.
+/// The chosen port can be retrieved by calling `sfTcpListener_getLocalPort()`.
+///
 /// If there is no specific address to listen to, pass sfIpAddress_Any
 ///
 /// \param listener TCP listener object
@@ -110,6 +114,17 @@ CSFML_NETWORK_API unsigned short sfTcpListener_getLocalPort(const sfTcpListener*
 ////////////////////////////////////////////////////////////
 CSFML_NETWORK_API sfSocketStatus sfTcpListener_listen(sfTcpListener* listener, unsigned short port, sfIpAddress address);
 
+////////////////////////////////////////////////////////////
+/// \brief Stop listening and close the socket
+///
+/// This function gracefully stops the listener. If the
+/// socket is not listening, this function has no effect.
+///
+/// \param listener  TCP listener object
+///
+////////////////////////////////////////////////////////////
+CSFML_NETWORK_API void sfTcpListener_close(sfTcpListener* listener);
+
 ////////////////////////////////////////////////////////////
 /// \brief Accept a new connection
 ///
@@ -127,3 +142,12 @@ CSFML_NETWORK_API sfSocketStatus sfTcpListener_listen(sfTcpListener* listener, u
 ///
 ////////////////////////////////////////////////////////////
 CSFML_NETWORK_API sfSocketStatus sfTcpListener_accept(sfTcpListener* listener, sfTcpSocket** connected);
+
+////////////////////////////////////////////////////////////
+/// \brief Return the special value that tells the system
+///        to pick any available port
+///
+/// \return The value to use for any port
+///
+////////////////////////////////////////////////////////////
+CSFML_NETWORK_API unsigned short sfTcpListener_anyPort(void);

include/CSFML/Network/TcpSocket.h

@@ -153,7 +153,7 @@ CSFML_NETWORK_API void sfTcpSocket_disconnect(sfTcpSocket* socket);
 /// \brief Send raw data to the remote peer of a TCP socket
 ///
 /// To be able to handle partial sends over non-blocking
-/// sockets, use the sfTcpSocket_sendPartial(sfTcpSocket*, const void*, std::size_t, size_t*)
+/// sockets, use the sfTcpSocket_sendPartial(sfTcpSocket*, const void*, size_t, size_t*)
 /// overload instead.
 /// This function will fail if the socket is not connected.
 ///

include/CSFML/Network/UdpSocket.h

@@ -102,6 +102,10 @@ CSFML_NETWORK_API unsigned short sfUdpSocket_getLocalPort(const sfUdpSocket* soc
 /// system to automatically pick an available port, and then
 /// call sfUdpSocket_getLocalPort to retrieve the chosen port.
 ///
+/// When providing `sfUdpSocket_anyPort()` as port, the listener
+/// will request an available port from the system.
+/// The chosen port can be retrieved by calling `sfUdpSocket_getLocalPort()`.
+///
 /// If there is no specific address to listen to, pass sfIpAddress_Any
 ///
 /// \param socket  UDP socket object
@@ -215,3 +219,12 @@ CSFML_NETWORK_API sfSocketStatus
 ///
 ////////////////////////////////////////////////////////////
 CSFML_NETWORK_API unsigned int sfUdpSocket_maxDatagramSize(void);
+
+////////////////////////////////////////////////////////////
+/// \brief Return the special value that tells the system
+///        to pick any available port
+///
+/// \return The value to use for any port
+///
+////////////////////////////////////////////////////////////
+CSFML_NETWORK_API unsigned short sfUdpSocket_anyPort(void);

include/CSFML/System/Time.h

@@ -43,7 +43,7 @@ typedef struct
 /// \brief Predefined "zero" time value
 ///
 ////////////////////////////////////////////////////////////
-CSFML_SYSTEM_API sfTime sfTime_Zero;
+CSFML_SYSTEM_API const sfTime sfTime_Zero;
 
 ////////////////////////////////////////////////////////////
 /// \brief Return a time value as a number of seconds

include/CSFML/Window/Keyboard.h

@@ -142,10 +142,12 @@ typedef enum
     sfKeyF14,          ///< The F14 key
     sfKeyF15,          ///< The F15 key
     sfKeyPause,        ///< The Pause key
-
-    sfKeyCount, ///< Keep last -- the total number of keyboard keys
 } sfKeyCode;
 
+enum
+{
+    sfKeyCount = sfKeyPause + 1 ///< The total number of keyboard keys
+};
 
 ////////////////////////////////////////////////////////////
 /// \brief Scancodes
@@ -310,10 +312,12 @@ typedef enum
     sfScanLaunchApplication2, //!< Keyboard Launch Application 2 key
     sfScanLaunchMail,         //!< Keyboard Launch Mail key
     sfScanLaunchMediaSelect,  //!< Keyboard Launch Media Select key
-
-    sfScancodeCount //!< Keep last -- the total number of scancodes
 } sfScancode;
 
+enum
+{
+    sfScancodeCount = sfScanLaunchMediaSelect + 1 //!< The total number of scancodes
+};
 
 ////////////////////////////////////////////////////////////
 /// \brief Check if a key is pressed

include/CSFML/Window/Mouse.h

@@ -39,15 +39,18 @@
 ////////////////////////////////////////////////////////////
 typedef enum
 {
-    sfMouseLeft,     ///< The left mouse button
-    sfMouseRight,    ///< The right mouse button
-    sfMouseMiddle,   ///< The middle (wheel) mouse button
-    sfMouseXButton1, ///< The first extra mouse button
-    sfMouseXButton2, ///< The second extra mouse button
-
-    sfMouseButtonCount ///< Keep last -- the total number of mouse buttons
+    sfMouseLeft,         ///< The left mouse button
+    sfMouseRight,        ///< The right mouse button
+    sfMouseMiddle,       ///< The middle (wheel) mouse button
+    sfMouseButtonExtra1, ///< The first extra mouse button
+    sfMouseButtonExtra2, ///< The second extra mouse button
 } sfMouseButton;
 
+enum
+{
+    sfMouseButtonCount = sfMouseButtonExtra2 + 1 ///< The total number of mouse buttons
+};
+
 ////////////////////////////////////////////////////////////
 /// \brief Mouse wheels
 ///

include/CSFML/Window/Sensor.h

@@ -45,10 +45,12 @@ typedef enum
     sfSensorGravity, ///< Measures the direction and intensity of gravity, independent of device acceleration (m/s^2)
     sfSensorUserAcceleration, ///< Measures the direction and intensity of device acceleration, independent of the gravity (m/s^2)
     sfSensorOrientation, ///< Measures the absolute 3D orientation (degrees)
-
-    sfSensorCount ///< Keep last -- the total number of sensor types
 } sfSensorType;
 
+enum
+{
+    sfSensorCount = sfSensorOrientation + 1 ///< The total number of sensor types
+};
 
 ////////////////////////////////////////////////////////////
 /// \brief Check if a sensor is available on the underlying platform

readme.md

@@ -9,7 +9,7 @@ SFML is a simple, fast, cross-platform and object-oriented multimedia API. It pr
 Development is focused on the next major version in the `master` branch. No more features are planned for the 2.x release series.
 
 -   The [`master`](https://github.com/SFML/CSFML/tree/master) branch contains work in progress for the next major version CSFML 3. As such it's considered unstable, but any testing and feedback is highly appreciated.
--   The [`2.6.1`](https://github.com/SFML/CSFML/tree/2.6.1) tag is the latest official SFML release and will be the last minor release in the 2.x series.
+-   The [`2.6.1`](https://github.com/SFML/CSFML/tree/2.6.1) tag is the latest official CSFML release and will be the last minor release in the 2.x series.
 -   The [`2.6.x`](https://github.com/SFML/CSFML/tree/2.6.x) branch contains the latest bugfix work on CSFML 2.6.x, matching SFML's `2.6.x` branch.
 
 ## Authors

src/CSFML/Audio/Music.cpp

@@ -83,7 +83,7 @@ void sfMusic_destroy(const sfMusic* music)
 void sfMusic_setLooping(sfMusic* music, bool loop)
 {
     assert(music);
-    music->setLooping(loop != 0);
+    music->setLooping(loop);
 }
 
 

src/CSFML/Audio/SoundRecorder.cpp

@@ -81,18 +81,17 @@ bool sfSoundRecorder_isAvailable()
 
 
 ////////////////////////////////////////////////////////////
-const char** sfSoundRecorder_getAvailableDevices(size_t* count)
+const char* const* sfSoundRecorder_getAvailableDevices(size_t* count)
 {
-    static std::vector<std::string> stringDevices = sf::SoundRecorder::getAvailableDevices();
-    static std::vector<const char*> cstringDevices;
-
-    if (cstringDevices.empty() && !stringDevices.empty())
+    static const auto cstringDevices = []
     {
+        static const std::vector<std::string> stringDevices = sf::SoundRecorder::getAvailableDevices();
+        std::vector<const char*>              devices;
+        devices.reserve(stringDevices.size());
         for (const auto& stringDevice : stringDevices)
-        {
-            cstringDevices.push_back(stringDevice.c_str());
-        }
-    }
+            devices.push_back(stringDevice.c_str());
+        return devices;
+    }();
 
     if (count)
         *count = cstringDevices.size();
@@ -104,7 +103,7 @@ const char** sfSoundRecorder_getAvailableDevices(size_t* count)
 ////////////////////////////////////////////////////////////
 const char* sfSoundRecorder_getDefaultDevice()
 {
-    static std::string defaultDevice = sf::SoundRecorder::getDefaultDevice();
+    static const std::string defaultDevice = sf::SoundRecorder::getDefaultDevice();
 
     return !defaultDevice.empty() ? defaultDevice.c_str() : nullptr;
 }

src/CSFML/ConvertEvent.hpp

@@ -1,181 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-//    you must not claim that you wrote the original software.
-//    If you use this software in a product, an acknowledgment
-//    in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-//    and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#pragma once
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <CSFML/System/ConvertVector2.hpp>
-#include <CSFML/System/ConvertVector3.hpp>
-#include <CSFML/Window/Event.h>
-
-#include <SFML/Window/Event.hpp>
-
-#include <optional>
-
-
-////////////////////////////////////////////////////////////
-// Convert sf::Event to sfEvent
-////////////////////////////////////////////////////////////
-[[nodiscard]] inline bool convertEvent(const std::optional<sf::Event>& sfmlEvent, sfEvent* event)
-{
-    if (!sfmlEvent)
-        return false;
-
-    if (sfmlEvent->is<sf::Event::Closed>())
-    {
-        event->type = sfEvtClosed;
-    }
-    else if (const auto* resized = sfmlEvent->getIf<sf::Event::Resized>())
-    {
-        event->type      = sfEvtResized;
-        event->size.size = convertVector2(resized->size);
-    }
-    else if (sfmlEvent->is<sf::Event::FocusLost>())
-    {
-        event->type = sfEvtFocusLost;
-    }
-    else if (sfmlEvent->is<sf::Event::FocusGained>())
-    {
-        event->type = sfEvtFocusGained;
-    }
-    else if (const auto* textEntered = sfmlEvent->getIf<sf::Event::TextEntered>())
-    {
-        event->type         = sfEvtTextEntered;
-        event->text.unicode = textEntered->unicode;
-    }
-    else if (const auto* keyReleased = sfmlEvent->getIf<sf::Event::KeyReleased>())
-    {
-        event->type         = sfEvtKeyReleased;
-        event->key.code     = static_cast<sfKeyCode>(keyReleased->code);
-        event->key.scancode = static_cast<sfScancode>(keyReleased->scancode);
-        event->key.alt      = keyReleased->alt;
-        event->key.control  = keyReleased->control;
-        event->key.shift    = keyReleased->shift;
-        event->key.system   = keyReleased->system;
-    }
-    else if (const auto* keyPressed = sfmlEvent->getIf<sf::Event::KeyPressed>())
-    {
-        event->type         = sfEvtKeyPressed;
-        event->key.code     = static_cast<sfKeyCode>(keyPressed->code);
-        event->key.scancode = static_cast<sfScancode>(keyPressed->scancode);
-        event->key.alt      = keyPressed->alt;
-        event->key.control  = keyPressed->control;
-        event->key.shift    = keyPressed->shift;
-        event->key.system   = keyPressed->system;
-    }
-    else if (const auto* mouseWheelScrolled = sfmlEvent->getIf<sf::Event::MouseWheelScrolled>())
-    {
-        event->type                      = sfEvtMouseWheelScrolled;
-        event->mouseWheelScroll.wheel    = static_cast<sfMouseWheel>(mouseWheelScrolled->wheel);
-        event->mouseWheelScroll.delta    = mouseWheelScrolled->delta;
-        event->mouseWheelScroll.position = convertVector2(mouseWheelScrolled->position);
-    }
-    else if (const auto* mouseButtonPressed = sfmlEvent->getIf<sf::Event::MouseButtonPressed>())
-    {
-        event->type                 = sfEvtMouseButtonPressed;
-        event->mouseButton.button   = static_cast<sfMouseButton>(mouseButtonPressed->button);
-        event->mouseButton.position = convertVector2(mouseButtonPressed->position);
-    }
-    else if (const auto* mouseButtonReleased = sfmlEvent->getIf<sf::Event::MouseButtonReleased>())
-    {
-        event->type                 = sfEvtMouseButtonReleased;
-        event->mouseButton.button   = static_cast<sfMouseButton>(mouseButtonReleased->button);
-        event->mouseButton.position = convertVector2(mouseButtonReleased->position);
-    }
-    else if (const auto* mouseMoved = sfmlEvent->getIf<sf::Event::MouseMoved>())
-    {
-        event->type               = sfEvtMouseMoved;
-        event->mouseMove.position = convertVector2(mouseMoved->position);
-    }
-    else if (const auto* mouseMovedRaw = sfmlEvent->getIf<sf::Event::MouseMovedRaw>())
-    {
-        event->type               = sfEvtMouseMovedRaw;
-        event->mouseMoveRaw.delta = convertVector2(mouseMovedRaw->delta);
-    }
-    else if (sfmlEvent->is<sf::Event::MouseEntered>())
-    {
-        event->type = sfEvtMouseEntered;
-    }
-    else if (sfmlEvent->is<sf::Event::MouseLeft>())
-    {
-        event->type = sfEvtMouseLeft;
-    }
-    else if (const auto* joystickButtonPressed = sfmlEvent->getIf<sf::Event::JoystickButtonPressed>())
-    {
-        event->type                      = sfEvtJoystickButtonPressed;
-        event->joystickButton.joystickId = joystickButtonPressed->joystickId;
-        event->joystickButton.button     = joystickButtonPressed->button;
-    }
-    else if (const auto* joystickButtonReleased = sfmlEvent->getIf<sf::Event::JoystickButtonReleased>())
-    {
-        event->type                      = sfEvtJoystickButtonReleased;
-        event->joystickButton.joystickId = joystickButtonReleased->joystickId;
-        event->joystickButton.button     = joystickButtonReleased->button;
-    }
-    else if (const auto* joystickMoved = sfmlEvent->getIf<sf::Event::JoystickMoved>())
-    {
-        event->type                    = sfEvtJoystickMoved;
-        event->joystickMove.joystickId = joystickMoved->joystickId;
-        event->joystickMove.axis       = static_cast<sfJoystickAxis>(joystickMoved->axis);
-        event->joystickMove.position   = joystickMoved->position;
-    }
-    else if (const auto* joystickConnected = sfmlEvent->getIf<sf::Event::JoystickConnected>())
-    {
-        event->type                       = sfEvtJoystickConnected;
-        event->joystickConnect.joystickId = joystickConnected->joystickId;
-    }
-    else if (const auto* joystickDisconnected = sfmlEvent->getIf<sf::Event::JoystickDisconnected>())
-    {
-        event->type                       = sfEvtJoystickDisconnected;
-        event->joystickConnect.joystickId = joystickDisconnected->joystickId;
-    }
-    else if (const auto* touchBegan = sfmlEvent->getIf<sf::Event::TouchBegan>())
-    {
-        event->type           = sfEvtTouchBegan;
-        event->touch.finger   = touchBegan->finger;
-        event->touch.position = convertVector2(touchBegan->position);
-    }
-    else if (const auto* touchMoved = sfmlEvent->getIf<sf::Event::TouchMoved>())
-    {
-        event->type           = sfEvtTouchMoved;
-        event->touch.finger   = touchMoved->finger;
-        event->touch.position = convertVector2(touchMoved->position);
-    }
-    else if (const auto* touchEnded = sfmlEvent->getIf<sf::Event::TouchEnded>())
-    {
-        event->type           = sfEvtTouchEnded;
-        event->touch.finger   = touchEnded->finger;
-        event->touch.position = convertVector2(touchEnded->position);
-    }
-    else if (const auto* sensorChanged = sfmlEvent->getIf<sf::Event::SensorChanged>())
-    {
-        event->type              = sfEvtSensorChanged;
-        event->sensor.sensorType = static_cast<sfSensorType>(sensorChanged->type);
-        event->sensor.value      = convertVector3(sensorChanged->value);
-    }
-
-    return true;
-}

src/CSFML/Graphics/CMakeLists.txt

@@ -19,6 +19,7 @@ set(SRC
     ${SRCROOT}/ConvexShape.cpp
     ${SRCROOT}/ConvexShapeStruct.hpp
     ${INCROOT}/ConvexShape.h
+    ${INCROOT}/CoordinateType.h
     ${SRCROOT}/Font.cpp
     ${SRCROOT}/FontStruct.hpp
     ${INCROOT}/Font.h

src/CSFML/Graphics/CircleShape.cpp

@@ -170,7 +170,7 @@ sfTransform sfCircleShape_getInverseTransform(const sfCircleShape* shape)
 void sfCircleShape_setTexture(sfCircleShape* shape, const sfTexture* texture, bool resetRect)
 {
     assert(shape);
-    shape->setTexture(texture, resetRect);
+    shape->setTexture(texture ? texture->This : nullptr, resetRect);
     shape->Texture = texture;
 }
 

src/CSFML/Graphics/Color.cpp

@@ -45,33 +45,26 @@ const sfColor sfTransparent = sfColor_fromRGBA(0, 0, 0, 0);
 ////////////////////////////////////////////////////////////
 sfColor sfColor_fromRGB(uint8_t red, uint8_t green, uint8_t blue)
 {
-    return sfColor_fromRGBA(red, green, blue, 255);
+    return {red, green, blue, 255};
 }
 
 
 ////////////////////////////////////////////////////////////
 sfColor sfColor_fromRGBA(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha)
 {
-    sfColor color;
-
-    color.r = red;
-    color.g = green;
-    color.b = blue;
-    color.a = alpha;
-
-    return color;
+    return {red, green, blue, alpha};
 }
 
 
 ////////////////////////////////////////////////////////////
 sfColor sfColor_fromInteger(uint32_t color)
 {
-    auto red   = static_cast<uint8_t>((color & 0xff000000) >> 24);
-    auto green = static_cast<uint8_t>((color & 0x00ff0000) >> 16);
-    auto blue  = static_cast<uint8_t>((color & 0x0000ff00) >> 8);
-    auto alpha = static_cast<uint8_t>((color & 0x000000ff) >> 0);
-
-    return sfColor_fromRGBA(red, green, blue, alpha);
+    return {
+        static_cast<uint8_t>((color & 0xff000000) >> 24),
+        static_cast<uint8_t>((color & 0x00ff0000) >> 16),
+        static_cast<uint8_t>((color & 0x0000ff00) >> 8),
+        static_cast<uint8_t>((color & 0x000000ff) >> 0),
+    };
 }
 
 
@@ -85,43 +78,34 @@ uint32_t sfColor_toInteger(sfColor color)
 ////////////////////////////////////////////////////////////
 sfColor sfColor_add(sfColor color1, sfColor color2)
 {
-    int red   = std::min(color1.r + color2.r, 255);
-    int green = std::min(color1.g + color2.g, 255);
-    int blue  = std::min(color1.b + color2.b, 255);
-    int alpha = std::min(color1.a + color2.a, 255);
-
-    return sfColor_fromRGBA(static_cast<uint8_t>(red),
-                            static_cast<uint8_t>(green),
-                            static_cast<uint8_t>(blue),
-                            static_cast<uint8_t>(alpha));
+    return {
+        static_cast<uint8_t>(std::min(color1.r + color2.r, 255)),
+        static_cast<uint8_t>(std::min(color1.g + color2.g, 255)),
+        static_cast<uint8_t>(std::min(color1.b + color2.b, 255)),
+        static_cast<uint8_t>(std::min(color1.a + color2.a, 255)),
+    };
 }
 
 
 ////////////////////////////////////////////////////////////
 sfColor sfColor_subtract(sfColor color1, sfColor color2)
 {
-    int red   = std::max(color1.r - color2.r, 0);
-    int green = std::max(color1.g - color2.g, 0);
-    int blue  = std::max(color1.b - color2.b, 0);
-    int alpha = std::max(color1.a - color2.a, 0);
-
-    return sfColor_fromRGBA(static_cast<uint8_t>(red),
-                            static_cast<uint8_t>(green),
-                            static_cast<uint8_t>(blue),
-                            static_cast<uint8_t>(alpha));
+    return {
+        static_cast<uint8_t>(std::max(color1.r - color2.r, 0)),
+        static_cast<uint8_t>(std::max(color1.g - color2.g, 0)),
+        static_cast<uint8_t>(std::max(color1.b - color2.b, 0)),
+        static_cast<uint8_t>(std::max(color1.a - color2.a, 0)),
+    };
 }
 
 
 ////////////////////////////////////////////////////////////
 sfColor sfColor_modulate(sfColor color1, sfColor color2)
 {
-    int red   = color1.r * color2.r / 255;
-    int green = color1.g * color2.g / 255;
-    int blue  = color1.b * color2.b / 255;
-    int alpha = color1.a * color2.a / 255;
-
-    return sfColor_fromRGBA(static_cast<uint8_t>(red),
-                            static_cast<uint8_t>(green),
-                            static_cast<uint8_t>(blue),
-                            static_cast<uint8_t>(alpha));
+    return {
+        static_cast<uint8_t>(color1.r * color2.r / 255),
+        static_cast<uint8_t>(color1.g * color2.g / 255),
+        static_cast<uint8_t>(color1.b * color2.b / 255),
+        static_cast<uint8_t>(color1.a * color2.a / 255),
+    };
 }

src/CSFML/Graphics/ConvertRenderStates.hpp

@@ -50,8 +50,15 @@
     renderStates.blendMode.alphaSrcFactor = static_cast<sf::BlendMode::Factor>(states->blendMode.alphaSrcFactor);
     renderStates.blendMode.alphaDstFactor = static_cast<sf::BlendMode::Factor>(states->blendMode.alphaDstFactor);
     renderStates.blendMode.alphaEquation  = static_cast<sf::BlendMode::Equation>(states->blendMode.alphaEquation);
-    renderStates.transform                = convertTransform(states->transform);
-    renderStates.texture                  = states->texture;
-    renderStates.shader                   = states->shader;
+    renderStates.stencilMode.stencilComparison = static_cast<sf::StencilComparison>(states->stencilMode.stencilComparison);
+    renderStates.stencilMode.stencilUpdateOperation = static_cast<sf::StencilUpdateOperation>(
+        states->stencilMode.stencilUpdateOperation);
+    renderStates.stencilMode.stencilReference.value = states->stencilMode.stencilReference.value;
+    renderStates.stencilMode.stencilMask.value      = states->stencilMode.stencilMask.value;
+    renderStates.stencilMode.stencilOnly            = states->stencilMode.stencilOnly;
+    renderStates.transform                          = convertTransform(states->transform);
+    renderStates.coordinateType                     = static_cast<sf::CoordinateType>(states->coordinateType);
+    renderStates.texture                            = states->texture ? states->texture->This : nullptr;
+    renderStates.shader                             = states->shader;
     return renderStates;
 }

src/CSFML/Graphics/ConvexShape.cpp

@@ -167,7 +167,7 @@ sfTransform sfConvexShape_getInverseTransform(const sfConvexShape* shape)
 void sfConvexShape_setTexture(sfConvexShape* shape, const sfTexture* texture, bool resetRect)
 {
     assert(shape);
-    shape->setTexture(texture, resetRect);
+    shape->setTexture(texture ? texture->This : nullptr, resetRect);
     shape->Texture = texture;
 }
 

src/CSFML/Graphics/Font.cpp

@@ -152,7 +152,7 @@ const sfTexture* sfFont_getTexture(sfFont* font, unsigned int characterSize)
 {
     assert(font);
 
-    font->Textures[characterSize] = sfTexture{font->getTexture(characterSize)};
+    *font->Textures[characterSize].This = font->getTexture(characterSize);
 
     return &font->Textures[characterSize];
 }

src/CSFML/Graphics/RectangleShape.cpp

@@ -167,7 +167,7 @@ sfTransform sfRectangleShape_getInverseTransform(const sfRectangleShape* shape)
 void sfRectangleShape_setTexture(sfRectangleShape* shape, const sfTexture* texture, bool resetRect)
 {
     assert(shape);
-    shape->setTexture(texture, resetRect);
+    shape->setTexture(texture ? texture->This : nullptr, resetRect);
     shape->Texture = texture;
 }
 

src/CSFML/Graphics/RenderStates.cpp

@@ -31,7 +31,9 @@
 ////////////////////////////////////////////////////////////
 const sfRenderStates sfRenderStates_default = {
     sfBlendAlpha,
+    sfStencilMode_default,
     sfTransform_Identity,
+    sfCoordinateTypePixels,
     nullptr,
     nullptr,
 };

src/CSFML/Graphics/RenderTexture.cpp

@@ -54,7 +54,7 @@ sfRenderTexture* sfRenderTexture_create(sfVector2u size, const sfContextSettings
     if (!renderTexture->resize(convertVector2(size), params))
         return nullptr;
 
-    renderTexture->Target      = sfTexture{renderTexture->getTexture()};
+    renderTexture->Target      = std::make_unique<sfTexture>(const_cast<sf::Texture*>(&renderTexture->getTexture()));
     renderTexture->DefaultView = sfView{renderTexture->getDefaultView()};
     renderTexture->CurrentView = sfView{renderTexture->getView()};
 
@@ -300,7 +300,7 @@ void sfRenderTexture_resetGLStates(sfRenderTexture* renderTexture)
 const sfTexture* sfRenderTexture_getTexture(const sfRenderTexture* renderTexture)
 {
     assert(renderTexture);
-    return &renderTexture->Target;
+    return renderTexture->Target.get();
 }
 
 

src/CSFML/Graphics/RenderTextureStruct.hpp

@@ -32,13 +32,15 @@
 
 #include <SFML/Graphics/RenderTexture.hpp>
 
+#include <memory>
+
 
 ////////////////////////////////////////////////////////////
 // Internal structure of sfRenderTexture
 ////////////////////////////////////////////////////////////
 struct sfRenderTexture : sf::RenderTexture
 {
-    sfTexture Target;
-    sfView    DefaultView;
-    sfView    CurrentView;
+    std::unique_ptr<const sfTexture> Target;
+    sfView                           DefaultView;
+    sfView                           CurrentView;
 };

src/CSFML/Graphics/RenderWindow.cpp

@@ -25,7 +25,6 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/ConvertEvent.hpp>
 #include <CSFML/Graphics/CircleShapeStruct.hpp>
 #include <CSFML/Graphics/ConvertColor.hpp>
 #include <CSFML/Graphics/ConvertRect.hpp>
@@ -43,6 +42,7 @@
 #include <CSFML/Graphics/VertexBufferStruct.hpp>
 #include <CSFML/System/ConvertVector2.hpp>
 #include <CSFML/Window/ConvertContextSettings.hpp>
+#include <CSFML/Window/ConvertEvent.hpp>
 #include <CSFML/Window/ConvertVideoMode.hpp>
 #include <CSFML/Window/CursorStruct.hpp>
 
@@ -145,7 +145,7 @@ bool sfRenderWindow_pollEvent(sfRenderWindow* renderWindow, sfEvent* event)
 {
     assert(renderWindow);
     assert(event);
-    return convertEvent(renderWindow->pollEvent(), event);
+    return convertEvent(renderWindow->pollEvent(), *event);
 }
 
 
@@ -154,7 +154,7 @@ bool sfRenderWindow_waitEvent(sfRenderWindow* renderWindow, sfTime timeout, sfEv
 {
     assert(renderWindow);
     assert(event);
-    return convertEvent(renderWindow->waitEvent(sf::microseconds(timeout.microseconds)), event);
+    return convertEvent(renderWindow->waitEvent(sf::microseconds(timeout.microseconds)), *event);
 }
 
 

src/CSFML/Graphics/Shader.cpp

@@ -37,41 +37,28 @@ sfShader* sfShader_createFromFile(const char* vertexShaderFilename,
                                   const char* geometryShaderFilename,
                                   const char* fragmentShaderFilename)
 {
+    // At least one shader must be provided
+    if (!(vertexShaderFilename || geometryShaderFilename || fragmentShaderFilename))
+        return nullptr;
+
     bool success = false;
     auto shader  = std::make_unique<sfShader>();
-    if (vertexShaderFilename || geometryShaderFilename || fragmentShaderFilename)
+
+    if (!geometryShaderFilename)
     {
-        if (!geometryShaderFilename)
-        {
-            if (!vertexShaderFilename)
-            {
-                // fragment shader only
-                success = shader->loadFromFile(fragmentShaderFilename, sf::Shader::Type::Fragment);
-            }
-            else if (!fragmentShaderFilename)
-            {
-                // vertex shader only
-                success = shader->loadFromFile(vertexShaderFilename, sf::Shader::Type::Vertex);
-            }
-            else
-            {
-                // vertex + fragment shaders
-                success = shader->loadFromFile(vertexShaderFilename, fragmentShaderFilename);
-            }
-        }
-        else
-        {
-            if (!vertexShaderFilename && !fragmentShaderFilename)
-            {
-                // geometry shader only
-                success = shader->loadFromFile(geometryShaderFilename, sf::Shader::Type::Geometry);
-            }
-            else
-            {
-                // vertex + geometry + fragment shaders
-                success = shader->loadFromFile(vertexShaderFilename, geometryShaderFilename, fragmentShaderFilename);
-            }
-        }
+        if (!vertexShaderFilename) // fragment shader only
+            success = shader->loadFromFile(fragmentShaderFilename, sf::Shader::Type::Fragment);
+        else if (!fragmentShaderFilename) // vertex shader only
+            success = shader->loadFromFile(vertexShaderFilename, sf::Shader::Type::Vertex);
+        else // vertex + fragment shaders
+            success = shader->loadFromFile(vertexShaderFilename, fragmentShaderFilename);
+    }
+    else
+    {
+        if (!vertexShaderFilename && !fragmentShaderFilename) // geometry shader only
+            success = shader->loadFromFile(geometryShaderFilename, sf::Shader::Type::Geometry);
+        else // vertex + geometry + fragment shaders
+            success = shader->loadFromFile(vertexShaderFilename, geometryShaderFilename, fragmentShaderFilename);
     }
 
     if (!success)
@@ -84,41 +71,28 @@ sfShader* sfShader_createFromFile(const char* vertexShaderFilename,
 ////////////////////////////////////////////////////////////
 sfShader* sfShader_createFromMemory(const char* vertexShader, const char* geometryShader, const char* fragmentShader)
 {
+    // At least one shader must be provided
+    if (!(vertexShader || geometryShader || fragmentShader))
+        return nullptr;
+
     bool success = false;
     auto shader  = std::make_unique<sfShader>();
-    if (vertexShader || geometryShader || fragmentShader)
+
+    if (!geometryShader)
     {
-        if (!geometryShader)
-        {
-            if (!vertexShader)
-            {
-                // fragment shader only
-                success = shader->loadFromMemory(fragmentShader, sf::Shader::Type::Fragment);
-            }
-            else if (!fragmentShader)
-            {
-                // vertex shader only
-                success = shader->loadFromMemory(vertexShader, sf::Shader::Type::Vertex);
-            }
-            else
-            {
-                // vertex + fragment shaders
-                success = shader->loadFromMemory(vertexShader, fragmentShader);
-            }
-        }
-        else
-        {
-            if (!vertexShader && !fragmentShader)
-            {
-                // geometry shader only
-                success = shader->loadFromMemory(geometryShader, sf::Shader::Type::Geometry);
-            }
-            else
-            {
-                // vertex + geometry + fragment shaders
-                success = shader->loadFromMemory(vertexShader, geometryShader, fragmentShader);
-            }
-        }
+        if (!vertexShader) // fragment shader only
+            success = shader->loadFromMemory(fragmentShader, sf::Shader::Type::Fragment);
+        else if (!fragmentShader) // vertex shader only
+            success = shader->loadFromMemory(vertexShader, sf::Shader::Type::Vertex);
+        else // vertex + fragment shaders
+            success = shader->loadFromMemory(vertexShader, fragmentShader);
+    }
+    else
+    {
+        if (!vertexShader && !fragmentShader) // geometry shader only
+            success = shader->loadFromMemory(geometryShader, sf::Shader::Type::Geometry);
+        else // vertex + geometry + fragment shaders
+            success = shader->loadFromMemory(vertexShader, geometryShader, fragmentShader);
     }
 
     if (!success)
@@ -133,47 +107,44 @@ sfShader* sfShader_createFromStream(sfInputStream* vertexShaderStream,
                                     sfInputStream* geometryShaderStream,
                                     sfInputStream* fragmentShaderStream)
 {
+    // At least one shader must be provided
+    if (!(vertexShaderStream || geometryShaderStream || fragmentShaderStream))
+        return nullptr;
+
     bool success = false;
     auto shader  = std::make_unique<sfShader>();
-    if (vertexShaderStream || geometryShaderStream || fragmentShaderStream)
+
+    if (!geometryShaderStream)
     {
-        if (!geometryShaderStream)
+        if (!vertexShaderStream) // fragment shader only
         {
-            if (!vertexShaderStream)
-            {
-                // fragment shader only
-                CallbackStream stream(fragmentShaderStream);
-                success = shader->loadFromStream(stream, sf::Shader::Type::Fragment);
-            }
-            else if (!fragmentShaderStream)
-            {
-                // vertex shader only
-                CallbackStream stream(vertexShaderStream);
-                success = shader->loadFromStream(stream, sf::Shader::Type::Vertex);
-            }
-            else
-            {
-                // vertex + fragment shaders
-                CallbackStream vertexStream(vertexShaderStream);
-                CallbackStream fragmentStream(fragmentShaderStream);
-                success = shader->loadFromStream(vertexStream, fragmentStream);
-            }
+            CallbackStream stream(fragmentShaderStream);
+            success = shader->loadFromStream(stream, sf::Shader::Type::Fragment);
         }
-        else
+        else if (!fragmentShaderStream) // vertex shader only
         {
-            CallbackStream geometryStream(geometryShaderStream);
-            if (!vertexShaderStream && !fragmentShaderStream)
-            {
-                // geometry shader only
-                success = shader->loadFromStream(geometryStream, sf::Shader::Type::Geometry);
-            }
-            else
-            {
-                // vertex + geometry + fragment shaders
-                CallbackStream vertexStream(vertexShaderStream);
-                CallbackStream fragmentStream(fragmentShaderStream);
-                success = shader->loadFromStream(vertexStream, geometryStream, fragmentStream);
-            }
+            CallbackStream stream(vertexShaderStream);
+            success = shader->loadFromStream(stream, sf::Shader::Type::Vertex);
+        }
+        else // vertex + fragment shaders
+        {
+            CallbackStream vertexStream(vertexShaderStream);
+            CallbackStream fragmentStream(fragmentShaderStream);
+            success = shader->loadFromStream(vertexStream, fragmentStream);
+        }
+    }
+    else
+    {
+        CallbackStream geometryStream(geometryShaderStream);
+        if (!vertexShaderStream && !fragmentShaderStream) // geometry shader only
+        {
+            success = shader->loadFromStream(geometryStream, sf::Shader::Type::Geometry);
+        }
+        else // vertex + geometry + fragment shaders
+        {
+            CallbackStream vertexStream(vertexShaderStream);
+            CallbackStream fragmentStream(fragmentShaderStream);
+            success = shader->loadFromStream(vertexStream, geometryStream, fragmentStream);
         }
     }
 
@@ -230,13 +201,14 @@ void sfShader_setVec4Uniform(sfShader* shader, const char* name, sfGlslVec4 vect
 ////////////////////////////////////////////////////////////
 void sfShader_setColorUniform(sfShader* shader, const char* name, sfColor color)
 {
-    sfGlslVec4 vec4;
-    vec4.x = color.r / 255.f;
-    vec4.y = color.g / 255.f;
-    vec4.z = color.b / 255.f;
-    vec4.w = color.a / 255.f;
-
-    sfShader_setVec4Uniform(shader, name, vec4);
+    sfShader_setVec4Uniform(shader,
+                            name,
+                            {
+                                color.r / 255.f,
+                                color.g / 255.f,
+                                color.b / 255.f,
+                                color.a / 255.f,
+                            });
 }
 
 ////////////////////////////////////////////////////////////
@@ -278,13 +250,14 @@ void sfShader_setIvec4Uniform(sfShader* shader, const char* name, sfGlslIvec4 ve
 ////////////////////////////////////////////////////////////
 void sfShader_setIntColorUniform(sfShader* shader, const char* name, sfColor color)
 {
-    sfGlslIvec4 ivec4;
-    ivec4.x = static_cast<int>(color.r);
-    ivec4.y = static_cast<int>(color.g);
-    ivec4.z = static_cast<int>(color.b);
-    ivec4.w = static_cast<int>(color.a);
-
-    sfShader_setIvec4Uniform(shader, name, ivec4);
+    sfShader_setIvec4Uniform(shader,
+                             name,
+                             {
+                                 color.r,
+                                 color.g,
+                                 color.b,
+                                 color.a,
+                             });
 }
 
 ////////////////////////////////////////////////////////////
@@ -346,8 +319,7 @@ void sfShader_setTextureUniform(sfShader* shader, const char* name, const sfText
 {
     assert(shader);
     assert(name);
-    assert(texture);
-    shader->setUniform(name, *texture);
+    shader->setUniform(name, *texture->This);
 }
 
 
@@ -420,7 +392,7 @@ void sfShader_setTextureParameter(sfShader* shader, const char* name, const sfTe
     assert(shader);
     assert(name);
     assert(texture);
-    shader->setUniform(name, *texture);
+    shader->setUniform(name, *texture->This);
 }
 
 

src/CSFML/Graphics/Shape.cpp

@@ -159,7 +159,7 @@ sfTransform sfShape_getInverseTransform(const sfShape* shape)
 void sfShape_setTexture(sfShape* shape, const sfTexture* texture, bool resetRect)
 {
     assert(shape);
-    shape->setTexture(texture, resetRect);
+    shape->setTexture(texture ? texture->This : nullptr, resetRect);
     shape->Texture = texture;
 }
 

src/CSFML/Graphics/Sprite.cpp

@@ -40,7 +40,8 @@
 sfSprite* sfSprite_create(const sfTexture* texture)
 {
     assert(texture);
-    auto sprite     = new sfSprite(*texture);
+    assert(texture->This);
+    auto sprite     = new sfSprite(*texture->This);
     sprite->Texture = texture;
     return sprite;
 }
@@ -170,10 +171,10 @@ sfTransform sfSprite_getInverseTransform(const sfSprite* sprite)
 ////////////////////////////////////////////////////////////
 void sfSprite_setTexture(sfSprite* sprite, const sfTexture* texture, bool resetRect)
 {
-    if (texture)
+    if (texture && texture->This)
     {
         assert(sprite);
-        sprite->setTexture(*texture, resetRect);
+        sprite->setTexture(*texture->This, resetRect);
         sprite->Texture = texture;
     }
 }

src/CSFML/Graphics/Texture.cpp

@@ -41,7 +41,7 @@
 sfTexture* sfTexture_create(sfVector2u size)
 {
     auto texture = std::make_unique<sfTexture>();
-    if (!texture->resize(convertVector2(size)))
+    if (!texture->This->resize(convertVector2(size)))
         return nullptr;
 
     return texture.release();
@@ -52,7 +52,7 @@ sfTexture* sfTexture_create(sfVector2u size)
 sfTexture* sfTexture_createSrgb(sfVector2u size)
 {
     auto texture = std::make_unique<sfTexture>();
-    if (!texture->resize(convertVector2(size), true))
+    if (!texture->This->resize(convertVector2(size), true))
         return nullptr;
 
     return texture.release();
@@ -65,7 +65,7 @@ sfTexture* sfTexture_createFromFile(const char* filename, const sfIntRect* area)
     assert(filename);
 
     auto texture = std::make_unique<sfTexture>();
-    if (!texture->loadFromFile(filename, false, area ? convertRect(*area) : sf::IntRect()))
+    if (!texture->This->loadFromFile(filename, false, area ? convertRect(*area) : sf::IntRect()))
         return nullptr;
 
     return texture.release();
@@ -77,7 +77,7 @@ sfTexture* sfTexture_createSrgbFromFile(const char* filename, const sfIntRect* a
     assert(filename);
 
     auto texture = std::make_unique<sfTexture>();
-    if (!texture->loadFromFile(filename, true, area ? convertRect(*area) : sf::IntRect()))
+    if (!texture->This->loadFromFile(filename, true, area ? convertRect(*area) : sf::IntRect()))
         return nullptr;
 
     return texture.release();
@@ -87,7 +87,7 @@ sfTexture* sfTexture_createSrgbFromFile(const char* filename, const sfIntRect* a
 sfTexture* sfTexture_createFromMemory(const void* data, size_t sizeInBytes, const sfIntRect* area)
 {
     auto texture = std::make_unique<sfTexture>();
-    if (!texture->loadFromMemory(data, sizeInBytes, false, area ? convertRect(*area) : sf::IntRect()))
+    if (!texture->This->loadFromMemory(data, sizeInBytes, false, area ? convertRect(*area) : sf::IntRect()))
         return nullptr;
 
     return texture.release();
@@ -97,7 +97,7 @@ sfTexture* sfTexture_createFromMemory(const void* data, size_t sizeInBytes, cons
 sfTexture* sfTexture_createSrgbFromMemory(const void* data, size_t sizeInBytes, const sfIntRect* area)
 {
     auto texture = std::make_unique<sfTexture>();
-    if (!texture->loadFromMemory(data, sizeInBytes, true, area ? convertRect(*area) : sf::IntRect()))
+    if (!texture->This->loadFromMemory(data, sizeInBytes, true, area ? convertRect(*area) : sf::IntRect()))
         return nullptr;
 
     return texture.release();
@@ -111,7 +111,7 @@ sfTexture* sfTexture_createFromStream(sfInputStream* stream, const sfIntRect* ar
 
     CallbackStream sfmlStream(stream);
     auto           texture = std::make_unique<sfTexture>();
-    if (!texture->loadFromStream(sfmlStream, false, area ? convertRect(*area) : sf::IntRect()))
+    if (!texture->This->loadFromStream(sfmlStream, false, area ? convertRect(*area) : sf::IntRect()))
         return nullptr;
 
     return texture.release();
@@ -124,7 +124,7 @@ sfTexture* sfTexture_createSrgbFromStream(sfInputStream* stream, const sfIntRect
 
     CallbackStream sfmlStream(stream);
     auto           texture = std::make_unique<sfTexture>();
-    if (!texture->loadFromStream(sfmlStream, true, area ? convertRect(*area) : sf::IntRect()))
+    if (!texture->This->loadFromStream(sfmlStream, true, area ? convertRect(*area) : sf::IntRect()))
         return nullptr;
 
     return texture.release();
@@ -137,7 +137,7 @@ sfTexture* sfTexture_createFromImage(const sfImage* image, const sfIntRect* area
     assert(image);
 
     auto texture = std::make_unique<sfTexture>();
-    if (!texture->loadFromImage(*image, false, area ? convertRect(*area) : sf::IntRect()))
+    if (!texture->This->loadFromImage(*image, false, area ? convertRect(*area) : sf::IntRect()))
         return nullptr;
 
     return texture.release();
@@ -149,7 +149,7 @@ sfTexture* sfTexture_createSrgbFromImage(const sfImage* image, const sfIntRect*
     assert(image);
 
     auto texture = std::make_unique<sfTexture>();
-    if (!texture->loadFromImage(*image, true, area ? convertRect(*area) : sf::IntRect()))
+    if (!texture->This->loadFromImage(*image, true, area ? convertRect(*area) : sf::IntRect()))
         return nullptr;
 
     return texture.release();
@@ -174,7 +174,7 @@ void sfTexture_destroy(const sfTexture* texture)
 sfVector2u sfTexture_getSize(const sfTexture* texture)
 {
     assert(texture);
-    return convertVector2(texture->getSize());
+    return convertVector2(texture->This->getSize());
 }
 
 
@@ -182,7 +182,8 @@ sfVector2u sfTexture_getSize(const sfTexture* texture)
 sfImage* sfTexture_copyToImage(const sfTexture* texture)
 {
     assert(texture);
-    return new sfImage{texture->copyToImage()};
+    assert(texture->This);
+    return new sfImage{texture->This->copyToImage()};
 }
 
 
@@ -190,7 +191,7 @@ sfImage* sfTexture_copyToImage(const sfTexture* texture)
 void sfTexture_updateFromPixels(sfTexture* texture, const uint8_t* pixels, sfVector2u size, sfVector2u offset)
 {
     assert(texture);
-    texture->update(pixels, convertVector2(size), convertVector2(offset));
+    texture->This->update(pixels, convertVector2(size), convertVector2(offset));
 }
 
 
@@ -199,7 +200,8 @@ void sfTexture_updateFromTexture(sfTexture* destination, const sfTexture* textur
 {
     assert(destination);
     assert(texture);
-    destination->update(*texture, convertVector2(offset));
+    assert(texture->This);
+    destination->This->update(*texture->This, convertVector2(offset));
 }
 
 
@@ -208,7 +210,7 @@ void sfTexture_updateFromImage(sfTexture* texture, const sfImage* image, sfVecto
 {
     assert(texture);
     assert(image);
-    texture->update(*image, convertVector2(offset));
+    texture->This->update(*image, convertVector2(offset));
 }
 
 
@@ -217,7 +219,7 @@ void sfTexture_updateFromWindow(sfTexture* texture, const sfWindow* window, sfVe
 {
     assert(texture);
     assert(window);
-    texture->update(*window, convertVector2(offset));
+    texture->This->update(*window, convertVector2(offset));
 }
 
 
@@ -226,7 +228,7 @@ void sfTexture_updateFromRenderWindow(sfTexture* texture, const sfRenderWindow*
 {
     assert(texture);
     assert(renderWindow);
-    texture->update(*renderWindow, convertVector2(offset));
+    texture->This->update(*renderWindow, convertVector2(offset));
 }
 
 
@@ -234,7 +236,7 @@ void sfTexture_updateFromRenderWindow(sfTexture* texture, const sfRenderWindow*
 void sfTexture_setSmooth(sfTexture* texture, bool smooth)
 {
     assert(texture);
-    texture->setSmooth(smooth);
+    texture->This->setSmooth(smooth);
 }
 
 
@@ -242,14 +244,15 @@ void sfTexture_setSmooth(sfTexture* texture, bool smooth)
 bool sfTexture_isSmooth(const sfTexture* texture)
 {
     assert(texture);
-    return texture->isSmooth();
+    assert(texture->This);
+    return texture->This->isSmooth();
 }
 
 ////////////////////////////////////////////////////////////
 bool sfTexture_isSrgb(const sfTexture* texture)
 {
     assert(texture);
-    return texture->isSrgb();
+    return texture->This->isSrgb();
 }
 
 
@@ -257,7 +260,7 @@ bool sfTexture_isSrgb(const sfTexture* texture)
 void sfTexture_setRepeated(sfTexture* texture, bool repeated)
 {
     assert(texture);
-    texture->setRepeated(repeated);
+    texture->This->setRepeated(repeated);
 }
 
 
@@ -265,7 +268,8 @@ void sfTexture_setRepeated(sfTexture* texture, bool repeated)
 bool sfTexture_isRepeated(const sfTexture* texture)
 {
     assert(texture);
-    return texture->isRepeated();
+    assert(texture->This);
+    return texture->This->isRepeated();
 }
 
 
@@ -273,7 +277,7 @@ bool sfTexture_isRepeated(const sfTexture* texture)
 bool sfTexture_generateMipmap(sfTexture* texture)
 {
     assert(texture);
-    return texture->generateMipmap();
+    return texture->This->generateMipmap();
 }
 
 
@@ -282,7 +286,7 @@ void sfTexture_swap(sfTexture* left, sfTexture* right)
 {
     assert(left);
     assert(right);
-    left->swap(*right);
+    left->This->swap(*right->This);
 }
 
 
@@ -290,14 +294,14 @@ void sfTexture_swap(sfTexture* left, sfTexture* right)
 unsigned int sfTexture_getNativeHandle(const sfTexture* texture)
 {
     assert(texture);
-    return texture->getNativeHandle();
+    return texture->This->getNativeHandle();
 }
 
 
 ////////////////////////////////////////////////////////////
-void sfTexture_bind(const sfTexture* texture, sfTextureCoordinateType type)
+void sfTexture_bind(const sfTexture* texture, sfCoordinateType type)
 {
-    sf::Texture::bind(texture, static_cast<sf::CoordinateType>(type));
+    sf::Texture::bind(texture ? texture->This : nullptr, static_cast<sf::CoordinateType>(type));
 }
 
 

src/CSFML/Graphics/TextureStruct.hpp

@@ -33,6 +33,24 @@
 ////////////////////////////////////////////////////////////
 // Internal structure of sfTexture
 ////////////////////////////////////////////////////////////
-struct sfTexture : sf::Texture
+struct sfTexture
 {
+    sfTexture() = default;
+
+    sfTexture(sf::Texture* texture) : This(texture), OwnInstance(false)
+    {
+    }
+
+    sfTexture(const sfTexture& texture) : This(texture.This ? new sf::Texture(*texture.This) : nullptr)
+    {
+    }
+
+    ~sfTexture()
+    {
+        if (OwnInstance)
+            delete This;
+    }
+
+    sf::Texture* This{new sf::Texture};
+    bool         OwnInstance{true};
 };

src/CSFML/Graphics/Transform.cpp

@@ -48,8 +48,13 @@ const sfTransform sfTransform_Identity = {
 ////////////////////////////////////////////////////////////
 sfTransform sfTransform_fromMatrix(float a00, float a01, float a02, float a10, float a11, float a12, float a20, float a21, float a22)
 {
-    sfTransform transform = {a00, a01, a02, a10, a11, a12, a20, a21, a22};
-    return transform;
+    // clang-format off
+    return {
+        a00, a01, a02,
+        a10, a11, a12,
+        a20, a21, a22,
+    };
+    // clang-format on
 }
 
 

src/CSFML/Graphics/Transformable.cpp

@@ -34,9 +34,7 @@
 ////////////////////////////////////////////////////////////
 sfTransformable* sfTransformable_create()
 {
-    auto* transformable = new sfTransformable;
-
-    return transformable;
+    return new sfTransformable;
 }
 
 

src/CSFML/Graphics/VertexArray.cpp

@@ -104,7 +104,7 @@ void sfVertexArray_setPrimitiveType(sfVertexArray* vertexArray, sfPrimitiveType
 
 
 ////////////////////////////////////////////////////////////
-sfPrimitiveType sfVertexArray_getPrimitiveType(sfVertexArray* vertexArray)
+sfPrimitiveType sfVertexArray_getPrimitiveType(const sfVertexArray* vertexArray)
 {
     assert(vertexArray);
     return static_cast<sfPrimitiveType>(vertexArray->getPrimitiveType());
@@ -112,7 +112,7 @@ sfPrimitiveType sfVertexArray_getPrimitiveType(sfVertexArray* vertexArray)
 
 
 ////////////////////////////////////////////////////////////
-sfFloatRect sfVertexArray_getBounds(sfVertexArray* vertexArray)
+sfFloatRect sfVertexArray_getBounds(const sfVertexArray* vertexArray)
 {
     assert(vertexArray);
     return convertRect(vertexArray->getBounds());

src/CSFML/Graphics/VertexBuffer.cpp

@@ -30,7 +30,7 @@
 
 
 ////////////////////////////////////////////////////////////
-sfVertexBuffer* sfVertexBuffer_create(unsigned int vertexCount, sfPrimitiveType type, sfVertexBufferUsage usage)
+sfVertexBuffer* sfVertexBuffer_create(size_t vertexCount, sfPrimitiveType type, sfVertexBufferUsage usage)
 {
     auto buffer = std::make_unique<sfVertexBuffer>();
     if (!buffer->create(vertexCount))
@@ -92,7 +92,7 @@ void sfVertexBuffer_swap(sfVertexBuffer* left, sfVertexBuffer* right)
 
 
 ////////////////////////////////////////////////////////////
-unsigned int sfVertexBuffer_getNativeHandle(sfVertexBuffer* vertexBuffer)
+unsigned int sfVertexBuffer_getNativeHandle(const sfVertexBuffer* vertexBuffer)
 {
     assert(vertexBuffer);
     return vertexBuffer->getNativeHandle();

src/CSFML/Network/Ftp.cpp

@@ -51,6 +51,8 @@ static_assert(alignof(sfChar32) == alignof(char32_t));
 {
     const std::size_t byteCount = sizeof(sfChar32) * str.getSize();
     auto*             utf32     = static_cast<sfChar32*>(std::malloc(byteCount + sizeof(sfChar32)));
+    if (!utf32)
+        return nullptr;
     std::memcpy(utf32, str.getData(), byteCount);
     utf32[str.getSize()] = 0;
 

src/CSFML/Network/IpAddress.cpp

@@ -37,26 +37,18 @@ namespace
 // Helper function for converting a SFML address to a CSFML one
 [[nodiscard]] sfIpAddress fromSFMLAddress(std::optional<sf::IpAddress> address)
 {
-    sfIpAddress result = {0};
-
-    if (address)
-    {
-        strncpy(result.address, address->toString().c_str(), 15);
-    }
+    if (!address)
+        return sfIpAddress_None;
 
+    sfIpAddress result{};
+    std::strncpy(result.address, address->toString().c_str(), 15);
     return result;
 }
-
-// Helper function for converting a CSFML address to a SFML one
-[[nodiscard]] std::optional<sf::IpAddress> toSFMLAddress(sfIpAddress address)
-{
-    return sf::IpAddress::resolve(address.address);
-}
 } // namespace
 
 
 ////////////////////////////////////////////////////////////
-const sfIpAddress sfIpAddress_None = sfIpAddress_fromBytes(0, 0, 0, 0);
+const sfIpAddress sfIpAddress_None = {{0}};
 
 
 ////////////////////////////////////////////////////////////
@@ -97,14 +89,14 @@ sfIpAddress sfIpAddress_fromInteger(uint32_t address)
 void sfIpAddress_toString(sfIpAddress address, char* string)
 {
     if (string)
-        strcpy(string, address.address);
+        std::strcpy(string, address.address);
 }
 
 
 ////////////////////////////////////////////////////////////
 uint32_t sfIpAddress_toInteger(sfIpAddress address)
 {
-    auto sfmlAddress = toSFMLAddress(address);
+    const auto sfmlAddress = sf::IpAddress::resolve(address.address);
     return sfmlAddress ? sfmlAddress->toInteger() : 0;
 }
 

src/CSFML/Network/Packet.cpp

@@ -105,7 +105,7 @@ bool sfPacket_endOfPacket(const sfPacket* packet)
 bool sfPacket_canRead(const sfPacket* packet)
 {
     assert(packet);
-    return static_cast<bool>(*packet);
+    return bool{*packet};
 }
 
 
@@ -156,6 +156,20 @@ uint32_t sfPacket_readUint32(sfPacket* packet)
     *packet >> value;
     return value;
 }
+int64_t sfPacket_readInt64(sfPacket* packet)
+{
+    assert(packet);
+    int64_t value = 0;
+    *packet >> value;
+    return value;
+}
+uint64_t sfPacket_readUint64(sfPacket* packet)
+{
+    assert(packet);
+    uint64_t value = 0;
+    *packet >> value;
+    return value;
+}
 float sfPacket_readFloat(sfPacket* packet)
 {
     assert(packet);
@@ -219,6 +233,16 @@ void sfPacket_writeUint32(sfPacket* packet, uint32_t value)
     assert(packet);
     *packet << value;
 }
+void sfPacket_writeInt64(sfPacket* packet, int64_t value)
+{
+    assert(packet);
+    *packet << value;
+}
+void sfPacket_writeUint64(sfPacket* packet, uint64_t value)
+{
+    assert(packet);
+    *packet << value;
+}
 void sfPacket_writeFloat(sfPacket* packet, float value)
 {
     assert(packet);

src/CSFML/Network/TcpListener.cpp

@@ -86,6 +86,14 @@ sfSocketStatus sfTcpListener_listen(sfTcpListener* listener, unsigned short port
 }
 
 
+////////////////////////////////////////////////////////////
+void sfTcpListener_close(sfTcpListener* listener)
+{
+    assert(listener);
+    listener->close();
+}
+
+
 ////////////////////////////////////////////////////////////
 sfSocketStatus sfTcpListener_accept(sfTcpListener* listener, sfTcpSocket** connected)
 {
@@ -102,3 +110,10 @@ sfSocketStatus sfTcpListener_accept(sfTcpListener* listener, sfTcpSocket** conne
 
     return status;
 }
+
+
+////////////////////////////////////////////////////////////
+unsigned short sfTcpListener_anyPort()
+{
+    return 0;
+}

src/CSFML/Network/TcpSocket.cpp

@@ -82,7 +82,7 @@ sfIpAddress sfTcpSocket_getRemoteAddress(const sfTcpSocket* socket)
     sfIpAddress result = sfIpAddress_None;
     if (address)
     {
-        strncpy(result.address, address->toString().c_str(), 15);
+        std::strncpy(result.address, address->toString().c_str(), 15);
     }
 
     return result;

src/CSFML/Network/UdpSocket.cpp

@@ -139,7 +139,7 @@ sfSocketStatus sfUdpSocket_receive(sfUdpSocket*    socket,
 
         if (address)
         {
-            strncpy(remoteAddress->address, address->toString().c_str(), 15);
+            std::strncpy(remoteAddress->address, address->toString().c_str(), 15);
         }
     }
 
@@ -187,7 +187,7 @@ sfSocketStatus sfUdpSocket_receivePacket(sfUdpSocket* socket, sfPacket* packet,
 
         if (address)
         {
-            strncpy(remoteAddress->address, address->toString().c_str(), 15);
+            std::strncpy(remoteAddress->address, address->toString().c_str(), 15);
         }
     }
 
@@ -203,3 +203,10 @@ unsigned int sfUdpSocket_maxDatagramSize()
 {
     return sf::UdpSocket::MaxDatagramSize;
 }
+
+
+////////////////////////////////////////////////////////////
+unsigned short sfUdpSocket_anyPort()
+{
+    return 0;
+}

src/CSFML/System/Alloc.cpp

@@ -33,5 +33,5 @@
 ////////////////////////////////////////////////////////////
 void sfFree(void* ptr)
 {
-    free(ptr);
+    std::free(ptr);
 }

src/CSFML/System/Time.cpp

@@ -29,7 +29,7 @@
 
 
 ////////////////////////////////////////////////////////////
-sfTime sfTime_Zero = {0};
+const sfTime sfTime_Zero = {0};
 
 
 ////////////////////////////////////////////////////////////
@@ -56,25 +56,19 @@ int64_t sfTime_asMicroseconds(sfTime time)
 ////////////////////////////////////////////////////////////
 sfTime sfSeconds(float amount)
 {
-    sfTime time;
-    time.microseconds = static_cast<int64_t>(amount * 1000000);
-    return time;
+    return {static_cast<int64_t>(amount * 1000000)};
 }
 
 
 ////////////////////////////////////////////////////////////
 sfTime sfMilliseconds(int32_t amount)
 {
-    sfTime time;
-    time.microseconds = static_cast<int64_t>(amount) * 1000;
-    return time;
+    return {int64_t{amount} * 1000};
 }
 
 
 ////////////////////////////////////////////////////////////
 sfTime sfMicroseconds(int64_t amount)
 {
-    sfTime time;
-    time.microseconds = amount;
-    return time;
+    return {amount};
 }

src/CSFML/Window/CMakeLists.txt

@@ -13,6 +13,7 @@ set(SRC
     ${SRCROOT}/ContextStruct.hpp
     ${INCROOT}/Context.h
     ${SRCROOT}/ConvertContextSettings.hpp
+    ${SRCROOT}/ConvertEvent.hpp
     ${SRCROOT}/ConvertVideoMode.hpp
     ${INCROOT}/Event.h
     ${SRCROOT}/Joystick.cpp

src/CSFML/Window/ConvertEvent.hpp

@@ -0,0 +1,181 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+//    you must not claim that you wrote the original software.
+//    If you use this software in a product, an acknowledgment
+//    in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+//    and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#pragma once
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <CSFML/System/ConvertVector2.hpp>
+#include <CSFML/System/ConvertVector3.hpp>
+#include <CSFML/Window/Event.h>
+
+#include <SFML/Window/Event.hpp>
+
+#include <optional>
+
+
+////////////////////////////////////////////////////////////
+// Convert sf::Event to sfEvent
+////////////////////////////////////////////////////////////
+[[nodiscard]] inline bool convertEvent(const std::optional<sf::Event>& sfmlEvent, sfEvent& event)
+{
+    if (!sfmlEvent)
+        return false;
+
+    if (sfmlEvent->is<sf::Event::Closed>())
+    {
+        event.type = sfEvtClosed;
+    }
+    else if (const auto* resized = sfmlEvent->getIf<sf::Event::Resized>())
+    {
+        event.type      = sfEvtResized;
+        event.size.size = convertVector2(resized->size);
+    }
+    else if (sfmlEvent->is<sf::Event::FocusLost>())
+    {
+        event.type = sfEvtFocusLost;
+    }
+    else if (sfmlEvent->is<sf::Event::FocusGained>())
+    {
+        event.type = sfEvtFocusGained;
+    }
+    else if (const auto* textEntered = sfmlEvent->getIf<sf::Event::TextEntered>())
+    {
+        event.type         = sfEvtTextEntered;
+        event.text.unicode = textEntered->unicode;
+    }
+    else if (const auto* keyReleased = sfmlEvent->getIf<sf::Event::KeyReleased>())
+    {
+        event.type         = sfEvtKeyReleased;
+        event.key.code     = static_cast<sfKeyCode>(keyReleased->code);
+        event.key.scancode = static_cast<sfScancode>(keyReleased->scancode);
+        event.key.alt      = keyReleased->alt;
+        event.key.control  = keyReleased->control;
+        event.key.shift    = keyReleased->shift;
+        event.key.system   = keyReleased->system;
+    }
+    else if (const auto* keyPressed = sfmlEvent->getIf<sf::Event::KeyPressed>())
+    {
+        event.type         = sfEvtKeyPressed;
+        event.key.code     = static_cast<sfKeyCode>(keyPressed->code);
+        event.key.scancode = static_cast<sfScancode>(keyPressed->scancode);
+        event.key.alt      = keyPressed->alt;
+        event.key.control  = keyPressed->control;
+        event.key.shift    = keyPressed->shift;
+        event.key.system   = keyPressed->system;
+    }
+    else if (const auto* mouseWheelScrolled = sfmlEvent->getIf<sf::Event::MouseWheelScrolled>())
+    {
+        event.type                      = sfEvtMouseWheelScrolled;
+        event.mouseWheelScroll.wheel    = static_cast<sfMouseWheel>(mouseWheelScrolled->wheel);
+        event.mouseWheelScroll.delta    = mouseWheelScrolled->delta;
+        event.mouseWheelScroll.position = convertVector2(mouseWheelScrolled->position);
+    }
+    else if (const auto* mouseButtonPressed = sfmlEvent->getIf<sf::Event::MouseButtonPressed>())
+    {
+        event.type                 = sfEvtMouseButtonPressed;
+        event.mouseButton.button   = static_cast<sfMouseButton>(mouseButtonPressed->button);
+        event.mouseButton.position = convertVector2(mouseButtonPressed->position);
+    }
+    else if (const auto* mouseButtonReleased = sfmlEvent->getIf<sf::Event::MouseButtonReleased>())
+    {
+        event.type                 = sfEvtMouseButtonReleased;
+        event.mouseButton.button   = static_cast<sfMouseButton>(mouseButtonReleased->button);
+        event.mouseButton.position = convertVector2(mouseButtonReleased->position);
+    }
+    else if (const auto* mouseMoved = sfmlEvent->getIf<sf::Event::MouseMoved>())
+    {
+        event.type               = sfEvtMouseMoved;
+        event.mouseMove.position = convertVector2(mouseMoved->position);
+    }
+    else if (const auto* mouseMovedRaw = sfmlEvent->getIf<sf::Event::MouseMovedRaw>())
+    {
+        event.type               = sfEvtMouseMovedRaw;
+        event.mouseMoveRaw.delta = convertVector2(mouseMovedRaw->delta);
+    }
+    else if (sfmlEvent->is<sf::Event::MouseEntered>())
+    {
+        event.type = sfEvtMouseEntered;
+    }
+    else if (sfmlEvent->is<sf::Event::MouseLeft>())
+    {
+        event.type = sfEvtMouseLeft;
+    }
+    else if (const auto* joystickButtonPressed = sfmlEvent->getIf<sf::Event::JoystickButtonPressed>())
+    {
+        event.type                      = sfEvtJoystickButtonPressed;
+        event.joystickButton.joystickId = joystickButtonPressed->joystickId;
+        event.joystickButton.button     = joystickButtonPressed->button;
+    }
+    else if (const auto* joystickButtonReleased = sfmlEvent->getIf<sf::Event::JoystickButtonReleased>())
+    {
+        event.type                      = sfEvtJoystickButtonReleased;
+        event.joystickButton.joystickId = joystickButtonReleased->joystickId;
+        event.joystickButton.button     = joystickButtonReleased->button;
+    }
+    else if (const auto* joystickMoved = sfmlEvent->getIf<sf::Event::JoystickMoved>())
+    {
+        event.type                    = sfEvtJoystickMoved;
+        event.joystickMove.joystickId = joystickMoved->joystickId;
+        event.joystickMove.axis       = static_cast<sfJoystickAxis>(joystickMoved->axis);
+        event.joystickMove.position   = joystickMoved->position;
+    }
+    else if (const auto* joystickConnected = sfmlEvent->getIf<sf::Event::JoystickConnected>())
+    {
+        event.type                       = sfEvtJoystickConnected;
+        event.joystickConnect.joystickId = joystickConnected->joystickId;
+    }
+    else if (const auto* joystickDisconnected = sfmlEvent->getIf<sf::Event::JoystickDisconnected>())
+    {
+        event.type                       = sfEvtJoystickDisconnected;
+        event.joystickConnect.joystickId = joystickDisconnected->joystickId;
+    }
+    else if (const auto* touchBegan = sfmlEvent->getIf<sf::Event::TouchBegan>())
+    {
+        event.type           = sfEvtTouchBegan;
+        event.touch.finger   = touchBegan->finger;
+        event.touch.position = convertVector2(touchBegan->position);
+    }
+    else if (const auto* touchMoved = sfmlEvent->getIf<sf::Event::TouchMoved>())
+    {
+        event.type           = sfEvtTouchMoved;
+        event.touch.finger   = touchMoved->finger;
+        event.touch.position = convertVector2(touchMoved->position);
+    }
+    else if (const auto* touchEnded = sfmlEvent->getIf<sf::Event::TouchEnded>())
+    {
+        event.type           = sfEvtTouchEnded;
+        event.touch.finger   = touchEnded->finger;
+        event.touch.position = convertVector2(touchEnded->position);
+    }
+    else if (const auto* sensorChanged = sfmlEvent->getIf<sf::Event::SensorChanged>())
+    {
+        event.type              = sfEvtSensorChanged;
+        event.sensor.sensorType = static_cast<sfSensorType>(sensorChanged->type);
+        event.sensor.value      = convertVector3(sensorChanged->value);
+    }
+
+    return true;
+}

src/CSFML/Window/VideoMode.cpp

@@ -41,14 +41,13 @@ sfVideoMode sfVideoMode_getDesktopMode()
 ////////////////////////////////////////////////////////////
 const sfVideoMode* sfVideoMode_getFullscreenModes(size_t* count)
 {
-    static std::vector<sfVideoMode> modes;
-
-    // Populate the array on first call
-    if (modes.empty())
+    static const auto modes = []
     {
+        std::vector<sfVideoMode> videomodes;
         for (const auto& mode : sf::VideoMode::getFullscreenModes())
-            modes.push_back(convertVideoMode(mode));
-    }
+            videomodes.push_back(convertVideoMode(mode));
+        return videomodes;
+    }();
 
     if (count)
         *count = modes.size();

src/CSFML/Window/Vulkan.cpp

@@ -31,9 +31,6 @@
 
 #include <SFML/Window/Vulkan.hpp>
 
-#include <cstdlib>
-#include <cstring>
-
 
 ////////////////////////////////////////////////////////////
 bool sfVulkan_isAvailable(bool requireGraphics)
@@ -52,7 +49,7 @@ sfVulkanFunctionPointer sfVulkan_getFunction(const char* name)
 ////////////////////////////////////////////////////////////
 const char* const* sfVulkan_getGraphicsRequiredInstanceExtensions(size_t* count)
 {
-    static std::vector<const char*> extensions = sf::Vulkan::getGraphicsRequiredInstanceExtensions();
+    static const std::vector<const char*> extensions = sf::Vulkan::getGraphicsRequiredInstanceExtensions();
 
     if (count)
         *count = extensions.size();

src/CSFML/Window/Window.cpp

@@ -25,9 +25,9 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/ConvertEvent.hpp>
 #include <CSFML/System/ConvertVector2.hpp>
 #include <CSFML/Window/ConvertContextSettings.hpp>
+#include <CSFML/Window/ConvertEvent.hpp>
 #include <CSFML/Window/ConvertVideoMode.hpp>
 #include <CSFML/Window/CursorStruct.hpp>
 #include <CSFML/Window/Window.h>
@@ -114,7 +114,7 @@ bool sfWindow_pollEvent(sfWindow* window, sfEvent* event)
 {
     assert(window);
     assert(event);
-    return convertEvent(window->pollEvent(), event);
+    return convertEvent(window->pollEvent(), *event);
 }
 
 
@@ -123,7 +123,7 @@ bool sfWindow_waitEvent(sfWindow* window, sfTime timeout, sfEvent* event)
 {
     assert(window);
     assert(event);
-    return convertEvent(window->waitEvent(sf::microseconds(timeout.microseconds)), event);
+    return convertEvent(window->waitEvent(sf::microseconds(timeout.microseconds)), *event);
 }
 
 

src/CSFML/Window/WindowBase.cpp

@@ -25,8 +25,8 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/ConvertEvent.hpp>
 #include <CSFML/System/ConvertVector2.hpp>
+#include <CSFML/Window/ConvertEvent.hpp>
 #include <CSFML/Window/ConvertVideoMode.hpp>
 #include <CSFML/Window/CursorStruct.hpp>
 #include <CSFML/Window/WindowBase.h>
@@ -96,7 +96,7 @@ bool sfWindowBase_pollEvent(sfWindowBase* windowBase, sfEvent* event)
 {
     assert(windowBase);
     assert(event);
-    return convertEvent(windowBase->pollEvent(), event);
+    return convertEvent(windowBase->pollEvent(), *event);
 }
 
 
@@ -105,7 +105,7 @@ bool sfWindowBase_waitEvent(sfWindowBase* windowBase, sfTime timeout, sfEvent* e
 {
     assert(windowBase);
     assert(event);
-    return convertEvent(windowBase->waitEvent(sf::microseconds(timeout.microseconds)), event);
+    return convertEvent(windowBase->waitEvent(sf::microseconds(timeout.microseconds)), *event);
 }
 
 

test/Audio/SoundChannel.test.cpp

@@ -0,0 +1,29 @@
+#include <CSFML/Audio/SoundChannel.h>
+
+#include <SFML/Audio/SoundChannel.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+
+TEST_CASE("[Audio] sfSoundChannel")
+{
+    STATIC_CHECK(sfSoundChannelUnspecified == static_cast<int>(sf::SoundChannel::Unspecified));
+    STATIC_CHECK(sfSoundChannelMono == static_cast<int>(sf::SoundChannel::Mono));
+    STATIC_CHECK(sfSoundChannelFrontLeft == static_cast<int>(sf::SoundChannel::FrontLeft));
+    STATIC_CHECK(sfSoundChannelFrontRight == static_cast<int>(sf::SoundChannel::FrontRight));
+    STATIC_CHECK(sfSoundChannelFrontCenter == static_cast<int>(sf::SoundChannel::FrontCenter));
+    STATIC_CHECK(sfSoundChannelFrontLeftOfCenter == static_cast<int>(sf::SoundChannel::FrontLeftOfCenter));
+    STATIC_CHECK(sfSoundChannelFrontRightOfCenter == static_cast<int>(sf::SoundChannel::FrontRightOfCenter));
+    STATIC_CHECK(sfSoundChannelLowFrequencyEffects == static_cast<int>(sf::SoundChannel::LowFrequencyEffects));
+    STATIC_CHECK(sfSoundChannelBackLeft == static_cast<int>(sf::SoundChannel::BackLeft));
+    STATIC_CHECK(sfSoundChannelBackRight == static_cast<int>(sf::SoundChannel::BackRight));
+    STATIC_CHECK(sfSoundChannelBackCenter == static_cast<int>(sf::SoundChannel::BackCenter));
+    STATIC_CHECK(sfSoundChannelSideLeft == static_cast<int>(sf::SoundChannel::SideLeft));
+    STATIC_CHECK(sfSoundChannelSideRight == static_cast<int>(sf::SoundChannel::SideRight));
+    STATIC_CHECK(sfSoundChannelTopCenter == static_cast<int>(sf::SoundChannel::TopCenter));
+    STATIC_CHECK(sfSoundChannelTopFrontLeft == static_cast<int>(sf::SoundChannel::TopFrontLeft));
+    STATIC_CHECK(sfSoundChannelTopFrontRight == static_cast<int>(sf::SoundChannel::TopFrontRight));
+    STATIC_CHECK(sfSoundChannelTopFrontCenter == static_cast<int>(sf::SoundChannel::TopFrontCenter));
+    STATIC_CHECK(sfSoundChannelTopBackLeft == static_cast<int>(sf::SoundChannel::TopBackLeft));
+    STATIC_CHECK(sfSoundChannelTopBackRight == static_cast<int>(sf::SoundChannel::TopBackRight));
+    STATIC_CHECK(sfSoundChannelTopBackCenter == static_cast<int>(sf::SoundChannel::TopBackCenter));
+}

test/CMakeLists.txt

@@ -44,6 +44,23 @@ target_link_libraries(test-csfml-window PRIVATE csfml-window Catch2::Catch2WithM
 set_target_warnings(test-csfml-window)
 catch_discover_tests(test-csfml-window)
 
+add_executable(test-csfml-graphics
+    Graphics/BlendMode.test.cpp
+    Graphics/Color.test.cpp
+    Graphics/CoordinateType.test.cpp
+    Graphics/PrimitiveType.test.cpp
+    Graphics/Rect.test.cpp
+    Graphics/RenderStates.test.cpp
+    Graphics/Shape.test.cpp
+    Graphics/StencilMode.test.cpp
+    Graphics/Transform.test.cpp
+    Graphics/VertexArray.test.cpp
+    Graphics/View.test.cpp
+)
+target_link_libraries(test-csfml-graphics PRIVATE csfml-graphics Catch2::Catch2WithMain SFML::Graphics)
+set_target_warnings(test-csfml-graphics)
+catch_discover_tests(test-csfml-graphics)
+
 add_executable(test-csfml-network
     Network/Ftp.test.cpp
     Network/Http.test.cpp
@@ -54,6 +71,13 @@ target_link_libraries(test-csfml-network PRIVATE csfml-network Catch2::Catch2Wit
 set_target_warnings(test-csfml-network)
 catch_discover_tests(test-csfml-network)
 
+add_executable(test-csfml-audio
+    Audio/SoundChannel.test.cpp
+)
+target_link_libraries(test-csfml-audio PRIVATE csfml-audio Catch2::Catch2WithMain SFML::Audio)
+set_target_warnings(test-csfml-audio)
+catch_discover_tests(test-csfml-audio)
+
 # Copy DLLs into the same directory
 if(SFML_OS_WINDOWS AND NOT CSFML_LINK_SFML_STATICALLY)
     foreach(SFML_TARGET SFML::System SFML::Window SFML::Graphics SFML::Audio SFML::Network)

test/Graphics/BlendMode.test.cpp

@@ -0,0 +1,105 @@
+#include <CSFML/Graphics/BlendMode.h>
+
+#include <SFML/Graphics/BlendMode.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+
+TEST_CASE("[Graphics] sfBlendMode")
+{
+    SECTION("sfBlendFactor")
+    {
+        STATIC_CHECK(sfBlendFactorZero == static_cast<int>(sf::BlendMode::Factor::Zero));
+        STATIC_CHECK(sfBlendFactorOne == static_cast<int>(sf::BlendMode::Factor::One));
+        STATIC_CHECK(sfBlendFactorSrcColor == static_cast<int>(sf::BlendMode::Factor::SrcColor));
+        STATIC_CHECK(sfBlendFactorOneMinusSrcColor == static_cast<int>(sf::BlendMode::Factor::OneMinusSrcColor));
+        STATIC_CHECK(sfBlendFactorDstColor == static_cast<int>(sf::BlendMode::Factor::DstColor));
+        STATIC_CHECK(sfBlendFactorOneMinusDstColor == static_cast<int>(sf::BlendMode::Factor::OneMinusDstColor));
+        STATIC_CHECK(sfBlendFactorSrcAlpha == static_cast<int>(sf::BlendMode::Factor::SrcAlpha));
+        STATIC_CHECK(sfBlendFactorOneMinusSrcAlpha == static_cast<int>(sf::BlendMode::Factor::OneMinusSrcAlpha));
+        STATIC_CHECK(sfBlendFactorDstAlpha == static_cast<int>(sf::BlendMode::Factor::DstAlpha));
+        STATIC_CHECK(sfBlendFactorOneMinusDstAlpha == static_cast<int>(sf::BlendMode::Factor::OneMinusDstAlpha));
+    }
+
+    SECTION("sfBlendEquation")
+    {
+        STATIC_CHECK(sfBlendEquationAdd == static_cast<int>(sf::BlendMode::Equation::Add));
+        STATIC_CHECK(sfBlendEquationSubtract == static_cast<int>(sf::BlendMode::Equation::Subtract));
+        STATIC_CHECK(sfBlendEquationReverseSubtract == static_cast<int>(sf::BlendMode::Equation::ReverseSubtract));
+        STATIC_CHECK(sfBlendEquationMin == static_cast<int>(sf::BlendMode::Equation::Min));
+        STATIC_CHECK(sfBlendEquationMax == static_cast<int>(sf::BlendMode::Equation::Max));
+    }
+
+    SECTION("Construction")
+    {
+        constexpr sfBlendMode blendMode{};
+        STATIC_CHECK(blendMode.colorSrcFactor == sfBlendFactorZero);
+        STATIC_CHECK(blendMode.colorDstFactor == sfBlendFactorZero);
+        STATIC_CHECK(blendMode.colorEquation == sfBlendEquationAdd);
+        STATIC_CHECK(blendMode.alphaSrcFactor == sfBlendFactorZero);
+        STATIC_CHECK(blendMode.alphaDstFactor == sfBlendFactorZero);
+        STATIC_CHECK(blendMode.alphaEquation == sfBlendEquationAdd);
+    }
+
+    SECTION("Constants")
+    {
+        SECTION("sfBlendAlpha")
+        {
+            CHECK(sfBlendAlpha.colorSrcFactor == sfBlendFactorSrcAlpha);
+            CHECK(sfBlendAlpha.colorDstFactor == sfBlendFactorOneMinusSrcAlpha);
+            CHECK(sfBlendAlpha.colorEquation == sfBlendEquationAdd);
+            CHECK(sfBlendAlpha.alphaSrcFactor == sfBlendFactorOne);
+            CHECK(sfBlendAlpha.alphaDstFactor == sfBlendFactorOneMinusSrcAlpha);
+            CHECK(sfBlendAlpha.alphaEquation == sfBlendEquationAdd);
+        }
+
+        SECTION("sfBlendAdd")
+        {
+            CHECK(sfBlendAdd.colorSrcFactor == sfBlendFactorSrcAlpha);
+            CHECK(sfBlendAdd.colorDstFactor == sfBlendFactorOne);
+            CHECK(sfBlendAdd.colorEquation == sfBlendEquationAdd);
+            CHECK(sfBlendAdd.alphaSrcFactor == sfBlendFactorOne);
+            CHECK(sfBlendAdd.alphaDstFactor == sfBlendFactorOne);
+            CHECK(sfBlendAdd.alphaEquation == sfBlendEquationAdd);
+        }
+
+        SECTION("sfBlendMultiply")
+        {
+            CHECK(sfBlendMultiply.colorSrcFactor == sfBlendFactorDstColor);
+            CHECK(sfBlendMultiply.colorDstFactor == sfBlendFactorZero);
+            CHECK(sfBlendMultiply.colorEquation == sfBlendEquationAdd);
+            CHECK(sfBlendMultiply.alphaSrcFactor == sfBlendFactorDstColor);
+            CHECK(sfBlendMultiply.alphaDstFactor == sfBlendFactorZero);
+            CHECK(sfBlendMultiply.alphaEquation == sfBlendEquationAdd);
+        }
+
+        SECTION("sfBlendMin")
+        {
+            CHECK(sfBlendMin.colorSrcFactor == sfBlendFactorOne);
+            CHECK(sfBlendMin.colorDstFactor == sfBlendFactorOne);
+            CHECK(sfBlendMin.colorEquation == sfBlendEquationMin);
+            CHECK(sfBlendMin.alphaSrcFactor == sfBlendFactorOne);
+            CHECK(sfBlendMin.alphaDstFactor == sfBlendFactorOne);
+            CHECK(sfBlendMin.alphaEquation == sfBlendEquationMin);
+        }
+
+        SECTION("sfBlendMax")
+        {
+            CHECK(sfBlendMax.colorSrcFactor == sfBlendFactorOne);
+            CHECK(sfBlendMax.colorDstFactor == sfBlendFactorOne);
+            CHECK(sfBlendMax.colorEquation == sfBlendEquationMax);
+            CHECK(sfBlendMax.alphaSrcFactor == sfBlendFactorOne);
+            CHECK(sfBlendMax.alphaDstFactor == sfBlendFactorOne);
+            CHECK(sfBlendMax.alphaEquation == sfBlendEquationMax);
+        }
+
+        SECTION("sfBlendNone")
+        {
+            CHECK(sfBlendNone.colorSrcFactor == sfBlendFactorOne);
+            CHECK(sfBlendNone.colorDstFactor == sfBlendFactorZero);
+            CHECK(sfBlendNone.colorEquation == sfBlendEquationAdd);
+            CHECK(sfBlendNone.alphaSrcFactor == sfBlendFactorOne);
+            CHECK(sfBlendNone.alphaDstFactor == sfBlendFactorZero);
+            CHECK(sfBlendNone.alphaEquation == sfBlendEquationAdd);
+        }
+    }
+}

test/Graphics/Color.test.cpp

@@ -0,0 +1,229 @@
+#include <CSFML/Graphics/Color.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+TEST_CASE("[Graphics] sfColor")
+{
+    SECTION("Construction")
+    {
+        constexpr sfColor color{};
+        STATIC_CHECK(color.r == 0);
+        STATIC_CHECK(color.g == 0);
+        STATIC_CHECK(color.b == 0);
+        STATIC_CHECK(color.a == 0);
+    }
+
+    SECTION("Constants")
+    {
+        SECTION("sfBlack")
+        {
+            CHECK(sfBlack.r == 0);
+            CHECK(sfBlack.g == 0);
+            CHECK(sfBlack.b == 0);
+            CHECK(sfBlack.a == 255);
+        }
+
+        SECTION("sfWhite")
+        {
+            CHECK(sfWhite.r == 255);
+            CHECK(sfWhite.g == 255);
+            CHECK(sfWhite.b == 255);
+            CHECK(sfWhite.a == 255);
+        }
+
+        SECTION("sfRed")
+        {
+            CHECK(sfRed.r == 255);
+            CHECK(sfRed.g == 0);
+            CHECK(sfRed.b == 0);
+            CHECK(sfRed.a == 255);
+        }
+
+        SECTION("sfGreen")
+        {
+            CHECK(sfGreen.r == 0);
+            CHECK(sfGreen.g == 255);
+            CHECK(sfGreen.b == 0);
+            CHECK(sfGreen.a == 255);
+        }
+
+        SECTION("sfBlue")
+        {
+            CHECK(sfBlue.r == 0);
+            CHECK(sfBlue.g == 0);
+            CHECK(sfBlue.b == 255);
+            CHECK(sfBlue.a == 255);
+        }
+
+        SECTION("sfYellow")
+        {
+            CHECK(sfYellow.r == 255);
+            CHECK(sfYellow.g == 255);
+            CHECK(sfYellow.b == 0);
+            CHECK(sfYellow.a == 255);
+        }
+
+        SECTION("sfMagenta")
+        {
+            CHECK(sfMagenta.r == 255);
+            CHECK(sfMagenta.g == 0);
+            CHECK(sfMagenta.b == 255);
+            CHECK(sfMagenta.a == 255);
+        }
+
+        SECTION("sfCyan")
+        {
+            CHECK(sfCyan.r == 0);
+            CHECK(sfCyan.g == 255);
+            CHECK(sfCyan.b == 255);
+            CHECK(sfCyan.a == 255);
+        }
+
+        SECTION("sfTransparent")
+        {
+            CHECK(sfTransparent.r == 0);
+            CHECK(sfTransparent.g == 0);
+            CHECK(sfTransparent.b == 0);
+            CHECK(sfTransparent.a == 0);
+        }
+    }
+
+    SECTION("sfColor_fromRGB")
+    {
+        const sfColor color = sfColor_fromRGB(1, 2, 3);
+        CHECK(color.r == 1);
+        CHECK(color.g == 2);
+        CHECK(color.b == 3);
+        CHECK(color.a == 255);
+    }
+
+    SECTION("sfColor_fromRGBA")
+    {
+        const sfColor color = sfColor_fromRGBA(4, 5, 6, 7);
+        CHECK(color.r == 4);
+        CHECK(color.g == 5);
+        CHECK(color.b == 6);
+        CHECK(color.a == 7);
+    }
+
+    SECTION("sfColor_fromInteger")
+    {
+        sfColor color = sfColor_fromInteger(0);
+        CHECK(color.r == 0);
+        CHECK(color.g == 0);
+        CHECK(color.b == 0);
+        CHECK(color.a == 0);
+
+        color = sfColor_fromInteger(1'000);
+        CHECK(color.r == 0);
+        CHECK(color.g == 0);
+        CHECK(color.b == 3);
+        CHECK(color.a == 232);
+
+        color = sfColor_fromInteger(1'000'000);
+        CHECK(color.r == 0);
+        CHECK(color.g == 15);
+        CHECK(color.b == 66);
+        CHECK(color.a == 64);
+
+        color = sfColor_fromInteger(1'000'000'000);
+        CHECK(color.r == 59);
+        CHECK(color.g == 154);
+        CHECK(color.b == 202);
+        CHECK(color.a == 0);
+
+        color = sfColor_fromInteger(std::numeric_limits<std::uint32_t>::max());
+        CHECK(color.r == 255);
+        CHECK(color.g == 255);
+        CHECK(color.b == 255);
+        CHECK(color.a == 255);
+    }
+
+    SECTION("sfColor_toInteger")
+    {
+        CHECK(sfColor_toInteger(sfBlack) == 255);
+        CHECK(sfColor_toInteger(sfWhite) == 4'294'967'295);
+        CHECK(sfColor_toInteger(sfRed) == 4'278'190'335);
+        CHECK(sfColor_toInteger(sfGreen) == 16'711'935);
+        CHECK(sfColor_toInteger(sfBlue) == 65'535);
+        CHECK(sfColor_toInteger(sfYellow) == 4'294'902'015);
+        CHECK(sfColor_toInteger(sfMagenta) == 4'278'255'615);
+        CHECK(sfColor_toInteger(sfYellow) == 4'294'902'015);
+        CHECK(sfColor_toInteger(sfTransparent) == 0);
+    }
+
+    SECTION("sfColor_add")
+    {
+        sfColor color = sfColor_add({}, {});
+        CHECK(color.r == 0);
+        CHECK(color.g == 0);
+        CHECK(color.b == 0);
+        CHECK(color.a == 0);
+
+        color = sfColor_add({1, 2, 3, 4}, {5, 6, 7, 8});
+        CHECK(color.r == 6);
+        CHECK(color.g == 8);
+        CHECK(color.b == 10);
+        CHECK(color.a == 12);
+
+        color = sfColor_add({10, 20, 30, 40}, {200, 210, 220, 230});
+        CHECK(color.r == 210);
+        CHECK(color.g == 230);
+        CHECK(color.b == 250);
+        CHECK(color.a == 255);
+
+        color = sfColor_add({255, 255, 255, 255}, {255, 255, 255, 25});
+        CHECK(color.r == 255);
+        CHECK(color.g == 255);
+        CHECK(color.b == 255);
+        CHECK(color.a == 255);
+    }
+
+    SECTION("sfColor_subtract")
+    {
+        sfColor color = sfColor_subtract({}, {});
+        CHECK(color.r == 0);
+        CHECK(color.g == 0);
+        CHECK(color.b == 0);
+        CHECK(color.a == 0);
+
+        color = sfColor_subtract({}, {10, 20, 30, 40});
+        CHECK(color.r == 0);
+        CHECK(color.g == 0);
+        CHECK(color.b == 0);
+        CHECK(color.a == 0);
+
+        color = sfColor_subtract({100, 90, 80, 70}, {30, 40, 50, 60});
+        CHECK(color.r == 70);
+        CHECK(color.g == 50);
+        CHECK(color.b == 30);
+        CHECK(color.a == 10);
+    }
+
+    SECTION("sfColor_modulate")
+    {
+        sfColor color = sfColor_modulate({}, {});
+        CHECK(color.r == 0);
+        CHECK(color.g == 0);
+        CHECK(color.b == 0);
+        CHECK(color.a == 0);
+
+        color = sfColor_modulate({}, {1, 2, 3, 4});
+        CHECK(color.r == 0);
+        CHECK(color.g == 0);
+        CHECK(color.b == 0);
+        CHECK(color.a == 0);
+
+        color = sfColor_modulate({5, 6, 7, 8}, {1, 2, 3, 4});
+        CHECK(color.r == 0);
+        CHECK(color.g == 0);
+        CHECK(color.b == 0);
+        CHECK(color.a == 0);
+
+        color = sfColor_modulate({128, 196, 216, 255}, {0, 128, 255, 128});
+        CHECK(color.r == 0);
+        CHECK(color.g == 98);
+        CHECK(color.b == 216);
+        CHECK(color.a == 128);
+    }
+}

test/Graphics/CoordinateType.test.cpp

@@ -0,0 +1,11 @@
+#include <CSFML/Graphics/CoordinateType.h>
+
+#include <SFML/Graphics/CoordinateType.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+
+TEST_CASE("[Graphics] sfCoordinateType")
+{
+    STATIC_CHECK(sfCoordinateTypeNormalized == static_cast<int>(sf::CoordinateType::Normalized));
+    STATIC_CHECK(sfCoordinateTypePixels == static_cast<int>(sf::CoordinateType::Pixels));
+}

test/Graphics/PrimitiveType.test.cpp

@@ -0,0 +1,15 @@
+#include <CSFML/Graphics/PrimitiveType.h>
+
+#include <SFML/Graphics/PrimitiveType.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+
+TEST_CASE("[Graphics] sfPrimitiveType")
+{
+    STATIC_CHECK(sfPoints == static_cast<int>(sf::PrimitiveType::Points));
+    STATIC_CHECK(sfLines == static_cast<int>(sf::PrimitiveType::Lines));
+    STATIC_CHECK(sfLineStrip == static_cast<int>(sf::PrimitiveType::LineStrip));
+    STATIC_CHECK(sfTriangles == static_cast<int>(sf::PrimitiveType::Triangles));
+    STATIC_CHECK(sfTriangleStrip == static_cast<int>(sf::PrimitiveType::TriangleStrip));
+    STATIC_CHECK(sfTriangleFan == static_cast<int>(sf::PrimitiveType::TriangleFan));
+}

test/Graphics/Rect.test.cpp

@@ -0,0 +1,56 @@
+#include <CSFML/Graphics/Rect.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+TEST_CASE("[Graphics] sfRect")
+{
+    SECTION("Construction")
+    {
+        SECTION("float")
+        {
+            const sfFloatRect rect{};
+            CHECK(rect.position.x == 0.f);
+            CHECK(rect.position.y == 0.f);
+            CHECK(rect.size.x == 0.f);
+            CHECK(rect.size.y == 0.f);
+        }
+
+        SECTION("int")
+        {
+            const sfFloatRect rect{};
+            CHECK(rect.position.x == 0);
+            CHECK(rect.position.y == 0);
+            CHECK(rect.size.x == 0);
+            CHECK(rect.size.y == 0);
+        }
+    }
+
+    SECTION("contains(Vector2)")
+    {
+        SECTION("float")
+        {
+            const sfFloatRect rect{{0, 0}, {10, 10}};
+            CHECK(sfFloatRect_contains(&rect, {0, 0}));
+            CHECK(sfFloatRect_contains(&rect, {9, 0}));
+            CHECK(sfFloatRect_contains(&rect, {0, 9}));
+            CHECK(sfFloatRect_contains(&rect, {9, 9}));
+            CHECK(!sfFloatRect_contains(&rect, {9, 10}));
+            CHECK(!sfFloatRect_contains(&rect, {10, 9}));
+            CHECK(!sfFloatRect_contains(&rect, {10, 10}));
+            CHECK(!sfFloatRect_contains(&rect, {15, 15}));
+        }
+
+        SECTION("int")
+        {
+            const sfIntRect rect{{0, 0}, {10, 10}};
+            CHECK(sfIntRect_contains(&rect, {0, 0}));
+            CHECK(sfIntRect_contains(&rect, {9, 0}));
+            CHECK(sfIntRect_contains(&rect, {0, 9}));
+            CHECK(sfIntRect_contains(&rect, {9, 9}));
+            CHECK(!sfIntRect_contains(&rect, {9, 10}));
+            CHECK(!sfIntRect_contains(&rect, {10, 9}));
+            CHECK(!sfIntRect_contains(&rect, {10, 10}));
+            CHECK(!sfIntRect_contains(&rect, {15, 15}));
+        }
+    }
+}

test/Graphics/RenderStates.test.cpp

@@ -0,0 +1,41 @@
+#include <CSFML/Graphics/RenderStates.h>
+
+#include <SFML/Graphics/RenderStates.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "CSFML/Graphics/CoordinateType.h"
+
+TEST_CASE("[Graphics] sfRenderStates")
+{
+    SECTION("Construction")
+    {
+        constexpr sfRenderStates renderStates{};
+        STATIC_CHECK(renderStates.blendMode.colorSrcFactor == sfBlendFactorZero);
+        STATIC_CHECK(renderStates.blendMode.colorDstFactor == sfBlendFactorZero);
+        STATIC_CHECK(renderStates.blendMode.colorEquation == sfBlendEquationAdd);
+        STATIC_CHECK(renderStates.blendMode.alphaSrcFactor == sfBlendFactorZero);
+        STATIC_CHECK(renderStates.blendMode.alphaDstFactor == sfBlendFactorZero);
+        STATIC_CHECK(renderStates.blendMode.alphaEquation == sfBlendEquationAdd);
+        STATIC_CHECK(renderStates.stencilMode.stencilComparison == sfStencilComparisonNever);
+        STATIC_CHECK(renderStates.stencilMode.stencilUpdateOperation == sfStencilUpdateOperationKeep);
+        STATIC_CHECK(renderStates.stencilMode.stencilReference.value == 0);
+        STATIC_CHECK(renderStates.stencilMode.stencilMask.value == 0);
+        STATIC_CHECK(!renderStates.stencilMode.stencilOnly);
+        for (const auto element : renderStates.transform.matrix)
+            CHECK(element == 0);
+        STATIC_CHECK(renderStates.coordinateType == sfCoordinateTypeNormalized);
+        STATIC_CHECK(renderStates.texture == nullptr);
+        STATIC_CHECK(renderStates.shader == nullptr);
+    }
+
+    SECTION("sfRenderStates_default")
+    {
+        CHECK(sfRenderStates_default.blendMode.alphaDstFactor == sfBlendAlpha.alphaDstFactor);
+        CHECK(sfRenderStates_default.blendMode.colorDstFactor == sfBlendAlpha.colorDstFactor);
+        CHECK(sfRenderStates_default.blendMode.colorEquation == sfBlendAlpha.colorEquation);
+        CHECK(sfRenderStates_default.blendMode.alphaSrcFactor == sfBlendAlpha.alphaSrcFactor);
+        CHECK(sfRenderStates_default.blendMode.alphaDstFactor == sfBlendAlpha.alphaDstFactor);
+        CHECK(sfRenderStates_default.blendMode.alphaEquation == sfBlendAlpha.alphaEquation);
+    }
+}

test/Graphics/Shape.test.cpp

@@ -0,0 +1,107 @@
+#include <CSFML/Graphics/Shape.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+TEST_CASE("[Graphics] sfShape")
+{
+    const auto getPointCount = [](void* userData) -> std::size_t
+    { return static_cast<std::vector<sfVector2f>*>(userData)->size(); };
+    const auto getPoint = [](std::size_t index, void* userData) -> sfVector2f
+    { return static_cast<std::vector<sfVector2f>*>(userData)->operator[](index); };
+    std::vector<sfVector2f> points = {{0, 0}, {30, 0}, {0, 30}};
+
+    SECTION("sfShape_create")
+    {
+        const sfShape*   shape    = sfShape_create(getPointCount, getPoint, &points);
+        const sfVector2f position = sfShape_getPosition(shape);
+        CHECK(position.x == 0);
+        CHECK(position.y == 0);
+        CHECK(sfShape_getRotation(shape) == 0);
+        const sfVector2f scale = sfShape_getScale(shape);
+        CHECK(scale.x == 1);
+        CHECK(scale.y == 1);
+        const sfVector2f origin = sfShape_getOrigin(shape);
+        CHECK(origin.x == 0);
+        CHECK(origin.y == 0);
+        const sfTransform transform = sfShape_getTransform(shape);
+        const std::vector matrix(std::data(transform.matrix), std::data(transform.matrix) + std::size(transform.matrix));
+        CHECK(matrix == std::vector<float>({1, 0, 0, 0, 1, 0, 0, 0, 1}));
+        const sfTransform inverseTransform = sfShape_getInverseTransform(shape);
+        const std::vector inverseMatrix(std::data(inverseTransform.matrix),
+                                        std::data(inverseTransform.matrix) + std::size(inverseTransform.matrix));
+        CHECK(inverseMatrix == std::vector<float>({1, 0, 0, 0, 1, 0, 0, 0, 1}));
+        CHECK(sfShape_getTexture(shape) == nullptr);
+        const sfIntRect textureRect = sfShape_getTextureRect(shape);
+        CHECK(textureRect.position.x == 0);
+        CHECK(textureRect.position.y == 0);
+        CHECK(textureRect.size.x == 0);
+        CHECK(textureRect.size.y == 0);
+        const sfColor fillColor = sfShape_getFillColor(shape);
+        CHECK(fillColor.r == sfWhite.r);
+        CHECK(fillColor.g == sfWhite.g);
+        CHECK(fillColor.b == sfWhite.b);
+        CHECK(fillColor.a == sfWhite.a);
+        const sfColor outlineColor = sfShape_getOutlineColor(shape);
+        CHECK(outlineColor.r == sfWhite.r);
+        CHECK(outlineColor.g == sfWhite.g);
+        CHECK(outlineColor.b == sfWhite.b);
+        CHECK(outlineColor.a == sfWhite.a);
+        CHECK(sfShape_getOutlineThickness(shape) == 0);
+        CHECK(sfShape_getPointCount(shape) == 3);
+        const sfVector2f point = sfShape_getPoint(shape, 0);
+        CHECK(point.x == 0);
+        CHECK(point.y == 0);
+        const sfVector2f geometricCenter = sfShape_getGeometricCenter(shape);
+        CHECK(geometricCenter.x == 10);
+        CHECK(geometricCenter.y == 10);
+        const sfFloatRect localBounds = sfShape_getLocalBounds(shape);
+        CHECK(localBounds.position.x == 0);
+        CHECK(localBounds.position.y == 0);
+        CHECK(localBounds.size.x == 0);
+        CHECK(localBounds.size.y == 0);
+        const sfFloatRect globalBounds = sfShape_getGlobalBounds(shape);
+        CHECK(globalBounds.position.x == 0);
+        CHECK(globalBounds.position.y == 0);
+        CHECK(globalBounds.size.x == 0);
+        CHECK(globalBounds.size.y == 0);
+        sfShape_destroy(shape);
+    }
+
+    SECTION("Set/get position")
+    {
+        sfShape* shape = sfShape_create(getPointCount, getPoint, &points);
+        sfShape_setPosition(shape, {10, 20});
+        const sfVector2f position = sfShape_getPosition(shape);
+        CHECK(position.x == 10);
+        CHECK(position.y == 20);
+        sfShape_destroy(shape);
+    }
+
+    SECTION("Set/get rotation")
+    {
+        sfShape* shape = sfShape_create(getPointCount, getPoint, &points);
+        sfShape_setRotation(shape, 45);
+        CHECK(sfShape_getRotation(shape) == 45);
+        sfShape_destroy(shape);
+    }
+
+    SECTION("Set/get scale")
+    {
+        sfShape* shape = sfShape_create(getPointCount, getPoint, &points);
+        sfShape_setScale(shape, {0.5f, 0.75f});
+        const sfVector2f scale = sfShape_getScale(shape);
+        CHECK(scale.x == 0.5f);
+        CHECK(scale.y == 0.75f);
+        sfShape_destroy(shape);
+    }
+
+    SECTION("Set/get origin")
+    {
+        sfShape* shape = sfShape_create(getPointCount, getPoint, &points);
+        sfShape_setOrigin(shape, {80, 90});
+        const sfVector2f origin = sfShape_getOrigin(shape);
+        CHECK(origin.x == 80);
+        CHECK(origin.y == 90);
+        sfShape_destroy(shape);
+    }
+}

test/Graphics/StencilMode.test.cpp

@@ -0,0 +1,55 @@
+#include <CSFML/Graphics/StencilMode.h>
+
+#include <SFML/Graphics/StencilMode.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+
+TEST_CASE("[Graphics] sfStencilMode")
+{
+    SECTION("sfStencilComparison")
+    {
+        STATIC_CHECK(sfStencilComparisonNever == static_cast<int>(sf::StencilComparison::Never));
+        STATIC_CHECK(sfStencilComparisonLess == static_cast<int>(sf::StencilComparison::Less));
+        STATIC_CHECK(sfStencilComparisonLessEqual == static_cast<int>(sf::StencilComparison::LessEqual));
+        STATIC_CHECK(sfStencilComparisonGreater == static_cast<int>(sf::StencilComparison::Greater));
+        STATIC_CHECK(sfStencilComparisonGreaterEqual == static_cast<int>(sf::StencilComparison::GreaterEqual));
+        STATIC_CHECK(sfStencilComparisonEqual == static_cast<int>(sf::StencilComparison::Equal));
+        STATIC_CHECK(sfStencilComparisonNotEqual == static_cast<int>(sf::StencilComparison::NotEqual));
+        STATIC_CHECK(sfStencilComparisonAlways == static_cast<int>(sf::StencilComparison::Always));
+    }
+
+    SECTION("sfStencilUpdateOperation")
+    {
+        STATIC_CHECK(sfStencilUpdateOperationKeep == static_cast<int>(sf::StencilUpdateOperation::Keep));
+        STATIC_CHECK(sfStencilUpdateOperationZero == static_cast<int>(sf::StencilUpdateOperation::Zero));
+        STATIC_CHECK(sfStencilUpdateOperationReplace == static_cast<int>(sf::StencilUpdateOperation::Replace));
+        STATIC_CHECK(sfStencilUpdateOperationIncrement == static_cast<int>(sf::StencilUpdateOperation::Increment));
+        STATIC_CHECK(sfStencilUpdateOperationDecrement == static_cast<int>(sf::StencilUpdateOperation::Decrement));
+        STATIC_CHECK(sfStencilUpdateOperationInvert == static_cast<int>(sf::StencilUpdateOperation::Invert));
+    }
+
+    SECTION("sfStencilValue")
+    {
+        constexpr sfStencilValue stencilValue{};
+        STATIC_CHECK(stencilValue.value == 0);
+    }
+
+    SECTION("sfStencilMode")
+    {
+        constexpr sfStencilMode stencilMode{};
+        STATIC_CHECK(stencilMode.stencilComparison == sfStencilComparisonNever);
+        STATIC_CHECK(stencilMode.stencilUpdateOperation == sfStencilUpdateOperationKeep);
+        STATIC_CHECK(stencilMode.stencilReference.value == 0);
+        STATIC_CHECK(stencilMode.stencilMask.value == 0);
+        STATIC_CHECK(!stencilMode.stencilOnly);
+    }
+
+    SECTION("sfStencilMode_default")
+    {
+        CHECK(sfStencilMode_default.stencilComparison == sfStencilComparisonAlways);
+        CHECK(sfStencilMode_default.stencilUpdateOperation == sfStencilUpdateOperationKeep);
+        CHECK(sfStencilMode_default.stencilReference.value == 0);
+        CHECK(sfStencilMode_default.stencilMask.value == ~0u);
+        CHECK(!sfStencilMode_default.stencilOnly);
+    }
+}

test/Graphics/Transform.test.cpp

@@ -0,0 +1,128 @@
+#include <CSFML/Graphics/Transform.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include <array>
+
+TEST_CASE("[Graphics] sfTransform")
+{
+    SECTION("Construction")
+    {
+        constexpr sfTransform transform{};
+        STATIC_CHECK(std::size(transform.matrix) == 9);
+        for (const auto element : transform.matrix)
+            CHECK(element == 0);
+    }
+
+    SECTION("sfTransform_Identity")
+    {
+        CHECK(sfTransform_Identity.matrix[0] == 1);
+        CHECK(sfTransform_Identity.matrix[1] == 0);
+        CHECK(sfTransform_Identity.matrix[2] == 0);
+        CHECK(sfTransform_Identity.matrix[3] == 0);
+        CHECK(sfTransform_Identity.matrix[4] == 1);
+        CHECK(sfTransform_Identity.matrix[5] == 0);
+        CHECK(sfTransform_Identity.matrix[6] == 0);
+        CHECK(sfTransform_Identity.matrix[7] == 0);
+        CHECK(sfTransform_Identity.matrix[8] == 1);
+    }
+
+    SECTION("sfTransform_fromMatrix")
+    {
+        const auto transform = sfTransform_fromMatrix(1, 2, 3, 4, 5, 6, 7, 8, 9);
+        CHECK(transform.matrix[0] == 1);
+        CHECK(transform.matrix[1] == 2);
+        CHECK(transform.matrix[2] == 3);
+        CHECK(transform.matrix[3] == 4);
+        CHECK(transform.matrix[4] == 5);
+        CHECK(transform.matrix[5] == 6);
+        CHECK(transform.matrix[6] == 7);
+        CHECK(transform.matrix[7] == 8);
+        CHECK(transform.matrix[8] == 9);
+    }
+
+    SECTION("sfTransform_getMatrix")
+    {
+        const auto            transform = sfTransform_fromMatrix(1, 2, 3, 4, 5, 6, 7, 8, 9);
+        std::array<float, 16> matrix{};
+        matrix.fill(std::numeric_limits<float>::signaling_NaN());
+        sfTransform_getMatrix(&transform, matrix.data());
+        CHECK(matrix[0] == 1);
+        CHECK(matrix[1] == 4);
+        CHECK(matrix[2] == 0);
+        CHECK(matrix[3] == 7);
+        CHECK(matrix[4] == 2);
+        CHECK(matrix[5] == 5);
+        CHECK(matrix[6] == 0);
+        CHECK(matrix[7] == 8);
+        CHECK(matrix[8] == 0);
+        CHECK(matrix[9] == 0);
+        CHECK(matrix[10] == 1);
+        CHECK(matrix[11] == 0);
+        CHECK(matrix[12] == 3);
+        CHECK(matrix[13] == 6);
+        CHECK(matrix[14] == 0);
+        CHECK(matrix[15] == 9);
+    }
+
+    SECTION("sfTransform_getInverse")
+    {
+        SECTION("Identity")
+        {
+            const auto inverse = sfTransform_getInverse(&sfTransform_Identity);
+            for (std::size_t i = 0; i < std::size(inverse.matrix); ++i)
+                CHECK(inverse.matrix[0] == sfTransform_Identity.matrix[0]);
+        }
+
+        SECTION("Non-identity")
+        {
+            const auto transform = sfTransform_fromMatrix(1, 2, 3, 4, 5, 4, 3, 2, 1);
+            const auto inverse   = sfTransform_getInverse(&transform);
+            CHECK(inverse.matrix[0] == 0.375f);
+            CHECK(inverse.matrix[1] == -0.5f);
+            CHECK(inverse.matrix[2] == 0.875f);
+            CHECK(inverse.matrix[3] == -1);
+            CHECK(inverse.matrix[4] == 1);
+            CHECK(inverse.matrix[5] == -1);
+            CHECK(inverse.matrix[6] == 0.875f);
+            CHECK(inverse.matrix[7] == -0.5f);
+            CHECK(inverse.matrix[8] == 0.375f);
+        }
+    }
+
+    SECTION("sfTransform_transformPoint")
+    {
+    }
+
+    SECTION("sfTransform_transformRect")
+    {
+    }
+
+    SECTION("sfTransform_combine")
+    {
+    }
+
+    SECTION("sfTransform_translate")
+    {
+    }
+
+    SECTION("sfTransform_rotate")
+    {
+    }
+
+    SECTION("sfTransform_rotateWithCenter")
+    {
+    }
+
+    SECTION("sfTransform_scale")
+    {
+    }
+
+    SECTION("sfTransform_scaleWithCenter")
+    {
+    }
+
+    SECTION("sfTransform_equal")
+    {
+    }
+}

test/Graphics/VertexArray.test.cpp

@@ -0,0 +1,116 @@
+#include <CSFML/Graphics/VertexArray.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+TEST_CASE("[Graphics] sfVertexArray")
+{
+    SECTION("sfVertexArray_create")
+    {
+        const sfVertexArray* vertexArray = sfVertexArray_create();
+        CHECK(sfVertexArray_getVertexCount(vertexArray) == 0);
+        CHECK(sfVertexArray_getPrimitiveType(vertexArray) == sfPoints);
+        const sfFloatRect bounds = sfVertexArray_getBounds(vertexArray);
+        CHECK(bounds.position.x == 0);
+        CHECK(bounds.position.y == 0);
+        CHECK(bounds.size.x == 0);
+        CHECK(bounds.size.y == 0);
+        sfVertexArray_destroy(vertexArray);
+    }
+
+    SECTION("sfVertexArray_copy")
+    {
+        sfVertexArray* vertexArray1 = sfVertexArray_create();
+        sfVertexArray_resize(vertexArray1, 10);
+        sfVertexArray_setPrimitiveType(vertexArray1, sfLines);
+        const sfVertexArray* vertexArray2 = sfVertexArray_copy(vertexArray1);
+        CHECK(sfVertexArray_getVertexCount(vertexArray2) == 10);
+        CHECK(sfVertexArray_getPrimitiveType(vertexArray2) == sfLines);
+        sfVertexArray_destroy(vertexArray2);
+        sfVertexArray_destroy(vertexArray1);
+    }
+
+    SECTION("sfVertexArray_resize")
+    {
+        sfVertexArray* vertexArray = sfVertexArray_create();
+        sfVertexArray_resize(vertexArray, 42);
+        const auto vertexCount = sfVertexArray_getVertexCount(vertexArray);
+        CHECK(vertexCount == 42);
+        for (std::size_t i = 0; i < vertexCount; ++i)
+        {
+            const auto& vertex = *sfVertexArray_getVertex(vertexArray, i);
+            CHECK(vertex.position.x == 0);
+            CHECK(vertex.position.y == 0);
+            CHECK(+vertex.color.r == sfWhite.r);
+            CHECK(+vertex.color.g == sfWhite.g);
+            CHECK(+vertex.color.b == sfWhite.b);
+            CHECK(+vertex.color.a == sfWhite.a);
+            CHECK(vertex.texCoords.x == 0);
+            CHECK(vertex.texCoords.y == 0);
+        }
+        sfVertexArray_destroy(vertexArray);
+    }
+
+    SECTION("sfVertexArray_clear")
+    {
+        sfVertexArray* vertexArray = sfVertexArray_create();
+        sfVertexArray_resize(vertexArray, 13);
+        sfVertexArray_setPrimitiveType(vertexArray, sfLines);
+        sfVertexArray_clear(vertexArray);
+        CHECK(sfVertexArray_getVertexCount(vertexArray) == 0);
+        CHECK(sfVertexArray_getPrimitiveType(vertexArray) == sfLines);
+        sfVertexArray_destroy(vertexArray);
+    }
+
+    SECTION("sfVertexArray_append")
+    {
+        sfVertexArray* vertexArray = sfVertexArray_create();
+        sfVertexArray_append(vertexArray, {{1, 2}, {3, 4, 5, 6}, {7, 8}});
+        CHECK(sfVertexArray_getVertexCount(vertexArray) == 1);
+        const auto& vertex = *sfVertexArray_getVertex(vertexArray, 0);
+        CHECK(vertex.position.x == 1);
+        CHECK(vertex.position.y == 2);
+        CHECK(+vertex.color.r == 3);
+        CHECK(+vertex.color.g == 4);
+        CHECK(+vertex.color.b == 5);
+        CHECK(+vertex.color.a == 6);
+        CHECK(vertex.texCoords.x == 7);
+        CHECK(vertex.texCoords.y == 8);
+        sfVertexArray_destroy(vertexArray);
+    }
+
+    SECTION("sfVertexArray_getBounds")
+    {
+        sfVertexArray* vertexArray = sfVertexArray_create();
+        sfVertexArray_append(vertexArray, {{1, 1}, {}, {}});
+        sfVertexArray_append(vertexArray, {{2, 2}, {}, {}});
+
+        sfFloatRect bounds = sfVertexArray_getBounds(vertexArray);
+        CHECK(bounds.position.x == 1);
+        CHECK(bounds.position.y == 1);
+        CHECK(bounds.size.x == 1);
+        CHECK(bounds.size.y == 1);
+
+        *sfVertexArray_getVertex(vertexArray, 0) = {{0, 0}, {}, {}};
+        bounds                                   = sfVertexArray_getBounds(vertexArray);
+        CHECK(bounds.position.x == 0);
+        CHECK(bounds.position.y == 0);
+        CHECK(bounds.size.x == 2);
+        CHECK(bounds.size.y == 2);
+
+        *sfVertexArray_getVertex(vertexArray, 0) = {{5, 5}, {}, {}};
+        bounds                                   = sfVertexArray_getBounds(vertexArray);
+        CHECK(bounds.position.x == 2);
+        CHECK(bounds.position.y == 2);
+        CHECK(bounds.size.x == 3);
+        CHECK(bounds.size.y == 3);
+
+        sfVertexArray_append(vertexArray, {{10, 10}, {}, {}});
+        bounds = sfVertexArray_getBounds(vertexArray);
+        CHECK(bounds.position.x == 2);
+        CHECK(bounds.position.y == 2);
+        CHECK(bounds.size.x == 8);
+        CHECK(bounds.size.y == 8);
+
+        sfVertexArray_destroy(vertexArray);
+    }
+}

test/Graphics/View.test.cpp

@@ -0,0 +1,157 @@
+#include <CSFML/Graphics/View.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+TEST_CASE("[Graphics] sfView")
+{
+    SECTION("sfView_create")
+    {
+        const sfView*    view   = sfView_create();
+        const sfVector2f center = sfView_getCenter(view);
+        CHECK(center.x == 500);
+        CHECK(center.y == 500);
+        const sfVector2f size = sfView_getSize(view);
+        CHECK(size.x == 1000);
+        CHECK(size.y == 1000);
+        CHECK(sfView_getRotation(view) == 0);
+        const sfFloatRect viewport = sfView_getViewport(view);
+        CHECK(viewport.position.x == 0);
+        CHECK(viewport.position.y == 0);
+        CHECK(viewport.size.x == 1);
+        CHECK(viewport.size.y == 1);
+        const sfFloatRect scissor = sfView_getScissor(view);
+        CHECK(scissor.position.x == 0);
+        CHECK(scissor.position.y == 0);
+        CHECK(scissor.size.x == 1);
+        CHECK(scissor.size.y == 1);
+        sfView_destroy(view);
+    }
+
+    SECTION("sfView_createFromRect")
+    {
+        const sfView*    view   = sfView_createFromRect({{50, 100}, {240, 360}});
+        const sfVector2f center = sfView_getCenter(view);
+        CHECK(center.x == 170);
+        CHECK(center.y == 280);
+        const sfVector2f size = sfView_getSize(view);
+        CHECK(size.x == 240);
+        CHECK(size.y == 360);
+        CHECK(sfView_getRotation(view) == 0);
+        const sfFloatRect viewport = sfView_getViewport(view);
+        CHECK(viewport.position.x == 0);
+        CHECK(viewport.position.y == 0);
+        CHECK(viewport.size.x == 1);
+        CHECK(viewport.size.y == 1);
+        const sfFloatRect scissor = sfView_getScissor(view);
+        CHECK(scissor.position.x == 0);
+        CHECK(scissor.position.y == 0);
+        CHECK(scissor.size.x == 1);
+        CHECK(scissor.size.y == 1);
+        sfView_destroy(view);
+    }
+
+    SECTION("sfView_copy")
+    {
+        sfView* view1 = sfView_createFromRect({{50, 100}, {240, 360}});
+        sfView_setViewport(view1, {{25, 40}, {100, 200}});
+        sfView_setScissor(view1, {{0.75f, 0.25f}, {0, 0.5f}});
+        const sfView*    view2  = sfView_copy(view1);
+        const sfVector2f center = sfView_getCenter(view2);
+        CHECK(center.x == 170);
+        CHECK(center.y == 280);
+        const sfVector2f size = sfView_getSize(view2);
+        CHECK(size.x == 240);
+        CHECK(size.y == 360);
+        CHECK(sfView_getRotation(view2) == 0);
+        const sfFloatRect viewport = sfView_getViewport(view2);
+        CHECK(viewport.position.x == 25);
+        CHECK(viewport.position.y == 40);
+        CHECK(viewport.size.x == 100);
+        CHECK(viewport.size.y == 200);
+        const sfFloatRect scissor = sfView_getScissor(view2);
+        CHECK(scissor.position.x == 0.75f);
+        CHECK(scissor.position.y == 0.25f);
+        CHECK(scissor.size.x == 0);
+        CHECK(scissor.size.y == 0.5f);
+        sfView_destroy(view2);
+        sfView_destroy(view1);
+    }
+
+    SECTION("sfView_setCenter")
+    {
+        sfView* view = sfView_create();
+        sfView_setCenter(view, {400, 600});
+        const sfVector2f center = sfView_getCenter(view);
+        CHECK(center.x == 400);
+        CHECK(center.y == 600);
+        sfView_destroy(view);
+    }
+
+    SECTION("sfView_setSize")
+    {
+        sfView* view = sfView_create();
+        sfView_setSize(view, {150, 350});
+        const sfVector2f size = sfView_getSize(view);
+        CHECK(size.x == 150);
+        CHECK(size.y == 350);
+        sfView_destroy(view);
+    }
+
+    SECTION("sfView_setRotation")
+    {
+        sfView* view = sfView_create();
+        sfView_setRotation(view, 45);
+        CHECK(sfView_getRotation(view) == 45);
+        sfView_destroy(view);
+    }
+
+    SECTION("sfView_setViewport")
+    {
+        sfView* view = sfView_create();
+        sfView_setViewport(view, {{25, 40}, {100, 200}});
+        const sfFloatRect viewport = sfView_getViewport(view);
+        CHECK(viewport.position.x == 25);
+        CHECK(viewport.position.y == 40);
+        CHECK(viewport.size.x == 100);
+        CHECK(viewport.size.y == 200);
+        sfView_destroy(view);
+    }
+
+    SECTION("sfView_setScissor")
+    {
+        sfView* view = sfView_create();
+        sfView_setScissor(view, {{0.75f, 0.25f}, {0, 0.5f}});
+        const sfFloatRect scissor = sfView_getScissor(view);
+        CHECK(scissor.position.x == 0.75f);
+        CHECK(scissor.position.y == 0.25f);
+        CHECK(scissor.size.x == 0);
+        CHECK(scissor.size.y == 0.5f);
+        sfView_destroy(view);
+    }
+
+    SECTION("sfView_move, sfView_rotate, sfView_zoom")
+    {
+        sfView* view = sfView_create();
+        sfView_move(view, {15, 35});
+        sfView_rotate(view, 180);
+        sfView_zoom(view, 2);
+        const sfVector2f center = sfView_getCenter(view);
+        CHECK(center.x == 515);
+        CHECK(center.y == 535);
+        const sfVector2f size = sfView_getSize(view);
+        CHECK(size.x == 2000);
+        CHECK(size.y == 2000);
+        CHECK(sfView_getRotation(view) == 180);
+        const sfFloatRect viewport = sfView_getViewport(view);
+        CHECK(viewport.position.x == 0);
+        CHECK(viewport.position.y == 0);
+        CHECK(viewport.size.x == 1);
+        CHECK(viewport.size.y == 1);
+        const sfFloatRect scissor = sfView_getScissor(view);
+        CHECK(scissor.position.x == 0);
+        CHECK(scissor.position.y == 0);
+        CHECK(scissor.size.x == 1);
+        CHECK(scissor.size.y == 1);
+        sfView_destroy(view);
+    }
+}

test/Network/IpAddress.test.cpp

@@ -2,6 +2,8 @@
 
 #include <catch2/catch_test_macros.hpp>
 
+#include <cstring>
+
 TEST_CASE("[Network] sfIpAddress")
 {
     SECTION("Constants")
@@ -10,6 +12,11 @@ TEST_CASE("[Network] sfIpAddress")
         CHECK(sfIpAddress_toInteger(sfIpAddress_Any) == 0);
         CHECK(sfIpAddress_toInteger(sfIpAddress_LocalHost) == 0x7F000001);
         CHECK(sfIpAddress_toInteger(sfIpAddress_Broadcast) == 0xFFFFFFFF);
+
+        CHECK(std::strcmp(sfIpAddress_None.address, "") == 0);
+        CHECK(std::strcmp(sfIpAddress_Any.address, "0.0.0.0") == 0);
+        CHECK(std::strcmp(sfIpAddress_LocalHost.address, "127.0.0.1") == 0);
+        CHECK(std::strcmp(sfIpAddress_Broadcast.address, "255.255.255.255") == 0);
     }
 
     SECTION("sfIpAddress_fromString")

test/System/Time.test.cpp

@@ -28,4 +28,7 @@ TEST_CASE("[System] sfTime")
     CHECK(sfSeconds(10).microseconds == 10'000'000);
     CHECK(sfMilliseconds(10).microseconds == 10'000);
     CHECK(sfMicroseconds(10).microseconds == 10);
+
+    CHECK(sfMilliseconds(std::numeric_limits<int32_t>::max()).microseconds == 2'147'483'647'000);
+    CHECK(sfMicroseconds(std::numeric_limits<int64_t>::max()).microseconds == std::numeric_limits<int64_t>::max());
 }

test/Window/Joystick.test.cpp

@@ -30,7 +30,7 @@ TEST_CASE("[Window] sfJoystick")
     // no joysticks will be detected. This is how we can ensure these
     // tests are portable and reliable.
 
-    const auto joystick = GENERATE(range(0u, static_cast<unsigned int>(sfJoystickCount - 1)));
+    const auto joystick = GENERATE(range(0u, unsigned{sfJoystickCount - 1}));
 
     SECTION("sfJoystick_isConnected()")
     {
@@ -56,7 +56,7 @@ TEST_CASE("[Window] sfJoystick")
 
     SECTION("sfJoystick_isButtonPressed()")
     {
-        const auto button = GENERATE(range(0u, static_cast<unsigned int>(sfJoystickButtonCount - 1)));
+        const auto button = GENERATE(range(0u, unsigned{sfJoystickButtonCount - 1}));
         CHECK(!sfJoystick_isButtonPressed(joystick, button));
     }
 

test/Window/Keyboard.test.cpp

@@ -26,4 +26,47 @@ TEST_CASE("[Window] sfKeyboard")
         STATIC_CHECK(sfScanD == static_cast<int>(sf::Keyboard::Scan::D));
         STATIC_CHECK(sfScancodeCount == sf::Keyboard::ScancodeCount);
     }
+
+    SECTION("sfKeyboard_isKeyPressed")
+    {
+        CHECK(!sfKeyboard_isKeyPressed(sfKeyW));
+        CHECK(!sfKeyboard_isKeyPressed(sfKeyA));
+        CHECK(!sfKeyboard_isKeyPressed(sfKeyS));
+        CHECK(!sfKeyboard_isKeyPressed(sfKeyD));
+    }
+
+    SECTION("sfKeyboard_isScancodePressed")
+    {
+        CHECK(!sfKeyboard_isScancodePressed(sfScanW));
+        CHECK(!sfKeyboard_isScancodePressed(sfScanA));
+        CHECK(!sfKeyboard_isScancodePressed(sfScanS));
+        CHECK(!sfKeyboard_isScancodePressed(sfScanD));
+    }
+
+    SECTION("sfKeyboard_localize")
+    {
+        CHECK(sfKeyboard_localize(sfScanSpace) == sfKeySpace);
+    }
+
+    SECTION("sfKeyboard_delocalize")
+    {
+        CHECK(sfKeyboard_delocalize(sfKeySpace) == sfScanSpace);
+    }
+
+    SECTION("sfKeyboard_getDescription")
+    {
+        using namespace std::string_literals;
+        CHECK(sfKeyboard_getDescription(sfScanF1) == "F1"s);
+        CHECK(sfKeyboard_getDescription(sfScanF2) == "F2"s);
+        CHECK(sfKeyboard_getDescription(sfScanF3) == "F3"s);
+        CHECK(sfKeyboard_getDescription(sfScanF4) == "F4"s);
+        CHECK(sfKeyboard_getDescription(sfScanF5) == "F5"s);
+        CHECK(sfKeyboard_getDescription(sfScanF6) == "F6"s);
+        CHECK(sfKeyboard_getDescription(sfScanF7) == "F7"s);
+        CHECK(sfKeyboard_getDescription(sfScanF8) == "F8"s);
+        CHECK(sfKeyboard_getDescription(sfScanF9) == "F9"s);
+        CHECK(sfKeyboard_getDescription(sfScanF10) == "F10"s);
+        CHECK(sfKeyboard_getDescription(sfScanF11) == "F11"s);
+        CHECK(sfKeyboard_getDescription(sfScanF12) == "F12"s);
+    }
 }

test/Window/Mouse.test.cpp

@@ -11,8 +11,8 @@ TEST_CASE("[Window] sfMouse")
         STATIC_CHECK(sfMouseLeft == static_cast<int>(sf::Mouse::Button::Left));
         STATIC_CHECK(sfMouseRight == static_cast<int>(sf::Mouse::Button::Right));
         STATIC_CHECK(sfMouseMiddle == static_cast<int>(sf::Mouse::Button::Middle));
-        STATIC_CHECK(sfMouseXButton1 == static_cast<int>(sf::Mouse::Button::Extra1));
-        STATIC_CHECK(sfMouseXButton2 == static_cast<int>(sf::Mouse::Button::Extra2));
+        STATIC_CHECK(sfMouseButtonExtra1 == static_cast<int>(sf::Mouse::Button::Extra1));
+        STATIC_CHECK(sfMouseButtonExtra2 == static_cast<int>(sf::Mouse::Button::Extra2));
         STATIC_CHECK(sfMouseButtonCount == sf::Mouse::ButtonCount);
     }
 

tools/nuget/build.win.ps1

@@ -154,7 +154,7 @@ cmake `
     "-DCMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE=$CSFMLLibDir" `
     `
     '-DCMAKE_SYSTEM_VERSION=8.1' `
-    '-DSTATIC_STD_LIBS=OFF' `
+    '-DCSFML_USE_STATIC_STD_LIBS=OFF' `
     `
     '-DBUILD_SHARED_LIBS=ON' `
     '-DCMAKE_BUILD_TYPE=Release' `