From 0fb0abe5737f88d7643276bf32ec0209786ec449 Mon Sep 17 00:00:00 2001 From: Caspian Rychlik-Prince Date: Mon, 19 Apr 2004 23:01:33 +0000 Subject: [PATCH] New Object Oriented Wank! --- src/java/org/lwjgl/util/GLImpl.java | 5854 +++++++++++++++++++++++++++ src/java/org/lwjgl/util/IGL.java | 5238 ++++++++++++++++++++++++ 2 files changed, 11092 insertions(+) create mode 100644 src/java/org/lwjgl/util/GLImpl.java create mode 100644 src/java/org/lwjgl/util/IGL.java diff --git a/src/java/org/lwjgl/util/GLImpl.java b/src/java/org/lwjgl/util/GLImpl.java new file mode 100644 index 00000000..482612d2 --- /dev/null +++ b/src/java/org/lwjgl/util/GLImpl.java @@ -0,0 +1,5854 @@ +/* + * Copyright (c) 2002 Light Weight Java Game Library 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 'Light Weight Java Game Library' 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; + +import java.nio.Buffer; +import java.nio.ByteBuffer; +import java.nio.DoubleBuffer; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import java.nio.ShortBuffer; + +/** + * $Id$ + * + * An extensible GL class that contains all the GL11 through GL15 methods, + * and all the ARB and EXT extension methods - but this time as instance methods, + * like JOGL, Magician, and GL4Java. + * + * @author $Author$ + * @version $Revision$ + */ +public class GLImpl implements IGL { + + /** + * C'tor + */ + public GLImpl() { + } + + /** + * @param op + * @param value + */ + public void glAccum(int op, float value) { + GL.glAccum(op, value); + } + /** + * @param face + */ + public void glActiveStencilFaceEXT(int face) { + GL.glActiveStencilFaceEXT(face); + } + /** + * @param texture + */ + public void glActiveTexture(int texture) { + GL.glActiveTexture(texture); + } + /** + * @param texture + */ + public void glActiveTextureARB(int texture) { + GL.glActiveTextureARB(texture); + } + /** + * @param func + * @param ref + */ + public void glAlphaFunc(int func, float ref) { + GL.glAlphaFunc(func, ref); + } + /** + * @param i + */ + public void glArrayElement(int i) { + GL.glArrayElement(i); + } + /** + * @param containerObj + * @param obj + */ + public void glAttachObjectARB(int containerObj, int obj) { + GL.glAttachObjectARB(containerObj, obj); + } + /** + * @param mode + */ + public void glBegin(int mode) { + GL.glBegin(mode); + } + /** + * @param target + * @param id + */ + public void glBeginQuery(int target, int id) { + GL.glBeginQuery(target, id); + } + /** + * @param target + * @param id + */ + public void glBeginQueryARB(int target, int id) { + GL.glBeginQueryARB(target, id); + } + /** + * + */ + public void glBeginVertexShaderEXT() { + GL.glBeginVertexShaderEXT(); + } + /** + * @param programObj + * @param index + * @param name + */ + public void glBindAttribLocationARB(int programObj, int index, + ByteBuffer name) { + GL.glBindAttribLocationARB(programObj, index, name); + } + /** + * @param target + * @param buffer + */ + public void glBindBuffer(int target, int buffer) { + GL.glBindBuffer(target, buffer); + } + /** + * @param target + * @param buffer + */ + public void glBindBufferARB(int target, int buffer) { + GL.glBindBufferARB(target, buffer); + } + /** + * @param light + * @param value + * @return + */ + public int glBindLightParameterEXT(int light, int value) { + return GL.glBindLightParameterEXT(light, value); + } + /** + * @param face + * @param value + * @return + */ + public int glBindMaterialParameterEXT(int face, int value) { + return GL.glBindMaterialParameterEXT(face, value); + } + /** + * @param value + * @return + */ + public int glBindParameterEXT(int value) { + return GL.glBindParameterEXT(value); + } + /** + * @param target + * @param program + */ + public void glBindProgramARB(int target, int program) { + GL.glBindProgramARB(target, program); + } + /** + * @param unit + * @param coord + * @param value + * @return + */ + public int glBindTexGenParameterEXT(int unit, int coord, int value) { + return GL.glBindTexGenParameterEXT(unit, coord, value); + } + /** + * @param target + * @param texture + */ + public void glBindTexture(int target, int texture) { + GL.glBindTexture(target, texture); + } + /** + * @param unit + * @param value + * @return + */ + public int glBindTextureUnitParameterEXT(int unit, int value) { + return GL.glBindTextureUnitParameterEXT(unit, value); + } + /** + * @param id + */ + public void glBindVertexShaderEXT(int id) { + GL.glBindVertexShaderEXT(id); + } + /** + * @param width + * @param height + * @param xorig + * @param yorig + * @param xmove + * @param ymove + * @param bitmap + */ + public void glBitmap(int width, int height, float xorig, + float yorig, float xmove, float ymove, ByteBuffer bitmap) { + GL.glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap); + } + /** + * @param red + * @param green + * @param blue + * @param alpha + */ + public void glBlendColor(float red, float green, float blue, + float alpha) { + GL.glBlendColor(red, green, blue, alpha); + } + /** + * @param mode + */ + public void glBlendEquation(int mode) { + GL.glBlendEquation(mode); + } + /** + * @param sfactor + * @param dfactor + */ + public void glBlendFunc(int sfactor, int dfactor) { + GL.glBlendFunc(sfactor, dfactor); + } + /** + * @param sfactorRGB + * @param dfactorRGB + * @param sfactorAlpha + * @param dfactorAlpha + */ + public void glBlendFuncSeparate(int sfactorRGB, int dfactorRGB, + int sfactorAlpha, int dfactorAlpha) { + GL.glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, + dfactorAlpha); + } + /** + * @param sfactorRGB + * @param dfactorRGB + * @param sfactorAlpha + * @param dfactorAlpha + */ + public void glBlendFuncSeparateEXT(int sfactorRGB, int dfactorRGB, + int sfactorAlpha, int dfactorAlpha) { + GL.glBlendFuncSeparateEXT(sfactorRGB, dfactorRGB, sfactorAlpha, + dfactorAlpha); + } + /** + * @param target + * @param size + * @param data + * @param usage + */ + public void glBufferData(int target, int size, ByteBuffer data, + int usage) { + GL.glBufferData(target, size, data, usage); + } + /** + * @param target + * @param size + * @param data + * @param usage + */ + public void glBufferData(int target, int size, FloatBuffer data, + int usage) { + GL.glBufferData(target, size, data, usage); + } + /** + * @param target + * @param size + * @param data + * @param usage + */ + public void glBufferData(int target, int size, IntBuffer data, + int usage) { + GL.glBufferData(target, size, data, usage); + } + /** + * @param target + * @param size + * @param data + * @param usage + */ + public void glBufferData(int target, int size, ShortBuffer data, + int usage) { + GL.glBufferData(target, size, data, usage); + } + /** + * @param target + * @param size + * @param data + * @param usage + */ + public void glBufferDataARB(int target, int size, ByteBuffer data, + int usage) { + GL.glBufferDataARB(target, size, data, usage); + } + /** + * @param target + * @param size + * @param data + * @param usage + */ + public void glBufferDataARB(int target, int size, FloatBuffer data, + int usage) { + GL.glBufferDataARB(target, size, data, usage); + } + /** + * @param target + * @param size + * @param data + * @param usage + */ + public void glBufferDataARB(int target, int size, IntBuffer data, + int usage) { + GL.glBufferDataARB(target, size, data, usage); + } + /** + * @param target + * @param size + * @param data + * @param usage + */ + public void glBufferDataARB(int target, int size, ShortBuffer data, + int usage) { + GL.glBufferDataARB(target, size, data, usage); + } + /** + * @param target + * @param offset + * @param data + */ + public void glBufferSubData(int target, int offset, ByteBuffer data) { + GL.glBufferSubData(target, offset, data); + } + /** + * @param target + * @param offset + * @param data + */ + public void glBufferSubData(int target, int offset, FloatBuffer data) { + GL.glBufferSubData(target, offset, data); + } + /** + * @param target + * @param offset + * @param data + */ + public void glBufferSubData(int target, int offset, IntBuffer data) { + GL.glBufferSubData(target, offset, data); + } + /** + * @param target + * @param offset + * @param data + */ + public void glBufferSubData(int target, int offset, ShortBuffer data) { + GL.glBufferSubData(target, offset, data); + } + /** + * @param target + * @param offset + * @param data + */ + public void glBufferSubDataARB(int target, int offset, + ByteBuffer data) { + GL.glBufferSubDataARB(target, offset, data); + } + /** + * @param target + * @param offset + * @param data + */ + public void glBufferSubDataARB(int target, int offset, + FloatBuffer data) { + GL.glBufferSubDataARB(target, offset, data); + } + /** + * @param target + * @param offset + * @param data + */ + public void glBufferSubDataARB(int target, int offset, IntBuffer data) { + GL.glBufferSubDataARB(target, offset, data); + } + /** + * @param target + * @param offset + * @param data + */ + public void glBufferSubDataARB(int target, int offset, + ShortBuffer data) { + GL.glBufferSubDataARB(target, offset, data); + } + /** + * @param list + */ + public void glCallList(int list) { + GL.glCallList(list); + } + /** + * @param lists + */ + public void glCallLists(ByteBuffer lists) { + GL.glCallLists(lists); + } + /** + * @param n + * @param lists + */ + public void glCallLists(int n, IntBuffer lists) { + GL.glCallLists(n, lists); + } + /** + * @param lists + */ + public void glCallLists(ShortBuffer lists) { + GL.glCallLists(lists); + } + /** + * @param mask + */ + public void glClear(int mask) { + GL.glClear(mask); + } + /** + * @param red + * @param green + * @param blue + * @param alpha + */ + public void glClearAccum(float red, float green, float blue, + float alpha) { + GL.glClearAccum(red, green, blue, alpha); + } + /** + * @param red + * @param green + * @param blue + * @param alpha + */ + public void glClearColor(float red, float green, float blue, + float alpha) { + GL.glClearColor(red, green, blue, alpha); + } + /** + * @param depth + */ + public void glClearDepth(double depth) { + GL.glClearDepth(depth); + } + /** + * @param c + */ + public void glClearIndex(float c) { + GL.glClearIndex(c); + } + /** + * @param s + */ + public void glClearStencil(int s) { + GL.glClearStencil(s); + } + /** + * @param texture + */ + public void glClientActiveTexture(int texture) { + GL.glClientActiveTexture(texture); + } + /** + * @param texture + */ + public void glClientActiveTextureARB(int texture) { + GL.glClientActiveTextureARB(texture); + } + /** + * @param plane + * @param equation + */ + public void glClipPlane(int plane, DoubleBuffer equation) { + GL.glClipPlane(plane, equation); + } + /** + * @param red + * @param green + * @param blue + */ + public void glColor3b(byte red, byte green, byte blue) { + GL.glColor3b(red, green, blue); + } + /** + * @param red + * @param green + * @param blue + */ + public void glColor3f(float red, float green, float blue) { + GL.glColor3f(red, green, blue); + } + /** + * @param red + * @param green + * @param blue + */ + public void glColor3ub(byte red, byte green, byte blue) { + GL.glColor3ub(red, green, blue); + } + /** + * @param red + * @param green + * @param blue + * @param alpha + */ + public void glColor4b(byte red, byte green, byte blue, byte alpha) { + GL.glColor4b(red, green, blue, alpha); + } + /** + * @param red + * @param green + * @param blue + * @param alpha + */ + public void glColor4f(float red, float green, float blue, float alpha) { + GL.glColor4f(red, green, blue, alpha); + } + /** + * @param red + * @param green + * @param blue + * @param alpha + */ + public void glColor4ub(byte red, byte green, byte blue, byte alpha) { + GL.glColor4ub(red, green, blue, alpha); + } + /** + * @param red + * @param green + * @param blue + * @param alpha + */ + public void glColorMask(boolean red, boolean green, boolean blue, + boolean alpha) { + GL.glColorMask(red, green, blue, alpha); + } + /** + * @param face + * @param mode + */ + public void glColorMaterial(int face, int mode) { + GL.glColorMaterial(face, mode); + } + /** + * @param size + * @param unsigned + * @param stride + * @param pointer + */ + public void glColorPointer(int size, boolean unsigned, int stride, + ByteBuffer pointer) { + GL.glColorPointer(size, unsigned, stride, pointer); + } + /** + * @param size + * @param stride + * @param pointer + */ + public void glColorPointer(int size, int stride, FloatBuffer pointer) { + GL.glColorPointer(size, stride, pointer); + } + /** + * @param size + * @param type + * @param stride + * @param buffer_offset + */ + public void glColorPointer(int size, int type, int stride, + int buffer_offset) { + GL.glColorPointer(size, type, stride, buffer_offset); + } + /** + * @param target + * @param start + * @param count + * @param format + * @param type + * @param data + */ + public void glColorSubTable(int target, int start, int count, + int format, int type, ByteBuffer data) { + GL.glColorSubTable(target, start, count, format, type, data); + } + /** + * @param target + * @param start + * @param count + * @param format + * @param type + * @param data + */ + public void glColorSubTable(int target, int start, int count, + int format, int type, FloatBuffer data) { + GL.glColorSubTable(target, start, count, format, type, data); + } + /** + * @param target + * @param internalFormat + * @param width + * @param format + * @param type + * @param data + */ + public void glColorTable(int target, int internalFormat, int width, + int format, int type, ByteBuffer data) { + GL.glColorTable(target, internalFormat, width, format, type, data); + } + /** + * @param target + * @param internalFormat + * @param width + * @param format + * @param type + * @param data + */ + public void glColorTable(int target, int internalFormat, int width, + int format, int type, FloatBuffer data) { + GL.glColorTable(target, internalFormat, width, format, type, data); + } + /** + * @param target + * @param pname + * @param params + */ + public void glColorTableParameter(int target, int pname, + FloatBuffer params) { + GL.glColorTableParameter(target, pname, params); + } + /** + * @param target + * @param pname + * @param params + */ + public void glColorTableParameter(int target, int pname, + IntBuffer params) { + GL.glColorTableParameter(target, pname, params); + } + /** + * @param shaderObj + */ + public void glCompileShaderARB(int shaderObj) { + GL.glCompileShaderARB(shaderObj); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage1D(int target, int level, + int internalformat, int width, int border, int imageSize, + ByteBuffer data) { + GL.glCompressedTexImage1D(target, level, internalformat, width, border, + imageSize, data); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage1D(int target, int level, + int internalformat, int width, int border, int imageSize, + FloatBuffer data) { + GL.glCompressedTexImage1D(target, level, internalformat, width, border, + imageSize, data); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage1D(int target, int level, + int internalformat, int width, int border, int imageSize, + IntBuffer data) { + GL.glCompressedTexImage1D(target, level, internalformat, width, border, + imageSize, data); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage1D(int target, int level, + int internalformat, int width, int border, int imageSize, + ShortBuffer data) { + GL.glCompressedTexImage1D(target, level, internalformat, width, border, + imageSize, data); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage1DARB(int target, int level, + int internalformat, int width, int border, int imageSize, + ByteBuffer pData) { + GL.glCompressedTexImage1DARB(target, level, internalformat, width, + border, imageSize, pData); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage1DARB(int target, int level, + int internalformat, int width, int border, int imageSize, + FloatBuffer pData) { + GL.glCompressedTexImage1DARB(target, level, internalformat, width, + border, imageSize, pData); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage1DARB(int target, int level, + int internalformat, int width, int border, int imageSize, + IntBuffer pData) { + GL.glCompressedTexImage1DARB(target, level, internalformat, width, + border, imageSize, pData); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage1DARB(int target, int level, + int internalformat, int width, int border, int imageSize, + ShortBuffer pData) { + GL.glCompressedTexImage1DARB(target, level, internalformat, width, + border, imageSize, pData); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage2D(int target, int level, + int internalformat, int width, int height, int border, + int imageSize, ByteBuffer data) { + GL.glCompressedTexImage2D(target, level, internalformat, width, height, + border, imageSize, data); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage2D(int target, int level, + int internalformat, int width, int height, int border, + int imageSize, FloatBuffer data) { + GL.glCompressedTexImage2D(target, level, internalformat, width, height, + border, imageSize, data); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage2D(int target, int level, + int internalformat, int width, int height, int border, + int imageSize, IntBuffer data) { + GL.glCompressedTexImage2D(target, level, internalformat, width, height, + border, imageSize, data); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage2D(int target, int level, + int internalformat, int width, int height, int border, + int imageSize, ShortBuffer data) { + GL.glCompressedTexImage2D(target, level, internalformat, width, height, + border, imageSize, data); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage2DARB(int target, int level, + int internalformat, int width, int height, int border, + int imageSize, ByteBuffer pData) { + GL.glCompressedTexImage2DARB(target, level, internalformat, width, + height, border, imageSize, pData); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage2DARB(int target, int level, + int internalformat, int width, int height, int border, + int imageSize, FloatBuffer pData) { + GL.glCompressedTexImage2DARB(target, level, internalformat, width, + height, border, imageSize, pData); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage2DARB(int target, int level, + int internalformat, int width, int height, int border, + int imageSize, IntBuffer pData) { + GL.glCompressedTexImage2DARB(target, level, internalformat, width, + height, border, imageSize, pData); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage2DARB(int target, int level, + int internalformat, int width, int height, int border, + int imageSize, ShortBuffer pData) { + GL.glCompressedTexImage2DARB(target, level, internalformat, width, + height, border, imageSize, pData); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage3D(int target, int level, + int internalformat, int width, int height, int depth, int border, + int imageSize, ByteBuffer data) { + GL.glCompressedTexImage3D(target, level, internalformat, width, height, + depth, border, imageSize, data); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage3D(int target, int level, + int internalformat, int width, int height, int depth, int border, + int imageSize, FloatBuffer data) { + GL.glCompressedTexImage3D(target, level, internalformat, width, height, + depth, border, imageSize, data); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage3D(int target, int level, + int internalformat, int width, int height, int depth, int border, + int imageSize, IntBuffer data) { + GL.glCompressedTexImage3D(target, level, internalformat, width, height, + depth, border, imageSize, data); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage3D(int target, int level, + int internalformat, int width, int height, int depth, int border, + int imageSize, ShortBuffer data) { + GL.glCompressedTexImage3D(target, level, internalformat, width, height, + depth, border, imageSize, data); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage3DARB(int target, int level, + int internalformat, int width, int height, int depth, int border, + int imageSize, ByteBuffer pData) { + GL.glCompressedTexImage3DARB(target, level, internalformat, width, + height, depth, border, imageSize, pData); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage3DARB(int target, int level, + int internalformat, int width, int height, int depth, int border, + int imageSize, FloatBuffer pData) { + GL.glCompressedTexImage3DARB(target, level, internalformat, width, + height, depth, border, imageSize, pData); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage3DARB(int target, int level, + int internalformat, int width, int height, int depth, int border, + int imageSize, IntBuffer pData) { + GL.glCompressedTexImage3DARB(target, level, internalformat, width, + height, depth, border, imageSize, pData); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage3DARB(int target, int level, + int internalformat, int width, int height, int depth, int border, + int imageSize, ShortBuffer pData) { + GL.glCompressedTexImage3DARB(target, level, internalformat, width, + height, depth, border, imageSize, pData); + } + /** + * @param target + * @param level + * @param xoffset + * @param width + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage1D(int target, int level, + int xoffset, int width, int format, int imageSize, ByteBuffer data) { + GL.glCompressedTexSubImage1D(target, level, xoffset, width, format, + imageSize, data); + } + /** + * @param target + * @param level + * @param xoffset + * @param width + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage1D(int target, int level, + int xoffset, int width, int format, int imageSize, FloatBuffer data) { + GL.glCompressedTexSubImage1D(target, level, xoffset, width, format, + imageSize, data); + } + /** + * @param target + * @param level + * @param xoffset + * @param width + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage1D(int target, int level, + int xoffset, int width, int format, int imageSize, IntBuffer data) { + GL.glCompressedTexSubImage1D(target, level, xoffset, width, format, + imageSize, data); + } + /** + * @param target + * @param level + * @param xoffset + * @param width + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage1D(int target, int level, + int xoffset, int width, int format, int imageSize, ShortBuffer data) { + GL.glCompressedTexSubImage1D(target, level, xoffset, width, format, + imageSize, data); + } + /** + * @param target + * @param level + * @param xoffset + * @param width + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage1DARB(int target, int level, + int xoffset, int width, int border, int imageSize, ByteBuffer pData) { + GL.glCompressedTexSubImage1DARB(target, level, xoffset, width, border, + imageSize, pData); + } + /** + * @param target + * @param level + * @param xoffset + * @param width + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage1DARB(int target, int level, + int xoffset, int width, int border, int imageSize, FloatBuffer pData) { + GL.glCompressedTexSubImage1DARB(target, level, xoffset, width, border, + imageSize, pData); + } + /** + * @param target + * @param level + * @param xoffset + * @param width + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage1DARB(int target, int level, + int xoffset, int width, int border, int imageSize, IntBuffer pData) { + GL.glCompressedTexSubImage1DARB(target, level, xoffset, width, border, + imageSize, pData); + } + /** + * @param target + * @param level + * @param xoffset + * @param width + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage1DARB(int target, int level, + int xoffset, int width, int border, int imageSize, ShortBuffer pData) { + GL.glCompressedTexSubImage1DARB(target, level, xoffset, width, border, + imageSize, pData); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param width + * @param height + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage2D(int target, int level, + int xoffset, int yoffset, int width, int height, int format, + int imageSize, ByteBuffer data) { + GL.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, + height, format, imageSize, data); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param width + * @param height + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage2D(int target, int level, + int xoffset, int yoffset, int width, int height, int format, + int imageSize, FloatBuffer data) { + GL.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, + height, format, imageSize, data); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param width + * @param height + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage2D(int target, int level, + int xoffset, int yoffset, int width, int height, int format, + int imageSize, IntBuffer data) { + GL.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, + height, format, imageSize, data); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param width + * @param height + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage2D(int target, int level, + int xoffset, int yoffset, int width, int height, int format, + int imageSize, ShortBuffer data) { + GL.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, + height, format, imageSize, data); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param width + * @param height + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage2DARB(int target, int level, + int xoffset, int yoffset, int width, int height, int border, + int imageSize, ByteBuffer pData) { + GL.glCompressedTexSubImage2DARB(target, level, xoffset, yoffset, width, + height, border, imageSize, pData); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param width + * @param height + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage2DARB(int target, int level, + int xoffset, int yoffset, int width, int height, int border, + int imageSize, FloatBuffer pData) { + GL.glCompressedTexSubImage2DARB(target, level, xoffset, yoffset, width, + height, border, imageSize, pData); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param width + * @param height + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage2DARB(int target, int level, + int xoffset, int yoffset, int width, int height, int border, + int imageSize, IntBuffer pData) { + GL.glCompressedTexSubImage2DARB(target, level, xoffset, yoffset, width, + height, border, imageSize, pData); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param width + * @param height + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage2DARB(int target, int level, + int xoffset, int yoffset, int width, int height, int border, + int imageSize, ShortBuffer pData) { + GL.glCompressedTexSubImage2DARB(target, level, xoffset, yoffset, width, + height, border, imageSize, pData); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage3D(int target, int level, + int xoffset, int yoffset, int zoffset, int width, int height, + int depth, int format, int imageSize, ByteBuffer data) { + GL.glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, + width, height, depth, format, imageSize, data); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage3D(int target, int level, + int xoffset, int yoffset, int zoffset, int width, int height, + int depth, int format, int imageSize, FloatBuffer data) { + GL.glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, + width, height, depth, format, imageSize, data); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage3D(int target, int level, + int xoffset, int yoffset, int zoffset, int width, int height, + int depth, int format, int imageSize, IntBuffer data) { + GL.glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, + width, height, depth, format, imageSize, data); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage3D(int target, int level, + int xoffset, int yoffset, int zoffset, int width, int height, + int depth, int format, int imageSize, ShortBuffer data) { + GL.glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, + width, height, depth, format, imageSize, data); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage3DARB(int target, int level, + int xoffset, int yoffset, int zoffset, int width, int height, + int depth, int border, int imageSize, ByteBuffer pData) { + GL.glCompressedTexSubImage3DARB(target, level, xoffset, yoffset, + zoffset, width, height, depth, border, imageSize, pData); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage3DARB(int target, int level, + int xoffset, int yoffset, int zoffset, int width, int height, + int depth, int border, int imageSize, FloatBuffer pData) { + GL.glCompressedTexSubImage3DARB(target, level, xoffset, yoffset, + zoffset, width, height, depth, border, imageSize, pData); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage3DARB(int target, int level, + int xoffset, int yoffset, int zoffset, int width, int height, + int depth, int border, int imageSize, IntBuffer pData) { + GL.glCompressedTexSubImage3DARB(target, level, xoffset, yoffset, + zoffset, width, height, depth, border, imageSize, pData); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage3DARB(int target, int level, + int xoffset, int yoffset, int zoffset, int width, int height, + int depth, int border, int imageSize, ShortBuffer pData) { + GL.glCompressedTexSubImage3DARB(target, level, xoffset, yoffset, + zoffset, width, height, depth, border, imageSize, pData); + } + /** + * @param target + * @param internalformat + * @param width + * @param format + * @param type + * @param image + */ + public void glConvolutionFilter1D(int target, int internalformat, + int width, int format, int type, ByteBuffer image) { + GL.glConvolutionFilter1D(target, internalformat, width, format, type, + image); + } + /** + * @param target + * @param internalformat + * @param width + * @param format + * @param type + * @param image + */ + public void glConvolutionFilter1D(int target, int internalformat, + int width, int format, int type, FloatBuffer image) { + GL.glConvolutionFilter1D(target, internalformat, width, format, type, + image); + } + /** + * @param target + * @param internalformat + * @param width + * @param format + * @param type + * @param image + */ + public void glConvolutionFilter1D(int target, int internalformat, + int width, int format, int type, IntBuffer image) { + GL.glConvolutionFilter1D(target, internalformat, width, format, type, + image); + } + /** + * @param target + * @param internalformat + * @param width + * @param format + * @param type + * @param image + */ + public void glConvolutionFilter1D(int target, int internalformat, + int width, int format, int type, ShortBuffer image) { + GL.glConvolutionFilter1D(target, internalformat, width, format, type, + image); + } + /** + * @param target + * @param internalformat + * @param width + * @param height + * @param format + * @param type + * @param image + */ + public void glConvolutionFilter2D(int target, int internalformat, + int width, int height, int format, int type, ByteBuffer image) { + GL.glConvolutionFilter2D(target, internalformat, width, height, format, + type, image); + } + /** + * @param target + * @param internalformat + * @param width + * @param height + * @param format + * @param type + * @param image + */ + public void glConvolutionFilter2D(int target, int internalformat, + int width, int height, int format, int type, IntBuffer image) { + GL.glConvolutionFilter2D(target, internalformat, width, height, format, + type, image); + } + /** + * @param target + * @param internalformat + * @param width + * @param height + * @param format + * @param type + * @param image + */ + public void glConvolutionFilter2D(int target, int internalformat, + int width, int height, int format, int type, ShortBuffer image) { + GL.glConvolutionFilter2D(target, internalformat, width, height, format, + type, image); + } + /** + * @param target + * @param pname + * @param params + */ + public void glConvolutionParameter(int target, int pname, + FloatBuffer params) { + GL.glConvolutionParameter(target, pname, params); + } + /** + * @param target + * @param pname + * @param params + */ + public void glConvolutionParameterf(int target, int pname, + float params) { + GL.glConvolutionParameterf(target, pname, params); + } + /** + * @param target + * @param pname + * @param params + */ + public void glConvolutionParameteri(int target, int pname, int params) { + GL.glConvolutionParameteri(target, pname, params); + } + /** + * @param target + * @param pname + * @param params + */ + public void glConvolutionParameteriv(int target, int pname, + IntBuffer params) { + GL.glConvolutionParameteriv(target, pname, params); + } + /** + * @param target + * @param start + * @param x + * @param y + * @param width + */ + public void glCopyColorSubTable(int target, int start, int x, int y, + int width) { + GL.glCopyColorSubTable(target, start, x, y, width); + } + /** + * @param target + * @param internalformat + * @param x + * @param y + * @param width + */ + public void glCopyColorTable(int target, int internalformat, int x, + int y, int width) { + GL.glCopyColorTable(target, internalformat, x, y, width); + } + /** + * @param target + * @param internalformat + * @param x + * @param y + * @param width + */ + public void glCopyConvolutionFilter1D(int target, + int internalformat, int x, int y, int width) { + GL.glCopyConvolutionFilter1D(target, internalformat, x, y, width); + } + /** + * @param target + * @param internalformat + * @param x + * @param y + * @param width + * @param height + */ + public void glCopyConvolutionFilter2D(int target, + int internalformat, int x, int y, int width, int height) { + GL.glCopyConvolutionFilter2D(target, internalformat, x, y, width, + height); + } + /** + * @param x + * @param y + * @param width + * @param height + * @param type + */ + public void glCopyPixels(int x, int y, int width, int height, + int type) { + GL.glCopyPixels(x, y, width, height, type); + } + /** + * @param target + * @param level + * @param internalFormat + * @param x + * @param y + * @param width + * @param border + */ + public void glCopyTexImage1D(int target, int level, + int internalFormat, int x, int y, int width, int border) { + GL.glCopyTexImage1D(target, level, internalFormat, x, y, width, border); + } + /** + * @param target + * @param level + * @param internalFormat + * @param x + * @param y + * @param width + * @param height + * @param border + */ + public void glCopyTexImage2D(int target, int level, + int internalFormat, int x, int y, int width, int height, int border) { + GL.glCopyTexImage2D(target, level, internalFormat, x, y, width, height, + border); + } + /** + * @param target + * @param level + * @param xoffset + * @param x + * @param y + * @param width + */ + public void glCopyTexSubImage1D(int target, int level, int xoffset, + int x, int y, int width) { + GL.glCopyTexSubImage1D(target, level, xoffset, x, y, width); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param x + * @param y + * @param width + * @param height + */ + public void glCopyTexSubImage2D(int target, int level, int xoffset, + int yoffset, int x, int y, int width, int height) { + GL.glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, + height); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param x + * @param y + * @param width + * @param height + */ + public void glCopyTexSubImage3D(int target, int level, int xoffset, + int yoffset, int zoffset, int x, int y, int width, int height) { + GL.glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, + width, height); + } + /** + * @return + */ + public int glCreateProgramObjectARB() { + return GL.glCreateProgramObjectARB(); + } + /** + * @param shaderType + * @return + */ + public int glCreateShaderObjectARB(int shaderType) { + return GL.glCreateShaderObjectARB(shaderType); + } + /** + * @param mode + */ + public void glCullFace(int mode) { + GL.glCullFace(mode); + } + /** + * @param index + */ + public void glCurrentPaletteMatrixARB(int index) { + GL.glCurrentPaletteMatrixARB(index); + } + /** + * @param buffers + */ + public void glDeleteBuffers(IntBuffer buffers) { + GL.glDeleteBuffers(buffers); + } + /** + * @param buffers + */ + public void glDeleteBuffersARB(IntBuffer buffers) { + GL.glDeleteBuffersARB(buffers); + } + /** + * @param list + * @param range + */ + public void glDeleteLists(int list, int range) { + GL.glDeleteLists(list, range); + } + /** + * @param obj + */ + public void glDeleteObjectARB(int obj) { + GL.glDeleteObjectARB(obj); + } + /** + * @param programs + */ + public void glDeleteProgramsARB(IntBuffer programs) { + GL.glDeleteProgramsARB(programs); + } + /** + * @param ids + */ + public void glDeleteQueries(IntBuffer ids) { + GL.glDeleteQueries(ids); + } + /** + * @param ids + */ + public void glDeleteQueriesARB(IntBuffer ids) { + GL.glDeleteQueriesARB(ids); + } + /** + * @param textures + */ + public void glDeleteTextures(IntBuffer textures) { + GL.glDeleteTextures(textures); + } + /** + * @param id + */ + public void glDeleteVertexShaderEXT(int id) { + GL.glDeleteVertexShaderEXT(id); + } + /** + * @param zmin + * @param zmax + */ + public void glDepthBoundsEXT(float zmin, float zmax) { + GL.glDepthBoundsEXT(zmin, zmax); + } + /** + * @param func + */ + public void glDepthFunc(int func) { + GL.glDepthFunc(func); + } + /** + * @param flag + */ + public void glDepthMask(boolean flag) { + GL.glDepthMask(flag); + } + /** + * @param zNear + * @param zFar + */ + public void glDepthRange(double zNear, double zFar) { + GL.glDepthRange(zNear, zFar); + } + /** + * @param containerObj + * @param attachedObj + */ + public void glDetachObjectARB(int containerObj, int attachedObj) { + GL.glDetachObjectARB(containerObj, attachedObj); + } + /** + * @param cap + */ + public void glDisable(int cap) { + GL.glDisable(cap); + } + /** + * @param cap + */ + public void glDisableClientState(int cap) { + GL.glDisableClientState(cap); + } + /** + * @param id + */ + public void glDisableVariantClientStateEXT(int id) { + GL.glDisableVariantClientStateEXT(id); + } + /** + * @param index + */ + public void glDisableVertexAttribArrayARB(int index) { + GL.glDisableVertexAttribArrayARB(index); + } + /** + * @param mode + * @param first + * @param count + */ + public void glDrawArrays(int mode, int first, int count) { + GL.glDrawArrays(mode, first, count); + } + /** + * @param mode + */ + public void glDrawBuffer(int mode) { + GL.glDrawBuffer(mode); + } + /** + * @param mode + * @param indices + */ + public void glDrawElements(int mode, ByteBuffer indices) { + GL.glDrawElements(mode, indices); + } + /** + * @param mode + * @param count + * @param type + * @param buffer_offset + */ + public void glDrawElements(int mode, int count, int type, + int buffer_offset) { + GL.glDrawElements(mode, count, type, buffer_offset); + } + /** + * @param mode + * @param indices + */ + public void glDrawElements(int mode, IntBuffer indices) { + GL.glDrawElements(mode, indices); + } + /** + * @param mode + * @param indices + */ + public void glDrawElements(int mode, ShortBuffer indices) { + GL.glDrawElements(mode, indices); + } + /** + * @param width + * @param height + * @param format + * @param type + * @param pixels + */ + public void glDrawPixels(int width, int height, int format, + int type, ByteBuffer pixels) { + GL.glDrawPixels(width, height, format, type, pixels); + } + /** + * @param width + * @param height + * @param format + * @param type + * @param pixels + */ + public void glDrawPixels(int width, int height, int format, + int type, IntBuffer pixels) { + GL.glDrawPixels(width, height, format, type, pixels); + } + /** + * @param width + * @param height + * @param format + * @param type + * @param pixels + */ + public void glDrawPixels(int width, int height, int format, + int type, ShortBuffer pixels) { + GL.glDrawPixels(width, height, format, type, pixels); + } + /** + * @param mode + * @param start + * @param end + * @param indices + */ + public void glDrawRangeElements(int mode, int start, int end, + ByteBuffer indices) { + GL.glDrawRangeElements(mode, start, end, indices); + } + /** + * @param mode + * @param start + * @param end + * @param count + * @param type + * @param buffer_offset + */ + public void glDrawRangeElements(int mode, int start, int end, + int count, int type, int buffer_offset) { + GL.glDrawRangeElements(mode, start, end, count, type, buffer_offset); + } + /** + * @param mode + * @param start + * @param end + * @param indices + */ + public void glDrawRangeElements(int mode, int start, int end, + IntBuffer indices) { + GL.glDrawRangeElements(mode, start, end, indices); + } + /** + * @param mode + * @param start + * @param end + * @param indices + */ + public void glDrawRangeElements(int mode, int start, int end, + ShortBuffer indices) { + GL.glDrawRangeElements(mode, start, end, indices); + } + /** + * @param mode + * @param start + * @param end + * @param pIndices + */ + public void glDrawRangeElementsEXT(int mode, int start, int end, + ByteBuffer pIndices) { + GL.glDrawRangeElementsEXT(mode, start, end, pIndices); + } + /** + * @param mode + * @param start + * @param end + * @param count + * @param type + * @param buffer_offset + */ + public void glDrawRangeElementsEXT(int mode, int start, int end, + int count, int type, int buffer_offset) { + GL.glDrawRangeElementsEXT(mode, start, end, count, type, buffer_offset); + } + /** + * @param mode + * @param start + * @param end + * @param pIndices + */ + public void glDrawRangeElementsEXT(int mode, int start, int end, + IntBuffer pIndices) { + GL.glDrawRangeElementsEXT(mode, start, end, pIndices); + } + /** + * @param mode + * @param start + * @param end + * @param pIndices + */ + public void glDrawRangeElementsEXT(int mode, int start, int end, + ShortBuffer pIndices) { + GL.glDrawRangeElementsEXT(mode, start, end, pIndices); + } + /** + * @param flag + */ + public void glEdgeFlag(boolean flag) { + GL.glEdgeFlag(flag); + } + /** + * @param stride + * @param pointer + */ + public void glEdgeFlagPointer(int stride, ByteBuffer pointer) { + GL.glEdgeFlagPointer(stride, pointer); + } + /** + * @param stride + * @param buffer_offset + */ + public void glEdgeFlagPointer(int stride, int buffer_offset) { + GL.glEdgeFlagPointer(stride, buffer_offset); + } + /** + * @param cap + */ + public void glEnable(int cap) { + GL.glEnable(cap); + } + /** + * @param cap + */ + public void glEnableClientState(int cap) { + GL.glEnableClientState(cap); + } + /** + * @param id + */ + public void glEnableVariantClientStateEXT(int id) { + GL.glEnableVariantClientStateEXT(id); + } + /** + * @param index + */ + public void glEnableVertexAttribArrayARB(int index) { + GL.glEnableVertexAttribArrayARB(index); + } + /** + * + */ + public void glEnd() { + GL.glEnd(); + } + /** + * + */ + public void glEndList() { + GL.glEndList(); + } + /** + * @param target + */ + public void glEndQuery(int target) { + GL.glEndQuery(target); + } + /** + * @param target + */ + public void glEndQueryARB(int target) { + GL.glEndQueryARB(target); + } + /** + * + */ + public void glEndVertexShaderEXT() { + GL.glEndVertexShaderEXT(); + } + /** + * @param u + */ + public void glEvalCoord1f(float u) { + GL.glEvalCoord1f(u); + } + /** + * @param u + * @param v + */ + public void glEvalCoord2f(float u, float v) { + GL.glEvalCoord2f(u, v); + } + /** + * @param mode + * @param i1 + * @param i2 + */ + public void glEvalMesh1(int mode, int i1, int i2) { + GL.glEvalMesh1(mode, i1, i2); + } + /** + * @param mode + * @param i1 + * @param i2 + * @param j1 + * @param j2 + */ + public void glEvalMesh2(int mode, int i1, int i2, int j1, int j2) { + GL.glEvalMesh2(mode, i1, i2, j1, j2); + } + /** + * @param i + */ + public void glEvalPoint1(int i) { + GL.glEvalPoint1(i); + } + /** + * @param i + * @param j + */ + public void glEvalPoint2(int i, int j) { + GL.glEvalPoint2(i, j); + } + /** + * @param res + * @param src + * @param num + */ + public void glExtractComponentEXT(int res, int src, int num) { + GL.glExtractComponentEXT(res, src, num); + } + /** + * @param type + * @param buffer + */ + public void glFeedbackBuffer(int type, FloatBuffer buffer) { + GL.glFeedbackBuffer(type, buffer); + } + /** + * + */ + public void glFinish() { + GL.glFinish(); + } + /** + * + */ + public void glFlush() { + GL.glFlush(); + } + /** + * @param pname + * @param params + */ + public void glFog(int pname, FloatBuffer params) { + GL.glFog(pname, params); + } + /** + * @param pname + * @param params + */ + public void glFog(int pname, IntBuffer params) { + GL.glFog(pname, params); + } + /** + * @param coord + */ + public void glFogCoordf(float coord) { + GL.glFogCoordf(coord); + } + /** + * @param coord + */ + public void glFogCoordfEXT(float coord) { + GL.glFogCoordfEXT(coord); + } + /** + * @param stride + * @param data + */ + public void glFogCoordPointer(int stride, FloatBuffer data) { + GL.glFogCoordPointer(stride, data); + } + /** + * @param type + * @param stride + * @param buffer_offset + */ + public void glFogCoordPointer(int type, int stride, int buffer_offset) { + GL.glFogCoordPointer(type, stride, buffer_offset); + } + /** + * @param stride + * @param data + */ + public void glFogCoordPointerEXT(int stride, FloatBuffer data) { + GL.glFogCoordPointerEXT(stride, data); + } + /** + * @param type + * @param stride + * @param buffer_offset + */ + public void glFogCoordPointerEXT(int type, int stride, + int buffer_offset) { + GL.glFogCoordPointerEXT(type, stride, buffer_offset); + } + /** + * @param pname + * @param param + */ + public void glFogf(int pname, float param) { + GL.glFogf(pname, param); + } + /** + * @param pname + * @param param + */ + public void glFogi(int pname, int param) { + GL.glFogi(pname, param); + } + /** + * @param mode + */ + public void glFrontFace(int mode) { + GL.glFrontFace(mode); + } + /** + * @param left + * @param right + * @param bottom + * @param top + * @param zNear + * @param zFar + */ + public void glFrustum(double left, double right, double bottom, + double top, double zNear, double zFar) { + GL.glFrustum(left, right, bottom, top, zNear, zFar); + } + /** + * @param buffers + */ + public void glGenBuffers(IntBuffer buffers) { + GL.glGenBuffers(buffers); + } + /** + * @param buffers + */ + public void glGenBuffersARB(IntBuffer buffers) { + GL.glGenBuffersARB(buffers); + } + /** + * @param range + * @return + */ + public int glGenLists(int range) { + return GL.glGenLists(range); + } + /** + * @param programs + */ + public void glGenProgramsARB(IntBuffer programs) { + GL.glGenProgramsARB(programs); + } + /** + * @param ids + */ + public void glGenQueries(IntBuffer ids) { + GL.glGenQueries(ids); + } + /** + * @param ids + */ + public void glGenQueriesARB(IntBuffer ids) { + GL.glGenQueriesARB(ids); + } + /** + * @param dataType + * @param storageType + * @param range + * @param components + * @return + */ + public int glGenSymbolsEXT(int dataType, int storageType, int range, + int components) { + return GL.glGenSymbolsEXT(dataType, storageType, range, components); + } + /** + * @param textures + */ + public void glGenTextures(IntBuffer textures) { + GL.glGenTextures(textures); + } + /** + * @param range + * @return + */ + public int glGenVertexShadersEXT(int range) { + return GL.glGenVertexShadersEXT(range); + } + /** + * @param programObj + * @param index + * @param length + * @param size + * @param type + * @param name + */ + public void glGetActiveAttribARB(int programObj, int index, + IntBuffer length, IntBuffer size, IntBuffer type, ByteBuffer name) { + GL.glGetActiveAttribARB(programObj, index, length, size, type, name); + } + /** + * @param programObj + * @param index + * @param length + * @param size + * @param type + * @param name + */ + public void glGetActiveUniformARB(int programObj, int index, + IntBuffer length, IntBuffer size, IntBuffer type, ByteBuffer name) { + GL.glGetActiveUniformARB(programObj, index, length, size, type, name); + } + /** + * @param containerObj + * @param count + * @param obj + */ + public void glGetAttachedObjectsARB(int containerObj, + IntBuffer count, IntBuffer obj) { + GL.glGetAttachedObjectsARB(containerObj, count, obj); + } + /** + * @param programObj + * @param name + * @return + */ + public int glGetAttribLocationARB(int programObj, ByteBuffer name) { + return GL.glGetAttribLocationARB(programObj, name); + } + /** + * @param pname + * @param params + */ + public void glGetBoolean(int pname, ByteBuffer params) { + GL.glGetBoolean(pname, params); + } + /** + * @param target + * @param pname + * @param params + */ + public void glGetBufferParameter(int target, int pname, + IntBuffer params) { + GL.glGetBufferParameter(target, pname, params); + } + /** + * @param target + * @param pname + * @param params + */ + public void glGetBufferParameterARB(int target, int pname, + IntBuffer params) { + GL.glGetBufferParameterARB(target, pname, params); + } + /** + * @param target + * @param pname + * @param size + * @return + */ + public ByteBuffer glGetBufferPointer(int target, int pname, int size) { + return GL.glGetBufferPointer(target, pname, size); + } + /** + * @param target + * @param pname + * @param size + * @return + */ + public ByteBuffer glGetBufferPointerARB(int target, int pname, + int size) { + return GL.glGetBufferPointerARB(target, pname, size); + } + /** + * @param target + * @param offset + * @param data + */ + public void glGetBufferSubData(int target, int offset, + ByteBuffer data) { + GL.glGetBufferSubData(target, offset, data); + } + /** + * @param target + * @param offset + * @param data + */ + public void glGetBufferSubData(int target, int offset, + FloatBuffer data) { + GL.glGetBufferSubData(target, offset, data); + } + /** + * @param target + * @param offset + * @param data + */ + public void glGetBufferSubData(int target, int offset, IntBuffer data) { + GL.glGetBufferSubData(target, offset, data); + } + /** + * @param target + * @param offset + * @param data + */ + public void glGetBufferSubData(int target, int offset, + ShortBuffer data) { + GL.glGetBufferSubData(target, offset, data); + } + /** + * @param target + * @param offset + * @param data + */ + public void glGetBufferSubDataARB(int target, int offset, + ByteBuffer data) { + GL.glGetBufferSubDataARB(target, offset, data); + } + /** + * @param target + * @param offset + * @param data + */ + public void glGetBufferSubDataARB(int target, int offset, + FloatBuffer data) { + GL.glGetBufferSubDataARB(target, offset, data); + } + /** + * @param target + * @param offset + * @param data + */ + public void glGetBufferSubDataARB(int target, int offset, + IntBuffer data) { + GL.glGetBufferSubDataARB(target, offset, data); + } + /** + * @param target + * @param offset + * @param data + */ + public void glGetBufferSubDataARB(int target, int offset, + ShortBuffer data) { + GL.glGetBufferSubDataARB(target, offset, data); + } + /** + * @param plane + * @param equation + */ + public void glGetClipPlane(int plane, DoubleBuffer equation) { + GL.glGetClipPlane(plane, equation); + } + /** + * @param target + * @param format + * @param type + * @param data + */ + public void glGetColorTable(int target, int format, int type, + ByteBuffer data) { + GL.glGetColorTable(target, format, type, data); + } + /** + * @param target + * @param format + * @param type + * @param data + */ + public void glGetColorTable(int target, int format, int type, + FloatBuffer data) { + GL.glGetColorTable(target, format, type, data); + } + /** + * @param target + * @param pname + * @param params + */ + public void glGetColorTableParameter(int target, int pname, + FloatBuffer params) { + GL.glGetColorTableParameter(target, pname, params); + } + /** + * @param target + * @param pname + * @param params + */ + public void glGetColorTableParameter(int target, int pname, + IntBuffer params) { + GL.glGetColorTableParameter(target, pname, params); + } + /** + * @param target + * @param lod + * @param img + */ + public void glGetCompressedTexImage(int target, int lod, + ByteBuffer img) { + GL.glGetCompressedTexImage(target, lod, img); + } + /** + * @param target + * @param lod + * @param img + */ + public void glGetCompressedTexImage(int target, int lod, + IntBuffer img) { + GL.glGetCompressedTexImage(target, lod, img); + } + /** + * @param target + * @param lod + * @param img + */ + public void glGetCompressedTexImage(int target, int lod, + ShortBuffer img) { + GL.glGetCompressedTexImage(target, lod, img); + } + /** + * @param target + * @param lod + * @param pImg + */ + public void glGetCompressedTexImageARB(int target, int lod, + ByteBuffer pImg) { + GL.glGetCompressedTexImageARB(target, lod, pImg); + } + /** + * @param target + * @param lod + * @param pImg + */ + public void glGetCompressedTexImageARB(int target, int lod, + IntBuffer pImg) { + GL.glGetCompressedTexImageARB(target, lod, pImg); + } + /** + * @param target + * @param lod + * @param pImg + */ + public void glGetCompressedTexImageARB(int target, int lod, + ShortBuffer pImg) { + GL.glGetCompressedTexImageARB(target, lod, pImg); + } + /** + * @param target + * @param format + * @param type + * @param image + */ + public void glGetConvolutionFilter(int target, int format, int type, + ByteBuffer image) { + GL.glGetConvolutionFilter(target, format, type, image); + } + /** + * @param target + * @param format + * @param type + * @param image + */ + public void glGetConvolutionFilter(int target, int format, int type, + FloatBuffer image) { + GL.glGetConvolutionFilter(target, format, type, image); + } + /** + * @param target + * @param format + * @param type + * @param image + */ + public void glGetConvolutionFilter(int target, int format, int type, + IntBuffer image) { + GL.glGetConvolutionFilter(target, format, type, image); + } + /** + * @param target + * @param format + * @param type + * @param image + */ + public void glGetConvolutionFilter(int target, int format, int type, + ShortBuffer image) { + GL.glGetConvolutionFilter(target, format, type, image); + } + /** + * @param target + * @param pname + * @param params + */ + public void glGetConvolutionParameter(int target, int pname, + FloatBuffer params) { + GL.glGetConvolutionParameter(target, pname, params); + } + /** + * @param target + * @param pname + * @param params + */ + public void glGetConvolutionParameter(int target, int pname, + IntBuffer params) { + GL.glGetConvolutionParameter(target, pname, params); + } + /** + * @param pname + * @param params + */ + public void glGetDouble(int pname, DoubleBuffer params) { + GL.glGetDouble(pname, params); + } + /** + * @return + */ + public int glGetError() { + return GL.glGetError(); + } + /** + * @param pname + * @param params + */ + public void glGetFloat(int pname, FloatBuffer params) { + GL.glGetFloat(pname, params); + } + /** + * @param pname + * @return + */ + public int glGetHandleARB(int pname) { + return GL.glGetHandleARB(pname); + } + /** + * @param target + * @param reset + * @param format + * @param type + * @param values + */ + public void glGetHistogram(int target, boolean reset, int format, + int type, ByteBuffer values) { + GL.glGetHistogram(target, reset, format, type, values); + } + /** + * @param target + * @param reset + * @param format + * @param type + * @param values + */ + public void glGetHistogram(int target, boolean reset, int format, + int type, FloatBuffer values) { + GL.glGetHistogram(target, reset, format, type, values); + } + /** + * @param target + * @param reset + * @param format + * @param type + * @param values + */ + public void glGetHistogram(int target, boolean reset, int format, + int type, IntBuffer values) { + GL.glGetHistogram(target, reset, format, type, values); + } + /** + * @param target + * @param reset + * @param format + * @param type + * @param values + */ + public void glGetHistogram(int target, boolean reset, int format, + int type, ShortBuffer values) { + GL.glGetHistogram(target, reset, format, type, values); + } + /** + * @param target + * @param pname + * @param params + */ + public void glGetHistogramParameter(int target, int pname, + FloatBuffer params) { + GL.glGetHistogramParameter(target, pname, params); + } + /** + * @param target + * @param pname + * @param params + */ + public void glGetHistogramParameter(int target, int pname, + IntBuffer params) { + GL.glGetHistogramParameter(target, pname, params); + } + /** + * @param obj + * @param length + * @param infoLog + */ + public void glGetInfoLogARB(int obj, IntBuffer length, + ByteBuffer infoLog) { + GL.glGetInfoLogARB(obj, length, infoLog); + } + /** + * @param pname + * @param params + */ + public void glGetInteger(int pname, IntBuffer params) { + GL.glGetInteger(pname, params); + } + /** + * @param id + * @param value + * @param pbData + */ + public void glGetInvariantBooleanEXT(int id, int value, + ByteBuffer pbData) { + GL.glGetInvariantBooleanEXT(id, value, pbData); + } + /** + * @param id + * @param value + * @param pfData + */ + public void glGetInvariantFloatEXT(int id, int value, + FloatBuffer pfData) { + GL.glGetInvariantFloatEXT(id, value, pfData); + } + /** + * @param id + * @param value + * @param piData + */ + public void glGetInvariantIntegerEXT(int id, int value, + IntBuffer piData) { + GL.glGetInvariantIntegerEXT(id, value, piData); + } + /** + * @param light + * @param pname + * @param params + */ + public void glGetLight(int light, int pname, FloatBuffer params) { + GL.glGetLight(light, pname, params); + } + /** + * @param light + * @param pname + * @param params + */ + public void glGetLight(int light, int pname, IntBuffer params) { + GL.glGetLight(light, pname, params); + } + /** + * @param id + * @param value + * @param pbData + */ + public void glGetLocalConstantBooleanEXT(int id, int value, + ByteBuffer pbData) { + GL.glGetLocalConstantBooleanEXT(id, value, pbData); + } + /** + * @param id + * @param value + * @param pfData + */ + public void glGetLocalConstantFloatEXT(int id, int value, + FloatBuffer pfData) { + GL.glGetLocalConstantFloatEXT(id, value, pfData); + } + /** + * @param id + * @param value + * @param piData + */ + public void glGetLocalConstantIntegerEXT(int id, int value, + IntBuffer piData) { + GL.glGetLocalConstantIntegerEXT(id, value, piData); + } + /** + * @param target + * @param query + * @param v + */ + public void glGetMap(int target, int query, FloatBuffer v) { + GL.glGetMap(target, query, v); + } + /** + * @param target + * @param query + * @param v + */ + public void glGetMap(int target, int query, IntBuffer v) { + GL.glGetMap(target, query, v); + } + /** + * @param face + * @param pname + * @param params + */ + public void glGetMaterial(int face, int pname, FloatBuffer params) { + GL.glGetMaterial(face, pname, params); + } + /** + * @param face + * @param pname + * @param params + */ + public void glGetMaterial(int face, int pname, IntBuffer params) { + GL.glGetMaterial(face, pname, params); + } + /** + * @param target + * @param reset + * @param format + * @param types + * @param values + */ + public void glGetMinmax(int target, boolean reset, int format, + int types, ByteBuffer values) { + GL.glGetMinmax(target, reset, format, types, values); + } + /** + * @param target + * @param reset + * @param format + * @param types + * @param values + */ + public void glGetMinmax(int target, boolean reset, int format, + int types, FloatBuffer values) { + GL.glGetMinmax(target, reset, format, types, values); + } + /** + * @param target + * @param reset + * @param format + * @param types + * @param values + */ + public void glGetMinmax(int target, boolean reset, int format, + int types, IntBuffer values) { + GL.glGetMinmax(target, reset, format, types, values); + } + /** + * @param target + * @param reset + * @param format + * @param types + * @param values + */ + public void glGetMinmax(int target, boolean reset, int format, + int types, ShortBuffer values) { + GL.glGetMinmax(target, reset, format, types, values); + } + /** + * @param target + * @param pname + * @param params + */ + public void glGetMinmaxParameter(int target, int pname, + FloatBuffer params) { + GL.glGetMinmaxParameter(target, pname, params); + } + /** + * @param target + * @param pname + * @param params + */ + public void glGetMinmaxParameter(int target, int pname, + IntBuffer params) { + GL.glGetMinmaxParameter(target, pname, params); + } + /** + * @param obj + * @param pname + * @param params + */ + public void glGetObjectParameterARB(int obj, int pname, + FloatBuffer params) { + GL.glGetObjectParameterARB(obj, pname, params); + } + /** + * @param obj + * @param pname + * @param params + */ + public void glGetObjectParameterARB(int obj, int pname, + IntBuffer params) { + GL.glGetObjectParameterARB(obj, pname, params); + } + /** + * @param map + * @param values + */ + public void glGetPixelMap(int map, FloatBuffer values) { + GL.glGetPixelMap(map, values); + } + /** + * @param map + * @param values + */ + public void glGetPixelMap(int map, IntBuffer values) { + GL.glGetPixelMap(map, values); + } + /** + * @param map + * @param values + */ + public void glGetPixelMap(int map, ShortBuffer values) { + GL.glGetPixelMap(map, values); + } + /** + * @param pname + * @param size + * @return + */ + public ByteBuffer glGetPointerv(int pname, int size) { + return GL.glGetPointerv(pname, size); + } + /** + * @param mask + */ + public void glGetPolygonStipple(ByteBuffer mask) { + GL.glGetPolygonStipple(mask); + } + /** + * @param target + * @param parameterName + * @param params + */ + public void glGetProgramARB(int target, int parameterName, + IntBuffer params) { + GL.glGetProgramARB(target, parameterName, params); + } + /** + * @param target + * @param index + * @param params + */ + public void glGetProgramEnvParameterARB(int target, int index, + FloatBuffer params) { + GL.glGetProgramEnvParameterARB(target, index, params); + } + /** + * @param target + * @param index + * @param params + */ + public void glGetProgramLocalParameterARB(int target, int index, + FloatBuffer params) { + GL.glGetProgramLocalParameterARB(target, index, params); + } + /** + * @param target + * @param parameterName + * @param paramString + */ + public void glGetProgramStringARB(int target, int parameterName, + ByteBuffer paramString) { + GL.glGetProgramStringARB(target, parameterName, paramString); + } + /** + * @param target + * @param pname + * @param params + */ + public void glGetQuery(int target, int pname, IntBuffer params) { + GL.glGetQuery(target, pname, params); + } + /** + * @param target + * @param pname + * @param params + */ + public void glGetQueryARB(int target, int pname, IntBuffer params) { + GL.glGetQueryARB(target, pname, params); + } + /** + * @param id + * @param pname + * @param params + */ + public void glGetQueryObject(int id, int pname, IntBuffer params) { + GL.glGetQueryObject(id, pname, params); + } + /** + * @param id + * @param pname + * @param params + */ + public void glGetQueryObjectiARB(int id, int pname, IntBuffer params) { + GL.glGetQueryObjectiARB(id, pname, params); + } + /** + * @param id + * @param pname + * @param params + */ + public void glGetQueryObjectu(int id, int pname, IntBuffer params) { + GL.glGetQueryObjectu(id, pname, params); + } + /** + * @param id + * @param pname + * @param params + */ + public void glGetQueryObjectuiARB(int id, int pname, IntBuffer params) { + GL.glGetQueryObjectuiARB(id, pname, params); + } + /** + * @param target + * @param format + * @param type + * @param row + * @param column + * @param span + */ + public void glGetSeparableFilter(int target, int format, int type, + Buffer row, Buffer column, Buffer span) { + GL.glGetSeparableFilter(target, format, type, row, column, span); + } + /** + * @param obj + * @param length + * @param source + */ + public void glGetShaderSourceARB(int obj, IntBuffer length, + ByteBuffer source) { + GL.glGetShaderSourceARB(obj, length, source); + } + /** + * @param name + * @return + */ + public String glGetString(int name) { + return GL.glGetString(name); + } + /** + * @param coord + * @param pname + * @param params + */ + public void glGetTexEnv(int coord, int pname, FloatBuffer params) { + GL.glGetTexEnv(coord, pname, params); + } + /** + * @param coord + * @param pname + * @param params + */ + public void glGetTexEnv(int coord, int pname, IntBuffer params) { + GL.glGetTexEnv(coord, pname, params); + } + /** + * @param coord + * @param pname + * @param params + */ + public void glGetTexGen(int coord, int pname, FloatBuffer params) { + GL.glGetTexGen(coord, pname, params); + } + /** + * @param coord + * @param pname + * @param params + */ + public void glGetTexGen(int coord, int pname, IntBuffer params) { + GL.glGetTexGen(coord, pname, params); + } + /** + * @param target + * @param level + * @param format + * @param type + * @param pixels + */ + public void glGetTexImage(int target, int level, int format, + int type, ByteBuffer pixels) { + GL.glGetTexImage(target, level, format, type, pixels); + } + /** + * @param target + * @param level + * @param format + * @param type + * @param pixels + */ + public void glGetTexImage(int target, int level, int format, + int type, IntBuffer pixels) { + GL.glGetTexImage(target, level, format, type, pixels); + } + /** + * @param target + * @param level + * @param format + * @param type + * @param pixels + */ + public void glGetTexImage(int target, int level, int format, + int type, ShortBuffer pixels) { + GL.glGetTexImage(target, level, format, type, pixels); + } + /** + * @param target + * @param level + * @param pname + * @param params + */ + public void glGetTexLevelParameter(int target, int level, int pname, + FloatBuffer params) { + GL.glGetTexLevelParameter(target, level, pname, params); + } + /** + * @param target + * @param level + * @param pname + * @param params + */ + public void glGetTexLevelParameter(int target, int level, int pname, + IntBuffer params) { + GL.glGetTexLevelParameter(target, level, pname, params); + } + /** + * @param target + * @param pname + * @param params + */ + public void glGetTexParameter(int target, int pname, + FloatBuffer params) { + GL.glGetTexParameter(target, pname, params); + } + /** + * @param target + * @param pname + * @param params + */ + public void glGetTexParameter(int target, int pname, IntBuffer params) { + GL.glGetTexParameter(target, pname, params); + } + /** + * @param programObj + * @param location + * @param params + */ + public void glGetUniformARB(int programObj, int location, + FloatBuffer params) { + GL.glGetUniformARB(programObj, location, params); + } + /** + * @param programObj + * @param location + * @param params + */ + public void glGetUniformARB(int programObj, int location, + IntBuffer params) { + GL.glGetUniformARB(programObj, location, params); + } + /** + * @param programObj + * @param name + * @return + */ + public int glGetUniformLocationARB(int programObj, ByteBuffer name) { + return GL.glGetUniformLocationARB(programObj, name); + } + /** + * @param id + * @param value + * @param pbData + */ + public void glGetVariantBooleanEXT(int id, int value, + ByteBuffer pbData) { + GL.glGetVariantBooleanEXT(id, value, pbData); + } + /** + * @param id + * @param value + * @param pfData + */ + public void glGetVariantFloatEXT(int id, int value, + FloatBuffer pfData) { + GL.glGetVariantFloatEXT(id, value, pfData); + } + /** + * @param id + * @param value + * @param piData + */ + public void glGetVariantIntegerEXT(int id, int value, + IntBuffer piData) { + GL.glGetVariantIntegerEXT(id, value, piData); + } + /** + * @param id + * @param value + * @param size + * @return + */ + public ByteBuffer glGetVariantPointerEXT(int id, int value, int size) { + return GL.glGetVariantPointerEXT(id, value, size); + } + /** + * @param index + * @param pname + * @param params + */ + public void glGetVertexAttribARB(int index, int pname, + FloatBuffer params) { + GL.glGetVertexAttribARB(index, pname, params); + } + /** + * @param index + * @param pname + * @param params + */ + public void glGetVertexAttribARB(int index, int pname, + IntBuffer params) { + GL.glGetVertexAttribARB(index, pname, params); + } + /** + * @param index + * @param pname + * @param size + * @return + */ + public ByteBuffer glGetVertexAttribPointerARB(int index, int pname, + int size) { + return GL.glGetVertexAttribPointerARB(index, pname, size); + } + /** + * @param target + * @param mode + */ + public void glHint(int target, int mode) { + GL.glHint(target, mode); + } + /** + * @param target + * @param width + * @param internalformat + * @param sink + */ + public void glHistogram(int target, int width, int internalformat, + boolean sink) { + GL.glHistogram(target, width, internalformat, sink); + } + /** + * + */ + public void glInitNames() { + GL.glInitNames(); + } + /** + * @param res + * @param src + * @param num + */ + public void glInsertComponentEXT(int res, int src, int num) { + GL.glInsertComponentEXT(res, src, num); + } + /** + * @param format + * @param stride + * @param pointer + */ + public void glInterleavedArrays(int format, int stride, + ByteBuffer pointer) { + GL.glInterleavedArrays(format, stride, pointer); + } + /** + * @param format + * @param stride + * @param pointer + */ + public void glInterleavedArrays(int format, int stride, + FloatBuffer pointer) { + GL.glInterleavedArrays(format, stride, pointer); + } + /** + * @param format + * @param stride + * @param buffer_offset + */ + public void glInterleavedArrays(int format, int stride, + int buffer_offset) { + GL.glInterleavedArrays(format, stride, buffer_offset); + } + /** + * @param format + * @param stride + * @param pointer + */ + public void glInterleavedArrays(int format, int stride, + IntBuffer pointer) { + GL.glInterleavedArrays(format, stride, pointer); + } + /** + * @param format + * @param stride + * @param pointer + */ + public void glInterleavedArrays(int format, int stride, + ShortBuffer pointer) { + GL.glInterleavedArrays(format, stride, pointer); + } + /** + * @param buffer + * @return + */ + public boolean glIsBuffer(int buffer) { + return GL.glIsBuffer(buffer); + } + /** + * @param buffer + * @return + */ + public boolean glIsBufferARB(int buffer) { + return GL.glIsBufferARB(buffer); + } + /** + * @param cap + * @return + */ + public boolean glIsEnabled(int cap) { + return GL.glIsEnabled(cap); + } + /** + * @param list + * @return + */ + public boolean glIsList(int list) { + return GL.glIsList(list); + } + /** + * @param program + * @return + */ + public boolean glIsProgramARB(int program) { + return GL.glIsProgramARB(program); + } + /** + * @param id + * @return + */ + public boolean glIsQuery(int id) { + return GL.glIsQuery(id); + } + /** + * @param id + * @return + */ + public boolean glIsQueryARB(int id) { + return GL.glIsQueryARB(id); + } + /** + * @param texture + * @return + */ + public boolean glIsTexture(int texture) { + return GL.glIsTexture(texture); + } + /** + * @param id + * @param cap + * @return + */ + public boolean glIsVariantEnabledEXT(int id, int cap) { + return GL.glIsVariantEnabledEXT(id, cap); + } + /** + * @param light + * @param pname + * @param params + */ + public void glLight(int light, int pname, FloatBuffer params) { + GL.glLight(light, pname, params); + } + /** + * @param light + * @param pname + * @param params + */ + public void glLight(int light, int pname, IntBuffer params) { + GL.glLight(light, pname, params); + } + /** + * @param light + * @param pname + * @param param + */ + public void glLightf(int light, int pname, float param) { + GL.glLightf(light, pname, param); + } + /** + * @param light + * @param pname + * @param param + */ + public void glLighti(int light, int pname, int param) { + GL.glLighti(light, pname, param); + } + /** + * @param pname + * @param params + */ + public void glLightModel(int pname, FloatBuffer params) { + GL.glLightModel(pname, params); + } + /** + * @param pname + * @param params + */ + public void glLightModel(int pname, IntBuffer params) { + GL.glLightModel(pname, params); + } + /** + * @param pname + * @param param + */ + public void glLightModelf(int pname, float param) { + GL.glLightModelf(pname, param); + } + /** + * @param pname + * @param param + */ + public void glLightModeli(int pname, int param) { + GL.glLightModeli(pname, param); + } + /** + * @param factor + * @param pattern + */ + public void glLineStipple(int factor, short pattern) { + GL.glLineStipple(factor, pattern); + } + /** + * @param width + */ + public void glLineWidth(float width) { + GL.glLineWidth(width); + } + /** + * @param programObj + */ + public void glLinkProgramARB(int programObj) { + GL.glLinkProgramARB(programObj); + } + /** + * @param base + */ + public void glListBase(int base) { + GL.glListBase(base); + } + /** + * + */ + public void glLoadIdentity() { + GL.glLoadIdentity(); + } + /** + * @param m + */ + public void glLoadMatrix(FloatBuffer m) { + GL.glLoadMatrix(m); + } + /** + * @param name + */ + public void glLoadName(int name) { + GL.glLoadName(name); + } + /** + * @param m + */ + public void glLoadTransposeMatrix(FloatBuffer m) { + GL.glLoadTransposeMatrix(m); + } + /** + * @param pfMtx + */ + public void glLoadTransposeMatrixARB(FloatBuffer pfMtx) { + GL.glLoadTransposeMatrixARB(pfMtx); + } + /** + * @param first + * @param count + */ + public void glLockArraysEXT(int first, int count) { + GL.glLockArraysEXT(first, count); + } + /** + * @param opcode + */ + public void glLogicOp(int opcode) { + GL.glLogicOp(opcode); + } + /** + * @param target + * @param u1 + * @param u2 + * @param stride + * @param order + * @param points + */ + public void glMap1f(int target, float u1, float u2, int stride, + int order, FloatBuffer points) { + GL.glMap1f(target, u1, u2, stride, order, points); + } + /** + * @param target + * @param u1 + * @param u2 + * @param ustride + * @param uorder + * @param v1 + * @param v2 + * @param vstride + * @param vorder + * @param points + */ + public void glMap2f(int target, float u1, float u2, int ustride, + int uorder, float v1, float v2, int vstride, int vorder, + FloatBuffer points) { + GL.glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, + points); + } + /** + * @param target + * @param access + * @param size + * @param oldBuffer + * @return + */ + public ByteBuffer glMapBuffer(int target, int access, int size, + ByteBuffer oldBuffer) { + return GL.glMapBuffer(target, access, size, oldBuffer); + } + /** + * @param target + * @param access + * @param size + * @param oldBuffer + * @return + */ + public ByteBuffer glMapBufferARB(int target, int access, int size, + ByteBuffer oldBuffer) { + return GL.glMapBufferARB(target, access, size, oldBuffer); + } + /** + * @param un + * @param u1 + * @param u2 + */ + public void glMapGrid1f(int un, float u1, float u2) { + GL.glMapGrid1f(un, u1, u2); + } + /** + * @param un + * @param u1 + * @param u2 + * @param vn + * @param v1 + * @param v2 + */ + public void glMapGrid2f(int un, float u1, float u2, int vn, + float v1, float v2) { + GL.glMapGrid2f(un, u1, u2, vn, v1, v2); + } + /** + * @param face + * @param pname + * @param params + */ + public void glMaterial(int face, int pname, FloatBuffer params) { + GL.glMaterial(face, pname, params); + } + /** + * @param face + * @param pname + * @param params + */ + public void glMaterial(int face, int pname, IntBuffer params) { + GL.glMaterial(face, pname, params); + } + /** + * @param face + * @param pname + * @param param + */ + public void glMaterialf(int face, int pname, float param) { + GL.glMaterialf(face, pname, param); + } + /** + * @param face + * @param pname + * @param param + */ + public void glMateriali(int face, int pname, int param) { + GL.glMateriali(face, pname, param); + } + /** + * @param size + * @param stride + * @param pPointer + */ + public void glMatrixIndexPointerARB(int size, int stride, + ByteBuffer pPointer) { + GL.glMatrixIndexPointerARB(size, stride, pPointer); + } + /** + * @param size + * @param type + * @param stride + * @param buffer_offset + */ + public void glMatrixIndexPointerARB(int size, int type, int stride, + int buffer_offset) { + GL.glMatrixIndexPointerARB(size, type, stride, buffer_offset); + } + /** + * @param size + * @param stride + * @param pPointer + */ + public void glMatrixIndexPointerARB(int size, int stride, + IntBuffer pPointer) { + GL.glMatrixIndexPointerARB(size, stride, pPointer); + } + /** + * @param size + * @param stride + * @param pPointer + */ + public void glMatrixIndexPointerARB(int size, int stride, + ShortBuffer pPointer) { + GL.glMatrixIndexPointerARB(size, stride, pPointer); + } + /** + * @param pIndices + */ + public void glMatrixIndexuARB(ByteBuffer pIndices) { + GL.glMatrixIndexuARB(pIndices); + } + /** + * @param piIndices + */ + public void glMatrixIndexuARB(IntBuffer piIndices) { + GL.glMatrixIndexuARB(piIndices); + } + /** + * @param psIndices + */ + public void glMatrixIndexuARB(ShortBuffer psIndices) { + GL.glMatrixIndexuARB(psIndices); + } + /** + * @param mode + */ + public void glMatrixMode(int mode) { + GL.glMatrixMode(mode); + } + /** + * @param target + * @param internalformat + * @param sink + */ + public void glMinmax(int target, int internalformat, boolean sink) { + GL.glMinmax(target, internalformat, sink); + } + /** + * @param mode + * @param piFirst + * @param piCount + */ + public void glMultiDrawArrays(int mode, IntBuffer piFirst, + IntBuffer piCount) { + GL.glMultiDrawArrays(mode, piFirst, piCount); + } + /** + * @param mode + * @param piFirst + * @param piCount + */ + public void glMultiDrawArraysEXT(int mode, IntBuffer piFirst, + IntBuffer piCount) { + GL.glMultiDrawArraysEXT(mode, piFirst, piCount); + } + /** + * @param target + * @param s + */ + public void glMultiTexCoord1f(int target, float s) { + GL.glMultiTexCoord1f(target, s); + } + /** + * @param target + * @param s + */ + public void glMultiTexCoord1fARB(int target, float s) { + GL.glMultiTexCoord1fARB(target, s); + } + /** + * @param target + * @param s + */ + public void glMultiTexCoord1iARB(int target, int s) { + GL.glMultiTexCoord1iARB(target, s); + } + /** + * @param target + * @param s + */ + public void glMultiTexCoord1sARB(int target, short s) { + GL.glMultiTexCoord1sARB(target, s); + } + /** + * @param target + * @param s + * @param t + */ + public void glMultiTexCoord2f(int target, float s, float t) { + GL.glMultiTexCoord2f(target, s, t); + } + /** + * @param target + * @param s + * @param t + */ + public void glMultiTexCoord2fARB(int target, float s, float t) { + GL.glMultiTexCoord2fARB(target, s, t); + } + /** + * @param target + * @param s + * @param t + */ + public void glMultiTexCoord2iARB(int target, int s, int t) { + GL.glMultiTexCoord2iARB(target, s, t); + } + /** + * @param target + * @param s + * @param t + */ + public void glMultiTexCoord2sARB(int target, short s, short t) { + GL.glMultiTexCoord2sARB(target, s, t); + } + /** + * @param target + * @param s + * @param t + * @param r + */ + public void glMultiTexCoord3f(int target, float s, float t, float r) { + GL.glMultiTexCoord3f(target, s, t, r); + } + /** + * @param target + * @param s + * @param t + * @param r + */ + public void glMultiTexCoord3fARB(int target, float s, float t, + float r) { + GL.glMultiTexCoord3fARB(target, s, t, r); + } + /** + * @param target + * @param s + * @param t + * @param r + */ + public void glMultiTexCoord3iARB(int target, int s, int t, int r) { + GL.glMultiTexCoord3iARB(target, s, t, r); + } + /** + * @param target + * @param s + * @param t + * @param r + */ + public void glMultiTexCoord3sARB(int target, short s, short t, + short r) { + GL.glMultiTexCoord3sARB(target, s, t, r); + } + /** + * @param target + * @param s + * @param t + * @param r + * @param q + */ + public void glMultiTexCoord4f(int target, float s, float t, float r, + float q) { + GL.glMultiTexCoord4f(target, s, t, r, q); + } + /** + * @param target + * @param s + * @param t + * @param r + * @param q + */ + public void glMultiTexCoord4fARB(int target, float s, float t, + float r, float q) { + GL.glMultiTexCoord4fARB(target, s, t, r, q); + } + /** + * @param target + * @param s + * @param t + * @param r + * @param q + */ + public void glMultiTexCoord4iARB(int target, int s, int t, int r, + int q) { + GL.glMultiTexCoord4iARB(target, s, t, r, q); + } + /** + * @param target + * @param s + * @param t + * @param r + * @param q + */ + public void glMultiTexCoord4sARB(int target, short s, short t, + short r, short q) { + GL.glMultiTexCoord4sARB(target, s, t, r, q); + } + /** + * @param m + */ + public void glMultMatrix(FloatBuffer m) { + GL.glMultMatrix(m); + } + /** + * @param m + */ + public void glMultTransposeMatrix(FloatBuffer m) { + GL.glMultTransposeMatrix(m); + } + /** + * @param pfMtx + */ + public void glMultTransposeMatrixfARB(FloatBuffer pfMtx) { + GL.glMultTransposeMatrixfARB(pfMtx); + } + /** + * @param list + * @param mode + */ + public void glNewList(int list, int mode) { + GL.glNewList(list, mode); + } + /** + * @param nx + * @param ny + * @param nz + */ + public void glNormal3b(byte nx, byte ny, byte nz) { + GL.glNormal3b(nx, ny, nz); + } + /** + * @param nx + * @param ny + * @param nz + */ + public void glNormal3f(float nx, float ny, float nz) { + GL.glNormal3f(nx, ny, nz); + } + /** + * @param nx + * @param ny + * @param nz + */ + public void glNormal3i(int nx, int ny, int nz) { + GL.glNormal3i(nx, ny, nz); + } + /** + * @param stride + * @param pointer + */ + public void glNormalPointer(int stride, ByteBuffer pointer) { + GL.glNormalPointer(stride, pointer); + } + /** + * @param stride + * @param pointer + */ + public void glNormalPointer(int stride, FloatBuffer pointer) { + GL.glNormalPointer(stride, pointer); + } + /** + * @param type + * @param stride + * @param buffer_offset + */ + public void glNormalPointer(int type, int stride, int buffer_offset) { + GL.glNormalPointer(type, stride, buffer_offset); + } + /** + * @param stride + * @param pointer + */ + public void glNormalPointer(int stride, IntBuffer pointer) { + GL.glNormalPointer(stride, pointer); + } + /** + * @param left + * @param right + * @param bottom + * @param top + * @param zNear + * @param zFar + */ + public void glOrtho(double left, double right, double bottom, + double top, double zNear, double zFar) { + GL.glOrtho(left, right, bottom, top, zNear, zFar); + } + /** + * @param token + */ + public void glPassThrough(float token) { + GL.glPassThrough(token); + } + /** + * @param map + * @param values + */ + public void glPixelMap(int map, FloatBuffer values) { + GL.glPixelMap(map, values); + } + /** + * @param map + * @param values + */ + public void glPixelMap(int map, IntBuffer values) { + GL.glPixelMap(map, values); + } + /** + * @param map + * @param values + */ + public void glPixelMap(int map, ShortBuffer values) { + GL.glPixelMap(map, values); + } + /** + * @param pname + * @param param + */ + public void glPixelStoref(int pname, float param) { + GL.glPixelStoref(pname, param); + } + /** + * @param pname + * @param param + */ + public void glPixelStorei(int pname, int param) { + GL.glPixelStorei(pname, param); + } + /** + * @param pname + * @param param + */ + public void glPixelTransferf(int pname, float param) { + GL.glPixelTransferf(pname, param); + } + /** + * @param pname + * @param param + */ + public void glPixelTransferi(int pname, int param) { + GL.glPixelTransferi(pname, param); + } + /** + * @param xfactor + * @param yfactor + */ + public void glPixelZoom(float xfactor, float yfactor) { + GL.glPixelZoom(xfactor, yfactor); + } + /** + * @param pname + * @param params + */ + public void glPointParameter(int pname, FloatBuffer params) { + GL.glPointParameter(pname, params); + } + /** + * @param pname + * @param pfParams + */ + public void glPointParameterARB(int pname, FloatBuffer pfParams) { + GL.glPointParameterARB(pname, pfParams); + } + /** + * @param pname + * @param pfParams + */ + public void glPointParameterEXT(int pname, FloatBuffer pfParams) { + GL.glPointParameterEXT(pname, pfParams); + } + /** + * @param pname + * @param param + */ + public void glPointParameterf(int pname, float param) { + GL.glPointParameterf(pname, param); + } + /** + * @param pname + * @param param + */ + public void glPointParameterfARB(int pname, float param) { + GL.glPointParameterfARB(pname, param); + } + /** + * @param pname + * @param param + */ + public void glPointParameterfEXT(int pname, float param) { + GL.glPointParameterfEXT(pname, param); + } + /** + * @param size + */ + public void glPointSize(float size) { + GL.glPointSize(size); + } + /** + * @param face + * @param mode + */ + public void glPolygonMode(int face, int mode) { + GL.glPolygonMode(face, mode); + } + /** + * @param factor + * @param units + */ + public void glPolygonOffset(float factor, float units) { + GL.glPolygonOffset(factor, units); + } + /** + * @param mask + */ + public void glPolygonStipple(ByteBuffer mask) { + GL.glPolygonStipple(mask); + } + /** + * + */ + public void glPopAttrib() { + GL.glPopAttrib(); + } + /** + * + */ + public void glPopClientAttrib() { + GL.glPopClientAttrib(); + } + /** + * + */ + public void glPopMatrix() { + GL.glPopMatrix(); + } + /** + * + */ + public void glPopName() { + GL.glPopName(); + } + /** + * @param target + * @param index + * @param x + * @param y + * @param z + * @param w + */ + public void glProgramEnvParameter4fARB(int target, int index, + float x, float y, float z, float w) { + GL.glProgramEnvParameter4fARB(target, index, x, y, z, w); + } + /** + * @param target + * @param index + * @param params + */ + public void glProgramEnvParameterARB(int target, int index, + FloatBuffer params) { + GL.glProgramEnvParameterARB(target, index, params); + } + /** + * @param target + * @param index + * @param x + * @param y + * @param z + * @param w + */ + public void glProgramLocalParameter4fARB(int target, int index, + float x, float y, float z, float w) { + GL.glProgramLocalParameter4fARB(target, index, x, y, z, w); + } + /** + * @param target + * @param index + * @param params + */ + public void glProgramLocalParameterARB(int target, int index, + FloatBuffer params) { + GL.glProgramLocalParameterARB(target, index, params); + } + /** + * @param target + * @param format + * @param string + */ + public void glProgramStringARB(int target, int format, + ByteBuffer string) { + GL.glProgramStringARB(target, format, string); + } + /** + * @param mask + */ + public void glPushAttrib(int mask) { + GL.glPushAttrib(mask); + } + /** + * @param mask + */ + public void glPushClientAttrib(int mask) { + GL.glPushClientAttrib(mask); + } + /** + * + */ + public void glPushMatrix() { + GL.glPushMatrix(); + } + /** + * @param name + */ + public void glPushName(int name) { + GL.glPushName(name); + } + /** + * @param x + * @param y + */ + public void glRasterPos2f(float x, float y) { + GL.glRasterPos2f(x, y); + } + /** + * @param x + * @param y + */ + public void glRasterPos2i(int x, int y) { + GL.glRasterPos2i(x, y); + } + /** + * @param x + * @param y + * @param z + */ + public void glRasterPos3f(float x, float y, float z) { + GL.glRasterPos3f(x, y, z); + } + /** + * @param x + * @param y + * @param z + */ + public void glRasterPos3i(int x, int y, int z) { + GL.glRasterPos3i(x, y, z); + } + /** + * @param x + * @param y + * @param z + * @param w + */ + public void glRasterPos4f(float x, float y, float z, float w) { + GL.glRasterPos4f(x, y, z, w); + } + /** + * @param x + * @param y + * @param z + * @param w + */ + public void glRasterPos4i(int x, int y, int z, int w) { + GL.glRasterPos4i(x, y, z, w); + } + /** + * @param mode + */ + public void glReadBuffer(int mode) { + GL.glReadBuffer(mode); + } + /** + * @param x + * @param y + * @param width + * @param height + * @param format + * @param type + * @param pixels + */ + public 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); + } + /** + * @param x + * @param y + * @param width + * @param height + * @param format + * @param type + * @param pixels + */ + public void glReadPixels(int x, int y, int width, int height, + int format, int type, IntBuffer pixels) { + GL.glReadPixels(x, y, width, height, format, type, pixels); + } + /** + * @param x + * @param y + * @param width + * @param height + * @param format + * @param type + * @param pixels + */ + public void glReadPixels(int x, int y, int width, int height, + int format, int type, ShortBuffer pixels) { + GL.glReadPixels(x, y, width, height, format, type, pixels); + } + /** + * @param x1 + * @param y1 + * @param x2 + * @param y2 + */ + public void glRectf(float x1, float y1, float x2, float y2) { + GL.glRectf(x1, y1, x2, y2); + } + /** + * @param x1 + * @param y1 + * @param x2 + * @param y2 + */ + public void glRecti(int x1, int y1, int x2, int y2) { + GL.glRecti(x1, y1, x2, y2); + } + /** + * @param mode + * @return + */ + public int glRenderMode(int mode) { + return GL.glRenderMode(mode); + } + /** + * @param target + */ + public void glResetHistogram(int target) { + GL.glResetHistogram(target); + } + /** + * @param target + */ + public void glResetMinmax(int target) { + GL.glResetMinmax(target); + } + /** + * @param angle + * @param x + * @param y + * @param z + */ + public void glRotatef(float angle, float x, float y, float z) { + GL.glRotatef(angle, x, y, z); + } + /** + * @param value + * @param invert + */ + public void glSampleCoverage(float value, boolean invert) { + GL.glSampleCoverage(value, invert); + } + /** + * @param value + * @param invert + */ + public void glSampleCoverageARB(float value, boolean invert) { + GL.glSampleCoverageARB(value, invert); + } + /** + * @param x + * @param y + * @param z + */ + public void glScalef(float x, float y, float z) { + GL.glScalef(x, y, z); + } + /** + * @param x + * @param y + * @param width + * @param height + */ + public void glScissor(int x, int y, int width, int height) { + GL.glScissor(x, y, width, height); + } + /** + * @param red + * @param green + * @param blue + */ + public void glSecondaryColor3b(byte red, byte green, byte blue) { + GL.glSecondaryColor3b(red, green, blue); + } + /** + * @param red + * @param green + * @param blue + */ + public void glSecondaryColor3bEXT(byte red, byte green, byte blue) { + GL.glSecondaryColor3bEXT(red, green, blue); + } + /** + * @param red + * @param green + * @param blue + */ + public void glSecondaryColor3f(float red, float green, float blue) { + GL.glSecondaryColor3f(red, green, blue); + } + /** + * @param red + * @param green + * @param blue + */ + public void glSecondaryColor3fEXT(float red, float green, float blue) { + GL.glSecondaryColor3fEXT(red, green, blue); + } + /** + * @param red + * @param green + * @param blue + */ + public void glSecondaryColor3ub(byte red, byte green, byte blue) { + GL.glSecondaryColor3ub(red, green, blue); + } + /** + * @param red + * @param green + * @param blue + */ + public void glSecondaryColor3ubEXT(byte red, byte green, byte blue) { + GL.glSecondaryColor3ubEXT(red, green, blue); + } + /** + * @param size + * @param unsigned + * @param stride + * @param data + */ + public void glSecondaryColorPointer(int size, boolean unsigned, + int stride, ByteBuffer data) { + GL.glSecondaryColorPointer(size, unsigned, stride, data); + } + /** + * @param size + * @param stride + * @param data + */ + public void glSecondaryColorPointer(int size, int stride, + FloatBuffer data) { + GL.glSecondaryColorPointer(size, stride, data); + } + /** + * @param size + * @param type + * @param stride + * @param buffer_offset + */ + public void glSecondaryColorPointer(int size, int type, int stride, + int buffer_offset) { + GL.glSecondaryColorPointer(size, type, stride, buffer_offset); + } + /** + * @param size + * @param unsigned + * @param stride + * @param pPointer + */ + public void glSecondaryColorPointerEXT(int size, boolean unsigned, + int stride, ByteBuffer pPointer) { + GL.glSecondaryColorPointerEXT(size, unsigned, stride, pPointer); + } + /** + * @param size + * @param stride + * @param pPointer + */ + public void glSecondaryColorPointerEXT(int size, int stride, + FloatBuffer pPointer) { + GL.glSecondaryColorPointerEXT(size, stride, pPointer); + } + /** + * @param size + * @param type + * @param stride + * @param buffer_offset + */ + public void glSecondaryColorPointerEXT(int size, int type, + int stride, int buffer_offset) { + GL.glSecondaryColorPointerEXT(size, type, stride, buffer_offset); + } + /** + * @param buffer + */ + public void glSelectBuffer(IntBuffer buffer) { + GL.glSelectBuffer(buffer); + } + /** + * @param target + * @param internalformat + * @param width + * @param height + * @param format + * @param type + * @param row + * @param column + */ + public void glSeparableFilter2D(int target, int internalformat, + int width, int height, int format, int type, Buffer row, + Buffer column) { + GL.glSeparableFilter2D(target, internalformat, width, height, format, + type, row, column); + } + /** + * @param id + * @param unsigned + * @param pAddr + */ + public void glSetInvariantEXT(int id, boolean unsigned, + ByteBuffer pAddr) { + GL.glSetInvariantEXT(id, unsigned, pAddr); + } + /** + * @param id + * @param unsigned + * @param pAddr + */ + public void glSetInvariantEXT(int id, boolean unsigned, + IntBuffer pAddr) { + GL.glSetInvariantEXT(id, unsigned, pAddr); + } + /** + * @param id + * @param unsigned + * @param pAddr + */ + public void glSetInvariantEXT(int id, boolean unsigned, + ShortBuffer pAddr) { + GL.glSetInvariantEXT(id, unsigned, pAddr); + } + /** + * @param id + * @param pAddr + */ + public void glSetInvariantEXT(int id, FloatBuffer pAddr) { + GL.glSetInvariantEXT(id, pAddr); + } + /** + * @param id + * @param unsigned + * @param pAddr + */ + public void glSetLocalConstantEXT(int id, boolean unsigned, + ByteBuffer pAddr) { + GL.glSetLocalConstantEXT(id, unsigned, pAddr); + } + /** + * @param id + * @param unsigned + * @param pAddr + */ + public void glSetLocalConstantEXT(int id, boolean unsigned, + IntBuffer pAddr) { + GL.glSetLocalConstantEXT(id, unsigned, pAddr); + } + /** + * @param id + * @param unsigned + * @param pAddr + */ + public void glSetLocalConstantEXT(int id, boolean unsigned, + ShortBuffer pAddr) { + GL.glSetLocalConstantEXT(id, unsigned, pAddr); + } + /** + * @param id + * @param pAddr + */ + public void glSetLocalConstantEXT(int id, FloatBuffer pAddr) { + GL.glSetLocalConstantEXT(id, pAddr); + } + /** + * @param mode + */ + public void glShadeModel(int mode) { + GL.glShadeModel(mode); + } + /** + * @param op + * @param res + * @param arg1 + */ + public void glShaderOp1EXT(int op, int res, int arg1) { + GL.glShaderOp1EXT(op, res, arg1); + } + /** + * @param op + * @param res + * @param arg1 + * @param arg2 + */ + public void glShaderOp2EXT(int op, int res, int arg1, int arg2) { + GL.glShaderOp2EXT(op, res, arg1, arg2); + } + /** + * @param op + * @param res + * @param arg1 + * @param arg2 + * @param arg3 + */ + public void glShaderOp3EXT(int op, int res, int arg1, int arg2, + int arg3) { + GL.glShaderOp3EXT(op, res, arg1, arg2, arg3); + } + /** + * @param shaderObj + * @param string + */ + public void glShaderSourceARB(int shaderObj, ByteBuffer string) { + GL.glShaderSourceARB(shaderObj, string); + } + /** + * @param shaderObj + * @param strings + */ + public void glShaderSourceARB(int shaderObj, ByteBuffer[] strings) { + GL.glShaderSourceARB(shaderObj, strings); + } + /** + * @param func + * @param ref + * @param mask + */ + public void glStencilFunc(int func, int ref, int mask) { + GL.glStencilFunc(func, ref, mask); + } + /** + * @param mask + */ + public void glStencilMask(int mask) { + GL.glStencilMask(mask); + } + /** + * @param fail + * @param zfail + * @param zpass + */ + public void glStencilOp(int fail, int zfail, int zpass) { + GL.glStencilOp(fail, zfail, zpass); + } + /** + * @param res + * @param in + * @param outX + * @param outY + * @param outZ + * @param outW + */ + public void glSwizzleEXT(int res, int in, int outX, int outY, + int outZ, int outW) { + GL.glSwizzleEXT(res, in, outX, outY, outZ, outW); + } + /** + * @param s + */ + public void glTexCoord1f(float s) { + GL.glTexCoord1f(s); + } + /** + * @param s + * @param t + */ + public void glTexCoord2f(float s, float t) { + GL.glTexCoord2f(s, t); + } + /** + * @param s + * @param t + * @param r + */ + public void glTexCoord3f(float s, float t, float r) { + GL.glTexCoord3f(s, t, r); + } + /** + * @param s + * @param t + * @param r + * @param q + */ + public void glTexCoord4f(float s, float t, float r, float q) { + GL.glTexCoord4f(s, t, r, q); + } + /** + * @param size + * @param stride + * @param pointer + */ + public void glTexCoordPointer(int size, int stride, + FloatBuffer pointer) { + GL.glTexCoordPointer(size, stride, pointer); + } + /** + * @param size + * @param type + * @param stride + * @param buffer_offset + */ + public void glTexCoordPointer(int size, int type, int stride, + int buffer_offset) { + GL.glTexCoordPointer(size, type, stride, buffer_offset); + } + /** + * @param target + * @param pname + * @param params + */ + public void glTexEnv(int target, int pname, FloatBuffer params) { + GL.glTexEnv(target, pname, params); + } + /** + * @param target + * @param pname + * @param params + */ + public void glTexEnv(int target, int pname, IntBuffer params) { + GL.glTexEnv(target, pname, params); + } + /** + * @param target + * @param pname + * @param param + */ + public void glTexEnvf(int target, int pname, float param) { + GL.glTexEnvf(target, pname, param); + } + /** + * @param target + * @param pname + * @param param + */ + public void glTexEnvi(int target, int pname, int param) { + GL.glTexEnvi(target, pname, param); + } + /** + * @param coord + * @param pname + * @param params + */ + public void glTexGen(int coord, int pname, FloatBuffer params) { + GL.glTexGen(coord, pname, params); + } + /** + * @param coord + * @param pname + * @param params + */ + public void glTexGen(int coord, int pname, IntBuffer params) { + GL.glTexGen(coord, pname, params); + } + /** + * @param coord + * @param pname + * @param param + */ + public void glTexGenf(int coord, int pname, float param) { + GL.glTexGenf(coord, pname, param); + } + /** + * @param coord + * @param pname + * @param param + */ + public void glTexGeni(int coord, int pname, int param) { + GL.glTexGeni(coord, pname, param); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param format + * @param type + * @param pixels + */ + public void glTexImage1D(int target, int level, int internalformat, + int width, int border, int format, int type, ByteBuffer pixels) { + GL.glTexImage1D(target, level, internalformat, width, border, format, + type, pixels); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param format + * @param type + * @param pixels + */ + public void glTexImage1D(int target, int level, int internalformat, + int width, int border, int format, int type, FloatBuffer pixels) { + GL.glTexImage1D(target, level, internalformat, width, border, format, + type, pixels); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param format + * @param type + * @param pixels + */ + public void glTexImage1D(int target, int level, int internalformat, + int width, int border, int format, int type, IntBuffer pixels) { + GL.glTexImage1D(target, level, internalformat, width, border, format, + type, pixels); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param format + * @param type + * @param pixels + */ + public void glTexImage1D(int target, int level, int internalformat, + int width, int border, int format, int type, ShortBuffer pixels) { + GL.glTexImage1D(target, level, internalformat, width, border, format, + type, pixels); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param format + * @param type + * @param pixels + */ + public 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, + format, type, pixels); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param format + * @param type + * @param pixels + */ + public void glTexImage2D(int target, int level, int internalformat, + int width, int height, int border, int format, int type, + FloatBuffer pixels) { + GL.glTexImage2D(target, level, internalformat, width, height, border, + format, type, pixels); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param format + * @param type + * @param pixels + */ + public 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, + format, type, pixels); + } + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param format + * @param type + * @param pixels + */ + public void glTexImage2D(int target, int level, int internalformat, + int width, int height, int border, int format, int type, + ShortBuffer pixels) { + GL.glTexImage2D(target, level, internalformat, width, height, border, + format, type, pixels); + } + /** + * @param target + * @param level + * @param internalFormat + * @param width + * @param height + * @param depth + * @param border + * @param format + * @param type + * @param pixels + */ + public void glTexImage3D(int target, int level, int internalFormat, + int width, int height, int depth, int border, int format, int type, + ByteBuffer pixels) { + GL.glTexImage3D(target, level, internalFormat, width, height, depth, + border, format, type, pixels); + } + /** + * @param target + * @param level + * @param internalFormat + * @param width + * @param height + * @param depth + * @param border + * @param format + * @param type + * @param pixels + */ + public void glTexImage3D(int target, int level, int internalFormat, + int width, int height, int depth, int border, int format, int type, + FloatBuffer pixels) { + GL.glTexImage3D(target, level, internalFormat, width, height, depth, + border, format, type, pixels); + } + /** + * @param target + * @param level + * @param internalFormat + * @param width + * @param height + * @param depth + * @param border + * @param format + * @param type + * @param pixels + */ + public void glTexImage3D(int target, int level, int internalFormat, + int width, int height, int depth, int border, int format, int type, + IntBuffer pixels) { + GL.glTexImage3D(target, level, internalFormat, width, height, depth, + border, format, type, pixels); + } + /** + * @param target + * @param level + * @param internalFormat + * @param width + * @param height + * @param depth + * @param border + * @param format + * @param type + * @param pixels + */ + public void glTexImage3D(int target, int level, int internalFormat, + int width, int height, int depth, int border, int format, int type, + ShortBuffer pixels) { + GL.glTexImage3D(target, level, internalFormat, width, height, depth, + border, format, type, pixels); + } + /** + * @param target + * @param pname + * @param param + */ + public void glTexParameter(int target, int pname, FloatBuffer param) { + GL.glTexParameter(target, pname, param); + } + /** + * @param target + * @param pname + * @param param + */ + public void glTexParameter(int target, int pname, IntBuffer param) { + GL.glTexParameter(target, pname, param); + } + /** + * @param target + * @param pname + * @param param + */ + public void glTexParameterf(int target, int pname, float param) { + GL.glTexParameterf(target, pname, param); + } + /** + * @param target + * @param pname + * @param param + */ + public void glTexParameteri(int target, int pname, int param) { + GL.glTexParameteri(target, pname, param); + } + /** + * @param target + * @param level + * @param xoffset + * @param width + * @param format + * @param type + * @param pixels + */ + public void glTexSubImage1D(int target, int level, int xoffset, + int width, int format, int type, ByteBuffer pixels) { + GL.glTexSubImage1D(target, level, xoffset, width, format, type, pixels); + } + /** + * @param target + * @param level + * @param xoffset + * @param width + * @param format + * @param type + * @param pixels + */ + public void glTexSubImage1D(int target, int level, int xoffset, + int width, int format, int type, IntBuffer pixels) { + GL.glTexSubImage1D(target, level, xoffset, width, format, type, pixels); + } + /** + * @param target + * @param level + * @param xoffset + * @param width + * @param format + * @param type + * @param pixels + */ + public void glTexSubImage1D(int target, int level, int xoffset, + int width, int format, int type, ShortBuffer pixels) { + GL.glTexSubImage1D(target, level, xoffset, width, format, type, pixels); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param width + * @param height + * @param format + * @param type + * @param pixels + */ + public void glTexSubImage2D(int target, int level, int xoffset, + int yoffset, int width, int height, int format, int type, + ByteBuffer pixels) { + GL.glTexSubImage2D(target, level, xoffset, yoffset, width, height, + format, type, pixels); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param width + * @param height + * @param format + * @param type + * @param pixels + */ + public 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, + format, type, pixels); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param width + * @param height + * @param format + * @param type + * @param pixels + */ + public void glTexSubImage2D(int target, int level, int xoffset, + int yoffset, int width, int height, int format, int type, + ShortBuffer pixels) { + GL.glTexSubImage2D(target, level, xoffset, yoffset, width, height, + format, type, pixels); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param format + * @param type + * @param pixels + */ + public void glTexSubImage3D(int target, int level, int xoffset, + int yoffset, int zoffset, int width, int height, int depth, + int format, int type, ByteBuffer pixels) { + GL.glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, + height, depth, format, type, pixels); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param format + * @param type + * @param pixels + */ + public void glTexSubImage3D(int target, int level, int xoffset, + int yoffset, int zoffset, int width, int height, int depth, + int format, int type, FloatBuffer pixels) { + GL.glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, + height, depth, format, type, pixels); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param format + * @param type + * @param pixels + */ + public void glTexSubImage3D(int target, int level, int xoffset, + int yoffset, int zoffset, int width, int height, int depth, + int format, int type, IntBuffer pixels) { + GL.glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, + height, depth, format, type, pixels); + } + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param format + * @param type + * @param pixels + */ + public void glTexSubImage3D(int target, int level, int xoffset, + int yoffset, int zoffset, int width, int height, int depth, + int format, int type, ShortBuffer pixels) { + GL.glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, + height, depth, format, type, pixels); + } + /** + * @param x + * @param y + * @param z + */ + public void glTranslatef(float x, float y, float z) { + GL.glTranslatef(x, y, z); + } + /** + * @param location + * @param values + */ + public void glUniform1ARB(int location, FloatBuffer values) { + GL.glUniform1ARB(location, values); + } + /** + * @param location + * @param values + */ + public void glUniform1ARB(int location, IntBuffer values) { + GL.glUniform1ARB(location, values); + } + /** + * @param location + * @param v0 + */ + public void glUniform1fARB(int location, float v0) { + GL.glUniform1fARB(location, v0); + } + /** + * @param location + * @param v0 + */ + public void glUniform1iARB(int location, int v0) { + GL.glUniform1iARB(location, v0); + } + /** + * @param location + * @param values + */ + public void glUniform2ARB(int location, FloatBuffer values) { + GL.glUniform2ARB(location, values); + } + /** + * @param location + * @param values + */ + public void glUniform2ARB(int location, IntBuffer values) { + GL.glUniform2ARB(location, values); + } + /** + * @param location + * @param v0 + * @param v1 + */ + public void glUniform2fARB(int location, float v0, float v1) { + GL.glUniform2fARB(location, v0, v1); + } + /** + * @param location + * @param v0 + * @param v1 + */ + public void glUniform2iARB(int location, int v0, int v1) { + GL.glUniform2iARB(location, v0, v1); + } + /** + * @param location + * @param values + */ + public void glUniform3ARB(int location, FloatBuffer values) { + GL.glUniform3ARB(location, values); + } + /** + * @param location + * @param values + */ + public void glUniform3ARB(int location, IntBuffer values) { + GL.glUniform3ARB(location, values); + } + /** + * @param location + * @param v0 + * @param v1 + * @param v2 + */ + public void glUniform3fARB(int location, float v0, float v1, float v2) { + GL.glUniform3fARB(location, v0, v1, v2); + } + /** + * @param location + * @param v0 + * @param v1 + * @param v2 + */ + public void glUniform3iARB(int location, int v0, int v1, int v2) { + GL.glUniform3iARB(location, v0, v1, v2); + } + /** + * @param location + * @param values + */ + public void glUniform4ARB(int location, FloatBuffer values) { + GL.glUniform4ARB(location, values); + } + /** + * @param location + * @param values + */ + public void glUniform4ARB(int location, IntBuffer values) { + GL.glUniform4ARB(location, values); + } + /** + * @param location + * @param v0 + * @param v1 + * @param v2 + * @param v3 + */ + public void glUniform4fARB(int location, float v0, float v1, + float v2, float v3) { + GL.glUniform4fARB(location, v0, v1, v2, v3); + } + /** + * @param location + * @param v0 + * @param v1 + * @param v2 + * @param v3 + */ + public void glUniform4iARB(int location, int v0, int v1, int v2, + int v3) { + GL.glUniform4iARB(location, v0, v1, v2, v3); + } + /** + * @param location + * @param transpose + * @param matrices + */ + public void glUniformMatrix2ARB(int location, boolean transpose, + FloatBuffer matrices) { + GL.glUniformMatrix2ARB(location, transpose, matrices); + } + /** + * @param location + * @param transpose + * @param matrices + */ + public void glUniformMatrix3ARB(int location, boolean transpose, + FloatBuffer matrices) { + GL.glUniformMatrix3ARB(location, transpose, matrices); + } + /** + * @param location + * @param transpose + * @param matrices + */ + public void glUniformMatrix4ARB(int location, boolean transpose, + FloatBuffer matrices) { + GL.glUniformMatrix4ARB(location, transpose, matrices); + } + /** + * + */ + public void glUnlockArraysEXT() { + GL.glUnlockArraysEXT(); + } + /** + * @param target + * @return + */ + public boolean glUnmapBuffer(int target) { + return GL.glUnmapBuffer(target); + } + /** + * @param target + * @return + */ + public boolean glUnmapBufferARB(int target) { + return GL.glUnmapBufferARB(target); + } + /** + * @param programObj + */ + public void glUseProgramObjectARB(int programObj) { + GL.glUseProgramObjectARB(programObj); + } + /** + * @param programObj + */ + public void glValidateProgramARB(int programObj) { + GL.glValidateProgramARB(programObj); + } + /** + * @param id + * @param pAddr + */ + public void glVariantEXT(int id, ByteBuffer pAddr) { + GL.glVariantEXT(id, pAddr); + } + /** + * @param id + * @param pfAddr + */ + public void glVariantEXT(int id, FloatBuffer pfAddr) { + GL.glVariantEXT(id, pfAddr); + } + /** + * @param id + * @param piAddr + */ + public void glVariantEXT(int id, IntBuffer piAddr) { + GL.glVariantEXT(id, piAddr); + } + /** + * @param id + * @param psAddr + */ + public void glVariantEXT(int id, ShortBuffer psAddr) { + GL.glVariantEXT(id, psAddr); + } + /** + * @param id + * @param unsigned + * @param stride + * @param pAddr + */ + public void glVariantPointerEXT(int id, boolean unsigned, + int stride, ByteBuffer pAddr) { + GL.glVariantPointerEXT(id, unsigned, stride, pAddr); + } + /** + * @param id + * @param unsigned + * @param stride + * @param pAddr + */ + public void glVariantPointerEXT(int id, boolean unsigned, + int stride, IntBuffer pAddr) { + GL.glVariantPointerEXT(id, unsigned, stride, pAddr); + } + /** + * @param id + * @param unsigned + * @param stride + * @param pAddr + */ + public void glVariantPointerEXT(int id, boolean unsigned, + int stride, ShortBuffer pAddr) { + GL.glVariantPointerEXT(id, unsigned, stride, pAddr); + } + /** + * @param id + * @param stride + * @param pAddr + */ + public void glVariantPointerEXT(int id, int stride, FloatBuffer pAddr) { + GL.glVariantPointerEXT(id, stride, pAddr); + } + /** + * @param id + * @param type + * @param stride + * @param buffer_offset + */ + public void glVariantPointerEXT(int id, int type, int stride, + int buffer_offset) { + GL.glVariantPointerEXT(id, type, stride, buffer_offset); + } + /** + * @param id + * @param pAddr + */ + public void glVariantuEXT(int id, ByteBuffer pAddr) { + GL.glVariantuEXT(id, pAddr); + } + /** + * @param id + * @param piAddr + */ + public void glVariantuEXT(int id, IntBuffer piAddr) { + GL.glVariantuEXT(id, piAddr); + } + /** + * @param id + * @param psAddr + */ + public void glVariantuEXT(int id, ShortBuffer psAddr) { + GL.glVariantuEXT(id, psAddr); + } + /** + * @param x + * @param y + */ + public void glVertex2f(float x, float y) { + GL.glVertex2f(x, y); + } + /** + * @param x + * @param y + */ + public void glVertex2i(int x, int y) { + GL.glVertex2i(x, y); + } + /** + * @param x + * @param y + * @param z + */ + public void glVertex3f(float x, float y, float z) { + GL.glVertex3f(x, y, z); + } + /** + * @param x + * @param y + * @param z + */ + public void glVertex3i(int x, int y, int z) { + GL.glVertex3i(x, y, z); + } + /** + * @param x + * @param y + * @param z + * @param w + */ + public void glVertex4f(float x, float y, float z, float w) { + GL.glVertex4f(x, y, z, w); + } + /** + * @param x + * @param y + * @param z + * @param w + */ + public void glVertex4i(int x, int y, int z, int w) { + GL.glVertex4i(x, y, z, w); + } + /** + * @param index + * @param x + */ + public void glVertexAttrib1fARB(int index, float x) { + GL.glVertexAttrib1fARB(index, x); + } + /** + * @param index + * @param x + */ + public void glVertexAttrib1sARB(int index, short x) { + GL.glVertexAttrib1sARB(index, x); + } + /** + * @param index + * @param x + * @param y + */ + public void glVertexAttrib2fARB(int index, float x, float y) { + GL.glVertexAttrib2fARB(index, x, y); + } + /** + * @param index + * @param x + * @param y + */ + public void glVertexAttrib2sARB(int index, short x, short y) { + GL.glVertexAttrib2sARB(index, x, y); + } + /** + * @param index + * @param x + * @param y + * @param z + */ + public void glVertexAttrib3fARB(int index, float x, float y, float z) { + GL.glVertexAttrib3fARB(index, x, y, z); + } + /** + * @param index + * @param x + * @param y + * @param z + */ + public void glVertexAttrib3sARB(int index, short x, short y, short z) { + GL.glVertexAttrib3sARB(index, x, y, z); + } + /** + * @param index + * @param x + * @param y + * @param z + * @param w + */ + public void glVertexAttrib4fARB(int index, float x, float y, + float z, float w) { + GL.glVertexAttrib4fARB(index, x, y, z, w); + } + /** + * @param index + * @param x + * @param y + * @param z + * @param w + */ + public void glVertexAttrib4NubARB(int index, byte x, byte y, byte z, + byte w) { + GL.glVertexAttrib4NubARB(index, x, y, z, w); + } + /** + * @param index + * @param x + * @param y + * @param z + * @param w + */ + public void glVertexAttrib4sARB(int index, short x, short y, + short z, short w) { + GL.glVertexAttrib4sARB(index, x, y, z, w); + } + /** + * @param index + * @param size + * @param unsigned + * @param normalized + * @param stride + * @param buffer + */ + public void glVertexAttribPointerARB(int index, int size, + boolean unsigned, boolean normalized, int stride, ByteBuffer buffer) { + GL.glVertexAttribPointerARB(index, size, unsigned, normalized, stride, + buffer); + } + /** + * @param index + * @param size + * @param unsigned + * @param normalized + * @param stride + * @param buffer + */ + public void glVertexAttribPointerARB(int index, int size, + boolean unsigned, boolean normalized, int stride, IntBuffer buffer) { + GL.glVertexAttribPointerARB(index, size, unsigned, normalized, stride, + buffer); + } + /** + * @param index + * @param size + * @param unsigned + * @param normalized + * @param stride + * @param buffer + */ + public void glVertexAttribPointerARB(int index, int size, + boolean unsigned, boolean normalized, int stride, ShortBuffer buffer) { + GL.glVertexAttribPointerARB(index, size, unsigned, normalized, stride, + buffer); + } + /** + * @param index + * @param size + * @param normalized + * @param stride + * @param buffer + */ + public void glVertexAttribPointerARB(int index, int size, + boolean normalized, int stride, FloatBuffer buffer) { + GL.glVertexAttribPointerARB(index, size, normalized, stride, buffer); + } + /** + * @param index + * @param size + * @param type + * @param normalized + * @param stride + * @param bufferOffset + */ + public void glVertexAttribPointerARB(int index, int size, int type, + boolean normalized, int stride, int bufferOffset) { + GL.glVertexAttribPointerARB(index, size, type, normalized, stride, + bufferOffset); + } + /** + * @param count + */ + public void glVertexBlendARB(int count) { + GL.glVertexBlendARB(count); + } + /** + * @param size + * @param stride + * @param pointer + */ + public void glVertexPointer(int size, int stride, FloatBuffer pointer) { + GL.glVertexPointer(size, stride, pointer); + } + /** + * @param size + * @param type + * @param stride + * @param buffer_offset + */ + public void glVertexPointer(int size, int type, int stride, + int buffer_offset) { + GL.glVertexPointer(size, type, stride, buffer_offset); + } + /** + * @param size + * @param stride + * @param pointer + */ + public void glVertexPointer(int size, int stride, IntBuffer pointer) { + GL.glVertexPointer(size, stride, pointer); + } + /** + * @param weight + */ + public void glVertexWeightfEXT(float weight) { + GL.glVertexWeightfEXT(weight); + } + /** + * @param size + * @param stride + * @param pPointer + */ + public void glVertexWeightPointerEXT(int size, int stride, + FloatBuffer pPointer) { + GL.glVertexWeightPointerEXT(size, stride, pPointer); + } + /** + * @param size + * @param type + * @param stride + * @param buffer_offset + */ + public void glVertexWeightPointerEXT(int size, int type, int stride, + int buffer_offset) { + GL.glVertexWeightPointerEXT(size, type, stride, buffer_offset); + } + /** + * @param x + * @param y + * @param width + * @param height + */ + public void glViewport(int x, int y, int width, int height) { + GL.glViewport(x, y, width, height); + } + /** + * @param pWeights + */ + public void glWeightARB(ByteBuffer pWeights) { + GL.glWeightARB(pWeights); + } + /** + * @param pfWeights + */ + public void glWeightARB(FloatBuffer pfWeights) { + GL.glWeightARB(pfWeights); + } + /** + * @param piWeights + */ + public void glWeightARB(IntBuffer piWeights) { + GL.glWeightARB(piWeights); + } + /** + * @param psWeights + */ + public void glWeightARB(ShortBuffer psWeights) { + GL.glWeightARB(psWeights); + } + /** + * @param size + * @param unsigned + * @param stride + * @param pPointer + */ + public void glWeightPointerARB(int size, boolean unsigned, + int stride, ByteBuffer pPointer) { + GL.glWeightPointerARB(size, unsigned, stride, pPointer); + } + /** + * @param size + * @param unsigned + * @param stride + * @param pPointer + */ + public void glWeightPointerARB(int size, boolean unsigned, + int stride, IntBuffer pPointer) { + GL.glWeightPointerARB(size, unsigned, stride, pPointer); + } + /** + * @param size + * @param unsigned + * @param stride + * @param pPointer + */ + public void glWeightPointerARB(int size, boolean unsigned, + int stride, ShortBuffer pPointer) { + GL.glWeightPointerARB(size, unsigned, stride, pPointer); + } + /** + * @param size + * @param stride + * @param pPointer + */ + public void glWeightPointerARB(int size, int stride, + FloatBuffer pPointer) { + GL.glWeightPointerARB(size, stride, pPointer); + } + /** + * @param size + * @param type + * @param stride + * @param buffer_offset + */ + public void glWeightPointerARB(int size, int type, int stride, + int buffer_offset) { + GL.glWeightPointerARB(size, type, stride, buffer_offset); + } + /** + * @param pWeights + */ + public void glWeightuARB(ByteBuffer pWeights) { + GL.glWeightuARB(pWeights); + } + /** + * @param piWeights + */ + public void glWeightuARB(IntBuffer piWeights) { + GL.glWeightuARB(piWeights); + } + /** + * @param psWeights + */ + public void glWeightuARB(ShortBuffer psWeights) { + GL.glWeightuARB(psWeights); + } + /** + * @param x + * @param y + */ + public void glWindowPos2f(float x, float y) { + GL.glWindowPos2f(x, y); + } + /** + * @param x + * @param y + */ + public void glWindowPos2fARB(float x, float y) { + GL.glWindowPos2fARB(x, y); + } + /** + * @param x + * @param y + */ + public void glWindowPos2i(int x, int y) { + GL.glWindowPos2i(x, y); + } + /** + * @param x + * @param y + */ + public void glWindowPos2iARB(int x, int y) { + GL.glWindowPos2iARB(x, y); + } + /** + * @param x + * @param y + */ + public void glWindowPos2sARB(short x, short y) { + GL.glWindowPos2sARB(x, y); + } + /** + * @param x + * @param y + * @param z + */ + public void glWindowPos3f(float x, float y, float z) { + GL.glWindowPos3f(x, y, z); + } + /** + * @param x + * @param y + * @param z + */ + public void glWindowPos3fARB(float x, float y, float z) { + GL.glWindowPos3fARB(x, y, z); + } + /** + * @param x + * @param y + * @param z + */ + public void glWindowPos3i(int x, int y, int z) { + GL.glWindowPos3i(x, y, z); + } + /** + * @param x + * @param y + * @param z + */ + public void glWindowPos3iARB(int x, int y, int z) { + GL.glWindowPos3iARB(x, y, z); + } + /** + * @param x + * @param y + * @param z + */ + public void glWindowPos3sARB(short x, short y, short z) { + GL.glWindowPos3sARB(x, y, z); + } + /** + * @param res + * @param in + * @param outX + * @param outY + * @param outZ + * @param outW + */ + public void glWriteMaskEXT(int res, int in, int outX, int outY, + int outZ, int outW) { + GL.glWriteMaskEXT(res, in, outX, outY, outZ, outW); + } +} diff --git a/src/java/org/lwjgl/util/IGL.java b/src/java/org/lwjgl/util/IGL.java new file mode 100644 index 00000000..95a38f24 --- /dev/null +++ b/src/java/org/lwjgl/util/IGL.java @@ -0,0 +1,5238 @@ +/* + * Copyright (c) 2003 Shaven Puppy Ltd + * 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 'Shaven Puppy' 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; + +import java.nio.Buffer; +import java.nio.ByteBuffer; +import java.nio.DoubleBuffer; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import java.nio.ShortBuffer; + +/** + * $Id$ + * This is an interface describing an Object that can render using + * OpenGL1.1, 1.2, 1.3, 1.4, 1.5, and all the EXT and ARB extensions + * in the LWJGL library. Its main purpose is to stop object-oriented + * zealots annoying us any more. + * @author $Author$ + * @version $Revision$ + */ +public interface IGL { + /** + * @param op + * @param value + */ + public void glAccum(int op, float value); + + /** + * @param func + * @param ref + */ + public void glAlphaFunc(int func, float ref); + + /** + * @param i + */ + public void glArrayElement(int i); + + /** + * @param mode + */ + public void glBegin(int mode); + + /** + * @param target + * @param texture + */ + public void glBindTexture(int target, int texture); + + /** + * @param width + * @param height + * @param xorig + * @param yorig + * @param xmove + * @param ymove + * @param bitmap + */ + public void glBitmap(int width, int height, float xorig, + float yorig, float xmove, float ymove, ByteBuffer bitmap); + + /** + * @param sfactor + * @param dfactor + */ + public void glBlendFunc(int sfactor, int dfactor); + + /** + * @param list + */ + public void glCallList(int list); + + /** + * @param lists + */ + public void glCallLists(ByteBuffer lists); + + /** + * @param n + * @param lists + */ + public void glCallLists(int n, IntBuffer lists); + + /** + * @param lists + */ + public void glCallLists(ShortBuffer lists); + + /** + * @param mask + */ + public void glClear(int mask); + + /** + * @param red + * @param green + * @param blue + * @param alpha + */ + public void glClearAccum(float red, float green, float blue, + float alpha); + + /** + * @param red + * @param green + * @param blue + * @param alpha + */ + public void glClearColor(float red, float green, float blue, + float alpha); + + /** + * @param depth + */ + public void glClearDepth(double depth); + + /** + * @param c + */ + public void glClearIndex(float c); + + /** + * @param s + */ + public void glClearStencil(int s); + + /** + * @param plane + * @param equation + */ + public void glClipPlane(int plane, DoubleBuffer equation); + + /** + * @param red + * @param green + * @param blue + */ + public void glColor3b(byte red, byte green, byte blue); + + /** + * @param red + * @param green + * @param blue + */ + public void glColor3f(float red, float green, float blue); + + /** + * @param red + * @param green + * @param blue + */ + public void glColor3ub(byte red, byte green, byte blue); + + /** + * @param red + * @param green + * @param blue + * @param alpha + */ + public void glColor4b(byte red, byte green, byte blue, byte alpha); + + /** + * @param red + * @param green + * @param blue + * @param alpha + */ + public void glColor4f(float red, float green, float blue, float alpha); + + /** + * @param red + * @param green + * @param blue + * @param alpha + */ + public void glColor4ub(byte red, byte green, byte blue, byte alpha); + + /** + * @param red + * @param green + * @param blue + * @param alpha + */ + public void glColorMask(boolean red, boolean green, boolean blue, + boolean alpha); + + /** + * @param face + * @param mode + */ + public void glColorMaterial(int face, int mode); + + /** + * @param size + * @param unsigned + * @param stride + * @param pointer + */ + public void glColorPointer(int size, boolean unsigned, int stride, + ByteBuffer pointer); + + /** + * @param size + * @param stride + * @param pointer + */ + public void glColorPointer(int size, int stride, FloatBuffer pointer); + + /** + * @param size + * @param type + * @param stride + * @param buffer_offset + */ + public void glColorPointer(int size, int type, int stride, + int buffer_offset); + + /** + * @param x + * @param y + * @param width + * @param height + * @param type + */ + public void glCopyPixels(int x, int y, int width, int height, + int type); + + /** + * @param target + * @param level + * @param internalFormat + * @param x + * @param y + * @param width + * @param border + */ + public void glCopyTexImage1D(int target, int level, + int internalFormat, int x, int y, int width, int border); + + + /** + * @param target + * @param level + * @param internalFormat + * @param x + * @param y + * @param width + * @param height + * @param border + */ + public void glCopyTexImage2D(int target, int level, + int internalFormat, int x, int y, int width, int height, int border); + + + /** + * @param target + * @param level + * @param xoffset + * @param x + * @param y + * @param width + */ + public void glCopyTexSubImage1D(int target, int level, int xoffset, + int x, int y, int width); + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param x + * @param y + * @param width + * @param height + */ + public void glCopyTexSubImage2D(int target, int level, int xoffset, + int yoffset, int x, int y, int width, int height); + + + /** + * @param mode + */ + public void glCullFace(int mode); + + /** + * @param list + * @param range + */ + public void glDeleteLists(int list, int range); + + /** + * @param textures + */ + public void glDeleteTextures(IntBuffer textures); + + /** + * @param func + */ + public void glDepthFunc(int func); + + /** + * @param flag + */ + public void glDepthMask(boolean flag); + + /** + * @param zNear + * @param zFar + */ + public void glDepthRange(double zNear, double zFar); + + /** + * @param cap + */ + public void glDisable(int cap); + + /** + * @param cap + */ + public void glDisableClientState(int cap); + + /** + * @param mode + * @param first + * @param count + */ + public void glDrawArrays(int mode, int first, int count); + + /** + * @param mode + */ + public void glDrawBuffer(int mode); + + /** + * @param mode + * @param indices + */ + public void glDrawElements(int mode, ByteBuffer indices); + + /** + * @param mode + * @param count + * @param type + * @param buffer_offset + */ + public void glDrawElements(int mode, int count, int type, + int buffer_offset); + + /** + * @param mode + * @param indices + */ + public void glDrawElements(int mode, IntBuffer indices); + + /** + * @param mode + * @param indices + */ + public void glDrawElements(int mode, ShortBuffer indices); + + /** + * @param width + * @param height + * @param format + * @param type + * @param pixels + */ + public void glDrawPixels(int width, int height, int format, + int type, ByteBuffer pixels); + + /** + * @param width + * @param height + * @param format + * @param type + * @param pixels + */ + public void glDrawPixels(int width, int height, int format, + int type, IntBuffer pixels); + + /** + * @param width + * @param height + * @param format + * @param type + * @param pixels + */ + public void glDrawPixels(int width, int height, int format, + int type, ShortBuffer pixels); + + /** + * @param flag + */ + public void glEdgeFlag(boolean flag); + + /** + * @param stride + * @param pointer + */ + public void glEdgeFlagPointer(int stride, ByteBuffer pointer); + + /** + * @param stride + * @param buffer_offset + */ + public void glEdgeFlagPointer(int stride, int buffer_offset); + + /** + * @param cap + */ + public void glEnable(int cap); + + /** + * @param cap + */ + public void glEnableClientState(int cap); + + /** + * + */ + public void glEnd(); + + /** + * + */ + public void glEndList(); + + /** + * @param u + */ + public void glEvalCoord1f(float u); + + /** + * @param u + * @param v + */ + public void glEvalCoord2f(float u, float v); + + /** + * @param mode + * @param i1 + * @param i2 + */ + public void glEvalMesh1(int mode, int i1, int i2); + + /** + * @param mode + * @param i1 + * @param i2 + * @param j1 + * @param j2 + */ + public void glEvalMesh2(int mode, int i1, int i2, int j1, int j2); + + /** + * @param i + */ + public void glEvalPoint1(int i); + + /** + * @param i + * @param j + */ + public void glEvalPoint2(int i, int j); + + /** + * @param type + * @param buffer + */ + public void glFeedbackBuffer(int type, FloatBuffer buffer); + + /** + * + */ + public void glFinish(); + + /** + * + */ + public void glFlush(); + + /** + * @param pname + * @param params + */ + public void glFog(int pname, FloatBuffer params); + + /** + * @param pname + * @param params + */ + public void glFog(int pname, IntBuffer params); + + /** + * @param pname + * @param param + */ + public void glFogf(int pname, float param); + + /** + * @param pname + * @param param + */ + public void glFogi(int pname, int param); + + /** + * @param mode + */ + public void glFrontFace(int mode); + + /** + * @param left + * @param right + * @param bottom + * @param top + * @param zNear + * @param zFar + */ + public void glFrustum(double left, double right, double bottom, + double top, double zNear, double zFar); + + /** + * @param range + * @return + */ + public int glGenLists(int range); + + /** + * @param textures + */ + public void glGenTextures(IntBuffer textures); + + /** + * @param pname + * @param params + */ + public void glGetBoolean(int pname, ByteBuffer params); + + /** + * @param plane + * @param equation + */ + public void glGetClipPlane(int plane, DoubleBuffer equation); + + /** + * @param pname + * @param params + */ + public void glGetDouble(int pname, DoubleBuffer params); + + /** + * @return + */ + public int glGetError(); + + /** + * @param pname + * @param params + */ + public void glGetFloat(int pname, FloatBuffer params); + + /** + * @param pname + * @param params + */ + public void glGetInteger(int pname, IntBuffer params); + + /** + * @param light + * @param pname + * @param params + */ + public void glGetLight(int light, int pname, FloatBuffer params); + + /** + * @param light + * @param pname + * @param params + */ + public void glGetLight(int light, int pname, IntBuffer params); + + /** + * @param target + * @param query + * @param v + */ + public void glGetMap(int target, int query, FloatBuffer v); + + /** + * @param target + * @param query + * @param v + */ + public void glGetMap(int target, int query, IntBuffer v); + + /** + * @param face + * @param pname + * @param params + */ + public void glGetMaterial(int face, int pname, FloatBuffer params); + + /** + * @param face + * @param pname + * @param params + */ + public void glGetMaterial(int face, int pname, IntBuffer params); + + /** + * @param map + * @param values + */ + public void glGetPixelMap(int map, FloatBuffer values); + + /** + * @param map + * @param values + */ + public void glGetPixelMap(int map, IntBuffer values); + + /** + * @param map + * @param values + */ + public void glGetPixelMap(int map, ShortBuffer values); + + /** + * @param pname + * @param size + * @return + */ + public ByteBuffer glGetPointerv(int pname, int size); + + /** + * @param mask + */ + public void glGetPolygonStipple(ByteBuffer mask); + + /** + * @param name + * @return + */ + public String glGetString(int name); + + /** + * @param coord + * @param pname + * @param params + */ + public void glGetTexEnv(int coord, int pname, FloatBuffer params); + + /** + * @param coord + * @param pname + * @param params + */ + public void glGetTexEnv(int coord, int pname, IntBuffer params); + + /** + * @param coord + * @param pname + * @param params + */ + public void glGetTexGen(int coord, int pname, FloatBuffer params); + + /** + * @param coord + * @param pname + * @param params + */ + public void glGetTexGen(int coord, int pname, IntBuffer params); + + /** + * @param target + * @param level + * @param format + * @param type + * @param pixels + */ + public void glGetTexImage(int target, int level, int format, + int type, ByteBuffer pixels); + + /** + * @param target + * @param level + * @param format + * @param type + * @param pixels + */ + public void glGetTexImage(int target, int level, int format, + int type, IntBuffer pixels); + + /** + * @param target + * @param level + * @param format + * @param type + * @param pixels + */ + public void glGetTexImage(int target, int level, int format, + int type, ShortBuffer pixels); + + /** + * @param target + * @param level + * @param pname + * @param params + */ + public void glGetTexLevelParameter(int target, int level, int pname, + FloatBuffer params); + + /** + * @param target + * @param level + * @param pname + * @param params + */ + public void glGetTexLevelParameter(int target, int level, int pname, + IntBuffer params); + + /** + * @param target + * @param pname + * @param params + */ + public void glGetTexParameter(int target, int pname, + FloatBuffer params); + + /** + * @param target + * @param pname + * @param params + */ + public void glGetTexParameter(int target, int pname, IntBuffer params); + + /** + * @param target + * @param mode + */ + public void glHint(int target, int mode); + + /** + * + */ + public void glInitNames(); + + /** + * @param format + * @param stride + * @param pointer + */ + public void glInterleavedArrays(int format, int stride, + ByteBuffer pointer); + + /** + * @param format + * @param stride + * @param pointer + */ + public void glInterleavedArrays(int format, int stride, + FloatBuffer pointer); + + /** + * @param format + * @param stride + * @param buffer_offset + */ + public void glInterleavedArrays(int format, int stride, + int buffer_offset); + + /** + * @param format + * @param stride + * @param pointer + */ + public void glInterleavedArrays(int format, int stride, + IntBuffer pointer); + + /** + * @param format + * @param stride + * @param pointer + */ + public void glInterleavedArrays(int format, int stride, + ShortBuffer pointer); + + /** + * @param cap + * @return + */ + public boolean glIsEnabled(int cap); + + /** + * @param list + * @return + */ + public boolean glIsList(int list); + + /** + * @param texture + * @return + */ + public boolean glIsTexture(int texture); + + /** + * @param light + * @param pname + * @param params + */ + public void glLight(int light, int pname, FloatBuffer params); + + /** + * @param light + * @param pname + * @param params + */ + public void glLight(int light, int pname, IntBuffer params); + + /** + * @param light + * @param pname + * @param param + */ + public void glLightf(int light, int pname, float param); + + /** + * @param light + * @param pname + * @param param + */ + public void glLighti(int light, int pname, int param); + + /** + * @param pname + * @param params + */ + public void glLightModel(int pname, FloatBuffer params); + + /** + * @param pname + * @param params + */ + public void glLightModel(int pname, IntBuffer params); + + /** + * @param pname + * @param param + */ + public void glLightModelf(int pname, float param); + + /** + * @param pname + * @param param + */ + public void glLightModeli(int pname, int param); + + /** + * @param factor + * @param pattern + */ + public void glLineStipple(int factor, short pattern); + + /** + * @param width + */ + public void glLineWidth(float width); + + /** + * @param base + */ + public void glListBase(int base); + + /** + * + */ + public void glLoadIdentity(); + + /** + * @param m + */ + public void glLoadMatrix(FloatBuffer m); + + /** + * @param name + */ + public void glLoadName(int name); + + /** + * @param opcode + */ + public void glLogicOp(int opcode); + + /** + * @param target + * @param u1 + * @param u2 + * @param stride + * @param order + * @param points + */ + public void glMap1f(int target, float u1, float u2, int stride, + int order, FloatBuffer points); + + /** + * @param target + * @param u1 + * @param u2 + * @param ustride + * @param uorder + * @param v1 + * @param v2 + * @param vstride + * @param vorder + * @param points + */ + public void glMap2f(int target, float u1, float u2, int ustride, + int uorder, float v1, float v2, int vstride, int vorder, + FloatBuffer points); + + + /** + * @param un + * @param u1 + * @param u2 + */ + public void glMapGrid1f(int un, float u1, float u2); + + /** + * @param un + * @param u1 + * @param u2 + * @param vn + * @param v1 + * @param v2 + */ + public void glMapGrid2f(int un, float u1, float u2, int vn, + float v1, float v2); + + /** + * @param face + * @param pname + * @param params + */ + public void glMaterial(int face, int pname, FloatBuffer params); + + /** + * @param face + * @param pname + * @param params + */ + public void glMaterial(int face, int pname, IntBuffer params); + + /** + * @param face + * @param pname + * @param param + */ + public void glMaterialf(int face, int pname, float param); + + /** + * @param face + * @param pname + * @param param + */ + public void glMateriali(int face, int pname, int param); + + /** + * @param mode + */ + public void glMatrixMode(int mode); + + /** + * @param m + */ + public void glMultMatrix(FloatBuffer m); + + /** + * @param list + * @param mode + */ + public void glNewList(int list, int mode); + + /** + * @param nx + * @param ny + * @param nz + */ + public void glNormal3b(byte nx, byte ny, byte nz); + + /** + * @param nx + * @param ny + * @param nz + */ + public void glNormal3f(float nx, float ny, float nz); + + /** + * @param nx + * @param ny + * @param nz + */ + public void glNormal3i(int nx, int ny, int nz); + + /** + * @param stride + * @param pointer + */ + public void glNormalPointer(int stride, ByteBuffer pointer); + + /** + * @param stride + * @param pointer + */ + public void glNormalPointer(int stride, FloatBuffer pointer); + + /** + * @param type + * @param stride + * @param buffer_offset + */ + public void glNormalPointer(int type, int stride, int buffer_offset); + + /** + * @param stride + * @param pointer + */ + public void glNormalPointer(int stride, IntBuffer pointer); + + /** + * @param left + * @param right + * @param bottom + * @param top + * @param zNear + * @param zFar + */ + public void glOrtho(double left, double right, double bottom, + double top, double zNear, double zFar); + + /** + * @param token + */ + public void glPassThrough(float token); + + /** + * @param map + * @param values + */ + public void glPixelMap(int map, FloatBuffer values); + + /** + * @param map + * @param values + */ + public void glPixelMap(int map, IntBuffer values); + + /** + * @param map + * @param values + */ + public void glPixelMap(int map, ShortBuffer values); + + /** + * @param pname + * @param param + */ + public void glPixelStoref(int pname, float param); + + /** + * @param pname + * @param param + */ + public void glPixelStorei(int pname, int param); + + /** + * @param pname + * @param param + */ + public void glPixelTransferf(int pname, float param); + + /** + * @param pname + * @param param + */ + public void glPixelTransferi(int pname, int param); + + /** + * @param xfactor + * @param yfactor + */ + public void glPixelZoom(float xfactor, float yfactor); + + /** + * @param size + */ + public void glPointSize(float size); + + /** + * @param face + * @param mode + */ + public void glPolygonMode(int face, int mode); + + /** + * @param factor + * @param units + */ + public void glPolygonOffset(float factor, float units); + + /** + * @param mask + */ + public void glPolygonStipple(ByteBuffer mask); + + /** + * + */ + public void glPopAttrib(); + + /** + * + */ + public void glPopClientAttrib(); + + /** + * + */ + public void glPopMatrix(); + + /** + * + */ + public void glPopName(); + + /** + * @param mask + */ + public void glPushAttrib(int mask); + + /** + * @param mask + */ + public void glPushClientAttrib(int mask); + + /** + * + */ + public void glPushMatrix(); + + /** + * @param name + */ + public void glPushName(int name); + + /** + * @param x + * @param y + */ + public void glRasterPos2f(float x, float y); + + /** + * @param x + * @param y + */ + public void glRasterPos2i(int x, int y); + + /** + * @param x + * @param y + * @param z + */ + public void glRasterPos3f(float x, float y, float z); + + /** + * @param x + * @param y + * @param z + */ + public void glRasterPos3i(int x, int y, int z); + + /** + * @param x + * @param y + * @param z + * @param w + */ + public void glRasterPos4f(float x, float y, float z, float w); + + /** + * @param x + * @param y + * @param z + * @param w + */ + public void glRasterPos4i(int x, int y, int z, int w); + + /** + * @param mode + */ + public void glReadBuffer(int mode); + + /** + * @param x + * @param y + * @param width + * @param height + * @param format + * @param type + * @param pixels + */ + public void glReadPixels(int x, int y, int width, int height, + int format, int type, ByteBuffer pixels); + + /** + * @param x + * @param y + * @param width + * @param height + * @param format + * @param type + * @param pixels + */ + public void glReadPixels(int x, int y, int width, int height, + int format, int type, IntBuffer pixels); + + /** + * @param x + * @param y + * @param width + * @param height + * @param format + * @param type + * @param pixels + */ + public void glReadPixels(int x, int y, int width, int height, + int format, int type, ShortBuffer pixels); + + /** + * @param x1 + * @param y1 + * @param x2 + * @param y2 + */ + public void glRectf(float x1, float y1, float x2, float y2); + + /** + * @param x1 + * @param y1 + * @param x2 + * @param y2 + */ + public void glRecti(int x1, int y1, int x2, int y2); + + /** + * @param mode + * @return + */ + public int glRenderMode(int mode); + + /** + * @param angle + * @param x + * @param y + * @param z + */ + public void glRotatef(float angle, float x, float y, float z); + + /** + * @param x + * @param y + * @param z + */ + public void glScalef(float x, float y, float z); + + /** + * @param x + * @param y + * @param width + * @param height + */ + public void glScissor(int x, int y, int width, int height); + + /** + * @param buffer + */ + public void glSelectBuffer(IntBuffer buffer); + + /** + * @param mode + */ + public void glShadeModel(int mode); + + /** + * @param func + * @param ref + * @param mask + */ + public void glStencilFunc(int func, int ref, int mask); + + /** + * @param mask + */ + public void glStencilMask(int mask); + + /** + * @param fail + * @param zfail + * @param zpass + */ + public void glStencilOp(int fail, int zfail, int zpass); + + /** + * @param s + */ + public void glTexCoord1f(float s); + + /** + * @param s + * @param t + */ + public void glTexCoord2f(float s, float t); + + /** + * @param s + * @param t + * @param r + */ + public void glTexCoord3f(float s, float t, float r); + + /** + * @param s + * @param t + * @param r + * @param q + */ + public void glTexCoord4f(float s, float t, float r, float q); + + /** + * @param size + * @param stride + * @param pointer + */ + public void glTexCoordPointer(int size, int stride, + FloatBuffer pointer); + + /** + * @param size + * @param type + * @param stride + * @param buffer_offset + */ + public void glTexCoordPointer(int size, int type, int stride, + int buffer_offset); + + /** + * @param target + * @param pname + * @param params + */ + public void glTexEnv(int target, int pname, FloatBuffer params); + + /** + * @param target + * @param pname + * @param params + */ + public void glTexEnv(int target, int pname, IntBuffer params); + + /** + * @param target + * @param pname + * @param param + */ + public void glTexEnvf(int target, int pname, float param); + + /** + * @param target + * @param pname + * @param param + */ + public void glTexEnvi(int target, int pname, int param); + + /** + * @param coord + * @param pname + * @param params + */ + public void glTexGen(int coord, int pname, FloatBuffer params); + + /** + * @param coord + * @param pname + * @param params + */ + public void glTexGen(int coord, int pname, IntBuffer params); + + /** + * @param coord + * @param pname + * @param param + */ + public void glTexGenf(int coord, int pname, float param); + + /** + * @param coord + * @param pname + * @param param + */ + public void glTexGeni(int coord, int pname, int param); + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param format + * @param type + * @param pixels + */ + public void glTexImage1D(int target, int level, int internalformat, + int width, int border, int format, int type, ByteBuffer pixels); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param format + * @param type + * @param pixels + */ + public void glTexImage1D(int target, int level, int internalformat, + int width, int border, int format, int type, FloatBuffer pixels); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param format + * @param type + * @param pixels + */ + public void glTexImage1D(int target, int level, int internalformat, + int width, int border, int format, int type, IntBuffer pixels); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param format + * @param type + * @param pixels + */ + public void glTexImage1D(int target, int level, int internalformat, + int width, int border, int format, int type, ShortBuffer pixels); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param format + * @param type + * @param pixels + */ + public void glTexImage2D(int target, int level, int internalformat, + int width, int height, int border, int format, int type, + ByteBuffer pixels); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param format + * @param type + * @param pixels + */ + public void glTexImage2D(int target, int level, int internalformat, + int width, int height, int border, int format, int type, + FloatBuffer pixels); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param format + * @param type + * @param pixels + */ + public void glTexImage2D(int target, int level, int internalformat, + int width, int height, int border, int format, int type, + IntBuffer pixels); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param format + * @param type + * @param pixels + */ + public void glTexImage2D(int target, int level, int internalformat, + int width, int height, int border, int format, int type, + ShortBuffer pixels); + + + /** + * @param target + * @param pname + * @param param + */ + public void glTexParameter(int target, int pname, FloatBuffer param); + + /** + * @param target + * @param pname + * @param param + */ + public void glTexParameter(int target, int pname, IntBuffer param); + + /** + * @param target + * @param pname + * @param param + */ + public void glTexParameterf(int target, int pname, float param); + + /** + * @param target + * @param pname + * @param param + */ + public void glTexParameteri(int target, int pname, int param); + + /** + * @param target + * @param level + * @param xoffset + * @param width + * @param format + * @param type + * @param pixels + */ + public void glTexSubImage1D(int target, int level, int xoffset, + int width, int format, int type, ByteBuffer pixels); + + + /** + * @param target + * @param level + * @param xoffset + * @param width + * @param format + * @param type + * @param pixels + */ + public void glTexSubImage1D(int target, int level, int xoffset, + int width, int format, int type, IntBuffer pixels); + + + /** + * @param target + * @param level + * @param xoffset + * @param width + * @param format + * @param type + * @param pixels + */ + public void glTexSubImage1D(int target, int level, int xoffset, + int width, int format, int type, ShortBuffer pixels); + + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param width + * @param height + * @param format + * @param type + * @param pixels + */ + public void glTexSubImage2D(int target, int level, int xoffset, + int yoffset, int width, int height, int format, int type, + ByteBuffer pixels); + + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param width + * @param height + * @param format + * @param type + * @param pixels + */ + public void glTexSubImage2D(int target, int level, int xoffset, + int yoffset, int width, int height, int format, int type, + IntBuffer pixels); + + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param width + * @param height + * @param format + * @param type + * @param pixels + */ + public void glTexSubImage2D(int target, int level, int xoffset, + int yoffset, int width, int height, int format, int type, + ShortBuffer pixels); + + + /** + * @param x + * @param y + * @param z + */ + public void glTranslatef(float x, float y, float z); + + /** + * @param x + * @param y + */ + public void glVertex2f(float x, float y); + + /** + * @param x + * @param y + */ + public void glVertex2i(int x, int y); + + /** + * @param x + * @param y + * @param z + */ + public void glVertex3f(float x, float y, float z); + + /** + * @param x + * @param y + * @param z + */ + public void glVertex3i(int x, int y, int z); + + /** + * @param x + * @param y + * @param z + * @param w + */ + public void glVertex4f(float x, float y, float z, float w); + + /** + * @param x + * @param y + * @param z + * @param w + */ + public void glVertex4i(int x, int y, int z, int w); + + /** + * @param size + * @param stride + * @param pointer + */ + public void glVertexPointer(int size, int stride, FloatBuffer pointer); + + /** + * @param size + * @param type + * @param stride + * @param buffer_offset + */ + public void glVertexPointer(int size, int type, int stride, + int buffer_offset); + + /** + * @param size + * @param stride + * @param pointer + */ + public void glVertexPointer(int size, int stride, IntBuffer pointer); + + /** + * @param x + * @param y + * @param width + * @param height + */ + public void glViewport(int x, int y, int width, int height); + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param x + * @param y + * @param width + * @param height + */ + public void glCopyTexSubImage3D(int target, int level, int xoffset, + int yoffset, int zoffset, int x, int y, int width, int height); + + + /** + * @param mode + * @param start + * @param end + * @param indices + */ + public void glDrawRangeElements(int mode, int start, int end, + ByteBuffer indices); + + /** + * @param mode + * @param start + * @param end + * @param count + * @param type + * @param buffer_offset + */ + public void glDrawRangeElements(int mode, int start, int end, + int count, int type, int buffer_offset); + + /** + * @param mode + * @param start + * @param end + * @param indices + */ + public void glDrawRangeElements(int mode, int start, int end, + IntBuffer indices); + + /** + * @param mode + * @param start + * @param end + * @param indices + */ + public void glDrawRangeElements(int mode, int start, int end, + ShortBuffer indices); + + /** + * @param target + * @param level + * @param internalFormat + * @param width + * @param height + * @param depth + * @param border + * @param format + * @param type + * @param pixels + */ + public void glTexImage3D(int target, int level, int internalFormat, + int width, int height, int depth, int border, int format, int type, + ByteBuffer pixels); + + + /** + * @param target + * @param level + * @param internalFormat + * @param width + * @param height + * @param depth + * @param border + * @param format + * @param type + * @param pixels + */ + public void glTexImage3D(int target, int level, int internalFormat, + int width, int height, int depth, int border, int format, int type, + FloatBuffer pixels); + + + /** + * @param target + * @param level + * @param internalFormat + * @param width + * @param height + * @param depth + * @param border + * @param format + * @param type + * @param pixels + */ + public void glTexImage3D(int target, int level, int internalFormat, + int width, int height, int depth, int border, int format, int type, + IntBuffer pixels); + + + /** + * @param target + * @param level + * @param internalFormat + * @param width + * @param height + * @param depth + * @param border + * @param format + * @param type + * @param pixels + */ + public void glTexImage3D(int target, int level, int internalFormat, + int width, int height, int depth, int border, int format, int type, + ShortBuffer pixels); + + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param format + * @param type + * @param pixels + */ + public void glTexSubImage3D(int target, int level, int xoffset, + int yoffset, int zoffset, int width, int height, int depth, + int format, int type, ByteBuffer pixels); + + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param format + * @param type + * @param pixels + */ + public void glTexSubImage3D(int target, int level, int xoffset, + int yoffset, int zoffset, int width, int height, int depth, + int format, int type, FloatBuffer pixels); + + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param format + * @param type + * @param pixels + */ + public void glTexSubImage3D(int target, int level, int xoffset, + int yoffset, int zoffset, int width, int height, int depth, + int format, int type, IntBuffer pixels); + + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param format + * @param type + * @param pixels + */ + public void glTexSubImage3D(int target, int level, int xoffset, + int yoffset, int zoffset, int width, int height, int depth, + int format, int type, ShortBuffer pixels); + + + /** + * @param texture + */ + public void glActiveTexture(int texture); + + /** + * @param texture + */ + public void glClientActiveTexture(int texture); + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage1D(int target, int level, + int internalformat, int width, int border, int imageSize, + ByteBuffer data); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage1D(int target, int level, + int internalformat, int width, int border, int imageSize, + FloatBuffer data); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage1D(int target, int level, + int internalformat, int width, int border, int imageSize, + IntBuffer data); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage1D(int target, int level, + int internalformat, int width, int border, int imageSize, + ShortBuffer data); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage2D(int target, int level, + int internalformat, int width, int height, int border, + int imageSize, ByteBuffer data); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage2D(int target, int level, + int internalformat, int width, int height, int border, + int imageSize, FloatBuffer data); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage2D(int target, int level, + int internalformat, int width, int height, int border, + int imageSize, IntBuffer data); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage2D(int target, int level, + int internalformat, int width, int height, int border, + int imageSize, ShortBuffer data); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage3D(int target, int level, + int internalformat, int width, int height, int depth, int border, + int imageSize, ByteBuffer data); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage3D(int target, int level, + int internalformat, int width, int height, int depth, int border, + int imageSize, FloatBuffer data); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage3D(int target, int level, + int internalformat, int width, int height, int depth, int border, + int imageSize, IntBuffer data); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param data + */ + public void glCompressedTexImage3D(int target, int level, + int internalformat, int width, int height, int depth, int border, + int imageSize, ShortBuffer data); + + + /** + * @param target + * @param level + * @param xoffset + * @param width + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage1D(int target, int level, + int xoffset, int width, int format, int imageSize, ByteBuffer data); + + + /** + * @param target + * @param level + * @param xoffset + * @param width + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage1D(int target, int level, + int xoffset, int width, int format, int imageSize, FloatBuffer data); + + + /** + * @param target + * @param level + * @param xoffset + * @param width + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage1D(int target, int level, + int xoffset, int width, int format, int imageSize, IntBuffer data); + + + /** + * @param target + * @param level + * @param xoffset + * @param width + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage1D(int target, int level, + int xoffset, int width, int format, int imageSize, ShortBuffer data); + + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param width + * @param height + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage2D(int target, int level, + int xoffset, int yoffset, int width, int height, int format, + int imageSize, ByteBuffer data); + + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param width + * @param height + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage2D(int target, int level, + int xoffset, int yoffset, int width, int height, int format, + int imageSize, FloatBuffer data); + + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param width + * @param height + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage2D(int target, int level, + int xoffset, int yoffset, int width, int height, int format, + int imageSize, IntBuffer data); + + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param width + * @param height + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage2D(int target, int level, + int xoffset, int yoffset, int width, int height, int format, + int imageSize, ShortBuffer data); + + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage3D(int target, int level, + int xoffset, int yoffset, int zoffset, int width, int height, + int depth, int format, int imageSize, ByteBuffer data); + + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage3D(int target, int level, + int xoffset, int yoffset, int zoffset, int width, int height, + int depth, int format, int imageSize, FloatBuffer data); + + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage3D(int target, int level, + int xoffset, int yoffset, int zoffset, int width, int height, + int depth, int format, int imageSize, IntBuffer data); + + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param format + * @param imageSize + * @param data + */ + public void glCompressedTexSubImage3D(int target, int level, + int xoffset, int yoffset, int zoffset, int width, int height, + int depth, int format, int imageSize, ShortBuffer data); + + + /** + * @param target + * @param lod + * @param img + */ + public void glGetCompressedTexImage(int target, int lod, + ByteBuffer img); + + /** + * @param target + * @param lod + * @param img + */ + public void glGetCompressedTexImage(int target, int lod, + IntBuffer img); + + /** + * @param target + * @param lod + * @param img + */ + public void glGetCompressedTexImage(int target, int lod, + ShortBuffer img); + + /** + * @param m + */ + public void glLoadTransposeMatrix(FloatBuffer m); + + /** + * @param target + * @param s + */ + public void glMultiTexCoord1f(int target, float s); + + /** + * @param target + * @param s + * @param t + */ + public void glMultiTexCoord2f(int target, float s, float t); + + /** + * @param target + * @param s + * @param t + * @param r + */ + public void glMultiTexCoord3f(int target, float s, float t, float r); + + /** + * @param target + * @param s + * @param t + * @param r + * @param q + */ + public void glMultiTexCoord4f(int target, float s, float t, float r, + float q); + + /** + * @param m + */ + public void glMultTransposeMatrix(FloatBuffer m); + + /** + * @param value + * @param invert + */ + public void glSampleCoverage(float value, boolean invert); + + /** + * @param red + * @param green + * @param blue + * @param alpha + */ + public void glBlendColor(float red, float green, float blue, + float alpha); + + /** + * @param mode + */ + public void glBlendEquation(int mode); + + /** + * @param sfactorRGB + * @param dfactorRGB + * @param sfactorAlpha + * @param dfactorAlpha + */ + public void glBlendFuncSeparate(int sfactorRGB, int dfactorRGB, + int sfactorAlpha, int dfactorAlpha); + + + /** + * @param coord + */ + public void glFogCoordf(float coord); + + /** + * @param stride + * @param data + */ + public void glFogCoordPointer(int stride, FloatBuffer data); + + /** + * @param type + * @param stride + * @param buffer_offset + */ + public void glFogCoordPointer(int type, int stride, int buffer_offset); + + /** + * @param mode + * @param piFirst + * @param piCount + */ + public void glMultiDrawArrays(int mode, IntBuffer piFirst, + IntBuffer piCount); + + /** + * @param pname + * @param params + */ + public void glPointParameter(int pname, FloatBuffer params); + + /** + * @param pname + * @param param + */ + public void glPointParameterf(int pname, float param); + + /** + * @param red + * @param green + * @param blue + */ + public void glSecondaryColor3b(byte red, byte green, byte blue); + + /** + * @param red + * @param green + * @param blue + */ + public void glSecondaryColor3f(float red, float green, float blue); + + /** + * @param red + * @param green + * @param blue + */ + public void glSecondaryColor3ub(byte red, byte green, byte blue); + + /** + * @param size + * @param unsigned + * @param stride + * @param data + */ + public void glSecondaryColorPointer(int size, boolean unsigned, + int stride, ByteBuffer data); + + /** + * @param size + * @param stride + * @param data + */ + public void glSecondaryColorPointer(int size, int stride, + FloatBuffer data); + + /** + * @param size + * @param type + * @param stride + * @param buffer_offset + */ + public void glSecondaryColorPointer(int size, int type, int stride, + int buffer_offset); + + /** + * @param x + * @param y + */ + public void glWindowPos2f(float x, float y); + + /** + * @param x + * @param y + */ + public void glWindowPos2i(int x, int y); + + /** + * @param x + * @param y + * @param z + */ + public void glWindowPos3f(float x, float y, float z); + + /** + * @param x + * @param y + * @param z + */ + public void glWindowPos3i(int x, int y, int z); + + /** + * @param target + * @param id + */ + public void glBeginQuery(int target, int id); + + /** + * @param target + * @param buffer + */ + public void glBindBuffer(int target, int buffer); + + /** + * @param target + * @param size + * @param data + * @param usage + */ + public void glBufferData(int target, int size, ByteBuffer data, + int usage); + + /** + * @param target + * @param size + * @param data + * @param usage + */ + public void glBufferData(int target, int size, FloatBuffer data, + int usage); + + /** + * @param target + * @param size + * @param data + * @param usage + */ + public void glBufferData(int target, int size, IntBuffer data, + int usage); + + /** + * @param target + * @param size + * @param data + * @param usage + */ + public void glBufferData(int target, int size, ShortBuffer data, + int usage); + + /** + * @param target + * @param offset + * @param data + */ + public void glBufferSubData(int target, int offset, ByteBuffer data); + + /** + * @param target + * @param offset + * @param data + */ + public void glBufferSubData(int target, int offset, FloatBuffer data); + + /** + * @param target + * @param offset + * @param data + */ + public void glBufferSubData(int target, int offset, IntBuffer data); + + /** + * @param target + * @param offset + * @param data + */ + public void glBufferSubData(int target, int offset, ShortBuffer data); + + /** + * @param buffers + */ + public void glDeleteBuffers(IntBuffer buffers); + + /** + * @param ids + */ + public void glDeleteQueries(IntBuffer ids); + + /** + * @param target + */ + public void glEndQuery(int target); + + /** + * @param buffers + */ + public void glGenBuffers(IntBuffer buffers); + + /** + * @param ids + */ + public void glGenQueries(IntBuffer ids); + + /** + * @param target + * @param pname + * @param params + */ + public void glGetBufferParameter(int target, int pname, + IntBuffer params); + + /** + * @param target + * @param pname + * @param size + * @return + */ + public ByteBuffer glGetBufferPointer(int target, int pname, int size); + + /** + * @param target + * @param offset + * @param data + */ + public void glGetBufferSubData(int target, int offset, + ByteBuffer data); + + /** + * @param target + * @param offset + * @param data + */ + public void glGetBufferSubData(int target, int offset, + FloatBuffer data); + + /** + * @param target + * @param offset + * @param data + */ + public void glGetBufferSubData(int target, int offset, IntBuffer data); + + /** + * @param target + * @param offset + * @param data + */ + public void glGetBufferSubData(int target, int offset, + ShortBuffer data); + + /** + * @param target + * @param pname + * @param params + */ + public void glGetQuery(int target, int pname, IntBuffer params); + + /** + * @param id + * @param pname + * @param params + */ + public void glGetQueryObject(int id, int pname, IntBuffer params); + + /** + * @param id + * @param pname + * @param params + */ + public void glGetQueryObjectu(int id, int pname, IntBuffer params); + + /** + * @param buffer + * @return + */ + public boolean glIsBuffer(int buffer); + + /** + * @param id + * @return + */ + public boolean glIsQuery(int id); + + /** + * @param target + * @param access + * @param size + * @param oldBuffer + * @return + */ + public ByteBuffer glMapBuffer(int target, int access, int size, + ByteBuffer oldBuffer); + + /** + * @param target + * @return + */ + public boolean glUnmapBuffer(int target); + + /** + * @param target + * @param buffer + */ + public void glBindBufferARB(int target, int buffer); + + /** + * @param target + * @param size + * @param data + * @param usage + */ + public void glBufferDataARB(int target, int size, ByteBuffer data, + int usage); + + /** + * @param target + * @param size + * @param data + * @param usage + */ + public void glBufferDataARB(int target, int size, FloatBuffer data, + int usage); + + /** + * @param target + * @param size + * @param data + * @param usage + */ + public void glBufferDataARB(int target, int size, IntBuffer data, + int usage); + + /** + * @param target + * @param size + * @param data + * @param usage + */ + public void glBufferDataARB(int target, int size, ShortBuffer data, + int usage); + + /** + * @param target + * @param offset + * @param data + */ + public void glBufferSubDataARB(int target, int offset, + ByteBuffer data); + + /** + * @param target + * @param offset + * @param data + */ + public void glBufferSubDataARB(int target, int offset, + FloatBuffer data); + + /** + * @param target + * @param offset + * @param data + */ + public void glBufferSubDataARB(int target, int offset, IntBuffer data); + + /** + * @param target + * @param offset + * @param data + */ + public void glBufferSubDataARB(int target, int offset, + ShortBuffer data); + + /** + * @param buffers + */ + public void glDeleteBuffersARB(IntBuffer buffers); + + /** + * @param buffers + */ + public void glGenBuffersARB(IntBuffer buffers); + + /** + * @param target + * @param pname + * @param params + */ + public void glGetBufferParameterARB(int target, int pname, + IntBuffer params); + + /** + * @param target + * @param pname + * @param size + * @return + */ + public ByteBuffer glGetBufferPointerARB(int target, int pname, + int size); + + /** + * @param target + * @param offset + * @param data + */ + public void glGetBufferSubDataARB(int target, int offset, + ByteBuffer data); + + /** + * @param target + * @param offset + * @param data + */ + public void glGetBufferSubDataARB(int target, int offset, + FloatBuffer data); + + /** + * @param target + * @param offset + * @param data + */ + public void glGetBufferSubDataARB(int target, int offset, + IntBuffer data); + + /** + * @param target + * @param offset + * @param data + */ + public void glGetBufferSubDataARB(int target, int offset, + ShortBuffer data); + + /** + * @param buffer + * @return + */ + public boolean glIsBufferARB(int buffer); + + /** + * @param target + * @param access + * @param size + * @param oldBuffer + * @return + */ + public ByteBuffer glMapBufferARB(int target, int access, int size, + ByteBuffer oldBuffer); + + /** + * @param target + * @return + */ + public boolean glUnmapBufferARB(int target); + + /** + * @param target + * @param program + */ + public void glBindProgramARB(int target, int program); + + /** + * @param programs + */ + public void glDeleteProgramsARB(IntBuffer programs); + + /** + * @param programs + */ + public void glGenProgramsARB(IntBuffer programs); + + /** + * @param target + * @param parameterName + * @param params + */ + public void glGetProgramARB(int target, int parameterName, + IntBuffer params); + + /** + * @param target + * @param index + * @param params + */ + public void glGetProgramEnvParameterARB(int target, int index, + FloatBuffer params); + + /** + * @param target + * @param index + * @param params + */ + public void glGetProgramLocalParameterARB(int target, int index, + FloatBuffer params); + + /** + * @param target + * @param parameterName + * @param paramString + */ + public void glGetProgramStringARB(int target, int parameterName, + ByteBuffer paramString); + + + /** + * @param program + * @return + */ + public boolean glIsProgramARB(int program); + + /** + * @param target + * @param index + * @param x + * @param y + * @param z + * @param w + */ + public void glProgramEnvParameter4fARB(int target, int index, + float x, float y, float z, float w); + + + /** + * @param target + * @param index + * @param params + */ + public void glProgramEnvParameterARB(int target, int index, + FloatBuffer params); + + /** + * @param target + * @param index + * @param x + * @param y + * @param z + * @param w + */ + public void glProgramLocalParameter4fARB(int target, int index, + float x, float y, float z, float w); + + + /** + * @param target + * @param index + * @param params + */ + public void glProgramLocalParameterARB(int target, int index, + FloatBuffer params); + + /** + * @param target + * @param format + * @param string + */ + public void glProgramStringARB(int target, int format, + ByteBuffer string); + + /** + * @param target + * @param start + * @param count + * @param format + * @param type + * @param data + */ + public void glColorSubTable(int target, int start, int count, + int format, int type, ByteBuffer data); + + /** + * @param target + * @param start + * @param count + * @param format + * @param type + * @param data + */ + public void glColorSubTable(int target, int start, int count, + int format, int type, FloatBuffer data); + + /** + * @param target + * @param internalFormat + * @param width + * @param format + * @param type + * @param data + */ + public void glColorTable(int target, int internalFormat, int width, + int format, int type, ByteBuffer data); + + + /** + * @param target + * @param internalFormat + * @param width + * @param format + * @param type + * @param data + */ + public void glColorTable(int target, int internalFormat, int width, + int format, int type, FloatBuffer data); + + + /** + * @param target + * @param pname + * @param params + */ + public void glColorTableParameter(int target, int pname, + FloatBuffer params); + + /** + * @param target + * @param pname + * @param params + */ + public void glColorTableParameter(int target, int pname, + IntBuffer params); + + /** + * @param target + * @param internalformat + * @param width + * @param format + * @param type + * @param image + */ + public void glConvolutionFilter1D(int target, int internalformat, + int width, int format, int type, ByteBuffer image); + + + /** + * @param target + * @param internalformat + * @param width + * @param format + * @param type + * @param image + */ + public void glConvolutionFilter1D(int target, int internalformat, + int width, int format, int type, FloatBuffer image); + + + /** + * @param target + * @param internalformat + * @param width + * @param format + * @param type + * @param image + */ + public void glConvolutionFilter1D(int target, int internalformat, + int width, int format, int type, IntBuffer image); + + + /** + * @param target + * @param internalformat + * @param width + * @param format + * @param type + * @param image + */ + public void glConvolutionFilter1D(int target, int internalformat, + int width, int format, int type, ShortBuffer image); + + + /** + * @param target + * @param internalformat + * @param width + * @param height + * @param format + * @param type + * @param image + */ + public void glConvolutionFilter2D(int target, int internalformat, + int width, int height, int format, int type, ByteBuffer image); + + + /** + * @param target + * @param internalformat + * @param width + * @param height + * @param format + * @param type + * @param image + */ + public void glConvolutionFilter2D(int target, int internalformat, + int width, int height, int format, int type, IntBuffer image); + + + /** + * @param target + * @param internalformat + * @param width + * @param height + * @param format + * @param type + * @param image + */ + public void glConvolutionFilter2D(int target, int internalformat, + int width, int height, int format, int type, ShortBuffer image); + + + /** + * @param target + * @param pname + * @param params + */ + public void glConvolutionParameter(int target, int pname, + FloatBuffer params); + + /** + * @param target + * @param pname + * @param params + */ + public void glConvolutionParameterf(int target, int pname, + float params); + + /** + * @param target + * @param pname + * @param params + */ + public void glConvolutionParameteri(int target, int pname, int params); + + /** + * @param target + * @param pname + * @param params + */ + public void glConvolutionParameteriv(int target, int pname, + IntBuffer params); + + /** + * @param target + * @param start + * @param x + * @param y + * @param width + */ + public void glCopyColorSubTable(int target, int start, int x, int y, + int width); + + /** + * @param target + * @param internalformat + * @param x + * @param y + * @param width + */ + public void glCopyColorTable(int target, int internalformat, int x, + int y, int width); + + /** + * @param target + * @param internalformat + * @param x + * @param y + * @param width + */ + public void glCopyConvolutionFilter1D(int target, + int internalformat, int x, int y, int width); + + + /** + * @param target + * @param internalformat + * @param x + * @param y + * @param width + * @param height + */ + public void glCopyConvolutionFilter2D(int target, + int internalformat, int x, int y, int width, int height); + + + /** + * @param target + * @param format + * @param type + * @param data + */ + public void glGetColorTable(int target, int format, int type, + ByteBuffer data); + + /** + * @param target + * @param format + * @param type + * @param data + */ + public void glGetColorTable(int target, int format, int type, + FloatBuffer data); + + /** + * @param target + * @param pname + * @param params + */ + public void glGetColorTableParameter(int target, int pname, + FloatBuffer params); + + /** + * @param target + * @param pname + * @param params + */ + public void glGetColorTableParameter(int target, int pname, + IntBuffer params); + + /** + * @param target + * @param format + * @param type + * @param image + */ + public void glGetConvolutionFilter(int target, int format, int type, + ByteBuffer image); + + /** + * @param target + * @param format + * @param type + * @param image + */ + public void glGetConvolutionFilter(int target, int format, int type, + FloatBuffer image); + + /** + * @param target + * @param format + * @param type + * @param image + */ + public void glGetConvolutionFilter(int target, int format, int type, + IntBuffer image); + + /** + * @param target + * @param format + * @param type + * @param image + */ + public void glGetConvolutionFilter(int target, int format, int type, + ShortBuffer image); + + /** + * @param target + * @param pname + * @param params + */ + public void glGetConvolutionParameter(int target, int pname, + FloatBuffer params); + + /** + * @param target + * @param pname + * @param params + */ + public void glGetConvolutionParameter(int target, int pname, + IntBuffer params); + + /** + * @param target + * @param reset + * @param format + * @param type + * @param values + */ + public void glGetHistogram(int target, boolean reset, int format, + int type, ByteBuffer values); + + /** + * @param target + * @param reset + * @param format + * @param type + * @param values + */ + public void glGetHistogram(int target, boolean reset, int format, + int type, FloatBuffer values); + + /** + * @param target + * @param reset + * @param format + * @param type + * @param values + */ + public void glGetHistogram(int target, boolean reset, int format, + int type, IntBuffer values); + + /** + * @param target + * @param reset + * @param format + * @param type + * @param values + */ + public void glGetHistogram(int target, boolean reset, int format, + int type, ShortBuffer values); + + /** + * @param target + * @param pname + * @param params + */ + public void glGetHistogramParameter(int target, int pname, + FloatBuffer params); + + /** + * @param target + * @param pname + * @param params + */ + public void glGetHistogramParameter(int target, int pname, + IntBuffer params); + + /** + * @param target + * @param reset + * @param format + * @param types + * @param values + */ + public void glGetMinmax(int target, boolean reset, int format, + int types, ByteBuffer values); + + /** + * @param target + * @param reset + * @param format + * @param types + * @param values + */ + public void glGetMinmax(int target, boolean reset, int format, + int types, FloatBuffer values); + + /** + * @param target + * @param reset + * @param format + * @param types + * @param values + */ + public void glGetMinmax(int target, boolean reset, int format, + int types, IntBuffer values); + + /** + * @param target + * @param reset + * @param format + * @param types + * @param values + */ + public void glGetMinmax(int target, boolean reset, int format, + int types, ShortBuffer values); + + /** + * @param target + * @param pname + * @param params + */ + public void glGetMinmaxParameter(int target, int pname, + FloatBuffer params); + + /** + * @param target + * @param pname + * @param params + */ + public void glGetMinmaxParameter(int target, int pname, + IntBuffer params); + + /** + * @param target + * @param format + * @param type + * @param row + * @param column + * @param span + */ + public void glGetSeparableFilter(int target, int format, int type, + Buffer row, Buffer column, Buffer span); + + + /** + * @param target + * @param width + * @param internalformat + * @param sink + */ + public void glHistogram(int target, int width, int internalformat, + boolean sink); + + /** + * @param target + * @param internalformat + * @param sink + */ + public void glMinmax(int target, int internalformat, boolean sink); + + /** + * @param target + */ + public void glResetHistogram(int target); + + /** + * @param target + */ + public void glResetMinmax(int target); + + /** + * @param target + * @param internalformat + * @param width + * @param height + * @param format + * @param type + * @param row + * @param column + */ + public void glSeparableFilter2D(int target, int internalformat, + int width, int height, int format, int type, Buffer row, + Buffer column); + + + /** + * @param index + */ + public void glCurrentPaletteMatrixARB(int index); + + /** + * @param size + * @param stride + * @param pPointer + */ + public void glMatrixIndexPointerARB(int size, int stride, + ByteBuffer pPointer); + + /** + * @param size + * @param type + * @param stride + * @param buffer_offset + */ + public void glMatrixIndexPointerARB(int size, int type, int stride, + int buffer_offset); + + + /** + * @param size + * @param stride + * @param pPointer + */ + public void glMatrixIndexPointerARB(int size, int stride, + IntBuffer pPointer); + + /** + * @param size + * @param stride + * @param pPointer + */ + public void glMatrixIndexPointerARB(int size, int stride, + ShortBuffer pPointer); + + /** + * @param pIndices + */ + public void glMatrixIndexuARB(ByteBuffer pIndices); + + /** + * @param piIndices + */ + public void glMatrixIndexuARB(IntBuffer piIndices); + + /** + * @param psIndices + */ + public void glMatrixIndexuARB(ShortBuffer psIndices); + + /** + * @param value + * @param invert + */ + public void glSampleCoverageARB(float value, boolean invert); + + /** + * @param texture + */ + public void glActiveTextureARB(int texture); + + /** + * @param texture + */ + public void glClientActiveTextureARB(int texture); + + /** + * @param target + * @param s + */ + public void glMultiTexCoord1fARB(int target, float s); + + /** + * @param target + * @param s + */ + public void glMultiTexCoord1iARB(int target, int s); + + /** + * @param target + * @param s + */ + public void glMultiTexCoord1sARB(int target, short s); + + /** + * @param target + * @param s + * @param t + */ + public void glMultiTexCoord2fARB(int target, float s, float t); + + /** + * @param target + * @param s + * @param t + */ + public void glMultiTexCoord2iARB(int target, int s, int t); + + /** + * @param target + * @param s + * @param t + */ + public void glMultiTexCoord2sARB(int target, short s, short t); + + /** + * @param target + * @param s + * @param t + * @param r + */ + public void glMultiTexCoord3fARB(int target, float s, float t, + float r); + + /** + * @param target + * @param s + * @param t + * @param r + */ + public void glMultiTexCoord3iARB(int target, int s, int t, int r); + + /** + * @param target + * @param s + * @param t + * @param r + */ + public void glMultiTexCoord3sARB(int target, short s, short t, + short r); + + /** + * @param target + * @param s + * @param t + * @param r + * @param q + */ + public void glMultiTexCoord4fARB(int target, float s, float t, + float r, float q); + + /** + * @param target + * @param s + * @param t + * @param r + * @param q + */ + public void glMultiTexCoord4iARB(int target, int s, int t, int r, + int q); + + /** + * @param target + * @param s + * @param t + * @param r + * @param q + */ + public void glMultiTexCoord4sARB(int target, short s, short t, + short r, short q); + + /** + * @param target + * @param id + */ + public void glBeginQueryARB(int target, int id); + + /** + * @param ids + */ + public void glDeleteQueriesARB(IntBuffer ids); + + /** + * @param target + */ + public void glEndQueryARB(int target); + + /** + * @param ids + */ + public void glGenQueriesARB(IntBuffer ids); + + /** + * @param target + * @param pname + * @param params + */ + public void glGetQueryARB(int target, int pname, IntBuffer params); + + /** + * @param id + * @param pname + * @param params + */ + public void glGetQueryObjectiARB(int id, int pname, IntBuffer params); + + /** + * @param id + * @param pname + * @param params + */ + public void glGetQueryObjectuiARB(int id, int pname, IntBuffer params); + + /** + * @param id + * @return + */ + public boolean glIsQueryARB(int id); + + /** + * @param pname + * @param pfParams + */ + public void glPointParameterARB(int pname, FloatBuffer pfParams); + + /** + * @param pname + * @param param + */ + public void glPointParameterfARB(int pname, float param); + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage1DARB(int target, int level, + int internalformat, int width, int border, int imageSize, + ByteBuffer pData); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage1DARB(int target, int level, + int internalformat, int width, int border, int imageSize, + FloatBuffer pData); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage1DARB(int target, int level, + int internalformat, int width, int border, int imageSize, + IntBuffer pData); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage1DARB(int target, int level, + int internalformat, int width, int border, int imageSize, + ShortBuffer pData); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage2DARB(int target, int level, + int internalformat, int width, int height, int border, + int imageSize, ByteBuffer pData); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage2DARB(int target, int level, + int internalformat, int width, int height, int border, + int imageSize, FloatBuffer pData); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage2DARB(int target, int level, + int internalformat, int width, int height, int border, + int imageSize, IntBuffer pData); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage2DARB(int target, int level, + int internalformat, int width, int height, int border, + int imageSize, ShortBuffer pData); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage3DARB(int target, int level, + int internalformat, int width, int height, int depth, int border, + int imageSize, ByteBuffer pData); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage3DARB(int target, int level, + int internalformat, int width, int height, int depth, int border, + int imageSize, FloatBuffer pData); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage3DARB(int target, int level, + int internalformat, int width, int height, int depth, int border, + int imageSize, IntBuffer pData); + + + /** + * @param target + * @param level + * @param internalformat + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexImage3DARB(int target, int level, + int internalformat, int width, int height, int depth, int border, + int imageSize, ShortBuffer pData); + + + /** + * @param target + * @param level + * @param xoffset + * @param width + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage1DARB(int target, int level, + int xoffset, int width, int border, int imageSize, ByteBuffer pData); + + + /** + * @param target + * @param level + * @param xoffset + * @param width + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage1DARB(int target, int level, + int xoffset, int width, int border, int imageSize, FloatBuffer pData); + + + /** + * @param target + * @param level + * @param xoffset + * @param width + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage1DARB(int target, int level, + int xoffset, int width, int border, int imageSize, IntBuffer pData); + + + /** + * @param target + * @param level + * @param xoffset + * @param width + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage1DARB(int target, int level, + int xoffset, int width, int border, int imageSize, ShortBuffer pData); + + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param width + * @param height + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage2DARB(int target, int level, + int xoffset, int yoffset, int width, int height, int border, + int imageSize, ByteBuffer pData); + + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param width + * @param height + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage2DARB(int target, int level, + int xoffset, int yoffset, int width, int height, int border, + int imageSize, FloatBuffer pData); + + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param width + * @param height + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage2DARB(int target, int level, + int xoffset, int yoffset, int width, int height, int border, + int imageSize, IntBuffer pData); + + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param width + * @param height + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage2DARB(int target, int level, + int xoffset, int yoffset, int width, int height, int border, + int imageSize, ShortBuffer pData); + + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage3DARB(int target, int level, + int xoffset, int yoffset, int zoffset, int width, int height, + int depth, int border, int imageSize, ByteBuffer pData); + + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage3DARB(int target, int level, + int xoffset, int yoffset, int zoffset, int width, int height, + int depth, int border, int imageSize, FloatBuffer pData); + + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage3DARB(int target, int level, + int xoffset, int yoffset, int zoffset, int width, int height, + int depth, int border, int imageSize, IntBuffer pData); + + + /** + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param zoffset + * @param width + * @param height + * @param depth + * @param border + * @param imageSize + * @param pData + */ + public void glCompressedTexSubImage3DARB(int target, int level, + int xoffset, int yoffset, int zoffset, int width, int height, + int depth, int border, int imageSize, ShortBuffer pData); + + + /** + * @param target + * @param lod + * @param pImg + */ + public void glGetCompressedTexImageARB(int target, int lod, + ByteBuffer pImg); + + /** + * @param target + * @param lod + * @param pImg + */ + public void glGetCompressedTexImageARB(int target, int lod, + IntBuffer pImg); + + /** + * @param target + * @param lod + * @param pImg + */ + public void glGetCompressedTexImageARB(int target, int lod, + ShortBuffer pImg); + + /** + * @param pfMtx + */ + public void glLoadTransposeMatrixARB(FloatBuffer pfMtx); + + /** + * @param pfMtx + */ + public void glMultTransposeMatrixfARB(FloatBuffer pfMtx); + + /** + * @param count + */ + public void glVertexBlendARB(int count); + + /** + * @param pWeights + */ + public void glWeightARB(ByteBuffer pWeights); + + /** + * @param pfWeights + */ + public void glWeightARB(FloatBuffer pfWeights); + + /** + * @param piWeights + */ + public void glWeightARB(IntBuffer piWeights); + + /** + * @param psWeights + */ + public void glWeightARB(ShortBuffer psWeights); + + /** + * @param size + * @param unsigned + * @param stride + * @param pPointer + */ + public void glWeightPointerARB(int size, boolean unsigned, + int stride, ByteBuffer pPointer); + + /** + * @param size + * @param unsigned + * @param stride + * @param pPointer + */ + public void glWeightPointerARB(int size, boolean unsigned, + int stride, IntBuffer pPointer); + + /** + * @param size + * @param unsigned + * @param stride + * @param pPointer + */ + public void glWeightPointerARB(int size, boolean unsigned, + int stride, ShortBuffer pPointer); + + /** + * @param size + * @param stride + * @param pPointer + */ + public void glWeightPointerARB(int size, int stride, + FloatBuffer pPointer); + + /** + * @param size + * @param type + * @param stride + * @param buffer_offset + */ + public void glWeightPointerARB(int size, int type, int stride, + int buffer_offset); + + /** + * @param pWeights + */ + public void glWeightuARB(ByteBuffer pWeights); + + /** + * @param piWeights + */ + public void glWeightuARB(IntBuffer piWeights); + + /** + * @param psWeights + */ + public void glWeightuARB(ShortBuffer psWeights); + + /** + * @param programObj + * @param index + * @param name + */ + public void glBindAttribLocationARB(int programObj, int index, + ByteBuffer name); + + /** + * @param programObj + * @param index + * @param length + * @param size + * @param type + * @param name + */ + public void glGetActiveAttribARB(int programObj, int index, + IntBuffer length, IntBuffer size, IntBuffer type, ByteBuffer name); + + + /** + * @param programObj + * @param name + * @return + */ + public int glGetAttribLocationARB(int programObj, ByteBuffer name); + + /** + * @param x + * @param y + */ + public void glWindowPos2fARB(float x, float y); + + /** + * @param x + * @param y + */ + public void glWindowPos2iARB(int x, int y); + + /** + * @param x + * @param y + */ + public void glWindowPos2sARB(short x, short y); + + /** + * @param x + * @param y + * @param z + */ + public void glWindowPos3fARB(float x, float y, float z); + + /** + * @param x + * @param y + * @param z + */ + public void glWindowPos3iARB(int x, int y, int z); + + /** + * @param x + * @param y + * @param z + */ + public void glWindowPos3sARB(short x, short y, short z); + + /** + * @param containerObj + * @param obj + */ + public void glAttachObjectARB(int containerObj, int obj); + + /** + * @param shaderObj + */ + public void glCompileShaderARB(int shaderObj); + + /** + * @return + */ + public int glCreateProgramObjectARB(); + + /** + * @param shaderType + * @return + */ + public int glCreateShaderObjectARB(int shaderType); + + /** + * @param obj + */ + public void glDeleteObjectARB(int obj); + + /** + * @param containerObj + * @param attachedObj + */ + public void glDetachObjectARB(int containerObj, int attachedObj); + + /** + * @param programObj + * @param index + * @param length + * @param size + * @param type + * @param name + */ + public void glGetActiveUniformARB(int programObj, int index, + IntBuffer length, IntBuffer size, IntBuffer type, ByteBuffer name); + + + /** + * @param containerObj + * @param count + * @param obj + */ + public void glGetAttachedObjectsARB(int containerObj, + IntBuffer count, IntBuffer obj); + + /** + * @param pname + * @return + */ + public int glGetHandleARB(int pname); + + /** + * @param obj + * @param length + * @param infoLog + */ + public void glGetInfoLogARB(int obj, IntBuffer length, + ByteBuffer infoLog); + + /** + * @param obj + * @param pname + * @param params + */ + public void glGetObjectParameterARB(int obj, int pname, + FloatBuffer params); + + /** + * @param obj + * @param pname + * @param params + */ + public void glGetObjectParameterARB(int obj, int pname, + IntBuffer params); + + /** + * @param obj + * @param length + * @param source + */ + public void glGetShaderSourceARB(int obj, IntBuffer length, + ByteBuffer source); + + /** + * @param programObj + * @param location + * @param params + */ + public void glGetUniformARB(int programObj, int location, + FloatBuffer params); + + /** + * @param programObj + * @param location + * @param params + */ + public void glGetUniformARB(int programObj, int location, + IntBuffer params); + + /** + * @param programObj + * @param name + * @return + */ + public int glGetUniformLocationARB(int programObj, ByteBuffer name); + + /** + * @param programObj + */ + public void glLinkProgramARB(int programObj); + + /** + * @param shaderObj + * @param string + */ + public void glShaderSourceARB(int shaderObj, ByteBuffer string); + + /** + * @param shaderObj + * @param strings + */ + public void glShaderSourceARB(int shaderObj, ByteBuffer[] strings); + + /** + * @param location + * @param values + */ + public void glUniform1ARB(int location, FloatBuffer values); + + /** + * @param location + * @param values + */ + public void glUniform1ARB(int location, IntBuffer values); + + /** + * @param location + * @param v0 + */ + public void glUniform1fARB(int location, float v0); + + /** + * @param location + * @param v0 + */ + public void glUniform1iARB(int location, int v0); + + /** + * @param location + * @param values + */ + public void glUniform2ARB(int location, FloatBuffer values); + + /** + * @param location + * @param values + */ + public void glUniform2ARB(int location, IntBuffer values); + + /** + * @param location + * @param v0 + * @param v1 + */ + public void glUniform2fARB(int location, float v0, float v1); + + /** + * @param location + * @param v0 + * @param v1 + */ + public void glUniform2iARB(int location, int v0, int v1); + + /** + * @param location + * @param values + */ + public void glUniform3ARB(int location, FloatBuffer values); + + /** + * @param location + * @param values + */ + public void glUniform3ARB(int location, IntBuffer values); + + /** + * @param location + * @param v0 + * @param v1 + * @param v2 + */ + public void glUniform3fARB(int location, float v0, float v1, float v2); + + /** + * @param location + * @param v0 + * @param v1 + * @param v2 + */ + public void glUniform3iARB(int location, int v0, int v1, int v2); + + /** + * @param location + * @param values + */ + public void glUniform4ARB(int location, FloatBuffer values); + + /** + * @param location + * @param values + */ + public void glUniform4ARB(int location, IntBuffer values); + + /** + * @param location + * @param v0 + * @param v1 + * @param v2 + * @param v3 + */ + public void glUniform4fARB(int location, float v0, float v1, + float v2, float v3); + + /** + * @param location + * @param v0 + * @param v1 + * @param v2 + * @param v3 + */ + public void glUniform4iARB(int location, int v0, int v1, int v2, + int v3); + + /** + * @param location + * @param transpose + * @param matrices + */ + public void glUniformMatrix2ARB(int location, boolean transpose, + FloatBuffer matrices); + + /** + * @param location + * @param transpose + * @param matrices + */ + public void glUniformMatrix3ARB(int location, boolean transpose, + FloatBuffer matrices); + + /** + * @param location + * @param transpose + * @param matrices + */ + public void glUniformMatrix4ARB(int location, boolean transpose, + FloatBuffer matrices); + + /** + * @param programObj + */ + public void glUseProgramObjectARB(int programObj); + + /** + * @param programObj + */ + public void glValidateProgramARB(int programObj); + + /** + * @param index + */ + public void glDisableVertexAttribArrayARB(int index); + + /** + * @param index + */ + public void glEnableVertexAttribArrayARB(int index); + + /** + * @param index + * @param pname + * @param params + */ + public void glGetVertexAttribARB(int index, int pname, + FloatBuffer params); + + /** + * @param index + * @param pname + * @param params + */ + public void glGetVertexAttribARB(int index, int pname, + IntBuffer params); + + /** + * @param index + * @param pname + * @param size + * @return + */ + public ByteBuffer glGetVertexAttribPointerARB(int index, int pname, + int size); + + /** + * @param index + * @param x + */ + public void glVertexAttrib1fARB(int index, float x); + + /** + * @param index + * @param x + */ + public void glVertexAttrib1sARB(int index, short x); + + /** + * @param index + * @param x + * @param y + */ + public void glVertexAttrib2fARB(int index, float x, float y); + + /** + * @param index + * @param x + * @param y + */ + public void glVertexAttrib2sARB(int index, short x, short y); + + /** + * @param index + * @param x + * @param y + * @param z + */ + public void glVertexAttrib3fARB(int index, float x, float y, float z); + + /** + * @param index + * @param x + * @param y + * @param z + */ + public void glVertexAttrib3sARB(int index, short x, short y, short z); + + /** + * @param index + * @param x + * @param y + * @param z + * @param w + */ + public void glVertexAttrib4fARB(int index, float x, float y, + float z, float w); + + /** + * @param index + * @param x + * @param y + * @param z + * @param w + */ + public void glVertexAttrib4NubARB(int index, byte x, byte y, byte z, + byte w); + + /** + * @param index + * @param x + * @param y + * @param z + * @param w + */ + public void glVertexAttrib4sARB(int index, short x, short y, + short z, short w); + + /** + * @param index + * @param size + * @param unsigned + * @param normalized + * @param stride + * @param buffer + */ + public void glVertexAttribPointerARB(int index, int size, + boolean unsigned, boolean normalized, int stride, ByteBuffer buffer); + + + /** + * @param index + * @param size + * @param unsigned + * @param normalized + * @param stride + * @param buffer + */ + public void glVertexAttribPointerARB(int index, int size, + boolean unsigned, boolean normalized, int stride, IntBuffer buffer); + + + /** + * @param index + * @param size + * @param unsigned + * @param normalized + * @param stride + * @param buffer + */ + public void glVertexAttribPointerARB(int index, int size, + boolean unsigned, boolean normalized, int stride, ShortBuffer buffer); + + + /** + * @param index + * @param size + * @param normalized + * @param stride + * @param buffer + */ + public void glVertexAttribPointerARB(int index, int size, + boolean normalized, int stride, FloatBuffer buffer); + + + /** + * @param index + * @param size + * @param type + * @param normalized + * @param stride + * @param bufferOffset + */ + public void glVertexAttribPointerARB(int index, int size, int type, + boolean normalized, int stride, int bufferOffset); + + + /** + * @param sfactorRGB + * @param dfactorRGB + * @param sfactorAlpha + * @param dfactorAlpha + */ + public void glBlendFuncSeparateEXT(int sfactorRGB, int dfactorRGB, + int sfactorAlpha, int dfactorAlpha); + + + /** + * @param first + * @param count + */ + public void glLockArraysEXT(int first, int count); + + /** + * + */ + public void glUnlockArraysEXT(); + + /** + * @param zmin + * @param zmax + */ + public void glDepthBoundsEXT(float zmin, float zmax); + + /** + * @param mode + * @param start + * @param end + * @param pIndices + */ + public void glDrawRangeElementsEXT(int mode, int start, int end, + ByteBuffer pIndices); + + /** + * @param mode + * @param start + * @param end + * @param count + * @param type + * @param buffer_offset + */ + public void glDrawRangeElementsEXT(int mode, int start, int end, + int count, int type, int buffer_offset); + + + /** + * @param mode + * @param start + * @param end + * @param pIndices + */ + public void glDrawRangeElementsEXT(int mode, int start, int end, + IntBuffer pIndices); + + /** + * @param mode + * @param start + * @param end + * @param pIndices + */ + public void glDrawRangeElementsEXT(int mode, int start, int end, + ShortBuffer pIndices); + + /** + * @param coord + */ + public void glFogCoordfEXT(float coord); + + /** + * @param stride + * @param data + */ + public void glFogCoordPointerEXT(int stride, FloatBuffer data); + + /** + * @param type + * @param stride + * @param buffer_offset + */ + public void glFogCoordPointerEXT(int type, int stride, + int buffer_offset); + + /** + * @param mode + * @param piFirst + * @param piCount + */ + public void glMultiDrawArraysEXT(int mode, IntBuffer piFirst, + IntBuffer piCount); + + /** + * @param pname + * @param pfParams + */ + public void glPointParameterEXT(int pname, FloatBuffer pfParams); + + /** + * @param pname + * @param param + */ + public void glPointParameterfEXT(int pname, float param); + + /** + * @param red + * @param green + * @param blue + */ + public void glSecondaryColor3bEXT(byte red, byte green, byte blue); + + /** + * @param red + * @param green + * @param blue + */ + public void glSecondaryColor3fEXT(float red, float green, float blue); + + /** + * @param red + * @param green + * @param blue + */ + public void glSecondaryColor3ubEXT(byte red, byte green, byte blue); + + /** + * @param size + * @param unsigned + * @param stride + * @param pPointer + */ + public void glSecondaryColorPointerEXT(int size, boolean unsigned, + int stride, ByteBuffer pPointer); + + + /** + * @param size + * @param stride + * @param pPointer + */ + public void glSecondaryColorPointerEXT(int size, int stride, + FloatBuffer pPointer); + + /** + * @param size + * @param type + * @param stride + * @param buffer_offset + */ + public void glSecondaryColorPointerEXT(int size, int type, + int stride, int buffer_offset); + + + /** + * @param face + */ + public void glActiveStencilFaceEXT(int face); + + /** + * + */ + public void glBeginVertexShaderEXT(); + + /** + * @param light + * @param value + * @return + */ + public int glBindLightParameterEXT(int light, int value); + + /** + * @param face + * @param value + * @return + */ + public int glBindMaterialParameterEXT(int face, int value); + + /** + * @param value + * @return + */ + public int glBindParameterEXT(int value); + + /** + * @param unit + * @param coord + * @param value + * @return + */ + public int glBindTexGenParameterEXT(int unit, int coord, int value); + + /** + * @param unit + * @param value + * @return + */ + public int glBindTextureUnitParameterEXT(int unit, int value); + + /** + * @param id + */ + public void glBindVertexShaderEXT(int id); + + /** + * @param id + */ + public void glDeleteVertexShaderEXT(int id); + + /** + * @param id + */ + public void glDisableVariantClientStateEXT(int id); + + /** + * @param id + */ + public void glEnableVariantClientStateEXT(int id); + + /** + * + */ + public void glEndVertexShaderEXT(); + + /** + * @param res + * @param src + * @param num + */ + public void glExtractComponentEXT(int res, int src, int num); + + /** + * @param dataType + * @param storageType + * @param range + * @param components + * @return + */ + public int glGenSymbolsEXT(int dataType, int storageType, int range, + int components); + + + /** + * @param range + * @return + */ + public int glGenVertexShadersEXT(int range); + + /** + * @param id + * @param value + * @param pbData + */ + public void glGetInvariantBooleanEXT(int id, int value, + ByteBuffer pbData); + + /** + * @param id + * @param value + * @param pfData + */ + public void glGetInvariantFloatEXT(int id, int value, + FloatBuffer pfData); + + /** + * @param id + * @param value + * @param piData + */ + public void glGetInvariantIntegerEXT(int id, int value, + IntBuffer piData); + + /** + * @param id + * @param value + * @param pbData + */ + public void glGetLocalConstantBooleanEXT(int id, int value, + ByteBuffer pbData); + + /** + * @param id + * @param value + * @param pfData + */ + public void glGetLocalConstantFloatEXT(int id, int value, + FloatBuffer pfData); + + /** + * @param id + * @param value + * @param piData + */ + public void glGetLocalConstantIntegerEXT(int id, int value, + IntBuffer piData); + + /** + * @param id + * @param value + * @param pbData + */ + public void glGetVariantBooleanEXT(int id, int value, + ByteBuffer pbData); + + /** + * @param id + * @param value + * @param pfData + */ + public void glGetVariantFloatEXT(int id, int value, + FloatBuffer pfData); + + /** + * @param id + * @param value + * @param piData + */ + public void glGetVariantIntegerEXT(int id, int value, + IntBuffer piData); + + /** + * @param id + * @param value + * @param size + * @return + */ + public ByteBuffer glGetVariantPointerEXT(int id, int value, int size); + + /** + * @param res + * @param src + * @param num + */ + public void glInsertComponentEXT(int res, int src, int num); + + /** + * @param id + * @param cap + * @return + */ + public boolean glIsVariantEnabledEXT(int id, int cap); + + /** + * @param id + * @param unsigned + * @param pAddr + */ + public void glSetInvariantEXT(int id, boolean unsigned, + ByteBuffer pAddr); + + /** + * @param id + * @param unsigned + * @param pAddr + */ + public void glSetInvariantEXT(int id, boolean unsigned, + IntBuffer pAddr); + + /** + * @param id + * @param unsigned + * @param pAddr + */ + public void glSetInvariantEXT(int id, boolean unsigned, + ShortBuffer pAddr); + + /** + * @param id + * @param pAddr + */ + public void glSetInvariantEXT(int id, FloatBuffer pAddr); + + /** + * @param id + * @param unsigned + * @param pAddr + */ + public void glSetLocalConstantEXT(int id, boolean unsigned, + ByteBuffer pAddr); + + /** + * @param id + * @param unsigned + * @param pAddr + */ + public void glSetLocalConstantEXT(int id, boolean unsigned, + IntBuffer pAddr); + + /** + * @param id + * @param unsigned + * @param pAddr + */ + public void glSetLocalConstantEXT(int id, boolean unsigned, + ShortBuffer pAddr); + + /** + * @param id + * @param pAddr + */ + public void glSetLocalConstantEXT(int id, FloatBuffer pAddr); + + /** + * @param op + * @param res + * @param arg1 + */ + public void glShaderOp1EXT(int op, int res, int arg1); + + /** + * @param op + * @param res + * @param arg1 + * @param arg2 + */ + public void glShaderOp2EXT(int op, int res, int arg1, int arg2); + + /** + * @param op + * @param res + * @param arg1 + * @param arg2 + * @param arg3 + */ + public void glShaderOp3EXT(int op, int res, int arg1, int arg2, + int arg3); + + /** + * @param res + * @param in + * @param outX + * @param outY + * @param outZ + * @param outW + */ + public void glSwizzleEXT(int res, int in, int outX, int outY, + int outZ, int outW); + + /** + * @param id + * @param pAddr + */ + public void glVariantEXT(int id, ByteBuffer pAddr); + + /** + * @param id + * @param pfAddr + */ + public void glVariantEXT(int id, FloatBuffer pfAddr); + + /** + * @param id + * @param piAddr + */ + public void glVariantEXT(int id, IntBuffer piAddr); + + /** + * @param id + * @param psAddr + */ + public void glVariantEXT(int id, ShortBuffer psAddr); + + /** + * @param id + * @param unsigned + * @param stride + * @param pAddr + */ + public void glVariantPointerEXT(int id, boolean unsigned, + int stride, ByteBuffer pAddr); + + /** + * @param id + * @param unsigned + * @param stride + * @param pAddr + */ + public void glVariantPointerEXT(int id, boolean unsigned, + int stride, IntBuffer pAddr); + + /** + * @param id + * @param unsigned + * @param stride + * @param pAddr + */ + public void glVariantPointerEXT(int id, boolean unsigned, + int stride, ShortBuffer pAddr); + + /** + * @param id + * @param stride + * @param pAddr + */ + public void glVariantPointerEXT(int id, int stride, FloatBuffer pAddr); + + /** + * @param id + * @param type + * @param stride + * @param buffer_offset + */ + public void glVariantPointerEXT(int id, int type, int stride, + int buffer_offset); + + /** + * @param id + * @param pAddr + */ + public void glVariantuEXT(int id, ByteBuffer pAddr); + + /** + * @param id + * @param piAddr + */ + public void glVariantuEXT(int id, IntBuffer piAddr); + + /** + * @param id + * @param psAddr + */ + public void glVariantuEXT(int id, ShortBuffer psAddr); + + /** + * @param res + * @param in + * @param outX + * @param outY + * @param outZ + * @param outW + */ + public void glWriteMaskEXT(int res, int in, int outX, int outY, + int outZ, int outW); + + /** + * @param weight + */ + public void glVertexWeightfEXT(float weight); + + /** + * @param size + * @param stride + * @param pPointer + */ + public void glVertexWeightPointerEXT(int size, int stride, + FloatBuffer pPointer); + + /** + * @param size + * @param type + * @param stride + * @param buffer_offset + */ + public void glVertexWeightPointerEXT(int size, int type, int stride, + int buffer_offset); + + + + +} \ No newline at end of file