/**
* Change the parent of a game object.
*
* <p>TODO: add code so that the object does not change its global position, rotation or scale
* when it is reparented.
*
* @param newParent
*/
public void setParent(GameObject newParent) {
GameObject oldParent = this.myParent;
double oldLocalRotation = this.getRotation();
double newLocalRotation =
MathUtil.normaliseAngle(
oldParent.getGlobalRotation() - newParent.getGlobalRotation() + oldLocalRotation);
double oldLocalScale = this.getScale();
double newLocalScale = oldParent.getGlobalScale() * oldLocalScale / newParent.getGlobalScale();
double[] globalPosition = this.getGlobalPosition();
double[] globalPositionPoint = new double[3];
globalPositionPoint[0] = globalPosition[0];
globalPositionPoint[1] = globalPosition[1];
globalPositionPoint[2] = 1;
double[] newLocalPositionPoint =
MathUtil.multiply(newParent.getInverseGlobalMatrix(), globalPositionPoint);
double[] newLocalPosition = new double[2];
newLocalPosition[0] = newLocalPositionPoint[0];
newLocalPosition[1] = newLocalPositionPoint[1];
myParent.myChildren.remove(this);
myParent = newParent;
myParent.myChildren.add(this);
this.myTranslation = newLocalPosition;
this.myRotation = newLocalRotation;
this.myScale = newLocalScale;
}
public double[][] getGlobalMatrix() {
double[] myGlobalPosition = this.getGlobalPosition();
double[][] myGlobalTranslationMatrix = MathUtil.translationMatrix(myGlobalPosition);
double myGlobalRotation = this.getGlobalRotation();
double[][] myGlobalRotationMatrix = MathUtil.rotationMatrix(myGlobalRotation);
double myGlobalScale = this.getGlobalScale();
double[][] myGlobalScaleMatrix = MathUtil.scaleMatrix(myGlobalScale);
double[][] m = MathUtil.getIdentity();
m = MathUtil.multiply(m, myGlobalTranslationMatrix);
m = MathUtil.multiply(m, myGlobalRotationMatrix);
m = MathUtil.multiply(m, myGlobalScaleMatrix);
return m;
}
public double[][] getInverseGlobalMatrix() {
double[] globalPosition = this.getGlobalPosition();
double[] inverseTranslation = new double[2];
inverseTranslation[0] = -globalPosition[0];
inverseTranslation[1] = -globalPosition[1];
double[][] myInverseGlobalTranslationMatrix = MathUtil.translationMatrix(inverseTranslation);
double myInverseRotation = -this.getGlobalRotation();
double[][] myInverseGlobalRotationMatrix = MathUtil.rotationMatrix(myInverseRotation);
double myInverseScale = 1d / this.getGlobalScale();
double[][] myInverseGlobalScaleMatrix = MathUtil.scaleMatrix(myInverseScale);
double[][] m = MathUtil.getIdentity();
m = MathUtil.multiply(m, myInverseGlobalScaleMatrix);
m = MathUtil.multiply(m, myInverseGlobalRotationMatrix);
m = MathUtil.multiply(m, myInverseGlobalTranslationMatrix);
return m;
}
/**
* Compute the object's position in world coordinates
*
* <p>TODO: Write this method
*
* @return a point in world coordinats in [x,y] form
*/
public double[] getGlobalPosition() {
double[] globalPosition = new double[2];
if (myParent == null) {
globalPosition[0] = myTranslation[0];
globalPosition[1] = myTranslation[1];
} else {
double[][] parentsGlobalMatrix = myParent.getGlobalMatrix();
double[] positionPoint = new double[3];
positionPoint[0] = myTranslation[0];
positionPoint[1] = myTranslation[1];
positionPoint[2] = 1;
double[] globalPositionPoint = MathUtil.multiply(parentsGlobalMatrix, positionPoint);
globalPosition[0] = globalPositionPoint[0];
globalPosition[1] = globalPositionPoint[1];
}
return globalPosition;
}