Documentation of SFML 2.6.1

Loading...
Searching...
No Matches
sf::Transform Class Reference

Define a 3x3 transform matrix. More...

#include <SFML/Graphics/Transform.hpp>

Public Member Functions

 Transform ()
 Default constructor.
 
 Transform (float a00, float a01, float a02, float a10, float a11, float a12, float a20, float a21, float a22)
 Construct a transform from a 3x3 matrix.
 
const float * getMatrix () const
 Return the transform as a 4x4 matrix.
 
Transform getInverse () const
 Return the inverse of the transform.
 
Vector2f transformPoint (float x, float y) const
 Transform a 2D point.
 
Vector2f transformPoint (const Vector2f &point) const
 Transform a 2D point.
 
FloatRect transformRect (const FloatRect &rectangle) const
 Transform a rectangle.
 
Transformcombine (const Transform &transform)
 Combine the current transform with another one.
 
Transformtranslate (float x, float y)
 Combine the current transform with a translation.
 
Transformtranslate (const Vector2f &offset)
 Combine the current transform with a translation.
 
Transformrotate (float angle)
 Combine the current transform with a rotation.
 
Transformrotate (float angle, float centerX, float centerY)
 Combine the current transform with a rotation.
 
Transformrotate (float angle, const Vector2f &center)
 Combine the current transform with a rotation.
 
Transformscale (float scaleX, float scaleY)
 Combine the current transform with a scaling.
 
Transformscale (float scaleX, float scaleY, float centerX, float centerY)
 Combine the current transform with a scaling.
 
Transformscale (const Vector2f &factors)
 Combine the current transform with a scaling.
 
Transformscale (const Vector2f &factors, const Vector2f &center)
 Combine the current transform with a scaling.
 

Static Public Attributes

static const Transform Identity
 The identity transform (does nothing)
 

Related Symbols

(Note that these are not member symbols.)

Transform operator* (const Transform &left, const Transform &right)
 Overload of binary operator * to combine two transforms.
 
Transformoperator*= (Transform &left, const Transform &right)
 Overload of binary operator *= to combine two transforms.
 
Vector2f operator* (const Transform &left, const Vector2f &right)
 Overload of binary operator * to transform a point.
 
bool operator== (const Transform &left, const Transform &right)
 Overload of binary operator == to compare two transforms.
 
bool operator!= (const Transform &left, const Transform &right)
 Overload of binary operator != to compare two transforms.
 

Detailed Description

Define a 3x3 transform matrix.

A sf::Transform specifies how to translate, rotate, scale, shear, project, whatever things.

In mathematical terms, it defines how to transform a coordinate system into another.

For example, if you apply a rotation transform to a sprite, the result will be a rotated sprite. And anything that is transformed by this rotation transform will be rotated the same way, according to its initial position.

Transforms are typically used for drawing. But they can also be used for any computation that requires to transform points between the local and global coordinate systems of an entity (like collision detection).

Example:

// define a translation transform
sf::Transform translation;
translation.translate(20, 50);
// define a rotation transform
sf::Transform rotation;
rotation.rotate(45);
// combine them
sf::Transform transform = translation * rotation;
// use the result to transform stuff...
sf::Vector2f point = transform.transformPoint(10, 20);
sf::FloatRect rect = transform.transformRect(sf::FloatRect(0, 0, 10, 100));
Define a 3x3 transform matrix.
Definition Transform.hpp:43
Transform & translate(float x, float y)
Combine the current transform with a translation.
FloatRect transformRect(const FloatRect &rectangle) const
Transform a rectangle.
Transform & rotate(float angle)
Combine the current transform with a rotation.
Vector2f transformPoint(float x, float y) const
Transform a 2D point.
See also
sf::Transformable, sf::RenderStates

Definition at line 42 of file Transform.hpp.

Constructor & Destructor Documentation

◆ Transform() [1/2]

sf::Transform::Transform ( )

Default constructor.

Creates an identity transform (a transform that does nothing).

◆ Transform() [2/2]

sf::Transform::Transform ( float  a00,
float  a01,
float  a02,
float  a10,
float  a11,
float  a12,
float  a20,
float  a21,
float  a22 
)

Construct a transform from a 3x3 matrix.

Parameters
a00Element (0, 0) of the matrix
a01Element (0, 1) of the matrix
a02Element (0, 2) of the matrix
a10Element (1, 0) of the matrix
a11Element (1, 1) of the matrix
a12Element (1, 2) of the matrix
a20Element (2, 0) of the matrix
a21Element (2, 1) of the matrix
a22Element (2, 2) of the matrix

Member Function Documentation

◆ combine()

Transform & sf::Transform::combine ( const Transform transform)

Combine the current transform with another one.

The result is a transform that is equivalent to applying transform followed by *this. Mathematically, it is equivalent to a matrix multiplication (*this) * transform.

These two statements are equivalent:

left.combine(right);
left *= right;
Parameters
transformTransform to combine with this transform
Returns
Reference to *this

◆ getInverse()

Transform sf::Transform::getInverse ( ) const

Return the inverse of the transform.

If the inverse cannot be computed, an identity transform is returned.

Returns
A new transform which is the inverse of self

◆ getMatrix()

const float * sf::Transform::getMatrix ( ) const

Return the transform as a 4x4 matrix.

This function returns a pointer to an array of 16 floats containing the transform elements as a 4x4 matrix, which is directly compatible with OpenGL functions.

sf::Transform transform = ...;
glLoadMatrixf(transform.getMatrix());
const float * getMatrix() const
Return the transform as a 4x4 matrix.
Returns
Pointer to a 4x4 matrix

◆ rotate() [1/3]

Transform & sf::Transform::rotate ( float  angle)

Combine the current transform with a rotation.

This function returns a reference to *this, so that calls can be chained.

sf::Transform transform;
transform.rotate(90).translate(50, 20);
Parameters
angleRotation angle, in degrees
Returns
Reference to *this
See also
translate, scale

◆ rotate() [2/3]

Transform & sf::Transform::rotate ( float  angle,
const Vector2f center 
)

Combine the current transform with a rotation.

The center of rotation is provided for convenience as a second argument, so that you can build rotations around arbitrary points more easily (and efficiently) than the usual translate(-center).rotate(angle).translate(center).

This function returns a reference to *this, so that calls can be chained.

sf::Transform transform;
transform.rotate(90, sf::Vector2f(8, 3)).translate(sf::Vector2f(50, 20));
Parameters
angleRotation angle, in degrees
centerCenter of rotation
Returns
Reference to *this
See also
translate, scale

◆ rotate() [3/3]

Transform & sf::Transform::rotate ( float  angle,
float  centerX,
float  centerY 
)

Combine the current transform with a rotation.

The center of rotation is provided for convenience as a second argument, so that you can build rotations around arbitrary points more easily (and efficiently) than the usual translate(-center).rotate(angle).translate(center).

This function returns a reference to *this, so that calls can be chained.

sf::Transform transform;
transform.rotate(90, 8, 3).translate(50, 20);
Parameters
angleRotation angle, in degrees
centerXX coordinate of the center of rotation
centerYY coordinate of the center of rotation
Returns
Reference to *this
See also
translate, scale

◆ scale() [1/4]

Transform & sf::Transform::scale ( const Vector2f factors)

Combine the current transform with a scaling.

This function returns a reference to *this, so that calls can be chained.

sf::Transform transform;
transform.scale(sf::Vector2f(2, 1)).rotate(45);
Transform & scale(float scaleX, float scaleY)
Combine the current transform with a scaling.
Parameters
factorsScaling factors
Returns
Reference to *this
See also
translate, rotate

◆ scale() [2/4]

Transform & sf::Transform::scale ( const Vector2f factors,
const Vector2f center 
)

Combine the current transform with a scaling.

The center of scaling is provided for convenience as a second argument, so that you can build scaling around arbitrary points more easily (and efficiently) than the usual translate(-center).scale(factors).translate(center).

This function returns a reference to *this, so that calls can be chained.

sf::Transform transform;
transform.scale(sf::Vector2f(2, 1), sf::Vector2f(8, 3)).rotate(45);
Parameters
factorsScaling factors
centerCenter of scaling
Returns
Reference to *this
See also
translate, rotate

◆ scale() [3/4]

Transform & sf::Transform::scale ( float  scaleX,
float  scaleY 
)

Combine the current transform with a scaling.

This function returns a reference to *this, so that calls can be chained.

sf::Transform transform;
transform.scale(2, 1).rotate(45);
Parameters
scaleXScaling factor on the X axis
scaleYScaling factor on the Y axis
Returns
Reference to *this
See also
translate, rotate

◆ scale() [4/4]

Transform & sf::Transform::scale ( float  scaleX,
float  scaleY,
float  centerX,
float  centerY 
)

Combine the current transform with a scaling.

The center of scaling is provided for convenience as a second argument, so that you can build scaling around arbitrary points more easily (and efficiently) than the usual translate(-center).scale(factors).translate(center).

This function returns a reference to *this, so that calls can be chained.

sf::Transform transform;
transform.scale(2, 1, 8, 3).rotate(45);
Parameters
scaleXScaling factor on X axis
scaleYScaling factor on Y axis
centerXX coordinate of the center of scaling
centerYY coordinate of the center of scaling
Returns
Reference to *this
See also
translate, rotate

◆ transformPoint() [1/2]

Vector2f sf::Transform::transformPoint ( const Vector2f point) const

Transform a 2D point.

These two statements are equivalent:

sf::Vector2f transformedPoint = matrix.transformPoint(point);
sf::Vector2f transformedPoint = matrix * point;
Parameters
pointPoint to transform
Returns
Transformed point

◆ transformPoint() [2/2]

Vector2f sf::Transform::transformPoint ( float  x,
float  y 
) const

Transform a 2D point.

These two statements are equivalent:

sf::Vector2f transformedPoint = matrix.transformPoint(x, y);
sf::Vector2f transformedPoint = matrix * sf::Vector2f(x, y);
Parameters
xX coordinate of the point to transform
yY coordinate of the point to transform
Returns
Transformed point

◆ transformRect()

FloatRect sf::Transform::transformRect ( const FloatRect rectangle) const

Transform a rectangle.

Since SFML doesn't provide support for oriented rectangles, the result of this function is always an axis-aligned rectangle. Which means that if the transform contains a rotation, the bounding rectangle of the transformed rectangle is returned.

Parameters
rectangleRectangle to transform
Returns
Transformed rectangle

◆ translate() [1/2]

Transform & sf::Transform::translate ( const Vector2f offset)

Combine the current transform with a translation.

This function returns a reference to *this, so that calls can be chained.

sf::Transform transform;
transform.translate(sf::Vector2f(100, 200)).rotate(45);
Parameters
offsetTranslation offset to apply
Returns
Reference to *this
See also
rotate, scale

◆ translate() [2/2]

Transform & sf::Transform::translate ( float  x,
float  y 
)

Combine the current transform with a translation.

This function returns a reference to *this, so that calls can be chained.

sf::Transform transform;
transform.translate(100, 200).rotate(45);
Parameters
xOffset to apply on X axis
yOffset to apply on Y axis
Returns
Reference to *this
See also
rotate, scale

Friends And Related Symbol Documentation

◆ operator!=()

bool operator!= ( const Transform left,
const Transform right 
)
related

Overload of binary operator != to compare two transforms.

This call is equivalent to !(left == right).

Parameters
leftLeft operand (the first transform)
rightRight operand (the second transform)
Returns
true if the transforms are not equal, false otherwise

◆ operator*() [1/2]

Transform operator* ( const Transform left,
const Transform right 
)
related

Overload of binary operator * to combine two transforms.

This call is equivalent to calling Transform(left).combine(right).

Parameters
leftLeft operand (the first transform)
rightRight operand (the second transform)
Returns
New combined transform

◆ operator*() [2/2]

Vector2f operator* ( const Transform left,
const Vector2f right 
)
related

Overload of binary operator * to transform a point.

This call is equivalent to calling left.transformPoint(right).

Parameters
leftLeft operand (the transform)
rightRight operand (the point to transform)
Returns
New transformed point

◆ operator*=()

Transform & operator*= ( Transform left,
const Transform right 
)
related

Overload of binary operator *= to combine two transforms.

This call is equivalent to calling left.combine(right).

Parameters
leftLeft operand (the first transform)
rightRight operand (the second transform)
Returns
The combined transform

◆ operator==()

bool operator== ( const Transform left,
const Transform right 
)
related

Overload of binary operator == to compare two transforms.

Performs an element-wise comparison of the elements of the left transform with the elements of the right transform.

Parameters
leftLeft operand (the first transform)
rightRight operand (the second transform)
Returns
true if the transforms are equal, false otherwise

Member Data Documentation

◆ Identity

const Transform sf::Transform::Identity
static

The identity transform (does nothing)

Definition at line 372 of file Transform.hpp.


The documentation for this class was generated from the following file: