Translation3.java

package mikera.transformz;

import mikera.matrixx.AMatrix;
import mikera.matrixx.Matrix33;
import mikera.transformz.marker.ISpecialisedTransform;
import mikera.vectorz.AVector;
import mikera.vectorz.Vector3;

/**
 * Specialised 3D translation class
 * 
 * @author Mike
 */
public final class Translation3 extends ATranslation  implements ISpecialisedTransform  {
	public double dx,dy,dz;
	
	public Translation3(AVector v) {
		assert(v.length()==3);
		dx=v.get(0);
		dy=v.get(1);
		dz=v.get(2);
	}

	public Translation3(ATranslation t) {
		this(t.getTranslationVector());
	}

	public Translation3(double dx, double dy, double dz) {
		this.dx=dx;
		this.dy=dy;
		this.dz=dz;
	}
	
	@Override
	public double calculateElement(int i, AVector v) {
		return v.get(i)+getTranslationComponent(i);
	}
	
	@Override
	public double getTranslationComponent(int i) {
		switch (i) {
			case 0: return dx;
			case 1: return dy;
			case 2: return dz;
			default: throw new IndexOutOfBoundsException("Index = "+i);
		}
	}
	
	public void transformNormal(Vector3 source, Vector3 dest) {
		dest.set(source);
	}

	@Override
	public Vector3 getTranslationVector() {
		return Vector3.of(dx,dy,dz);
	}

	@Override
	public AMatrix getMatrix() {
		return copyOfMatrix();
	}
	
	@Override
	public Vector3 copyOfTranslationVector() {
		return Vector3.of(dx,dy,dz);
	}
	
	@Override
	public Matrix33 copyOfMatrix() {
		return Matrix33.createIdentityMatrix();
	}

	@Override
	public ATranslation getTranslation() {
		return this;
	}

	@Override 
	public int dimensions() {
		return 3;
	}
	
	@Override
	public int inputDimensions() {
		return 3;
	}

	@Override
	public int outputDimensions() {
		return 3;
	}
	
	@Override
	public boolean isIdentity() {
		return (dx==0.0)&&(dy==0.0)&&(dz==0.0);
	}
	
	@Override
	public void transform(AVector source,AVector dest) {
		if ((source instanceof Vector3)&&(dest instanceof Vector3)) {
			transform((Vector3)source,(Vector3)dest);
			return;
		}
		dest.set(0,source.get(0)+dx);
		dest.set(1,source.get(1)+dy);
		dest.set(2,source.get(2)+dz);
	}
	
	@Override
	public void transformInPlace(AVector v) {
		if (v instanceof Vector3) {
			transformInPlace((Vector3)v);
			return;
		}
		v.set(0,v.get(0)+dx);
		v.set(1,v.get(1)+dy);
		v.set(2,v.get(2)+dz);
	}
	
	
	public void transform(Vector3 source,Vector3 dest) {
		dest.x=source.x+dx;
		dest.y=source.y+dy;
		dest.z=source.z+dz;
	}
	
	public void transformInPlace(Vector3 v) {
		v.x+=dx;
		v.y+=dy;
		v.z+=dz;
	}
	
	@Override 
	public void composeWith(ATransform t) {
		if (t instanceof Translation3) {
			composeWith((Translation3) t);
			return;
		} else if (t instanceof Translation) {
			composeWith((Translation) t);
			return;
		}
		super.composeWith(t);
	}
	
	public void composeWith(Translation t) {
		AVector v=t.getTranslationVector();
		dx+=v.get(0);
		dy+=v.get(1);
		dz+=v.get(2);
	}
	
	public void composeWith(Translation3 t) {
		dx+=t.dx;
		dy+=t.dy;
		dz+=t.dz;
	}
	
	@Override 
	public Translation3 inverse() {
		return new Translation3(-dx,-dy,-dz);
	}

}