/**
* Calculates the inverse of this transform.
*
* @return the inverted transform
*/
public CCTransform invert() {
CCTransform result = new CCTransform();
if (_myIsIdentity) {
result.setIdentity();
return result;
}
result._myMatrix.set(_myMatrix);
if (_myIsRotationMatrix) {
if (_myIsUniformScale) {
final double sx = _myScale.x;
result._myMatrix.transposeLocal();
if (sx != 1.0) {
result._myMatrix.multiplyLocal(1.0f / sx);
}
} else {
result._myMatrix.set(result._myMatrix.multiplyDiagonalPost(_myScale).invertLocal());
}
} else {
result._myMatrix.invertLocal();
}
result._myTranslation.set(result._myMatrix.applyPost(_myTranslation).negateLocal());
result.updateFlags(_myIsRotationMatrix);
return result;
}
/**
* @param o the object to compare for equality
* @return true if this transform and the provided transform have the exact same double values.
*/
public boolean strictEquals(final Object o) {
if (this == o) {
return true;
}
if (!(o instanceof CCTransform)) {
return false;
}
final CCTransform comp = (CCTransform) o;
return _myMatrix.strictEquals(comp.getMatrix())
&& _myScale.equals(comp.scale())
&& _myTranslation.equals(comp.translation());
}
/**
* Check a transform... if it is null or one of its members are invalid, return false. Else return
* true.
*
* @param transform the transform to check
* @return true or false as stated above.
*/
public static boolean isValid(final CCTransform transform) {
if (transform == null) {
return false;
}
if (!CCVector3.isValid(transform.scale())
|| !CCVector3.isValid(transform.translation())
|| !CCMatrix3x3.isValid(transform.getMatrix())) {
return false;
}
return true;
}
/**
* Constructs a new Transform object from the information stored in the given source Transform.
*
* @param theSource
* @throws NullPointerException if source is null.
*/
public CCTransform(final CCTransform theSource) {
_myMatrix.set(theSource.getMatrix());
_myScale.set(theSource.scale());
_myTranslation.set(theSource.translation());
_myIsIdentity = theSource.isIdentity();
_myIsRotationMatrix = theSource.isRotationMatrix();
_myIsUniformScale = theSource.isUniformScale();
}
/**
* Copies the given transform values into this transform object.
*
* @param source
* @return this transform for chaining.
* @throws NullPointerException if source is null.
*/
public CCTransform set(final CCTransform source) {
if (source.isIdentity()) {
setIdentity();
} else {
_myMatrix.set(source.getMatrix());
_myScale.set(source.scale());
_myTranslation.set(source.translation());
_myIsIdentity = false;
_myIsRotationMatrix = source.isRotationMatrix();
_myIsUniformScale = source.isUniformScale();
}
return this;
}
/**
* @param o the object to compare for equality
* @return true if this transform and the provided transform have the same values.
*/
@Override
public boolean equals(final Object o) {
if (this == o) {
return true;
}
if (!(o instanceof CCTransform)) {
return false;
}
final CCTransform comp = (CCTransform) o;
return _myMatrix.equals(comp.getMatrix())
&& Math.abs(_myTranslation.x - comp.translation().x) < CCTransform.ALLOWED_DEVIANCE
&& Math.abs(_myTranslation.y - comp.translation().y) < CCTransform.ALLOWED_DEVIANCE
&& Math.abs(_myTranslation.z - comp.translation().z) < CCTransform.ALLOWED_DEVIANCE
&& Math.abs(_myScale.x - comp.scale().x) < CCTransform.ALLOWED_DEVIANCE
&& Math.abs(_myScale.y - comp.scale().y) < CCTransform.ALLOWED_DEVIANCE
&& Math.abs(_myScale.z - comp.scale().z) < CCTransform.ALLOWED_DEVIANCE;
}
/**
* Calculates the product of this transform with the given "transformBy" transform (P = this * T)
* and stores this in store.
*
* @param transformBy
* @return the product
* @throws NullPointerException if transformBy is null.
*/
public CCTransform multiply(final CCTransform transformBy, CCTransform theStore) {
if (theStore == null) theStore = new CCTransform();
if (_myIsIdentity) {
return theStore.set(transformBy);
}
if (transformBy.isIdentity()) {
return theStore.set(this);
}
if (_myIsRotationMatrix && transformBy.isRotationMatrix() && _myIsUniformScale) {
theStore._myIsRotationMatrix = true;
theStore._myMatrix.set(_myMatrix).multiplyLocal(transformBy.getMatrix());
theStore._myTranslation.set(transformBy.translation());
theStore._myTranslation.set(_myMatrix.applyPost(theStore._myTranslation));
// uniform scale, so just use X.
theStore._myTranslation.multiplyLocal(_myScale.x);
theStore._myTranslation.addLocal(_myTranslation);
if (transformBy.isUniformScale()) {
theStore.scale(_myScale.x * transformBy.scale().x);
} else {
final CCVector3 scale = theStore._myScale.set(transformBy.scale());
scale.multiplyLocal(_myScale.x);
}
// update our flags in one place.
theStore.updateFlags(true);
return theStore;
}
// In all remaining cases, the matrix cannot be written as R*S*X+T.
final CCMatrix3x3 matrixA =
isRotationMatrix() ? _myMatrix.multiplyDiagonalPost(_myScale) : _myMatrix;
final CCMatrix3x3 matrixB =
transformBy.isRotationMatrix()
? transformBy.getMatrix().multiplyDiagonalPost(transformBy.scale())
: transformBy.getMatrix();
final CCMatrix3x3 newMatrix = theStore._myMatrix;
newMatrix.set(matrixA).multiplyLocal(matrixB);
theStore._myTranslation.set(
matrixA.applyPost(transformBy.translation()).addLocal(translation()));
// prevent scale bleeding since we don't set it.
theStore._myScale.set(1.0f, 1.0f, 1.0f);
// update our flags in one place.
theStore.updateFlags(false);
return theStore;
}