diff --git a/src/generated/java/org/lwjgl/util/vector/Matrix.java b/src/generated/java/org/lwjgl/util/vector/Matrix.java index ae3ca2d..3493ba1 100644 --- a/src/generated/java/org/lwjgl/util/vector/Matrix.java +++ b/src/generated/java/org/lwjgl/util/vector/Matrix.java @@ -1,23 +1,123 @@ +/* + * Copyright (c) 2002-2008 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ package org.lwjgl.util.vector; -public abstract class Matrix { +import java.io.Serializable; +import java.nio.FloatBuffer; + +/** + * + * Base class for matrices. When a matrix is constructed it will be the identity + * matrix unless otherwise stated. + * + * @author cix_foo + * @version $Revision: 3418 $ + * $Id: Matrix.java 3418 2010-09-28 21:11:35Z spasi $ + */ +public abstract class Matrix implements Serializable { + + /** + * Constructor for Matrix. + */ + protected Matrix() { + super(); + } + + /** + * Set this matrix to be the identity matrix. + * @return this + */ + public abstract Matrix setIdentity(); + + /** + * Invert this matrix + * @return this + */ + public abstract Matrix invert(); + + /** + * Load from a float buffer. The buffer stores the matrix in column major + * (OpenGL) order. + * + * @param buf A float buffer to read from + * @return this + */ + public abstract Matrix load(FloatBuffer buf); + + /** + * Load from a float buffer. The buffer stores the matrix in row major + * (mathematical) order. + * + * @param buf A float buffer to read from + * @return this + */ + public abstract Matrix loadTranspose(FloatBuffer buf); + + /** + * Negate this matrix + * @return this + */ + public abstract Matrix negate(); + + /** + * Store this matrix in a float buffer. The matrix is stored in column + * major (openGL) order. + * @param buf The buffer to store this matrix in + * @return this + */ + public abstract Matrix store(FloatBuffer buf); + + /** + * Store this matrix in a float buffer. The matrix is stored in row + * major (maths) order. + * @param buf The buffer to store this matrix in + * @return this + */ + public abstract Matrix storeTranspose(FloatBuffer buf); + + /** + * Transpose this matrix + * @return this + */ + public abstract Matrix transpose(); + + /** + * Set this matrix to 0. + * @return this + */ + public abstract Matrix setZero(); + + /** + * @return the determinant of the matrix + */ public abstract float determinant(); - - public abstract org.lwjgl.util.vector.Matrix invert(); - - public abstract org.lwjgl.util.vector.Matrix load(java.nio.FloatBuffer arg0); - - public abstract org.lwjgl.util.vector.Matrix loadTranspose(java.nio.FloatBuffer arg0); - - public abstract org.lwjgl.util.vector.Matrix negate(); - - public abstract org.lwjgl.util.vector.Matrix setIdentity(); - - public abstract org.lwjgl.util.vector.Matrix setZero(); - - public abstract org.lwjgl.util.vector.Matrix store(java.nio.FloatBuffer arg0); - - public abstract org.lwjgl.util.vector.Matrix storeTranspose(java.nio.FloatBuffer arg0); - - public abstract org.lwjgl.util.vector.Matrix transpose(); } diff --git a/src/generated/java/org/lwjgl/util/vector/Matrix2f.java b/src/generated/java/org/lwjgl/util/vector/Matrix2f.java index aa847b4..ebcb3af 100644 --- a/src/generated/java/org/lwjgl/util/vector/Matrix2f.java +++ b/src/generated/java/org/lwjgl/util/vector/Matrix2f.java @@ -1,120 +1,388 @@ +/* + * Copyright (c) 2002-2008 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ package org.lwjgl.util.vector; -public class Matrix2f extends org.lwjgl.util.vector.Matrix { - public float m00 = 0.0F; - public float m01 = 0.0F; - public float m10 = 0.0F; - public float m11 = 0.0F; +import java.io.Serializable; +import java.nio.FloatBuffer; - public static org.lwjgl.util.vector.Matrix2f add( - org.lwjgl.util.vector.Matrix2f arg0, - org.lwjgl.util.vector.Matrix2f arg1, - org.lwjgl.util.vector.Matrix2f arg2) { - throw new UnsupportedOperationException(); +/** + * + * Holds a 2x2 matrix + * + * @author cix_foo + * @version $Revision: 3799 $ + * $Id: Matrix2f.java 3799 2012-09-12 11:29:40Z kappa1 $ + */ +public class Matrix2f extends Matrix implements Serializable { + + private static final long serialVersionUID = 1L; + + public float m00, m01, m10, m11; + + /** + * Constructor for Matrix2f. The matrix is initialised to the identity. + */ + public Matrix2f() { + setIdentity(); } + /** + * Constructor + */ + public Matrix2f(Matrix2f src) { + load(src); + } + + /** + * Load from another matrix + * @param src The source matrix + * @return this + */ + public Matrix2f load(Matrix2f src) { + return load(src, this); + } + + /** + * Copy the source matrix to the destination matrix. + * @param src The source matrix + * @param dest The destination matrix, or null if a new one should be created. + * @return The copied matrix + */ + public static Matrix2f load(Matrix2f src, Matrix2f dest) { + if (dest == null) dest = new Matrix2f(); + + dest.m00 = src.m00; + dest.m01 = src.m01; + dest.m10 = src.m10; + dest.m11 = src.m11; + + return dest; + } + + /** + * Load from a float buffer. The buffer stores the matrix in column major + * (OpenGL) order. + * + * @param buf A float buffer to read from + * @return this + */ + public Matrix load(FloatBuffer buf) { + + m00 = buf.get(); + m01 = buf.get(); + m10 = buf.get(); + m11 = buf.get(); + + return this; + } + + /** + * Load from a float buffer. The buffer stores the matrix in row major + * (mathematical) order. + * + * @param buf A float buffer to read from + * @return this + */ + public Matrix loadTranspose(FloatBuffer buf) { + + m00 = buf.get(); + m10 = buf.get(); + m01 = buf.get(); + m11 = buf.get(); + + return this; + } + + /** + * Store this matrix in a float buffer. The matrix is stored in column + * major (openGL) order. + * @param buf The buffer to store this matrix in + */ + public Matrix store(FloatBuffer buf) { + buf.put(m00); + buf.put(m01); + buf.put(m10); + buf.put(m11); + return this; + } + + /** + * Store this matrix in a float buffer. The matrix is stored in row + * major (maths) order. + * @param buf The buffer to store this matrix in + */ + public Matrix storeTranspose(FloatBuffer buf) { + buf.put(m00); + buf.put(m10); + buf.put(m01); + buf.put(m11); + return this; + } + + /** + * Add two matrices together and place the result in a third matrix. + * @param left The left source matrix + * @param right The right source matrix + * @param dest The destination matrix, or null if a new one is to be created + * @return the destination matrix + */ + public static Matrix2f add(Matrix2f left, Matrix2f right, Matrix2f dest) { + if (dest == null) dest = new Matrix2f(); + + dest.m00 = left.m00 + right.m00; + dest.m01 = left.m01 + right.m01; + dest.m10 = left.m10 + right.m10; + dest.m11 = left.m11 + right.m11; + + return dest; + } + + /** + * Subtract the right matrix from the left and place the result in a third matrix. + * @param left The left source matrix + * @param right The right source matrix + * @param dest The destination matrix, or null if a new one is to be created + * @return the destination matrix + */ + public static Matrix2f sub(Matrix2f left, Matrix2f right, Matrix2f dest) { + if (dest == null) dest = new Matrix2f(); + + dest.m00 = left.m00 - right.m00; + dest.m01 = left.m01 - right.m01; + dest.m10 = left.m10 - right.m10; + dest.m11 = left.m11 - right.m11; + + return dest; + } + + /** + * Multiply the right matrix by the left and place the result in a third matrix. + * @param left The left source matrix + * @param right The right source matrix + * @param dest The destination matrix, or null if a new one is to be created + * @return the destination matrix + */ + public static Matrix2f mul(Matrix2f left, Matrix2f right, Matrix2f dest) { + if (dest == null) dest = new Matrix2f(); + + float m00 = left.m00 * right.m00 + left.m10 * right.m01; + float m01 = left.m01 * right.m00 + left.m11 * right.m01; + float m10 = left.m00 * right.m10 + left.m10 * right.m11; + float m11 = left.m01 * right.m10 + left.m11 * right.m11; + + dest.m00 = m00; + dest.m01 = m01; + dest.m10 = m10; + dest.m11 = m11; + + return dest; + } + + /** + * Transform a Vector by a matrix and return the result in a destination + * vector. + * @param left The left matrix + * @param right The right vector + * @param dest The destination vector, or null if a new one is to be created + * @return the destination vector + */ + public static Vector2f transform(Matrix2f left, Vector2f right, Vector2f dest) { + if (dest == null) dest = new Vector2f(); + + float x = left.m00 * right.x + left.m10 * right.y; + float y = left.m01 * right.x + left.m11 * right.y; + + dest.x = x; + dest.y = y; + + return dest; + } + + /** + * Transpose this matrix + * @return this + */ + public Matrix transpose() { + return transpose(this); + } + + /** + * Transpose this matrix and place the result in another matrix. + * @param dest The destination matrix or null if a new matrix is to be created + * @return the transposed matrix + */ + public Matrix2f transpose(Matrix2f dest) { + return transpose(this, dest); + } + + /** + * Transpose the source matrix and place the result in the destination matrix. + * @param src The source matrix or null if a new matrix is to be created + * @param dest The destination matrix or null if a new matrix is to be created + * @return the transposed matrix + */ + public static Matrix2f transpose(Matrix2f src, Matrix2f dest) { + if (dest == null) dest = new Matrix2f(); + + float m01 = src.m10; + float m10 = src.m01; + + dest.m01 = m01; + dest.m10 = m10; + + return dest; + } + + /** + * Invert this matrix + * @return this if successful, null otherwise + */ + public Matrix invert() { + return invert(this, this); + } + + /** + * Invert the source matrix and place the result in the destination matrix. + * @param src The source matrix to be inverted + * @param dest The destination matrix or null if a new matrix is to be created + * @return The inverted matrix, or null if source can't be reverted. + */ + public static Matrix2f invert(Matrix2f src, Matrix2f dest) { + /* + *inv(A) = 1/det(A) * adj(A); + */ + + float determinant = src.determinant(); + if (determinant != 0) { + if (dest == null) dest = new Matrix2f(); + float determinant_inv = 1f / determinant; + float t00 = src.m11 * determinant_inv; + float t01 = -src.m01 * determinant_inv; + float t11 = src.m00 * determinant_inv; + float t10 = -src.m10 * determinant_inv; + + dest.m00 = t00; + dest.m01 = t01; + dest.m10 = t10; + dest.m11 = t11; + return dest; + } else return null; + } + + /** + * Returns a string representation of this matrix + */ + public String toString() { + StringBuilder buf = new StringBuilder(); + buf.append(m00).append(' ').append(m10).append(' ').append('\n'); + buf.append(m01).append(' ').append(m11).append(' ').append('\n'); + return buf.toString(); + } + + /** + * Negate this matrix + * @return this + */ + public Matrix negate() { + return negate(this); + } + + /** + * Negate this matrix and stash the result in another matrix. + * @param dest The destination matrix, or null if a new matrix is to be created + * @return the negated matrix + */ + public Matrix2f negate(Matrix2f dest) { + return negate(this, dest); + } + + /** + * Negate the source matrix and stash the result in the destination matrix. + * @param src The source matrix to be negated + * @param dest The destination matrix, or null if a new matrix is to be created + * @return the negated matrix + */ + public static Matrix2f negate(Matrix2f src, Matrix2f dest) { + if (dest == null) dest = new Matrix2f(); + + dest.m00 = -src.m00; + dest.m01 = -src.m01; + dest.m10 = -src.m10; + dest.m11 = -src.m11; + + return dest; + } + + /** + * Set this matrix to be the identity matrix. + * @return this + */ + public Matrix setIdentity() { + return setIdentity(this); + } + + /** + * Set the source matrix to be the identity matrix. + * @param src The matrix to set to the identity. + * @return The source matrix + */ + public static Matrix2f setIdentity(Matrix2f src) { + src.m00 = 1.0f; + src.m01 = 0.0f; + src.m10 = 0.0f; + src.m11 = 1.0f; + return src; + } + + /** + * Set this matrix to 0. + * @return this + */ + public Matrix setZero() { + return setZero(this); + } + + public static Matrix2f setZero(Matrix2f src) { + src.m00 = 0.0f; + src.m01 = 0.0f; + src.m10 = 0.0f; + src.m11 = 0.0f; + return src; + } + + /* (non-Javadoc) + * @see org.lwjgl.vector.Matrix#determinant() + */ public float determinant() { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix invert() { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Matrix2f invert( - org.lwjgl.util.vector.Matrix2f arg0, org.lwjgl.util.vector.Matrix2f arg1) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix load(java.nio.FloatBuffer arg0) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix2f load(org.lwjgl.util.vector.Matrix2f arg0) { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Matrix2f load( - org.lwjgl.util.vector.Matrix2f arg0, org.lwjgl.util.vector.Matrix2f arg1) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix loadTranspose(java.nio.FloatBuffer arg0) { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Matrix2f mul( - org.lwjgl.util.vector.Matrix2f arg0, - org.lwjgl.util.vector.Matrix2f arg1, - org.lwjgl.util.vector.Matrix2f arg2) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix negate() { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix2f negate(org.lwjgl.util.vector.Matrix2f arg0) { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Matrix2f negate( - org.lwjgl.util.vector.Matrix2f arg0, org.lwjgl.util.vector.Matrix2f arg1) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix setIdentity() { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Matrix2f setIdentity(org.lwjgl.util.vector.Matrix2f arg0) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix setZero() { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Matrix2f setZero(org.lwjgl.util.vector.Matrix2f arg0) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix store(java.nio.FloatBuffer arg0) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix storeTranspose(java.nio.FloatBuffer arg0) { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Matrix2f sub( - org.lwjgl.util.vector.Matrix2f arg0, - org.lwjgl.util.vector.Matrix2f arg1, - org.lwjgl.util.vector.Matrix2f arg2) { - throw new UnsupportedOperationException(); - } - - public java.lang.String toString() { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Vector2f transform( - org.lwjgl.util.vector.Matrix2f arg0, - org.lwjgl.util.vector.Vector2f arg1, - org.lwjgl.util.vector.Vector2f arg2) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix transpose() { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix2f transpose(org.lwjgl.util.vector.Matrix2f arg0) { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Matrix2f transpose( - org.lwjgl.util.vector.Matrix2f arg0, org.lwjgl.util.vector.Matrix2f arg1) { - throw new UnsupportedOperationException(); + return m00 * m11 - m01 * m10; } } diff --git a/src/generated/java/org/lwjgl/util/vector/Matrix3f.java b/src/generated/java/org/lwjgl/util/vector/Matrix3f.java index bd0c913..02ca908 100644 --- a/src/generated/java/org/lwjgl/util/vector/Matrix3f.java +++ b/src/generated/java/org/lwjgl/util/vector/Matrix3f.java @@ -1,125 +1,497 @@ +/* + * Copyright (c) 2002-2008 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ package org.lwjgl.util.vector; -public class Matrix3f extends org.lwjgl.util.vector.Matrix { - public float m00 = 0.0F; - public float m01 = 0.0F; - public float m02 = 0.0F; - public float m10 = 0.0F; - public float m11 = 0.0F; - public float m12 = 0.0F; - public float m20 = 0.0F; - public float m21 = 0.0F; - public float m22 = 0.0F; +import java.io.Serializable; +import java.nio.FloatBuffer; - public static org.lwjgl.util.vector.Matrix3f add( - org.lwjgl.util.vector.Matrix3f arg0, - org.lwjgl.util.vector.Matrix3f arg1, - org.lwjgl.util.vector.Matrix3f arg2) { - throw new UnsupportedOperationException(); +/** + * + * Holds a 3x3 matrix. + * + * @author cix_foo + * @version $Revision: 3799 $ + * $Id: Matrix3f.java 3799 2012-09-12 11:29:40Z kappa1 $ + */ +public class Matrix3f extends Matrix implements Serializable { + + private static final long serialVersionUID = 1L; + + public float m00, m01, m02, m10, m11, m12, m20, m21, m22; + + /** + * Constructor for Matrix3f. Matrix is initialised to the identity. + */ + public Matrix3f() { + super(); + setIdentity(); } + /** + * Load from another matrix + * @param src The source matrix + * @return this + */ + public Matrix3f load(Matrix3f src) { + return load(src, this); + } + + /** + * Copy source matrix to destination matrix + * @param src The source matrix + * @param dest The destination matrix, or null of a new matrix is to be created + * @return The copied matrix + */ + public static Matrix3f load(Matrix3f src, Matrix3f dest) { + if (dest == null) dest = new Matrix3f(); + + dest.m00 = src.m00; + dest.m10 = src.m10; + dest.m20 = src.m20; + dest.m01 = src.m01; + dest.m11 = src.m11; + dest.m21 = src.m21; + dest.m02 = src.m02; + dest.m12 = src.m12; + dest.m22 = src.m22; + + return dest; + } + + /** + * Load from a float buffer. The buffer stores the matrix in column major + * (OpenGL) order. + * + * @param buf A float buffer to read from + * @return this + */ + public Matrix load(FloatBuffer buf) { + + m00 = buf.get(); + m01 = buf.get(); + m02 = buf.get(); + m10 = buf.get(); + m11 = buf.get(); + m12 = buf.get(); + m20 = buf.get(); + m21 = buf.get(); + m22 = buf.get(); + + return this; + } + + /** + * Load from a float buffer. The buffer stores the matrix in row major + * (maths) order. + * + * @param buf A float buffer to read from + * @return this + */ + public Matrix loadTranspose(FloatBuffer buf) { + + m00 = buf.get(); + m10 = buf.get(); + m20 = buf.get(); + m01 = buf.get(); + m11 = buf.get(); + m21 = buf.get(); + m02 = buf.get(); + m12 = buf.get(); + m22 = buf.get(); + + return this; + } + + /** + * Store this matrix in a float buffer. The matrix is stored in column + * major (openGL) order. + * @param buf The buffer to store this matrix in + */ + public Matrix store(FloatBuffer buf) { + buf.put(m00); + buf.put(m01); + buf.put(m02); + buf.put(m10); + buf.put(m11); + buf.put(m12); + buf.put(m20); + buf.put(m21); + buf.put(m22); + return this; + } + + /** + * Store this matrix in a float buffer. The matrix is stored in row + * major (maths) order. + * @param buf The buffer to store this matrix in + */ + public Matrix storeTranspose(FloatBuffer buf) { + buf.put(m00); + buf.put(m10); + buf.put(m20); + buf.put(m01); + buf.put(m11); + buf.put(m21); + buf.put(m02); + buf.put(m12); + buf.put(m22); + return this; + } + + /** + * Add two matrices together and place the result in a third matrix. + * @param left The left source matrix + * @param right The right source matrix + * @param dest The destination matrix, or null if a new one is to be created + * @return the destination matrix + */ + public static Matrix3f add(Matrix3f left, Matrix3f right, Matrix3f dest) { + if (dest == null) dest = new Matrix3f(); + + dest.m00 = left.m00 + right.m00; + dest.m01 = left.m01 + right.m01; + dest.m02 = left.m02 + right.m02; + dest.m10 = left.m10 + right.m10; + dest.m11 = left.m11 + right.m11; + dest.m12 = left.m12 + right.m12; + dest.m20 = left.m20 + right.m20; + dest.m21 = left.m21 + right.m21; + dest.m22 = left.m22 + right.m22; + + return dest; + } + + /** + * Subtract the right matrix from the left and place the result in a third matrix. + * @param left The left source matrix + * @param right The right source matrix + * @param dest The destination matrix, or null if a new one is to be created + * @return the destination matrix + */ + public static Matrix3f sub(Matrix3f left, Matrix3f right, Matrix3f dest) { + if (dest == null) dest = new Matrix3f(); + + dest.m00 = left.m00 - right.m00; + dest.m01 = left.m01 - right.m01; + dest.m02 = left.m02 - right.m02; + dest.m10 = left.m10 - right.m10; + dest.m11 = left.m11 - right.m11; + dest.m12 = left.m12 - right.m12; + dest.m20 = left.m20 - right.m20; + dest.m21 = left.m21 - right.m21; + dest.m22 = left.m22 - right.m22; + + return dest; + } + + /** + * Multiply the right matrix by the left and place the result in a third matrix. + * @param left The left source matrix + * @param right The right source matrix + * @param dest The destination matrix, or null if a new one is to be created + * @return the destination matrix + */ + public static Matrix3f mul(Matrix3f left, Matrix3f right, Matrix3f dest) { + if (dest == null) dest = new Matrix3f(); + + float m00 = left.m00 * right.m00 + left.m10 * right.m01 + left.m20 * right.m02; + float m01 = left.m01 * right.m00 + left.m11 * right.m01 + left.m21 * right.m02; + float m02 = left.m02 * right.m00 + left.m12 * right.m01 + left.m22 * right.m02; + float m10 = left.m00 * right.m10 + left.m10 * right.m11 + left.m20 * right.m12; + float m11 = left.m01 * right.m10 + left.m11 * right.m11 + left.m21 * right.m12; + float m12 = left.m02 * right.m10 + left.m12 * right.m11 + left.m22 * right.m12; + float m20 = left.m00 * right.m20 + left.m10 * right.m21 + left.m20 * right.m22; + float m21 = left.m01 * right.m20 + left.m11 * right.m21 + left.m21 * right.m22; + float m22 = left.m02 * right.m20 + left.m12 * right.m21 + left.m22 * right.m22; + + dest.m00 = m00; + dest.m01 = m01; + dest.m02 = m02; + dest.m10 = m10; + dest.m11 = m11; + dest.m12 = m12; + dest.m20 = m20; + dest.m21 = m21; + dest.m22 = m22; + + return dest; + } + + /** + * Transform a Vector by a matrix and return the result in a destination + * vector. + * @param left The left matrix + * @param right The right vector + * @param dest The destination vector, or null if a new one is to be created + * @return the destination vector + */ + public static Vector3f transform(Matrix3f left, Vector3f right, Vector3f dest) { + if (dest == null) dest = new Vector3f(); + + float x = left.m00 * right.x + left.m10 * right.y + left.m20 * right.z; + float y = left.m01 * right.x + left.m11 * right.y + left.m21 * right.z; + float z = left.m02 * right.x + left.m12 * right.y + left.m22 * right.z; + + dest.x = x; + dest.y = y; + dest.z = z; + + return dest; + } + + /** + * Transpose this matrix + * @return this + */ + public Matrix transpose() { + return transpose(this, this); + } + + /** + * Transpose this matrix and place the result in another matrix + * @param dest The destination matrix or null if a new matrix is to be created + * @return the transposed matrix + */ + public Matrix3f transpose(Matrix3f dest) { + return transpose(this, dest); + } + + /** + * Transpose the source matrix and place the result into the destination matrix + * @param src The source matrix to be transposed + * @param dest The destination matrix or null if a new matrix is to be created + * @return the transposed matrix + */ + public static Matrix3f transpose(Matrix3f src, Matrix3f dest) { + if (dest == null) dest = new Matrix3f(); + float m00 = src.m00; + float m01 = src.m10; + float m02 = src.m20; + float m10 = src.m01; + float m11 = src.m11; + float m12 = src.m21; + float m20 = src.m02; + float m21 = src.m12; + float m22 = src.m22; + + dest.m00 = m00; + dest.m01 = m01; + dest.m02 = m02; + dest.m10 = m10; + dest.m11 = m11; + dest.m12 = m12; + dest.m20 = m20; + dest.m21 = m21; + dest.m22 = m22; + return dest; + } + + /** + * @return the determinant of the matrix + */ public float determinant() { - throw new UnsupportedOperationException(); + float f = m00 * (m11 * m22 - m12 * m21) + m01 * (m12 * m20 - m10 * m22) + m02 * (m10 * m21 - m11 * m20); + return f; } - public org.lwjgl.util.vector.Matrix invert() { - throw new UnsupportedOperationException(); + /** + * Returns a string representation of this matrix + */ + public String toString() { + StringBuilder buf = new StringBuilder(); + buf.append(m00) + .append(' ') + .append(m10) + .append(' ') + .append(m20) + .append(' ') + .append('\n'); + buf.append(m01) + .append(' ') + .append(m11) + .append(' ') + .append(m21) + .append(' ') + .append('\n'); + buf.append(m02) + .append(' ') + .append(m12) + .append(' ') + .append(m22) + .append(' ') + .append('\n'); + return buf.toString(); } - public static org.lwjgl.util.vector.Matrix3f invert( - org.lwjgl.util.vector.Matrix3f arg0, org.lwjgl.util.vector.Matrix3f arg1) { - throw new UnsupportedOperationException(); + /** + * Invert this matrix + * @return this if successful, null otherwise + */ + public Matrix invert() { + return invert(this, this); } - public org.lwjgl.util.vector.Matrix load(java.nio.FloatBuffer arg0) { - throw new UnsupportedOperationException(); + /** + * Invert the source matrix and put the result into the destination matrix + * @param src The source matrix to be inverted + * @param dest The destination matrix, or null if a new one is to be created + * @return The inverted matrix if successful, null otherwise + */ + public static Matrix3f invert(Matrix3f src, Matrix3f dest) { + float determinant = src.determinant(); + + if (determinant != 0) { + if (dest == null) dest = new Matrix3f(); + /* do it the ordinary way + * + * inv(A) = 1/det(A) * adj(T), where adj(T) = transpose(Conjugate Matrix) + * + * m00 m01 m02 + * m10 m11 m12 + * m20 m21 m22 + */ + float determinant_inv = 1f / determinant; + + // get the conjugate matrix + float t00 = src.m11 * src.m22 - src.m12 * src.m21; + float t01 = -src.m10 * src.m22 + src.m12 * src.m20; + float t02 = src.m10 * src.m21 - src.m11 * src.m20; + float t10 = -src.m01 * src.m22 + src.m02 * src.m21; + float t11 = src.m00 * src.m22 - src.m02 * src.m20; + float t12 = -src.m00 * src.m21 + src.m01 * src.m20; + float t20 = src.m01 * src.m12 - src.m02 * src.m11; + float t21 = -src.m00 * src.m12 + src.m02 * src.m10; + float t22 = src.m00 * src.m11 - src.m01 * src.m10; + + dest.m00 = t00 * determinant_inv; + dest.m11 = t11 * determinant_inv; + dest.m22 = t22 * determinant_inv; + dest.m01 = t10 * determinant_inv; + dest.m10 = t01 * determinant_inv; + dest.m20 = t02 * determinant_inv; + dest.m02 = t20 * determinant_inv; + dest.m12 = t21 * determinant_inv; + dest.m21 = t12 * determinant_inv; + return dest; + } else return null; } - public org.lwjgl.util.vector.Matrix3f load(org.lwjgl.util.vector.Matrix3f arg0) { - throw new UnsupportedOperationException(); + /** + * Negate this matrix + * @return this + */ + public Matrix negate() { + return negate(this); } - public static org.lwjgl.util.vector.Matrix3f load( - org.lwjgl.util.vector.Matrix3f arg0, org.lwjgl.util.vector.Matrix3f arg1) { - throw new UnsupportedOperationException(); + /** + * Negate this matrix and place the result in a destination matrix. + * @param dest The destination matrix, or null if a new matrix is to be created + * @return the negated matrix + */ + public Matrix3f negate(Matrix3f dest) { + return negate(this, dest); } - public org.lwjgl.util.vector.Matrix loadTranspose(java.nio.FloatBuffer arg0) { - throw new UnsupportedOperationException(); + /** + * Negate the source matrix and place the result in the destination matrix. + * @param src The source matrix + * @param dest The destination matrix, or null if a new matrix is to be created + * @return the negated matrix + */ + public static Matrix3f negate(Matrix3f src, Matrix3f dest) { + if (dest == null) dest = new Matrix3f(); + + dest.m00 = -src.m00; + dest.m01 = -src.m02; + dest.m02 = -src.m01; + dest.m10 = -src.m10; + dest.m11 = -src.m12; + dest.m12 = -src.m11; + dest.m20 = -src.m20; + dest.m21 = -src.m22; + dest.m22 = -src.m21; + return dest; } - public static org.lwjgl.util.vector.Matrix3f mul( - org.lwjgl.util.vector.Matrix3f arg0, - org.lwjgl.util.vector.Matrix3f arg1, - org.lwjgl.util.vector.Matrix3f arg2) { - throw new UnsupportedOperationException(); + /** + * Set this matrix to be the identity matrix. + * @return this + */ + public Matrix setIdentity() { + return setIdentity(this); } - public org.lwjgl.util.vector.Matrix negate() { - throw new UnsupportedOperationException(); + /** + * Set the matrix to be the identity matrix. + * @param m The matrix to be set to the identity + * @return m + */ + public static Matrix3f setIdentity(Matrix3f m) { + m.m00 = 1.0f; + m.m01 = 0.0f; + m.m02 = 0.0f; + m.m10 = 0.0f; + m.m11 = 1.0f; + m.m12 = 0.0f; + m.m20 = 0.0f; + m.m21 = 0.0f; + m.m22 = 1.0f; + return m; } - public org.lwjgl.util.vector.Matrix3f negate(org.lwjgl.util.vector.Matrix3f arg0) { - throw new UnsupportedOperationException(); + /** + * Set this matrix to 0. + * @return this + */ + public Matrix setZero() { + return setZero(this); } - public static org.lwjgl.util.vector.Matrix3f negate( - org.lwjgl.util.vector.Matrix3f arg0, org.lwjgl.util.vector.Matrix3f arg1) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix setIdentity() { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Matrix3f setIdentity(org.lwjgl.util.vector.Matrix3f arg0) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix setZero() { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Matrix3f setZero(org.lwjgl.util.vector.Matrix3f arg0) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix store(java.nio.FloatBuffer arg0) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix storeTranspose(java.nio.FloatBuffer arg0) { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Matrix3f sub( - org.lwjgl.util.vector.Matrix3f arg0, - org.lwjgl.util.vector.Matrix3f arg1, - org.lwjgl.util.vector.Matrix3f arg2) { - throw new UnsupportedOperationException(); - } - - public java.lang.String toString() { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Vector3f transform( - org.lwjgl.util.vector.Matrix3f arg0, - org.lwjgl.util.vector.Vector3f arg1, - org.lwjgl.util.vector.Vector3f arg2) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix transpose() { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix3f transpose(org.lwjgl.util.vector.Matrix3f arg0) { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Matrix3f transpose( - org.lwjgl.util.vector.Matrix3f arg0, org.lwjgl.util.vector.Matrix3f arg1) { - throw new UnsupportedOperationException(); + /** + * Set the matrix matrix to 0. + * @param m The matrix to be set to 0 + * @return m + */ + public static Matrix3f setZero(Matrix3f m) { + m.m00 = 0.0f; + m.m01 = 0.0f; + m.m02 = 0.0f; + m.m10 = 0.0f; + m.m11 = 0.0f; + m.m12 = 0.0f; + m.m20 = 0.0f; + m.m21 = 0.0f; + m.m22 = 0.0f; + return m; } } diff --git a/src/generated/java/org/lwjgl/util/vector/Matrix4f.java b/src/generated/java/org/lwjgl/util/vector/Matrix4f.java index 56542d4..4e553e6 100644 --- a/src/generated/java/org/lwjgl/util/vector/Matrix4f.java +++ b/src/generated/java/org/lwjgl/util/vector/Matrix4f.java @@ -1,196 +1,866 @@ +/* + * Copyright (c) 2002-2008 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ package org.lwjgl.util.vector; -public class Matrix4f extends org.lwjgl.util.vector.Matrix { - public float m00 = 0.0F; - public float m01 = 0.0F; - public float m02 = 0.0F; - public float m03 = 0.0F; - public float m10 = 0.0F; - public float m11 = 0.0F; - public float m12 = 0.0F; - public float m13 = 0.0F; - public float m20 = 0.0F; - public float m21 = 0.0F; - public float m22 = 0.0F; - public float m23 = 0.0F; - public float m30 = 0.0F; - public float m31 = 0.0F; - public float m32 = 0.0F; - public float m33 = 0.0F; +import java.io.Serializable; +import java.nio.FloatBuffer; - public static org.lwjgl.util.vector.Matrix4f add( - org.lwjgl.util.vector.Matrix4f arg0, - org.lwjgl.util.vector.Matrix4f arg1, - org.lwjgl.util.vector.Matrix4f arg2) { - throw new UnsupportedOperationException(); +/** + * Holds a 4x4 float matrix. + * + * @author foo + */ +public class Matrix4f extends Matrix implements Serializable { + private static final long serialVersionUID = 1L; + + public float m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33; + + /** + * Construct a new matrix, initialized to the identity. + */ + public Matrix4f() { + super(); + setIdentity(); } + public Matrix4f(final Matrix4f src) { + super(); + load(src); + } + + /** + * Returns a string representation of this matrix + */ + public String toString() { + StringBuilder buf = new StringBuilder(); + buf.append(m00) + .append(' ') + .append(m10) + .append(' ') + .append(m20) + .append(' ') + .append(m30) + .append('\n'); + buf.append(m01) + .append(' ') + .append(m11) + .append(' ') + .append(m21) + .append(' ') + .append(m31) + .append('\n'); + buf.append(m02) + .append(' ') + .append(m12) + .append(' ') + .append(m22) + .append(' ') + .append(m32) + .append('\n'); + buf.append(m03) + .append(' ') + .append(m13) + .append(' ') + .append(m23) + .append(' ') + .append(m33) + .append('\n'); + return buf.toString(); + } + + /** + * Set this matrix to be the identity matrix. + * @return this + */ + public Matrix setIdentity() { + return setIdentity(this); + } + + /** + * Set the given matrix to be the identity matrix. + * @param m The matrix to set to the identity + * @return m + */ + public static Matrix4f setIdentity(Matrix4f m) { + m.m00 = 1.0f; + m.m01 = 0.0f; + m.m02 = 0.0f; + m.m03 = 0.0f; + m.m10 = 0.0f; + m.m11 = 1.0f; + m.m12 = 0.0f; + m.m13 = 0.0f; + m.m20 = 0.0f; + m.m21 = 0.0f; + m.m22 = 1.0f; + m.m23 = 0.0f; + m.m30 = 0.0f; + m.m31 = 0.0f; + m.m32 = 0.0f; + m.m33 = 1.0f; + + return m; + } + + /** + * Set this matrix to 0. + * @return this + */ + public Matrix setZero() { + return setZero(this); + } + + /** + * Set the given matrix to 0. + * @param m The matrix to set to 0 + * @return m + */ + public static Matrix4f setZero(Matrix4f m) { + m.m00 = 0.0f; + m.m01 = 0.0f; + m.m02 = 0.0f; + m.m03 = 0.0f; + m.m10 = 0.0f; + m.m11 = 0.0f; + m.m12 = 0.0f; + m.m13 = 0.0f; + m.m20 = 0.0f; + m.m21 = 0.0f; + m.m22 = 0.0f; + m.m23 = 0.0f; + m.m30 = 0.0f; + m.m31 = 0.0f; + m.m32 = 0.0f; + m.m33 = 0.0f; + + return m; + } + + /** + * Load from another matrix4f + * @param src The source matrix + * @return this + */ + public Matrix4f load(Matrix4f src) { + return load(src, this); + } + + /** + * Copy the source matrix to the destination matrix + * @param src The source matrix + * @param dest The destination matrix, or null of a new one is to be created + * @return The copied matrix + */ + public static Matrix4f load(Matrix4f src, Matrix4f dest) { + if (dest == null) dest = new Matrix4f(); + dest.m00 = src.m00; + dest.m01 = src.m01; + dest.m02 = src.m02; + dest.m03 = src.m03; + dest.m10 = src.m10; + dest.m11 = src.m11; + dest.m12 = src.m12; + dest.m13 = src.m13; + dest.m20 = src.m20; + dest.m21 = src.m21; + dest.m22 = src.m22; + dest.m23 = src.m23; + dest.m30 = src.m30; + dest.m31 = src.m31; + dest.m32 = src.m32; + dest.m33 = src.m33; + + return dest; + } + + /** + * Load from a float buffer. The buffer stores the matrix in column major + * (OpenGL) order. + * + * @param buf A float buffer to read from + * @return this + */ + public Matrix load(FloatBuffer buf) { + + m00 = buf.get(); + m01 = buf.get(); + m02 = buf.get(); + m03 = buf.get(); + m10 = buf.get(); + m11 = buf.get(); + m12 = buf.get(); + m13 = buf.get(); + m20 = buf.get(); + m21 = buf.get(); + m22 = buf.get(); + m23 = buf.get(); + m30 = buf.get(); + m31 = buf.get(); + m32 = buf.get(); + m33 = buf.get(); + + return this; + } + + /** + * Load from a float buffer. The buffer stores the matrix in row major + * (maths) order. + * + * @param buf A float buffer to read from + * @return this + */ + public Matrix loadTranspose(FloatBuffer buf) { + + m00 = buf.get(); + m10 = buf.get(); + m20 = buf.get(); + m30 = buf.get(); + m01 = buf.get(); + m11 = buf.get(); + m21 = buf.get(); + m31 = buf.get(); + m02 = buf.get(); + m12 = buf.get(); + m22 = buf.get(); + m32 = buf.get(); + m03 = buf.get(); + m13 = buf.get(); + m23 = buf.get(); + m33 = buf.get(); + + return this; + } + + /** + * Store this matrix in a float buffer. The matrix is stored in column + * major (openGL) order. + * @param buf The buffer to store this matrix in + */ + public Matrix store(FloatBuffer buf) { + buf.put(m00); + buf.put(m01); + buf.put(m02); + buf.put(m03); + buf.put(m10); + buf.put(m11); + buf.put(m12); + buf.put(m13); + buf.put(m20); + buf.put(m21); + buf.put(m22); + buf.put(m23); + buf.put(m30); + buf.put(m31); + buf.put(m32); + buf.put(m33); + return this; + } + + /** + * Store this matrix in a float buffer. The matrix is stored in row + * major (maths) order. + * @param buf The buffer to store this matrix in + */ + public Matrix storeTranspose(FloatBuffer buf) { + buf.put(m00); + buf.put(m10); + buf.put(m20); + buf.put(m30); + buf.put(m01); + buf.put(m11); + buf.put(m21); + buf.put(m31); + buf.put(m02); + buf.put(m12); + buf.put(m22); + buf.put(m32); + buf.put(m03); + buf.put(m13); + buf.put(m23); + buf.put(m33); + return this; + } + + /** + * Store the rotation portion of this matrix in a float buffer. The matrix is stored in column + * major (openGL) order. + * @param buf The buffer to store this matrix in + */ + public Matrix store3f(FloatBuffer buf) { + buf.put(m00); + buf.put(m01); + buf.put(m02); + buf.put(m10); + buf.put(m11); + buf.put(m12); + buf.put(m20); + buf.put(m21); + buf.put(m22); + return this; + } + + /** + * Add two matrices together and place the result in a third matrix. + * @param left The left source matrix + * @param right The right source matrix + * @param dest The destination matrix, or null if a new one is to be created + * @return the destination matrix + */ + public static Matrix4f add(Matrix4f left, Matrix4f right, Matrix4f dest) { + if (dest == null) dest = new Matrix4f(); + + dest.m00 = left.m00 + right.m00; + dest.m01 = left.m01 + right.m01; + dest.m02 = left.m02 + right.m02; + dest.m03 = left.m03 + right.m03; + dest.m10 = left.m10 + right.m10; + dest.m11 = left.m11 + right.m11; + dest.m12 = left.m12 + right.m12; + dest.m13 = left.m13 + right.m13; + dest.m20 = left.m20 + right.m20; + dest.m21 = left.m21 + right.m21; + dest.m22 = left.m22 + right.m22; + dest.m23 = left.m23 + right.m23; + dest.m30 = left.m30 + right.m30; + dest.m31 = left.m31 + right.m31; + dest.m32 = left.m32 + right.m32; + dest.m33 = left.m33 + right.m33; + + return dest; + } + + /** + * Subtract the right matrix from the left and place the result in a third matrix. + * @param left The left source matrix + * @param right The right source matrix + * @param dest The destination matrix, or null if a new one is to be created + * @return the destination matrix + */ + public static Matrix4f sub(Matrix4f left, Matrix4f right, Matrix4f dest) { + if (dest == null) dest = new Matrix4f(); + + dest.m00 = left.m00 - right.m00; + dest.m01 = left.m01 - right.m01; + dest.m02 = left.m02 - right.m02; + dest.m03 = left.m03 - right.m03; + dest.m10 = left.m10 - right.m10; + dest.m11 = left.m11 - right.m11; + dest.m12 = left.m12 - right.m12; + dest.m13 = left.m13 - right.m13; + dest.m20 = left.m20 - right.m20; + dest.m21 = left.m21 - right.m21; + dest.m22 = left.m22 - right.m22; + dest.m23 = left.m23 - right.m23; + dest.m30 = left.m30 - right.m30; + dest.m31 = left.m31 - right.m31; + dest.m32 = left.m32 - right.m32; + dest.m33 = left.m33 - right.m33; + + return dest; + } + + /** + * Multiply the right matrix by the left and place the result in a third matrix. + * @param left The left source matrix + * @param right The right source matrix + * @param dest The destination matrix, or null if a new one is to be created + * @return the destination matrix + */ + public static Matrix4f mul(Matrix4f left, Matrix4f right, Matrix4f dest) { + if (dest == null) dest = new Matrix4f(); + + float m00 = left.m00 * right.m00 + left.m10 * right.m01 + left.m20 * right.m02 + left.m30 * right.m03; + float m01 = left.m01 * right.m00 + left.m11 * right.m01 + left.m21 * right.m02 + left.m31 * right.m03; + float m02 = left.m02 * right.m00 + left.m12 * right.m01 + left.m22 * right.m02 + left.m32 * right.m03; + float m03 = left.m03 * right.m00 + left.m13 * right.m01 + left.m23 * right.m02 + left.m33 * right.m03; + float m10 = left.m00 * right.m10 + left.m10 * right.m11 + left.m20 * right.m12 + left.m30 * right.m13; + float m11 = left.m01 * right.m10 + left.m11 * right.m11 + left.m21 * right.m12 + left.m31 * right.m13; + float m12 = left.m02 * right.m10 + left.m12 * right.m11 + left.m22 * right.m12 + left.m32 * right.m13; + float m13 = left.m03 * right.m10 + left.m13 * right.m11 + left.m23 * right.m12 + left.m33 * right.m13; + float m20 = left.m00 * right.m20 + left.m10 * right.m21 + left.m20 * right.m22 + left.m30 * right.m23; + float m21 = left.m01 * right.m20 + left.m11 * right.m21 + left.m21 * right.m22 + left.m31 * right.m23; + float m22 = left.m02 * right.m20 + left.m12 * right.m21 + left.m22 * right.m22 + left.m32 * right.m23; + float m23 = left.m03 * right.m20 + left.m13 * right.m21 + left.m23 * right.m22 + left.m33 * right.m23; + float m30 = left.m00 * right.m30 + left.m10 * right.m31 + left.m20 * right.m32 + left.m30 * right.m33; + float m31 = left.m01 * right.m30 + left.m11 * right.m31 + left.m21 * right.m32 + left.m31 * right.m33; + float m32 = left.m02 * right.m30 + left.m12 * right.m31 + left.m22 * right.m32 + left.m32 * right.m33; + float m33 = left.m03 * right.m30 + left.m13 * right.m31 + left.m23 * right.m32 + left.m33 * right.m33; + + dest.m00 = m00; + dest.m01 = m01; + dest.m02 = m02; + dest.m03 = m03; + dest.m10 = m10; + dest.m11 = m11; + dest.m12 = m12; + dest.m13 = m13; + dest.m20 = m20; + dest.m21 = m21; + dest.m22 = m22; + dest.m23 = m23; + dest.m30 = m30; + dest.m31 = m31; + dest.m32 = m32; + dest.m33 = m33; + + return dest; + } + + /** + * Transform a Vector by a matrix and return the result in a destination + * vector. + * @param left The left matrix + * @param right The right vector + * @param dest The destination vector, or null if a new one is to be created + * @return the destination vector + */ + public static Vector4f transform(Matrix4f left, Vector4f right, Vector4f dest) { + if (dest == null) dest = new Vector4f(); + + float x = left.m00 * right.x + left.m10 * right.y + left.m20 * right.z + left.m30 * right.w; + float y = left.m01 * right.x + left.m11 * right.y + left.m21 * right.z + left.m31 * right.w; + float z = left.m02 * right.x + left.m12 * right.y + left.m22 * right.z + left.m32 * right.w; + float w = left.m03 * right.x + left.m13 * right.y + left.m23 * right.z + left.m33 * right.w; + + dest.x = x; + dest.y = y; + dest.z = z; + dest.w = w; + + return dest; + } + + /** + * Transpose this matrix + * @return this + */ + public Matrix transpose() { + return transpose(this); + } + + /** + * Translate this matrix + * @param vec The vector to translate by + * @return this + */ + public Matrix4f translate(Vector2f vec) { + return translate(vec, this); + } + + /** + * Translate this matrix + * @param vec The vector to translate by + * @return this + */ + public Matrix4f translate(Vector3f vec) { + return translate(vec, this); + } + + /** + * Scales this matrix + * @param vec The vector to scale by + * @return this + */ + public Matrix4f scale(Vector3f vec) { + return scale(vec, this, this); + } + + /** + * Scales the source matrix and put the result in the destination matrix + * @param vec The vector to scale by + * @param src The source matrix + * @param dest The destination matrix, or null if a new matrix is to be created + * @return The scaled matrix + */ + public static Matrix4f scale(Vector3f vec, Matrix4f src, Matrix4f dest) { + if (dest == null) dest = new Matrix4f(); + dest.m00 = src.m00 * vec.x; + dest.m01 = src.m01 * vec.x; + dest.m02 = src.m02 * vec.x; + dest.m03 = src.m03 * vec.x; + dest.m10 = src.m10 * vec.y; + dest.m11 = src.m11 * vec.y; + dest.m12 = src.m12 * vec.y; + dest.m13 = src.m13 * vec.y; + dest.m20 = src.m20 * vec.z; + dest.m21 = src.m21 * vec.z; + dest.m22 = src.m22 * vec.z; + dest.m23 = src.m23 * vec.z; + return dest; + } + + /** + * Rotates the matrix around the given axis the specified angle + * @param angle the angle, in radians. + * @param axis The vector representing the rotation axis. Must be normalized. + * @return this + */ + public Matrix4f rotate(float angle, Vector3f axis) { + return rotate(angle, axis, this); + } + + /** + * Rotates the matrix around the given axis the specified angle + * @param angle the angle, in radians. + * @param axis The vector representing the rotation axis. Must be normalized. + * @param dest The matrix to put the result, or null if a new matrix is to be created + * @return The rotated matrix + */ + public Matrix4f rotate(float angle, Vector3f axis, Matrix4f dest) { + return rotate(angle, axis, this, dest); + } + + /** + * Rotates the source matrix around the given axis the specified angle and + * put the result in the destination matrix. + * @param angle the angle, in radians. + * @param axis The vector representing the rotation axis. Must be normalized. + * @param src The matrix to rotate + * @param dest The matrix to put the result, or null if a new matrix is to be created + * @return The rotated matrix + */ + public static Matrix4f rotate(float angle, Vector3f axis, Matrix4f src, Matrix4f dest) { + if (dest == null) dest = new Matrix4f(); + float c = (float) Math.cos(angle); + float s = (float) Math.sin(angle); + float oneminusc = 1.0f - c; + float xy = axis.x * axis.y; + float yz = axis.y * axis.z; + float xz = axis.x * axis.z; + float xs = axis.x * s; + float ys = axis.y * s; + float zs = axis.z * s; + + float f00 = axis.x * axis.x * oneminusc + c; + float f01 = xy * oneminusc + zs; + float f02 = xz * oneminusc - ys; + // n[3] not used + float f10 = xy * oneminusc - zs; + float f11 = axis.y * axis.y * oneminusc + c; + float f12 = yz * oneminusc + xs; + // n[7] not used + float f20 = xz * oneminusc + ys; + float f21 = yz * oneminusc - xs; + float f22 = axis.z * axis.z * oneminusc + c; + + float t00 = src.m00 * f00 + src.m10 * f01 + src.m20 * f02; + float t01 = src.m01 * f00 + src.m11 * f01 + src.m21 * f02; + float t02 = src.m02 * f00 + src.m12 * f01 + src.m22 * f02; + float t03 = src.m03 * f00 + src.m13 * f01 + src.m23 * f02; + float t10 = src.m00 * f10 + src.m10 * f11 + src.m20 * f12; + float t11 = src.m01 * f10 + src.m11 * f11 + src.m21 * f12; + float t12 = src.m02 * f10 + src.m12 * f11 + src.m22 * f12; + float t13 = src.m03 * f10 + src.m13 * f11 + src.m23 * f12; + dest.m20 = src.m00 * f20 + src.m10 * f21 + src.m20 * f22; + dest.m21 = src.m01 * f20 + src.m11 * f21 + src.m21 * f22; + dest.m22 = src.m02 * f20 + src.m12 * f21 + src.m22 * f22; + dest.m23 = src.m03 * f20 + src.m13 * f21 + src.m23 * f22; + dest.m00 = t00; + dest.m01 = t01; + dest.m02 = t02; + dest.m03 = t03; + dest.m10 = t10; + dest.m11 = t11; + dest.m12 = t12; + dest.m13 = t13; + return dest; + } + + /** + * Translate this matrix and stash the result in another matrix + * @param vec The vector to translate by + * @param dest The destination matrix or null if a new matrix is to be created + * @return the translated matrix + */ + public Matrix4f translate(Vector3f vec, Matrix4f dest) { + return translate(vec, this, dest); + } + + /** + * Translate the source matrix and stash the result in the destination matrix + * @param vec The vector to translate by + * @param src The source matrix + * @param dest The destination matrix or null if a new matrix is to be created + * @return The translated matrix + */ + public static Matrix4f translate(Vector3f vec, Matrix4f src, Matrix4f dest) { + if (dest == null) dest = new Matrix4f(); + + dest.m30 += src.m00 * vec.x + src.m10 * vec.y + src.m20 * vec.z; + dest.m31 += src.m01 * vec.x + src.m11 * vec.y + src.m21 * vec.z; + dest.m32 += src.m02 * vec.x + src.m12 * vec.y + src.m22 * vec.z; + dest.m33 += src.m03 * vec.x + src.m13 * vec.y + src.m23 * vec.z; + + return dest; + } + + /** + * Translate this matrix and stash the result in another matrix + * @param vec The vector to translate by + * @param dest The destination matrix or null if a new matrix is to be created + * @return the translated matrix + */ + public Matrix4f translate(Vector2f vec, Matrix4f dest) { + return translate(vec, this, dest); + } + + /** + * Translate the source matrix and stash the result in the destination matrix + * @param vec The vector to translate by + * @param src The source matrix + * @param dest The destination matrix or null if a new matrix is to be created + * @return The translated matrix + */ + public static Matrix4f translate(Vector2f vec, Matrix4f src, Matrix4f dest) { + if (dest == null) dest = new Matrix4f(); + + dest.m30 += src.m00 * vec.x + src.m10 * vec.y; + dest.m31 += src.m01 * vec.x + src.m11 * vec.y; + dest.m32 += src.m02 * vec.x + src.m12 * vec.y; + dest.m33 += src.m03 * vec.x + src.m13 * vec.y; + + return dest; + } + + /** + * Transpose this matrix and place the result in another matrix + * @param dest The destination matrix or null if a new matrix is to be created + * @return the transposed matrix + */ + public Matrix4f transpose(Matrix4f dest) { + return transpose(this, dest); + } + + /** + * Transpose the source matrix and place the result in the destination matrix + * @param src The source matrix + * @param dest The destination matrix or null if a new matrix is to be created + * @return the transposed matrix + */ + public static Matrix4f transpose(Matrix4f src, Matrix4f dest) { + if (dest == null) dest = new Matrix4f(); + float m00 = src.m00; + float m01 = src.m10; + float m02 = src.m20; + float m03 = src.m30; + float m10 = src.m01; + float m11 = src.m11; + float m12 = src.m21; + float m13 = src.m31; + float m20 = src.m02; + float m21 = src.m12; + float m22 = src.m22; + float m23 = src.m32; + float m30 = src.m03; + float m31 = src.m13; + float m32 = src.m23; + float m33 = src.m33; + + dest.m00 = m00; + dest.m01 = m01; + dest.m02 = m02; + dest.m03 = m03; + dest.m10 = m10; + dest.m11 = m11; + dest.m12 = m12; + dest.m13 = m13; + dest.m20 = m20; + dest.m21 = m21; + dest.m22 = m22; + dest.m23 = m23; + dest.m30 = m30; + dest.m31 = m31; + dest.m32 = m32; + dest.m33 = m33; + + return dest; + } + + /** + * @return the determinant of the matrix + */ public float determinant() { - throw new UnsupportedOperationException(); + float f = m00 + * ((m11 * m22 * m33 + m12 * m23 * m31 + m13 * m21 * m32) + - m13 * m22 * m31 + - m11 * m23 * m32 + - m12 * m21 * m33); + f -= m01 + * ((m10 * m22 * m33 + m12 * m23 * m30 + m13 * m20 * m32) + - m13 * m22 * m30 + - m10 * m23 * m32 + - m12 * m20 * m33); + f += m02 + * ((m10 * m21 * m33 + m11 * m23 * m30 + m13 * m20 * m31) + - m13 * m21 * m30 + - m10 * m23 * m31 + - m11 * m20 * m33); + f -= m03 + * ((m10 * m21 * m32 + m11 * m22 * m30 + m12 * m20 * m31) + - m12 * m21 * m30 + - m10 * m22 * m31 + - m11 * m20 * m32); + return f; } - public org.lwjgl.util.vector.Matrix invert() { - throw new UnsupportedOperationException(); + /** + * Calculate the determinant of a 3x3 matrix + * @return result + */ + private static float determinant3x3( + float t00, float t01, float t02, float t10, float t11, float t12, float t20, float t21, float t22) { + return t00 * (t11 * t22 - t12 * t21) + t01 * (t12 * t20 - t10 * t22) + t02 * (t10 * t21 - t11 * t20); } - public static org.lwjgl.util.vector.Matrix4f invert( - org.lwjgl.util.vector.Matrix4f arg0, org.lwjgl.util.vector.Matrix4f arg1) { - throw new UnsupportedOperationException(); + /** + * Invert this matrix + * @return this if successful, null otherwise + */ + public Matrix invert() { + return invert(this, this); } - public org.lwjgl.util.vector.Matrix load(java.nio.FloatBuffer arg0) { - throw new UnsupportedOperationException(); + /** + * Invert the source matrix and put the result in the destination + * @param src The source matrix + * @param dest The destination matrix, or null if a new matrix is to be created + * @return The inverted matrix if successful, null otherwise + */ + public static Matrix4f invert(Matrix4f src, Matrix4f dest) { + float determinant = src.determinant(); + + if (determinant != 0) { + /* + * m00 m01 m02 m03 + * m10 m11 m12 m13 + * m20 m21 m22 m23 + * m30 m31 m32 m33 + */ + if (dest == null) dest = new Matrix4f(); + float determinant_inv = 1f / determinant; + + // first row + float t00 = determinant3x3(src.m11, src.m12, src.m13, src.m21, src.m22, src.m23, src.m31, src.m32, src.m33); + float t01 = + -determinant3x3(src.m10, src.m12, src.m13, src.m20, src.m22, src.m23, src.m30, src.m32, src.m33); + float t02 = determinant3x3(src.m10, src.m11, src.m13, src.m20, src.m21, src.m23, src.m30, src.m31, src.m33); + float t03 = + -determinant3x3(src.m10, src.m11, src.m12, src.m20, src.m21, src.m22, src.m30, src.m31, src.m32); + // second row + float t10 = + -determinant3x3(src.m01, src.m02, src.m03, src.m21, src.m22, src.m23, src.m31, src.m32, src.m33); + float t11 = determinant3x3(src.m00, src.m02, src.m03, src.m20, src.m22, src.m23, src.m30, src.m32, src.m33); + float t12 = + -determinant3x3(src.m00, src.m01, src.m03, src.m20, src.m21, src.m23, src.m30, src.m31, src.m33); + float t13 = determinant3x3(src.m00, src.m01, src.m02, src.m20, src.m21, src.m22, src.m30, src.m31, src.m32); + // third row + float t20 = determinant3x3(src.m01, src.m02, src.m03, src.m11, src.m12, src.m13, src.m31, src.m32, src.m33); + float t21 = + -determinant3x3(src.m00, src.m02, src.m03, src.m10, src.m12, src.m13, src.m30, src.m32, src.m33); + float t22 = determinant3x3(src.m00, src.m01, src.m03, src.m10, src.m11, src.m13, src.m30, src.m31, src.m33); + float t23 = + -determinant3x3(src.m00, src.m01, src.m02, src.m10, src.m11, src.m12, src.m30, src.m31, src.m32); + // fourth row + float t30 = + -determinant3x3(src.m01, src.m02, src.m03, src.m11, src.m12, src.m13, src.m21, src.m22, src.m23); + float t31 = determinant3x3(src.m00, src.m02, src.m03, src.m10, src.m12, src.m13, src.m20, src.m22, src.m23); + float t32 = + -determinant3x3(src.m00, src.m01, src.m03, src.m10, src.m11, src.m13, src.m20, src.m21, src.m23); + float t33 = determinant3x3(src.m00, src.m01, src.m02, src.m10, src.m11, src.m12, src.m20, src.m21, src.m22); + + // transpose and divide by the determinant + dest.m00 = t00 * determinant_inv; + dest.m11 = t11 * determinant_inv; + dest.m22 = t22 * determinant_inv; + dest.m33 = t33 * determinant_inv; + dest.m01 = t10 * determinant_inv; + dest.m10 = t01 * determinant_inv; + dest.m20 = t02 * determinant_inv; + dest.m02 = t20 * determinant_inv; + dest.m12 = t21 * determinant_inv; + dest.m21 = t12 * determinant_inv; + dest.m03 = t30 * determinant_inv; + dest.m30 = t03 * determinant_inv; + dest.m13 = t31 * determinant_inv; + dest.m31 = t13 * determinant_inv; + dest.m32 = t23 * determinant_inv; + dest.m23 = t32 * determinant_inv; + return dest; + } else return null; } - public org.lwjgl.util.vector.Matrix4f load(org.lwjgl.util.vector.Matrix4f arg0) { - throw new UnsupportedOperationException(); + /** + * Negate this matrix + * @return this + */ + public Matrix negate() { + return negate(this); } - public static org.lwjgl.util.vector.Matrix4f load( - org.lwjgl.util.vector.Matrix4f arg0, org.lwjgl.util.vector.Matrix4f arg1) { - throw new UnsupportedOperationException(); + /** + * Negate this matrix and place the result in a destination matrix. + * @param dest The destination matrix, or null if a new matrix is to be created + * @return the negated matrix + */ + public Matrix4f negate(Matrix4f dest) { + return negate(this, dest); } - public org.lwjgl.util.vector.Matrix loadTranspose(java.nio.FloatBuffer arg0) { - throw new UnsupportedOperationException(); - } + /** + * Negate this matrix and place the result in a destination matrix. + * @param src The source matrix + * @param dest The destination matrix, or null if a new matrix is to be created + * @return The negated matrix + */ + public static Matrix4f negate(Matrix4f src, Matrix4f dest) { + if (dest == null) dest = new Matrix4f(); - public static org.lwjgl.util.vector.Matrix4f mul( - org.lwjgl.util.vector.Matrix4f arg0, - org.lwjgl.util.vector.Matrix4f arg1, - org.lwjgl.util.vector.Matrix4f arg2) { - throw new UnsupportedOperationException(); - } + dest.m00 = -src.m00; + dest.m01 = -src.m01; + dest.m02 = -src.m02; + dest.m03 = -src.m03; + dest.m10 = -src.m10; + dest.m11 = -src.m11; + dest.m12 = -src.m12; + dest.m13 = -src.m13; + dest.m20 = -src.m20; + dest.m21 = -src.m21; + dest.m22 = -src.m22; + dest.m23 = -src.m23; + dest.m30 = -src.m30; + dest.m31 = -src.m31; + dest.m32 = -src.m32; + dest.m33 = -src.m33; - public org.lwjgl.util.vector.Matrix negate() { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix4f negate(org.lwjgl.util.vector.Matrix4f arg0) { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Matrix4f negate( - org.lwjgl.util.vector.Matrix4f arg0, org.lwjgl.util.vector.Matrix4f arg1) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix4f rotate(float arg0, org.lwjgl.util.vector.Vector3f arg1) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix4f rotate( - float arg0, org.lwjgl.util.vector.Vector3f arg1, org.lwjgl.util.vector.Matrix4f arg2) { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Matrix4f rotate( - float arg0, - org.lwjgl.util.vector.Vector3f arg1, - org.lwjgl.util.vector.Matrix4f arg2, - org.lwjgl.util.vector.Matrix4f arg3) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix4f scale(org.lwjgl.util.vector.Vector3f arg0) { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Matrix4f scale( - org.lwjgl.util.vector.Vector3f arg0, - org.lwjgl.util.vector.Matrix4f arg1, - org.lwjgl.util.vector.Matrix4f arg2) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix setIdentity() { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Matrix4f setIdentity(org.lwjgl.util.vector.Matrix4f arg0) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix setZero() { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Matrix4f setZero(org.lwjgl.util.vector.Matrix4f arg0) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix store3f(java.nio.FloatBuffer arg0) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix store(java.nio.FloatBuffer arg0) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix storeTranspose(java.nio.FloatBuffer arg0) { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Matrix4f sub( - org.lwjgl.util.vector.Matrix4f arg0, - org.lwjgl.util.vector.Matrix4f arg1, - org.lwjgl.util.vector.Matrix4f arg2) { - throw new UnsupportedOperationException(); - } - - public java.lang.String toString() { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Vector4f transform( - org.lwjgl.util.vector.Matrix4f arg0, - org.lwjgl.util.vector.Vector4f arg1, - org.lwjgl.util.vector.Vector4f arg2) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix4f translate(org.lwjgl.util.vector.Vector2f arg0) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix4f translate( - org.lwjgl.util.vector.Vector2f arg0, org.lwjgl.util.vector.Matrix4f arg1) { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Matrix4f translate( - org.lwjgl.util.vector.Vector2f arg0, - org.lwjgl.util.vector.Matrix4f arg1, - org.lwjgl.util.vector.Matrix4f arg2) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix4f translate(org.lwjgl.util.vector.Vector3f arg0) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix4f translate( - org.lwjgl.util.vector.Vector3f arg0, org.lwjgl.util.vector.Matrix4f arg1) { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Matrix4f translate( - org.lwjgl.util.vector.Vector3f arg0, - org.lwjgl.util.vector.Matrix4f arg1, - org.lwjgl.util.vector.Matrix4f arg2) { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix transpose() { - throw new UnsupportedOperationException(); - } - - public org.lwjgl.util.vector.Matrix4f transpose(org.lwjgl.util.vector.Matrix4f arg0) { - throw new UnsupportedOperationException(); - } - - public static org.lwjgl.util.vector.Matrix4f transpose( - org.lwjgl.util.vector.Matrix4f arg0, org.lwjgl.util.vector.Matrix4f arg1) { - throw new UnsupportedOperationException(); + return dest; } } diff --git a/src/generated/java/org/lwjgl/util/vector/Quaternion.java b/src/generated/java/org/lwjgl/util/vector/Quaternion.java index 64e18ee..1278ee8 100644 --- a/src/generated/java/org/lwjgl/util/vector/Quaternion.java +++ b/src/generated/java/org/lwjgl/util/vector/Quaternion.java @@ -1,151 +1,513 @@ +/* + * Copyright (c) 2002-2008 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ package org.lwjgl.util.vector; -public class Quaternion extends org.lwjgl.util.vector.Vector { - public float w = 0.0F; - public float x = 0.0F; - public float y = 0.0F; - public float z = 0.0F; +/** + * + * Quaternions for LWJGL! + * + * @author fbi + * @version $Revision: 3418 $ + * $Id: Quaternion.java 3418 2010-09-28 21:11:35Z spasi $ + */ +import java.nio.FloatBuffer; - public static float dot(org.lwjgl.util.vector.Quaternion arg0, org.lwjgl.util.vector.Quaternion arg1) { - throw new UnsupportedOperationException(); +public class Quaternion extends Vector implements ReadableVector4f { + private static final long serialVersionUID = 1L; + + public float x, y, z, w; + + /** + * C'tor. The quaternion will be initialized to the identity. + */ + public Quaternion() { + super(); + setIdentity(); } - public float getW() { - throw new UnsupportedOperationException(); + /** + * C'tor + * + * @param src + */ + public Quaternion(ReadableVector4f src) { + set(src); } - public final float getX() { - throw new UnsupportedOperationException(); + /** + * C'tor + * + */ + public Quaternion(float x, float y, float z, float w) { + set(x, y, z, w); } - public final float getY() { - throw new UnsupportedOperationException(); + /* + * (non-Javadoc) + * + * @see org.lwjgl.util.vector.WritableVector2f#set(float, float) + */ + public void set(float x, float y) { + this.x = x; + this.y = y; } - public float getZ() { - throw new UnsupportedOperationException(); + /* + * (non-Javadoc) + * + * @see org.lwjgl.util.vector.WritableVector3f#set(float, float, float) + */ + public void set(float x, float y, float z) { + this.x = x; + this.y = y; + this.z = z; } + /* + * (non-Javadoc) + * + * @see org.lwjgl.util.vector.WritableVector4f#set(float, float, float, + * float) + */ + public void set(float x, float y, float z, float w) { + this.x = x; + this.y = y; + this.z = z; + this.w = w; + } + + /** + * Load from another Vector4f + * + * @param src + * The source vector + * @return this + */ + public Quaternion set(ReadableVector4f src) { + x = src.getX(); + y = src.getY(); + z = src.getZ(); + w = src.getW(); + return this; + } + + /** + * Set this quaternion to the multiplication identity. + * @return this + */ + public Quaternion setIdentity() { + return setIdentity(this); + } + + /** + * Set the given quaternion to the multiplication identity. + * @param q The quaternion + * @return q + */ + public static Quaternion setIdentity(Quaternion q) { + q.x = 0; + q.y = 0; + q.z = 0; + q.w = 1; + return q; + } + + /** + * @return the length squared of the quaternion + */ public float lengthSquared() { - throw new UnsupportedOperationException(); + return x * x + y * y + z * z + w * w; } - public org.lwjgl.util.vector.Vector load(java.nio.FloatBuffer arg0) { - throw new UnsupportedOperationException(); + /** + * Normalise the source quaternion and place the result in another quaternion. + * + * @param src + * The source quaternion + * @param dest + * The destination quaternion, or null if a new quaternion is to be + * created + * @return The normalised quaternion + */ + public static Quaternion normalise(Quaternion src, Quaternion dest) { + float inv_l = 1f / src.length(); + + if (dest == null) dest = new Quaternion(); + + dest.set(src.x * inv_l, src.y * inv_l, src.z * inv_l, src.w * inv_l); + + return dest; } - public static org.lwjgl.util.vector.Quaternion mul( - org.lwjgl.util.vector.Quaternion arg0, - org.lwjgl.util.vector.Quaternion arg1, - org.lwjgl.util.vector.Quaternion arg2) { - throw new UnsupportedOperationException(); + /** + * Normalise this quaternion and place the result in another quaternion. + * + * @param dest + * The destination quaternion, or null if a new quaternion is to be + * created + * @return the normalised quaternion + */ + public Quaternion normalise(Quaternion dest) { + return normalise(this, dest); } - public static org.lwjgl.util.vector.Quaternion mulInverse( - org.lwjgl.util.vector.Quaternion arg0, - org.lwjgl.util.vector.Quaternion arg1, - org.lwjgl.util.vector.Quaternion arg2) { - throw new UnsupportedOperationException(); + /** + * The dot product of two quaternions + * + * @param left + * The LHS quat + * @param right + * The RHS quat + * @return left dot right + */ + public static float dot(Quaternion left, Quaternion right) { + return left.x * right.x + left.y * right.y + left.z * right.z + left.w * right.w; } - public org.lwjgl.util.vector.Vector negate() { - throw new UnsupportedOperationException(); + /** + * Calculate the conjugate of this quaternion and put it into the given one + * + * @param dest + * The quaternion which should be set to the conjugate of this + * quaternion + */ + public Quaternion negate(Quaternion dest) { + return negate(this, dest); } - public org.lwjgl.util.vector.Quaternion negate(org.lwjgl.util.vector.Quaternion arg0) { - throw new UnsupportedOperationException(); + /** + * Calculate the conjugate of this quaternion and put it into the given one + * + * @param src + * The source quaternion + * @param dest + * The quaternion which should be set to the conjugate of this + * quaternion + */ + public static Quaternion negate(Quaternion src, Quaternion dest) { + if (dest == null) dest = new Quaternion(); + + dest.x = -src.x; + dest.y = -src.y; + dest.z = -src.z; + dest.w = src.w; + + return dest; } - public static org.lwjgl.util.vector.Quaternion negate( - org.lwjgl.util.vector.Quaternion arg0, org.lwjgl.util.vector.Quaternion arg1) { - throw new UnsupportedOperationException(); + /** + * Calculate the conjugate of this quaternion + */ + public Vector negate() { + return negate(this, this); } - public org.lwjgl.util.vector.Quaternion normalise(org.lwjgl.util.vector.Quaternion arg0) { - throw new UnsupportedOperationException(); + /* (non-Javadoc) + * @see org.lwjgl.util.vector.Vector#load(java.nio.FloatBuffer) + */ + public Vector load(FloatBuffer buf) { + x = buf.get(); + y = buf.get(); + z = buf.get(); + w = buf.get(); + return this; } - public static org.lwjgl.util.vector.Quaternion normalise( - org.lwjgl.util.vector.Quaternion arg0, org.lwjgl.util.vector.Quaternion arg1) { - throw new UnsupportedOperationException(); + /* + * (non-Javadoc) + * + * @see org.lwjgl.vector.Vector#scale(float) + */ + public Vector scale(float scale) { + return scale(scale, this, this); } - public org.lwjgl.util.vector.Vector scale(float arg0) { - throw new UnsupportedOperationException(); + /** + * Scale the source quaternion by scale and put the result in the destination + * @param scale The amount to scale by + * @param src The source quaternion + * @param dest The destination quaternion, or null if a new quaternion is to be created + * @return The scaled quaternion + */ + public static Quaternion scale(float scale, Quaternion src, Quaternion dest) { + if (dest == null) dest = new Quaternion(); + dest.x = src.x * scale; + dest.y = src.y * scale; + dest.z = src.z * scale; + dest.w = src.w * scale; + return dest; } - public static org.lwjgl.util.vector.Quaternion scale( - float arg0, org.lwjgl.util.vector.Quaternion arg1, org.lwjgl.util.vector.Quaternion arg2) { - throw new UnsupportedOperationException(); + /* (non-Javadoc) + * @see org.lwjgl.util.vector.ReadableVector#store(java.nio.FloatBuffer) + */ + public Vector store(FloatBuffer buf) { + buf.put(x); + buf.put(y); + buf.put(z); + buf.put(w); + + return this; } - public void set(float arg0, float arg1) { - throw new UnsupportedOperationException(); + /** + * @return x + */ + public final float getX() { + return x; } - public void set(float arg0, float arg1, float arg2) { - throw new UnsupportedOperationException(); + /** + * @return y + */ + public final float getY() { + return y; } - public void set(float arg0, float arg1, float arg2, float arg3) { - throw new UnsupportedOperationException(); + /** + * Set X + * + * @param x + */ + public final void setX(float x) { + this.x = x; } - public org.lwjgl.util.vector.Quaternion set(org.lwjgl.util.vector.ReadableVector4f arg0) { - throw new UnsupportedOperationException(); + /** + * Set Y + * + * @param y + */ + public final void setY(float y) { + this.y = y; } - public final void setFromAxisAngle(org.lwjgl.util.vector.Vector4f arg0) { - throw new UnsupportedOperationException(); + /** + * Set Z + * + * @param z + */ + public void setZ(float z) { + this.z = z; } - public final org.lwjgl.util.vector.Quaternion setFromMatrix(org.lwjgl.util.vector.Matrix3f arg0) { - throw new UnsupportedOperationException(); + /* + * (Overrides) + * + * @see org.lwjgl.vector.ReadableVector3f#getZ() + */ + public float getZ() { + return z; } - public static org.lwjgl.util.vector.Quaternion setFromMatrix( - org.lwjgl.util.vector.Matrix3f arg0, org.lwjgl.util.vector.Quaternion arg1) { - throw new UnsupportedOperationException(); + /** + * Set W + * + * @param w + */ + public void setW(float w) { + this.w = w; } - public final org.lwjgl.util.vector.Quaternion setFromMatrix(org.lwjgl.util.vector.Matrix4f arg0) { - throw new UnsupportedOperationException(); + /* + * (Overrides) + * + * @see org.lwjgl.vector.ReadableVector3f#getW() + */ + public float getW() { + return w; } - public static org.lwjgl.util.vector.Quaternion setFromMatrix( - org.lwjgl.util.vector.Matrix4f arg0, org.lwjgl.util.vector.Quaternion arg1) { - throw new UnsupportedOperationException(); + public String toString() { + return "Quaternion: " + x + " " + y + " " + z + " " + w; } - public org.lwjgl.util.vector.Quaternion setIdentity() { - throw new UnsupportedOperationException(); + /** + * Sets the value of this quaternion to the quaternion product of + * quaternions left and right (this = left * right). Note that this is safe + * for aliasing (e.g. this can be left or right). + * + * @param left + * the first quaternion + * @param right + * the second quaternion + */ + public static Quaternion mul(Quaternion left, Quaternion right, Quaternion dest) { + if (dest == null) dest = new Quaternion(); + dest.set( + left.x * right.w + left.w * right.x + left.y * right.z - left.z * right.y, + left.y * right.w + left.w * right.y + left.z * right.x - left.x * right.z, + left.z * right.w + left.w * right.z + left.x * right.y - left.y * right.x, + left.w * right.w - left.x * right.x - left.y * right.y - left.z * right.z); + return dest; } - public static org.lwjgl.util.vector.Quaternion setIdentity(org.lwjgl.util.vector.Quaternion arg0) { - throw new UnsupportedOperationException(); + /** + * + * Multiplies quaternion left by the inverse of quaternion right and places + * the value into this quaternion. The value of both argument quaternions is + * preservered (this = left * right^-1). + * + * @param left + * the left quaternion + * @param right + * the right quaternion + */ + public static Quaternion mulInverse(Quaternion left, Quaternion right, Quaternion dest) { + float n = right.lengthSquared(); + // zero-div may occur. + n = (n == 0.0 ? n : 1 / n); + // store on stack once for aliasing-safty + if (dest == null) dest = new Quaternion(); + dest.set( + (left.x * right.w - left.w * right.x - left.y * right.z + left.z * right.y) * n, + (left.y * right.w - left.w * right.y - left.z * right.x + left.x * right.z) * n, + (left.z * right.w - left.w * right.z - left.x * right.y + left.y * right.x) * n, + (left.w * right.w + left.x * right.x + left.y * right.y + left.z * right.z) * n); + + return dest; } - public void setW(float arg0) { - throw new UnsupportedOperationException(); + /** + * Sets the value of this quaternion to the equivalent rotation of the + * Axis-Angle argument. + * + * @param a1 + * the axis-angle: (x,y,z) is the axis and w is the angle + */ + public final void setFromAxisAngle(Vector4f a1) { + x = a1.x; + y = a1.y; + z = a1.z; + float n = (float) Math.sqrt(x * x + y * y + z * z); + // zero-div may occur. + float s = (float) (Math.sin(0.5 * a1.w) / n); + x *= s; + y *= s; + z *= s; + w = (float) Math.cos(0.5 * a1.w); } - public final void setX(float arg0) { - throw new UnsupportedOperationException(); + /** + * Sets the value of this quaternion using the rotational component of the + * passed matrix. + * + * @param m + * The matrix + * @return this + */ + public final Quaternion setFromMatrix(Matrix4f m) { + return setFromMatrix(m, this); } - public final void setY(float arg0) { - throw new UnsupportedOperationException(); + /** + * Sets the value of the source quaternion using the rotational component of the + * passed matrix. + * + * @param m + * The source matrix + * @param q + * The destination quaternion, or null if a new quaternion is to be created + * @return q + */ + public static Quaternion setFromMatrix(Matrix4f m, Quaternion q) { + return q.setFromMat(m.m00, m.m01, m.m02, m.m10, m.m11, m.m12, m.m20, m.m21, m.m22); } - public void setZ(float arg0) { - throw new UnsupportedOperationException(); + /** + * Sets the value of this quaternion using the rotational component of the + * passed matrix. + * + * @param m + * The source matrix + */ + public final Quaternion setFromMatrix(Matrix3f m) { + return setFromMatrix(m, this); } - public org.lwjgl.util.vector.Vector store(java.nio.FloatBuffer arg0) { - throw new UnsupportedOperationException(); + /** + * Sets the value of the source quaternion using the rotational component of the + * passed matrix. + * + * @param m + * The source matrix + * @param q + * The destination quaternion, or null if a new quaternion is to be created + * @return q + */ + public static Quaternion setFromMatrix(Matrix3f m, Quaternion q) { + return q.setFromMat(m.m00, m.m01, m.m02, m.m10, m.m11, m.m12, m.m20, m.m21, m.m22); } - public java.lang.String toString() { - throw new UnsupportedOperationException(); + /** + * Private method to perform the matrix-to-quaternion conversion + */ + private Quaternion setFromMat( + float m00, float m01, float m02, float m10, float m11, float m12, float m20, float m21, float m22) { + + float s; + float tr = m00 + m11 + m22; + if (tr >= 0.0) { + s = (float) Math.sqrt(tr + 1.0); + w = s * 0.5f; + s = 0.5f / s; + x = (m21 - m12) * s; + y = (m02 - m20) * s; + z = (m10 - m01) * s; + } else { + float max = Math.max(Math.max(m00, m11), m22); + if (max == m00) { + s = (float) Math.sqrt(m00 - (m11 + m22) + 1.0); + x = s * 0.5f; + s = 0.5f / s; + y = (m01 + m10) * s; + z = (m20 + m02) * s; + w = (m21 - m12) * s; + } else if (max == m11) { + s = (float) Math.sqrt(m11 - (m22 + m00) + 1.0); + y = s * 0.5f; + s = 0.5f / s; + z = (m12 + m21) * s; + x = (m01 + m10) * s; + w = (m02 - m20) * s; + } else { + s = (float) Math.sqrt(m22 - (m00 + m11) + 1.0); + z = s * 0.5f; + s = 0.5f / s; + x = (m20 + m02) * s; + y = (m12 + m21) * s; + w = (m10 - m01) * s; + } + } + return this; } } diff --git a/src/generated/java/org/lwjgl/util/vector/ReadableVector.java b/src/generated/java/org/lwjgl/util/vector/ReadableVector.java index 21c8f87..423868c 100644 --- a/src/generated/java/org/lwjgl/util/vector/ReadableVector.java +++ b/src/generated/java/org/lwjgl/util/vector/ReadableVector.java @@ -1,9 +1,54 @@ +/* + * Copyright (c) 2002-2008 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ package org.lwjgl.util.vector; +import java.nio.FloatBuffer; + +/** + * @author foo + */ public interface ReadableVector { - public abstract float length(); - - public abstract float lengthSquared(); - - public abstract org.lwjgl.util.vector.Vector store(java.nio.FloatBuffer arg0); + /** + * @return the length of the vector + */ + float length(); + /** + * @return the length squared of the vector + */ + float lengthSquared(); + /** + * Store this vector in a FloatBuffer + * @param buf The buffer to store it in, at the current position + * @return this + */ + Vector store(FloatBuffer buf); } diff --git a/src/generated/java/org/lwjgl/util/vector/ReadableVector2f.java b/src/generated/java/org/lwjgl/util/vector/ReadableVector2f.java index a3f3629..1a522d8 100644 --- a/src/generated/java/org/lwjgl/util/vector/ReadableVector2f.java +++ b/src/generated/java/org/lwjgl/util/vector/ReadableVector2f.java @@ -1,7 +1,46 @@ +/* + * Copyright (c) 2002-2008 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ package org.lwjgl.util.vector; -public interface ReadableVector2f { - public abstract float getX(); - - public abstract float getY(); +/** + * @author foo + */ +public interface ReadableVector2f extends ReadableVector { + /** + * @return x + */ + float getX(); + /** + * @return y + */ + float getY(); } diff --git a/src/generated/java/org/lwjgl/util/vector/ReadableVector3f.java b/src/generated/java/org/lwjgl/util/vector/ReadableVector3f.java index b3e18ab..227403c 100644 --- a/src/generated/java/org/lwjgl/util/vector/ReadableVector3f.java +++ b/src/generated/java/org/lwjgl/util/vector/ReadableVector3f.java @@ -1,5 +1,42 @@ +/* + * Copyright (c) 2002-2008 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ package org.lwjgl.util.vector; -public interface ReadableVector3f { - public abstract float getZ(); +/** + * @author foo + */ +public interface ReadableVector3f extends ReadableVector2f { + /** + * @return z + */ + float getZ(); } diff --git a/src/generated/java/org/lwjgl/util/vector/ReadableVector4f.java b/src/generated/java/org/lwjgl/util/vector/ReadableVector4f.java index 18eb513..5b79cd1 100644 --- a/src/generated/java/org/lwjgl/util/vector/ReadableVector4f.java +++ b/src/generated/java/org/lwjgl/util/vector/ReadableVector4f.java @@ -1,5 +1,43 @@ +/* + * Copyright (c) 2002-2008 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ package org.lwjgl.util.vector; -public interface ReadableVector4f { - public abstract float getW(); +/** + * @author foo + */ +public interface ReadableVector4f extends ReadableVector3f { + + /** + * @return w + */ + float getW(); } diff --git a/src/generated/java/org/lwjgl/util/vector/Vector.java b/src/generated/java/org/lwjgl/util/vector/Vector.java index e8b29fe..93051ce 100644 --- a/src/generated/java/org/lwjgl/util/vector/Vector.java +++ b/src/generated/java/org/lwjgl/util/vector/Vector.java @@ -1,21 +1,104 @@ +/* + * Copyright (c) 2002-2008 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ package org.lwjgl.util.vector; -public abstract class Vector { - public final float length() { - throw new UnsupportedOperationException(); +import java.io.Serializable; +import java.nio.FloatBuffer; + +/** + * + * Base class for vectors. + * + * @author cix_foo + * @version $Revision: 3418 $ + * $Id: Vector.java 3418 2010-09-28 21:11:35Z spasi $ + */ +public abstract class Vector implements Serializable, ReadableVector { + + /** + * Constructor for Vector. + */ + protected Vector() { + super(); } + /** + * @return the length of the vector + */ + public final float length() { + return (float) Math.sqrt(lengthSquared()); + } + + /** + * @return the length squared of the vector + */ public abstract float lengthSquared(); - public abstract org.lwjgl.util.vector.Vector load(java.nio.FloatBuffer arg0); + /** + * Load this vector from a FloatBuffer + * @param buf The buffer to load it from, at the current position + * @return this + */ + public abstract Vector load(FloatBuffer buf); - public abstract org.lwjgl.util.vector.Vector negate(); + /** + * Negate a vector + * @return this + */ + public abstract Vector negate(); - public final org.lwjgl.util.vector.Vector normalise() { - throw new UnsupportedOperationException(); + /** + * Normalise this vector + * @return this + */ + public final Vector normalise() { + float len = length(); + if (len != 0.0f) { + float l = 1.0f / len; + return scale(l); + } else throw new IllegalStateException("Zero length vector"); } - public abstract org.lwjgl.util.vector.Vector scale(float arg0); + /** + * Store this vector in a FloatBuffer + * @param buf The buffer to store it in, at the current position + * @return this + */ + public abstract Vector store(FloatBuffer buf); - public abstract org.lwjgl.util.vector.Vector store(java.nio.FloatBuffer arg0); + /** + * Scale this vector + * @param scale The scale factor + * @return this + */ + public abstract Vector scale(float scale); } diff --git a/src/generated/java/org/lwjgl/util/vector/Vector2f.java b/src/generated/java/org/lwjgl/util/vector/Vector2f.java index 2dc0e17..5e1ce0b 100644 --- a/src/generated/java/org/lwjgl/util/vector/Vector2f.java +++ b/src/generated/java/org/lwjgl/util/vector/Vector2f.java @@ -1,92 +1,278 @@ +/* + * Copyright (c) 2002-2008 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ package org.lwjgl.util.vector; -public class Vector2f extends org.lwjgl.util.vector.Vector { - public float x = 0.0F; - public float y = 0.0F; +import java.io.Serializable; +import java.nio.FloatBuffer; - public static org.lwjgl.util.vector.Vector2f add( - org.lwjgl.util.vector.Vector2f arg0, - org.lwjgl.util.vector.Vector2f arg1, - org.lwjgl.util.vector.Vector2f arg2) { - throw new UnsupportedOperationException(); +/** + * + * Holds a 2-tuple vector. + * + * @author cix_foo + * @version $Revision: 3418 $ + * $Id: Vector2f.java 3418 2010-09-28 21:11:35Z spasi $ + */ +public class Vector2f extends Vector implements Serializable, ReadableVector2f, WritableVector2f { + + private static final long serialVersionUID = 1L; + + public float x, y; + + /** + * Constructor for Vector3f. + */ + public Vector2f() { + super(); } - public static float angle(org.lwjgl.util.vector.Vector2f arg0, org.lwjgl.util.vector.Vector2f arg1) { - throw new UnsupportedOperationException(); + /** + * Constructor + */ + public Vector2f(ReadableVector2f src) { + set(src); } - public static float dot(org.lwjgl.util.vector.Vector2f arg0, org.lwjgl.util.vector.Vector2f arg1) { - throw new UnsupportedOperationException(); + /** + * Constructor + */ + public Vector2f(float x, float y) { + set(x, y); } - public boolean equals(java.lang.Object arg0) { - throw new UnsupportedOperationException(); + /* (non-Javadoc) + * @see org.lwjgl.util.vector.WritableVector2f#set(float, float) + */ + public void set(float x, float y) { + this.x = x; + this.y = y; } - public final float getX() { - throw new UnsupportedOperationException(); - } - - public final float getY() { - throw new UnsupportedOperationException(); + /** + * Load from another Vector2f + * @param src The source vector + * @return this + */ + public Vector2f set(ReadableVector2f src) { + x = src.getX(); + y = src.getY(); + return this; } + /** + * @return the length squared of the vector + */ public float lengthSquared() { - throw new UnsupportedOperationException(); + return x * x + y * y; } - public org.lwjgl.util.vector.Vector load(java.nio.FloatBuffer arg0) { - throw new UnsupportedOperationException(); + /** + * Translate a vector + * @param x The translation in x + * @param y the translation in y + * @return this + */ + public Vector2f translate(float x, float y) { + this.x += x; + this.y += y; + return this; } - public org.lwjgl.util.vector.Vector negate() { - throw new UnsupportedOperationException(); + /** + * Negate a vector + * @return this + */ + public Vector negate() { + x = -x; + y = -y; + return this; } - public org.lwjgl.util.vector.Vector2f negate(org.lwjgl.util.vector.Vector2f arg0) { - throw new UnsupportedOperationException(); + /** + * Negate a vector and place the result in a destination vector. + * @param dest The destination vector or null if a new vector is to be created + * @return the negated vector + */ + public Vector2f negate(Vector2f dest) { + if (dest == null) dest = new Vector2f(); + dest.x = -x; + dest.y = -y; + return dest; } - public org.lwjgl.util.vector.Vector2f normalise(org.lwjgl.util.vector.Vector2f arg0) { - throw new UnsupportedOperationException(); + /** + * Normalise this vector and place the result in another vector. + * @param dest The destination vector, or null if a new vector is to be created + * @return the normalised vector + */ + public Vector2f normalise(Vector2f dest) { + float l = length(); + + if (dest == null) dest = new Vector2f(x / l, y / l); + else dest.set(x / l, y / l); + + return dest; } - public org.lwjgl.util.vector.Vector scale(float arg0) { - throw new UnsupportedOperationException(); + /** + * The dot product of two vectors is calculated as + * v1.x * v2.x + v1.y * v2.y + v1.z * v2.z + * @param left The LHS vector + * @param right The RHS vector + * @return left dot right + */ + public static float dot(Vector2f left, Vector2f right) { + return left.x * right.x + left.y * right.y; } - public void set(float arg0, float arg1) { - throw new UnsupportedOperationException(); + /** + * Calculate the angle between two vectors, in radians + * @param a A vector + * @param b The other vector + * @return the angle between the two vectors, in radians + */ + public static float angle(Vector2f a, Vector2f b) { + float dls = dot(a, b) / (a.length() * b.length()); + if (dls < -1f) dls = -1f; + else if (dls > 1.0f) dls = 1.0f; + return (float) Math.acos(dls); } - public org.lwjgl.util.vector.Vector2f set(org.lwjgl.util.vector.ReadableVector2f arg0) { - throw new UnsupportedOperationException(); + /** + * Add a vector to another vector and place the result in a destination + * vector. + * @param left The LHS vector + * @param right The RHS vector + * @param dest The destination vector, or null if a new vector is to be created + * @return the sum of left and right in dest + */ + public static Vector2f add(Vector2f left, Vector2f right, Vector2f dest) { + if (dest == null) return new Vector2f(left.x + right.x, left.y + right.y); + else { + dest.set(left.x + right.x, left.y + right.y); + return dest; + } } - public final void setX(float arg0) { - throw new UnsupportedOperationException(); + /** + * Subtract a vector from another vector and place the result in a destination + * vector. + * @param left The LHS vector + * @param right The RHS vector + * @param dest The destination vector, or null if a new vector is to be created + * @return left minus right in dest + */ + public static Vector2f sub(Vector2f left, Vector2f right, Vector2f dest) { + if (dest == null) return new Vector2f(left.x - right.x, left.y - right.y); + else { + dest.set(left.x - right.x, left.y - right.y); + return dest; + } } - public final void setY(float arg0) { - throw new UnsupportedOperationException(); + /** + * Store this vector in a FloatBuffer + * @param buf The buffer to store it in, at the current position + * @return this + */ + public Vector store(FloatBuffer buf) { + buf.put(x); + buf.put(y); + return this; } - public org.lwjgl.util.vector.Vector store(java.nio.FloatBuffer arg0) { - throw new UnsupportedOperationException(); + /** + * Load this vector from a FloatBuffer + * @param buf The buffer to load it from, at the current position + * @return this + */ + public Vector load(FloatBuffer buf) { + x = buf.get(); + y = buf.get(); + return this; } - public static org.lwjgl.util.vector.Vector2f sub( - org.lwjgl.util.vector.Vector2f arg0, - org.lwjgl.util.vector.Vector2f arg1, - org.lwjgl.util.vector.Vector2f arg2) { - throw new UnsupportedOperationException(); + /* (non-Javadoc) + * @see org.lwjgl.vector.Vector#scale(float) + */ + public Vector scale(float scale) { + + x *= scale; + y *= scale; + + return this; } - public java.lang.String toString() { - throw new UnsupportedOperationException(); + /* (non-Javadoc) + * @see java.lang.Object#toString() + */ + public String toString() { + StringBuilder sb = new StringBuilder(64); + + sb.append("Vector2f["); + sb.append(x); + sb.append(", "); + sb.append(y); + sb.append(']'); + return sb.toString(); } - public org.lwjgl.util.vector.Vector2f translate(float arg0, float arg1) { - throw new UnsupportedOperationException(); + /** + * @return x + */ + public final float getX() { + return x; + } + + /** + * @return y + */ + public final float getY() { + return y; + } + + /** + * Set X + * @param x + */ + public final void setX(float x) { + this.x = x; + } + + /** + * Set Y + * @param y + */ + public final void setY(float y) { + this.y = y; } } diff --git a/src/generated/java/org/lwjgl/util/vector/Vector3f.java b/src/generated/java/org/lwjgl/util/vector/Vector3f.java index 05cdf90..333c930 100644 --- a/src/generated/java/org/lwjgl/util/vector/Vector3f.java +++ b/src/generated/java/org/lwjgl/util/vector/Vector3f.java @@ -1,112 +1,329 @@ +/* + * Copyright (c) 2002-2008 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ package org.lwjgl.util.vector; -public class Vector3f extends org.lwjgl.util.vector.Vector { - public float x = 0.0F; - public float y = 0.0F; - public float z = 0.0F; +import java.io.Serializable; +import java.nio.FloatBuffer; - public static org.lwjgl.util.vector.Vector3f add( - org.lwjgl.util.vector.Vector3f arg0, - org.lwjgl.util.vector.Vector3f arg1, - org.lwjgl.util.vector.Vector3f arg2) { - throw new UnsupportedOperationException(); +/** + * + * Holds a 3-tuple vector. + * + * @author cix_foo + * @version $Revision: 3418 $ + * $Id: Vector3f.java 3418 2010-09-28 21:11:35Z spasi $ + */ +public class Vector3f extends Vector implements Serializable, ReadableVector3f, WritableVector3f { + + private static final long serialVersionUID = 1L; + + public float x, y, z; + + /** + * Constructor for Vector3f. + */ + public Vector3f() { + super(); } - public static float angle(org.lwjgl.util.vector.Vector3f arg0, org.lwjgl.util.vector.Vector3f arg1) { - throw new UnsupportedOperationException(); + /** + * Constructor + */ + public Vector3f(ReadableVector3f src) { + set(src); } - public static org.lwjgl.util.vector.Vector3f cross( - org.lwjgl.util.vector.Vector3f arg0, - org.lwjgl.util.vector.Vector3f arg1, - org.lwjgl.util.vector.Vector3f arg2) { - throw new UnsupportedOperationException(); + /** + * Constructor + */ + public Vector3f(float x, float y, float z) { + set(x, y, z); } - public static float dot(org.lwjgl.util.vector.Vector3f arg0, org.lwjgl.util.vector.Vector3f arg1) { - throw new UnsupportedOperationException(); + /* (non-Javadoc) + * @see org.lwjgl.util.vector.WritableVector2f#set(float, float) + */ + public void set(float x, float y) { + this.x = x; + this.y = y; } - public boolean equals(java.lang.Object arg0) { - throw new UnsupportedOperationException(); + /* (non-Javadoc) + * @see org.lwjgl.util.vector.WritableVector3f#set(float, float, float) + */ + public void set(float x, float y, float z) { + this.x = x; + this.y = y; + this.z = z; } - public final float getX() { - throw new UnsupportedOperationException(); - } - - public final float getY() { - throw new UnsupportedOperationException(); - } - - public float getZ() { - throw new UnsupportedOperationException(); + /** + * Load from another Vector3f + * @param src The source vector + * @return this + */ + public Vector3f set(ReadableVector3f src) { + x = src.getX(); + y = src.getY(); + z = src.getZ(); + return this; } + /** + * @return the length squared of the vector + */ public float lengthSquared() { - throw new UnsupportedOperationException(); + return x * x + y * y + z * z; } - public org.lwjgl.util.vector.Vector load(java.nio.FloatBuffer arg0) { - throw new UnsupportedOperationException(); + /** + * Translate a vector + * @param x The translation in x + * @param y the translation in y + * @return this + */ + public Vector3f translate(float x, float y, float z) { + this.x += x; + this.y += y; + this.z += z; + return this; } - public org.lwjgl.util.vector.Vector negate() { - throw new UnsupportedOperationException(); + /** + * Add a vector to another vector and place the result in a destination + * vector. + * @param left The LHS vector + * @param right The RHS vector + * @param dest The destination vector, or null if a new vector is to be created + * @return the sum of left and right in dest + */ + public static Vector3f add(Vector3f left, Vector3f right, Vector3f dest) { + if (dest == null) return new Vector3f(left.x + right.x, left.y + right.y, left.z + right.z); + else { + dest.set(left.x + right.x, left.y + right.y, left.z + right.z); + return dest; + } } - public org.lwjgl.util.vector.Vector3f negate(org.lwjgl.util.vector.Vector3f arg0) { - throw new UnsupportedOperationException(); + /** + * Subtract a vector from another vector and place the result in a destination + * vector. + * @param left The LHS vector + * @param right The RHS vector + * @param dest The destination vector, or null if a new vector is to be created + * @return left minus right in dest + */ + public static Vector3f sub(Vector3f left, Vector3f right, Vector3f dest) { + if (dest == null) return new Vector3f(left.x - right.x, left.y - right.y, left.z - right.z); + else { + dest.set(left.x - right.x, left.y - right.y, left.z - right.z); + return dest; + } } - public org.lwjgl.util.vector.Vector3f normalise(org.lwjgl.util.vector.Vector3f arg0) { - throw new UnsupportedOperationException(); + /** + * The cross product of two vectors. + * + * @param left The LHS vector + * @param right The RHS vector + * @param dest The destination result, or null if a new vector is to be created + * @return left cross right + */ + public static Vector3f cross(Vector3f left, Vector3f right, Vector3f dest) { + + if (dest == null) dest = new Vector3f(); + + dest.set( + left.y * right.z - left.z * right.y, + right.x * left.z - right.z * left.x, + left.x * right.y - left.y * right.x); + + return dest; } - public org.lwjgl.util.vector.Vector scale(float arg0) { - throw new UnsupportedOperationException(); + /** + * Negate a vector + * @return this + */ + public Vector negate() { + x = -x; + y = -y; + z = -z; + return this; } - public void set(float arg0, float arg1) { - throw new UnsupportedOperationException(); + /** + * Negate a vector and place the result in a destination vector. + * @param dest The destination vector or null if a new vector is to be created + * @return the negated vector + */ + public Vector3f negate(Vector3f dest) { + if (dest == null) dest = new Vector3f(); + dest.x = -x; + dest.y = -y; + dest.z = -z; + return dest; } - public void set(float arg0, float arg1, float arg2) { - throw new UnsupportedOperationException(); + /** + * Normalise this vector and place the result in another vector. + * @param dest The destination vector, or null if a new vector is to be created + * @return the normalised vector + */ + public Vector3f normalise(Vector3f dest) { + float l = length(); + + if (dest == null) dest = new Vector3f(x / l, y / l, z / l); + else dest.set(x / l, y / l, z / l); + + return dest; } - public org.lwjgl.util.vector.Vector3f set(org.lwjgl.util.vector.ReadableVector3f arg0) { - throw new UnsupportedOperationException(); + /** + * The dot product of two vectors is calculated as + * v1.x * v2.x + v1.y * v2.y + v1.z * v2.z + * @param left The LHS vector + * @param right The RHS vector + * @return left dot right + */ + public static float dot(Vector3f left, Vector3f right) { + return left.x * right.x + left.y * right.y + left.z * right.z; } - public final void setX(float arg0) { - throw new UnsupportedOperationException(); + /** + * Calculate the angle between two vectors, in radians + * @param a A vector + * @param b The other vector + * @return the angle between the two vectors, in radians + */ + public static float angle(Vector3f a, Vector3f b) { + float dls = dot(a, b) / (a.length() * b.length()); + if (dls < -1f) dls = -1f; + else if (dls > 1.0f) dls = 1.0f; + return (float) Math.acos(dls); } - public final void setY(float arg0) { - throw new UnsupportedOperationException(); + /* (non-Javadoc) + * @see org.lwjgl.vector.Vector#load(FloatBuffer) + */ + public Vector load(FloatBuffer buf) { + x = buf.get(); + y = buf.get(); + z = buf.get(); + return this; } - public void setZ(float arg0) { - throw new UnsupportedOperationException(); + /* (non-Javadoc) + * @see org.lwjgl.vector.Vector#scale(float) + */ + public Vector scale(float scale) { + + x *= scale; + y *= scale; + z *= scale; + + return this; } - public org.lwjgl.util.vector.Vector store(java.nio.FloatBuffer arg0) { - throw new UnsupportedOperationException(); + /* (non-Javadoc) + * @see org.lwjgl.vector.Vector#store(FloatBuffer) + */ + public Vector store(FloatBuffer buf) { + + buf.put(x); + buf.put(y); + buf.put(z); + + return this; } - public static org.lwjgl.util.vector.Vector3f sub( - org.lwjgl.util.vector.Vector3f arg0, - org.lwjgl.util.vector.Vector3f arg1, - org.lwjgl.util.vector.Vector3f arg2) { - throw new UnsupportedOperationException(); + /* (non-Javadoc) + * @see java.lang.Object#toString() + */ + public String toString() { + StringBuilder sb = new StringBuilder(64); + + sb.append("Vector3f["); + sb.append(x); + sb.append(", "); + sb.append(y); + sb.append(", "); + sb.append(z); + sb.append(']'); + return sb.toString(); } - public java.lang.String toString() { - throw new UnsupportedOperationException(); + /** + * @return x + */ + public final float getX() { + return x; } - public org.lwjgl.util.vector.Vector3f translate(float arg0, float arg1, float arg2) { - throw new UnsupportedOperationException(); + /** + * @return y + */ + public final float getY() { + return y; + } + + /** + * Set X + * @param x + */ + public final void setX(float x) { + this.x = x; + } + + /** + * Set Y + * @param y + */ + public final void setY(float y) { + this.y = y; + } + + /** + * Set Z + * @param z + */ + public void setZ(float z) { + this.z = z; + } + + /* (Overrides) + * @see org.lwjgl.vector.ReadableVector3f#getZ() + */ + public float getZ() { + return z; } } diff --git a/src/generated/java/org/lwjgl/util/vector/Vector4f.java b/src/generated/java/org/lwjgl/util/vector/Vector4f.java index b4cf5f9..9519ce9 100644 --- a/src/generated/java/org/lwjgl/util/vector/Vector4f.java +++ b/src/generated/java/org/lwjgl/util/vector/Vector4f.java @@ -1,118 +1,327 @@ +/* + * Copyright (c) 2002-2008 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ package org.lwjgl.util.vector; -public class Vector4f extends org.lwjgl.util.vector.Vector { - public float w = 0.0F; - public float x = 0.0F; - public float y = 0.0F; - public float z = 0.0F; +import java.io.Serializable; +import java.nio.FloatBuffer; - public static org.lwjgl.util.vector.Vector4f add( - org.lwjgl.util.vector.Vector4f arg0, - org.lwjgl.util.vector.Vector4f arg1, - org.lwjgl.util.vector.Vector4f arg2) { - throw new UnsupportedOperationException(); +/** + * + * Holds a 4-tuple vector. + * + * @author cix_foo + * @version $Revision: 2983 $ + * $Id: Vector4f.java 2983 2008-04-07 18:36:09Z matzon $ + */ +public class Vector4f extends Vector implements Serializable, ReadableVector4f, WritableVector4f { + + private static final long serialVersionUID = 1L; + + public float x, y, z, w; + + /** + * Constructor for Vector4f. + */ + public Vector4f() { + super(); } - public static float angle(org.lwjgl.util.vector.Vector4f arg0, org.lwjgl.util.vector.Vector4f arg1) { - throw new UnsupportedOperationException(); + /** + * Constructor + */ + public Vector4f(ReadableVector4f src) { + set(src); } - public static float dot(org.lwjgl.util.vector.Vector4f arg0, org.lwjgl.util.vector.Vector4f arg1) { - throw new UnsupportedOperationException(); + /** + * Constructor + */ + public Vector4f(float x, float y, float z, float w) { + set(x, y, z, w); } - public boolean equals(java.lang.Object arg0) { - throw new UnsupportedOperationException(); + /* (non-Javadoc) + * @see org.lwjgl.util.vector.WritableVector2f#set(float, float) + */ + public void set(float x, float y) { + this.x = x; + this.y = y; } - public float getW() { - throw new UnsupportedOperationException(); + /* (non-Javadoc) + * @see org.lwjgl.util.vector.WritableVector3f#set(float, float, float) + */ + public void set(float x, float y, float z) { + this.x = x; + this.y = y; + this.z = z; } - public final float getX() { - throw new UnsupportedOperationException(); + /* (non-Javadoc) + * @see org.lwjgl.util.vector.WritableVector4f#set(float, float, float, float) + */ + public void set(float x, float y, float z, float w) { + this.x = x; + this.y = y; + this.z = z; + this.w = w; } - public final float getY() { - throw new UnsupportedOperationException(); - } - - public float getZ() { - throw new UnsupportedOperationException(); + /** + * Load from another Vector4f + * @param src The source vector + * @return this + */ + public Vector4f set(ReadableVector4f src) { + x = src.getX(); + y = src.getY(); + z = src.getZ(); + w = src.getW(); + return this; } + /** + * @return the length squared of the vector + */ public float lengthSquared() { - throw new UnsupportedOperationException(); + return x * x + y * y + z * z + w * w; } - public org.lwjgl.util.vector.Vector load(java.nio.FloatBuffer arg0) { - throw new UnsupportedOperationException(); + /** + * Translate a vector + * @param x The translation in x + * @param y the translation in y + * @return this + */ + public Vector4f translate(float x, float y, float z, float w) { + this.x += x; + this.y += y; + this.z += z; + this.w += w; + return this; } - public org.lwjgl.util.vector.Vector negate() { - throw new UnsupportedOperationException(); + /** + * Add a vector to another vector and place the result in a destination + * vector. + * @param left The LHS vector + * @param right The RHS vector + * @param dest The destination vector, or null if a new vector is to be created + * @return the sum of left and right in dest + */ + public static Vector4f add(Vector4f left, Vector4f right, Vector4f dest) { + if (dest == null) return new Vector4f(left.x + right.x, left.y + right.y, left.z + right.z, left.w + right.w); + else { + dest.set(left.x + right.x, left.y + right.y, left.z + right.z, left.w + right.w); + return dest; + } } - public org.lwjgl.util.vector.Vector4f negate(org.lwjgl.util.vector.Vector4f arg0) { - throw new UnsupportedOperationException(); + /** + * Subtract a vector from another vector and place the result in a destination + * vector. + * @param left The LHS vector + * @param right The RHS vector + * @param dest The destination vector, or null if a new vector is to be created + * @return left minus right in dest + */ + public static Vector4f sub(Vector4f left, Vector4f right, Vector4f dest) { + if (dest == null) return new Vector4f(left.x - right.x, left.y - right.y, left.z - right.z, left.w - right.w); + else { + dest.set(left.x - right.x, left.y - right.y, left.z - right.z, left.w - right.w); + return dest; + } } - public org.lwjgl.util.vector.Vector4f normalise(org.lwjgl.util.vector.Vector4f arg0) { - throw new UnsupportedOperationException(); + /** + * Negate a vector + * @return this + */ + public Vector negate() { + x = -x; + y = -y; + z = -z; + w = -w; + return this; } - public org.lwjgl.util.vector.Vector scale(float arg0) { - throw new UnsupportedOperationException(); + /** + * Negate a vector and place the result in a destination vector. + * @param dest The destination vector or null if a new vector is to be created + * @return the negated vector + */ + public Vector4f negate(Vector4f dest) { + if (dest == null) dest = new Vector4f(); + dest.x = -x; + dest.y = -y; + dest.z = -z; + dest.w = -w; + return dest; } - public void set(float arg0, float arg1) { - throw new UnsupportedOperationException(); + /** + * Normalise this vector and place the result in another vector. + * @param dest The destination vector, or null if a new vector is to be created + * @return the normalised vector + */ + public Vector4f normalise(Vector4f dest) { + float l = length(); + + if (dest == null) dest = new Vector4f(x / l, y / l, z / l, w / l); + else dest.set(x / l, y / l, z / l, w / l); + + return dest; } - public void set(float arg0, float arg1, float arg2) { - throw new UnsupportedOperationException(); + /** + * The dot product of two vectors is calculated as + * v1.x * v2.x + v1.y * v2.y + v1.z * v2.z + v1.w * v2.w + * @param left The LHS vector + * @param right The RHS vector + * @return left dot right + */ + public static float dot(Vector4f left, Vector4f right) { + return left.x * right.x + left.y * right.y + left.z * right.z + left.w * right.w; } - public void set(float arg0, float arg1, float arg2, float arg3) { - throw new UnsupportedOperationException(); + /** + * Calculate the angle between two vectors, in radians + * @param a A vector + * @param b The other vector + * @return the angle between the two vectors, in radians + */ + public static float angle(Vector4f a, Vector4f b) { + float dls = dot(a, b) / (a.length() * b.length()); + if (dls < -1f) dls = -1f; + else if (dls > 1.0f) dls = 1.0f; + return (float) Math.acos(dls); } - public org.lwjgl.util.vector.Vector4f set(org.lwjgl.util.vector.ReadableVector4f arg0) { - throw new UnsupportedOperationException(); + /* (non-Javadoc) + * @see org.lwjgl.vector.Vector#load(FloatBuffer) + */ + public Vector load(FloatBuffer buf) { + x = buf.get(); + y = buf.get(); + z = buf.get(); + w = buf.get(); + return this; } - public void setW(float arg0) { - throw new UnsupportedOperationException(); + /* (non-Javadoc) + * @see org.lwjgl.vector.Vector#scale(float) + */ + public Vector scale(float scale) { + x *= scale; + y *= scale; + z *= scale; + w *= scale; + return this; } - public final void setX(float arg0) { - throw new UnsupportedOperationException(); + /* (non-Javadoc) + * @see org.lwjgl.vector.Vector#store(FloatBuffer) + */ + public Vector store(FloatBuffer buf) { + + buf.put(x); + buf.put(y); + buf.put(z); + buf.put(w); + + return this; } - public final void setY(float arg0) { - throw new UnsupportedOperationException(); + public String toString() { + return "Vector4f: " + x + " " + y + " " + z + " " + w; } - public void setZ(float arg0) { - throw new UnsupportedOperationException(); + /** + * @return x + */ + public final float getX() { + return x; } - public org.lwjgl.util.vector.Vector store(java.nio.FloatBuffer arg0) { - throw new UnsupportedOperationException(); + /** + * @return y + */ + public final float getY() { + return y; } - public static org.lwjgl.util.vector.Vector4f sub( - org.lwjgl.util.vector.Vector4f arg0, - org.lwjgl.util.vector.Vector4f arg1, - org.lwjgl.util.vector.Vector4f arg2) { - throw new UnsupportedOperationException(); + /** + * Set X + * @param x + */ + public final void setX(float x) { + this.x = x; } - public java.lang.String toString() { - throw new UnsupportedOperationException(); + /** + * Set Y + * @param y + */ + public final void setY(float y) { + this.y = y; } - public org.lwjgl.util.vector.Vector4f translate(float arg0, float arg1, float arg2, float arg3) { - throw new UnsupportedOperationException(); + /** + * Set Z + * @param z + */ + public void setZ(float z) { + this.z = z; + } + + /* (Overrides) + * @see org.lwjgl.vector.ReadableVector3f#getZ() + */ + public float getZ() { + return z; + } + + /** + * Set W + * @param w + */ + public void setW(float w) { + this.w = w; + } + + /* (Overrides) + * @see org.lwjgl.vector.ReadableVector3f#getZ() + */ + public float getW() { + return w; } } diff --git a/src/generated/java/org/lwjgl/util/vector/WritableVector2f.java b/src/generated/java/org/lwjgl/util/vector/WritableVector2f.java index 0021a5f..da75abf 100644 --- a/src/generated/java/org/lwjgl/util/vector/WritableVector2f.java +++ b/src/generated/java/org/lwjgl/util/vector/WritableVector2f.java @@ -1,9 +1,60 @@ +/* + * Copyright (c) 2002-2008 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ package org.lwjgl.util.vector; +/** + * Writable interface to Vector2fs + * @author $author$ + * @version $revision$ + * $Id: WritableVector2f.java 3418 2010-09-28 21:11:35Z spasi $ + */ public interface WritableVector2f { - public abstract void set(float arg0, float arg1); - public abstract void setX(float arg0); + /** + * Set the X value + * @param x + */ + void setX(float x); - public abstract void setY(float arg0); + /** + * Set the Y value + * @param y + */ + void setY(float y); + + /** + * Set the X,Y values + * @param x + * @param y + */ + void set(float x, float y); } diff --git a/src/generated/java/org/lwjgl/util/vector/WritableVector3f.java b/src/generated/java/org/lwjgl/util/vector/WritableVector3f.java index dee2e0e..2cc7b1d 100644 --- a/src/generated/java/org/lwjgl/util/vector/WritableVector3f.java +++ b/src/generated/java/org/lwjgl/util/vector/WritableVector3f.java @@ -1,7 +1,55 @@ +/* + * Copyright (c) 2002-2008 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ package org.lwjgl.util.vector; -public interface WritableVector3f { - public abstract void set(float arg0, float arg1, float arg2); +/** + * Writable interface to Vector3fs + * @author $author$ + * @version $revision$ + * $Id: WritableVector3f.java 3418 2010-09-28 21:11:35Z spasi $ + */ +public interface WritableVector3f extends WritableVector2f { - public abstract void setZ(float arg0); + /** + * Set the Z value + * @param z + */ + void setZ(float z); + + /** + * Set the X,Y,Z values + * @param x + * @param y + * @param z + */ + void set(float x, float y, float z); } diff --git a/src/generated/java/org/lwjgl/util/vector/WritableVector4f.java b/src/generated/java/org/lwjgl/util/vector/WritableVector4f.java index dae6f02..093e0f7 100644 --- a/src/generated/java/org/lwjgl/util/vector/WritableVector4f.java +++ b/src/generated/java/org/lwjgl/util/vector/WritableVector4f.java @@ -1,7 +1,56 @@ +/* + * Copyright (c) 2002-2008 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ package org.lwjgl.util.vector; -public interface WritableVector4f { - public abstract void set(float arg0, float arg1, float arg2, float arg3); +/** + * Writable interface to Vector4fs + * @author $author$ + * @version $revision$ + * $Id: WritableVector4f.java 3418 2010-09-28 21:11:35Z spasi $ + */ +public interface WritableVector4f extends WritableVector3f { - public abstract void setW(float arg0); + /** + * Set the W value + * @param w + */ + void setW(float w); + + /** + * Set the X,Y,Z,W values + * @param x + * @param y + * @param z + * @param w + */ + void set(float x, float y, float z, float w); }