Decomposed transform defined by a position, a rotation and a scale. More...
#include <Transformable.hpp>
Public Member Functions  
Transformable ()  
Default constructor.  
virtual  ~Transformable () 
Virtual destructor.  
void  setPosition (float x, float y) 
set the position of the object  
void  setPosition (const Vector2f &position) 
set the position of the object  
void  setRotation (float angle) 
set the orientation of the object  
void  setScale (float factorX, float factorY) 
set the scale factors of the object  
void  setScale (const Vector2f &factors) 
set the scale factors of the object  
void  setOrigin (float x, float y) 
set the local origin of the object  
void  setOrigin (const Vector2f &origin) 
set the local origin of the object  
const Vector2f &  getPosition () const 
get the position of the object  
float  getRotation () const 
get the orientation of the object  
const Vector2f &  getScale () const 
get the current scale of the object  
const Vector2f &  getOrigin () const 
get the local origin of the object  
void  move (float offsetX, float offsetY) 
Move the object by a given offset.  
void  move (const Vector2f &offset) 
Move the object by a given offset.  
void  rotate (float angle) 
Rotate the object.  
void  scale (float factorX, float factorY) 
Scale the object.  
void  scale (const Vector2f &factor) 
Scale the object.  
const Transform &  getTransform () const 
get the combined transform of the object  
const Transform &  getInverseTransform () const 
get the inverse of the combined transform of the object  
Decomposed transform defined by a position, a rotation and a scale.
This class is provided for convenience, on top of sf::Transform.
sf::Transform, as a lowlevel class, offers a great level of flexibility but it is not always convenient to manage. Indeed, one can easily combine any kind of operation, such as a translation followed by a rotation followed by a scaling, but once the result transform is built, there's no way to go backward and, let's say, change only the rotation without modifying the translation and scaling. The entire transform must be recomputed, which means that you need to retrieve the initial translation and scale factors as well, and combine them the same way you did before updating the rotation. This is a tedious operation, and it requires to store all the individual components of the final transform.
That's exactly what sf::Transformable was written for: it hides these variables and the composed transform behind an easy to use interface. You can set or get any of the individual components without worrying about the others. It also provides the composed transform (as a sf::Transform), and keeps it uptodate.
In addition to the position, rotation and scale, sf::Transformable provides an "origin" component, which represents the local origin of the three other components. Let's take an example with a 10x10 pixels sprite. By default, the sprite is positionned/rotated/scaled relatively to its topleft corner, because it is the local point (0, 0). But if we change the origin to be (5, 5), the sprite will be positionned/rotated/scaled around its center instead. And if we set the origin to (10, 10), it will be transformed around its bottomright corner.
To keep the sf::Transformable class simple, there's only one origin for all the components. You cannot position the sprite relatively to its topleft corner while rotating it around its center, for example. To do such things, use sf::Transform directly.
sf::Transformable can be used as a base class. It is often combined with sf::Drawable – that's what SFML's sprites, texts and shapes do.
It can also be used as a member, if you don't want to use its API directly (because you don't need all its functions, or you have different naming conventions for example).
Definition at line 41 of file Transformable.hpp.
sf::Transformable::Transformable  (  ) 
Default constructor.

virtual 
Virtual destructor.
const Transform& sf::Transformable::getInverseTransform  (  )  const 
get the inverse of the combined transform of the object
const Vector2f& sf::Transformable::getOrigin  (  )  const 
const Vector2f& sf::Transformable::getPosition  (  )  const 
float sf::Transformable::getRotation  (  )  const 
get the orientation of the object
The rotation is always in the range [0, 360].
const Vector2f& sf::Transformable::getScale  (  )  const 
const Transform& sf::Transformable::getTransform  (  )  const 
get the combined transform of the object
void sf::Transformable::move  (  float  offsetX, 
float  offsetY  
) 
Move the object by a given offset.
This function adds to the current position of the object, unlike setPosition which overwrites it. Thus, it is equivalent to the following code:
offsetX  X offset 
offsetY  Y offset 
void sf::Transformable::move  (  const Vector2f &  offset  ) 
Move the object by a given offset.
This function adds to the current position of the object, unlike setPosition which overwrites it. Thus, it is equivalent to the following code:
offset  Offset 
void sf::Transformable::rotate  (  float  angle  ) 
Rotate the object.
This function adds to the current rotation of the object, unlike setRotation which overwrites it. Thus, it is equivalent to the following code:
angle  Angle of rotation, in degrees 
void sf::Transformable::scale  (  float  factorX, 
float  factorY  
) 
Scale the object.
This function multiplies the current scale of the object, unlike setScale which overwrites it. Thus, it is equivalent to the following code:
factorX  Horizontal scale factor 
factorY  Vertical scale factor 
void sf::Transformable::scale  (  const Vector2f &  factor  ) 
Scale the object.
This function multiplies the current scale of the object, unlike setScale which overwrites it. Thus, it is equivalent to the following code:
factor  Scale factors 
void sf::Transformable::setOrigin  (  float  x, 
float  y  
) 
set the local origin of the object
The origin of an object defines the center point for all transformations (position, scale, rotation). The coordinates of this point must be relative to the topleft corner of the object, and ignore all transformations (position, scale, rotation). The default origin of a transformable object is (0, 0).
x  X coordinate of the new origin 
y  Y coordinate of the new origin 
void sf::Transformable::setOrigin  (  const Vector2f &  origin  ) 
set the local origin of the object
The origin of an object defines the center point for all transformations (position, scale, rotation). The coordinates of this point must be relative to the topleft corner of the object, and ignore all transformations (position, scale, rotation). The default origin of a transformable object is (0, 0).
origin  New origin 
void sf::Transformable::setPosition  (  float  x, 
float  y  
) 
set the position of the object
This function completely overwrites the previous position. See the move function to apply an offset based on the previous position instead. The default position of a transformable object is (0, 0).
x  X coordinate of the new position 
y  Y coordinate of the new position 
void sf::Transformable::setPosition  (  const Vector2f &  position  ) 
set the position of the object
This function completely overwrites the previous position. See the move function to apply an offset based on the previous position instead. The default position of a transformable object is (0, 0).
position  New position 
void sf::Transformable::setRotation  (  float  angle  ) 
set the orientation of the object
This function completely overwrites the previous rotation. See the rotate function to add an angle based on the previous rotation instead. The default rotation of a transformable object is 0.
angle  New rotation, in degrees 
void sf::Transformable::setScale  (  float  factorX, 
float  factorY  
) 
set the scale factors of the object
This function completely overwrites the previous scale. See the scale function to add a factor based on the previous scale instead. The default scale of a transformable object is (1, 1).
factorX  New horizontal scale factor 
factorY  New vertical scale factor 
void sf::Transformable::setScale  (  const Vector2f &  factors  ) 