java-game-lib-cvs Mailing List for Lightweight Java Game Library

Update of /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/opengl/glu
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv2519

Modified Files:
	Project.java Util.java 
Log Message:
optimizations

Index: Project.java
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/opengl/glu/Project.java,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -d -r1.5 -r1.6
--- Project.java	29 Feb 2004 23:42:51 -0000	1.5
+++ Project.java	4 Mar 2004 00:36:39 -0000	1.6
@@ -1,108 +1,112 @@
 package org.lwjgl.opengl.glu;
 
+import org.lwjgl.BufferUtils;
+import org.lwjgl.opengl.GL11;
+
 import java.nio.FloatBuffer;
 import java.nio.IntBuffer;
 
-import org.lwjgl.opengl.GL11;
-
 /**
  * Project.java
- *
- *
+ * <p/>
+ * <p/>
  * Created 11-jan-2004
+ *
  * @author Erik Duijs
  */
 public class Project extends Util implements GLUConstants {
 
-	private static FloatBuffer matrix = createFloatBuffer(16);
-	private static FloatBuffer finalMatrix = createFloatBuffer(16);
+	private static final float[] IDENTITY_MATRIX = new float[] {
+		1.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, 1.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 1.0f, 0.0f,
+		0.0f, 0.0f, 0.0f, 1.0f
+	};
+
+	private static final FloatBuffer matrix = BufferUtils.createFloatBuffer(16);
+	private static final FloatBuffer finalMatrix = BufferUtils.createFloatBuffer(16);
+
+	private static final float[][] tempMatrix = new float[4][4];
+	private static final float[] in = new float[4];
+	private static final float[] out = new float[4];
+
+	private static final float[] forward = new float[3];
+	private static final float[] side = new float[3];
+	private static final float[] up = new float[3];
 
 	/**
 	 * Make matrix an identity matrix
 	 */
 	private static void __gluMakeIdentityf(FloatBuffer m) {
-		m.put(0 + 4 * 0, 1);
-		m.put(0 + 4 * 1, 0);
-		m.put(0 + 4 * 2, 0);
-		m.put(0 + 4 * 3, 0);
-		m.put(1 + 4 * 0, 0);
-		m.put(1 + 4 * 1, 1);
-		m.put(1 + 4 * 2, 0);
-		m.put(1 + 4 * 3, 0);
-		m.put(2 + 4 * 0, 0);
-		m.put(2 + 4 * 1, 0);
-		m.put(2 + 4 * 2, 1);
-		m.put(2 + 4 * 3, 0);
-		m.put(3 + 4 * 0, 0);
-		m.put(3 + 4 * 1, 0);
-		m.put(3 + 4 * 2, 0);
-		m.put(3 + 4 * 3, 1);
+		int oldPos = m.position();
+		m.put(IDENTITY_MATRIX);
+		m.position(oldPos);
 	}
 
 	/**
 	 * Method __gluMultMatrixVecf
+	 *
 	 * @param finalMatrix
 	 * @param in
 	 * @param out
 	 */
 	private static void __gluMultMatrixVecf(FloatBuffer finalMatrix, float[] in, float[] out) {
-
-		for (int i=0; i<4; i++) {
-			out[i] =
-				in[0] * finalMatrix.get(0*4+i) +
-				in[1] * finalMatrix.get(1*4+i) +
-				in[2] * finalMatrix.get(2*4+i) +
-				in[3] * finalMatrix.get(3*4+i);
+		for ( int i = 0; i < 4; i++ ) {
+			out[i] = in[0] * finalMatrix.get((0 * 4) + i)
+			         + in[1] * finalMatrix.get((1 * 4) + i)
+			         + in[2] * finalMatrix.get((2 * 4) + i)
+			         + in[3] * finalMatrix.get((3 * 4) + i);
 		}
 	}
 
 	/**
 	 * @param src
 	 * @param inverse
+	 *
 	 * @return
 	 */
 	private static boolean __gluInvertMatrixf(FloatBuffer src, FloatBuffer inverse) {
 		int i, j, k, swap;
 		float t;
-		float[][] temp = new float[4][4];
+		float[][] temp = Project.tempMatrix;
 
-		for (i=0; i<4; i++) {
-			for (j=0; j<4; j++) {
-				temp[i][j] = src.get(i*4+j);
+		for ( i = 0; i < 4; i++ ) {
+			for ( j = 0; j < 4; j++ ) {
+				temp[i][j] = src.get((i << 2) + j);
 			}
 		}
 		__gluMakeIdentityf(inverse);
 
-		for (i = 0; i < 4; i++) {
+		for ( i = 0; i < 4; i++ ) {
 			/*
 			 ** Look for largest element in column
 			 */
 			swap = i;
-			for (j = i + 1; j < 4; j++) {
+			for ( j = i + 1; j < 4; j++ ) {
 				/*if (fabs(temp[j][i]) > fabs(temp[i][i])) {
 				 swap = j;
 				 }*/
-				if (Math.abs(temp[j][i]) > Math.abs(temp[i][i])) {
+				if ( Math.abs(temp[j][i]) > Math.abs(temp[i][i]) ) {
 					swap = j;
 				}
 			}
 
-			if (swap != i) {
+			if ( swap != i ) {
 				/*
 				 ** Swap rows.
 				 */
-				for (k = 0; k < 4; k++) {
+				for ( k = 0; k < 4; k++ ) {
 					t = temp[i][k];
 					temp[i][k] = temp[swap][k];
 					temp[swap][k] = t;
 
-					t = inverse.get(i*4+k);
-					inverse.put(i*4+k, inverse.get(swap*4+k));
-					inverse.put(swap*4+k,t);
+					t = inverse.get((i << 2) + k);
+					inverse.put((i << 2) + k, inverse.get((swap << 2) + k));
+					inverse.put((swap << 2) + k, t);
 				}
 			}
 
-			if (temp[i][i] == 0) {
+			if ( temp[i][i] == 0 ) {
 				/*
 				 ** No non-zero pivot.  The matrix is singular, which shouldn't
 				 ** happen.  This means the user gave us a bad matrix.
@@ -111,16 +115,16 @@
 			}
 
 			t = temp[i][i];
-			for (k = 0; k < 4; k++) {
+			for ( k = 0; k < 4; k++ ) {
 				temp[i][k] /= t;
-				inverse.put(i*4+k, inverse.get(i*4+k) / t);
+				inverse.put((i << 2) + k, inverse.get((i << 2) + k) / t);
 			}
-			for (j = 0; j < 4; j++) {
-				if (j != i) {
+			for ( j = 0; j < 4; j++ ) {
+				if ( j != i ) {
 					t = temp[j][i];
-					for (k = 0; k < 4; k++) {
-						temp[j][k] -= temp[i][k]*t;
-						inverse.put(j*4+k, inverse.get(j*4+k) - inverse.get(i*4+k)*t);
+					for ( k = 0; k < 4; k++ ) {
+						temp[j][k] -= temp[i][k] * t;
+						inverse.put((j << 2) + k, inverse.get((j << 2) + k) - inverse.get((i << 2) + k) * t);
 					}
 				}
 			}
@@ -134,20 +138,20 @@
 	 * @param r
 	 */
 	private static void __gluMultMatricesf(FloatBuffer a, FloatBuffer b, FloatBuffer r) {
-
-		for (int i = 0; i < 4; i++) {
-			for (int j = 0; j < 4; j++) {
-				r.put(i*4+j,
-						a.get(i*4+0)*b.get(0*4+j) +
-						a.get(i*4+1)*b.get(1*4+j) +
-						a.get(i*4+2)*b.get(2*4+j) +
-						a.get(i*4+3)*b.get(3*4+j));
+		for ( int i = 0; i < 4; i++ ) {
+			for ( int j = 0; j < 4; j++ ) {
+				r.put((i << 2) + j,
+				      a.get((i << 2) + 0) * b.get((0 * 4) + j) +
+				      a.get((i << 2) + 1) * b.get((1 * 4) + j) +
+				      a.get((i << 2) + 2) * b.get((2 * 4) + j) +
+				      a.get((i << 2) + 3) * b.get((3 * 4) + j));
 			}
 		}
 	}
 
 	/**
 	 * Method gluPerspective.
+	 *
 	 * @param fovy
 	 * @param aspect
 	 * @param zNear
@@ -158,17 +162,19 @@
 		float radians = fovy / 2 * PI / 180;
 
 		deltaZ = zFar - zNear;
-		sine = (float) Math.sin(radians);
-		if ((deltaZ == 0) || (sine == 0) || (aspect == 0)) {
+		sine = (float)Math.sin(radians);
+
+		if ( (deltaZ == 0) || (sine == 0) || (aspect == 0) ) {
 			return;
 		}
-		cotangent = (float) Math.cos(radians) / sine;
+
+		cotangent = (float)Math.cos(radians) / sine;
 
 		__gluMakeIdentityf(matrix);
 
 		matrix.put(0 * 4 + 0, cotangent / aspect);
 		matrix.put(1 * 4 + 1, cotangent);
-		matrix.put(2 * 4 + 2, - (zFar + zNear) / deltaZ);
+		matrix.put(2 * 4 + 2, -(zFar + zNear) / deltaZ);
 		matrix.put(2 * 4 + 3, -1);
 		matrix.put(3 * 4 + 2, -2 * zNear * zFar / deltaZ);
 		matrix.put(3 * 4 + 3, 0);
@@ -178,6 +184,7 @@
 
 	/**
 	 * Method gluLookAt
+	 *
 	 * @param eyex
 	 * @param eyey
 	 * @param eyez
@@ -188,20 +195,12 @@
 	 * @param upy
 	 * @param upz
 	 */
-	public static void gluLookAt(
-			float eyex,
-			float eyey,
-			float eyez,
-			float centerx,
-			float centery,
-			float centerz,
-			float upx,
-			float upy,
-			float upz) {
-
-		float[] forward = new float[3];
-		float[] side = new float[3];
-		float[] up = new float[3];
+	public static void gluLookAt(float eyex, float eyey, float eyez,
+	                             float centerx, float centery, float centerz,
+	                             float upx, float upy, float upz) {
+		float[] forward = Project.forward;
+		float[] side = Project.side;
+		float[] up = Project.up;
 
 		forward[0] = centerx - eyex;
 		forward[1] = centery - eyey;
@@ -239,6 +238,7 @@
 
 	/**
 	 * Method gluProject
+	 *
 	 * @param objx
 	 * @param objy
 	 * @param objz
@@ -246,40 +246,40 @@
 	 * @param projMatrix
 	 * @param viewport
 	 * @param win_pos
+	 *
 	 * @return
 	 */
 	public static boolean gluProject(float objx, float objy, float objz,
-			FloatBuffer modelMatrix,
-			FloatBuffer projMatrix,
-			IntBuffer viewport,
-			FloatBuffer win_pos)
-	{
-		float[] in = new float[4];
-		float[] out = new float[4];
+	                                 FloatBuffer modelMatrix,
+	                                 FloatBuffer projMatrix,
+	                                 IntBuffer viewport,
+	                                 FloatBuffer win_pos) {
+		float[] in = Project.in;
+		float[] out = Project.out;
+
+		in[0] = objx;
+		in[1] = objy;
+		in[2] = objz;
+		in[3] = 1.0f;
 
-		in[0]=objx;
-		in[1]=objy;
-		in[2]=objz;
-		in[3]=1.0f;
 		__gluMultMatrixVecf(modelMatrix, in, out);
 		__gluMultMatrixVecf(projMatrix, out, in);
-		if (in[3] == 0.0) return false;
-		in[0] /= in[3];
-		in[1] /= in[3];
-		in[2] /= in[3];
-		// Map x, y and z to range 0-1
-		in[0] = in[0] * 0.5f + 0.5f;
-		in[1] = in[1] * 0.5f + 0.5f;
-		in[2] = in[2] * 0.5f + 0.5f;
 
-		// Map x,y to viewport
-		in[0] = in[0] * viewport.get(2) + viewport.get(0);
-		in[1] = in[1] * viewport.get(3) + viewport.get(1);
+		if ( in[3] == 0.0 )
+			return false;
+
+		in[3] = (1.0f / in[3]) * 0.5f;
+
+		// Map x, y and z to range 0-1
+		in[0] = in[0] * in[3] + 0.5f;
+		in[1] = in[1] * in[3] + 0.5f;
+		in[2] = in[2] * in[3] + 0.5f;
 
 		int pos = win_pos.position();
 
-		win_pos.put(pos++, in[0]);
-		win_pos.put(pos++, in[1]);
+		// Map x,y to viewport
+		win_pos.put(pos++, in[0] * viewport.get(2) + viewport.get(0));
+		win_pos.put(pos++, in[1] * viewport.get(3) + viewport.get(1));
 		win_pos.put(pos, in[2]);
 
 		return true;
@@ -287,6 +287,7 @@
 
 	/**
 	 * Method gluUnproject
+	 *
 	 * @param winx
 	 * @param winy
 	 * @param winz
@@ -294,24 +295,26 @@
 	 * @param projMatrix
 	 * @param viewport
 	 * @param obj_pos
+	 *
 	 * @return
 	 */
 	public static boolean gluUnProject(float winx, float winy, float winz,
-			FloatBuffer modelMatrix,
-			FloatBuffer projMatrix,
-			IntBuffer viewport,
-			FloatBuffer obj_pos)
-	{
-		float[] in = new float[4];
-		float[] out = new float[4];
+	                                   FloatBuffer modelMatrix,
+	                                   FloatBuffer projMatrix,
+	                                   IntBuffer viewport,
+	                                   FloatBuffer obj_pos) {
+		float[] in = Project.in;
+		float[] out = Project.out;
 
 		__gluMultMatricesf(modelMatrix, projMatrix, finalMatrix);
-		if (!__gluInvertMatrixf(finalMatrix, finalMatrix)) return false;
 
-		in[0]=winx;
-		in[1]=winy;
-		in[2]=winz;
-		in[3]=1.0f;
+		if ( !__gluInvertMatrixf(finalMatrix, finalMatrix) )
+			return false;
+
+		in[0] = winx;
+		in[1] = winy;
+		in[2] = winz;
+		in[3] = 1.0f;
 
 		// Map x and y from window coordinates
 		in[0] = (in[0] - viewport.get(0)) / viewport.get(2);
@@ -323,43 +326,39 @@
 		in[2] = in[2] * 2 - 1;
 
 		__gluMultMatrixVecf(finalMatrix, in, out);
-		if (out[3] == 0.0) return false;
-		out[0] /= out[3];
-		out[1] /= out[3];
-		out[2] /= out[3];
+
+		if ( out[3] == 0.0 )
+			return false;
+
+		out[3] = 1.0f / out[3];
 
 		int pos = obj_pos.position();
 
-		obj_pos.put(pos++, out[0]);
-		obj_pos.put(pos++, out[1]);
-		obj_pos.put(pos, out[2]);
+		obj_pos.put(pos++, out[0] * out[3]);
+		obj_pos.put(pos++, out[1] * out[3]);
+		obj_pos.put(pos, out[2] * out[3]);
 
 		return true;
 	}
 
 	/**
 	 * Method gluPickMatrix
+	 *
 	 * @param x
 	 * @param y
-	 * @param deltax
-	 * @param deltay
+	 * @param deltaX
+	 * @param deltaY
 	 * @param viewport
 	 */
-	public static void gluPickMatrix(
-			float x,
-			float y,
-			float deltax,
-			float deltay,
-			IntBuffer viewport) {
-		if (deltax <= 0 || deltay <= 0) {
+	public static void gluPickMatrix(float x, float y, float deltaX, float deltaY, IntBuffer viewport) {
+		if ( deltaX <= 0 || deltaY <= 0 ) {
 			return;
 		}
 
 		/* Translate and scale the picked region to the entire window */
-		GL11.glTranslatef(
-			(viewport.get(2) - 2 * (x - viewport.get(0))) / deltax,
-			(viewport.get(3) - 2 * (y - viewport.get(1))) / deltay,
-			0);
-		GL11.glScalef(viewport.get(2) / deltax, viewport.get(3) / deltay, 1.0f);
+		GL11.glTranslatef((viewport.get(2) - 2 * (x - viewport.get(0))) / deltaX,
+		                  (viewport.get(3) - 2 * (y - viewport.get(1))) / deltaY,
+		                  0);
+		GL11.glScalef(viewport.get(2) / deltaX, viewport.get(3) / deltaY, 1.0f);
 	}
 }

Index: Util.java
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/opengl/glu/Util.java,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- Util.java	29 Feb 2004 23:42:51 -0000	1.4
+++ Util.java	4 Mar 2004 00:36:39 -0000	1.5
@@ -1,29 +1,32 @@
 package org.lwjgl.opengl.glu;
 
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-import java.nio.FloatBuffer;
-import java.nio.IntBuffer;
-
+import org.lwjgl.BufferUtils;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL12;
 
+import java.nio.IntBuffer;
+
 /**
  * Util.java
- *
- *
+ * <p/>
+ * <p/>
  * Created 7-jan-2004
+ *
  * @author Erik Duijs
  */
 public class Util {
 
-	/** temp IntBuffer of one for getting an int from some GL functions */
-	private static IntBuffer scratch = createIntBuffer(256);
+	/**
+	 * temp IntBuffer of one for getting an int from some GL functions
+	 */
+	private static IntBuffer scratch = BufferUtils.createIntBuffer(16);
 
 	/**
 	 * Return ceiling of integer division
+	 *
 	 * @param a
 	 * @param b
+	 *
 	 * @return int
 	 */
 	protected static int ceil(int a, int b) {
@@ -32,25 +35,30 @@
 
 	/**
 	 * Normalize vector
+	 *
 	 * @param v
+	 *
 	 * @return float[]
 	 */
 	protected static float[] normalize(float[] v) {
 		float r;
 
-		r = (float) Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
-		if (r == 0.0)
+		r = (float)Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+		if ( r == 0.0 )
 			return v;
 
-		v[0] /= r;
-		v[1] /= r;
-		v[2] /= r;
+		r = 1.0f / r;
+
+		v[0] *= r;
+		v[1] *= r;
+		v[2] *= r;
 
 		return v;
 	}
 
 	/**
 	 * Calculate cross-product
+	 *
 	 * @param v1
 	 * @param v2
 	 * @param result
@@ -63,28 +71,30 @@
 
 	/**
 	 * Method compPerPix.
+	 *
 	 * @param format
+	 *
 	 * @return int
 	 */
 	protected static int compPerPix(int format) {
 		/* Determine number of components per pixel */
-		switch (format) {
-			case GL11.GL_COLOR_INDEX :
-			case GL11.GL_STENCIL_INDEX :
-			case GL11.GL_DEPTH_COMPONENT :
-			case GL11.GL_RED :
-			case GL11.GL_GREEN :
-			case GL11.GL_BLUE :
-			case GL11.GL_ALPHA :
-			case GL11.GL_LUMINANCE :
+		switch ( format ) {
+			case GL11.GL_COLOR_INDEX:
+			case GL11.GL_STENCIL_INDEX:
+			case GL11.GL_DEPTH_COMPONENT:
+			case GL11.GL_RED:
+			case GL11.GL_GREEN:
+			case GL11.GL_BLUE:
+			case GL11.GL_ALPHA:
+			case GL11.GL_LUMINANCE:
 				return 1;
-			case GL11.GL_LUMINANCE_ALPHA :
+			case GL11.GL_LUMINANCE_ALPHA:
 				return 2;
-			case GL11.GL_RGB :
-			case GL12.GL_BGR :
+			case GL11.GL_RGB:
+			case GL12.GL_BGR:
 				return 3;
-			case GL11.GL_RGBA :
-			case GL12.GL_BGRA :
+			case GL11.GL_RGBA:
+			case GL12.GL_BGRA:
 				return 4;
 			default :
 				return -1;
@@ -93,11 +103,11 @@
 
 	/**
 	 * Method nearestPower.
-	 *
-	 * Compute the nearest power of 2 number.  This algorithm is a little
-	 * strange, but it works quite well.
+	 * <p/>
+	 * Compute the nearest power of 2 number.  This algorithm is a little strange, but it works quite well.
 	 *
 	 * @param value
+	 *
 	 * @return int
 	 */
 	protected static int nearestPower(int value) {
@@ -106,14 +116,14 @@
 		i = 1;
 
 		/* Error! */
-		if (value == 0)
+		if ( value == 0 )
 			return -1;
 
-		for (;;) {
-			if (value == 1) {
+		for ( ; ; ) {
+			if ( value == 1 ) {
 				return i;
-			} else if (value == 3) {
-				return i * 4;
+			} else if ( value == 3 ) {
+				return i << 2;
 			}
 			value >>= 1;
 			i <<= 1;
@@ -122,62 +132,64 @@
 
 	/**
 	 * Method bytesPerPixel.
+	 *
 	 * @param format
 	 * @param type
+	 *
 	 * @return int
 	 */
 	protected static int bytesPerPixel(int format, int type) {
 		int n, m;
 
-		switch (format) {
-			case GL11.GL_COLOR_INDEX :
-			case GL11.GL_STENCIL_INDEX :
-			case GL11.GL_DEPTH_COMPONENT :
-			case GL11.GL_RED :
-			case GL11.GL_GREEN :
-			case GL11.GL_BLUE :
-			case GL11.GL_ALPHA :
-			case GL11.GL_LUMINANCE :
+		switch ( format ) {
+			case GL11.GL_COLOR_INDEX:
+			case GL11.GL_STENCIL_INDEX:
+			case GL11.GL_DEPTH_COMPONENT:
+			case GL11.GL_RED:
+			case GL11.GL_GREEN:
+			case GL11.GL_BLUE:
+			case GL11.GL_ALPHA:
+			case GL11.GL_LUMINANCE:
 				n = 1;
 				break;
-			case GL11.GL_LUMINANCE_ALPHA :
+			case GL11.GL_LUMINANCE_ALPHA:
 				n = 2;
 				break;
-			case GL11.GL_RGB :
-			case GL12.GL_BGR :
+			case GL11.GL_RGB:
+			case GL12.GL_BGR:
 				n = 3;
 				break;
-			case GL11.GL_RGBA :
-			case GL12.GL_BGRA :
+			case GL11.GL_RGBA:
+			case GL12.GL_BGRA:
 				n = 4;
 				break;
 			default :
 				n = 0;
 		}
 
-		switch (type) {
-			case GL11.GL_UNSIGNED_BYTE :
+		switch ( type ) {
+			case GL11.GL_UNSIGNED_BYTE:
 				m = 1;
 				break;
-			case GL11.GL_BYTE :
+			case GL11.GL_BYTE:
 				m = 1;
 				break;
-			case GL11.GL_BITMAP :
+			case GL11.GL_BITMAP:
 				m = 1;
 				break;
-			case GL11.GL_UNSIGNED_SHORT :
+			case GL11.GL_UNSIGNED_SHORT:
 				m = 2;
 				break;
-			case GL11.GL_SHORT :
+			case GL11.GL_SHORT:
 				m = 2;
 				break;
-			case GL11.GL_UNSIGNED_INT :
+			case GL11.GL_UNSIGNED_INT:
 				m = 4;
 				break;
-			case GL11.GL_INT :
+			case GL11.GL_INT:
 				m = 4;
 				break;
-			case GL11.GL_FLOAT :
+			case GL11.GL_FLOAT:
 				m = 4;
 				break;
 			default :
@@ -188,34 +200,10 @@
 	}
 
 	/**
-	 * Create a FloatBuffer of specified size.
-	 * @param size
-	 * @return FloatBuffer
-	 */
-	protected static FloatBuffer createFloatBuffer(int size) {
-		ByteBuffer temp = ByteBuffer.allocateDirect(4 * size);
-		temp.order(ByteOrder.nativeOrder());
-
-		return temp.asFloatBuffer();
-	}
-
-	/**
-	 * Create IntBuffer of specified size.
-	 * @param size
-	 * @return IntBuffer
-	 */
-	protected static IntBuffer createIntBuffer(int size) {
-		ByteBuffer temp = ByteBuffer.allocateDirect(4 * size);
-		temp.order(ByteOrder.nativeOrder());
-
-		return temp.asIntBuffer();
-	}
-
-	/**
-	 * Convenience method for returning an int,
-	 * rather than getting it out of a buffer yourself.
+	 * Convenience method for returning an int, rather than getting it out of a buffer yourself.
 	 *
 	 * @param what
+	 *
 	 * @return int
 	 */
 	protected static int glGetIntegerv(int what) {