diff --git a/examples/sound/Sound.cpp b/examples/sound/Sound.cpp
index fd31ce7aa..89537351c 100644
--- a/examples/sound/Sound.cpp
+++ b/examples/sound/Sound.cpp
@@ -20,9 +20,9 @@ void PlaySound()
 
     // Display sound informations
     std::cout << "canary.wav :" << std::endl;
-    std::cout << " " << buffer.GetDuration() / 1000.f  << " seconds"       << std::endl;
-    std::cout << " " << buffer.GetSampleRate()         << " samples / sec" << std::endl;
-    std::cout << " " << buffer.GetChannelsCount()      << " channels"      << std::endl;
+    std::cout << " " << buffer.GetDuration() / 1000.f << " seconds"       << std::endl;
+    std::cout << " " << buffer.GetSampleRate()        << " samples / sec" << std::endl;
+    std::cout << " " << buffer.GetChannelCount()      << " channels"      << std::endl;
 
     // Create a sound instance and play it
     sf::Sound sound(buffer);
@@ -57,7 +57,7 @@ void PlayMusic()
     std::cout << "orchestral.ogg :" << std::endl;
     std::cout << " " << music.GetDuration() / 1000.f << " seconds"       << std::endl;
     std::cout << " " << music.GetSampleRate()        << " samples / sec" << std::endl;
-    std::cout << " " << music.GetChannelsCount()     << " channels"      << std::endl;
+    std::cout << " " << music.GetChannelCount()      << " channels"      << std::endl;
 
     // Play it
     music.Play();
diff --git a/examples/sound_capture/SoundCapture.cpp b/examples/sound_capture/SoundCapture.cpp
index 41b7da765..c6fa35871 100644
--- a/examples/sound_capture/SoundCapture.cpp
+++ b/examples/sound_capture/SoundCapture.cpp
@@ -46,9 +46,9 @@ int main()
 
     // Display captured sound informations
     std::cout << "Sound information :" << std::endl;
-    std::cout << " " << buffer.GetDuration() / 1000.f  << " seconds"           << std::endl;
-    std::cout << " " << buffer.GetSampleRate()         << " samples / seconds" << std::endl;
-    std::cout << " " << buffer.GetChannelsCount()      << " channels"          << std::endl;
+    std::cout << " " << buffer.GetDuration() / 1000.f << " seconds"           << std::endl;
+    std::cout << " " << buffer.GetSampleRate()        << " samples / seconds" << std::endl;
+    std::cout << " " << buffer.GetChannelCount()      << " channels"          << std::endl;
 
     // Choose what to do with the recorded sound data
     char choice;
diff --git a/examples/voip/Client.cpp b/examples/voip/Client.cpp
index f44bb9181..8c2a42a0e 100644
--- a/examples/voip/Client.cpp
+++ b/examples/voip/Client.cpp
@@ -55,12 +55,12 @@ private :
     /// /see SoundRecorder::ProcessSamples
     ///
     ////////////////////////////////////////////////////////////
-    virtual bool OnProcessSamples(const sf::Int16* samples, std::size_t samplesCount)
+    virtual bool OnProcessSamples(const sf::Int16* samples, std::size_t sampleCount)
     {
         // Pack the audio samples into a network packet
         sf::Packet packet;
         packet << audioData;
-        packet.Append(samples, samplesCount * sizeof(sf::Int16));
+        packet.Append(samples, sampleCount * sizeof(sf::Int16));
 
         // Send the audio packet to the server
         return mySocket.Send(packet) == sf::Socket::Done;
diff --git a/examples/voip/Server.cpp b/examples/voip/Server.cpp
index 7b527216d..bdc7853dd 100644
--- a/examples/voip/Server.cpp
+++ b/examples/voip/Server.cpp
@@ -103,7 +103,7 @@ private :
     ////////////////////////////////////////////////////////////
     virtual void OnSeek(sf::Uint32 timeOffset)
     {
-        myOffset = timeOffset * GetSampleRate() * GetChannelsCount() / 1000;
+        myOffset = timeOffset * GetSampleRate() * GetChannelCount() / 1000;
     }
 
     ////////////////////////////////////////////////////////////
@@ -129,7 +129,7 @@ private :
                 const sf::Int16* samples   = reinterpret_cast<const sf::Int16*>(packet.GetData() + 1);
                 std::size_t      nbSamples = (packet.GetDataSize() - 1) / sizeof(sf::Int16);
 
-                // Don't forget that the other thread can access the samples array at any time
+                // 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(myMutex);
diff --git a/include/SFML/Audio/SoundBuffer.hpp b/include/SFML/Audio/SoundBuffer.hpp
index 2e8fe699a..14956a9ef 100644
--- a/include/SFML/Audio/SoundBuffer.hpp
+++ b/include/SFML/Audio/SoundBuffer.hpp
@@ -127,17 +127,17 @@ public :
     /// The assumed format of the audio samples is 16 bits signed integer
     /// (sf::Int16).
     ///
-    /// \param samples       Pointer to the array of samples in memory
-    /// \param samplesCount  Number of samples in the array
-    /// \param channelsCount Number of channels (1 = mono, 2 = stereo, ...)
-    /// \param sampleRate    Sample rate (number of samples to play per second)
+    /// \param samples      Pointer to the array of samples in memory
+    /// \param sampleCount  Number of samples in the array
+    /// \param channelCount Number of channels (1 = mono, 2 = stereo, ...)
+    /// \param sampleRate   Sample rate (number of samples to play per second)
     ///
     /// \return True if loading succeeded, false if it failed
     ///
     /// \see LoadFromFile, LoadFromMemory, SaveToFile
     ///
     ////////////////////////////////////////////////////////////
-    bool LoadFromSamples(const Int16* samples, std::size_t samplesCount, unsigned int channelsCount, unsigned int sampleRate);
+    bool LoadFromSamples(const Int16* samples, std::size_t sampleCount, unsigned int channelCount, unsigned int sampleRate);
 
     ////////////////////////////////////////////////////////////
     /// \brief Save the sound buffer to an audio file
@@ -160,11 +160,11 @@ public :
     ///
     /// The format of the returned samples is 16 bits signed integer
     /// (sf::Int16). The total number of samples in this array
-    /// is given by the GetSamplesCount() function.
+    /// is given by the GetSampleCount() function.
     ///
     /// \return Read-only pointer to the array of sound samples
     ///
-    /// \see GetSamplesCount
+    /// \see GetSampleCount
     ///
     ////////////////////////////////////////////////////////////
     const Int16* GetSamples() const;
@@ -180,7 +180,7 @@ public :
     /// \see GetSamples
     ///
     ////////////////////////////////////////////////////////////
-    std::size_t GetSamplesCount() const;
+    std::size_t GetSampleCount() const;
 
     ////////////////////////////////////////////////////////////
     /// \brief Get the sample rate of the sound
@@ -191,7 +191,7 @@ public :
     ///
     /// \return Sample rate (number of samples per second)
     ///
-    /// \see GetChannelsCount, GetDuration
+    /// \see GetChannelCount, GetDuration
     ///
     ////////////////////////////////////////////////////////////
     unsigned int GetSampleRate() const;
@@ -207,14 +207,14 @@ public :
     /// \see GetSampleRate, GetDuration
     ///
     ////////////////////////////////////////////////////////////
-    unsigned int GetChannelsCount() const;
+    unsigned int GetChannelCount() const;
 
     ////////////////////////////////////////////////////////////
     /// \brief Get the total duration of the sound
     ///
     /// \return Sound duration, in milliseconds
     ///
-    /// \see GetSampleRate, GetChannelsCount
+    /// \see GetSampleRate, GetChannelCount
     ///
     ////////////////////////////////////////////////////////////
     Uint32 GetDuration() const;
@@ -246,13 +246,13 @@ private :
     ////////////////////////////////////////////////////////////
     /// \brief Update the internal buffer with the cached audio samples
     ///
-    /// \param channelsCount Number of channels
-    /// \param sampleRate    Sample rate (number of samples per second)
+    /// \param channelCount Number of channels
+    /// \param sampleRate   Sample rate (number of samples per second)
     ///
     /// \return True on success, false if any error happened
     ///
     ////////////////////////////////////////////////////////////
-    bool Update(unsigned int channelsCount, unsigned int sampleRate);
+    bool Update(unsigned int channelCount, unsigned int sampleRate);
 
     ////////////////////////////////////////////////////////////
     /// \brief Add a sound to the list of sounds that use this buffer
diff --git a/include/SFML/Audio/SoundBufferRecorder.hpp b/include/SFML/Audio/SoundBufferRecorder.hpp
index 7d56bce78..aeea49687 100644
--- a/include/SFML/Audio/SoundBufferRecorder.hpp
+++ b/include/SFML/Audio/SoundBufferRecorder.hpp
@@ -70,13 +70,13 @@ private :
     ////////////////////////////////////////////////////////////
     /// \brief Process a new chunk of recorded samples
     ///
-    /// \param samples      Pointer to the new chunk of recorded samples
-    /// \param samplesCount Number of samples pointed by \a samples
+    /// \param samples     Pointer to the new chunk of recorded samples
+    /// \param sampleCount Number of samples pointed by \a samples
     ///
     /// \return True to continue the capture, or false to stop it
     ///
     ////////////////////////////////////////////////////////////
-    virtual bool OnProcessSamples(const Int16* samples, std::size_t samplesCount);
+    virtual bool OnProcessSamples(const Int16* samples, std::size_t sampleCount);
 
     ////////////////////////////////////////////////////////////
     /// \brief Stop capturing audio data
diff --git a/include/SFML/Audio/SoundRecorder.hpp b/include/SFML/Audio/SoundRecorder.hpp
index 2a3a0e92e..35567efcc 100644
--- a/include/SFML/Audio/SoundRecorder.hpp
+++ b/include/SFML/Audio/SoundRecorder.hpp
@@ -131,13 +131,13 @@ private :
     /// whatever it wants with it (storing it, playing it, sending
     /// it over the network, etc.).
     ///
-    /// \param samples      Pointer to the new chunk of recorded samples
-    /// \param samplesCount Number of samples pointed by \a samples
+    /// \param samples     Pointer to the new chunk of recorded samples
+    /// \param sampleCount Number of samples pointed by \a samples
     ///
     /// \return True to continue the capture, or false to stop it
     ///
     ////////////////////////////////////////////////////////////
-    virtual bool OnProcessSamples(const Int16* samples, std::size_t samplesCount) = 0;
+    virtual bool OnProcessSamples(const Int16* samples, std::size_t sampleCount) = 0;
 
     ////////////////////////////////////////////////////////////
     /// \brief Stop capturing audio data
@@ -238,7 +238,7 @@ private :
 ///         return true;
 ///     }
 ///
-///     virtual bool OnProcessSamples(const Int16* samples, std::size_t samplesCount)
+///     virtual bool OnProcessSamples(const Int16* samples, std::size_t sampleCount)
 ///     {
 ///         // Do something with the new chunk of samples (store them, send them, ...)
 ///         ...
diff --git a/include/SFML/Audio/SoundStream.hpp b/include/SFML/Audio/SoundStream.hpp
index 65200cb85..05073a4cb 100644
--- a/include/SFML/Audio/SoundStream.hpp
+++ b/include/SFML/Audio/SoundStream.hpp
@@ -104,7 +104,7 @@ public :
     /// \return Number of channels
     ///
     ////////////////////////////////////////////////////////////
-    unsigned int GetChannelsCount() const;
+    unsigned int GetChannelCount() const;
 
     ////////////////////////////////////////////////////////////
     /// \brief Get the stream sample rate of the stream
@@ -193,11 +193,11 @@ protected :
     /// It can be called multiple times if the settings of the
     /// audio stream change, but only when the stream is stopped.
     ///
-    /// \param channelsCount Number of channels of the stream
-    /// \param sampleRate    Sample rate, in samples per second
+    /// \param channelCount Number of channels of the stream
+    /// \param sampleRate   Sample rate, in samples per second
     ///
     ////////////////////////////////////////////////////////////
-    void Initialize(unsigned int channelsCount, unsigned int sampleRate);
+    void Initialize(unsigned int channelCount, unsigned int sampleRate);
 
 private :
 
@@ -245,7 +245,7 @@ private :
     /// consumed; it fills it again and inserts it back into the
     /// playing queue.
     ///
-    /// \param buffer Number of the buffer to fill (in [0, BuffersCount])
+    /// \param buffer Number of the buffer to fill (in [0, BufferCount])
     ///
     /// \return True if the stream source has requested to stop, false otherwise
     ///
@@ -273,21 +273,21 @@ private :
 
     enum
     {
-        BuffersCount = 3 ///< Number of audio buffers used by the streaming loop
+        BufferCount = 3 ///< Number of audio buffers used by the streaming loop
     };
 
     ////////////////////////////////////////////////////////////
     // Member data
     ////////////////////////////////////////////////////////////
-    Thread        myThread;                   ///< Thread running the background tasks
-    bool          myIsStreaming;              ///< Streaming state (true = playing, false = stopped)
-    unsigned int  myBuffers[BuffersCount];    ///< Sound buffers used to store temporary audio data
-    unsigned int  myChannelsCount;            ///< Number of channels (1 = mono, 2 = stereo, ...)
-    unsigned int  mySampleRate;               ///< Frequency (samples / second)
-    Uint32        myFormat;                   ///< Format of the internal sound buffers
-    bool          myLoop;                     ///< Loop flag (true to loop, false to play once)
-    Uint64        mySamplesProcessed;         ///< Number of buffers processed since beginning of the stream
-    bool          myEndBuffers[BuffersCount]; ///< Each buffer is marked as "end buffer" or not, for proper duration calculation
+    Thread        myThread;                  ///< Thread running the background tasks
+    bool          myIsStreaming;             ///< Streaming state (true = playing, false = stopped)
+    unsigned int  myBuffers[BufferCount];    ///< Sound buffers used to store temporary audio data
+    unsigned int  myChannelCount;            ///< Number of channels (1 = mono, 2 = stereo, ...)
+    unsigned int  mySampleRate;              ///< Frequency (samples / second)
+    Uint32        myFormat;                  ///< Format of the internal sound buffers
+    bool          myLoop;                    ///< Loop flag (true to loop, false to play once)
+    Uint64        mySamplesProcessed;        ///< Number of buffers processed since beginning of the stream
+    bool          myEndBuffers[BufferCount]; ///< Each buffer is marked as "end buffer" or not, for proper duration calculation
 };
 
 } // namespace sf
@@ -338,11 +338,11 @@ private :
 ///     {
 ///         // Open the source and get audio settings
 ///         ...
-///         unsigned int channelsCount = ...;
+///         unsigned int channelCount = ...;
 ///         unsigned int sampleRate = ...;
 ///
 ///         // Initialize the stream -- important!
-///         Initialize(channelsCount, sampleRate);
+///         Initialize(channelCount, sampleRate);
 ///     }
 ///
 /// private :
diff --git a/include/SFML/Graphics/CircleShape.hpp b/include/SFML/Graphics/CircleShape.hpp
index 446dcc36e..a945f0409 100644
--- a/include/SFML/Graphics/CircleShape.hpp
+++ b/include/SFML/Graphics/CircleShape.hpp
@@ -44,11 +44,11 @@ public :
     ////////////////////////////////////////////////////////////
     /// \brief Default constructor
     ///
-    /// \param radius      Radius of the circle
-    /// \param pointsCount Number of points composing the circle
+    /// \param radius     Radius of the circle
+    /// \param pointCount Number of points composing the circle
     ///
     ////////////////////////////////////////////////////////////
-    explicit CircleShape(float radius = 0, unsigned int pointsCount = 30);
+    explicit CircleShape(float radius = 0, unsigned int pointCount = 30);
 
     ////////////////////////////////////////////////////////////
     /// \brief Set the radius of the circle
@@ -75,20 +75,20 @@ public :
     ///
     /// \param count New number of points of the circle
     ///
-    /// \see GetPointsCount
+    /// \see GetPointCount
     ///
     ////////////////////////////////////////////////////////////
-    void SetPointsCount(unsigned int count);
+    void SetPointCount(unsigned int count);
 
     ////////////////////////////////////////////////////////////
     /// \brief Get the number of points of the shape
     ///
     /// \return Number of points of the shape
     ///
-    /// \see SetPointsCount
+    /// \see SetPointCount
     ///
     ////////////////////////////////////////////////////////////
-    virtual unsigned int GetPointsCount() const;
+    virtual unsigned int GetPointCount() const;
 
     ////////////////////////////////////////////////////////////
     /// \brief Get a point of the shape
@@ -105,8 +105,8 @@ private :
     ////////////////////////////////////////////////////////////
     // Member data
     ////////////////////////////////////////////////////////////
-    float        myRadius;      ///< Radius of the circle
-    unsigned int myPointsCount; ///< Number of points composing the circle
+    float        myRadius;     ///< Radius of the circle
+    unsigned int myPointCount; ///< Number of points composing the circle
 };
 
 } // namespace sf
diff --git a/include/SFML/Graphics/ConvexShape.hpp b/include/SFML/Graphics/ConvexShape.hpp
index 771f15217..0cf92591c 100644
--- a/include/SFML/Graphics/ConvexShape.hpp
+++ b/include/SFML/Graphics/ConvexShape.hpp
@@ -45,30 +45,30 @@ public :
     ////////////////////////////////////////////////////////////
     /// \brief Default constructor
     ///
-    /// \param pointsCount Number of points of the polygon
+    /// \param pointCount Number of points of the polygon
     ///
     ////////////////////////////////////////////////////////////
-    explicit ConvexShape(unsigned int pointsCount = 0);
+    explicit ConvexShape(unsigned int pointCount = 0);
 
     ////////////////////////////////////////////////////////////
     /// \brief Set the number of points of the polygon
     ///
     /// \param count New number of points of the polygon
     ///
-    /// \see GetPointsCount
+    /// \see GetPointCount
     ///
     ////////////////////////////////////////////////////////////
-    void SetPointsCount(unsigned int count);
+    void SetPointCount(unsigned int count);
 
     ////////////////////////////////////////////////////////////
     /// \brief Get the number of points of the polygon
     ///
     /// \return Number of points of the polygon
     ///
-    /// \see SetPointsCount
+    /// \see SetPointCount
     ///
     ////////////////////////////////////////////////////////////
-    virtual unsigned int GetPointsCount() const;
+    virtual unsigned int GetPointCount() const;
 
     ////////////////////////////////////////////////////////////
     /// \brief Set the position of a point
@@ -126,7 +126,7 @@ private :
 /// Usage example:
 /// \code
 /// sf::ConvexShape polygon;
-/// polygon.SetPointsCount(3);
+/// polygon.SetPointCount(3);
 /// polygon.SetPoint(0, sf::Vector2f(0, 0));
 /// polygon.SetPoint(1, sf::Vector2f(0, 10));
 /// polygon.SetPoint(2, sf::Vector2f(25, 5));
diff --git a/include/SFML/Graphics/Image.hpp b/include/SFML/Graphics/Image.hpp
index ff5830ed4..d28c0f3d7 100644
--- a/include/SFML/Graphics/Image.hpp
+++ b/include/SFML/Graphics/Image.hpp
@@ -67,7 +67,7 @@ public :
     ////////////////////////////////////////////////////////////
     /// \brief Create the image from an arry of pixels
     ///
-    /// The \a pixels array is assumed to contain 32-bits RGBA pixels,
+    /// The \a pixel array is assumed to contain 32-bits RGBA pixels,
     /// and have the given \a width and \a height. If not, this is
     /// an undefined behaviour.
     /// If \a pixels is null, an empty image is created.
diff --git a/include/SFML/Graphics/RectangleShape.hpp b/include/SFML/Graphics/RectangleShape.hpp
index 6d3b4c040..3745e03f1 100644
--- a/include/SFML/Graphics/RectangleShape.hpp
+++ b/include/SFML/Graphics/RectangleShape.hpp
@@ -75,7 +75,7 @@ public :
     /// \return Number of points of the shape
     ///
     ////////////////////////////////////////////////////////////
-    virtual unsigned int GetPointsCount() const;
+    virtual unsigned int GetPointCount() const;
 
     ////////////////////////////////////////////////////////////
     /// \brief Get a point of the shape
diff --git a/include/SFML/Graphics/RenderTarget.hpp b/include/SFML/Graphics/RenderTarget.hpp
index e87ffc3b0..bc40ba7b5 100644
--- a/include/SFML/Graphics/RenderTarget.hpp
+++ b/include/SFML/Graphics/RenderTarget.hpp
@@ -189,13 +189,13 @@ public :
     ////////////////////////////////////////////////////////////
     /// \brief Draw primitives defined by an array of vertices
     ///
-    /// \param vertices      Pointer to the vertices
-    /// \param verticesCount Number of vertices in the array
-    /// \param type          Type of primitives to draw
-    /// \param states        Render states to use for drawing
+    /// \param vertices    Pointer to the vertices
+    /// \param vertexCount Number of vertices in the array
+    /// \param type        Type of primitives to draw
+    /// \param states      Render states to use for drawing
     ///
     ////////////////////////////////////////////////////////////
-    void Draw(const Vertex* vertices, unsigned int verticesCount,
+    void Draw(const Vertex* vertices, unsigned int vertexCount,
               PrimitiveType type, const RenderStates& states = RenderStates::Default);
 
     ////////////////////////////////////////////////////////////
diff --git a/include/SFML/Graphics/Shape.hpp b/include/SFML/Graphics/Shape.hpp
index 1b545b418..83d5ce14c 100644
--- a/include/SFML/Graphics/Shape.hpp
+++ b/include/SFML/Graphics/Shape.hpp
@@ -190,12 +190,12 @@ public :
     /// \return Number of points of the shape
     ///
     ////////////////////////////////////////////////////////////
-    virtual unsigned int GetPointsCount() const = 0;
+    virtual unsigned int GetPointCount() const = 0;
 
     ////////////////////////////////////////////////////////////
     /// \brief Get a point of the shape
     ///
-    /// \param index Index of the point to get, in range [0 .. GetPointsCount() - 1]
+    /// \param index Index of the point to get, in range [0 .. GetPointCount() - 1]
     ///
     /// \return Index-th point of the shape
     ///
@@ -243,7 +243,7 @@ protected :
     ///
     /// This function must be called by the derived class everytime
     /// the shape's points change (ie. the result of either
-    /// GetPointsCount or GetPoint is different).
+    /// GetPointCount or GetPoint is different).
     ///
     ////////////////////////////////////////////////////////////
     void Update();
@@ -330,7 +330,7 @@ private :
 ///
 /// You can write your own derived shape class, there are only
 /// two virtual functions to override:
-/// \li GetOutlinePointsCount must return the number of points of the shape
+/// \li GetOutlinePointCount must return the number of points of the shape
 /// \li GetOutlinePoint must return the points of the shape
 ///
 /// \see sf::LineShape, sf::RectangleShape, sf::CircleShape, sf::ConvexShape, sf::Transformable
diff --git a/include/SFML/Graphics/Texture.hpp b/include/SFML/Graphics/Texture.hpp
index 7a2ee5e48..1cbb99628 100644
--- a/include/SFML/Graphics/Texture.hpp
+++ b/include/SFML/Graphics/Texture.hpp
@@ -250,7 +250,7 @@ public :
     ////////////////////////////////////////////////////////////
     /// \brief Update the whole texture from an array of pixels
     ///
-    /// The \a pixels array is assumed to have the same size as
+    /// The \a pixel array is assumed to have the same size as
     /// the \a area rectangle, and to contain 32-bits RGBA pixels.
     ///
     /// No additional check is performed on the size of the pixel
@@ -268,7 +268,7 @@ public :
     ////////////////////////////////////////////////////////////
     /// \brief Update a part of the texture from an array of pixels
     ///
-    /// The size of the \a pixels array must match the \a width and
+    /// The size of the \a pixel array must match the \a width and
     /// \a height arguments, and it must contain 32-bits RGBA pixels.
     ///
     /// No additional check is performed on the size of the pixel
diff --git a/include/SFML/Graphics/VertexArray.hpp b/include/SFML/Graphics/VertexArray.hpp
index 5c8470543..8fc5ef85b 100644
--- a/include/SFML/Graphics/VertexArray.hpp
+++ b/include/SFML/Graphics/VertexArray.hpp
@@ -56,11 +56,11 @@ public :
     ////////////////////////////////////////////////////////////
     /// \brief Construct the vertex array with a type and an initial number of vertices
     ///
-    /// \param type          Type of primitives
-    /// \param verticesCount Initial number of vertices in the array
+    /// \param type        Type of primitives
+    /// \param vertexCount Initial number of vertices in the array
     ///
     ////////////////////////////////////////////////////////////
-    VertexArray(PrimitiveType type, unsigned int verticesCount = 0);
+    VertexArray(PrimitiveType type, unsigned int vertexCount = 0);
 
     ////////////////////////////////////////////////////////////
     /// \brief Return the vertices count
@@ -68,19 +68,19 @@ public :
     /// \return Number of vertices in the array
     ///
     ////////////////////////////////////////////////////////////
-    unsigned int GetVerticesCount() const;
+    unsigned int GetVertexCount() const;
 
     ////////////////////////////////////////////////////////////
     /// \brief Get a read-write access to a vertex by its index
     ///
     /// This function doesn't check \a index, it must be in range
-    /// [0, GetVerticesCount() - 1].
+    /// [0, GetVertexCount() - 1].
     ///
     /// \param index Index of the vertex to get
     ///
     /// \return Reference to the index-th vertex
     ///
-    /// \see GetVerticesCount
+    /// \see GetVertexCount
     ///
     ////////////////////////////////////////////////////////////
     Vertex& operator [](unsigned int index);
@@ -89,13 +89,13 @@ public :
     /// \brief Get a read-only access to a vertex by its index
     ///
     /// This function doesn't check \a index, it must be in range
-    /// [0, GetVerticesCount() - 1].
+    /// [0, GetVertexCount() - 1].
     ///
     /// \param index Index of the vertex to get
     ///
     /// \return Const reference to the index-th vertex
     ///
-    /// \see GetVerticesCount
+    /// \see GetVertexCount
     ///
     ////////////////////////////////////////////////////////////
     const Vertex& operator [](unsigned int index) const;
@@ -120,10 +120,10 @@ public :
     /// If \a count is less than the current size, existing vertices
     /// are removed from the array.
     ///
-    /// \param verticesCount New size of the array (number of vertices)
+    /// \param vertexCount New size of the array (number of vertices)
     ///
     ////////////////////////////////////////////////////////////
-    void Resize(unsigned int verticesCount);
+    void Resize(unsigned int vertexCount);
 
     ////////////////////////////////////////////////////////////
     /// \brief Add a vertex to the array
diff --git a/src/SFML/Audio/AudioDevice.cpp b/src/SFML/Audio/AudioDevice.cpp
index 39d5b9075..5c39e4a50 100644
--- a/src/SFML/Audio/AudioDevice.cpp
+++ b/src/SFML/Audio/AudioDevice.cpp
@@ -99,12 +99,12 @@ bool AudioDevice::IsExtensionSupported(const std::string& extension)
 
 
 ////////////////////////////////////////////////////////////
-int AudioDevice::GetFormatFromChannelsCount(unsigned int channelsCount)
+int AudioDevice::GetFormatFromChannelCount(unsigned int channelCount)
 {
     EnsureALInit();
 
     // Find the good format according to the number of channels
-    switch (channelsCount)
+    switch (channelCount)
     {
         case 1  : return AL_FORMAT_MONO16;
         case 2  : return AL_FORMAT_STEREO16;
diff --git a/src/SFML/Audio/AudioDevice.hpp b/src/SFML/Audio/AudioDevice.hpp
index 334869f9a..5457ab0e5 100644
--- a/src/SFML/Audio/AudioDevice.hpp
+++ b/src/SFML/Audio/AudioDevice.hpp
@@ -75,12 +75,12 @@ public :
     ////////////////////////////////////////////////////////////
     /// \brief Get the OpenAL format that matches the given number of channels
     ///
-    /// \param channelsCount Number of channels
+    /// \param channelCount Number of channels
     ///
     /// \return Corresponding format
     ///
     ////////////////////////////////////////////////////////////
-    static int GetFormatFromChannelsCount(unsigned int channelsCount);
+    static int GetFormatFromChannelCount(unsigned int channelCount);
 };
 
 } // namespace priv
diff --git a/src/SFML/Audio/Music.cpp b/src/SFML/Audio/Music.cpp
index 36dc8822f..3e374d0f0 100644
--- a/src/SFML/Audio/Music.cpp
+++ b/src/SFML/Audio/Music.cpp
@@ -139,14 +139,14 @@ void Music::OnSeek(Uint32 timeOffset)
 void Music::Initialize()
 {
     // Compute the music duration
-    Uint64 samples = myFile->GetSamplesCount();
-    myDuration = static_cast<Uint32>(1000 * samples / myFile->GetSampleRate() / myFile->GetChannelsCount());
+    Uint64 samples = myFile->GetSampleCount();
+    myDuration = static_cast<Uint32>(1000 * samples / myFile->GetSampleRate() / myFile->GetChannelCount());
 
     // Resize the internal buffer so that it can contain 1 second of audio samples
-    mySamples.resize(myFile->GetSampleRate() * myFile->GetChannelsCount());
+    mySamples.resize(myFile->GetSampleRate() * myFile->GetChannelCount());
 
     // Initialize the stream
-    SoundStream::Initialize(myFile->GetChannelsCount(), myFile->GetSampleRate());
+    SoundStream::Initialize(myFile->GetChannelCount(), myFile->GetSampleRate());
 }
 
 } // namespace sf
diff --git a/src/SFML/Audio/SoundBuffer.cpp b/src/SFML/Audio/SoundBuffer.cpp
index 5f5295911..1900eac57 100644
--- a/src/SFML/Audio/SoundBuffer.cpp
+++ b/src/SFML/Audio/SoundBuffer.cpp
@@ -59,7 +59,7 @@ mySounds  () // don't copy the attached sounds
     ALCheck(alGenBuffers(1, &myBuffer));
 
     // Update the internal buffer with the new samples
-    Update(copy.GetChannelsCount(), copy.GetSampleRate());
+    Update(copy.GetChannelCount(), copy.GetSampleRate());
 }
 
 
@@ -110,24 +110,24 @@ bool SoundBuffer::LoadFromStream(InputStream& stream)
 
 
 ////////////////////////////////////////////////////////////
-bool SoundBuffer::LoadFromSamples(const Int16* samples, std::size_t samplesCount, unsigned int channelsCount, unsigned int sampleRate)
+bool SoundBuffer::LoadFromSamples(const Int16* samples, std::size_t sampleCount, unsigned int channelCount, unsigned int sampleRate)
 {
-    if (samples && samplesCount && channelsCount && sampleRate)
+    if (samples && sampleCount && channelCount && sampleRate)
     {
         // Copy the new audio samples
-        mySamples.assign(samples, samples + samplesCount);
+        mySamples.assign(samples, samples + sampleCount);
 
         // Update the internal buffer with the new samples
-        return Update(channelsCount, sampleRate);
+        return Update(channelCount, sampleRate);
     }
     else
     {
         // Error...
         Err() << "Failed to load sound buffer from samples ("
-              << "array: "      << samples       << ", "
-              << "count: "      << samplesCount  << ", "
-              << "channels: "   << channelsCount << ", "
-              << "samplerate: " << sampleRate    << ")"
+              << "array: "      << samples      << ", "
+              << "count: "      << sampleCount  << ", "
+              << "channels: "   << channelCount << ", "
+              << "samplerate: " << sampleRate   << ")"
               << std::endl;
 
         return false;
@@ -140,7 +140,7 @@ bool SoundBuffer::SaveToFile(const std::string& filename) const
 {
     // Create the sound file in write mode
     priv::SoundFile file;
-    if (file.OpenWrite(filename, GetChannelsCount(), GetSampleRate()))
+    if (file.OpenWrite(filename, GetChannelCount(), GetSampleRate()))
     {
         // Write the samples to the opened file
         file.Write(&mySamples[0], mySamples.size());
@@ -162,7 +162,7 @@ const Int16* SoundBuffer::GetSamples() const
 
 
 ////////////////////////////////////////////////////////////
-std::size_t SoundBuffer::GetSamplesCount() const
+std::size_t SoundBuffer::GetSampleCount() const
 {
     return mySamples.size();
 }
@@ -179,12 +179,12 @@ unsigned int SoundBuffer::GetSampleRate() const
 
 
 ////////////////////////////////////////////////////////////
-unsigned int SoundBuffer::GetChannelsCount() const
+unsigned int SoundBuffer::GetChannelCount() const
 {
-    ALint channelsCount;
-    ALCheck(alGetBufferi(myBuffer, AL_CHANNELS, &channelsCount));
+    ALint channelCount;
+    ALCheck(alGetBufferi(myBuffer, AL_CHANNELS, &channelCount));
 
-    return channelsCount;
+    return channelCount;
 }
 
 
@@ -213,16 +213,16 @@ SoundBuffer& SoundBuffer::operator =(const SoundBuffer& right)
 bool SoundBuffer::Initialize(priv::SoundFile& file)
 {
     // Retrieve the sound parameters
-    std::size_t  nbSamples     = file.GetSamplesCount();
-    unsigned int channelsCount = file.GetChannelsCount();
-    unsigned int sampleRate    = file.GetSampleRate();
+    std::size_t  nbSamples    = file.GetSampleCount();
+    unsigned int channelCount = file.GetChannelCount();
+    unsigned int sampleRate   = file.GetSampleRate();
 
     // Read the samples from the provided file
     mySamples.resize(nbSamples);
     if (file.Read(&mySamples[0], nbSamples) == nbSamples)
     {
         // Update the internal buffer with the new samples
-        return Update(channelsCount, sampleRate);
+        return Update(channelCount, sampleRate);
     }
     else
     {
@@ -232,19 +232,19 @@ bool SoundBuffer::Initialize(priv::SoundFile& file)
 
 
 ////////////////////////////////////////////////////////////
-bool SoundBuffer::Update(unsigned int channelsCount, unsigned int sampleRate)
+bool SoundBuffer::Update(unsigned int channelCount, unsigned int sampleRate)
 {
     // Check parameters
-    if (!channelsCount || !sampleRate || mySamples.empty())
+    if (!channelCount || !sampleRate || mySamples.empty())
         return false;
 
     // Find the good format according to the number of channels
-    ALenum format = priv::AudioDevice::GetFormatFromChannelsCount(channelsCount);
+    ALenum format = priv::AudioDevice::GetFormatFromChannelCount(channelCount);
 
     // Check if the format is valid
     if (format == 0)
     {
-        Err() << "Failed to load sound buffer (unsupported number of channels: " << channelsCount << ")" << std::endl;
+        Err() << "Failed to load sound buffer (unsupported number of channels: " << channelCount << ")" << std::endl;
         return false;
     }
 
@@ -253,7 +253,7 @@ bool SoundBuffer::Update(unsigned int channelsCount, unsigned int sampleRate)
     ALCheck(alBufferData(myBuffer, format, &mySamples[0], size, sampleRate));
 
     // Compute the duration
-    myDuration = static_cast<Uint32>(1000 * mySamples.size() / sampleRate / channelsCount);
+    myDuration = static_cast<Uint32>(1000 * mySamples.size() / sampleRate / channelCount);
 
     return true;
 }
diff --git a/src/SFML/Audio/SoundBufferRecorder.cpp b/src/SFML/Audio/SoundBufferRecorder.cpp
index d9ee9598a..8e744ddce 100644
--- a/src/SFML/Audio/SoundBufferRecorder.cpp
+++ b/src/SFML/Audio/SoundBufferRecorder.cpp
@@ -43,9 +43,9 @@ bool SoundBufferRecorder::OnStart()
 
 
 ////////////////////////////////////////////////////////////
-bool SoundBufferRecorder::OnProcessSamples(const Int16* samples, std::size_t samplesCount)
+bool SoundBufferRecorder::OnProcessSamples(const Int16* samples, std::size_t sampleCount)
 {
-    std::copy(samples, samples + samplesCount, std::back_inserter(mySamples));
+    std::copy(samples, samples + sampleCount, std::back_inserter(mySamples));
 
     return true;
 }
diff --git a/src/SFML/Audio/SoundFile.cpp b/src/SFML/Audio/SoundFile.cpp
index 5fb75b635..a34b995c4 100644
--- a/src/SFML/Audio/SoundFile.cpp
+++ b/src/SFML/Audio/SoundFile.cpp
@@ -53,10 +53,10 @@ namespace priv
 {
 ////////////////////////////////////////////////////////////
 SoundFile::SoundFile() :
-myFile         (NULL),
-myNbSamples    (0),
-myChannelsCount(0),
-mySampleRate   (0)
+myFile        (NULL),
+myNbSamples   (0),
+myChannelCount(0),
+mySampleRate  (0)
 {
 
 }
@@ -71,16 +71,16 @@ SoundFile::~SoundFile()
 
 
 ////////////////////////////////////////////////////////////
-std::size_t SoundFile::GetSamplesCount() const
+std::size_t SoundFile::GetSampleCount() const
 {
     return myNbSamples;
 }
 
 
 ////////////////////////////////////////////////////////////
-unsigned int SoundFile::GetChannelsCount() const
+unsigned int SoundFile::GetChannelCount() const
 {
-    return myChannelsCount;
+    return myChannelCount;
 }
 
 
@@ -108,9 +108,9 @@ bool SoundFile::OpenRead(const std::string& filename)
     }
 
     // Set the sound parameters
-    myChannelsCount = fileInfos.channels;
-    mySampleRate    = fileInfos.samplerate;
-    myNbSamples     = static_cast<std::size_t>(fileInfos.frames) * myChannelsCount;
+    myChannelCount = fileInfos.channels;
+    mySampleRate   = fileInfos.samplerate;
+    myNbSamples    = static_cast<std::size_t>(fileInfos.frames) * myChannelCount;
 
     return true;
 }
@@ -145,9 +145,9 @@ bool SoundFile::OpenRead(const void* data, std::size_t sizeInBytes)
     }
 
     // Set the sound parameters
-    myChannelsCount = fileInfos.channels;
-    mySampleRate    = fileInfos.samplerate;
-    myNbSamples     = static_cast<std::size_t>(fileInfos.frames) * myChannelsCount;
+    myChannelCount = fileInfos.channels;
+    mySampleRate   = fileInfos.samplerate;
+    myNbSamples    = static_cast<std::size_t>(fileInfos.frames) * myChannelCount;
 
     return true;
 }
@@ -177,16 +177,16 @@ bool SoundFile::OpenRead(InputStream& stream)
     }
 
     // Set the sound parameters
-    myChannelsCount = fileInfos.channels;
-    mySampleRate    = fileInfos.samplerate;
-    myNbSamples     = static_cast<std::size_t>(fileInfos.frames) * myChannelsCount;
+    myChannelCount = fileInfos.channels;
+    mySampleRate   = fileInfos.samplerate;
+    myNbSamples    = static_cast<std::size_t>(fileInfos.frames) * myChannelCount;
 
     return true;
 }
 
 
 ////////////////////////////////////////////////////////////
-bool SoundFile::OpenWrite(const std::string& filename, unsigned int channelsCount, unsigned int sampleRate)
+bool SoundFile::OpenWrite(const std::string& filename, unsigned int channelCount, unsigned int sampleRate)
 {
     // If the file is already opened, first close it
     if (myFile)
@@ -203,7 +203,7 @@ bool SoundFile::OpenWrite(const std::string& filename, unsigned int channelsCoun
 
     // Fill the sound infos with parameters
     SF_INFO fileInfos;
-    fileInfos.channels   = channelsCount;
+    fileInfos.channels   = channelCount;
     fileInfos.samplerate = sampleRate;
     fileInfos.format     = format | (format == SF_FORMAT_OGG ? SF_FORMAT_VORBIS : SF_FORMAT_PCM_16);
 
@@ -216,9 +216,9 @@ bool SoundFile::OpenWrite(const std::string& filename, unsigned int channelsCoun
     }
 
     // Set the sound parameters
-    myChannelsCount = channelsCount;
-    mySampleRate    = sampleRate;
-    myNbSamples     = 0;
+    myChannelCount = channelCount;
+    mySampleRate   = sampleRate;
+    myNbSamples    = 0;
 
     return true;
 }
diff --git a/src/SFML/Audio/SoundFile.hpp b/src/SFML/Audio/SoundFile.hpp
index 4695df05a..bd75e021e 100644
--- a/src/SFML/Audio/SoundFile.hpp
+++ b/src/SFML/Audio/SoundFile.hpp
@@ -65,7 +65,7 @@ public :
     /// \return Number of samples
     ///
     ////////////////////////////////////////////////////////////
-    std::size_t GetSamplesCount() const;
+    std::size_t GetSampleCount() const;
 
     ////////////////////////////////////////////////////////////
     /// \brief Get the number of channels used by the sound
@@ -73,7 +73,7 @@ public :
     /// \return Number of channels (1 = mono, 2 = stereo)
     ///
     ////////////////////////////////////////////////////////////
-    unsigned int GetChannelsCount() const;
+    unsigned int GetChannelCount() const;
 
     ////////////////////////////////////////////////////////////
     /// \brief Get the sample rate of the sound
@@ -117,19 +117,19 @@ public :
     ////////////////////////////////////////////////////////////
     /// \brief a the sound file for writing
     ///
-    /// \param filename      Path of the sound file to write
-    /// \param channelsCount Number of channels in the sound
-    /// \param sampleRate    Sample rate of the sound
+    /// \param filename     Path of the sound file to write
+    /// \param channelCount Number of channels in the sound
+    /// \param sampleRate   Sample rate of the sound
     ///
     /// \return True if the file was successfully opened
     ///
     ////////////////////////////////////////////////////////////
-    bool OpenWrite(const std::string& filename, unsigned int channelsCount, unsigned int sampleRate);
+    bool OpenWrite(const std::string& filename, unsigned int channelCount, unsigned int sampleRate);
 
     ////////////////////////////////////////////////////////////
     /// \brief Read audio samples from the loaded sound
     ///
-    /// \param data      Pointer to the samples array to fill
+    /// \param data      Pointer to the sample array to fill
     /// \param nbSamples Number of samples to read
     ///
     /// \return Number of samples actually read (may be less than \a nbSamples)
@@ -140,7 +140,7 @@ public :
     ////////////////////////////////////////////////////////////
     /// \brief Write audio samples to the file
     ///
-    /// \param data      Pointer to the samples array to write
+    /// \param data      Pointer to the sample array to write
     /// \param nbSamples Number of samples to write
     ///
     ////////////////////////////////////////////////////////////
@@ -198,11 +198,11 @@ private :
     ////////////////////////////////////////////////////////////
     // Member data
     ////////////////////////////////////////////////////////////
-    SNDFILE*     myFile;          ///< File descriptor
-    Memory       myMemory;        ///< Memory reading info
-    std::size_t  myNbSamples;     ///< Total number of samples in the file
-    unsigned int myChannelsCount; ///< Number of channels used by the sound
-    unsigned int mySampleRate;    ///< Number of samples per second
+    SNDFILE*     myFile;         ///< File descriptor
+    Memory       myMemory;       ///< Memory reading info
+    std::size_t  myNbSamples;    ///< Total number of samples in the file
+    unsigned int myChannelCount; ///< Number of channels used by the sound
+    unsigned int mySampleRate;   ///< Number of samples per second
 };
 
 } // namespace priv
diff --git a/src/SFML/Audio/SoundStream.cpp b/src/SFML/Audio/SoundStream.cpp
index 07b88a0ce..4624d3413 100644
--- a/src/SFML/Audio/SoundStream.cpp
+++ b/src/SFML/Audio/SoundStream.cpp
@@ -42,7 +42,7 @@ namespace sf
 SoundStream::SoundStream() :
 myThread          (&SoundStream::Stream, this),
 myIsStreaming     (false),
-myChannelsCount   (0),
+myChannelCount    (0),
 mySampleRate      (0),
 myFormat          (0),
 myLoop            (false),
@@ -61,20 +61,20 @@ SoundStream::~SoundStream()
 
 
 ////////////////////////////////////////////////////////////
-void SoundStream::Initialize(unsigned int channelsCount, unsigned int sampleRate)
+void SoundStream::Initialize(unsigned int channelCount, unsigned int sampleRate)
 {
-    myChannelsCount = channelsCount;
-    mySampleRate    = sampleRate;
+    myChannelCount = channelCount;
+    mySampleRate   = sampleRate;
 
     // Deduce the format from the number of channels
-    myFormat = priv::AudioDevice::GetFormatFromChannelsCount(channelsCount);
+    myFormat = priv::AudioDevice::GetFormatFromChannelCount(channelCount);
 
     // Check if the format is valid
     if (myFormat == 0)
     {
-        myChannelsCount = 0;
-        mySampleRate    = 0;
-        Err() << "Unsupported number of channels (" << myChannelsCount << ")" << std::endl;
+        myChannelCount = 0;
+        mySampleRate   = 0;
+        Err() << "Unsupported number of channels (" << myChannelCount << ")" << std::endl;
     }
 }
 
@@ -123,9 +123,9 @@ void SoundStream::Stop()
 
 
 ////////////////////////////////////////////////////////////
-unsigned int SoundStream::GetChannelsCount() const
+unsigned int SoundStream::GetChannelCount() const
 {
-    return myChannelsCount;
+    return myChannelCount;
 }
 
 
@@ -159,7 +159,7 @@ void SoundStream::SetPlayingOffset(Uint32 timeOffset)
     OnSeek(timeOffset);
 
     // Restart streaming
-    mySamplesProcessed = static_cast<Uint64>(timeOffset) * mySampleRate * myChannelsCount / 1000;
+    mySamplesProcessed = static_cast<Uint64>(timeOffset) * mySampleRate * myChannelCount / 1000;
     myIsStreaming = true;
     myThread.Launch();
 }
@@ -171,7 +171,7 @@ Uint32 SoundStream::GetPlayingOffset() const
     ALfloat seconds = 0.f;
     ALCheck(alGetSourcef(mySource, AL_SEC_OFFSET, &seconds));
 
-    return static_cast<Uint32>(1000 * seconds + 1000 * mySamplesProcessed / mySampleRate / myChannelsCount);
+    return static_cast<Uint32>(1000 * seconds + 1000 * mySamplesProcessed / mySampleRate / myChannelCount);
 }
 
 
@@ -193,8 +193,8 @@ bool SoundStream::GetLoop() const
 void SoundStream::Stream()
 {
     // Create the buffers
-    ALCheck(alGenBuffers(BuffersCount, myBuffers));
-    for (int i = 0; i < BuffersCount; ++i)
+    ALCheck(alGenBuffers(BufferCount, myBuffers));
+    for (int i = 0; i < BufferCount; ++i)
         myEndBuffers[i] = false;
 
     // Fill the queue
@@ -232,7 +232,7 @@ void SoundStream::Stream()
 
             // Find its number
             unsigned int bufferNum = 0;
-            for (int i = 0; i < BuffersCount; ++i)
+            for (int i = 0; i < BufferCount; ++i)
                 if (myBuffers[i] == buffer)
                 {
                     bufferNum = i;
@@ -275,7 +275,7 @@ void SoundStream::Stream()
 
     // Delete the buffers
     ALCheck(alSourcei(mySource, AL_BUFFER, 0));
-    ALCheck(alDeleteBuffers(BuffersCount, myBuffers));
+    ALCheck(alDeleteBuffers(BufferCount, myBuffers));
 }
 
 
@@ -332,7 +332,7 @@ bool SoundStream::FillQueue()
 {
     // Fill and enqueue all the available buffers
     bool requestStop = false;
-    for (int i = 0; (i < BuffersCount) && !requestStop; ++i)
+    for (int i = 0; (i < BufferCount) && !requestStop; ++i)
     {
         if (FillAndPushBuffer(i))
             requestStop = true;
diff --git a/src/SFML/Graphics/CircleShape.cpp b/src/SFML/Graphics/CircleShape.cpp
index 4d6b0e89d..7f4318bd6 100644
--- a/src/SFML/Graphics/CircleShape.cpp
+++ b/src/SFML/Graphics/CircleShape.cpp
@@ -32,9 +32,9 @@
 namespace sf
 {
 ////////////////////////////////////////////////////////////
-CircleShape::CircleShape(float radius, unsigned int pointsCount) :
-myRadius     (radius),
-myPointsCount(pointsCount)
+CircleShape::CircleShape(float radius, unsigned int pointCount) :
+myRadius    (radius),
+myPointCount(pointCount)
 {
     Update();
 }
@@ -56,16 +56,16 @@ float CircleShape::GetRadius() const
 
 
 ////////////////////////////////////////////////////////////
-void CircleShape::SetPointsCount(unsigned int count)
+void CircleShape::SetPointCount(unsigned int count)
 {
-    myPointsCount = count;
+    myPointCount = count;
     Update();
 }
 
 ////////////////////////////////////////////////////////////
-unsigned int CircleShape::GetPointsCount() const
+unsigned int CircleShape::GetPointCount() const
 {
-    return myPointsCount;
+    return myPointCount;
 }
 
 
@@ -74,7 +74,7 @@ Vector2f CircleShape::GetPoint(unsigned int index) const
 {
     static const float pi = 3.141592654f;
 
-    float angle = index * 2 * pi / myPointsCount - pi / 2;
+    float angle = index * 2 * pi / myPointCount - pi / 2;
     float x = std::cos(angle) * myRadius;
     float y = std::sin(angle) * myRadius;
 
diff --git a/src/SFML/Graphics/ConvexShape.cpp b/src/SFML/Graphics/ConvexShape.cpp
index d60b583b9..786024a01 100644
--- a/src/SFML/Graphics/ConvexShape.cpp
+++ b/src/SFML/Graphics/ConvexShape.cpp
@@ -31,14 +31,14 @@
 namespace sf
 {
 ////////////////////////////////////////////////////////////
-ConvexShape::ConvexShape(unsigned int pointsCount)
+ConvexShape::ConvexShape(unsigned int pointCount)
 {
-    SetPointsCount(pointsCount);
+    SetPointCount(pointCount);
 }
 
 
 ////////////////////////////////////////////////////////////
-void ConvexShape::SetPointsCount(unsigned int count)
+void ConvexShape::SetPointCount(unsigned int count)
 {
     myPoints.resize(count);
     Update();
@@ -46,7 +46,7 @@ void ConvexShape::SetPointsCount(unsigned int count)
 
 
 ////////////////////////////////////////////////////////////
-unsigned int ConvexShape::GetPointsCount() const
+unsigned int ConvexShape::GetPointCount() const
 {
     return myPoints.size();
 }
diff --git a/src/SFML/Graphics/RectangleShape.cpp b/src/SFML/Graphics/RectangleShape.cpp
index 0d49192df..342e30d2e 100644
--- a/src/SFML/Graphics/RectangleShape.cpp
+++ b/src/SFML/Graphics/RectangleShape.cpp
@@ -54,7 +54,7 @@ const Vector2f& RectangleShape::GetSize() const
 
 
 ////////////////////////////////////////////////////////////
-unsigned int RectangleShape::GetPointsCount() const
+unsigned int RectangleShape::GetPointCount() const
 {
     return 4;
 }
diff --git a/src/SFML/Graphics/RenderTarget.cpp b/src/SFML/Graphics/RenderTarget.cpp
index cea7386bd..113e666e4 100644
--- a/src/SFML/Graphics/RenderTarget.cpp
+++ b/src/SFML/Graphics/RenderTarget.cpp
@@ -127,21 +127,21 @@ void RenderTarget::Draw(const Drawable& drawable, const RenderStates& states)
 
 
 ////////////////////////////////////////////////////////////
-void RenderTarget::Draw(const Vertex* vertices, unsigned int verticesCount,
+void RenderTarget::Draw(const Vertex* vertices, unsigned int vertexCount,
                         PrimitiveType type, const RenderStates& states)
 {
     // Nothing to draw?
-    if (!vertices || (verticesCount == 0))
+    if (!vertices || (vertexCount == 0))
         return;
 
     if (Activate(true))
     {
         // Check if the vertex count is low enough so that we can pre-transform them
-        bool useVertexCache = (verticesCount <= StatesCache::VertexCacheSize);
+        bool useVertexCache = (vertexCount <= StatesCache::VertexCacheSize);
         if (useVertexCache)
         {
             // Pre-transform the vertices and store them into the vertex cache
-            for (unsigned int i = 0; i < verticesCount; ++i)
+            for (unsigned int i = 0; i < vertexCount; ++i)
             {
                 Vertex& vertex = myCache.VertexCache[i];
                 vertex.Position = states.Transform * vertices[i].Position;
@@ -200,7 +200,7 @@ void RenderTarget::Draw(const Vertex* vertices, unsigned int verticesCount,
         GLenum mode = modes[type];
 
         // Draw the primitives
-        GLCheck(glDrawArrays(mode, 0, verticesCount));
+        GLCheck(glDrawArrays(mode, 0, vertexCount));
 
         // Unbind the shader, if any
         if (states.Shader)
diff --git a/src/SFML/Graphics/Shape.cpp b/src/SFML/Graphics/Shape.cpp
index de585e92e..4b39b8a0f 100644
--- a/src/SFML/Graphics/Shape.cpp
+++ b/src/SFML/Graphics/Shape.cpp
@@ -169,7 +169,7 @@ myBounds          ()
 void Shape::Update()
 {
     // Get the total number of points of the shape
-    unsigned int count = GetPointsCount();
+    unsigned int count = GetPointCount();
     if (count < 3)
     {
         myVertices.Resize(0);
@@ -227,7 +227,7 @@ void Shape::Draw(RenderTarget& target, RenderStates states) const
 ////////////////////////////////////////////////////////////
 void Shape::UpdateFillColors()
 {
-    for (unsigned int i = 0; i < myVertices.GetVerticesCount(); ++i)
+    for (unsigned int i = 0; i < myVertices.GetVertexCount(); ++i)
         myVertices[i].Color = myFillColor;
 }
 
@@ -235,7 +235,7 @@ void Shape::UpdateFillColors()
 ////////////////////////////////////////////////////////////
 void Shape::UpdateTexCoords()
 {
-    for (unsigned int i = 0; i < myVertices.GetVerticesCount(); ++i)
+    for (unsigned int i = 0; i < myVertices.GetVertexCount(); ++i)
     {
         float xratio = (myVertices[i].Position.x - myInsideBounds.Left) / myInsideBounds.Width;
         float yratio = (myVertices[i].Position.y - myInsideBounds.Top) / myInsideBounds.Height;
@@ -248,7 +248,7 @@ void Shape::UpdateTexCoords()
 ////////////////////////////////////////////////////////////
 void Shape::UpdateOutline()
 {
-    unsigned int count = myVertices.GetVerticesCount() - 2;
+    unsigned int count = myVertices.GetVertexCount() - 2;
     myOutlineVertices.Resize((count + 1) * 2);
 
     for (unsigned int i = 0; i < count; ++i)
@@ -288,7 +288,7 @@ void Shape::UpdateOutline()
 ////////////////////////////////////////////////////////////
 void Shape::UpdateOutlineColors()
 {
-    for (unsigned int i = 0; i < myOutlineVertices.GetVerticesCount(); ++i)
+    for (unsigned int i = 0; i < myOutlineVertices.GetVertexCount(); ++i)
         myOutlineVertices[i].Color = myOutlineColor;
 }
 
diff --git a/src/SFML/Graphics/Text.cpp b/src/SFML/Graphics/Text.cpp
index a602818ba..ae7016121 100644
--- a/src/SFML/Graphics/Text.cpp
+++ b/src/SFML/Graphics/Text.cpp
@@ -106,7 +106,7 @@ void Text::SetColor(const Color& color)
     if (color != myColor)
     {
         myColor = color;
-        for (unsigned int i = 0; i < myVertices.GetVerticesCount(); ++i)
+        for (unsigned int i = 0; i < myVertices.GetVertexCount(); ++i)
             myVertices[i].Color = myColor;
     }
 }
diff --git a/src/SFML/Graphics/VertexArray.cpp b/src/SFML/Graphics/VertexArray.cpp
index eeb1d2300..7d93e4eb5 100644
--- a/src/SFML/Graphics/VertexArray.cpp
+++ b/src/SFML/Graphics/VertexArray.cpp
@@ -40,15 +40,15 @@ myPrimitiveType(Points)
 
 
 ////////////////////////////////////////////////////////////
-VertexArray::VertexArray(PrimitiveType type, unsigned int verticesCount) :
-myVertices     (verticesCount),
+VertexArray::VertexArray(PrimitiveType type, unsigned int vertexCount) :
+myVertices     (vertexCount),
 myPrimitiveType(type)
 {
 }
 
 
 ////////////////////////////////////////////////////////////
-unsigned int VertexArray::GetVerticesCount() const
+unsigned int VertexArray::GetVertexCount() const
 {
     return myVertices.size();
 }
@@ -76,9 +76,9 @@ void VertexArray::Clear()
 
 
 ////////////////////////////////////////////////////////////
-void VertexArray::Resize(unsigned int verticesCount)
+void VertexArray::Resize(unsigned int vertexCount)
 {
-    myVertices.resize(verticesCount);
+    myVertices.resize(vertexCount);
 }
 
 
diff --git a/src/SFML/Window/Win32/WindowImplWin32.cpp b/src/SFML/Window/Win32/WindowImplWin32.cpp
index 4f7320692..f948723d1 100644
--- a/src/SFML/Window/Win32/WindowImplWin32.cpp
+++ b/src/SFML/Window/Win32/WindowImplWin32.cpp
@@ -290,7 +290,7 @@ void WindowImplWin32::SetIcon(unsigned int width, unsigned int height, const Uin
         iconPixels[i * 4 + 3] = pixels[i * 4 + 3];
     }
 
-    // Create the icon from the pixels array
+    // Create the icon from the pixel array
     myIcon = CreateIcon(GetModuleHandle(NULL), width, height, 1, 32, NULL, &iconPixels[0]);
 
     // Set it as both big and small icon of the window