*important* sf::Rect now uses Width/Height instead of Right/Bottom

Removed Offset, GetSize and GetCenter functions from sf::Rect
Added a sf::Rect constructor taking two Vector2 parameters
Updated the API documentation of the sf::Rect class

git-svn-id: https://sfml.svn.sourceforge.net/svnroot/sfml/branches/sfml2@1503 4e206d99-4929-0410-ac5d-dfc041789085

include/SFML/Graphics/Rect.hpp

@@ -35,8 +35,8 @@
 namespace sf
 {
 ////////////////////////////////////////////////////////////
-/// Rect is an utility class for manipulating rectangles.
+/// \brief Utility class for manipulating 2D axis aligned rectangles
-/// Template parameter defines the type of coordinates (integer, float, ...)
+///
 ////////////////////////////////////////////////////////////
 template <typename T>
 class Rect
@@ -44,94 +44,89 @@ class Rect
 public :
 
     ////////////////////////////////////////////////////////////
-    /// Default constructor
+    /// \brief Default constructor
+    ///
+    /// Creates an empty rectangle (it is equivalent to calling
+    /// Rect(0, 0, 0, 0)).
     ///
     ////////////////////////////////////////////////////////////
     Rect();
 
     ////////////////////////////////////////////////////////////
-    /// Construct the rectangle from its coordinates
+    /// \brief Construct the rectangle from its coordinates
     ///
-    /// \param left :   Left coordinate of the rectangle
+    /// Be careful, the last two parameters are the width
-    /// \param top :    Top coordinate of the rectangle
+    /// and height, not the right and bottom coordinates!
-    /// \param right :  Right coordinate of the rectangle
+    ///
-    /// \param bottom : Bottom coordinate of the rectangle
+    /// \param left   Left coordinate of the rectangle
+    /// \param top    Top coordinate of the rectangle
+    /// \param width  Width of the rectangle
+    /// \param height Height of the rectangle
     ///
     ////////////////////////////////////////////////////////////
-    Rect(T left, T top, T right, T bottom);
+    Rect(T left, T top, T width, T height);
 
     ////////////////////////////////////////////////////////////
-    /// Get the size of the rectangle
+    /// \brief Construct the rectangle from position and size
     ///
-    /// \return Size of rectangle
+    /// Be careful, the last parameter is the size,
+    /// not the bottom-right corner!
+    ///
+    /// \param position Position of the top-left corner of the rectangle
+    /// \param size     Size of the rectangle
     ///
     ////////////////////////////////////////////////////////////
-    Vector2<T> GetSize() const;
+    Rect(const Vector2<T>& position, const Vector2<T>& size);
 
     ////////////////////////////////////////////////////////////
-    /// Get the center of the rectangle
+    /// \brief Check if a point is inside the rectangle's area
     ///
-    /// \return Center of rectangle
+    /// \param x X coordinate of the point to test
+    /// \param y Y coordinate of the point to test
     ///
-    ////////////////////////////////////////////////////////////
+    /// \return True if the point is inside, false otherwise
-    Vector2<T> GetCenter() const;
-
-    ////////////////////////////////////////////////////////////
-    /// Move the whole rectangle by the given offset
     ///
-    /// \param offsetX : Horizontal offset
+    /// \see Intersects
-    /// \param offsetY : Vertical offset
-    ///
-    ////////////////////////////////////////////////////////////
-    void Offset(T offsetX, T offsetY);
-
-    ////////////////////////////////////////////////////////////
-    /// Move the whole rectangle by the given offset
-    ///
-    /// \param offset : Offset to apply to the current position
-    ///
-    ////////////////////////////////////////////////////////////
-    void Offset(const Vector2<T>& offset);
-
-    ////////////////////////////////////////////////////////////
-    /// Check if a point is inside the rectangle's area
-    ///
-    /// \param x : X coordinate of the point to test
-    /// \param y : Y coordinate of the point to test
-    ///
-    /// \return True if the point is inside
     ///
     ////////////////////////////////////////////////////////////
     bool Contains(T x, T y) const;
 
     ////////////////////////////////////////////////////////////
-    /// Check if a point is inside the rectangle's area
+    /// \brief Check if a point is inside the rectangle's area
     ///
-    /// \param point : Point to test
+    /// \param point Point to test
     ///
-    /// \return True if the point is inside
+    /// \return True if the point is inside, false otherwise
+    ///
+    /// \see Intersects
     ///
     ////////////////////////////////////////////////////////////
     bool Contains(const Vector2<T>& point) const;
 
     ////////////////////////////////////////////////////////////
-    /// Check intersection between two rectangles
+    /// \brief Check the intersection between two rectangles
     ///
-    /// \param rectangle : Rectangle to test
+    /// \param rectangle Rectangle to test
     ///
-    /// \return True if rectangles overlap
+    /// \return True if rectangles overlap, false otherwise
+    ///
+    /// \see Contains
     ///
     ////////////////////////////////////////////////////////////
     bool Intersects(const Rect<T>& rectangle) const;
 
     ////////////////////////////////////////////////////////////
-    /// Check intersection between two rectangles and return the
+    /// \brief Check the intersection between two rectangles
-    /// resulting rectangle
     ///
-    /// \param rectangle :    Rectangle to test
+    /// This overload returns the overlapped rectangle in the
-    /// \param intersection : Rectangle to be filled with the intersection of both rectangles
+    /// \a intersection parameter.
     ///
-    /// \return True if rectangles overlap
+    /// \param rectangle    Rectangle to test
+    /// \param intersection Rectangle to be filled with the intersection
+    ///
+    /// \return True if rectangles overlap, false otherwise
+    ///
+    /// \see Contains
     ///
     ////////////////////////////////////////////////////////////
     bool Intersects(const Rect<T>& rectangle, Rect<T>& intersection) const;
@@ -141,13 +136,13 @@ public :
     ////////////////////////////////////////////////////////////
     T Left;   ///< Left coordinate of the rectangle
     T Top;    ///< Top coordinate of the rectangle
-    T Right;  ///< Right coordinate of the rectangle
+    T Width;  ///< Width of the rectangle
-    T Bottom; ///< Bottom coordinate of the rectangle
+    T Height; ///< Height of the rectangle
 };
 
 #include <SFML/Graphics/Rect.inl>
 
-// Define the most common types
+// Create typedefs for the most common types
 typedef Rect<int>   IntRect;
 typedef Rect<float> FloatRect;
 
@@ -155,3 +150,54 @@ typedef Rect<float> FloatRect;
 
 
 #endif // SFML_RECT_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Rect
+///
+/// A rectangle is defined by its top-left corner and its size.
+/// It is a very simple class defined for convenience, so
+/// its member variables (Left, Top, Width and Height) are public
+/// and can be accessed directly, just like the vector classes
+/// (Vector2 and Vector3).
+///
+/// To keep things simple, sf::Rect doesn't define
+/// functions to emulate the properties that are not directly
+/// members (such as Right, Bottom, Center, etc.), it rather
+/// only provides intersection functions.
+///
+/// sf::Rect uses the usual rules for its boundaries:
+/// \li The Left and Top edges are included in the rectangle's area
+/// \li The right (Left + Width) and bottom (Top + Height) edges are excluded from the rectangle's area
+///
+/// This means that sf::IntRect(0, 0, 1, 1) and sf::IntRect(1, 1, 1, 1)
+/// don't intersect.
+///
+/// sf::Rect is a template and may be used with any numeric type, but
+/// for simplicity the instanciations used by SFML are typedefed:
+/// \li sf::Rect<int> is sf::IntRect
+/// \li sf::Rect<float> is sf::FloatRect
+///
+/// So that you don't have to care about the template syntax.
+///
+/// Usage example:
+/// \code
+/// // Define a rectangle, located at (0, 0) with a size of 20x5
+/// sf::IntRect r1(0, 0, 20, 5);
+///
+/// // Define another rectangle, located at (4, 2) with a size of 18x10
+/// sf::Vector2i position(4, 2);
+/// sf::Vector2i size(18, 10);
+/// sf::IntRect r2(position, size);
+///
+/// // Test intersections with the point (3, 1)
+/// bool b1 = r1.Contains(3, 1); // true
+/// bool b2 = r2.Contains(3, 1); // false
+///
+/// // Test the intersection between r1 and r2
+/// sf::IntRect result;
+/// bool b3 = r1.Intersects(r2, result); // true
+/// // result == (4, 2, 16, 3)
+/// \endcode
+///
+////////////////////////////////////////////////////////////

include/SFML/Graphics/Rect.inl

@@ -23,89 +23,50 @@
 ////////////////////////////////////////////////////////////
 
 
-////////////////////////////////////////////////////////////
-/// Default constructor
 ////////////////////////////////////////////////////////////
 template <typename T>
 Rect<T>::Rect() :
 Left  (0),
 Top   (0),
-Right (0),
+Width (0),
-Bottom(0)
+Height(0)
 {
 
 }
 
 
-////////////////////////////////////////////////////////////
-/// Construct the color from its coordinates
 ////////////////////////////////////////////////////////////
 template <typename T>
-Rect<T>::Rect(T left, T top, T right, T bottom) :
+Rect<T>::Rect(T left, T top, T width, T height) :
 Left  (left),
 Top   (top),
-Right (right),
+Width (width),
-Bottom(bottom)
+Height(height)
 {
 
 }
 
 
-////////////////////////////////////////////////////////////
-/// Get the size of the rectangle
 ////////////////////////////////////////////////////////////
 template <typename T>
-Vector2<T> Rect<T>::GetSize() const
+Rect<T>::Rect(const Vector2<T>& position, const Vector2<T>& size) :
+Left  (position.x),
+Top   (position.y),
+Width (size.x),
+Height(size.y)
 {
-    return Vector2<T>(Right - Left, Bottom - Top);
+
 }
 
 
-////////////////////////////////////////////////////////////
-/// Get the center of the rectangle
-////////////////////////////////////////////////////////////
-template <typename T>
-Vector2<T> Rect<T>::GetCenter() const
-{
-    return Vector2<T>((Left + Right) / 2, (Top + Bottom) / 2);
-}
-
-
-////////////////////////////////////////////////////////////
-/// Move the whole rectangle by the given offset
-////////////////////////////////////////////////////////////
-template <typename T>
-void Rect<T>::Offset(T offsetX, T offsetY)
-{
-    Left   += offsetX;
-    Right  += offsetX;
-    Top    += offsetY;
-    Bottom += offsetY;
-}
-
-
-////////////////////////////////////////////////////////////
-/// Move the whole rectangle by the given offset
-////////////////////////////////////////////////////////////
-template <typename T>
-void Rect<T>::Offset(const Vector2<T>& offset)
-{
-    Offset(offset.x, offset.y);
-}
-
-
-////////////////////////////////////////////////////////////
-/// Check if a point is inside the rectangle's area
 ////////////////////////////////////////////////////////////
 template <typename T>
 bool Rect<T>::Contains(T x, T y) const
 {
-    return (x >= Left) && (x <= Right) && (y >= Top) && (y <= Bottom);
+    return (x >= Left) && (x < Left + Width) && (y >= Top) && (y < Top + Height);
 }
 
 
-////////////////////////////////////////////////////////////
-/// Check if a point is inside the rectangle's area
 ////////////////////////////////////////////////////////////
 template <typename T>
 bool Rect<T>::Contains(const Vector2<T>& point) const
@@ -114,40 +75,29 @@ bool Rect<T>::Contains(const Vector2<T>& point) const
 }
 
 
-////////////////////////////////////////////////////////////
-/// Check intersection between two rectangles
 ////////////////////////////////////////////////////////////
 template <typename T>
 bool Rect<T>::Intersects(const Rect<T>& rectangle) const
 {
-    // Compute overlapping rect
+    Rect<T> intersection;
-    Rect<T> overlapping(std::max(Left,   rectangle.Left),
+    return Intersects(rectangle, intersection);
-                        std::max(Top,    rectangle.Top),
-                        std::min(Right,  rectangle.Right),
-                        std::min(Bottom, rectangle.Bottom));
-
-    // If overlapping rect is valid, then there is intersection
-    return (overlapping.Left < overlapping.Right) && (overlapping.Top < overlapping.Bottom);
 }
 
 
-////////////////////////////////////////////////////////////
-/// Check intersection between two rectangles and return the
-/// resulting rectangle
 ////////////////////////////////////////////////////////////
 template <typename T>
 bool Rect<T>::Intersects(const Rect<T>& rectangle, Rect<T>& intersection) const
 {
-    // Compute overlapping rect
+    // Compute the intersection boundaries
-    Rect<T> overlapping(std::max(Left,   rectangle.Left),
+    T left   = std::max(Left,         rectangle.Left);
-                        std::max(Top,    rectangle.Top),
+    T top    = std::max(Top,          rectangle.Top);
-                        std::min(Right,  rectangle.Right),
+    T right  = std::min(Left + Width, rectangle.Left + rectangle.Width);
-                        std::min(Bottom, rectangle.Bottom));
+    T bottom = std::min(Top + Height, rectangle.Top + rectangle.Height);
 
-    // If overlapping rect is valid, then there is intersection
+    // If the intersection is valid (positive non zero area), then there is an intersection
-    if ((overlapping.Left < overlapping.Right) && (overlapping.Top < overlapping.Bottom))
+    if ((left < right) && (top < bottom))
     {
-        intersection = overlapping;
+        intersection = Rect<T>(left, top, right - left, bottom - top);
         return true;
     }
     else

include/SFML/Graphics/View.hpp

@@ -320,8 +320,8 @@ private :
 /// sf::RenderWindow window;
 /// sf::View view;
 /// 
-/// // Initialize the view to a rectangle going from (100, 100) to (500, 300)
+/// // Initialize the view to a rectangle located at (100, 100) and with a size of 400x200
-/// view.Reset(sf::FloatRect(100, 100, 500, 300));
+/// view.Reset(sf::FloatRect(100, 100, 400, 200));
 ///
 /// // Rotate it by 45 degrees
 /// view.Rotate(45);

include/SFML/Network/Ftp.hpp

@@ -39,7 +39,7 @@ namespace sf
 class IpAddress;
 
 ////////////////////////////////////////////////////////////
-/// \li A FTP client
+/// \brief A FTP client
 ///
 ////////////////////////////////////////////////////////////
 class SFML_API Ftp : NonCopyable

src/SFML/Graphics/Font.cpp

@@ -369,8 +369,8 @@ Glyph Font::LoadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold) c
         // Compute the glyph's bounding box
         glyph.Bounds.Left   = bitmapGlyph->left - padding;
         glyph.Bounds.Top    = -bitmapGlyph->top - padding;
-        glyph.Bounds.Right  = bitmapGlyph->left + width + padding;
+        glyph.Bounds.Width  = width + 2 * padding;
-        glyph.Bounds.Bottom = -bitmapGlyph->top + height + padding;
+        glyph.Bounds.Height = height + 2 * padding;
 
         // Extract the glyph's pixels from the bitmap
         myPixelBuffer.resize(width * height * 4, 255);
@@ -408,8 +408,8 @@ Glyph Font::LoadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold) c
         IntRect subrect = glyph.SubRect;
         subrect.Left   += padding;
         subrect.Top    += padding;
-        subrect.Right  -= padding;
+        subrect.Width  -= 2 * padding;
-        subrect.Bottom -= padding;
+        subrect.Height -= 2 * padding;
         page.Texture.UpdatePixels(&myPixelBuffer[0], subrect);
     }
 
@@ -481,7 +481,7 @@ IntRect Font::FindGlyphRect(Page& page, unsigned int width, unsigned int height)
     }
 
     // Find the glyph's rectangle on the selected row
-    IntRect rect(row->Width, row->Top, row->Width + width, row->Top + height);
+    IntRect rect(row->Width, row->Top, width, height);
 
     // Update the row informations
     row->Width += width;

src/SFML/Graphics/Image.cpp

@@ -272,24 +272,24 @@ void Image::Copy(const Image& source, unsigned int destX, unsigned int destY, co
 
     // Adjust the source rectangle
     IntRect srcRect = sourceRect;
-    if (srcRect.GetSize().x == 0 || (srcRect.GetSize().y == 0))
+    if (srcRect.Width == 0 || (srcRect.Height == 0))
     {
         srcRect.Left   = 0;
         srcRect.Top    = 0;
-        srcRect.Right  = source.myWidth;
+        srcRect.Width  = source.myWidth;
-        srcRect.Bottom = source.myHeight;
+        srcRect.Height = source.myHeight;
     }
     else
     {
         if (srcRect.Left   < 0) srcRect.Left = 0;
         if (srcRect.Top    < 0) srcRect.Top  = 0;
-        if (srcRect.Right  > static_cast<int>(source.myWidth))  srcRect.Right  = source.myWidth;
+        if (srcRect.Width  > static_cast<int>(source.myWidth))  srcRect.Width  = source.myWidth;
-        if (srcRect.Bottom > static_cast<int>(source.myHeight)) srcRect.Bottom = source.myHeight;
+        if (srcRect.Height > static_cast<int>(source.myHeight)) srcRect.Height = source.myHeight;
     }
 
     // Then find the valid bounds of the destination rectangle
-    int width  = srcRect.GetSize().x;
+    int width  = srcRect.Width;
-    int height = srcRect.GetSize().y;
+    int height = srcRect.Height;
     if (destX + width  > myWidth)  width  = myWidth  - destX;
     if (destY + height > myHeight) height = myHeight - destY;
 
@@ -353,24 +353,24 @@ bool Image::CopyScreen(RenderWindow& window, const IntRect& sourceRect)
 {
     // Adjust the source rectangle
     IntRect srcRect = sourceRect;
-    if (srcRect.GetSize().x == 0 || (srcRect.GetSize().y == 0))
+    if (srcRect.Width == 0 || (srcRect.Height == 0))
     {
         srcRect.Left   = 0;
         srcRect.Top    = 0;
-        srcRect.Right  = window.GetWidth();
+        srcRect.Width  = window.GetWidth();
-        srcRect.Bottom = window.GetHeight();
+        srcRect.Height = window.GetHeight();
     }
     else
     {
         if (srcRect.Left   < 0) srcRect.Left = 0;
         if (srcRect.Top    < 0) srcRect.Top  = 0;
-        if (srcRect.Right  > static_cast<int>(window.GetWidth()))  srcRect.Right  = window.GetWidth();
+        if (srcRect.Width  > static_cast<int>(window.GetWidth()))  srcRect.Width  = window.GetWidth();
-        if (srcRect.Bottom > static_cast<int>(window.GetHeight())) srcRect.Bottom = window.GetHeight();
+        if (srcRect.Height > static_cast<int>(window.GetHeight())) srcRect.Height = window.GetHeight();
     }
 
     // Store the texture dimensions
-    myWidth  = srcRect.GetSize().x;
+    myWidth  = srcRect.Width;
-    myHeight = srcRect.GetSize().y;
+    myHeight = srcRect.Height;
 
     // We can then create the texture
     if (window.SetActive() && CreateTexture())
@@ -486,7 +486,7 @@ void Image::UpdatePixels(const Uint8* pixels, const IntRect& rectangle)
 
     // Update the texture from the array of pixels
     GLCheck(glBindTexture(GL_TEXTURE_2D, myTexture));
-    GLCheck(glTexSubImage2D(GL_TEXTURE_2D, 0, rectangle.Left, rectangle.Top, rectangle.GetSize().x, rectangle.GetSize().y, GL_RGBA, GL_UNSIGNED_BYTE, pixels));
+    GLCheck(glTexSubImage2D(GL_TEXTURE_2D, 0, rectangle.Left, rectangle.Top, rectangle.Width, rectangle.Height, GL_RGBA, GL_UNSIGNED_BYTE, pixels));
 
     GLCheck(glBindTexture(GL_TEXTURE_2D, previous));
 
@@ -573,16 +573,16 @@ FloatRect Image::GetTexCoords(const IntRect& rect) const
         if (myPixelsFlipped)
         {
             return FloatRect(rect.Left   / width,
-                             rect.Bottom / height,
+                             rect.Height / height,
-                             rect.Right  / width,
+                             rect.Width  / width,
                              rect.Top    / height);
         }
         else
         {
             return FloatRect(rect.Left   / width,
                              rect.Top    / height,
-                             rect.Right  / width,
+                             rect.Width  / width,
-                             rect.Bottom / height);
+                             rect.Height / height);
         }
     }
     else

src/SFML/Graphics/RenderTarget.cpp

@@ -153,8 +153,8 @@ IntRect RenderTarget::GetViewport(const View& view) const
 
     return IntRect(static_cast<int>(0.5f + width  * viewport.Left),
                    static_cast<int>(0.5f + height * viewport.Top),
-                   static_cast<int>(0.5f + width  * viewport.Right),
+                   static_cast<int>(width  * viewport.Width),
-                   static_cast<int>(0.5f + height * viewport.Bottom));
+                   static_cast<int>(height * viewport.Height));
 }
 
 
@@ -171,8 +171,8 @@ Vector2f RenderTarget::ConvertCoords(unsigned int x, unsigned int y, const View&
     // First, convert from viewport coordinates to homogeneous coordinates
     Vector2f coords;
     IntRect viewport = GetViewport(view);
-    coords.x = -1.f + 2.f * (static_cast<int>(x) - viewport.Left) / viewport.GetSize().x;
+    coords.x = -1.f + 2.f * (static_cast<int>(x) - viewport.Left) / viewport.Width;
-    coords.y = 1.f  - 2.f * (static_cast<int>(y) - viewport.Top)  / viewport.GetSize().y;
+    coords.y = 1.f  - 2.f * (static_cast<int>(y) - viewport.Top)  / viewport.Height;
 
     // Then transform by the inverse of the view matrix
     return view.GetInverseMatrix().Transform(coords);

src/SFML/Graphics/Renderer.cpp

@@ -173,12 +173,15 @@ void Renderer::ApplyColor(const Color& color)
 ////////////////////////////////////////////////////////////
 void Renderer::SetViewport(const IntRect& viewport)
 {
-    if ((viewport.Left != myViewport.Left) || (viewport.Right  != myViewport.Right)  ||
+    if ((viewport.Left != myViewport.Left) || (viewport.Width  != myViewport.Width)  ||
-        (viewport.Top  != myViewport.Top)  || (viewport.Bottom != myViewport.Bottom) ||
+        (viewport.Top  != myViewport.Top)  || (viewport.Height != myViewport.Height) ||
         !myViewportIsValid)
     {
-        // Apply the new viewport -- revert Y axis to match the OpenGL convention
+        // Revert the Y axis to match the OpenGL convention
-        GLCheck(glViewport(viewport.Left, myTarget.GetHeight() - viewport.Bottom, viewport.GetSize().x, viewport.GetSize().y));
+        int top = myTarget.GetHeight() - (viewport.Top + viewport.Height);
+
+        // Apply the new viewport
+        GLCheck(glViewport(viewport.Left, top, viewport.Width, viewport.Height));
 
         // Store it
         myViewport = viewport;

src/SFML/Graphics/Sprite.cpp

@@ -93,11 +93,8 @@ void Sprite::SetSubRect(const IntRect& rectangle)
 ////////////////////////////////////////////////////////////
 void Sprite::Resize(float width, float height)
 {
-    int localWidth  = mySubRect.GetSize().x;
+    if ((mySubRect.Width > 0) && (mySubRect.Height > 0))
-    int localHeight = mySubRect.GetSize().y;
+        SetScale(width / mySubRect.Width, height / mySubRect.Height);
-
-    if ((localWidth > 0) && (localHeight > 0))
-        SetScale(width / localWidth, height / localHeight);
 }
 
 
@@ -152,7 +149,7 @@ const IntRect& Sprite::GetSubRect() const
 ////////////////////////////////////////////////////////////
 Vector2f Sprite::GetSize() const
 {
-    return Vector2f(mySubRect.GetSize().x * GetScale().x, mySubRect.GetSize().y * GetScale().y);
+    return Vector2f(mySubRect.Width * GetScale().x, mySubRect.Height * GetScale().y);
 }
 
 
@@ -167,8 +164,8 @@ Color Sprite::GetPixel(unsigned int x, unsigned int y) const
         unsigned int imageX = mySubRect.Left + x;
         unsigned int imageY = mySubRect.Top  + y;
 
-        if (myIsFlippedX) imageX = mySubRect.GetSize().x - imageX - 1;
+        if (myIsFlippedX) imageX = mySubRect.Width  - imageX - 1;
-        if (myIsFlippedY) imageY = mySubRect.GetSize().y - imageY - 1;
+        if (myIsFlippedY) imageY = mySubRect.Height - imageY - 1;
 
         return myImage->GetPixel(imageX, imageY) * GetColor();
     }
@@ -185,27 +182,29 @@ Color Sprite::GetPixel(unsigned int x, unsigned int y) const
 void Sprite::Render(RenderTarget&, Renderer& renderer) const
 {
     // Get the sprite size
-    float width  = static_cast<float>(mySubRect.GetSize().x);
+    float width  = static_cast<float>(mySubRect.Width);
-    float height = static_cast<float>(mySubRect.GetSize().y);
+    float height = static_cast<float>(mySubRect.Height);
 
     // Check if the image is valid, and calculate the texture coordinates
     FloatRect coords;
     if (myImage)
     {
         coords = myImage->GetTexCoords(mySubRect);
-        if (myIsFlippedX) std::swap(coords.Left, coords.Right);
+        if (myIsFlippedX) coords.Width  = -coords.Width;
-        if (myIsFlippedY) std::swap(coords.Top, coords.Bottom);
+        if (myIsFlippedY) coords.Height = -coords.Height;
     }
 
     // Bind the texture
     renderer.SetTexture(myImage);
 
     // Draw the sprite's geometry
+    float right  = coords.Left + coords.Width;
+    float bottom = coords.Top + coords.Height;
     renderer.Begin(Renderer::TriangleStrip);
         renderer.AddVertex(0,     0,      coords.Left, coords.Top);
-        renderer.AddVertex(width, 0,      coords.Right, coords.Top);
+        renderer.AddVertex(width, 0,      right,       coords.Top);
-        renderer.AddVertex(0,     height, coords.Left,  coords.Bottom);
+        renderer.AddVertex(0,     height, coords.Left, bottom);
-        renderer.AddVertex(width, height, coords.Right, coords.Bottom);
+        renderer.AddVertex(width, height, right,       bottom);
     renderer.End();
 }
 

src/SFML/Graphics/Text.cpp

@@ -202,8 +202,8 @@ FloatRect Text::GetRect() const
     FloatRect rect;
     rect.Left   = (myBaseRect.Left   - GetOrigin().x) * GetScale().x + GetPosition().x;
     rect.Top    = (myBaseRect.Top    - GetOrigin().y) * GetScale().y + GetPosition().y;
-    rect.Right  = (myBaseRect.Right  - GetOrigin().x) * GetScale().x + GetPosition().x;
+    rect.Width  = myBaseRect.Width  * GetScale().x;
-    rect.Bottom = (myBaseRect.Bottom - GetOrigin().y) * GetScale().y + GetPosition().y;
+    rect.Height = myBaseRect.Height * GetScale().y;
 
     return rect;
 }
@@ -229,6 +229,10 @@ void Text::Render(RenderTarget&, Renderer& renderer) const
     float underlineOffset     = myCharacterSize * 0.1f;
     float underlineThickness  = myCharacterSize * (bold ? 0.1f : 0.07f);
     FloatRect underlineCoords = texture.GetTexCoords(IntRect(1, 1, 1, 1));
+    float underlineLeft       = underlineCoords.Left;
+    float underlineTop        = underlineCoords.Top;
+    float underlineRight      = underlineCoords.Left + underlineCoords.Width;
+    float underlineBottom     = underlineCoords.Top + underlineCoords.Height;
 
     // Initialize the rendering coordinates
     float space       = static_cast<float>(myFont->GetGlyph(L' ', myCharacterSize, bold).Advance);
@@ -257,10 +261,10 @@ void Text::Render(RenderTarget&, Renderer& renderer) const
             float bottom = top + underlineThickness;
 
             renderer.Begin(Renderer::QuadList);
-                renderer.AddVertex(0, top,    underlineCoords.Left,  underlineCoords.Top);
+                renderer.AddVertex(0, top,    underlineLeft,  underlineTop);
-                renderer.AddVertex(x, top,    underlineCoords.Right, underlineCoords.Top);
+                renderer.AddVertex(x, top,    underlineRight, underlineTop);
-                renderer.AddVertex(x, bottom, underlineCoords.Right, underlineCoords.Bottom);
+                renderer.AddVertex(x, bottom, underlineRight, underlineBottom);
-                renderer.AddVertex(0, bottom, underlineCoords.Left,  underlineCoords.Bottom);
+                renderer.AddVertex(0, bottom, underlineLeft,  underlineBottom);
             renderer.End();
         }
 
@@ -279,12 +283,17 @@ void Text::Render(RenderTarget&, Renderer& renderer) const
         const IntRect&   bounds  = glyph.Bounds;
         const FloatRect& coords  = texture.GetTexCoords(glyph.SubRect);
 
+        int   boundsRight  = bounds.Left + bounds.Width;
+        int   boundsBottom = bounds.Top  + bounds.Height;
+        float coordsRight  = coords.Left + coords.Width;
+        float coordsBottom = coords.Top  + coords.Height;
+
         // Draw a textured quad for the current character
         renderer.Begin(Renderer::QuadList);
             renderer.AddVertex(x + bounds.Left - italicCoeff * bounds.Top,   y + bounds.Top,   coords.Left, coords.Top);
-            renderer.AddVertex(x + bounds.Right - italicCoeff * bounds.Top,    y + bounds.Top,    coords.Right, coords.Top);
+            renderer.AddVertex(x + boundsRight - italicCoeff * bounds.Top,   y + bounds.Top,   coordsRight, coords.Top);
-            renderer.AddVertex(x + bounds.Right - italicCoeff * bounds.Bottom, y + bounds.Bottom, coords.Right, coords.Bottom);
+            renderer.AddVertex(x + boundsRight - italicCoeff * boundsBottom, y + boundsBottom, coordsRight, coordsBottom);
-            renderer.AddVertex(x + bounds.Left  - italicCoeff * bounds.Bottom, y + bounds.Bottom, coords.Left,  coords.Bottom);
+            renderer.AddVertex(x + bounds.Left - italicCoeff * boundsBottom, y + boundsBottom, coords.Left, coordsBottom);
         renderer.End();
 
         // Advance to the next character
@@ -298,10 +307,10 @@ void Text::Render(RenderTarget&, Renderer& renderer) const
         float bottom = top + underlineThickness;
 
         renderer.Begin(Renderer::QuadList);
-            renderer.AddVertex(0, top,    underlineCoords.Left,  underlineCoords.Top);
+            renderer.AddVertex(0, top,    underlineLeft,  underlineTop);
-            renderer.AddVertex(x, top,    underlineCoords.Right, underlineCoords.Top);
+            renderer.AddVertex(x, top,    underlineRight, underlineTop);
-            renderer.AddVertex(x, bottom, underlineCoords.Right, underlineCoords.Bottom);
+            renderer.AddVertex(x, bottom, underlineRight, underlineBottom);
-            renderer.AddVertex(0, bottom, underlineCoords.Left,  underlineCoords.Bottom);
+            renderer.AddVertex(0, bottom, underlineLeft,  underlineBottom);
         renderer.End();
     }
 }
@@ -375,7 +384,7 @@ void Text::UpdateRect() const
         curWidth += static_cast<float>(curGlyph.Advance);
 
         // Update the maximum height
-        float charHeight = charSize + curGlyph.Bounds.Bottom;
+        float charHeight = charSize + curGlyph.Bounds.Top + curGlyph.Bounds.Height;
         if (charHeight > curHeight)
             curHeight = charHeight;
     }
@@ -404,8 +413,8 @@ void Text::UpdateRect() const
     // Finally update the rectangle
     myBaseRect.Left   = 0;
     myBaseRect.Top    = 0;
-    myBaseRect.Right  = width;
+    myBaseRect.Width  = width;
-    myBaseRect.Bottom = height;
+    myBaseRect.Height = height;
 }
 
 } // namespace sf

src/SFML/Graphics/View.cpp

@@ -126,8 +126,10 @@ void View::SetViewport(const FloatRect& viewport)
 ////////////////////////////////////////////////////////////
 void View::Reset(const FloatRect& rectangle)
 {
-    myCenter   = rectangle.GetCenter();
+    myCenter.x = (rectangle.Left + rectangle.Width) / 2.f;
-    mySize     = rectangle.GetSize();
+    myCenter.y = (rectangle.Top + rectangle.Height) / 2.f;
+    mySize.x   = rectangle.Width;
+    mySize.y   = rectangle.Height;
     myRotation = 0;
 
     myMatrixUpdated    = false;