AffineTransform

val IDENTITY: ImmutableAffineTransform

Constant representing an identity transformation, which maps a point to itself, i.e. it leaves it unchanged.

fun applyTransform(box: Box, outParallelogram: MutableParallelogram): MutableParallelogram

Apply the AffineTransform to the Box and store the result in the MutableParallelogram. This is the only Apply function where the input cannot also be the output, as applying an Affine Transform to a Box makes a Parallelogram.

fun applyTransform(
    parallelogram: Parallelogram,
    outParallelogram: MutableParallelogram
): MutableParallelogram

Apply the AffineTransform to the Parallelogram and store the result in the MutableParallelogram. The same MutableParallelogram can be used as both the input and output to avoid additional allocations.

fun applyTransform(point: Vec, outVec: MutableVec): MutableVec

Apply the AffineTransform to the Vec and store the result in the MutableVec. The same MutableVec can be used as both the input and output to avoid additional allocations. Returns outVec.

Note that this treats point as a location, not an offset. If you want to transform an offset, you must also transform the origin and subtract that from the result, e.g.:

Vec.subtract(
  transform.applyTransform(vec, scratchPoint1),
  transform.applyTransform(Vec.ORIGIN, scratchPoint2),
  result
)

fun applyTransform(segment: Segment, outSegment: MutableSegment): MutableSegment

Apply the AffineTransform to the Segment and store the result in the MutableSegment. The same MutableSegment can be used as both the input and output to avoid additional allocations. Returns outSegment.

fun applyTransform(triangle: Triangle, outTriangle: MutableTriangle): MutableTriangle

Apply the AffineTransform to the Triangle and store the result in the MutableTriangle. The same MutableTriangle can be used as both the input and output to avoid additional allocations. Returns outTriangle.

fun computeInverse(outAffineTransform: MutableAffineTransform): MutableAffineTransform

Populates outAffineTransform with the inverse of this AffineTransform. The same MutableAffineTransform instance can be used as the output to avoid additional allocations. Returns outAffineTransform.

fun getValues(outArray: @Size(min = 6) FloatArray = FloatArray(6)): @Size(min = 6) FloatArray

Populates the first 6 elements of outArray with the values of this transform, starting with the top left corner of the matrix and proceeding in row-major order.

In performance-sensitive code, prefer to pass in an array that has already been allocated and is being reused, rather than relying on the default behavior of allocating a new instance for each call.

Prefer to apply this transform to an object, such as with applyTransform, rather than accessing the actual numeric values of this transform. This function is useful for when the values are needed in bulk but not to apply a transform, for example for serialization.

To set these values on a transform in the same order that they are retrieved here, use the ImmutableAffineTransform constructor or use MutableAffineTransform.setValues.