# dsfml.graphics.transform

- struct
__Transform__; - Define a 3x3 transform matrix.

A__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).

**Authors:**

Laurent Gomila, Jeremy DeHaan

**See Also:**

**http:**

//www.sfml-dev.org/documentation/2.0/classsf_1_1Transform.php#details

- this(float
*a00*, float*a01*, float*a02*, float*a10*, float*a11*, float*a12*, float*a20*, float*a21*, float*a22*); - Construct a 3x3 matrix.

**Params:**

float *a00*Element (0, 0) of the matrix float *a01*Element (0, 1) of the matrix float *a02*Element (0, 2) of the matrix float *a10*Element (1, 0) of the matrix float *a11*Element (1, 1) of the matrix float *a12*Element (1, 2) of the matrix float *a20*Element (2, 0) of the matrix float *a21*Element (2, 1) of the matrix float *a22*Element (2, 2) of the matrix

- const Transform
__getInverse__(); - 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.

- const(float)[]
__getMatrix__(); - 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.

**Returns:**

A 4x4 matrix.

- void
__combine__(Transform*otherTransform*); - Combine the current transform with another one.

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

**Params:**

transform Transform to __combine__with this one.

**Returns:**

Reference to this.

- const Vector2f
__transformPoint__(Vector2f*point*); - Transform a 2D
*point*.

**Params:**

x X coordinate of the *point*to transform.y Y coordinate of the *point*to transform.

**Returns:**

Transformed*point*.

- const FloatRect
__transformRect__(const(FloatRect)*rect*); - 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.

**Params:**

rectangle Rectangle to transform.

**Returns:**

Transformed rectangle.

- void
__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.

**Params:**

offset Translation offset to apply.

**Returns:**

this

- void
__rotate__(float*angle*); - Combine the current transform with a rotation.

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

**Params:**

float *angle*Rotation *angle*, in degrees.

**Returns:**

this

- void
__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.

**Params:**

float *angle*Rotation *angle*, in degrees.center Center of rotation

**Returns:**

this

- void
__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.

**Params:**

float *scaleX*Scaling factor on the X-axis. float *scaleY*Scaling factor on the Y-axis.

**Returns:**

this

- void
__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.

**Params:**

float *scaleX*Scaling factor on the X-axis. float *scaleY*Scaling factor on the Y-axis. float *centerX*X coordinate of the center of scaling float *centerY*Y coordinate of the center of scaling

**Returns:**

this

- static const const(Transform)
__Identity__; - Indentity transform (does nothing).

- this(float