Fix API changes in SFML 3

.github/workflows/ci.yml

@@ -46,7 +46,7 @@ jobs:
       uses: actions/checkout@v4
       with:
         repository: SFML/SFML
-        ref: c89c32d7baa15927a39a161a4ead867c11d5ea21
+        ref: b583eaf1606e54e5f443b094b3b2a6e3af72a5a4
         path: SFML
 
     - name: Configure SFML CMake

src/SFML/Audio/SoundBuffer.cpp

@@ -34,30 +34,22 @@
 ////////////////////////////////////////////////////////////
 sfSoundBuffer* sfSoundBuffer_createFromFile(const char* filename)
 {
-    sfSoundBuffer* buffer = new sfSoundBuffer;
+    auto soundBuffer = sf::SoundBuffer::loadFromFile(filename);
+    if (!soundBuffer)
+        return nullptr;
 
-    if (!buffer->This.loadFromFile(filename))
+    return new sfSoundBuffer{std::move(*soundBuffer)};
-    {
-        delete buffer;
-        buffer = nullptr;
-    }
-
-    return buffer;
 }
 
 
 ////////////////////////////////////////////////////////////
 sfSoundBuffer* sfSoundBuffer_createFromMemory(const void* data, size_t sizeInBytes)
 {
-    sfSoundBuffer* buffer = new sfSoundBuffer;
+    auto soundBuffer = sf::SoundBuffer::loadFromMemory(data, sizeInBytes);
+    if (!soundBuffer)
+        return nullptr;
 
-    if (!buffer->This.loadFromMemory(data, sizeInBytes))
+    return new sfSoundBuffer{std::move(*soundBuffer)};
-    {
-        delete buffer;
-        buffer = nullptr;
-    }
-
-    return buffer;
 }
 
 
@@ -67,15 +59,12 @@ sfSoundBuffer* sfSoundBuffer_createFromStream(sfInputStream* stream)
 {
     CSFML_CHECK_RETURN(stream, nullptr);
 
-    sfSoundBuffer* buffer = new sfSoundBuffer;
     CallbackStream sfmlStream(stream);
-    if (!buffer->This.loadFromStream(sfmlStream))
+    auto soundBuffer = sf::SoundBuffer::loadFromStream(sfmlStream);
-    {
+    if (!soundBuffer)
-        delete buffer;
+        return nullptr;
-        buffer = nullptr;
-    }
 
-    return buffer;
+    return new sfSoundBuffer{std::move(*soundBuffer)};
 }
 
 
@@ -87,18 +76,15 @@ sfSoundBuffer* sfSoundBuffer_createFromSamples(const int16_t*    samples,
                                                sfSoundChannel*   channelMapData,
                                                size_t            channelMapSize)
 {
-    sfSoundBuffer* buffer = new sfSoundBuffer;
-
     std::vector<sf::SoundChannel> channelMap(channelMapSize);
     for (std::size_t i = 0; i < channelMap.size(); ++i)
         channelMap[i] = static_cast<sf::SoundChannel>(channelMapData[i]);
-    if (!buffer->This.loadFromSamples(samples, sampleCount, channelCount, sampleRate, channelMap))
-    {
-        delete buffer;
-        buffer = nullptr;
-    }
 
-    return buffer;
+    auto soundBuffer = sf::SoundBuffer::loadFromSamples(samples, sampleCount, channelCount, sampleRate, channelMap);
+    if (!soundBuffer)
+        return nullptr;
+
+    return new sfSoundBuffer{std::move(*soundBuffer)};
 }
 
 

src/SFML/Audio/SoundBufferRecorder.cpp

@@ -70,9 +70,9 @@ const sfSoundBuffer* sfSoundBufferRecorder_getBuffer(const sfSoundBufferRecorder
 {
     CSFML_CHECK_RETURN(soundBufferRecorder, nullptr);
 
-    soundBufferRecorder->SoundBuffer.This = soundBufferRecorder->This.getBuffer();
+    soundBufferRecorder->SoundBuffer = sfSoundBuffer{soundBufferRecorder->This.getBuffer()};
 
-    return &soundBufferRecorder->SoundBuffer;
+    return &*soundBufferRecorder->SoundBuffer;
 }
 
 ////////////////////////////////////////////////////////////

src/SFML/Audio/SoundBufferRecorderStruct.h

@@ -31,15 +31,17 @@
 #include <SFML/Audio/SoundBufferRecorder.hpp>
 #include <SFML/Audio/SoundBufferStruct.h>
 
+#include <optional>
+
 
 ////////////////////////////////////////////////////////////
 // Internal structure of sfSoundBufferRecorder
 ////////////////////////////////////////////////////////////
 struct sfSoundBufferRecorder
 {
-    sf::SoundBufferRecorder This;
+    sf::SoundBufferRecorder              This;
-    mutable sfSoundBuffer   SoundBuffer;
+    mutable std::optional<sfSoundBuffer> SoundBuffer;
-    std::string             DeviceName;
+    std::string                          DeviceName;
 };
 
 

src/SFML/Graphics/Font.cpp

@@ -34,28 +34,22 @@
 ////////////////////////////////////////////////////////////
 sfFont* sfFont_createFromFile(const char* filename)
 {
-    sfFont* font = new sfFont;
+    auto font = sf::Font::loadFromFile(filename);
-    if (!font->This.loadFromFile(filename))
+    if (!font)
-    {
+        return nullptr;
-        delete font;
-        font = nullptr;
-    }
 
-    return font;
+    return new sfFont{std::move(*font), {}, {}};
 }
 
 
 ////////////////////////////////////////////////////////////
 sfFont* sfFont_createFromMemory(const void* data, size_t sizeInBytes)
 {
-    sfFont* font = new sfFont;
+    auto font = sf::Font::loadFromMemory(data, sizeInBytes);
-    if (!font->This.loadFromMemory(data, sizeInBytes))
+    if (!font)
-    {
+        return nullptr;
-        delete font;
-        font = nullptr;
-    }
 
-    return font;
+    return new sfFont{std::move(*font), {}, {}};
 }
 
 
@@ -64,15 +58,12 @@ sfFont* sfFont_createFromStream(sfInputStream* stream)
 {
     CSFML_CHECK_RETURN(stream, nullptr);
 
-    sfFont* font = new sfFont;
+    auto sfmlStream = std::make_shared<CallbackStream>(stream);
-    font->Stream = CallbackStream(stream);
+    auto font = sf::Font::loadFromStream(*sfmlStream);
-    if (!font->This.loadFromStream(font->Stream))
+    if (!font)
-    {
+        return nullptr;
-        delete font;
-        font = nullptr;
-    }
 
-    return font;
+    return new sfFont{std::move(*font), {}, std::move(sfmlStream)};
 }
 
 

src/SFML/Graphics/FontStruct.h

@@ -32,6 +32,7 @@
 #include <SFML/Graphics/TextureStruct.h>
 #include <SFML/CallbackStream.h>
 #include <map>
+#include <memory>
 
 
 ////////////////////////////////////////////////////////////
@@ -41,7 +42,7 @@ struct sfFont
 {
     sf::Font This;
     std::map<unsigned int, sfTexture> Textures;
-    CallbackStream Stream;
+    std::shared_ptr<CallbackStream> Stream;
 };
 
 

src/SFML/Graphics/Image.cpp

@@ -35,60 +35,43 @@
 ////////////////////////////////////////////////////////////
 sfImage* sfImage_create(unsigned int width, unsigned int height)
 {
-    sfImage* image = new sfImage;
+    return new sfImage{sf::Image({width, height})};
-    image->This.create({ width, height });
-
-    return image;
 }
 
 
 ////////////////////////////////////////////////////////////
 sfImage* sfImage_createFromColor(unsigned int width, unsigned int height, sfColor color)
 {
-    sfImage* image = new sfImage;
+    return new sfImage{sf::Image({ width, height }, sf::Color(color.r, color.g, color.b, color.a))};
-    image->This.create({ width, height }, sf::Color(color.r, color.g, color.b, color.a));
-
-    return image;
 }
 
 
 ////////////////////////////////////////////////////////////
 sfImage* sfImage_createFromPixels(unsigned int width, unsigned int height, const uint8_t* data)
 {
-    sfImage* image = new sfImage;
+    return new sfImage{sf::Image({ width, height }, data)};
-    image->This.create({ width, height }, data);
-
-    return image;
 }
 
 
 ////////////////////////////////////////////////////////////
 sfImage* sfImage_createFromFile(const char* filename)
 {
-    sfImage* image = new sfImage;
+    auto image = sf::Image::loadFromFile(filename);
+    if (!image)
+        return nullptr;
 
-    if (!image->This.loadFromFile(filename))
+    return new sfImage{std::move(*image)};
-    {
-        delete image;
-        image = nullptr;
-    }
-
-    return image;
 }
 
 
 ////////////////////////////////////////////////////////////
 sfImage* sfImage_createFromMemory(const void* data, size_t sizeInBytes)
 {
-    sfImage* image = new sfImage;
+    auto image = sf::Image::loadFromMemory(data, sizeInBytes);
+    if (!image)
+        return nullptr;
 
-    if (!image->This.loadFromMemory(data, sizeInBytes))
+    return new sfImage{std::move(*image)};
-    {
-        delete image;
-        image = nullptr;
-    }
-
-    return image;
 }
 
 
@@ -97,16 +80,12 @@ sfImage* sfImage_createFromStream(sfInputStream* stream)
 {
     CSFML_CHECK_RETURN(stream, nullptr);
 
-    sfImage* image = new sfImage;
-
     CallbackStream sfmlStream(stream);
-    if (!image->This.loadFromStream(sfmlStream))
+    auto image = sf::Image::loadFromStream(sfmlStream);
-    {
+    if (!image)
-        delete image;
+        return nullptr;
-        image = nullptr;
-    }
 
-    return image;
+    return new sfImage{std::move(*image)};
 }
 
 

src/SFML/Graphics/RenderTexture.cpp

@@ -51,19 +51,14 @@ sfRenderTexture* sfRenderTexture_create(unsigned int width, unsigned int height,
     }
 
     // Create the render texture
-    sfRenderTexture* renderTexture = new sfRenderTexture;
+    auto renderTexture = sf::RenderTexture::create({ width, height }, params);
-
+    if (!renderTexture)
-    if (!renderTexture->This.create({ width, height }, params))
-    {
-        delete renderTexture;
         return nullptr;
-    }
 
-    renderTexture->Target = new sfTexture(const_cast<sf::Texture*>(&renderTexture->This.getTexture()));
+    return new sfRenderTexture{std::move(*renderTexture),
-    renderTexture->DefaultView.This = renderTexture->This.getDefaultView();
+                               new sfTexture(const_cast<sf::Texture*>(&renderTexture->getTexture())),
-    renderTexture->CurrentView.This = renderTexture->This.getView();
+                               {renderTexture->getDefaultView()},
-
+                               {renderTexture->getView()}};
-    return renderTexture;
 }
 
 

src/SFML/Graphics/Shader.cpp

@@ -36,8 +36,7 @@
 ////////////////////////////////////////////////////////////
 sfShader* sfShader_createFromFile(const char* vertexShaderFilename, const char* geometryShaderFilename, const char* fragmentShaderFilename)
 {
-    bool success = false;
+    std::optional<sf::Shader> shader;
-    sfShader* shader = new sfShader;
     if (vertexShaderFilename || geometryShaderFilename || fragmentShaderFilename)
     {
         if (!geometryShaderFilename)
@@ -45,17 +44,17 @@ sfShader* sfShader_createFromFile(const char* vertexShaderFilename, const char*
             if (!vertexShaderFilename)
             {
                 // fragment shader only
-                success = shader->This.loadFromFile(fragmentShaderFilename, sf::Shader::Type::Fragment);
+                shader = sf::Shader::loadFromFile(fragmentShaderFilename, sf::Shader::Type::Fragment);
             }
             else if (!fragmentShaderFilename)
             {
                 // vertex shader only
-                success = shader->This.loadFromFile(vertexShaderFilename, sf::Shader::Type::Vertex);
+                shader = sf::Shader::loadFromFile(vertexShaderFilename, sf::Shader::Type::Vertex);
             }
             else
             {
                 // vertex + fragment shaders
-                success = shader->This.loadFromFile(vertexShaderFilename, fragmentShaderFilename);
+                shader = sf::Shader::loadFromFile(vertexShaderFilename, fragmentShaderFilename);
             }
         }
         else
@@ -63,31 +62,27 @@ sfShader* sfShader_createFromFile(const char* vertexShaderFilename, const char*
             if (!vertexShaderFilename && !fragmentShaderFilename)
             {
                 // geometry shader only
-                success = shader->This.loadFromFile(geometryShaderFilename, sf::Shader::Type::Geometry);
+                shader = sf::Shader::loadFromFile(geometryShaderFilename, sf::Shader::Type::Geometry);
             }
             else
             {
                 // vertex + geometry + fragment shaders
-                success = shader->This.loadFromFile(vertexShaderFilename, geometryShaderFilename, fragmentShaderFilename);
+                shader = sf::Shader::loadFromFile(vertexShaderFilename, geometryShaderFilename, fragmentShaderFilename);
             }
         }
     }
 
-    if (!success)
+    if (!shader)
-    {
+        return nullptr;
-        delete shader;
-        shader = nullptr;
-    }
 
-    return shader;
+    return new sfShader{std::move(*shader)};
 }
 
 
 ////////////////////////////////////////////////////////////
 sfShader* sfShader_createFromMemory(const char* vertexShader, const char* geometryShader, const char* fragmentShader)
 {
-    bool success = false;
+    std::optional<sf::Shader> shader;
-    sfShader* shader = new sfShader;
     if (vertexShader || geometryShader || fragmentShader)
     {
         if (!geometryShader)
@@ -95,17 +90,17 @@ sfShader* sfShader_createFromMemory(const char* vertexShader, const char* geomet
             if (!vertexShader)
             {
                 // fragment shader only
-                success = shader->This.loadFromMemory(fragmentShader, sf::Shader::Type::Fragment);
+                shader = sf::Shader::loadFromMemory(fragmentShader, sf::Shader::Type::Fragment);
             }
             else if (!fragmentShader)
             {
                 // vertex shader only
-                success = shader->This.loadFromMemory(vertexShader, sf::Shader::Type::Vertex);
+                shader = sf::Shader::loadFromMemory(vertexShader, sf::Shader::Type::Vertex);
             }
             else
             {
                 // vertex + fragment shaders
-                success = shader->This.loadFromMemory(vertexShader, fragmentShader);
+                shader = sf::Shader::loadFromMemory(vertexShader, fragmentShader);
             }
         }
         else
@@ -113,31 +108,27 @@ sfShader* sfShader_createFromMemory(const char* vertexShader, const char* geomet
             if (!vertexShader && !fragmentShader)
             {
                 // geometry shader only
-                success = shader->This.loadFromMemory(geometryShader, sf::Shader::Type::Geometry);
+                shader = sf::Shader::loadFromMemory(geometryShader, sf::Shader::Type::Geometry);
             }
             else
             {
                 // vertex + geometry + fragment shaders
-                success = shader->This.loadFromMemory(vertexShader, geometryShader, fragmentShader);
+                shader = sf::Shader::loadFromMemory(vertexShader, geometryShader, fragmentShader);
             }
         }
     }
 
-    if (!success)
+    if (!shader)
-    {
+        return nullptr;
-        delete shader;
-        shader = nullptr;
-    }
 
-    return shader;
+    return new sfShader{std::move(*shader)};
 }
 
 
 ////////////////////////////////////////////////////////////
 sfShader* sfShader_createFromStream(sfInputStream* vertexShaderStream, sfInputStream* geometryShaderStream, sfInputStream* fragmentShaderStream)
 {
-    bool success = false;
+    std::optional<sf::Shader> shader;
-    sfShader* shader = new sfShader;
     if (vertexShaderStream || geometryShaderStream || fragmentShaderStream)
     {
         if (!geometryShaderStream)
@@ -146,20 +137,20 @@ sfShader* sfShader_createFromStream(sfInputStream* vertexShaderStream, sfInputSt
             {
                 // fragment shader only
                 CallbackStream stream(fragmentShaderStream);
-                success = shader->This.loadFromStream(stream, sf::Shader::Type::Fragment);
+                shader = sf::Shader::loadFromStream(stream, sf::Shader::Type::Fragment);
             }
             else if (!fragmentShaderStream)
             {
                 // vertex shader only
                 CallbackStream stream(vertexShaderStream);
-                success = shader->This.loadFromStream(stream, sf::Shader::Type::Vertex);
+                shader = sf::Shader::loadFromStream(stream, sf::Shader::Type::Vertex);
             }
             else
             {
                 // vertex + fragment shaders
                 CallbackStream vertexStream(vertexShaderStream);
                 CallbackStream fragmentStream(fragmentShaderStream);
-                success = shader->This.loadFromStream(vertexStream, fragmentStream);
+                shader = sf::Shader::loadFromStream(vertexStream, fragmentStream);
             }
         }
         else
@@ -168,25 +159,22 @@ sfShader* sfShader_createFromStream(sfInputStream* vertexShaderStream, sfInputSt
             if (!vertexShaderStream && !fragmentShaderStream)
             {
                 // geometry shader only
-                success = shader->This.loadFromStream(geometryStream, sf::Shader::Type::Geometry);
+                shader = sf::Shader::loadFromStream(geometryStream, sf::Shader::Type::Geometry);
             }
             else
             {
                 // vertex + geometry + fragment shaders
                 CallbackStream vertexStream(vertexShaderStream);
                 CallbackStream fragmentStream(fragmentShaderStream);
-                success = shader->This.loadFromStream(vertexStream, geometryStream, fragmentStream);
+                shader = sf::Shader::loadFromStream(vertexStream, geometryStream, fragmentStream);
             }
         }
     }
 
-    if (!success)
+    if (!shader)
-    {
+        return nullptr;
-        delete shader;
-        shader = nullptr;
-    }
 
-    return shader;
+    return new sfShader{std::move(*shader)};
 }
 
 

src/SFML/Graphics/Texture.cpp

@@ -250,10 +250,7 @@ sfImage* sfTexture_copyToImage(const sfTexture* texture)
     CSFML_CHECK_RETURN(texture, nullptr);
     CSFML_CHECK_RETURN(texture->This, nullptr);
 
-    sfImage* image = new sfImage;
+    return new sfImage{texture->This->copyToImage()};
-    image->This = texture->This->copyToImage();
-
-    return image;
 }
 
 

src/SFML/Window/Cursor.cpp

@@ -33,30 +33,22 @@
 ////////////////////////////////////////////////////////////
 sfCursor* sfCursor_createFromPixels(const uint8_t* pixels, sfVector2u size, sfVector2u hotspot)
 {
-    sfCursor* cursor = new sfCursor;
+    auto cursor = sf::Cursor::loadFromPixels(pixels, sf::Vector2u(size.x, size.y), sf::Vector2u(hotspot.x, hotspot.y));
+    if (!cursor)
+        return nullptr;
 
-    if (!cursor->This.loadFromPixels(pixels, sf::Vector2u(size.x, size.y), sf::Vector2u(hotspot.x, hotspot.y)))
+    return new sfCursor{std::move(*cursor)};
-    {
-        delete cursor;
-        cursor = nullptr;
-    }
-
-    return cursor;
 }
 
 
 ////////////////////////////////////////////////////////////
 sfCursor* sfCursor_createFromSystem(sfCursorType type)
 {
-    sfCursor* cursor = new sfCursor;
+    auto cursor = sf::Cursor::loadFromSystem(static_cast<sf::Cursor::Type>(type));
+    if (!cursor)
+        return nullptr;
 
-    if (!cursor->This.loadFromSystem(static_cast<sf::Cursor::Type>(type)))
+    return new sfCursor{std::move(*cursor)};
-    {
-        delete cursor;
-        cursor = nullptr;
-    }
-
-    return cursor;
 }