Reimplement sfTexture

.github/FUNDING.yml

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

.github/workflows/ci.yml

@@ -6,9 +6,6 @@ concurrency:
   group: environment-${{github.ref}}
   cancel-in-progress: true
 
-env:
-  SFML_VERSION: 3.0.0
-
 defaults:
   run:
     shell: bash
@@ -52,7 +49,7 @@ jobs:
       uses: actions/checkout@v4
       with:
         repository: SFML/SFML
-        ref: ${{env.SFML_VERSION}}
+        ref: master
         path: SFML
 
     - name: Configure SFML CMake
@@ -77,17 +74,14 @@ jobs:
 
   format:
     name: Formatting
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.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-17 -P cmake/Format.cmake
+      run: cmake -DCLANG_FORMAT_EXECUTABLE=clang-format-14 -P cmake/Format.cmake
 
     - name: Check Formatting
       run: git diff --exit-code
@@ -107,7 +101,7 @@ jobs:
       uses: actions/checkout@v4
       with:
         repository: SFML/SFML
-        ref: ${{env.SFML_VERSION}}
+        ref: master
         path: SFML
 
     - name: Configure SFML CMake
@@ -141,7 +135,7 @@ jobs:
       uses: actions/checkout@v4
       with:
         repository: SFML/SFML
-        ref: ${{env.SFML_VERSION}}
+        ref: master
         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)
-    csfml_set_option(CSFML_USE_STATIC_STD_LIBS OFF BOOL "ON to statically link to the standard libraries, OFF to use them as DLLs")
+    set(STATIC_STD_LIBS OFF CACHE 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 17")
+csfml_set_option(CLANG_FORMAT_EXECUTABLE clang-format STRING "Override clang-format executable, requires version 14")
 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 17)
-    message(FATAL_ERROR "clang-format version ${CMAKE_MATCH_1} not supported. Must use version 17")
+if(NOT CMAKE_MATCH_1 EQUAL 14)
+    message(FATAL_ERROR "clang-format version ${CMAKE_MATCH_1} not supported. Must use version 14")
 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(CSFML_USE_STATIC_STD_LIBS)
+        if(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 CSFML_USE_STATIC_STD_LIBS option if it is enabled
+    # apply the SFML_USE_STATIC_STD_LIBS option if it is enabled
     if(SFML_OS_WINDOWS AND SFML_COMPILER_GCC)
-        if(CSFML_USE_STATIC_STD_LIBS AND NOT SFML_COMPILER_GCC_TDM)
+        if(SFML_USE_STATIC_STD_LIBS AND NOT SFML_COMPILER_GCC_TDM)
             set_target_properties(${target} PROPERTIES LINK_FLAGS "-static-libgcc -static-libstdc++")
-        elseif(NOT CSFML_USE_STATIC_STD_LIBS AND SFML_COMPILER_GCC_TDM)
+        elseif(NOT SFML_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 sfTime
+/// \brief Sets the beginning and end of the sound's looping sequence using sf::Time
 ///
 /// 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* const* sfSoundRecorder_getAvailableDevices(size_t* count);
+CSFML_AUDIO_API const char** sfSoundRecorder_getAvailableDevices(size_t* count);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the name of the default audio capture device

include/CSFML/Graphics/CoordinateType.h

@@ -1,35 +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
-
-////////////////////////////////////////////////////////////
-/// \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 an sfVertexArray can render
+/// \brief Types of primitives that a sf::VertexArray 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,8 +30,6 @@
 #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>
 
@@ -42,12 +40,10 @@
 ////////////////////////////////////////////////////////////
 typedef struct
 {
-    sfBlendMode      blendMode;      ///< Blending mode
-    sfStencilMode    stencilMode;    //!< Stencil mode
-    sfTransform      transform;      ///< Transform
-    sfCoordinateType coordinateType; //!< Texture coordinate type
-    const sfTexture* texture;        ///< Texture
-    const sfShader*  shader;         ///< Shader
+    sfBlendMode      blendMode; ///< Blending mode
+    sfTransform      transform; ///< Transform
+    const sfTexture* texture;   ///< Texture
+    const sfShader*  shader;    ///< Shader
 } sfRenderStates;
 
 ////////////////////////////////////////////////////////////

include/CSFML/Graphics/Texture.h

@@ -29,7 +29,6 @@
 ////////////////////////////////////////////////////////////
 #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>
@@ -38,6 +37,16 @@
 
 #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
 ///
@@ -391,7 +400,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, sfCoordinateType type);
+CSFML_GRAPHICS_API void sfTexture_bind(const sfTexture* texture, sfTextureCoordinateType type);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the maximum texture size allowed

include/CSFML/Graphics/VertexBuffer.h

@@ -69,7 +69,7 @@ typedef enum
 /// \return A new sfVertexBuffer object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfVertexBuffer* sfVertexBuffer_create(size_t vertexCount, sfPrimitiveType type, sfVertexBufferUsage usage);
+CSFML_GRAPHICS_API sfVertexBuffer* sfVertexBuffer_create(unsigned int vertexCount, sfPrimitiveType type, sfVertexBufferUsage usage);
 
 ////////////////////////////////////////////////////////////
 /// \brief Copy an existing vertex buffer
@@ -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 sfPoints.
+/// The default primitive type is sf::Points.
 ///
 /// \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 sfVertexBuffer will fail.
+/// any attempt to use sf::VertexBuffer will fail.
 ///
 /// \return True if vertex buffers are supported, false otherwise
 ///

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 or NULL if it failed
+/// \return Directory name
 ///
 ////////////////////////////////////////////////////////////
 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 or NULL if it failed
+/// \return Directory name
 ///
 ////////////////////////////////////////////////////////////
 CSFML_NETWORK_API const sfChar32* sfFtpDirectoryResponse_getDirectoryUnicode(const sfFtpDirectoryResponse* ftpDirectoryResponse);

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*, size_t, size_t*)
+/// sockets, use the sfTcpSocket_sendPartial(sfTcpSocket*, const void*, std::size_t, size_t*)
 /// overload instead.
 /// This function will fail if the socket is not connected.
 ///

include/CSFML/System/Time.h

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

include/CSFML/Window/Keyboard.h

@@ -142,12 +142,10 @@ 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
@@ -312,12 +310,10 @@ 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,17 +39,14 @@
 ////////////////////////////////////////////////////////////
 typedef enum
 {
-    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;
+    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
 
-enum
-{
-    sfMouseButtonCount = sfMouseButtonExtra2 + 1 ///< The total number of mouse buttons
-};
+    sfMouseButtonCount ///< Keep last -- the total number of mouse buttons
+} sfMouseButton;
 
 ////////////////////////////////////////////////////////////
 /// \brief Mouse wheels

include/CSFML/Window/Sensor.h

@@ -45,12 +45,10 @@ 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 CSFML 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 SFML 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);
+    music->setLooping(loop != 0);
 }
 
 

src/CSFML/Audio/SoundRecorder.cpp

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

src/CSFML/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/Graphics/CMakeLists.txt

@@ -19,7 +19,6 @@ 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 ? texture->This : nullptr, resetRect);
+    shape->setTexture(texture, resetRect);
     shape->Texture = texture;
 }
 

src/CSFML/Graphics/Color.cpp

@@ -45,26 +45,33 @@ const sfColor sfTransparent = sfColor_fromRGBA(0, 0, 0, 0);
 ////////////////////////////////////////////////////////////
 sfColor sfColor_fromRGB(uint8_t red, uint8_t green, uint8_t blue)
 {
-    return {red, green, blue, 255};
+    return sfColor_fromRGBA(red, green, blue, 255);
 }
 
 
 ////////////////////////////////////////////////////////////
 sfColor sfColor_fromRGBA(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha)
 {
-    return {red, green, blue, alpha};
+    sfColor color;
+
+    color.r = red;
+    color.g = green;
+    color.b = blue;
+    color.a = alpha;
+
+    return color;
 }
 
 
 ////////////////////////////////////////////////////////////
 sfColor sfColor_fromInteger(uint32_t color)
 {
-    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),
-    };
+    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);
 }
 
 
@@ -78,34 +85,43 @@ uint32_t sfColor_toInteger(sfColor color)
 ////////////////////////////////////////////////////////////
 sfColor sfColor_add(sfColor color1, sfColor color2)
 {
-    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)),
-    };
+    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));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfColor sfColor_subtract(sfColor color1, sfColor color2)
 {
-    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)),
-    };
+    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));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfColor sfColor_modulate(sfColor color1, sfColor color2)
 {
-    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),
-    };
+    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));
 }

src/CSFML/Graphics/ConvertRenderStates.hpp

@@ -50,15 +50,8 @@
     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.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;
+    renderStates.transform                = convertTransform(states->transform);
+    renderStates.texture                  = states->texture;
+    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 ? texture->This : nullptr, resetRect);
+    shape->setTexture(texture, 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].This = font->getTexture(characterSize);
+    font->Textures[characterSize] = sfTexture{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 ? texture->This : nullptr, resetRect);
+    shape->setTexture(texture, resetRect);
     shape->Texture = texture;
 }
 

src/CSFML/Graphics/RenderStates.cpp

@@ -31,9 +31,7 @@
 ////////////////////////////////////////////////////////////
 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      = std::make_unique<sfTexture>(const_cast<sf::Texture*>(&renderTexture->getTexture()));
+    renderTexture->Target      = sfTexture{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.get();
+    return &renderTexture->Target;
 }
 
 

src/CSFML/Graphics/RenderTextureStruct.hpp

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

src/CSFML/Graphics/RenderWindow.cpp

@@ -25,6 +25,7 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
+#include <CSFML/ConvertEvent.hpp>
 #include <CSFML/Graphics/CircleShapeStruct.hpp>
 #include <CSFML/Graphics/ConvertColor.hpp>
 #include <CSFML/Graphics/ConvertRect.hpp>
@@ -42,7 +43,6 @@
 #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,28 +37,41 @@ 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 (!geometryShaderFilename)
+    if (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 (!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 (!success)
@@ -71,28 +84,41 @@ 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 (!geometryShader)
+    if (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 (!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 (!success)
@@ -107,44 +133,47 @@ 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 (!geometryShaderStream)
+    if (vertexShaderStream || geometryShaderStream || fragmentShaderStream)
     {
-        if (!vertexShaderStream) // fragment shader only
+        if (!geometryShaderStream)
         {
-            CallbackStream stream(fragmentShaderStream);
-            success = shader->loadFromStream(stream, sf::Shader::Type::Fragment);
+            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);
+            }
         }
-        else if (!fragmentShaderStream) // vertex shader only
+        else
         {
-            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);
+            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);
+            }
         }
     }
 
@@ -201,14 +230,13 @@ void sfShader_setVec4Uniform(sfShader* shader, const char* name, sfGlslVec4 vect
 ////////////////////////////////////////////////////////////
 void sfShader_setColorUniform(sfShader* shader, const char* name, sfColor color)
 {
-    sfShader_setVec4Uniform(shader,
-                            name,
-                            {
-                                color.r / 255.f,
-                                color.g / 255.f,
-                                color.b / 255.f,
-                                color.a / 255.f,
-                            });
+    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);
 }
 
 ////////////////////////////////////////////////////////////
@@ -250,14 +278,13 @@ void sfShader_setIvec4Uniform(sfShader* shader, const char* name, sfGlslIvec4 ve
 ////////////////////////////////////////////////////////////
 void sfShader_setIntColorUniform(sfShader* shader, const char* name, sfColor color)
 {
-    sfShader_setIvec4Uniform(shader,
-                             name,
-                             {
-                                 color.r,
-                                 color.g,
-                                 color.b,
-                                 color.a,
-                             });
+    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);
 }
 
 ////////////////////////////////////////////////////////////
@@ -319,7 +346,8 @@ void sfShader_setTextureUniform(sfShader* shader, const char* name, const sfText
 {
     assert(shader);
     assert(name);
-    shader->setUniform(name, *texture->This);
+    assert(texture);
+    shader->setUniform(name, *texture);
 }
 
 
@@ -392,7 +420,7 @@ void sfShader_setTextureParameter(sfShader* shader, const char* name, const sfTe
     assert(shader);
     assert(name);
     assert(texture);
-    shader->setUniform(name, *texture->This);
+    shader->setUniform(name, *texture);
 }
 
 

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 ? texture->This : nullptr, resetRect);
+    shape->setTexture(texture, resetRect);
     shape->Texture = texture;
 }
 

src/CSFML/Graphics/Sprite.cpp

@@ -40,8 +40,7 @@
 sfSprite* sfSprite_create(const sfTexture* texture)
 {
     assert(texture);
-    assert(texture->This);
-    auto sprite     = new sfSprite(*texture->This);
+    auto sprite     = new sfSprite(*texture);
     sprite->Texture = texture;
     return sprite;
 }
@@ -171,10 +170,10 @@ sfTransform sfSprite_getInverseTransform(const sfSprite* sprite)
 ////////////////////////////////////////////////////////////
 void sfSprite_setTexture(sfSprite* sprite, const sfTexture* texture, bool resetRect)
 {
-    if (texture && texture->This)
+    if (texture)
     {
         assert(sprite);
-        sprite->setTexture(*texture->This, resetRect);
+        sprite->setTexture(*texture, 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->This->resize(convertVector2(size)))
+    if (!texture->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->This->resize(convertVector2(size), true))
+    if (!texture->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->This->loadFromFile(filename, false, area ? convertRect(*area) : sf::IntRect()))
+    if (!texture->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->This->loadFromFile(filename, true, area ? convertRect(*area) : sf::IntRect()))
+    if (!texture->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->This->loadFromMemory(data, sizeInBytes, false, area ? convertRect(*area) : sf::IntRect()))
+    if (!texture->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->This->loadFromMemory(data, sizeInBytes, true, area ? convertRect(*area) : sf::IntRect()))
+    if (!texture->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->This->loadFromStream(sfmlStream, false, area ? convertRect(*area) : sf::IntRect()))
+    if (!texture->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->This->loadFromStream(sfmlStream, true, area ? convertRect(*area) : sf::IntRect()))
+    if (!texture->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->This->loadFromImage(*image, false, area ? convertRect(*area) : sf::IntRect()))
+    if (!texture->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->This->loadFromImage(*image, true, area ? convertRect(*area) : sf::IntRect()))
+    if (!texture->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->This->getSize());
+    return convertVector2(texture->getSize());
 }
 
 
@@ -182,8 +182,7 @@ sfVector2u sfTexture_getSize(const sfTexture* texture)
 sfImage* sfTexture_copyToImage(const sfTexture* texture)
 {
     assert(texture);
-    assert(texture->This);
-    return new sfImage{texture->This->copyToImage()};
+    return new sfImage{texture->copyToImage()};
 }
 
 
@@ -191,7 +190,7 @@ sfImage* sfTexture_copyToImage(const sfTexture* texture)
 void sfTexture_updateFromPixels(sfTexture* texture, const uint8_t* pixels, sfVector2u size, sfVector2u offset)
 {
     assert(texture);
-    texture->This->update(pixels, convertVector2(size), convertVector2(offset));
+    texture->update(pixels, convertVector2(size), convertVector2(offset));
 }
 
 
@@ -200,8 +199,7 @@ void sfTexture_updateFromTexture(sfTexture* destination, const sfTexture* textur
 {
     assert(destination);
     assert(texture);
-    assert(texture->This);
-    destination->This->update(*texture->This, convertVector2(offset));
+    destination->update(*texture, convertVector2(offset));
 }
 
 
@@ -210,7 +208,7 @@ void sfTexture_updateFromImage(sfTexture* texture, const sfImage* image, sfVecto
 {
     assert(texture);
     assert(image);
-    texture->This->update(*image, convertVector2(offset));
+    texture->update(*image, convertVector2(offset));
 }
 
 
@@ -219,7 +217,7 @@ void sfTexture_updateFromWindow(sfTexture* texture, const sfWindow* window, sfVe
 {
     assert(texture);
     assert(window);
-    texture->This->update(*window, convertVector2(offset));
+    texture->update(*window, convertVector2(offset));
 }
 
 
@@ -228,7 +226,7 @@ void sfTexture_updateFromRenderWindow(sfTexture* texture, const sfRenderWindow*
 {
     assert(texture);
     assert(renderWindow);
-    texture->This->update(*renderWindow, convertVector2(offset));
+    texture->update(*renderWindow, convertVector2(offset));
 }
 
 
@@ -236,7 +234,7 @@ void sfTexture_updateFromRenderWindow(sfTexture* texture, const sfRenderWindow*
 void sfTexture_setSmooth(sfTexture* texture, bool smooth)
 {
     assert(texture);
-    texture->This->setSmooth(smooth);
+    texture->setSmooth(smooth);
 }
 
 
@@ -244,15 +242,14 @@ void sfTexture_setSmooth(sfTexture* texture, bool smooth)
 bool sfTexture_isSmooth(const sfTexture* texture)
 {
     assert(texture);
-    assert(texture->This);
-    return texture->This->isSmooth();
+    return texture->isSmooth();
 }
 
 ////////////////////////////////////////////////////////////
 bool sfTexture_isSrgb(const sfTexture* texture)
 {
     assert(texture);
-    return texture->This->isSrgb();
+    return texture->isSrgb();
 }
 
 
@@ -260,7 +257,7 @@ bool sfTexture_isSrgb(const sfTexture* texture)
 void sfTexture_setRepeated(sfTexture* texture, bool repeated)
 {
     assert(texture);
-    texture->This->setRepeated(repeated);
+    texture->setRepeated(repeated);
 }
 
 
@@ -268,8 +265,7 @@ void sfTexture_setRepeated(sfTexture* texture, bool repeated)
 bool sfTexture_isRepeated(const sfTexture* texture)
 {
     assert(texture);
-    assert(texture->This);
-    return texture->This->isRepeated();
+    return texture->isRepeated();
 }
 
 
@@ -277,7 +273,7 @@ bool sfTexture_isRepeated(const sfTexture* texture)
 bool sfTexture_generateMipmap(sfTexture* texture)
 {
     assert(texture);
-    return texture->This->generateMipmap();
+    return texture->generateMipmap();
 }
 
 
@@ -286,7 +282,7 @@ void sfTexture_swap(sfTexture* left, sfTexture* right)
 {
     assert(left);
     assert(right);
-    left->This->swap(*right->This);
+    left->swap(*right);
 }
 
 
@@ -294,14 +290,14 @@ void sfTexture_swap(sfTexture* left, sfTexture* right)
 unsigned int sfTexture_getNativeHandle(const sfTexture* texture)
 {
     assert(texture);
-    return texture->This->getNativeHandle();
+    return texture->getNativeHandle();
 }
 
 
 ////////////////////////////////////////////////////////////
-void sfTexture_bind(const sfTexture* texture, sfCoordinateType type)
+void sfTexture_bind(const sfTexture* texture, sfTextureCoordinateType type)
 {
-    sf::Texture::bind(texture ? texture->This : nullptr, static_cast<sf::CoordinateType>(type));
+    sf::Texture::bind(texture, static_cast<sf::CoordinateType>(type));
 }
 
 

src/CSFML/Graphics/TextureStruct.hpp

@@ -33,24 +33,6 @@
 ////////////////////////////////////////////////////////////
 // Internal structure of sfTexture
 ////////////////////////////////////////////////////////////
-struct sfTexture
+struct sfTexture : sf::Texture
 {
-    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,13 +48,8 @@ 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)
 {
-    // clang-format off
-    return {
-        a00, a01, a02,
-        a10, a11, a12,
-        a20, a21, a22,
-    };
-    // clang-format on
+    sfTransform transform = {a00, a01, a02, a10, a11, a12, a20, a21, a22};
+    return transform;
 }
 
 

src/CSFML/Graphics/Transformable.cpp

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

src/CSFML/Graphics/VertexBuffer.cpp

@@ -30,7 +30,7 @@
 
 
 ////////////////////////////////////////////////////////////
-sfVertexBuffer* sfVertexBuffer_create(size_t vertexCount, sfPrimitiveType type, sfVertexBufferUsage usage)
+sfVertexBuffer* sfVertexBuffer_create(unsigned int vertexCount, sfPrimitiveType type, sfVertexBufferUsage usage)
 {
     auto buffer = std::make_unique<sfVertexBuffer>();
     if (!buffer->create(vertexCount))

src/CSFML/Network/Ftp.cpp

@@ -51,8 +51,6 @@ 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,13 +37,21 @@ namespace
 // Helper function for converting a SFML address to a CSFML one
 [[nodiscard]] sfIpAddress fromSFMLAddress(std::optional<sf::IpAddress> address)
 {
-    if (!address)
-        return sfIpAddress_None;
+    sfIpAddress result = {0};
+
+    if (address)
+    {
+        strncpy(result.address, address->toString().c_str(), 15);
+    }
 
-    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
 
 
@@ -89,14 +97,14 @@ sfIpAddress sfIpAddress_fromInteger(uint32_t address)
 void sfIpAddress_toString(sfIpAddress address, char* string)
 {
     if (string)
-        std::strcpy(string, address.address);
+        strcpy(string, address.address);
 }
 
 
 ////////////////////////////////////////////////////////////
 uint32_t sfIpAddress_toInteger(sfIpAddress address)
 {
-    const auto sfmlAddress = sf::IpAddress::resolve(address.address);
+    auto sfmlAddress = toSFMLAddress(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 bool{*packet};
+    return static_cast<bool>(*packet);
 }
 
 

src/CSFML/Network/TcpSocket.cpp

@@ -82,7 +82,7 @@ sfIpAddress sfTcpSocket_getRemoteAddress(const sfTcpSocket* socket)
     sfIpAddress result = sfIpAddress_None;
     if (address)
     {
-        std::strncpy(result.address, address->toString().c_str(), 15);
+        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)
         {
-            std::strncpy(remoteAddress->address, address->toString().c_str(), 15);
+            strncpy(remoteAddress->address, address->toString().c_str(), 15);
         }
     }
 
@@ -187,7 +187,7 @@ sfSocketStatus sfUdpSocket_receivePacket(sfUdpSocket* socket, sfPacket* packet,
 
         if (address)
         {
-            std::strncpy(remoteAddress->address, address->toString().c_str(), 15);
+            strncpy(remoteAddress->address, address->toString().c_str(), 15);
         }
     }
 

src/CSFML/System/Alloc.cpp

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

src/CSFML/System/Time.cpp

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

src/CSFML/Window/CMakeLists.txt

@@ -13,7 +13,6 @@ 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

@@ -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/Window/VideoMode.cpp

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

src/CSFML/Window/Vulkan.cpp

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

@@ -1,29 +0,0 @@
-#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

@@ -37,7 +37,6 @@ add_executable(test-csfml-window
     Window/Keyboard.test.cpp
     Window/Mouse.test.cpp
     Window/Sensor.test.cpp
-    Window/VideoMode.test.cpp
     Window/Window.test.cpp
     Window/WindowBase.test.cpp
 )
@@ -45,16 +44,6 @@ 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/Rect.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
@@ -65,13 +54,6 @@ 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

@@ -1,112 +0,0 @@
-#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")
-    {
-        // sfBlendFactor   colorSrcFactor; ///< Source blending factor for the color channels
-        // sfBlendFactor   colorDstFactor; ///< Destination blending factor for the color channels
-        // sfBlendEquation colorEquation;  ///< Blending equation for the color channels
-        // sfBlendFactor   alphaSrcFactor; ///< Source blending factor for the alpha channel
-        // sfBlendFactor   alphaDstFactor; ///< Destination blending factor for the alpha channel
-        // sfBlendEquation alphaEquation;  ///< Blending equation for the alpha channel
-
-        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

@@ -1,229 +0,0 @@
-#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

@@ -1,11 +0,0 @@
-#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/Rect.test.cpp

@@ -1,56 +0,0 @@
-#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/System/Time.test.cpp

@@ -28,7 +28,4 @@ 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, unsigned{sfJoystickCount - 1}));
+    const auto joystick = GENERATE(range(0u, static_cast<unsigned int>(sfJoystickCount - 1)));
 
     SECTION("sfJoystick_isConnected()")
     {
@@ -56,7 +56,7 @@ TEST_CASE("[Window] sfJoystick")
 
     SECTION("sfJoystick_isButtonPressed()")
     {
-        const auto button = GENERATE(range(0u, unsigned{sfJoystickButtonCount - 1}));
+        const auto button = GENERATE(range(0u, static_cast<unsigned int>(sfJoystickButtonCount - 1)));
         CHECK(!sfJoystick_isButtonPressed(joystick, button));
     }
 

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(sfMouseButtonExtra1 == static_cast<int>(sf::Mouse::Button::Extra1));
-        STATIC_CHECK(sfMouseButtonExtra2 == static_cast<int>(sf::Mouse::Button::Extra2));
+        STATIC_CHECK(sfMouseXButton1 == static_cast<int>(sf::Mouse::Button::Extra1));
+        STATIC_CHECK(sfMouseXButton2 == static_cast<int>(sf::Mouse::Button::Extra2));
         STATIC_CHECK(sfMouseButtonCount == sf::Mouse::ButtonCount);
     }
 

test/Window/VideoMode.test.cpp

@@ -1,38 +0,0 @@
-#include <CSFML/Window/VideoMode.h>
-
-#include <catch2/catch_test_macros.hpp>
-
-TEST_CASE("[Window] sfVideoMode")
-{
-    SECTION("Construction")
-    {
-        const sfVideoMode videoMode{};
-        CHECK(videoMode.size.x == 0);
-        CHECK(videoMode.size.y == 0);
-        CHECK(videoMode.bitsPerPixel == 0);
-    }
-
-    SECTION("sfVideoMode_getDesktopMode()")
-    {
-        const sfVideoMode videoMode = sfVideoMode_getDesktopMode();
-        CHECK(videoMode.size.x != 0);
-        CHECK(videoMode.size.y != 0);
-        CHECK(videoMode.bitsPerPixel != 0);
-    }
-
-    SECTION("sfVideoMode_getFullscreenModes()")
-    {
-        std::size_t        count      = 0;
-        const sfVideoMode* videoModes = sfVideoMode_getFullscreenModes(&count);
-        REQUIRE(count > 0);
-        const sfVideoMode& videoMode = videoModes[0];
-        CHECK(videoMode.size.x != 0);
-        CHECK(videoMode.size.y != 0);
-        CHECK(videoMode.bitsPerPixel != 0);
-    }
-
-    SECTION("sfVideoMode_isValid")
-    {
-        CHECK(!sfVideoMode_isValid({}));
-    }
-}

tools/nuget/build.win.ps1

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