update to lwjgl 1.0 rc1 (org.lwjgl.util.GL was removed)

1 files changed, 69 insertions, 71 deletions

diff --git a/src/jake2/render/opengl/LwjglGL.java b/src/jake2/render/opengl/LwjglGL.java
index 5be7df4..8134d46 100644
--- a/src/jake2/render/opengl/LwjglGL.java
+++ b/src/jake2/render/opengl/LwjglGL.java
@@ -1,10 +1,8 @@
 package jake2.render.opengl;
 
-
-
 import java.nio.*;
 
-import org.lwjgl.util.GL;
+import org.lwjgl.opengl.*;
 
 public class LwjglGL implements QGL {
     
@@ -13,290 +11,290 @@ public class LwjglGL implements QGL {
     }
     
     public final void glAlphaFunc(int func, float ref) {
-        GL.glAlphaFunc(func, ref);
+        GL11.glAlphaFunc(func, ref);
     }
 
     public final void glBegin(int mode) {
-        GL.glBegin(mode);
+        GL11.glBegin(mode);
     }
 
     public final void glBindTexture(int target, int texture) {
-        GL.glBindTexture(target, texture);
+        GL11.glBindTexture(target, texture);
     }
 
     public final void glBlendFunc(int sfactor, int dfactor) {
-        GL.glBlendFunc(sfactor, dfactor);
+        GL11.glBlendFunc(sfactor, dfactor);
     }
 
     public final void glClear(int mask) {
-        GL.glClear(mask);
+        GL11.glClear(mask);
     }
 
     public final void glClearColor(float red, float green, float blue, float alpha) {
-        GL.glClearColor(red, green, blue, alpha);
+        GL11.glClearColor(red, green, blue, alpha);
     }
 
     public final void glColor3f(float red, float green, float blue) {
-        GL.glColor3f(red, green, blue);
+        GL11.glColor3f(red, green, blue);
     }
 
     public final void glColor3ub(byte red, byte green, byte blue) {
-        GL.glColor3ub(red, green, blue);
+        GL11.glColor3ub(red, green, blue);
     }
 
     public final void glColor4f(float red, float green, float blue, float alpha) {
-        GL.glColor4f(red, green, blue, alpha);
+        GL11.glColor4f(red, green, blue, alpha);
     }
 
     public final void glColor4ub(byte red, byte green, byte blue, byte alpha) {
-        GL.glColor4ub(red, green, blue, alpha);
+        GL11.glColor4ub(red, green, blue, alpha);
     }
 
     public final void glColorPointer(int size, boolean unsigned, int stride,
             ByteBuffer pointer) {
-        GL.glColorPointer(size, unsigned, stride, pointer);
+        GL11.glColorPointer(size, unsigned, stride, pointer);
     }
     
     public final void glColorPointer(int size, int stride, FloatBuffer pointer) {
-        GL.glColorPointer(size, stride, pointer);
+        GL11.glColorPointer(size, stride, pointer);
     }
 
     public final void glCullFace(int mode) {
-        GL.glCullFace(mode);
+        GL11.glCullFace(mode);
     }
 
     public final void glDeleteTextures(IntBuffer textures) {
-        GL.glDeleteTextures(textures);
+        GL11.glDeleteTextures(textures);
     }
 
     public final void glDepthFunc(int func) {
-        GL.glDepthFunc(func);
+        GL11.glDepthFunc(func);
     }
 
     public final void glDepthMask(boolean flag) {
-        GL.glDepthMask(flag);
+        GL11.glDepthMask(flag);
     }
 
     public final void glDepthRange(double zNear, double zFar) {
-        GL.glDepthRange(zNear, zFar);
+        GL11.glDepthRange(zNear, zFar);
     }
 
     public final void glDisable(int cap) {
-        GL.glDisable(cap);
+        GL11.glDisable(cap);
     }
 
     public final void glDisableClientState(int cap) {
-        GL.glDisableClientState(cap);
+        GL11.glDisableClientState(cap);
     }
 
     public final void glDrawArrays(int mode, int first, int count) {
-        GL.glDrawArrays(mode, first, count);
+        GL11.glDrawArrays(mode, first, count);
     }
 
     public final void glDrawBuffer(int mode) {
-        GL.glDrawBuffer(mode);
+        GL11.glDrawBuffer(mode);
     }
 
     public final void glDrawElements(int mode, IntBuffer indices) {
-        GL.glDrawElements(mode, indices);
+        GL11.glDrawElements(mode, indices);
     }
 
     public final void glEnable(int cap) {
-        GL.glEnable(cap);
+        GL11.glEnable(cap);
     }
 
     public final void glEnableClientState(int cap) {
-        GL.glEnableClientState(cap);
+        GL11.glEnableClientState(cap);
     }
 
     public final void glEnd() {
-        GL.glEnd();
+        GL11.glEnd();
     }
 
     public final void glFinish() {
-        GL.glFinish();
+        GL11.glFinish();
     }
 
     public final void glFlush() {
-        GL.glFlush();
+        GL11.glFlush();
     }
 
     public final void glFrustum(double left, double right, double bottom,
             double top, double zNear, double zFar) {
-        GL.glFrustum(left, right, bottom, top, zNear, zFar);
+        GL11.glFrustum(left, right, bottom, top, zNear, zFar);
     }
 
     public final int glGetError() {
-        return GL.glGetError();
+        return GL11.glGetError();
     }
 
     public final void glGetFloat(int pname, FloatBuffer params) {
-        GL.glGetFloat(pname, params);
+        GL11.glGetFloat(pname, params);
     }
 
     public final String glGetString(int name) {
-        return GL.glGetString(name);
+        return GL11.glGetString(name);
     }
 
     public final void glInterleavedArrays(int format, int stride,
             FloatBuffer pointer) {
-        GL.glInterleavedArrays(format, stride, pointer);
+        GL11.glInterleavedArrays(format, stride, pointer);
     }
 
     public final void glLoadIdentity() {
-        GL.glLoadIdentity();
+        GL11.glLoadIdentity();
     }
 
     public final void glLoadMatrix(FloatBuffer m) {
-        GL.glLoadMatrix(m);
+        GL11.glLoadMatrix(m);
     }
 
     public final void glMatrixMode(int mode) {
-        GL.glMatrixMode(mode);
+        GL11.glMatrixMode(mode);
     }
 
     public final void glOrtho(double left, double right, double bottom,
             double top, double zNear, double zFar) {
-        GL.glOrtho(left, right, bottom, top, zNear, zFar);
+        GL11.glOrtho(left, right, bottom, top, zNear, zFar);
     }
 
     public final void glPixelStorei(int pname, int param) {
-        GL.glPixelStorei(pname, param);
+        GL11.glPixelStorei(pname, param);
     }
 
     public final void glPointSize(float size) {
-        GL.glPointSize(size);
+        GL11.glPointSize(size);
     }
 
     public final void glPolygonMode(int face, int mode) {
-        GL.glPolygonMode(face, mode);
+        GL11.glPolygonMode(face, mode);
     }
 
     public final void glPopMatrix() {
-        GL.glPopMatrix();
+        GL11.glPopMatrix();
     }
 
     public final void glPushMatrix() {
-        GL.glPushMatrix();
+        GL11.glPushMatrix();
     }
 
     public final void glReadPixels(int x, int y, int width, int height,
             int format, int type, ByteBuffer pixels) {
-        GL.glReadPixels(x, y, width, height, format, type, pixels);
+        GL11.glReadPixels(x, y, width, height, format, type, pixels);
     }
 
     public final void glRotatef(float angle, float x, float y, float z) {
-        GL.glRotatef(angle, x, y, z);
+        GL11.glRotatef(angle, x, y, z);
     }
 
     public final void glScalef(float x, float y, float z) {
-        GL.glScalef(x, y, z);
+        GL11.glScalef(x, y, z);
     }
 
     public final void glScissor(int x, int y, int width, int height) {
-        GL.glScissor(x, y, width, height);
+        GL11.glScissor(x, y, width, height);
     }
 
     public final void glShadeModel(int mode) {
-        GL.glShadeModel(mode);
+        GL11.glShadeModel(mode);
     }
 
     public final void glTexCoord2f(float s, float t) {
-        GL.glTexCoord2f(s, t);
+        GL11.glTexCoord2f(s, t);
     }
 
     public final void glTexCoordPointer(int size, int stride, FloatBuffer pointer) {
-        GL.glTexCoordPointer(size, stride, pointer);
+        GL11.glTexCoordPointer(size, stride, pointer);
     }
 
     public final void glTexEnvi(int target, int pname, int param) {
-        GL.glTexEnvi(target, pname, param);
+        GL11.glTexEnvi(target, pname, param);
     }
 
     public final void glTexImage2D(int target, int level, int internalformat,
             int width, int height, int border, int format, int type,
             ByteBuffer pixels) {
-        GL.glTexImage2D(target, level, internalformat, width, height, border,
+        GL11.glTexImage2D(target, level, internalformat, width, height, border,
                 format, type, pixels);
     }
 
     public final void glTexImage2D(int target, int level, int internalformat,
             int width, int height, int border, int format, int type,
             IntBuffer pixels) {
-        GL.glTexImage2D(target, level, internalformat, width, height, border,
+        GL11.glTexImage2D(target, level, internalformat, width, height, border,
                 format, type, pixels);
     }
 
     public final void glTexParameterf(int target, int pname, float param) {
-        GL.glTexParameterf(target, pname, param);
+        GL11.glTexParameterf(target, pname, param);
     }
 
     public final void glTexParameteri(int target, int pname, int param) {
-        GL.glTexParameteri(target, pname, param);
+        GL11.glTexParameteri(target, pname, param);
     }
 
     public final void glTexSubImage2D(int target, int level, int xoffset,
             int yoffset, int width, int height, int format, int type,
             IntBuffer pixels) {
-        GL.glTexSubImage2D(target, level, xoffset, yoffset, width, height,
+        GL11.glTexSubImage2D(target, level, xoffset, yoffset, width, height,
                 format, type, pixels);
     }
 
     public final void glTranslatef(float x, float y, float z) {
-        GL.glTranslatef(x, y, z);
+        GL11.glTranslatef(x, y, z);
     }
 
     public final void glVertex2f(float x, float y) {
-        GL.glVertex2f(x, y);
+        GL11.glVertex2f(x, y);
     }
 
     public final void glVertex3f(float x, float y, float z) {
-        GL.glVertex3f(x, y, z);
+        GL11.glVertex3f(x, y, z);
     }
 
     public final void glVertexPointer(int size, int stride, FloatBuffer pointer) {
-        GL.glVertexPointer(size, stride, pointer);
+        GL11.glVertexPointer(size, stride, pointer);
     }
 
     public final void glViewport(int x, int y, int width, int height) {
-        GL.glViewport(x, y, width, height);
+        GL11.glViewport(x, y, width, height);
     }
 
     public final void glColorTable(int target, int internalFormat, int width,
             int format, int type, ByteBuffer data) {
-        GL.glColorTable(target, internalFormat, width, format, type, data);
+        EXTPalettedTexture.glColorTableEXT(target, internalFormat, width, format, type, data);
     }
 
     public final void glActiveTextureARB(int texture) {
-        GL.glActiveTextureARB(texture);
+        ARBMultitexture.glActiveTextureARB(texture);
     }
 
     public final void glClientActiveTextureARB(int texture) {
-        GL.glClientActiveTextureARB(texture);
+	ARBMultitexture.glClientActiveTextureARB(texture);
     }
 
     public final void glPointParameterEXT(int pname, FloatBuffer pfParams) {
-        GL.glPointParameterEXT(pname, pfParams);
+        EXTPointParameters.glPointParameterEXT(pname, pfParams);
     }
 
     public final void glPointParameterfEXT(int pname, float param) {
-        GL.glPointParameterfEXT(pname, param);
+	EXTPointParameters.glPointParameterfEXT(pname, param);
     }
 
     public final void glLockArraysEXT(int first, int count) {
-        GL.glLockArraysEXT(first, count);
+        EXTCompiledVertexArray.glLockArraysEXT(first, count);
     }
 
     public final void glArrayElement(int index) {
-        GL.glArrayElement(index);
+        GL11.glArrayElement(index);
     }
 
     public final void glUnlockArraysEXT() {
-        GL.glUnlockArraysEXT();
+	EXTCompiledVertexArray.glUnlockArraysEXT();
     }
 
     public final void glMultiTexCoord2f(int target, float s, float t) {
-        GL.glMultiTexCoord2f(target, s, t);
+	GL13.glMultiTexCoord2f(target, s, t);
     }
 
 }