Reimplement sfTexture

.github/FUNDING.yml

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

.github/workflows/ci.yml

@@ -74,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

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)
+if(NOT CMAKE_MATCH_1 EQUAL 14)
-    message(FATAL_ERROR "clang-format version ${CMAKE_MATCH_1} not supported. Must use version 17")
+    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
+    sfBlendMode      blendMode; ///< Blending mode
-    sfStencilMode    stencilMode;    //!< Stencil mode
+    sfTransform      transform; ///< Transform
-    sfTransform      transform;      ///< Transform
+    const sfTexture* texture;   ///< Texture
-    sfCoordinateType coordinateType; //!< Texture coordinate type
+    const sfShader*  shader;    ///< Shader
-    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
+    sfMouseLeft,     ///< The left mouse button
-    sfMouseRight,        ///< The right mouse button
+    sfMouseRight,    ///< The right mouse button
-    sfMouseMiddle,       ///< The middle (wheel) mouse button
+    sfMouseMiddle,   ///< The middle (wheel) mouse button
-    sfMouseButtonExtra1, ///< The first extra mouse button
+    sfMouseXButton1, ///< The first extra mouse button
-    sfMouseButtonExtra2, ///< The second extra mouse button
+    sfMouseXButton2, ///< The second extra mouse button
-} sfMouseButton;
 
-enum
+    sfMouseButtonCount ///< Keep last -- the total number of mouse buttons
-{
+} sfMouseButton;
-    sfMouseButtonCount = sfMouseButtonExtra2 + 1 ///< The total number of mouse buttons
-};
 
 ////////////////////////////////////////////////////////////
 /// \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

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 {
+    auto red   = static_cast<uint8_t>((color & 0xff000000) >> 24);
-        static_cast<uint8_t>((color & 0xff000000) >> 24),
+    auto green = static_cast<uint8_t>((color & 0x00ff0000) >> 16);
-        static_cast<uint8_t>((color & 0x00ff0000) >> 16),
+    auto blue  = static_cast<uint8_t>((color & 0x0000ff00) >> 8);
-        static_cast<uint8_t>((color & 0x0000ff00) >> 8),
+    auto alpha = static_cast<uint8_t>((color & 0x000000ff) >> 0);
-        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 {
+    int red   = std::min(color1.r + color2.r, 255);
-        static_cast<uint8_t>(std::min(color1.r + color2.r, 255)),
+    int green = std::min(color1.g + color2.g, 255);
-        static_cast<uint8_t>(std::min(color1.g + color2.g, 255)),
+    int blue  = std::min(color1.b + color2.b, 255);
-        static_cast<uint8_t>(std::min(color1.b + color2.b, 255)),
+    int alpha = std::min(color1.a + color2.a, 255);
-        static_cast<uint8_t>(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 {
+    int red   = std::max(color1.r - color2.r, 0);
-        static_cast<uint8_t>(std::max(color1.r - color2.r, 0)),
+    int green = std::max(color1.g - color2.g, 0);
-        static_cast<uint8_t>(std::max(color1.g - color2.g, 0)),
+    int blue  = std::max(color1.b - color2.b, 0);
-        static_cast<uint8_t>(std::max(color1.b - color2.b, 0)),
+    int alpha = std::max(color1.a - color2.a, 0);
-        static_cast<uint8_t>(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 {
+    int red   = color1.r * color2.r / 255;
-        static_cast<uint8_t>(color1.r * color2.r / 255),
+    int green = color1.g * color2.g / 255;
-        static_cast<uint8_t>(color1.g * color2.g / 255),
+    int blue  = color1.b * color2.b / 255;
-        static_cast<uint8_t>(color1.b * color2.b / 255),
+    int alpha = color1.a * color2.a / 255;
-        static_cast<uint8_t>(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.transform                = convertTransform(states->transform);
-    renderStates.stencilMode.stencilUpdateOperation = static_cast<sf::StencilUpdateOperation>(
+    renderStates.texture                  = states->texture;
-        states->stencilMode.stencilUpdateOperation);
+    renderStates.shader                   = states->shader;
-    renderStates.stencilMode.stencilReference.value = states->stencilMode.stencilReference.value;
-    renderStates.stencilMode.stencilMask.value      = states->stencilMode.stencilMask.value;
-    renderStates.stencilMode.stencilOnly            = states->stencilMode.stencilOnly;
-    renderStates.transform                          = convertTransform(states->transform);
-    renderStates.coordinateType                     = static_cast<sf::CoordinateType>(states->coordinateType);
-    renderStates.texture                            = states->texture ? states->texture->This : nullptr;
-    renderStates.shader                             = states->shader;
     return renderStates;
 }

src/CSFML/Graphics/ConvexShape.cpp

@@ -167,7 +167,7 @@ sfTransform sfConvexShape_getInverseTransform(const sfConvexShape* shape)
 void sfConvexShape_setTexture(sfConvexShape* shape, const sfTexture* texture, bool resetRect)
 {
     assert(shape);
-    shape->setTexture(texture ? 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;
+    sfTexture Target;
-    sfView                           DefaultView;
+    sfView    DefaultView;
-    sfView                           CurrentView;
+    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 (vertexShaderFilename || geometryShaderFilename || fragmentShaderFilename)
-    if (!geometryShaderFilename)
     {
-        if (!vertexShaderFilename) // fragment shader only
+        if (!geometryShaderFilename)
-            success = shader->loadFromFile(fragmentShaderFilename, sf::Shader::Type::Fragment);
+        {
-        else if (!fragmentShaderFilename) // vertex shader only
+            if (!vertexShaderFilename)
-            success = shader->loadFromFile(vertexShaderFilename, sf::Shader::Type::Vertex);
+            {
-        else // vertex + fragment shaders
+                // fragment shader only
-            success = shader->loadFromFile(vertexShaderFilename, fragmentShaderFilename);
+                success = shader->loadFromFile(fragmentShaderFilename, sf::Shader::Type::Fragment);
-    }
+            }
-    else
+            else if (!fragmentShaderFilename)
-    {
+            {
-        if (!vertexShaderFilename && !fragmentShaderFilename) // geometry shader only
+                // vertex shader only
-            success = shader->loadFromFile(geometryShaderFilename, sf::Shader::Type::Geometry);
+                success = shader->loadFromFile(vertexShaderFilename, sf::Shader::Type::Vertex);
-        else // vertex + geometry + fragment shaders
+            }
-            success = shader->loadFromFile(vertexShaderFilename, geometryShaderFilename, fragmentShaderFilename);
+            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 (vertexShader || geometryShader || fragmentShader)
-    if (!geometryShader)
     {
-        if (!vertexShader) // fragment shader only
+        if (!geometryShader)
-            success = shader->loadFromMemory(fragmentShader, sf::Shader::Type::Fragment);
+        {
-        else if (!fragmentShader) // vertex shader only
+            if (!vertexShader)
-            success = shader->loadFromMemory(vertexShader, sf::Shader::Type::Vertex);
+            {
-        else // vertex + fragment shaders
+                // fragment shader only
-            success = shader->loadFromMemory(vertexShader, fragmentShader);
+                success = shader->loadFromMemory(fragmentShader, sf::Shader::Type::Fragment);
-    }
+            }
-    else
+            else if (!fragmentShader)
-    {
+            {
-        if (!vertexShader && !fragmentShader) // geometry shader only
+                // vertex shader only
-            success = shader->loadFromMemory(geometryShader, sf::Shader::Type::Geometry);
+                success = shader->loadFromMemory(vertexShader, sf::Shader::Type::Vertex);
-        else // vertex + geometry + fragment shaders
+            }
-            success = shader->loadFromMemory(vertexShader, geometryShader, fragmentShader);
+            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 (vertexShaderStream || geometryShaderStream || fragmentShaderStream)
-    if (!geometryShaderStream)
     {
-        if (!vertexShaderStream) // fragment shader only
+        if (!geometryShaderStream)
         {
-            CallbackStream stream(fragmentShaderStream);
+            if (!vertexShaderStream)
-            success = shader->loadFromStream(stream, sf::Shader::Type::Fragment);
+            {
+                // 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);
+            CallbackStream geometryStream(geometryShaderStream);
-            success = shader->loadFromStream(stream, sf::Shader::Type::Vertex);
+            if (!vertexShaderStream && !fragmentShaderStream)
-        }
+            {
-        else // vertex + fragment shaders
+                // geometry shader only
-        {
+                success = shader->loadFromStream(geometryStream, sf::Shader::Type::Geometry);
-            CallbackStream vertexStream(vertexShaderStream);
+            }
-            CallbackStream fragmentStream(fragmentShaderStream);
+            else
-            success = shader->loadFromStream(vertexStream, fragmentStream);
+            {
-        }
+                // vertex + geometry + fragment shaders
-    }
+                CallbackStream vertexStream(vertexShaderStream);
-    else
+                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,
+    sfGlslVec4 vec4;
-                            name,
+    vec4.x = color.r / 255.f;
-                            {
+    vec4.y = color.g / 255.f;
-                                color.r / 255.f,
+    vec4.z = color.b / 255.f;
-                                color.g / 255.f,
+    vec4.w = color.a / 255.f;
-                                color.b / 255.f,
+
-                                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,
+    sfGlslIvec4 ivec4;
-                             name,
+    ivec4.x = static_cast<int>(color.r);
-                             {
+    ivec4.y = static_cast<int>(color.g);
-                                 color.r,
+    ivec4.z = static_cast<int>(color.b);
-                                 color.g,
+    ivec4.w = static_cast<int>(color.a);
-                                 color.b,
+
-                                 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);
-    auto sprite     = new sfSprite(*texture->This);
     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->copyToImage()};
-    return new sfImage{texture->This->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->update(*texture, convertVector2(offset));
-    destination->This->update(*texture->This, 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->isSmooth();
-    return texture->This->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->isRepeated();
-    return texture->This->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
+    sfTransform transform = {a00, a01, a02, a10, a11, a12, a20, a21, a22};
-    return {
+    return transform;
-        a00, a01, a02,
-        a10, a11, a12,
-        a20, a21, a22,
-    };
-    // clang-format on
 }
 
 

src/CSFML/Graphics/Transformable.cpp

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

src/CSFML/Graphics/VertexArray.cpp

@@ -30,9 +30,6 @@
 #include <CSFML/Graphics/VertexArrayStruct.hpp>
 
 
-static_assert(sizeof(sf::Vertex) == sizeof(sfVertex));
-static_assert(alignof(sf::Vertex) == alignof(sfVertex));
-
 ////////////////////////////////////////////////////////////
 sfVertexArray* sfVertexArray_create()
 {

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)
+    sfIpAddress result = {0};
-        return sfIpAddress_None;
+
+    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);
 }
 
 
@@ -173,14 +173,14 @@ double sfPacket_readDouble(sfPacket* packet)
 void sfPacket_readString(sfPacket* packet, char* string)
 {
     assert(packet);
-    assert(string);
+    if (string)
-    *packet >> string;
+        *packet >> string;
 }
 void sfPacket_readWideString(sfPacket* packet, wchar_t* string)
 {
     assert(packet);
-    assert(string);
+    if (string)
-    *packet >> string;
+        *packet >> string;
 }
 
 
@@ -232,12 +232,12 @@ void sfPacket_writeDouble(sfPacket* packet, double value)
 void sfPacket_writeString(sfPacket* packet, const char* string)
 {
     assert(packet);
-    assert(string);
+    if (string)
-    *packet << string;
+        *packet << string;
 }
 void sfPacket_writeWideString(sfPacket* packet, const wchar_t* string)
 {
     assert(packet);
-    assert(string);
+    if (string)
-    *packet << string;
+        *packet << string;
 }

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));
+            modes.push_back(convertVideoMode(mode));
-        return videomodes;
+    }
-    }();
 
     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/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(sfMouseXButton1 == static_cast<int>(sf::Mouse::Button::Extra1));
-        STATIC_CHECK(sfMouseButtonExtra2 == static_cast<int>(sf::Mouse::Button::Extra2));
+        STATIC_CHECK(sfMouseXButton2 == static_cast<int>(sf::Mouse::Button::Extra2));
         STATIC_CHECK(sfMouseButtonCount == sf::Mouse::ButtonCount);
     }
 

tools/nuget/build.win.ps1

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