Use assert to protect against dereferencing null pointers

src/CSFML/Audio/Music.cpp

@@ -27,7 +27,6 @@
 ////////////////////////////////////////////////////////////
 #include <CSFML/Audio/Music.h>
 #include <CSFML/Audio/MusicStruct.hpp>
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/ConvertVector3.hpp>
 
 
@@ -62,7 +61,7 @@ sfMusic* sfMusic_createFromMemory(const void* data, size_t sizeInBytes)
 ////////////////////////////////////////////////////////////
 sfMusic* sfMusic_createFromStream(sfInputStream* stream)
 {
-    CSFML_CHECK_RETURN(stream, nullptr);
+    assert(stream);
 
     sfMusic* music = new sfMusic;
     music->Stream  = CallbackStream(stream);
@@ -86,92 +85,89 @@ void sfMusic_destroy(sfMusic* music)
 ////////////////////////////////////////////////////////////
 void sfMusic_setLooping(sfMusic* music, bool loop)
 {
-    CSFML_CALL(music, setLooping(loop != 0));
+    assert(music);
+    music->This.setLooping(loop != 0);
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfMusic_isLooping(const sfMusic* music)
 {
-    CSFML_CALL_RETURN(music, isLooping(), false);
+    assert(music);
+    return music->This.isLooping();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfTime sfMusic_getDuration(const sfMusic* music)
 {
-    sfTime time = {0};
-    CSFML_CHECK_RETURN(music, time);
-
-    time.microseconds = music->This.getDuration().asMicroseconds();
-    return time;
+    assert(music);
+    return {music->This.getDuration().asMicroseconds()};
 }
 
 
 ////////////////////////////////////////////////////////////
 sfTimeSpan sfMusic_getLoopPoints(const sfMusic* music)
 {
-    sfTimeSpan timeSpan = {{0}, {0}};
-    CSFML_CHECK_RETURN(music, timeSpan);
-
-    sf::Music::TimeSpan span = music->This.getLoopPoints();
-
-    timeSpan.offset.microseconds = span.offset.asMicroseconds();
-    timeSpan.length.microseconds = span.length.asMicroseconds();
-
-    return timeSpan;
+    assert(music);
+    const auto [offset, length] = music->This.getLoopPoints();
+    return {{offset.asMicroseconds()}, {length.asMicroseconds()}};
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfMusic_setLoopPoints(sfMusic* music, sfTimeSpan timePoints)
 {
-    CSFML_CALL(music,
-               setLoopPoints(sf::Music::TimeSpan(
-                   {sf::microseconds(timePoints.offset.microseconds), sf::microseconds(timePoints.length.microseconds)})));
+    assert(music);
+    music->This.setLoopPoints(
+        {sf::microseconds(timePoints.offset.microseconds), sf::microseconds(timePoints.length.microseconds)});
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfMusic_play(sfMusic* music)
 {
-    CSFML_CALL(music, play());
+    assert(music);
+    music->This.play();
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfMusic_pause(sfMusic* music)
 {
-    CSFML_CALL(music, pause());
+    assert(music);
+    music->This.pause();
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfMusic_stop(sfMusic* music)
 {
-    CSFML_CALL(music, stop());
+    assert(music);
+    music->This.stop();
 }
 
 
 ////////////////////////////////////////////////////////////
 unsigned int sfMusic_getChannelCount(const sfMusic* music)
 {
-    CSFML_CALL_RETURN(music, getChannelCount(), 0);
+    assert(music);
+    return music->This.getChannelCount();
 }
 
 
 ////////////////////////////////////////////////////////////
 unsigned int sfMusic_getSampleRate(const sfMusic* music)
 {
-    CSFML_CALL_RETURN(music, getSampleRate(), 0);
+    assert(music);
+    return music->This.getSampleRate();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfSoundStatus sfMusic_getStatus(const sfMusic* music)
 {
-    CSFML_CHECK_RETURN(music, sfStopped);
-
+    assert(music);
     return static_cast<sfSoundStatus>(music->This.getStatus());
 }
 
@@ -179,82 +175,87 @@ sfSoundStatus sfMusic_getStatus(const sfMusic* music)
 ////////////////////////////////////////////////////////////
 sfTime sfMusic_getPlayingOffset(const sfMusic* music)
 {
-    sfTime time = {0};
-    CSFML_CHECK_RETURN(music, time);
-
-    time.microseconds = music->This.getPlayingOffset().asMicroseconds();
-    return time;
+    assert(music);
+    return {music->This.getPlayingOffset().asMicroseconds()};
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfMusic_setPitch(sfMusic* music, float pitch)
 {
-    CSFML_CALL(music, setPitch(pitch));
+    assert(music);
+    music->This.setPitch(pitch);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfMusic_setVolume(sfMusic* music, float volume)
 {
-    CSFML_CALL(music, setVolume(volume));
+    assert(music);
+    music->This.setVolume(volume);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfMusic_setPosition(sfMusic* music, sfVector3f position)
 {
-    CSFML_CALL(music, setPosition(convertVector3(position)));
+    assert(music);
+    music->This.setPosition(convertVector3(position));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfMusic_setRelativeToListener(sfMusic* music, bool relative)
 {
-    CSFML_CALL(music, setRelativeToListener(relative));
+    assert(music);
+    music->This.setRelativeToListener(relative);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfMusic_setMinDistance(sfMusic* music, float distance)
 {
-    CSFML_CALL(music, setMinDistance(distance));
+    assert(music);
+    music->This.setMinDistance(distance);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfMusic_setAttenuation(sfMusic* music, float attenuation)
 {
-    CSFML_CALL(music, setAttenuation(attenuation));
+    assert(music);
+    music->This.setAttenuation(attenuation);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfMusic_setPlayingOffset(sfMusic* music, sfTime timeOffset)
 {
-    CSFML_CALL(music, setPlayingOffset(sf::microseconds(timeOffset.microseconds)));
+    assert(music);
+    music->This.setPlayingOffset(sf::microseconds(timeOffset.microseconds));
 }
 
 
 ////////////////////////////////////////////////////////////
 float sfMusic_getPitch(const sfMusic* music)
 {
-    CSFML_CALL_RETURN(music, getPitch(), 0.f);
+    assert(music);
+    return music->This.getPitch();
 }
 
 
 ////////////////////////////////////////////////////////////
 float sfMusic_getVolume(const sfMusic* music)
 {
-    CSFML_CALL_RETURN(music, getVolume(), 0.f);
+    assert(music);
+    return music->This.getVolume();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector3f sfMusic_getPosition(const sfMusic* music)
 {
-    CSFML_CHECK_RETURN(music, {});
-
+    assert(music);
     return convertVector3(music->This.getPosition());
 }
 
@@ -262,19 +263,22 @@ sfVector3f sfMusic_getPosition(const sfMusic* music)
 ////////////////////////////////////////////////////////////
 bool sfMusic_isRelativeToListener(const sfMusic* music)
 {
-    CSFML_CALL_RETURN(music, isRelativeToListener(), false);
+    assert(music);
+    return music->This.isRelativeToListener();
 }
 
 
 ////////////////////////////////////////////////////////////
 float sfMusic_getMinDistance(const sfMusic* music)
 {
-    CSFML_CALL_RETURN(music, getMinDistance(), 0.f);
+    assert(music);
+    return music->This.getMinDistance();
 }
 
 
 ////////////////////////////////////////////////////////////
 float sfMusic_getAttenuation(const sfMusic* music)
 {
-    CSFML_CALL_RETURN(music, getAttenuation(), 0.f);
+    assert(music);
+    return music->This.getAttenuation();
 }

src/CSFML/Audio/Sound.cpp

@@ -27,15 +27,13 @@
 ////////////////////////////////////////////////////////////
 #include <CSFML/Audio/Sound.h>
 #include <CSFML/Audio/SoundStruct.hpp>
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/ConvertVector3.hpp>
 
 
 ////////////////////////////////////////////////////////////
 sfSound* sfSound_create(const sfSoundBuffer* buffer)
 {
-    CSFML_CHECK_RETURN(buffer, nullptr);
-
+    assert(buffer);
     return new sfSound{sf::Sound{buffer->This}, buffer};
 }
 
@@ -43,8 +41,7 @@ sfSound* sfSound_create(const sfSoundBuffer* buffer)
 ////////////////////////////////////////////////////////////
 sfSound* sfSound_copy(const sfSound* sound)
 {
-    CSFML_CHECK_RETURN(sound, nullptr);
-
+    assert(sound);
     return new sfSound(*sound);
 }
 
@@ -59,21 +56,24 @@ void sfSound_destroy(sfSound* sound)
 ////////////////////////////////////////////////////////////
 void sfSound_play(sfSound* sound)
 {
-    CSFML_CALL(sound, play());
+    assert(sound);
+    sound->This.play();
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSound_pause(sfSound* sound)
 {
-    CSFML_CALL(sound, pause());
+    assert(sound);
+    sound->This.pause();
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSound_stop(sfSound* sound)
 {
-    CSFML_CALL(sound, stop());
+    assert(sound);
+    sound->This.stop();
 }
 
 
@@ -82,7 +82,8 @@ void sfSound_setBuffer(sfSound* sound, const sfSoundBuffer* buffer)
 {
     if (buffer)
     {
-        CSFML_CALL(sound, setBuffer(buffer->This));
+        assert(sound);
+        sound->This.setBuffer(buffer->This);
         sound->Buffer = buffer;
     }
 }
@@ -91,8 +92,7 @@ void sfSound_setBuffer(sfSound* sound, const sfSoundBuffer* buffer)
 ////////////////////////////////////////////////////////////
 const sfSoundBuffer* sfSound_getBuffer(const sfSound* sound)
 {
-    CSFML_CHECK_RETURN(sound, nullptr);
-
+    assert(sound);
     return sound->Buffer;
 }
 
@@ -100,22 +100,23 @@ const sfSoundBuffer* sfSound_getBuffer(const sfSound* sound)
 ////////////////////////////////////////////////////////////
 void sfSound_setLooping(sfSound* sound, bool loop)
 {
-    CSFML_CALL(sound, setLooping(loop));
+    assert(sound);
+    sound->This.setLooping(loop);
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfSound_isLooping(const sfSound* sound)
 {
-    CSFML_CALL_RETURN(sound, isLooping(), false);
+    assert(sound);
+    return sound->This.isLooping();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfSoundStatus sfSound_getStatus(const sfSound* sound)
 {
-    CSFML_CHECK_RETURN(sound, sfStopped);
-
+    assert(sound);
     return static_cast<sfSoundStatus>(sound->This.getStatus());
 }
 
@@ -123,71 +124,79 @@ sfSoundStatus sfSound_getStatus(const sfSound* sound)
 ////////////////////////////////////////////////////////////
 void sfSound_setPitch(sfSound* sound, float pitch)
 {
-    CSFML_CALL(sound, setPitch(pitch));
+    assert(sound);
+    sound->This.setPitch(pitch);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSound_setVolume(sfSound* sound, float volume)
 {
-    CSFML_CALL(sound, setVolume(volume));
+    assert(sound);
+    sound->This.setVolume(volume);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSound_setPosition(sfSound* sound, sfVector3f position)
 {
-    CSFML_CALL(sound, setPosition(convertVector3(position)));
+    assert(sound);
+    sound->This.setPosition(convertVector3(position));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSound_setRelativeToListener(sfSound* sound, bool relative)
 {
-    CSFML_CALL(sound, setRelativeToListener(relative));
+    assert(sound);
+    sound->This.setRelativeToListener(relative);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSound_setMinDistance(sfSound* sound, float distance)
 {
-    CSFML_CALL(sound, setMinDistance(distance));
+    assert(sound);
+    sound->This.setMinDistance(distance);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSound_setAttenuation(sfSound* sound, float attenuation)
 {
-    CSFML_CALL(sound, setAttenuation(attenuation));
+    assert(sound);
+    sound->This.setAttenuation(attenuation);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSound_setPlayingOffset(sfSound* sound, sfTime timeOffset)
 {
-    CSFML_CALL(sound, setPlayingOffset(sf::microseconds(timeOffset.microseconds)));
+    assert(sound);
+    sound->This.setPlayingOffset(sf::microseconds(timeOffset.microseconds));
 }
 
 
 ////////////////////////////////////////////////////////////
 float sfSound_getPitch(const sfSound* sound)
 {
-    CSFML_CALL_RETURN(sound, getPitch(), 0.f);
+    assert(sound);
+    return sound->This.getPitch();
 }
 
 
 ////////////////////////////////////////////////////////////
 float sfSound_getVolume(const sfSound* sound)
 {
-    CSFML_CALL_RETURN(sound, getVolume(), 0.f);
+    assert(sound);
+    return sound->This.getVolume();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector3f sfSound_getPosition(const sfSound* sound)
 {
-    CSFML_CHECK_RETURN(sound, {});
-
+    assert(sound);
     return convertVector3(sound->This.getPosition());
 }
 
@@ -195,30 +204,30 @@ sfVector3f sfSound_getPosition(const sfSound* sound)
 ////////////////////////////////////////////////////////////
 bool sfSound_isRelativeToListener(const sfSound* sound)
 {
-    CSFML_CALL_RETURN(sound, isRelativeToListener(), false);
+    assert(sound);
+    return sound->This.isRelativeToListener();
 }
 
 
 ////////////////////////////////////////////////////////////
 float sfSound_getMinDistance(const sfSound* sound)
 {
-    CSFML_CALL_RETURN(sound, getMinDistance(), 0.f);
+    assert(sound);
+    return sound->This.getMinDistance();
 }
 
 
 ////////////////////////////////////////////////////////////
 float sfSound_getAttenuation(const sfSound* sound)
 {
-    CSFML_CALL_RETURN(sound, getAttenuation(), 0.f);
+    assert(sound);
+    return sound->This.getAttenuation();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfTime sfSound_getPlayingOffset(const sfSound* sound)
 {
-    sfTime time = {0};
-    CSFML_CHECK_RETURN(sound, time);
-
-    time.microseconds = sound->This.getPlayingOffset().asMicroseconds();
-    return time;
+    assert(sound);
+    return {sound->This.getPlayingOffset().asMicroseconds()};
 }

src/CSFML/Audio/SoundBuffer.cpp

@@ -28,7 +28,6 @@
 #include <CSFML/Audio/SoundBuffer.h>
 #include <CSFML/Audio/SoundBufferStruct.hpp>
 #include <CSFML/CallbackStream.hpp>
-#include <CSFML/Internal.hpp>
 
 
 ////////////////////////////////////////////////////////////
@@ -56,7 +55,7 @@ sfSoundBuffer* sfSoundBuffer_createFromMemory(const void* data, size_t sizeInByt
 ////////////////////////////////////////////////////////////
 sfSoundBuffer* sfSoundBuffer_createFromStream(sfInputStream* stream)
 {
-    CSFML_CHECK_RETURN(stream, nullptr);
+    assert(stream);
 
     CallbackStream  sfmlStream(stream);
     sf::SoundBuffer soundBuffer;
@@ -91,8 +90,7 @@ sfSoundBuffer* sfSoundBuffer_createFromSamples(
 ////////////////////////////////////////////////////////////
 sfSoundBuffer* sfSoundBuffer_copy(const sfSoundBuffer* soundBuffer)
 {
-    CSFML_CHECK_RETURN(soundBuffer, nullptr);
-
+    assert(soundBuffer);
     return new sfSoundBuffer(*soundBuffer);
 }
 
@@ -107,44 +105,46 @@ void sfSoundBuffer_destroy(sfSoundBuffer* soundBuffer)
 ////////////////////////////////////////////////////////////
 bool sfSoundBuffer_saveToFile(const sfSoundBuffer* soundBuffer, const char* filename)
 {
-    CSFML_CALL_RETURN(soundBuffer, saveToFile(filename), false);
+    assert(soundBuffer);
+    return soundBuffer->This.saveToFile(filename);
 }
 
 
 ////////////////////////////////////////////////////////////
 const int16_t* sfSoundBuffer_getSamples(const sfSoundBuffer* soundBuffer)
 {
-    CSFML_CALL_RETURN(soundBuffer, getSamples(), nullptr);
+    assert(soundBuffer);
+    return soundBuffer->This.getSamples();
 }
 
 
 ////////////////////////////////////////////////////////////
 uint64_t sfSoundBuffer_getSampleCount(const sfSoundBuffer* soundBuffer)
 {
-    CSFML_CALL_RETURN(soundBuffer, getSampleCount(), 0);
+    assert(soundBuffer);
+    return soundBuffer->This.getSampleCount();
 }
 
 
 ////////////////////////////////////////////////////////////
 unsigned int sfSoundBuffer_getSampleRate(const sfSoundBuffer* soundBuffer)
 {
-    CSFML_CALL_RETURN(soundBuffer, getSampleRate(), 0);
+    assert(soundBuffer);
+    return soundBuffer->This.getSampleRate();
 }
 
 
 ////////////////////////////////////////////////////////////
 unsigned int sfSoundBuffer_getChannelCount(const sfSoundBuffer* soundBuffer)
 {
-    CSFML_CALL_RETURN(soundBuffer, getChannelCount(), 0);
+    assert(soundBuffer);
+    return soundBuffer->This.getChannelCount();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfTime sfSoundBuffer_getDuration(const sfSoundBuffer* soundBuffer)
 {
-    sfTime time = {0};
-    CSFML_CHECK_RETURN(soundBuffer, time);
-
-    time.microseconds = soundBuffer->This.getDuration().asMicroseconds();
-    return time;
+    assert(soundBuffer);
+    return {soundBuffer->This.getDuration().asMicroseconds()};
 }

src/CSFML/Audio/SoundBufferRecorder.cpp

@@ -27,7 +27,6 @@
 ////////////////////////////////////////////////////////////
 #include <CSFML/Audio/SoundBufferRecorder.h>
 #include <CSFML/Audio/SoundBufferRecorderStruct.hpp>
-#include <CSFML/Internal.hpp>
 
 
 ////////////////////////////////////////////////////////////
@@ -47,28 +46,31 @@ void sfSoundBufferRecorder_destroy(sfSoundBufferRecorder* soundBufferRecorder)
 ////////////////////////////////////////////////////////////
 bool sfSoundBufferRecorder_start(sfSoundBufferRecorder* soundBufferRecorder, unsigned int sampleRate)
 {
-    CSFML_CALL_RETURN(soundBufferRecorder, start(sampleRate), false);
+    assert(soundBufferRecorder);
+    return soundBufferRecorder->This.start(sampleRate);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSoundBufferRecorder_stop(sfSoundBufferRecorder* soundBufferRecorder)
 {
-    CSFML_CALL(soundBufferRecorder, stop());
+    assert(soundBufferRecorder);
+    soundBufferRecorder->This.stop();
 }
 
 
 ////////////////////////////////////////////////////////////
 unsigned int sfSoundBufferRecorder_getSampleRate(const sfSoundBufferRecorder* soundBufferRecorder)
 {
-    CSFML_CALL_RETURN(soundBufferRecorder, getSampleRate(), 0);
+    assert(soundBufferRecorder);
+    return soundBufferRecorder->This.getSampleRate();
 }
 
 
 ////////////////////////////////////////////////////////////
 const sfSoundBuffer* sfSoundBufferRecorder_getBuffer(const sfSoundBufferRecorder* soundBufferRecorder)
 {
-    CSFML_CHECK_RETURN(soundBufferRecorder, nullptr);
+    assert(soundBufferRecorder);
 
     soundBufferRecorder->SoundBuffer.This = soundBufferRecorder->This.getBuffer();
 
@@ -78,13 +80,14 @@ const sfSoundBuffer* sfSoundBufferRecorder_getBuffer(const sfSoundBufferRecorder
 ////////////////////////////////////////////////////////////
 bool sfSoundBufferRecorder_setDevice(sfSoundBufferRecorder* soundBufferRecorder, const char* name)
 {
-    CSFML_CALL_RETURN(soundBufferRecorder, setDevice(name), false);
+    assert(soundBufferRecorder);
+    return soundBufferRecorder->This.setDevice(name);
 }
 
 ////////////////////////////////////////////////////////////
 const char* sfSoundBufferRecorder_getDevice(sfSoundBufferRecorder* soundBufferRecorder)
 {
-    CSFML_CHECK_RETURN(soundBufferRecorder, nullptr);
+    assert(soundBufferRecorder);
 
     soundBufferRecorder->DeviceName = soundBufferRecorder->This.getDevice();
 

src/CSFML/Audio/SoundRecorder.cpp

@@ -27,7 +27,8 @@
 ////////////////////////////////////////////////////////////
 #include <CSFML/Audio/SoundRecorder.h>
 #include <CSFML/Audio/SoundRecorderStruct.hpp>
-#include <CSFML/Internal.hpp>
+
+#include <cassert>
 
 
 ////////////////////////////////////////////////////////////
@@ -50,21 +51,24 @@ void sfSoundRecorder_destroy(sfSoundRecorder* soundRecorder)
 ////////////////////////////////////////////////////////////
 bool sfSoundRecorder_start(sfSoundRecorder* soundRecorder, unsigned int sampleRate)
 {
-    CSFML_CALL_RETURN(soundRecorder, start(sampleRate), false);
+    assert(soundRecorder);
+    return soundRecorder->This.start(sampleRate);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSoundRecorder_stop(sfSoundRecorder* soundRecorder)
 {
-    CSFML_CALL(soundRecorder, stop());
+    assert(soundRecorder);
+    soundRecorder->This.stop();
 }
 
 
 ////////////////////////////////////////////////////////////
 unsigned int sfSoundRecorder_getSampleRate(const sfSoundRecorder* soundRecorder)
 {
-    CSFML_CALL_RETURN(soundRecorder, getSampleRate(), 0);
+    assert(soundRecorder);
+    return soundRecorder->This.getSampleRate();
 }
 
 
@@ -108,14 +112,15 @@ const char* sfSoundRecorder_getDefaultDevice()
 ////////////////////////////////////////////////////////////
 bool sfSoundRecorder_setDevice(sfSoundRecorder* soundRecorder, const char* name)
 {
-    CSFML_CALL_RETURN(soundRecorder, setDevice(name), false);
+    assert(soundRecorder);
+    return soundRecorder->This.setDevice(name);
 }
 
 
 ////////////////////////////////////////////////////////////
 const char* sfSoundRecorder_getDevice(sfSoundRecorder* soundRecorder)
 {
-    CSFML_CHECK_RETURN(soundRecorder, nullptr);
+    assert(soundRecorder);
 
     soundRecorder->DeviceName = soundRecorder->This.getDevice();
 
@@ -126,12 +131,14 @@ const char* sfSoundRecorder_getDevice(sfSoundRecorder* soundRecorder)
 ////////////////////////////////////////////////////////////
 void sfSoundRecorder_setChannelCount(sfSoundRecorder* soundRecorder, unsigned int channelCount)
 {
-    CSFML_CALL(soundRecorder, setChannelCount(channelCount));
+    assert(soundRecorder);
+    soundRecorder->This.setChannelCount(channelCount);
 }
 
 
 ////////////////////////////////////////////////////////////
 unsigned int sfSoundRecorder_getChannelCount(const sfSoundRecorder* soundRecorder)
 {
-    CSFML_CALL_RETURN(soundRecorder, getChannelCount(), 0);
+    assert(soundRecorder);
+    return soundRecorder->This.getChannelCount();
 }

src/CSFML/Audio/SoundStream.cpp

@@ -27,7 +27,6 @@
 ////////////////////////////////////////////////////////////
 #include <CSFML/Audio/SoundStream.h>
 #include <CSFML/Audio/SoundStreamStruct.hpp>
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/ConvertVector3.hpp>
 
 
@@ -55,29 +54,31 @@ void sfSoundStream_destroy(sfSoundStream* soundStream)
 ////////////////////////////////////////////////////////////
 void sfSoundStream_play(sfSoundStream* soundStream)
 {
-    CSFML_CALL(soundStream, play());
+    assert(soundStream);
+    soundStream->This.play();
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSoundStream_pause(sfSoundStream* soundStream)
 {
-    CSFML_CALL(soundStream, pause());
+    assert(soundStream);
+    soundStream->This.pause();
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSoundStream_stop(sfSoundStream* soundStream)
 {
-    CSFML_CALL(soundStream, stop());
+    assert(soundStream);
+    soundStream->This.stop();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfSoundStatus sfSoundStream_getStatus(const sfSoundStream* soundStream)
 {
-    CSFML_CHECK_RETURN(soundStream, sfStopped);
-
+    assert(soundStream);
     return static_cast<sfSoundStatus>(soundStream->This.getStatus());
 }
 
@@ -85,92 +86,103 @@ sfSoundStatus sfSoundStream_getStatus(const sfSoundStream* soundStream)
 ////////////////////////////////////////////////////////////
 unsigned int sfSoundStream_getChannelCount(const sfSoundStream* soundStream)
 {
-    CSFML_CALL_RETURN(soundStream, getChannelCount(), 0);
+    assert(soundStream);
+    return soundStream->This.getChannelCount();
 }
 
 
 ////////////////////////////////////////////////////////////
 unsigned int sfSoundStream_getSampleRate(const sfSoundStream* soundStream)
 {
-    CSFML_CALL_RETURN(soundStream, getSampleRate(), 0);
+    assert(soundStream);
+    return soundStream->This.getSampleRate();
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSoundStream_setPitch(sfSoundStream* soundStream, float pitch)
 {
-    CSFML_CALL(soundStream, setPitch(pitch));
+    assert(soundStream);
+    soundStream->This.setPitch(pitch);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSoundStream_setVolume(sfSoundStream* soundStream, float volume)
 {
-    CSFML_CALL(soundStream, setVolume(volume));
+    assert(soundStream);
+    soundStream->This.setVolume(volume);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSoundStream_setPosition(sfSoundStream* soundStream, sfVector3f position)
 {
-    CSFML_CALL(soundStream, setPosition(convertVector3(position)));
+    assert(soundStream);
+    soundStream->This.setPosition(convertVector3(position));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSoundStream_setRelativeToListener(sfSoundStream* soundStream, bool relative)
 {
-    CSFML_CALL(soundStream, setRelativeToListener(relative));
+    assert(soundStream);
+    soundStream->This.setRelativeToListener(relative);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSoundStream_setMinDistance(sfSoundStream* soundStream, float distance)
 {
-    CSFML_CALL(soundStream, setMinDistance(distance));
+    assert(soundStream);
+    soundStream->This.setMinDistance(distance);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSoundStream_setAttenuation(sfSoundStream* soundStream, float attenuation)
 {
-    CSFML_CALL(soundStream, setAttenuation(attenuation));
+    assert(soundStream);
+    soundStream->This.setAttenuation(attenuation);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSoundStream_setPlayingOffset(sfSoundStream* soundStream, sfTime timeOffset)
 {
-    CSFML_CALL(soundStream, setPlayingOffset(sf::microseconds(timeOffset.microseconds)));
+    assert(soundStream);
+    soundStream->This.setPlayingOffset(sf::microseconds(timeOffset.microseconds));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSoundStream_setLooping(sfSoundStream* soundStream, bool loop)
 {
-    CSFML_CALL(soundStream, setLooping(loop));
+    assert(soundStream);
+    soundStream->This.setLooping(loop);
 }
 
 
 ////////////////////////////////////////////////////////////
 float sfSoundStream_getPitch(const sfSoundStream* soundStream)
 {
-    CSFML_CALL_RETURN(soundStream, getPitch(), 0.f);
+    assert(soundStream);
+    return soundStream->This.getPitch();
 }
 
 
 ////////////////////////////////////////////////////////////
 float sfSoundStream_getVolume(const sfSoundStream* soundStream)
 {
-    CSFML_CALL_RETURN(soundStream, getVolume(), 0.f);
+    assert(soundStream);
+    return soundStream->This.getVolume();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector3f sfSoundStream_getPosition(const sfSoundStream* soundStream)
 {
-    CSFML_CHECK_RETURN(soundStream, {});
-
+    assert(soundStream);
     return convertVector3(soundStream->This.getPosition());
 }
 
@@ -178,37 +190,38 @@ sfVector3f sfSoundStream_getPosition(const sfSoundStream* soundStream)
 ////////////////////////////////////////////////////////////
 bool sfSoundStream_isRelativeToListener(const sfSoundStream* soundStream)
 {
-    CSFML_CALL_RETURN(soundStream, isRelativeToListener(), false);
+    assert(soundStream);
+    return soundStream->This.isRelativeToListener();
 }
 
 
 ////////////////////////////////////////////////////////////
 float sfSoundStream_getMinDistance(const sfSoundStream* soundStream)
 {
-    CSFML_CALL_RETURN(soundStream, getMinDistance(), 0.f);
+    assert(soundStream);
+    return soundStream->This.getMinDistance();
 }
 
 
 ////////////////////////////////////////////////////////////
 float sfSoundStream_getAttenuation(const sfSoundStream* soundStream)
 {
-    CSFML_CALL_RETURN(soundStream, getAttenuation(), 0.f);
+    assert(soundStream);
+    return soundStream->This.getAttenuation();
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfSoundStream_isLooping(const sfSoundStream* soundStream)
 {
-    CSFML_CALL_RETURN(soundStream, isLooping(), false);
+    assert(soundStream);
+    return soundStream->This.isLooping();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfTime sfSoundStream_getPlayingOffset(const sfSoundStream* soundStream)
 {
-    sfTime time = {0};
-    CSFML_CHECK_RETURN(soundStream, time);
-
-    time.microseconds = soundStream->This.getPlayingOffset().asMicroseconds();
-    return time;
+    assert(soundStream);
+    return {soundStream->This.getPlayingOffset().asMicroseconds()};
 }

src/CSFML/Char32.hpp

@@ -34,6 +34,15 @@
 #include <string.h>
 
 
+////////////////////////////////////////////////////////////
+// Ensure char32_t has the same size as sfChar32 (uint32_t)
+// Identical alignment and size is required because we're type punning
+// when doing sfChar32* <-> char32_t* casts
+////////////////////////////////////////////////////////////
+static_assert(sizeof(sfChar32) == sizeof(char32_t));
+static_assert(alignof(sfChar32) == alignof(char32_t));
+
+
 ////////////////////////////////////////////////////////////
 // Define utils to copy from / to sfChar32 and sf::String
 ////////////////////////////////////////////////////////////

src/CSFML/Graphics/CircleShape.cpp

@@ -30,7 +30,6 @@
 #include <CSFML/Graphics/ConvertColor.hpp>
 #include <CSFML/Graphics/ConvertRect.hpp>
 #include <CSFML/Graphics/ConvertTransform.hpp>
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/ConvertVector2.hpp>
 
 #include <SFML/Graphics/Color.hpp>
@@ -49,8 +48,7 @@ sfCircleShape* sfCircleShape_create()
 ////////////////////////////////////////////////////////////
 sfCircleShape* sfCircleShape_copy(const sfCircleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, nullptr);
-
+    assert(shape);
     return new sfCircleShape(*shape);
 }
 
@@ -65,36 +63,39 @@ void sfCircleShape_destroy(sfCircleShape* shape)
 ////////////////////////////////////////////////////////////
 void sfCircleShape_setPosition(sfCircleShape* shape, sfVector2f position)
 {
-    CSFML_CALL(shape, setPosition(convertVector2(position)));
+    assert(shape);
+    shape->This.setPosition(convertVector2(position));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfCircleShape_setRotation(sfCircleShape* shape, float angle)
 {
-    CSFML_CALL(shape, setRotation(sf::degrees(angle)));
+    assert(shape);
+    shape->This.setRotation(sf::degrees(angle));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfCircleShape_setScale(sfCircleShape* shape, sfVector2f scale)
 {
-    CSFML_CALL(shape, setScale(convertVector2(scale)));
+    assert(shape);
+    shape->This.setScale(convertVector2(scale));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfCircleShape_setOrigin(sfCircleShape* shape, sfVector2f origin)
 {
-    CSFML_CALL(shape, setOrigin(convertVector2(origin)));
+    assert(shape);
+    shape->This.setOrigin(convertVector2(origin));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2f sfCircleShape_getPosition(const sfCircleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertVector2(shape->This.getPosition());
 }
 
@@ -102,15 +103,15 @@ sfVector2f sfCircleShape_getPosition(const sfCircleShape* shape)
 ////////////////////////////////////////////////////////////
 float sfCircleShape_getRotation(const sfCircleShape* shape)
 {
-    CSFML_CALL_RETURN(shape, getRotation().asDegrees(), 0.f);
+    assert(shape);
+    return shape->This.getRotation().asDegrees();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2f sfCircleShape_getScale(const sfCircleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertVector2(shape->This.getScale());
 }
 
@@ -118,8 +119,7 @@ sfVector2f sfCircleShape_getScale(const sfCircleShape* shape)
 ////////////////////////////////////////////////////////////
 sfVector2f sfCircleShape_getOrigin(const sfCircleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertVector2(shape->This.getOrigin());
 }
 
@@ -127,29 +127,31 @@ sfVector2f sfCircleShape_getOrigin(const sfCircleShape* shape)
 ////////////////////////////////////////////////////////////
 void sfCircleShape_move(sfCircleShape* shape, sfVector2f offset)
 {
-    CSFML_CALL(shape, move(convertVector2(offset)));
+    assert(shape);
+    shape->This.move(convertVector2(offset));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfCircleShape_rotate(sfCircleShape* shape, float angle)
 {
-    CSFML_CALL(shape, rotate(sf::degrees(angle)));
+    assert(shape);
+    shape->This.rotate(sf::degrees(angle));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfCircleShape_scale(sfCircleShape* shape, sfVector2f factors)
 {
-    CSFML_CALL(shape, scale(convertVector2(factors)));
+    assert(shape);
+    shape->This.scale(convertVector2(factors));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfTransform sfCircleShape_getTransform(const sfCircleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, sfTransform_Identity);
-
+    assert(shape);
     shape->Transform = convertTransform(shape->This.getTransform());
     return shape->Transform;
 }
@@ -158,8 +160,7 @@ sfTransform sfCircleShape_getTransform(const sfCircleShape* shape)
 ////////////////////////////////////////////////////////////
 sfTransform sfCircleShape_getInverseTransform(const sfCircleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, sfTransform_Identity);
-
+    assert(shape);
     shape->InverseTransform = convertTransform(shape->This.getInverseTransform());
     return shape->InverseTransform;
 }
@@ -168,7 +169,8 @@ sfTransform sfCircleShape_getInverseTransform(const sfCircleShape* shape)
 ////////////////////////////////////////////////////////////
 void sfCircleShape_setTexture(sfCircleShape* shape, const sfTexture* texture, bool resetRect)
 {
-    CSFML_CALL(shape, setTexture(texture ? texture->This : nullptr, resetRect));
+    assert(shape);
+    shape->This.setTexture(texture ? texture->This : nullptr, resetRect);
     shape->Texture = texture;
 }
 
@@ -176,36 +178,39 @@ void sfCircleShape_setTexture(sfCircleShape* shape, const sfTexture* texture, bo
 ////////////////////////////////////////////////////////////
 void sfCircleShape_setTextureRect(sfCircleShape* shape, sfIntRect rect)
 {
-    CSFML_CALL(shape, setTextureRect(convertRect(rect)));
+    assert(shape);
+    shape->This.setTextureRect(convertRect(rect));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfCircleShape_setFillColor(sfCircleShape* shape, sfColor color)
 {
-    CSFML_CALL(shape, setFillColor(convertColor(color)));
+    assert(shape);
+    shape->This.setFillColor(convertColor(color));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfCircleShape_setOutlineColor(sfCircleShape* shape, sfColor color)
 {
-    CSFML_CALL(shape, setOutlineColor(convertColor(color)));
+    assert(shape);
+    shape->This.setOutlineColor(convertColor(color));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfCircleShape_setOutlineThickness(sfCircleShape* shape, float thickness)
 {
-    CSFML_CALL(shape, setOutlineThickness(thickness));
+    assert(shape);
+    shape->This.setOutlineThickness(thickness);
 }
 
 
 ////////////////////////////////////////////////////////////
 const sfTexture* sfCircleShape_getTexture(const sfCircleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, nullptr);
-
+    assert(shape);
     return shape->Texture;
 }
 
@@ -213,8 +218,7 @@ const sfTexture* sfCircleShape_getTexture(const sfCircleShape* shape)
 ////////////////////////////////////////////////////////////
 sfIntRect sfCircleShape_getTextureRect(const sfCircleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertRect(shape->This.getTextureRect());
 }
 
@@ -222,8 +226,7 @@ sfIntRect sfCircleShape_getTextureRect(const sfCircleShape* shape)
 ////////////////////////////////////////////////////////////
 sfColor sfCircleShape_getFillColor(const sfCircleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertColor(shape->This.getFillColor());
 }
 
@@ -231,8 +234,7 @@ sfColor sfCircleShape_getFillColor(const sfCircleShape* shape)
 ////////////////////////////////////////////////////////////
 sfColor sfCircleShape_getOutlineColor(const sfCircleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertColor(shape->This.getOutlineColor());
 }
 
@@ -240,22 +242,23 @@ sfColor sfCircleShape_getOutlineColor(const sfCircleShape* shape)
 ////////////////////////////////////////////////////////////
 float sfCircleShape_getOutlineThickness(const sfCircleShape* shape)
 {
-    CSFML_CALL_RETURN(shape, getOutlineThickness(), 0.f);
+    assert(shape);
+    return shape->This.getOutlineThickness();
 }
 
 
 ////////////////////////////////////////////////////////////
 size_t sfCircleShape_getPointCount(const sfCircleShape* shape)
 {
-    CSFML_CALL_RETURN(shape, getPointCount(), 0);
+    assert(shape);
+    return shape->This.getPointCount();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2f sfCircleShape_getPoint(const sfCircleShape* shape, size_t index)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertVector2(shape->This.getPoint(index));
 }
 
@@ -263,29 +266,31 @@ sfVector2f sfCircleShape_getPoint(const sfCircleShape* shape, size_t index)
 ////////////////////////////////////////////////////////////
 void sfCircleShape_setRadius(sfCircleShape* shape, float radius)
 {
-    CSFML_CALL(shape, setRadius(radius));
+    assert(shape);
+    shape->This.setRadius(radius);
 }
 
 
 ////////////////////////////////////////////////////////////
 float sfCircleShape_getRadius(const sfCircleShape* shape)
 {
-    CSFML_CALL_RETURN(shape, getRadius(), 0.f);
+    assert(shape);
+    return shape->This.getRadius();
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfCircleShape_setPointCount(sfCircleShape* shape, size_t count)
 {
-    CSFML_CALL(shape, setPointCount(count));
+    assert(shape);
+    shape->This.setPointCount(count);
 }
 
 
 ////////////////////////////////////////////////////////////
 sfFloatRect sfCircleShape_getLocalBounds(const sfCircleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertRect(shape->This.getLocalBounds());
 }
 
@@ -293,7 +298,6 @@ sfFloatRect sfCircleShape_getLocalBounds(const sfCircleShape* shape)
 ////////////////////////////////////////////////////////////
 sfFloatRect sfCircleShape_getGlobalBounds(const sfCircleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertRect(shape->This.getGlobalBounds());
 }

src/CSFML/Graphics/Color.cpp

@@ -26,7 +26,6 @@
 // Headers
 ////////////////////////////////////////////////////////////
 #include <CSFML/Graphics/Color.h>
-#include <CSFML/Internal.hpp>
 
 #include <algorithm>
 

src/CSFML/Graphics/ConvexShape.cpp

@@ -30,7 +30,6 @@
 #include <CSFML/Graphics/ConvertTransform.hpp>
 #include <CSFML/Graphics/ConvexShape.h>
 #include <CSFML/Graphics/ConvexShapeStruct.hpp>
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/ConvertVector2.hpp>
 
 #include <SFML/Graphics/Color.hpp>
@@ -46,8 +45,7 @@ sfConvexShape* sfConvexShape_create()
 ////////////////////////////////////////////////////////////
 sfConvexShape* sfConvexShape_copy(const sfConvexShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, nullptr);
-
+    assert(shape);
     return new sfConvexShape(*shape);
 }
 
@@ -62,36 +60,39 @@ void sfConvexShape_destroy(sfConvexShape* shape)
 ////////////////////////////////////////////////////////////
 void sfConvexShape_setPosition(sfConvexShape* shape, sfVector2f position)
 {
-    CSFML_CALL(shape, setPosition(convertVector2(position)));
+    assert(shape);
+    shape->This.setPosition(convertVector2(position));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfConvexShape_setRotation(sfConvexShape* shape, float angle)
 {
-    CSFML_CALL(shape, setRotation(sf::degrees(angle)));
+    assert(shape);
+    shape->This.setRotation(sf::degrees(angle));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfConvexShape_setScale(sfConvexShape* shape, sfVector2f scale)
 {
-    CSFML_CALL(shape, setScale(convertVector2(scale)));
+    assert(shape);
+    shape->This.setScale(convertVector2(scale));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfConvexShape_setOrigin(sfConvexShape* shape, sfVector2f origin)
 {
-    CSFML_CALL(shape, setOrigin(convertVector2(origin)));
+    assert(shape);
+    shape->This.setOrigin(convertVector2(origin));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2f sfConvexShape_getPosition(const sfConvexShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertVector2(shape->This.getPosition());
 }
 
@@ -99,15 +100,15 @@ sfVector2f sfConvexShape_getPosition(const sfConvexShape* shape)
 ////////////////////////////////////////////////////////////
 float sfConvexShape_getRotation(const sfConvexShape* shape)
 {
-    CSFML_CALL_RETURN(shape, getRotation().asDegrees(), 0.f);
+    assert(shape);
+    return shape->This.getRotation().asDegrees();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2f sfConvexShape_getScale(const sfConvexShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertVector2(shape->This.getScale());
 }
 
@@ -115,8 +116,7 @@ sfVector2f sfConvexShape_getScale(const sfConvexShape* shape)
 ////////////////////////////////////////////////////////////
 sfVector2f sfConvexShape_getOrigin(const sfConvexShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertVector2(shape->This.getOrigin());
 }
 
@@ -124,29 +124,31 @@ sfVector2f sfConvexShape_getOrigin(const sfConvexShape* shape)
 ////////////////////////////////////////////////////////////
 void sfConvexShape_move(sfConvexShape* shape, sfVector2f offset)
 {
-    CSFML_CALL(shape, move(convertVector2(offset)));
+    assert(shape);
+    shape->This.move(convertVector2(offset));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfConvexShape_rotate(sfConvexShape* shape, float angle)
 {
-    CSFML_CALL(shape, rotate(sf::degrees(angle)));
+    assert(shape);
+    shape->This.rotate(sf::degrees(angle));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfConvexShape_scale(sfConvexShape* shape, sfVector2f factors)
 {
-    CSFML_CALL(shape, scale(convertVector2(factors)));
+    assert(shape);
+    shape->This.scale(convertVector2(factors));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfTransform sfConvexShape_getTransform(const sfConvexShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, sfTransform_Identity);
-
+    assert(shape);
     shape->Transform = convertTransform(shape->This.getTransform());
     return shape->Transform;
 }
@@ -155,8 +157,7 @@ sfTransform sfConvexShape_getTransform(const sfConvexShape* shape)
 ////////////////////////////////////////////////////////////
 sfTransform sfConvexShape_getInverseTransform(const sfConvexShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, sfTransform_Identity);
-
+    assert(shape);
     shape->InverseTransform = convertTransform(shape->This.getInverseTransform());
     return shape->InverseTransform;
 }
@@ -165,7 +166,8 @@ sfTransform sfConvexShape_getInverseTransform(const sfConvexShape* shape)
 ////////////////////////////////////////////////////////////
 void sfConvexShape_setTexture(sfConvexShape* shape, const sfTexture* texture, bool resetRect)
 {
-    CSFML_CALL(shape, setTexture(texture ? texture->This : nullptr, resetRect));
+    assert(shape);
+    shape->This.setTexture(texture ? texture->This : nullptr, resetRect);
     shape->Texture = texture;
 }
 
@@ -173,36 +175,39 @@ void sfConvexShape_setTexture(sfConvexShape* shape, const sfTexture* texture, bo
 ////////////////////////////////////////////////////////////
 void sfConvexShape_setTextureRect(sfConvexShape* shape, sfIntRect rect)
 {
-    CSFML_CALL(shape, setTextureRect(convertRect(rect)));
+    assert(shape);
+    shape->This.setTextureRect(convertRect(rect));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfConvexShape_setFillColor(sfConvexShape* shape, sfColor color)
 {
-    CSFML_CALL(shape, setFillColor(convertColor(color)));
+    assert(shape);
+    shape->This.setFillColor(convertColor(color));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfConvexShape_setOutlineColor(sfConvexShape* shape, sfColor color)
 {
-    CSFML_CALL(shape, setOutlineColor(convertColor(color)));
+    assert(shape);
+    shape->This.setOutlineColor(convertColor(color));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfConvexShape_setOutlineThickness(sfConvexShape* shape, float thickness)
 {
-    CSFML_CALL(shape, setOutlineThickness(thickness));
+    assert(shape);
+    shape->This.setOutlineThickness(thickness);
 }
 
 
 ////////////////////////////////////////////////////////////
 const sfTexture* sfConvexShape_getTexture(const sfConvexShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, nullptr);
-
+    assert(shape);
     return shape->Texture;
 }
 
@@ -210,8 +215,7 @@ const sfTexture* sfConvexShape_getTexture(const sfConvexShape* shape)
 ////////////////////////////////////////////////////////////
 sfIntRect sfConvexShape_getTextureRect(const sfConvexShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertRect(shape->This.getTextureRect());
 }
 
@@ -219,8 +223,7 @@ sfIntRect sfConvexShape_getTextureRect(const sfConvexShape* shape)
 ////////////////////////////////////////////////////////////
 sfColor sfConvexShape_getFillColor(const sfConvexShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertColor(shape->This.getFillColor());
 }
 
@@ -228,8 +231,7 @@ sfColor sfConvexShape_getFillColor(const sfConvexShape* shape)
 ////////////////////////////////////////////////////////////
 sfColor sfConvexShape_getOutlineColor(const sfConvexShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertColor(shape->This.getOutlineColor());
 }
 
@@ -237,22 +239,23 @@ sfColor sfConvexShape_getOutlineColor(const sfConvexShape* shape)
 ////////////////////////////////////////////////////////////
 float sfConvexShape_getOutlineThickness(const sfConvexShape* shape)
 {
-    CSFML_CALL_RETURN(shape, getOutlineThickness(), 0.f);
+    assert(shape);
+    return shape->This.getOutlineThickness();
 }
 
 
 ////////////////////////////////////////////////////////////
 size_t sfConvexShape_getPointCount(const sfConvexShape* shape)
 {
-    CSFML_CALL_RETURN(shape, getPointCount(), 0);
+    assert(shape);
+    return shape->This.getPointCount();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2f sfConvexShape_getPoint(const sfConvexShape* shape, size_t index)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertVector2(shape->This.getPoint(index));
 }
 
@@ -260,22 +263,23 @@ sfVector2f sfConvexShape_getPoint(const sfConvexShape* shape, size_t index)
 ////////////////////////////////////////////////////////////
 void sfConvexShape_setPointCount(sfConvexShape* shape, size_t count)
 {
-    CSFML_CALL(shape, setPointCount(count));
+    assert(shape);
+    shape->This.setPointCount(count);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfConvexShape_setPoint(sfConvexShape* shape, size_t index, sfVector2f point)
 {
-    CSFML_CALL(shape, setPoint(index, convertVector2(point)));
+    assert(shape);
+    shape->This.setPoint(index, convertVector2(point));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfFloatRect sfConvexShape_getLocalBounds(const sfConvexShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertRect(shape->This.getLocalBounds());
 }
 
@@ -283,7 +287,6 @@ sfFloatRect sfConvexShape_getLocalBounds(const sfConvexShape* shape)
 ////////////////////////////////////////////////////////////
 sfFloatRect sfConvexShape_getGlobalBounds(const sfConvexShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertRect(shape->This.getGlobalBounds());
 }

src/CSFML/Graphics/Font.cpp

@@ -29,7 +29,6 @@
 #include <CSFML/Graphics/ConvertRect.hpp>
 #include <CSFML/Graphics/Font.h>
 #include <CSFML/Graphics/FontStruct.hpp>
-#include <CSFML/Internal.hpp>
 
 
 ////////////////////////////////////////////////////////////
@@ -57,7 +56,7 @@ sfFont* sfFont_createFromMemory(const void* data, size_t sizeInBytes)
 ////////////////////////////////////////////////////////////
 sfFont* sfFont_createFromStream(sfInputStream* stream)
 {
-    CSFML_CHECK_RETURN(stream, nullptr);
+    assert(stream);
 
     sfFont* font = new sfFont;
     font->Stream = CallbackStream(stream);
@@ -74,8 +73,7 @@ sfFont* sfFont_createFromStream(sfInputStream* stream)
 ////////////////////////////////////////////////////////////
 sfFont* sfFont_copy(const sfFont* font)
 {
-    CSFML_CHECK_RETURN(font, nullptr);
-
+    assert(font);
     return new sfFont(*font);
 }
 
@@ -90,11 +88,11 @@ void sfFont_destroy(sfFont* font)
 ////////////////////////////////////////////////////////////
 sfGlyph sfFont_getGlyph(const sfFont* font, uint32_t codePoint, unsigned int characterSize, bool bold, float outlineThickness)
 {
-    sfGlyph glyph = {0, {{0, 0}, {0, 0}}, {{0, 0}, {0, 0}}};
-    CSFML_CHECK_RETURN(font, glyph);
+    assert(font);
 
     sf::Glyph SFMLGlyph = font->This.getGlyph(codePoint, characterSize, bold, outlineThickness);
 
+    sfGlyph glyph{};
     glyph.advance     = SFMLGlyph.advance;
     glyph.bounds      = convertRect(SFMLGlyph.bounds);
     glyph.textureRect = convertRect(SFMLGlyph.textureRect);
@@ -106,49 +104,55 @@ sfGlyph sfFont_getGlyph(const sfFont* font, uint32_t codePoint, unsigned int cha
 ////////////////////////////////////////////////////////////
 bool sfFont_hasGlyph(const sfFont* font, uint32_t codePoint)
 {
-    CSFML_CALL_RETURN(font, hasGlyph(codePoint), false);
+    assert(font);
+    return font->This.hasGlyph(codePoint);
 }
 
 
 ////////////////////////////////////////////////////////////
 float sfFont_getKerning(const sfFont* font, uint32_t first, uint32_t second, unsigned int characterSize)
 {
-    CSFML_CALL_RETURN(font, getKerning(first, second, characterSize), 0);
+    assert(font);
+    return font->This.getKerning(first, second, characterSize);
 }
 
 
 ////////////////////////////////////////////////////////////
 float sfFont_getBoldKerning(const sfFont* font, uint32_t first, uint32_t second, unsigned int characterSize)
 {
-    CSFML_CALL_RETURN(font, getKerning(first, second, characterSize, true), 0);
+    assert(font);
+    return font->This.getKerning(first, second, characterSize, true);
 }
 
 
 ////////////////////////////////////////////////////////////
 float sfFont_getLineSpacing(const sfFont* font, unsigned int characterSize)
 {
-    CSFML_CALL_RETURN(font, getLineSpacing(characterSize), 0);
+    assert(font);
+    return font->This.getLineSpacing(characterSize);
 }
 
 
 ////////////////////////////////////////////////////////////
 float sfFont_getUnderlinePosition(const sfFont* font, unsigned int characterSize)
 {
-    CSFML_CALL_RETURN(font, getUnderlinePosition(characterSize), 0)
+    assert(font);
+    return font->This.getUnderlinePosition(characterSize);
 }
 
 
 ////////////////////////////////////////////////////////////
 float sfFont_getUnderlineThickness(const sfFont* font, unsigned int characterSize)
 {
-    CSFML_CALL_RETURN(font, getUnderlineThickness(characterSize), 0)
+    assert(font);
+    return font->This.getUnderlineThickness(characterSize);
 }
 
 
 ////////////////////////////////////////////////////////////
 const sfTexture* sfFont_getTexture(sfFont* font, unsigned int characterSize)
 {
-    CSFML_CHECK_RETURN(font, nullptr);
+    assert(font);
 
     *font->Textures[characterSize].This = font->This.getTexture(characterSize);
 
@@ -173,10 +177,6 @@ bool sfFont_isSmooth(const sfFont* font)
 ////////////////////////////////////////////////////////////
 sfFontInfo sfFont_getInfo(const sfFont* font)
 {
-    sfFontInfo info = {nullptr};
-    CSFML_CHECK_RETURN(font, info);
-
-    info.family = font->This.getInfo().family.c_str();
-
-    return info;
+    assert(font);
+    return {font->This.getInfo().family.c_str()};
 }

src/CSFML/Graphics/Image.cpp

@@ -30,7 +30,6 @@
 #include <CSFML/Graphics/ConvertRect.hpp>
 #include <CSFML/Graphics/Image.h>
 #include <CSFML/Graphics/ImageStruct.hpp>
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/BufferStruct.hpp>
 #include <CSFML/System/ConvertVector2.hpp>
 
@@ -81,7 +80,7 @@ sfImage* sfImage_createFromMemory(const void* data, size_t sizeInBytes)
 ////////////////////////////////////////////////////////////
 sfImage* sfImage_createFromStream(sfInputStream* stream)
 {
-    CSFML_CHECK_RETURN(stream, nullptr);
+    assert(stream);
 
     CallbackStream sfmlStream(stream);
     sf::Image      image;
@@ -95,8 +94,7 @@ sfImage* sfImage_createFromStream(sfInputStream* stream)
 ////////////////////////////////////////////////////////////
 sfImage* sfImage_copy(const sfImage* image)
 {
-    CSFML_CHECK_RETURN(image, nullptr);
-
+    assert(image);
     return new sfImage(*image);
 }
 
@@ -111,15 +109,16 @@ void sfImage_destroy(sfImage* image)
 ////////////////////////////////////////////////////////////
 bool sfImage_saveToFile(const sfImage* image, const char* filename)
 {
-    CSFML_CALL_RETURN(image, saveToFile(filename), false);
+    assert(image);
+    return image->This.saveToFile(filename);
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfImage_saveToMemory(const sfImage* image, sfBuffer* output, const char* format)
 {
-    CSFML_CHECK_RETURN(output, false);
-    CSFML_CHECK_RETURN(image, false);
+    assert(image);
+    assert(output);
 
     auto data = image->This.saveToMemory(format);
 
@@ -136,16 +135,16 @@ bool sfImage_saveToMemory(const sfImage* image, sfBuffer* output, const char* fo
 ////////////////////////////////////////////////////////////
 void sfImage_createMaskFromColor(sfImage* image, sfColor colorKey, uint8_t alpha)
 {
-    CSFML_CALL(image, createMaskFromColor(convertColor(colorKey), alpha));
+    assert(image);
+    image->This.createMaskFromColor(convertColor(colorKey), alpha);
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfImage_copyImage(sfImage* image, const sfImage* source, sfVector2u dest, sfIntRect sourceRect, bool applyAlpha)
 {
-    CSFML_CHECK_RETURN(image, false);
-    CSFML_CHECK_RETURN(source, false);
-
+    assert(image);
+    assert(source);
     return image->This.copy(source->This, convertVector2(dest), convertRect(sourceRect), applyAlpha);
 }
 
@@ -153,15 +152,15 @@ bool sfImage_copyImage(sfImage* image, const sfImage* source, sfVector2u dest, s
 ////////////////////////////////////////////////////////////
 void sfImage_setPixel(sfImage* image, sfVector2u coords, sfColor color)
 {
-    CSFML_CALL(image, setPixel(convertVector2(coords), convertColor(color)));
+    assert(image);
+    image->This.setPixel(convertVector2(coords), convertColor(color));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfColor sfImage_getPixel(const sfImage* image, sfVector2u coords)
 {
-    CSFML_CHECK_RETURN(image, {});
-
+    assert(image);
     return convertColor(image->This.getPixel(convertVector2(coords)));
 }
 
@@ -169,15 +168,15 @@ sfColor sfImage_getPixel(const sfImage* image, sfVector2u coords)
 ////////////////////////////////////////////////////////////
 const uint8_t* sfImage_getPixelsPtr(const sfImage* image)
 {
-    CSFML_CALL_RETURN(image, getPixelsPtr(), nullptr);
+    assert(image);
+    return image->This.getPixelsPtr();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2u sfImage_getSize(const sfImage* image)
 {
-    CSFML_CHECK_RETURN(image, {});
-
+    assert(image);
     return convertVector2(image->This.getSize());
 }
 
@@ -185,12 +184,14 @@ sfVector2u sfImage_getSize(const sfImage* image)
 ////////////////////////////////////////////////////////////
 void sfImage_flipHorizontally(sfImage* image)
 {
-    CSFML_CALL(image, flipHorizontally());
+    assert(image);
+    image->This.flipHorizontally();
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfImage_flipVertically(sfImage* image)
 {
-    CSFML_CALL(image, flipVertically());
+    assert(image);
+    image->This.flipVertically();
 }

src/CSFML/Graphics/Rect.cpp

@@ -27,7 +27,6 @@
 ////////////////////////////////////////////////////////////
 #include <CSFML/Graphics/ConvertRect.hpp>
 #include <CSFML/Graphics/Rect.h>
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/ConvertVector2.hpp>
 
 #include <SFML/Graphics/Rect.hpp>
@@ -38,12 +37,12 @@
 ////////////////////////////////////////////////////////////
 bool sfFloatRect_contains(const sfFloatRect* rect, sfVector2f point)
 {
-    CSFML_CHECK_RETURN(rect, false);
+    assert(rect);
     return convertRect(*rect).contains(convertVector2(point));
 }
 bool sfIntRect_contains(const sfIntRect* rect, sfVector2i point)
 {
-    CSFML_CHECK_RETURN(rect, false);
+    assert(rect);
     return convertRect(*rect).contains(convertVector2(point));
 }
 
@@ -53,8 +52,8 @@ bool sfIntRect_contains(const sfIntRect* rect, sfVector2i point)
 ////////////////////////////////////////////////////////////
 bool sfFloatRect_intersects(const sfFloatRect* rect1, const sfFloatRect* rect2, sfFloatRect* intersection)
 {
-    CSFML_CHECK_RETURN(rect1, false);
-    CSFML_CHECK_RETURN(rect2, false);
+    assert(rect1);
+    assert(rect2);
 
     const std::optional overlap = convertRect(*rect1).findIntersection(convertRect(*rect2));
 
@@ -65,8 +64,8 @@ bool sfFloatRect_intersects(const sfFloatRect* rect1, const sfFloatRect* rect2,
 }
 bool sfIntRect_intersects(const sfIntRect* rect1, const sfIntRect* rect2, sfIntRect* intersection)
 {
-    CSFML_CHECK_RETURN(rect1, false);
-    CSFML_CHECK_RETURN(rect2, false);
+    assert(rect1);
+    assert(rect2);
 
     const std::optional overlap = convertRect(*rect1).findIntersection(convertRect(*rect2));
 

src/CSFML/Graphics/RectangleShape.cpp

@@ -30,7 +30,6 @@
 #include <CSFML/Graphics/ConvertTransform.hpp>
 #include <CSFML/Graphics/RectangleShape.h>
 #include <CSFML/Graphics/RectangleShapeStruct.hpp>
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/ConvertVector2.hpp>
 
 #include <SFML/Graphics/Color.hpp>
@@ -46,8 +45,7 @@ sfRectangleShape* sfRectangleShape_create()
 ////////////////////////////////////////////////////////////
 sfRectangleShape* sfRectangleShape_copy(const sfRectangleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, nullptr);
-
+    assert(shape);
     return new sfRectangleShape(*shape);
 }
 
@@ -62,36 +60,39 @@ void sfRectangleShape_destroy(sfRectangleShape* shape)
 ////////////////////////////////////////////////////////////
 void sfRectangleShape_setPosition(sfRectangleShape* shape, sfVector2f position)
 {
-    CSFML_CALL(shape, setPosition(convertVector2(position)));
+    assert(shape);
+    shape->This.setPosition(convertVector2(position));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRectangleShape_setRotation(sfRectangleShape* shape, float angle)
 {
-    CSFML_CALL(shape, setRotation(sf::degrees(angle)));
+    assert(shape);
+    shape->This.setRotation(sf::degrees(angle));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRectangleShape_setScale(sfRectangleShape* shape, sfVector2f scale)
 {
-    CSFML_CALL(shape, setScale(convertVector2(scale)));
+    assert(shape);
+    shape->This.setScale(convertVector2(scale));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRectangleShape_setOrigin(sfRectangleShape* shape, sfVector2f origin)
 {
-    CSFML_CALL(shape, setOrigin(convertVector2(origin)));
+    assert(shape);
+    shape->This.setOrigin(convertVector2(origin));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2f sfRectangleShape_getPosition(const sfRectangleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertVector2(shape->This.getPosition());
 }
 
@@ -99,15 +100,15 @@ sfVector2f sfRectangleShape_getPosition(const sfRectangleShape* shape)
 ////////////////////////////////////////////////////////////
 float sfRectangleShape_getRotation(const sfRectangleShape* shape)
 {
-    CSFML_CALL_RETURN(shape, getRotation().asDegrees(), 0.f);
+    assert(shape);
+    return shape->This.getRotation().asDegrees();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2f sfRectangleShape_getScale(const sfRectangleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertVector2(shape->This.getScale());
 }
 
@@ -115,8 +116,7 @@ sfVector2f sfRectangleShape_getScale(const sfRectangleShape* shape)
 ////////////////////////////////////////////////////////////
 sfVector2f sfRectangleShape_getOrigin(const sfRectangleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertVector2(shape->This.getOrigin());
 }
 
@@ -124,29 +124,31 @@ sfVector2f sfRectangleShape_getOrigin(const sfRectangleShape* shape)
 ////////////////////////////////////////////////////////////
 void sfRectangleShape_move(sfRectangleShape* shape, sfVector2f offset)
 {
-    CSFML_CALL(shape, move(convertVector2(offset)));
+    assert(shape);
+    shape->This.move(convertVector2(offset));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRectangleShape_rotate(sfRectangleShape* shape, float angle)
 {
-    CSFML_CALL(shape, rotate(sf::degrees(angle)));
+    assert(shape);
+    shape->This.rotate(sf::degrees(angle));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRectangleShape_scale(sfRectangleShape* shape, sfVector2f factors)
 {
-    CSFML_CALL(shape, scale(convertVector2(factors)));
+    assert(shape);
+    shape->This.scale(convertVector2(factors));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfTransform sfRectangleShape_getTransform(const sfRectangleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, sfTransform_Identity);
-
+    assert(shape);
     shape->Transform = convertTransform(shape->This.getTransform());
     return shape->Transform;
 }
@@ -155,8 +157,7 @@ sfTransform sfRectangleShape_getTransform(const sfRectangleShape* shape)
 ////////////////////////////////////////////////////////////
 sfTransform sfRectangleShape_getInverseTransform(const sfRectangleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, sfTransform_Identity);
-
+    assert(shape);
     shape->InverseTransform = convertTransform(shape->This.getInverseTransform());
     return shape->InverseTransform;
 }
@@ -165,7 +166,8 @@ sfTransform sfRectangleShape_getInverseTransform(const sfRectangleShape* shape)
 ////////////////////////////////////////////////////////////
 void sfRectangleShape_setTexture(sfRectangleShape* shape, const sfTexture* texture, bool resetRect)
 {
-    CSFML_CALL(shape, setTexture(texture ? texture->This : nullptr, resetRect));
+    assert(shape);
+    shape->This.setTexture(texture ? texture->This : nullptr, resetRect);
     shape->Texture = texture;
 }
 
@@ -173,36 +175,39 @@ void sfRectangleShape_setTexture(sfRectangleShape* shape, const sfTexture* textu
 ////////////////////////////////////////////////////////////
 void sfRectangleShape_setTextureRect(sfRectangleShape* shape, sfIntRect rect)
 {
-    CSFML_CALL(shape, setTextureRect(convertRect(rect)));
+    assert(shape);
+    shape->This.setTextureRect(convertRect(rect));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRectangleShape_setFillColor(sfRectangleShape* shape, sfColor color)
 {
-    CSFML_CALL(shape, setFillColor(convertColor(color)));
+    assert(shape);
+    shape->This.setFillColor(convertColor(color));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRectangleShape_setOutlineColor(sfRectangleShape* shape, sfColor color)
 {
-    CSFML_CALL(shape, setOutlineColor(convertColor(color)));
+    assert(shape);
+    shape->This.setOutlineColor(convertColor(color));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRectangleShape_setOutlineThickness(sfRectangleShape* shape, float thickness)
 {
-    CSFML_CALL(shape, setOutlineThickness(thickness));
+    assert(shape);
+    shape->This.setOutlineThickness(thickness);
 }
 
 
 ////////////////////////////////////////////////////////////
 const sfTexture* sfRectangleShape_getTexture(const sfRectangleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, nullptr);
-
+    assert(shape);
     return shape->Texture;
 }
 
@@ -210,8 +215,7 @@ const sfTexture* sfRectangleShape_getTexture(const sfRectangleShape* shape)
 ////////////////////////////////////////////////////////////
 sfIntRect sfRectangleShape_getTextureRect(const sfRectangleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertRect(shape->This.getTextureRect());
 }
 
@@ -219,8 +223,7 @@ sfIntRect sfRectangleShape_getTextureRect(const sfRectangleShape* shape)
 ////////////////////////////////////////////////////////////
 sfColor sfRectangleShape_getFillColor(const sfRectangleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertColor(shape->This.getFillColor());
 }
 
@@ -228,8 +231,7 @@ sfColor sfRectangleShape_getFillColor(const sfRectangleShape* shape)
 ////////////////////////////////////////////////////////////
 sfColor sfRectangleShape_getOutlineColor(const sfRectangleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertColor(shape->This.getOutlineColor());
 }
 
@@ -237,22 +239,23 @@ sfColor sfRectangleShape_getOutlineColor(const sfRectangleShape* shape)
 ////////////////////////////////////////////////////////////
 float sfRectangleShape_getOutlineThickness(const sfRectangleShape* shape)
 {
-    CSFML_CALL_RETURN(shape, getOutlineThickness(), 0.f);
+    assert(shape);
+    return shape->This.getOutlineThickness();
 }
 
 
 ////////////////////////////////////////////////////////////
 size_t sfRectangleShape_getPointCount(const sfRectangleShape* shape)
 {
-    CSFML_CALL_RETURN(shape, getPointCount(), 0);
+    assert(shape);
+    return shape->This.getPointCount();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2f sfRectangleShape_getPoint(const sfRectangleShape* shape, size_t index)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertVector2(shape->This.getPoint(index));
 }
 
@@ -260,15 +263,15 @@ sfVector2f sfRectangleShape_getPoint(const sfRectangleShape* shape, size_t index
 ////////////////////////////////////////////////////////////
 void sfRectangleShape_setSize(sfRectangleShape* shape, sfVector2f size)
 {
-    CSFML_CALL(shape, setSize(convertVector2(size)));
+    assert(shape);
+    shape->This.setSize(convertVector2(size));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2f sfRectangleShape_getSize(const sfRectangleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertVector2(shape->This.getSize());
 }
 
@@ -276,8 +279,7 @@ sfVector2f sfRectangleShape_getSize(const sfRectangleShape* shape)
 ////////////////////////////////////////////////////////////
 sfFloatRect sfRectangleShape_getLocalBounds(const sfRectangleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertRect(shape->This.getLocalBounds());
 }
 
@@ -285,7 +287,6 @@ sfFloatRect sfRectangleShape_getLocalBounds(const sfRectangleShape* shape)
 ////////////////////////////////////////////////////////////
 sfFloatRect sfRectangleShape_getGlobalBounds(const sfRectangleShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertRect(shape->This.getGlobalBounds());
 }

src/CSFML/Graphics/RenderTexture.cpp

@@ -38,7 +38,6 @@
 #include <CSFML/Graphics/TextStruct.hpp>
 #include <CSFML/Graphics/VertexArrayStruct.hpp>
 #include <CSFML/Graphics/VertexBufferStruct.hpp>
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/ConvertVector2.hpp>
 #include <CSFML/Window/ConvertContextSettings.hpp>
 
@@ -73,8 +72,7 @@ void sfRenderTexture_destroy(sfRenderTexture* renderTexture)
 ////////////////////////////////////////////////////////////
 sfVector2u sfRenderTexture_getSize(const sfRenderTexture* renderTexture)
 {
-    CSFML_CHECK_RETURN(renderTexture, {});
-
+    assert(renderTexture);
     return convertVector2(renderTexture->This.getSize());
 }
 
@@ -82,7 +80,7 @@ sfVector2u sfRenderTexture_getSize(const sfRenderTexture* renderTexture)
 ////////////////////////////////////////////////////////////
 bool sfRenderTexture_isSrgb(const sfRenderTexture* renderTexture)
 {
-    CSFML_CHECK_RETURN(renderTexture, false);
+    assert(renderTexture);
     return renderTexture->This.isSrgb();
 }
 
@@ -90,29 +88,33 @@ bool sfRenderTexture_isSrgb(const sfRenderTexture* renderTexture)
 ////////////////////////////////////////////////////////////
 bool sfRenderTexture_setActive(sfRenderTexture* renderTexture, bool active)
 {
-    CSFML_CALL_RETURN(renderTexture, setActive(active), false);
+    assert(renderTexture);
+    return renderTexture->This.setActive(active);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderTexture_display(sfRenderTexture* renderTexture)
 {
-    CSFML_CALL(renderTexture, display());
+    assert(renderTexture);
+    renderTexture->This.display();
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderTexture_clear(sfRenderTexture* renderTexture, sfColor color)
 {
-    CSFML_CALL(renderTexture, clear(convertColor(color)));
+    assert(renderTexture);
+    renderTexture->This.clear(convertColor(color));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderTexture_setView(sfRenderTexture* renderTexture, const sfView* view)
 {
-    CSFML_CHECK(view);
-    CSFML_CALL(renderTexture, setView(view->This));
+    assert(renderTexture);
+    assert(view);
+    renderTexture->This.setView(view->This);
     renderTexture->CurrentView.This = view->This;
 }
 
@@ -120,8 +122,7 @@ void sfRenderTexture_setView(sfRenderTexture* renderTexture, const sfView* view)
 ////////////////////////////////////////////////////////////
 const sfView* sfRenderTexture_getView(const sfRenderTexture* renderTexture)
 {
-    CSFML_CHECK_RETURN(renderTexture, nullptr);
-
+    assert(renderTexture);
     return &renderTexture->CurrentView;
 }
 
@@ -129,8 +130,7 @@ const sfView* sfRenderTexture_getView(const sfRenderTexture* renderTexture)
 ////////////////////////////////////////////////////////////
 const sfView* sfRenderTexture_getDefaultView(const sfRenderTexture* renderTexture)
 {
-    CSFML_CHECK_RETURN(renderTexture, nullptr);
-
+    assert(renderTexture);
     return &renderTexture->DefaultView;
 }
 
@@ -138,9 +138,8 @@ const sfView* sfRenderTexture_getDefaultView(const sfRenderTexture* renderTextur
 ////////////////////////////////////////////////////////////
 sfIntRect sfRenderTexture_getViewport(const sfRenderTexture* renderTexture, const sfView* view)
 {
-    CSFML_CHECK_RETURN(view, {});
-    CSFML_CHECK_RETURN(renderTexture, {});
-
+    assert(renderTexture);
+    assert(view);
     return convertRect(renderTexture->This.getViewport(view->This));
 }
 
@@ -148,7 +147,7 @@ sfIntRect sfRenderTexture_getViewport(const sfRenderTexture* renderTexture, cons
 ////////////////////////////////////////////////////////////
 sfVector2f sfRenderTexture_mapPixelToCoords(const sfRenderTexture* renderTexture, sfVector2i point, const sfView* targetView)
 {
-    CSFML_CHECK_RETURN(renderTexture, {});
+    assert(renderTexture);
 
     if (targetView)
         return convertVector2(renderTexture->This.mapPixelToCoords(convertVector2(point), targetView->This));
@@ -160,7 +159,7 @@ sfVector2f sfRenderTexture_mapPixelToCoords(const sfRenderTexture* renderTexture
 ////////////////////////////////////////////////////////////
 sfVector2i sfRenderTexture_mapCoordsToPixel(const sfRenderTexture* renderTexture, sfVector2f point, const sfView* targetView)
 {
-    CSFML_CHECK_RETURN(renderTexture, {});
+    assert(renderTexture);
 
     if (targetView)
         return convertVector2(renderTexture->This.mapCoordsToPixel(convertVector2(point), targetView->This));
@@ -172,43 +171,51 @@ sfVector2i sfRenderTexture_mapCoordsToPixel(const sfRenderTexture* renderTexture
 ////////////////////////////////////////////////////////////
 void sfRenderTexture_drawSprite(sfRenderTexture* renderTexture, const sfSprite* object, const sfRenderStates* states)
 {
-    CSFML_CHECK(object);
-    CSFML_CALL(renderTexture, draw(object->This, convertRenderStates(states)));
+    assert(renderTexture);
+    assert(object);
+    renderTexture->This.draw(object->This, convertRenderStates(states));
 }
 void sfRenderTexture_drawText(sfRenderTexture* renderTexture, const sfText* object, const sfRenderStates* states)
 {
-    CSFML_CHECK(object);
-    CSFML_CALL(renderTexture, draw(object->This, convertRenderStates(states)));
+    assert(renderTexture);
+    assert(object);
+    renderTexture->This.draw(object->This, convertRenderStates(states));
 }
 void sfRenderTexture_drawShape(sfRenderTexture* renderTexture, const sfShape* object, const sfRenderStates* states)
 {
-    CSFML_CHECK(object);
-    CSFML_CALL(renderTexture, draw(object->This, convertRenderStates(states)));
+    assert(renderTexture);
+    assert(object);
+    renderTexture->This.draw(object->This, convertRenderStates(states));
 }
 void sfRenderTexture_drawCircleShape(sfRenderTexture* renderTexture, const sfCircleShape* object, const sfRenderStates* states)
 {
-    CSFML_CHECK(object);
-    CSFML_CALL(renderTexture, draw(object->This, convertRenderStates(states)));
+    assert(renderTexture);
+    assert(object);
+    renderTexture->This.draw(object->This, convertRenderStates(states));
 }
 void sfRenderTexture_drawConvexShape(sfRenderTexture* renderTexture, const sfConvexShape* object, const sfRenderStates* states)
 {
-    CSFML_CHECK(object);
-    CSFML_CALL(renderTexture, draw(object->This, convertRenderStates(states)));
+    assert(renderTexture);
+    assert(object);
+    renderTexture->This.draw(object->This, convertRenderStates(states));
 }
 void sfRenderTexture_drawRectangleShape(sfRenderTexture* renderTexture, const sfRectangleShape* object, const sfRenderStates* states)
 {
-    CSFML_CHECK(object);
-    CSFML_CALL(renderTexture, draw(object->This, convertRenderStates(states)));
+    assert(renderTexture);
+    assert(object);
+    renderTexture->This.draw(object->This, convertRenderStates(states));
 }
 void sfRenderTexture_drawVertexArray(sfRenderTexture* renderTexture, const sfVertexArray* object, const sfRenderStates* states)
 {
-    CSFML_CHECK(object);
-    CSFML_CALL(renderTexture, draw(object->This, convertRenderStates(states)));
+    assert(renderTexture);
+    assert(object);
+    renderTexture->This.draw(object->This, convertRenderStates(states));
 }
 void sfRenderTexture_drawVertexBuffer(sfRenderTexture* renderTexture, const sfVertexBuffer* object, const sfRenderStates* states)
 {
-    CSFML_CHECK(object);
-    CSFML_CALL(renderTexture, draw(object->This, convertRenderStates(states)));
+    assert(renderTexture);
+    assert(object);
+    renderTexture->This.draw(object->This, convertRenderStates(states));
 }
 
 
@@ -219,8 +226,9 @@ void sfRenderTexture_drawVertexBufferRange(sfRenderTexture*      renderTexture,
                                            size_t                vertexCount,
                                            const sfRenderStates* states)
 {
-    CSFML_CHECK(object);
-    CSFML_CALL(renderTexture, draw(object->This, firstVertex, vertexCount, convertRenderStates(states)));
+    assert(renderTexture);
+    assert(object);
+    renderTexture->This.draw(object->This, firstVertex, vertexCount, convertRenderStates(states));
 }
 
 
@@ -231,40 +239,42 @@ void sfRenderTexture_drawPrimitives(sfRenderTexture*      renderTexture,
                                     sfPrimitiveType       type,
                                     const sfRenderStates* states)
 {
-    CSFML_CALL(renderTexture,
-               draw(reinterpret_cast<const sf::Vertex*>(vertices),
-                    vertexCount,
-                    static_cast<sf::PrimitiveType>(type),
-                    convertRenderStates(states)));
+    assert(renderTexture);
+    renderTexture->This.draw(reinterpret_cast<const sf::Vertex*>(vertices),
+                             vertexCount,
+                             static_cast<sf::PrimitiveType>(type),
+                             convertRenderStates(states));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderTexture_pushGLStates(sfRenderTexture* renderTexture)
 {
-    CSFML_CALL(renderTexture, pushGLStates());
+    assert(renderTexture);
+    renderTexture->This.pushGLStates();
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderTexture_popGLStates(sfRenderTexture* renderTexture)
 {
-    CSFML_CALL(renderTexture, popGLStates());
+    assert(renderTexture);
+    renderTexture->This.popGLStates();
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderTexture_resetGLStates(sfRenderTexture* renderTexture)
 {
-    CSFML_CALL(renderTexture, resetGLStates());
+    assert(renderTexture);
+    renderTexture->This.resetGLStates();
 }
 
 
 ////////////////////////////////////////////////////////////
 const sfTexture* sfRenderTexture_getTexture(const sfRenderTexture* renderTexture)
 {
-    CSFML_CHECK_RETURN(renderTexture, nullptr);
-
+    assert(renderTexture);
     return renderTexture->Target;
 }
 
@@ -272,7 +282,8 @@ const sfTexture* sfRenderTexture_getTexture(const sfRenderTexture* renderTexture
 ////////////////////////////////////////////////////////////
 void sfRenderTexture_setSmooth(sfRenderTexture* renderTexture, bool smooth)
 {
-    CSFML_CALL(renderTexture, setSmooth(smooth));
+    assert(renderTexture);
+    renderTexture->This.setSmooth(smooth);
 }
 
 
@@ -286,25 +297,29 @@ unsigned int sfRenderTexture_getMaximumAntialiasingLevel()
 ////////////////////////////////////////////////////////////
 bool sfRenderTexture_isSmooth(const sfRenderTexture* renderTexture)
 {
-    CSFML_CALL_RETURN(renderTexture, isSmooth(), false);
+    assert(renderTexture);
+    return renderTexture->This.isSmooth();
 }
 
 ////////////////////////////////////////////////////////////
 void sfRenderTexture_setRepeated(sfRenderTexture* renderTexture, bool repeated)
 {
-    CSFML_CALL(renderTexture, setRepeated(repeated));
+    assert(renderTexture);
+    renderTexture->This.setRepeated(repeated);
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfRenderTexture_isRepeated(const sfRenderTexture* renderTexture)
 {
-    CSFML_CALL_RETURN(renderTexture, isRepeated(), false);
+    assert(renderTexture);
+    return renderTexture->This.isRepeated();
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfRenderTexture_generateMipmap(sfRenderTexture* renderTexture)
 {
-    CSFML_CALL_RETURN(renderTexture, generateMipmap(), false);
+    assert(renderTexture);
+    return renderTexture->This.generateMipmap();
 }

src/CSFML/Graphics/RenderWindow.cpp

@@ -40,7 +40,6 @@
 #include <CSFML/Graphics/TextStruct.hpp>
 #include <CSFML/Graphics/VertexArrayStruct.hpp>
 #include <CSFML/Graphics/VertexBufferStruct.hpp>
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/ConvertVector2.hpp>
 #include <CSFML/Window/ConvertContextSettings.hpp>
 #include <CSFML/Window/ConvertVideoMode.hpp>
@@ -119,22 +118,23 @@ void sfRenderWindow_destroy(sfRenderWindow* renderWindow)
 ////////////////////////////////////////////////////////////
 void sfRenderWindow_close(sfRenderWindow* renderWindow)
 {
-    CSFML_CALL(renderWindow, close());
+    assert(renderWindow);
+    renderWindow->This.close();
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfRenderWindow_isOpen(const sfRenderWindow* renderWindow)
 {
-    CSFML_CALL_RETURN(renderWindow, isOpen(), false);
+    assert(renderWindow);
+    return renderWindow->This.isOpen();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfContextSettings sfRenderWindow_getSettings(const sfRenderWindow* renderWindow)
 {
-    CSFML_CHECK_RETURN(renderWindow, sfContextSettings{});
-
+    assert(renderWindow);
     return convertContextSettings(renderWindow->This.getSettings());
 }
 
@@ -142,8 +142,8 @@ sfContextSettings sfRenderWindow_getSettings(const sfRenderWindow* renderWindow)
 ////////////////////////////////////////////////////////////
 bool sfRenderWindow_pollEvent(sfRenderWindow* renderWindow, sfEvent* event)
 {
-    CSFML_CHECK_RETURN(renderWindow, false);
-    CSFML_CHECK_RETURN(event, false);
+    assert(renderWindow);
+    assert(event);
 
     // Get the event
     const std::optional sfmlEvent = renderWindow->This.pollEvent();
@@ -162,8 +162,8 @@ bool sfRenderWindow_pollEvent(sfRenderWindow* renderWindow, sfEvent* event)
 ////////////////////////////////////////////////////////////
 bool sfRenderWindow_waitEvent(sfRenderWindow* renderWindow, sfEvent* event)
 {
-    CSFML_CHECK_RETURN(renderWindow, false);
-    CSFML_CHECK_RETURN(event, false);
+    assert(renderWindow);
+    assert(event);
 
     // Get the event
     const std::optional sfmlEvent = renderWindow->This.waitEvent();
@@ -182,25 +182,23 @@ bool sfRenderWindow_waitEvent(sfRenderWindow* renderWindow, sfEvent* event)
 ////////////////////////////////////////////////////////////
 sfVector2i sfRenderWindow_getPosition(const sfRenderWindow* renderWindow)
 {
-    CSFML_CHECK_RETURN(renderWindow, {});
-
+    assert(renderWindow);
     return convertVector2(renderWindow->This.getPosition());
-    ;
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderWindow_setPosition(sfRenderWindow* renderWindow, sfVector2i position)
 {
-    CSFML_CALL(renderWindow, setPosition(convertVector2(position)));
+    assert(renderWindow);
+    renderWindow->This.setPosition(convertVector2(position));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2u sfRenderWindow_getSize(const sfRenderWindow* renderWindow)
 {
-    CSFML_CHECK_RETURN(renderWindow, {});
-
+    assert(renderWindow);
     return convertVector2(renderWindow->This.getSize());
 }
 
@@ -208,7 +206,7 @@ sfVector2u sfRenderWindow_getSize(const sfRenderWindow* renderWindow)
 ////////////////////////////////////////////////////////////
 bool sfRenderWindow_isSrgb(const sfRenderWindow* renderWindow)
 {
-    CSFML_CHECK_RETURN(renderWindow, false);
+    assert(renderWindow);
     return renderWindow->This.isSrgb();
 }
 
@@ -216,122 +214,136 @@ bool sfRenderWindow_isSrgb(const sfRenderWindow* renderWindow)
 ////////////////////////////////////////////////////////////
 void sfRenderWindow_setSize(sfRenderWindow* renderWindow, sfVector2u size)
 {
-    CSFML_CALL(renderWindow, setSize(convertVector2(size)));
+    assert(renderWindow);
+    renderWindow->This.setSize(convertVector2(size));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderWindow_setTitle(sfRenderWindow* renderWindow, const char* title)
 {
-    CSFML_CALL(renderWindow, setTitle(title));
+    assert(renderWindow);
+    renderWindow->This.setTitle(title);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderWindow_setUnicodeTitle(sfRenderWindow* renderWindow, const sfChar32* title)
 {
-    CSFML_CALL(renderWindow, setTitle(reinterpret_cast<const char32_t*>(title)));
+    assert(renderWindow);
+    renderWindow->This.setTitle(reinterpret_cast<const char32_t*>(title));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderWindow_setIcon(sfRenderWindow* renderWindow, sfVector2u size, const uint8_t* pixels)
 {
-    CSFML_CALL(renderWindow, setIcon(convertVector2(size), pixels));
+    assert(renderWindow);
+    renderWindow->This.setIcon(convertVector2(size), pixels);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderWindow_setVisible(sfRenderWindow* renderWindow, bool visible)
 {
-    CSFML_CALL(renderWindow, setVisible(visible));
+    assert(renderWindow);
+    renderWindow->This.setVisible(visible);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderWindow_setVerticalSyncEnabled(sfRenderWindow* renderWindow, bool enabled)
 {
-    CSFML_CALL(renderWindow, setVerticalSyncEnabled(enabled));
+    assert(renderWindow);
+    renderWindow->This.setVerticalSyncEnabled(enabled);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderWindow_setMouseCursorVisible(sfRenderWindow* renderWindow, bool visible)
 {
-    CSFML_CALL(renderWindow, setMouseCursorVisible(visible));
+    assert(renderWindow);
+    renderWindow->This.setMouseCursorVisible(visible);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderWindow_setMouseCursorGrabbed(sfRenderWindow* renderWindow, bool grabbed)
 {
-    CSFML_CALL(renderWindow, setMouseCursorGrabbed(grabbed));
+    assert(renderWindow);
+    renderWindow->This.setMouseCursorGrabbed(grabbed);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderWindow_setMouseCursor(sfRenderWindow* window, const sfCursor* cursor)
 {
-    CSFML_CHECK(cursor);
-
-    CSFML_CALL(window, setMouseCursor(cursor->This));
+    assert(window);
+    assert(cursor);
+    window->This.setMouseCursor(cursor->This);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderWindow_setKeyRepeatEnabled(sfRenderWindow* renderWindow, bool enabled)
 {
-    CSFML_CALL(renderWindow, setKeyRepeatEnabled(enabled));
+    assert(renderWindow);
+    renderWindow->This.setKeyRepeatEnabled(enabled);
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfRenderWindow_setActive(sfRenderWindow* renderWindow, bool active)
 {
-    CSFML_CALL_RETURN(renderWindow, setActive(active), false);
+    assert(renderWindow);
+    return renderWindow->This.setActive(active);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderWindow_requestFocus(sfRenderWindow* renderWindow)
 {
-    CSFML_CALL(renderWindow, requestFocus());
+    assert(renderWindow);
+    renderWindow->This.requestFocus();
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfRenderWindow_hasFocus(const sfRenderWindow* renderWindow)
 {
-    CSFML_CALL_RETURN(renderWindow, hasFocus(), false);
+    assert(renderWindow);
+    return renderWindow->This.hasFocus();
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderWindow_display(sfRenderWindow* renderWindow)
 {
-    CSFML_CALL(renderWindow, display());
+    assert(renderWindow);
+    renderWindow->This.display();
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderWindow_setFramerateLimit(sfRenderWindow* renderWindow, unsigned int limit)
 {
-    CSFML_CALL(renderWindow, setFramerateLimit(limit));
+    assert(renderWindow);
+    renderWindow->This.setFramerateLimit(limit);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderWindow_setJoystickThreshold(sfRenderWindow* renderWindow, float threshold)
 {
-    CSFML_CALL(renderWindow, setJoystickThreshold(threshold));
+    assert(renderWindow);
+    renderWindow->This.setJoystickThreshold(threshold);
 }
 
 
 ////////////////////////////////////////////////////////////
 sfWindowHandle sfRenderWindow_getNativeHandle(const sfRenderWindow* renderWindow)
 {
-    CSFML_CHECK_RETURN(renderWindow, 0);
-
+    assert(renderWindow);
     return static_cast<sfWindowHandle>(renderWindow->This.getNativeHandle());
 }
 
@@ -339,15 +351,17 @@ sfWindowHandle sfRenderWindow_getNativeHandle(const sfRenderWindow* renderWindow
 ////////////////////////////////////////////////////////////
 void sfRenderWindow_clear(sfRenderWindow* renderWindow, sfColor color)
 {
-    CSFML_CALL(renderWindow, clear(convertColor(color)));
+    assert(renderWindow);
+    renderWindow->This.clear(convertColor(color));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderWindow_setView(sfRenderWindow* renderWindow, const sfView* view)
 {
-    CSFML_CHECK(view);
-    CSFML_CALL(renderWindow, setView(view->This));
+    assert(renderWindow);
+    assert(view);
+    renderWindow->This.setView(view->This);
     renderWindow->CurrentView.This = view->This;
 }
 
@@ -355,8 +369,7 @@ void sfRenderWindow_setView(sfRenderWindow* renderWindow, const sfView* view)
 ////////////////////////////////////////////////////////////
 const sfView* sfRenderWindow_getView(const sfRenderWindow* renderWindow)
 {
-    CSFML_CHECK_RETURN(renderWindow, nullptr);
-
+    assert(renderWindow);
     return &renderWindow->CurrentView;
 }
 
@@ -364,8 +377,7 @@ const sfView* sfRenderWindow_getView(const sfRenderWindow* renderWindow)
 ////////////////////////////////////////////////////////////
 const sfView* sfRenderWindow_getDefaultView(const sfRenderWindow* renderWindow)
 {
-    CSFML_CHECK_RETURN(renderWindow, nullptr);
-
+    assert(renderWindow);
     return &renderWindow->DefaultView;
 }
 
@@ -373,9 +385,8 @@ const sfView* sfRenderWindow_getDefaultView(const sfRenderWindow* renderWindow)
 ////////////////////////////////////////////////////////////
 sfIntRect sfRenderWindow_getViewport(const sfRenderWindow* renderWindow, const sfView* view)
 {
-    CSFML_CHECK_RETURN(view, {});
-    CSFML_CHECK_RETURN(renderWindow, {});
-
+    assert(renderWindow);
+    assert(view);
     return convertRect(renderWindow->This.getViewport(view->This));
 }
 
@@ -383,7 +394,7 @@ sfIntRect sfRenderWindow_getViewport(const sfRenderWindow* renderWindow, const s
 ////////////////////////////////////////////////////////////
 sfVector2f sfRenderWindow_mapPixelToCoords(const sfRenderWindow* renderWindow, sfVector2i point, const sfView* targetView)
 {
-    CSFML_CHECK_RETURN(renderWindow, {});
+    assert(renderWindow);
 
     if (targetView)
         return convertVector2(renderWindow->This.mapPixelToCoords(convertVector2(point), targetView->This));
@@ -395,7 +406,7 @@ sfVector2f sfRenderWindow_mapPixelToCoords(const sfRenderWindow* renderWindow, s
 ////////////////////////////////////////////////////////////
 sfVector2i sfRenderWindow_mapCoordsToPixel(const sfRenderWindow* renderWindow, sfVector2f point, const sfView* targetView)
 {
-    CSFML_CHECK_RETURN(renderWindow, {});
+    assert(renderWindow);
 
     if (targetView)
         return convertVector2(renderWindow->This.mapCoordsToPixel(convertVector2(point), targetView->This));
@@ -407,43 +418,51 @@ sfVector2i sfRenderWindow_mapCoordsToPixel(const sfRenderWindow* renderWindow, s
 ////////////////////////////////////////////////////////////
 void sfRenderWindow_drawSprite(sfRenderWindow* renderWindow, const sfSprite* object, const sfRenderStates* states)
 {
-    CSFML_CHECK(object);
-    CSFML_CALL(renderWindow, draw(object->This, convertRenderStates(states)));
+    assert(renderWindow);
+    assert(object);
+    renderWindow->This.draw(object->This, convertRenderStates(states));
 }
 void sfRenderWindow_drawText(sfRenderWindow* renderWindow, const sfText* object, const sfRenderStates* states)
 {
-    CSFML_CHECK(object);
-    CSFML_CALL(renderWindow, draw(object->This, convertRenderStates(states)));
+    assert(renderWindow);
+    assert(object);
+    renderWindow->This.draw(object->This, convertRenderStates(states));
 }
 void sfRenderWindow_drawShape(sfRenderWindow* renderWindow, const sfShape* object, const sfRenderStates* states)
 {
-    CSFML_CHECK(object);
-    CSFML_CALL(renderWindow, draw(object->This, convertRenderStates(states)));
+    assert(renderWindow);
+    assert(object);
+    renderWindow->This.draw(object->This, convertRenderStates(states));
 }
 void sfRenderWindow_drawCircleShape(sfRenderWindow* renderWindow, const sfCircleShape* object, const sfRenderStates* states)
 {
-    CSFML_CHECK(object);
-    CSFML_CALL(renderWindow, draw(object->This, convertRenderStates(states)));
+    assert(renderWindow);
+    assert(object);
+    renderWindow->This.draw(object->This, convertRenderStates(states));
 }
 void sfRenderWindow_drawConvexShape(sfRenderWindow* renderWindow, const sfConvexShape* object, const sfRenderStates* states)
 {
-    CSFML_CHECK(object);
-    CSFML_CALL(renderWindow, draw(object->This, convertRenderStates(states)));
+    assert(renderWindow);
+    assert(object);
+    renderWindow->This.draw(object->This, convertRenderStates(states));
 }
 void sfRenderWindow_drawRectangleShape(sfRenderWindow* renderWindow, const sfRectangleShape* object, const sfRenderStates* states)
 {
-    CSFML_CHECK(object);
-    CSFML_CALL(renderWindow, draw(object->This, convertRenderStates(states)));
+    assert(renderWindow);
+    assert(object);
+    renderWindow->This.draw(object->This, convertRenderStates(states));
 }
 void sfRenderWindow_drawVertexArray(sfRenderWindow* renderWindow, const sfVertexArray* object, const sfRenderStates* states)
 {
-    CSFML_CHECK(object);
-    CSFML_CALL(renderWindow, draw(object->This, convertRenderStates(states)));
+    assert(renderWindow);
+    assert(object);
+    renderWindow->This.draw(object->This, convertRenderStates(states));
 }
 void sfRenderWindow_drawVertexBuffer(sfRenderWindow* renderWindow, const sfVertexBuffer* object, const sfRenderStates* states)
 {
-    CSFML_CHECK(object);
-    CSFML_CALL(renderWindow, draw(object->This, convertRenderStates(states)));
+    assert(renderWindow);
+    assert(object);
+    renderWindow->This.draw(object->This, convertRenderStates(states));
 }
 
 
@@ -454,8 +473,9 @@ void sfRenderWindow_drawVertexBufferRange(sfRenderWindow*       renderWindow,
                                           size_t                vertexCount,
                                           const sfRenderStates* states)
 {
-    CSFML_CHECK(object);
-    CSFML_CALL(renderWindow, draw(object->This, firstVertex, vertexCount, convertRenderStates(states)));
+    assert(renderWindow);
+    assert(object);
+    renderWindow->This.draw(object->This, firstVertex, vertexCount, convertRenderStates(states));
 }
 
 
@@ -466,32 +486,35 @@ void sfRenderWindow_drawPrimitives(sfRenderWindow*       renderWindow,
                                    sfPrimitiveType       type,
                                    const sfRenderStates* states)
 {
-    CSFML_CALL(renderWindow,
-               draw(reinterpret_cast<const sf::Vertex*>(vertices),
-                    vertexCount,
-                    static_cast<sf::PrimitiveType>(type),
-                    convertRenderStates(states)));
+    assert(renderWindow);
+    renderWindow->This.draw(reinterpret_cast<const sf::Vertex*>(vertices),
+                            vertexCount,
+                            static_cast<sf::PrimitiveType>(type),
+                            convertRenderStates(states));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderWindow_pushGLStates(sfRenderWindow* renderWindow)
 {
-    CSFML_CALL(renderWindow, pushGLStates());
+    assert(renderWindow);
+    renderWindow->This.pushGLStates();
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderWindow_popGLStates(sfRenderWindow* renderWindow)
 {
-    CSFML_CALL(renderWindow, popGLStates());
+    assert(renderWindow);
+    renderWindow->This.popGLStates();
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfRenderWindow_resetGLStates(sfRenderWindow* renderWindow)
 {
-    CSFML_CALL(renderWindow, resetGLStates());
+    assert(renderWindow);
+    renderWindow->This.resetGLStates();
 }
 
 
@@ -531,7 +554,8 @@ bool sfRenderWindow_createVulkanSurface(sfRenderWindow*              renderWindo
                                         VkSurfaceKHR*                surface,
                                         const VkAllocationCallbacks* allocator)
 {
-    CSFML_CHECK_RETURN(instance, false);
-    CSFML_CHECK_RETURN(surface, false);
-    CSFML_CALL_RETURN(renderWindow, createVulkanSurface(*instance, *surface, allocator), false);
+    assert(renderWindow);
+    assert(instance);
+    assert(surface);
+    return renderWindow->This.createVulkanSurface(*instance, *surface, allocator);
 }

src/CSFML/Graphics/Shader.cpp

@@ -30,7 +30,6 @@
 #include <CSFML/Graphics/Shader.h>
 #include <CSFML/Graphics/ShaderStruct.hpp>
 #include <CSFML/Graphics/TextureStruct.hpp>
-#include <CSFML/Internal.hpp>
 
 
 ////////////////////////////////////////////////////////////
@@ -195,28 +194,32 @@ void sfShader_destroy(sfShader* shader)
 ////////////////////////////////////////////////////////////
 void sfShader_setFloatUniform(sfShader* shader, const char* name, float x)
 {
-    CSFML_CALL(shader, setUniform(name, x));
+    assert(shader);
+    shader->This.setUniform(name, x);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setVec2Uniform(sfShader* shader, const char* name, sfGlslVec2 vector)
 {
-    CSFML_CALL(shader, setUniform(name, sf::Glsl::Vec2(vector.x, vector.y)));
+    assert(shader);
+    shader->This.setUniform(name, sf::Glsl::Vec2(vector.x, vector.y));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setVec3Uniform(sfShader* shader, const char* name, sfGlslVec3 vector)
 {
-    CSFML_CALL(shader, setUniform(name, sf::Glsl::Vec3(vector.x, vector.y, vector.z)));
+    assert(shader);
+    shader->This.setUniform(name, sf::Glsl::Vec3(vector.x, vector.y, vector.z));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setVec4Uniform(sfShader* shader, const char* name, sfGlslVec4 vector)
 {
-    CSFML_CALL(shader, setUniform(name, sf::Glsl::Vec4(vector.x, vector.y, vector.z, vector.w)));
+    assert(shader);
+    shader->This.setUniform(name, sf::Glsl::Vec4(vector.x, vector.y, vector.z, vector.w));
 }
 
 
@@ -235,28 +238,32 @@ void sfShader_setColorUniform(sfShader* shader, const char* name, sfColor color)
 ////////////////////////////////////////////////////////////
 void sfShader_setIntUniform(sfShader* shader, const char* name, int x)
 {
-    CSFML_CALL(shader, setUniform(name, x));
+    assert(shader);
+    shader->This.setUniform(name, x);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setIvec2Uniform(sfShader* shader, const char* name, sfGlslIvec2 vector)
 {
-    CSFML_CALL(shader, setUniform(name, sf::Glsl::Ivec2(vector.x, vector.y)));
+    assert(shader);
+    shader->This.setUniform(name, sf::Glsl::Ivec2(vector.x, vector.y));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setIvec3Uniform(sfShader* shader, const char* name, sfGlslIvec3 vector)
 {
-    CSFML_CALL(shader, setUniform(name, sf::Glsl::Ivec3(vector.x, vector.y, vector.z)));
+    assert(shader);
+    shader->This.setUniform(name, sf::Glsl::Ivec3(vector.x, vector.y, vector.z));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setIvec4Uniform(sfShader* shader, const char* name, sfGlslIvec4 vector)
 {
-    CSFML_CALL(shader, setUniform(name, sf::Glsl::Ivec4(vector.x, vector.y, vector.z, vector.w)));
+    assert(shader);
+    shader->This.setUniform(name, sf::Glsl::Ivec4(vector.x, vector.y, vector.z, vector.w));
 }
 
 
@@ -275,113 +282,129 @@ void sfShader_setIntColorUniform(sfShader* shader, const char* name, sfColor col
 ////////////////////////////////////////////////////////////
 void sfShader_setBoolUniform(sfShader* shader, const char* name, bool x)
 {
-    CSFML_CALL(shader, setUniform(name, x));
+    assert(shader);
+    shader->This.setUniform(name, x);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setBvec2Uniform(sfShader* shader, const char* name, sfGlslBvec2 vector)
 {
-    CSFML_CALL(shader, setUniform(name, sf::Glsl::Bvec2(vector.x, vector.y)));
+    assert(shader);
+    shader->This.setUniform(name, sf::Glsl::Bvec2(vector.x, vector.y));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setBvec3Uniform(sfShader* shader, const char* name, sfGlslBvec3 vector)
 {
-    CSFML_CALL(shader, setUniform(name, sf::Glsl::Bvec3(vector.x, vector.y, vector.z)));
+    assert(shader);
+    shader->This.setUniform(name, sf::Glsl::Bvec3(vector.x, vector.y, vector.z));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setBvec4Uniform(sfShader* shader, const char* name, sfGlslBvec4 vector)
 {
-    CSFML_CALL(shader, setUniform(name, sf::Glsl::Bvec4(vector.x, vector.y, vector.z, vector.w)));
+    assert(shader);
+    shader->This.setUniform(name, sf::Glsl::Bvec4(vector.x, vector.y, vector.z, vector.w));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setMat3Uniform(sfShader* shader, const char* name, const sfGlslMat3* matrix)
 {
-    CSFML_CALL(shader, setUniform(name, sf::Glsl::Mat3(matrix->array)));
+    assert(shader);
+    shader->This.setUniform(name, sf::Glsl::Mat3(matrix->array));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setMat4Uniform(sfShader* shader, const char* name, const sfGlslMat4* matrix)
 {
-    CSFML_CALL(shader, setUniform(name, sf::Glsl::Mat4(matrix->array)));
+    assert(shader);
+    shader->This.setUniform(name, sf::Glsl::Mat4(matrix->array));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setTextureUniform(sfShader* shader, const char* name, const sfTexture* texture)
 {
-    CSFML_CALL(shader, setUniform(name, *texture->This));
+    assert(shader);
+    shader->This.setUniform(name, *texture->This);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setCurrentTextureUniform(sfShader* shader, const char* name)
 {
-    CSFML_CALL(shader, setUniform(name, sf::Shader::CurrentTexture));
+    assert(shader);
+    shader->This.setUniform(name, sf::Shader::CurrentTexture);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setFloatUniformArray(sfShader* shader, const char* name, const float* scalarArray, size_t length)
 {
-    CSFML_CALL(shader, setUniformArray(name, scalarArray, length));
+    assert(shader);
+    shader->This.setUniformArray(name, scalarArray, length);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setVec2UniformArray(sfShader* shader, const char* name, const sfGlslVec2* vectorArray, size_t length)
 {
-    CSFML_CALL(shader, setUniformArray(name, reinterpret_cast<const sf::Glsl::Vec2*>(vectorArray), length));
+    assert(shader);
+    shader->This.setUniformArray(name, reinterpret_cast<const sf::Glsl::Vec2*>(vectorArray), length);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setVec3UniformArray(sfShader* shader, const char* name, const sfGlslVec3* vectorArray, size_t length)
 {
-    CSFML_CALL(shader, setUniformArray(name, reinterpret_cast<const sf::Glsl::Vec3*>(vectorArray), length));
+    assert(shader);
+    shader->This.setUniformArray(name, reinterpret_cast<const sf::Glsl::Vec3*>(vectorArray), length);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setVec4UniformArray(sfShader* shader, const char* name, const sfGlslVec4* vectorArray, size_t length)
 {
-    CSFML_CALL(shader, setUniformArray(name, reinterpret_cast<const sf::Glsl::Vec4*>(vectorArray), length));
+    assert(shader);
+    shader->This.setUniformArray(name, reinterpret_cast<const sf::Glsl::Vec4*>(vectorArray), length);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setMat3UniformArray(sfShader* shader, const char* name, const sfGlslMat3* matrixArray, size_t length)
 {
-    CSFML_CALL(shader, setUniformArray(name, reinterpret_cast<const sf::Glsl::Mat3*>(matrixArray), length));
+    assert(shader);
+    shader->This.setUniformArray(name, reinterpret_cast<const sf::Glsl::Mat3*>(matrixArray), length);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setMat4UniformArray(sfShader* shader, const char* name, const sfGlslMat4* matrixArray, size_t length)
 {
-    CSFML_CALL(shader, setUniformArray(name, reinterpret_cast<const sf::Glsl::Mat4*>(matrixArray), length));
+    assert(shader);
+    shader->This.setUniformArray(name, reinterpret_cast<const sf::Glsl::Mat4*>(matrixArray), length);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setTextureParameter(sfShader* shader, const char* name, const sfTexture* texture)
 {
-    CSFML_CHECK(texture);
-    CSFML_CALL(shader, setUniform(name, *texture->This));
+    assert(shader);
+    assert(texture);
+    shader->This.setUniform(name, *texture->This);
 }
 
 
 ////////////////////////////////////////////////////////////
 unsigned int sfShader_getNativeHandle(const sfShader* shader)
 {
-    CSFML_CALL_RETURN(shader, getNativeHandle(), 0);
+    assert(shader);
+    return shader->This.getNativeHandle();
 }
 
 

src/CSFML/Graphics/Shape.cpp

@@ -30,7 +30,6 @@
 #include <CSFML/Graphics/ConvertTransform.hpp>
 #include <CSFML/Graphics/Shape.h>
 #include <CSFML/Graphics/ShapeStruct.hpp>
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/ConvertVector2.hpp>
 
 #include <SFML/Graphics/Color.hpp>
@@ -53,36 +52,39 @@ void sfShape_destroy(sfShape* shape)
 ////////////////////////////////////////////////////////////
 void sfShape_setPosition(sfShape* shape, sfVector2f position)
 {
-    CSFML_CALL(shape, setPosition(convertVector2(position)));
+    assert(shape);
+    shape->This.setPosition(convertVector2(position));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShape_setRotation(sfShape* shape, float angle)
 {
-    CSFML_CALL(shape, setRotation(sf::degrees(angle)));
+    assert(shape);
+    shape->This.setRotation(sf::degrees(angle));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShape_setScale(sfShape* shape, sfVector2f scale)
 {
-    CSFML_CALL(shape, setScale(convertVector2(scale)));
+    assert(shape);
+    shape->This.setScale(convertVector2(scale));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShape_setOrigin(sfShape* shape, sfVector2f origin)
 {
-    CSFML_CALL(shape, setOrigin(convertVector2(origin)));
+    assert(shape);
+    shape->This.setOrigin(convertVector2(origin));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2f sfShape_getPosition(const sfShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertVector2(shape->This.getPosition());
 }
 
@@ -90,15 +92,15 @@ sfVector2f sfShape_getPosition(const sfShape* shape)
 ////////////////////////////////////////////////////////////
 float sfShape_getRotation(const sfShape* shape)
 {
-    CSFML_CALL_RETURN(shape, getRotation().asDegrees(), 0.f);
+    assert(shape);
+    return shape->This.getRotation().asDegrees();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2f sfShape_getScale(const sfShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertVector2(shape->This.getScale());
 }
 
@@ -106,8 +108,7 @@ sfVector2f sfShape_getScale(const sfShape* shape)
 ////////////////////////////////////////////////////////////
 sfVector2f sfShape_getOrigin(const sfShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertVector2(shape->This.getOrigin());
 }
 
@@ -115,29 +116,31 @@ sfVector2f sfShape_getOrigin(const sfShape* shape)
 ////////////////////////////////////////////////////////////
 void sfShape_move(sfShape* shape, sfVector2f offset)
 {
-    CSFML_CALL(shape, move(convertVector2(offset)));
+    assert(shape);
+    shape->This.move(convertVector2(offset));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShape_rotate(sfShape* shape, float angle)
 {
-    CSFML_CALL(shape, rotate(sf::degrees(angle)));
+    assert(shape);
+    shape->This.rotate(sf::degrees(angle));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShape_scale(sfShape* shape, sfVector2f factors)
 {
-    CSFML_CALL(shape, scale(convertVector2(factors)));
+    assert(shape);
+    shape->This.scale(convertVector2(factors));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfTransform sfShape_getTransform(const sfShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, sfTransform_Identity);
-
+    assert(shape);
     shape->Transform = convertTransform(shape->This.getTransform());
     return shape->Transform;
 }
@@ -146,8 +149,7 @@ sfTransform sfShape_getTransform(const sfShape* shape)
 ////////////////////////////////////////////////////////////
 sfTransform sfShape_getInverseTransform(const sfShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, sfTransform_Identity);
-
+    assert(shape);
     shape->InverseTransform = convertTransform(shape->This.getInverseTransform());
     return shape->InverseTransform;
 }
@@ -156,7 +158,8 @@ sfTransform sfShape_getInverseTransform(const sfShape* shape)
 ////////////////////////////////////////////////////////////
 void sfShape_setTexture(sfShape* shape, const sfTexture* texture, bool resetRect)
 {
-    CSFML_CALL(shape, setTexture(texture ? texture->This : nullptr, resetRect));
+    assert(shape);
+    shape->This.setTexture(texture ? texture->This : nullptr, resetRect);
     shape->Texture = texture;
 }
 
@@ -164,36 +167,39 @@ void sfShape_setTexture(sfShape* shape, const sfTexture* texture, bool resetRect
 ////////////////////////////////////////////////////////////
 void sfShape_setTextureRect(sfShape* shape, sfIntRect rect)
 {
-    CSFML_CALL(shape, setTextureRect(convertRect(rect)));
+    assert(shape);
+    shape->This.setTextureRect(convertRect(rect));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShape_setFillColor(sfShape* shape, sfColor color)
 {
-    CSFML_CALL(shape, setFillColor(convertColor(color)));
+    assert(shape);
+    shape->This.setFillColor(convertColor(color));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShape_setOutlineColor(sfShape* shape, sfColor color)
 {
-    CSFML_CALL(shape, setOutlineColor(convertColor(color)));
+    assert(shape);
+    shape->This.setOutlineColor(convertColor(color));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShape_setOutlineThickness(sfShape* shape, float thickness)
 {
-    CSFML_CALL(shape, setOutlineThickness(thickness));
+    assert(shape);
+    shape->This.setOutlineThickness(thickness);
 }
 
 
 ////////////////////////////////////////////////////////////
 const sfTexture* sfShape_getTexture(const sfShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, nullptr);
-
+    assert(shape);
     return shape->Texture;
 }
 
@@ -201,8 +207,7 @@ const sfTexture* sfShape_getTexture(const sfShape* shape)
 ////////////////////////////////////////////////////////////
 sfIntRect sfShape_getTextureRect(const sfShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertRect(shape->This.getTextureRect());
 }
 
@@ -210,8 +215,7 @@ sfIntRect sfShape_getTextureRect(const sfShape* shape)
 ////////////////////////////////////////////////////////////
 sfColor sfShape_getFillColor(const sfShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertColor(shape->This.getFillColor());
 }
 
@@ -219,8 +223,7 @@ sfColor sfShape_getFillColor(const sfShape* shape)
 ////////////////////////////////////////////////////////////
 sfColor sfShape_getOutlineColor(const sfShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertColor(shape->This.getOutlineColor());
 }
 
@@ -228,22 +231,23 @@ sfColor sfShape_getOutlineColor(const sfShape* shape)
 ////////////////////////////////////////////////////////////
 float sfShape_getOutlineThickness(const sfShape* shape)
 {
-    CSFML_CALL_RETURN(shape, getOutlineThickness(), 0.f);
+    assert(shape);
+    return shape->This.getOutlineThickness();
 }
 
 
 ////////////////////////////////////////////////////////////
 size_t sfShape_getPointCount(const sfShape* shape)
 {
-    CSFML_CALL_RETURN(shape, getPointCount(), 0);
+    assert(shape);
+    return shape->This.getPointCount();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2f sfShape_getPoint(const sfShape* shape, size_t index)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertVector2(shape->This.getPoint(index));
 }
 
@@ -251,8 +255,7 @@ sfVector2f sfShape_getPoint(const sfShape* shape, size_t index)
 ////////////////////////////////////////////////////////////
 sfFloatRect sfShape_getLocalBounds(const sfShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertRect(shape->This.getLocalBounds());
 }
 
@@ -260,8 +263,7 @@ sfFloatRect sfShape_getLocalBounds(const sfShape* shape)
 ////////////////////////////////////////////////////////////
 sfFloatRect sfShape_getGlobalBounds(const sfShape* shape)
 {
-    CSFML_CHECK_RETURN(shape, {});
-
+    assert(shape);
     return convertRect(shape->This.getGlobalBounds());
 }
 
@@ -269,5 +271,6 @@ sfFloatRect sfShape_getGlobalBounds(const sfShape* shape)
 ////////////////////////////////////////////////////////////
 void sfShape_update(sfShape* shape)
 {
-    CSFML_CALL(shape, update());
+    assert(shape);
+    shape->This.update();
 }

src/CSFML/Graphics/Sprite.cpp

@@ -30,7 +30,6 @@
 #include <CSFML/Graphics/ConvertTransform.hpp>
 #include <CSFML/Graphics/Sprite.h>
 #include <CSFML/Graphics/SpriteStruct.hpp>
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/ConvertVector2.hpp>
 
 #include <SFML/Graphics/Color.hpp>
@@ -40,9 +39,8 @@
 ////////////////////////////////////////////////////////////
 sfSprite* sfSprite_create(const sfTexture* texture)
 {
-    CSFML_CHECK_RETURN(texture, nullptr);
-    CSFML_CHECK_RETURN(texture->This, nullptr);
-
+    assert(texture);
+    assert(texture->This);
     return new sfSprite{sf::Sprite{*texture->This}, texture, {}, {}};
 }
 
@@ -50,8 +48,7 @@ sfSprite* sfSprite_create(const sfTexture* texture)
 ////////////////////////////////////////////////////////////
 sfSprite* sfSprite_copy(const sfSprite* sprite)
 {
-    CSFML_CHECK_RETURN(sprite, nullptr);
-
+    assert(sprite);
     return new sfSprite(*sprite);
 }
 
@@ -66,36 +63,39 @@ void sfSprite_destroy(sfSprite* sprite)
 ////////////////////////////////////////////////////////////
 void sfSprite_setPosition(sfSprite* sprite, sfVector2f position)
 {
-    CSFML_CALL(sprite, setPosition(convertVector2(position)));
+    assert(sprite);
+    sprite->This.setPosition(convertVector2(position));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSprite_setRotation(sfSprite* sprite, float angle)
 {
-    CSFML_CALL(sprite, setRotation(sf::degrees(angle)));
+    assert(sprite);
+    sprite->This.setRotation(sf::degrees(angle));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSprite_setScale(sfSprite* sprite, sfVector2f scale)
 {
-    CSFML_CALL(sprite, setScale(convertVector2(scale)));
+    assert(sprite);
+    sprite->This.setScale(convertVector2(scale));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSprite_setOrigin(sfSprite* sprite, sfVector2f origin)
 {
-    CSFML_CALL(sprite, setOrigin(convertVector2(origin)));
+    assert(sprite);
+    sprite->This.setOrigin(convertVector2(origin));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2f sfSprite_getPosition(const sfSprite* sprite)
 {
-    CSFML_CHECK_RETURN(sprite, {});
-
+    assert(sprite);
     return convertVector2(sprite->This.getPosition());
 }
 
@@ -103,15 +103,15 @@ sfVector2f sfSprite_getPosition(const sfSprite* sprite)
 ////////////////////////////////////////////////////////////
 float sfSprite_getRotation(const sfSprite* sprite)
 {
-    CSFML_CALL_RETURN(sprite, getRotation().asDegrees(), 0.f);
+    assert(sprite);
+    return sprite->This.getRotation().asDegrees();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2f sfSprite_getScale(const sfSprite* sprite)
 {
-    CSFML_CHECK_RETURN(sprite, {});
-
+    assert(sprite);
     return convertVector2(sprite->This.getScale());
 }
 
@@ -119,8 +119,7 @@ sfVector2f sfSprite_getScale(const sfSprite* sprite)
 ////////////////////////////////////////////////////////////
 sfVector2f sfSprite_getOrigin(const sfSprite* sprite)
 {
-    CSFML_CHECK_RETURN(sprite, {});
-
+    assert(sprite);
     return convertVector2(sprite->This.getOrigin());
 }
 
@@ -128,29 +127,31 @@ sfVector2f sfSprite_getOrigin(const sfSprite* sprite)
 ////////////////////////////////////////////////////////////
 void sfSprite_move(sfSprite* sprite, sfVector2f offset)
 {
-    CSFML_CALL(sprite, move(convertVector2(offset)));
+    assert(sprite);
+    sprite->This.move(convertVector2(offset));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSprite_rotate(sfSprite* sprite, float angle)
 {
-    CSFML_CALL(sprite, rotate(sf::degrees(angle)));
+    assert(sprite);
+    sprite->This.rotate(sf::degrees(angle));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSprite_scale(sfSprite* sprite, sfVector2f factors)
 {
-    CSFML_CALL(sprite, scale(convertVector2(factors)));
+    assert(sprite);
+    sprite->This.scale(convertVector2(factors));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfTransform sfSprite_getTransform(const sfSprite* sprite)
 {
-    CSFML_CHECK_RETURN(sprite, sfTransform_Identity);
-
+    assert(sprite);
     sprite->Transform = convertTransform(sprite->This.getTransform());
     return sprite->Transform;
 }
@@ -159,8 +160,7 @@ sfTransform sfSprite_getTransform(const sfSprite* sprite)
 ////////////////////////////////////////////////////////////
 sfTransform sfSprite_getInverseTransform(const sfSprite* sprite)
 {
-    CSFML_CHECK_RETURN(sprite, sfTransform_Identity);
-
+    assert(sprite);
     sprite->InverseTransform = convertTransform(sprite->This.getInverseTransform());
     return sprite->InverseTransform;
 }
@@ -171,7 +171,8 @@ void sfSprite_setTexture(sfSprite* sprite, const sfTexture* texture, bool resetR
 {
     if (texture && texture->This)
     {
-        CSFML_CALL(sprite, setTexture(*texture->This, resetRect));
+        assert(sprite);
+        sprite->This.setTexture(*texture->This, resetRect);
         sprite->Texture = texture;
     }
 }
@@ -180,22 +181,23 @@ void sfSprite_setTexture(sfSprite* sprite, const sfTexture* texture, bool resetR
 ////////////////////////////////////////////////////////////
 void sfSprite_setTextureRect(sfSprite* sprite, sfIntRect rectangle)
 {
-    CSFML_CALL(sprite, setTextureRect(convertRect(rectangle)));
+    assert(sprite);
+    sprite->This.setTextureRect(convertRect(rectangle));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSprite_setColor(sfSprite* sprite, sfColor color)
 {
-    CSFML_CALL(sprite, setColor(convertColor(color)));
+    assert(sprite);
+    sprite->This.setColor(convertColor(color));
 }
 
 
 ////////////////////////////////////////////////////////////
 const sfTexture* sfSprite_getTexture(const sfSprite* sprite)
 {
-    CSFML_CHECK_RETURN(sprite, nullptr);
-
+    assert(sprite);
     return sprite->Texture;
 }
 
@@ -203,8 +205,7 @@ const sfTexture* sfSprite_getTexture(const sfSprite* sprite)
 ////////////////////////////////////////////////////////////
 sfIntRect sfSprite_getTextureRect(const sfSprite* sprite)
 {
-    CSFML_CHECK_RETURN(sprite, {});
-
+    assert(sprite);
     return convertRect(sprite->This.getTextureRect());
 }
 
@@ -212,8 +213,7 @@ sfIntRect sfSprite_getTextureRect(const sfSprite* sprite)
 ////////////////////////////////////////////////////////////
 sfColor sfSprite_getColor(const sfSprite* sprite)
 {
-    CSFML_CHECK_RETURN(sprite, {});
-
+    assert(sprite);
     return convertColor(sprite->This.getColor());
 }
 
@@ -221,8 +221,7 @@ sfColor sfSprite_getColor(const sfSprite* sprite)
 ////////////////////////////////////////////////////////////
 sfFloatRect sfSprite_getLocalBounds(const sfSprite* sprite)
 {
-    CSFML_CHECK_RETURN(sprite, {});
-
+    assert(sprite);
     return convertRect(sprite->This.getLocalBounds());
 }
 
@@ -230,7 +229,6 @@ sfFloatRect sfSprite_getLocalBounds(const sfSprite* sprite)
 ////////////////////////////////////////////////////////////
 sfFloatRect sfSprite_getGlobalBounds(const sfSprite* sprite)
 {
-    CSFML_CHECK_RETURN(sprite, {});
-
+    assert(sprite);
     return convertRect(sprite->This.getGlobalBounds());
 }

src/CSFML/Graphics/Text.cpp

@@ -31,7 +31,6 @@
 #include <CSFML/Graphics/Font.h>
 #include <CSFML/Graphics/Text.h>
 #include <CSFML/Graphics/TextStruct.hpp>
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/ConvertVector2.hpp>
 
 #include <SFML/Graphics/Color.hpp>
@@ -40,8 +39,7 @@
 ////////////////////////////////////////////////////////////
 sfText* sfText_create(const sfFont* font)
 {
-    CSFML_CHECK_RETURN(font, nullptr);
-
+    assert(font);
     return new sfText{sf::Text{font->This}, font, {}, {}, {}};
 }
 
@@ -49,8 +47,7 @@ sfText* sfText_create(const sfFont* font)
 ////////////////////////////////////////////////////////////
 sfText* sfText_copy(const sfText* text)
 {
-    CSFML_CHECK_RETURN(text, nullptr);
-
+    assert(text);
     return new sfText(*text);
 }
 
@@ -65,36 +62,39 @@ void sfText_destroy(sfText* text)
 ////////////////////////////////////////////////////////////
 void sfText_setPosition(sfText* text, sfVector2f position)
 {
-    CSFML_CALL(text, setPosition(convertVector2(position)));
+    assert(text);
+    text->This.setPosition(convertVector2(position));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfText_setRotation(sfText* text, float angle)
 {
-    CSFML_CALL(text, setRotation(sf::degrees(angle)));
+    assert(text);
+    text->This.setRotation(sf::degrees(angle));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfText_setScale(sfText* text, sfVector2f scale)
 {
-    CSFML_CALL(text, setScale(convertVector2(scale)));
+    assert(text);
+    text->This.setScale(convertVector2(scale));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfText_setOrigin(sfText* text, sfVector2f origin)
 {
-    CSFML_CALL(text, setOrigin(convertVector2(origin)));
+    assert(text);
+    text->This.setOrigin(convertVector2(origin));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2f sfText_getPosition(const sfText* text)
 {
-    CSFML_CHECK_RETURN(text, {});
-
+    assert(text);
     return convertVector2(text->This.getPosition());
 }
 
@@ -102,15 +102,15 @@ sfVector2f sfText_getPosition(const sfText* text)
 ////////////////////////////////////////////////////////////
 float sfText_getRotation(const sfText* text)
 {
-    CSFML_CALL_RETURN(text, getRotation().asDegrees(), 0.f);
+    assert(text);
+    return text->This.getRotation().asDegrees();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2f sfText_getScale(const sfText* text)
 {
-    CSFML_CHECK_RETURN(text, {});
-
+    assert(text);
     return convertVector2(text->This.getScale());
 }
 
@@ -118,8 +118,7 @@ sfVector2f sfText_getScale(const sfText* text)
 ////////////////////////////////////////////////////////////
 sfVector2f sfText_getOrigin(const sfText* text)
 {
-    CSFML_CHECK_RETURN(text, {});
-
+    assert(text);
     return convertVector2(text->This.getOrigin());
 }
 
@@ -127,29 +126,31 @@ sfVector2f sfText_getOrigin(const sfText* text)
 ////////////////////////////////////////////////////////////
 void sfText_move(sfText* text, sfVector2f offset)
 {
-    CSFML_CALL(text, move(convertVector2(offset)));
+    assert(text);
+    text->This.move(convertVector2(offset));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfText_rotate(sfText* text, float angle)
 {
-    CSFML_CALL(text, rotate(sf::degrees(angle)));
+    assert(text);
+    text->This.rotate(sf::degrees(angle));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfText_scale(sfText* text, sfVector2f factors)
 {
-    CSFML_CALL(text, scale(convertVector2(factors)));
+    assert(text);
+    text->This.scale(convertVector2(factors));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfTransform sfText_getTransform(const sfText* text)
 {
-    CSFML_CHECK_RETURN(text, sfTransform_Identity);
-
+    assert(text);
     text->Transform = convertTransform(text->This.getTransform());
     return text->Transform;
 }
@@ -158,8 +159,7 @@ sfTransform sfText_getTransform(const sfText* text)
 ////////////////////////////////////////////////////////////
 sfTransform sfText_getInverseTransform(const sfText* text)
 {
-    CSFML_CHECK_RETURN(text, sfTransform_Identity);
-
+    assert(text);
     text->InverseTransform = convertTransform(text->This.getInverseTransform());
     return text->InverseTransform;
 }
@@ -168,24 +168,26 @@ sfTransform sfText_getInverseTransform(const sfText* text)
 ////////////////////////////////////////////////////////////
 void sfText_setString(sfText* text, const char* string)
 {
-    CSFML_CALL(text, setString(string));
+    assert(text);
+    text->This.setString(string);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfText_setUnicodeString(sfText* text, const sfChar32* string)
 {
+    assert(text);
     sf::String UTF32Text = reinterpret_cast<const char32_t*>(string);
-    CSFML_CALL(text, setString(UTF32Text));
+    text->This.setString(UTF32Text);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfText_setFont(sfText* text, const sfFont* font)
 {
-    CSFML_CHECK(font);
-
-    CSFML_CALL(text, setFont(font->This));
+    assert(text);
+    assert(font);
+    text->This.setFont(font->This);
     text->Font = font;
 }
 
@@ -193,56 +195,63 @@ void sfText_setFont(sfText* text, const sfFont* font)
 ////////////////////////////////////////////////////////////
 void sfText_setCharacterSize(sfText* text, unsigned int size)
 {
-    CSFML_CALL(text, setCharacterSize(size));
+    assert(text);
+    text->This.setCharacterSize(size);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfText_setLineSpacing(sfText* text, float spacingFactor)
 {
-    CSFML_CALL(text, setLineSpacing(spacingFactor));
+    assert(text);
+    text->This.setLineSpacing(spacingFactor);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfText_setLetterSpacing(sfText* text, float spacingFactor)
 {
-    CSFML_CALL(text, setLetterSpacing(spacingFactor));
+    assert(text);
+    text->This.setLetterSpacing(spacingFactor);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfText_setStyle(sfText* text, uint32_t style)
 {
-    CSFML_CALL(text, setStyle(style));
+    assert(text);
+    text->This.setStyle(style);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfText_setFillColor(sfText* text, sfColor color)
 {
-    CSFML_CALL(text, setFillColor(convertColor(color)));
+    assert(text);
+    text->This.setFillColor(convertColor(color));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfText_setOutlineColor(sfText* text, sfColor color)
 {
-    CSFML_CALL(text, setOutlineColor(convertColor(color)));
+    assert(text);
+    text->This.setOutlineColor(convertColor(color));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfText_setOutlineThickness(sfText* text, float thickness)
 {
-    CSFML_CALL(text, setOutlineThickness(thickness));
+    assert(text);
+    text->This.setOutlineThickness(thickness);
 }
 
 
 ////////////////////////////////////////////////////////////
 const char* sfText_getString(const sfText* text)
 {
-    CSFML_CHECK_RETURN(text, nullptr);
+    assert(text);
 
     text->String = text->This.getString().toAnsiString();
 
@@ -253,8 +262,7 @@ const char* sfText_getString(const sfText* text)
 ////////////////////////////////////////////////////////////
 const sfChar32* sfText_getUnicodeString(const sfText* text)
 {
-    CSFML_CHECK_RETURN(text, nullptr);
-
+    assert(text);
     return reinterpret_cast<const sfChar32*>(text->This.getString().getData());
 }
 
@@ -262,8 +270,7 @@ const sfChar32* sfText_getUnicodeString(const sfText* text)
 ////////////////////////////////////////////////////////////
 const sfFont* sfText_getFont(const sfText* text)
 {
-    CSFML_CHECK_RETURN(text, nullptr);
-
+    assert(text);
     return text->Font;
 }
 
@@ -271,36 +278,39 @@ const sfFont* sfText_getFont(const sfText* text)
 ////////////////////////////////////////////////////////////
 unsigned int sfText_getCharacterSize(const sfText* text)
 {
-    CSFML_CALL_RETURN(text, getCharacterSize(), 0);
+    assert(text);
+    return text->This.getCharacterSize();
 }
 
 
 ////////////////////////////////////////////////////////////
 float sfText_getLetterSpacing(const sfText* text)
 {
-    CSFML_CALL_RETURN(text, getLetterSpacing(), 1);
+    assert(text);
+    return text->This.getLetterSpacing();
 }
 
 
 ////////////////////////////////////////////////////////////
 float sfText_getLineSpacing(const sfText* text)
 {
-    CSFML_CALL_RETURN(text, getLineSpacing(), 1);
+    assert(text);
+    return text->This.getLineSpacing();
 }
 
 
 ////////////////////////////////////////////////////////////
 uint32_t sfText_getStyle(const sfText* text)
 {
-    CSFML_CALL_RETURN(text, getStyle(), 0);
+    assert(text);
+    return text->This.getStyle();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfColor sfText_getFillColor(const sfText* text)
 {
-    CSFML_CHECK_RETURN(text, {});
-
+    assert(text);
     return convertColor(text->This.getFillColor());
 }
 
@@ -308,8 +318,7 @@ sfColor sfText_getFillColor(const sfText* text)
 ////////////////////////////////////////////////////////////
 sfColor sfText_getOutlineColor(const sfText* text)
 {
-    CSFML_CHECK_RETURN(text, {});
-
+    assert(text);
     return convertColor(text->This.getOutlineColor());
 }
 
@@ -317,15 +326,15 @@ sfColor sfText_getOutlineColor(const sfText* text)
 ////////////////////////////////////////////////////////////
 float sfText_getOutlineThickness(const sfText* text)
 {
-    CSFML_CALL_RETURN(text, getOutlineThickness(), 0.f);
+    assert(text);
+    return text->This.getOutlineThickness();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2f sfText_findCharacterPos(const sfText* text, size_t index)
 {
-    CSFML_CHECK_RETURN(text, {});
-
+    assert(text);
     return convertVector2(text->This.findCharacterPos(index));
 }
 
@@ -333,8 +342,7 @@ sfVector2f sfText_findCharacterPos(const sfText* text, size_t index)
 ////////////////////////////////////////////////////////////
 sfFloatRect sfText_getLocalBounds(const sfText* text)
 {
-    CSFML_CHECK_RETURN(text, {});
-
+    assert(text);
     return convertRect(text->This.getLocalBounds());
 }
 
@@ -342,7 +350,6 @@ sfFloatRect sfText_getLocalBounds(const sfText* text)
 ////////////////////////////////////////////////////////////
 sfFloatRect sfText_getGlobalBounds(const sfText* text)
 {
-    CSFML_CHECK_RETURN(text, {});
-
+    assert(text);
     return convertRect(text->This.getGlobalBounds());
 }

src/CSFML/Graphics/Texture.cpp

@@ -31,7 +31,6 @@
 #include <CSFML/Graphics/RenderWindowStruct.hpp>
 #include <CSFML/Graphics/Texture.h>
 #include <CSFML/Graphics/TextureStruct.hpp>
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/ConvertVector2.hpp>
 #include <CSFML/Window/WindowStruct.hpp>
 
@@ -119,7 +118,7 @@ sfTexture* sfTexture_createSrgbFromMemory(const void* data, size_t sizeInBytes,
 ////////////////////////////////////////////////////////////
 sfTexture* sfTexture_createFromStream(sfInputStream* stream, const sfIntRect* area)
 {
-    CSFML_CHECK_RETURN(stream, nullptr);
+    assert(stream);
 
     sfTexture* texture = new sfTexture;
 
@@ -138,7 +137,7 @@ sfTexture* sfTexture_createFromStream(sfInputStream* stream, const sfIntRect* ar
 ////////////////////////////////////////////////////////////
 sfTexture* sfTexture_createSrgbFromStream(sfInputStream* stream, const sfIntRect* area)
 {
-    CSFML_CHECK_RETURN(stream, nullptr);
+    assert(stream);
 
     sfTexture* texture = new sfTexture;
 
@@ -158,7 +157,7 @@ sfTexture* sfTexture_createSrgbFromStream(sfInputStream* stream, const sfIntRect
 ////////////////////////////////////////////////////////////
 sfTexture* sfTexture_createFromImage(const sfImage* image, const sfIntRect* area)
 {
-    CSFML_CHECK_RETURN(image, nullptr);
+    assert(image);
 
     sfTexture* texture = new sfTexture;
 
@@ -176,7 +175,7 @@ sfTexture* sfTexture_createFromImage(const sfImage* image, const sfIntRect* area
 ////////////////////////////////////////////////////////////
 sfTexture* sfTexture_createSrgbFromImage(const sfImage* image, const sfIntRect* area)
 {
-    CSFML_CHECK_RETURN(image, nullptr);
+    assert(image);
 
     sfTexture* texture = new sfTexture;
 
@@ -194,8 +193,7 @@ sfTexture* sfTexture_createSrgbFromImage(const sfImage* image, const sfIntRect*
 ////////////////////////////////////////////////////////////
 sfTexture* sfTexture_copy(const sfTexture* texture)
 {
-    CSFML_CHECK_RETURN(texture, nullptr);
-
+    assert(texture);
     return new sfTexture(*texture);
 }
 
@@ -210,8 +208,7 @@ void sfTexture_destroy(sfTexture* texture)
 ////////////////////////////////////////////////////////////
 sfVector2u sfTexture_getSize(const sfTexture* texture)
 {
-    CSFML_CHECK_RETURN(texture, {});
-
+    assert(texture);
     return convertVector2(texture->This->getSize());
 }
 
@@ -219,9 +216,8 @@ sfVector2u sfTexture_getSize(const sfTexture* texture)
 ////////////////////////////////////////////////////////////
 sfImage* sfTexture_copyToImage(const sfTexture* texture)
 {
-    CSFML_CHECK_RETURN(texture, nullptr);
-    CSFML_CHECK_RETURN(texture->This, nullptr);
-
+    assert(texture);
+    assert(texture->This);
     return new sfImage{texture->This->copyToImage()};
 }
 
@@ -229,83 +225,85 @@ sfImage* sfTexture_copyToImage(const sfTexture* texture)
 ////////////////////////////////////////////////////////////
 void sfTexture_updateFromPixels(sfTexture* texture, const uint8_t* pixels, sfVector2u size, sfVector2u offset)
 {
-    CSFML_CALL_PTR(texture, update(pixels, convertVector2(size), convertVector2(offset)));
+    assert(texture);
+    texture->This->update(pixels, convertVector2(size), convertVector2(offset));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfTexture_updateFromTexture(sfTexture* destination, const sfTexture* texture, sfVector2u offset)
 {
-    CSFML_CHECK(texture);
-    CSFML_CHECK(texture->This);
-
-    CSFML_CALL_PTR(destination, update(*texture->This, convertVector2(offset)));
+    assert(destination);
+    assert(texture);
+    assert(texture->This);
+    destination->This->update(*texture->This, convertVector2(offset));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfTexture_updateFromImage(sfTexture* texture, const sfImage* image, sfVector2u offset)
 {
-    CSFML_CHECK(image);
-
-    CSFML_CALL_PTR(texture, update(image->This, convertVector2(offset)));
+    assert(texture);
+    assert(image);
+    texture->This->update(image->This, convertVector2(offset));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfTexture_updateFromWindow(sfTexture* texture, const sfWindow* window, sfVector2u offset)
 {
-    CSFML_CHECK(window);
-
-    CSFML_CALL_PTR(texture, update(window->This, convertVector2(offset)));
+    assert(texture);
+    assert(window);
+    texture->This->update(window->This, convertVector2(offset));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfTexture_updateFromRenderWindow(sfTexture* texture, const sfRenderWindow* renderWindow, sfVector2u offset)
 {
-    CSFML_CHECK(renderWindow);
-
-    CSFML_CALL_PTR(texture, update(renderWindow->This, convertVector2(offset)));
+    assert(texture);
+    assert(renderWindow);
+    texture->This->update(renderWindow->This, convertVector2(offset));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfTexture_setSmooth(sfTexture* texture, bool smooth)
 {
-    CSFML_CALL_PTR(texture, setSmooth(smooth));
+    assert(texture);
+    texture->This->setSmooth(smooth);
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfTexture_isSmooth(const sfTexture* texture)
 {
-    CSFML_CHECK_RETURN(texture, false);
-    CSFML_CHECK_RETURN(texture->This, false);
-
+    assert(texture);
+    assert(texture->This);
     return texture->This->isSmooth();
 }
 
 ////////////////////////////////////////////////////////////
 bool sfTexture_isSrgb(const sfTexture* texture)
 {
-    CSFML_CALL_PTR_RETURN(texture, isSrgb(), false);
+    assert(texture);
+    return texture->This->isSrgb();
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfTexture_setRepeated(sfTexture* texture, bool repeated)
 {
-    CSFML_CALL_PTR(texture, setRepeated(repeated));
+    assert(texture);
+    texture->This->setRepeated(repeated);
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfTexture_isRepeated(const sfTexture* texture)
 {
-    CSFML_CHECK_RETURN(texture, false);
-    CSFML_CHECK_RETURN(texture->This, false);
-
+    assert(texture);
+    assert(texture->This);
     return texture->This->isRepeated();
 }
 
@@ -313,23 +311,25 @@ bool sfTexture_isRepeated(const sfTexture* texture)
 ////////////////////////////////////////////////////////////
 bool sfTexture_generateMipmap(sfTexture* texture)
 {
-    CSFML_CALL_PTR_RETURN(texture, generateMipmap(), false);
+    assert(texture);
+    return texture->This->generateMipmap();
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfTexture_swap(sfTexture* left, sfTexture* right)
 {
-    CSFML_CHECK(right);
-
-    CSFML_CALL_PTR(left, swap(*right->This));
+    assert(left);
+    assert(right);
+    left->This->swap(*right->This);
 }
 
 
 ////////////////////////////////////////////////////////////
 unsigned int sfTexture_getNativeHandle(const sfTexture* texture)
 {
-    CSFML_CALL_PTR_RETURN(texture, getNativeHandle(), 0);
+    assert(texture);
+    return texture->This->getNativeHandle();
 }
 
 

src/CSFML/Graphics/Transform.cpp

@@ -28,7 +28,6 @@
 #include <CSFML/Graphics/ConvertRect.hpp>
 #include <CSFML/Graphics/ConvertTransform.hpp>
 #include <CSFML/Graphics/Transform.h>
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/ConvertVector2.hpp>
 
 #include <SFML/Graphics/Transform.hpp>
@@ -57,8 +56,7 @@ sfTransform sfTransform_fromMatrix(float a00, float a01, float a02, float a10, f
 ////////////////////////////////////////////////////////////
 void sfTransform_getMatrix(const sfTransform* transform, float* matrix)
 {
-    CSFML_CHECK(transform);
-
+    assert(transform);
     sf::Transform converted = convertTransform(*transform);
     if (matrix)
         std::memcpy(matrix, converted.getMatrix(), 16 * sizeof(float));
@@ -68,8 +66,7 @@ void sfTransform_getMatrix(const sfTransform* transform, float* matrix)
 ////////////////////////////////////////////////////////////
 sfTransform sfTransform_getInverse(const sfTransform* transform)
 {
-    CSFML_CHECK_RETURN(transform, sfTransform_Identity);
-
+    assert(transform);
     return convertTransform(convertTransform(*transform).getInverse());
 }
 
@@ -77,8 +74,7 @@ sfTransform sfTransform_getInverse(const sfTransform* transform)
 ////////////////////////////////////////////////////////////
 sfVector2f sfTransform_transformPoint(const sfTransform* transform, sfVector2f point)
 {
-    CSFML_CHECK_RETURN(transform, {});
-
+    assert(transform);
     return convertVector2(convertTransform(*transform).transformPoint(convertVector2(point)));
 }
 
@@ -86,8 +82,7 @@ sfVector2f sfTransform_transformPoint(const sfTransform* transform, sfVector2f p
 ////////////////////////////////////////////////////////////
 sfFloatRect sfTransform_transformRect(const sfTransform* transform, sfFloatRect rectangle)
 {
-    CSFML_CHECK_RETURN(transform, {});
-
+    assert(transform);
     return convertRect(convertTransform(*transform).transformRect(convertRect(rectangle)));
 }
 
@@ -95,9 +90,8 @@ sfFloatRect sfTransform_transformRect(const sfTransform* transform, sfFloatRect
 ////////////////////////////////////////////////////////////
 void sfTransform_combine(sfTransform* transform, const sfTransform* other)
 {
-    CSFML_CHECK(transform);
-    CSFML_CHECK(other);
-
+    assert(transform);
+    assert(other);
     *transform = convertTransform(convertTransform(*transform).combine(convertTransform(*other)));
 }
 
@@ -105,8 +99,7 @@ void sfTransform_combine(sfTransform* transform, const sfTransform* other)
 ////////////////////////////////////////////////////////////
 void sfTransform_translate(sfTransform* transform, sfVector2f offset)
 {
-    CSFML_CHECK(transform);
-
+    assert(transform);
     *transform = convertTransform(convertTransform(*transform).translate(convertVector2(offset)));
 }
 
@@ -114,8 +107,7 @@ void sfTransform_translate(sfTransform* transform, sfVector2f offset)
 ////////////////////////////////////////////////////////////
 void sfTransform_rotate(sfTransform* transform, float angle)
 {
-    CSFML_CHECK(transform);
-
+    assert(transform);
     *transform = convertTransform(convertTransform(*transform).rotate(sf::degrees(angle)));
 }
 
@@ -123,8 +115,7 @@ void sfTransform_rotate(sfTransform* transform, float angle)
 ////////////////////////////////////////////////////////////
 void sfTransform_rotateWithCenter(sfTransform* transform, float angle, sfVector2f center)
 {
-    CSFML_CHECK(transform);
-
+    assert(transform);
     *transform = convertTransform(convertTransform(*transform).rotate(sf::degrees(angle), convertVector2(center)));
 }
 
@@ -132,8 +123,7 @@ void sfTransform_rotateWithCenter(sfTransform* transform, float angle, sfVector2
 ////////////////////////////////////////////////////////////
 void sfTransform_scale(sfTransform* transform, sfVector2f scale)
 {
-    CSFML_CHECK(transform);
-
+    assert(transform);
     *transform = convertTransform(convertTransform(*transform).scale(convertVector2(scale)));
 }
 
@@ -141,8 +131,7 @@ void sfTransform_scale(sfTransform* transform, sfVector2f scale)
 ////////////////////////////////////////////////////////////
 void sfTransform_scaleWithCenter(sfTransform* transform, sfVector2f scale, sfVector2f center)
 {
-    CSFML_CHECK(transform);
-
+    assert(transform);
     *transform = convertTransform(convertTransform(*transform).scale(convertVector2(scale), convertVector2(center)));
 }
 
@@ -150,8 +139,8 @@ void sfTransform_scaleWithCenter(sfTransform* transform, sfVector2f scale, sfVec
 ////////////////////////////////////////////////////////////
 bool sfTransform_equal(sfTransform* left, sfTransform* right)
 {
-    CSFML_CHECK_RETURN(left, false);
-    CSFML_CHECK_RETURN(right, false);
+    assert(left);
+    assert(right);
 
     for (int i = 0; i < 9; ++i)
     {

src/CSFML/Graphics/Transformable.cpp

@@ -28,7 +28,6 @@
 #include <CSFML/Graphics/ConvertTransform.hpp>
 #include <CSFML/Graphics/Transformable.h>
 #include <CSFML/Graphics/TransformableStruct.hpp>
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/ConvertVector2.hpp>
 
 
@@ -44,8 +43,7 @@ sfTransformable* sfTransformable_create()
 ////////////////////////////////////////////////////////////
 sfTransformable* sfTransformable_copy(const sfTransformable* transformable)
 {
-    CSFML_CHECK_RETURN(transformable, nullptr);
-
+    assert(transformable);
     return new sfTransformable(*transformable);
 }
 
@@ -60,36 +58,39 @@ void sfTransformable_destroy(sfTransformable* transformable)
 ////////////////////////////////////////////////////////////
 void sfTransformable_setPosition(sfTransformable* transformable, sfVector2f position)
 {
-    CSFML_CALL(transformable, setPosition(convertVector2(position)));
+    assert(transformable);
+    transformable->This.setPosition(convertVector2(position));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfTransformable_setRotation(sfTransformable* transformable, float angle)
 {
-    CSFML_CALL(transformable, setRotation(sf::degrees(angle)));
+    assert(transformable);
+    transformable->This.setRotation(sf::degrees(angle));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfTransformable_setScale(sfTransformable* transformable, sfVector2f scale)
 {
-    CSFML_CALL(transformable, setScale(convertVector2(scale)));
+    assert(transformable);
+    transformable->This.setScale(convertVector2(scale));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfTransformable_setOrigin(sfTransformable* transformable, sfVector2f origin)
 {
-    CSFML_CALL(transformable, setOrigin(convertVector2(origin)));
+    assert(transformable);
+    transformable->This.setOrigin(convertVector2(origin));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2f sfTransformable_getPosition(const sfTransformable* transformable)
 {
-    CSFML_CHECK_RETURN(transformable, {});
-
+    assert(transformable);
     return convertVector2(transformable->This.getPosition());
 }
 
@@ -97,15 +98,15 @@ sfVector2f sfTransformable_getPosition(const sfTransformable* transformable)
 ////////////////////////////////////////////////////////////
 float sfTransformable_getRotation(const sfTransformable* transformable)
 {
-    CSFML_CALL_RETURN(transformable, getRotation().asDegrees(), 0.f);
+    assert(transformable);
+    return transformable->This.getRotation().asDegrees();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2f sfTransformable_getScale(const sfTransformable* transformable)
 {
-    CSFML_CHECK_RETURN(transformable, {});
-
+    assert(transformable);
     return convertVector2(transformable->This.getScale());
 }
 
@@ -113,8 +114,7 @@ sfVector2f sfTransformable_getScale(const sfTransformable* transformable)
 ////////////////////////////////////////////////////////////
 sfVector2f sfTransformable_getOrigin(const sfTransformable* transformable)
 {
-    CSFML_CHECK_RETURN(transformable, {});
-
+    assert(transformable);
     return convertVector2(transformable->This.getOrigin());
 }
 
@@ -122,29 +122,31 @@ sfVector2f sfTransformable_getOrigin(const sfTransformable* transformable)
 ////////////////////////////////////////////////////////////
 void sfTransformable_move(sfTransformable* transformable, sfVector2f offset)
 {
-    CSFML_CALL(transformable, move(convertVector2(offset)));
+    assert(transformable);
+    transformable->This.move(convertVector2(offset));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfTransformable_rotate(sfTransformable* transformable, float angle)
 {
-    CSFML_CALL(transformable, rotate(sf::degrees(angle)));
+    assert(transformable);
+    transformable->This.rotate(sf::degrees(angle));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfTransformable_scale(sfTransformable* transformable, sfVector2f factors)
 {
-    CSFML_CALL(transformable, scale(convertVector2(factors)));
+    assert(transformable);
+    transformable->This.scale(convertVector2(factors));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfTransform sfTransformable_getTransform(const sfTransformable* transformable)
 {
-    CSFML_CHECK_RETURN(transformable, sfTransform_Identity);
-
+    assert(transformable);
     transformable->Transform = convertTransform(transformable->This.getTransform());
     return transformable->Transform;
 }
@@ -153,8 +155,7 @@ sfTransform sfTransformable_getTransform(const sfTransformable* transformable)
 ////////////////////////////////////////////////////////////
 sfTransform sfTransformable_getInverseTransform(const sfTransformable* transformable)
 {
-    CSFML_CHECK_RETURN(transformable, sfTransform_Identity);
-
+    assert(transformable);
     transformable->InverseTransform = convertTransform(transformable->This.getInverseTransform());
     return transformable->InverseTransform;
 }

src/CSFML/Graphics/VertexArray.cpp

@@ -28,7 +28,6 @@
 #include <CSFML/Graphics/ConvertRect.hpp>
 #include <CSFML/Graphics/VertexArray.h>
 #include <CSFML/Graphics/VertexArrayStruct.hpp>
-#include <CSFML/Internal.hpp>
 
 
 ////////////////////////////////////////////////////////////
@@ -41,8 +40,7 @@ sfVertexArray* sfVertexArray_create()
 ////////////////////////////////////////////////////////////
 sfVertexArray* sfVertexArray_copy(const sfVertexArray* vertexArray)
 {
-    CSFML_CHECK_RETURN(vertexArray, nullptr);
-
+    assert(vertexArray);
     return new sfVertexArray(*vertexArray);
 }
 
@@ -57,14 +55,15 @@ void sfVertexArray_destroy(sfVertexArray* vertexArray)
 ////////////////////////////////////////////////////////////
 size_t sfVertexArray_getVertexCount(const sfVertexArray* vertexArray)
 {
-    CSFML_CALL_RETURN(vertexArray, getVertexCount(), 0);
+    assert(vertexArray);
+    return vertexArray->This.getVertexCount();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVertex* sfVertexArray_getVertex(sfVertexArray* vertexArray, size_t index)
 {
-    CSFML_CHECK_RETURN(vertexArray, nullptr);
+    assert(vertexArray);
 
     // the cast is safe, sfVertex has to be binary compatible with sf::Vertex
     return reinterpret_cast<sfVertex*>(&vertexArray->This[index]);
@@ -74,14 +73,16 @@ sfVertex* sfVertexArray_getVertex(sfVertexArray* vertexArray, size_t index)
 ////////////////////////////////////////////////////////////
 void sfVertexArray_clear(sfVertexArray* vertexArray)
 {
-    CSFML_CALL(vertexArray, clear());
+    assert(vertexArray);
+    vertexArray->This.clear();
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfVertexArray_resize(sfVertexArray* vertexArray, size_t vertexCount)
 {
-    CSFML_CALL(vertexArray, resize(vertexCount));
+    assert(vertexArray);
+    vertexArray->This.resize(vertexCount);
 }
 
 
@@ -89,21 +90,23 @@ void sfVertexArray_resize(sfVertexArray* vertexArray, size_t vertexCount)
 void sfVertexArray_append(sfVertexArray* vertexArray, sfVertex vertex)
 {
     // the cast is safe, sfVertex has to be binary compatible with sf::Vertex
-    CSFML_CALL(vertexArray, append(reinterpret_cast<sf::Vertex&>(vertex)));
+    assert(vertexArray);
+    vertexArray->This.append(reinterpret_cast<sf::Vertex&>(vertex));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfVertexArray_setPrimitiveType(sfVertexArray* vertexArray, sfPrimitiveType type)
 {
-    CSFML_CALL(vertexArray, setPrimitiveType(static_cast<sf::PrimitiveType>(type)));
+    assert(vertexArray);
+    vertexArray->This.setPrimitiveType(static_cast<sf::PrimitiveType>(type));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfPrimitiveType sfVertexArray_getPrimitiveType(sfVertexArray* vertexArray)
 {
-    CSFML_CHECK_RETURN(vertexArray, sfPoints);
+    assert(vertexArray);
     return static_cast<sfPrimitiveType>(vertexArray->This.getPrimitiveType());
 }
 
@@ -111,7 +114,6 @@ sfPrimitiveType sfVertexArray_getPrimitiveType(sfVertexArray* vertexArray)
 ////////////////////////////////////////////////////////////
 sfFloatRect sfVertexArray_getBounds(sfVertexArray* vertexArray)
 {
-    CSFML_CHECK_RETURN(vertexArray, {});
-
+    assert(vertexArray);
     return convertRect(vertexArray->This.getBounds());
 }

src/CSFML/Graphics/VertexBuffer.cpp

@@ -27,7 +27,6 @@
 ////////////////////////////////////////////////////////////
 #include <CSFML/Graphics/VertexBuffer.h>
 #include <CSFML/Graphics/VertexBufferStruct.hpp>
-#include <CSFML/Internal.hpp>
 
 
 ////////////////////////////////////////////////////////////
@@ -69,7 +68,7 @@ void sfVertexBuffer_destroy(sfVertexBuffer* vertexBuffer)
 ////////////////////////////////////////////////////////////
 unsigned int sfVertexBuffer_getVertexCount(const sfVertexBuffer* vertexBuffer)
 {
-    CSFML_CHECK_RETURN(vertexBuffer, 0);
+    assert(vertexBuffer);
     return static_cast<unsigned int>(vertexBuffer->This.getVertexCount());
 }
 
@@ -78,44 +77,48 @@ unsigned int sfVertexBuffer_getVertexCount(const sfVertexBuffer* vertexBuffer)
 bool sfVertexBuffer_update(sfVertexBuffer* vertexBuffer, const sfVertex* vertices, unsigned int vertexCount, unsigned int offset)
 {
     // the cast is safe, sfVertex has to be binary compatible with sf::Vertex
-    CSFML_CALL_RETURN(vertexBuffer, update(reinterpret_cast<const sf::Vertex*>(vertices), vertexCount, offset), false);
+    assert(vertexBuffer);
+    return vertexBuffer->This.update(reinterpret_cast<const sf::Vertex*>(vertices), vertexCount, offset);
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfVertexBuffer_updateFromVertexBuffer(sfVertexBuffer* vertexBuffer, const sfVertexBuffer* other)
 {
-    CSFML_CALL_RETURN(vertexBuffer, update(other->This), false);
+    assert(vertexBuffer);
+    return vertexBuffer->This.update(other->This);
 }
 
 
 ///////////////////////////////////////////////////////////
 void sfVertexBuffer_swap(sfVertexBuffer* left, sfVertexBuffer* right)
 {
-    CSFML_CHECK(right);
-
-    CSFML_CALL(left, swap(right->This));
+    assert(left);
+    assert(right);
+    left->This.swap(right->This);
 }
 
 
 ////////////////////////////////////////////////////////////
 unsigned int sfVertexBuffer_getNativeHandle(sfVertexBuffer* vertexBuffer)
 {
-    CSFML_CALL_RETURN(vertexBuffer, getNativeHandle(), 0);
+    assert(vertexBuffer);
+    return vertexBuffer->This.getNativeHandle();
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfVertexBuffer_setPrimitiveType(sfVertexBuffer* vertexBuffer, sfPrimitiveType type)
 {
-    CSFML_CALL(vertexBuffer, setPrimitiveType(static_cast<sf::PrimitiveType>(type)));
+    assert(vertexBuffer);
+    vertexBuffer->This.setPrimitiveType(static_cast<sf::PrimitiveType>(type));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfPrimitiveType sfVertexBuffer_getPrimitiveType(const sfVertexBuffer* vertexBuffer)
 {
-    CSFML_CHECK_RETURN(vertexBuffer, sfPoints);
+    assert(vertexBuffer);
     return static_cast<sfPrimitiveType>(vertexBuffer->This.getPrimitiveType());
 }
 
@@ -123,14 +126,15 @@ sfPrimitiveType sfVertexBuffer_getPrimitiveType(const sfVertexBuffer* vertexBuff
 ////////////////////////////////////////////////////////////
 void sfVertexBuffer_setUsage(sfVertexBuffer* vertexBuffer, sfVertexBufferUsage usage)
 {
-    CSFML_CALL(vertexBuffer, setUsage(static_cast<sf::VertexBuffer::Usage>(usage)));
+    assert(vertexBuffer);
+    vertexBuffer->This.setUsage(static_cast<sf::VertexBuffer::Usage>(usage));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVertexBufferUsage sfVertexBuffer_getUsage(const sfVertexBuffer* vertexBuffer)
 {
-    CSFML_CHECK_RETURN(vertexBuffer, sfVertexBufferStream);
+    assert(vertexBuffer);
     return static_cast<sfVertexBufferUsage>(vertexBuffer->This.getUsage());
 }
 

src/CSFML/Graphics/View.cpp

@@ -28,7 +28,6 @@
 #include <CSFML/Graphics/ConvertRect.hpp>
 #include <CSFML/Graphics/View.h>
 #include <CSFML/Graphics/ViewStruct.hpp>
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/ConvertVector2.hpp>
 
 
@@ -49,8 +48,7 @@ sfView* sfView_createFromRect(sfFloatRect rectangle)
 ////////////////////////////////////////////////////////////
 sfView* sfView_copy(const sfView* view)
 {
-    CSFML_CHECK_RETURN(view, nullptr);
-
+    assert(view);
     return new sfView(*view);
 }
 
@@ -65,36 +63,39 @@ void sfView_destroy(sfView* view)
 ////////////////////////////////////////////////////////////
 void sfView_setCenter(sfView* view, sfVector2f center)
 {
-    CSFML_CALL(view, setCenter(convertVector2(center)));
+    assert(view);
+    view->This.setCenter(convertVector2(center));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfView_setSize(sfView* view, sfVector2f size)
 {
-    CSFML_CALL(view, setSize(convertVector2(size)));
+    assert(view);
+    view->This.setSize(convertVector2(size));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfView_setRotation(sfView* view, float angle)
 {
-    CSFML_CALL(view, setRotation(sf::degrees(angle)));
+    assert(view);
+    view->This.setRotation(sf::degrees(angle));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfView_setViewport(sfView* view, sfFloatRect viewport)
 {
-    CSFML_CALL(view, setViewport(convertRect(viewport)));
+    assert(view);
+    view->This.setViewport(convertRect(viewport));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2f sfView_getCenter(const sfView* view)
 {
-    CSFML_CHECK_RETURN(view, {});
-
+    assert(view);
     return convertVector2(view->This.getCenter());
 }
 
@@ -102,8 +103,7 @@ sfVector2f sfView_getCenter(const sfView* view)
 ////////////////////////////////////////////////////////////
 sfVector2f sfView_getSize(const sfView* view)
 {
-    CSFML_CHECK_RETURN(view, {});
-
+    assert(view);
     return convertVector2(view->This.getSize());
 }
 
@@ -111,15 +111,15 @@ sfVector2f sfView_getSize(const sfView* view)
 ////////////////////////////////////////////////////////////
 float sfView_getRotation(const sfView* view)
 {
-    CSFML_CALL_RETURN(view, getRotation().asDegrees(), 0.f);
+    assert(view);
+    return view->This.getRotation().asDegrees();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfFloatRect sfView_getViewport(const sfView* view)
 {
-    CSFML_CHECK_RETURN(view, {});
-
+    assert(view);
     return convertRect(view->This.getViewport());
 }
 
@@ -127,19 +127,22 @@ sfFloatRect sfView_getViewport(const sfView* view)
 ////////////////////////////////////////////////////////////
 void sfView_move(sfView* view, sfVector2f offset)
 {
-    CSFML_CALL(view, move(convertVector2(offset)));
+    assert(view);
+    view->This.move(convertVector2(offset));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfView_rotate(sfView* view, float angle)
 {
-    CSFML_CALL(view, rotate(sf::degrees(angle)));
+    assert(view);
+    view->This.rotate(sf::degrees(angle));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfView_zoom(sfView* view, float factor)
 {
-    CSFML_CALL(view, zoom(factor));
+    assert(view);
+    view->This.zoom(factor);
 }

src/CSFML/Internal.hpp

@@ -1,128 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2023 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
-
-////////////////////////////////////////////////////////////
-// Define macros to check the validity of CSFML objects in debug run
-////////////////////////////////////////////////////////////
-#include <CSFML/Config.h>
-
-#include <SFML/System/Err.hpp>
-
-#include <ostream>
-
-#ifndef NDEBUG
-
-#define CSFML_CHECK(object_)                                                         \
-    do                                                                               \
-    {                                                                                \
-        if ((object_) == nullptr)                                                    \
-        {                                                                            \
-            sf::err() << "SFML warning: trying to use a null " #object_ " object\n"; \
-            return;                                                                  \
-        }                                                                            \
-    } while (0)
-
-#define CSFML_CALL(object_, function_)                                               \
-    do                                                                               \
-    {                                                                                \
-        if (object_)                                                                 \
-        {                                                                            \
-            ((object_)->This.function_);                                             \
-        }                                                                            \
-        else                                                                         \
-        {                                                                            \
-            sf::err() << "SFML warning: trying to use a null " #object_ " object\n"; \
-        }                                                                            \
-    } while (0)
-
-#define CSFML_CALL_PTR(object_, function_)                                           \
-    do                                                                               \
-    {                                                                                \
-        if (object_)                                                                 \
-        {                                                                            \
-            ((object_)->This->function_);                                            \
-        }                                                                            \
-        else                                                                         \
-        {                                                                            \
-            sf::err() << "SFML warning: trying to use a null " #object_ " object\n"; \
-        }                                                                            \
-    } while (0)
-
-#define CSFML_CHECK_RETURN(object_, default_)                                        \
-    do                                                                               \
-    {                                                                                \
-        if ((object_) == nullptr)                                                    \
-        {                                                                            \
-            sf::err() << "SFML warning: trying to use a null " #object_ " object\n"; \
-            return default_;                                                         \
-        }                                                                            \
-    } while (0)
-
-#define CSFML_CALL_RETURN(object_, function_, default_)                          \
-    if (object_)                                                                 \
-    {                                                                            \
-        return ((object_)->This.function_);                                      \
-    }                                                                            \
-    else                                                                         \
-    {                                                                            \
-        sf::err() << "SFML warning: trying to use a null " #object_ " object\n"; \
-        return default_;                                                         \
-    }
-
-#define CSFML_CALL_PTR_RETURN(object_, function_, default_)                      \
-    if (object_)                                                                 \
-    {                                                                            \
-        return ((object_)->This->function_);                                     \
-    }                                                                            \
-    else                                                                         \
-    {                                                                            \
-        sf::err() << "SFML warning: trying to use a null " #object_ " object\n"; \
-        return default_;                                                         \
-    }
-
-#else
-
-#define CSFML_CHECK(object_)
-
-#define CSFML_CALL(object_, function_) ((object_)->This.function_)
-
-#define CSFML_CALL_PTR(object_, function_) ((object_)->This->function_)
-
-#define CSFML_CHECK_RETURN(object_, default_)
-
-#define CSFML_CALL_RETURN(object_, function_, default_) return ((object_)->This.function_);
-
-#define CSFML_CALL_PTR_RETURN(object_, function_, default_) return ((object_)->This->function_);
-
-#endif
-
-////////////////////////////////////////////////////////////
-// Ensure char32_t has the same size as sfChar32 (uint32_t)
-// Identical alignment and size is required because we're type punning
-// when doing sfChar32* <-> char32_t* casts
-////////////////////////////////////////////////////////////
-static_assert(sizeof(sfChar32) == sizeof(char32_t));
-static_assert(alignof(sfChar32) == alignof(char32_t));

src/CSFML/Network/Ftp.cpp

@@ -26,7 +26,6 @@
 // Headers
 ////////////////////////////////////////////////////////////
 #include <CSFML/Char32.hpp>
-#include <CSFML/Internal.hpp>
 #include <CSFML/Network/Ftp.h>
 #include <CSFML/Network/FtpStruct.hpp>
 
@@ -46,15 +45,15 @@ void sfFtpListingResponse_destroy(sfFtpListingResponse* ftpListingResponse)
 ////////////////////////////////////////////////////////////
 bool sfFtpListingResponse_isOk(const sfFtpListingResponse* ftpListingResponse)
 {
-    CSFML_CALL_RETURN(ftpListingResponse, isOk(), false);
+    assert(ftpListingResponse);
+    return ftpListingResponse->This.isOk();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfFtpStatus sfFtpListingResponse_getStatus(const sfFtpListingResponse* ftpListingResponse)
 {
-    CSFML_CHECK_RETURN(ftpListingResponse, sfFtpInvalidResponse);
-
+    assert(ftpListingResponse);
     return static_cast<sfFtpStatus>(ftpListingResponse->This.getStatus());
 }
 
@@ -62,8 +61,7 @@ sfFtpStatus sfFtpListingResponse_getStatus(const sfFtpListingResponse* ftpListin
 ////////////////////////////////////////////////////////////
 const char* sfFtpListingResponse_getMessage(const sfFtpListingResponse* ftpListingResponse)
 {
-    CSFML_CHECK_RETURN(ftpListingResponse, nullptr);
-
+    assert(ftpListingResponse);
     return ftpListingResponse->This.getMessage().c_str();
 }
 
@@ -71,8 +69,7 @@ const char* sfFtpListingResponse_getMessage(const sfFtpListingResponse* ftpListi
 ////////////////////////////////////////////////////////////
 size_t sfFtpListingResponse_getCount(const sfFtpListingResponse* ftpListingResponse)
 {
-    CSFML_CHECK_RETURN(ftpListingResponse, 0);
-
+    assert(ftpListingResponse);
     return ftpListingResponse->This.getListing().size();
 }
 
@@ -80,8 +77,7 @@ size_t sfFtpListingResponse_getCount(const sfFtpListingResponse* ftpListingRespo
 ////////////////////////////////////////////////////////////
 const char* sfFtpListingResponse_getName(const sfFtpListingResponse* ftpListingResponse, size_t index)
 {
-    CSFML_CHECK_RETURN(ftpListingResponse, nullptr);
-
+    assert(ftpListingResponse);
     return ftpListingResponse->This.getListing()[index].c_str();
 }
 
@@ -96,15 +92,15 @@ void sfFtpDirectoryResponse_destroy(sfFtpDirectoryResponse* ftpDirectoryResponse
 ////////////////////////////////////////////////////////////
 bool sfFtpDirectoryResponse_isOk(const sfFtpDirectoryResponse* ftpDirectoryResponse)
 {
-    CSFML_CALL_RETURN(ftpDirectoryResponse, isOk(), false);
+    assert(ftpDirectoryResponse);
+    return ftpDirectoryResponse->This.isOk();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfFtpStatus sfFtpDirectoryResponse_getStatus(const sfFtpDirectoryResponse* ftpDirectoryResponse)
 {
-    CSFML_CHECK_RETURN(ftpDirectoryResponse, sfFtpInvalidResponse);
-
+    assert(ftpDirectoryResponse);
     return static_cast<sfFtpStatus>(ftpDirectoryResponse->This.getStatus());
 }
 
@@ -112,8 +108,7 @@ sfFtpStatus sfFtpDirectoryResponse_getStatus(const sfFtpDirectoryResponse* ftpDi
 ////////////////////////////////////////////////////////////
 const char* sfFtpDirectoryResponse_getMessage(const sfFtpDirectoryResponse* ftpDirectoryResponse)
 {
-    CSFML_CHECK_RETURN(ftpDirectoryResponse, nullptr);
-
+    assert(ftpDirectoryResponse);
     return ftpDirectoryResponse->This.getMessage().c_str();
 }
 
@@ -121,7 +116,7 @@ const char* sfFtpDirectoryResponse_getMessage(const sfFtpDirectoryResponse* ftpD
 ////////////////////////////////////////////////////////////
 const char* sfFtpDirectoryResponse_getDirectory(const sfFtpDirectoryResponse* ftpDirectoryResponse)
 {
-    CSFML_CHECK_RETURN(ftpDirectoryResponse, nullptr);
+    assert(ftpDirectoryResponse);
     return strdup(ftpDirectoryResponse->This.getDirectory().string().c_str());
 }
 
@@ -129,8 +124,7 @@ const char* sfFtpDirectoryResponse_getDirectory(const sfFtpDirectoryResponse* ft
 ////////////////////////////////////////////////////////////
 const sfChar32* sfFtpDirectoryResponse_getDirectoryUnicode(const sfFtpDirectoryResponse* ftpDirectoryResponse)
 {
-    CSFML_CHECK_RETURN(ftpDirectoryResponse, nullptr);
-
+    assert(ftpDirectoryResponse);
     sf::String str = sf::String(ftpDirectoryResponse->This.getDirectory().c_str());
     return copyToChar32(str);
 }
@@ -146,15 +140,15 @@ void sfFtpResponse_destroy(sfFtpResponse* ftpResponse)
 ////////////////////////////////////////////////////////////
 bool sfFtpResponse_isOk(const sfFtpResponse* ftpResponse)
 {
-    CSFML_CALL_RETURN(ftpResponse, isOk(), false);
+    assert(ftpResponse);
+    return ftpResponse->This.isOk();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfFtpStatus sfFtpResponse_getStatus(const sfFtpResponse* ftpResponse)
 {
-    CSFML_CHECK_RETURN(ftpResponse, sfFtpInvalidResponse);
-
+    assert(ftpResponse);
     return static_cast<sfFtpStatus>(ftpResponse->This.getStatus());
 }
 
@@ -162,8 +156,7 @@ sfFtpStatus sfFtpResponse_getStatus(const sfFtpResponse* ftpResponse)
 ////////////////////////////////////////////////////////////
 const char* sfFtpResponse_getMessage(const sfFtpResponse* ftpResponse)
 {
-    CSFML_CHECK_RETURN(ftpResponse, nullptr);
-
+    assert(ftpResponse);
     return ftpResponse->This.getMessage().c_str();
 }
 
@@ -185,7 +178,7 @@ void sfFtp_destroy(sfFtp* ftp)
 ////////////////////////////////////////////////////////////
 sfFtpResponse* sfFtp_connect(sfFtp* ftp, sfIpAddress server, unsigned short port, sfTime timeout)
 {
-    CSFML_CHECK_RETURN(ftp, nullptr);
+    assert(ftp);
 
     std::optional<sf::IpAddress> SFMLServer = sf::IpAddress::resolve(server.address);
 
@@ -199,8 +192,7 @@ sfFtpResponse* sfFtp_connect(sfFtp* ftp, sfIpAddress server, unsigned short port
 ////////////////////////////////////////////////////////////
 sfFtpResponse* sfFtp_loginAnonymous(sfFtp* ftp)
 {
-    CSFML_CHECK_RETURN(ftp, nullptr);
-
+    assert(ftp);
     return new sfFtpResponse(ftp->This.login());
 }
 
@@ -208,8 +200,7 @@ sfFtpResponse* sfFtp_loginAnonymous(sfFtp* ftp)
 ////////////////////////////////////////////////////////////
 sfFtpResponse* sfFtp_login(sfFtp* ftp, const char* name, const char* password)
 {
-    CSFML_CHECK_RETURN(ftp, nullptr);
-
+    assert(ftp);
     return new sfFtpResponse(ftp->This.login(name ? name : "", password ? password : ""));
 }
 
@@ -217,8 +208,7 @@ sfFtpResponse* sfFtp_login(sfFtp* ftp, const char* name, const char* password)
 ////////////////////////////////////////////////////////////
 sfFtpResponse* sfFtp_disconnect(sfFtp* ftp)
 {
-    CSFML_CHECK_RETURN(ftp, nullptr);
-
+    assert(ftp);
     return new sfFtpResponse(ftp->This.disconnect());
 }
 
@@ -226,8 +216,7 @@ sfFtpResponse* sfFtp_disconnect(sfFtp* ftp)
 ////////////////////////////////////////////////////////////
 sfFtpResponse* sfFtp_keepAlive(sfFtp* ftp)
 {
-    CSFML_CHECK_RETURN(ftp, nullptr);
-
+    assert(ftp);
     return new sfFtpResponse(ftp->This.keepAlive());
 }
 
@@ -235,8 +224,7 @@ sfFtpResponse* sfFtp_keepAlive(sfFtp* ftp)
 ////////////////////////////////////////////////////////////
 sfFtpDirectoryResponse* sfFtp_getWorkingDirectory(sfFtp* ftp)
 {
-    CSFML_CHECK_RETURN(ftp, nullptr);
-
+    assert(ftp);
     return new sfFtpDirectoryResponse(ftp->This.getWorkingDirectory());
 }
 
@@ -244,8 +232,7 @@ sfFtpDirectoryResponse* sfFtp_getWorkingDirectory(sfFtp* ftp)
 ////////////////////////////////////////////////////////////
 sfFtpListingResponse* sfFtp_getDirectoryListing(sfFtp* ftp, const char* directory)
 {
-    CSFML_CHECK_RETURN(ftp, nullptr);
-
+    assert(ftp);
     return new sfFtpListingResponse(ftp->This.getDirectoryListing(directory ? directory : ""));
 }
 
@@ -253,8 +240,7 @@ sfFtpListingResponse* sfFtp_getDirectoryListing(sfFtp* ftp, const char* director
 ////////////////////////////////////////////////////////////
 sfFtpResponse* sfFtp_changeDirectory(sfFtp* ftp, const char* directory)
 {
-    CSFML_CHECK_RETURN(ftp, nullptr);
-
+    assert(ftp);
     return new sfFtpResponse(ftp->This.changeDirectory(directory ? directory : ""));
 }
 
@@ -262,8 +248,7 @@ sfFtpResponse* sfFtp_changeDirectory(sfFtp* ftp, const char* directory)
 ////////////////////////////////////////////////////////////
 sfFtpResponse* sfFtp_parentDirectory(sfFtp* ftp)
 {
-    CSFML_CHECK_RETURN(ftp, nullptr);
-
+    assert(ftp);
     return new sfFtpResponse(ftp->This.parentDirectory());
 }
 
@@ -271,8 +256,7 @@ sfFtpResponse* sfFtp_parentDirectory(sfFtp* ftp)
 ////////////////////////////////////////////////////////////
 sfFtpResponse* sfFtp_createDirectory(sfFtp* ftp, const char* name)
 {
-    CSFML_CHECK_RETURN(ftp, nullptr);
-
+    assert(ftp);
     return new sfFtpResponse(ftp->This.createDirectory(name ? name : ""));
 }
 
@@ -280,8 +264,7 @@ sfFtpResponse* sfFtp_createDirectory(sfFtp* ftp, const char* name)
 ////////////////////////////////////////////////////////////
 sfFtpResponse* sfFtp_deleteDirectory(sfFtp* ftp, const char* name)
 {
-    CSFML_CHECK_RETURN(ftp, nullptr);
-
+    assert(ftp);
     return new sfFtpResponse(ftp->This.deleteDirectory(name ? name : ""));
 }
 
@@ -289,8 +272,7 @@ sfFtpResponse* sfFtp_deleteDirectory(sfFtp* ftp, const char* name)
 ////////////////////////////////////////////////////////////
 sfFtpResponse* sfFtp_renameFile(sfFtp* ftp, const char* file, const char* newName)
 {
-    CSFML_CHECK_RETURN(ftp, nullptr);
-
+    assert(ftp);
     return new sfFtpResponse(ftp->This.renameFile(file ? file : "", newName ? newName : ""));
 }
 
@@ -298,8 +280,7 @@ sfFtpResponse* sfFtp_renameFile(sfFtp* ftp, const char* file, const char* newNam
 ////////////////////////////////////////////////////////////
 sfFtpResponse* sfFtp_deleteFile(sfFtp* ftp, const char* name)
 {
-    CSFML_CHECK_RETURN(ftp, nullptr);
-
+    assert(ftp);
     return new sfFtpResponse(ftp->This.deleteFile(name ? name : ""));
 }
 
@@ -307,8 +288,7 @@ sfFtpResponse* sfFtp_deleteFile(sfFtp* ftp, const char* name)
 ////////////////////////////////////////////////////////////
 sfFtpResponse* sfFtp_download(sfFtp* ftp, const char* remoteFile, const char* localPath, sfFtpTransferMode mode)
 {
-    CSFML_CHECK_RETURN(ftp, nullptr);
-
+    assert(ftp);
     return new sfFtpResponse(ftp->This.download(remoteFile ? remoteFile : "",
                                                 localPath ? localPath : "",
                                                 static_cast<sf::Ftp::TransferMode>(mode)));
@@ -318,8 +298,7 @@ sfFtpResponse* sfFtp_download(sfFtp* ftp, const char* remoteFile, const char* lo
 ////////////////////////////////////////////////////////////
 sfFtpResponse* sfFtp_upload(sfFtp* ftp, const char* localFile, const char* remotePath, sfFtpTransferMode mode, bool append)
 {
-    CSFML_CHECK_RETURN(ftp, nullptr);
-
+    assert(ftp);
     return new sfFtpResponse(ftp->This.upload(localFile ? localFile : "",
                                               remotePath ? remotePath : "",
                                               static_cast<sf::Ftp::TransferMode>(mode),
@@ -330,7 +309,6 @@ sfFtpResponse* sfFtp_upload(sfFtp* ftp, const char* localFile, const char* remot
 ////////////////////////////////////////////////////////////
 sfFtpResponse* sfFtp_sendCommand(sfFtp* ftp, const char* command, const char* parameter)
 {
-    CSFML_CHECK_RETURN(ftp, nullptr);
-
+    assert(ftp);
     return new sfFtpResponse(ftp->This.sendCommand(command ? command : "", parameter ? parameter : ""));
 }

src/CSFML/Network/Http.cpp

@@ -25,7 +25,6 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Internal.hpp>
 #include <CSFML/Network/Http.h>
 #include <CSFML/Network/HttpStruct.hpp>
 
@@ -47,7 +46,7 @@ void sfHttpRequest_destroy(sfHttpRequest* httpRequest)
 ////////////////////////////////////////////////////////////
 void sfHttpRequest_setField(sfHttpRequest* httpRequest, const char* field, const char* value)
 {
-    CSFML_CHECK(httpRequest);
+    assert(httpRequest);
     if (field)
         httpRequest->This.setField(field, value);
 }
@@ -56,28 +55,32 @@ void sfHttpRequest_setField(sfHttpRequest* httpRequest, const char* field, const
 ////////////////////////////////////////////////////////////
 void sfHttpRequest_setMethod(sfHttpRequest* httpRequest, sfHttpMethod method)
 {
-    CSFML_CALL(httpRequest, setMethod(static_cast<sf::Http::Request::Method>(method)));
+    assert(httpRequest);
+    httpRequest->This.setMethod(static_cast<sf::Http::Request::Method>(method));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfHttpRequest_setUri(sfHttpRequest* httpRequest, const char* uri)
 {
-    CSFML_CALL(httpRequest, setUri(uri ? uri : ""));
+    assert(httpRequest);
+    httpRequest->This.setUri(uri ? uri : "");
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfHttpRequest_setHttpVersion(sfHttpRequest* httpRequest, unsigned int major, unsigned int minor)
 {
-    CSFML_CALL(httpRequest, setHttpVersion(major, minor));
+    assert(httpRequest);
+    httpRequest->This.setHttpVersion(major, minor);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfHttpRequest_setBody(sfHttpRequest* httpRequest, const char* body)
 {
-    CSFML_CALL(httpRequest, setBody(body ? body : ""));
+    assert(httpRequest);
+    httpRequest->This.setBody(body ? body : "");
 }
 
 
@@ -91,7 +94,7 @@ void sfHttpResponse_destroy(sfHttpResponse* httpResponse)
 ////////////////////////////////////////////////////////////
 const char* sfHttpResponse_getField(const sfHttpResponse* httpResponse, const char* field)
 {
-    CSFML_CHECK_RETURN(httpResponse, nullptr);
+    assert(httpResponse);
     if (!field)
         return nullptr;
 
@@ -102,8 +105,7 @@ const char* sfHttpResponse_getField(const sfHttpResponse* httpResponse, const ch
 ////////////////////////////////////////////////////////////
 sfHttpStatus sfHttpResponse_getStatus(const sfHttpResponse* httpResponse)
 {
-    CSFML_CHECK_RETURN(httpResponse, sfHttpInvalidResponse);
-
+    assert(httpResponse);
     return static_cast<sfHttpStatus>(httpResponse->This.getStatus());
 }
 
@@ -111,22 +113,23 @@ sfHttpStatus sfHttpResponse_getStatus(const sfHttpResponse* httpResponse)
 ////////////////////////////////////////////////////////////
 unsigned int sfHttpResponse_getMajorVersion(const sfHttpResponse* httpResponse)
 {
-    CSFML_CALL_RETURN(httpResponse, getMajorHttpVersion(), 0);
+    assert(httpResponse);
+    return httpResponse->This.getMajorHttpVersion();
 }
 
 
 ////////////////////////////////////////////////////////////
 unsigned int sfHttpResponse_getMinorVersion(const sfHttpResponse* httpResponse)
 {
-    CSFML_CALL_RETURN(httpResponse, getMinorHttpVersion(), 0);
+    assert(httpResponse);
+    return httpResponse->This.getMinorHttpVersion();
 }
 
 
 ////////////////////////////////////////////////////////////
 const char* sfHttpResponse_getBody(const sfHttpResponse* httpResponse)
 {
-    CSFML_CHECK_RETURN(httpResponse, nullptr);
-
+    assert(httpResponse);
     return httpResponse->This.getBody().c_str();
 }
 
@@ -148,15 +151,16 @@ void sfHttp_destroy(sfHttp* http)
 ////////////////////////////////////////////////////////////
 void sfHttp_setHost(sfHttp* http, const char* host, unsigned short port)
 {
-    CSFML_CALL(http, setHost(host ? host : "", port));
+    assert(http);
+    http->This.setHost(host ? host : "", port);
 }
 
 
 ////////////////////////////////////////////////////////////
 sfHttpResponse* sfHttp_sendRequest(sfHttp* http, const sfHttpRequest* request, sfTime timeout)
 {
-    CSFML_CHECK_RETURN(http, nullptr);
-    CSFML_CHECK_RETURN(request, nullptr);
+    assert(http);
+    assert(request);
 
     sfHttpResponse* response = new sfHttpResponse;
     response->This           = http->This.sendRequest(request->This, sf::microseconds(timeout.microseconds));

src/CSFML/Network/Packet.cpp

@@ -25,10 +25,11 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Internal.hpp>
 #include <CSFML/Network/Packet.h>
 #include <CSFML/Network/PacketStruct.hpp>
 
+#include <cassert>
+
 
 ////////////////////////////////////////////////////////////
 sfPacket* sfPacket_create()
@@ -40,8 +41,7 @@ sfPacket* sfPacket_create()
 ////////////////////////////////////////////////////////////
 sfPacket* sfPacket_copy(const sfPacket* packet)
 {
-    CSFML_CHECK_RETURN(packet, nullptr);
-
+    assert(packet);
     return new sfPacket(*packet);
 }
 
@@ -56,49 +56,55 @@ void sfPacket_destroy(sfPacket* packet)
 ////////////////////////////////////////////////////////////
 void sfPacket_append(sfPacket* packet, const void* data, size_t sizeInBytes)
 {
-    CSFML_CALL(packet, append(data, sizeInBytes));
+    assert(packet);
+    packet->This.append(data, sizeInBytes);
 }
 
 
 ////////////////////////////////////////////////////////////
 size_t sfPacket_getReadPosition(const sfPacket* packet)
 {
-    CSFML_CALL_RETURN(packet, getReadPosition(), 0);
+    assert(packet);
+    return packet->This.getReadPosition();
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfPacket_clear(sfPacket* packet)
 {
-    CSFML_CALL(packet, clear());
+    assert(packet);
+    packet->This.clear();
 }
 
 
 ////////////////////////////////////////////////////////////
 const void* sfPacket_getData(const sfPacket* packet)
 {
-    CSFML_CALL_RETURN(packet, getData(), nullptr);
+    assert(packet);
+    return packet->This.getData();
 }
 
 
 ////////////////////////////////////////////////////////////
 size_t sfPacket_getDataSize(const sfPacket* packet)
 {
-    CSFML_CALL_RETURN(packet, getDataSize(), 0);
+    assert(packet);
+    return packet->This.getDataSize();
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfPacket_endOfPacket(const sfPacket* packet)
 {
-    CSFML_CALL_RETURN(packet, endOfPacket(), false);
+    assert(packet);
+    return packet->This.endOfPacket();
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfPacket_canRead(const sfPacket* packet)
 {
-    CSFML_CHECK_RETURN(packet, false);
+    assert(packet);
     return static_cast<bool>(packet->This);
 }
 
@@ -110,69 +116,69 @@ bool sfPacket_readBool(sfPacket* packet)
 }
 int8_t sfPacket_readInt8(sfPacket* packet)
 {
-    CSFML_CHECK_RETURN(packet, false);
+    assert(packet);
     int8_t value;
     packet->This >> value;
     return value;
 }
 uint8_t sfPacket_readUint8(sfPacket* packet)
 {
-    CSFML_CHECK_RETURN(packet, false);
+    assert(packet);
     uint8_t value;
     packet->This >> value;
     return value;
 }
 int16_t sfPacket_readInt16(sfPacket* packet)
 {
-    CSFML_CHECK_RETURN(packet, false);
+    assert(packet);
     int16_t value;
     packet->This >> value;
     return value;
 }
 uint16_t sfPacket_readUint16(sfPacket* packet)
 {
-    CSFML_CHECK_RETURN(packet, false);
+    assert(packet);
     uint16_t value;
     packet->This >> value;
     return value;
 }
 int32_t sfPacket_readInt32(sfPacket* packet)
 {
-    CSFML_CHECK_RETURN(packet, false);
+    assert(packet);
     int32_t value;
     packet->This >> value;
     return value;
 }
 uint32_t sfPacket_readUint32(sfPacket* packet)
 {
-    CSFML_CHECK_RETURN(packet, false);
+    assert(packet);
     uint32_t value;
     packet->This >> value;
     return value;
 }
 float sfPacket_readFloat(sfPacket* packet)
 {
-    CSFML_CHECK_RETURN(packet, false);
+    assert(packet);
     float value;
     packet->This >> value;
     return value;
 }
 double sfPacket_readDouble(sfPacket* packet)
 {
-    CSFML_CHECK_RETURN(packet, false);
+    assert(packet);
     double value;
     packet->This >> value;
     return value;
 }
 void sfPacket_readString(sfPacket* packet, char* string)
 {
-    CSFML_CHECK(packet);
+    assert(packet);
     if (string)
         packet->This >> string;
 }
 void sfPacket_readWideString(sfPacket* packet, wchar_t* string)
 {
-    CSFML_CHECK(packet);
+    assert(packet);
     if (string)
         packet->This >> string;
 }
@@ -185,55 +191,53 @@ void sfPacket_writeBool(sfPacket* packet, bool value)
 }
 void sfPacket_writeInt8(sfPacket* packet, int8_t value)
 {
-    CSFML_CHECK(packet);
+    assert(packet);
     packet->This << value;
 }
 void sfPacket_writeUint8(sfPacket* packet, uint8_t value)
 {
-    CSFML_CHECK(packet);
+    assert(packet);
     packet->This << value;
 }
 void sfPacket_writeInt16(sfPacket* packet, int16_t value)
 {
-    CSFML_CHECK(packet);
+    assert(packet);
     packet->This << value;
 }
 void sfPacket_writeUint16(sfPacket* packet, uint16_t value)
 {
-    CSFML_CHECK(packet);
+    assert(packet);
     packet->This << value;
 }
 void sfPacket_writeInt32(sfPacket* packet, int32_t value)
 {
-    CSFML_CHECK(packet);
+    assert(packet);
     packet->This << value;
 }
 void sfPacket_writeUint32(sfPacket* packet, uint32_t value)
 {
-    CSFML_CHECK(packet);
+    assert(packet);
     packet->This << value;
 }
 void sfPacket_writeFloat(sfPacket* packet, float value)
 {
-    CSFML_CHECK(packet);
+    assert(packet);
     packet->This << value;
 }
 void sfPacket_writeDouble(sfPacket* packet, double value)
 {
-    CSFML_CHECK(packet);
+    assert(packet);
     packet->This << value;
 }
 void sfPacket_writeString(sfPacket* packet, const char* string)
 {
-    CSFML_CHECK(packet);
-
+    assert(packet);
     if (string)
         packet->This << string;
 }
 void sfPacket_writeWideString(sfPacket* packet, const wchar_t* string)
 {
-    CSFML_CHECK(packet);
-
+    assert(packet);
     if (string)
         packet->This << string;
 }

src/CSFML/Network/SocketSelector.cpp

@@ -25,7 +25,6 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Internal.hpp>
 #include <CSFML/Network/SocketSelector.h>
 #include <CSFML/Network/SocketSelectorStruct.hpp>
 #include <CSFML/Network/TcpListenerStruct.hpp>
@@ -43,8 +42,7 @@ sfSocketSelector* sfSocketSelector_create()
 ////////////////////////////////////////////////////////////
 sfSocketSelector* sfSocketSelector_copy(const sfSocketSelector* selector)
 {
-    CSFML_CHECK_RETURN(selector, nullptr);
-
+    assert(selector);
     return new sfSocketSelector(*selector);
 }
 
@@ -59,66 +57,77 @@ void sfSocketSelector_destroy(sfSocketSelector* selector)
 ////////////////////////////////////////////////////////////
 void sfSocketSelector_addTcpListener(sfSocketSelector* selector, sfTcpListener* socket)
 {
-    CSFML_CHECK(socket);
-    CSFML_CALL(selector, add(socket->This));
+    assert(selector);
+    assert(socket);
+    selector->This.add(socket->This);
 }
 void sfSocketSelector_addTcpSocket(sfSocketSelector* selector, sfTcpSocket* socket)
 {
-    CSFML_CHECK(socket);
-    CSFML_CALL(selector, add(socket->This));
+    assert(selector);
+    assert(socket);
+    selector->This.add(socket->This);
 }
 void sfSocketSelector_addUdpSocket(sfSocketSelector* selector, sfUdpSocket* socket)
 {
-    CSFML_CHECK(socket);
-    CSFML_CALL(selector, add(socket->This));
+    assert(selector);
+    assert(socket);
+    selector->This.add(socket->This);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSocketSelector_removeTcpListener(sfSocketSelector* selector, sfTcpListener* socket)
 {
-    CSFML_CHECK(socket);
-    CSFML_CALL(selector, remove(socket->This));
+    assert(selector);
+    assert(socket);
+    selector->This.remove(socket->This);
 }
 void sfSocketSelector_removeTcpSocket(sfSocketSelector* selector, sfTcpSocket* socket)
 {
-    CSFML_CHECK(socket);
-    CSFML_CALL(selector, remove(socket->This));
+    assert(selector);
+    assert(socket);
+    selector->This.remove(socket->This);
 }
 void sfSocketSelector_removeUdpSocket(sfSocketSelector* selector, sfUdpSocket* socket)
 {
-    CSFML_CHECK(socket);
-    CSFML_CALL(selector, remove(socket->This));
+    assert(selector);
+    assert(socket);
+    selector->This.remove(socket->This);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfSocketSelector_clear(sfSocketSelector* selector)
 {
-    CSFML_CALL(selector, clear());
+    assert(selector);
+    selector->This.clear();
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfSocketSelector_wait(sfSocketSelector* selector, sfTime timeout)
 {
-    CSFML_CALL_RETURN(selector, wait(sf::microseconds(timeout.microseconds)), false);
+    assert(selector);
+    return selector->This.wait(sf::microseconds(timeout.microseconds));
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfSocketSelector_isTcpListenerReady(const sfSocketSelector* selector, sfTcpListener* socket)
 {
-    CSFML_CHECK_RETURN(socket, false);
-    CSFML_CALL_RETURN(selector, isReady(socket->This), false);
+    assert(selector);
+    assert(socket);
+    return selector->This.isReady(socket->This);
 }
 bool sfSocketSelector_isTcpSocketReady(const sfSocketSelector* selector, sfTcpSocket* socket)
 {
-    CSFML_CHECK_RETURN(socket, false);
-    CSFML_CALL_RETURN(selector, isReady(socket->This), false);
+    assert(selector);
+    assert(socket);
+    return selector->This.isReady(socket->This);
 }
 bool sfSocketSelector_isUdpSocketReady(const sfSocketSelector* selector, sfUdpSocket* socket)
 {
-    CSFML_CHECK_RETURN(socket, false);
-    CSFML_CALL_RETURN(selector, isReady(socket->This), false);
+    assert(selector);
+    assert(socket);
+    return selector->This.isReady(socket->This);
 }

src/CSFML/Network/TcpListener.cpp

@@ -25,7 +25,6 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Internal.hpp>
 #include <CSFML/Network/TcpListener.h>
 #include <CSFML/Network/TcpListenerStruct.hpp>
 #include <CSFML/Network/TcpSocketStruct.hpp>
@@ -48,28 +47,31 @@ void sfTcpListener_destroy(sfTcpListener* listener)
 ////////////////////////////////////////////////////////////
 void sfTcpListener_setBlocking(sfTcpListener* listener, bool blocking)
 {
-    CSFML_CALL(listener, setBlocking(blocking));
+    assert(listener);
+    listener->This.setBlocking(blocking);
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfTcpListener_isBlocking(const sfTcpListener* listener)
 {
-    CSFML_CALL_RETURN(listener, isBlocking(), false);
+    assert(listener);
+    return listener->This.isBlocking();
 }
 
 
 ////////////////////////////////////////////////////////////
 unsigned short sfTcpListener_getLocalPort(const sfTcpListener* listener)
 {
-    CSFML_CALL_RETURN(listener, getLocalPort(), 0);
+    assert(listener);
+    return listener->This.getLocalPort();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfSocketStatus sfTcpListener_listen(sfTcpListener* listener, unsigned short port, sfIpAddress address)
 {
-    CSFML_CHECK_RETURN(listener, sfSocketError);
+    assert(listener);
 
     std::optional<sf::IpAddress> sfmlAddress = sf::IpAddress::resolve(address.address);
 
@@ -85,8 +87,8 @@ sfSocketStatus sfTcpListener_listen(sfTcpListener* listener, unsigned short port
 ////////////////////////////////////////////////////////////
 sfSocketStatus sfTcpListener_accept(sfTcpListener* listener, sfTcpSocket** connected)
 {
-    CSFML_CHECK_RETURN(listener, sfSocketError);
-    CSFML_CHECK_RETURN(connected, sfSocketError);
+    assert(listener);
+    assert(connected);
 
     *connected            = new sfTcpSocket;
     sfSocketStatus status = static_cast<sfSocketStatus>(listener->This.accept((*connected)->This));

src/CSFML/Network/TcpSocket.cpp

@@ -25,7 +25,6 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Internal.hpp>
 #include <CSFML/Network/PacketStruct.hpp>
 #include <CSFML/Network/TcpSocket.h>
 #include <CSFML/Network/TcpSocketStruct.hpp>
@@ -52,32 +51,35 @@ void sfTcpSocket_destroy(sfTcpSocket* socket)
 ////////////////////////////////////////////////////////////
 void sfTcpSocket_setBlocking(sfTcpSocket* socket, bool blocking)
 {
-    CSFML_CALL(socket, setBlocking(blocking));
+    assert(socket);
+    socket->This.setBlocking(blocking);
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfTcpSocket_isBlocking(const sfTcpSocket* socket)
 {
-    CSFML_CALL_RETURN(socket, isBlocking(), false);
+    assert(socket);
+    return socket->This.isBlocking();
 }
 
 
 ////////////////////////////////////////////////////////////
 unsigned short sfTcpSocket_getLocalPort(const sfTcpSocket* socket)
 {
-    CSFML_CALL_RETURN(socket, getLocalPort(), 0);
+    assert(socket);
+    return socket->This.getLocalPort();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfIpAddress sfTcpSocket_getRemoteAddress(const sfTcpSocket* socket)
 {
-    sfIpAddress result = sfIpAddress_None;
-    CSFML_CHECK_RETURN(socket, result);
+    assert(socket);
 
     std::optional<sf::IpAddress> address = socket->This.getRemoteAddress();
 
+    sfIpAddress result = sfIpAddress_None;
     if (address)
     {
         strncpy(result.address, address->toString().c_str(), 15);
@@ -90,7 +92,8 @@ sfIpAddress sfTcpSocket_getRemoteAddress(const sfTcpSocket* socket)
 ////////////////////////////////////////////////////////////
 unsigned short sfTcpSocket_getRemotePort(const sfTcpSocket* socket)
 {
-    CSFML_CALL_RETURN(socket, getRemotePort(), 0);
+    assert(socket);
+    return socket->This.getRemotePort();
 }
 
 
@@ -104,8 +107,7 @@ sfSocketStatus sfTcpSocket_connect(sfTcpSocket* socket, sfIpAddress remoteAddres
         return sfSocketError;
     }
 
-    CSFML_CHECK_RETURN(socket, sfSocketError);
-
+    assert(socket);
     return static_cast<sfSocketStatus>(socket->This.connect(*address, remotePort, sf::microseconds(timeout.microseconds)));
 }
 
@@ -113,15 +115,15 @@ sfSocketStatus sfTcpSocket_connect(sfTcpSocket* socket, sfIpAddress remoteAddres
 ////////////////////////////////////////////////////////////
 void sfTcpSocket_disconnect(sfTcpSocket* socket)
 {
-    CSFML_CALL(socket, disconnect());
+    assert(socket);
+    socket->This.disconnect();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfSocketStatus sfTcpSocket_send(sfTcpSocket* socket, const void* data, size_t size)
 {
-    CSFML_CHECK_RETURN(socket, sfSocketError);
-
+    assert(socket);
     return static_cast<sfSocketStatus>(socket->This.send(data, size));
 }
 
@@ -129,8 +131,7 @@ sfSocketStatus sfTcpSocket_send(sfTcpSocket* socket, const void* data, size_t si
 ////////////////////////////////////////////////////////////
 sfSocketStatus sfTcpSocket_sendPartial(sfTcpSocket* socket, const void* data, size_t size, size_t* sent)
 {
-    CSFML_CHECK_RETURN(socket, sfSocketError);
-
+    assert(socket);
     return static_cast<sfSocketStatus>(socket->This.send(data, size, *sent));
 }
 
@@ -138,7 +139,7 @@ sfSocketStatus sfTcpSocket_sendPartial(sfTcpSocket* socket, const void* data, si
 ////////////////////////////////////////////////////////////
 sfSocketStatus sfTcpSocket_receive(sfTcpSocket* socket, void* data, size_t size, size_t* received)
 {
-    CSFML_CHECK_RETURN(socket, sfSocketError);
+    assert(socket);
 
     if (received)
     {
@@ -155,9 +156,8 @@ sfSocketStatus sfTcpSocket_receive(sfTcpSocket* socket, void* data, size_t size,
 ////////////////////////////////////////////////////////////
 sfSocketStatus sfTcpSocket_sendPacket(sfTcpSocket* socket, sfPacket* packet)
 {
-    CSFML_CHECK_RETURN(socket, sfSocketError);
-    CSFML_CHECK_RETURN(packet, sfSocketError);
-
+    assert(socket);
+    assert(packet);
     return static_cast<sfSocketStatus>(socket->This.send(packet->This));
 }
 
@@ -165,8 +165,7 @@ sfSocketStatus sfTcpSocket_sendPacket(sfTcpSocket* socket, sfPacket* packet)
 ////////////////////////////////////////////////////////////
 sfSocketStatus sfTcpSocket_receivePacket(sfTcpSocket* socket, sfPacket* packet)
 {
-    CSFML_CHECK_RETURN(socket, sfSocketError);
-    CSFML_CHECK_RETURN(packet, sfSocketError);
-
+    assert(socket);
+    assert(packet);
     return static_cast<sfSocketStatus>(socket->This.receive(packet->This));
 }

src/CSFML/Network/UdpSocket.cpp

@@ -25,7 +25,6 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Internal.hpp>
 #include <CSFML/Network/PacketStruct.hpp>
 #include <CSFML/Network/UdpSocket.h>
 #include <CSFML/Network/UdpSocketStruct.hpp>
@@ -52,27 +51,30 @@ void sfUdpSocket_destroy(sfUdpSocket* socket)
 ////////////////////////////////////////////////////////////
 void sfUdpSocket_setBlocking(sfUdpSocket* socket, bool blocking)
 {
-    CSFML_CALL(socket, setBlocking(blocking));
+    assert(socket);
+    socket->This.setBlocking(blocking);
 }
 
 ////////////////////////////////////////////////////////////
 bool sfUdpSocket_isBlocking(const sfUdpSocket* socket)
 {
-    CSFML_CALL_RETURN(socket, isBlocking(), false);
+    assert(socket);
+    return socket->This.isBlocking();
 }
 
 
 ////////////////////////////////////////////////////////////
 unsigned short sfUdpSocket_getLocalPort(const sfUdpSocket* socket)
 {
-    CSFML_CALL_RETURN(socket, getLocalPort(), 0);
+    assert(socket);
+    return socket->This.getLocalPort();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfSocketStatus sfUdpSocket_bind(sfUdpSocket* socket, unsigned short port, sfIpAddress address)
 {
-    CSFML_CHECK_RETURN(socket, sfSocketError);
+    assert(socket);
 
     std::optional<sf::IpAddress> sfmlAddress = sf::IpAddress::resolve(address.address);
 
@@ -88,14 +90,15 @@ sfSocketStatus sfUdpSocket_bind(sfUdpSocket* socket, unsigned short port, sfIpAd
 ////////////////////////////////////////////////////////////
 void sfUdpSocket_unbind(sfUdpSocket* socket)
 {
-    CSFML_CALL(socket, unbind());
+    assert(socket);
+    socket->This.unbind();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfSocketStatus sfUdpSocket_send(sfUdpSocket* socket, const void* data, size_t size, sfIpAddress remoteAddress, unsigned short remotePort)
 {
-    CSFML_CHECK_RETURN(socket, sfSocketError);
+    assert(socket);
 
     // Convert the address
     std::optional<sf::IpAddress> address = sf::IpAddress::resolve(remoteAddress.address);
@@ -117,7 +120,7 @@ sfSocketStatus sfUdpSocket_receive(sfUdpSocket*    socket,
                                    sfIpAddress*    remoteAddress,
                                    unsigned short* remotePort)
 {
-    CSFML_CHECK_RETURN(socket, sfSocketError);
+    assert(socket);
 
     std::optional<sf::IpAddress> address;
     unsigned short               port;
@@ -150,8 +153,8 @@ sfSocketStatus sfUdpSocket_receive(sfUdpSocket*    socket,
 ////////////////////////////////////////////////////////////
 sfSocketStatus sfUdpSocket_sendPacket(sfUdpSocket* socket, sfPacket* packet, sfIpAddress remoteAddress, unsigned short remotePort)
 {
-    CSFML_CHECK_RETURN(socket, sfSocketError);
-    CSFML_CHECK_RETURN(packet, sfSocketError);
+    assert(socket);
+    assert(packet);
 
     // Convert the address
     std::optional<sf::IpAddress> address = sf::IpAddress::resolve(remoteAddress.address);
@@ -168,8 +171,8 @@ sfSocketStatus sfUdpSocket_sendPacket(sfUdpSocket* socket, sfPacket* packet, sfI
 ////////////////////////////////////////////////////////////
 sfSocketStatus sfUdpSocket_receivePacket(sfUdpSocket* socket, sfPacket* packet, sfIpAddress* remoteAddress, unsigned short* remotePort)
 {
-    CSFML_CHECK_RETURN(socket, sfSocketError);
-    CSFML_CHECK_RETURN(packet, sfSocketError);
+    assert(socket);
+    assert(packet);
 
     std::optional<sf::IpAddress> address;
     unsigned short               port;

src/CSFML/System/Buffer.cpp

@@ -25,10 +25,11 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/Buffer.h>
 #include <CSFML/System/BufferStruct.hpp>
 
+#include <cassert>
+
 
 ////////////////////////////////////////////////////////////
 sfBuffer* sfBuffer_create()
@@ -47,7 +48,7 @@ void sfBuffer_destroy(sfBuffer* buffer)
 ////////////////////////////////////////////////////////////
 size_t sfBuffer_getSize(const sfBuffer* buffer)
 {
-    CSFML_CHECK_RETURN(buffer, 0);
+    assert(buffer);
     return buffer->buffer.size();
 }
 
@@ -55,6 +56,6 @@ size_t sfBuffer_getSize(const sfBuffer* buffer)
 ////////////////////////////////////////////////////////////
 const uint8_t* sfBuffer_getData(const sfBuffer* buffer)
 {
-    CSFML_CHECK_RETURN(buffer, nullptr);
+    assert(buffer);
     return !buffer->buffer.empty() ? buffer->buffer.data() : nullptr;
 }

src/CSFML/System/Clock.cpp

@@ -25,7 +25,6 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/Clock.h>
 #include <CSFML/System/ClockStruct.hpp>
 
@@ -42,8 +41,7 @@ sfClock* sfClock_create()
 ////////////////////////////////////////////////////////////
 sfClock* sfClock_copy(const sfClock* clock)
 {
-    CSFML_CHECK_RETURN(clock, nullptr);
-
+    assert(clock);
     return new sfClock(*clock);
 }
 
@@ -58,18 +56,14 @@ void sfClock_destroy(sfClock* clock)
 ////////////////////////////////////////////////////////////
 sfTime sfClock_getElapsedTime(const sfClock* clock)
 {
-    CSFML_CHECK_RETURN(clock, sfTime_Zero);
-
-    sf::Time time = clock->This.getElapsedTime();
-    return sfMicroseconds(time.asMicroseconds());
+    assert(clock);
+    return {clock->This.getElapsedTime().asMicroseconds()};
 }
 
 
 ////////////////////////////////////////////////////////////
 sfTime sfClock_restart(sfClock* clock)
 {
-    CSFML_CHECK_RETURN(clock, sfTime_Zero);
-
-    sf::Time time = clock->This.restart();
-    return sfMicroseconds(time.asMicroseconds());
+    assert(clock);
+    return {clock->This.restart().asMicroseconds()};
 }

src/CSFML/System/Sleep.cpp

@@ -25,7 +25,6 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/Sleep.h>
 
 #include <SFML/System/Sleep.hpp>

src/CSFML/Window/Clipboard.cpp

@@ -25,7 +25,6 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Internal.hpp>
 #include <CSFML/Window/Clipboard.h>
 
 #include <SFML/System/String.hpp>

src/CSFML/Window/Context.cpp

@@ -25,7 +25,6 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Internal.hpp>
 #include <CSFML/Window/Context.h>
 #include <CSFML/Window/ContextStruct.hpp>
 #include <CSFML/Window/ConvertContextSettings.hpp>
@@ -53,7 +52,11 @@ bool sfContext_isExtensionAvailable(const char* name)
 
 
 ////////////////////////////////////////////////////////////
-bool sfContext_setActive(sfContext* context, bool active){CSFML_CALL_RETURN(context, setActive(active), false)}
+bool sfContext_setActive(sfContext* context, bool active)
+{
+    assert(context);
+    return context->This.setActive(active);
+}
 
 
 ////////////////////////////////////////////////////////////
@@ -66,8 +69,7 @@ GlFunctionPointer sfContext_getFunction(const char* name)
 ////////////////////////////////////////////////////////////
 sfContextSettings sfContext_getSettings(const sfContext* context)
 {
-    CSFML_CHECK_RETURN(context, sfContextSettings{});
-
+    assert(context);
     return convertContextSettings(context->This.getSettings());
 }
 

src/CSFML/Window/Cursor.cpp

@@ -25,7 +25,6 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/ConvertVector2.hpp>
 #include <CSFML/Window/Cursor.h>
 #include <CSFML/Window/CursorStruct.hpp>

src/CSFML/Window/Joystick.cpp

@@ -25,7 +25,6 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Internal.hpp>
 #include <CSFML/Window/Joystick.h>
 
 #include <SFML/Window/Joystick.hpp>

src/CSFML/Window/Keyboard.cpp

@@ -25,7 +25,6 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Internal.hpp>
 #include <CSFML/Window/Keyboard.h>
 
 #include <SFML/System/String.hpp>

src/CSFML/Window/Mouse.cpp

@@ -25,7 +25,6 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/ConvertVector2.hpp>
 #include <CSFML/Window/Mouse.h>
 #include <CSFML/Window/WindowBaseStruct.hpp>

src/CSFML/Window/Sensor.cpp

@@ -25,7 +25,6 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/ConvertVector3.hpp>
 #include <CSFML/Window/Sensor.h>
 

src/CSFML/Window/Touch.cpp

@@ -25,7 +25,6 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/ConvertVector2.hpp>
 #include <CSFML/Window/Touch.h>
 #include <CSFML/Window/WindowBaseStruct.hpp>

src/CSFML/Window/VideoMode.cpp

@@ -25,7 +25,6 @@
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
-#include <CSFML/Internal.hpp>
 #include <CSFML/Window/ConvertVideoMode.hpp>
 #include <CSFML/Window/VideoMode.h>
 

src/CSFML/Window/Window.cpp

@@ -26,7 +26,6 @@
 // Headers
 ////////////////////////////////////////////////////////////
 #include <CSFML/ConvertEvent.hpp>
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/ConvertVector2.hpp>
 #include <CSFML/Window/ConvertContextSettings.hpp>
 #include <CSFML/Window/ConvertVideoMode.hpp>
@@ -93,22 +92,23 @@ void sfWindow_destroy(sfWindow* window)
 ////////////////////////////////////////////////////////////
 void sfWindow_close(sfWindow* window)
 {
-    CSFML_CALL(window, close());
+    assert(window);
+    window->This.close();
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfWindow_isOpen(const sfWindow* window)
 {
-    CSFML_CALL_RETURN(window, isOpen(), false);
+    assert(window);
+    return window->This.isOpen();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfContextSettings sfWindow_getSettings(const sfWindow* window)
 {
-    CSFML_CHECK_RETURN(window, sfContextSettings{});
-
+    assert(window);
     return convertContextSettings(window->This.getSettings());
 }
 
@@ -116,8 +116,8 @@ sfContextSettings sfWindow_getSettings(const sfWindow* window)
 ////////////////////////////////////////////////////////////
 bool sfWindow_pollEvent(sfWindow* window, sfEvent* event)
 {
-    CSFML_CHECK_RETURN(window, false);
-    CSFML_CHECK_RETURN(event, false);
+    assert(window);
+    assert(event);
 
     // Get the event
     const std::optional sfmlEvent = window->This.pollEvent();
@@ -136,8 +136,8 @@ bool sfWindow_pollEvent(sfWindow* window, sfEvent* event)
 ////////////////////////////////////////////////////////////
 bool sfWindow_waitEvent(sfWindow* window, sfEvent* event)
 {
-    CSFML_CHECK_RETURN(window, false);
-    CSFML_CHECK_RETURN(event, false);
+    assert(window);
+    assert(event);
 
     // Get the event
     const std::optional sfmlEvent = window->This.waitEvent();
@@ -156,8 +156,7 @@ bool sfWindow_waitEvent(sfWindow* window, sfEvent* event)
 ////////////////////////////////////////////////////////////
 sfVector2i sfWindow_getPosition(const sfWindow* window)
 {
-    CSFML_CHECK_RETURN(window, {});
-
+    assert(window);
     return convertVector2(window->This.getPosition());
 }
 
@@ -165,15 +164,15 @@ sfVector2i sfWindow_getPosition(const sfWindow* window)
 ////////////////////////////////////////////////////////////
 void sfWindow_setPosition(sfWindow* window, sfVector2i position)
 {
-    CSFML_CALL(window, setPosition(convertVector2(position)));
+    assert(window);
+    window->This.setPosition(convertVector2(position));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2u sfWindow_getSize(const sfWindow* window)
 {
-    CSFML_CHECK_RETURN(window, {});
-
+    assert(window);
     return convertVector2(window->This.getSize());
 }
 
@@ -181,121 +180,135 @@ sfVector2u sfWindow_getSize(const sfWindow* window)
 ////////////////////////////////////////////////////////////
 void sfWindow_setSize(sfWindow* window, sfVector2u size)
 {
-    CSFML_CALL(window, setSize(convertVector2(size)));
+    assert(window);
+    window->This.setSize(convertVector2(size));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfWindow_setTitle(sfWindow* window, const char* title)
 {
-    CSFML_CALL(window, setTitle(title));
+    assert(window);
+    window->This.setTitle(title);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfWindow_setUnicodeTitle(sfWindow* window, const sfChar32* title)
 {
-    CSFML_CALL(window, setTitle(reinterpret_cast<const char32_t*>(title)));
+    assert(window);
+    window->This.setTitle(reinterpret_cast<const char32_t*>(title));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfWindow_setIcon(sfWindow* window, sfVector2u size, const uint8_t* pixels)
 {
-    CSFML_CALL(window, setIcon(convertVector2(size), pixels));
+    assert(window);
+    window->This.setIcon(convertVector2(size), pixels);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfWindow_setVisible(sfWindow* window, bool visible)
 {
-    CSFML_CALL(window, setVisible(visible));
+    assert(window);
+    window->This.setVisible(visible);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfWindow_setMouseCursorVisible(sfWindow* window, bool visible)
 {
-    CSFML_CALL(window, setMouseCursorVisible(visible));
+    assert(window);
+    window->This.setMouseCursorVisible(visible);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfWindow_setMouseCursorGrabbed(sfWindow* window, bool grabbed)
 {
-    CSFML_CALL(window, setMouseCursorGrabbed(grabbed));
+    assert(window);
+    window->This.setMouseCursorGrabbed(grabbed);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfWindow_setMouseCursor(sfWindow* window, const sfCursor* cursor)
 {
-    CSFML_CHECK(cursor);
-
-    CSFML_CALL(window, setMouseCursor(cursor->This));
+    assert(window);
+    assert(cursor);
+    window->This.setMouseCursor(cursor->This);
 }
 
 ////////////////////////////////////////////////////////////
 void sfWindow_setVerticalSyncEnabled(sfWindow* window, bool enabled)
 {
-    CSFML_CALL(window, setVerticalSyncEnabled(enabled));
+    assert(window);
+    window->This.setVerticalSyncEnabled(enabled);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfWindow_setKeyRepeatEnabled(sfWindow* window, bool enabled)
 {
-    CSFML_CALL(window, setKeyRepeatEnabled(enabled));
+    assert(window);
+    window->This.setKeyRepeatEnabled(enabled);
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfWindow_setActive(sfWindow* window, bool active)
 {
-    CSFML_CALL_RETURN(window, setActive(active), false);
+    assert(window);
+    return window->This.setActive(active);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfWindow_requestFocus(sfWindow* window)
 {
-    CSFML_CALL(window, requestFocus());
+    assert(window);
+    window->This.requestFocus();
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfWindow_hasFocus(const sfWindow* window)
 {
-    CSFML_CALL_RETURN(window, hasFocus(), false);
+    assert(window);
+    return window->This.hasFocus();
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfWindow_display(sfWindow* window)
 {
-    CSFML_CALL(window, display());
+    assert(window);
+    window->This.display();
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfWindow_setFramerateLimit(sfWindow* window, unsigned int limit)
 {
-    CSFML_CALL(window, setFramerateLimit(limit));
+    assert(window);
+    window->This.setFramerateLimit(limit);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfWindow_setJoystickThreshold(sfWindow* window, float threshold)
 {
-    CSFML_CALL(window, setJoystickThreshold(threshold));
+    assert(window);
+    window->This.setJoystickThreshold(threshold);
 }
 
 
 ////////////////////////////////////////////////////////////
 sfWindowHandle sfWindow_getNativeHandle(const sfWindow* window)
 {
-    CSFML_CHECK_RETURN(window, 0);
-
+    assert(window);
     return static_cast<sfWindowHandle>(window->This.getNativeHandle());
 }
 
@@ -306,7 +319,8 @@ bool sfWindow_createVulkanSurface(sfWindow*                    window,
                                   VkSurfaceKHR*                surface,
                                   const VkAllocationCallbacks* allocator)
 {
-    CSFML_CHECK_RETURN(instance, false);
-    CSFML_CHECK_RETURN(surface, false);
-    CSFML_CALL_RETURN(window, createVulkanSurface(*instance, *surface, allocator), false);
+    assert(window);
+    assert(instance);
+    assert(surface);
+    return window->This.createVulkanSurface(*instance, *surface, allocator);
 }

src/CSFML/Window/WindowBase.cpp

@@ -26,7 +26,6 @@
 // Headers
 ////////////////////////////////////////////////////////////
 #include <CSFML/ConvertEvent.hpp>
-#include <CSFML/Internal.hpp>
 #include <CSFML/System/ConvertVector2.hpp>
 #include <CSFML/Window/ConvertVideoMode.hpp>
 #include <CSFML/Window/CursorStruct.hpp>
@@ -79,22 +78,24 @@ void sfWindowBase_destroy(sfWindowBase* windowBase)
 ////////////////////////////////////////////////////////////
 void sfWindowBase_close(sfWindowBase* windowBase)
 {
-    CSFML_CALL(windowBase, close());
+    assert(windowBase);
+    windowBase->This.close();
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfWindowBase_isOpen(const sfWindowBase* windowBase)
 {
-    CSFML_CALL_RETURN(windowBase, isOpen(), false);
+    assert(windowBase);
+    return windowBase->This.isOpen();
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfWindowBase_pollEvent(sfWindowBase* windowBase, sfEvent* event)
 {
-    CSFML_CHECK_RETURN(windowBase, false);
-    CSFML_CHECK_RETURN(event, false);
+    assert(windowBase);
+    assert(event);
 
     // Get the event
     const std::optional sfmlEvent = windowBase->This.pollEvent();
@@ -113,8 +114,8 @@ bool sfWindowBase_pollEvent(sfWindowBase* windowBase, sfEvent* event)
 ////////////////////////////////////////////////////////////
 bool sfWindowBase_waitEvent(sfWindowBase* windowBase, sfEvent* event)
 {
-    CSFML_CHECK_RETURN(windowBase, false);
-    CSFML_CHECK_RETURN(event, false);
+    assert(windowBase);
+    assert(event);
 
     // Get the event
     const std::optional sfmlEvent = windowBase->This.waitEvent();
@@ -133,8 +134,7 @@ bool sfWindowBase_waitEvent(sfWindowBase* windowBase, sfEvent* event)
 ////////////////////////////////////////////////////////////
 sfVector2i sfWindowBase_getPosition(const sfWindowBase* windowBase)
 {
-    CSFML_CHECK_RETURN(windowBase, {});
-
+    assert(windowBase);
     return convertVector2(windowBase->This.getPosition());
 }
 
@@ -142,15 +142,15 @@ sfVector2i sfWindowBase_getPosition(const sfWindowBase* windowBase)
 ////////////////////////////////////////////////////////////
 void sfWindowBase_setPosition(sfWindowBase* windowBase, sfVector2i position)
 {
-    CSFML_CALL(windowBase, setPosition(convertVector2(position)));
+    assert(windowBase);
+    windowBase->This.setPosition(convertVector2(position));
 }
 
 
 ////////////////////////////////////////////////////////////
 sfVector2u sfWindowBase_getSize(const sfWindowBase* windowBase)
 {
-    CSFML_CHECK_RETURN(windowBase, {});
-
+    assert(windowBase);
     return convertVector2(windowBase->This.getSize());
 }
 
@@ -158,94 +158,104 @@ sfVector2u sfWindowBase_getSize(const sfWindowBase* windowBase)
 ////////////////////////////////////////////////////////////
 void sfWindowBase_setSize(sfWindowBase* windowBase, sfVector2u size)
 {
-    CSFML_CALL(windowBase, setSize(convertVector2(size)));
+    assert(windowBase);
+    windowBase->This.setSize(convertVector2(size));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfWindowBase_setTitle(sfWindowBase* windowBase, const char* title)
 {
-    CSFML_CALL(windowBase, setTitle(title));
+    assert(windowBase);
+    windowBase->This.setTitle(title);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfWindowBase_setUnicodeTitle(sfWindowBase* windowBase, const sfChar32* title)
 {
-    CSFML_CALL(windowBase, setTitle(reinterpret_cast<const char32_t*>(title)));
+    assert(windowBase);
+    windowBase->This.setTitle(reinterpret_cast<const char32_t*>(title));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfWindowBase_setIcon(sfWindowBase* windowBase, sfVector2u size, const uint8_t* pixels)
 {
-    CSFML_CALL(windowBase, setIcon(convertVector2(size), pixels));
+    assert(windowBase);
+    windowBase->This.setIcon(convertVector2(size), pixels);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfWindowBase_setVisible(sfWindowBase* windowBase, bool visible)
 {
-    CSFML_CALL(windowBase, setVisible(visible));
+    assert(windowBase);
+    windowBase->This.setVisible(visible);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfWindowBase_setMouseCursorVisible(sfWindowBase* windowBase, bool visible)
 {
-    CSFML_CALL(windowBase, setMouseCursorVisible(visible));
+    assert(windowBase);
+    windowBase->This.setMouseCursorVisible(visible);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfWindowBase_setMouseCursorGrabbed(sfWindowBase* windowBase, bool grabbed)
 {
-    CSFML_CALL(windowBase, setMouseCursorGrabbed(grabbed));
+    assert(windowBase);
+    windowBase->This.setMouseCursorGrabbed(grabbed);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfWindowBase_setMouseCursor(sfWindowBase* windowBase, const sfCursor* cursor)
 {
-    CSFML_CHECK(cursor);
-
-    CSFML_CALL(windowBase, setMouseCursor(cursor->This));
+    assert(windowBase);
+    assert(cursor);
+    windowBase->This.setMouseCursor(cursor->This);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfWindowBase_setKeyRepeatEnabled(sfWindowBase* windowBase, bool enabled)
 {
-    CSFML_CALL(windowBase, setKeyRepeatEnabled(enabled));
+    assert(windowBase);
+    windowBase->This.setKeyRepeatEnabled(enabled);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfWindowBase_setJoystickThreshold(sfWindowBase* windowBase, float threshold)
 {
-    CSFML_CALL(windowBase, setJoystickThreshold(threshold));
+    assert(windowBase);
+    windowBase->This.setJoystickThreshold(threshold);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfWindowBase_requestFocus(sfWindowBase* windowBase)
 {
-    CSFML_CALL(windowBase, requestFocus());
+    assert(windowBase);
+    windowBase->This.requestFocus();
 }
 
 
 ////////////////////////////////////////////////////////////
 bool sfWindowBase_hasFocus(const sfWindowBase* windowBase)
 {
-    CSFML_CALL_RETURN(windowBase, hasFocus(), false);
+    assert(windowBase);
+    return windowBase->This.hasFocus();
 }
 
 
 ////////////////////////////////////////////////////////////
 sfWindowHandle sfWindowBase_getNativeHandle(const sfWindowBase* windowBase)
 {
-    CSFML_CHECK_RETURN(windowBase, 0);
-
+    assert(windowBase);
     return static_cast<sfWindowHandle>(windowBase->This.getNativeHandle());
 }
 
@@ -255,7 +265,8 @@ bool sfWindowBase_createVulkanSurface(sfWindowBase*                windowBase,
                                       VkSurfaceKHR*                surface,
                                       const VkAllocationCallbacks* allocator)
 {
-    CSFML_CHECK_RETURN(instance, false);
-    CSFML_CHECK_RETURN(surface, false);
-    CSFML_CALL_RETURN(windowBase, createVulkanSurface(*instance, *surface, allocator), false);
+    assert(windowBase);
+    assert(instance);
+    assert(surface);
+    return windowBase->This.createVulkanSurface(*instance, *surface, allocator);
 }