Skip to content

Commit

Permalink
Remove Proxy class, readOnlyView() and immutableCopy() (#134)
Browse files Browse the repository at this point in the history
  • Loading branch information
@httpdigest
httpdigest committed Oct 3, 2017
1 parent 7d1d196 commit deceacd
Show file tree
Hide file tree
Showing 24 changed files with 0 additions and 6,855 deletions.
374 changes: 0 additions & 374 deletions src/org/joml/Matrix3d.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -47,352 +47,6 @@ of this software and associated documentation files (the "Software"), to deal
*/
public class Matrix3d implements Externalizable, Matrix3dc {

private final class Proxy implements Matrix3dc {
private final Matrix3dc delegate;

Proxy(Matrix3dc delegate) {
this.delegate = delegate;
}

public double m00() {
return delegate.m00();
}

public double m01() {
return delegate.m01();
}

public double m02() {
return delegate.m02();
}

public double m10() {
return delegate.m10();
}

public double m11() {
return delegate.m11();
}

public double m12() {
return delegate.m12();
}

public double m20() {
return delegate.m20();
}

public double m21() {
return delegate.m21();
}

public double m22() {
return delegate.m22();
}

public Matrix3d mul(Matrix3dc right, Matrix3d dest) {
return delegate.mul(right, dest);
}

public Matrix3d mulLocal(Matrix3dc left, Matrix3d dest) {
return delegate.mulLocal(left, dest);
}

public Matrix3d mul(Matrix3fc right, Matrix3d dest) {
return delegate.mul(right, dest);
}

public double determinant() {
return delegate.determinant();
}

public Matrix3d invert(Matrix3d dest) {
return delegate.invert(dest);
}

public Matrix3d transpose(Matrix3d dest) {
return delegate.transpose(dest);
}

public Matrix3d get(Matrix3d dest) {
return delegate.get(dest);
}

public AxisAngle4f getRotation(AxisAngle4f dest) {
return delegate.getRotation(dest);
}

public Quaternionf getUnnormalizedRotation(Quaternionf dest) {
return delegate.getUnnormalizedRotation(dest);
}

public Quaternionf getNormalizedRotation(Quaternionf dest) {
return delegate.getNormalizedRotation(dest);
}

public Quaterniond getUnnormalizedRotation(Quaterniond dest) {
return delegate.getUnnormalizedRotation(dest);
}

public Quaterniond getNormalizedRotation(Quaterniond dest) {
return delegate.getNormalizedRotation(dest);
}

//#ifdef __HAS_NIO__
public DoubleBuffer get(DoubleBuffer buffer) {
return delegate.get(buffer);
}

public DoubleBuffer get(int index, DoubleBuffer buffer) {
return delegate.get(index, buffer);
}

public FloatBuffer get(FloatBuffer buffer) {
return delegate.get(buffer);
}

public FloatBuffer get(int index, FloatBuffer buffer) {
return delegate.get(index, buffer);
}

public ByteBuffer get(ByteBuffer buffer) {
return delegate.get(buffer);
}

public ByteBuffer get(int index, ByteBuffer buffer) {
return delegate.get(index, buffer);
}

public ByteBuffer getFloats(ByteBuffer buffer) {
return delegate.getFloats(buffer);
}

public ByteBuffer getFloats(int index, ByteBuffer buffer) {
return delegate.getFloats(index, buffer);
}
//#endif

public double[] get(double[] arr, int offset) {
return delegate.get(arr, offset);
}

public double[] get(double[] arr) {
return delegate.get(arr);
}

public float[] get(float[] arr, int offset) {
return delegate.get(arr, offset);
}

public float[] get(float[] arr) {
return delegate.get(arr);
}

public Matrix3d scale(Vector3dc xyz, Matrix3d dest) {
return delegate.scale(xyz, dest);
}

public Matrix3d scale(double x, double y, double z, Matrix3d dest) {
return delegate.scale(x, y, z, dest);
}

public Matrix3d scale(double xyz, Matrix3d dest) {
return delegate.scale(xyz, dest);
}

public Matrix3d scaleLocal(double x, double y, double z, Matrix3d dest) {
return delegate.scaleLocal(x, y, z, dest);
}

public Vector3d transform(Vector3d v) {
return delegate.transform(v);
}

public Vector3d transform(Vector3dc v, Vector3d dest) {
return delegate.transform(v, dest);
}

public Vector3f transform(Vector3f v) {
return delegate.transform(v);
}

public Vector3f transform(Vector3fc v, Vector3f dest) {
return delegate.transform(v, dest);
}

public Vector3d transform(double x, double y, double z, Vector3d dest) {
return delegate.transform(x, y, z, dest);
}

public Vector3d transformTranspose(Vector3d v) {
return delegate.transformTranspose(v);
}

public Vector3d transformTranspose(Vector3dc v, Vector3d dest) {
return delegate.transformTranspose(v, dest);
}

public Vector3d transformTranspose(double x, double y, double z, Vector3d dest) {
return delegate.transformTranspose(x, y, z, dest);
}

public Matrix3d rotateX(double ang, Matrix3d dest) {
return delegate.rotateX(ang, dest);
}

public Matrix3d rotateY(double ang, Matrix3d dest) {
return delegate.rotateY(ang, dest);
}

public Matrix3d rotateZ(double ang, Matrix3d dest) {
return delegate.rotateZ(ang, dest);
}

public Matrix3d rotateXYZ(double angleX, double angleY, double angleZ, Matrix3d dest) {
return delegate.rotateXYZ(angleX, angleY, angleZ, dest);
}

public Matrix3d rotateZYX(double angleZ, double angleY, double angleX, Matrix3d dest) {
return delegate.rotateZYX(angleZ, angleY, angleX, dest);
}

public Matrix3d rotateYXZ(double angleY, double angleX, double angleZ, Matrix3d dest) {
return delegate.rotateYXZ(angleY, angleX, angleZ, dest);
}

public Matrix3d rotate(double ang, double x, double y, double z, Matrix3d dest) {
return delegate.rotate(ang, x, y, z, dest);
}

public Matrix3d rotateLocal(double ang, double x, double y, double z, Matrix3d dest) {
return delegate.rotateLocal(ang, x, y, z, dest);
}

public Matrix3d rotateLocal(Quaterniondc quat, Matrix3d dest) {
return delegate.rotateLocal(quat, dest);
}

public Matrix3d rotateLocalX(double ang, Matrix3d dest) {
return delegate.rotateLocalX(ang, dest);
}

public Matrix3d rotateLocalY(double ang, Matrix3d dest) {
return delegate.rotateLocalY(ang, dest);
}

public Matrix3d rotateLocalZ(double ang, Matrix3d dest) {
return delegate.rotateLocalZ(ang, dest);
}

public Matrix3d rotateLocal(Quaternionfc quat, Matrix3d dest) {
return delegate.rotateLocal(quat, dest);
}

public Matrix3d rotate(Quaterniondc quat, Matrix3d dest) {
return delegate.rotate(quat, dest);
}

public Matrix3d rotate(Quaternionfc quat, Matrix3d dest) {
return delegate.rotate(quat, dest);
}

public Matrix3d rotate(AxisAngle4f axisAngle, Matrix3d dest) {
return delegate.rotate(axisAngle, dest);
}

public Matrix3d rotate(AxisAngle4d axisAngle, Matrix3d dest) {
return delegate.rotate(axisAngle, dest);
}

public Matrix3d rotate(double angle, Vector3dc axis, Matrix3d dest) {
return delegate.rotate(angle, axis, dest);
}

public Matrix3d rotate(double angle, Vector3fc axis, Matrix3d dest) {
return delegate.rotate(angle, axis, dest);
}

public Vector3d getRow(int row, Vector3d dest) throws IndexOutOfBoundsException {
return delegate.getRow(row, dest);
}

public Vector3d getColumn(int column, Vector3d dest) throws IndexOutOfBoundsException {
return delegate.getColumn(column, dest);
}

public double get(int column, int row) {
return delegate.get(column, row);
}

public Matrix3d normal(Matrix3d dest) {
return delegate.normal(dest);
}

public Matrix3d lookAlong(Vector3dc dir, Vector3dc up, Matrix3d dest) {
return delegate.lookAlong(dir, up, dest);
}

public Matrix3d lookAlong(double dirX, double dirY, double dirZ, double upX, double upY, double upZ, Matrix3d dest) {
return delegate.lookAlong(dirX, dirY, dirZ, upX, upY, upZ, dest);
}

public Vector3d getScale(Vector3d dest) {
return delegate.getScale(dest);
}

public Vector3d positiveZ(Vector3d dir) {
return delegate.positiveZ(dir);
}

public Vector3d normalizedPositiveZ(Vector3d dir) {
return delegate.normalizedPositiveZ(dir);
}

public Vector3d positiveX(Vector3d dir) {
return delegate.positiveX(dir);
}

public Vector3d normalizedPositiveX(Vector3d dir) {
return delegate.normalizedPositiveX(dir);
}

public Vector3d positiveY(Vector3d dir) {
return delegate.positiveY(dir);
}

public Vector3d normalizedPositiveY(Vector3d dir) {
return delegate.normalizedPositiveY(dir);
}

public Matrix3d add(Matrix3dc other, Matrix3d dest) {
return delegate.add(other, dest);
}

public Matrix3d sub(Matrix3dc subtrahend, Matrix3d dest) {
return delegate.sub(subtrahend, dest);
}

public Matrix3d mulComponentWise(Matrix3dc other, Matrix3d dest) {
return delegate.mulComponentWise(other, dest);
}

public Matrix3d lerp(Matrix3dc other, double t, Matrix3d dest) {
return delegate.lerp(other, t, dest);
}

public Matrix3d rotateTowards(Vector3dc direction, Vector3dc up, Matrix3d dest) {
return delegate.rotateTowards(direction, up, dest);
}

public Matrix3d rotateTowards(double dirX, double dirY, double dirZ, double upX, double upY, double upZ, Matrix3d dest) {
return delegate.rotateTowards(dirX, dirY, dirZ, upX, upY, upZ, dest);
}

public Vector3d getEulerAnglesZYX(Vector3d dest) {
return delegate.getEulerAnglesZYX(dest);
}
}

private static final long serialVersionUID = 1L;

public double m00, m01, m02;
Expand Down Expand Up @@ -4831,32 +4485,4 @@ public Vector3d getEulerAnglesZYX(Vector3d dest) {
return dest;
}

/**
* Create a new read-only view of this {@link Matrix3d}.
* <p>
* The observable state of the returned object is the same as that of <code>this</code>, but casting
* the returned object to Matrix3d will not be possible. This means that any modification of <code>this</code>
* will be observable throught the returned read-only view instance.
* <p>
* This method allocates a new instance of a class implementing Matrix3dc on every call.
*
* @return the read-only view of this matrix instance
*/
public Matrix3dc readOnlyView() {
if (!Options.DEBUG)
return this;
return new Proxy(this);
}

/**
* Create a new immutable copy of this {@link Matrix3d}.
* <p>
* This method allocates a new instance of a class implementing Matrix3dc on every call.
*
* @return the immutable copy of this matrix instance
*/
public Matrix3dc immutableCopy() {
return new Matrix3d(this).readOnlyView();
}

}
Loading

0 comments on commit deceacd

Please sign in to comment.