Java tutorial
/******************************************************************************* * Copyright 2011 See AUTHORS file. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. ******************************************************************************/ package com.badlogic.gdx.math; import java.io.Serializable; import com.badlogic.gdx.utils.GdxRuntimeException; /** A specialized 3x3 matrix that can represent sequences of 2D translations, scales, flips, rotations, and shears. <a * href="http://en.wikipedia.org/wiki/Affine_transformation">Affine transformations</a> preserve straight lines, and * parallel lines remain parallel after the transformation. Operations on affine matrices are faster because the last row can * always be assumed (0, 0, 1). * * @author vmilea */ public final class Affine2 implements Serializable { private static final long serialVersionUID = 1524569123485049187L; public float m00 = 1, m01 = 0, m02 = 0; public float m10 = 0, m11 = 1, m12 = 0; // constant: m21 = 0, m21 = 1, m22 = 1 /** Constructs an identity matrix. */ public Affine2() { } /** Constructs a matrix from the given affine matrix. * * @param other The affine matrix to copy. This matrix will not be modified. */ public Affine2(Affine2 other) { set(other); } /** Sets this matrix to the identity matrix * @return This matrix for the purpose of chaining operations. */ public Affine2 idt() { m00 = 1; m01 = 0; m02 = 0; m10 = 0; m11 = 1; m12 = 0; return this; } /** Copies the values from the provided affine matrix to this matrix. * @param other The affine matrix to copy. * @return This matrix for the purposes of chaining. */ public Affine2 set(Affine2 other) { m00 = other.m00; m01 = other.m01; m02 = other.m02; m10 = other.m10; m11 = other.m11; m12 = other.m12; return this; } /** Copies the values from the provided matrix to this matrix. * @param matrix The matrix to copy, assumed to be an affine transformation. * @return This matrix for the purposes of chaining. */ public Affine2 set(Matrix3 matrix) { float[] other = matrix.val; m00 = other[Matrix3.M00]; m01 = other[Matrix3.M01]; m02 = other[Matrix3.M02]; m10 = other[Matrix3.M10]; m11 = other[Matrix3.M11]; m12 = other[Matrix3.M12]; return this; } /** Copies the 2D transformation components from the provided 4x4 matrix. The values are mapped as follows: * * <pre> * [ M00 M01 M03 ] * [ M10 M11 M13 ] * [ 0 0 1 ] * </pre> * @param matrix The source matrix, assumed to be an affine transformation within XY plane. This matrix will not be modified. * @return This matrix for the purpose of chaining operations. */ public Affine2 set(Matrix4 matrix) { float[] other = matrix.val; m00 = other[Matrix4.M00]; m01 = other[Matrix4.M01]; m02 = other[Matrix4.M03]; m10 = other[Matrix4.M10]; m11 = other[Matrix4.M11]; m12 = other[Matrix4.M13]; return this; } /** Sets this matrix to a translation matrix. * @param x The translation in x * @param y The translation in y * @return This matrix for the purpose of chaining operations. */ public Affine2 setToTranslation(float x, float y) { m00 = 1; m01 = 0; m02 = x; m10 = 0; m11 = 1; m12 = y; return this; } /** Sets this matrix to a translation matrix. * @param trn The translation vector. * @return This matrix for the purpose of chaining operations. */ public Affine2 setToTranslation(Vector2 trn) { return setToTranslation(trn.x, trn.y); } /** Sets this matrix to a scaling matrix. * @param scaleX The scale in x. * @param scaleY The scale in y. * @return This matrix for the purpose of chaining operations. */ public Affine2 setToScaling(float scaleX, float scaleY) { m00 = scaleX; m01 = 0; m02 = 0; m10 = 0; m11 = scaleY; m12 = 0; return this; } /** Sets this matrix to a scaling matrix. * @param scale The scale vector. * @return This matrix for the purpose of chaining operations. */ public Affine2 setToScaling(Vector2 scale) { return setToScaling(scale.x, scale.y); } /** Sets this matrix to a rotation matrix that will rotate any vector in counter-clockwise direction around the z-axis. * @param degrees The angle in degrees. * @return This matrix for the purpose of chaining operations. */ public Affine2 setToRotation(float degrees) { float cos = MathUtils.cosDeg(degrees); float sin = MathUtils.sinDeg(degrees); m00 = cos; m01 = -sin; m02 = 0; m10 = sin; m11 = cos; m12 = 0; return this; } /** Sets this matrix to a rotation matrix that will rotate any vector in counter-clockwise direction around the z-axis. * @param radians The angle in radians. * @return This matrix for the purpose of chaining operations. */ public Affine2 setToRotationRad(float radians) { float cos = MathUtils.cos(radians); float sin = MathUtils.sin(radians); m00 = cos; m01 = -sin; m02 = 0; m10 = sin; m11 = cos; m12 = 0; return this; } /** Sets this matrix to a rotation matrix that will rotate any vector in counter-clockwise direction around the z-axis. * @param cos The angle cosine. * @param sin The angle sine. * @return This matrix for the purpose of chaining operations. */ public Affine2 setToRotation(float cos, float sin) { m00 = cos; m01 = -sin; m02 = 0; m10 = sin; m11 = cos; m12 = 0; return this; } /** Sets this matrix to a shearing matrix. * @param shearX The shear in x direction. * @param shearY The shear in y direction. * @return This matrix for the purpose of chaining operations. */ public Affine2 setToShearing(float shearX, float shearY) { m00 = 1; m01 = shearX; m02 = 0; m10 = shearY; m11 = 1; m12 = 0; return this; } /** Sets this matrix to a shearing matrix. * @param shear The shear vector. * @return This matrix for the purpose of chaining operations. */ public Affine2 setToShearing(Vector2 shear) { return setToShearing(shear.x, shear.y); } /** Sets this matrix to a concatenation of translation, rotation and scale. It is a more efficient form for: * <code>idt().translate(x, y).rotate(degrees).scale(scaleX, scaleY)</code> * @param x The translation in x. * @param y The translation in y. * @param degrees The angle in degrees. * @param scaleX The scale in y. * @param scaleY The scale in x. * @return This matrix for the purpose of chaining operations. */ public Affine2 setToTrnRotScl(float x, float y, float degrees, float scaleX, float scaleY) { m02 = x; m12 = y; if (degrees == 0) { m00 = scaleX; m01 = 0; m10 = 0; m11 = scaleY; } else { float sin = MathUtils.sinDeg(degrees); float cos = MathUtils.cosDeg(degrees); m00 = cos * scaleX; m01 = -sin * scaleY; m10 = sin * scaleX; m11 = cos * scaleY; } return this; } /** Sets this matrix to a concatenation of translation, rotation and scale. It is a more efficient form for: * <code>idt().translate(trn).rotate(degrees).scale(scale)</code> * @param trn The translation vector. * @param degrees The angle in degrees. * @param scale The scale vector. * @return This matrix for the purpose of chaining operations. */ public Affine2 setToTrnRotScl(Vector2 trn, float degrees, Vector2 scale) { return setToTrnRotScl(trn.x, trn.y, degrees, scale.x, scale.y); } /** Sets this matrix to a concatenation of translation, rotation and scale. It is a more efficient form for: * <code>idt().translate(x, y).rotateRad(radians).scale(scaleX, scaleY)</code> * @param x The translation in x. * @param y The translation in y. * @param radians The angle in radians. * @param scaleX The scale in y. * @param scaleY The scale in x. * @return This matrix for the purpose of chaining operations. */ public Affine2 setToTrnRotRadScl(float x, float y, float radians, float scaleX, float scaleY) { m02 = x; m12 = y; if (radians == 0) { m00 = scaleX; m01 = 0; m10 = 0; m11 = scaleY; } else { float sin = MathUtils.sin(radians); float cos = MathUtils.cos(radians); m00 = cos * scaleX; m01 = -sin * scaleY; m10 = sin * scaleX; m11 = cos * scaleY; } return this; } /** Sets this matrix to a concatenation of translation, rotation and scale. It is a more efficient form for: * <code>idt().translate(trn).rotateRad(radians).scale(scale)</code> * @param trn The translation vector. * @param radians The angle in radians. * @param scale The scale vector. * @return This matrix for the purpose of chaining operations. */ public Affine2 setToTrnRotRadScl(Vector2 trn, float radians, Vector2 scale) { return setToTrnRotRadScl(trn.x, trn.y, radians, scale.x, scale.y); } /** Sets this matrix to a concatenation of translation and scale. It is a more efficient form for: * <code>idt().translate(x, y).scale(scaleX, scaleY)</code> * @param x The translation in x. * @param y The translation in y. * @param scaleX The scale in y. * @param scaleY The scale in x. * @return This matrix for the purpose of chaining operations. */ public Affine2 setToTrnScl(float x, float y, float scaleX, float scaleY) { m00 = scaleX; m01 = 0; m02 = x; m10 = 0; m11 = scaleY; m12 = y; return this; } /** Sets this matrix to a concatenation of translation and scale. It is a more efficient form for: * <code>idt().translate(trn).scale(scale)</code> * @param trn The translation vector. * @param scale The scale vector. * @return This matrix for the purpose of chaining operations. */ public Affine2 setToTrnScl(Vector2 trn, Vector2 scale) { return setToTrnScl(trn.x, trn.y, scale.x, scale.y); } /** Sets this matrix to the product of two matrices. * @param l Left matrix. * @param r Right matrix. * @return This matrix for the purpose of chaining operations. */ public Affine2 setToProduct(Affine2 l, Affine2 r) { m00 = l.m00 * r.m00 + l.m01 * r.m10; m01 = l.m00 * r.m01 + l.m01 * r.m11; m02 = l.m00 * r.m02 + l.m01 * r.m12 + l.m02; m10 = l.m10 * r.m00 + l.m11 * r.m10; m11 = l.m10 * r.m01 + l.m11 * r.m11; m12 = l.m10 * r.m02 + l.m11 * r.m12 + l.m12; return this; } /** Inverts this matrix given that the determinant is != 0. * @return This matrix for the purpose of chaining operations. * @throws GdxRuntimeException if the matrix is singular (not invertible) */ public Affine2 inv() { float det = det(); if (det == 0) throw new GdxRuntimeException("Can't invert a singular affine matrix"); float invDet = 1.0f / det; float tmp00 = m11; float tmp01 = -m01; float tmp02 = m01 * m12 - m11 * m02; float tmp10 = -m10; float tmp11 = m00; float tmp12 = m10 * m02 - m00 * m12; m00 = invDet * tmp00; m01 = invDet * tmp01; m02 = invDet * tmp02; m10 = invDet * tmp10; m11 = invDet * tmp11; m12 = invDet * tmp12; return this; } /** Postmultiplies this matrix with the provided matrix and stores the result in this matrix. For example: * * <pre> * A.mul(B) results in A := AB * </pre> * @param other Matrix to multiply by. * @return This matrix for the purpose of chaining operations together. */ public Affine2 mul(Affine2 other) { float tmp00 = m00 * other.m00 + m01 * other.m10; float tmp01 = m00 * other.m01 + m01 * other.m11; float tmp02 = m00 * other.m02 + m01 * other.m12 + m02; float tmp10 = m10 * other.m00 + m11 * other.m10; float tmp11 = m10 * other.m01 + m11 * other.m11; float tmp12 = m10 * other.m02 + m11 * other.m12 + m12; m00 = tmp00; m01 = tmp01; m02 = tmp02; m10 = tmp10; m11 = tmp11; m12 = tmp12; return this; } /** Premultiplies this matrix with the provided matrix and stores the result in this matrix. For example: * * <pre> * A.preMul(B) results in A := BA * </pre> * @param other The other Matrix to multiply by * @return This matrix for the purpose of chaining operations. */ public Affine2 preMul(Affine2 other) { float tmp00 = other.m00 * m00 + other.m01 * m10; float tmp01 = other.m00 * m01 + other.m01 * m11; float tmp02 = other.m00 * m02 + other.m01 * m12 + other.m02; float tmp10 = other.m10 * m00 + other.m11 * m10; float tmp11 = other.m10 * m01 + other.m11 * m11; float tmp12 = other.m10 * m02 + other.m11 * m12 + other.m12; m00 = tmp00; m01 = tmp01; m02 = tmp02; m10 = tmp10; m11 = tmp11; m12 = tmp12; return this; } /** Postmultiplies this matrix by a translation matrix. * @param x The x-component of the translation vector. * @param y The y-component of the translation vector. * @return This matrix for the purpose of chaining. */ public Affine2 translate(float x, float y) { m02 += m00 * x + m01 * y; m12 += m10 * x + m11 * y; return this; } /** Postmultiplies this matrix by a translation matrix. * @param trn The translation vector. * @return This matrix for the purpose of chaining. */ public Affine2 translate(Vector2 trn) { return translate(trn.x, trn.y); } /** Premultiplies this matrix by a translation matrix. * @param x The x-component of the translation vector. * @param y The y-component of the translation vector. * @return This matrix for the purpose of chaining. */ public Affine2 preTranslate(float x, float y) { m02 += x; m12 += y; return this; } /** Premultiplies this matrix by a translation matrix. * @param trn The translation vector. * @return This matrix for the purpose of chaining. */ public Affine2 preTranslate(Vector2 trn) { return preTranslate(trn.x, trn.y); } /** Postmultiplies this matrix with a scale matrix. * @param scaleX The scale in the x-axis. * @param scaleY The scale in the y-axis. * @return This matrix for the purpose of chaining. */ public Affine2 scale(float scaleX, float scaleY) { m00 *= scaleX; m01 *= scaleY; m10 *= scaleX; m11 *= scaleY; return this; } /** Postmultiplies this matrix with a scale matrix. * @param scale The scale vector. * @return This matrix for the purpose of chaining. */ public Affine2 scale(Vector2 scale) { return scale(scale.x, scale.y); } /** Premultiplies this matrix with a scale matrix. * @param scaleX The scale in the x-axis. * @param scaleY The scale in the y-axis. * @return This matrix for the purpose of chaining. */ public Affine2 preScale(float scaleX, float scaleY) { m00 *= scaleX; m01 *= scaleX; m02 *= scaleX; m10 *= scaleY; m11 *= scaleY; m12 *= scaleY; return this; } /** Premultiplies this matrix with a scale matrix. * @param scale The scale vector. * @return This matrix for the purpose of chaining. */ public Affine2 preScale(Vector2 scale) { return preScale(scale.x, scale.y); } /** Postmultiplies this matrix with a (counter-clockwise) rotation matrix. * @param degrees The angle in degrees * @return This matrix for the purpose of chaining. */ public Affine2 rotate(float degrees) { if (degrees == 0) return this; float cos = MathUtils.cosDeg(degrees); float sin = MathUtils.sinDeg(degrees); float tmp00 = m00 * cos + m01 * sin; float tmp01 = m00 * -sin + m01 * cos; float tmp10 = m10 * cos + m11 * sin; float tmp11 = m10 * -sin + m11 * cos; m00 = tmp00; m01 = tmp01; m10 = tmp10; m11 = tmp11; return this; } /** Postmultiplies this matrix with a (counter-clockwise) rotation matrix. * @param radians The angle in radians * @return This matrix for the purpose of chaining. */ public Affine2 rotateRad(float radians) { if (radians == 0) return this; float cos = MathUtils.cos(radians); float sin = MathUtils.sin(radians); float tmp00 = m00 * cos + m01 * sin; float tmp01 = m00 * -sin + m01 * cos; float tmp10 = m10 * cos + m11 * sin; float tmp11 = m10 * -sin + m11 * cos; m00 = tmp00; m01 = tmp01; m10 = tmp10; m11 = tmp11; return this; } /** Premultiplies this matrix with a (counter-clockwise) rotation matrix. * @param degrees The angle in degrees * @return This matrix for the purpose of chaining. */ public Affine2 preRotate(float degrees) { if (degrees == 0) return this; float cos = MathUtils.cosDeg(degrees); float sin = MathUtils.sinDeg(degrees); float tmp00 = cos * m00 - sin * m10; float tmp01 = cos * m01 - sin * m11; float tmp02 = cos * m02 - sin * m12; float tmp10 = sin * m00 + cos * m10; float tmp11 = sin * m01 + cos * m11; float tmp12 = sin * m02 + cos * m12; m00 = tmp00; m01 = tmp01; m02 = tmp02; m10 = tmp10; m11 = tmp11; m12 = tmp12; return this; } /** Premultiplies this matrix with a (counter-clockwise) rotation matrix. * @param radians The angle in radians * @return This matrix for the purpose of chaining. */ public Affine2 preRotateRad(float radians) { if (radians == 0) return this; float cos = MathUtils.cos(radians); float sin = MathUtils.sin(radians); float tmp00 = cos * m00 - sin * m10; float tmp01 = cos * m01 - sin * m11; float tmp02 = cos * m02 - sin * m12; float tmp10 = sin * m00 + cos * m10; float tmp11 = sin * m01 + cos * m11; float tmp12 = sin * m02 + cos * m12; m00 = tmp00; m01 = tmp01; m02 = tmp02; m10 = tmp10; m11 = tmp11; m12 = tmp12; return this; } /** Postmultiplies this matrix by a shear matrix. * @param shearX The shear in x direction. * @param shearY The shear in y direction. * @return This matrix for the purpose of chaining. */ public Affine2 shear(float shearX, float shearY) { float tmp0 = m00 + shearY * m01; float tmp1 = m01 + shearX * m00; m00 = tmp0; m01 = tmp1; tmp0 = m10 + shearY * m11; tmp1 = m11 + shearX * m10; m10 = tmp0; m11 = tmp1; return this; } /** Postmultiplies this matrix by a shear matrix. * @param shear The shear vector. * @return This matrix for the purpose of chaining. */ public Affine2 shear(Vector2 shear) { return shear(shear.x, shear.y); } /** Premultiplies this matrix by a shear matrix. * @param shearX The shear in x direction. * @param shearY The shear in y direction. * @return This matrix for the purpose of chaining. */ public Affine2 preShear(float shearX, float shearY) { float tmp00 = m00 + shearX * m10; float tmp01 = m01 + shearX * m11; float tmp02 = m02 + shearX * m12; float tmp10 = m10 + shearY * m00; float tmp11 = m11 + shearY * m01; float tmp12 = m12 + shearY * m02; m00 = tmp00; m01 = tmp01; m02 = tmp02; m10 = tmp10; m11 = tmp11; m12 = tmp12; return this; } /** Premultiplies this matrix by a shear matrix. * @param shear The shear vector. * @return This matrix for the purpose of chaining. */ public Affine2 preShear(Vector2 shear) { return preShear(shear.x, shear.y); } /** Calculates the determinant of the matrix. * @return The determinant of this matrix. */ public float det() { return m00 * m11 - m01 * m10; } /** Get the x-y translation component of the matrix. * @param position Output vector. * @return Filled position. */ public Vector2 getTranslation(Vector2 position) { position.x = m02; position.y = m12; return position; } /** Check if the this is a plain translation matrix. * @return True if scale is 1 and rotation is 0. */ public boolean isTranslation() { return (m00 == 1 && m11 == 1 && m01 == 0 && m10 == 0); } /** Check if this is an indentity matrix. * @return True if scale is 1 and rotation is 0. */ public boolean isIdt() { return (m00 == 1 && m02 == 0 && m12 == 0 && m11 == 1 && m01 == 0 && m10 == 0); } /** Applies the affine transformation on a vector. */ public void applyTo(Vector2 point) { float x = point.x; float y = point.y; point.x = m00 * x + m01 * y + m02; point.y = m10 * x + m11 * y + m12; } @Override public String toString() { return "[" + m00 + "|" + m01 + "|" + m02 + "]\n[" + m10 + "|" + m11 + "|" + m12 + "]\n[0.0|0.0|0.1]"; } }