Use C standard library utilities for booleans and fixed-width ints

cmake/Macros.cmake

@@ -19,8 +19,8 @@ macro(csfml_add_library target)
     # add warnings
     set_file_warnings(${THIS_SOURCES})
 
-    # require C++17
+    # require C99 and C++17
-    target_compile_features(${target} PUBLIC cxx_std_17)
+    target_compile_features(${target} PUBLIC c_std_99 cxx_std_17)
 
     # define the export symbol of the module
     string(REPLACE "-" "_" NAME_UPPER "${target}")

doc/mainpage.hpp

@@ -36,7 +36,7 @@
 ///     if (!texture)
 ///         return EXIT_FAILURE;
 ///     sprite = sfSprite_create();
-///     sfSprite_setTexture(sprite, texture, sfTrue);
+///     sfSprite_setTexture(sprite, texture, true);
 /// 
 ///     /* Create a graphical text to display */
 ///     font = sfFont_createFromFile("arial.ttf");

examples/example.c

@@ -19,7 +19,7 @@ int main(void)
         return EXIT_FAILURE;
     }
     sfSprite* sprite = sfSprite_create();
-    sfSprite_setTexture(sprite, texture, sfTrue);
+    sfSprite_setTexture(sprite, texture, true);
     const sfVector2f spritePosition = {200, 200};
     sfSprite_setPosition(sprite, spritePosition);
 

include/SFML/Audio/Music.h

@@ -110,24 +110,24 @@ CSFML_AUDIO_API void sfMusic_destroy(sfMusic* music);
 ///
 /// If set, the music will restart from beginning after
 /// reaching the end and so on, until it is stopped or
-/// sfMusic_setLoop(music, sfFalse) is called.
+/// sfMusic_setLoop(music, false) is called.
 /// The default looping state for musics is false.
 ///
 /// \param music Music object
-/// \param loop  sfTrue to play in loop, sfFalse to play once
+/// \param loop  true to play in loop, false to play once
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfMusic_setLoop(sfMusic* music, sfBool loop);
+CSFML_AUDIO_API void sfMusic_setLoop(sfMusic* music, bool loop);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether or not a music is in loop mode
 ///
 /// \param music Music object
 ///
-/// \return sfTrue if the music is looping, sfFalse otherwise
+/// \return true if the music is looping, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfBool sfMusic_getLoop(const sfMusic* music);
+CSFML_AUDIO_API bool sfMusic_getLoop(const sfMusic* music);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the total duration of a music
@@ -310,10 +310,10 @@ CSFML_AUDIO_API void sfMusic_setPosition(sfMusic* music, sfVector3f position);
 /// The default value is false (position is absolute).
 ///
 /// \param music    Music object
-/// \param relative sfTrue to set the position relative, sfFalse to set it absolute
+/// \param relative true to set the position relative, false to set it absolute
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfMusic_setRelativeToListener(sfMusic* music, sfBool relative);
+CSFML_AUDIO_API void sfMusic_setRelativeToListener(sfMusic* music, bool relative);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the minimum distance of a music
@@ -397,10 +397,10 @@ CSFML_AUDIO_API sfVector3f sfMusic_getPosition(const sfMusic* music);
 ///
 /// \param music Music object
 ///
-/// \return sfTrue if the position is relative, sfFalse if it's absolute
+/// \return true if the position is relative, false if it's absolute
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfBool sfMusic_isRelativeToListener(const sfMusic* music);
+CSFML_AUDIO_API bool sfMusic_isRelativeToListener(const sfMusic* music);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the minimum distance of a music

include/SFML/Audio/Sound.h

@@ -126,24 +126,24 @@ CSFML_AUDIO_API const sfSoundBuffer* sfSound_getBuffer(const sfSound* sound);
 ///
 /// If set, the sound will restart from beginning after
 /// reaching the end and so on, until it is stopped or
-/// sfSound_setLoop(sound, sfFalse) is called.
+/// sfSound_setLoop(sound, false) is called.
 /// The default looping state for sounds is false.
 ///
 /// \param sound Sound object
-/// \param loop  sfTrue to play in loop, sfFalse to play once
+/// \param loop  true to play in loop, false to play once
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfSound_setLoop(sfSound* sound, sfBool loop);
+CSFML_AUDIO_API void sfSound_setLoop(sfSound* sound, bool loop);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether or not a sound is in loop mode
 ///
 /// \param sound Sound object
 ///
-/// \return sfTrue if the sound is looping, sfFalse otherwise
+/// \return true if the sound is looping, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfBool sfSound_getLoop(const sfSound* sound);
+CSFML_AUDIO_API bool sfSound_getLoop(const sfSound* sound);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the current status of a sound (stopped, paused, playing)
@@ -205,10 +205,10 @@ CSFML_AUDIO_API void sfSound_setPosition(sfSound* sound, sfVector3f position);
 /// The default value is false (position is absolute).
 ///
 /// \param sound    Sound object
-/// \param relative sfTrue to set the position relative, sfFalse to set it absolute
+/// \param relative true to set the position relative, false to set it absolute
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfSound_setRelativeToListener(sfSound* sound, sfBool relative);
+CSFML_AUDIO_API void sfSound_setRelativeToListener(sfSound* sound, bool relative);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the minimum distance of a sound
@@ -292,10 +292,10 @@ CSFML_AUDIO_API sfVector3f sfSound_getPosition(const sfSound* sound);
 ///
 /// \param sound Sound object
 ///
-/// \return sfTrue if the position is relative, sfFalse if it's absolute
+/// \return true if the position is relative, false if it's absolute
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfBool sfSound_isRelativeToListener(const sfSound* sound);
+CSFML_AUDIO_API bool sfSound_isRelativeToListener(const sfSound* sound);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the minimum distance of a sound

include/SFML/Audio/SoundBuffer.h

@@ -82,7 +82,7 @@ CSFML_AUDIO_API sfSoundBuffer* sfSoundBuffer_createFromStream(sfInputStream* str
 /// \brief Create a new sound buffer and load it from an array of samples in memory
 ///
 /// The assumed format of the audio samples is 16 bits signed integer
-/// (sfInt16).
+/// (int16_t).
 ///
 /// \param samples      Pointer to the array of samples in memory
 /// \param sampleCount  Number of samples in the array
@@ -92,7 +92,7 @@ CSFML_AUDIO_API sfSoundBuffer* sfSoundBuffer_createFromStream(sfInputStream* str
 /// \return A new sfSoundBuffer object (NULL if failed)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfSoundBuffer* sfSoundBuffer_createFromSamples(const sfInt16* samples, sfUint64 sampleCount, unsigned int channelCount, unsigned int sampleRate);
+CSFML_AUDIO_API sfSoundBuffer* sfSoundBuffer_createFromSamples(const int16_t* samples, uint64_t sampleCount, unsigned int channelCount, unsigned int sampleRate);
 
 ////////////////////////////////////////////////////////////
 /// \brief Create a new sound buffer by copying an existing one
@@ -122,16 +122,16 @@ CSFML_AUDIO_API void sfSoundBuffer_destroy(sfSoundBuffer* soundBuffer);
 /// \param soundBuffer Sound buffer object
 /// \param filename    Path of the sound file to write
 ///
-/// \return sfTrue if saving succeeded, sfFalse if it failed
+/// \return true if saving succeeded, false if it failed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfBool sfSoundBuffer_saveToFile(const sfSoundBuffer* soundBuffer, const char* filename);
+CSFML_AUDIO_API bool sfSoundBuffer_saveToFile(const sfSoundBuffer* soundBuffer, const char* filename);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the array of audio samples stored in a sound buffer
 ///
 /// The format of the returned samples is 16 bits signed integer
-/// (sfInt16). The total number of samples in this array
+/// (int16_t). The total number of samples in this array
 /// is given by the sfSoundBuffer_getSampleCount function.
 ///
 /// \param soundBuffer Sound buffer object
@@ -139,7 +139,7 @@ CSFML_AUDIO_API sfBool sfSoundBuffer_saveToFile(const sfSoundBuffer* soundBuffer
 /// \return Read-only pointer to the array of sound samples
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API const sfInt16* sfSoundBuffer_getSamples(const sfSoundBuffer* soundBuffer);
+CSFML_AUDIO_API const int16_t* sfSoundBuffer_getSamples(const sfSoundBuffer* soundBuffer);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the number of samples stored in a sound buffer
@@ -152,7 +152,7 @@ CSFML_AUDIO_API const sfInt16* sfSoundBuffer_getSamples(const sfSoundBuffer* sou
 /// \return Number of samples
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfUint64 sfSoundBuffer_getSampleCount(const sfSoundBuffer* soundBuffer);
+CSFML_AUDIO_API uint64_t sfSoundBuffer_getSampleCount(const sfSoundBuffer* soundBuffer);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the sample rate of a sound buffer

include/SFML/Audio/SoundBufferRecorder.h

@@ -61,10 +61,10 @@ CSFML_AUDIO_API void sfSoundBufferRecorder_destroy(sfSoundBufferRecorder* soundB
 /// \param soundBufferRecorder Sound buffer recorder object
 /// \param sampleRate          Desired capture rate, in number of samples per second
 ///
-/// \return sfTrue, if it was able to start recording
+/// \return true, if it was able to start recording
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfBool sfSoundBufferRecorder_start(sfSoundBufferRecorder* soundBufferRecorder, unsigned int sampleRate);
+CSFML_AUDIO_API bool sfSoundBufferRecorder_start(sfSoundBufferRecorder* soundBufferRecorder, unsigned int sampleRate);
 
 ////////////////////////////////////////////////////////////
 /// \brief Stop the capture of a sound recorder
@@ -114,10 +114,10 @@ CSFML_AUDIO_API const sfSoundBuffer* sfSoundBufferRecorder_getBuffer(const sfSou
 /// \param soundBufferRecorder Sound buffer recorder object
 /// \param name                The name of the audio capture device
 ///
-/// \return sfTrue, if it was able to set the requested device
+/// \return true, if it was able to set the requested device
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfBool sfSoundBufferRecorder_setDevice(sfSoundBufferRecorder* soundBufferRecorder, const char* name);
+CSFML_AUDIO_API bool sfSoundBufferRecorder_setDevice(sfSoundBufferRecorder* soundBufferRecorder, const char* name);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the name of the current audio capture device

include/SFML/Audio/SoundRecorder.h

@@ -34,9 +34,9 @@
 #include <stddef.h>
 
 
-typedef sfBool (*sfSoundRecorderStartCallback)(void*);                           ///< Type of the callback used when starting a capture
+typedef bool (*sfSoundRecorderStartCallback)(void*);                           ///< Type of the callback used when starting a capture
-typedef sfBool (*sfSoundRecorderProcessCallback)(const sfInt16*, size_t, void*); ///< Type of the callback used to process audio data
+typedef bool (*sfSoundRecorderProcessCallback)(const int16_t*, size_t, void*); ///< Type of the callback used to process audio data
-typedef void   (*sfSoundRecorderStopCallback)(void*);                            ///< Type of the callback used when stopping a capture
+typedef void (*sfSoundRecorderStopCallback)(void*);                            ///< Type of the callback used when stopping a capture
 
 
 ////////////////////////////////////////////////////////////
@@ -79,7 +79,7 @@ CSFML_AUDIO_API void sfSoundRecorder_destroy(sfSoundRecorder* soundRecorder);
 /// \return True, if start of capture was successful
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfBool sfSoundRecorder_start(sfSoundRecorder* soundRecorder, unsigned int sampleRate);
+CSFML_AUDIO_API bool sfSoundRecorder_start(sfSoundRecorder* soundRecorder, unsigned int sampleRate);
 
 ////////////////////////////////////////////////////////////
 /// \brief Stop the capture of a sound recorder
@@ -110,10 +110,10 @@ CSFML_AUDIO_API unsigned int sfSoundRecorder_getSampleRate(const sfSoundRecorder
 /// the audio capture features. If it returns false, then
 /// any attempt to use sfSoundRecorder will fail.
 ///
-/// \return sfTrue if audio capture is supported, sfFalse otherwise
+/// \return true if audio capture is supported, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfBool sfSoundRecorder_isAvailable(void);
+CSFML_AUDIO_API bool sfSoundRecorder_isAvailable(void);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the processing interval
@@ -170,10 +170,10 @@ CSFML_AUDIO_API const char* sfSoundRecorder_getDefaultDevice(void);
 /// \param soundRecorder Sound recorder object
 /// \param name          The name of the audio capture device
 ///
-/// \return sfTrue, if it was able to set the requested device
+/// \return true, if it was able to set the requested device
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfBool sfSoundRecorder_setDevice(sfSoundRecorder* soundRecorder, const char* name);
+CSFML_AUDIO_API bool sfSoundRecorder_setDevice(sfSoundRecorder* soundRecorder, const char* name);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the name of the current audio capture device

include/SFML/Audio/SoundStream.h

@@ -41,12 +41,12 @@
 ////////////////////////////////////////////////////////////
 typedef struct
 {
-    sfInt16*     samples;     ///< Pointer to the audio samples
+    int16_t*     samples;     ///< Pointer to the audio samples
     unsigned int sampleCount; ///< Number of samples pointed by Samples
 } sfSoundStreamChunk;
 
-typedef sfBool (*sfSoundStreamGetDataCallback)(sfSoundStreamChunk*, void*); ///< Type of the callback used to get a sound stream data
+typedef bool (*sfSoundStreamGetDataCallback)(sfSoundStreamChunk*, void*); ///< Type of the callback used to get a sound stream data
-typedef void   (*sfSoundStreamSeekCallback)(sfTime, void*);                 ///< Type of the callback used to seek in a sound stream
+typedef void (*sfSoundStreamSeekCallback)(sfTime, void*);                 ///< Type of the callback used to seek in a sound stream
 
 
 ////////////////////////////////////////////////////////////
@@ -197,10 +197,10 @@ CSFML_AUDIO_API void sfSoundStream_setPosition(sfSoundStream* soundStream, sfVec
 /// The default value is false (position is absolute).
 ///
 /// \param soundStream Sound stream object
-/// \param relative    sfTrue to set the position relative, sfFalse to set it absolute
+/// \param relative    true to set the position relative, false to set it absolute
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfSoundStream_setRelativeToListener(sfSoundStream* soundStream, sfBool relative);
+CSFML_AUDIO_API void sfSoundStream_setRelativeToListener(sfSoundStream* soundStream, bool relative);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the minimum distance of a sound stream
@@ -253,14 +253,14 @@ CSFML_AUDIO_API void sfSoundStream_setPlayingOffset(sfSoundStream* soundStream,
 ///
 /// If set, the stream will restart from beginning after
 /// reaching the end and so on, until it is stopped or
-/// sfSoundStream_setLoop(stream, sfFalse) is called.
+/// sfSoundStream_setLoop(stream, false) is called.
 /// The default looping state for sound streams is false.
 ///
 /// \param soundStream Sound stream object
-/// \param loop        sfTrue to play in loop, sfFalse to play once
+/// \param loop        true to play in loop, false to play once
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API void sfSoundStream_setLoop(sfSoundStream* soundStream, sfBool loop);
+CSFML_AUDIO_API void sfSoundStream_setLoop(sfSoundStream* soundStream, bool loop);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the pitch of a sound stream
@@ -298,10 +298,10 @@ CSFML_AUDIO_API sfVector3f sfSoundStream_getPosition(const sfSoundStream* soundS
 ///
 /// \param soundStream Sound stream object
 ///
-/// \return sfTrue if the position is relative, sfFalse if it's absolute
+/// \return true if the position is relative, false if it's absolute
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfBool sfSoundStream_isRelativeToListener(const sfSoundStream* soundStream);
+CSFML_AUDIO_API bool sfSoundStream_isRelativeToListener(const sfSoundStream* soundStream);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the minimum distance of a sound stream
@@ -328,10 +328,10 @@ CSFML_AUDIO_API float sfSoundStream_getAttenuation(const sfSoundStream* soundStr
 ///
 /// \param soundStream Sound stream object
 ///
-/// \return sfTrue if the music is looping, sfFalse otherwise
+/// \return true if the music is looping, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_AUDIO_API sfBool sfSoundStream_getLoop(const sfSoundStream* soundStream);
+CSFML_AUDIO_API bool sfSoundStream_getLoop(const sfSoundStream* soundStream);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the current playing position of a sound stream

include/SFML/Config.h

@@ -25,6 +25,13 @@
 #ifndef SFML_CONFIG_H
 #define SFML_CONFIG_H
 
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+
+#include <stdint.h>
+#include <stdbool.h>
+
 
 ////////////////////////////////////////////////////////////
 // Define the CSFML version
@@ -135,42 +142,4 @@
 
 #endif
 
-////////////////////////////////////////////////////////////
-// Define a portable boolean type
-////////////////////////////////////////////////////////////
-typedef int sfBool;
-#define sfFalse 0
-#define sfTrue  1
-
-
-////////////////////////////////////////////////////////////
-// Define portable fixed-size types
-////////////////////////////////////////////////////////////
-
-// All "common" platforms use the same size for char, short and int
-// (basically there are 3 types for 3 sizes, so no other match is possible),
-// we can use them without doing any kind of check
-
-// 8 bits integer types
-typedef signed   char sfInt8;
-typedef unsigned char sfUint8;
-
-// 16 bits integer types
-typedef signed   short sfInt16;
-typedef unsigned short sfUint16;
-
-// 32 bits integer types
-typedef signed   int sfInt32;
-typedef unsigned int sfUint32;
-
-// 64 bits integer types
-#if defined(_MSC_VER)
-    typedef signed   __int64 sfInt64;
-    typedef unsigned __int64 sfUint64;
-#else
-    typedef signed   long long sfInt64;
-    typedef unsigned long long sfUint64;
-#endif
-
-
 #endif // SFML_CONFIG_H

include/SFML/Graphics/CircleShape.h

@@ -235,7 +235,7 @@ CSFML_GRAPHICS_API sfTransform sfCircleShape_getInverseTransform(const sfCircleS
 /// \param resetRect Should the texture rect be reset to the size of the new texture?
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfCircleShape_setTexture(sfCircleShape* shape, const sfTexture* texture, sfBool resetRect);
+CSFML_GRAPHICS_API void sfCircleShape_setTexture(sfCircleShape* shape, const sfTexture* texture, bool resetRect);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the sub-rectangle of the texture that a circle shape will display

include/SFML/Graphics/Color.h

@@ -37,10 +37,10 @@
 ////////////////////////////////////////////////////////////
 typedef struct
 {
-    sfUint8 r;
+    uint8_t r;
-    sfUint8 g;
+    uint8_t g;
-    sfUint8 b;
+    uint8_t b;
-    sfUint8 a;
+    uint8_t a;
 } sfColor;
 
 
@@ -65,7 +65,7 @@ CSFML_GRAPHICS_API sfColor sfTransparent; ///< Transparent (black) predefined co
 /// \return sfColor constructed from the components
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfColor sfColor_fromRGB(sfUint8 red, sfUint8 green, sfUint8 blue);
+CSFML_GRAPHICS_API sfColor sfColor_fromRGB(uint8_t red, uint8_t green, uint8_t blue);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct a color from its 4 RGBA components
@@ -78,7 +78,7 @@ CSFML_GRAPHICS_API sfColor sfColor_fromRGB(sfUint8 red, sfUint8 green, sfUint8 b
 /// \return sfColor constructed from the components
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfColor sfColor_fromRGBA(sfUint8 red, sfUint8 green, sfUint8 blue, sfUint8 alpha);
+CSFML_GRAPHICS_API sfColor sfColor_fromRGBA(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct the color from 32-bit unsigned integer
@@ -88,7 +88,7 @@ CSFML_GRAPHICS_API sfColor sfColor_fromRGBA(sfUint8 red, sfUint8 green, sfUint8
 /// \return sfColor constructed from the 32-bit unsigned integer
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfColor sfColor_fromInteger(sfUint32 color);
+CSFML_GRAPHICS_API sfColor sfColor_fromInteger(uint32_t color);
 
 ////////////////////////////////////////////////////////////
 /// \brief Convert a color to a 32-bit unsigned integer
@@ -96,7 +96,7 @@ CSFML_GRAPHICS_API sfColor sfColor_fromInteger(sfUint32 color);
 /// \return Color represented as a 32-bit unsigned integer
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfUint32 sfColor_toInteger(sfColor color);
+CSFML_GRAPHICS_API uint32_t sfColor_toInteger(sfColor color);
 
 ////////////////////////////////////////////////////////////
 /// \brief Add two colors

include/SFML/Graphics/ConvexShape.h

@@ -235,7 +235,7 @@ CSFML_GRAPHICS_API sfTransform sfConvexShape_getInverseTransform(const sfConvexS
 /// \param resetRect Should the texture rect be reset to the size of the new texture?
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfConvexShape_setTexture(sfConvexShape* shape, const sfTexture* texture, sfBool resetRect);
+CSFML_GRAPHICS_API void sfConvexShape_setTexture(sfConvexShape* shape, const sfTexture* texture, bool resetRect);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the sub-rectangle of the texture that a convex shape will display

include/SFML/Graphics/Font.h

@@ -97,7 +97,7 @@ CSFML_GRAPHICS_API void sfFont_destroy(sfFont* font);
 /// \return The corresponding glyph
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfGlyph sfFont_getGlyph(const sfFont* font, sfUint32 codePoint, unsigned int characterSize, sfBool bold, float outlineThickness);
+CSFML_GRAPHICS_API sfGlyph sfFont_getGlyph(const sfFont* font, uint32_t codePoint, unsigned int characterSize, bool bold, float outlineThickness);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the kerning value corresponding to a given pair of characters in a font
@@ -110,7 +110,7 @@ CSFML_GRAPHICS_API sfGlyph sfFont_getGlyph(const sfFont* font, sfUint32 codePoin
 /// \return Kerning offset, in pixels
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API float sfFont_getKerning(const sfFont* font, sfUint32 first, sfUint32 second, unsigned int characterSize);
+CSFML_GRAPHICS_API float sfFont_getKerning(const sfFont* font, uint32_t first, uint32_t second, unsigned int characterSize);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the bold kerning value corresponding to a given pair of characters in a font
@@ -123,7 +123,7 @@ CSFML_GRAPHICS_API float sfFont_getKerning(const sfFont* font, sfUint32 first, s
 /// \return Kerning offset, in pixels
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API float sfFont_getBoldKerning(const sfFont* font, sfUint32 first, sfUint32 second, unsigned int characterSize);
+CSFML_GRAPHICS_API float sfFont_getBoldKerning(const sfFont* font, uint32_t first, uint32_t second, unsigned int characterSize);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the line spacing value
@@ -184,24 +184,24 @@ CSFML_GRAPHICS_API const sfTexture* sfFont_getTexture(sfFont* font, unsigned int
 /// The smooth filter is enabled by default.
 ///
 /// \param font          Source font
-/// \param smooth        sfTrue to enable smoothing, sfFalse to disable it
+/// \param smooth        true to enable smoothing, false to disable it
 ///
 /// \see isSmooth
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfFont_setSmooth(sfFont* font, sfBool smooth);
+CSFML_GRAPHICS_API void sfFont_setSmooth(sfFont* font, bool smooth);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether the smooth filter is enabled or disabled
 ///
 /// \param font          Source font
 ///
-/// \return sfTrue if smoothing is enabled, sfFalse if it is disabled
+/// \return true if smoothing is enabled, false if it is disabled
 ///
 /// \see setSmooth
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfFont_isSmooth(const sfFont* font);
+CSFML_GRAPHICS_API bool sfFont_isSmooth(const sfFont* font);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the font information

include/SFML/Graphics/Glsl.h

@@ -39,8 +39,8 @@ typedef sfVector2i sfGlslIvec2;
 
 typedef struct
 {
-    sfBool x;
+    bool x;
-    sfBool y;
+    bool y;
 } sfGlslBvec2;
 
 // 3D vectors
@@ -55,9 +55,9 @@ typedef struct
 
 typedef struct
 {
-    sfBool x;
+    bool x;
-    sfBool y;
+    bool y;
-    sfBool z;
+    bool z;
 } sfGlslBvec3;
 
 // 4D vectors
@@ -79,10 +79,10 @@ typedef struct
 
 typedef struct
 {
-    sfBool x;
+    bool x;
-    sfBool y;
+    bool y;
-    sfBool z;
+    bool z;
-    sfBool w;
+    bool w;
 } sfGlslBvec4;
 
 // matrices

include/SFML/Graphics/Image.h

@@ -78,7 +78,7 @@ CSFML_GRAPHICS_API sfImage* sfImage_createFromColor(unsigned int width, unsigned
 /// \return A new sfImage object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfImage* sfImage_createFromPixels(unsigned int width, unsigned int height, const sfUint8* pixels);
+CSFML_GRAPHICS_API sfImage* sfImage_createFromPixels(unsigned int width, unsigned int height, const uint8_t* pixels);
 
 ////////////////////////////////////////////////////////////
 /// \brief Create an image from a file on disk
@@ -155,12 +155,12 @@ CSFML_GRAPHICS_API void sfImage_destroy(sfImage* image);
 /// \param image    Image object
 /// \param filename Path of the file to save
 ///
-/// \return sfTrue if saving was successful
+/// \return true if saving was successful
 ///
 /// \see sfImage_saveToMemory
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfImage_saveToFile(const sfImage* image, const char* filename);
+CSFML_GRAPHICS_API bool sfImage_saveToFile(const sfImage* image, const char* filename);
 
 ////////////////////////////////////////////////////////////
 /// \brief Save the image to a buffer in memory
@@ -174,12 +174,12 @@ CSFML_GRAPHICS_API sfBool sfImage_saveToFile(const sfImage* image, const char* f
 /// \param output Buffer to fill with encoded data
 /// \param format Encoding format to use
 ///
-/// \return sfTrue if saving was successful
+/// \return true if saving was successful
 ///
 /// \see sfImage_saveToFile
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfImage_saveToMemory(const sfImage* image, sfBuffer* output, const char* format);
+CSFML_GRAPHICS_API bool sfImage_saveToMemory(const sfImage* image, sfBuffer* output, const char* format);
 
 ////////////////////////////////////////////////////////////
 /// \brief Return the size of an image
@@ -203,7 +203,7 @@ CSFML_GRAPHICS_API sfVector2u sfImage_getSize(const sfImage* image);
 /// \param alpha Alpha value to assign to transparent pixels
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfImage_createMaskFromColor(sfImage* image, sfColor color, sfUint8 alpha);
+CSFML_GRAPHICS_API void sfImage_createMaskFromColor(sfImage* image, sfColor color, uint8_t alpha);
 
 ////////////////////////////////////////////////////////////
 /// \brief Copy pixels from an image onto another
@@ -226,7 +226,7 @@ CSFML_GRAPHICS_API void sfImage_createMaskFromColor(sfImage* image, sfColor colo
 /// \param applyAlpha Should the copy take in account the source transparency?
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfImage_copyImage(sfImage* image, const sfImage* source, unsigned int destX, unsigned int destY, sfIntRect sourceRect, sfBool applyAlpha);
+CSFML_GRAPHICS_API void sfImage_copyImage(sfImage* image, const sfImage* source, unsigned int destX, unsigned int destY, sfIntRect sourceRect, bool applyAlpha);
 
 ////////////////////////////////////////////////////////////
 /// \brief Change the color of a pixel in an image
@@ -274,7 +274,7 @@ CSFML_GRAPHICS_API sfColor sfImage_getPixel(const sfImage* image, unsigned int x
 /// \return Read-only pointer to the array of pixels
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API const sfUint8* sfImage_getPixelsPtr(const sfImage* image);
+CSFML_GRAPHICS_API const uint8_t* sfImage_getPixelsPtr(const sfImage* image);
 
 ////////////////////////////////////////////////////////////
 /// \brief Flip an image horizontally (left <-> right)

include/SFML/Graphics/Rect.h

@@ -60,11 +60,11 @@ typedef struct
 /// \param x    X coordinate of the point to test
 /// \param y    Y coordinate of the point to test
 ///
-/// \return sfTrue if the point is inside
+/// \return true if the point is inside
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfFloatRect_contains(const sfFloatRect* rect, float x, float y);
+CSFML_GRAPHICS_API bool sfFloatRect_contains(const sfFloatRect* rect, float x, float y);
-CSFML_GRAPHICS_API sfBool sfIntRect_contains(const sfIntRect* rect, int x, int y);
+CSFML_GRAPHICS_API bool sfIntRect_contains(const sfIntRect* rect, int x, int y);
 
 ////////////////////////////////////////////////////////////
 /// \brief Check intersection between two rectangles
@@ -73,11 +73,11 @@ CSFML_GRAPHICS_API sfBool sfIntRect_contains(const sfIntRect* rect, int x, int y
 /// \param rect2        Second rectangle to test
 /// \param intersection Rectangle to be filled with overlapping rect (can be NULL)
 ///
-/// \return sfTrue if rectangles overlap
+/// \return true if rectangles overlap
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfFloatRect_intersects(const sfFloatRect* rect1, const sfFloatRect* rect2, sfFloatRect* intersection);
+CSFML_GRAPHICS_API bool sfFloatRect_intersects(const sfFloatRect* rect1, const sfFloatRect* rect2, sfFloatRect* intersection);
-CSFML_GRAPHICS_API sfBool sfIntRect_intersects(const sfIntRect* rect1, const sfIntRect* rect2, sfIntRect* intersection);
+CSFML_GRAPHICS_API bool sfIntRect_intersects(const sfIntRect* rect1, const sfIntRect* rect2, sfIntRect* intersection);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the position of the rectangle's top-left corner

include/SFML/Graphics/RectangleShape.h

@@ -235,7 +235,7 @@ CSFML_GRAPHICS_API sfTransform sfRectangleShape_getInverseTransform(const sfRect
 /// \param resetRect Should the texture rect be reset to the size of the new texture?
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRectangleShape_setTexture(sfRectangleShape* shape, const sfTexture* texture, sfBool resetRect);
+CSFML_GRAPHICS_API void sfRectangleShape_setTexture(sfRectangleShape* shape, const sfTexture* texture, bool resetRect);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the sub-rectangle of the texture that a rectangle shape will display

include/SFML/Graphics/RenderTexture.h

@@ -53,7 +53,7 @@
 /// Use sfRenderTexture_createWithSettings instead.
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfRenderTexture* sfRenderTexture_create(unsigned int width, unsigned int height, sfBool depthBuffer);
+CSFML_GRAPHICS_API sfRenderTexture* sfRenderTexture_create(unsigned int width, unsigned int height, bool depthBuffer);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct a new render texture
@@ -90,21 +90,21 @@ CSFML_GRAPHICS_API sfVector2u sfRenderTexture_getSize(const sfRenderTexture* ren
 ///
 /// \param renderTexture Render texture object
 ///
-/// \return sfTrue if the render texture use sRGB encoding, sfFalse otherwise
+/// \return true if the render texture use sRGB encoding, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfRenderTexture_isSrgb(const sfRenderTexture* renderTexture);
+CSFML_GRAPHICS_API bool sfRenderTexture_isSrgb(const sfRenderTexture* renderTexture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Activate or deactivate a render texture as the current target for rendering
 ///
 /// \param renderTexture Render texture object
-/// \param active        sfTrue to activate, sfFalse to deactivate
+/// \param active        true to activate, false to deactivate
 ///
 /// \return True if operation was successful, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfRenderTexture_setActive(sfRenderTexture* renderTexture, sfBool active);
+CSFML_GRAPHICS_API bool sfRenderTexture_setActive(sfRenderTexture* renderTexture, bool active);
 
 ////////////////////////////////////////////////////////////
 /// \brief Update the contents of the target texture
@@ -332,39 +332,39 @@ CSFML_GRAPHICS_API unsigned int sfRenderTexture_getMaximumAntialiasingLevel(void
 /// \brief Enable or disable the smooth filter on a render texture
 ///
 /// \param renderTexture Render texture object
-/// \param smooth        sfTrue to enable smoothing, sfFalse to disable it
+/// \param smooth        true to enable smoothing, false to disable it
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderTexture_setSmooth(sfRenderTexture* renderTexture, sfBool smooth);
+CSFML_GRAPHICS_API void sfRenderTexture_setSmooth(sfRenderTexture* renderTexture, bool smooth);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether the smooth filter is enabled or not for a render texture
 ///
 /// \param renderTexture Render texture object
 ///
-/// \return sfTrue if smoothing is enabled, sfFalse if it is disabled
+/// \return true if smoothing is enabled, false if it is disabled
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfRenderTexture_isSmooth(const sfRenderTexture* renderTexture);
+CSFML_GRAPHICS_API bool sfRenderTexture_isSmooth(const sfRenderTexture* renderTexture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Enable or disable texture repeating
 ///
 /// \param renderTexture Render texture object
-/// \param repeated      sfTrue to enable repeating, sfFalse to disable it
+/// \param repeated      true to enable repeating, false to disable it
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderTexture_setRepeated(sfRenderTexture* renderTexture, sfBool repeated);
+CSFML_GRAPHICS_API void sfRenderTexture_setRepeated(sfRenderTexture* renderTexture, bool repeated);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether the texture is repeated or not
 ///
 /// \param renderTexture Render texture object
 ///
-/// \return sfTrue if repeat mode is enabled, sfFalse if it is disabled
+/// \return true if repeat mode is enabled, false if it is disabled
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfRenderTexture_isRepeated(const sfRenderTexture* renderTexture);
+CSFML_GRAPHICS_API bool sfRenderTexture_isRepeated(const sfRenderTexture* renderTexture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Generate a mipmap using the current texture data
@@ -377,10 +377,10 @@ CSFML_GRAPHICS_API sfBool sfRenderTexture_isRepeated(const sfRenderTexture* rend
 /// after subsequent drawing will lead to undefined behavior if a mipmap
 /// had been previously generated.
 ///
-/// \return sfTrue if mipmap generation was successful, sfFalse if unsuccessful
+/// \return true if mipmap generation was successful, false if unsuccessful
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfRenderTexture_generateMipmap(sfRenderTexture* renderTexture);
+CSFML_GRAPHICS_API bool sfRenderTexture_generateMipmap(sfRenderTexture* renderTexture);
 
 
 #endif // SFML_RENDERTEXTURE_H

include/SFML/Graphics/RenderWindow.h

@@ -52,7 +52,7 @@
 /// \param settings Creation settings (pass NULL to use default values)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfRenderWindow* sfRenderWindow_create(sfVideoMode mode, const char* title, sfUint32 style, const sfContextSettings* settings);
+CSFML_GRAPHICS_API sfRenderWindow* sfRenderWindow_create(sfVideoMode mode, const char* title, uint32_t style, const sfContextSettings* settings);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct a new render window (with a UTF-32 title)
@@ -63,7 +63,7 @@ CSFML_GRAPHICS_API sfRenderWindow* sfRenderWindow_create(sfVideoMode mode, const
 /// \param settings Creation settings (pass NULL to use default values)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfRenderWindow* sfRenderWindow_createUnicode(sfVideoMode mode, const sfUint32* title, sfUint32 style, const sfContextSettings* settings);
+CSFML_GRAPHICS_API sfRenderWindow* sfRenderWindow_createUnicode(sfVideoMode mode, const uint32_t* title, uint32_t style, const sfContextSettings* settings);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct a render window from an existing control
@@ -96,7 +96,7 @@ CSFML_GRAPHICS_API void sfRenderWindow_close(sfRenderWindow* renderWindow);
 /// \param renderWindow Render window object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfRenderWindow_isOpen(const sfRenderWindow* renderWindow);
+CSFML_GRAPHICS_API bool sfRenderWindow_isOpen(const sfRenderWindow* renderWindow);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the creation settings of a render window
@@ -114,10 +114,10 @@ CSFML_GRAPHICS_API sfContextSettings sfRenderWindow_getSettings(const sfRenderWi
 /// \param renderWindow Render window object
 /// \param event        Event to fill, if any
 ///
-/// \return sfTrue if an event was returned, sfFalse if event queue was empty
+/// \return true if an event was returned, false if event queue was empty
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfRenderWindow_pollEvent(sfRenderWindow* renderWindow, sfEvent* event);
+CSFML_GRAPHICS_API bool sfRenderWindow_pollEvent(sfRenderWindow* renderWindow, sfEvent* event);
 
 ////////////////////////////////////////////////////////////
 /// \brief Wait for an event and return it
@@ -125,10 +125,10 @@ CSFML_GRAPHICS_API sfBool sfRenderWindow_pollEvent(sfRenderWindow* renderWindow,
 /// \param renderWindow Render window object
 /// \param event        Event to fill
 ///
-/// \return sfFalse if an error occured
+/// \return false if an error occured
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfRenderWindow_waitEvent(sfRenderWindow* renderWindow, sfEvent* event);
+CSFML_GRAPHICS_API bool sfRenderWindow_waitEvent(sfRenderWindow* renderWindow, sfEvent* event);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the position of a render window
@@ -166,10 +166,10 @@ CSFML_GRAPHICS_API sfVector2u sfRenderWindow_getSize(const sfRenderWindow* rende
 ///
 /// \param renderWindow Render window object
 ///
-/// \return sfTrue if the render window use sRGB encoding, sfFalse otherwise
+/// \return true if the render window use sRGB encoding, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfRenderWindow_isSrgb(const sfRenderWindow* renderWindow);
+CSFML_GRAPHICS_API bool sfRenderWindow_isSrgb(const sfRenderWindow* renderWindow);
 
 ////////////////////////////////////////////////////////////
 /// \brief Change the size of the rendering region of a render window
@@ -196,7 +196,7 @@ CSFML_GRAPHICS_API void sfRenderWindow_setTitle(sfRenderWindow* renderWindow, co
 /// \param title        New title
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setUnicodeTitle(sfRenderWindow* renderWindow, const sfUint32* title);
+CSFML_GRAPHICS_API void sfRenderWindow_setUnicodeTitle(sfRenderWindow* renderWindow, const uint32_t* title);
 
 ////////////////////////////////////////////////////////////
 /// \brief Change a render window's icon
@@ -207,34 +207,34 @@ CSFML_GRAPHICS_API void sfRenderWindow_setUnicodeTitle(sfRenderWindow* renderWin
 /// \param pixels       Pointer to the pixels in memory, format must be RGBA 32 bits
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setIcon(sfRenderWindow* renderWindow, unsigned int width, unsigned int height, const sfUint8* pixels);
+CSFML_GRAPHICS_API void sfRenderWindow_setIcon(sfRenderWindow* renderWindow, unsigned int width, unsigned int height, const uint8_t* pixels);
 
 ////////////////////////////////////////////////////////////
 /// \brief Show or hide a render window
 ///
 /// \param renderWindow Render window object
-/// \param visible      sfTrue to show the window, sfFalse to hide it
+/// \param visible      true to show the window, false to hide it
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setVisible(sfRenderWindow* renderWindow, sfBool visible);
+CSFML_GRAPHICS_API void sfRenderWindow_setVisible(sfRenderWindow* renderWindow, bool visible);
 
 ////////////////////////////////////////////////////////////
 /// \brief Enable / disable vertical synchronization on a render window
 ///
 /// \param renderWindow Render window object
-/// \param enabled      sfTrue to enable v-sync, sfFalse to deactivate
+/// \param enabled      true to enable v-sync, false to deactivate
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setVerticalSyncEnabled(sfRenderWindow* renderWindow, sfBool enabled);
+CSFML_GRAPHICS_API void sfRenderWindow_setVerticalSyncEnabled(sfRenderWindow* renderWindow, bool enabled);
 
 ////////////////////////////////////////////////////////////
 /// \brief Show or hide the mouse cursor on a render window
 ///
 /// \param renderWindow Render window object
-/// \param show         sfTrue to show, sfFalse to hide
+/// \param show         true to show, false to hide
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursorVisible(sfRenderWindow* renderWindow, sfBool show);
+CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursorVisible(sfRenderWindow* renderWindow, bool show);
 
 ////////////////////////////////////////////////////////////
 /// \brief Grab or release the mouse cursor
@@ -246,10 +246,10 @@ CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursorVisible(sfRenderWindow* ren
 /// won't have any effect (fullscreen windows always grab the
 /// cursor).
 ///
-/// \param grabbed sfTrue to enable, sfFalse to disable
+/// \param grabbed true to enable, false to disable
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursorGrabbed(sfRenderWindow* renderWindow, sfBool grabbed);
+CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursorGrabbed(sfRenderWindow* renderWindow, bool grabbed);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the displayed cursor to a native system cursor
@@ -276,10 +276,10 @@ CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursor(sfRenderWindow* window, co
 /// Automatic key-repeat is enabled by default
 ///
 /// \param renderWindow Render window object
-/// \param enabled      sfTrue to enable, sfFalse to disable
+/// \param enabled      true to enable, false to disable
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfRenderWindow_setKeyRepeatEnabled(sfRenderWindow* renderWindow, sfBool enabled);
+CSFML_GRAPHICS_API void sfRenderWindow_setKeyRepeatEnabled(sfRenderWindow* renderWindow, bool enabled);
 
 ////////////////////////////////////////////////////////////
 /// \brief Limit the framerate to a maximum fixed frequency for a render window
@@ -303,12 +303,12 @@ CSFML_GRAPHICS_API void sfRenderWindow_setJoystickThreshold(sfRenderWindow* rend
 /// \brief Activate or deactivate a render window as the current target for rendering
 ///
 /// \param renderWindow Render window object
-/// \param active       sfTrue to activate, sfFalse to deactivate
+/// \param active       true to activate, false to deactivate
 ///
 /// \return True if operation was successful, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfRenderWindow_setActive(sfRenderWindow* renderWindow, sfBool active);
+CSFML_GRAPHICS_API bool sfRenderWindow_setActive(sfRenderWindow* renderWindow, bool active);
 
 ///////////////////////////////////////////////////////////
 /// \brief Request the current render window to be made the active
@@ -334,7 +334,7 @@ CSFML_GRAPHICS_API void sfRenderWindow_requestFocus(sfRenderWindow* renderWindow
 /// \return True if window has focus, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfRenderWindow_hasFocus(const sfRenderWindow* renderWindow);
+CSFML_GRAPHICS_API bool sfRenderWindow_hasFocus(const sfRenderWindow* renderWindow);
 
 ////////////////////////////////////////////////////////////
 /// \brief Display a render window on screen

include/SFML/Graphics/Shader.h

@@ -221,7 +221,7 @@ CSFML_GRAPHICS_API void sfShader_setIntColorUniform(sfShader* shader, const char
 /// \param x      Value of the bool scalar
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfShader_setBoolUniform(sfShader* shader, const char* name, sfBool x);
+CSFML_GRAPHICS_API void sfShader_setBoolUniform(sfShader* shader, const char* name, bool x);
 
 ////////////////////////////////////////////////////////////
 /// \brief Specify value for \p bvec2 uniform
@@ -689,10 +689,10 @@ CSFML_GRAPHICS_API void sfShader_bind(const sfShader* shader);
 /// the shader features. If it returns false, then
 /// any attempt to use sfShader will fail.
 ///
-/// \return sfTrue if the system can use shaders, sfFalse otherwise
+/// \return true if the system can use shaders, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfShader_isAvailable(void);
+CSFML_GRAPHICS_API bool sfShader_isAvailable(void);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether or not the system supports geometry shaders
@@ -711,6 +711,6 @@ CSFML_GRAPHICS_API sfBool sfShader_isAvailable(void);
 /// \return True if geometry shaders are supported, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfShader_isGeometryAvailable(void);
+CSFML_GRAPHICS_API bool sfShader_isGeometryAvailable(void);
 
 #endif // SFML_SHADER_H

include/SFML/Graphics/Shape.h

@@ -234,7 +234,7 @@ CSFML_GRAPHICS_API sfTransform sfShape_getInverseTransform(const sfShape* shape)
 /// \param resetRect Should the texture rect be reset to the size of the new texture?
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfShape_setTexture(sfShape* shape, const sfTexture* texture, sfBool resetRect);
+CSFML_GRAPHICS_API void sfShape_setTexture(sfShape* shape, const sfTexture* texture, bool resetRect);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the sub-rectangle of the texture that a shape will display

include/SFML/Graphics/Sprite.h

@@ -234,7 +234,7 @@ CSFML_GRAPHICS_API sfTransform sfSprite_getInverseTransform(const sfSprite* spri
 /// \param resetRect Should the texture rect be reset to the size of the new texture?
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfSprite_setTexture(sfSprite* sprite, const sfTexture* texture, sfBool resetRect);
+CSFML_GRAPHICS_API void sfSprite_setTexture(sfSprite* sprite, const sfTexture* texture, bool resetRect);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the sub-rectangle of the texture that a sprite will display

include/SFML/Graphics/Text.h

@@ -247,7 +247,7 @@ CSFML_GRAPHICS_API void sfText_setString(sfText* text, const char* string);
 /// \param string New string
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfText_setUnicodeString(sfText* text, const sfUint32* string);
+CSFML_GRAPHICS_API void sfText_setUnicodeString(sfText* text, const uint32_t* string);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the font of a text
@@ -322,7 +322,7 @@ CSFML_GRAPHICS_API void sfText_setLetterSpacing(sfText* text, float spacingFacto
 /// \param style New style
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfText_setStyle(sfText* text, sfUint32 style);
+CSFML_GRAPHICS_API void sfText_setStyle(sfText* text, uint32_t style);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the fill color of a text
@@ -397,7 +397,7 @@ CSFML_GRAPHICS_API const char* sfText_getString(const sfText* text);
 /// \return String as UTF-32
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API const sfUint32* sfText_getUnicodeString(const sfText* text);
+CSFML_GRAPHICS_API const uint32_t* sfText_getUnicodeString(const sfText* text);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the font used by a text
@@ -455,7 +455,7 @@ CSFML_GRAPHICS_API float sfText_getLineSpacing(const sfText* text);
 /// \return Current string style (see sfTextStyle enum)
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfUint32 sfText_getStyle(const sfText* text);
+CSFML_GRAPHICS_API uint32_t sfText_getStyle(const sfText* text);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the fill color of a text

include/SFML/Graphics/Texture.h

@@ -208,7 +208,7 @@ CSFML_GRAPHICS_API sfImage* sfTexture_copyToImage(const sfTexture* texture);
 /// \param y       Y offset in the texture where to copy the source pixels
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTexture_updateFromPixels(sfTexture* texture, const sfUint8* pixels, unsigned int width, unsigned int height, unsigned int x, unsigned int y);
+CSFML_GRAPHICS_API void sfTexture_updateFromPixels(sfTexture* texture, const uint8_t* pixels, unsigned int width, unsigned int height, unsigned int x, unsigned int y);
 
 ////////////////////////////////////////////////////////////
 /// \brief Update a part of this texture from another texture
@@ -265,20 +265,20 @@ CSFML_GRAPHICS_API void sfTexture_updateFromRenderWindow(sfTexture* texture, con
 /// \brief Enable or disable the smooth filter on a texture
 ///
 /// \param texture The texture object
-/// \param smooth  sfTrue to enable smoothing, sfFalse to disable it
+/// \param smooth  true to enable smoothing, false to disable it
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTexture_setSmooth(sfTexture* texture, sfBool smooth);
+CSFML_GRAPHICS_API void sfTexture_setSmooth(sfTexture* texture, bool smooth);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether the smooth filter is enabled or not for a texture
 ///
 /// \param texture The texture object
 ///
-/// \return sfTrue if smoothing is enabled, sfFalse if it is disabled
+/// \return true if smoothing is enabled, false if it is disabled
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfTexture_isSmooth(const sfTexture* texture);
+CSFML_GRAPHICS_API bool sfTexture_isSmooth(const sfTexture* texture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether the texture source is converted from sRGB or not
@@ -291,7 +291,7 @@ CSFML_GRAPHICS_API sfBool sfTexture_isSmooth(const sfTexture* texture);
 /// \see sfTexture_createSrgbFromImage
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfTexture_isSrgb(const sfTexture* texture);
+CSFML_GRAPHICS_API bool sfTexture_isSrgb(const sfTexture* texture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Enable or disable repeating for a texture
@@ -314,17 +314,17 @@ CSFML_GRAPHICS_API sfBool sfTexture_isSrgb(const sfTexture* texture);
 /// \param repeated True to repeat the texture, false to disable repeating
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API void sfTexture_setRepeated(sfTexture* texture, sfBool repeated);
+CSFML_GRAPHICS_API void sfTexture_setRepeated(sfTexture* texture, bool repeated);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether a texture is repeated or not
 ///
 /// \param texture The texture object
 ///
-/// \return sfTrue if repeat mode is enabled, sfFalse if it is disabled
+/// \return true if repeat mode is enabled, false if it is disabled
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfTexture_isRepeated(const sfTexture* texture);
+CSFML_GRAPHICS_API bool sfTexture_isRepeated(const sfTexture* texture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Generate a mipmap using the current texture data
@@ -346,10 +346,10 @@ CSFML_GRAPHICS_API sfBool sfTexture_isRepeated(const sfTexture* texture);
 /// modified, at which point this function will have to be called again to
 /// regenerate it.
 ///
-/// \return sfTrue if mipmap generation was successful, sfFalse if unsuccessful
+/// \return true if mipmap generation was successful, false if unsuccessful
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfTexture_generateMipmap(sfTexture* texture);
+CSFML_GRAPHICS_API bool sfTexture_generateMipmap(sfTexture* texture);
 
 ////////////////////////////////////////////////////////////
 /// \brief Swap the contents of a texture with those of another

include/SFML/Graphics/Transform.h

@@ -218,6 +218,6 @@ CSFML_GRAPHICS_API void sfTransform_scaleWithCenter(sfTransform* transform, floa
 /// \return true if the transforms are equal, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfTransform_equal(sfTransform* left, sfTransform* right);
+CSFML_GRAPHICS_API bool sfTransform_equal(sfTransform* left, sfTransform* right);
 
 #endif // SFML_TRANSFORM_H

include/SFML/Graphics/VertexBuffer.h

@@ -126,10 +126,10 @@ CSFML_GRAPHICS_API unsigned int sfVertexBuffer_getVertexCount(const sfVertexBuff
 /// \param vertexCount Number of vertices to copy
 /// \param offset      Offset in the buffer to copy to
 ///
-/// \return sfTrue if the update was successful
+/// \return true if the update was successful
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfVertexBuffer_update(sfVertexBuffer* vertexBuffer, const sfVertex* vertices, unsigned int vertexCount, unsigned int offset);
+CSFML_GRAPHICS_API bool sfVertexBuffer_update(sfVertexBuffer* vertexBuffer, const sfVertex* vertices, unsigned int vertexCount, unsigned int offset);
 
 ////////////////////////////////////////////////////////////
 /// \brief Copy the contents of another buffer into this buffer
@@ -137,10 +137,10 @@ CSFML_GRAPHICS_API sfBool sfVertexBuffer_update(sfVertexBuffer* vertexBuffer, co
 /// \param vertexBuffer Vertex buffer object
 /// \param other Vertex buffer whose contents to copy into first vertex buffer
 ///
-/// \return sfTrue if the copy was successful
+/// \return true if the copy was successful
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfVertexBuffer_updateFromVertexBuffer(sfVertexBuffer* vertexBuffer, const sfVertexBuffer* other);
+CSFML_GRAPHICS_API bool sfVertexBuffer_updateFromVertexBuffer(sfVertexBuffer* vertexBuffer, const sfVertexBuffer* other);
 
 ////////////////////////////////////////////////////////////
 /// \brief Swap the contents of this vertex buffer with those of another
@@ -248,7 +248,7 @@ CSFML_GRAPHICS_API void sfVertexBuffer_bind(const sfVertexBuffer* vertexBuffer);
 /// \return True if vertex buffers are supported, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_GRAPHICS_API sfBool sfVertexBuffer_isAvailable(void);
+CSFML_GRAPHICS_API bool sfVertexBuffer_isAvailable(void);
 
 
 #endif // SFML_VERTEXBUFFER_H

include/SFML/Network/Ftp.h

@@ -129,10 +129,10 @@ CSFML_NETWORK_API void sfFtpListingResponse_destroy(sfFtpListingResponse* ftpLis
 ///
 /// \param ftpListingResponse Ftp listing response
 ///
-/// \return sfTrue if the status is a success, sfFalse if it is a failure
+/// \return true if the status is a success, false if it is a failure
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfBool sfFtpListingResponse_isOk(const sfFtpListingResponse* ftpListingResponse);
+CSFML_NETWORK_API bool sfFtpListingResponse_isOk(const sfFtpListingResponse* ftpListingResponse);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the status code of a FTP listing response
@@ -191,10 +191,10 @@ CSFML_NETWORK_API void sfFtpDirectoryResponse_destroy(sfFtpDirectoryResponse* ft
 ///
 /// \param ftpDirectoryResponse Ftp directory response
 ///
-/// \return sfTrue if the status is a success, sfFalse if it is a failure
+/// \return true if the status is a success, false if it is a failure
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfBool sfFtpDirectoryResponse_isOk(const sfFtpDirectoryResponse* ftpDirectoryResponse);
+CSFML_NETWORK_API bool sfFtpDirectoryResponse_isOk(const sfFtpDirectoryResponse* ftpDirectoryResponse);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the status code of a FTP directory response
@@ -243,10 +243,10 @@ CSFML_NETWORK_API void sfFtpResponse_destroy(sfFtpResponse* ftpResponse);
 ///
 /// \param ftpResponse Ftp response object
 ///
-/// \return sfTrue if the status is a success, sfFalse if it is a failure
+/// \return true if the status is a success, false if it is a failure
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfBool sfFtpResponse_isOk(const sfFtpResponse* ftpResponse);
+CSFML_NETWORK_API bool sfFtpResponse_isOk(const sfFtpResponse* ftpResponse);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the status code of a FTP response
@@ -500,12 +500,12 @@ CSFML_NETWORK_API sfFtpResponse* sfFtp_download(sfFtp* ftp, const char* remoteFi
 /// \param localFile  Path of the local file to upload
 /// \param remotePath Where to put to file on the server
 /// \param mode       Transfer mode
-/// \param append     Pass sfTrue to append to or sfFalse to overwrite the remote file if it already exists
+/// \param append     Pass true to append to or false to overwrite the remote file if it already exists
 ///
 /// \return Server response to the request
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfFtpResponse* sfFtp_upload(sfFtp* ftp, const char* localFile, const char* remotePath, sfFtpTransferMode mode, sfBool append);
+CSFML_NETWORK_API sfFtpResponse* sfFtp_upload(sfFtp* ftp, const char* localFile, const char* remotePath, sfFtpTransferMode mode, bool append);
 
 ////////////////////////////////////////////////////////////
 /// \brief Send a command to the FTP server

include/SFML/Network/IpAddress.h

@@ -95,7 +95,7 @@ CSFML_NETWORK_API sfIpAddress sfIpAddress_fromString(const char* address);
 /// \return Resulting address
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfIpAddress sfIpAddress_fromBytes(sfUint8 byte0, sfUint8 byte1, sfUint8 byte2, sfUint8 byte3);
+CSFML_NETWORK_API sfIpAddress sfIpAddress_fromBytes(uint8_t byte0, uint8_t byte1, uint8_t byte2, uint8_t byte3);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct an address from a 32-bits integer
@@ -110,7 +110,7 @@ CSFML_NETWORK_API sfIpAddress sfIpAddress_fromBytes(sfUint8 byte0, sfUint8 byte1
 /// \return Resulting address
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfIpAddress sfIpAddress_fromInteger(sfUint32 address);
+CSFML_NETWORK_API sfIpAddress sfIpAddress_fromInteger(uint32_t address);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get a string representation of an address
@@ -139,7 +139,7 @@ CSFML_NETWORK_API void sfIpAddress_toString(sfIpAddress address, char* string);
 /// \return 32-bits unsigned integer representation of the address
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfUint32 sfIpAddress_toInteger(sfIpAddress address);
+CSFML_NETWORK_API uint32_t sfIpAddress_toInteger(sfIpAddress address);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the computer's local address

include/SFML/Network/Packet.h

@@ -128,10 +128,10 @@ CSFML_NETWORK_API size_t sfPacket_getDataSize(const sfPacket* packet);
 ///
 /// \param packet Packet object
 ///
-/// \return sfTrue if all data was read, sfFalse otherwise
+/// \return true if all data was read, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfBool sfPacket_endOfPacket(const sfPacket* packet);
+CSFML_NETWORK_API bool sfPacket_endOfPacket(const sfPacket* packet);
 
 ////////////////////////////////////////////////////////////
 /// \brief Test the validity of a packet, for reading
@@ -144,10 +144,10 @@ CSFML_NETWORK_API sfBool sfPacket_endOfPacket(const sfPacket* packet);
 ///
 /// \param packet Packet object
 ///
-/// \return sfTrue if last data extraction from packet was successful
+/// \return true if last data extraction from packet was successful
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfBool sfPacket_canRead(const sfPacket* packet);
+CSFML_NETWORK_API bool sfPacket_canRead(const sfPacket* packet);
 
 ////////////////////////////////////////////////////////////
 /// \brief Functions to extract data from a packet
@@ -155,13 +155,13 @@ CSFML_NETWORK_API sfBool sfPacket_canRead(const sfPacket* packet);
 /// \param packet Packet object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfBool   sfPacket_readBool(sfPacket* packet);
+CSFML_NETWORK_API bool     sfPacket_readBool(sfPacket* packet);
-CSFML_NETWORK_API sfInt8   sfPacket_readInt8(sfPacket* packet);
+CSFML_NETWORK_API int8_t   sfPacket_readInt8(sfPacket* packet);
-CSFML_NETWORK_API sfUint8  sfPacket_readUint8(sfPacket* packet);
+CSFML_NETWORK_API uint8_t  sfPacket_readUint8(sfPacket* packet);
-CSFML_NETWORK_API sfInt16  sfPacket_readInt16(sfPacket* packet);
+CSFML_NETWORK_API int16_t  sfPacket_readInt16(sfPacket* packet);
-CSFML_NETWORK_API sfUint16 sfPacket_readUint16(sfPacket* packet);
+CSFML_NETWORK_API uint16_t sfPacket_readUint16(sfPacket* packet);
-CSFML_NETWORK_API sfInt32  sfPacket_readInt32(sfPacket* packet);
+CSFML_NETWORK_API int32_t  sfPacket_readInt32(sfPacket* packet);
-CSFML_NETWORK_API sfUint32 sfPacket_readUint32(sfPacket* packet);
+CSFML_NETWORK_API uint32_t sfPacket_readUint32(sfPacket* packet);
 CSFML_NETWORK_API float    sfPacket_readFloat(sfPacket* packet);
 CSFML_NETWORK_API double   sfPacket_readDouble(sfPacket* packet);
 CSFML_NETWORK_API void     sfPacket_readString(sfPacket* packet, char* string);
@@ -173,13 +173,13 @@ CSFML_NETWORK_API void     sfPacket_readWideString(sfPacket* packet, wchar_t* st
 /// \param packet Packet object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfPacket_writeBool(sfPacket* packet, sfBool);
+CSFML_NETWORK_API void sfPacket_writeBool(sfPacket* packet, bool);
-CSFML_NETWORK_API void sfPacket_writeInt8(sfPacket* packet, sfInt8);
+CSFML_NETWORK_API void sfPacket_writeInt8(sfPacket* packet, int8_t);
-CSFML_NETWORK_API void sfPacket_writeUint8(sfPacket* packet, sfUint8);
+CSFML_NETWORK_API void sfPacket_writeUint8(sfPacket* packet, uint8_t);
-CSFML_NETWORK_API void sfPacket_writeInt16(sfPacket* packet, sfInt16);
+CSFML_NETWORK_API void sfPacket_writeInt16(sfPacket* packet, int16_t);
-CSFML_NETWORK_API void sfPacket_writeUint16(sfPacket* packet, sfUint16);
+CSFML_NETWORK_API void sfPacket_writeUint16(sfPacket* packet, uint16_t);
-CSFML_NETWORK_API void sfPacket_writeInt32(sfPacket* packet, sfInt32);
+CSFML_NETWORK_API void sfPacket_writeInt32(sfPacket* packet, int32_t);
-CSFML_NETWORK_API void sfPacket_writeUint32(sfPacket* packet, sfUint32);
+CSFML_NETWORK_API void sfPacket_writeUint32(sfPacket* packet, uint32_t);
 CSFML_NETWORK_API void sfPacket_writeFloat(sfPacket* packet, float);
 CSFML_NETWORK_API void sfPacket_writeDouble(sfPacket* packet, double);
 CSFML_NETWORK_API void sfPacket_writeString(sfPacket* packet, const char* string);

include/SFML/Network/SocketSelector.h

@@ -107,15 +107,15 @@ CSFML_NETWORK_API void sfSocketSelector_clear(sfSocketSelector* selector);
 /// some data available to be received. To know which sockets are
 /// ready, use the sfSocketSelector_isXxxReady functions.
 /// If you use a timeout and no socket is ready before the timeout
-/// is over, the function returns sfFalse.
+/// is over, the function returns false.
 ///
 /// \param selector Socket selector object
 /// \param timeout  Maximum time to wait (use sfTimeZero for infinity)
 ///
-/// \return sfTrue if there are sockets ready, sfFalse otherwise
+/// \return true if there are sockets ready, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfBool sfSocketSelector_wait(sfSocketSelector* selector, sfTime timeout);
+CSFML_NETWORK_API bool sfSocketSelector_wait(sfSocketSelector* selector, sfTime timeout);
 
 ////////////////////////////////////////////////////////////
 /// \brief Test a socket to know if it is ready to receive data
@@ -124,18 +124,18 @@ CSFML_NETWORK_API sfBool sfSocketSelector_wait(sfSocketSelector* selector, sfTim
 /// sfSocketSelector_wait, to know which sockets are ready to
 /// receive data. If a socket is ready, a call to Receive will
 /// never block because we know that there is data available to read.
-/// Note that if this function returns sfTrue for a sfTcpListener,
+/// Note that if this function returns true for a sfTcpListener,
 /// this means that it is ready to accept a new connection.
 ///
 /// \param selector Socket selector object
 /// \param socket   Socket to test
 ///
-/// \return sfTrue if the socket is ready to read, sfFalse otherwise
+/// \return true if the socket is ready to read, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfBool sfSocketSelector_isTcpListenerReady(const sfSocketSelector* selector, sfTcpListener* socket);
+CSFML_NETWORK_API bool sfSocketSelector_isTcpListenerReady(const sfSocketSelector* selector, sfTcpListener* socket);
-CSFML_NETWORK_API sfBool sfSocketSelector_isTcpSocketReady(const sfSocketSelector* selector, sfTcpSocket* socket);
+CSFML_NETWORK_API bool sfSocketSelector_isTcpSocketReady(const sfSocketSelector* selector, sfTcpSocket* socket);
-CSFML_NETWORK_API sfBool sfSocketSelector_isUdpSocketReady(const sfSocketSelector* selector, sfUdpSocket* socket);
+CSFML_NETWORK_API bool sfSocketSelector_isUdpSocketReady(const sfSocketSelector* selector, sfUdpSocket* socket);
 
 
 #endif // SFML_SOCKETSELECTOR_H

include/SFML/Network/TcpListener.h

@@ -63,20 +63,20 @@ CSFML_NETWORK_API void sfTcpListener_destroy(sfTcpListener* listener);
 /// By default, all sockets are blocking.
 ///
 /// \param listener TCP listener object
-/// \param blocking sfTrue to set the socket as blocking, sfFalse for non-blocking
+/// \param blocking true to set the socket as blocking, false for non-blocking
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfTcpListener_setBlocking(sfTcpListener* listener, sfBool blocking);
+CSFML_NETWORK_API void sfTcpListener_setBlocking(sfTcpListener* listener, bool blocking);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether a TCP listener is in blocking or non-blocking mode
 ///
 /// \param listener TCP listener object
 ///
-/// \return sfTrue if the socket is blocking, sfFalse otherwise
+/// \return true if the socket is blocking, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfBool sfTcpListener_isBlocking(const sfTcpListener* listener);
+CSFML_NETWORK_API bool sfTcpListener_isBlocking(const sfTcpListener* listener);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the port to which a TCP listener is bound locally

include/SFML/Network/TcpSocket.h

@@ -65,20 +65,20 @@ CSFML_NETWORK_API void sfTcpSocket_destroy(sfTcpSocket* socket);
 /// By default, all sockets are blocking.
 ///
 /// \param socket   TCP socket object
-/// \param blocking sfTrue to set the socket as blocking, sfFalse for non-blocking
+/// \param blocking true to set the socket as blocking, false for non-blocking
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfTcpSocket_setBlocking(sfTcpSocket* socket, sfBool blocking);
+CSFML_NETWORK_API void sfTcpSocket_setBlocking(sfTcpSocket* socket, bool blocking);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether a TCP socket is in blocking or non-blocking mode
 ///
 /// \param socket TCP socket object
 ///
-/// \return sfTrue if the socket is blocking, sfFalse otherwise
+/// \return true if the socket is blocking, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfBool sfTcpSocket_isBlocking(const sfTcpSocket* socket);
+CSFML_NETWORK_API bool sfTcpSocket_isBlocking(const sfTcpSocket* socket);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the port to which a TCP socket is bound locally

include/SFML/Network/UdpSocket.h

@@ -64,20 +64,20 @@ CSFML_NETWORK_API void sfUdpSocket_destroy(sfUdpSocket* socket);
 /// By default, all sockets are blocking.
 ///
 /// \param socket   UDP socket object
-/// \param blocking sfTrue to set the socket as blocking, sfFalse for non-blocking
+/// \param blocking true to set the socket as blocking, false for non-blocking
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API void sfUdpSocket_setBlocking(sfUdpSocket* socket, sfBool blocking);
+CSFML_NETWORK_API void sfUdpSocket_setBlocking(sfUdpSocket* socket, bool blocking);
 
 ////////////////////////////////////////////////////////////
 /// \brief Tell whether a UDP socket is in blocking or non-blocking mode
 ///
 /// \param socket UDP socket object
 ///
-/// \return sfTrue if the socket is blocking, sfFalse otherwise
+/// \return true if the socket is blocking, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_NETWORK_API sfBool sfUdpSocket_isBlocking(const sfUdpSocket* socket);
+CSFML_NETWORK_API bool sfUdpSocket_isBlocking(const sfUdpSocket* socket);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the port to which a UDP socket is bound locally

include/SFML/System/Buffer.h

@@ -67,7 +67,7 @@ CSFML_SYSTEM_API size_t sfBuffer_getSize(const sfBuffer* buffer);
 /// \return Read-only pointer to the array of bytes
 ///
 ////////////////////////////////////////////////////////////
-CSFML_SYSTEM_API const sfUint8* sfBuffer_getData(const sfBuffer* buffer);
+CSFML_SYSTEM_API const uint8_t* sfBuffer_getData(const sfBuffer* buffer);
 
 
 #endif // SFML_BUFFER_H

include/SFML/System/InputStream.h

@@ -31,10 +31,10 @@
 #include <SFML/System/Export.h>
 
 
-typedef sfInt64 (*sfInputStreamReadFunc)(void* data, sfInt64 size, void* userData);
+typedef int64_t (*sfInputStreamReadFunc)(void* data, int64_t size, void* userData);
-typedef sfInt64 (*sfInputStreamSeekFunc)(sfInt64 position, void* userData);
+typedef int64_t (*sfInputStreamSeekFunc)(int64_t position, void* userData);
-typedef sfInt64 (*sfInputStreamTellFunc)(void* userData);
+typedef int64_t (*sfInputStreamTellFunc)(void* userData);
-typedef sfInt64 (*sfInputStreamGetSizeFunc)(void* userData);
+typedef int64_t (*sfInputStreamGetSizeFunc)(void* userData);
 
 
 ////////////////////////////////////////////////////////////

include/SFML/System/Time.h

@@ -37,7 +37,7 @@
 ////////////////////////////////////////////////////////////
 typedef struct
 {
-    sfInt64 microseconds;
+    int64_t microseconds;
 } sfTime;
 
 ////////////////////////////////////////////////////////////
@@ -64,7 +64,7 @@ CSFML_SYSTEM_API float sfTime_asSeconds(sfTime time);
 /// \return Time in milliseconds
 ///
 ////////////////////////////////////////////////////////////
-CSFML_SYSTEM_API sfInt32 sfTime_asMilliseconds(sfTime time);
+CSFML_SYSTEM_API int32_t sfTime_asMilliseconds(sfTime time);
 
 ////////////////////////////////////////////////////////////
 /// \brief Return a time value as a number of microseconds
@@ -74,7 +74,7 @@ CSFML_SYSTEM_API sfInt32 sfTime_asMilliseconds(sfTime time);
 /// \return Time in microseconds
 ///
 ////////////////////////////////////////////////////////////
-CSFML_SYSTEM_API sfInt64 sfTime_asMicroseconds(sfTime time);
+CSFML_SYSTEM_API int64_t sfTime_asMicroseconds(sfTime time);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct a time value from a number of seconds
@@ -94,7 +94,7 @@ CSFML_SYSTEM_API sfTime sfSeconds(float amount);
 /// \return Time value constructed from the amount of milliseconds
 ///
 ////////////////////////////////////////////////////////////
-CSFML_SYSTEM_API sfTime sfMilliseconds(sfInt32 amount);
+CSFML_SYSTEM_API sfTime sfMilliseconds(int32_t amount);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct a time value from a number of microseconds
@@ -104,7 +104,7 @@ CSFML_SYSTEM_API sfTime sfMilliseconds(sfInt32 amount);
 /// \return Time value constructed from the amount of microseconds
 ///
 ////////////////////////////////////////////////////////////
-CSFML_SYSTEM_API sfTime sfMicroseconds(sfInt64 amount);
+CSFML_SYSTEM_API sfTime sfMicroseconds(int64_t amount);
 
 
 #endif // SFML_TIME_H

include/SFML/Window/Clipboard.h

@@ -55,7 +55,7 @@ CSFML_WINDOW_API const char* sfClipboard_getString(void);
 /// \return Clipboard contents as UTF-32
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API const sfUint32* sfClipboard_getUnicodeString(void);
+CSFML_WINDOW_API const uint32_t* sfClipboard_getUnicodeString(void);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the content of the clipboard as ANSI string data
@@ -79,7 +79,7 @@ CSFML_WINDOW_API void sfClipboard_setString(const char* text);
 /// to the clipboard
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfClipboard_setUnicodeString(const sfUint32* text);
+CSFML_WINDOW_API void sfClipboard_setUnicodeString(const uint32_t* text);
 
 
 #endif // SFML_CURSOR_H

include/SFML/Window/Context.h

@@ -60,18 +60,18 @@ CSFML_WINDOW_API void sfContext_destroy(sfContext* context);
 /// \return True if available, false if unavailable
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfContext_isExtensionAvailable(const char* name);
+CSFML_WINDOW_API bool sfContext_isExtensionAvailable(const char* name);
 
 ////////////////////////////////////////////////////////////
 /// \brief Activate or deactivate explicitely a context
 ///
 /// \param context Context object
-/// \param active  sfTrue to activate, sfFalse to deactivate
+/// \param active  true to activate, false to deactivate
 ///
-/// \return sfTrue on success, sfFalse on failure
+/// \return true on success, false on failure
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfContext_setActive(sfContext* context, sfBool active);
+CSFML_WINDOW_API bool sfContext_setActive(sfContext* context, bool active);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the address of an OpenGL function.
@@ -106,6 +106,6 @@ CSFML_WINDOW_API sfContextSettings sfContext_getSettings(const sfContext* contex
 /// \return The active context's ID or 0 if no context is currently active
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfUint64 sfContext_getActiveContextId(void);
+CSFML_WINDOW_API uint64_t sfContext_getActiveContextId(void);
 
 #endif // SFML_CONTEXT_H

include/SFML/Window/Cursor.h

@@ -118,7 +118,7 @@ typedef enum
 /// \return A new sfCursor object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfCursor* sfCursor_createFromPixels(const sfUint8* pixels, sfVector2u size, sfVector2u hotspot);
+CSFML_WINDOW_API sfCursor* sfCursor_createFromPixels(const uint8_t* pixels, sfVector2u size, sfVector2u hotspot);
 
 
 ////////////////////////////////////////////////////////////

include/SFML/Window/Event.h

@@ -78,10 +78,10 @@ typedef struct
     sfEventType type;
     sfKeyCode   code;
     sfScancode  scancode;
-    sfBool      alt;
+    bool        alt;
-    sfBool      control;
+    bool        control;
-    sfBool      shift;
+    bool        shift;
-    sfBool      system;
+    bool        system;
 } sfKeyEvent;
 
 ////////////////////////////////////////////////////////////
@@ -91,7 +91,7 @@ typedef struct
 typedef struct
 {
     sfEventType type;
-    sfUint32    unicode;
+    uint32_t    unicode;
 } sfTextEvent;
 
 ////////////////////////////////////////////////////////////

include/SFML/Window/Joystick.h

@@ -66,10 +66,10 @@ typedef enum
 ///
 /// \param joystick Index of the joystick to check
 ///
-/// \return sfTrue if the joystick is connected, sfFalse otherwise
+/// \return true if the joystick is connected, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfJoystick_isConnected(unsigned int joystick);
+CSFML_WINDOW_API bool sfJoystick_isConnected(unsigned int joystick);
 
 ////////////////////////////////////////////////////////////
 /// \brief Return the number of buttons supported by a joystick
@@ -91,10 +91,10 @@ CSFML_WINDOW_API unsigned int sfJoystick_getButtonCount(unsigned int joystick);
 /// \param joystick Index of the joystick
 /// \param axis     Axis to check
 ///
-/// \return sfTrue if the joystick supports the axis, sfFalse otherwise
+/// \return true if the joystick supports the axis, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfJoystick_hasAxis(unsigned int joystick, sfJoystickAxis axis);
+CSFML_WINDOW_API bool sfJoystick_hasAxis(unsigned int joystick, sfJoystickAxis axis);
 
 ////////////////////////////////////////////////////////////
 /// \brief Check if a joystick button is pressed
@@ -104,10 +104,10 @@ CSFML_WINDOW_API sfBool sfJoystick_hasAxis(unsigned int joystick, sfJoystickAxis
 /// \param joystick Index of the joystick
 /// \param button   Button to check
 ///
-/// \return sfTrue if the button is pressed, sfFalse otherwise
+/// \return true if the button is pressed, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfJoystick_isButtonPressed(unsigned int joystick, unsigned int button);
+CSFML_WINDOW_API bool sfJoystick_isButtonPressed(unsigned int joystick, unsigned int button);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the current position of a joystick axis

include/SFML/Window/Keyboard.h

@@ -331,24 +331,24 @@ typedef enum
 ///
 /// \param key Key to check
 ///
-/// \return sfTrue if the key is pressed, sfFalse otherwise
+/// \return true if the key is pressed, false otherwise
 ///
 /// \see sfKeyboard_isScancodePressed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfKeyboard_isKeyPressed(sfKeyCode key);
+CSFML_WINDOW_API bool sfKeyboard_isKeyPressed(sfKeyCode key);
 
 ////////////////////////////////////////////////////////////
 /// \brief Check if a key is pressed
 ///
 /// \param code Scancode to check
 ///
-/// \return sfTrue if the physical key is pressed, sfFalse otherwise
+/// \return true if the physical key is pressed, false otherwise
 ///
 /// \see sfKeyboard_isKeyPressed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfKeyboard_isScancodePressed(sfScancode code);
+CSFML_WINDOW_API bool sfKeyboard_isScancodePressed(sfScancode code);
 
 ////////////////////////////////////////////////////////////
 /// \brief Localize a physical key to a logical one
@@ -418,6 +418,6 @@ CSFML_WINDOW_API const char* sfKeyboard_getDescription(sfScancode code);
 /// \param visible True to show, false to hide
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfKeyboard_setVirtualKeyboardVisible(sfBool visible);
+CSFML_WINDOW_API void sfKeyboard_setVirtualKeyboardVisible(bool visible);
 
 #endif // SFML_KEYBOARD_H

include/SFML/Window/Mouse.h

@@ -64,10 +64,10 @@ typedef enum
 ///
 /// \param button Button to check
 ///
-/// \return sfTrue if the button is pressed, sfFalse otherwise
+/// \return true if the button is pressed, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfMouse_isButtonPressed(sfMouseButton button);
+CSFML_WINDOW_API bool sfMouse_isButtonPressed(sfMouseButton button);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the current position of the mouse

include/SFML/Window/Sensor.h

@@ -55,10 +55,10 @@ typedef enum
 ///
 /// \param sensor Sensor to check
 ///
-/// \return sfTrue if the sensor is available, sfFalse otherwise
+/// \return true if the sensor is available, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfSensor_isAvailable(sfSensorType sensor);
+CSFML_WINDOW_API bool sfSensor_isAvailable(sfSensorType sensor);
 
 ////////////////////////////////////////////////////////////
 /// \brief Enable or disable a sensor
@@ -70,10 +70,10 @@ CSFML_WINDOW_API sfBool sfSensor_isAvailable(sfSensorType sensor);
 /// This function does nothing if the sensor is unavailable.
 ///
 /// \param sensor Sensor to enable
-/// \param enabled sfTrue to enable, sfFalse to disable
+/// \param enabled true to enable, false to disable
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfSensor_setEnabled(sfSensorType sensor, sfBool enabled);
+CSFML_WINDOW_API void sfSensor_setEnabled(sfSensorType sensor, bool enabled);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the current sensor value

include/SFML/Window/Touch.h

@@ -38,10 +38,10 @@
 ///
 /// \param finger Finger index
 ///
-/// \return sfTrue if \a finger is currently touching the screen, sfFalse otherwise
+/// \return true if \a finger is currently touching the screen, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfTouch_isDown(unsigned int finger);
+CSFML_WINDOW_API bool sfTouch_isDown(unsigned int finger);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the current position of a touch in window coordinates

include/SFML/Window/VideoMode.h

@@ -81,10 +81,10 @@ CSFML_WINDOW_API const sfVideoMode* sfVideoMode_getFullscreenModes(size_t* count
 ///
 /// \param mode Video mode
 ///
-/// \return sfTrue if the video mode is valid for fullscreen mode
+/// \return true if the video mode is valid for fullscreen mode
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfVideoMode_isValid(sfVideoMode mode);
+CSFML_WINDOW_API bool sfVideoMode_isValid(sfVideoMode mode);
 
 
 #endif // SFML_VIDEOMODE_H

include/SFML/Window/Vulkan.h

@@ -37,7 +37,7 @@ typedef struct VkSurfaceKHR_T* VkSurfaceKHR;
 
 #else
 
-typedef sfUint64 VkSurfaceKHR;
+typedef uint64_t VkSurfaceKHR;
 
 #endif
 
@@ -62,7 +62,7 @@ typedef void (*sfVulkanFunctionPointer)(void);
 /// \return True if Vulkan is supported, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfVulkan_isAvailable(sfBool requireGraphics);
+CSFML_WINDOW_API bool sfVulkan_isAvailable(bool requireGraphics);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the address of a Vulkan function

include/SFML/Window/Window.h

@@ -60,8 +60,8 @@ typedef struct
     unsigned int antialiasingLevel; ///< Level of antialiasing
     unsigned int majorVersion;      ///< Major number of the context version to create
     unsigned int minorVersion;      ///< Minor number of the context version to create
-    sfUint32     attributeFlags;    ///< The attribute flags to create the context with
+    uint32_t     attributeFlags;    ///< The attribute flags to create the context with
-    sfBool       sRgbCapable;       ///< Whether the context framebuffer is sRGB capable
+    bool         sRgbCapable;       ///< Whether the context framebuffer is sRGB capable
 } sfContextSettings;
 
 
@@ -86,7 +86,7 @@ typedef struct
 /// \return A new sfWindow object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfWindow* sfWindow_create(sfVideoMode mode, const char* title, sfUint32 style, const sfContextSettings* settings);
+CSFML_WINDOW_API sfWindow* sfWindow_create(sfVideoMode mode, const char* title, uint32_t style, const sfContextSettings* settings);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct a new window (with a UTF-32 title)
@@ -109,7 +109,7 @@ CSFML_WINDOW_API sfWindow* sfWindow_create(sfVideoMode mode, const char* title,
 /// \return A new sfWindow object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfWindow* sfWindow_createUnicode(sfVideoMode mode, const sfUint32* title, sfUint32 style, const sfContextSettings* settings);
+CSFML_WINDOW_API sfWindow* sfWindow_createUnicode(sfVideoMode mode, const uint32_t* title, uint32_t style, const sfContextSettings* settings);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct a window from an existing control
@@ -155,15 +155,15 @@ CSFML_WINDOW_API void sfWindow_close(sfWindow* window);
 /// \brief Tell whether or not a window is opened
 ///
 /// This function returns whether or not the window exists.
-/// Note that a hidden window (sfWindow_setVisible(sfFalse)) will return
+/// Note that a hidden window (sfWindow_setVisible(false)) will return
-/// sfTrue.
+/// true.
 ///
 /// \param window Window object
 ///
-/// \return sfTrue if the window is opened, sfFalse if it has been closed
+/// \return true if the window is opened, false if it has been closed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfWindow_isOpen(const sfWindow* window);
+CSFML_WINDOW_API bool sfWindow_isOpen(const sfWindow* window);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the settings of the OpenGL context of a window
@@ -192,10 +192,10 @@ CSFML_WINDOW_API sfContextSettings sfWindow_getSettings(const sfWindow* window);
 /// \param window Window object
 /// \param event  Event to be returned
 ///
-/// \return sfTrue if an event was returned, or sfFalse if the event queue was empty
+/// \return true if an event was returned, or false if the event queue was empty
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfWindow_pollEvent(sfWindow* window, sfEvent* event);
+CSFML_WINDOW_API bool sfWindow_pollEvent(sfWindow* window, sfEvent* event);
 
 ////////////////////////////////////////////////////////////
 /// \brief Wait for an event and return it
@@ -211,10 +211,10 @@ CSFML_WINDOW_API sfBool sfWindow_pollEvent(sfWindow* window, sfEvent* event);
 /// \param window Window object
 /// \param event  Event to be returned
 ///
-/// \return sfFalse if any error occured
+/// \return false if any error occured
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfWindow_waitEvent(sfWindow* window, sfEvent* event);
+CSFML_WINDOW_API bool sfWindow_waitEvent(sfWindow* window, sfEvent* event);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the position of a window
@@ -277,7 +277,7 @@ CSFML_WINDOW_API void sfWindow_setTitle(sfWindow* window, const char* title);
 /// \param title  New title
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindow_setUnicodeTitle(sfWindow* window, const sfUint32* title);
+CSFML_WINDOW_API void sfWindow_setUnicodeTitle(sfWindow* window, const uint32_t* title);
 
 ////////////////////////////////////////////////////////////
 /// \brief Change a window's icon
@@ -291,16 +291,16 @@ CSFML_WINDOW_API void sfWindow_setUnicodeTitle(sfWindow* window, const sfUint32*
 /// \param pixels Pointer to the array of pixels in memory
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindow_setIcon(sfWindow* window, unsigned int width, unsigned int height, const sfUint8* pixels);
+CSFML_WINDOW_API void sfWindow_setIcon(sfWindow* window, unsigned int width, unsigned int height, const uint8_t* pixels);
 
 ////////////////////////////////////////////////////////////
 /// \brief Show or hide a window
 ///
 /// \param window  Window object
-/// \param visible sfTrue to show the window, sfFalse to hide it
+/// \param visible true to show the window, false to hide it
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindow_setVisible(sfWindow* window, sfBool visible);
+CSFML_WINDOW_API void sfWindow_setVisible(sfWindow* window, bool visible);
 
 ////////////////////////////////////////////////////////////
 /// \brief Enable or disable vertical synchronization
@@ -311,19 +311,19 @@ CSFML_WINDOW_API void sfWindow_setVisible(sfWindow* window, sfBool visible);
 /// to a good value (but not constant across different computers).
 ///
 /// \param window  Window object
-/// \param enabled sfTrue to enable v-sync, sfFalse to deactivate
+/// \param enabled true to enable v-sync, false to deactivate
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindow_setVerticalSyncEnabled(sfWindow* window, sfBool enabled);
+CSFML_WINDOW_API void sfWindow_setVerticalSyncEnabled(sfWindow* window, bool enabled);
 
 ////////////////////////////////////////////////////////////
 /// \brief Show or hide the mouse cursor
 ///
 /// \param window  Window object
-/// \param visible sfTrue to show, sfFalse to hide
+/// \param visible true to show, false to hide
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindow_setMouseCursorVisible(sfWindow* window, sfBool visible);
+CSFML_WINDOW_API void sfWindow_setMouseCursorVisible(sfWindow* window, bool visible);
 
 ////////////////////////////////////////////////////////////
 /// \brief Grab or release the mouse cursor
@@ -335,10 +335,10 @@ CSFML_WINDOW_API void sfWindow_setMouseCursorVisible(sfWindow* window, sfBool vi
 /// won't have any effect (fullscreen windows always grab the
 /// cursor).
 ///
-/// \param grabbed sfTrue to enable, sfFalse to disable
+/// \param grabbed true to enable, false to disable
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindow_setMouseCursorGrabbed(sfWindow* window, sfBool grabbed);
+CSFML_WINDOW_API void sfWindow_setMouseCursorGrabbed(sfWindow* window, bool grabbed);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the displayed cursor to a native system cursor
@@ -370,10 +370,10 @@ CSFML_WINDOW_API void sfWindow_setMouseCursor(sfWindow* window, const sfCursor*
 /// Key repeat is enabled by default.
 ///
 /// \param window  Window object
-/// \param enabled sfTrue to enable, sfFalse to disable
+/// \param enabled true to enable, false to disable
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindow_setKeyRepeatEnabled(sfWindow* window, sfBool enabled);
+CSFML_WINDOW_API void sfWindow_setKeyRepeatEnabled(sfWindow* window, bool enabled);
 
 ////////////////////////////////////////////////////////////
 /// \brief Limit the framerate to a maximum fixed frequency
@@ -412,12 +412,12 @@ CSFML_WINDOW_API void sfWindow_setJoystickThreshold(sfWindow* window, float thre
 /// This is not to be confused with sfWindow_requestFocus().
 ///
 /// \param window Window object
-/// \param active sfTrue to activate, sfFalse to deactivate
+/// \param active true to activate, false to deactivate
 ///
-/// \return sfTrue if operation was successful, sfFalse otherwise
+/// \return true if operation was successful, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfWindow_setActive(sfWindow* window, sfBool active);
+CSFML_WINDOW_API bool sfWindow_setActive(sfWindow* window, bool active);
 
 ////////////////////////////////////////////////////////////
 /// \brief Request the current window to be made the active
@@ -443,7 +443,7 @@ CSFML_WINDOW_API void sfWindow_requestFocus(sfWindow* window);
 /// \return True if window has focus, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfWindow_hasFocus(const sfWindow* window);
+CSFML_WINDOW_API bool sfWindow_hasFocus(const sfWindow* window);
 
 ////////////////////////////////////////////////////////////
 /// \brief Display on screen what has been rendered to the

include/SFML/Window/WindowBase.h

@@ -68,7 +68,7 @@ typedef enum
 /// \return A new sfWindow object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfWindowBase* sfWindowBase_create(sfVideoMode mode, const char* title, sfUint32 style);
+CSFML_WINDOW_API sfWindowBase* sfWindowBase_create(sfVideoMode mode, const char* title, uint32_t style);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct a new window (with a UTF-32 title)
@@ -86,7 +86,7 @@ CSFML_WINDOW_API sfWindowBase* sfWindowBase_create(sfVideoMode mode, const char*
 /// \return A new sfWindow object
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfWindowBase* sfWindowBase_createUnicode(sfVideoMode mode, const sfUint32* title, sfUint32 style);
+CSFML_WINDOW_API sfWindowBase* sfWindowBase_createUnicode(sfVideoMode mode, const uint32_t* title, uint32_t style);
 
 ////////////////////////////////////////////////////////////
 /// \brief Construct a window from an existing control
@@ -124,15 +124,15 @@ CSFML_WINDOW_API void sfWindowBase_close(sfWindowBase* windowBase);
 /// \brief Tell whether or not a window is opened
 ///
 /// This function returns whether or not the window exists.
-/// Note that a hidden window (sfWindowBase_setVisible(sfFalse)) will return
+/// Note that a hidden window (sfWindowBase_setVisible(false)) will return
-/// sfTrue.
+/// true.
 ///
 /// \param windowBase Window object
 ///
-/// \return sfTrue if the window is opened, sfFalse if it has been closed
+/// \return true if the window is opened, false if it has been closed
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfWindowBase_isOpen(const sfWindowBase* windowBase);
+CSFML_WINDOW_API bool sfWindowBase_isOpen(const sfWindowBase* windowBase);
 
 ////////////////////////////////////////////////////////////
 /// \brief Pop the event on top of event queue, if any, and return it
@@ -146,10 +146,10 @@ CSFML_WINDOW_API sfBool sfWindowBase_isOpen(const sfWindowBase* windowBase);
 /// \param windowBase Window object
 /// \param event      Event to be returned
 ///
-/// \return sfTrue if an event was returned, or sfFalse if the event queue was empty
+/// \return true if an event was returned, or false if the event queue was empty
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfWindowBase_pollEvent(sfWindowBase* windowBase, sfEvent* event);
+CSFML_WINDOW_API bool sfWindowBase_pollEvent(sfWindowBase* windowBase, sfEvent* event);
 
 ////////////////////////////////////////////////////////////
 /// \brief Wait for an event and return it
@@ -165,10 +165,10 @@ CSFML_WINDOW_API sfBool sfWindowBase_pollEvent(sfWindowBase* windowBase, sfEvent
 /// \param windowBase Window object
 /// \param event      Event to be returned
 ///
-/// \return sfFalse if any error occured
+/// \return false if any error occured
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfWindowBase_waitEvent(sfWindowBase* windowBase, sfEvent* event);
+CSFML_WINDOW_API bool sfWindowBase_waitEvent(sfWindowBase* windowBase, sfEvent* event);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the position of a window
@@ -231,7 +231,7 @@ CSFML_WINDOW_API void sfWindowBase_setTitle(sfWindowBase* windowBase, const char
 /// \param title      New title
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindowBase_setUnicodeTitle(sfWindowBase* windowBase, const sfUint32* title);
+CSFML_WINDOW_API void sfWindowBase_setUnicodeTitle(sfWindowBase* windowBase, const uint32_t* title);
 
 ////////////////////////////////////////////////////////////
 /// \brief Change a window's icon
@@ -245,25 +245,25 @@ CSFML_WINDOW_API void sfWindowBase_setUnicodeTitle(sfWindowBase* windowBase, con
 /// \param pixels     Pointer to the array of pixels in memory
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindowBase_setIcon(sfWindowBase* windowBase, unsigned int width, unsigned int height, const sfUint8* pixels);
+CSFML_WINDOW_API void sfWindowBase_setIcon(sfWindowBase* windowBase, unsigned int width, unsigned int height, const uint8_t* pixels);
 
 ////////////////////////////////////////////////////////////
 /// \brief Show or hide a window
 ///
 /// \param windowBase Window object
-/// \param visible    sfTrue to show the windowBase, sfFalse to hide it
+/// \param visible    true to show the windowBase, false to hide it
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindowBase_setVisible(sfWindowBase* windowBase, sfBool visible);
+CSFML_WINDOW_API void sfWindowBase_setVisible(sfWindowBase* windowBase, bool visible);
 
 ////////////////////////////////////////////////////////////
 /// \brief Show or hide the mouse cursor
 ///
 /// \param windowBase Window object
-/// \param visible    sfTrue to show, sfFalse to hide
+/// \param visible    true to show, false to hide
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindowBase_setMouseCursorVisible(sfWindowBase* windowBase, sfBool visible);
+CSFML_WINDOW_API void sfWindowBase_setMouseCursorVisible(sfWindowBase* windowBase, bool visible);
 
 ////////////////////////////////////////////////////////////
 /// \brief Grab or release the mouse cursor
@@ -275,10 +275,10 @@ CSFML_WINDOW_API void sfWindowBase_setMouseCursorVisible(sfWindowBase* windowBas
 /// won't have any effect (fullscreen windows always grab the
 /// cursor).
 ///
-/// \param grabbed sfTrue to enable, sfFalse to disable
+/// \param grabbed true to enable, false to disable
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindowBase_setMouseCursorGrabbed(sfWindowBase* windowBase, sfBool grabbed);
+CSFML_WINDOW_API void sfWindowBase_setMouseCursorGrabbed(sfWindowBase* windowBase, bool grabbed);
 
 ////////////////////////////////////////////////////////////
 /// \brief Set the displayed cursor to a native system cursor
@@ -310,10 +310,10 @@ CSFML_WINDOW_API void sfWindowBase_setMouseCursor(sfWindowBase* windowBase, cons
 /// Key repeat is enabled by default.
 ///
 /// \param windowBase Window object
-/// \param enabled    sfTrue to enable, sfFalse to disable
+/// \param enabled    true to enable, false to disable
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API void sfWindowBase_setKeyRepeatEnabled(sfWindowBase* windowBase, sfBool enabled);
+CSFML_WINDOW_API void sfWindowBase_setKeyRepeatEnabled(sfWindowBase* windowBase, bool enabled);
 
 ////////////////////////////////////////////////////////////
 /// \brief Change the joystick threshold
@@ -350,7 +350,7 @@ CSFML_WINDOW_API void sfWindowBase_requestFocus(sfWindowBase* windowBase);
 /// \return True if window has focus, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfWindowBase_hasFocus(const sfWindowBase* windowBase);
+CSFML_WINDOW_API bool sfWindowBase_hasFocus(const sfWindowBase* windowBase);
 
 ////////////////////////////////////////////////////////////
 /// \brief Get the OS-specific handle of the window
@@ -379,6 +379,6 @@ CSFML_WINDOW_API sfWindowHandle sfWindowBase_getSystemHandle(const sfWindowBase*
 /// \return True if surface creation was successful, false otherwise
 ///
 ////////////////////////////////////////////////////////////
-CSFML_WINDOW_API sfBool sfWindowBase_createVulkanSurface(sfWindowBase* windowBase, const VkInstance* instance, VkSurfaceKHR* surface, const VkAllocationCallbacks* allocator);
+CSFML_WINDOW_API bool sfWindowBase_createVulkanSurface(sfWindowBase* windowBase, const VkInstance* instance, VkSurfaceKHR* surface, const VkAllocationCallbacks* allocator);
 
 #endif // SFML_WINDOWBASE_H

src/SFML/Audio/Music.cpp

@@ -83,16 +83,16 @@ void sfMusic_destroy(sfMusic* music)
 
 
 ////////////////////////////////////////////////////////////
-void sfMusic_setLoop(sfMusic* music, sfBool loop)
+void sfMusic_setLoop(sfMusic* music, bool loop)
 {
     CSFML_CALL(music, setLoop(loop != 0));
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfMusic_getLoop(const sfMusic* music)
+bool sfMusic_getLoop(const sfMusic* music)
 {
-    CSFML_CALL_RETURN(music, getLoop(), sfFalse);
+    CSFML_CALL_RETURN(music, getLoop(), false);
 }
 
 
@@ -207,9 +207,9 @@ void sfMusic_setPosition(sfMusic* music, sfVector3f position)
 
 
 ////////////////////////////////////////////////////////////
-void sfMusic_setRelativeToListener(sfMusic* music, sfBool relative)
+void sfMusic_setRelativeToListener(sfMusic* music, bool relative)
 {
-    CSFML_CALL(music, setRelativeToListener(relative == sfTrue));
+    CSFML_CALL(music, setRelativeToListener(relative));
 }
 
 
@@ -264,9 +264,9 @@ sfVector3f sfMusic_getPosition(const sfMusic* music)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfMusic_isRelativeToListener(const sfMusic* music)
+bool sfMusic_isRelativeToListener(const sfMusic* music)
 {
-    CSFML_CALL_RETURN(music, isRelativeToListener(), sfFalse);
+    CSFML_CALL_RETURN(music, isRelativeToListener(), false);
 }
 
 

src/SFML/Audio/Sound.cpp

@@ -95,16 +95,16 @@ const sfSoundBuffer* sfSound_getBuffer(const sfSound* sound)
 
 
 ////////////////////////////////////////////////////////////
-void sfSound_setLoop(sfSound* sound, sfBool loop)
+void sfSound_setLoop(sfSound* sound, bool loop)
 {
-    CSFML_CALL(sound, setLoop(loop == sfTrue));
+    CSFML_CALL(sound, setLoop(loop));
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfSound_getLoop(const sfSound* sound)
+bool sfSound_getLoop(const sfSound* sound)
 {
-    CSFML_CALL_RETURN(sound, getLoop(), sfFalse);
+    CSFML_CALL_RETURN(sound, getLoop(), false);
 }
 
 
@@ -139,9 +139,9 @@ void sfSound_setPosition(sfSound* sound, sfVector3f position)
 
 
 ////////////////////////////////////////////////////////////
-void sfSound_setRelativeToListener(sfSound* sound, sfBool relative)
+void sfSound_setRelativeToListener(sfSound* sound, bool relative)
 {
-    CSFML_CALL(sound, setRelativeToListener(relative == sfTrue));
+    CSFML_CALL(sound, setRelativeToListener(relative));
 }
 
 
@@ -196,9 +196,9 @@ sfVector3f sfSound_getPosition(const sfSound* sound)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfSound_isRelativeToListener(const sfSound* sound)
+bool sfSound_isRelativeToListener(const sfSound* sound)
 {
-    CSFML_CALL_RETURN(sound, isRelativeToListener(), sfFalse);
+    CSFML_CALL_RETURN(sound, isRelativeToListener(), false);
 }
 
 

src/SFML/Audio/SoundBuffer.cpp

@@ -80,7 +80,7 @@ sfSoundBuffer* sfSoundBuffer_createFromStream(sfInputStream* stream)
 
 
 ////////////////////////////////////////////////////////////
-sfSoundBuffer* sfSoundBuffer_createFromSamples(const sfInt16* samples, sfUint64 sampleCount, unsigned int channelCount, unsigned int sampleRate)
+sfSoundBuffer* sfSoundBuffer_createFromSamples(const int16_t* samples, uint64_t sampleCount, unsigned int channelCount, unsigned int sampleRate)
 {
     sfSoundBuffer* buffer = new sfSoundBuffer;
 
@@ -111,21 +111,21 @@ void sfSoundBuffer_destroy(sfSoundBuffer* soundBuffer)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfSoundBuffer_saveToFile(const sfSoundBuffer* soundBuffer, const char* filename)
+bool sfSoundBuffer_saveToFile(const sfSoundBuffer* soundBuffer, const char* filename)
 {
-    CSFML_CALL_RETURN(soundBuffer, saveToFile(filename), sfFalse);
+    CSFML_CALL_RETURN(soundBuffer, saveToFile(filename), false);
 }
 
 
 ////////////////////////////////////////////////////////////
-const sfInt16* sfSoundBuffer_getSamples(const sfSoundBuffer* soundBuffer)
+const int16_t* sfSoundBuffer_getSamples(const sfSoundBuffer* soundBuffer)
 {
     CSFML_CALL_RETURN(soundBuffer, getSamples(), nullptr);
 }
 
 
 ////////////////////////////////////////////////////////////
-sfUint64 sfSoundBuffer_getSampleCount(const sfSoundBuffer* soundBuffer)
+uint64_t sfSoundBuffer_getSampleCount(const sfSoundBuffer* soundBuffer)
 {
     CSFML_CALL_RETURN(soundBuffer, getSampleCount(), 0);
 }

src/SFML/Audio/SoundBufferRecorder.cpp

@@ -45,9 +45,9 @@ void sfSoundBufferRecorder_destroy(sfSoundBufferRecorder* soundBufferRecorder)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfSoundBufferRecorder_start(sfSoundBufferRecorder* soundBufferRecorder, unsigned int sampleRate)
+bool sfSoundBufferRecorder_start(sfSoundBufferRecorder* soundBufferRecorder, unsigned int sampleRate)
 {
-    CSFML_CALL_RETURN(soundBufferRecorder, start(sampleRate), sfFalse);
+    CSFML_CALL_RETURN(soundBufferRecorder, start(sampleRate), false);
 }
 
 
@@ -76,9 +76,9 @@ const sfSoundBuffer* sfSoundBufferRecorder_getBuffer(const sfSoundBufferRecorder
 }
 
 ////////////////////////////////////////////////////////////
-sfBool sfSoundBufferRecorder_setDevice(sfSoundBufferRecorder* soundBufferRecorder, const char* name)
+bool sfSoundBufferRecorder_setDevice(sfSoundBufferRecorder* soundBufferRecorder, const char* name)
 {
-    CSFML_CALL_RETURN(soundBufferRecorder, setDevice(name), sfFalse);
+    CSFML_CALL_RETURN(soundBufferRecorder, setDevice(name), false);
 }
 
 ////////////////////////////////////////////////////////////

src/SFML/Audio/SoundRecorder.cpp

@@ -48,9 +48,9 @@ void sfSoundRecorder_destroy(sfSoundRecorder* soundRecorder)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfSoundRecorder_start(sfSoundRecorder* soundRecorder, unsigned int sampleRate)
+bool sfSoundRecorder_start(sfSoundRecorder* soundRecorder, unsigned int sampleRate)
 {
-    CSFML_CALL_RETURN(soundRecorder, start(sampleRate), sfFalse);
+    CSFML_CALL_RETURN(soundRecorder, start(sampleRate), false);
 }
 
 
@@ -69,7 +69,7 @@ unsigned int sfSoundRecorder_getSampleRate(const sfSoundRecorder* soundRecorder)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfSoundRecorder_isAvailable(void)
+bool sfSoundRecorder_isAvailable(void)
 {
     return sf::SoundRecorder::isAvailable();
 }
@@ -113,9 +113,9 @@ const char* sfSoundRecorder_getDefaultDevice()
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfSoundRecorder_setDevice(sfSoundRecorder* soundRecorder, const char* name)
+bool sfSoundRecorder_setDevice(sfSoundRecorder* soundRecorder, const char* name)
 {
-    CSFML_CALL_RETURN(soundRecorder, setDevice(name), sfFalse);
+    CSFML_CALL_RETURN(soundRecorder, setDevice(name), false);
 }
 
 

src/SFML/Audio/SoundRecorderStruct.h

@@ -61,7 +61,7 @@ private :
     virtual bool onStart()
     {
         if (myStartCallback)
-            return myStartCallback(myUserData) == sfTrue;
+            return myStartCallback(myUserData);
         else
             return true;
     }
@@ -69,7 +69,7 @@ private :
     virtual bool onProcessSamples(const sf::Int16* samples, std::size_t sampleCount)
     {
         if (myProcessCallback)
-            return myProcessCallback(samples, sampleCount, myUserData) == sfTrue;
+            return myProcessCallback(samples, sampleCount, myUserData);
         else
             return true;
     }

src/SFML/Audio/SoundStream.cpp

@@ -114,9 +114,9 @@ void sfSoundStream_setPosition(sfSoundStream* soundStream, sfVector3f position)
 
 
 ////////////////////////////////////////////////////////////
-void sfSoundStream_setRelativeToListener(sfSoundStream* soundStream, sfBool relative)
+void sfSoundStream_setRelativeToListener(sfSoundStream* soundStream, bool relative)
 {
-    CSFML_CALL(soundStream, setRelativeToListener(relative == sfTrue));
+    CSFML_CALL(soundStream, setRelativeToListener(relative));
 }
 
 
@@ -142,9 +142,9 @@ void sfSoundStream_setPlayingOffset(sfSoundStream* soundStream, sfTime timeOffse
 
 
 ////////////////////////////////////////////////////////////
-void sfSoundStream_setLoop(sfSoundStream* soundStream, sfBool loop)
+void sfSoundStream_setLoop(sfSoundStream* soundStream, bool loop)
 {
-    CSFML_CALL(soundStream, setLoop(loop == sfTrue));
+    CSFML_CALL(soundStream, setLoop(loop));
 }
 
 
@@ -178,9 +178,9 @@ sfVector3f sfSoundStream_getPosition(const sfSoundStream* soundStream)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfSoundStream_isRelativeToListener(const sfSoundStream* soundStream)
+bool sfSoundStream_isRelativeToListener(const sfSoundStream* soundStream)
 {
-    CSFML_CALL_RETURN(soundStream, isRelativeToListener(), sfFalse);
+    CSFML_CALL_RETURN(soundStream, isRelativeToListener(), false);
 }
 
 
@@ -199,9 +199,9 @@ float sfSoundStream_getAttenuation(const sfSoundStream* soundStream)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfSoundStream_getLoop(const sfSoundStream* soundStream)
+bool sfSoundStream_getLoop(const sfSoundStream* soundStream)
 {
-    CSFML_CALL_RETURN(soundStream, getLoop(), sfFalse);
+    CSFML_CALL_RETURN(soundStream, getLoop(), false);
 }
 
 

src/SFML/Audio/SoundStreamStruct.h

@@ -56,7 +56,7 @@ private :
     virtual bool onGetData(Chunk& data)
     {
         sfSoundStreamChunk chunk = {nullptr, 0};
-        bool ok = (myGetDataCallback(&chunk, myUserData) == sfTrue);
+        bool ok = myGetDataCallback(&chunk, myUserData);
 
         data.samples     = chunk.samples;
         data.sampleCount = chunk.sampleCount;

src/SFML/ConvertEvent.h

@@ -56,10 +56,10 @@ inline void convertEvent(const sf::Event& sfmlEvent, sfEvent* event)
         case sfEvtKeyPressed :
             event->key.code     = static_cast<sfKeyCode>(sfmlEvent.key.code);
             event->key.scancode = static_cast<sfScancode>(sfmlEvent.key.scancode);
-            event->key.alt      = sfmlEvent.key.alt     ? sfTrue : sfFalse;
+            event->key.alt      = sfmlEvent.key.alt;
-            event->key.control  = sfmlEvent.key.control ? sfTrue : sfFalse;
+            event->key.control  = sfmlEvent.key.control;
-            event->key.shift    = sfmlEvent.key.shift   ? sfTrue : sfFalse;
+            event->key.shift    = sfmlEvent.key.shift;
-            event->key.system   = sfmlEvent.key.system  ? sfTrue : sfFalse;
+            event->key.system   = sfmlEvent.key.system;
             break;
 
         case sfEvtMouseWheelMoved :

src/SFML/Graphics/CircleShape.cpp

@@ -177,9 +177,9 @@ sfTransform sfCircleShape_getInverseTransform(const sfCircleShape* shape)
 
 
 ////////////////////////////////////////////////////////////
-void sfCircleShape_setTexture(sfCircleShape* shape, const sfTexture* texture, sfBool resetRect)
+void sfCircleShape_setTexture(sfCircleShape* shape, const sfTexture* texture, bool resetRect)
 {
-    CSFML_CALL(shape, setTexture(texture ? texture->This : nullptr, resetRect == sfTrue));
+    CSFML_CALL(shape, setTexture(texture ? texture->This : nullptr, resetRect));
     shape->Texture = texture;
 }
 

src/SFML/Graphics/Color.cpp

@@ -43,14 +43,14 @@ sfColor sfTransparent = sfColor_fromRGBA( 0,   0,   0, 0);
 
 
 ////////////////////////////////////////////////////////////
-sfColor sfColor_fromRGB(sfUint8 red, sfUint8 green, sfUint8 blue)
+sfColor sfColor_fromRGB(uint8_t red, uint8_t green, uint8_t blue)
 {
     return sfColor_fromRGBA(red, green, blue, 255);
 }
 
 
 ////////////////////////////////////////////////////////////
-sfColor sfColor_fromRGBA(sfUint8 red, sfUint8 green, sfUint8 blue, sfUint8 alpha)
+sfColor sfColor_fromRGBA(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha)
 {
     sfColor color;
 
@@ -64,21 +64,21 @@ sfColor sfColor_fromRGBA(sfUint8 red, sfUint8 green, sfUint8 blue, sfUint8 alpha
 
 
 ////////////////////////////////////////////////////////////
-sfColor sfColor_fromInteger(sfUint32 color)
+sfColor sfColor_fromInteger(uint32_t color)
 {
-    sfUint8 red =   static_cast<sfUint8>((color & 0xff000000) >> 24);
+    uint8_t red =   static_cast<uint8_t>((color & 0xff000000) >> 24);
-    sfUint8 green = static_cast<sfUint8>((color & 0x00ff0000) >> 16);
+    uint8_t green = static_cast<uint8_t>((color & 0x00ff0000) >> 16);
-    sfUint8 blue =  static_cast<sfUint8>((color & 0x0000ff00) >> 8);
+    uint8_t blue =  static_cast<uint8_t>((color & 0x0000ff00) >> 8);
-    sfUint8 alpha = static_cast<sfUint8>((color & 0x000000ff) >> 0);
+    uint8_t alpha = static_cast<uint8_t>((color & 0x000000ff) >> 0);
 
     return sfColor_fromRGBA(red, green, blue, alpha);
 }
 
 
 ////////////////////////////////////////////////////////////
-sfUint32 sfColor_toInteger(sfColor color)
+uint32_t sfColor_toInteger(sfColor color)
 {
-    return static_cast<sfUint32>((color.r << 24) | (color.g << 16) | (color.b << 8) | color.a);
+    return static_cast<uint32_t>((color.r << 24) | (color.g << 16) | (color.b << 8) | color.a);
 }
 
 
@@ -90,10 +90,10 @@ sfColor sfColor_add(sfColor color1, sfColor color2)
     int blue  = std::min(color1.b + color2.b, 255);
     int alpha = std::min(color1.a + color2.a, 255);
 
-    return sfColor_fromRGBA(static_cast<sfUint8>(red),
+    return sfColor_fromRGBA(static_cast<uint8_t>(red),
-                            static_cast<sfUint8>(green),
+                            static_cast<uint8_t>(green),
-                            static_cast<sfUint8>(blue),
+                            static_cast<uint8_t>(blue),
-                            static_cast<sfUint8>(alpha));
+                            static_cast<uint8_t>(alpha));
 }
 
 
@@ -105,10 +105,10 @@ sfColor sfColor_subtract(sfColor color1, sfColor color2)
     int blue  = std::max(color1.b - color2.b, 0);
     int alpha = std::max(color1.a - color2.a, 0);
 
-    return sfColor_fromRGBA(static_cast<sfUint8>(red),
+    return sfColor_fromRGBA(static_cast<uint8_t>(red),
-                            static_cast<sfUint8>(green),
+                            static_cast<uint8_t>(green),
-                            static_cast<sfUint8>(blue),
+                            static_cast<uint8_t>(blue),
-                            static_cast<sfUint8>(alpha));
+                            static_cast<uint8_t>(alpha));
 }
 
 
@@ -120,8 +120,8 @@ sfColor sfColor_modulate(sfColor color1, sfColor color2)
     int blue  = color1.b * color2.b / 255;
     int alpha = color1.a * color2.a / 255;
 
-    return sfColor_fromRGBA(static_cast<sfUint8>(red),
+    return sfColor_fromRGBA(static_cast<uint8_t>(red),
-                            static_cast<sfUint8>(green),
+                            static_cast<uint8_t>(green),
-                            static_cast<sfUint8>(blue),
+                            static_cast<uint8_t>(blue),
-                            static_cast<sfUint8>(alpha));
+                            static_cast<uint8_t>(alpha));
 }

src/SFML/Graphics/ConvexShape.cpp

@@ -174,9 +174,9 @@ sfTransform sfConvexShape_getInverseTransform(const sfConvexShape* shape)
 
 
 ////////////////////////////////////////////////////////////
-void sfConvexShape_setTexture(sfConvexShape* shape, const sfTexture* texture, sfBool resetRect)
+void sfConvexShape_setTexture(sfConvexShape* shape, const sfTexture* texture, bool resetRect)
 {
-    CSFML_CALL(shape, setTexture(texture ? texture->This : nullptr, resetRect == sfTrue));
+    CSFML_CALL(shape, setTexture(texture ? texture->This : nullptr, resetRect));
     shape->Texture = texture;
 }
 

src/SFML/Graphics/Font.cpp

@@ -93,12 +93,12 @@ void sfFont_destroy(sfFont* font)
 
 
 ////////////////////////////////////////////////////////////
-sfGlyph sfFont_getGlyph(const sfFont* font, sfUint32 codePoint, unsigned int characterSize, sfBool bold, float outlineThickness)
+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);
 
-    sf::Glyph SFMLGlyph = font->This.getGlyph(codePoint, characterSize, bold == sfTrue, outlineThickness);
+    sf::Glyph SFMLGlyph = font->This.getGlyph(codePoint, characterSize, bold, outlineThickness);
 
     glyph.advance            = SFMLGlyph.advance;
     glyph.bounds.left        = SFMLGlyph.bounds.left;
@@ -115,14 +115,14 @@ sfGlyph sfFont_getGlyph(const sfFont* font, sfUint32 codePoint, unsigned int cha
 
 
 ////////////////////////////////////////////////////////////
-float sfFont_getKerning(const sfFont* font, sfUint32 first, sfUint32 second, unsigned int characterSize)
+float sfFont_getKerning(const sfFont* font, uint32_t first, uint32_t second, unsigned int characterSize)
 {
     CSFML_CALL_RETURN(font, getKerning(first, second, characterSize), 0);
 }
 
 
 ////////////////////////////////////////////////////////////
-float sfFont_getBoldKerning(const sfFont* font, sfUint32 first, sfUint32 second, unsigned int 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);
 }
@@ -161,21 +161,16 @@ const sfTexture* sfFont_getTexture(sfFont* font, unsigned int characterSize)
 
 
 ////////////////////////////////////////////////////////////
-void sfFont_setSmooth(sfFont* font, sfBool smooth)
+void sfFont_setSmooth(sfFont* font, bool smooth)
 {
-    font->This.setSmooth(smooth == sfTrue);
+    font->This.setSmooth(smooth);
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfFont_isSmooth(const sfFont *font)
+bool sfFont_isSmooth(const sfFont *font)
 {
-    if (font->This.isSmooth())
+    return font->This.isSmooth();
-    {
-        return sfTrue;
-    }
-
-    return sfFalse;
 }
 
 

src/SFML/Graphics/Image.cpp

@@ -53,7 +53,7 @@ sfImage* sfImage_createFromColor(unsigned int width, unsigned int height, sfColo
 
 
 ////////////////////////////////////////////////////////////
-sfImage* sfImage_createFromPixels(unsigned int width, unsigned int height, const sfUint8* data)
+sfImage* sfImage_createFromPixels(unsigned int width, unsigned int height, const uint8_t* data)
 {
     sfImage* image = new sfImage;
     image->This.create(width, height, data);
@@ -127,33 +127,33 @@ void sfImage_destroy(sfImage* image)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfImage_saveToFile(const sfImage* image, const char* filename)
+bool sfImage_saveToFile(const sfImage* image, const char* filename)
 {
-    CSFML_CALL_RETURN(image, saveToFile(filename), sfFalse);
+    CSFML_CALL_RETURN(image, saveToFile(filename), false);
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfImage_saveToMemory(const sfImage* image, sfBuffer* output, const char* format)
+bool sfImage_saveToMemory(const sfImage* image, sfBuffer* output, const char* format)
 {
-    CSFML_CHECK_RETURN(output, sfFalse);
+    CSFML_CHECK_RETURN(output, false);
-    CSFML_CALL_RETURN(image, saveToMemory(output->buffer, format), sfFalse);
+    CSFML_CALL_RETURN(image, saveToMemory(output->buffer, format), false);
 }
 
 
 ////////////////////////////////////////////////////////////
-void sfImage_createMaskFromColor(sfImage* image, sfColor colorKey, sfUint8 alpha)
+void sfImage_createMaskFromColor(sfImage* image, sfColor colorKey, uint8_t alpha)
 {
     CSFML_CALL(image, createMaskFromColor(sf::Color(colorKey.r, colorKey.g, colorKey.b, colorKey.a), alpha));
 }
 
 
 ////////////////////////////////////////////////////////////
-void sfImage_copyImage(sfImage* image, const sfImage* source, unsigned int destX, unsigned int destY, sfIntRect sourceRect, sfBool applyAlpha)
+void sfImage_copyImage(sfImage* image, const sfImage* source, unsigned int destX, unsigned int destY, sfIntRect sourceRect, bool applyAlpha)
 {
     CSFML_CHECK(source);
     sf::IntRect sfmlRect(sourceRect.left, sourceRect.top, sourceRect.width, sourceRect.height);
-    CSFML_CALL(image, copy(source->This, destX, destY, sfmlRect, applyAlpha == sfTrue));
+    CSFML_CALL(image, copy(source->This, destX, destY, sfmlRect, applyAlpha));
 }
 
 
@@ -177,7 +177,7 @@ sfColor sfImage_getPixel(const sfImage* image, unsigned int x, unsigned int y)
 
 
 ////////////////////////////////////////////////////////////
-const sfUint8* sfImage_getPixelsPtr(const sfImage* image)
+const uint8_t* sfImage_getPixelsPtr(const sfImage* image)
 {
     CSFML_CALL_RETURN(image, getPixelsPtr(), nullptr);
 }

src/SFML/Graphics/Rect.cpp

@@ -48,14 +48,14 @@ sfVector2i toCType(const sf::Vector2i& vector)
 ////////////////////////////////////////////////////////////
 /// Check if a point is inside a rectangle's area
 ////////////////////////////////////////////////////////////
-sfBool sfFloatRect_contains(const sfFloatRect* rect, float x, float y)
+bool sfFloatRect_contains(const sfFloatRect* rect, float x, float y)
 {
-    CSFML_CHECK_RETURN(rect, sfFalse);
+    CSFML_CHECK_RETURN(rect, false);
     return sf::FloatRect(rect->left, rect->top, rect->width, rect->height).contains(x, y);
 }
-sfBool sfIntRect_contains(const sfIntRect* rect, int x, int y)
+bool sfIntRect_contains(const sfIntRect* rect, int x, int y)
 {
-    CSFML_CHECK_RETURN(rect, sfFalse);
+    CSFML_CHECK_RETURN(rect, false);
     return sf::IntRect(rect->left, rect->top, rect->width, rect->height).contains(x, y);
 }
 
@@ -63,10 +63,10 @@ sfBool sfIntRect_contains(const sfIntRect* rect, int x, int y)
 ////////////////////////////////////////////////////////////
 /// Check intersection between two rectangles
 ////////////////////////////////////////////////////////////
-sfBool sfFloatRect_intersects(const sfFloatRect* rect1, const sfFloatRect* rect2, sfFloatRect* intersection)
+bool sfFloatRect_intersects(const sfFloatRect* rect1, const sfFloatRect* rect2, sfFloatRect* intersection)
 {
-    CSFML_CHECK_RETURN(rect1, sfFalse);
+    CSFML_CHECK_RETURN(rect1, false);
-    CSFML_CHECK_RETURN(rect2, sfFalse);
+    CSFML_CHECK_RETURN(rect2, false);
 
     sf::FloatRect SFMLRect1(rect1->left, rect1->top, rect1->width, rect1->height);
     sf::FloatRect SFMLRect2(rect2->left, rect2->top, rect2->width, rect2->height);
@@ -88,10 +88,10 @@ sfBool sfFloatRect_intersects(const sfFloatRect* rect1, const sfFloatRect* rect2
         return SFMLRect1.intersects(SFMLRect2);
     }
 }
-sfBool sfIntRect_intersects(const sfIntRect* rect1, const sfIntRect* rect2, sfIntRect* intersection)
+bool sfIntRect_intersects(const sfIntRect* rect1, const sfIntRect* rect2, sfIntRect* intersection)
 {
-    CSFML_CHECK_RETURN(rect1, sfFalse);
+    CSFML_CHECK_RETURN(rect1, false);
-    CSFML_CHECK_RETURN(rect2, sfFalse);
+    CSFML_CHECK_RETURN(rect2, false);
 
     sf::IntRect SFMLRect1(rect1->left, rect1->top, rect1->width, rect1->height);
     sf::IntRect SFMLRect2(rect2->left, rect2->top, rect2->width, rect2->height);

src/SFML/Graphics/RectangleShape.cpp

@@ -174,9 +174,9 @@ sfTransform sfRectangleShape_getInverseTransform(const sfRectangleShape* shape)
 
 
 ////////////////////////////////////////////////////////////
-void sfRectangleShape_setTexture(sfRectangleShape* shape, const sfTexture* texture, sfBool resetRect)
+void sfRectangleShape_setTexture(sfRectangleShape* shape, const sfTexture* texture, bool resetRect)
 {
-    CSFML_CALL(shape, setTexture(texture ? texture->This : nullptr, resetRect == sfTrue));
+    CSFML_CALL(shape, setTexture(texture ? texture->This : nullptr, resetRect));
     shape->Texture = texture;
 }
 

src/SFML/Graphics/RenderTexture.cpp

@@ -41,10 +41,10 @@
 
 
 ////////////////////////////////////////////////////////////
-sfRenderTexture* sfRenderTexture_create(unsigned int width, unsigned int height, sfBool depthBuffer)
+sfRenderTexture* sfRenderTexture_create(unsigned int width, unsigned int height, bool depthBuffer)
 {
     sfRenderTexture* renderTexture = new sfRenderTexture;
-    renderTexture->This.create(width, height, depthBuffer == sfTrue);
+    renderTexture->This.create(width, height, depthBuffer);
     renderTexture->Target = new sfTexture(const_cast<sf::Texture*>(&renderTexture->This.getTexture()));
     renderTexture->DefaultView.This = renderTexture->This.getDefaultView();
     renderTexture->CurrentView.This = renderTexture->This.getView();
@@ -97,17 +97,17 @@ sfVector2u sfRenderTexture_getSize(const sfRenderTexture* renderTexture)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfRenderTexture_isSrgb(const sfRenderTexture* renderTexture)
+bool sfRenderTexture_isSrgb(const sfRenderTexture* renderTexture)
 {
-    CSFML_CHECK_RETURN(renderTexture, sfFalse);
+    CSFML_CHECK_RETURN(renderTexture, false);
     return renderTexture->This.isSrgb();
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfRenderTexture_setActive(sfRenderTexture* renderTexture, sfBool active)
+bool sfRenderTexture_setActive(sfRenderTexture* renderTexture, bool active)
 {
-    CSFML_CALL_RETURN(renderTexture, setActive(active == sfTrue), sfFalse);
+    CSFML_CALL_RETURN(renderTexture, setActive(active), false);
 }
 
 
@@ -303,9 +303,9 @@ const sfTexture* sfRenderTexture_getTexture(const sfRenderTexture* renderTexture
 
 
 ////////////////////////////////////////////////////////////
-void sfRenderTexture_setSmooth(sfRenderTexture* renderTexture, sfBool smooth)
+void sfRenderTexture_setSmooth(sfRenderTexture* renderTexture, bool smooth)
 {
-    CSFML_CALL(renderTexture, setSmooth(smooth == sfTrue));
+    CSFML_CALL(renderTexture, setSmooth(smooth));
 }
 
 
@@ -317,27 +317,27 @@ unsigned int sfRenderTexture_getMaximumAntialiasingLevel()
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfRenderTexture_isSmooth(const sfRenderTexture* renderTexture)
+bool sfRenderTexture_isSmooth(const sfRenderTexture* renderTexture)
 {
-    CSFML_CALL_RETURN(renderTexture, isSmooth(), sfFalse);
+    CSFML_CALL_RETURN(renderTexture, isSmooth(), false);
 }
 
 ////////////////////////////////////////////////////////////
-void sfRenderTexture_setRepeated(sfRenderTexture* renderTexture, sfBool repeated)
+void sfRenderTexture_setRepeated(sfRenderTexture* renderTexture, bool repeated)
 {
-    CSFML_CALL(renderTexture, setRepeated(repeated == sfTrue));
+    CSFML_CALL(renderTexture, setRepeated(repeated));
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfRenderTexture_isRepeated(const sfRenderTexture* renderTexture)
+bool sfRenderTexture_isRepeated(const sfRenderTexture* renderTexture)
 {
-    CSFML_CALL_RETURN(renderTexture, isRepeated(), sfFalse);
+    CSFML_CALL_RETURN(renderTexture, isRepeated(), false);
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfRenderTexture_generateMipmap(sfRenderTexture* renderTexture)
+bool sfRenderTexture_generateMipmap(sfRenderTexture* renderTexture)
 {
-    CSFML_CALL_RETURN(renderTexture, generateMipmap(), sfFalse);
+    CSFML_CALL_RETURN(renderTexture, generateMipmap(), false);
 }

src/SFML/Graphics/RenderWindow.cpp

@@ -45,7 +45,7 @@
 
 
 ////////////////////////////////////////////////////////////
-sfRenderWindow* sfRenderWindow_create(sfVideoMode mode, const char* title, sfUint32 style, const sfContextSettings* settings)
+sfRenderWindow* sfRenderWindow_create(sfVideoMode mode, const char* title, uint32_t style, const sfContextSettings* settings)
 {
     // Convert video mode
     sf::VideoMode videoMode(mode.width, mode.height, mode.bitsPerPixel);
@@ -67,7 +67,7 @@ sfRenderWindow* sfRenderWindow_create(sfVideoMode mode, const char* title, sfUin
 }
 
 ////////////////////////////////////////////////////////////
-sfRenderWindow* sfRenderWindow_createUnicode(sfVideoMode mode, const sfUint32* title, sfUint32 style, const sfContextSettings* settings)
+sfRenderWindow* sfRenderWindow_createUnicode(sfVideoMode mode, const uint32_t* title, uint32_t style, const sfContextSettings* settings)
 {
     // Convert video mode
     sf::VideoMode videoMode(mode.width, mode.height, mode.bitsPerPixel);
@@ -124,9 +124,9 @@ void sfRenderWindow_close(sfRenderWindow* renderWindow)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfRenderWindow_isOpen(const sfRenderWindow* renderWindow)
+bool sfRenderWindow_isOpen(const sfRenderWindow* renderWindow)
 {
-    CSFML_CALL_RETURN(renderWindow, isOpen(), sfFalse);
+    CSFML_CALL_RETURN(renderWindow, isOpen(), false);
 }
 
 
@@ -144,44 +144,44 @@ sfContextSettings sfRenderWindow_getSettings(const sfRenderWindow* renderWindow)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfRenderWindow_pollEvent(sfRenderWindow* renderWindow, sfEvent* event)
+bool sfRenderWindow_pollEvent(sfRenderWindow* renderWindow, sfEvent* event)
 {
-    CSFML_CHECK_RETURN(renderWindow, sfFalse);
+    CSFML_CHECK_RETURN(renderWindow, false);
-    CSFML_CHECK_RETURN(event,        sfFalse);
+    CSFML_CHECK_RETURN(event,        false);
 
     // Get the event
     sf::Event sfmlEvent;
-    sfBool ret = renderWindow->This.pollEvent(sfmlEvent);
+    bool ret = renderWindow->This.pollEvent(sfmlEvent);
 
     // No event, return
     if (!ret)
-        return sfFalse;
+        return false;
 
     // Convert the sf::Event event to a sfEvent
     convertEvent(sfmlEvent, event);
 
-    return sfTrue;
+    return true;
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfRenderWindow_waitEvent(sfRenderWindow* renderWindow, sfEvent* event)
+bool sfRenderWindow_waitEvent(sfRenderWindow* renderWindow, sfEvent* event)
 {
-    CSFML_CHECK_RETURN(renderWindow, sfFalse);
+    CSFML_CHECK_RETURN(renderWindow, false);
-    CSFML_CHECK_RETURN(event,        sfFalse);
+    CSFML_CHECK_RETURN(event,        false);
 
     // Get the event
     sf::Event sfmlEvent;
-    sfBool ret = renderWindow->This.waitEvent(sfmlEvent);
+    bool ret = renderWindow->This.waitEvent(sfmlEvent);
 
     // Error, return
     if (!ret)
-        return sfFalse;
+        return false;
 
     // Convert the sf::Event event to a sfEvent
     convertEvent(sfmlEvent, event);
 
-    return sfTrue;
+    return true;
 }
 
 
@@ -221,9 +221,9 @@ sfVector2u sfRenderWindow_getSize(const sfRenderWindow* renderWindow)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfRenderWindow_isSrgb(const sfRenderWindow* renderWindow)
+bool sfRenderWindow_isSrgb(const sfRenderWindow* renderWindow)
 {
-    CSFML_CHECK_RETURN(renderWindow, sfFalse);
+    CSFML_CHECK_RETURN(renderWindow, false);
     return renderWindow->This.isSrgb();
 }
 
@@ -243,44 +243,44 @@ void sfRenderWindow_setTitle(sfRenderWindow* renderWindow, const char* title)
 
 
 ////////////////////////////////////////////////////////////
-void sfRenderWindow_setUnicodeTitle(sfRenderWindow* renderWindow, const sfUint32* title)
+void sfRenderWindow_setUnicodeTitle(sfRenderWindow* renderWindow, const uint32_t* title)
 {
     CSFML_CALL(renderWindow, setTitle(title));
 }
 
 
 ////////////////////////////////////////////////////////////
-void sfRenderWindow_setIcon(sfRenderWindow* renderWindow, unsigned int width, unsigned int height, const sfUint8* pixels)
+void sfRenderWindow_setIcon(sfRenderWindow* renderWindow, unsigned int width, unsigned int height, const uint8_t* pixels)
 {
     CSFML_CALL(renderWindow, setIcon(width, height, pixels));
 }
 
 
 ////////////////////////////////////////////////////////////
-void sfRenderWindow_setVisible(sfRenderWindow* renderWindow, sfBool visible)
+void sfRenderWindow_setVisible(sfRenderWindow* renderWindow, bool visible)
 {
-    CSFML_CALL(renderWindow, setVisible(visible == sfTrue));
+    CSFML_CALL(renderWindow, setVisible(visible));
 }
 
 
 ////////////////////////////////////////////////////////////
-void sfRenderWindow_setVerticalSyncEnabled(sfRenderWindow* renderWindow, sfBool enabled)
+void sfRenderWindow_setVerticalSyncEnabled(sfRenderWindow* renderWindow, bool enabled)
 {
-    CSFML_CALL(renderWindow, setVerticalSyncEnabled(enabled == sfTrue));
+    CSFML_CALL(renderWindow, setVerticalSyncEnabled(enabled));
 }
 
 
 ////////////////////////////////////////////////////////////
-void sfRenderWindow_setMouseCursorVisible(sfRenderWindow* renderWindow, sfBool visible)
+void sfRenderWindow_setMouseCursorVisible(sfRenderWindow* renderWindow, bool visible)
 {
-    CSFML_CALL(renderWindow, setMouseCursorVisible(visible == sfTrue));
+    CSFML_CALL(renderWindow, setMouseCursorVisible(visible));
 }
 
 
 ////////////////////////////////////////////////////////////
-void sfRenderWindow_setMouseCursorGrabbed(sfRenderWindow* renderWindow, sfBool grabbed)
+void sfRenderWindow_setMouseCursorGrabbed(sfRenderWindow* renderWindow, bool grabbed)
 {
-    CSFML_CALL(renderWindow, setMouseCursorGrabbed(grabbed == sfTrue));
+    CSFML_CALL(renderWindow, setMouseCursorGrabbed(grabbed));
 }
 
 
@@ -294,16 +294,16 @@ void sfRenderWindow_setMouseCursor(sfRenderWindow* window, const sfCursor* curso
 
 
 ////////////////////////////////////////////////////////////
-void sfRenderWindow_setKeyRepeatEnabled(sfRenderWindow* renderWindow, sfBool enabled)
+void sfRenderWindow_setKeyRepeatEnabled(sfRenderWindow* renderWindow, bool enabled)
 {
-    CSFML_CALL(renderWindow, setKeyRepeatEnabled(enabled == sfTrue));
+    CSFML_CALL(renderWindow, setKeyRepeatEnabled(enabled));
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfRenderWindow_setActive(sfRenderWindow* renderWindow, sfBool active)
+bool sfRenderWindow_setActive(sfRenderWindow* renderWindow, bool active)
 {
-    CSFML_CALL_RETURN(renderWindow, setActive(active == sfTrue), sfFalse);
+    CSFML_CALL_RETURN(renderWindow, setActive(active), false);
 }
 
 
@@ -315,9 +315,9 @@ void sfRenderWindow_requestFocus(sfRenderWindow* renderWindow)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfRenderWindow_hasFocus(const sfRenderWindow* renderWindow)
+bool sfRenderWindow_hasFocus(const sfRenderWindow* renderWindow)
 {
-    CSFML_CALL_RETURN(renderWindow, hasFocus(), sfFalse);
+    CSFML_CALL_RETURN(renderWindow, hasFocus(), false);
 }
 
 

src/SFML/Graphics/Shader.cpp

@@ -278,30 +278,30 @@ void sfShader_setIntColorUniform(sfShader* shader, const char* name, sfColor col
 }
 
 ////////////////////////////////////////////////////////////
-void sfShader_setBoolUniform(sfShader* shader, const char* name, sfBool x)
+void sfShader_setBoolUniform(sfShader* shader, const char* name, bool x)
 {
-    CSFML_CALL(shader, setUniform(name, x != sfFalse));
+    CSFML_CALL(shader, setUniform(name, x));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setBvec2Uniform(sfShader* shader, const char* name, sfGlslBvec2 vector)
 {
-    CSFML_CALL(shader, setUniform(name, sf::Glsl::Bvec2(vector.x != sfFalse, vector.y != sfFalse)));
+    CSFML_CALL(shader, 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 != sfFalse, vector.y != sfFalse, vector.z != sfFalse)));
+    CSFML_CALL(shader, 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 != sfFalse, vector.y != sfFalse, vector.z != sfFalse, vector.w != sfFalse)));
+    CSFML_CALL(shader, setUniform(name, sf::Glsl::Bvec4(vector.x, vector.y, vector.z, vector.w)));
 }
 
 
@@ -461,14 +461,14 @@ void sfShader_bind(const sfShader* shader)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfShader_isAvailable(void)
+bool sfShader_isAvailable(void)
 {
-    return sf::Shader::isAvailable() ? sfTrue : sfFalse;
+    return sf::Shader::isAvailable();
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfShader_isGeometryAvailable(void)
+bool sfShader_isGeometryAvailable(void)
 {
-    return sf::Shader::isGeometryAvailable() ? sfTrue : sfFalse;
+    return sf::Shader::isGeometryAvailable();
 }

src/SFML/Graphics/Shape.cpp

@@ -167,9 +167,9 @@ sfTransform sfShape_getInverseTransform(const sfShape* shape)
 
 
 ////////////////////////////////////////////////////////////
-void sfShape_setTexture(sfShape* shape, const sfTexture* texture, sfBool resetRect)
+void sfShape_setTexture(sfShape* shape, const sfTexture* texture, bool resetRect)
 {
-    CSFML_CALL(shape, setTexture(texture ? texture->This : nullptr, resetRect == sfTrue));
+    CSFML_CALL(shape, setTexture(texture ? texture->This : nullptr, resetRect));
     shape->Texture = texture;
 }
 

src/SFML/Graphics/Sprite.cpp

@@ -178,11 +178,11 @@ sfTransform sfSprite_getInverseTransform(const sfSprite* sprite)
 
 
 ////////////////////////////////////////////////////////////
-void sfSprite_setTexture(sfSprite* sprite, const sfTexture* texture, sfBool resetRect)
+void sfSprite_setTexture(sfSprite* sprite, const sfTexture* texture, bool resetRect)
 {
     if (texture && texture->This)
     {
-        CSFML_CALL(sprite, setTexture(*texture->This, resetRect == sfTrue));
+        CSFML_CALL(sprite, setTexture(*texture->This, resetRect));
         sprite->Texture = texture;
     }
 }

src/SFML/Graphics/Text.cpp

@@ -185,7 +185,7 @@ void sfText_setString(sfText* text, const char* string)
 
 
 ////////////////////////////////////////////////////////////
-void sfText_setUnicodeString(sfText* text, const sfUint32* string)
+void sfText_setUnicodeString(sfText* text, const uint32_t* string)
 {
     sf::String UTF32Text = string;
     CSFML_CALL(text, setString(UTF32Text));
@@ -224,7 +224,7 @@ void sfText_setLetterSpacing(sfText* text, float spacingFactor)
 
 
 ////////////////////////////////////////////////////////////
-void sfText_setStyle(sfText* text, sfUint32 style)
+void sfText_setStyle(sfText* text, uint32_t style)
 {
     CSFML_CALL(text, setStyle(style));
 }
@@ -270,7 +270,7 @@ const char* sfText_getString(const sfText* text)
 
 
 ////////////////////////////////////////////////////////////
-const sfUint32* sfText_getUnicodeString(const sfText* text)
+const uint32_t* sfText_getUnicodeString(const sfText* text)
 {
     CSFML_CHECK_RETURN(text, nullptr);
 
@@ -310,7 +310,7 @@ float sfText_getLineSpacing(const sfText* text)
 
 
 ////////////////////////////////////////////////////////////
-sfUint32 sfText_getStyle(const sfText* text)
+uint32_t sfText_getStyle(const sfText* text)
 {
     CSFML_CALL_RETURN(text, getStyle(), 0);
 }

src/SFML/Graphics/Texture.cpp

@@ -258,7 +258,7 @@ sfImage* sfTexture_copyToImage(const sfTexture* texture)
 
 
 ////////////////////////////////////////////////////////////
-void sfTexture_updateFromPixels(sfTexture* texture, const sfUint8* pixels, unsigned int width, unsigned int height, unsigned int x, unsigned int y)
+void sfTexture_updateFromPixels(sfTexture* texture, const uint8_t* pixels, unsigned int width, unsigned int height, unsigned int x, unsigned int y)
 {
     CSFML_CALL_PTR(texture, update(pixels, width, height, x, y));
 }
@@ -302,49 +302,49 @@ void sfTexture_updateFromRenderWindow(sfTexture* texture, const sfRenderWindow*
 
 
 ////////////////////////////////////////////////////////////
-void sfTexture_setSmooth(sfTexture* texture, sfBool smooth)
+void sfTexture_setSmooth(sfTexture* texture, bool smooth)
 {
-    CSFML_CALL_PTR(texture, setSmooth(smooth == sfTrue));
+    CSFML_CALL_PTR(texture, setSmooth(smooth));
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfTexture_isSmooth(const sfTexture* texture)
+bool sfTexture_isSmooth(const sfTexture* texture)
 {
-    CSFML_CHECK_RETURN(texture, sfFalse);
+    CSFML_CHECK_RETURN(texture, false);
-    CSFML_CHECK_RETURN(texture->This, sfFalse);
+    CSFML_CHECK_RETURN(texture->This, false);
 
     return texture->This->isSmooth();
 }
 
 ////////////////////////////////////////////////////////////
-sfBool sfTexture_isSrgb(const sfTexture* texture)
+bool sfTexture_isSrgb(const sfTexture* texture)
 {
-    CSFML_CALL_PTR_RETURN(texture, isSrgb(), sfFalse);
+    CSFML_CALL_PTR_RETURN(texture, isSrgb(), false);
 }
 
 
 ////////////////////////////////////////////////////////////
-void sfTexture_setRepeated(sfTexture* texture, sfBool repeated)
+void sfTexture_setRepeated(sfTexture* texture, bool repeated)
 {
-    CSFML_CALL_PTR(texture, setRepeated(repeated == sfTrue));
+    CSFML_CALL_PTR(texture, setRepeated(repeated));
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfTexture_isRepeated(const sfTexture* texture)
+bool sfTexture_isRepeated(const sfTexture* texture)
 {
-    CSFML_CHECK_RETURN(texture, sfFalse);
+    CSFML_CHECK_RETURN(texture, false);
-    CSFML_CHECK_RETURN(texture->This, sfFalse);
+    CSFML_CHECK_RETURN(texture->This, false);
 
     return texture->This->isRepeated();
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfTexture_generateMipmap(sfTexture* texture)
+bool sfTexture_generateMipmap(sfTexture* texture)
 {
-    CSFML_CALL_PTR_RETURN(texture, generateMipmap(), sfFalse);
+    CSFML_CALL_PTR_RETURN(texture, generateMipmap(), false);
 }
 
 

src/SFML/Graphics/Transform.cpp

@@ -159,13 +159,13 @@ void sfTransform_scaleWithCenter(sfTransform* transform, float scaleX, float sca
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfTransform_equal(sfTransform* left, sfTransform* right)
+bool sfTransform_equal(sfTransform* left, sfTransform* right)
 {
     CSFML_CHECK_RETURN(left, false);
     CSFML_CHECK_RETURN(right, false);
 
     for (int i = 0; i < 9; ++i) {
-        if (left->matrix[i] != right->matrix[i]) return sfFalse;
+        if (left->matrix[i] != right->matrix[i]) return false;
     }
-    return sfTrue;
+    return true;
 }

src/SFML/Graphics/VertexBuffer.cpp

@@ -75,17 +75,17 @@ unsigned int sfVertexBuffer_getVertexCount(const sfVertexBuffer* vertexBuffer)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfVertexBuffer_update(sfVertexBuffer* vertexBuffer, const sfVertex* vertices, unsigned int vertexCount, unsigned int offset)
+bool sfVertexBuffer_update(sfVertexBuffer* vertexBuffer, const sfVertex* vertices, unsigned int vertexCount, unsigned int offset)
 {
     // the cast is safe, sfVertex has to be binary compatible with sf::Vertex
-    CSFML_CALL_RETURN(vertexBuffer, update(reinterpret_cast<const sf::Vertex*>(vertices), vertexCount, offset), sfFalse);
+    CSFML_CALL_RETURN(vertexBuffer, update(reinterpret_cast<const sf::Vertex*>(vertices), vertexCount, offset), false);
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfVertexBuffer_updateFromVertexBuffer(sfVertexBuffer* vertexBuffer, const sfVertexBuffer* other)
+bool sfVertexBuffer_updateFromVertexBuffer(sfVertexBuffer* vertexBuffer, const sfVertexBuffer* other)
 {
-    CSFML_CALL_RETURN(vertexBuffer, update(other->This), sfFalse);
+    CSFML_CALL_RETURN(vertexBuffer, update(other->This), false);
 }
 
 
@@ -143,7 +143,7 @@ void sfVertexBuffer_bind(const sfVertexBuffer* vertexBuffer)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfVertexBuffer_isAvailable()
+bool sfVertexBuffer_isAvailable()
 {
-    return sf::VertexBuffer::isAvailable() ? sfTrue : sfFalse;
+    return sf::VertexBuffer::isAvailable();
 }

src/SFML/Network/Ftp.cpp

@@ -39,9 +39,9 @@ void sfFtpListingResponse_destroy(sfFtpListingResponse* ftpListingResponse)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfFtpListingResponse_isOk(const sfFtpListingResponse* ftpListingResponse)
+bool sfFtpListingResponse_isOk(const sfFtpListingResponse* ftpListingResponse)
 {
-    CSFML_CALL_RETURN(ftpListingResponse, isOk(), sfFalse);
+    CSFML_CALL_RETURN(ftpListingResponse, isOk(), false);
 }
 
 
@@ -89,9 +89,9 @@ void sfFtpDirectoryResponse_destroy(sfFtpDirectoryResponse* ftpDirectoryResponse
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfFtpDirectoryResponse_isOk(const sfFtpDirectoryResponse* ftpDirectoryResponse)
+bool sfFtpDirectoryResponse_isOk(const sfFtpDirectoryResponse* ftpDirectoryResponse)
 {
-    CSFML_CALL_RETURN(ftpDirectoryResponse, isOk(), sfFalse);
+    CSFML_CALL_RETURN(ftpDirectoryResponse, isOk(), false);
 }
 
 
@@ -130,9 +130,9 @@ void sfFtpResponse_destroy(sfFtpResponse* ftpResponse)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfFtpResponse_isOk(const sfFtpResponse* ftpResponse)
+bool sfFtpResponse_isOk(const sfFtpResponse* ftpResponse)
 {
-    CSFML_CALL_RETURN(ftpResponse, isOk(), sfFalse);
+    CSFML_CALL_RETURN(ftpResponse, isOk(), false);
 }
 
 
@@ -299,14 +299,14 @@ sfFtpResponse* sfFtp_download(sfFtp* ftp, const char* remoteFile, const char* lo
 
 
 ////////////////////////////////////////////////////////////
-sfFtpResponse* sfFtp_upload(sfFtp* ftp, const char* localFile, const char* remotePath, sfFtpTransferMode mode, sfBool append)
+sfFtpResponse* sfFtp_upload(sfFtp* ftp, const char* localFile, const char* remotePath, sfFtpTransferMode mode, bool append)
 {
     CSFML_CHECK_RETURN(ftp, nullptr);
 
     return new sfFtpResponse(ftp->This.upload(localFile ? localFile : "",
                                               remotePath ? remotePath : "",
                                               static_cast<sf::Ftp::TransferMode>(mode),
-                                              append == sfTrue));
+                                              append));
 }
 
 

src/SFML/Network/IpAddress.cpp

@@ -73,14 +73,14 @@ sfIpAddress sfIpAddress_fromString(const char* address)
 
 
 ////////////////////////////////////////////////////////////
-sfIpAddress sfIpAddress_fromBytes(sfUint8 byte0, sfUint8 byte1, sfUint8 byte2, sfUint8 byte3)
+sfIpAddress sfIpAddress_fromBytes(uint8_t byte0, uint8_t byte1, uint8_t byte2, uint8_t byte3)
 {
     return fromSFMLAddress(sf::IpAddress(byte0, byte1, byte2, byte3));
 }
 
 
 ////////////////////////////////////////////////////////////
-sfIpAddress sfIpAddress_fromInteger(sfUint32 address)
+sfIpAddress sfIpAddress_fromInteger(uint32_t address)
 {
     return fromSFMLAddress(sf::IpAddress(address));
 }
@@ -95,7 +95,7 @@ void sfIpAddress_toString(sfIpAddress address, char* string)
 
 
 ////////////////////////////////////////////////////////////
-sfUint32 sfIpAddress_toInteger(sfIpAddress address)
+uint32_t sfIpAddress_toInteger(sfIpAddress address)
 {
     return toSFMLAddress(address).toInteger();
 }

src/SFML/Network/Packet.cpp

@@ -89,77 +89,77 @@ size_t sfPacket_getDataSize(const sfPacket* packet)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfPacket_endOfPacket(const sfPacket* packet)
+bool sfPacket_endOfPacket(const sfPacket* packet)
 {
-    CSFML_CALL_RETURN(packet, endOfPacket(), sfFalse);
+    CSFML_CALL_RETURN(packet, endOfPacket(), false);
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfPacket_canRead(const sfPacket* packet)
+bool sfPacket_canRead(const sfPacket* packet)
 {
-    CSFML_CHECK_RETURN(packet, sfFalse);
+    CSFML_CHECK_RETURN(packet, false);
-    return packet->This ? sfTrue : sfFalse;
+    return packet->This;
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfPacket_readBool(sfPacket* packet)
+bool sfPacket_readBool(sfPacket* packet)
 {
     return sfPacket_readUint8(packet);
 }
-sfInt8 sfPacket_readInt8(sfPacket* packet)
+int8_t sfPacket_readInt8(sfPacket* packet)
 {
-    CSFML_CHECK_RETURN(packet, sfFalse);
+    CSFML_CHECK_RETURN(packet, false);
-    sfInt8 value;
+    int8_t value;
     packet->This >> value;
     return value;
 }
-sfUint8 sfPacket_readUint8(sfPacket* packet)
+uint8_t sfPacket_readUint8(sfPacket* packet)
 {
-    CSFML_CHECK_RETURN(packet, sfFalse);
+    CSFML_CHECK_RETURN(packet, false);
-    sfUint8 value;
+    uint8_t value;
     packet->This >> value;
     return value;
 }
-sfInt16 sfPacket_readInt16(sfPacket* packet)
+int16_t sfPacket_readInt16(sfPacket* packet)
 {
-    CSFML_CHECK_RETURN(packet, sfFalse);
+    CSFML_CHECK_RETURN(packet, false);
-    sfInt16 value;
+    int16_t value;
     packet->This >> value;
     return value;
 }
-sfUint16 sfPacket_readUint16(sfPacket* packet)
+uint16_t sfPacket_readUint16(sfPacket* packet)
 {
-    CSFML_CHECK_RETURN(packet, sfFalse);
+    CSFML_CHECK_RETURN(packet, false);
-    sfUint16 value;
+    uint16_t value;
     packet->This >> value;
     return value;
 }
-sfInt32 sfPacket_readInt32(sfPacket* packet)
+int32_t sfPacket_readInt32(sfPacket* packet)
 {
-    CSFML_CHECK_RETURN(packet, sfFalse);
+    CSFML_CHECK_RETURN(packet, false);
-    sfInt32 value;
+    int32_t value;
     packet->This >> value;
     return value;
 }
-sfUint32 sfPacket_readUint32(sfPacket* packet)
+uint32_t sfPacket_readUint32(sfPacket* packet)
 {
-    CSFML_CHECK_RETURN(packet, sfFalse);
+    CSFML_CHECK_RETURN(packet, false);
-    sfUint32 value;
+    uint32_t value;
     packet->This >> value;
     return value;
 }
 float sfPacket_readFloat(sfPacket* packet)
 {
-    CSFML_CHECK_RETURN(packet, sfFalse);
+    CSFML_CHECK_RETURN(packet, false);
     float value;
     packet->This >> value;
     return value;
 }
 double sfPacket_readDouble(sfPacket* packet)
 {
-    CSFML_CHECK_RETURN(packet, sfFalse);
+    CSFML_CHECK_RETURN(packet, false);
     double value;
     packet->This >> value;
     return value;
@@ -179,36 +179,36 @@ void sfPacket_readWideString(sfPacket* packet, wchar_t* string)
 
 
 ////////////////////////////////////////////////////////////
-void sfPacket_writeBool(sfPacket* packet, sfBool value)
+void sfPacket_writeBool(sfPacket* packet, bool value)
 {
     sfPacket_writeUint8(packet, value ? 1 : 0);
 }
-void sfPacket_writeInt8(sfPacket* packet, sfInt8 value)
+void sfPacket_writeInt8(sfPacket* packet, int8_t value)
 {
     CSFML_CHECK(packet);
     packet->This << value;
 }
-void sfPacket_writeUint8(sfPacket* packet, sfUint8 value)
+void sfPacket_writeUint8(sfPacket* packet, uint8_t value)
 {
     CSFML_CHECK(packet);
     packet->This << value;
 }
-void sfPacket_writeInt16(sfPacket* packet, sfInt16 value)
+void sfPacket_writeInt16(sfPacket* packet, int16_t value)
 {
     CSFML_CHECK(packet);
     packet->This << value;
 }
-void sfPacket_writeUint16(sfPacket* packet, sfUint16 value)
+void sfPacket_writeUint16(sfPacket* packet, uint16_t value)
 {
     CSFML_CHECK(packet);
     packet->This << value;
 }
-void sfPacket_writeInt32(sfPacket* packet, sfInt32 value)
+void sfPacket_writeInt32(sfPacket* packet, int32_t value)
 {
     CSFML_CHECK(packet);
     packet->This << value;
 }
-void sfPacket_writeUint32(sfPacket* packet, sfUint32 value)
+void sfPacket_writeUint32(sfPacket* packet, uint32_t value)
 {
     CSFML_CHECK(packet);
     packet->This << value;

src/SFML/Network/SocketSelector.cpp

@@ -100,25 +100,25 @@ void sfSocketSelector_clear(sfSocketSelector* selector)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfSocketSelector_wait(sfSocketSelector* selector, sfTime timeout)
+bool sfSocketSelector_wait(sfSocketSelector* selector, sfTime timeout)
 {
-    CSFML_CALL_RETURN(selector, wait(sf::microseconds(timeout.microseconds)), sfFalse);
+    CSFML_CALL_RETURN(selector, wait(sf::microseconds(timeout.microseconds)), false);
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfSocketSelector_isTcpListenerReady(const sfSocketSelector* selector, sfTcpListener* socket)
+bool sfSocketSelector_isTcpListenerReady(const sfSocketSelector* selector, sfTcpListener* socket)
 {
-    CSFML_CHECK_RETURN(socket, sfFalse);
+    CSFML_CHECK_RETURN(socket, false);
-    CSFML_CALL_RETURN(selector, isReady(socket->This), sfFalse);
+    CSFML_CALL_RETURN(selector, isReady(socket->This), false);
 }
-sfBool sfSocketSelector_isTcpSocketReady(const sfSocketSelector* selector, sfTcpSocket* socket)
+bool sfSocketSelector_isTcpSocketReady(const sfSocketSelector* selector, sfTcpSocket* socket)
 {
-    CSFML_CHECK_RETURN(socket, sfFalse);
+    CSFML_CHECK_RETURN(socket, false);
-    CSFML_CALL_RETURN(selector, isReady(socket->This), sfFalse);
+    CSFML_CALL_RETURN(selector, isReady(socket->This), false);
 }
-sfBool sfSocketSelector_isUdpSocketReady(const sfSocketSelector* selector, sfUdpSocket* socket)
+bool sfSocketSelector_isUdpSocketReady(const sfSocketSelector* selector, sfUdpSocket* socket)
 {
-    CSFML_CHECK_RETURN(socket, sfFalse);
+    CSFML_CHECK_RETURN(socket, false);
-    CSFML_CALL_RETURN(selector, isReady(socket->This), sfFalse);
+    CSFML_CALL_RETURN(selector, isReady(socket->This), false);
 }

src/SFML/Network/TcpListener.cpp

@@ -46,16 +46,16 @@ void sfTcpListener_destroy(sfTcpListener* listener)
 
 
 ////////////////////////////////////////////////////////////
-void sfTcpListener_setBlocking(sfTcpListener* listener, sfBool blocking)
+void sfTcpListener_setBlocking(sfTcpListener* listener, bool blocking)
 {
-    CSFML_CALL(listener, setBlocking(blocking == sfTrue));
+    CSFML_CALL(listener, setBlocking(blocking));
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfTcpListener_isBlocking(const sfTcpListener* listener)
+bool sfTcpListener_isBlocking(const sfTcpListener* listener)
 {
-    CSFML_CALL_RETURN(listener, isBlocking(), sfFalse);
+    CSFML_CALL_RETURN(listener, isBlocking(), false);
 }
 
 

src/SFML/Network/TcpSocket.cpp

@@ -48,16 +48,16 @@ void sfTcpSocket_destroy(sfTcpSocket* socket)
 
 
 ////////////////////////////////////////////////////////////
-void sfTcpSocket_setBlocking(sfTcpSocket* socket, sfBool blocking)
+void sfTcpSocket_setBlocking(sfTcpSocket* socket, bool blocking)
 {
-    CSFML_CALL(socket, setBlocking(blocking == sfTrue));
+    CSFML_CALL(socket, setBlocking(blocking));
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfTcpSocket_isBlocking(const sfTcpSocket* socket)
+bool sfTcpSocket_isBlocking(const sfTcpSocket* socket)
 {
-    CSFML_CALL_RETURN(socket, isBlocking(), sfFalse);
+    CSFML_CALL_RETURN(socket, isBlocking(), false);
 }
 
 

src/SFML/Network/UdpSocket.cpp

@@ -48,15 +48,15 @@ void sfUdpSocket_destroy(sfUdpSocket* socket)
 
 
 ////////////////////////////////////////////////////////////
-void sfUdpSocket_setBlocking(sfUdpSocket* socket, sfBool blocking)
+void sfUdpSocket_setBlocking(sfUdpSocket* socket, bool blocking)
 {
-    CSFML_CALL(socket, setBlocking(blocking == sfTrue));
+    CSFML_CALL(socket, setBlocking(blocking));
 }
 
 ////////////////////////////////////////////////////////////
-sfBool sfUdpSocket_isBlocking(const sfUdpSocket* socket)
+bool sfUdpSocket_isBlocking(const sfUdpSocket* socket)
 {
-    CSFML_CALL_RETURN(socket, isBlocking(), sfFalse);
+    CSFML_CALL_RETURN(socket, isBlocking(), false);
 }
 
 

src/SFML/System/Buffer.cpp

@@ -53,7 +53,7 @@ size_t sfBuffer_getSize(const sfBuffer* buffer)
 
 
 ////////////////////////////////////////////////////////////
-const sfUint8* sfBuffer_getData(const sfBuffer* buffer)
+const uint8_t* sfBuffer_getData(const sfBuffer* buffer)
 {
     CSFML_CHECK_RETURN(buffer, nullptr);
     return !buffer->buffer.empty() ? &buffer->buffer[0] : nullptr;

src/SFML/System/Time.cpp

@@ -40,14 +40,14 @@ float sfTime_asSeconds(sfTime time)
 
 
 ////////////////////////////////////////////////////////////
-sfInt32 sfTime_asMilliseconds(sfTime time)
+int32_t sfTime_asMilliseconds(sfTime time)
 {
-    return static_cast<sfInt32>(time.microseconds / 1000);
+    return static_cast<int32_t>(time.microseconds / 1000);
 }
 
 
 ////////////////////////////////////////////////////////////
-sfInt64 sfTime_asMicroseconds(sfTime time)
+int64_t sfTime_asMicroseconds(sfTime time)
 {
     return time.microseconds;
 }
@@ -57,22 +57,22 @@ sfInt64 sfTime_asMicroseconds(sfTime time)
 sfTime sfSeconds(float amount)
 {
     sfTime time;
-    time.microseconds = static_cast<sfInt64>(amount * 1000000);
+    time.microseconds = static_cast<int64_t>(amount * 1000000);
     return time;
 }
 
 
 ////////////////////////////////////////////////////////////
-sfTime sfMilliseconds(sfInt32 amount)
+sfTime sfMilliseconds(int32_t amount)
 {
     sfTime time;
-    time.microseconds = static_cast<sfInt64>(amount) * 1000;
+    time.microseconds = static_cast<int64_t>(amount) * 1000;
     return time;
 }
 
 
 ////////////////////////////////////////////////////////////
-sfTime sfMicroseconds(sfInt64 amount)
+sfTime sfMicroseconds(int64_t amount)
 {
     sfTime time;
     time.microseconds = amount;

src/SFML/Window/Clipboard.cpp

@@ -46,7 +46,7 @@ const char* sfClipboard_getString()
 
 
 ////////////////////////////////////////////////////////////
-const sfUint32* sfClipboard_getUnicodeString()
+const uint32_t* sfClipboard_getUnicodeString()
 {
     ClipboardString = sf::Clipboard::getString();
     return ClipboardString.getData();
@@ -61,7 +61,7 @@ void sfClipboard_setString(const char* text)
 
 
 ////////////////////////////////////////////////////////////
-void sfClipboard_setUnicodeString(const sfUint32* text)
+void sfClipboard_setUnicodeString(const uint32_t* text)
 {
     sf::Clipboard::setString(text);
 }

src/SFML/Window/Context.cpp

@@ -46,16 +46,16 @@ void sfContext_destroy(sfContext* context)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfContext_isExtensionAvailable(const char* name)
+bool sfContext_isExtensionAvailable(const char* name)
 {
     return sf::Context::isExtensionAvailable(name);
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfContext_setActive(sfContext* context, sfBool active)
+bool sfContext_setActive(sfContext* context, bool active)
 {
-    CSFML_CALL_RETURN(context, setActive(active == sfTrue), false)
+    CSFML_CALL_RETURN(context, setActive(active), false)
 }
 
 
@@ -80,7 +80,7 @@ sfContextSettings sfContext_getSettings(const sfContext* context)
 
 
 ////////////////////////////////////////////////////////////
-sfUint64 sfContext_getActiveContextId()
+uint64_t sfContext_getActiveContextId()
 {
     return sf::Context::getActiveContextId();
 }

src/SFML/Window/ContextSettingsInternal.h

@@ -38,7 +38,7 @@ namespace priv
     ////////////////////////////////////////////////////////////
     inline sfContextSettings sfContextSettings_null()
     {
-        sfContextSettings settings = {0, 0, 0, 0, 0, 0, sfFalse};
+        sfContextSettings settings = {0, 0, 0, 0, 0, 0, false};
 
         return settings;
     }
@@ -54,7 +54,7 @@ namespace priv
         to.majorVersion      = from.majorVersion;
         to.minorVersion      = from.minorVersion;
         to.attributeFlags    = from.attributeFlags;
-        to.sRgbCapable       = from.sRgbCapable ? sfTrue : sfFalse;
+        to.sRgbCapable       = from.sRgbCapable;
     }
 
     ////////////////////////////////////////////////////////////
@@ -68,7 +68,7 @@ namespace priv
         to.majorVersion      = from.majorVersion;
         to.minorVersion      = from.minorVersion;
         to.attributeFlags    = from.attributeFlags;
-        to.sRgbCapable       = from.sRgbCapable == sfTrue;
+        to.sRgbCapable       = from.sRgbCapable;
     }
 }
 

src/SFML/Window/Cursor.cpp

@@ -31,7 +31,7 @@
 
 
 ////////////////////////////////////////////////////////////
-sfCursor* sfCursor_createFromPixels(const sfUint8* pixels, sfVector2u size, sfVector2u hotspot)
+sfCursor* sfCursor_createFromPixels(const uint8_t* pixels, sfVector2u size, sfVector2u hotspot)
 {
     sfCursor* cursor = new sfCursor;
 

src/SFML/Window/Joystick.cpp

@@ -31,9 +31,9 @@
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfJoystick_isConnected(unsigned int joystick)
+bool sfJoystick_isConnected(unsigned int joystick)
 {
-    return sf::Joystick::isConnected(joystick) ? sfTrue : sfFalse;
+    return sf::Joystick::isConnected(joystick);
 }
 
 
@@ -45,16 +45,16 @@ unsigned int sfJoystick_getButtonCount(unsigned int joystick)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfJoystick_hasAxis(unsigned int joystick, sfJoystickAxis axis)
+bool sfJoystick_hasAxis(unsigned int joystick, sfJoystickAxis axis)
 {
-    return sf::Joystick::hasAxis(joystick, static_cast<sf::Joystick::Axis>(axis)) ? sfTrue : sfFalse;
+    return sf::Joystick::hasAxis(joystick, static_cast<sf::Joystick::Axis>(axis));
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfJoystick_isButtonPressed(unsigned int joystick, unsigned int button)
+bool sfJoystick_isButtonPressed(unsigned int joystick, unsigned int button)
 {
-    return sf::Joystick::isButtonPressed(joystick, button) ? sfTrue : sfFalse;
+    return sf::Joystick::isButtonPressed(joystick, button);
 }
 
 

src/SFML/Window/Keyboard.cpp

@@ -34,14 +34,14 @@
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfKeyboard_isKeyPressed(sfKeyCode key)
+bool sfKeyboard_isKeyPressed(sfKeyCode key)
 {
     return sf::Keyboard::isKeyPressed(static_cast<sf::Keyboard::Key>(key));
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfKeyboard_isScancodePressed(sfScancode code)
+bool sfKeyboard_isScancodePressed(sfScancode code)
 {
     return sf::Keyboard::isKeyPressed(static_cast<sf::Keyboard::Scancode>(code));
 }
@@ -69,7 +69,7 @@ const char* sfKeyboard_getDescription(sfScancode code)
 
 
 ////////////////////////////////////////////////////////////
-void sfKeyboard_setVirtualKeyboardVisible(sfBool visible)
+void sfKeyboard_setVirtualKeyboardVisible(bool visible)
 {
-    sf::Keyboard::setVirtualKeyboardVisible(visible == sfTrue);
+    sf::Keyboard::setVirtualKeyboardVisible(visible);
 }

src/SFML/Window/Mouse.cpp

@@ -32,9 +32,9 @@
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfMouse_isButtonPressed(sfMouseButton button)
+bool sfMouse_isButtonPressed(sfMouseButton button)
 {
-    return sf::Mouse::isButtonPressed(static_cast<sf::Mouse::Button>(button)) ? sfTrue : sfFalse;
+    return sf::Mouse::isButtonPressed(static_cast<sf::Mouse::Button>(button));
 }
 
 

src/SFML/Window/Sensor.cpp

@@ -31,15 +31,15 @@
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfSensor_isAvailable(sfSensorType sensor)
+bool sfSensor_isAvailable(sfSensorType sensor)
 {
     return sf::Sensor::isAvailable(static_cast<sf::Sensor::Type>(sensor));
 }
 
 ////////////////////////////////////////////////////////////
-void sfSensor_setEnabled(sfSensorType sensor, sfBool enabled)
+void sfSensor_setEnabled(sfSensorType sensor, bool enabled)
 {
-    sf::Sensor::setEnabled(static_cast<sf::Sensor::Type>(sensor), enabled == sfTrue);
+    sf::Sensor::setEnabled(static_cast<sf::Sensor::Type>(sensor), enabled);
 }
 
 ////////////////////////////////////////////////////////////

src/SFML/Window/Touch.cpp

@@ -32,7 +32,7 @@
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfTouch_isDown(unsigned int finger)
+bool sfTouch_isDown(unsigned int finger)
 {
     return sf::Touch::isDown(finger);
 }
@@ -50,4 +50,3 @@ sfVector2i sfTouch_getPosition(unsigned int finger, const sfWindow* relativeTo)
     sfVector2i position = {sfmlPosition.x, sfmlPosition.y};
     return position;
 }
-

src/SFML/Window/VideoMode.cpp

@@ -70,8 +70,8 @@ const sfVideoMode* sfVideoMode_getFullscreenModes(size_t* count)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfVideoMode_isValid(sfVideoMode mode)
+bool sfVideoMode_isValid(sfVideoMode mode)
 {
     sf::VideoMode videoMode(mode.width, mode.height, mode.bitsPerPixel);
-    return videoMode.isValid() ? sfTrue : sfFalse;
+    return videoMode.isValid();
 }

src/SFML/Window/Vulkan.cpp

@@ -34,7 +34,7 @@
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfVulkan_isAvailable(sfBool requireGraphics)
+bool sfVulkan_isAvailable(bool requireGraphics)
 {
     return sf::Vulkan::isAvailable(requireGraphics);
 }

src/SFML/Window/Window.cpp

@@ -34,7 +34,7 @@
 
 
 ////////////////////////////////////////////////////////////
-sfWindow* sfWindow_create(sfVideoMode mode, const char* title, sfUint32 style, const sfContextSettings* settings)
+sfWindow* sfWindow_create(sfVideoMode mode, const char* title, uint32_t style, const sfContextSettings* settings)
 {
     // Convert video mode
     sf::VideoMode videoMode(mode.width, mode.height, mode.bitsPerPixel);
@@ -54,7 +54,7 @@ sfWindow* sfWindow_create(sfVideoMode mode, const char* title, sfUint32 style, c
 }
 
 ////////////////////////////////////////////////////////////
-sfWindow* sfWindow_createUnicode(sfVideoMode mode, const sfUint32* title, sfUint32 style, const sfContextSettings* settings)
+sfWindow* sfWindow_createUnicode(sfVideoMode mode, const uint32_t* title, uint32_t style, const sfContextSettings* settings)
 {
     // Convert video mode
     sf::VideoMode videoMode(mode.width, mode.height, mode.bitsPerPixel);
@@ -106,9 +106,9 @@ void sfWindow_close(sfWindow* window)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfWindow_isOpen(const sfWindow* window)
+bool sfWindow_isOpen(const sfWindow* window)
 {
-    CSFML_CALL_RETURN(window, isOpen(), sfFalse);
+    CSFML_CALL_RETURN(window, isOpen(), false);
 }
 
 
@@ -126,44 +126,44 @@ sfContextSettings sfWindow_getSettings(const sfWindow* window)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfWindow_pollEvent(sfWindow* window, sfEvent* event)
+bool sfWindow_pollEvent(sfWindow* window, sfEvent* event)
 {
-    CSFML_CHECK_RETURN(window, sfFalse);
+    CSFML_CHECK_RETURN(window, false);
-    CSFML_CHECK_RETURN(event, sfFalse);
+    CSFML_CHECK_RETURN(event, false);
 
     // Get the event
     sf::Event sfmlEvent;
-    sfBool ret = window->This.pollEvent(sfmlEvent);
+    bool ret = window->This.pollEvent(sfmlEvent);
 
     // No event, return
     if (!ret)
-        return sfFalse;
+        return false;
 
     // Convert the sf::Event event to a sfEvent
     convertEvent(sfmlEvent, event);
 
-    return sfTrue;
+    return true;
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfWindow_waitEvent(sfWindow* window, sfEvent* event)
+bool sfWindow_waitEvent(sfWindow* window, sfEvent* event)
 {
-    CSFML_CHECK_RETURN(window, sfFalse);
+    CSFML_CHECK_RETURN(window, false);
-    CSFML_CHECK_RETURN(event, sfFalse);
+    CSFML_CHECK_RETURN(event, false);
 
     // Get the event
     sf::Event sfmlEvent;
-    sfBool ret = window->This.waitEvent(sfmlEvent);
+    bool ret = window->This.waitEvent(sfmlEvent);
 
     // Error, return
     if (!ret)
-        return sfFalse;
+        return false;
 
     // Convert the sf::Event event to a sfEvent
     convertEvent(sfmlEvent, event);
 
-    return sfTrue;
+    return true;
 }
 
 
@@ -217,37 +217,37 @@ void sfWindow_setTitle(sfWindow* window, const char* title)
 
 
 ////////////////////////////////////////////////////////////
-void sfWindow_setUnicodeTitle(sfWindow* window, const sfUint32* title)
+void sfWindow_setUnicodeTitle(sfWindow* window, const uint32_t* title)
 {
     CSFML_CALL(window, setTitle(title));
 }
 
 
 ////////////////////////////////////////////////////////////
-void sfWindow_setIcon(sfWindow* window, unsigned int width, unsigned int height, const sfUint8* pixels)
+void sfWindow_setIcon(sfWindow* window, unsigned int width, unsigned int height, const uint8_t* pixels)
 {
     CSFML_CALL(window, setIcon(width, height, pixels));
 }
 
 
 ////////////////////////////////////////////////////////////
-void sfWindow_setVisible(sfWindow* window, sfBool visible)
+void sfWindow_setVisible(sfWindow* window, bool visible)
 {
-    CSFML_CALL(window, setVisible(visible == sfTrue));
+    CSFML_CALL(window, setVisible(visible));
 }
 
 
 ////////////////////////////////////////////////////////////
-void sfWindow_setMouseCursorVisible(sfWindow* window, sfBool visible)
+void sfWindow_setMouseCursorVisible(sfWindow* window, bool visible)
 {
-    CSFML_CALL(window, setMouseCursorVisible(visible == sfTrue));
+    CSFML_CALL(window, setMouseCursorVisible(visible));
 }
 
 
 ////////////////////////////////////////////////////////////
-void sfWindow_setMouseCursorGrabbed(sfWindow* window, sfBool grabbed)
+void sfWindow_setMouseCursorGrabbed(sfWindow* window, bool grabbed)
 {
-    CSFML_CALL(window, setMouseCursorGrabbed(grabbed == sfTrue));
+    CSFML_CALL(window, setMouseCursorGrabbed(grabbed));
 }
 
 
@@ -260,23 +260,23 @@ void sfWindow_setMouseCursor(sfWindow* window, const sfCursor* cursor)
 }
 
 ////////////////////////////////////////////////////////////
-void sfWindow_setVerticalSyncEnabled(sfWindow* window, sfBool enabled)
+void sfWindow_setVerticalSyncEnabled(sfWindow* window, bool enabled)
 {
-    CSFML_CALL(window, setVerticalSyncEnabled(enabled == sfTrue));
+    CSFML_CALL(window, setVerticalSyncEnabled(enabled));
 }
 
 
 ////////////////////////////////////////////////////////////
-void sfWindow_setKeyRepeatEnabled(sfWindow* window, sfBool enabled)
+void sfWindow_setKeyRepeatEnabled(sfWindow* window, bool enabled)
 {
-    CSFML_CALL(window, setKeyRepeatEnabled(enabled == sfTrue));
+    CSFML_CALL(window, setKeyRepeatEnabled(enabled));
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfWindow_setActive(sfWindow* window, sfBool active)
+bool sfWindow_setActive(sfWindow* window, bool active)
 {
-    CSFML_CALL_RETURN(window, setActive(active == sfTrue), sfFalse);
+    CSFML_CALL_RETURN(window, setActive(active), false);
 }
 
 
@@ -288,9 +288,9 @@ void sfWindow_requestFocus(sfWindow* window)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfWindow_hasFocus(const sfWindow* window)
+bool sfWindow_hasFocus(const sfWindow* window)
 {
-    CSFML_CALL_RETURN(window, hasFocus(), sfFalse);
+    CSFML_CALL_RETURN(window, hasFocus(), false);
 }
 
 

src/SFML/Window/WindowBase.cpp

@@ -33,7 +33,7 @@
 
 
 ////////////////////////////////////////////////////////////
-sfWindowBase* sfWindowBase_create(sfVideoMode mode, const char* title, sfUint32 style)
+sfWindowBase* sfWindowBase_create(sfVideoMode mode, const char* title, uint32_t style)
 {
     // Convert video mode
     sf::VideoMode videoMode(mode.width, mode.height, mode.bitsPerPixel);
@@ -47,7 +47,7 @@ sfWindowBase* sfWindowBase_create(sfVideoMode mode, const char* title, sfUint32
 
 
 ////////////////////////////////////////////////////////////
-sfWindowBase* sfWindowBase_createUnicode(sfVideoMode mode, const sfUint32* title, sfUint32 style)
+sfWindowBase* sfWindowBase_createUnicode(sfVideoMode mode, const uint32_t* title, uint32_t style)
 {
     // Convert video mode
     sf::VideoMode videoMode(mode.width, mode.height, mode.bitsPerPixel);
@@ -86,51 +86,51 @@ void sfWindowBase_close(sfWindowBase* windowBase)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfWindowBase_isOpen(const sfWindowBase* windowBase)
+bool sfWindowBase_isOpen(const sfWindowBase* windowBase)
 {
-    CSFML_CALL_RETURN(windowBase, isOpen(), sfFalse);
+    CSFML_CALL_RETURN(windowBase, isOpen(), false);
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfWindowBase_pollEvent(sfWindowBase* windowBase, sfEvent* event)
+bool sfWindowBase_pollEvent(sfWindowBase* windowBase, sfEvent* event)
 {
-    CSFML_CHECK_RETURN(windowBase, sfFalse);
+    CSFML_CHECK_RETURN(windowBase, false);
-    CSFML_CHECK_RETURN(event, sfFalse);
+    CSFML_CHECK_RETURN(event, false);
 
     // Get the event
     sf::Event sfmlEvent;
-    sfBool ret = windowBase->This.pollEvent(sfmlEvent);
+    bool ret = windowBase->This.pollEvent(sfmlEvent);
 
     // No event, return
     if (!ret)
-        return sfFalse;
+        return false;
 
     // Convert the sf::Event event to a sfEvent
     convertEvent(sfmlEvent, event);
 
-    return sfTrue;
+    return true;
 }
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfWindowBase_waitEvent(sfWindowBase* windowBase, sfEvent* event)
+bool sfWindowBase_waitEvent(sfWindowBase* windowBase, sfEvent* event)
 {
-    CSFML_CHECK_RETURN(windowBase, sfFalse);
+    CSFML_CHECK_RETURN(windowBase, false);
-    CSFML_CHECK_RETURN(event, sfFalse);
+    CSFML_CHECK_RETURN(event, false);
 
     // Get the event
     sf::Event sfmlEvent;
-    sfBool ret = windowBase->This.waitEvent(sfmlEvent);
+    bool ret = windowBase->This.waitEvent(sfmlEvent);
 
     // Error, return
     if (!ret)
-        return sfFalse;
+        return false;
 
     // Convert the sf::Event event to a sfEvent
     convertEvent(sfmlEvent, event);
 
-    return sfTrue;
+    return true;
 }
 
 
@@ -184,37 +184,37 @@ void sfWindowBase_setTitle(sfWindowBase* windowBase, const char* title)
 
 
 ////////////////////////////////////////////////////////////
-void sfWindowBase_setUnicodeTitle(sfWindowBase* windowBase, const sfUint32* title)
+void sfWindowBase_setUnicodeTitle(sfWindowBase* windowBase, const uint32_t* title)
 {
     CSFML_CALL(windowBase, setTitle(title));
 }
 
 
 ////////////////////////////////////////////////////////////
-void sfWindowBase_setIcon(sfWindowBase* windowBase, unsigned int width, unsigned int height, const sfUint8* pixels)
+void sfWindowBase_setIcon(sfWindowBase* windowBase, unsigned int width, unsigned int height, const uint8_t* pixels)
 {
     CSFML_CALL(windowBase, setIcon(width, height, pixels));
 }
 
 
 ////////////////////////////////////////////////////////////
-void sfWindowBase_setVisible(sfWindowBase* windowBase, sfBool visible)
+void sfWindowBase_setVisible(sfWindowBase* windowBase, bool visible)
 {
-    CSFML_CALL(windowBase, setVisible(visible == sfTrue));
+    CSFML_CALL(windowBase, setVisible(visible));
 }
 
 
 ////////////////////////////////////////////////////////////
-void sfWindowBase_setMouseCursorVisible(sfWindowBase* windowBase, sfBool visible)
+void sfWindowBase_setMouseCursorVisible(sfWindowBase* windowBase, bool visible)
 {
-    CSFML_CALL(windowBase, setMouseCursorVisible(visible == sfTrue));
+    CSFML_CALL(windowBase, setMouseCursorVisible(visible));
 }
 
 
 ////////////////////////////////////////////////////////////
-void sfWindowBase_setMouseCursorGrabbed(sfWindowBase* windowBase, sfBool grabbed)
+void sfWindowBase_setMouseCursorGrabbed(sfWindowBase* windowBase, bool grabbed)
 {
-    CSFML_CALL(windowBase, setMouseCursorGrabbed(grabbed == sfTrue));
+    CSFML_CALL(windowBase, setMouseCursorGrabbed(grabbed));
 }
 
 
@@ -228,9 +228,9 @@ void sfWindowBase_setMouseCursor(sfWindowBase* windowBase, const sfCursor* curso
 
 
 ////////////////////////////////////////////////////////////
-void sfWindowBase_setKeyRepeatEnabled(sfWindowBase* windowBase, sfBool enabled)
+void sfWindowBase_setKeyRepeatEnabled(sfWindowBase* windowBase, bool enabled)
 {
-    CSFML_CALL(windowBase, setKeyRepeatEnabled(enabled == sfTrue));
+    CSFML_CALL(windowBase, setKeyRepeatEnabled(enabled));
 }
 
 
@@ -249,9 +249,9 @@ void sfWindowBase_requestFocus(sfWindowBase* windowBase)
 
 
 ////////////////////////////////////////////////////////////
-sfBool sfWindowBase_hasFocus(const sfWindowBase* windowBase)
+bool sfWindowBase_hasFocus(const sfWindowBase* windowBase)
 {
-    CSFML_CALL_RETURN(windowBase, hasFocus(), sfFalse);
+    CSFML_CALL_RETURN(windowBase, hasFocus(), false);
 }
 
 
@@ -264,9 +264,9 @@ sfWindowHandle sfWindowBase_getSystemHandle(const sfWindowBase* windowBase)
 }
 
 ////////////////////////////////////////////////////////////
-sfBool sfWindowBase_createVulkanSurface(sfWindowBase* windowBase, const VkInstance* instance, VkSurfaceKHR* surface, const VkAllocationCallbacks* allocator)
+bool sfWindowBase_createVulkanSurface(sfWindowBase* windowBase, const VkInstance* instance, VkSurfaceKHR* surface, const VkAllocationCallbacks* allocator)
 {
-    CSFML_CHECK_RETURN(instance, sfFalse);
+    CSFML_CHECK_RETURN(instance, false);
-    CSFML_CHECK_RETURN(surface, sfFalse);
+    CSFML_CHECK_RETURN(surface, false);
-    CSFML_CALL_RETURN(windowBase, createVulkanSurface(*instance, *surface, allocator), sfFalse);
+    CSFML_CALL_RETURN(windowBase, createVulkanSurface(*instance, *surface, allocator), false);
 }