From 009bd8a3e903b72782566ec1ceb8cf3ccc70d87a Mon Sep 17 00:00:00 2001 From: Chris Thrasher Date: Sun, 1 Sep 2024 21:19:41 -0600 Subject: [PATCH] Use `assert` to protect against dereferencing null pointers --- src/CSFML/Audio/Music.cpp | 98 ++++++------- src/CSFML/Audio/Sound.cpp | 77 +++++----- src/CSFML/Audio/SoundBuffer.cpp | 28 ++-- src/CSFML/Audio/SoundBufferRecorder.cpp | 17 ++- src/CSFML/Audio/SoundRecorder.cpp | 23 +-- src/CSFML/Audio/SoundStream.cpp | 71 ++++++---- src/CSFML/Char32.hpp | 9 ++ src/CSFML/Graphics/CircleShape.cpp | 94 +++++++------ src/CSFML/Graphics/Color.cpp | 1 - src/CSFML/Graphics/ConvexShape.cpp | 91 ++++++------ src/CSFML/Graphics/Font.cpp | 38 ++--- src/CSFML/Graphics/Image.cpp | 39 +++--- src/CSFML/Graphics/Rect.cpp | 13 +- src/CSFML/Graphics/RectangleShape.cpp | 91 ++++++------ src/CSFML/Graphics/RenderTexture.cpp | 117 +++++++++------- src/CSFML/Graphics/RenderWindow.cpp | 178 ++++++++++++++---------- src/CSFML/Graphics/Shader.cpp | 75 ++++++---- src/CSFML/Graphics/Shape.cpp | 85 +++++------ src/CSFML/Graphics/Sprite.cpp | 72 +++++----- src/CSFML/Graphics/Text.cpp | 117 ++++++++-------- src/CSFML/Graphics/Texture.cpp | 80 +++++------ src/CSFML/Graphics/Transform.cpp | 37 ++--- src/CSFML/Graphics/Transformable.cpp | 43 +++--- src/CSFML/Graphics/VertexArray.cpp | 26 ++-- src/CSFML/Graphics/VertexBuffer.cpp | 28 ++-- src/CSFML/Graphics/View.cpp | 37 ++--- src/CSFML/Internal.hpp | 128 ----------------- src/CSFML/Network/Ftp.cpp | 86 +++++------- src/CSFML/Network/Http.cpp | 36 ++--- src/CSFML/Network/Packet.cpp | 68 ++++----- src/CSFML/Network/SocketSelector.cpp | 55 +++++--- src/CSFML/Network/TcpListener.cpp | 16 ++- src/CSFML/Network/TcpSocket.cpp | 41 +++--- src/CSFML/Network/UdpSocket.cpp | 27 ++-- src/CSFML/System/Buffer.cpp | 7 +- src/CSFML/System/Clock.cpp | 16 +-- src/CSFML/System/Sleep.cpp | 1 - src/CSFML/Window/Clipboard.cpp | 1 - src/CSFML/Window/Context.cpp | 10 +- src/CSFML/Window/Cursor.cpp | 1 - src/CSFML/Window/Joystick.cpp | 1 - src/CSFML/Window/Keyboard.cpp | 1 - src/CSFML/Window/Mouse.cpp | 1 - src/CSFML/Window/Sensor.cpp | 1 - src/CSFML/Window/Touch.cpp | 1 - src/CSFML/Window/VideoMode.cpp | 1 - src/CSFML/Window/Window.cpp | 88 +++++++----- src/CSFML/Window/WindowBase.cpp | 73 +++++----- 48 files changed, 1125 insertions(+), 1120 deletions(-) delete mode 100644 src/CSFML/Internal.hpp diff --git a/src/CSFML/Audio/Music.cpp b/src/CSFML/Audio/Music.cpp index d8e97f1e..de7884fc 100644 --- a/src/CSFML/Audio/Music.cpp +++ b/src/CSFML/Audio/Music.cpp @@ -27,7 +27,6 @@ //////////////////////////////////////////////////////////// #include #include -#include #include @@ -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(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(); } diff --git a/src/CSFML/Audio/Sound.cpp b/src/CSFML/Audio/Sound.cpp index b8d13ed9..f5cc4f55 100644 --- a/src/CSFML/Audio/Sound.cpp +++ b/src/CSFML/Audio/Sound.cpp @@ -27,15 +27,13 @@ //////////////////////////////////////////////////////////// #include #include -#include #include //////////////////////////////////////////////////////////// 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(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()}; } diff --git a/src/CSFML/Audio/SoundBuffer.cpp b/src/CSFML/Audio/SoundBuffer.cpp index 2fdd7e6c..3780a3b4 100644 --- a/src/CSFML/Audio/SoundBuffer.cpp +++ b/src/CSFML/Audio/SoundBuffer.cpp @@ -28,7 +28,6 @@ #include #include #include -#include //////////////////////////////////////////////////////////// @@ -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()}; } diff --git a/src/CSFML/Audio/SoundBufferRecorder.cpp b/src/CSFML/Audio/SoundBufferRecorder.cpp index 73f9c7f9..a46ddaff 100644 --- a/src/CSFML/Audio/SoundBufferRecorder.cpp +++ b/src/CSFML/Audio/SoundBufferRecorder.cpp @@ -27,7 +27,6 @@ //////////////////////////////////////////////////////////// #include #include -#include //////////////////////////////////////////////////////////// @@ -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(); diff --git a/src/CSFML/Audio/SoundRecorder.cpp b/src/CSFML/Audio/SoundRecorder.cpp index 6aa5580e..4f750bc0 100644 --- a/src/CSFML/Audio/SoundRecorder.cpp +++ b/src/CSFML/Audio/SoundRecorder.cpp @@ -27,7 +27,8 @@ //////////////////////////////////////////////////////////// #include #include -#include + +#include //////////////////////////////////////////////////////////// @@ -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(); } diff --git a/src/CSFML/Audio/SoundStream.cpp b/src/CSFML/Audio/SoundStream.cpp index 92f113d7..640f8022 100644 --- a/src/CSFML/Audio/SoundStream.cpp +++ b/src/CSFML/Audio/SoundStream.cpp @@ -27,7 +27,6 @@ //////////////////////////////////////////////////////////// #include #include -#include #include @@ -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(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()}; } diff --git a/src/CSFML/Char32.hpp b/src/CSFML/Char32.hpp index c8024674..204cc24e 100644 --- a/src/CSFML/Char32.hpp +++ b/src/CSFML/Char32.hpp @@ -34,6 +34,15 @@ #include +//////////////////////////////////////////////////////////// +// 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 //////////////////////////////////////////////////////////// diff --git a/src/CSFML/Graphics/CircleShape.cpp b/src/CSFML/Graphics/CircleShape.cpp index bee4dab1..a3bb226f 100644 --- a/src/CSFML/Graphics/CircleShape.cpp +++ b/src/CSFML/Graphics/CircleShape.cpp @@ -30,7 +30,6 @@ #include #include #include -#include #include #include @@ -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()); } diff --git a/src/CSFML/Graphics/Color.cpp b/src/CSFML/Graphics/Color.cpp index 251496cc..124b9fcc 100644 --- a/src/CSFML/Graphics/Color.cpp +++ b/src/CSFML/Graphics/Color.cpp @@ -26,7 +26,6 @@ // Headers //////////////////////////////////////////////////////////// #include -#include #include diff --git a/src/CSFML/Graphics/ConvexShape.cpp b/src/CSFML/Graphics/ConvexShape.cpp index 12bf55d9..f1828975 100644 --- a/src/CSFML/Graphics/ConvexShape.cpp +++ b/src/CSFML/Graphics/ConvexShape.cpp @@ -30,7 +30,6 @@ #include #include #include -#include #include #include @@ -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()); } diff --git a/src/CSFML/Graphics/Font.cpp b/src/CSFML/Graphics/Font.cpp index b4a1f3ac..1a6a5ba7 100644 --- a/src/CSFML/Graphics/Font.cpp +++ b/src/CSFML/Graphics/Font.cpp @@ -29,7 +29,6 @@ #include #include #include -#include //////////////////////////////////////////////////////////// @@ -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()}; } diff --git a/src/CSFML/Graphics/Image.cpp b/src/CSFML/Graphics/Image.cpp index 59ee09c6..aea8a038 100644 --- a/src/CSFML/Graphics/Image.cpp +++ b/src/CSFML/Graphics/Image.cpp @@ -30,7 +30,6 @@ #include #include #include -#include #include #include @@ -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(); } diff --git a/src/CSFML/Graphics/Rect.cpp b/src/CSFML/Graphics/Rect.cpp index 8160cef2..6b805e80 100644 --- a/src/CSFML/Graphics/Rect.cpp +++ b/src/CSFML/Graphics/Rect.cpp @@ -27,7 +27,6 @@ //////////////////////////////////////////////////////////// #include #include -#include #include #include @@ -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)); diff --git a/src/CSFML/Graphics/RectangleShape.cpp b/src/CSFML/Graphics/RectangleShape.cpp index 511f01e4..b2d06bfa 100644 --- a/src/CSFML/Graphics/RectangleShape.cpp +++ b/src/CSFML/Graphics/RectangleShape.cpp @@ -30,7 +30,6 @@ #include #include #include -#include #include #include @@ -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()); } diff --git a/src/CSFML/Graphics/RenderTexture.cpp b/src/CSFML/Graphics/RenderTexture.cpp index e3c07012..d619380a 100644 --- a/src/CSFML/Graphics/RenderTexture.cpp +++ b/src/CSFML/Graphics/RenderTexture.cpp @@ -38,7 +38,6 @@ #include #include #include -#include #include #include @@ -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(vertices), - vertexCount, - static_cast(type), - convertRenderStates(states))); + assert(renderTexture); + renderTexture->This.draw(reinterpret_cast(vertices), + vertexCount, + static_cast(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(); } diff --git a/src/CSFML/Graphics/RenderWindow.cpp b/src/CSFML/Graphics/RenderWindow.cpp index b21c2d6b..ab7e5f54 100644 --- a/src/CSFML/Graphics/RenderWindow.cpp +++ b/src/CSFML/Graphics/RenderWindow.cpp @@ -40,7 +40,6 @@ #include #include #include -#include #include #include #include @@ -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(title))); + assert(renderWindow); + renderWindow->This.setTitle(reinterpret_cast(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(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(vertices), - vertexCount, - static_cast(type), - convertRenderStates(states))); + assert(renderWindow); + renderWindow->This.draw(reinterpret_cast(vertices), + vertexCount, + static_cast(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); } diff --git a/src/CSFML/Graphics/Shader.cpp b/src/CSFML/Graphics/Shader.cpp index 095464fe..750af239 100644 --- a/src/CSFML/Graphics/Shader.cpp +++ b/src/CSFML/Graphics/Shader.cpp @@ -30,7 +30,6 @@ #include #include #include -#include //////////////////////////////////////////////////////////// @@ -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(vectorArray), length)); + assert(shader); + shader->This.setUniformArray(name, reinterpret_cast(vectorArray), length); } //////////////////////////////////////////////////////////// void sfShader_setVec3UniformArray(sfShader* shader, const char* name, const sfGlslVec3* vectorArray, size_t length) { - CSFML_CALL(shader, setUniformArray(name, reinterpret_cast(vectorArray), length)); + assert(shader); + shader->This.setUniformArray(name, reinterpret_cast(vectorArray), length); } //////////////////////////////////////////////////////////// void sfShader_setVec4UniformArray(sfShader* shader, const char* name, const sfGlslVec4* vectorArray, size_t length) { - CSFML_CALL(shader, setUniformArray(name, reinterpret_cast(vectorArray), length)); + assert(shader); + shader->This.setUniformArray(name, reinterpret_cast(vectorArray), length); } //////////////////////////////////////////////////////////// void sfShader_setMat3UniformArray(sfShader* shader, const char* name, const sfGlslMat3* matrixArray, size_t length) { - CSFML_CALL(shader, setUniformArray(name, reinterpret_cast(matrixArray), length)); + assert(shader); + shader->This.setUniformArray(name, reinterpret_cast(matrixArray), length); } //////////////////////////////////////////////////////////// void sfShader_setMat4UniformArray(sfShader* shader, const char* name, const sfGlslMat4* matrixArray, size_t length) { - CSFML_CALL(shader, setUniformArray(name, reinterpret_cast(matrixArray), length)); + assert(shader); + shader->This.setUniformArray(name, reinterpret_cast(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(); } diff --git a/src/CSFML/Graphics/Shape.cpp b/src/CSFML/Graphics/Shape.cpp index 2fb71090..4b2f8425 100644 --- a/src/CSFML/Graphics/Shape.cpp +++ b/src/CSFML/Graphics/Shape.cpp @@ -30,7 +30,6 @@ #include #include #include -#include #include #include @@ -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(); } diff --git a/src/CSFML/Graphics/Sprite.cpp b/src/CSFML/Graphics/Sprite.cpp index 415c7992..81be8f36 100644 --- a/src/CSFML/Graphics/Sprite.cpp +++ b/src/CSFML/Graphics/Sprite.cpp @@ -30,7 +30,6 @@ #include #include #include -#include #include #include @@ -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()); } diff --git a/src/CSFML/Graphics/Text.cpp b/src/CSFML/Graphics/Text.cpp index b4b1ef16..bef88cd8 100644 --- a/src/CSFML/Graphics/Text.cpp +++ b/src/CSFML/Graphics/Text.cpp @@ -31,7 +31,6 @@ #include #include #include -#include #include #include @@ -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(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(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()); } diff --git a/src/CSFML/Graphics/Texture.cpp b/src/CSFML/Graphics/Texture.cpp index dbb2fa90..40590c69 100644 --- a/src/CSFML/Graphics/Texture.cpp +++ b/src/CSFML/Graphics/Texture.cpp @@ -31,7 +31,6 @@ #include #include #include -#include #include #include @@ -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(); } diff --git a/src/CSFML/Graphics/Transform.cpp b/src/CSFML/Graphics/Transform.cpp index ab9e4b03..9839e33a 100644 --- a/src/CSFML/Graphics/Transform.cpp +++ b/src/CSFML/Graphics/Transform.cpp @@ -28,7 +28,6 @@ #include #include #include -#include #include #include @@ -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) { diff --git a/src/CSFML/Graphics/Transformable.cpp b/src/CSFML/Graphics/Transformable.cpp index fbe18cbc..c6d2b23a 100644 --- a/src/CSFML/Graphics/Transformable.cpp +++ b/src/CSFML/Graphics/Transformable.cpp @@ -28,7 +28,6 @@ #include #include #include -#include #include @@ -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; } diff --git a/src/CSFML/Graphics/VertexArray.cpp b/src/CSFML/Graphics/VertexArray.cpp index c842ea9a..989018be 100644 --- a/src/CSFML/Graphics/VertexArray.cpp +++ b/src/CSFML/Graphics/VertexArray.cpp @@ -28,7 +28,6 @@ #include #include #include -#include //////////////////////////////////////////////////////////// @@ -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(&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(vertex))); + assert(vertexArray); + vertexArray->This.append(reinterpret_cast(vertex)); } //////////////////////////////////////////////////////////// void sfVertexArray_setPrimitiveType(sfVertexArray* vertexArray, sfPrimitiveType type) { - CSFML_CALL(vertexArray, setPrimitiveType(static_cast(type))); + assert(vertexArray); + vertexArray->This.setPrimitiveType(static_cast(type)); } //////////////////////////////////////////////////////////// sfPrimitiveType sfVertexArray_getPrimitiveType(sfVertexArray* vertexArray) { - CSFML_CHECK_RETURN(vertexArray, sfPoints); + assert(vertexArray); return static_cast(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()); } diff --git a/src/CSFML/Graphics/VertexBuffer.cpp b/src/CSFML/Graphics/VertexBuffer.cpp index a2712369..592137b2 100644 --- a/src/CSFML/Graphics/VertexBuffer.cpp +++ b/src/CSFML/Graphics/VertexBuffer.cpp @@ -27,7 +27,6 @@ //////////////////////////////////////////////////////////// #include #include -#include //////////////////////////////////////////////////////////// @@ -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(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(vertices), vertexCount, offset), false); + assert(vertexBuffer); + return vertexBuffer->This.update(reinterpret_cast(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(type))); + assert(vertexBuffer); + vertexBuffer->This.setPrimitiveType(static_cast(type)); } //////////////////////////////////////////////////////////// sfPrimitiveType sfVertexBuffer_getPrimitiveType(const sfVertexBuffer* vertexBuffer) { - CSFML_CHECK_RETURN(vertexBuffer, sfPoints); + assert(vertexBuffer); return static_cast(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(usage))); + assert(vertexBuffer); + vertexBuffer->This.setUsage(static_cast(usage)); } //////////////////////////////////////////////////////////// sfVertexBufferUsage sfVertexBuffer_getUsage(const sfVertexBuffer* vertexBuffer) { - CSFML_CHECK_RETURN(vertexBuffer, sfVertexBufferStream); + assert(vertexBuffer); return static_cast(vertexBuffer->This.getUsage()); } diff --git a/src/CSFML/Graphics/View.cpp b/src/CSFML/Graphics/View.cpp index 81dcddb3..cdbf89bf 100644 --- a/src/CSFML/Graphics/View.cpp +++ b/src/CSFML/Graphics/View.cpp @@ -28,7 +28,6 @@ #include #include #include -#include #include @@ -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); } diff --git a/src/CSFML/Internal.hpp b/src/CSFML/Internal.hpp deleted file mode 100644 index ad8560bb..00000000 --- a/src/CSFML/Internal.hpp +++ /dev/null @@ -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 - -#include - -#include - -#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)); diff --git a/src/CSFML/Network/Ftp.cpp b/src/CSFML/Network/Ftp.cpp index eff0529f..35ae9c0a 100644 --- a/src/CSFML/Network/Ftp.cpp +++ b/src/CSFML/Network/Ftp.cpp @@ -26,7 +26,6 @@ // Headers //////////////////////////////////////////////////////////// #include -#include #include #include @@ -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(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(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(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 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(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(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 : "")); } diff --git a/src/CSFML/Network/Http.cpp b/src/CSFML/Network/Http.cpp index 9cea7eed..8ad00608 100644 --- a/src/CSFML/Network/Http.cpp +++ b/src/CSFML/Network/Http.cpp @@ -25,7 +25,6 @@ //////////////////////////////////////////////////////////// // Headers //////////////////////////////////////////////////////////// -#include #include #include @@ -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(method))); + assert(httpRequest); + httpRequest->This.setMethod(static_cast(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(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)); diff --git a/src/CSFML/Network/Packet.cpp b/src/CSFML/Network/Packet.cpp index 7c291fec..901bb652 100644 --- a/src/CSFML/Network/Packet.cpp +++ b/src/CSFML/Network/Packet.cpp @@ -25,10 +25,11 @@ //////////////////////////////////////////////////////////// // Headers //////////////////////////////////////////////////////////// -#include #include #include +#include + //////////////////////////////////////////////////////////// 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(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; } diff --git a/src/CSFML/Network/SocketSelector.cpp b/src/CSFML/Network/SocketSelector.cpp index 1dd23bbd..5eaeab02 100644 --- a/src/CSFML/Network/SocketSelector.cpp +++ b/src/CSFML/Network/SocketSelector.cpp @@ -25,7 +25,6 @@ //////////////////////////////////////////////////////////// // Headers //////////////////////////////////////////////////////////// -#include #include #include #include @@ -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); } diff --git a/src/CSFML/Network/TcpListener.cpp b/src/CSFML/Network/TcpListener.cpp index bf3b7e1d..e99499a7 100644 --- a/src/CSFML/Network/TcpListener.cpp +++ b/src/CSFML/Network/TcpListener.cpp @@ -25,7 +25,6 @@ //////////////////////////////////////////////////////////// // Headers //////////////////////////////////////////////////////////// -#include #include #include #include @@ -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 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(listener->This.accept((*connected)->This)); diff --git a/src/CSFML/Network/TcpSocket.cpp b/src/CSFML/Network/TcpSocket.cpp index b28f834a..422381d3 100644 --- a/src/CSFML/Network/TcpSocket.cpp +++ b/src/CSFML/Network/TcpSocket.cpp @@ -25,7 +25,6 @@ //////////////////////////////////////////////////////////// // Headers //////////////////////////////////////////////////////////// -#include #include #include #include @@ -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 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(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(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(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(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(socket->This.receive(packet->This)); } diff --git a/src/CSFML/Network/UdpSocket.cpp b/src/CSFML/Network/UdpSocket.cpp index b5cdf8fd..bde46f77 100644 --- a/src/CSFML/Network/UdpSocket.cpp +++ b/src/CSFML/Network/UdpSocket.cpp @@ -25,7 +25,6 @@ //////////////////////////////////////////////////////////// // Headers //////////////////////////////////////////////////////////// -#include #include #include #include @@ -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 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 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 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 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 address; unsigned short port; diff --git a/src/CSFML/System/Buffer.cpp b/src/CSFML/System/Buffer.cpp index 4d9737ef..8fda3826 100644 --- a/src/CSFML/System/Buffer.cpp +++ b/src/CSFML/System/Buffer.cpp @@ -25,10 +25,11 @@ //////////////////////////////////////////////////////////// // Headers //////////////////////////////////////////////////////////// -#include #include #include +#include + //////////////////////////////////////////////////////////// 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; } diff --git a/src/CSFML/System/Clock.cpp b/src/CSFML/System/Clock.cpp index 8ff158b6..5994ff6b 100644 --- a/src/CSFML/System/Clock.cpp +++ b/src/CSFML/System/Clock.cpp @@ -25,7 +25,6 @@ //////////////////////////////////////////////////////////// // Headers //////////////////////////////////////////////////////////// -#include #include #include @@ -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()}; } diff --git a/src/CSFML/System/Sleep.cpp b/src/CSFML/System/Sleep.cpp index 9b1f32bf..7107a637 100644 --- a/src/CSFML/System/Sleep.cpp +++ b/src/CSFML/System/Sleep.cpp @@ -25,7 +25,6 @@ //////////////////////////////////////////////////////////// // Headers //////////////////////////////////////////////////////////// -#include #include #include diff --git a/src/CSFML/Window/Clipboard.cpp b/src/CSFML/Window/Clipboard.cpp index c342062f..9d39ea4f 100644 --- a/src/CSFML/Window/Clipboard.cpp +++ b/src/CSFML/Window/Clipboard.cpp @@ -25,7 +25,6 @@ //////////////////////////////////////////////////////////// // Headers //////////////////////////////////////////////////////////// -#include #include #include diff --git a/src/CSFML/Window/Context.cpp b/src/CSFML/Window/Context.cpp index abda8f60..aebd961f 100644 --- a/src/CSFML/Window/Context.cpp +++ b/src/CSFML/Window/Context.cpp @@ -25,7 +25,6 @@ //////////////////////////////////////////////////////////// // Headers //////////////////////////////////////////////////////////// -#include #include #include #include @@ -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()); } diff --git a/src/CSFML/Window/Cursor.cpp b/src/CSFML/Window/Cursor.cpp index 70139c7c..ae7749a7 100644 --- a/src/CSFML/Window/Cursor.cpp +++ b/src/CSFML/Window/Cursor.cpp @@ -25,7 +25,6 @@ //////////////////////////////////////////////////////////// // Headers //////////////////////////////////////////////////////////// -#include #include #include #include diff --git a/src/CSFML/Window/Joystick.cpp b/src/CSFML/Window/Joystick.cpp index 84ebfc4f..4f885d0f 100644 --- a/src/CSFML/Window/Joystick.cpp +++ b/src/CSFML/Window/Joystick.cpp @@ -25,7 +25,6 @@ //////////////////////////////////////////////////////////// // Headers //////////////////////////////////////////////////////////// -#include #include #include diff --git a/src/CSFML/Window/Keyboard.cpp b/src/CSFML/Window/Keyboard.cpp index 518305a4..acbb2463 100644 --- a/src/CSFML/Window/Keyboard.cpp +++ b/src/CSFML/Window/Keyboard.cpp @@ -25,7 +25,6 @@ //////////////////////////////////////////////////////////// // Headers //////////////////////////////////////////////////////////// -#include #include #include diff --git a/src/CSFML/Window/Mouse.cpp b/src/CSFML/Window/Mouse.cpp index 1fa8dcc0..f900ca56 100644 --- a/src/CSFML/Window/Mouse.cpp +++ b/src/CSFML/Window/Mouse.cpp @@ -25,7 +25,6 @@ //////////////////////////////////////////////////////////// // Headers //////////////////////////////////////////////////////////// -#include #include #include #include diff --git a/src/CSFML/Window/Sensor.cpp b/src/CSFML/Window/Sensor.cpp index e954a1b0..2fedd271 100644 --- a/src/CSFML/Window/Sensor.cpp +++ b/src/CSFML/Window/Sensor.cpp @@ -25,7 +25,6 @@ //////////////////////////////////////////////////////////// // Headers //////////////////////////////////////////////////////////// -#include #include #include diff --git a/src/CSFML/Window/Touch.cpp b/src/CSFML/Window/Touch.cpp index ca1df482..8255fbf4 100644 --- a/src/CSFML/Window/Touch.cpp +++ b/src/CSFML/Window/Touch.cpp @@ -25,7 +25,6 @@ //////////////////////////////////////////////////////////// // Headers //////////////////////////////////////////////////////////// -#include #include #include #include diff --git a/src/CSFML/Window/VideoMode.cpp b/src/CSFML/Window/VideoMode.cpp index 03b1222c..ef20b237 100644 --- a/src/CSFML/Window/VideoMode.cpp +++ b/src/CSFML/Window/VideoMode.cpp @@ -25,7 +25,6 @@ //////////////////////////////////////////////////////////// // Headers //////////////////////////////////////////////////////////// -#include #include #include diff --git a/src/CSFML/Window/Window.cpp b/src/CSFML/Window/Window.cpp index 2978ba0b..2089fbbf 100644 --- a/src/CSFML/Window/Window.cpp +++ b/src/CSFML/Window/Window.cpp @@ -26,7 +26,6 @@ // Headers //////////////////////////////////////////////////////////// #include -#include #include #include #include @@ -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(title))); + assert(window); + window->This.setTitle(reinterpret_cast(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(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); } diff --git a/src/CSFML/Window/WindowBase.cpp b/src/CSFML/Window/WindowBase.cpp index 19a3da91..861e6d19 100644 --- a/src/CSFML/Window/WindowBase.cpp +++ b/src/CSFML/Window/WindowBase.cpp @@ -26,7 +26,6 @@ // Headers //////////////////////////////////////////////////////////// #include -#include #include #include #include @@ -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(title))); + assert(windowBase); + windowBase->This.setTitle(reinterpret_cast(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(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); }