Adjust sf::NonCopyable to make use of = default and = delete thus also making it move-enabled.

Fixes for:
 - C++14 settings
 - Strongly typed enum

CMakeLists.txt

@@ -1,4 +1,8 @@
-cmake_minimum_required(VERSION 2.8.3)
+cmake_minimum_required(VERSION 3.1.0)
+
+# set the minimum required C++ standard to C++14
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 # define a macro that helps defining an option
 macro(sfml_set_option var default type docstring)
@@ -19,6 +23,23 @@ set(CMAKE_LEGACY_CYGWIN_WIN32 0)
 # Suppress Mac OS X RPATH warnings and adopt new related behaviors
 cmake_policy(SET CMP0042 NEW)
 
+# add some default value for some additional macOS variable
+# note that those variables are ignored on other systems
+if(NOT CMAKE_OSX_ARCHITECTURES)
+    set(CMAKE_OSX_ARCHITECTURES "x86_64" CACHE STRING "macOS architecture to build; 64-bit is expected" FORCE)
+endif()
+if(NOT CMAKE_OSX_DEPLOYMENT_TARGET)
+    set(CMAKE_OSX_DEPLOYMENT_TARGET "10.9" CACHE STRING "macOS deployement target; 10.9+ is expected" FORCE)
+endif()
+if(NOT CMAKE_OSX_SYSROOT)
+    # query the path to the default SDK, will fail on non-macOS, but it's okay.
+    execute_process(COMMAND xcodebuild -sdk macosx -version Path
+                    COMMAND head -n 1
+                    COMMAND tr -d '\n'
+                    OUTPUT_VARIABLE CMAKE_OSX_SYSROOT
+                    ERROR_QUIET)
+endif()
+
 # set Android specific options
 
 # define the minimum API level to be used
@@ -229,11 +250,15 @@ if(SFML_OS_MACOSX)
     endif()
 
     # only the default architecture (i.e. 64-bit) is supported
-    if(CMAKE_OSX_ARCHITECTURES AND NOT "${CMAKE_OSX_ARCHITECTURES}" STREQUAL "x86_64")
+    if(NOT CMAKE_OSX_ARCHITECTURES STREQUAL "x86_64")
         message(FATAL_ERROR "Only 64-bit architecture is supported")
-        return()
     endif()
-        
+
+    # Ensure macOS 10.9+ is used
+    if(CMAKE_OSX_DEPLOYMENT_TARGET VERSION_LESS "10.9")
+        message(FATAL_ERROR "macOS 10.9 or greater is required for the deployment target.")
+    endif()
+
     # configure Xcode templates
     set(XCODE_TEMPLATES_ARCH "\$(NATIVE_ARCH_ACTUAL)")
 endif()

cmake/Config.cmake

@@ -89,7 +89,7 @@ endif()
 # detect the compiler and its version
 # Note: on some platforms (OS X), CMAKE_COMPILER_IS_GNUCXX is true
 # even when CLANG is used, therefore the Clang test is done first
-if(CMAKE_CXX_COMPILER MATCHES ".*clang[+][+]" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+if(CMAKE_CXX_COMPILER MATCHES ".*clang[+][+]" OR CMAKE_CXX_COMPILER_ID MATCHES "^(Apple)?Clang")
    # CMAKE_CXX_COMPILER_ID is an internal CMake variable subject to change,
    # but there is no other way to detect CLang at the moment
    set(SFML_COMPILER_CLANG 1)
@@ -122,7 +122,7 @@ elseif(MSVC)
         set(SFML_MSVC_VERSION 14)
     endif()
 else()
-    message(FATAL_ERROR "Unsupported compiler")
+    message(FATAL_ERROR "Unsupported compiler ('${CMAKE_CXX_COMPILER_ID}' by '${CMAKE_CXX_COMPILER}')")
     return()
 endif()
 

examples/cocoa/CocoaAppDelegate.mm

@@ -161,10 +161,10 @@ struct SFMLmainWindow
 
     // Scaling
     /* /!\ we do this at 60fps so choose low scaling factor! /!\ */
-    if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up))
+    if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Up))
         self.mainWindow->sprite.scale(1.01f, 1.01f);
 
-    if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down))
+    if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Down))
         self.mainWindow->sprite.scale(0.99f, 0.99f);
 
     // Clear the window, display some stuff and display it into our view.

examples/ftp/Ftp.cpp

@@ -13,7 +13,7 @@
 ////////////////////////////////////////////////////////////
 std::ostream& operator <<(std::ostream& stream, const sf::Ftp::Response& response)
 {
-    return stream << response.getStatus() << response.getMessage();
+    return stream << static_cast<unsigned short>(response.getStatus()) << response.getMessage();
 }
 
 
@@ -103,8 +103,8 @@ int main()
                 sf::Ftp::ListingResponse response = server.getDirectoryListing();
                 std::cout << response << std::endl;
                 const std::vector<std::string>& names = response.getListing();
-                for (std::vector<std::string>::const_iterator it = names.begin(); it != names.end(); ++it)
-                    std::cout << *it << std::endl;
+                for (const auto& name : names)
+                    std::cout << name << std::endl;
                 break;
             }
 

examples/opengl/OpenGL.cpp

@@ -161,21 +161,21 @@ int main()
             while (window.pollEvent(event))
             {
                 // Close window: exit
-                if (event.type == sf::Event::Closed)
+                if (event.type == sf::Event::Type::Closed)
                 {
                     exit = true;
                     window.close();
                 }
 
                 // Escape key: exit
-                if ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Escape))
+                if ((event.type == sf::Event::Type::KeyPressed) && (event.key.code == sf::Keyboard::Key::Escape))
                 {
                     exit = true;
                     window.close();
                 }
 
                 // Return key: toggle mipmapping
-                if ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Return))
+                if ((event.type == sf::Event::Type::KeyPressed) && (event.key.code == sf::Keyboard::Key::Return))
                 {
                     if (mipmapEnabled)
                     {
@@ -194,14 +194,14 @@ int main()
                 }
 
                 // Space key: toggle sRGB conversion
-                if ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Space))
+                if ((event.type == sf::Event::Type::KeyPressed) && (event.key.code == sf::Keyboard::Key::Space))
                 {
                     sRgb = !sRgb;
                     window.close();
                 }
 
                 // Adjust the viewport when the window is resized
-                if (event.type == sf::Event::Resized)
+                if (event.type == sf::Event::Type::Resized)
                 {
                     // Make the window the active window for OpenGL calls
                     window.setActive(true);

examples/pong/Pong.cpp

@@ -17,7 +17,7 @@
 ////////////////////////////////////////////////////////////
 int main()
 {
-    std::srand(static_cast<unsigned int>(std::time(NULL)));
+    std::srand(static_cast<unsigned int>(std::time(nullptr)));
 
     // Define some constants
     const float pi = 3.14159f;
@@ -91,15 +91,15 @@ int main()
         while (window.pollEvent(event))
         {
             // Window closed or escape key pressed: exit
-            if ((event.type == sf::Event::Closed) ||
-               ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Escape)))
+            if ((event.type == sf::Event::Type::Closed) ||
+               ((event.type == sf::Event::Type::KeyPressed) && (event.key.code == sf::Keyboard::Key::Escape)))
             {
                 window.close();
                 break;
             }
 
             // Space key pressed: play
-            if ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Space))
+            if ((event.type == sf::Event::Type::KeyPressed) && (event.key.code == sf::Keyboard::Key::Space))
             {
                 if (!isPlaying)
                 {
@@ -128,12 +128,12 @@ int main()
             float deltaTime = clock.restart().asSeconds();
 
             // Move the player's paddle
-            if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up) &&
+            if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Up) &&
                (leftPaddle.getPosition().y - paddleSize.y / 2 > 5.f))
             {
                 leftPaddle.move(0.f, -paddleSpeed * deltaTime);
             }
-            if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down) &&
+            if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Down) &&
                (leftPaddle.getPosition().y + paddleSize.y / 2 < gameHeight - 5.f))
             {
                 leftPaddle.move(0.f, paddleSpeed * deltaTime);

examples/shader/Effect.hpp

@@ -66,7 +66,7 @@ protected:
 
     static const sf::Font& getFont()
     {
-        assert(s_font != NULL);
+        assert(s_font != nullptr);
         return *s_font;
     }
 

examples/shader/Shader.cpp

@@ -5,9 +5,10 @@
 #include "Effect.hpp"
 #include <vector>
 #include <cmath>
+#include <memory>
 
 
-const sf::Font* Effect::s_font = NULL;
+const sf::Font* Effect::s_font = nullptr;
 
 ////////////////////////////////////////////////////////////
 // "Pixelate" fragment shader
@@ -29,7 +30,7 @@ public:
         m_sprite.setTexture(m_texture);
 
         // Load the shader
-        if (!m_shader.loadFromFile("resources/pixelate.frag", sf::Shader::Fragment))
+        if (!m_shader.loadFromFile("resources/pixelate.frag", sf::Shader::Type::Fragment))
             return false;
         m_shader.setUniform("texture", sf::Shader::CurrentTexture);
 
@@ -134,7 +135,7 @@ public:
     bool onLoad()
     {
         // Create the points
-        m_points.setPrimitiveType(sf::Points);
+        m_points.setPrimitiveType(sf::PrimitiveType::Points);
         for (int i = 0; i < 40000; ++i)
         {
             float x = static_cast<float>(std::rand() % 800);
@@ -213,7 +214,7 @@ public:
         }
 
         // Load the shader
-        if (!m_shader.loadFromFile("resources/edge.frag", sf::Shader::Fragment))
+        if (!m_shader.loadFromFile("resources/edge.frag", sf::Shader::Type::Fragment))
             return false;
         m_shader.setUniform("texture", sf::Shader::CurrentTexture);
 
@@ -267,7 +268,7 @@ public:
 
     Geometry() :
         Effect("geometry shader billboards"),
-        m_pointCloud(sf::Points, 10000)
+        m_pointCloud(sf::PrimitiveType::Points, 10000)
     {
     }
 
@@ -357,12 +358,12 @@ int main()
     Effect::setFont(font);
 
     // Create the effects
-    std::vector<Effect*> effects;
-    effects.push_back(new Pixelate);
-    effects.push_back(new WaveBlur);
-    effects.push_back(new StormBlink);
-    effects.push_back(new Edge);
-    effects.push_back(new Geometry);
+    std::vector<std::unique_ptr<Effect>> effects;
+    effects.push_back(std::make_unique<Pixelate>());
+    effects.push_back(std::make_unique<WaveBlur>());
+    effects.push_back(std::make_unique<StormBlink>());
+    effects.push_back(std::make_unique<Edge>());
+    effects.push_back(std::make_unique<Geometry>());
     std::size_t current = 0;
 
     // Initialize them
@@ -396,20 +397,20 @@ int main()
         while (window.pollEvent(event))
         {
             // Close window: exit
-            if (event.type == sf::Event::Closed)
+            if (event.type == sf::Event::Type::Closed)
                 window.close();
 
-            if (event.type == sf::Event::KeyPressed)
+            if (event.type == sf::Event::Type::KeyPressed)
             {
                 switch (event.key.code)
                 {
                     // Escape key: exit
-                    case sf::Keyboard::Escape:
+                    case sf::Keyboard::Key::Escape:
                         window.close();
                         break;
 
                     // Left arrow key: previous shader
-                    case sf::Keyboard::Left:
+                    case sf::Keyboard::Key::Left:
                         if (current == 0)
                             current = effects.size() - 1;
                         else
@@ -418,7 +419,7 @@ int main()
                         break;
 
                     // Right arrow key: next shader
-                    case sf::Keyboard::Right:
+                    case sf::Keyboard::Key::Right:
                         if (current == effects.size() - 1)
                             current = 0;
                         else
@@ -452,9 +453,5 @@ int main()
         window.display();
     }
 
-    // delete the effects
-    for (std::size_t i = 0; i < effects.size(); ++i)
-        delete effects[i];
-
     return EXIT_SUCCESS;
 }

examples/sockets/TCP.cpp

@@ -17,26 +17,26 @@ void runTcpServer(unsigned short port)
     sf::TcpListener listener;
 
     // Listen to the given port for incoming connections
-    if (listener.listen(port) != sf::Socket::Done)
+    if (listener.listen(port) != sf::Socket::Status::Done)
         return;
     std::cout << "Server is listening to port " << port << ", waiting for connections... " << std::endl;
 
     // Wait for a connection
     sf::TcpSocket socket;
-    if (listener.accept(socket) != sf::Socket::Done)
+    if (listener.accept(socket) != sf::Socket::Status::Done)
         return;
     std::cout << "Client connected: " << socket.getRemoteAddress() << std::endl;
 
     // Send a message to the connected client
     const char out[] = "Hi, I'm the server";
-    if (socket.send(out, sizeof(out)) != sf::Socket::Done)
+    if (socket.send(out, sizeof(out)) != sf::Socket::Status::Done)
         return;
     std::cout << "Message sent to the client: \"" << out << "\"" << std::endl;
 
     // Receive a message back from the client
     char in[128];
     std::size_t received;
-    if (socket.receive(in, sizeof(in), received) != sf::Socket::Done)
+    if (socket.receive(in, sizeof(in), received) != sf::Socket::Status::Done)
         return;
     std::cout << "Answer received from the client: \"" << in << "\"" << std::endl;
 }
@@ -62,20 +62,20 @@ void runTcpClient(unsigned short port)
     sf::TcpSocket socket;
 
     // Connect to the server
-    if (socket.connect(server, port) != sf::Socket::Done)
+    if (socket.connect(server, port) != sf::Socket::Status::Done)
         return;
     std::cout << "Connected to server " << server << std::endl;
 
     // Receive a message from the server
     char in[128];
     std::size_t received;
-    if (socket.receive(in, sizeof(in), received) != sf::Socket::Done)
+    if (socket.receive(in, sizeof(in), received) != sf::Socket::Status::Done)
         return;
     std::cout << "Message received from the server: \"" << in << "\"" << std::endl;
 
     // Send an answer to the server
     const char out[] = "Hi, I'm a client";
-    if (socket.send(out, sizeof(out)) != sf::Socket::Done)
+    if (socket.send(out, sizeof(out)) != sf::Socket::Status::Done)
         return;
     std::cout << "Message sent to the server: \"" << out << "\"" << std::endl;
 }

examples/sockets/UDP.cpp

@@ -16,7 +16,7 @@ void runUdpServer(unsigned short port)
     sf::UdpSocket socket;
 
     // Listen to messages on the specified port
-    if (socket.bind(port) != sf::Socket::Done)
+    if (socket.bind(port) != sf::Socket::Status::Done)
         return;
     std::cout << "Server is listening to port " << port << ", waiting for a message... " << std::endl;
 
@@ -25,13 +25,13 @@ void runUdpServer(unsigned short port)
     std::size_t received;
     sf::IpAddress sender;
     unsigned short senderPort;
-    if (socket.receive(in, sizeof(in), received, sender, senderPort) != sf::Socket::Done)
+    if (socket.receive(in, sizeof(in), received, sender, senderPort) != sf::Socket::Status::Done)
         return;
     std::cout << "Message received from client " << sender << ": \"" << in << "\"" << std::endl;
 
     // Send an answer to the client
     const char out[] = "Hi, I'm the server";
-    if (socket.send(out, sizeof(out), sender, senderPort) != sf::Socket::Done)
+    if (socket.send(out, sizeof(out), sender, senderPort) != sf::Socket::Status::Done)
         return;
     std::cout << "Message sent to the client: \"" << out << "\"" << std::endl;
 }
@@ -57,7 +57,7 @@ void runUdpClient(unsigned short port)
 
     // Send a message to the server
     const char out[] = "Hi, I'm a client";
-    if (socket.send(out, sizeof(out), server, port) != sf::Socket::Done)
+    if (socket.send(out, sizeof(out), server, port) != sf::Socket::Status::Done)
         return;
     std::cout << "Message sent to the server: \"" << out << "\"" << std::endl;
 
@@ -66,7 +66,7 @@ void runUdpClient(unsigned short port)
     std::size_t received;
     sf::IpAddress sender;
     unsigned short senderPort;
-    if (socket.receive(in, sizeof(in), received, sender, senderPort) != sf::Socket::Done)
+    if (socket.receive(in, sizeof(in), received, sender, senderPort) != sf::Socket::Status::Done)
         return;
     std::cout << "Message received from " << sender << ": \"" << in << "\"" << std::endl;
 }

examples/sound/Sound.cpp

@@ -29,7 +29,7 @@ void playSound()
     sound.play();
 
     // Loop while the sound is playing
-    while (sound.getStatus() == sf::Sound::Playing)
+    while (sound.getStatus() == sf::Sound::Status::Playing)
     {
         // Leave some CPU time for other processes
         sf::sleep(sf::milliseconds(100));
@@ -63,7 +63,7 @@ void playMusic(const std::string& filename)
     music.play();
 
     // Loop while the music is playing
-    while (music.getStatus() == sf::Music::Playing)
+    while (music.getStatus() == sf::Music::Status::Playing)
     {
         // Leave some CPU time for other processes
         sf::sleep(sf::milliseconds(100));

examples/sound_capture/SoundCapture.cpp

@@ -72,7 +72,7 @@ int main()
         sound.play();
 
         // Wait until finished
-        while (sound.getStatus() == sf::Sound::Playing)
+        while (sound.getStatus() == sf::Sound::Status::Playing)
         {
             // Display the playing position
             std::cout << "\rPlaying... " << sound.getPlayingOffset().asSeconds() << " sec        ";

examples/voip/Client.cpp

@@ -52,7 +52,7 @@ private:
     ////////////////////////////////////////////////////////////
     virtual bool onStart()
     {
-        if (m_socket.connect(m_host, m_port) == sf::Socket::Done)
+        if (m_socket.connect(m_host, m_port) == sf::Socket::Status::Done)
         {
             std::cout << "Connected to server " << m_host << std::endl;
             return true;
@@ -75,7 +75,7 @@ private:
         packet.append(samples, sampleCount * sizeof(sf::Int16));
 
         // Send the audio packet to the server
-        return m_socket.send(packet) == sf::Socket::Done;
+        return m_socket.send(packet) == sf::Socket::Status::Done;
     }
 
     ////////////////////////////////////////////////////////////

examples/voip/Server.cpp

@@ -7,6 +7,7 @@
 #include <iomanip>
 #include <iostream>
 #include <iterator>
+#include <mutex>
 
 
 const sf::Uint8 audioData   = 1;
@@ -42,12 +43,12 @@ public:
         if (!m_hasFinished)
         {
             // Listen to the given port for incoming connections
-            if (m_listener.listen(port) != sf::Socket::Done)
+            if (m_listener.listen(port) != sf::Socket::Status::Done)
                 return;
             std::cout << "Server is listening to port " << port << ", waiting for connections... " << std::endl;
 
             // Wait for a connection
-            if (m_listener.accept(m_client) != sf::Socket::Done)
+            if (m_listener.accept(m_client) != sf::Socket::Status::Done)
                 return;
             std::cout << "Client connected: " << m_client.getRemoteAddress() << std::endl;
 
@@ -83,12 +84,12 @@ private:
         // Copy samples into a local buffer to avoid synchronization problems
         // (don't forget that we run in two separate threads)
         {
-            sf::Lock lock(m_mutex);
+            std::lock_guard<std::mutex> lock(m_mutex);
             m_tempBuffer.assign(m_samples.begin() + m_offset, m_samples.end());
         }
 
         // Fill audio data to pass to the stream
-        data.samples     = &m_tempBuffer[0];
+        data.samples     = m_tempBuffer.data();
         data.sampleCount = m_tempBuffer.size();
 
         // Update the playing offset
@@ -116,7 +117,7 @@ private:
         {
             // Get waiting audio data from the network
             sf::Packet packet;
-            if (m_client.receive(packet) != sf::Socket::Done)
+            if (m_client.receive(packet) != sf::Socket::Status::Done)
                 break;
 
             // Extract the message ID
@@ -132,7 +133,7 @@ private:
                 // Don't forget that the other thread can access the sample array at any time
                 // (so we protect any operation on it with the mutex)
                 {
-                    sf::Lock lock(m_mutex);
+                    std::lock_guard<std::mutex> lock(m_mutex);
                     std::copy(samples, samples + sampleCount, std::back_inserter(m_samples));
                 }
             }
@@ -156,7 +157,7 @@ private:
     ////////////////////////////////////////////////////////////
     sf::TcpListener        m_listener;
     sf::TcpSocket          m_client;
-    sf::Mutex              m_mutex;
+    std::mutex             m_mutex;
     std::vector<sf::Int16> m_samples;
     std::vector<sf::Int16> m_tempBuffer;
     std::size_t            m_offset;
@@ -176,7 +177,7 @@ void doServer(unsigned short port)
     audioStream.start(port);
 
     // Loop until the sound playback is finished
-    while (audioStream.getStatus() != sf::SoundStream::Stopped)
+    while (audioStream.getStatus() != sf::SoundStream::Status::Stopped)
     {
         // Leave some CPU time for other threads
         sf::sleep(sf::milliseconds(100));
@@ -192,7 +193,7 @@ void doServer(unsigned short port)
     audioStream.play();
 
     // Loop until the sound playback is finished
-    while (audioStream.getStatus() != sf::SoundStream::Stopped)
+    while (audioStream.getStatus() != sf::SoundStream::Status::Stopped)
     {
         // Leave some CPU time for other threads
         sf::sleep(sf::milliseconds(100));

examples/win32/Win32.cpp

@@ -49,7 +49,7 @@ LRESULT CALLBACK onEvent(HWND handle, UINT message, WPARAM wParam, LPARAM lParam
 ////////////////////////////////////////////////////////////
 int main()
 {
-    HINSTANCE instance = GetModuleHandle(NULL);
+    HINSTANCE instance = GetModuleHandle(nullptr);
 
     // Define a class for our main window
     WNDCLASS windowClass;
@@ -58,22 +58,22 @@ int main()
     windowClass.cbClsExtra    = 0;
     windowClass.cbWndExtra    = 0;
     windowClass.hInstance     = instance;
-    windowClass.hIcon         = NULL;
+    windowClass.hIcon         = nullptr;
     windowClass.hCursor       = 0;
     windowClass.hbrBackground = reinterpret_cast<HBRUSH>(COLOR_BACKGROUND);
-    windowClass.lpszMenuName  = NULL;
+    windowClass.lpszMenuName  = nullptr;
     windowClass.lpszClassName = TEXT("SFML App");
     RegisterClass(&windowClass);
 
     // Let's create the main window
-    HWND window = CreateWindow(TEXT("SFML App"), TEXT("SFML Win32"), WS_SYSMENU | WS_VISIBLE, 200, 200, 660, 520, NULL, NULL, instance, NULL);
+    HWND window = CreateWindow(TEXT("SFML App"), TEXT("SFML Win32"), WS_SYSMENU | WS_VISIBLE, 200, 200, 660, 520, nullptr, nullptr, instance, nullptr);
 
     // Add a button for exiting
-    button = CreateWindow(TEXT("BUTTON"), TEXT("Quit"), WS_CHILD | WS_VISIBLE, 560, 440, 80, 40, window, NULL, instance, NULL);
+    button = CreateWindow(TEXT("BUTTON"), TEXT("Quit"), WS_CHILD | WS_VISIBLE, 560, 440, 80, 40, window, nullptr, instance, nullptr);
 
     // Let's create two SFML views
-    HWND view1 = CreateWindow(TEXT("STATIC"), NULL, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS, 20,  20, 300, 400, window, NULL, instance, NULL);
-    HWND view2 = CreateWindow(TEXT("STATIC"), NULL, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS, 340, 20, 300, 400, window, NULL, instance, NULL);
+    HWND view1 = CreateWindow(TEXT("STATIC"), nullptr, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS, 20,  20, 300, 400, window, nullptr, instance, nullptr);
+    HWND view2 = CreateWindow(TEXT("STATIC"), nullptr, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS, 340, 20, 300, 400, window, nullptr, instance, nullptr);
     sf::RenderWindow SFMLView1(view1);
     sf::RenderWindow SFMLView2(view2);
 
@@ -94,7 +94,7 @@ int main()
     message.message = static_cast<UINT>(~WM_QUIT);
     while (message.message != WM_QUIT)
     {
-        if (PeekMessage(&message, NULL, 0, 0, PM_REMOVE))
+        if (PeekMessage(&message, nullptr, 0, 0, PM_REMOVE))
         {
             // If a message was waiting in the message queue, process it
             TranslateMessage(&message);

examples/window/Window.cpp

@@ -112,15 +112,15 @@ int main()
         while (window.pollEvent(event))
         {
             // Close window: exit
-            if (event.type == sf::Event::Closed)
+            if (event.type == sf::Event::Type::Closed)
                 window.close();
 
             // Escape key: exit
-            if ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Escape))
+            if ((event.type == sf::Event::Type::KeyPressed) && (event.key.code == sf::Keyboard::Key::Escape))
                 window.close();
 
             // Resize event: adjust the viewport
-            if (event.type == sf::Event::Resized)
+            if (event.type == sf::Event::Type::Resized)
                 glViewport(0, 0, event.size.width, event.size.height);
         }
 

include/SFML/Audio/InputSoundFile.hpp

@@ -33,6 +33,7 @@
 #include <SFML/System/Time.hpp>
 #include <string>
 #include <algorithm>
+#include <memory>
 
 
 namespace sf
@@ -217,13 +218,13 @@ private:
     ////////////////////////////////////////////////////////////
     // Member data
     ////////////////////////////////////////////////////////////
-    SoundFileReader* m_reader;       ///< Reader that handles I/O on the file's format
-    InputStream*     m_stream;       ///< Input stream used to access the file's data
-    bool             m_streamOwned;  ///< Is the stream internal or external?
-    Uint64           m_sampleOffset; ///< Sample Read Position
-    Uint64           m_sampleCount;  ///< Total number of samples in the file
-    unsigned int     m_channelCount; ///< Number of channels of the sound
-    unsigned int     m_sampleRate;   ///< Number of samples per second
+    std::unique_ptr<SoundFileReader> m_reader;       ///< Reader that handles I/O on the file's format
+    std::unique_ptr<InputStream>     m_ownedStream;  ///< The stream we own if any
+    InputStream*                     m_stream;       ///< Input stream used to access the file's data
+    Uint64                           m_sampleOffset; ///< Sample Read Position
+    Uint64                           m_sampleCount;  ///< Total number of samples in the file
+    unsigned int                     m_channelCount; ///< Number of channels of the sound
+    unsigned int                     m_sampleRate;   ///< Number of samples per second
 };
 
 } // namespace sf

include/SFML/Audio/Music.hpp

@@ -31,10 +31,10 @@
 #include <SFML/Audio/Export.hpp>
 #include <SFML/Audio/SoundStream.hpp>
 #include <SFML/Audio/InputSoundFile.hpp>
-#include <SFML/System/Mutex.hpp>
 #include <SFML/System/Time.hpp>
 #include <string>
 #include <vector>
+#include <mutex>
 
 
 namespace sf
@@ -59,7 +59,7 @@ public:
     /// \brief Destructor
     ///
     ////////////////////////////////////////////////////////////
-    ~Music();
+    ~Music() override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Open a music from an audio file
@@ -147,7 +147,7 @@ protected:
     /// \return True to continue playback, false to stop
     ///
     ////////////////////////////////////////////////////////////
-    virtual bool onGetData(Chunk& data);
+    bool onGetData(Chunk& data) override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Change the current playing position in the stream source
@@ -155,7 +155,7 @@ protected:
     /// \param timeOffset New playing position, from the beginning of the music
     ///
     ////////////////////////////////////////////////////////////
-    virtual void onSeek(Time timeOffset);
+    void onSeek(Time timeOffset) override;
 
 private:
 
@@ -170,7 +170,7 @@ private:
     ////////////////////////////////////////////////////////////
     InputSoundFile     m_file;    ///< The streamed music file
     std::vector<Int16> m_samples; ///< Temporary buffer of samples
-    Mutex              m_mutex;   ///< Mutex protecting the data
+    std::mutex         m_mutex;   ///< Mutex protecting the data
 };
 
 } // namespace sf

include/SFML/Audio/OutputSoundFile.hpp

@@ -31,6 +31,7 @@
 #include <SFML/Audio/Export.hpp>
 #include <SFML/System/NonCopyable.hpp>
 #include <string>
+#include <memory>
 
 
 namespace sf
@@ -93,7 +94,7 @@ private:
     ////////////////////////////////////////////////////////////
     // Member data
     ////////////////////////////////////////////////////////////
-    SoundFileWriter* m_writer; ///< Writer that handles I/O on the file's format
+    std::unique_ptr<SoundFileWriter> m_writer; ///< Writer that handles I/O on the file's format
 };
 
 } // namespace sf

include/SFML/Audio/Sound.hpp

@@ -72,7 +72,7 @@ public:
     /// \brief Destructor
     ///
     ////////////////////////////////////////////////////////////
-    ~Sound();
+    ~Sound() override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Start or resume playing the sound
@@ -158,7 +158,7 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Get the audio buffer attached to the sound
     ///
-    /// \return Sound buffer attached to the sound (can be NULL)
+    /// \return Sound buffer attached to the sound (can be nullptr)
     ///
     ////////////////////////////////////////////////////////////
     const SoundBuffer* getBuffer() const;

include/SFML/Audio/SoundBufferRecorder.hpp

@@ -49,7 +49,7 @@ public:
     /// \brief destructor
     ///
     ////////////////////////////////////////////////////////////
-    ~SoundBufferRecorder();
+    ~SoundBufferRecorder() override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Get the sound buffer containing the captured audio data
@@ -72,7 +72,7 @@ protected:
     /// \return True to start the capture, or false to abort it
     ///
     ////////////////////////////////////////////////////////////
-    virtual bool onStart();
+    bool onStart() override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Process a new chunk of recorded samples
@@ -83,13 +83,13 @@ protected:
     /// \return True to continue the capture, or false to stop it
     ///
     ////////////////////////////////////////////////////////////
-    virtual bool onProcessSamples(const Int16* samples, std::size_t sampleCount);
+    bool onProcessSamples(const Int16* samples, std::size_t sampleCount) override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Stop capturing audio data
     ///
     ////////////////////////////////////////////////////////////
-    virtual void onStop();
+    void onStop() override;
 
 private:
 

include/SFML/Audio/SoundFileFactory.hpp

@@ -31,6 +31,7 @@
 #include <SFML/Audio/Export.hpp>
 #include <string>
 #include <vector>
+#include <memory>
 
 
 namespace sf
@@ -95,7 +96,7 @@ public:
     /// \see createReaderFromMemory, createReaderFromStream
     ///
     ////////////////////////////////////////////////////////////
-    static SoundFileReader* createReaderFromFilename(const std::string& filename);
+    static std::unique_ptr<SoundFileReader> createReaderFromFilename(const std::string& filename);
 
     ////////////////////////////////////////////////////////////
     /// \brief Instantiate the right codec for the given file in memory
@@ -110,7 +111,7 @@ public:
     /// \see createReaderFromFilename, createReaderFromStream
     ///
     ////////////////////////////////////////////////////////////
-    static SoundFileReader* createReaderFromMemory(const void* data, std::size_t sizeInBytes);
+    static std::unique_ptr<SoundFileReader> createReaderFromMemory(const void* data, std::size_t sizeInBytes);
 
     ////////////////////////////////////////////////////////////
     /// \brief Instantiate the right codec for the given file in stream
@@ -124,7 +125,7 @@ public:
     /// \see createReaderFromFilename, createReaderFromMemory
     ///
     ////////////////////////////////////////////////////////////
-    static SoundFileReader* createReaderFromStream(InputStream& stream);
+    static std::unique_ptr<SoundFileReader> createReaderFromStream(InputStream& stream);
 
     ////////////////////////////////////////////////////////////
     /// \brief Instantiate the right writer for the given file on disk
@@ -136,7 +137,7 @@ public:
     /// \return A new sound file writer that can write given file, or null if no writer can handle it
     ///
     ////////////////////////////////////////////////////////////
-    static SoundFileWriter* createWriterFromFilename(const std::string& filename);
+    static std::unique_ptr<SoundFileWriter> createWriterFromFilename(const std::string& filename);
 
 private:
 
@@ -146,14 +147,14 @@ private:
     struct ReaderFactory
     {
         bool (*check)(InputStream&);
-        SoundFileReader* (*create)();
+        std::unique_ptr<SoundFileReader> (*create)();
     };
     typedef std::vector<ReaderFactory> ReaderFactoryArray;
 
     struct WriterFactory
     {
         bool (*check)(const std::string&);
-        SoundFileWriter* (*create)();
+        std::unique_ptr<SoundFileWriter> (*create)();
     };
     typedef std::vector<WriterFactory> WriterFactoryArray;
 

include/SFML/Audio/SoundFileFactory.inl

@@ -31,8 +31,8 @@ namespace sf
 {
 namespace priv
 {
-    template <typename T> SoundFileReader* createReader() {return new T;}
-    template <typename T> SoundFileWriter* createWriter() {return new T;}
+    template <typename T> std::unique_ptr<SoundFileReader> createReader() {return std::make_unique<T>();}
+    template <typename T> std::unique_ptr<SoundFileWriter> createWriter() {return std::make_unique<T>();}
 }
 
 ////////////////////////////////////////////////////////////
@@ -57,7 +57,7 @@ template <typename T>
 void SoundFileFactory::unregisterReader()
 {
     // Remove the instance(s) of the reader from the array of factories
-    for (ReaderFactoryArray::iterator it = s_readers.begin(); it != s_readers.end(); )
+    for (auto it = s_readers.begin(); it != s_readers.end(); )
     {
         if (it->create == &priv::createReader<T>)
             it = s_readers.erase(it);
@@ -88,7 +88,7 @@ template <typename T>
 void SoundFileFactory::unregisterWriter()
 {
     // Remove the instance(s) of the writer from the array of factories
-    for (WriterFactoryArray::iterator it = s_writers.begin(); it != s_writers.end(); )
+    for (auto it = s_writers.begin(); it != s_writers.end(); )
     {
         if (it->create == &priv::createWriter<T>)
             it = s_writers.erase(it);

include/SFML/Audio/SoundRecorder.hpp

@@ -30,10 +30,10 @@
 ////////////////////////////////////////////////////////////
 #include <SFML/Audio/Export.hpp>
 #include <SFML/Audio/AlResource.hpp>
-#include <SFML/System/Thread.hpp>
 #include <SFML/System/Time.hpp>
 #include <vector>
 #include <string>
+#include <thread>
 
 
 namespace sf
@@ -285,7 +285,7 @@ private:
     ////////////////////////////////////////////////////////////
     // Member data
     ////////////////////////////////////////////////////////////
-    Thread             m_thread;             ///< Thread running the background recording task
+    std::thread        m_thread;             ///< Thread running the background recording task
     std::vector<Int16> m_samples;            ///< Buffer to store captured samples
     unsigned int       m_sampleRate;         ///< Sample rate
     Time               m_processingInterval; ///< Time period between calls to onProcessSamples

include/SFML/Audio/SoundSource.hpp

@@ -47,7 +47,7 @@ public:
     /// \brief Enumeration of the sound source states
     ///
     ////////////////////////////////////////////////////////////
-    enum Status
+    enum class Status : unsigned char
     {
         Stopped, ///< Sound is not playing
         Paused,  ///< Sound is paused

include/SFML/Audio/SoundStream.hpp

@@ -30,10 +30,10 @@
 ////////////////////////////////////////////////////////////
 #include <SFML/Audio/Export.hpp>
 #include <SFML/Audio/SoundSource.hpp>
-#include <SFML/System/Thread.hpp>
 #include <SFML/System/Time.hpp>
-#include <SFML/System/Mutex.hpp>
 #include <cstdlib>
+#include <mutex>
+#include <thread>
 
 
 namespace sf
@@ -60,7 +60,7 @@ public:
     /// \brief Destructor
     ///
     ////////////////////////////////////////////////////////////
-    virtual ~SoundStream();
+    ~SoundStream() override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Start or resume playing the audio stream
@@ -289,17 +289,17 @@ private:
     ////////////////////////////////////////////////////////////
     // Member data
     ////////////////////////////////////////////////////////////
-    Thread        m_thread;                  ///< Thread running the background tasks
-    mutable Mutex m_threadMutex;             ///< Thread mutex
-    Status        m_threadStartState;        ///< State the thread starts in (Playing, Paused, Stopped)
-    bool          m_isStreaming;             ///< Streaming state (true = playing, false = stopped)
-    unsigned int  m_buffers[BufferCount];    ///< Sound buffers used to store temporary audio data
-    unsigned int  m_channelCount;            ///< Number of channels (1 = mono, 2 = stereo, ...)
-    unsigned int  m_sampleRate;              ///< Frequency (samples / second)
-    Uint32        m_format;                  ///< Format of the internal sound buffers
-    bool          m_loop;                    ///< Loop flag (true to loop, false to play once)
-    Uint64        m_samplesProcessed;        ///< Number of buffers processed since beginning of the stream
-    bool          m_endBuffers[BufferCount]; ///< Each buffer is marked as "end buffer" or not, for proper duration calculation
+    std::thread        m_thread;                  ///< Thread running the background tasks
+    mutable std::mutex m_threadMutex;             ///< Thread mutex
+    Status             m_threadStartState;        ///< State the thread starts in (Playing, Paused, Stopped)
+    bool               m_isStreaming;             ///< Streaming state (true = playing, false = stopped)
+    unsigned int       m_buffers[BufferCount];    ///< Sound buffers used to store temporary audio data
+    unsigned int       m_channelCount;            ///< Number of channels (1 = mono, 2 = stereo, ...)
+    unsigned int       m_sampleRate;              ///< Frequency (samples / second)
+    Uint32             m_format;                  ///< Format of the internal sound buffers
+    bool               m_loop;                    ///< Loop flag (true to loop, false to play once)
+    Uint64             m_samplesProcessed;        ///< Number of buffers processed since beginning of the stream
+    bool               m_endBuffers[BufferCount]; ///< Each buffer is marked as "end buffer" or not, for proper duration calculation
 };
 
 } // namespace sf

include/SFML/Graphics/BlendMode.hpp

@@ -46,7 +46,7 @@ struct SFML_GRAPHICS_API BlendMode
     /// The factors are mapped directly to their OpenGL equivalents,
     /// specified by glBlendFunc() or glBlendFuncSeparate().
     ////////////////////////////////////////////////////////
-    enum Factor
+    enum class Factor : unsigned char
     {
         Zero,             ///< (0, 0, 0, 0)
         One,              ///< (1, 1, 1, 1)
@@ -66,7 +66,7 @@ struct SFML_GRAPHICS_API BlendMode
     /// The equations are mapped directly to their OpenGL equivalents,
     /// specified by glBlendEquation() or glBlendEquationSeparate().
     ////////////////////////////////////////////////////////
-    enum Equation
+    enum class Equation : unsigned char
     {
         Add,            ///< Pixel = Src * SrcFactor + Dst * DstFactor
         Subtract,       ///< Pixel = Src * SrcFactor - Dst * DstFactor
@@ -92,7 +92,7 @@ struct SFML_GRAPHICS_API BlendMode
     /// \param blendEquation     Specifies how to combine the source and destination colors and alpha.
     ///
     ////////////////////////////////////////////////////////////
-    BlendMode(Factor sourceFactor, Factor destinationFactor, Equation blendEquation = Add);
+    BlendMode(Factor sourceFactor, Factor destinationFactor, Equation blendEquation = Equation::Add);
 
     ////////////////////////////////////////////////////////////
     /// \brief Construct the blend mode given the factors and equation.

include/SFML/Graphics/CircleShape.hpp

@@ -89,7 +89,7 @@ public:
     /// \see setPointCount
     ///
     ////////////////////////////////////////////////////////////
-    virtual std::size_t getPointCount() const;
+    std::size_t getPointCount() const override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Get a point of the circle
@@ -104,7 +104,7 @@ public:
     /// \return index-th point of the shape
     ///
     ////////////////////////////////////////////////////////////
-    virtual Vector2f getPoint(std::size_t index) const;
+    Vector2f getPoint(std::size_t index) const override;
 
 private:
 

include/SFML/Graphics/ConvexShape.hpp

@@ -71,7 +71,7 @@ public:
     /// \see setPointCount
     ///
     ////////////////////////////////////////////////////////////
-    virtual std::size_t getPointCount() const;
+    std::size_t getPointCount() const override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Set the position of a point
@@ -105,7 +105,7 @@ public:
     /// \see setPoint
     ///
     ////////////////////////////////////////////////////////////
-    virtual Vector2f getPoint(std::size_t index) const;
+    Vector2f getPoint(std::size_t index) const override;
 
 private:
 

include/SFML/Graphics/Font.hpp

@@ -37,6 +37,7 @@
 #include <map>
 #include <string>
 #include <vector>
+#include <memory>
 
 
 namespace sf
@@ -348,14 +349,14 @@ private:
     ////////////////////////////////////////////////////////////
     void*                      m_library;     ///< Pointer to the internal library interface (it is typeless to avoid exposing implementation details)
     void*                      m_face;        ///< Pointer to the internal font face (it is typeless to avoid exposing implementation details)
-    void*                      m_streamRec;   ///< Pointer to the stream rec instance (it is typeless to avoid exposing implementation details)
+    std::shared_ptr<void>      m_streamRec;   ///< Pointer to the stream rec instance (it is typeless to avoid exposing implementation details)
     void*                      m_stroker;     ///< Pointer to the stroker (it is typeless to avoid exposing implementation details)
-    int*                       m_refCount;    ///< Reference counter used by implicit sharing
+    std::shared_ptr<int>       m_refCount;    ///< Reference counter used by implicit sharing
     Info                       m_info;        ///< Information about the font
     mutable PageTable          m_pages;       ///< Table containing the glyphs pages by character size
     mutable std::vector<Uint8> m_pixelBuffer; ///< Pixel buffer holding a glyph's pixels before being written to the texture
     #ifdef SFML_SYSTEM_ANDROID
-    void*                      m_stream; ///< Asset file streamer (if loaded from file)
+    std::shared_ptr<void>      m_stream;      ///< Asset file streamer (if loaded from file)
     #endif
 };
 

include/SFML/Graphics/Image.hpp

@@ -33,7 +33,7 @@
 #include <SFML/Graphics/Rect.hpp>
 #include <string>
 #include <vector>
-
+#include <memory>
 
 namespace sf
 {
@@ -263,10 +263,10 @@ private:
     ////////////////////////////////////////////////////////////
     // Member data
     ////////////////////////////////////////////////////////////
-    Vector2u           m_size;   ///< Image size
-    std::vector<Uint8> m_pixels; ///< Pixels of the image
+    Vector2u              m_size;   ///< Image size
+    std::vector<Uint8>    m_pixels; ///< Pixels of the image
     #ifdef SFML_SYSTEM_ANDROID
-    void*              m_stream; ///< Asset file streamer (if loaded from file)
+    std::shared_ptr<void> m_stream; ///< Asset file streamer (if loaded from file)
     #endif
 };
 

include/SFML/Graphics/PrimitiveType.hpp

@@ -36,20 +36,14 @@ namespace sf
 /// and view.
 ///
 ////////////////////////////////////////////////////////////
-enum PrimitiveType
+enum class PrimitiveType : unsigned char
 {
     Points,        ///< List of individual points
     Lines,         ///< List of individual lines
     LineStrip,     ///< List of connected lines, a point uses the previous point to form a line
     Triangles,     ///< List of individual triangles
     TriangleStrip, ///< List of connected triangles, a point uses the two previous points to form a triangle
-    TriangleFan,   ///< List of connected triangles, a point uses the common center and the previous point to form a triangle
-    Quads,         ///< List of individual quads (deprecated, don't work with OpenGL ES)
-
-    // Deprecated names
-    LinesStrip     = LineStrip,     ///< \deprecated Use LineStrip instead
-    TrianglesStrip = TriangleStrip, ///< \deprecated Use TriangleStrip instead
-    TrianglesFan   = TriangleFan    ///< \deprecated Use TriangleFan instead
+    TriangleFan    ///< List of connected triangles, a point uses the common center and the previous point to form a triangle
 };
 
 } // namespace sf

include/SFML/Graphics/RectangleShape.hpp

@@ -77,7 +77,7 @@ public:
     ///         shapes, this number is always 4.
     ///
     ////////////////////////////////////////////////////////////
-    virtual std::size_t getPointCount() const;
+    std::size_t getPointCount() const override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Get a point of the rectangle
@@ -92,7 +92,7 @@ public:
     /// \return index-th point of the shape
     ///
     ////////////////////////////////////////////////////////////
-    virtual Vector2f getPoint(std::size_t index) const;
+    Vector2f getPoint(std::size_t index) const override;
 
 private:
 

include/SFML/Graphics/RenderTexture.hpp

@@ -31,6 +31,7 @@
 #include <SFML/Graphics/Export.hpp>
 #include <SFML/Graphics/Texture.hpp>
 #include <SFML/Graphics/RenderTarget.hpp>
+#include <memory>
 
 
 namespace sf
@@ -63,7 +64,7 @@ public:
     /// \brief Destructor
     ///
     ////////////////////////////////////////////////////////////
-    virtual ~RenderTexture();
+    ~RenderTexture() override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Create the render-texture
@@ -162,7 +163,7 @@ public:
     /// \return True if operation was successful, false otherwise
     ///
     ////////////////////////////////////////////////////////////
-    bool setActive(bool active = true);
+    bool setActive(bool active = true) override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Update the contents of the target texture
@@ -184,7 +185,7 @@ public:
     /// \return Size in pixels
     ///
     ////////////////////////////////////////////////////////////
-    virtual Vector2u getSize() const;
+    Vector2u getSize() const override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Get a read-only reference to the target texture
@@ -207,8 +208,8 @@ private:
     ////////////////////////////////////////////////////////////
     // Member data
     ////////////////////////////////////////////////////////////
-    priv::RenderTextureImpl* m_impl;    ///< Platform/hardware specific implementation
-    Texture                  m_texture; ///< Target texture to draw on
+    std::unique_ptr<priv::RenderTextureImpl> m_impl;    ///< Platform/hardware specific implementation
+    Texture                                  m_texture; ///< Target texture to draw on
 };
 
 } // namespace sf

include/SFML/Graphics/RenderWindow.hpp

@@ -99,7 +99,7 @@ public:
     /// Closes the window and frees all the resources attached to it.
     ///
     ////////////////////////////////////////////////////////////
-    virtual ~RenderWindow();
+    ~RenderWindow() override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Get the size of the rendering region of the window
@@ -110,7 +110,7 @@ public:
     /// \return Size in pixels
     ///
     ////////////////////////////////////////////////////////////
-    virtual Vector2u getSize() const;
+    Vector2u getSize() const override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Activate or deactivate the window as the current target
@@ -128,7 +128,7 @@ public:
     /// \return True if operation was successful, false otherwise
     ///
     ////////////////////////////////////////////////////////////
-    bool setActive(bool active = true);
+    bool setActive(bool active = true) override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Copy the current contents of the window to an image
@@ -167,7 +167,7 @@ protected:
     /// the window is created.
     ///
     ////////////////////////////////////////////////////////////
-    virtual void onCreate();
+    void onCreate() override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Function called after the window has been resized
@@ -176,7 +176,7 @@ protected:
     /// perform custom actions when the size of the window changes.
     ///
     ////////////////////////////////////////////////////////////
-    virtual void onResize();
+    void onResize() override;
 };
 
 } // namespace sf

include/SFML/Graphics/Shader.hpp

@@ -57,7 +57,7 @@ public:
     /// \brief Types of shaders
     ///
     ////////////////////////////////////////////////////////////
-    enum Type
+    enum class Type : unsigned char
     {
         Vertex,   ///< %Vertex shader
         Geometry, ///< Geometry shader
@@ -651,7 +651,7 @@ public:
     /// // draw OpenGL stuff that use s1...
     /// sf::Shader::bind(&s2);
     /// // draw OpenGL stuff that use s2...
-    /// sf::Shader::bind(NULL);
+    /// sf::Shader::bind(nullptr);
     /// // draw OpenGL stuff that use no shader...
     /// \endcode
     ///
@@ -696,7 +696,7 @@ private:
     ////////////////////////////////////////////////////////////
     /// \brief Compile the shader(s) and create the program
     ///
-    /// If one of the arguments is NULL, the corresponding shader
+    /// If one of the arguments is nullptr, the corresponding shader
     /// is not created.
     ///
     /// \param vertexShaderCode   Source code of the vertex shader
@@ -867,7 +867,7 @@ private:
 /// \code
 /// sf::Shader::bind(&shader);
 /// ... render OpenGL geometry ...
-/// sf::Shader::bind(NULL);
+/// sf::Shader::bind(nullptr);
 /// \endcode
 ///
 /// \see sf::Glsl

include/SFML/Graphics/Shape.hpp

@@ -49,7 +49,7 @@ public:
     /// \brief Virtual destructor
     ///
     ////////////////////////////////////////////////////////////
-    virtual ~Shape();
+    ~Shape() override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Change the source texture of the shape
@@ -60,7 +60,7 @@ public:
     /// a pointer to the one that you passed to this function.
     /// If the source texture is destroyed and the shape tries to
     /// use it, the behavior is undefined.
-    /// \a texture can be NULL to disable texturing.
+    /// \a texture can be nullptr to disable texturing.
     /// If \a resetRect is true, the TextureRect property of
     /// the shape is automatically adjusted to the size of the new
     /// texture. If it is false, the texture rect is left unchanged.
@@ -134,7 +134,7 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Get the source texture of the shape
     ///
-    /// If the shape has no source texture, a NULL pointer is returned.
+    /// If the shape has no source texture, a nullptr pointer is returned.
     /// The returned pointer is const, which means that you can't
     /// modify the texture when you retrieve it with this function.
     ///
@@ -274,7 +274,7 @@ private:
     /// \param states Current render states
     ///
     ////////////////////////////////////////////////////////////
-    virtual void draw(RenderTarget& target, RenderStates states) const;
+    void draw(RenderTarget& target, RenderStates states) const override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Update the fill vertices' color

include/SFML/Graphics/Sprite.hpp

@@ -130,7 +130,7 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Get the source texture of the sprite
     ///
-    /// If the sprite has no source texture, a NULL pointer is returned.
+    /// If the sprite has no source texture, a nullptr pointer is returned.
     /// The returned pointer is const, which means that you can't
     /// modify the texture when you retrieve it with this function.
     ///
@@ -198,7 +198,7 @@ private:
     /// \param states Current render states
     ///
     ////////////////////////////////////////////////////////////
-    virtual void draw(RenderTarget& target, RenderStates states) const;
+    void draw(RenderTarget& target, RenderStates states) const override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Update the vertices' positions

include/SFML/Graphics/Text.hpp

@@ -239,7 +239,7 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Get the text's font
     ///
-    /// If the text has no font attached, a NULL pointer is returned.
+    /// If the text has no font attached, a nullptr pointer is returned.
     /// The returned pointer is const, which means that you
     /// cannot modify the font when you get it from this function.
     ///
@@ -368,7 +368,7 @@ private:
     /// \param states Current render states
     ///
     ////////////////////////////////////////////////////////////
-    virtual void draw(RenderTarget& target, RenderStates states) const;
+    void draw(RenderTarget& target, RenderStates states) const override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Make sure the text's geometry is updated

include/SFML/Graphics/Texture.hpp

@@ -52,7 +52,7 @@ public:
     /// \brief Types of texture coordinates that can be used for rendering
     ///
     ////////////////////////////////////////////////////////////
-    enum CoordinateType
+    enum class CoordinateType : unsigned char
     {
         Normalized, ///< Texture coordinates in range [0 .. 1]
         Pixels      ///< Texture coordinates in range [0 .. size]
@@ -551,7 +551,7 @@ public:
     /// // draw OpenGL stuff that use t1...
     /// sf::Texture::bind(&t2);
     /// // draw OpenGL stuff that use t2...
-    /// sf::Texture::bind(NULL);
+    /// sf::Texture::bind(nullptr);
     /// // draw OpenGL stuff that use no texture...
     /// \endcode
     ///
@@ -568,7 +568,7 @@ public:
     /// \param coordinateType Type of texture coordinates to use
     ///
     ////////////////////////////////////////////////////////////
-    static void bind(const Texture* texture, CoordinateType coordinateType = Normalized);
+    static void bind(const Texture* texture, CoordinateType coordinateType = CoordinateType::Normalized);
 
     ////////////////////////////////////////////////////////////
     /// \brief Get the maximum texture size allowed
@@ -723,7 +723,7 @@ private:
 /// \code
 /// sf::Texture::bind(&texture);
 /// ... render OpenGL geometry ...
-/// sf::Texture::bind(NULL);
+/// sf::Texture::bind(nullptr);
 /// \endcode
 ///
 /// \see sf::Sprite, sf::Image, sf::RenderTexture

include/SFML/Graphics/VertexArray.hpp

@@ -180,7 +180,7 @@ private:
     /// \param states Current render states
     ///
     ////////////////////////////////////////////////////////////
-    virtual void draw(RenderTarget& target, RenderStates states) const;
+    void draw(RenderTarget& target, RenderStates states) const override;
 
 private:
 

include/SFML/Network/Ftp.hpp

@@ -52,7 +52,7 @@ public:
     /// \brief Enumeration of transfer modes
     ///
     ////////////////////////////////////////////////////////////
-    enum TransferMode
+    enum class TransferMode : unsigned char
     {
         Binary, ///< Binary mode (file is transfered as a sequence of bytes)
         Ascii,  ///< Text mode using ASCII encoding
@@ -71,7 +71,7 @@ public:
         /// \brief Status codes possibly returned by a FTP response
         ///
         ////////////////////////////////////////////////////////////
-        enum Status
+        enum class Status : unsigned short
         {
             // 1xx: the requested action is being initiated,
             // expect another reply before proceeding with a new command
@@ -143,7 +143,7 @@ public:
         /// \param message Response message
         ///
         ////////////////////////////////////////////////////////////
-        explicit Response(Status code = InvalidResponse, const std::string& message = "");
+        explicit Response(Status code = Status::InvalidResponse, const std::string& message = "");
 
         ////////////////////////////////////////////////////////////
         /// \brief Check if the status code means a success
@@ -465,7 +465,7 @@ public:
     /// \see upload
     ///
     ////////////////////////////////////////////////////////////
-    Response download(const std::string& remoteFile, const std::string& localPath, TransferMode mode = Binary);
+    Response download(const std::string& remoteFile, const std::string& localPath, TransferMode mode = TransferMode::Binary);
 
     ////////////////////////////////////////////////////////////
     /// \brief Upload a file to the server
@@ -484,7 +484,7 @@ public:
     /// \see download
     ///
     ////////////////////////////////////////////////////////////
-    Response upload(const std::string& localFile, const std::string& remotePath, TransferMode mode = Binary);
+    Response upload(const std::string& localFile, const std::string& remotePath, TransferMode mode = TransferMode::Binary);
 
     ////////////////////////////////////////////////////////////
     /// \brief Send a command to the FTP server

include/SFML/Network/Http.hpp

@@ -59,7 +59,7 @@ public:
         /// \brief Enumerate the available HTTP methods for a request
         ///
         ////////////////////////////////////////////////////////////
-        enum Method
+        enum class Method : unsigned char
         {
             Get,   ///< Request in get mode, standard method to retrieve a page
             Post,  ///< Request in post mode, usually to send data to a page
@@ -79,7 +79,7 @@ public:
         /// \param body   Content of the request's body
         ///
         ////////////////////////////////////////////////////////////
-        Request(const std::string& uri = "/", Method method = Get, const std::string& body = "");
+        Request(const std::string& uri = "/", Method method = Method::Get, const std::string& body = "");
 
         ////////////////////////////////////////////////////////////
         /// \brief Set the value of a field
@@ -198,7 +198,7 @@ public:
         /// \brief Enumerate all the valid status codes for a response
         ///
         ////////////////////////////////////////////////////////////
-        enum Status
+        enum class Status : unsigned short
         {
             // 2xx: success
             Ok             = 200, ///< Most common code returned when operation was successful

include/SFML/Network/Packet.hpp

@@ -92,7 +92,7 @@ public:
     /// Warning: the returned pointer may become invalid after
     /// you append data to the packet, therefore it should never
     /// be stored.
-    /// The return pointer is NULL if the packet is empty.
+    /// The return pointer is nullptr if the packet is empty.
     ///
     /// \return Pointer to the data
     ///

include/SFML/Network/Socket.hpp

@@ -50,7 +50,7 @@ public:
     /// \brief Status codes that may be returned by socket functions
     ///
     ////////////////////////////////////////////////////////////
-    enum Status
+    enum class Status : unsigned char
     {
         Done,         ///< The socket has sent / received the data
         NotReady,     ///< The socket is not ready to send / receive data yet
@@ -111,7 +111,7 @@ protected:
     /// \brief Types of protocols that the socket can use
     ///
     ////////////////////////////////////////////////////////////
-    enum Type
+    enum class Type : unsigned char
     {
         Tcp, ///< TCP protocol
         Udp  ///< UDP protocol

include/SFML/Network/SocketSelector.hpp

@@ -30,6 +30,7 @@
 ////////////////////////////////////////////////////////////
 #include <SFML/Network/Export.hpp>
 #include <SFML/System/Time.hpp>
+#include <memory>
 
 
 namespace sf
@@ -158,7 +159,7 @@ private:
     ////////////////////////////////////////////////////////////
     // Member data
     ////////////////////////////////////////////////////////////
-    SocketSelectorImpl* m_impl; ///< Opaque pointer to the implementation (which requires OS-specific types)
+    std::unique_ptr<SocketSelectorImpl> m_impl; ///< Opaque pointer to the implementation (which requires OS-specific types)
 };
 
 } // namespace sf
@@ -240,9 +241,9 @@ private:
 ///         else
 ///         {
 ///             // The listener socket is not ready, test all other sockets (the clients)
-///             for (std::list<sf::TcpSocket*>::iterator it = clients.begin(); it != clients.end(); ++it)
+///             for (auto c : clients)
 ///             {
-///                 sf::TcpSocket& client = **it;
+///                 sf::TcpSocket& client = *c;
 ///                 if (selector.isReady(client))
 ///                 {
 ///                     // The client has sent some data, we can receive it

include/SFML/System.hpp

@@ -34,15 +34,10 @@
 #include <SFML/System/Err.hpp>
 #include <SFML/System/FileInputStream.hpp>
 #include <SFML/System/InputStream.hpp>
-#include <SFML/System/Lock.hpp>
 #include <SFML/System/MemoryInputStream.hpp>
-#include <SFML/System/Mutex.hpp>
 #include <SFML/System/NonCopyable.hpp>
 #include <SFML/System/Sleep.hpp>
 #include <SFML/System/String.hpp>
-#include <SFML/System/Thread.hpp>
-#include <SFML/System/ThreadLocal.hpp>
-#include <SFML/System/ThreadLocalPtr.hpp>
 #include <SFML/System/Time.hpp>
 #include <SFML/System/Utf.hpp>
 #include <SFML/System/Vector2.hpp>

include/SFML/System/Err.hpp

@@ -69,7 +69,7 @@ SFML_SYSTEM_API std::ostream& err();
 /// std::streambuf* previous = sf::err().rdbuf(file.rdbuf());
 ///
 /// // Redirect to nothing
-/// sf::err().rdbuf(NULL);
+/// sf::err().rdbuf(nullptr);
 ///
 /// // Restore the original output
 /// sf::err().rdbuf(previous);

include/SFML/System/FileInputStream.hpp

@@ -34,6 +34,7 @@
 #include <SFML/System/NonCopyable.hpp>
 #include <cstdio>
 #include <string>
+#include <memory>
 
 #ifdef ANDROID
 namespace sf
@@ -65,7 +66,7 @@ public:
     /// \brief Default destructor
     ///
     ////////////////////////////////////////////////////////////
-    virtual ~FileInputStream();
+    ~FileInputStream() override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Open the stream from a file path
@@ -89,7 +90,7 @@ public:
     /// \return The number of bytes actually read, or -1 on error
     ///
     ////////////////////////////////////////////////////////////
-    virtual Int64 read(void* data, Int64 size);
+    Int64 read(void* data, Int64 size) override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Change the current reading position
@@ -99,7 +100,7 @@ public:
     /// \return The position actually sought to, or -1 on error
     ///
     ////////////////////////////////////////////////////////////
-    virtual Int64 seek(Int64 position);
+    Int64 seek(Int64 position) override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Get the current reading position in the stream
@@ -107,7 +108,7 @@ public:
     /// \return The current position, or -1 on error.
     ///
     ////////////////////////////////////////////////////////////
-    virtual Int64 tell();
+    Int64 tell() override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Return the size of the stream
@@ -115,7 +116,7 @@ public:
     /// \return The total number of bytes available in the stream, or -1 on error
     ///
     ////////////////////////////////////////////////////////////
-    virtual Int64 getSize();
+    Int64 getSize() override;
 
 private:
 
@@ -123,7 +124,7 @@ private:
     // Member data
     ////////////////////////////////////////////////////////////
 #ifdef ANDROID
-    priv::ResourceStream* m_file;
+    std::unique_ptr<priv::ResourceStream> m_file;
 #else
     std::FILE* m_file; ///< stdio file stream
 #endif

include/SFML/System/Lock.hpp

@@ -1,139 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2017 Laurent Gomila (laurent@sfml-dev.org)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-//    you must not claim that you wrote the original software.
-//    If you use this software in a product, an acknowledgment
-//    in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-//    and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_LOCK_HPP
-#define SFML_LOCK_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <SFML/System/Export.hpp>
-#include <SFML/System/NonCopyable.hpp>
-
-
-namespace sf
-{
-class Mutex;
-
-////////////////////////////////////////////////////////////
-/// \brief Automatic wrapper for locking and unlocking mutexes
-///
-////////////////////////////////////////////////////////////
-class SFML_SYSTEM_API Lock : NonCopyable
-{
-public:
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Construct the lock with a target mutex
-    ///
-    /// The mutex passed to sf::Lock is automatically locked.
-    ///
-    /// \param mutex Mutex to lock
-    ///
-    ////////////////////////////////////////////////////////////
-    explicit Lock(Mutex& mutex);
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Destructor
-    ///
-    /// The destructor of sf::Lock automatically unlocks its mutex.
-    ///
-    ////////////////////////////////////////////////////////////
-    ~Lock();
-
-private:
-
-    ////////////////////////////////////////////////////////////
-    // Member data
-    ////////////////////////////////////////////////////////////
-    Mutex& m_mutex; ///< Mutex to lock / unlock
-};
-
-} // namespace sf
-
-
-#endif // SFML_LOCK_HPP
-
-
-////////////////////////////////////////////////////////////
-/// \class sf::Lock
-/// \ingroup system
-///
-/// sf::Lock is a RAII wrapper for sf::Mutex. By unlocking
-/// it in its destructor, it ensures that the mutex will
-/// always be released when the current scope (most likely
-/// a function) ends.
-/// This is even more important when an exception or an early
-/// return statement can interrupt the execution flow of the
-/// function.
-///
-/// For maximum robustness, sf::Lock should always be used
-/// to lock/unlock a mutex.
-///
-/// Usage example:
-/// \code
-/// sf::Mutex mutex;
-///
-/// void function()
-/// {
-///     sf::Lock lock(mutex); // mutex is now locked
-///
-///     functionThatMayThrowAnException(); // mutex is unlocked if this function throws
-///
-///     if (someCondition)
-///         return; // mutex is unlocked
-///
-/// } // mutex is unlocked
-/// \endcode
-///
-/// Because the mutex is not explicitly unlocked in the code,
-/// it may remain locked longer than needed. If the region
-/// of the code that needs to be protected by the mutex is
-/// not the entire function, a good practice is to create a
-/// smaller, inner scope so that the lock is limited to this
-/// part of the code.
-///
-/// \code
-/// sf::Mutex mutex;
-///
-/// void function()
-/// {
-///     {
-///       sf::Lock lock(mutex);
-///       codeThatRequiresProtection();
-///
-///     } // mutex is unlocked here
-///
-///     codeThatDoesntCareAboutTheMutex();
-/// }
-/// \endcode
-///
-/// Having a mutex locked longer than required is a bad practice
-/// which can lead to bad performances. Don't forget that when
-/// a mutex is locked, other threads may be waiting doing nothing
-/// until it is released.
-///
-/// \see sf::Mutex
-///
-////////////////////////////////////////////////////////////

include/SFML/System/MemoryInputStream.hpp

@@ -71,7 +71,7 @@ public:
     /// \return The number of bytes actually read, or -1 on error
     ///
     ////////////////////////////////////////////////////////////
-    virtual Int64 read(void* data, Int64 size);
+    Int64 read(void* data, Int64 size) override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Change the current reading position
@@ -81,7 +81,7 @@ public:
     /// \return The position actually sought to, or -1 on error
     ///
     ////////////////////////////////////////////////////////////
-    virtual Int64 seek(Int64 position);
+    Int64 seek(Int64 position) override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Get the current reading position in the stream
@@ -89,7 +89,7 @@ public:
     /// \return The current position, or -1 on error.
     ///
     ////////////////////////////////////////////////////////////
-    virtual Int64 tell();
+    Int64 tell() override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Return the size of the stream
@@ -97,7 +97,7 @@ public:
     /// \return The total number of bytes available in the stream, or -1 on error
     ///
     ////////////////////////////////////////////////////////////
-    virtual Int64 getSize();
+    Int64 getSize() override;
 
 private:
 

include/SFML/System/Mutex.hpp

@@ -1,148 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2017 Laurent Gomila (laurent@sfml-dev.org)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-//    you must not claim that you wrote the original software.
-//    If you use this software in a product, an acknowledgment
-//    in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-//    and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_MUTEX_HPP
-#define SFML_MUTEX_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <SFML/System/Export.hpp>
-#include <SFML/System/NonCopyable.hpp>
-
-
-namespace sf
-{
-namespace priv
-{
-    class MutexImpl;
-}
-
-////////////////////////////////////////////////////////////
-/// \brief Blocks concurrent access to shared resources
-///        from multiple threads
-///
-////////////////////////////////////////////////////////////
-class SFML_SYSTEM_API Mutex : NonCopyable
-{
-public:
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Default constructor
-    ///
-    ////////////////////////////////////////////////////////////
-    Mutex();
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Destructor
-    ///
-    ////////////////////////////////////////////////////////////
-    ~Mutex();
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Lock the mutex
-    ///
-    /// If the mutex is already locked in another thread,
-    /// this call will block the execution until the mutex
-    /// is released.
-    ///
-    /// \see unlock
-    ///
-    ////////////////////////////////////////////////////////////
-    void lock();
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Unlock the mutex
-    ///
-    /// \see lock
-    ///
-    ////////////////////////////////////////////////////////////
-    void unlock();
-
-private:
-
-    ////////////////////////////////////////////////////////////
-    // Member data
-    ////////////////////////////////////////////////////////////
-    priv::MutexImpl* m_mutexImpl; ///< OS-specific implementation
-};
-
-} // namespace sf
-
-
-#endif // SFML_MUTEX_HPP
-
-
-////////////////////////////////////////////////////////////
-/// \class sf::Mutex
-/// \ingroup system
-///
-/// Mutex stands for "MUTual EXclusion". A mutex is a
-/// synchronization object, used when multiple threads are involved.
-///
-/// When you want to protect a part of the code from being accessed
-/// simultaneously by multiple threads, you typically use a
-/// mutex. When a thread is locked by a mutex, any other thread
-/// trying to lock it will be blocked until the mutex is released
-/// by the thread that locked it. This way, you can allow only
-/// one thread at a time to access a critical region of your code.
-///
-/// Usage example:
-/// \code
-/// Database database; // this is a critical resource that needs some protection
-/// sf::Mutex mutex;
-///
-/// void thread1()
-/// {
-///     mutex.lock(); // this call will block the thread if the mutex is already locked by thread2
-///     database.write(...);
-///     mutex.unlock(); // if thread2 was waiting, it will now be unblocked
-/// }
-///
-/// void thread2()
-/// {
-///     mutex.lock(); // this call will block the thread if the mutex is already locked by thread1
-///     database.write(...);
-///     mutex.unlock(); // if thread1 was waiting, it will now be unblocked
-/// }
-/// \endcode
-///
-/// Be very careful with mutexes. A bad usage can lead to bad problems,
-/// like deadlocks (two threads are waiting for each other and the
-/// application is globally stuck).
-///
-/// To make the usage of mutexes more robust, particularly in
-/// environments where exceptions can be thrown, you should
-/// use the helper class sf::Lock to lock/unlock mutexes.
-///
-/// SFML mutexes are recursive, which means that you can lock
-/// a mutex multiple times in the same thread without creating
-/// a deadlock. In this case, the first call to lock() behaves
-/// as usual, and the following ones have no effect.
-/// However, you must call unlock() exactly as many times as you
-/// called lock(). If you don't, the mutex won't be released.
-///
-/// \see sf::Lock
-///
-////////////////////////////////////////////////////////////

include/SFML/System/NonCopyable.hpp

@@ -47,10 +47,10 @@ protected:
     ///
     /// Because this class has a copy constructor, the compiler
     /// will not automatically generate the default constructor.
-    /// That's why we must define it explicitly.
+    /// That's why we must mark it as defaulted explicitly.
     ///
     ////////////////////////////////////////////////////////////
-    NonCopyable() {}
+    NonCopyable() = default;
     
     ////////////////////////////////////////////////////////////
     /// \brief Default destructor
@@ -60,33 +60,49 @@ protected:
     /// preventing possible resource leaks.
     ///
     ////////////////////////////////////////////////////////////
-    ~NonCopyable() {}
-
-private:
+    ~NonCopyable() = default;
 
     ////////////////////////////////////////////////////////////
     /// \brief Disabled copy constructor
     ///
-    /// By making the copy constructor private, the compiler will
-    /// trigger an error if anyone outside tries to use it.
-    /// To prevent NonCopyable or friend classes from using it,
-    /// we also give no definition, so that the linker will
-    /// produce an error if the first protection was inefficient.
+    /// By marking the copy constructor as deleted, the compiler
+    /// will trigger an error if anyone outside tries to use it.
     ///
     ////////////////////////////////////////////////////////////
-    NonCopyable(const NonCopyable&);
+    NonCopyable(const NonCopyable&) = delete;
 
     ////////////////////////////////////////////////////////////
-    /// \brief Disabled assignment operator
+    /// \brief Disabled copy assignment operator
     ///
-    /// By making the assignment operator private, the compiler will
-    /// trigger an error if anyone outside tries to use it.
-    /// To prevent NonCopyable or friend classes from using it,
-    /// we also give no definition, so that the linker will
-    /// produce an error if the first protection was inefficient.
+    /// By marking the copy assignment operator as deleted, the
+    /// compiler will trigger an error if anyone outside tries
+    /// to use it.
     ///
     ////////////////////////////////////////////////////////////
-    NonCopyable& operator =(const NonCopyable&);
+    NonCopyable& operator =(const NonCopyable&) = delete;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Default move constructor
+    ///
+    /// Because this class has all other special member
+    /// functions user-defined, the compiler will not
+    /// automatically generate the default move constructor.
+    /// That's why we must mark it as defaulted explicitly.
+    ///
+    ////////////////////////////////////////////////////////////
+    NonCopyable(NonCopyable&&) = default;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Default move assignment operator
+    ///
+    /// Because this class has all other special member
+    /// functions user-defined, the compiler will not
+    /// automatically generate the default move assignment
+    /// operator. That's why we must mark it as defaulted
+    /// explicitly.
+    ///
+    ////////////////////////////////////////////////////////////
+    NonCopyable& operator =(NonCopyable&&) = default;
 };
 
 } // namespace sf
@@ -99,17 +115,18 @@ private:
 /// \class sf::NonCopyable
 /// \ingroup system
 ///
-/// This class makes its instances non-copyable, by explicitly
-/// disabling its copy constructor and its assignment operator.
+/// This class makes its instances non-copyable, by
+/// explicitly deleting its copy constructor and its
+/// assignment operator.
 ///
 /// To create a non-copyable class, simply inherit from
 /// sf::NonCopyable.
 ///
-/// The type of inheritance (public or private) doesn't matter,
-/// the copy constructor and assignment operator are declared private
-/// in sf::NonCopyable so they will end up being inaccessible in both
-/// cases. Thus you can use a shorter syntax for inheriting from it
-/// (see below).
+/// The type of inheritance (public or private) doesn't
+/// matter, the copy constructor and assignment operator
+/// are deleted in sf::NonCopyable so they will end up being
+/// inaccessible in both cases. Thus you can use a shorter
+/// syntax for inheriting from it (see below).
 ///
 /// Usage example:
 /// \code
@@ -120,10 +137,11 @@ private:
 /// \endcode
 ///
 /// Deciding whether the instances of a class can be copied
-/// or not is a very important design choice. You are strongly
-/// encouraged to think about it before writing a class,
-/// and to use sf::NonCopyable when necessary to prevent
-/// many potential future errors when using it. This is also
-/// a very important indication to users of your class.
+/// or not is a very important design choice. You are
+/// strongly encouraged to think about it before writing a
+/// class, and to use sf::NonCopyable when necessary to
+/// prevent many potential future errors when using it. This
+/// is alsoa very important indication to users of your
+/// class.
 ///
 ////////////////////////////////////////////////////////////

include/SFML/System/Thread.hpp

@@ -1,282 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2017 Laurent Gomila (laurent@sfml-dev.org)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-//    you must not claim that you wrote the original software.
-//    If you use this software in a product, an acknowledgment
-//    in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-//    and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_THREAD_HPP
-#define SFML_THREAD_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <SFML/System/Export.hpp>
-#include <SFML/System/NonCopyable.hpp>
-#include <cstdlib>
-
-
-namespace sf
-{
-namespace priv
-{
-    class ThreadImpl;
-    struct ThreadFunc;
-}
-
-////////////////////////////////////////////////////////////
-/// \brief Utility class to manipulate threads
-///
-////////////////////////////////////////////////////////////
-class SFML_SYSTEM_API Thread : NonCopyable
-{
-public:
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Construct the thread from a functor with no argument
-    ///
-    /// This constructor works for function objects, as well
-    /// as free functions.
-    ///
-    /// Use this constructor for this kind of function:
-    /// \code
-    /// void function();
-    ///
-    /// // --- or ----
-    ///
-    /// struct Functor
-    /// {
-    ///     void operator()();
-    /// };
-    /// \endcode
-    /// Note: this does *not* run the thread, use launch().
-    ///
-    /// \param function Functor or free function to use as the entry point of the thread
-    ///
-    ////////////////////////////////////////////////////////////
-    template <typename F>
-    Thread(F function);
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Construct the thread from a functor with an argument
-    ///
-    /// This constructor works for function objects, as well
-    /// as free functions.
-    /// It is a template, which means that the argument can
-    /// have any type (int, std::string, void*, Toto, ...).
-    ///
-    /// Use this constructor for this kind of function:
-    /// \code
-    /// void function(int arg);
-    ///
-    /// // --- or ----
-    ///
-    /// struct Functor
-    /// {
-    ///     void operator()(std::string arg);
-    /// };
-    /// \endcode
-    /// Note: this does *not* run the thread, use launch().
-    ///
-    /// \param function Functor or free function to use as the entry point of the thread
-    /// \param argument argument to forward to the function
-    ///
-    ////////////////////////////////////////////////////////////
-    template <typename F, typename A>
-    Thread(F function, A argument);
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Construct the thread from a member function and an object
-    ///
-    /// This constructor is a template, which means that you can
-    /// use it with any class.
-    /// Use this constructor for this kind of function:
-    /// \code
-    /// class MyClass
-    /// {
-    /// public:
-    ///
-    ///     void function();
-    /// };
-    /// \endcode
-    /// Note: this does *not* run the thread, use launch().
-    ///
-    /// \param function Entry point of the thread
-    /// \param object Pointer to the object to use
-    ///
-    ////////////////////////////////////////////////////////////
-    template <typename C>
-    Thread(void(C::*function)(), C* object);
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Destructor
-    ///
-    /// This destructor calls wait(), so that the internal thread
-    /// cannot survive after its sf::Thread instance is destroyed.
-    ///
-    ////////////////////////////////////////////////////////////
-    ~Thread();
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Run the thread
-    ///
-    /// This function starts the entry point passed to the
-    /// thread's constructor, and returns immediately.
-    /// After this function returns, the thread's function is
-    /// running in parallel to the calling code.
-    ///
-    ////////////////////////////////////////////////////////////
-    void launch();
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Wait until the thread finishes
-    ///
-    /// This function will block the execution until the
-    /// thread's function ends.
-    /// Warning: if the thread function never ends, the calling
-    /// thread will block forever.
-    /// If this function is called from its owner thread, it
-    /// returns without doing anything.
-    ///
-    ////////////////////////////////////////////////////////////
-    void wait();
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Terminate the thread
-    ///
-    /// This function immediately stops the thread, without waiting
-    /// for its function to finish.
-    /// Terminating a thread with this function is not safe,
-    /// and can lead to local variables not being destroyed
-    /// on some operating systems. You should rather try to make
-    /// the thread function terminate by itself.
-    ///
-    ////////////////////////////////////////////////////////////
-    void terminate();
-
-private:
-
-    friend class priv::ThreadImpl;
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Internal entry point of the thread
-    ///
-    /// This function is called by the thread implementation.
-    ///
-    ////////////////////////////////////////////////////////////
-    void run();
-
-    ////////////////////////////////////////////////////////////
-    // Member data
-    ////////////////////////////////////////////////////////////
-    priv::ThreadImpl* m_impl;       ///< OS-specific implementation of the thread
-    priv::ThreadFunc* m_entryPoint; ///< Abstraction of the function to run
-};
-
-#include <SFML/System/Thread.inl>
-
-} // namespace sf
-
-#endif // SFML_THREAD_HPP
-
-
-////////////////////////////////////////////////////////////
-/// \class sf::Thread
-/// \ingroup system
-///
-/// Threads provide a way to run multiple parts of the code
-/// in parallel. When you launch a new thread, the execution
-/// is split and both the new thread and the caller run
-/// in parallel.
-///
-/// To use a sf::Thread, you construct it directly with the
-/// function to execute as the entry point of the thread.
-/// sf::Thread has multiple template constructors, which means
-/// that you can use several types of entry points:
-/// \li non-member functions with no argument
-/// \li non-member functions with one argument of any type
-/// \li functors with no argument (this one is particularly useful for compatibility with boost/std::%bind)
-/// \li functors with one argument of any type
-/// \li member functions from any class with no argument
-///
-/// The function argument, if any, is copied in the sf::Thread
-/// instance, as well as the functor (if the corresponding
-/// constructor is used). Class instances, however, are passed
-/// by pointer so you must make sure that the object won't be
-/// destroyed while the thread is still using it.
-///
-/// The thread ends when its function is terminated. If the
-/// owner sf::Thread instance is destroyed before the
-/// thread is finished, the destructor will wait (see wait())
-///
-/// Usage examples:
-/// \code
-/// // example 1: non member function with one argument
-///
-/// void threadFunc(int argument)
-/// {
-///     ...
-/// }
-///
-/// sf::Thread thread(&threadFunc, 5);
-/// thread.launch(); // start the thread (internally calls threadFunc(5))
-/// \endcode
-///
-/// \code
-/// // example 2: member function
-///
-/// class Task
-/// {
-/// public:
-///     void run()
-///     {
-///         ...
-///     }
-/// };
-///
-/// Task task;
-/// sf::Thread thread(&Task::run, &task);
-/// thread.launch(); // start the thread (internally calls task.run())
-/// \endcode
-///
-/// \code
-/// // example 3: functor
-///
-/// struct Task
-/// {
-///     void operator()()
-///     {
-///         ...
-///     }
-/// };
-///
-/// sf::Thread thread(Task());
-/// thread.launch(); // start the thread (internally calls operator() on the Task instance)
-/// \endcode
-///
-/// Creating parallel threads of execution can be dangerous:
-/// all threads inside the same process share the same memory space,
-/// which means that you may end up accessing the same variable
-/// from multiple threads at the same time. To prevent this
-/// kind of situations, you can use mutexes (see sf::Mutex).
-///
-/// \see sf::Mutex
-///
-////////////////////////////////////////////////////////////

include/SFML/System/Thread.inl

@@ -1,90 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2017 Laurent Gomila (laurent@sfml-dev.org)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-//    you must not claim that you wrote the original software.
-//    If you use this software in a product, an acknowledgment
-//    in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-//    and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-namespace priv
-{
-// Base class for abstract thread functions
-struct ThreadFunc
-{
-    virtual ~ThreadFunc() {}
-    virtual void run() = 0;
-};
-
-// Specialization using a functor (including free functions) with no argument
-template <typename T>
-struct ThreadFunctor : ThreadFunc
-{
-    ThreadFunctor(T functor) : m_functor(functor) {}
-    virtual void run() {m_functor();}
-    T m_functor;
-};
-
-// Specialization using a functor (including free functions) with one argument
-template <typename F, typename A>
-struct ThreadFunctorWithArg : ThreadFunc
-{
-    ThreadFunctorWithArg(F function, A arg) : m_function(function), m_arg(arg) {}
-    virtual void run() {m_function(m_arg);}
-    F m_function;
-    A m_arg;
-};
-
-// Specialization using a member function
-template <typename C>
-struct ThreadMemberFunc : ThreadFunc
-{
-    ThreadMemberFunc(void(C::*function)(), C* object) : m_function(function), m_object(object) {}
-    virtual void run() {(m_object->*m_function)();}
-    void(C::*m_function)();
-    C* m_object;
-};
-
-} // namespace priv
-
-
-////////////////////////////////////////////////////////////
-template <typename F>
-Thread::Thread(F functor) :
-m_impl      (NULL),
-m_entryPoint(new priv::ThreadFunctor<F>(functor))
-{
-}
-
-
-////////////////////////////////////////////////////////////
-template <typename F, typename A>
-Thread::Thread(F function, A argument) :
-m_impl      (NULL),
-m_entryPoint(new priv::ThreadFunctorWithArg<F, A>(function, argument))
-{
-}
-
-
-////////////////////////////////////////////////////////////
-template <typename C>
-Thread::Thread(void(C::*function)(), C* object) :
-m_impl      (NULL),
-m_entryPoint(new priv::ThreadMemberFunc<C>(function, object))
-{
-}

include/SFML/System/ThreadLocal.hpp

@@ -1,103 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2017 Laurent Gomila (laurent@sfml-dev.org)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-//    you must not claim that you wrote the original software.
-//    If you use this software in a product, an acknowledgment
-//    in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-//    and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_THREADLOCAL_HPP
-#define SFML_THREADLOCAL_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <SFML/System/Export.hpp>
-#include <SFML/System/NonCopyable.hpp>
-#include <cstdlib>
-
-
-namespace sf
-{
-namespace priv
-{
-    class ThreadLocalImpl;
-}
-
-////////////////////////////////////////////////////////////
-/// \brief Defines variables with thread-local storage
-///
-////////////////////////////////////////////////////////////
-class SFML_SYSTEM_API ThreadLocal : NonCopyable
-{
-public:
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Default constructor
-    ///
-    /// \param value Optional value to initialize the variable
-    ///
-    ////////////////////////////////////////////////////////////
-    ThreadLocal(void* value = NULL);
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Destructor
-    ///
-    ////////////////////////////////////////////////////////////
-    ~ThreadLocal();
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Set the thread-specific value of the variable
-    ///
-    /// \param value Value of the variable for the current thread
-    ///
-    ////////////////////////////////////////////////////////////
-    void setValue(void* value);
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Retrieve the thread-specific value of the variable
-    ///
-    /// \return Value of the variable for the current thread
-    ///
-    ////////////////////////////////////////////////////////////
-    void* getValue() const;
-
-private:
-
-    ////////////////////////////////////////////////////////////
-    // Member data
-    ////////////////////////////////////////////////////////////
-    priv::ThreadLocalImpl* m_impl; ///< Pointer to the OS specific implementation
-};
-
-} // namespace sf
-
-
-#endif // SFML_THREADLOCAL_HPP
-
-
-////////////////////////////////////////////////////////////
-/// \class sf::ThreadLocal
-/// \ingroup system
-///
-/// This class manipulates void* parameters and thus is not
-/// appropriate for strongly-typed variables. You should rather
-/// use the sf::ThreadLocalPtr template class.
-///
-////////////////////////////////////////////////////////////

include/SFML/System/ThreadLocalPtr.hpp

@@ -1,158 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2017 Laurent Gomila (laurent@sfml-dev.org)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-//    you must not claim that you wrote the original software.
-//    If you use this software in a product, an acknowledgment
-//    in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-//    and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_THREADLOCALPTR_HPP
-#define SFML_THREADLOCALPTR_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <SFML/System/ThreadLocal.hpp>
-
-
-namespace sf
-{
-////////////////////////////////////////////////////////////
-/// \brief Pointer to a thread-local variable
-///
-////////////////////////////////////////////////////////////
-template <typename T>
-class ThreadLocalPtr : private ThreadLocal
-{
-public:
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Default constructor
-    ///
-    /// \param value Optional value to initialize the variable
-    ///
-    ////////////////////////////////////////////////////////////
-    ThreadLocalPtr(T* value = NULL);
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Overload of unary operator *
-    ///
-    /// Like raw pointers, applying the * operator returns a
-    /// reference to the pointed-to object.
-    ///
-    /// \return Reference to the thread-local variable
-    ///
-    ////////////////////////////////////////////////////////////
-    T& operator *() const;
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Overload of operator ->
-    ///
-    /// Similarly to raw pointers, applying the -> operator
-    /// returns the pointed-to object.
-    ///
-    /// \return Pointer to the thread-local variable
-    ///
-    ////////////////////////////////////////////////////////////
-    T* operator ->() const;
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Conversion operator to implicitly convert the
-    ///        pointer to its raw pointer type (T*)
-    ///
-    /// \return Pointer to the actual object
-    ///
-    ////////////////////////////////////////////////////////////
-    operator T*() const;
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Assignment operator for a raw pointer parameter
-    ///
-    /// \param value Pointer to assign
-    ///
-    /// \return Reference to self
-    ///
-    ////////////////////////////////////////////////////////////
-    ThreadLocalPtr<T>& operator =(T* value);
-
-    ////////////////////////////////////////////////////////////
-    /// \brief Assignment operator for a ThreadLocalPtr parameter
-    ///
-    /// \param right ThreadLocalPtr to assign
-    ///
-    /// \return Reference to self
-    ///
-    ////////////////////////////////////////////////////////////
-    ThreadLocalPtr<T>& operator =(const ThreadLocalPtr<T>& right);
-};
-
-} // namespace sf
-
-#include <SFML/System/ThreadLocalPtr.inl>
-
-
-#endif // SFML_THREADLOCALPTR_HPP
-
-
-////////////////////////////////////////////////////////////
-/// \class sf::ThreadLocalPtr
-/// \ingroup system
-///
-/// sf::ThreadLocalPtr is a type-safe wrapper for storing
-/// pointers to thread-local variables. A thread-local
-/// variable holds a different value for each different
-/// thread, unlike normal variables that are shared.
-///
-/// Its usage is completely transparent, so that it is similar
-/// to manipulating the raw pointer directly (like any smart pointer).
-///
-/// Usage example:
-/// \code
-/// MyClass object1;
-/// MyClass object2;
-/// sf::ThreadLocalPtr<MyClass> objectPtr;
-///
-/// void thread1()
-/// {
-///     objectPtr = &object1; // doesn't impact thread2
-///     ...
-/// }
-///
-/// void thread2()
-/// {
-///     objectPtr = &object2; // doesn't impact thread1
-///     ...
-/// }
-///
-/// int main()
-/// {
-///     // Create and launch the two threads
-///     sf::Thread t1(&thread1);
-///     sf::Thread t2(&thread2);
-///     t1.launch();
-///     t2.launch();
-///
-///     return 0;
-/// }
-/// \endcode
-///
-/// ThreadLocalPtr is designed for internal use; however you
-/// can use it if you feel like it fits well your implementation.
-///
-////////////////////////////////////////////////////////////

include/SFML/System/ThreadLocalPtr.inl

@@ -1,77 +0,0 @@
-////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2017 Laurent Gomila (laurent@sfml-dev.org)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-//    you must not claim that you wrote the original software.
-//    If you use this software in a product, an acknowledgment
-//    in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-//    and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-
-namespace sf
-{
-////////////////////////////////////////////////////////////
-template <typename T>
-ThreadLocalPtr<T>::ThreadLocalPtr(T* value) :
-ThreadLocal(value)
-{
-}
-
-
-////////////////////////////////////////////////////////////
-template <typename T>
-T& ThreadLocalPtr<T>::operator *() const
-{
-    return *static_cast<T*>(getValue());
-}
-
-
-////////////////////////////////////////////////////////////
-template <typename T>
-T* ThreadLocalPtr<T>::operator ->() const
-{
-    return static_cast<T*>(getValue());
-}
-
-
-////////////////////////////////////////////////////////////
-template <typename T>
-ThreadLocalPtr<T>::operator T*() const
-{
-    return static_cast<T*>(getValue());
-}
-
-
-////////////////////////////////////////////////////////////
-template <typename T>
-ThreadLocalPtr<T>& ThreadLocalPtr<T>::operator =(T* value)
-{
-    setValue(value);
-    return *this;
-}
-
-
-////////////////////////////////////////////////////////////
-template <typename T>
-ThreadLocalPtr<T>& ThreadLocalPtr<T>::operator =(const ThreadLocalPtr<T>& right)
-{
-    setValue(right.getValue());
-    return *this;
-}
-
-} // namespace sf

include/SFML/System/Time.hpp

@@ -29,6 +29,7 @@
 // Headers
 ////////////////////////////////////////////////////////////
 #include <SFML/System/Export.hpp>
+#include <chrono>
 
 
 namespace sf
@@ -54,7 +55,7 @@ public:
     ///
     /// \return Time in seconds
     ///
-    /// \see asMilliseconds, asMicroseconds
+    /// \see asMilliseconds, asMicroseconds, asNanoseconds
     ///
     ////////////////////////////////////////////////////////////
     float asSeconds() const;
@@ -64,7 +65,7 @@ public:
     ///
     /// \return Time in milliseconds
     ///
-    /// \see asSeconds, asMicroseconds
+    /// \see asSeconds, asMicroseconds, asNanoseconds
     ///
     ////////////////////////////////////////////////////////////
     Int32 asMilliseconds() const;
@@ -74,11 +75,21 @@ public:
     ///
     /// \return Time in microseconds
     ///
-    /// \see asSeconds, asMilliseconds
+    /// \see asSeconds, asMilliseconds, asNanoseconds
     ///
     ////////////////////////////////////////////////////////////
     Int64 asMicroseconds() const;
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Return the time value as a number of nanoseconds
+    ///
+    /// \return Time in nanoseconds
+    ///
+    /// \see asSeconds, asMilliseconds, asMicroseconds
+    ///
+    ////////////////////////////////////////////////////////////
+    Int64 asNanoseconds() const;
+
     ////////////////////////////////////////////////////////////
     // Static member data
     ////////////////////////////////////////////////////////////
@@ -89,24 +100,26 @@ private:
     friend SFML_SYSTEM_API Time seconds(float);
     friend SFML_SYSTEM_API Time milliseconds(Int32);
     friend SFML_SYSTEM_API Time microseconds(Int64);
+    friend SFML_SYSTEM_API Time nanoseconds(Int64);
 
     ////////////////////////////////////////////////////////////
-    /// \brief Construct from a number of microseconds
+    /// \brief Construct from a number of nanoseconds
     ///
     /// This function is internal. To construct time values,
-    /// use sf::seconds, sf::milliseconds or sf::microseconds instead.
+    /// use sf::seconds, sf::milliseconds, sf::microseconds
+    /// or sf::nanoseconds instead.
     ///
-    /// \param microseconds Number of microseconds
+    /// \param nanoseconds Number of nanoseconds
     ///
     ////////////////////////////////////////////////////////////
-    explicit Time(Int64 microseconds);
+    explicit Time(Int64 nanoseconds);
 
 private:
 
     ////////////////////////////////////////////////////////////
     // Member data
     ////////////////////////////////////////////////////////////
-    Int64 m_microseconds; ///< Time value stored as microseconds
+    std::chrono::nanoseconds m_nanoseconds; ///< Time value stored as nanoseconds
 };
 
 ////////////////////////////////////////////////////////////
@@ -117,7 +130,7 @@ private:
 ///
 /// \return Time value constructed from the amount of seconds
 ///
-/// \see milliseconds, microseconds
+/// \see milliseconds, microseconds, nanoseconds
 ///
 ////////////////////////////////////////////////////////////
 SFML_SYSTEM_API Time seconds(float amount);
@@ -130,7 +143,7 @@ SFML_SYSTEM_API Time seconds(float amount);
 ///
 /// \return Time value constructed from the amount of milliseconds
 ///
-/// \see seconds, microseconds
+/// \see seconds, microseconds, nanoseconds
 ///
 ////////////////////////////////////////////////////////////
 SFML_SYSTEM_API Time milliseconds(Int32 amount);
@@ -143,11 +156,24 @@ SFML_SYSTEM_API Time milliseconds(Int32 amount);
 ///
 /// \return Time value constructed from the amount of microseconds
 ///
-/// \see seconds, milliseconds
+/// \see seconds, milliseconds, nanoseconds
 ///
 ////////////////////////////////////////////////////////////
 SFML_SYSTEM_API Time microseconds(Int64 amount);
 
+////////////////////////////////////////////////////////////
+/// \relates Time
+/// \brief Construct a time value from a number of nanoseconds
+///
+/// \param amount Number of nanoseconds
+///
+/// \return Time value constructed from the amount of nanoseconds
+///
+/// \see seconds, milliseconds, microseconds
+///
+////////////////////////////////////////////////////////////
+SFML_SYSTEM_API Time nanoseconds(Int64 amount);
+
 ////////////////////////////////////////////////////////////
 /// \relates Time
 /// \brief Overload of == operator to compare two time values

include/SFML/Window/Context.hpp

@@ -32,6 +32,7 @@
 #include <SFML/Window/GlResource.hpp>
 #include <SFML/Window/ContextSettings.hpp>
 #include <SFML/System/NonCopyable.hpp>
+#include <memory>
 
 
 namespace sf
@@ -112,7 +113,7 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Get the currently active context
     ///
-    /// \return The currently active context or NULL if none is active
+    /// \return The currently active context or nullptr if none is active
     ///
     ////////////////////////////////////////////////////////////
     static const Context* getActiveContext();
@@ -135,7 +136,7 @@ private:
     ////////////////////////////////////////////////////////////
     // Member data
     ////////////////////////////////////////////////////////////
-    priv::GlContext* m_context; ///< Internal OpenGL context
+    std::unique_ptr<priv::GlContext> m_context; ///< Internal OpenGL context
 };
 
 } // namespace sf

include/SFML/Window/Event.hpp

@@ -184,7 +184,7 @@ public:
     /// \brief Enumeration of the different types of events
     ///
     ////////////////////////////////////////////////////////////
-    enum EventType
+    enum class Type : unsigned char
     {
         Closed,                 ///< The window requested to be closed (no data)
         Resized,                ///< The window was resized (data in event.size)
@@ -216,7 +216,7 @@ public:
     ////////////////////////////////////////////////////////////
     // Member data
     ////////////////////////////////////////////////////////////
-    EventType type; ///< Type of the event
+    Type type; ///< Type of the event
 
     union
     {

include/SFML/Window/Joystick.hpp

@@ -49,15 +49,14 @@ public:
     enum
     {
         Count       = 8,  ///< Maximum number of supported joysticks
-        ButtonCount = 32, ///< Maximum number of supported buttons
-        AxisCount   = 8   ///< Maximum number of supported axes
+        ButtonCount = 32  ///< Maximum number of supported buttons
     };
 
     ////////////////////////////////////////////////////////////
     /// \brief Axes supported by SFML joysticks
     ///
     ////////////////////////////////////////////////////////////
-    enum Axis
+    enum class Axis : unsigned char
     {
         X,    ///< The X axis
         Y,    ///< The Y axis
@@ -66,7 +65,9 @@ public:
         U,    ///< The U axis
         V,    ///< The V axis
         PovX, ///< The X axis of the point-of-view hat
-        PovY  ///< The Y axis of the point-of-view hat
+        PovY, ///< The Y axis of the point-of-view hat
+
+        Count ///< Maximum number of supported axes
     };
 
     ////////////////////////////////////////////////////////////

include/SFML/Window/Keyboard.hpp

@@ -45,112 +45,113 @@ public:
     /// \brief Key codes
     ///
     ////////////////////////////////////////////////////////////
-    enum Key
+    enum class Key : unsigned char
     {
-        Unknown = -1, ///< Unhandled key
-        A = 0,        ///< The A key
-        B,            ///< The B key
-        C,            ///< The C key
-        D,            ///< The D key
-        E,            ///< The E key
-        F,            ///< The F key
-        G,            ///< The G key
-        H,            ///< The H key
-        I,            ///< The I key
-        J,            ///< The J key
-        K,            ///< The K key
-        L,            ///< The L key
-        M,            ///< The M key
-        N,            ///< The N key
-        O,            ///< The O key
-        P,            ///< The P key
-        Q,            ///< The Q key
-        R,            ///< The R key
-        S,            ///< The S key
-        T,            ///< The T key
-        U,            ///< The U key
-        V,            ///< The V key
-        W,            ///< The W key
-        X,            ///< The X key
-        Y,            ///< The Y key
-        Z,            ///< The Z key
-        Num0,         ///< The 0 key
-        Num1,         ///< The 1 key
-        Num2,         ///< The 2 key
-        Num3,         ///< The 3 key
-        Num4,         ///< The 4 key
-        Num5,         ///< The 5 key
-        Num6,         ///< The 6 key
-        Num7,         ///< The 7 key
-        Num8,         ///< The 8 key
-        Num9,         ///< The 9 key
-        Escape,       ///< The Escape key
-        LControl,     ///< The left Control key
-        LShift,       ///< The left Shift key
-        LAlt,         ///< The left Alt key
-        LSystem,      ///< The left OS specific key: window (Windows and Linux), apple (MacOS X), ...
-        RControl,     ///< The right Control key
-        RShift,       ///< The right Shift key
-        RAlt,         ///< The right Alt key
-        RSystem,      ///< The right OS specific key: window (Windows and Linux), apple (MacOS X), ...
-        Menu,         ///< The Menu key
-        LBracket,     ///< The [ key
-        RBracket,     ///< The ] key
-        SemiColon,    ///< The ; key
-        Comma,        ///< The , key
-        Period,       ///< The . key
-        Quote,        ///< The ' key
-        Slash,        ///< The / key
-        BackSlash,    ///< The \ key
-        Tilde,        ///< The ~ key
-        Equal,        ///< The = key
-        Dash,         ///< The - key
-        Space,        ///< The Space key
-        Return,       ///< The Return key
-        BackSpace,    ///< The Backspace key
-        Tab,          ///< The Tabulation key
-        PageUp,       ///< The Page up key
-        PageDown,     ///< The Page down key
-        End,          ///< The End key
-        Home,         ///< The Home key
-        Insert,       ///< The Insert key
-        Delete,       ///< The Delete key
-        Add,          ///< The + key
-        Subtract,     ///< The - key
-        Multiply,     ///< The * key
-        Divide,       ///< The / key
-        Left,         ///< Left arrow
-        Right,        ///< Right arrow
-        Up,           ///< Up arrow
-        Down,         ///< Down arrow
-        Numpad0,      ///< The numpad 0 key
-        Numpad1,      ///< The numpad 1 key
-        Numpad2,      ///< The numpad 2 key
-        Numpad3,      ///< The numpad 3 key
-        Numpad4,      ///< The numpad 4 key
-        Numpad5,      ///< The numpad 5 key
-        Numpad6,      ///< The numpad 6 key
-        Numpad7,      ///< The numpad 7 key
-        Numpad8,      ///< The numpad 8 key
-        Numpad9,      ///< The numpad 9 key
-        F1,           ///< The F1 key
-        F2,           ///< The F2 key
-        F3,           ///< The F3 key
-        F4,           ///< The F4 key
-        F5,           ///< The F5 key
-        F6,           ///< The F6 key
-        F7,           ///< The F7 key
-        F8,           ///< The F8 key
-        F9,           ///< The F9 key
-        F10,          ///< The F10 key
-        F11,          ///< The F11 key
-        F12,          ///< The F12 key
-        F13,          ///< The F13 key
-        F14,          ///< The F14 key
-        F15,          ///< The F15 key
-        Pause,        ///< The Pause key
+        Unknown = static_cast<unsigned char>(-1), ///< Unhandled key
 
-        KeyCount      ///< Keep last -- the total number of keyboard keys
+        A = 0,                                    ///< The A key
+        B,                                        ///< The B key
+        C,                                        ///< The C key
+        D,                                        ///< The D key
+        E,                                        ///< The E key
+        F,                                        ///< The F key
+        G,                                        ///< The G key
+        H,                                        ///< The H key
+        I,                                        ///< The I key
+        J,                                        ///< The J key
+        K,                                        ///< The K key
+        L,                                        ///< The L key
+        M,                                        ///< The M key
+        N,                                        ///< The N key
+        O,                                        ///< The O key
+        P,                                        ///< The P key
+        Q,                                        ///< The Q key
+        R,                                        ///< The R key
+        S,                                        ///< The S key
+        T,                                        ///< The T key
+        U,                                        ///< The U key
+        V,                                        ///< The V key
+        W,                                        ///< The W key
+        X,                                        ///< The X key
+        Y,                                        ///< The Y key
+        Z,                                        ///< The Z key
+        Num0,                                     ///< The 0 key
+        Num1,                                     ///< The 1 key
+        Num2,                                     ///< The 2 key
+        Num3,                                     ///< The 3 key
+        Num4,                                     ///< The 4 key
+        Num5,                                     ///< The 5 key
+        Num6,                                     ///< The 6 key
+        Num7,                                     ///< The 7 key
+        Num8,                                     ///< The 8 key
+        Num9,                                     ///< The 9 key
+        Escape,                                   ///< The Escape key
+        LControl,                                 ///< The left Control key
+        LShift,                                   ///< The left Shift key
+        LAlt,                                     ///< The left Alt key
+        LSystem,                                  ///< The left OS specific key: window (Windows and Linux), apple (MacOS X), ...
+        RControl,                                 ///< The right Control key
+        RShift,                                   ///< The right Shift key
+        RAlt,                                     ///< The right Alt key
+        RSystem,                                  ///< The right OS specific key: window (Windows and Linux), apple (MacOS X), ...
+        Menu,                                     ///< The Menu key
+        LBracket,                                 ///< The [ key
+        RBracket,                                 ///< The ] key
+        SemiColon,                                ///< The ; key
+        Comma,                                    ///< The , key
+        Period,                                   ///< The . key
+        Quote,                                    ///< The ' key
+        Slash,                                    ///< The / key
+        BackSlash,                                ///< The \ key
+        Tilde,                                    ///< The ~ key
+        Equal,                                    ///< The = key
+        Dash,                                     ///< The - key
+        Space,                                    ///< The Space key
+        Return,                                   ///< The Return key
+        BackSpace,                                ///< The Backspace key
+        Tab,                                      ///< The Tabulation key
+        PageUp,                                   ///< The Page up key
+        PageDown,                                 ///< The Page down key
+        End,                                      ///< The End key
+        Home,                                     ///< The Home key
+        Insert,                                   ///< The Insert key
+        Delete,                                   ///< The Delete key
+        Add,                                      ///< The + key
+        Subtract,                                 ///< The - key
+        Multiply,                                 ///< The * key
+        Divide,                                   ///< The / key
+        Left,                                     ///< Left arrow
+        Right,                                    ///< Right arrow
+        Up,                                       ///< Up arrow
+        Down,                                     ///< Down arrow
+        Numpad0,                                  ///< The numpad 0 key
+        Numpad1,                                  ///< The numpad 1 key
+        Numpad2,                                  ///< The numpad 2 key
+        Numpad3,                                  ///< The numpad 3 key
+        Numpad4,                                  ///< The numpad 4 key
+        Numpad5,                                  ///< The numpad 5 key
+        Numpad6,                                  ///< The numpad 6 key
+        Numpad7,                                  ///< The numpad 7 key
+        Numpad8,                                  ///< The numpad 8 key
+        Numpad9,                                  ///< The numpad 9 key
+        F1,                                       ///< The F1 key
+        F2,                                       ///< The F2 key
+        F3,                                       ///< The F3 key
+        F4,                                       ///< The F4 key
+        F5,                                       ///< The F5 key
+        F6,                                       ///< The F6 key
+        F7,                                       ///< The F7 key
+        F8,                                       ///< The F8 key
+        F9,                                       ///< The F9 key
+        F10,                                      ///< The F10 key
+        F11,                                      ///< The F11 key
+        F12,                                      ///< The F12 key
+        F13,                                      ///< The F13 key
+        F14,                                      ///< The F14 key
+        F15,                                      ///< The F15 key
+        Pause,                                    ///< The Pause key
+
+        Count                                     ///< Keep last -- the total number of keyboard keys
     };
 
     ////////////////////////////////////////////////////////////

include/SFML/Window/Mouse.hpp

@@ -48,7 +48,7 @@ public:
     /// \brief Mouse buttons
     ///
     ////////////////////////////////////////////////////////////
-    enum Button
+    enum class Button : unsigned char
     {
         Left,       ///< The left mouse button
         Right,      ///< The right mouse button
@@ -56,14 +56,14 @@ public:
         XButton1,   ///< The first extra mouse button
         XButton2,   ///< The second extra mouse button
 
-        ButtonCount ///< Keep last -- the total number of mouse buttons
+        Count       ///< Keep last -- the total number of mouse buttons
     };
 
     ////////////////////////////////////////////////////////////
     /// \brief Mouse wheels
     ///
     ////////////////////////////////////////////////////////////
-    enum Wheel
+    enum class Wheel : unsigned char
     {
         VerticalWheel,  ///< The vertical mouse wheel
         HorizontalWheel ///< The horizontal mouse wheel

include/SFML/Window/Sensor.hpp

@@ -47,7 +47,7 @@ public:
     /// \brief Sensor type
     ///
     ////////////////////////////////////////////////////////////
-    enum Type
+    enum class Type : unsigned char
     {
         Accelerometer,    ///< Measures the raw acceleration (m/s^2)
         Gyroscope,        ///< Measures the raw rotation rates (degrees/s)

include/SFML/Window/Window.hpp

@@ -38,6 +38,7 @@
 #include <SFML/System/Vector2.hpp>
 #include <SFML/System/NonCopyable.hpp>
 #include <SFML/System/String.hpp>
+#include <memory>
 
 
 namespace sf
@@ -522,11 +523,11 @@ private:
     ////////////////////////////////////////////////////////////
     // Member data
     ////////////////////////////////////////////////////////////
-    priv::WindowImpl* m_impl;           ///< Platform-specific implementation of the window
-    priv::GlContext*  m_context;        ///< Platform-specific implementation of the OpenGL context
-    Clock             m_clock;          ///< Clock for measuring the elapsed time between frames
-    Time              m_frameTimeLimit; ///< Current framerate limit
-    Vector2u          m_size;           ///< Current size of the window
+    std::unique_ptr<priv::WindowImpl> m_impl;   ///< Platform-specific implementation of the window
+    std::unique_ptr<priv::GlContext> m_context; ///< Platform-specific implementation of the OpenGL context
+    Clock             m_clock;                  ///< Clock for measuring the elapsed time between frames
+    Time              m_frameTimeLimit;         ///< Current framerate limit
+    Vector2u          m_size;                   ///< Current size of the window
 };
 
 } // namespace sf

src/SFML/Audio/AlResource.cpp

@@ -27,20 +27,20 @@
 ////////////////////////////////////////////////////////////
 #include <SFML/Audio/AlResource.hpp>
 #include <SFML/Audio/AudioDevice.hpp>
-#include <SFML/System/Mutex.hpp>
-#include <SFML/System/Lock.hpp>
+#include <memory>
+#include <mutex>
 
 
 namespace
 {
     // OpenAL resources counter and its mutex
     unsigned int count = 0;
-    sf::Mutex mutex;
+    std::mutex mutex;
 
     // The audio device is instantiated on demand rather than at global startup,
     // which solves a lot of weird crashes and errors.
     // It is destroyed when it is no longer needed.
-    sf::priv::AudioDevice* globalDevice;
+    std::unique_ptr<sf::priv::AudioDevice> globalDevice;
 }
 
 
@@ -50,11 +50,11 @@ namespace sf
 AlResource::AlResource()
 {
     // Protect from concurrent access
-    Lock lock(mutex);
+    std::lock_guard<std::mutex> lock(mutex);
 
     // If this is the very first resource, trigger the global device initialization
     if (count == 0)
-        globalDevice = new priv::AudioDevice;
+        globalDevice = std::make_unique<priv::AudioDevice>();
 
     // Increment the resources counter
     count++;
@@ -65,14 +65,14 @@ AlResource::AlResource()
 AlResource::~AlResource()
 {
     // Protect from concurrent access
-    Lock lock(mutex);
+    std::lock_guard<std::mutex> lock(mutex);
 
     // Decrement the resources counter
     count--;
 
     // If there's no more resource alive, we can destroy the device
     if (count == 0)
-        delete globalDevice;
+        globalDevice.reset();
 }
 
 } // namespace sf

src/SFML/Audio/AudioDevice.cpp

@@ -29,13 +29,12 @@
 #include <SFML/Audio/ALCheck.hpp>
 #include <SFML/Audio/Listener.hpp>
 #include <SFML/System/Err.hpp>
-#include <memory>
 
 
 namespace
 {
-    ALCdevice*  audioDevice  = NULL;
-    ALCcontext* audioContext = NULL;
+    ALCdevice*  audioDevice  = nullptr;
+    ALCcontext* audioContext = nullptr;
 
     float        listenerVolume = 100.f;
     sf::Vector3f listenerPosition (0.f, 0.f, 0.f);
@@ -51,12 +50,12 @@ namespace priv
 AudioDevice::AudioDevice()
 {
     // Create the device
-    audioDevice = alcOpenDevice(NULL);
+    audioDevice = alcOpenDevice(nullptr);
 
     if (audioDevice)
     {
         // Create the context
-        audioContext = alcCreateContext(audioDevice, NULL);
+        audioContext = alcCreateContext(audioDevice, nullptr);
 
         if (audioContext)
         {
@@ -90,7 +89,7 @@ AudioDevice::AudioDevice()
 AudioDevice::~AudioDevice()
 {
     // Destroy the context
-    alcMakeContextCurrent(NULL);
+    alcMakeContextCurrent(nullptr);
     if (audioContext)
         alcDestroyContext(audioContext);
 
@@ -103,50 +102,67 @@ AudioDevice::~AudioDevice()
 ////////////////////////////////////////////////////////////
 bool AudioDevice::isExtensionSupported(const std::string& extension)
 {
-    // Create a temporary audio device in case none exists yet.
-    // This device will not be used in this function and merely
-    // makes sure there is a valid OpenAL device for extension
-    // queries if none has been created yet.
-    std::auto_ptr<AudioDevice> device;
-    if (!audioDevice)
-        device.reset(new AudioDevice);
+    auto checkExtension = [&extension]
+    {
 
-    if ((extension.length() > 2) && (extension.substr(0, 3) == "ALC"))
-        return alcIsExtensionPresent(audioDevice, extension.c_str()) != AL_FALSE;
-    else
-        return alIsExtensionPresent(extension.c_str()) != AL_FALSE;
+        if ((extension.length() > 2) && (extension.substr(0, 3) == "ALC"))
+            return alcIsExtensionPresent(audioDevice, extension.c_str()) != AL_FALSE;
+        else
+            return alIsExtensionPresent(extension.c_str()) != AL_FALSE;
+    };
+
+    if (!audioDevice)
+    {
+        // Create a temporary audio device in case none exists yet.
+        // This device will not be used in this function and merely
+        // makes sure there is a valid OpenAL device for extension
+        // queries if none has been created yet.
+        AudioDevice device;
+
+        return checkExtension();
+    }
+
+    return checkExtension();
 }
 
 
 ////////////////////////////////////////////////////////////
 int AudioDevice::getFormatFromChannelCount(unsigned int channelCount)
 {
-    // Create a temporary audio device in case none exists yet.
-    // This device will not be used in this function and merely
-    // makes sure there is a valid OpenAL device for format
-    // queries if none has been created yet.
-    std::auto_ptr<AudioDevice> device;
-    if (!audioDevice)
-        device.reset(new AudioDevice);
-
-    // Find the good format according to the number of channels
-    int format = 0;
-    switch (channelCount)
+    auto getFormat = [channelCount]
     {
-        case 1:  format = AL_FORMAT_MONO16;                    break;
-        case 2:  format = AL_FORMAT_STEREO16;                  break;
-        case 4:  format = alGetEnumValue("AL_FORMAT_QUAD16");  break;
-        case 6:  format = alGetEnumValue("AL_FORMAT_51CHN16"); break;
-        case 7:  format = alGetEnumValue("AL_FORMAT_61CHN16"); break;
-        case 8:  format = alGetEnumValue("AL_FORMAT_71CHN16"); break;
-        default: format = 0;                                   break;
+        // Find the good format according to the number of channels
+        int format = 0;
+        switch (channelCount)
+        {
+            case 1:  format = AL_FORMAT_MONO16;                    break;
+            case 2:  format = AL_FORMAT_STEREO16;                  break;
+            case 4:  format = alGetEnumValue("AL_FORMAT_QUAD16");  break;
+            case 6:  format = alGetEnumValue("AL_FORMAT_51CHN16"); break;
+            case 7:  format = alGetEnumValue("AL_FORMAT_61CHN16"); break;
+            case 8:  format = alGetEnumValue("AL_FORMAT_71CHN16"); break;
+            default: format = 0;                                   break;
+        }
+
+        // Fixes a bug on OS X
+        if (format == -1)
+            format = 0;
+
+        return format;
+    };
+
+    if (!audioDevice)
+    {
+        // Create a temporary audio device in case none exists yet.
+        // This device will not be used in this function and merely
+        // makes sure there is a valid OpenAL device for format
+        // queries if none has been created yet.
+        AudioDevice device;
+
+        return getFormat();
     }
 
-    // Fixes a bug on OS X
-    if (format == -1)
-        format = 0;
-
-    return format;
+    return getFormat();
 }
 
 

src/SFML/Audio/InputSoundFile.cpp

@@ -38,10 +38,8 @@ namespace sf
 {
 ////////////////////////////////////////////////////////////
 InputSoundFile::InputSoundFile() :
-m_reader      (NULL),
-m_stream      (NULL),
-m_streamOwned (false),
-m_sampleOffset   (0),
+m_stream      (nullptr),
+m_sampleOffset(0),
 m_sampleCount (0),
 m_channelCount(0),
 m_sampleRate  (0)
@@ -69,9 +67,7 @@ bool InputSoundFile::openFromFile(const std::string& filename)
         return false;
 
     // Wrap the file into a stream
-    FileInputStream* file = new FileInputStream;
-    m_stream = file;
-    m_streamOwned = true;
+    auto file = std::make_unique<FileInputStream>();
 
     // Open it
     if (!file->open(filename))
@@ -93,6 +89,9 @@ bool InputSoundFile::openFromFile(const std::string& filename)
     m_channelCount = info.channelCount;
     m_sampleRate = info.sampleRate;
 
+    m_ownedStream = std::move(file);
+    m_stream = m_ownedStream.get();
+
     return true;
 }
 
@@ -109,9 +108,7 @@ bool InputSoundFile::openFromMemory(const void* data, std::size_t sizeInBytes)
         return false;
 
     // Wrap the memory file into a stream
-    MemoryInputStream* memory = new MemoryInputStream;
-    m_stream = memory;
-    m_streamOwned = true;
+    auto memory = std::make_unique<MemoryInputStream>();
 
     // Open it
     memory->open(data, sizeInBytes);
@@ -129,6 +126,9 @@ bool InputSoundFile::openFromMemory(const void* data, std::size_t sizeInBytes)
     m_channelCount = info.channelCount;
     m_sampleRate = info.sampleRate;
 
+    m_ownedStream = std::move(memory);
+    m_stream = m_ownedStream.get();
+
     return true;
 }
 
@@ -146,7 +146,6 @@ bool InputSoundFile::openFromStream(InputStream& stream)
 
     // store the stream
     m_stream = &stream;
-    m_streamOwned = false;
 
     // Don't forget to reset the stream to its beginning before re-opening it
     if (stream.seek(0) != 0)
@@ -257,16 +256,11 @@ Uint64 InputSoundFile::read(Int16* samples, Uint64 maxCount)
 void InputSoundFile::close()
 {
     // Destroy the reader
-    delete m_reader;
-    m_reader = NULL;
+    m_reader.reset();
 
-    // Destroy the stream if we own it
-    if (m_streamOwned)
-    {
-        delete m_stream;
-        m_streamOwned = false;
-    }
-    m_stream = NULL;
+    m_ownedStream.reset();
+
+    m_stream = nullptr;
     m_sampleOffset = 0;
 
     // Reset the sound file attributes

src/SFML/Audio/Music.cpp

@@ -27,7 +27,6 @@
 ////////////////////////////////////////////////////////////
 #include <SFML/Audio/Music.hpp>
 #include <SFML/Audio/ALCheck.hpp>
-#include <SFML/System/Lock.hpp>
 #include <SFML/System/Err.hpp>
 #include <fstream>
 
@@ -111,11 +110,11 @@ Time Music::getDuration() const
 ////////////////////////////////////////////////////////////
 bool Music::onGetData(SoundStream::Chunk& data)
 {
-    Lock lock(m_mutex);
+    std::lock_guard<std::mutex> lock(m_mutex);
 
     // Fill the chunk parameters
-    data.samples     = &m_samples[0];
-    data.sampleCount = static_cast<std::size_t>(m_file.read(&m_samples[0], m_samples.size()));
+    data.samples     = m_samples.data();
+    data.sampleCount = static_cast<std::size_t>(m_file.read(m_samples.data(), m_samples.size()));
 
     // Check if we have stopped obtaining samples or reached the end of the audio file
     return (data.sampleCount != 0) && (m_file.getSampleOffset() < m_file.getSampleCount());
@@ -125,7 +124,7 @@ bool Music::onGetData(SoundStream::Chunk& data)
 ////////////////////////////////////////////////////////////
 void Music::onSeek(Time timeOffset)
 {
-    Lock lock(m_mutex);
+    std::lock_guard<std::mutex> lock(m_mutex);
 
     m_file.seek(timeOffset);
 }

src/SFML/Audio/OutputSoundFile.cpp

@@ -33,8 +33,7 @@
 namespace sf
 {
 ////////////////////////////////////////////////////////////
-OutputSoundFile::OutputSoundFile() :
-m_writer(NULL)
+OutputSoundFile::OutputSoundFile()
 {
 }
 
@@ -80,9 +79,8 @@ void OutputSoundFile::write(const Int16* samples, Uint64 count)
 ////////////////////////////////////////////////////////////
 void OutputSoundFile::close()
 {
-    // Destroy the reader
-    delete m_writer;
-    m_writer = NULL;
+    // Destroy the writer
+    m_writer.reset();
 }
 
 } // namespace sf

src/SFML/Audio/Sound.cpp

@@ -34,14 +34,14 @@ namespace sf
 {
 ////////////////////////////////////////////////////////////
 Sound::Sound() :
-m_buffer(NULL)
+m_buffer(nullptr)
 {
 }
 
 
 ////////////////////////////////////////////////////////////
 Sound::Sound(const SoundBuffer& buffer) :
-m_buffer(NULL)
+m_buffer(nullptr)
 {
     setBuffer(buffer);
 }
@@ -50,7 +50,7 @@ m_buffer(NULL)
 ////////////////////////////////////////////////////////////
 Sound::Sound(const Sound& copy) :
 SoundSource(copy),
-m_buffer   (NULL)
+m_buffer   (nullptr)
 {
     if (copy.m_buffer)
         setBuffer(*copy.m_buffer);
@@ -168,7 +168,7 @@ Sound& Sound::operator =(const Sound& right)
     {
         stop();
         m_buffer->detachSound(this);
-        m_buffer = NULL;
+        m_buffer = nullptr;
     }
 
     // Copy the remaining sound attributes
@@ -191,7 +191,7 @@ void Sound::resetBuffer()
     {
         alCheck(alSourcei(m_source, AL_BUFFER, 0));
         m_buffer->detachSound(this);
-        m_buffer = NULL;
+        m_buffer = nullptr;
     }
 }
 

src/SFML/Audio/SoundBuffer.cpp

@@ -72,8 +72,8 @@ SoundBuffer::~SoundBuffer()
     sounds.swap(m_sounds);
 
     // Detach the buffer from the sounds that use it (to avoid OpenAL errors)
-    for (SoundList::const_iterator it = sounds.begin(); it != sounds.end(); ++it)
-        (*it)->resetBuffer();
+    for (const auto& sound : sounds)
+        sound->resetBuffer();
 
     // Destroy the buffer
     if (m_buffer)
@@ -148,7 +148,7 @@ bool SoundBuffer::saveToFile(const std::string& filename) const
     if (file.openFromFile(filename, getSampleRate(), getChannelCount()))
     {
         // Write the samples to the opened file
-        file.write(&m_samples[0], m_samples.size());
+        file.write(m_samples.data(), m_samples.size());
 
         return true;
     }
@@ -162,7 +162,7 @@ bool SoundBuffer::saveToFile(const std::string& filename) const
 ////////////////////////////////////////////////////////////
 const Int16* SoundBuffer::getSamples() const
 {
-    return m_samples.empty() ? NULL : &m_samples[0];
+    return m_samples.empty() ? nullptr : m_samples.data();
 }
 
 
@@ -224,7 +224,7 @@ bool SoundBuffer::initialize(InputSoundFile& file)
 
     // Read the samples from the provided file
     m_samples.resize(static_cast<std::size_t>(sampleCount));
-    if (file.read(&m_samples[0], sampleCount) == sampleCount)
+    if (file.read(m_samples.data(), sampleCount) == sampleCount)
     {
         // Update the internal buffer with the new samples
         return update(channelCount, sampleRate);
@@ -257,19 +257,19 @@ bool SoundBuffer::update(unsigned int channelCount, unsigned int sampleRate)
     SoundList sounds(m_sounds);
 
     // Detach the buffer from the sounds that use it (to avoid OpenAL errors)
-    for (SoundList::const_iterator it = sounds.begin(); it != sounds.end(); ++it)
-        (*it)->resetBuffer();
+    for (const auto& sound : sounds)
+        sound->resetBuffer();
 
     // Fill the buffer
     ALsizei size = static_cast<ALsizei>(m_samples.size()) * sizeof(Int16);
-    alCheck(alBufferData(m_buffer, format, &m_samples[0], size, sampleRate));
+    alCheck(alBufferData(m_buffer, format, m_samples.data(), size, sampleRate));
 
     // Compute the duration
     m_duration = seconds(static_cast<float>(m_samples.size()) / sampleRate / channelCount);
 
     // Now reattach the buffer to the sounds that use it
-    for (SoundList::const_iterator it = sounds.begin(); it != sounds.end(); ++it)
-        (*it)->setBuffer(*this);
+    for (const auto& sound : sounds)
+        sound->setBuffer(*this);
 
     return true;
 }

src/SFML/Audio/SoundBufferRecorder.cpp

@@ -63,7 +63,7 @@ bool SoundBufferRecorder::onProcessSamples(const Int16* samples, std::size_t sam
 void SoundBufferRecorder::onStop()
 {
     if (!m_samples.empty())
-        m_buffer.loadFromSamples(&m_samples[0], m_samples.size(), getChannelCount(), getSampleRate());
+        m_buffer.loadFromSamples(m_samples.data(), m_samples.size(), getChannelCount(), getSampleRate());
 }
 
 

src/SFML/Audio/SoundFileFactory.cpp

@@ -35,6 +35,7 @@
 #include <SFML/System/FileInputStream.hpp>
 #include <SFML/System/MemoryInputStream.hpp>
 #include <SFML/System/Err.hpp>
+#include <mutex>
 
 
 namespace
@@ -42,8 +43,8 @@ namespace
     // Register all the built-in readers and writers if not already done
     void ensureDefaultReadersWritersRegistered()
     {
-        static bool registered = false;
-        if (!registered)
+        static std::once_flag registered;
+        std::call_once(registered, []
         {
             sf::SoundFileFactory::registerReader<sf::priv::SoundFileReaderFlac>();
             sf::SoundFileFactory::registerWriter<sf::priv::SoundFileWriterFlac>();
@@ -51,8 +52,7 @@ namespace
             sf::SoundFileFactory::registerWriter<sf::priv::SoundFileWriterOgg>();
             sf::SoundFileFactory::registerReader<sf::priv::SoundFileReaderWav>();
             sf::SoundFileFactory::registerWriter<sf::priv::SoundFileWriterWav>();
-            registered = true;
-        }
+        });
     }
 }
 
@@ -63,7 +63,7 @@ SoundFileFactory::WriterFactoryArray SoundFileFactory::s_writers;
 
 
 ////////////////////////////////////////////////////////////
-SoundFileReader* SoundFileFactory::createReaderFromFilename(const std::string& filename)
+std::unique_ptr<SoundFileReader> SoundFileFactory::createReaderFromFilename(const std::string& filename)
 {
     // Register the built-in readers/writers on first call
     ensureDefaultReadersWritersRegistered();
@@ -72,25 +72,25 @@ SoundFileReader* SoundFileFactory::createReaderFromFilename(const std::string& f
     FileInputStream stream;
     if (!stream.open(filename)) {
         err() << "Failed to open sound file \"" << filename << "\" (couldn't open stream)" << std::endl;
-        return NULL;
+        return nullptr;
     }
 
     // Test the filename in all the registered factories
-    for (ReaderFactoryArray::const_iterator it = s_readers.begin(); it != s_readers.end(); ++it)
+    for (const auto& reader : s_readers)
     {
         stream.seek(0);
-        if (it->check(stream))
-            return it->create();
+        if (reader.check(stream))
+            return reader.create();
     }
 
     // No suitable reader found
     err() << "Failed to open sound file \"" << filename << "\" (format not supported)" << std::endl;
-    return NULL;
+    return nullptr;
 }
 
 
 ////////////////////////////////////////////////////////////
-SoundFileReader* SoundFileFactory::createReaderFromMemory(const void* data, std::size_t sizeInBytes)
+std::unique_ptr<SoundFileReader> SoundFileFactory::createReaderFromMemory(const void* data, std::size_t sizeInBytes)
 {
     // Register the built-in readers/writers on first call
     ensureDefaultReadersWritersRegistered();
@@ -100,55 +100,55 @@ SoundFileReader* SoundFileFactory::createReaderFromMemory(const void* data, std:
     stream.open(data, sizeInBytes);
 
     // Test the stream for all the registered factories
-    for (ReaderFactoryArray::const_iterator it = s_readers.begin(); it != s_readers.end(); ++it)
+    for (const auto& reader : s_readers)
     {
         stream.seek(0);
-        if (it->check(stream))
-            return it->create();
+        if (reader.check(stream))
+            return reader.create();
     }
 
     // No suitable reader found
     err() << "Failed to open sound file from memory (format not supported)" << std::endl;
-    return NULL;
+    return nullptr;
 }
 
 
 ////////////////////////////////////////////////////////////
-SoundFileReader* SoundFileFactory::createReaderFromStream(InputStream& stream)
+std::unique_ptr<SoundFileReader> SoundFileFactory::createReaderFromStream(InputStream& stream)
 {
     // Register the built-in readers/writers on first call
     ensureDefaultReadersWritersRegistered();
 
     // Test the stream for all the registered factories
-    for (ReaderFactoryArray::const_iterator it = s_readers.begin(); it != s_readers.end(); ++it)
+    for (const auto& reader : s_readers)
     {
         stream.seek(0);
-        if (it->check(stream))
-            return it->create();
+        if (reader.check(stream))
+            return reader.create();
     }
 
     // No suitable reader found
     err() << "Failed to open sound file from stream (format not supported)" << std::endl;
-    return NULL;
+    return nullptr;
 }
 
 
 ////////////////////////////////////////////////////////////
-SoundFileWriter* SoundFileFactory::createWriterFromFilename(const std::string& filename)
+std::unique_ptr<SoundFileWriter> SoundFileFactory::createWriterFromFilename(const std::string& filename)
 {
     // Register the built-in readers/writers on first call
     ensureDefaultReadersWritersRegistered();
 
     // Test the filename in all the registered factories
-    for (WriterFactoryArray::const_iterator it = s_writers.begin(); it != s_writers.end(); ++it)
+    for (const auto& writer : s_writers)
     {
-        if (it->check(filename))
-            return it->create();
+        if (writer.check(filename))
+            return writer.create();
     }
 
     // No suitable writer found
     err() << "Failed to open sound file \"" << filename << "\" (format not supported)" << std::endl;
-    return NULL;
+    return nullptr;
 }
 
 } // namespace sf

src/SFML/Audio/SoundFileReaderFlac.cpp

@@ -191,7 +191,7 @@ bool SoundFileReaderFlac::check(InputStream& stream)
     ClientData data;
     data.stream = &stream;
     data.error = false;
-    FLAC__stream_decoder_init_stream(decoder, &streamRead, &streamSeek, &streamTell, &streamLength, &streamEof, &streamWrite, NULL, &streamError, &data);
+    FLAC__stream_decoder_init_stream(decoder, &streamRead, &streamSeek, &streamTell, &streamLength, &streamEof, &streamWrite, nullptr, &streamError, &data);
 
     // Read the header
     bool valid = FLAC__stream_decoder_process_until_end_of_metadata(decoder) != 0;
@@ -206,7 +206,7 @@ bool SoundFileReaderFlac::check(InputStream& stream)
 
 ////////////////////////////////////////////////////////////
 SoundFileReaderFlac::SoundFileReaderFlac() :
-m_decoder(NULL),
+m_decoder(nullptr),
 m_clientData()
 {
 }
@@ -255,7 +255,7 @@ void SoundFileReaderFlac::seek(Uint64 sampleOffset)
     assert(m_decoder);
 
     // Reset the callback data (the "write" callback will be called)
-    m_clientData.buffer = NULL;
+    m_clientData.buffer = nullptr;
     m_clientData.remaining = 0;
     m_clientData.leftovers.clear();
 
@@ -331,7 +331,7 @@ void SoundFileReaderFlac::close()
     {
         FLAC__stream_decoder_finish(m_decoder);
         FLAC__stream_decoder_delete(m_decoder);
-        m_decoder = NULL;
+        m_decoder = nullptr;
     }
 }
 

src/SFML/Audio/SoundFileReaderFlac.hpp

@@ -68,7 +68,7 @@ public:
     /// \brief Default constructor
     ///
     ////////////////////////////////////////////////////////////
-    ~SoundFileReaderFlac();
+    ~SoundFileReaderFlac() override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Open a sound file for reading
@@ -77,7 +77,7 @@ public:
     /// \param info   Structure to fill with the attributes of the loaded sound
     ///
     ////////////////////////////////////////////////////////////
-    virtual bool open(sf::InputStream& stream, Info& info);
+    bool open(sf::InputStream& stream, Info& info) override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Change the current read position to the given sample offset
@@ -91,7 +91,7 @@ public:
     /// \param sampleOffset Index of the sample to jump to, relative to the beginning
     ///
     ////////////////////////////////////////////////////////////
-    virtual void seek(Uint64 sampleOffset);
+    void seek(Uint64 sampleOffset) override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Read audio samples from the open file
@@ -102,7 +102,7 @@ public:
     /// \return Number of samples actually read (may be less than \a maxCount)
     ///
     ////////////////////////////////////////////////////////////
-    virtual Uint64 read(Int16* samples, Uint64 maxCount);
+    Uint64 read(Int16* samples, Uint64 maxCount) override;
 
 public:
 

src/SFML/Audio/SoundFileReaderOgg.cpp

@@ -63,7 +63,7 @@ namespace
         return static_cast<long>(stream->tell());
     }
 
-    static ov_callbacks callbacks = {&read, &seek, NULL, &tell};
+    static ov_callbacks callbacks = {&read, &seek, nullptr, &tell};
 }
 
 namespace sf
@@ -74,7 +74,7 @@ namespace priv
 bool SoundFileReaderOgg::check(InputStream& stream)
 {
     OggVorbis_File file;
-    if (ov_test_callbacks(&stream, &file, NULL, 0, callbacks) == 0)
+    if (ov_test_callbacks(&stream, &file, nullptr, 0, callbacks) == 0)
     {
         ov_clear(&file);
         return true;
@@ -91,7 +91,7 @@ SoundFileReaderOgg::SoundFileReaderOgg() :
 m_vorbis      (),
 m_channelCount(0)
 {
-    m_vorbis.datasource = NULL;
+    m_vorbis.datasource = nullptr;
 }
 
 
@@ -106,7 +106,7 @@ SoundFileReaderOgg::~SoundFileReaderOgg()
 bool SoundFileReaderOgg::open(InputStream& stream, Info& info)
 {
     // Open the Vorbis stream
-    int status = ov_open_callbacks(&stream, &m_vorbis, NULL, 0, callbacks);
+    int status = ov_open_callbacks(&stream, &m_vorbis, nullptr, 0, callbacks);
     if (status < 0)
     {
         err() << "Failed to open Vorbis file for reading" << std::endl;
@@ -145,7 +145,7 @@ Uint64 SoundFileReaderOgg::read(Int16* samples, Uint64 maxCount)
     while (count < maxCount)
     {
         int bytesToRead = static_cast<int>(maxCount - count) * sizeof(Int16);
-        long bytesRead = ov_read(&m_vorbis, reinterpret_cast<char*>(samples), bytesToRead, 0, 2, 1, NULL);
+        long bytesRead = ov_read(&m_vorbis, reinterpret_cast<char*>(samples), bytesToRead, 0, 2, 1, nullptr);
         if (bytesRead > 0)
         {
             long samplesRead = bytesRead / sizeof(Int16);
@@ -169,7 +169,7 @@ void SoundFileReaderOgg::close()
     if (m_vorbis.datasource)
     {
         ov_clear(&m_vorbis);
-        m_vorbis.datasource = NULL;
+        m_vorbis.datasource = nullptr;
         m_channelCount = 0;
     }
 }

src/SFML/Audio/SoundFileReaderOgg.hpp

@@ -66,7 +66,7 @@ public:
     /// \brief Destructor
     ///
     ////////////////////////////////////////////////////////////
-    ~SoundFileReaderOgg();
+    ~SoundFileReaderOgg() override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Open a sound file for reading
@@ -77,7 +77,7 @@ public:
     /// \return True if the file was successfully opened
     ///
     ////////////////////////////////////////////////////////////
-    virtual bool open(InputStream& stream, Info& info);
+    bool open(InputStream& stream, Info& info) override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Change the current read position to the given sample offset
@@ -91,7 +91,7 @@ public:
     /// \param sampleOffset Index of the sample to jump to, relative to the beginning
     ///
     ////////////////////////////////////////////////////////////
-    virtual void seek(Uint64 sampleOffset);
+    void seek(Uint64 sampleOffset) override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Read audio samples from the open file
@@ -102,7 +102,7 @@ public:
     /// \return Number of samples actually read (may be less than \a maxCount)
     ///
     ////////////////////////////////////////////////////////////
-    virtual Uint64 read(Int16* samples, Uint64 maxCount);
+    Uint64 read(Int16* samples, Uint64 maxCount) override;
 
 private:
 

src/SFML/Audio/SoundFileReaderWav.cpp

@@ -108,7 +108,7 @@ bool SoundFileReaderWav::check(InputStream& stream)
 
 ////////////////////////////////////////////////////////////
 SoundFileReaderWav::SoundFileReaderWav() :
-m_stream        (NULL),
+m_stream        (nullptr),
 m_bytesPerSample(0),
 m_dataStart     (0),
 m_dataEnd       (0)

src/SFML/Audio/SoundFileReaderWav.hpp

@@ -69,7 +69,7 @@ public:
     /// \param info   Structure to fill with the attributes of the loaded sound
     ///
     ////////////////////////////////////////////////////////////
-    virtual bool open(sf::InputStream& stream, Info& info);
+    bool open(sf::InputStream& stream, Info& info) override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Change the current read position to the given sample offset
@@ -83,7 +83,7 @@ public:
     /// \param sampleOffset Index of the sample to jump to, relative to the beginning
     ///
     ////////////////////////////////////////////////////////////
-    virtual void seek(Uint64 sampleOffset);
+    void seek(Uint64 sampleOffset) override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Read audio samples from the open file
@@ -94,7 +94,7 @@ public:
     /// \return Number of samples actually read (may be less than \a maxCount)
     ///
     ////////////////////////////////////////////////////////////
-    virtual Uint64 read(Int16* samples, Uint64 maxCount);
+    Uint64 read(Int16* samples, Uint64 maxCount) override;
 
 private:
 

src/SFML/Audio/SoundFileWriterFlac.cpp

@@ -48,7 +48,7 @@ bool SoundFileWriterFlac::check(const std::string& filename)
 
 ////////////////////////////////////////////////////////////
 SoundFileWriterFlac::SoundFileWriterFlac() :
-m_encoder     (NULL),
+m_encoder     (nullptr),
 m_channelCount(0),
 m_samples32   ()
 {
@@ -79,7 +79,7 @@ bool SoundFileWriterFlac::open(const std::string& filename, unsigned int sampleR
     FLAC__stream_encoder_set_sample_rate(m_encoder, sampleRate);
 
     // Initialize the output stream
-    if (FLAC__stream_encoder_init_file(m_encoder, filename.c_str(), NULL, NULL) != FLAC__STREAM_ENCODER_INIT_STATUS_OK)
+    if (FLAC__stream_encoder_init_file(m_encoder, filename.c_str(), nullptr, nullptr) != FLAC__STREAM_ENCODER_INIT_STATUS_OK)
     {
         err() << "Failed to write flac file \"" << filename << "\" (failed to open the file)" << std::endl;
         close();
@@ -105,7 +105,7 @@ void SoundFileWriterFlac::write(const Int16* samples, Uint64 count)
         m_samples32.assign(samples, samples + frames * m_channelCount);
 
         // Write them to the FLAC stream
-        FLAC__stream_encoder_process_interleaved(m_encoder, &m_samples32[0], frames);
+        FLAC__stream_encoder_process_interleaved(m_encoder, m_samples32.data(), frames);
 
         // Next chunk
         count -= m_samples32.size();
@@ -124,7 +124,7 @@ void SoundFileWriterFlac::close()
 
         // Destroy the encoder
         FLAC__stream_encoder_delete(m_encoder);
-        m_encoder = NULL;
+        m_encoder = nullptr;
     }
 }
 

src/SFML/Audio/SoundFileWriterFlac.hpp

@@ -67,7 +67,7 @@ public:
     /// \brief Destructor
     ///
     ////////////////////////////////////////////////////////////
-    ~SoundFileWriterFlac();
+    ~SoundFileWriterFlac() override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Open a sound file for writing
@@ -79,7 +79,7 @@ public:
     /// \return True if the file was successfully opened
     ///
     ////////////////////////////////////////////////////////////
-    virtual bool open(const std::string& filename, unsigned int sampleRate, unsigned int channelCount);
+    bool open(const std::string& filename, unsigned int sampleRate, unsigned int channelCount) override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Write audio samples to the open file
@@ -88,7 +88,7 @@ public:
     /// \param count   Number of samples to write
     ///
     ////////////////////////////////////////////////////////////
-    virtual void write(const Int16* samples, Uint64 count);
+    void write(const Int16* samples, Uint64 count) override;
 
 private:
 

src/SFML/Audio/SoundFileWriterOgg.cpp

@@ -131,7 +131,7 @@ bool SoundFileWriterOgg::open(const std::string& filename, unsigned int sampleRa
 void SoundFileWriterOgg::write(const Int16* samples, Uint64 count)
 {
     // Vorbis has issues with buffers that are too large, so we ask for 64K
-    static const int bufferSize = 65536;
+    constexpr auto bufferSize = 65536;
 
     // A frame contains a sample from each channel
     int frameCount = static_cast<int>(count / m_channelCount);
@@ -167,7 +167,7 @@ void SoundFileWriterOgg::flushBlocks()
     while (vorbis_analysis_blockout(&m_state, &block) == 1)
     {
         // Let the automatic bitrate management do its job
-        vorbis_analysis(&block, NULL);
+        vorbis_analysis(&block, nullptr);
         vorbis_bitrate_addblock(&block);
 
         // Get new packets from the bitrate management engine

src/SFML/Audio/SoundFileWriterOgg.hpp

@@ -67,7 +67,7 @@ public:
     /// \brief Destructor
     ///
     ////////////////////////////////////////////////////////////
-    ~SoundFileWriterOgg();
+    ~SoundFileWriterOgg() override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Open a sound file for writing
@@ -79,7 +79,7 @@ public:
     /// \return True if the file was successfully opened
     ///
     ////////////////////////////////////////////////////////////
-    virtual bool open(const std::string& filename, unsigned int sampleRate, unsigned int channelCount);
+    bool open(const std::string& filename, unsigned int sampleRate, unsigned int channelCount) override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Write audio samples to the open file
@@ -88,7 +88,7 @@ public:
     /// \param count   Number of samples to write
     ///
     ////////////////////////////////////////////////////////////
-    virtual void write(const Int16* samples, Uint64 count);
+    void write(const Int16* samples, Uint64 count) override;
 
 private:
 

src/SFML/Audio/SoundFileWriterWav.hpp

@@ -67,7 +67,7 @@ public:
     /// \brief Destructor
     ///
     ////////////////////////////////////////////////////////////
-    ~SoundFileWriterWav();
+    ~SoundFileWriterWav() override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Open a sound file for writing
@@ -79,7 +79,7 @@ public:
     /// \return True if the file was successfully opened
     ///
     ////////////////////////////////////////////////////////////
-    virtual bool open(const std::string& filename, unsigned int sampleRate, unsigned int channelCount);
+    bool open(const std::string& filename, unsigned int sampleRate, unsigned int channelCount) override;
 
     ////////////////////////////////////////////////////////////
     /// \brief Write audio samples to the open file
@@ -88,7 +88,7 @@ public:
     /// \param count   Number of samples to write
     ///
     ////////////////////////////////////////////////////////////
-    virtual void write(const Int16* samples, Uint64 count);
+    void write(const Int16* samples, Uint64 count) override;
 
 private:
 

src/SFML/Audio/SoundRecorder.cpp

@@ -40,14 +40,13 @@
 
 namespace
 {
-    ALCdevice* captureDevice = NULL;
+    ALCdevice* captureDevice = nullptr;
 }
 
 namespace sf
 {
 ////////////////////////////////////////////////////////////
 SoundRecorder::SoundRecorder() :
-m_thread            (&SoundRecorder::record, this),
 m_sampleRate        (0),
 m_processingInterval(milliseconds(100)),
 m_isCapturing       (false),
@@ -112,7 +111,10 @@ bool SoundRecorder::start(unsigned int sampleRate)
 
         // Start the capture in a new thread, to avoid blocking the main thread
         m_isCapturing = true;
-        m_thread.launch();
+        m_thread = std::thread([this]
+        {
+            record();
+        });
 
         return true;
     }
@@ -128,7 +130,9 @@ void SoundRecorder::stop()
     if (m_isCapturing)
     {
         m_isCapturing = false;
-        m_thread.wait();
+
+        if (m_thread.joinable())
+            m_thread.join();
 
         // Notify derived class
         onStop();
@@ -148,7 +152,7 @@ std::vector<std::string> SoundRecorder::getAvailableDevices()
 {
     std::vector<std::string> deviceNameList;
 
-    const ALchar* deviceList = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER);
+    const ALchar* deviceList = alcGetString(nullptr, ALC_CAPTURE_DEVICE_SPECIFIER);
     if (deviceList)
     {
         while (*deviceList)
@@ -165,7 +169,7 @@ std::vector<std::string> SoundRecorder::getAvailableDevices()
 ////////////////////////////////////////////////////////////
 std::string SoundRecorder::getDefaultDevice()
 {
-    return alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
+    return alcGetString(nullptr, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
 }
 
 
@@ -182,7 +186,9 @@ bool SoundRecorder::setDevice(const std::string& name)
     {
         // Stop the capturing thread
         m_isCapturing = false;
-        m_thread.wait();
+
+        if (m_thread.joinable())
+            m_thread.join();
 
         // Determine the recording format
         ALCenum format = (m_channelCount == 1) ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16;
@@ -203,7 +209,10 @@ bool SoundRecorder::setDevice(const std::string& name)
 
         // Start the capture in a new thread, to avoid blocking the main thread
         m_isCapturing = true;
-        m_thread.launch();
+        m_thread = std::thread([this]
+        {
+            record();
+        });
     }
 
     return true;
@@ -301,10 +310,10 @@ void SoundRecorder::processCapturedSamples()
     {
         // Get the recorded samples
         m_samples.resize(samplesAvailable * getChannelCount());
-        alcCaptureSamples(captureDevice, &m_samples[0], samplesAvailable);
+        alcCaptureSamples(captureDevice, m_samples.data(), samplesAvailable);
 
         // Forward them to the derived class
-        if (!onProcessSamples(&m_samples[0], m_samples.size()))
+        if (!onProcessSamples(m_samples.data(), m_samples.size()))
         {
             // The user wants to stop the capture
             m_isCapturing = false;
@@ -324,7 +333,7 @@ void SoundRecorder::cleanup()
 
     // Close the device
     alcCaptureCloseDevice(captureDevice);
-    captureDevice = NULL;
+    captureDevice = nullptr;
 }
 
 } // namespace sf

src/SFML/Audio/SoundSource.cpp

@@ -198,12 +198,12 @@ SoundSource::Status SoundSource::getStatus() const
     switch (status)
     {
         case AL_INITIAL:
-        case AL_STOPPED: return Stopped;
-        case AL_PAUSED:  return Paused;
-        case AL_PLAYING: return Playing;
+        case AL_STOPPED: return Status::Stopped;
+        case AL_PAUSED:  return Status::Paused;
+        case AL_PLAYING: return Status::Playing;
     }
 
-    return Stopped;
+    return Status::Stopped;
 }
 
 } // namespace sf

src/SFML/Audio/SoundStream.cpp

@@ -30,7 +30,6 @@
 #include <SFML/Audio/ALCheck.hpp>
 #include <SFML/System/Sleep.hpp>
 #include <SFML/System/Err.hpp>
-#include <SFML/System/Lock.hpp>
 
 #ifdef _MSC_VER
     #pragma warning(disable: 4355) // 'this' used in base member initializer list
@@ -41,9 +40,8 @@ namespace sf
 {
 ////////////////////////////////////////////////////////////
 SoundStream::SoundStream() :
-m_thread          (&SoundStream::streamData, this),
 m_threadMutex     (),
-m_threadStartState(Stopped),
+m_threadStartState(Status::Stopped),
 m_isStreaming     (false),
 m_buffers         (),
 m_channelCount    (0),
@@ -64,12 +62,13 @@ SoundStream::~SoundStream()
 
     // Request the thread to terminate
     {
-        Lock lock(m_threadMutex);
+        std::lock_guard<std::mutex> lock(m_threadMutex);
         m_isStreaming = false;
     }
 
     // Wait for the thread to terminate
-    m_thread.wait();
+    if (m_thread.joinable())
+        m_thread.join();
 }
 
 
@@ -105,25 +104,25 @@ void SoundStream::play()
     }
 
     bool isStreaming = false;
-    Status threadStartState = Stopped;
+    Status threadStartState = Status::Stopped;
 
     {
-        Lock lock(m_threadMutex);
+        std::lock_guard<std::mutex> lock(m_threadMutex);
 
         isStreaming = m_isStreaming;
         threadStartState = m_threadStartState;
     }
 
 
-    if (isStreaming && (threadStartState == Paused))
+    if (isStreaming && (threadStartState == Status::Paused))
     {
         // If the sound is paused, resume it
-        Lock lock(m_threadMutex);
-        m_threadStartState = Playing;
+        std::lock_guard<std::mutex> lock(m_threadMutex);
+        m_threadStartState = Status::Playing;
         alCheck(alSourcePlay(m_source));
         return;
     }
-    else if (isStreaming && (threadStartState == Playing))
+    else if (isStreaming && (threadStartState == Status::Playing))
     {
         // If the sound is playing, stop it and continue as if it was stopped
         stop();
@@ -131,8 +130,11 @@ void SoundStream::play()
 
     // Start updating the stream in a separate thread to avoid blocking the application
     m_isStreaming = true;
-    m_threadStartState = Playing;
-    m_thread.launch();
+    m_threadStartState = Status::Playing;
+    m_thread = std::thread([this]
+    {
+        streamData();
+    });
 }
 
 
@@ -141,12 +143,12 @@ void SoundStream::pause()
 {
     // Handle pause() being called before the thread has started
     {
-        Lock lock(m_threadMutex);
+        std::lock_guard<std::mutex> lock(m_threadMutex);
 
         if (!m_isStreaming)
             return;
 
-        m_threadStartState = Paused;
+        m_threadStartState = Status::Paused;
     }
 
     alCheck(alSourcePause(m_source));
@@ -158,12 +160,13 @@ void SoundStream::stop()
 {
     // Request the thread to terminate
     {
-        Lock lock(m_threadMutex);
+        std::lock_guard<std::mutex> lock(m_threadMutex);
         m_isStreaming = false;
     }
 
     // Wait for the thread to terminate
-    m_thread.wait();
+    if (m_thread.joinable())
+        m_thread.join();
 
     // Move to the beginning
     onSeek(Time::Zero);
@@ -193,9 +196,9 @@ SoundStream::Status SoundStream::getStatus() const
     Status status = SoundSource::getStatus();
 
     // To compensate for the lag between play() and alSourceplay()
-    if (status == Stopped)
+    if (status == Status::Stopped)
     {
-        Lock lock(m_threadMutex);
+        std::lock_guard<std::mutex> lock(m_threadMutex);
 
         if (m_isStreaming)
             status = m_threadStartState;
@@ -220,12 +223,15 @@ void SoundStream::setPlayingOffset(Time timeOffset)
     // Restart streaming
     m_samplesProcessed = static_cast<Uint64>(timeOffset.asSeconds() * m_sampleRate * m_channelCount);
 
-    if (oldStatus == Stopped)
+    if (oldStatus == Status::Stopped)
         return;
 
     m_isStreaming = true;
     m_threadStartState = oldStatus;
-    m_thread.launch();
+    m_thread = std::thread([this]
+    {
+        streamData();
+    });
 }
 
 
@@ -266,10 +272,10 @@ void SoundStream::streamData()
     bool requestStop = false;
 
     {
-        Lock lock(m_threadMutex);
+        std::lock_guard<std::mutex> lock(m_threadMutex);
 
         // Check if the thread was launched Stopped
-        if (m_threadStartState == Stopped)
+        if (m_threadStartState == Status::Stopped)
         {
             m_isStreaming = false;
             return;
@@ -278,8 +284,8 @@ void SoundStream::streamData()
 
     // Create the buffers
     alCheck(alGenBuffers(BufferCount, m_buffers));
-    for (int i = 0; i < BufferCount; ++i)
-        m_endBuffers[i] = false;
+    for (auto& buffer : m_endBuffers)
+        buffer = false;
 
     // Fill the queue
     requestStop = fillQueue();
@@ -288,23 +294,23 @@ void SoundStream::streamData()
     alCheck(alSourcePlay(m_source));
 
     {
-        Lock lock(m_threadMutex);
+        std::lock_guard<std::mutex> lock(m_threadMutex);
 
         // Check if the thread was launched Paused
-        if (m_threadStartState == Paused)
+        if (m_threadStartState == Status::Paused)
             alCheck(alSourcePause(m_source));
     }
 
     for (;;)
     {
         {
-            Lock lock(m_threadMutex);
+            std::lock_guard<std::mutex> lock(m_threadMutex);
             if (!m_isStreaming)
                 break;
         }
 
         // The stream has been interrupted!
-        if (SoundSource::getStatus() == Stopped)
+        if (SoundSource::getStatus() == Status::Stopped)
         {
             if (!requestStop)
             {
@@ -314,7 +320,7 @@ void SoundStream::streamData()
             else
             {
                 // End streaming
-                Lock lock(m_threadMutex);
+                std::lock_guard<std::mutex> lock(m_threadMutex);
                 m_isStreaming = false;
             }
         }
@@ -331,7 +337,7 @@ void SoundStream::streamData()
 
             // Find its number
             unsigned int bufferNum = 0;
-            for (int i = 0; i < BufferCount; ++i)
+            for (auto i = 0; i < BufferCount; ++i)
                 if (m_buffers[i] == buffer)
                 {
                     bufferNum = i;
@@ -358,7 +364,7 @@ void SoundStream::streamData()
                           << "and initialize() has been called correctly" << std::endl;
 
                     // Abort streaming (exit main loop)
-                    Lock lock(m_threadMutex);
+                    std::lock_guard<std::mutex> lock(m_threadMutex);
                     m_isStreaming = false;
                     requestStop = true;
                     break;
@@ -378,7 +384,7 @@ void SoundStream::streamData()
         }
 
         // Leave some time for the other threads if the stream is still playing
-        if (SoundSource::getStatus() != Stopped)
+        if (SoundSource::getStatus() != Status::Stopped)
             sleep(milliseconds(10));
     }
 
@@ -400,7 +406,7 @@ bool SoundStream::fillAndPushBuffer(unsigned int bufferNum, bool immediateLoop)
     bool requestStop = false;
 
     // Acquire audio data, also address EOF and error cases if they occur
-    Chunk data = {NULL, 0};
+    Chunk data = {nullptr, 0};
     for (Uint32 retryCount = 0; !onGetData(data) && (retryCount < BufferRetries); ++retryCount)
     {
         // Mark the buffer as the last one (so that we know when to reset the playing position)

src/SFML/Graphics/BlendMode.cpp

@@ -33,22 +33,22 @@ namespace sf
 ////////////////////////////////////////////////////////////
 // Commonly used blending modes
 ////////////////////////////////////////////////////////////
-const BlendMode BlendAlpha(BlendMode::SrcAlpha, BlendMode::OneMinusSrcAlpha, BlendMode::Add,
-                           BlendMode::One, BlendMode::OneMinusSrcAlpha, BlendMode::Add);
-const BlendMode BlendAdd(BlendMode::SrcAlpha, BlendMode::One, BlendMode::Add,
-                         BlendMode::One, BlendMode::One, BlendMode::Add);
-const BlendMode BlendMultiply(BlendMode::DstColor, BlendMode::Zero);
-const BlendMode BlendNone(BlendMode::One, BlendMode::Zero);
+const BlendMode BlendAlpha(BlendMode::Factor::SrcAlpha, BlendMode::Factor::OneMinusSrcAlpha, BlendMode::Equation::Add,
+                           BlendMode::Factor::One, BlendMode::Factor::OneMinusSrcAlpha, BlendMode::Equation::Add);
+const BlendMode BlendAdd(BlendMode::Factor::SrcAlpha, BlendMode::Factor::One, BlendMode::Equation::Add,
+                         BlendMode::Factor::One, BlendMode::Factor::One, BlendMode::Equation::Add);
+const BlendMode BlendMultiply(BlendMode::Factor::DstColor, BlendMode::Factor::Zero);
+const BlendMode BlendNone(BlendMode::Factor::One, BlendMode::Factor::Zero);
 
 
 ////////////////////////////////////////////////////////////
 BlendMode::BlendMode() :
-colorSrcFactor(BlendMode::SrcAlpha),
-colorDstFactor(BlendMode::OneMinusSrcAlpha),
-colorEquation (BlendMode::Add),
-alphaSrcFactor(BlendMode::One),
-alphaDstFactor(BlendMode::OneMinusSrcAlpha),
-alphaEquation (BlendMode::Add)
+colorSrcFactor(BlendMode::Factor::SrcAlpha),
+colorDstFactor(BlendMode::Factor::OneMinusSrcAlpha),
+colorEquation (BlendMode::Equation::Add),
+alphaSrcFactor(BlendMode::Factor::One),
+alphaDstFactor(BlendMode::Factor::OneMinusSrcAlpha),
+alphaEquation (BlendMode::Equation::Add)
 {
 
 }

src/SFML/Graphics/CircleShape.cpp

@@ -72,7 +72,7 @@ std::size_t CircleShape::getPointCount() const
 ////////////////////////////////////////////////////////////
 Vector2f CircleShape::getPoint(std::size_t index) const
 {
-    static const float pi = 3.141592654f;
+    constexpr auto pi = 3.141592654f;
 
     float angle = index * 2 * pi / m_pointCount - pi / 2;
     float x = std::cos(angle) * m_radius;

src/SFML/Graphics/Font.cpp

@@ -68,16 +68,11 @@ namespace sf
 {
 ////////////////////////////////////////////////////////////
 Font::Font() :
-m_library  (NULL),
-m_face     (NULL),
-m_streamRec(NULL),
-m_stroker  (NULL),
-m_refCount (NULL),
+m_library  (nullptr),
+m_face     (nullptr),
+m_stroker  (nullptr),
 m_info     ()
 {
-    #ifdef SFML_SYSTEM_ANDROID
-        m_stream = NULL;
-    #endif
 }
 
 
@@ -92,10 +87,6 @@ m_info       (copy.m_info),
 m_pages      (copy.m_pages),
 m_pixelBuffer(copy.m_pixelBuffer)
 {
-    #ifdef SFML_SYSTEM_ANDROID
-        m_stream = NULL;
-    #endif
-
     // Note: as FreeType doesn't provide functions for copying/cloning,
     // we must share all the FreeType pointers
 
@@ -108,13 +99,6 @@ m_pixelBuffer(copy.m_pixelBuffer)
 Font::~Font()
 {
     cleanup();
-
-    #ifdef SFML_SYSTEM_ANDROID
-
-    if (m_stream)
-        delete (priv::ResourceStream*)m_stream;
-
-    #endif
 }
 
 
@@ -125,7 +109,7 @@ bool Font::loadFromFile(const std::string& filename)
 
     // Cleanup the previous resources
     cleanup();
-    m_refCount = new int(1);
+    m_refCount = std::make_shared<int>(1);
 
     // Initialize FreeType
     // Note: we initialize FreeType for every font instance in order to avoid having a single
@@ -173,11 +157,8 @@ bool Font::loadFromFile(const std::string& filename)
 
     #else
 
-    if (m_stream)
-        delete (priv::ResourceStream*)m_stream;
-
-    m_stream = new priv::ResourceStream(filename);
-    return loadFromStream(*(priv::ResourceStream*)m_stream);
+    m_stream = std::make_shared<priv::ResourceStream>(filename);
+    return loadFromStream(*std::static_pointer_cast<priv::ResourceStream>(m_stream));
 
     #endif
 }
@@ -188,7 +169,7 @@ bool Font::loadFromMemory(const void* data, std::size_t sizeInBytes)
 {
     // Cleanup the previous resources
     cleanup();
-    m_refCount = new int(1);
+    m_refCount = std::make_shared<int>(1);
 
     // Initialize FreeType
     // Note: we initialize FreeType for every font instance in order to avoid having a single
@@ -241,7 +222,7 @@ bool Font::loadFromStream(InputStream& stream)
 {
     // Cleanup the previous resources
     cleanup();
-    m_refCount = new int(1);
+    m_refCount = std::make_shared<int>(1);
 
     // Initialize FreeType
     // Note: we initialize FreeType for every font instance in order to avoid having a single
@@ -258,9 +239,9 @@ bool Font::loadFromStream(InputStream& stream)
     stream.seek(0);
 
     // Prepare a wrapper for our stream, that we'll pass to FreeType callbacks
-    FT_StreamRec* rec = new FT_StreamRec;
-    std::memset(rec, 0, sizeof(*rec));
-    rec->base               = NULL;
+    auto rec = std::make_shared<FT_StreamRec>();
+    std::memset(rec.get(), 0, sizeof(FT_StreamRec));
+    rec->base               = nullptr;
     rec->size               = static_cast<unsigned long>(stream.getSize());
     rec->pos                = 0;
     rec->descriptor.pointer = &stream;
@@ -270,7 +251,7 @@ bool Font::loadFromStream(InputStream& stream)
     // Setup the FreeType callbacks that will read our stream
     FT_Open_Args args;
     args.flags  = FT_OPEN_STREAM;
-    args.stream = rec;
+    args.stream = rec.get();
     args.driver = 0;
 
     // Load the new font face from the specified stream
@@ -278,7 +259,6 @@ bool Font::loadFromStream(InputStream& stream)
     if (FT_Open_Face(static_cast<FT_Library>(m_library), &args, 0, &face) != 0)
     {
         err() << "Failed to load font from stream (failed to create the font face)" << std::endl;
-        delete rec;
         return false;
     }
 
@@ -296,7 +276,6 @@ bool Font::loadFromStream(InputStream& stream)
     {
         err() << "Failed to load font from stream (failed to set the Unicode character set)" << std::endl;
         FT_Done_Face(face);
-        delete rec;
         return false;
     }
 
@@ -477,7 +456,7 @@ void Font::cleanup()
         if (*m_refCount == 0)
         {
             // Delete the reference counter
-            delete m_refCount;
+            m_refCount.reset();
 
             // Destroy the stroker
             if (m_stroker)
@@ -488,8 +467,7 @@ void Font::cleanup()
                 FT_Done_Face(static_cast<FT_Face>(m_face));
 
             // Destroy the stream rec instance, if any (must be done after FT_Done_Face!)
-            if (m_streamRec)
-                delete static_cast<FT_StreamRec*>(m_streamRec);
+            m_streamRec.reset();
 
             // Close the library
             if (m_library)
@@ -498,11 +476,10 @@ void Font::cleanup()
     }
 
     // Reset members
-    m_library   = NULL;
-    m_face      = NULL;
-    m_stroker   = NULL;
-    m_streamRec = NULL;
-    m_refCount  = NULL;
+    m_library   = nullptr;
+    m_face      = nullptr;
+    m_stroker   = nullptr;
+    m_streamRec = nullptr;
     m_pages.clear();
     std::vector<Uint8>().swap(m_pixelBuffer);
 }
@@ -608,7 +585,7 @@ Glyph Font::loadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold, f
         // Resize the pixel buffer to the new size and fill it with transparent white pixels
         m_pixelBuffer.resize(width * height * 4);
 
-        Uint8* current = &m_pixelBuffer[0];
+        Uint8* current = m_pixelBuffer.data();
         Uint8* end = current + width * height * 4;
 
         while (current != end)
@@ -655,7 +632,7 @@ Glyph Font::loadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold, f
         unsigned int y = glyph.textureRect.top - padding;
         unsigned int w = glyph.textureRect.width + 2 * padding;
         unsigned int h = glyph.textureRect.height + 2 * padding;
-        page.texture.update(&m_pixelBuffer[0], w, h, x, y);
+        page.texture.update(m_pixelBuffer.data(), w, h, x, y);
     }
 
     // Delete the FT glyph
@@ -670,7 +647,7 @@ Glyph Font::loadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold, f
 IntRect Font::findGlyphRect(Page& page, unsigned int width, unsigned int height) const
 {
     // Find the line that fits well the glyph
-    Row* row = NULL;
+    Row* row = nullptr;
     float bestRatio = 0;
     for (std::vector<Row>::iterator it = page.rows.begin(); it != page.rows.end() && !row; ++it)
     {

src/SFML/Graphics/GLExtensions.cpp

@@ -28,6 +28,7 @@
 #include <SFML/Graphics/GLExtensions.hpp>
 #include <SFML/Window/Context.hpp>
 #include <SFML/System/Err.hpp>
+#include <mutex>
 
 #if !defined(GL_MAJOR_VERSION)
     #define GL_MAJOR_VERSION 0x821B
@@ -46,11 +47,10 @@ namespace priv
 void ensureExtensionsInit()
 {
 #if !defined(SFML_OPENGL_ES)
-    static bool initialized = false;
-    if (!initialized)
-    {
-        initialized = true;
+    static std::once_flag initialized;
 
+    std::call_once(initialized, []
+    {
         sfogl_LoadFunctions();
 
         // Retrieve the context version number
@@ -84,7 +84,7 @@ void ensureExtensionsInit()
             err() << "sfml-graphics requires support for OpenGL 1.1 or greater" << std::endl;
             err() << "Ensure that hardware acceleration is enabled if available" << std::endl;
         }
-    }
+    });
 #endif
 }
 

src/SFML/Graphics/GLLoader.cpp

@@ -50,7 +50,7 @@ int sfogl_ext_EXT_framebuffer_object = sfogl_LOAD_FAILED;
 int sfogl_ext_EXT_framebuffer_blit = sfogl_LOAD_FAILED;
 int sfogl_ext_ARB_geometry_shader4 = sfogl_LOAD_FAILED;
 
-void (GL_FUNCPTR *sf_ptrc_glBlendEquationEXT)(GLenum) = NULL;
+void (GL_FUNCPTR *sf_ptrc_glBlendEquationEXT)(GLenum) = nullptr;
 
 static int Load_EXT_blend_minmax()
 {
@@ -63,40 +63,40 @@ static int Load_EXT_blend_minmax()
     return numFailed;
 }
 
-void (GL_FUNCPTR *sf_ptrc_glActiveTextureARB)(GLenum) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glClientActiveTextureARB)(GLenum) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord1dARB)(GLenum, GLdouble) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord1dvARB)(GLenum, const GLdouble*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord1fARB)(GLenum, GLfloat) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord1fvARB)(GLenum, const GLfloat*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord1iARB)(GLenum, GLint) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord1ivARB)(GLenum, const GLint*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord1sARB)(GLenum, GLshort) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord1svARB)(GLenum, const GLshort*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord2dARB)(GLenum, GLdouble, GLdouble) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord2dvARB)(GLenum, const GLdouble*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord2fARB)(GLenum, GLfloat, GLfloat) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord2fvARB)(GLenum, const GLfloat*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord2iARB)(GLenum, GLint, GLint) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord2ivARB)(GLenum, const GLint*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord2sARB)(GLenum, GLshort, GLshort) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord2svARB)(GLenum, const GLshort*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord3dARB)(GLenum, GLdouble, GLdouble, GLdouble) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord3dvARB)(GLenum, const GLdouble*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord3fARB)(GLenum, GLfloat, GLfloat, GLfloat) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord3fvARB)(GLenum, const GLfloat*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord3iARB)(GLenum, GLint, GLint, GLint) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord3ivARB)(GLenum, const GLint*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord3sARB)(GLenum, GLshort, GLshort, GLshort) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord3svARB)(GLenum, const GLshort*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord4dARB)(GLenum, GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord4dvARB)(GLenum, const GLdouble*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord4fARB)(GLenum, GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord4fvARB)(GLenum, const GLfloat*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord4iARB)(GLenum, GLint, GLint, GLint, GLint) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord4ivARB)(GLenum, const GLint*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord4sARB)(GLenum, GLshort, GLshort, GLshort, GLshort) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord4svARB)(GLenum, const GLshort*) = NULL;
+void (GL_FUNCPTR *sf_ptrc_glActiveTextureARB)(GLenum) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glClientActiveTextureARB)(GLenum) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord1dARB)(GLenum, GLdouble) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord1dvARB)(GLenum, const GLdouble*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord1fARB)(GLenum, GLfloat) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord1fvARB)(GLenum, const GLfloat*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord1iARB)(GLenum, GLint) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord1ivARB)(GLenum, const GLint*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord1sARB)(GLenum, GLshort) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord1svARB)(GLenum, const GLshort*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord2dARB)(GLenum, GLdouble, GLdouble) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord2dvARB)(GLenum, const GLdouble*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord2fARB)(GLenum, GLfloat, GLfloat) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord2fvARB)(GLenum, const GLfloat*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord2iARB)(GLenum, GLint, GLint) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord2ivARB)(GLenum, const GLint*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord2sARB)(GLenum, GLshort, GLshort) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord2svARB)(GLenum, const GLshort*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord3dARB)(GLenum, GLdouble, GLdouble, GLdouble) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord3dvARB)(GLenum, const GLdouble*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord3fARB)(GLenum, GLfloat, GLfloat, GLfloat) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord3fvARB)(GLenum, const GLfloat*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord3iARB)(GLenum, GLint, GLint, GLint) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord3ivARB)(GLenum, const GLint*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord3sARB)(GLenum, GLshort, GLshort, GLshort) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord3svARB)(GLenum, const GLshort*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord4dARB)(GLenum, GLdouble, GLdouble, GLdouble, GLdouble) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord4dvARB)(GLenum, const GLdouble*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord4fARB)(GLenum, GLfloat, GLfloat, GLfloat, GLfloat) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord4fvARB)(GLenum, const GLfloat*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord4iARB)(GLenum, GLint, GLint, GLint, GLint) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord4ivARB)(GLenum, const GLint*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord4sARB)(GLenum, GLshort, GLshort, GLshort, GLshort) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glMultiTexCoord4svARB)(GLenum, const GLshort*) = nullptr;
 
 static int Load_ARB_multitexture()
 {
@@ -241,7 +241,7 @@ static int Load_ARB_multitexture()
     return numFailed;
 }
 
-void (GL_FUNCPTR *sf_ptrc_glBlendFuncSeparateEXT)(GLenum, GLenum, GLenum, GLenum) = NULL;
+void (GL_FUNCPTR *sf_ptrc_glBlendFuncSeparateEXT)(GLenum, GLenum, GLenum, GLenum) = nullptr;
 
 static int Load_EXT_blend_func_separate()
 {
@@ -254,45 +254,45 @@ static int Load_EXT_blend_func_separate()
     return numFailed;
 }
 
-void (GL_FUNCPTR *sf_ptrc_glAttachObjectARB)(GLhandleARB, GLhandleARB) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glCompileShaderARB)(GLhandleARB) = NULL;
-GLhandleARB (GL_FUNCPTR *sf_ptrc_glCreateProgramObjectARB)() = NULL;
-GLhandleARB (GL_FUNCPTR *sf_ptrc_glCreateShaderObjectARB)(GLenum) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glDeleteObjectARB)(GLhandleARB) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glDetachObjectARB)(GLhandleARB, GLhandleARB) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glGetActiveUniformARB)(GLhandleARB, GLuint, GLsizei, GLsizei*, GLint*, GLenum*, GLcharARB*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glGetAttachedObjectsARB)(GLhandleARB, GLsizei, GLsizei*, GLhandleARB*) = NULL;
-GLhandleARB (GL_FUNCPTR *sf_ptrc_glGetHandleARB)(GLenum) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glGetInfoLogARB)(GLhandleARB, GLsizei, GLsizei*, GLcharARB*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glGetObjectParameterfvARB)(GLhandleARB, GLenum, GLfloat*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glGetObjectParameterivARB)(GLhandleARB, GLenum, GLint*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glGetShaderSourceARB)(GLhandleARB, GLsizei, GLsizei*, GLcharARB*) = NULL;
-GLint (GL_FUNCPTR *sf_ptrc_glGetUniformLocationARB)(GLhandleARB, const GLcharARB*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glGetUniformfvARB)(GLhandleARB, GLint, GLfloat*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glGetUniformivARB)(GLhandleARB, GLint, GLint*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glLinkProgramARB)(GLhandleARB) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glShaderSourceARB)(GLhandleARB, GLsizei, const GLcharARB**, const GLint*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glUniform1fARB)(GLint, GLfloat) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glUniform1fvARB)(GLint, GLsizei, const GLfloat*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glUniform1iARB)(GLint, GLint) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glUniform1ivARB)(GLint, GLsizei, const GLint*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glUniform2fARB)(GLint, GLfloat, GLfloat) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glUniform2fvARB)(GLint, GLsizei, const GLfloat*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glUniform2iARB)(GLint, GLint, GLint) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glUniform2ivARB)(GLint, GLsizei, const GLint*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glUniform3fARB)(GLint, GLfloat, GLfloat, GLfloat) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glUniform3fvARB)(GLint, GLsizei, const GLfloat*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glUniform3iARB)(GLint, GLint, GLint, GLint) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glUniform3ivARB)(GLint, GLsizei, const GLint*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glUniform4fARB)(GLint, GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glUniform4fvARB)(GLint, GLsizei, const GLfloat*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glUniform4iARB)(GLint, GLint, GLint, GLint, GLint) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glUniform4ivARB)(GLint, GLsizei, const GLint*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glUniformMatrix2fvARB)(GLint, GLsizei, GLboolean, const GLfloat*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glUniformMatrix3fvARB)(GLint, GLsizei, GLboolean, const GLfloat*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glUniformMatrix4fvARB)(GLint, GLsizei, GLboolean, const GLfloat*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glUseProgramObjectARB)(GLhandleARB) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glValidateProgramARB)(GLhandleARB) = NULL;
+void (GL_FUNCPTR *sf_ptrc_glAttachObjectARB)(GLhandleARB, GLhandleARB) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glCompileShaderARB)(GLhandleARB) = nullptr;
+GLhandleARB (GL_FUNCPTR *sf_ptrc_glCreateProgramObjectARB)() = nullptr;
+GLhandleARB (GL_FUNCPTR *sf_ptrc_glCreateShaderObjectARB)(GLenum) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glDeleteObjectARB)(GLhandleARB) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glDetachObjectARB)(GLhandleARB, GLhandleARB) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glGetActiveUniformARB)(GLhandleARB, GLuint, GLsizei, GLsizei*, GLint*, GLenum*, GLcharARB*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glGetAttachedObjectsARB)(GLhandleARB, GLsizei, GLsizei*, GLhandleARB*) = nullptr;
+GLhandleARB (GL_FUNCPTR *sf_ptrc_glGetHandleARB)(GLenum) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glGetInfoLogARB)(GLhandleARB, GLsizei, GLsizei*, GLcharARB*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glGetObjectParameterfvARB)(GLhandleARB, GLenum, GLfloat*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glGetObjectParameterivARB)(GLhandleARB, GLenum, GLint*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glGetShaderSourceARB)(GLhandleARB, GLsizei, GLsizei*, GLcharARB*) = nullptr;
+GLint (GL_FUNCPTR *sf_ptrc_glGetUniformLocationARB)(GLhandleARB, const GLcharARB*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glGetUniformfvARB)(GLhandleARB, GLint, GLfloat*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glGetUniformivARB)(GLhandleARB, GLint, GLint*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glLinkProgramARB)(GLhandleARB) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glShaderSourceARB)(GLhandleARB, GLsizei, const GLcharARB**, const GLint*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glUniform1fARB)(GLint, GLfloat) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glUniform1fvARB)(GLint, GLsizei, const GLfloat*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glUniform1iARB)(GLint, GLint) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glUniform1ivARB)(GLint, GLsizei, const GLint*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glUniform2fARB)(GLint, GLfloat, GLfloat) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glUniform2fvARB)(GLint, GLsizei, const GLfloat*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glUniform2iARB)(GLint, GLint, GLint) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glUniform2ivARB)(GLint, GLsizei, const GLint*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glUniform3fARB)(GLint, GLfloat, GLfloat, GLfloat) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glUniform3fvARB)(GLint, GLsizei, const GLfloat*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glUniform3iARB)(GLint, GLint, GLint, GLint) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glUniform3ivARB)(GLint, GLsizei, const GLint*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glUniform4fARB)(GLint, GLfloat, GLfloat, GLfloat, GLfloat) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glUniform4fvARB)(GLint, GLsizei, const GLfloat*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glUniform4iARB)(GLint, GLint, GLint, GLint, GLint) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glUniform4ivARB)(GLint, GLsizei, const GLint*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glUniformMatrix2fvARB)(GLint, GLsizei, GLboolean, const GLfloat*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glUniformMatrix3fvARB)(GLint, GLsizei, GLboolean, const GLfloat*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glUniformMatrix4fvARB)(GLint, GLsizei, GLboolean, const GLfloat*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glUseProgramObjectARB)(GLhandleARB) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glValidateProgramARB)(GLhandleARB) = nullptr;
 
 static int Load_ARB_shader_objects()
 {
@@ -457,52 +457,52 @@ static int Load_ARB_shader_objects()
     return numFailed;
 }
 
-void (GL_FUNCPTR *sf_ptrc_glBindAttribLocationARB)(GLhandleARB, GLuint, const GLcharARB*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glDisableVertexAttribArrayARB)(GLuint) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glEnableVertexAttribArrayARB)(GLuint) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glGetActiveAttribARB)(GLhandleARB, GLuint, GLsizei, GLsizei*, GLint*, GLenum*, GLcharARB*) = NULL;
-GLint (GL_FUNCPTR *sf_ptrc_glGetAttribLocationARB)(GLhandleARB, const GLcharARB*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glGetVertexAttribPointervARB)(GLuint, GLenum, void**) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glGetVertexAttribdvARB)(GLuint, GLenum, GLdouble*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glGetVertexAttribfvARB)(GLuint, GLenum, GLfloat*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glGetVertexAttribivARB)(GLuint, GLenum, GLint*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib1dARB)(GLuint, GLdouble) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib1dvARB)(GLuint, const GLdouble*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib1fARB)(GLuint, GLfloat) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib1fvARB)(GLuint, const GLfloat*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib1sARB)(GLuint, GLshort) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib1svARB)(GLuint, const GLshort*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib2dARB)(GLuint, GLdouble, GLdouble) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib2dvARB)(GLuint, const GLdouble*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib2fARB)(GLuint, GLfloat, GLfloat) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib2fvARB)(GLuint, const GLfloat*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib2sARB)(GLuint, GLshort, GLshort) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib2svARB)(GLuint, const GLshort*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib3dARB)(GLuint, GLdouble, GLdouble, GLdouble) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib3dvARB)(GLuint, const GLdouble*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib3fARB)(GLuint, GLfloat, GLfloat, GLfloat) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib3fvARB)(GLuint, const GLfloat*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib3sARB)(GLuint, GLshort, GLshort, GLshort) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib3svARB)(GLuint, const GLshort*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4NbvARB)(GLuint, const GLbyte*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4NivARB)(GLuint, const GLint*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4NsvARB)(GLuint, const GLshort*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4NubARB)(GLuint, GLubyte, GLubyte, GLubyte, GLubyte) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4NubvARB)(GLuint, const GLubyte*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4NuivARB)(GLuint, const GLuint*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4NusvARB)(GLuint, const GLushort*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4bvARB)(GLuint, const GLbyte*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4dARB)(GLuint, GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4dvARB)(GLuint, const GLdouble*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4fARB)(GLuint, GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4fvARB)(GLuint, const GLfloat*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4ivARB)(GLuint, const GLint*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4sARB)(GLuint, GLshort, GLshort, GLshort, GLshort) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4svARB)(GLuint, const GLshort*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4ubvARB)(GLuint, const GLubyte*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4uivARB)(GLuint, const GLuint*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4usvARB)(GLuint, const GLushort*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glVertexAttribPointerARB)(GLuint, GLint, GLenum, GLboolean, GLsizei, const void*) = NULL;
+void (GL_FUNCPTR *sf_ptrc_glBindAttribLocationARB)(GLhandleARB, GLuint, const GLcharARB*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glDisableVertexAttribArrayARB)(GLuint) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glEnableVertexAttribArrayARB)(GLuint) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glGetActiveAttribARB)(GLhandleARB, GLuint, GLsizei, GLsizei*, GLint*, GLenum*, GLcharARB*) = nullptr;
+GLint (GL_FUNCPTR *sf_ptrc_glGetAttribLocationARB)(GLhandleARB, const GLcharARB*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glGetVertexAttribPointervARB)(GLuint, GLenum, void**) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glGetVertexAttribdvARB)(GLuint, GLenum, GLdouble*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glGetVertexAttribfvARB)(GLuint, GLenum, GLfloat*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glGetVertexAttribivARB)(GLuint, GLenum, GLint*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib1dARB)(GLuint, GLdouble) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib1dvARB)(GLuint, const GLdouble*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib1fARB)(GLuint, GLfloat) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib1fvARB)(GLuint, const GLfloat*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib1sARB)(GLuint, GLshort) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib1svARB)(GLuint, const GLshort*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib2dARB)(GLuint, GLdouble, GLdouble) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib2dvARB)(GLuint, const GLdouble*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib2fARB)(GLuint, GLfloat, GLfloat) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib2fvARB)(GLuint, const GLfloat*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib2sARB)(GLuint, GLshort, GLshort) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib2svARB)(GLuint, const GLshort*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib3dARB)(GLuint, GLdouble, GLdouble, GLdouble) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib3dvARB)(GLuint, const GLdouble*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib3fARB)(GLuint, GLfloat, GLfloat, GLfloat) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib3fvARB)(GLuint, const GLfloat*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib3sARB)(GLuint, GLshort, GLshort, GLshort) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib3svARB)(GLuint, const GLshort*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4NbvARB)(GLuint, const GLbyte*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4NivARB)(GLuint, const GLint*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4NsvARB)(GLuint, const GLshort*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4NubARB)(GLuint, GLubyte, GLubyte, GLubyte, GLubyte) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4NubvARB)(GLuint, const GLubyte*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4NuivARB)(GLuint, const GLuint*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4NusvARB)(GLuint, const GLushort*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4bvARB)(GLuint, const GLbyte*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4dARB)(GLuint, GLdouble, GLdouble, GLdouble, GLdouble) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4dvARB)(GLuint, const GLdouble*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4fARB)(GLuint, GLfloat, GLfloat, GLfloat, GLfloat) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4fvARB)(GLuint, const GLfloat*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4ivARB)(GLuint, const GLint*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4sARB)(GLuint, GLshort, GLshort, GLshort, GLshort) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4svARB)(GLuint, const GLshort*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4ubvARB)(GLuint, const GLubyte*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4uivARB)(GLuint, const GLuint*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttrib4usvARB)(GLuint, const GLushort*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glVertexAttribPointerARB)(GLuint, GLint, GLenum, GLboolean, GLsizei, const void*) = nullptr;
 
 static int Load_ARB_vertex_shader()
 {
@@ -695,7 +695,7 @@ static int Load_ARB_vertex_shader()
     return numFailed;
 }
 
-void (GL_FUNCPTR *sf_ptrc_glBlendEquationSeparateEXT)(GLenum, GLenum) = NULL;
+void (GL_FUNCPTR *sf_ptrc_glBlendEquationSeparateEXT)(GLenum, GLenum) = nullptr;
 
 static int Load_EXT_blend_equation_separate()
 {
@@ -708,23 +708,23 @@ static int Load_EXT_blend_equation_separate()
     return numFailed;
 }
 
-void (GL_FUNCPTR *sf_ptrc_glBindFramebufferEXT)(GLenum, GLuint) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glBindRenderbufferEXT)(GLenum, GLuint) = NULL;
-GLenum (GL_FUNCPTR *sf_ptrc_glCheckFramebufferStatusEXT)(GLenum) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glDeleteFramebuffersEXT)(GLsizei, const GLuint*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glDeleteRenderbuffersEXT)(GLsizei, const GLuint*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glFramebufferRenderbufferEXT)(GLenum, GLenum, GLenum, GLuint) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glFramebufferTexture1DEXT)(GLenum, GLenum, GLenum, GLuint, GLint) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glFramebufferTexture2DEXT)(GLenum, GLenum, GLenum, GLuint, GLint) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glFramebufferTexture3DEXT)(GLenum, GLenum, GLenum, GLuint, GLint, GLint) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glGenFramebuffersEXT)(GLsizei, GLuint*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glGenRenderbuffersEXT)(GLsizei, GLuint*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glGenerateMipmapEXT)(GLenum) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glGetFramebufferAttachmentParameterivEXT)(GLenum, GLenum, GLenum, GLint*) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glGetRenderbufferParameterivEXT)(GLenum, GLenum, GLint*) = NULL;
-GLboolean (GL_FUNCPTR *sf_ptrc_glIsFramebufferEXT)(GLuint) = NULL;
-GLboolean (GL_FUNCPTR *sf_ptrc_glIsRenderbufferEXT)(GLuint) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glRenderbufferStorageEXT)(GLenum, GLenum, GLsizei, GLsizei) = NULL;
+void (GL_FUNCPTR *sf_ptrc_glBindFramebufferEXT)(GLenum, GLuint) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glBindRenderbufferEXT)(GLenum, GLuint) = nullptr;
+GLenum (GL_FUNCPTR *sf_ptrc_glCheckFramebufferStatusEXT)(GLenum) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glDeleteFramebuffersEXT)(GLsizei, const GLuint*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glDeleteRenderbuffersEXT)(GLsizei, const GLuint*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glFramebufferRenderbufferEXT)(GLenum, GLenum, GLenum, GLuint) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glFramebufferTexture1DEXT)(GLenum, GLenum, GLenum, GLuint, GLint) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glFramebufferTexture2DEXT)(GLenum, GLenum, GLenum, GLuint, GLint) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glFramebufferTexture3DEXT)(GLenum, GLenum, GLenum, GLuint, GLint, GLint) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glGenFramebuffersEXT)(GLsizei, GLuint*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glGenRenderbuffersEXT)(GLsizei, GLuint*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glGenerateMipmapEXT)(GLenum) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glGetFramebufferAttachmentParameterivEXT)(GLenum, GLenum, GLenum, GLint*) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glGetRenderbufferParameterivEXT)(GLenum, GLenum, GLint*) = nullptr;
+GLboolean (GL_FUNCPTR *sf_ptrc_glIsFramebufferEXT)(GLuint) = nullptr;
+GLboolean (GL_FUNCPTR *sf_ptrc_glIsRenderbufferEXT)(GLuint) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glRenderbufferStorageEXT)(GLenum, GLenum, GLsizei, GLsizei) = nullptr;
 
 static int Load_EXT_framebuffer_object()
 {
@@ -801,7 +801,7 @@ static int Load_EXT_framebuffer_object()
     return numFailed;
 }
 
-void (GL_FUNCPTR *sf_ptrc_glBlitFramebufferEXT)(GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum) = NULL;
+void (GL_FUNCPTR *sf_ptrc_glBlitFramebufferEXT)(GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum) = nullptr;
 
 static int Load_EXT_framebuffer_blit()
 {
@@ -814,10 +814,10 @@ static int Load_EXT_framebuffer_blit()
     return numFailed;
 }
 
-void (GL_FUNCPTR *sf_ptrc_glFramebufferTextureARB)(GLenum, GLenum, GLuint, GLint) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glFramebufferTextureFaceARB)(GLenum, GLenum, GLuint, GLint, GLenum) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glFramebufferTextureLayerARB)(GLenum, GLenum, GLuint, GLint, GLint) = NULL;
-void (GL_FUNCPTR *sf_ptrc_glProgramParameteriARB)(GLuint, GLenum, GLint) = NULL;
+void (GL_FUNCPTR *sf_ptrc_glFramebufferTextureARB)(GLenum, GLenum, GLuint, GLint) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glFramebufferTextureFaceARB)(GLenum, GLenum, GLuint, GLint, GLenum) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glFramebufferTextureLayerARB)(GLenum, GLenum, GLuint, GLint, GLint) = nullptr;
+void (GL_FUNCPTR *sf_ptrc_glProgramParameteriARB)(GLuint, GLenum, GLint) = nullptr;
 
 static int Load_ARB_geometry_shader4()
 {
@@ -851,19 +851,19 @@ typedef struct sfogl_StrToExtMap_s
 } sfogl_StrToExtMap;
 
 static sfogl_StrToExtMap ExtensionMap[16] = {
-    {"GL_SGIS_texture_edge_clamp", &sfogl_ext_SGIS_texture_edge_clamp, NULL},
-    {"GL_EXT_texture_edge_clamp", &sfogl_ext_EXT_texture_edge_clamp, NULL},
+    {"GL_SGIS_texture_edge_clamp", &sfogl_ext_SGIS_texture_edge_clamp, nullptr},
+    {"GL_EXT_texture_edge_clamp", &sfogl_ext_EXT_texture_edge_clamp, nullptr},
     {"GL_EXT_blend_minmax", &sfogl_ext_EXT_blend_minmax, Load_EXT_blend_minmax},
-    {"GL_EXT_blend_subtract", &sfogl_ext_EXT_blend_subtract, NULL},
+    {"GL_EXT_blend_subtract", &sfogl_ext_EXT_blend_subtract, nullptr},
     {"GL_ARB_multitexture", &sfogl_ext_ARB_multitexture, Load_ARB_multitexture},
     {"GL_EXT_blend_func_separate", &sfogl_ext_EXT_blend_func_separate, Load_EXT_blend_func_separate},
-    {"GL_ARB_shading_language_100", &sfogl_ext_ARB_shading_language_100, NULL},
+    {"GL_ARB_shading_language_100", &sfogl_ext_ARB_shading_language_100, nullptr},
     {"GL_ARB_shader_objects", &sfogl_ext_ARB_shader_objects, Load_ARB_shader_objects},
     {"GL_ARB_vertex_shader", &sfogl_ext_ARB_vertex_shader, Load_ARB_vertex_shader},
-    {"GL_ARB_fragment_shader", &sfogl_ext_ARB_fragment_shader, NULL},
-    {"GL_ARB_texture_non_power_of_two", &sfogl_ext_ARB_texture_non_power_of_two, NULL},
+    {"GL_ARB_fragment_shader", &sfogl_ext_ARB_fragment_shader, nullptr},
+    {"GL_ARB_texture_non_power_of_two", &sfogl_ext_ARB_texture_non_power_of_two, nullptr},
     {"GL_EXT_blend_equation_separate", &sfogl_ext_EXT_blend_equation_separate, Load_EXT_blend_equation_separate},
-    {"GL_EXT_texture_sRGB", &sfogl_ext_EXT_texture_sRGB, NULL},
+    {"GL_EXT_texture_sRGB", &sfogl_ext_EXT_texture_sRGB, nullptr},
     {"GL_EXT_framebuffer_object", &sfogl_ext_EXT_framebuffer_object, Load_EXT_framebuffer_object},
     {"GL_EXT_framebuffer_blit", &sfogl_ext_EXT_framebuffer_blit, Load_EXT_framebuffer_blit},
     {"GL_ARB_geometry_shader4", &sfogl_ext_ARB_geometry_shader4, Load_ARB_geometry_shader4}

src/SFML/Graphics/Image.cpp

@@ -41,24 +41,11 @@ namespace sf
 Image::Image() :
 m_size(0, 0)
 {
-    #ifdef SFML_SYSTEM_ANDROID
-
-    m_stream = NULL;
-
-    #endif
 }
 
 
 ////////////////////////////////////////////////////////////
-Image::~Image()
-{
-    #ifdef SFML_SYSTEM_ANDROID
-
-        if (m_stream)
-            delete (priv::ResourceStream*)m_stream;
-
-    #endif
-}
+Image::~Image() = default;
 
 
 ////////////////////////////////////////////////////////////
@@ -70,7 +57,7 @@ void Image::create(unsigned int width, unsigned int height, const Color& color)
         std::vector<Uint8> newPixels(width * height * 4);
     
         // Fill it with the specified color
-        Uint8* ptr = &newPixels[0];
+        Uint8* ptr = newPixels.data();
         Uint8* end = ptr + newPixels.size();
         while (ptr < end)
         {
@@ -135,11 +122,8 @@ bool Image::loadFromFile(const std::string& filename)
 
     #else
 
-        if (m_stream)
-            delete (priv::ResourceStream*)m_stream;
-
-        m_stream = new priv::ResourceStream(filename);
-        return loadFromStream(*(priv::ResourceStream*)m_stream);
+        m_stream = std::make_shared<priv::ResourceStream>(filename);
+        return loadFromStream(*std::static_pointer_cast<priv::ResourceStream*>(m_stream));
 
     #endif
 }
@@ -180,7 +164,7 @@ void Image::createMaskFromColor(const Color& color, Uint8 alpha)
     if (!m_pixels.empty())
     {
         // Replace the alpha of the pixels that match the transparent color
-        Uint8* ptr = &m_pixels[0];
+        Uint8* ptr = m_pixels.data();
         Uint8* end = ptr + m_pixels.size();
         while (ptr < end)
         {
@@ -231,8 +215,8 @@ void Image::copy(const Image& source, unsigned int destX, unsigned int destY, co
     int          rows      = height;
     int          srcStride = source.m_size.x * 4;
     int          dstStride = m_size.x * 4;
-    const Uint8* srcPixels = &source.m_pixels[0] + (srcRect.left + srcRect.top * source.m_size.x) * 4;
-    Uint8*       dstPixels = &m_pixels[0] + (destX + destY * m_size.x) * 4;
+    const Uint8* srcPixels = source.m_pixels.data() + (srcRect.left + srcRect.top * source.m_size.x) * 4;
+    Uint8*       dstPixels = m_pixels.data() + (destX + destY * m_size.x) * 4;
 
     // Copy the pixels
     if (applyAlpha)
@@ -295,12 +279,12 @@ const Uint8* Image::getPixelsPtr() const
 {
     if (!m_pixels.empty())
     {
-        return &m_pixels[0];
+        return m_pixels.data();
     }
     else
     {
         err() << "Trying to access the pixels of an empty image" << std::endl;
-        return NULL;
+        return nullptr;
     }
 }
 

src/SFML/Graphics/ImageLoader.cpp

@@ -37,6 +37,7 @@ extern "C"
     #include <jpeglib.h>
     #include <jerror.h>
 }
+#include <algorithm>
 #include <cctype>
 
 
@@ -45,8 +46,7 @@ namespace
     // Convert a string to lower case
     std::string toLower(std::string str)
     {
-        for (std::string::iterator i = str.begin(); i != str.end(); ++i)
-            *i = static_cast<char>(std::tolower(*i));
+        std::transform(str.begin(), str.end(), str.begin(), ::tolower);
         return str;
     }
 
@@ -118,7 +118,7 @@ bool ImageLoader::loadImageFromFile(const std::string& filename, std::vector<Uin
         {
             // Copy the loaded pixels to the pixel buffer
             pixels.resize(width * height * 4);
-            memcpy(&pixels[0], ptr, pixels.size());
+            memcpy(pixels.data(), ptr, pixels.size());
         }
 
         // Free the loaded pixels (they are now in our own pixel buffer)
@@ -162,7 +162,7 @@ bool ImageLoader::loadImageFromMemory(const void* data, std::size_t dataSize, st
             {
                 // Copy the loaded pixels to the pixel buffer
                 pixels.resize(width * height * 4);
-                memcpy(&pixels[0], ptr, pixels.size());
+                memcpy(pixels.data(), ptr, pixels.size());
             }
 
             // Free the loaded pixels (they are now in our own pixel buffer)
@@ -217,7 +217,7 @@ bool ImageLoader::loadImageFromStream(InputStream& stream, std::vector<Uint8>& p
         {
             // Copy the loaded pixels to the pixel buffer
             pixels.resize(width * height * 4);
-            memcpy(&pixels[0], ptr, pixels.size());
+            memcpy(pixels.data(), ptr, pixels.size());
         }
 
         // Free the loaded pixels (they are now in our own pixel buffer)
@@ -250,19 +250,19 @@ bool ImageLoader::saveImageToFile(const std::string& filename, const std::vector
         if (extension == "bmp")
         {
             // BMP format
-            if (stbi_write_bmp(filename.c_str(), size.x, size.y, 4, &pixels[0]))
+            if (stbi_write_bmp(filename.c_str(), size.x, size.y, 4, pixels.data()))
                 return true;
         }
         else if (extension == "tga")
         {
             // TGA format
-            if (stbi_write_tga(filename.c_str(), size.x, size.y, 4, &pixels[0]))
+            if (stbi_write_tga(filename.c_str(), size.x, size.y, 4, pixels.data()))
                 return true;
         }
         else if (extension == "png")
         {
             // PNG format
-            if (stbi_write_png(filename.c_str(), size.x, size.y, 4, &pixels[0], 0))
+            if (stbi_write_png(filename.c_str(), size.x, size.y, 4, pixels.data(), 0))
                 return true;
         }
         else if (extension == "jpg" || extension == "jpeg")
@@ -309,7 +309,7 @@ bool ImageLoader::writeJpg(const std::string& filename, const std::vector<Uint8>
         buffer[i * 3 + 1] = pixels[i * 4 + 1];
         buffer[i * 3 + 2] = pixels[i * 4 + 2];
     }
-    Uint8* ptr = &buffer[0];
+    Uint8* ptr = buffer.data();
 
     // Start compression
     jpeg_start_compress(&compressInfos, TRUE);

src/SFML/Graphics/RenderStates.cpp

@@ -35,16 +35,16 @@ namespace sf
 // We cannot use the default constructor here, because it accesses BlendAlpha, which is also global (and dynamically
 // initialized). Initialization order of global objects in different translation units is not defined.
 const RenderStates RenderStates::Default(BlendMode(
-    BlendMode::SrcAlpha, BlendMode::OneMinusSrcAlpha, BlendMode::Add,
-    BlendMode::One, BlendMode::OneMinusSrcAlpha, BlendMode::Add));
+    BlendMode::Factor::SrcAlpha, BlendMode::Factor::OneMinusSrcAlpha, BlendMode::Equation::Add,
+    BlendMode::Factor::One, BlendMode::Factor::OneMinusSrcAlpha, BlendMode::Equation::Add));
 
 
 ////////////////////////////////////////////////////////////
 RenderStates::RenderStates() :
 blendMode(BlendAlpha),
 transform(),
-texture  (NULL),
-shader   (NULL)
+texture  (nullptr),
+shader   (nullptr)
 {
 }
 
@@ -53,8 +53,8 @@ shader   (NULL)
 RenderStates::RenderStates(const Transform& theTransform) :
 blendMode(BlendAlpha),
 transform(theTransform),
-texture  (NULL),
-shader   (NULL)
+texture  (nullptr),
+shader   (nullptr)
 {
 }
 
@@ -63,8 +63,8 @@ shader   (NULL)
 RenderStates::RenderStates(const BlendMode& theBlendMode) :
 blendMode(theBlendMode),
 transform(),
-texture  (NULL),
-shader   (NULL)
+texture  (nullptr),
+shader   (nullptr)
 {
 }
 
@@ -74,7 +74,7 @@ RenderStates::RenderStates(const Texture* theTexture) :
 blendMode(BlendAlpha),
 transform(),
 texture  (theTexture),
-shader   (NULL)
+shader   (nullptr)
 {
 }
 
@@ -83,7 +83,7 @@ shader   (NULL)
 RenderStates::RenderStates(const Shader* theShader) :
 blendMode(BlendAlpha),
 transform(),
-texture  (NULL),
+texture  (nullptr),
 shader   (theShader)
 {
 }

src/SFML/Graphics/RenderTarget.cpp

@@ -34,6 +34,7 @@
 #include <SFML/System/Err.hpp>
 #include <cassert>
 #include <iostream>
+#include <mutex>
 
 namespace
 {
@@ -42,16 +43,16 @@ namespace
     {
         switch (blendFactor)
         {
-            case sf::BlendMode::Zero:             return GL_ZERO;
-            case sf::BlendMode::One:              return GL_ONE;
-            case sf::BlendMode::SrcColor:         return GL_SRC_COLOR;
-            case sf::BlendMode::OneMinusSrcColor: return GL_ONE_MINUS_SRC_COLOR;
-            case sf::BlendMode::DstColor:         return GL_DST_COLOR;
-            case sf::BlendMode::OneMinusDstColor: return GL_ONE_MINUS_DST_COLOR;
-            case sf::BlendMode::SrcAlpha:         return GL_SRC_ALPHA;
-            case sf::BlendMode::OneMinusSrcAlpha: return GL_ONE_MINUS_SRC_ALPHA;
-            case sf::BlendMode::DstAlpha:         return GL_DST_ALPHA;
-            case sf::BlendMode::OneMinusDstAlpha: return GL_ONE_MINUS_DST_ALPHA;
+            case sf::BlendMode::Factor::Zero:             return GL_ZERO;
+            case sf::BlendMode::Factor::One:              return GL_ONE;
+            case sf::BlendMode::Factor::SrcColor:         return GL_SRC_COLOR;
+            case sf::BlendMode::Factor::OneMinusSrcColor: return GL_ONE_MINUS_SRC_COLOR;
+            case sf::BlendMode::Factor::DstColor:         return GL_DST_COLOR;
+            case sf::BlendMode::Factor::OneMinusDstColor: return GL_ONE_MINUS_DST_COLOR;
+            case sf::BlendMode::Factor::SrcAlpha:         return GL_SRC_ALPHA;
+            case sf::BlendMode::Factor::OneMinusSrcAlpha: return GL_ONE_MINUS_SRC_ALPHA;
+            case sf::BlendMode::Factor::DstAlpha:         return GL_DST_ALPHA;
+            case sf::BlendMode::Factor::OneMinusDstAlpha: return GL_ONE_MINUS_DST_ALPHA;
         }
 
         sf::err() << "Invalid value for sf::BlendMode::Factor! Fallback to sf::BlendMode::Zero." << std::endl;
@@ -65,9 +66,9 @@ namespace
     {
         switch (blendEquation)
         {
-            case sf::BlendMode::Add:             return GLEXT_GL_FUNC_ADD;
-            case sf::BlendMode::Subtract:        return GLEXT_GL_FUNC_SUBTRACT;
-            case sf::BlendMode::ReverseSubtract: return GLEXT_GL_FUNC_REVERSE_SUBTRACT;
+            case sf::BlendMode::Equation::Add:             return GLEXT_GL_FUNC_ADD;
+            case sf::BlendMode::Equation::Subtract:        return GLEXT_GL_FUNC_SUBTRACT;
+            case sf::BlendMode::Equation::ReverseSubtract: return GLEXT_GL_FUNC_REVERSE_SUBTRACT;
         }
 
         sf::err() << "Invalid value for sf::BlendMode::Equation! Fallback to sf::BlendMode::Add." << std::endl;
@@ -101,7 +102,7 @@ void RenderTarget::clear(const Color& color)
     if (setActive(true))
     {
         // Unbind texture to fix RenderTexture preventing clear
-        applyTexture(NULL);
+        applyTexture(nullptr);
 
         glCheck(glClearColor(color.r / 255.f, color.g / 255.f, color.b / 255.f, color.a / 255.f));
         glCheck(glClear(GL_COLOR_BUFFER_BIT));
@@ -266,7 +267,7 @@ void RenderTarget::draw(const Vertex* vertices, std::size_t vertexCount,
             if (!m_cache.useVertexCache)
                 vertices = m_cache.vertexCache;
             else
-                vertices = NULL;
+                vertices = nullptr;
         }
 
         // Setup the pointers to the vertices' components
@@ -279,21 +280,21 @@ void RenderTarget::draw(const Vertex* vertices, std::size_t vertexCount,
         }
 
         // Find the OpenGL primitive type
-        static const GLenum modes[] = {GL_POINTS, GL_LINES, GL_LINE_STRIP, GL_TRIANGLES,
+        constexpr GLenum modes[] = {GL_POINTS, GL_LINES, GL_LINE_STRIP, GL_TRIANGLES,
                                        GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS};
-        GLenum mode = modes[type];
+        GLenum mode = modes[static_cast<size_t>(type)];
 
         // Draw the primitives
         glCheck(glDrawArrays(mode, 0, vertexCount));
 
         // Unbind the shader, if any
         if (states.shader)
-            applyShader(NULL);
+            applyShader(nullptr);
 
         // If the texture we used to draw belonged to a RenderTexture, then forcibly unbind that texture.
         // This prevents a bug where some drivers do not clear RenderTextures properly.
         if (states.texture && states.texture->m_fboAttachment)
-            applyTexture(NULL);
+            applyTexture(nullptr);
 
         // Update the cache
         m_cache.useVertexCache = useVertexCache;
@@ -386,9 +387,9 @@ void RenderTarget::resetGLStates()
         // Apply the default SFML states
         applyBlendMode(BlendAlpha);
         applyTransform(Transform::Identity);
-        applyTexture(NULL);
+        applyTexture(nullptr);
         if (shaderAvailable)
-            applyShader(NULL);
+            applyShader(nullptr);
 
         m_cache.useVertexCache = false;
 
@@ -459,18 +460,15 @@ void RenderTarget::applyBlendMode(const BlendMode& mode)
             glCheck(GLEXT_glBlendEquation(equationToGlConstant(mode.colorEquation)));
         }
     }
-    else if ((mode.colorEquation != BlendMode::Add) || (mode.alphaEquation != BlendMode::Add))
+    else if ((mode.colorEquation != BlendMode::Equation::Add) || (mode.alphaEquation != BlendMode::Equation::Add))
     {
-        static bool warned = false;
-
-        if (!warned)
+        static std::once_flag warned;
+        std::call_once(warned, []
         {
             err() << "OpenGL extension EXT_blend_minmax and/or EXT_blend_subtract unavailable" << std::endl;
             err() << "Selecting a blend equation not possible" << std::endl;
             err() << "Ensure that hardware acceleration is enabled if available" << std::endl;
-
-            warned = true;
-        }
+        });
     }
 
     m_cache.lastBlendMode = mode;
@@ -489,7 +487,7 @@ void RenderTarget::applyTransform(const Transform& transform)
 ////////////////////////////////////////////////////////////
 void RenderTarget::applyTexture(const Texture* texture)
 {
-    Texture::bind(texture, Texture::Pixels);
+    Texture::bind(texture, Texture::CoordinateType::Pixels);
 
     m_cache.lastTextureId = texture ? texture->m_cacheId : 0;
 }

src/SFML/Graphics/RenderTexture.cpp

@@ -34,18 +34,11 @@
 namespace sf
 {
 ////////////////////////////////////////////////////////////
-RenderTexture::RenderTexture() :
-m_impl(NULL)
-{
-
-}
+RenderTexture::RenderTexture() = default;
 
 
 ////////////////////////////////////////////////////////////
-RenderTexture::~RenderTexture()
-{
-    delete m_impl;
-}
+RenderTexture::~RenderTexture() = default;
 
 
 ////////////////////////////////////////////////////////////
@@ -62,11 +55,10 @@ bool RenderTexture::create(unsigned int width, unsigned int height, bool depthBu
     setSmooth(false);
 
     // Create the implementation
-    delete m_impl;
     if (priv::RenderTextureImplFBO::isAvailable())
     {
         // Use frame-buffer object (FBO)
-        m_impl = new priv::RenderTextureImplFBO;
+        m_impl = std::make_unique<priv::RenderTextureImplFBO>();
 
         // Mark the texture as being a framebuffer object attachment
         m_texture.m_fboAttachment = true;
@@ -74,7 +66,7 @@ bool RenderTexture::create(unsigned int width, unsigned int height, bool depthBu
     else
     {
         // Use default implementation
-        m_impl = new priv::RenderTextureImplDefault;
+        m_impl = std::make_unique<priv::RenderTextureImplDefault>();
     }
 
     // Initialize the render texture

src/SFML/Graphics/RenderTextureImplDefault.cpp

@@ -38,7 +38,6 @@ namespace priv
 {
 ////////////////////////////////////////////////////////////
 RenderTextureImplDefault::RenderTextureImplDefault() :
-m_context(0),
 m_width  (0),
 m_height (0)
 {
@@ -46,14 +45,6 @@ m_height (0)
 }
 
 
-////////////////////////////////////////////////////////////
-RenderTextureImplDefault::~RenderTextureImplDefault()
-{
-    // Destroy the context
-    delete m_context;
-}
-
-
 ////////////////////////////////////////////////////////////
 bool RenderTextureImplDefault::create(unsigned int width, unsigned int height, unsigned int, bool depthBuffer)
 {
@@ -62,7 +53,7 @@ bool RenderTextureImplDefault::create(unsigned int width, unsigned int height, u
     m_height = height;
 
     // Create the in-memory OpenGL context
-    m_context = new Context(ContextSettings(depthBuffer ? 32 : 0), width, height);
+    m_context = std::make_unique<Context>(ContextSettings(depthBuffer ? 32 : 0), width, height);
 
     return true;
 }