diff --git a/src/native/linux/Game.java b/src/native/linux/Game.java new file mode 100644 index 00000000..4c1cfc6e --- /dev/null +++ b/src/native/linux/Game.java @@ -0,0 +1,131 @@ +import org.lwjgl.*; +import org.lwjgl.opengl.*; +import org.lwjgl.input.*; + + +public final class Game { + static { + try { + DisplayMode[] modes = Display.getAvailableDisplayModes(); + System.out.println("Available display modes:"); + for (int i = 0; i < modes.length; i ++) + System.out.println(modes[i]); + // For now let's just pick a mode we're certain to have + Display.create(new DisplayMode(640, 480, 16, 60), true); + System.out.println("Created display."); + } catch (Exception e) { + System.err.println("Failed to create display due to "+e); + System.exit(1); + } + } + + public static final GL gl = new GL(16, 0, 16, 8); + public static final GLU glu = new GLU(gl); + static { + try { + gl.create(); + System.out.println("Created OpenGL."); + } catch (Exception e) { + System.err.println("Failed to create OpenGL due to "+e); + System.exit(1); + } + } + + /** Is the game finished? */ + private static boolean finished; + + /** A rotating square! */ + private static float angle; + + /** + * No construction allowed + */ + private Game() { + } + + public static void main(String[] arguments) { + try { + init(); + while (!finished) { +// Keyboard.poll(); + mainLoop(); + render(); + gl.swapBuffers(); + } + } catch (Throwable t) { + t.printStackTrace(); + } finally { + cleanup(); + } + } + + /** + * All calculations are done in here + */ + private static void mainLoop() { + angle += 1f; + if (angle > 360.0f) + angle = 0.0f; + + Mouse.poll(); + if (Mouse.dx != 0 || Mouse.dy != 0) + System.out.println("Mouse moved " + Mouse.dx + " " + Mouse.dy); + for (int i = 0; i < 8; i++) + if (Mouse.isButtonDown(i)) + System.out.println("Button " + i + " down"); +/* Keyboard.poll(); + if (Keyboard.isKeyDown(Keyboard.KEY_ESCAPE)) + finished = true;*/ + Keyboard.read(); + if (Keyboard.getNumKeyboardEvents() > 0) { + Keyboard.next(); + if (Keyboard.key == Keyboard.KEY_ESCAPE && Keyboard.state) + finished = true; + } + } + + /** + * All rendering is done in here + */ + private static void render() { + gl.clear(GL.COLOR_BUFFER_BIT); + gl.pushMatrix(); + gl.translatef(Display.getWidth() / 2, Display.getHeight() / 2, 0.0f); + gl.rotatef(angle, 0, 0, 1.0f); + gl.begin(GL.QUADS); + gl.vertex2i(-50, -50); + gl.vertex2i(50, -50); + gl.vertex2i(50, 50); + gl.vertex2i(-50, 50); + gl.end(); + gl.popMatrix(); + } + + /** + * Initialize + */ + private static void init() throws Exception { + Keyboard.create(); + Keyboard.enableBuffer(); + Mouse.create(); + // Go into orthographic projection mode. + gl.matrixMode(GL.PROJECTION); + gl.loadIdentity(); + glu.ortho2D(0, Display.getWidth(), 0, Display.getHeight()); + gl.matrixMode(GL.MODELVIEW); + gl.loadIdentity(); + gl.viewport(0, 0, Display.getWidth(), Display.getHeight()); + // Fix the refresh rate to the display frequency. + gl.wglSwapIntervalEXT(1); + } + + /** + * Cleanup + */ + private static void cleanup() { + Keyboard.destroy(); + Mouse.destroy(); + gl.destroy(); + Display.destroy(); + } + } diff --git a/src/native/linux/Makefile b/src/native/linux/Makefile new file mode 100644 index 00000000..7822e727 --- /dev/null +++ b/src/native/linux/Makefile @@ -0,0 +1,29 @@ +GCC = gcc +LINK = gcc +JAVAHOME=/usr/java/j2sdk1.4.1_01 +JAVAC=$(JAVAHOME)/bin/javac +JAVAH=$(JAVAHOME)/bin/javah +CP=../../java +JAVAFILES=$(shell find ../../java -name \*.java -print|grep -v CVS) +CLASSFILES=$(JAVAFILES:.java=.class) + +all: liblwjgl.so + +liblwjgl.so: org_lwjgl_Display.o org_lwjgl_Sys.o org_lwjgl_opengl_BaseGL.o org_lwjgl_opengl_GL.o org_lwjgl_opengl_CoreGL.o org_lwjgl_input_Keyboard.o org_lwjgl_opengl_GLU.o org_lwjgl_input_Mouse.o + $(LINK) -shared -o $@ $^ -L/usr/X11R6/lib -lX11 -lXext -lXxf86vm -lGL -lGLU + cp $@ ../../../bin/ + +.SUFFIXES: .cpp .so .o .java .h .class + +%.class: %.java + $(JAVAC) -deprecation -O -source 1.4 -classpath $(CP) $< + +%.o : %.c + $(GCC) -Wall -I$(JAVAHOME)/include -I../common -I$(JAVAHOME)/include/linux -c -o $@ $< + +testprog : main.o + $(LINK) -o $@ $< -L/usr/X11R6/lib -lX11 -lXext -lXxf86vm -lGL -lGLU + +.PHONY clean: + rm -rf *.o *.so + rm -rf `find ../../ -name \*.class -print` diff --git a/src/native/linux/org_lwjgl_Display.c b/src/native/linux/org_lwjgl_Display.c new file mode 100644 index 00000000..a49811df --- /dev/null +++ b/src/native/linux/org_lwjgl_Display.c @@ -0,0 +1,174 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "org_lwjgl_Display.h" + + +Display * disp; +int screen; +Window win; +XF86VidModeModeInfo **avail_modes; +XVisualInfo * vis_info; + +void waitMapped(Display *disp, Window win) { + XEvent event; + + do { + XMaskEvent(disp, StructureNotifyMask, &event); + } while ((event.type != MapNotify) || (event.xmap.event != win)); +} + +int getDisplayModes(Display *disp, int screen, int *num_modes, XF86VidModeModeInfo ***avail_modes) { + unsigned int event_base, error_base, xvid_ver, xvid_rev; + + if (!XF86VidModeQueryExtension(disp, &event_base, &error_base)) { +#ifdef _DEBUG + printf("XF86VidMode extention not available\n"); +#endif + return 0; + } + XF86VidModeQueryVersion(disp, &xvid_ver, &xvid_rev); +#ifdef _DEBUG + printf("XF86VidMode extention version %i.%i\n", xvid_ver, xvid_rev); +#endif + XF86VidModeGetAllModeLines(disp, screen, num_modes, avail_modes); + return 1; +} + +JNIEXPORT jboolean JNICALL Java_org_lwjgl_Display_nCreate(JNIEnv * env, jclass clazz, jint width, jint height, jint bpp, jint freq, jboolean fullscreen) { + Window root_win; + XSetWindowAttributes attribs; + Colormap cmap; + int attribmask; + int bpe = bpp/4; + int attriblist[] = {GLX_RGBA, GLX_DOUBLEBUFFER, GLX_DEPTH_SIZE, 24, GLX_RED_SIZE, bpe, GLX_GREEN_SIZE, bpe, GLX_BLUE_SIZE, bpe, GLX_ALPHA_SIZE, bpe, None}; + int num_modes, i; + + disp = XOpenDisplay(NULL); + if (disp == NULL) { +#ifdef _DEBUG + printf("Could not open X connection\n"); +#endif + return JNI_FALSE; + } + screen = DefaultScreen(disp); + root_win = RootWindow(disp, screen); + + vis_info = glXChooseVisual(disp, screen, attriblist); + if (vis_info == NULL) { +#ifdef _DEBUG + printf("Could not choose glx visual\n"); +#endif + return JNI_FALSE; + } + + cmap = XCreateColormap(disp, root_win, vis_info->visual, AllocNone); + attribs.colormap = cmap; + attribs.event_mask = ExposureMask | FocusChangeMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask; + attribs.background_pixel = 0xFF000000; + attribs.event_mask = StructureNotifyMask; + attribmask = CWColormap | CWBackPixel | CWEventMask; + if (fullscreen) { + attribmask |= CWOverrideRedirect; + attribs.override_redirect = True; + } + win = XCreateWindow(disp, root_win, 0, 0, width, height, 0, vis_info->depth, InputOutput, vis_info->visual, attribmask, &attribs); +#ifdef _DEBUG + printf("Created window\n"); +#endif + if (fullscreen) { + XMapRaised(disp, win); + waitMapped(disp, win); + if (!getDisplayModes(disp, screen, &num_modes, &avail_modes)) { +#ifdef _DEBUG + printf("Could not get display modes\n"); +#endif + return JNI_FALSE; + } + for ( i = 0; i < num_modes; ++i ) { +#ifdef _DEBUG + printf("Mode %d: %dx%d\n", i, avail_modes[i]->hdisplay, avail_modes[i]->vdisplay); +#endif + if (avail_modes[i]->hdisplay == width && avail_modes[i]->vdisplay == height) { + if (!XF86VidModeSwitchToMode(disp, screen, avail_modes[i])) { +#ifdef _DEBUG + printf("Could not switch mode\n"); +#endif + return JNI_FALSE; + } + } + } + XF86VidModeSetViewPort(disp, screen, 0, 0); + } else { + XMapWindow(disp, win); + waitMapped(disp, win); + } + XClearWindow(disp, win); + XSync(disp, True); + + return JNI_TRUE; +} + +JNIEXPORT void JNICALL Java_org_lwjgl_Display_nDestroy(JNIEnv * env, jclass clazz) { + XDestroyWindow(disp, win); + if (!XF86VidModeSwitchToMode(disp, screen, avail_modes[0])) { +#ifdef _DEBUG + printf("Could not switch mode\n"); +#endif + } + XFree(vis_info); + XFree(avail_modes); + XCloseDisplay(disp); +#ifdef _DEBUG + printf("Closed X connection\n"); +#endif +} + +/* + * Class: org_lwjgl_Display + * Method: getAvailableDisplayModes + * Signature: ()[Lorg/lwjgl/DisplayMode; + */ +JNIEXPORT jobjectArray JNICALL Java_org_lwjgl_Display_getAvailableDisplayModes + (JNIEnv * env, jclass clazz) +{ + int num_modes, i; + + Display *disp = XOpenDisplay(NULL); + int screen = DefaultScreen(disp); + XF86VidModeModeInfo **avail_modes; + + int depth = DefaultDepth(disp, screen); + + if (disp == NULL) { +#ifdef _DEBUG + printf("Could not open X connection\n"); +#endif + return NULL; + } + if (!getDisplayModes(disp, screen, &num_modes, &avail_modes)) { +#ifdef _DEBUG + printf("Could not get display modes\n"); +#endif + return NULL; + } + // Allocate an array of DisplayModes big enough + jclass displayModeClass = (*env)->FindClass(env, "org/lwjgl/DisplayMode"); + jobjectArray ret = (*env)->NewObjectArray(env, num_modes, displayModeClass, NULL); + jmethodID displayModeConstructor = (*env)->GetMethodID(env, displayModeClass, "", "(IIII)V"); + + for (i = 0; i < num_modes; i++) { + jobject displayMode = (*env)->NewObject(env, displayModeClass, displayModeConstructor, avail_modes[i]->hdisplay, avail_modes[i]->vdisplay, depth, 0); + (*env)->SetObjectArrayElement(env, ret, i, displayMode); + } + XFree(avail_modes); + XCloseDisplay(disp); + return ret; +} + diff --git a/src/native/linux/org_lwjgl_Sys.c b/src/native/linux/org_lwjgl_Sys.c new file mode 100644 index 00000000..13550102 --- /dev/null +++ b/src/native/linux/org_lwjgl_Sys.c @@ -0,0 +1,140 @@ +/* + * 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. + */ + +/** + * $Id$ + * + * Win32 system library. + * + * @author cix_foo + * @version $Revision$ + */ + +#include "org_lwjgl_Sys.h" + +long int hires_timer_freq; // Hires timer frequency +long int hires_timer_start; // Hires timer start +long int hires_timer; // Hires timer current time + +/* + * Class: org_lwjgl_Sys + * Method: getDirectBufferAddress + * Signature: (Ljava/nio/Buffer;)I + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_Sys_getDirectBufferAddress + (JNIEnv * env, jclass clazz, jobject buf) +{ + return (jint) (*env)->GetDirectBufferAddress(env, buf); +} + +/* + * Class: org_lwjgl_Sys + * Method: createDirectBuffer + * Signature: (II)Ljava/nio/ByteBuffer; + */ +JNIEXPORT jobject JNICALL Java_org_lwjgl_Sys_createDirectBuffer + (JNIEnv * env, jclass clazz, jint address, jint length) +{ + return (*env)->NewDirectByteBuffer(env, (void *)address, length); +} + +/* + * Class: org_lwjgl_Sys + * Method: getTimerResolution + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_lwjgl_Sys_getTimerResolution + (JNIEnv * env, jclass clazz) +{ + return hires_timer_freq; +} + +/* + * Class: org_lwjgl_Sys + * Method: getTime + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_org_lwjgl_Sys_getTime + (JNIEnv * env, jclass clazz) +{ +// QueryPerformanceCounter((LARGE_INTEGER*) &hires_timer); + hires_timer -= hires_timer_start; + return hires_timer; +} + +/* + * Class: org_lwjgl_Sys + * Method: setTime + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_lwjgl_Sys_setTime + (JNIEnv * env, jclass clazz, jlong startTime) +{ +/* QueryPerformanceFrequency((LARGE_INTEGER*) &hires_timer_freq); + QueryPerformanceCounter((LARGE_INTEGER*) &hires_timer_start);*/ + hires_timer_start -= startTime; +} + +/* + * Class: org_lwjgl_Sys + * Method: setProcessPriority + * Signature: (I)V + */ +JNIEXPORT void JNICALL Java_org_lwjgl_Sys_setProcessPriority + (JNIEnv * env, jclass clazz, jint priority) +{ +/* HANDLE me = GetCurrentProcess(); + int win32priority; + + switch (priority) { + case org_lwjgl_Sys_REALTIME_PRIORITY: + win32priority = REALTIME_PRIORITY_CLASS; + break; + case org_lwjgl_Sys_HIGH_PRIORITY: + win32priority = HIGH_PRIORITY_CLASS; + break; + case org_lwjgl_Sys_NORMAL_PRIORITY: + win32priority = NORMAL_PRIORITY_CLASS; + break; + case org_lwjgl_Sys_LOW_PRIORITY: + win32priority = IDLE_PRIORITY_CLASS; + break; + default: + return; + } + + if (!SetPriorityClass(me, win32priority)) { +#ifdef _DEBUG + printf("Failed to set priority class.\n"); +#endif + }*/ +} diff --git a/src/native/linux/org_lwjgl_input_Keyboard.c b/src/native/linux/org_lwjgl_input_Keyboard.c new file mode 100644 index 00000000..4abdd1c1 --- /dev/null +++ b/src/native/linux/org_lwjgl_input_Keyboard.c @@ -0,0 +1,163 @@ +/* + * 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. + */ + +/** + * $Id$ + * + * Win32 keyboard handling. + * + * @author cix_foo + * @version $Revision$ + */ + +#include +#include +#include +#include +#include "org_lwjgl_input_Keyboard.h" + +#define KEYBOARD_BUFFER_SIZE 50 +#define KEYBOARD_SIZE 256 +short readBuffer[KEYBOARD_BUFFER_SIZE]; +jfieldID fid_readBuffer; +jfieldID fid_readBufferAddress; +unsigned char key_buf[KEYBOARD_SIZE]; + +extern Display *disp; +extern Window win; + +/* + * Class: org_lwjgl_input_Keyboard + * Method: initIDs + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_org_lwjgl_input_Keyboard_initIDs + (JNIEnv * env, jclass clazz) +{ + // Get a global class instance, just to be sure + static jobject globalClassLock = NULL; + + if (globalClassLock == NULL) { + globalClassLock = (*env)->NewGlobalRef(env, clazz); + } + + fid_readBuffer = (*env)->GetStaticFieldID(env, clazz, "readBuffer", "Ljava/nio/ByteBuffer;"); + fid_readBufferAddress = (*env)->GetStaticFieldID(env, clazz, "readBufferAddress", "I"); +} + +/* + * Class: org_lwjgl_input_Keyboard + * Method: nCreate + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_input_Keyboard_nCreate + (JNIEnv * env, jclass clazz) +{ + int result = XGrabKeyboard(disp, win, False, GrabModeAsync, GrabModeAsync, CurrentTime); + if (result != GrabSuccess) { +#ifdef _DEBUG + printf("Could not grab keyboard\n"); +#endif + return JNI_FALSE; + } + memset(key_buf, 0, KEYBOARD_SIZE*sizeof(unsigned char)); + return JNI_TRUE; +} + +/* + * Class: org_lwjgl_input_Keyboard + * Method: nDestroy + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_org_lwjgl_input_Keyboard_nDestroy + (JNIEnv * env, jclass clazz) +{ + XUngrabKeyboard(disp, CurrentTime); +} + +int checkKeyEvents(unsigned char *result_buf) { + XEvent event; + int count = 0; + int buf_count = 0; + while (XCheckMaskEvent(disp, KeyPressMask | KeyReleaseMask, &event)) { + unsigned char keycode = (unsigned char)((event.xkey.keycode - 8) & 0xff); + if (result_buf != NULL) { + result_buf[buf_count++] = keycode; + result_buf[buf_count++] = 1; + } + count++; + if (event.type == KeyPress) { + key_buf[keycode] = 1; + } else if (event.type == KeyRelease) { + key_buf[keycode] = 0; + } else + assert(0); + } + return count; +} + +/* + * Class: org_lwjgl_input_Keyboard + * Method: nPoll + * Signature: (I)V + */ +JNIEXPORT void JNICALL Java_org_lwjgl_input_Keyboard_nPoll + (JNIEnv * env, jclass clazz, jint buf) +{ + checkKeyEvents(NULL); + memcpy((unsigned char*)buf, key_buf, KEYBOARD_SIZE*sizeof(unsigned char)); +} + +/* + * Class: org_lwjgl_input_Keyboard + * Method: nRead + * Signature: (I)V + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_input_Keyboard_nRead + (JNIEnv * env, jclass clazz, jint keys) +{ + return checkKeyEvents((unsigned char *)keys); +} + +/* + * Class: org_lwjgl_input_Keyboard + * Method: nEnableBuffer + * Signature: ()I + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_input_Keyboard_nEnableBuffer + (JNIEnv * env, jclass clazz) +{ + jobject newBuffer = (*env)->NewDirectByteBuffer(env, &readBuffer, KEYBOARD_BUFFER_SIZE); + (*env)->SetStaticObjectField(env, clazz, fid_readBuffer, newBuffer); + (*env)->SetStaticIntField(env, clazz, fid_readBufferAddress, (jint) (&readBuffer)); + return KEYBOARD_BUFFER_SIZE; +} diff --git a/src/native/linux/org_lwjgl_input_Mouse.c b/src/native/linux/org_lwjgl_input_Mouse.c new file mode 100644 index 00000000..eb17d3c5 --- /dev/null +++ b/src/native/linux/org_lwjgl_input_Mouse.c @@ -0,0 +1,191 @@ +/* + * 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. + */ + +/** + * $Id$ + * + * Win32 mouse handling. + * + * @author cix_foo + * @version $Revision$ + */ + + +#include +#include +#include +#include +#include "org_lwjgl_input_Mouse.h" + +#define NUM_BUTTONS 8 + +extern Display *disp; +extern Window win; + +jfieldID fid_button; +jfieldID fid_dx; +jfieldID fid_dy; +jfieldID fid_dz; + +int last_x; +int last_y; +int current_x; +int current_y; +unsigned char buttons[NUM_BUTTONS]; + +/* + * Class: org_lwjgl_input_Mouse + * Method: initIDs + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_org_lwjgl_input_Mouse_initIDs + (JNIEnv * env, jclass clazz) +{ + // Get a global class instance, just to be sure + static jobject globalClassLock = NULL; + + if (globalClassLock == NULL) { + globalClassLock = (*env)->NewGlobalRef(env, clazz); + } + + // Now cache the field IDs: + if (fid_button == NULL) { + fid_button = (*env)->GetStaticFieldID(env, clazz, "button", "[Z"); + } + if (fid_dx == NULL) { + fid_dx = (*env)->GetStaticFieldID(env, clazz, "dx", "I"); + } + if (fid_dy == NULL) { + fid_dy = (*env)->GetStaticFieldID(env, clazz, "dy", "I"); + } + if (fid_dz == NULL) { + fid_dz = (*env)->GetStaticFieldID(env, clazz, "dz", "I"); + } +} + +/* + * Class: org_lwjgl_input_Mouse + * Method: nCreate + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_input_Mouse_nCreate + (JNIEnv * env, jclass clazz) +{ + int i; + current_x = current_y = last_x = last_y = 0; + for (i = 0; i < NUM_BUTTONS; i++) + buttons[i] = 0; + int result = XGrabPointer(disp, win, False, PointerMotionMask | ButtonPressMask | ButtonReleaseMask, GrabModeAsync, GrabModeAsync, win, None, CurrentTime); + if (result != GrabSuccess) { +#ifdef _DEBUG + printf("Could not grab mouse\n"); +#endif + return JNI_FALSE; + } + return JNI_TRUE; +} + +/* + * Class: org_lwjgl_input_Mouse + * Method: nDestroy + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_org_lwjgl_input_Mouse_nDestroy + (JNIEnv * env, jclass clazz) +{ + XUngrabPointer(disp, CurrentTime); +} + +void setButtonState(XButtonEvent event, unsigned char val) { + switch (event.button) { + case Button1: + buttons[0] = val; + break; + case Button2: + buttons[1] = val; + break; + case Button3: + buttons[2] = val; + break; + case Button4: + buttons[3] = val; + break; + case Button5: + buttons[4] = val; + break; + default: assert(0); + } +} + +int checkPointer() { + XEvent event; + int count = 0; + while (XCheckMaskEvent(disp, ButtonPressMask | ButtonReleaseMask | PointerMotionMask, &event)) { + count++; + switch (event.type) { + case ButtonPress: + setButtonState(event.xbutton, 1); + break; + case ButtonRelease: + setButtonState(event.xbutton, 0); + break; + case MotionNotify: + current_x = event.xbutton.x; + current_y = event.xbutton.y; + break; + default: assert(0); + } + } + return count; +} + +/* + * Class: org_lwjgl_input_Mouse + * Method: nPoll + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_org_lwjgl_input_Mouse_nPoll + (JNIEnv * env, jclass clazz) +{ + checkPointer(); + int moved_x = current_x - last_x; + int moved_y = current_y - last_y; + (*env)->SetStaticIntField(env, clazz, fid_dx, (jint)moved_x); + (*env)->SetStaticIntField(env, clazz, fid_dy, (jint)moved_y); + (*env)->SetStaticIntField(env, clazz, fid_dz, (jint)0); + last_x = current_x; + last_y = current_y; + jbooleanArray buttonsArray = (jbooleanArray) (*env)->GetStaticObjectField(env, clazz, fid_button); + unsigned char * class_buttons = (unsigned char *) (*env)->GetPrimitiveArrayCritical(env, buttonsArray, NULL); + memcpy(class_buttons, buttons, NUM_BUTTONS*sizeof(unsigned char)); + (*env)->ReleasePrimitiveArrayCritical(env, buttonsArray, class_buttons, 0); +} diff --git a/src/native/linux/org_lwjgl_opengl_BaseGL.c b/src/native/linux/org_lwjgl_opengl_BaseGL.c new file mode 100644 index 00000000..75a98d33 --- /dev/null +++ b/src/native/linux/org_lwjgl_opengl_BaseGL.c @@ -0,0 +1,111 @@ +/* + * 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. + */ + +/** + * $Id$ + * + * Base Win32 functionality for GL. + * + * @author cix_foo + * @version $Revision$ + */ + +#include +#include "org_lwjgl_opengl_BaseGL.h" + +GLXContext context = NULL; // OpenGL rendering context +extern XVisualInfo * vis_info; +extern Window win; +extern Display * disp; + +/* + * Class: org_lwjgl_opengl_BaseGL + * Method: nCreate + * Signature: (IIII)Z + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_BaseGL_nCreate + (JNIEnv * env, jobject obj, jint colorBits, jint alphaBits, jint depthBits, jint stencilBits) +{ + + if (!vis_info) { +#ifdef _DEBUG + printf("No visual info\n"); +#endif + return JNI_FALSE; + } + context = glXCreateContext(disp, vis_info, NULL, True); + if (!context) { +#ifdef _DEBUG + printf("Could not create context\n"); +#endif + return JNI_FALSE; + } + + return JNI_TRUE; +} + +/* + * Class: org_lwjgl_opengl_BaseGL + * Method: nDestroy + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_BaseGL_nDestroy + (JNIEnv * env, jobject obj) +{ + glXMakeCurrent(disp, None, NULL); + + // Delete the rendering context + if (context != NULL) + glXDestroyContext(disp, context); +} + +/* + * Class: org_lwjgl_opengl_BaseGL + * Method: swapBuffers + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_BaseGL_swapBuffers(JNIEnv * env, jobject obj) +{ + glXSwapBuffers(disp, win); +} + +/* + * Class: org_lwjgl_opengl_BaseGL + * Method: nMakeCurrent + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_BaseGL_nMakeCurrent + (JNIEnv * env, jobject obj) +{ + glXMakeCurrent(disp, win, context); +} + diff --git a/src/native/linux/org_lwjgl_opengl_CoreGL.c b/src/native/linux/org_lwjgl_opengl_CoreGL.c new file mode 100644 index 00000000..999df306 --- /dev/null +++ b/src/native/linux/org_lwjgl_opengl_CoreGL.c @@ -0,0 +1,3210 @@ +/* + * 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. + */ + +/** + * $Id$ + * + * Core OpenGL functions. + * + * @author cix_foo + * @version $Revision$ + */ + +#include "org_lwjgl_opengl_CoreGL.h" +#include "checkGLerror.h" +#include + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: accum + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_accum(JNIEnv * env, jobject obj, jint p0, jfloat p1) +{ + glAccum((GLint) p0, (GLfloat) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: alphaFunc + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_alphaFunc(JNIEnv * env, jobject obj, jint p0, jfloat p1) +{ + glAlphaFunc((GLint) p0, (GLfloat) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: clearColor + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_clearColor(JNIEnv * env, jobject obj, jfloat p0, jfloat p1, jfloat p2, jfloat p3) +{ + glClearColor((GLfloat) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: clearAccum + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_clearAccum(JNIEnv * env, jobject obj, jfloat p0, jfloat p1, jfloat p2, jfloat p3) +{ + glClearAccum((GLfloat) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: clear + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_clear(JNIEnv * env, jobject obj, jint p0) +{ + glClear((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: callLists + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_callLists(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glCallLists((GLint) p0, (GLint) p1, (const void *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: callList + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_callList(JNIEnv * env, jobject obj, jint p0) +{ + glCallList((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: blendFunc + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_blendFunc(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glBlendFunc((GLint) p0, (GLint) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: blendColorEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_blendColorEXT(JNIEnv * env, jobject obj, jfloat p0, jfloat p1, jfloat p2, jfloat p3) +{ + glBlendColor((GLfloat) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: bitmap + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_bitmap(JNIEnv * env, jobject obj, jint p0, jint p1, jfloat p2, jfloat p3, jfloat p4, jfloat p5, jint p6) +{ + glBitmap((GLint) p0, (GLint) p1, (GLfloat) p2, (GLfloat) p3, (GLfloat) p4, (GLfloat) p5, (const unsigned char *) p6); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: bindTexture + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_bindTexture(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glBindTexture((GLint) p0, (GLint) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: begin + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_begin(JNIEnv * env, jobject obj, jint p0) +{ + glBegin((GLint) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: end + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_end(JNIEnv * env, jobject obj) +{ + glEnd(); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: arrayElement + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_arrayElement(JNIEnv * env, jobject obj, jint p0) +{ + glArrayElement((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: areTexturesResident + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_CoreGL_areTexturesResident(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + jboolean ret = (jboolean) glAreTexturesResident((GLint) p0, (const GLuint *) p1, (GLboolean *) p2); + CHECK_GL_ERROR + return ret; +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: clearDepth + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_clearDepth(JNIEnv * env, jobject obj, jdouble p0) +{ + glClearDepth((GLdouble) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: deleteLists + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_deleteLists(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glDeleteLists((GLint) p0, (GLint) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: deleteTextures + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_deleteTextures(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glDeleteTextures((GLint) p0, (const GLuint *) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: cullFace + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_cullFace(JNIEnv * env, jobject obj, jint p0) +{ + glCullFace((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: copyTexSubImage2D + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_copyTexSubImage2D(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6, jint p7) +{ + glCopyTexSubImage2D((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6, (GLint) p7); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: copyTexSubImage1D + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_copyTexSubImage1D(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5) +{ + glCopyTexSubImage1D((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: copyTexImage2D + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_copyTexImage2D(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6, jint p7) +{ + glCopyTexImage2D((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6, (GLint) p7); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: copyTexImage1D + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_copyTexImage1D(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6) +{ + glCopyTexImage1D((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: copyPixels + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_copyPixels(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4) +{ + glCopyPixels((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: colorPointer + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_colorPointer(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ + glColorPointer((GLint) p0, (GLint) p1, (GLint) p2, (const void *) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: colorMaterial + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_colorMaterial(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glColorMaterial((GLint) p0, (GLint) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: colorMask + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_colorMask(JNIEnv * env, jobject obj, jboolean p0, jboolean p1, jboolean p2, jboolean p3) +{ + glColorMask((GLboolean) p0, (GLboolean) p1, (GLboolean) p2, (GLboolean) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: color3b + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_color3b(JNIEnv * env, jobject obj, jbyte p0, jbyte p1, jbyte p2) +{ + glColor3b((GLbyte) p0, (GLbyte) p1, (GLbyte) p2); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: color3d + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_color3d(JNIEnv * env, jobject obj, jdouble p0, jdouble p1, jdouble p2) +{ + glColor3d((GLdouble) p0, (GLdouble) p1, (GLdouble) p2); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: color3f + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_color3f(JNIEnv * env, jobject obj, jfloat p0, jfloat p1, jfloat p2) +{ + glColor3f((GLfloat) p0, (GLfloat) p1, (GLfloat) p2); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: color3i + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_color3i(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glColor3i((GLint) p0, (GLint) p1, (GLint) p2); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: color3s + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_color3s(JNIEnv * env, jobject obj, jshort p0, jshort p1, jshort p2) +{ + glColor3s((GLshort) p0, (GLshort) p1, (GLshort) p2); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: color3ub + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_color3ub(JNIEnv * env, jobject obj, jbyte p0, jbyte p1, jbyte p2) +{ + glColor3ub((GLbyte) p0, (GLbyte) p1, (GLbyte) p2); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: color3ui + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_color3ui(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glColor3ui((GLint) p0, (GLint) p1, (GLint) p2); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: color3us + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_color3us(JNIEnv * env, jobject obj, jshort p0, jshort p1, jshort p2) +{ + glColor3us((GLshort) p0, (GLshort) p1, (GLshort) p2); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: color4b + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_color4b(JNIEnv * env, jobject obj, jbyte p0, jbyte p1, jbyte p2, jbyte p3) +{ + glColor4b((GLbyte) p0, (GLbyte) p1, (GLbyte) p2, (GLbyte) p3); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: color4d + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_color4d(JNIEnv * env, jobject obj, jdouble p0, jdouble p1, jdouble p2, jdouble p3) +{ + glColor4d((GLdouble) p0, (GLdouble) p1, (GLdouble) p2, (GLdouble) p3); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: color4f + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_color4f(JNIEnv * env, jobject obj, jfloat p0, jfloat p1, jfloat p2, jfloat p3) +{ + glColor4f((GLfloat) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: color4i + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_color4i(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ + glColor4i((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: color4s + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_color4s(JNIEnv * env, jobject obj, jshort p0, jshort p1, jshort p2, jshort p3) +{ + glColor4s((GLshort) p0, (GLshort) p1, (GLshort) p2, (GLshort) p3); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: color4ub + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_color4ub(JNIEnv * env, jobject obj, jbyte p0, jbyte p1, jbyte p2, jbyte p3) +{ + glColor4ub((GLbyte) p0, (GLbyte) p1, (GLbyte) p2, (GLbyte) p3); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: color4ui + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_color4ui(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ + glColor4ui((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: color4us + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_color4us(JNIEnv * env, jobject obj, jshort p0, jshort p1, jshort p2, jshort p3) +{ + glColor4us((GLshort) p0, (GLshort) p1, (GLshort) p2, (GLshort) p3); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: clipPlane + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_clipPlane(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glClipPlane((GLint) p0, (const GLdouble *) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: clearStencil + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_clearStencil(JNIEnv * env, jobject obj, jint p0) +{ + glClearStencil((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: clearIndex + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_clearIndex(JNIEnv * env, jobject obj, jfloat p0) +{ + glClearIndex((GLfloat) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: evalPoint1 + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_evalPoint1(JNIEnv * env, jobject obj, jint p0) +{ + glEvalPoint1((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: evalPoint2 + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_evalPoint2(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glEvalPoint2((GLint) p0, (GLint) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: evalMesh1 + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_evalMesh1(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glEvalMesh1((GLint) p0, (GLint) p1, (GLint) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: evalMesh2 + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_evalMesh2(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4) +{ + glEvalMesh2((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: evalCoord1d + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_evalCoord1d(JNIEnv * env, jobject obj, jdouble p0) +{ + glEvalCoord1d((GLdouble) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: evalCoord1f + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_evalCoord1f(JNIEnv * env, jobject obj, jfloat p0) +{ + glEvalCoord1f((GLfloat) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: evalCoord2d + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_evalCoord2d(JNIEnv * env, jobject obj, jdouble p0, jdouble p1) +{ + glEvalCoord2d((GLdouble) p0, (GLdouble) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: evalCoord2f + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_evalCoord2f(JNIEnv * env, jobject obj, jfloat p0, jfloat p1) +{ + glEvalCoord2f((GLfloat) p0, (GLfloat) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: evalCoord1dv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_evalCoord1dv(JNIEnv * env, jobject obj, jint p0) +{ + glEvalCoord1dv((const GLdouble *) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: evalCoord1fv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_evalCoord1fv(JNIEnv * env, jobject obj, jint p0) +{ + glEvalCoord1fv((const GLfloat *) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: evalCoord2dv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_evalCoord2dv(JNIEnv * env, jobject obj, jint p0) +{ + glEvalCoord2dv((const GLdouble *) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: evalCoord2fv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_evalCoord2fv(JNIEnv * env, jobject obj, jint p0) +{ + glEvalCoord2fv((const GLfloat *) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: enableClientState + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_enableClientState(JNIEnv * env, jobject obj, jint p0) +{ + glEnableClientState((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: disableClientState + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_disableClientState(JNIEnv * env, jobject obj, jint p0) +{ + glDisableClientState((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: enable + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_enable(JNIEnv * env, jobject obj, jint p0) +{ + glEnable((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: disable + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_disable(JNIEnv * env, jobject obj, jint p0) +{ + glDisable((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: edgeFlagPointer + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_edgeFlagPointer(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glEdgeFlagPointer((GLint) p0, (const void *) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: edgeFlag + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_edgeFlag(JNIEnv * env, jobject obj, jboolean p0) +{ + glEdgeFlag((GLboolean) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: edgeFlagv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_edgeFlagv(JNIEnv * env, jobject obj, jint p0) +{ + glEdgeFlagv((const unsigned char *) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: drawPixels + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_drawPixels(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4) +{ + glDrawPixels((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (const void *) p4); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: drawElements + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_drawElements(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ + glDrawElements((GLint) p0, (GLint) p1, (GLint) p2, (const void *) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: drawBuffer + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_drawBuffer(JNIEnv * env, jobject obj, jint p0) +{ + glDrawBuffer((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: drawArrays + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_drawArrays(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glDrawArrays((GLint) p0, (GLint) p1, (GLint) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: depthRange + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_depthRange(JNIEnv * env, jobject obj, jdouble p0, jdouble p1) +{ + glDepthRange((GLdouble) p0, (GLdouble) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: depthMask + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_depthMask(JNIEnv * env, jobject obj, jboolean p0) +{ + glDepthMask((GLboolean) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: depthFunc + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_depthFunc(JNIEnv * env, jobject obj, jint p0) +{ + glDepthFunc((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: feedbackBuffer + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_feedbackBuffer(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glFeedbackBuffer((GLint) p0, (GLint) p1, (GLfloat *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getPixelMapfv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getPixelMapfv(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glGetPixelMapfv((GLint) p0, (GLfloat *) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getPixelMapuiv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getPixelMapuiv(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glGetPixelMapuiv((GLint) p0, (GLuint *) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getPixelMapusv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getPixelMapusv(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glGetPixelMapusv((GLint) p0, (GLushort *) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getMaterialfv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getMaterialfv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glGetMaterialfv((GLint) p0, (GLint) p1, (GLfloat *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getMaterialiv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getMaterialiv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glGetMaterialiv((GLint) p0, (GLint) p1, (GLint *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getMapdv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getMapdv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glGetMapdv((GLint) p0, (GLint) p1, (GLdouble *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getMapfv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getMapfv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glGetMapfv((GLint) p0, (GLint) p1, (GLfloat *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getMapiv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getMapiv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glGetMapiv((GLint) p0, (GLint) p1, (GLint *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getLightfv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getLightfv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glGetLightfv((GLint) p0, (GLint) p1, (GLfloat *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getLightiv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getLightiv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glGetLightiv((GLint) p0, (GLint) p1, (GLint *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getError + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_CoreGL_getError(JNIEnv * env, jobject obj) +{ + jint ret = (jint) glGetError(); + CHECK_GL_ERROR + return ret; +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getClipPlane + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getClipPlane(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glGetClipPlane((GLint) p0, (GLdouble *) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getBooleanv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getBooleanv(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glGetBooleanv((GLint) p0, (GLubyte *) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getDoublev + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getDoublev(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glGetDoublev((GLint) p0, (GLdouble *) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getFloatv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getFloatv(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glGetFloatv((GLint) p0, (GLfloat *) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getIntegerv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getIntegerv(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glGetIntegerv((GLint) p0, (GLint *) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: genTextures + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_genTextures(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glGenTextures((GLint) p0, (GLuint *) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: genLists + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_CoreGL_genLists(JNIEnv * env, jobject obj, jint p0) +{ + jint ret = (jint) glGenLists((GLint) p0); + CHECK_GL_ERROR + return ret; +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: frustum + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_frustum(JNIEnv * env, jobject obj, jdouble p0, jdouble p1, jdouble p2, jdouble p3, jdouble p4, jdouble p5) +{ + glFrustum((GLdouble) p0, (GLdouble) p1, (GLdouble) p2, (GLdouble) p3, (GLdouble) p4, (GLdouble) p5); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: frontFace + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_frontFace(JNIEnv * env, jobject obj, jint p0) +{ + glFrontFace((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: fogf + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_fogf(JNIEnv * env, jobject obj, jint p0, jfloat p1) +{ + glFogf((GLint) p0, (GLfloat) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: fogi + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_fogi(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glFogi((GLint) p0, (GLint) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: fogfv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_fogfv(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glFogfv((GLint) p0, (const GLfloat *) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: fogiv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_fogiv(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glFogiv((GLint) p0, (const GLint *) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: flush + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_flush(JNIEnv * env, jobject obj) +{ + glFlush(); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: finish + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_finish(JNIEnv * env, jobject obj) +{ + glFinish(); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getPointerv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getPointerv(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glGetPointerv((GLint) p0, (void **) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: isEnabled + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_CoreGL_isEnabled(JNIEnv * env, jobject obj, jint p0) +{ + jboolean ret = (jboolean) glIsEnabled((GLint) p0); + CHECK_GL_ERROR + return ret; +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: interleavedArrays + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_interleavedArrays(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glInterleavedArrays((GLint) p0, (GLint) p1, (const void *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: initNames + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_initNames(JNIEnv * env, jobject obj) +{ + glInitNames(); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: indexPointer + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_indexPointer(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glIndexPointer((GLint) p0, (GLint) p1, (const void *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: indexMask + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_indexMask(JNIEnv * env, jobject obj, jint p0) +{ + glIndexMask((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: indexd + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_indexd(JNIEnv * env, jobject obj, jdouble p0) +{ + glIndexd((GLdouble) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: indexf + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_indexf(JNIEnv * env, jobject obj, jfloat p0) +{ + glIndexf((GLfloat) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: indexi + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_indexi(JNIEnv * env, jobject obj, jint p0) +{ + glIndexi((GLint) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: indexs + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_indexs(JNIEnv * env, jobject obj, jshort p0) +{ + glIndexs((GLshort) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: indexub + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_indexub(JNIEnv * env, jobject obj, jbyte p0) +{ + glIndexub((GLbyte) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: indexdv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_indexdv(JNIEnv * env, jobject obj, jint p0) +{ + glIndexdv((const GLdouble *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: indexfv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_indexfv(JNIEnv * env, jobject obj, jint p0) +{ + glIndexfv((const GLfloat *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: indexiv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_indexiv(JNIEnv * env, jobject obj, jint p0) +{ + glIndexiv((const GLint *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: indexsv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_indexsv(JNIEnv * env, jobject obj, jint p0) +{ + glIndexsv((const GLshort *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: indexubv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_indexubv(JNIEnv * env, jobject obj, jint p0) +{ + glIndexubv((const unsigned char *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: hint + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_hint(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glHint((GLint) p0, (GLint) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getTexParameterfv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getTexParameterfv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glGetTexParameterfv((GLint) p0, (GLint) p1, (GLfloat *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getTexParameteriv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getTexParameteriv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glGetTexParameteriv((GLint) p0, (GLint) p1, (GLint *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getTexLevelParameterfv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getTexLevelParameterfv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ + glGetTexLevelParameterfv((GLint) p0, (GLint) p1, (GLint) p2, (GLfloat *) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getTexLevelParameteriv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getTexLevelParameteriv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ + glGetTexLevelParameteriv((GLint) p0, (GLint) p1, (GLint) p2, (GLint *) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getTexImage + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getTexImage(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4) +{ + glGetTexImage((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (void *) p4); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getTexGendv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getTexGendv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glGetTexGendv((GLint) p0, (GLint) p1, (GLdouble *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getTexGenfv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getTexGenfv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glGetTexGenfv((GLint) p0, (GLint) p1, (GLfloat *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getTexGeniv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getTexGeniv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glGetTexGeniv((GLint) p0, (GLint) p1, (GLint *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getTexEnvfv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getTexEnvfv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glGetTexEnvfv((GLint) p0, (GLint) p1, (GLfloat *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getTexEnviv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getTexEnviv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glGetTexEnviv((GLint) p0, (GLint) p1, (GLint *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getString + */ +JNIEXPORT jstring JNICALL Java_org_lwjgl_opengl_CoreGL_getString(JNIEnv * env, jobject obj, jint p0) +{ + const GLubyte * string = glGetString((GLenum) p0); + return (*env)->NewStringUTF(env, (const char *) string); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getPolygonStipple + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getPolygonStipple(JNIEnv * env, jobject obj, jint p0) +{ + glGetPolygonStipple((GLubyte *) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: isList + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_CoreGL_isList(JNIEnv * env, jobject obj, jint p0) +{ + jboolean ret = (jboolean) glIsList((GLint) p0); + CHECK_GL_ERROR + return ret; +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: materialf + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_materialf(JNIEnv * env, jobject obj, jint p0, jint p1, jfloat p2) +{ + glMaterialf((GLint) p0, (GLint) p1, (GLfloat) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: materiali + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_materiali(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glMateriali((GLint) p0, (GLint) p1, (GLint) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: materialfv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_materialfv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glMaterialfv((GLint) p0, (GLint) p1, (const GLfloat *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: materialiv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_materialiv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glMaterialiv((GLint) p0, (GLint) p1, (const GLint *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: mapGrid1d + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_mapGrid1d(JNIEnv * env, jobject obj, jint p0, jdouble p1, jdouble p2) +{ + glMapGrid1d((GLint) p0, (GLdouble) p1, (GLdouble) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: mapGrid1f + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_mapGrid1f(JNIEnv * env, jobject obj, jint p0, jfloat p1, jfloat p2) +{ + glMapGrid1f((GLint) p0, (GLfloat) p1, (GLfloat) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: mapGrid2d + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_mapGrid2d(JNIEnv * env, jobject obj, jint p0, jdouble p1, jdouble p2, jint p3, jdouble p4, jdouble p5) +{ + glMapGrid2d((GLint) p0, (GLdouble) p1, (GLdouble) p2, (GLint) p3, (GLdouble) p4, (GLdouble) p5); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: mapGrid2f + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_mapGrid2f(JNIEnv * env, jobject obj, jint p0, jfloat p1, jfloat p2, jint p3, jfloat p4, jfloat p5) +{ + glMapGrid2f((GLint) p0, (GLfloat) p1, (GLfloat) p2, (GLint) p3, (GLfloat) p4, (GLfloat) p5); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: map2d + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_map2d(JNIEnv * env, jobject obj, jint p0, jdouble p1, jdouble p2, jint p3, jint p4, jdouble p5, jdouble p6, jint p7, jint p8, jint p9) +{ + glMap2d((GLint) p0, (GLdouble) p1, (GLdouble) p2, (GLint) p3, (GLint) p4, (GLdouble) p5, (GLdouble) p6, (GLint) p7, (GLint) p8, (const GLdouble *) p9); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: map2f + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_map2f(JNIEnv * env, jobject obj, jint p0, jfloat p1, jfloat p2, jint p3, jint p4, jfloat p5, jfloat p6, jint p7, jint p8, jint p9) +{ + glMap2f((GLint) p0, (GLfloat) p1, (GLfloat) p2, (GLint) p3, (GLint) p4, (GLfloat) p5, (GLfloat) p6, (GLint) p7, (GLint) p8, (const GLfloat *) p9); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: map1d + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_map1d(JNIEnv * env, jobject obj, jint p0, jdouble p1, jdouble p2, jint p3, jint p4, jint p5) +{ + glMap1d((GLint) p0, (GLdouble) p1, (GLdouble) p2, (GLint) p3, (GLint) p4, (const GLdouble *) p5); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: map1f + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_map1f(JNIEnv * env, jobject obj, jint p0, jfloat p1, jfloat p2, jint p3, jint p4, jint p5) +{ + glMap1f((GLint) p0, (GLfloat) p1, (GLfloat) p2, (GLint) p3, (GLint) p4, (const GLfloat *) p5); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: logicOp + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_logicOp(JNIEnv * env, jobject obj, jint p0) +{ + glLogicOp((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: loadName + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_loadName(JNIEnv * env, jobject obj, jint p0) +{ + glLoadName((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: loadMatrixd + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_loadMatrixd(JNIEnv * env, jobject obj, jint p0) +{ + glLoadMatrixd((const GLdouble *) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: loadMatrixf + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_loadMatrixf(JNIEnv * env, jobject obj, jint p0) +{ + glLoadMatrixf((const GLfloat *) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: loadIdentity + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_loadIdentity(JNIEnv * env, jobject obj) +{ + glLoadIdentity(); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: listBase + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_listBase(JNIEnv * env, jobject obj, jint p0) +{ + glListBase((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: lineWidth + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_lineWidth(JNIEnv * env, jobject obj, jfloat p0) +{ + glLineWidth((GLfloat) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: lineStipple + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_lineStipple(JNIEnv * env, jobject obj, jint p0, jshort p1) +{ + glLineStipple((GLint) p0, (GLshort) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: lightModelf + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_lightModelf(JNIEnv * env, jobject obj, jint p0, jfloat p1) +{ + glLightModelf((GLint) p0, (GLfloat) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: lightModeli + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_lightModeli(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glLightModeli((GLint) p0, (GLint) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: lightModelfv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_lightModelfv(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glLightModelfv((GLint) p0, (const GLfloat *) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: lightModeliv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_lightModeliv(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glLightModeliv((GLint) p0, (const GLint *) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: lightf + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_lightf(JNIEnv * env, jobject obj, jint p0, jint p1, jfloat p2) +{ + glLightf((GLint) p0, (GLint) p1, (GLfloat) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: lighti + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_lighti(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glLighti((GLint) p0, (GLint) p1, (GLint) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: lightfv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_lightfv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glLightfv((GLint) p0, (GLint) p1, (const GLfloat *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: lightiv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_lightiv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glLightiv((GLint) p0, (GLint) p1, (const GLint *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: isTexture + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_CoreGL_isTexture(JNIEnv * env, jobject obj, jint p0) +{ + jboolean ret = (jboolean) glIsTexture((GLint) p0); + CHECK_GL_ERROR + return ret; +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: matrixMode + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_matrixMode(JNIEnv * env, jobject obj, jint p0) +{ + glMatrixMode((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: polygonStipple + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_polygonStipple(JNIEnv * env, jobject obj, jint p0) +{ + glPolygonStipple((const unsigned char *) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: polygonOffset + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_polygonOffset(JNIEnv * env, jobject obj, jfloat p0, jfloat p1) +{ + glPolygonOffset((GLfloat) p0, (GLfloat) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: polygonMode + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_polygonMode(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glPolygonMode((GLint) p0, (GLint) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: pointSize + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_pointSize(JNIEnv * env, jobject obj, jfloat p0) +{ + glPointSize((GLfloat) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: pixelZoom + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_pixelZoom(JNIEnv * env, jobject obj, jfloat p0, jfloat p1) +{ + glPixelZoom((GLfloat) p0, (GLfloat) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: pixelTransferf + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_pixelTransferf(JNIEnv * env, jobject obj, jint p0, jfloat p1) +{ + glPixelTransferf((GLint) p0, (GLfloat) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: pixelTransferi + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_pixelTransferi(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glPixelTransferi((GLint) p0, (GLint) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: pixelStoref + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_pixelStoref(JNIEnv * env, jobject obj, jint p0, jfloat p1) +{ + glPixelStoref((GLint) p0, (GLfloat) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: pixelStorei + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_pixelStorei(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glPixelStorei((GLint) p0, (GLint) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: pixelMapfv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_pixelMapfv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glPixelMapfv((GLint) p0, (GLint) p1, (const GLfloat *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: pixelMapuiv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_pixelMapuiv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glPixelMapuiv((GLint) p0, (GLint) p1, (const GLuint *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: pixelMapusv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_pixelMapusv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glPixelMapusv((GLint) p0, (GLint) p1, (const GLushort *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: passThrough + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_passThrough(JNIEnv * env, jobject obj, jfloat p0) +{ + glPassThrough((GLfloat) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: ortho + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_ortho(JNIEnv * env, jobject obj, jdouble p0, jdouble p1, jdouble p2, jdouble p3, jdouble p4, jdouble p5) +{ + glOrtho((GLdouble) p0, (GLdouble) p1, (GLdouble) p2, (GLdouble) p3, (GLdouble) p4, (GLdouble) p5); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: normalPointer + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_normalPointer(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glNormalPointer((GLint) p0, (GLint) p1, (const void *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: normal3b + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_normal3b(JNIEnv * env, jobject obj, jbyte p0, jbyte p1, jbyte p2) +{ + glNormal3b((GLbyte) p0, (GLbyte) p1, (GLbyte) p2); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: normal3d + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_normal3d(JNIEnv * env, jobject obj, jdouble p0, jdouble p1, jdouble p2) +{ + glNormal3d((GLdouble) p0, (GLdouble) p1, (GLdouble) p2); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: normal3f + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_normal3f(JNIEnv * env, jobject obj, jfloat p0, jfloat p1, jfloat p2) +{ + glNormal3f((GLfloat) p0, (GLfloat) p1, (GLfloat) p2); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: normal3i + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_normal3i(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glNormal3i((GLint) p0, (GLint) p1, (GLint) p2); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: normal3s + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_normal3s(JNIEnv * env, jobject obj, jshort p0, jshort p1, jshort p2) +{ + glNormal3s((GLshort) p0, (GLshort) p1, (GLshort) p2); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: normal3bv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_normal3bv(JNIEnv * env, jobject obj, jint p0) +{ + glNormal3bv((const GLbyte *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: normal3dv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_normal3dv(JNIEnv * env, jobject obj, jint p0) +{ + glNormal3dv((const GLdouble *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: normal3fv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_normal3fv(JNIEnv * env, jobject obj, jint p0) +{ + glNormal3fv((const GLfloat *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: normal3iv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_normal3iv(JNIEnv * env, jobject obj, jint p0) +{ + glNormal3iv((const GLint *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: normal3sv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_normal3sv(JNIEnv * env, jobject obj, jint p0) +{ + glNormal3sv((const GLshort *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: newList + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_newList(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glNewList((GLint) p0, (GLint) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: endList + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_endList(JNIEnv * env, jobject obj) +{ + glEndList(); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: multMatrixd + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_multMatrixd(JNIEnv * env, jobject obj, jint p0) +{ + glMultMatrixd((const GLdouble *) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: multMatrixf + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_multMatrixf(JNIEnv * env, jobject obj, jint p0) +{ + glMultMatrixf((const GLfloat *) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: prioritizeTextures + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_prioritizeTextures(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glPrioritizeTextures((GLint) p0, (const GLuint *) p1, (const GLfloat *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: shadeModel + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_shadeModel(JNIEnv * env, jobject obj, jint p0) +{ + glShadeModel((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: selectBuffer + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_selectBuffer(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glSelectBuffer((GLint) p0, (GLuint *) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: scissor + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_scissor(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ + glScissor((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: scaled + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_scaled(JNIEnv * env, jobject obj, jdouble p0, jdouble p1, jdouble p2) +{ + glScaled((GLdouble) p0, (GLdouble) p1, (GLdouble) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: scalef + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_scalef(JNIEnv * env, jobject obj, jfloat p0, jfloat p1, jfloat p2) +{ + glScalef((GLfloat) p0, (GLfloat) p1, (GLfloat) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rotated + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rotated(JNIEnv * env, jobject obj, jdouble p0, jdouble p1, jdouble p2, jdouble p3) +{ + glRotated((GLdouble) p0, (GLdouble) p1, (GLdouble) p2, (GLdouble) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rotatef + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rotatef(JNIEnv * env, jobject obj, jfloat p0, jfloat p1, jfloat p2, jfloat p3) +{ + glRotatef((GLfloat) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: renderMode + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_CoreGL_renderMode(JNIEnv * env, jobject obj, jint p0) +{ + jint ret = (jint) glRenderMode((GLint) p0); + CHECK_GL_ERROR + return ret; +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rectd + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rectd(JNIEnv * env, jobject obj, jdouble p0, jdouble p1, jdouble p2, jdouble p3) +{ + glRectd((GLdouble) p0, (GLdouble) p1, (GLdouble) p2, (GLdouble) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rectf + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rectf(JNIEnv * env, jobject obj, jfloat p0, jfloat p1, jfloat p2, jfloat p3) +{ + glRectf((GLfloat) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: recti + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_recti(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ + glRecti((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rects + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rects(JNIEnv * env, jobject obj, jshort p0, jshort p1, jshort p2, jshort p3) +{ + glRects((GLshort) p0, (GLshort) p1, (GLshort) p2, (GLshort) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rectdv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rectdv(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glRectdv((const GLdouble *) p0, (const GLdouble *) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rectfv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rectfv(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glRectfv((const GLfloat *) p0, (const GLfloat *) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rectiv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rectiv(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glRectiv((const GLint *) p0, (const GLint *) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rectsv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rectsv(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glRectsv((const GLshort *) p0, (const GLshort *) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: readPixels + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_readPixels(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6) +{ + glReadPixels((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (void *) p6); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: readBuffer + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_readBuffer(JNIEnv * env, jobject obj, jint p0) +{ + glReadBuffer((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos2d + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos2d(JNIEnv * env, jobject obj, jdouble p0, jdouble p1) +{ + glRasterPos2d((GLdouble) p0, (GLdouble) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos2f + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos2f(JNIEnv * env, jobject obj, jfloat p0, jfloat p1) +{ + glRasterPos2f((GLfloat) p0, (GLfloat) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos2i + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos2i(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glRasterPos2i((GLint) p0, (GLint) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos2s + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos2s(JNIEnv * env, jobject obj, jshort p0, jshort p1) +{ + glRasterPos2s((GLshort) p0, (GLshort) p1); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos3d + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos3d(JNIEnv * env, jobject obj, jdouble p0, jdouble p1, jdouble p2) +{ + glRasterPos3d((GLdouble) p0, (GLdouble) p1, (GLdouble) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos3f + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos3f(JNIEnv * env, jobject obj, jfloat p0, jfloat p1, jfloat p2) +{ + glRasterPos3f((GLfloat) p0, (GLfloat) p1, (GLfloat) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos3i + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos3i(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glRasterPos3i((GLint) p0, (GLint) p1, (GLint) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos3s + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos3s(JNIEnv * env, jobject obj, jshort p0, jshort p1, jshort p2) +{ + glRasterPos3s((GLshort) p0, (GLshort) p1, (GLshort) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos4d + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos4d(JNIEnv * env, jobject obj, jdouble p0, jdouble p1, jdouble p2, jdouble p3) +{ + glRasterPos4d((GLdouble) p0, (GLdouble) p1, (GLdouble) p2, (GLdouble) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos4f + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos4f(JNIEnv * env, jobject obj, jfloat p0, jfloat p1, jfloat p2, jfloat p3) +{ + glRasterPos4f((GLfloat) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos4i + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos4i(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ + glRasterPos4i((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos4s + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos4s(JNIEnv * env, jobject obj, jshort p0, jshort p1, jshort p2, jshort p3) +{ + glRasterPos4s((GLshort) p0, (GLshort) p1, (GLshort) p2, (GLshort) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos2dv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos2dv(JNIEnv * env, jobject obj, jint p0) +{ + glRasterPos2dv((const GLdouble *) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos2fv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos2fv(JNIEnv * env, jobject obj, jint p0) +{ + glRasterPos2fv((const GLfloat *) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos2iv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos2iv(JNIEnv * env, jobject obj, jint p0) +{ + glRasterPos2iv((const GLint *) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos2sv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos2sv(JNIEnv * env, jobject obj, jint p0) +{ + glRasterPos2sv((const GLshort *) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos3dv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos3dv(JNIEnv * env, jobject obj, jint p0) +{ + glRasterPos3dv((const GLdouble *) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos3fv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos3fv(JNIEnv * env, jobject obj, jint p0) +{ + glRasterPos3fv((const GLfloat *) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos3iv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos3iv(JNIEnv * env, jobject obj, jint p0) +{ + glRasterPos3iv((const GLint *) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos3sv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos3sv(JNIEnv * env, jobject obj, jint p0) +{ + glRasterPos3sv((const GLshort *) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos4dv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos4dv(JNIEnv * env, jobject obj, jint p0) +{ + glRasterPos4dv((const GLdouble *) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos4fv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos4fv(JNIEnv * env, jobject obj, jint p0) +{ + glRasterPos4fv((const GLfloat *) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos4iv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos4iv(JNIEnv * env, jobject obj, jint p0) +{ + glRasterPos4iv((const GLint *) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: rasterPos4sv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_rasterPos4sv(JNIEnv * env, jobject obj, jint p0) +{ + glRasterPos4sv((const GLshort *) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: pushName + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_pushName(JNIEnv * env, jobject obj, jint p0) +{ + glPushName((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: popName + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_popName(JNIEnv * env, jobject obj) +{ + glPopName(); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: pushMatrix + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_pushMatrix(JNIEnv * env, jobject obj) +{ + glPushMatrix(); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: popMatrix + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_popMatrix(JNIEnv * env, jobject obj) +{ + glPopMatrix(); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: pushClientAttrib + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_pushClientAttrib(JNIEnv * env, jobject obj, jint p0) +{ + glPushClientAttrib((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: popClientAttrib + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_popClientAttrib(JNIEnv * env, jobject obj) +{ + glPopClientAttrib(); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: pushAttrib + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_pushAttrib(JNIEnv * env, jobject obj, jint p0) +{ + glPushAttrib((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: popAttrib + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_popAttrib(JNIEnv * env, jobject obj) +{ + glPopAttrib(); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: stencilFunc + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_stencilFunc(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glStencilFunc((GLint) p0, (GLint) p1, (GLint) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertexPointer + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertexPointer(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ + glVertexPointer((GLint) p0, (GLint) p1, (GLint) p2, (const void *) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex2d + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex2d(JNIEnv * env, jobject obj, jdouble p0, jdouble p1) +{ + glVertex2d((GLdouble) p0, (GLdouble) p1); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex2f + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex2f(JNIEnv * env, jobject obj, jfloat p0, jfloat p1) +{ + glVertex2f((GLfloat) p0, (GLfloat) p1); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex2i + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex2i(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glVertex2i((GLint) p0, (GLint) p1); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex2s + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex2s(JNIEnv * env, jobject obj, jshort p0, jshort p1) +{ + glVertex2s((GLshort) p0, (GLshort) p1); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex3d + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex3d(JNIEnv * env, jobject obj, jdouble p0, jdouble p1, jdouble p2) +{ + glVertex3d((GLdouble) p0, (GLdouble) p1, (GLdouble) p2); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex3f + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex3f(JNIEnv * env, jobject obj, jfloat p0, jfloat p1, jfloat p2) +{ + glVertex3f((GLfloat) p0, (GLfloat) p1, (GLfloat) p2); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex3i + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex3i(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glVertex3i((GLint) p0, (GLint) p1, (GLint) p2); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex3s + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex3s(JNIEnv * env, jobject obj, jshort p0, jshort p1, jshort p2) +{ + glVertex3s((GLshort) p0, (GLshort) p1, (GLshort) p2); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex4d + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex4d(JNIEnv * env, jobject obj, jdouble p0, jdouble p1, jdouble p2, jdouble p3) +{ + glVertex4d((GLdouble) p0, (GLdouble) p1, (GLdouble) p2, (GLdouble) p3); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex4f + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex4f(JNIEnv * env, jobject obj, jfloat p0, jfloat p1, jfloat p2, jfloat p3) +{ + glVertex4f((GLfloat) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex4i + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex4i(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ + glVertex4i((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex4s + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex4s(JNIEnv * env, jobject obj, jshort p0, jshort p1, jshort p2, jshort p3) +{ + glVertex4s((GLshort) p0, (GLshort) p1, (GLshort) p2, (GLshort) p3); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex2dv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex2dv(JNIEnv * env, jobject obj, jint p0) +{ + glVertex2dv((const GLdouble *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex2fv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex2fv(JNIEnv * env, jobject obj, jint p0) +{ + glVertex2fv((const GLfloat *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex2iv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex2iv(JNIEnv * env, jobject obj, jint p0) +{ + glVertex2iv((const GLint *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex2sv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex2sv(JNIEnv * env, jobject obj, jint p0) +{ + glVertex2sv((const GLshort *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex3dv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex3dv(JNIEnv * env, jobject obj, jint p0) +{ + glVertex3dv((const GLdouble *) p0); + +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex3fv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex3fv(JNIEnv * env, jobject obj, jint p0) +{ + glVertex3fv((const GLfloat *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex3iv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex3iv(JNIEnv * env, jobject obj, jint p0) +{ + glVertex3iv((const GLint *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex3sv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex3sv(JNIEnv * env, jobject obj, jint p0) +{ + glVertex3sv((const GLshort *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex4dv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex4dv(JNIEnv * env, jobject obj, jint p0) +{ + glVertex4dv((const GLdouble *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex4fv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex4fv(JNIEnv * env, jobject obj, jint p0) +{ + glVertex4fv((const GLfloat *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex4iv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex4iv(JNIEnv * env, jobject obj, jint p0) +{ + glVertex4iv((const GLint *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: vertex4sv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_vertex4sv(JNIEnv * env, jobject obj, jint p0) +{ + glVertex4sv((const GLshort *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: translated + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_translated(JNIEnv * env, jobject obj, jdouble p0, jdouble p1, jdouble p2) +{ + glTranslated((GLdouble) p0, (GLdouble) p1, (GLdouble) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: translatef + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_translatef(JNIEnv * env, jobject obj, jfloat p0, jfloat p1, jfloat p2) +{ + glTranslatef((GLfloat) p0, (GLfloat) p1, (GLfloat) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texSubImage2D + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texSubImage2D(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6, jint p7, jint p8) +{ + glTexSubImage2D((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6, (GLint) p7, (const void *) p8); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texSubImage1D + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texSubImage1D(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6) +{ + glTexSubImage1D((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (const void *) p6); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texParameterf + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texParameterf(JNIEnv * env, jobject obj, jint p0, jint p1, jfloat p2) +{ + glTexParameterf((GLint) p0, (GLint) p1, (GLfloat) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texParameteri + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texParameteri(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glTexParameteri((GLint) p0, (GLint) p1, (GLint) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texImage2D + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texImage2D(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6, jint p7, jint p8) +{ + glTexImage2D((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6, (GLint) p7, (const void *) p8); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texImage1D + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texImage1D(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6, jint p7) +{ + glTexImage1D((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6, (const void *) p7); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texGend + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texGend(JNIEnv * env, jobject obj, jint p0, jint p1, jdouble p2) +{ + glTexGend((GLint) p0, (GLint) p1, (GLdouble) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texGenf + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texGenf(JNIEnv * env, jobject obj, jint p0, jint p1, jfloat p2) +{ + glTexGenf((GLint) p0, (GLint) p1, (GLfloat) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texGeni + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texGeni(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glTexGeni((GLint) p0, (GLint) p1, (GLint) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texGendv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texGendv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glTexGendv((GLint) p0, (GLint) p1, (const GLdouble *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texGenfv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texGenfv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glTexGenfv((GLint) p0, (GLint) p1, (const GLfloat *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texGeniv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texGeniv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glTexGeniv((GLint) p0, (GLint) p1, (const GLint *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texEnvf + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texEnvf(JNIEnv * env, jobject obj, jint p0, jint p1, jfloat p2) +{ + glTexEnvf((GLint) p0, (GLint) p1, (GLfloat) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texEnvi + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texEnvi(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glTexEnvi((GLint) p0, (GLint) p1, (GLint) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texEnvfv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texEnvfv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glTexEnvfv((GLint) p0, (GLint) p1, (const GLfloat *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texEnviv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texEnviv(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glTexEnviv((GLint) p0, (GLint) p1, (const GLint *) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoordPointer + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoordPointer(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ + glTexCoordPointer((GLint) p0, (GLint) p1, (GLint) p2, (const void *) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord1d + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord1d(JNIEnv * env, jobject obj, jdouble p0) +{ + glTexCoord1d((GLdouble) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord1f + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord1f(JNIEnv * env, jobject obj, jfloat p0) +{ + glTexCoord1f((GLfloat) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord1i + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord1i(JNIEnv * env, jobject obj, jint p0) +{ + glTexCoord1i((GLint) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord1s + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord1s(JNIEnv * env, jobject obj, jshort p0) +{ + glTexCoord1s((GLshort) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord2d + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord2d(JNIEnv * env, jobject obj, jdouble p0, jdouble p1) +{ + glTexCoord2d((GLdouble) p0, (GLdouble) p1); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord2f + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord2f(JNIEnv * env, jobject obj, jfloat p0, jfloat p1) +{ + glTexCoord2f((GLfloat) p0, (GLfloat) p1); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord2i + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord2i(JNIEnv * env, jobject obj, jint p0, jint p1) +{ + glTexCoord2i((GLint) p0, (GLint) p1); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord2s + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord2s(JNIEnv * env, jobject obj, jshort p0, jshort p1) +{ + glTexCoord2s((GLshort) p0, (GLshort) p1); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord3d + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord3d(JNIEnv * env, jobject obj, jdouble p0, jdouble p1, jdouble p2) +{ + glTexCoord3d((GLdouble) p0, (GLdouble) p1, (GLdouble) p2); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord3f + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord3f(JNIEnv * env, jobject obj, jfloat p0, jfloat p1, jfloat p2) +{ + glTexCoord3f((GLfloat) p0, (GLfloat) p1, (GLfloat) p2); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord3i + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord3i(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glTexCoord3i((GLint) p0, (GLint) p1, (GLint) p2); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord3s + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord3s(JNIEnv * env, jobject obj, jshort p0, jshort p1, jshort p2) +{ + glTexCoord3s((GLshort) p0, (GLshort) p1, (GLshort) p2); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord4d + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord4d(JNIEnv * env, jobject obj, jdouble p0, jdouble p1, jdouble p2, jdouble p3) +{ + glTexCoord4d((GLdouble) p0, (GLdouble) p1, (GLdouble) p2, (GLdouble) p3); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord4f + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord4f(JNIEnv * env, jobject obj, jfloat p0, jfloat p1, jfloat p2, jfloat p3) +{ + glTexCoord4f((GLfloat) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord4i + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord4i(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ + glTexCoord4i((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord4s + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord4s(JNIEnv * env, jobject obj, jshort p0, jshort p1, jshort p2, jshort p3) +{ + glTexCoord4s((GLshort) p0, (GLshort) p1, (GLshort) p2, (GLshort) p3); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord1dv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord1dv(JNIEnv * env, jobject obj, jint p0) +{ + glTexCoord1dv((const GLdouble *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord1fv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord1fv(JNIEnv * env, jobject obj, jint p0) +{ + glTexCoord1fv((const GLfloat *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord1iv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord1iv(JNIEnv * env, jobject obj, jint p0) +{ + glTexCoord1iv((const GLint *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord1sv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord1sv(JNIEnv * env, jobject obj, jint p0) +{ + glTexCoord1sv((const GLshort *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord2dv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord2dv(JNIEnv * env, jobject obj, jint p0) +{ + glTexCoord2dv((const GLdouble *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord2fv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord2fv(JNIEnv * env, jobject obj, jint p0) +{ + glTexCoord2fv((const GLfloat *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord2iv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord2iv(JNIEnv * env, jobject obj, jint p0) +{ + glTexCoord2iv((const GLint *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord2sv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord2sv(JNIEnv * env, jobject obj, jint p0) +{ + glTexCoord2sv((const GLshort *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord3dv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord3dv(JNIEnv * env, jobject obj, jint p0) +{ + glTexCoord3dv((const GLdouble *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord3fv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord3fv(JNIEnv * env, jobject obj, jint p0) +{ + glTexCoord3fv((const GLfloat *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord3iv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord3iv(JNIEnv * env, jobject obj, jint p0) +{ + glTexCoord3iv((const GLint *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord3sv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord3sv(JNIEnv * env, jobject obj, jint p0) +{ + glTexCoord3sv((const GLshort *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord4dv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord4dv(JNIEnv * env, jobject obj, jint p0) +{ + glTexCoord4dv((const GLdouble *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord4fv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord4fv(JNIEnv * env, jobject obj, jint p0) +{ + glTexCoord4fv((const GLfloat *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord4iv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord4iv(JNIEnv * env, jobject obj, jint p0) +{ + glTexCoord4iv((const GLint *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: texCoord4sv + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_texCoord4sv(JNIEnv * env, jobject obj, jint p0) +{ + glTexCoord4sv((const GLshort *) p0); +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: stencilOp + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_stencilOp(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ + glStencilOp((GLint) p0, (GLint) p1, (GLint) p2); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: stencilMask + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_stencilMask(JNIEnv * env, jobject obj, jint p0) +{ + glStencilMask((GLint) p0); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: viewport + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_viewport(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ + glViewport((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: colorTable + * Signature: (IIIIII)V + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_colorTable + (JNIEnv * env, jobject obj, jint target, jint internalFormat, jint width, jint format, jint type, jint data) +{ + glColorTable(target, internalFormat, width, format, type, (const void *) data); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: colorSubTable + * Signature: (IIIIII)V + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_colorSubTable + (JNIEnv * env, jobject obj, jint target, jint start, jint count, jint format, jint type, jint data) +{ + glColorSubTable(target, start, count, format, type, (const void *) data); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getColorTable + * Signature: (IIII)V + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getColorTable + (JNIEnv * env, jobject obj, jint target, jint format, jint type, jint data) +{ + glGetColorTable(target, format, type, (void *) data); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getColorTableParameteriv + * Signature: (III)V + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getColorTableParameteriv + (JNIEnv * env, jobject obj, jint target, jint pname, jint params) +{ + glGetColorTableParameteriv(target, pname, (int *)params); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_CoreGL + * Method: getColorTableParameterfv + * Signature: (III)V + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getColorTableParameterfv + (JNIEnv * env, jobject obj, jint target, jint pname, jint params) +{ + glGetColorTableParameterfv(target, pname, (float *)params); + CHECK_GL_ERROR +} + diff --git a/src/native/linux/org_lwjgl_opengl_GL.c b/src/native/linux/org_lwjgl_opengl_GL.c new file mode 100644 index 00000000..2c45227c --- /dev/null +++ b/src/native/linux/org_lwjgl_opengl_GL.c @@ -0,0 +1,4110 @@ +/* + * 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. + */ + +/** + * $Id$ + * + * GL extensions library. + * + * @author cix_foo + * @version $Revision$ + */ + +#include "org_lwjgl_opengl_GL.h" +#include "checkGLerror.h" + +/* + * Class: org_lwjgl_opengl_GL + * Method: activeStencilFaceEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_activeStencilFaceEXT(JNIEnv * env, jobject obj, jint p0) +{ +//glActiveStencilFaceEXT((GLint) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: activeTextureARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_activeTextureARB(JNIEnv * env, jobject obj, jint p0) +{ +//glActiveTextureARB((GLint) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: alphaFragmentOp1ATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_alphaFragmentOp1ATI(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5) +{ +//glAlphaFragmentOp1ATI((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: alphaFragmentOp2ATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_alphaFragmentOp2ATI(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6, jint p7, jint p8) +{ +//glAlphaFragmentOp2ATI((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6, (GLint) p7, (GLint) p8); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: alphaFragmentOp3ATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_alphaFragmentOp3ATI(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6, jint p7, jint p8, jint p9, jint p10, jint p11) +{ +//glAlphaFragmentOp3ATI((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6, (GLint) p7, (GLint) p8, (GLint) p9, (GLint) p10, (GLint) p11); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: areProgramsResidentNV + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL_areProgramsResidentNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//jboolean ret = (jboolean) glAreProgramsResidentNV((GLint) p0, (const GLuint *) p1, (GLubyte *) p2); +//CHECK_GL_ERROR +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: arrayObjectATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_arrayObjectATI(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5) +{ +//glArrayObjectATI((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: beginFragmentShaderATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_beginFragmentShaderATI(JNIEnv * env, jobject obj) +{ +//glBeginFragmentShaderATI(); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: beginOcclusionQueryNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_beginOcclusionQueryNV(JNIEnv * env, jobject obj, jint p0) +{ +//glBeginOcclusionQueryNV((GLint) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: beginVertexShaderEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_beginVertexShaderEXT(JNIEnv * env, jobject obj) +{ +//glBeginVertexShaderEXT(); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: bindFragmentShaderATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_bindFragmentShaderATI(JNIEnv * env, jobject obj, jint p0) +{ +//glBindFragmentShaderATI((GLint) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: bindLightParameterEXT + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL_bindLightParameterEXT(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//jint ret = (jint) glBindLightParameterEXT((GLint) p0, (GLint) p1); +//CHECK_GL_ERROR +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: bindMaterialParameterEXT + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL_bindMaterialParameterEXT(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//jint ret = (jint) glBindMaterialParameterEXT((GLint) p0, (GLint) p1); +//CHECK_GL_ERROR +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: bindParameterEXT + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL_bindParameterEXT(JNIEnv * env, jobject obj, jint p0) +{ +//jint ret = (jint) glBindParameterEXT((GLint) p0); +//CHECK_GL_ERROR +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: bindProgramARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_bindProgramARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glBindProgramARB((GLint) p0, (GLint) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: bindProgramNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_bindProgramNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glBindProgramNV((GLint) p0, (GLint) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: bindTexGenParameterEXT + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL_bindTexGenParameterEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//jint ret = (jint) glBindTexGenParameterEXT((GLint) p0, (GLint) p1, (GLint) p2); +//CHECK_GL_ERROR +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: bindTextureUnitParameterEXT + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL_bindTextureUnitParameterEXT(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//jint ret = (jint) glBindTextureUnitParameterEXT((GLint) p0, (GLint) p1); +//CHECK_GL_ERROR +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: bindVertexShaderEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_bindVertexShaderEXT(JNIEnv * env, jobject obj, jint p0) +{ +//glBindVertexShaderEXT((GLint) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: clientActiveTextureARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_clientActiveTextureARB(JNIEnv * env, jobject obj, jint p0) +{ +//glClientActiveTextureARB((GLint) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: clientActiveVertexStreamATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_clientActiveVertexStreamATI(JNIEnv * env, jobject obj, jint p0) +{ +//glClientActiveVertexStreamATI((GLint) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: colorFragmentOp1ATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_colorFragmentOp1ATI(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6) +{ +//glColorFragmentOp1ATI((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: colorFragmentOp2ATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_colorFragmentOp2ATI(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6, jint p7, jint p8, jint p9) +{ +//glColorFragmentOp2ATI((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6, (GLint) p7, (GLint) p8, (GLint) p9); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: colorFragmentOp3ATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_colorFragmentOp3ATI(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6, jint p7, jint p8, jint p9, jint p10, jint p11, jint p12) +{ +//glColorFragmentOp3ATI((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6, (GLint) p7, (GLint) p8, (GLint) p9, (GLint) p10, (GLint) p11, (GLint) p12); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: combinerInputNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_combinerInputNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5) +{ +//glCombinerInputNV((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: combinerOutputNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_combinerOutputNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6, jboolean p7, jboolean p8, jboolean p9) +{ +//glCombinerOutputNV((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6, (GLboolean) p7, (GLboolean) p8, (GLboolean) p9); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: combinerParameterfNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_combinerParameterfNV(JNIEnv * env, jobject obj, jint p0, jfloat p1) +{ +//glCombinerParameterfNV((GLint) p0, (GLfloat) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: combinerParameterfvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_combinerParameterfvNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glCombinerParameterfvNV((GLuint) p0, (const GLfloat *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: combinerParameteriNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_combinerParameteriNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glCombinerParameteriNV((GLint) p0, (GLint) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: combinerParameterivNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_combinerParameterivNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glCombinerParameterivNV((GLint) p0, (const GLint *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: combinerStageParameterfvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_combinerStageParameterfvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glCombinerStageParameterfvNV((GLint) p0, (GLint) p1, (GLfloat *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: compressedTexImage1DARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_compressedTexImage1DARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6) +{ +//glCompressedTexImage1DARB((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (const void *) p6); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: compressedTexImage2DARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_compressedTexImage2DARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6, jint p7) +{ +//glCompressedTexImage2DARB((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6, (const void *) p7); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: compressedTexImage3DARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_compressedTexImage3DARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6, jint p7, jint p8) +{ +//glCompressedTexImage3DARB((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6, (GLint) p7, (const void *) p8); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: compressedTexSubImage1DARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_compressedTexSubImage1DARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6) +{ +//glCompressedTexSubImage1DARB((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (const void *) p6); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: compressedTexSubImage2DARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_compressedTexSubImage2DARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6, jint p7, jint p8) +{ +//glCompressedTexSubImage2DARB((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6, (GLint) p7, (const void *) p8); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: compressedTexSubImage3DARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_compressedTexSubImage3DARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6, jint p7, jint p8, jint p9, jint p10) +{ +//glCompressedTexSubImage3DARB((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6, (GLint) p7, (GLint) p8, (GLint) p9, (const void *) p10); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: currentPaletteMatrixARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_currentPaletteMatrixARB(JNIEnv * env, jobject obj, jint p0) +{ +//glCurrentPaletteMatrixARB((GLint) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: deleteFencesNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_deleteFencesNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glDeleteFencesNV((GLint) p0, (const GLuint *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: deleteFragmentShaderATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_deleteFragmentShaderATI(JNIEnv * env, jobject obj, jint p0) +{ +//glDeleteFragmentShaderATI((GLint) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: deleteOcclusionQueriesNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_deleteOcclusionQueriesNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glDeleteOcclusionQueriesNV((GLint) p0, (const GLuint *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: deleteProgramsARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_deleteProgramsARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glDeleteProgramsARB((GLint) p0, (const GLuint *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: deleteProgramsNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_deleteProgramsNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glDeleteProgramsNV((GLint) p0, (const GLuint *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: deleteVertexShaderEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_deleteVertexShaderEXT(JNIEnv * env, jobject obj, jint p0) +{ +//glDeleteVertexShaderEXT((GLint) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: disableVariantClientStateEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_disableVariantClientStateEXT(JNIEnv * env, jobject obj, jint p0) +{ +//glDisableVariantClientStateEXT((GLint) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: disableVertexAttribArrayARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_disableVertexAttribArrayARB(JNIEnv * env, jobject obj, jint p0) +{ +//glDisableVertexAttribArrayARB((GLint) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: drawElementArrayATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_drawElementArrayATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glDrawElementArrayATI((GLint) p0, (GLint) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: drawRangeElementArrayATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_drawRangeElementArrayATI(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glDrawRangeElementArrayATI((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: drawRangeElementsEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_drawRangeElementsEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5) +{ +//glDrawRangeElementsEXT((GLuint) p0, (GLuint) p1, (GLuint) p2, (GLint) p3, (GLuint) p4, (const void *) p5); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: elementPointerATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_elementPointerATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glElementPointerATI((GLint) p0, (const void *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: enableVariantClientStateEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_enableVariantClientStateEXT(JNIEnv * env, jobject obj, jint p0) +{ +//glEnableVariantClientStateEXT((GLint) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: enableVertexAttribArrayARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_enableVertexAttribArrayARB(JNIEnv * env, jobject obj, jint p0) +{ +//glEnableVertexAttribArrayARB((GLint) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: endFragmentShaderATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_endFragmentShaderATI(JNIEnv * env, jobject obj) +{ +//glEndFragmentShaderATI(); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: endOcclusionQueryNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_endOcclusionQueryNV(JNIEnv * env, jobject obj) +{ +//glEndOcclusionQueryNV(); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: endVertexShaderEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_endVertexShaderEXT(JNIEnv * env, jobject obj) +{ +//glEndVertexShaderEXT(); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: evalMapsNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_evalMapsNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glEvalMapsNV((GLint) p0, (GLint) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: executeProgramNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_executeProgramNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glExecuteProgramNV((GLuint) p0, (GLuint) p1, (const GLfloat *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: extractComponentEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_extractComponentEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glExtractComponentEXT((GLint) p0, (GLint) p1, (GLint) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: finalCombinerInputNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_finalCombinerInputNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glFinalCombinerInputNV((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: finishFenceNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_finishFenceNV(JNIEnv * env, jobject obj, jint p0) +{ +//glFinishFenceNV((GLint) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: flushVertexArrayRangeNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_flushVertexArrayRangeNV(JNIEnv * env, jobject obj) +{ +//glFlushVertexArrayRangeNV(); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: fogCoorddEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_fogCoorddEXT(JNIEnv * env, jobject obj, jdouble p0) +{ +//glFogCoorddEXT((GLdouble) p0); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: fogCoorddvEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_fogCoorddvEXT(JNIEnv * env, jobject obj, jint p0) +{ +//glFogCoorddvEXT((const GLdouble *) p0); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: fogCoordfEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_fogCoordfEXT(JNIEnv * env, jobject obj, jfloat p0) +{ +//glFogCoordfEXT((GLfloat) p0); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: fogCoordfvEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_fogCoordfvEXT(JNIEnv * env, jobject obj, jint p0) +{ +//glFogCoordfvEXT((const GLfloat *) p0); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: fogCoordPointerEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_fogCoordPointerEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glFogCoordPointerEXT((GLuint) p0, (GLint) p1, (const void *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: freeObjectBufferATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_freeObjectBufferATI(JNIEnv * env, jobject obj, jint p0) +{ +//glFreeObjectBufferATI((GLint) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: genFencesNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_genFencesNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glGenFencesNV((GLint) p0, (GLuint *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: genFragmentShadersATI + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL_genFragmentShadersATI(JNIEnv * env, jobject obj, jint p0) +{ +//jint ret = (jint) glGenFragmentShadersATI((GLint) p0); +//CHECK_GL_ERROR +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: genOcclusionQueriesNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_genOcclusionQueriesNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glGenOcclusionQueriesNV((GLint) p0, (GLuint *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: genProgramsARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_genProgramsARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glGenProgramsARB((GLint) p0, (GLuint *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: genProgramsNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_genProgramsNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glGenProgramsNV((GLint) p0, (GLuint *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: genSymbolsEXT + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL_genSymbolsEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//jint ret = (jint) glGenSymbolsEXT((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3); +//CHECK_GL_ERROR +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: genVertexShadersEXT + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL_genVertexShadersEXT(JNIEnv * env, jobject obj, jint p0) +{ +//jint ret = (jint) glGenVertexShadersEXT((GLint) p0); +//CHECK_GL_ERROR +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getArrayObjectfvATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getArrayObjectfvATI(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetArrayObjectfvATI((GLuint) p0, (GLuint) p1, (GLfloat *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getArrayObjectivATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getArrayObjectivATI(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetArrayObjectivATI((GLuint) p0, (GLuint) p1, (GLint *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getCombinerInputParameterfvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getCombinerInputParameterfvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4) +{ +//glGetCombinerInputParameterfvNV((GLuint) p0, (GLuint) p1, (GLuint) p2, (GLuint) p3, (GLfloat *) p4); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getCombinerInputParameterivNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getCombinerInputParameterivNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4) +{ +//glGetCombinerInputParameterivNV((GLuint) p0, (GLuint) p1, (GLuint) p2, (GLuint) p3, (GLint *) p4); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getCombinerOutputParameterfvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getCombinerOutputParameterfvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glGetCombinerOutputParameterfvNV((GLuint) p0, (GLuint) p1, (GLuint) p2, (GLfloat *) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getCombinerOutputParameterivNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getCombinerOutputParameterivNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glGetCombinerOutputParameterivNV((GLuint) p0, (GLuint) p1, (GLuint) p2, (GLint *) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getCombinerStageParameterfvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getCombinerStageParameterfvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetCombinerStageParameterfvNV((GLuint) p0, (GLuint) p1, (GLfloat *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getCompressedTexImageARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getCompressedTexImageARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetCompressedTexImageARB((GLuint) p0, (GLint) p1, (void *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getFenceivNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getFenceivNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetFenceivNV((GLuint) p0, (GLuint) p1, (GLint *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getFinalCombinerInputParameterfvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getFinalCombinerInputParameterfvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetFinalCombinerInputParameterfvNV((GLuint) p0, (GLuint) p1, (GLfloat *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getFinalCombinerInputParameterivNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getFinalCombinerInputParameterivNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetFinalCombinerInputParameterivNV((GLuint) p0, (GLuint) p1, (GLint *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getInvariantBooleanvEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getInvariantBooleanvEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetInvariantBooleanvEXT((GLuint) p0, (GLuint) p1, (GLubyte *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getInvariantFloatvEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getInvariantFloatvEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetInvariantFloatvEXT((GLuint) p0, (GLuint) p1, (GLfloat *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getInvariantIntegervEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getInvariantIntegervEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetInvariantIntegervEXT((GLuint) p0, (GLuint) p1, (GLint *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getLocalConstantBooleanvEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getLocalConstantBooleanvEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetLocalConstantBooleanvEXT((GLuint) p0, (GLuint) p1, (GLubyte *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getLocalConstantFloatvEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getLocalConstantFloatvEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetLocalConstantFloatvEXT((GLuint) p0, (GLuint) p1, (GLfloat *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getLocalConstantIntegervEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getLocalConstantIntegervEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetLocalConstantIntegervEXT((GLint) p0, (GLint) p1, (GLint *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getMapAttribParameterfvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getMapAttribParameterfvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glGetMapAttribParameterfvNV((GLuint) p0, (GLuint) p1, (GLuint) p2, (GLfloat *) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getMapAttribParameterivNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getMapAttribParameterivNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glGetMapAttribParameterivNV((GLint) p0, (GLint) p1, (GLint) p2, (GLint *) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getMapControlPointsNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getMapControlPointsNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jboolean p5, jint p6) +{ +//glGetMapControlPointsNV((GLuint) p0, (GLuint) p1, (GLuint) p2, (GLint) p3, (GLint) p4, (GLboolean) p5, (void *) p6); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getMapParameterfvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getMapParameterfvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetMapParameterfvNV((GLuint) p0, (GLuint) p1, (GLfloat *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getMapParameterivNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getMapParameterivNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetMapParameterivNV((GLuint) p0, (GLuint) p1, (GLint *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getObjectBufferfvATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getObjectBufferfvATI(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetObjectBufferfvATI((GLuint) p0, (GLuint) p1, (GLfloat *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getObjectBufferivATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getObjectBufferivATI(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetObjectBufferivATI((GLuint) p0, (GLuint) p1, (GLint *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getOcclusionQueryivNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getOcclusionQueryivNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetOcclusionQueryivNV((GLuint) p0, (GLuint) p1, (GLint *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getOcclusionQueryuivNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getOcclusionQueryuivNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetOcclusionQueryuivNV((GLuint) p0, (GLuint) p1, (GLuint *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getProgramEnvParameterdvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getProgramEnvParameterdvARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetProgramEnvParameterdvARB((GLuint) p0, (GLuint) p1, (GLdouble *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getProgramEnvParameterfvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getProgramEnvParameterfvARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetProgramEnvParameterfvARB((GLuint) p0, (GLuint) p1, (GLfloat *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getProgramivARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getProgramivARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetProgramivARB((GLuint) p0, (GLuint) p1, (GLint *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getProgramivNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getProgramivNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetProgramivNV((GLuint) p0, (GLuint) p1, (GLint *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getProgramLocalParameterdvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getProgramLocalParameterdvARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetProgramLocalParameterdvARB((GLuint) p0, (GLuint) p1, (GLdouble *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getProgramLocalParameterfvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getProgramLocalParameterfvARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetProgramLocalParameterfvARB((GLuint) p0, (GLuint) p1, (GLfloat *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getProgramParameterdvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getProgramParameterdvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glGetProgramParameterdvNV((GLuint) p0, (GLuint) p1, (GLuint) p2, (GLdouble *) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getProgramParameterfvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getProgramParameterfvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glGetProgramParameterfvNV((GLuint) p0, (GLuint) p1, (GLuint) p2, (GLfloat *) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getProgramStringARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getProgramStringARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetProgramStringARB((GLuint) p0, (GLuint) p1, (void *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getProgramStringNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getProgramStringNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetProgramStringNV((GLuint) p0, (GLuint) p1, (GLubyte *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getTexBumpParameterfvATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getTexBumpParameterfvATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glGetTexBumpParameterfvATI((GLuint) p0, (GLfloat *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getTexBumpParameterivATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getTexBumpParameterivATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glGetTexBumpParameterivATI((GLuint) p0, (GLint *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getTrackMatrixivNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getTrackMatrixivNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glGetTrackMatrixivNV((GLuint) p0, (GLuint) p1, (GLuint) p2, (GLint *) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getVariantArrayObjectfvATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getVariantArrayObjectfvATI(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetVariantArrayObjectfvATI((GLuint) p0, (GLuint) p1, (GLfloat *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getVariantArrayObjectivATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getVariantArrayObjectivATI(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetVariantArrayObjectivATI((GLuint) p0, (GLuint) p1, (GLint *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getVariantBooleanvEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getVariantBooleanvEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetVariantBooleanvEXT((GLuint) p0, (GLuint) p1, (GLboolean *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getVariantFloatvEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getVariantFloatvEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetVariantFloatvEXT((GLuint) p0, (GLuint) p1, (GLfloat *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getVariantIntegervEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getVariantIntegervEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetVariantIntegervEXT((GLuint) p0, (GLuint) p1, (GLint *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getVariantPointervEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getVariantPointervEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetVariantPointervEXT((GLuint) p0, (GLuint) p1, (void **) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getVertexAttribdvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getVertexAttribdvARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetVertexAttribdvARB((GLuint) p0, (GLuint) p1, (GLdouble *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getVertexAttribdvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getVertexAttribdvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetVertexAttribdvNV((GLuint) p0, (GLuint) p1, (GLdouble *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getVertexAttribfvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getVertexAttribfvARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetVertexAttribfvARB((GLuint) p0, (GLuint) p1, (GLfloat *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getVertexAttribfvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getVertexAttribfvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetVertexAttribfvNV((GLuint) p0, (GLuint) p1, (GLfloat *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getVertexAttribivARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getVertexAttribivARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetVertexAttribivARB((GLuint) p0, (GLuint) p1, (GLint *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getVertexAttribivNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getVertexAttribivNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetVertexAttribivNV((GLuint) p0, (GLuint) p1, (GLint *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getVertexAttribPointervARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getVertexAttribPointervARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetVertexAttribPointervARB((GLuint) p0, (GLuint) p1, (void **) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: getVertexAttribPointervNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_getVertexAttribPointervNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glGetVertexAttribPointervNV((GLuint) p0, (GLuint) p1, (void **) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: insertComponentEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_insertComponentEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glInsertComponentEXT((GLint) p0, (GLint) p1, (GLint) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: isFenceNV + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL_isFenceNV(JNIEnv * env, jobject obj, jint p0) +{ +//jboolean ret = (jboolean) glIsFenceNV((GLint) p0); +//CHECK_GL_ERROR +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: isObjectBufferATI + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL_isObjectBufferATI(JNIEnv * env, jobject obj, jint p0) +{ +//jboolean ret = (jboolean) glIsObjectBufferATI((GLint) p0); +//CHECK_GL_ERROR +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: isOcclusionQueryNV + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL_isOcclusionQueryNV(JNIEnv * env, jobject obj, jint p0) +{ +//jboolean ret = (jboolean) glIsOcclusionQueryNV((GLint) p0); +//CHECK_GL_ERROR +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: isProgramARB + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL_isProgramARB(JNIEnv * env, jobject obj, jint p0) +{ +//jboolean ret = (jboolean) glIsProgramARB((GLint) p0); +//CHECK_GL_ERROR +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: isProgramNV + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL_isProgramNV(JNIEnv * env, jobject obj, jint p0) +{ +//jboolean ret = (jboolean) glIsProgramNV((GLint) p0); +//CHECK_GL_ERROR +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: isVariantEnabledEXT + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL_isVariantEnabledEXT(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//jboolean ret = (jboolean) glIsVariantEnabledEXT((GLint) p0, (GLint) p1); +//CHECK_GL_ERROR +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: loadProgramNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_loadProgramNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glLoadProgramNV((GLuint) p0, (GLuint) p1, (GLint) p2, (const GLubyte *) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: loadTransposeMatrixdARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_loadTransposeMatrixdARB(JNIEnv * env, jobject obj, jint p0) +{ +//glLoadTransposeMatrixdARB((const GLdouble *) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: loadTransposeMatrixfARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_loadTransposeMatrixfARB(JNIEnv * env, jobject obj, jint p0) +{ +//glLoadTransposeMatrixfARB((const GLfloat *) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: lockArraysEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_lockArraysEXT(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glLockArraysEXT((GLint) p0, (GLint) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: mapControlPointsNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_mapControlPointsNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6, jboolean p7, jint p8) +{ +//glMapControlPointsNV((GLuint) p0, (GLuint) p1, (GLuint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6, (GLboolean) p7, (const void *) p8); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: mapParameterfvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_mapParameterfvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glMapParameterfvNV((GLuint) p0, (GLuint) p1, (const GLfloat *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: mapParameterivNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_mapParameterivNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glMapParameterivNV((GLuint) p0, (GLuint) p1, (const GLint *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: matrixIndexPointerARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_matrixIndexPointerARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glMatrixIndexPointerARB((GLint) p0, (GLuint) p1, (GLint) p2, (void *) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: matrixIndexubvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_matrixIndexubvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glMatrixIndexubvARB((GLint) p0, (GLubyte *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: matrixIndexuivARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_matrixIndexuivARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glMatrixIndexuivARB((GLint) p0, (GLuint *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: matrixIndexusvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_matrixIndexusvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glMatrixIndexusvARB((GLint) p0, (GLushort *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiDrawArraysEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiDrawArraysEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glMultiDrawArraysEXT((GLuint) p0, (GLint *) p1, (GLint *) p2, (GLint) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiDrawElementsEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiDrawElementsEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4) +{ +//glMultiDrawElementsEXT((GLuint) p0, (GLint *) p1, (GLuint) p2, (const void **) p3, (GLint) p4); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord1dARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord1dARB(JNIEnv * env, jobject obj, jint p0, jdouble p1) +{ +//glMultiTexCoord1dARB((GLint) p0, (GLdouble) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord1dvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord1dvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glMultiTexCoord1dvARB((GLuint) p0, (const GLdouble *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord1fARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord1fARB(JNIEnv * env, jobject obj, jint p0, jfloat p1) +{ +//glMultiTexCoord1fARB((GLuint) p0, (GLfloat) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord1fvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord1fvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glMultiTexCoord1fvARB((GLint) p0, (const GLfloat *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord1iARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord1iARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glMultiTexCoord1iARB((GLint) p0, (GLint) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord1ivARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord1ivARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glMultiTexCoord1ivARB((GLuint) p0, (const GLint *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord1sARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord1sARB(JNIEnv * env, jobject obj, jint p0, jshort p1) +{ +//glMultiTexCoord1sARB((GLint) p0, (GLshort) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord1svARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord1svARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glMultiTexCoord1svARB((GLuint) p0, (const GLshort *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord2dARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord2dARB(JNIEnv * env, jobject obj, jint p0, jdouble p1, jdouble p2) +{ +//glMultiTexCoord2dARB((GLint) p0, (GLdouble) p1, (GLdouble) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord2dvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord2dvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glMultiTexCoord2dvARB((GLuint) p0, (const GLdouble *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord2fARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord2fARB(JNIEnv * env, jobject obj, jint p0, jfloat p1, jfloat p2) +{ +//glMultiTexCoord2fARB((GLint) p0, (GLfloat) p1, (GLfloat) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord2fvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord2fvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glMultiTexCoord2fvARB((GLuint) p0, (const GLfloat *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord2iARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord2iARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glMultiTexCoord2iARB((GLint) p0, (GLint) p1, (GLint) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord2ivARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord2ivARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glMultiTexCoord2ivARB((GLuint) p0, (const GLint *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord2sARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord2sARB(JNIEnv * env, jobject obj, jint p0, jshort p1, jshort p2) +{ +//glMultiTexCoord2sARB((GLint) p0, (GLshort) p1, (GLshort) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord2svARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord2svARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glMultiTexCoord2svARB((GLuint) p0, (const GLshort *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord3dARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord3dARB(JNIEnv * env, jobject obj, jint p0, jdouble p1, jdouble p2, jdouble p3) +{ +//glMultiTexCoord3dARB((GLint) p0, (GLdouble) p1, (GLdouble) p2, (GLdouble) p3); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord3dvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord3dvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glMultiTexCoord3dvARB((GLuint) p0, (const GLdouble *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord3fARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord3fARB(JNIEnv * env, jobject obj, jint p0, jfloat p1, jfloat p2, jfloat p3) +{ +//glMultiTexCoord3fARB((GLint) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord3fvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord3fvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glMultiTexCoord3fvARB((GLuint) p0, (const GLfloat *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord3iARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord3iARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glMultiTexCoord3iARB((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord3ivARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord3ivARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glMultiTexCoord3ivARB((GLuint) p0, (const GLint *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord3sARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord3sARB(JNIEnv * env, jobject obj, jint p0, jshort p1, jshort p2, jshort p3) +{ +//glMultiTexCoord3sARB((GLint) p0, (GLshort) p1, (GLshort) p2, (GLshort) p3); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord3svARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord3svARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glMultiTexCoord3svARB((GLuint) p0, (const GLshort *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord4dARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord4dARB(JNIEnv * env, jobject obj, jint p0, jdouble p1, jdouble p2, jdouble p3, jdouble p4) +{ +//glMultiTexCoord4dARB((GLint) p0, (GLdouble) p1, (GLdouble) p2, (GLdouble) p3, (GLdouble) p4); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord4dvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord4dvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glMultiTexCoord4dvARB((GLuint) p0, (const GLdouble *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord4fARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord4fARB(JNIEnv * env, jobject obj, jint p0, jfloat p1, jfloat p2, jfloat p3, jfloat p4) +{ +//glMultiTexCoord4fARB((GLint) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3, (GLfloat) p4); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord4fvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord4fvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glMultiTexCoord4fvARB((GLuint) p0, (const GLfloat *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord4iARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord4iARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4) +{ +//glMultiTexCoord4iARB((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord4ivARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord4ivARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glMultiTexCoord4ivARB((GLuint) p0, (const GLint *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord4sARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord4sARB(JNIEnv * env, jobject obj, jint p0, jshort p1, jshort p2, jshort p3, jshort p4) +{ +//glMultiTexCoord4sARB((GLint) p0, (GLshort) p1, (GLshort) p2, (GLshort) p3, (GLshort) p4); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multiTexCoord4svARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multiTexCoord4svARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glMultiTexCoord4svARB((GLuint) p0, (const GLshort *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multTransposeMatrixdARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multTransposeMatrixdARB(JNIEnv * env, jobject obj, jint p0) +{ +//glMultTransposeMatrixdARB((const GLdouble *) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: multTransposeMatrixfARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_multTransposeMatrixfARB(JNIEnv * env, jobject obj, jint p0) +{ +//glMultTransposeMatrixfARB((const GLfloat *) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: newObjectBufferATI + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL_newObjectBufferATI(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//jint ret = (jint) glNewObjectBufferATI((GLint) p0, (const void *) p1, (GLuint) p2); +//CHECK_GL_ERROR +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: normalStream3bATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_normalStream3bATI(JNIEnv * env, jobject obj, jint p0, jbyte p1, jbyte p2, jbyte p3) +{ +//glNormalStream3bATI((GLint) p0, (GLbyte) p1, (GLbyte) p2, (GLbyte) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: normalStream3bvATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_normalStream3bvATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glNormalStream3bvATI((GLint) p0, (const GLbyte *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: normalStream3dATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_normalStream3dATI(JNIEnv * env, jobject obj, jint p0, jdouble p1, jdouble p2, jdouble p3) +{ +//glNormalStream3dATI((GLint) p0, (GLdouble) p1, (GLdouble) p2, (GLdouble) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: normalStream3dvATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_normalStream3dvATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glNormalStream3dvATI((GLuint) p0, (const GLdouble *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: normalStream3fATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_normalStream3fATI(JNIEnv * env, jobject obj, jint p0, jfloat p1, jfloat p2, jfloat p3) +{ +//glNormalStream3fATI((GLint) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: normalStream3fvATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_normalStream3fvATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glNormalStream3fvATI((GLuint) p0, (const GLfloat *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: normalStream3iATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_normalStream3iATI(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glNormalStream3iATI((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: normalStream3ivATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_normalStream3ivATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glNormalStream3ivATI((GLuint) p0, (const GLint *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: normalStream3sATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_normalStream3sATI(JNIEnv * env, jobject obj, jint p0, jshort p1, jshort p2, jshort p3) +{ +//glNormalStream3sATI((GLint) p0, (GLshort) p1, (GLshort) p2, (GLshort) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: normalStream3svATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_normalStream3svATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glNormalStream3svATI((GLuint) p0, (const GLshort *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: passTexCoordATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_passTexCoordATI(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glPassTexCoordATI((GLint) p0, (GLint) p1, (GLint) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: PNTrianglesfATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_PNTrianglesfATI(JNIEnv * env, jobject obj, jint p0, jfloat p1) +{ +//glPNTrianglesfATI((GLint) p0, (GLfloat) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: PNTrianglesiATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_PNTrianglesiATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glPNTrianglesiATI((GLint) p0, (GLint) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: pointParameterfARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_pointParameterfARB(JNIEnv * env, jobject obj, jint p0, jfloat p1) +{ +//glPointParameterfARB((GLint) p0, (GLfloat) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: pointParameterfEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_pointParameterfEXT(JNIEnv * env, jobject obj, jint p0, jfloat p1) +{ +//glPointParameterfEXT((GLint) p0, (GLfloat) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: pointParameterfvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_pointParameterfvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glPointParameterfvARB((GLuint) p0, (GLfloat *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: pointParameterfvEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_pointParameterfvEXT(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glPointParameterfvEXT((GLuint) p0, (const GLfloat *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: pointParameteriNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_pointParameteriNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glPointParameteriNV((GLint) p0, (GLint) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: pointParameterivNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_pointParameterivNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glPointParameterivNV((GLuint) p0, (const GLint *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: programEnvParameter4dARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_programEnvParameter4dARB(JNIEnv * env, jobject obj, jint p0, jint p1, jdouble p2, jdouble p3, jdouble p4, jdouble p5) +{ +//glProgramEnvParameter4dARB((GLint) p0, (GLint) p1, (GLdouble) p2, (GLdouble) p3, (GLdouble) p4, (GLdouble) p5); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: programEnvParameter4dvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_programEnvParameter4dvARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glProgramEnvParameter4dvARB((GLuint) p0, (GLuint) p1, (const GLdouble *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: programEnvParameter4fARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_programEnvParameter4fARB(JNIEnv * env, jobject obj, jint p0, jint p1, jfloat p2, jfloat p3, jfloat p4, jfloat p5) +{ +//glProgramEnvParameter4fARB((GLint) p0, (GLint) p1, (GLfloat) p2, (GLfloat) p3, (GLfloat) p4, (GLfloat) p5); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: programEnvParameter4fvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_programEnvParameter4fvARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glProgramEnvParameter4fvARB((GLuint) p0, (GLuint) p1, (const GLfloat *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: programLocalParameter4dARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_programLocalParameter4dARB(JNIEnv * env, jobject obj, jint p0, jint p1, jdouble p2, jdouble p3, jdouble p4, jdouble p5) +{ +//glProgramLocalParameter4dARB((GLint) p0, (GLint) p1, (GLdouble) p2, (GLdouble) p3, (GLdouble) p4, (GLdouble) p5); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: programLocalParameter4dvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_programLocalParameter4dvARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glProgramLocalParameter4dvARB((GLuint) p0, (GLuint) p1, (const GLdouble *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: programLocalParameter4fARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_programLocalParameter4fARB(JNIEnv * env, jobject obj, jint p0, jint p1, jfloat p2, jfloat p3, jfloat p4, jfloat p5) +{ +//glProgramLocalParameter4fARB((GLint) p0, (GLint) p1, (GLfloat) p2, (GLfloat) p3, (GLfloat) p4, (GLfloat) p5); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: programLocalParameter4fvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_programLocalParameter4fvARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glProgramLocalParameter4fvARB((GLuint) p0, (GLuint) p1, (const GLfloat *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: programParameter4dNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_programParameter4dNV(JNIEnv * env, jobject obj, jint p0, jint p1, jdouble p2, jdouble p3, jdouble p4, jdouble p5) +{ +//glProgramParameter4dNV((GLint) p0, (GLint) p1, (GLdouble) p2, (GLdouble) p3, (GLdouble) p4, (GLdouble) p5); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: programParameter4dvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_programParameter4dvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glProgramParameter4dvNV((GLuint) p0, (GLuint) p1, (const GLdouble *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: programParameter4fNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_programParameter4fNV(JNIEnv * env, jobject obj, jint p0, jint p1, jfloat p2, jfloat p3, jfloat p4, jfloat p5) +{ +//glProgramParameter4fNV((GLint) p0, (GLint) p1, (GLfloat) p2, (GLfloat) p3, (GLfloat) p4, (GLfloat) p5); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: programParameter4fvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_programParameter4fvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glProgramParameter4fvNV((GLuint) p0, (GLuint) p1, (const GLfloat *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: programParameters4dvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_programParameters4dvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glProgramParameters4dvNV((GLuint) p0, (GLuint) p1, (GLuint) p2, (const GLdouble *) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: programParameters4fvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_programParameters4fvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glProgramParameters4fvNV((GLuint) p0, (GLuint) p1, (GLuint) p2, (const GLfloat *) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: programStringARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_programStringARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glProgramStringARB((GLuint) p0, (GLuint) p1, (GLint) p2, (const void *) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: requestResidentProgramsNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_requestResidentProgramsNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glRequestResidentProgramsNV((GLint) p0, (GLuint *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: sampleCoverageARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_sampleCoverageARB(JNIEnv * env, jobject obj, jfloat p0, jboolean p1) +{ +//glSampleCoverageARB((GLfloat) p0, (GLboolean) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: sampleMapATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_sampleMapATI(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glSampleMapATI((GLint) p0, (GLint) p1, (GLint) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: secondaryColor3bEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_secondaryColor3bEXT(JNIEnv * env, jobject obj, jbyte p0, jbyte p1, jbyte p2) +{ +//glSecondaryColor3bEXT((GLbyte) p0, (GLbyte) p1, (GLbyte) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: secondaryColor3bvEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_secondaryColor3bvEXT(JNIEnv * env, jobject obj, jint p0) +{ +//glSecondaryColor3bvEXT((const GLbyte *) p0); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: secondaryColor3dEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_secondaryColor3dEXT(JNIEnv * env, jobject obj, jdouble p0, jdouble p1, jdouble p2) +{ +//glSecondaryColor3dEXT((GLdouble) p0, (GLdouble) p1, (GLdouble) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: secondaryColor3dvEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_secondaryColor3dvEXT(JNIEnv * env, jobject obj, jint p0) +{ +//glSecondaryColor3dvEXT((const GLdouble *) p0); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: secondaryColor3fEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_secondaryColor3fEXT(JNIEnv * env, jobject obj, jfloat p0, jfloat p1, jfloat p2) +{ +//glSecondaryColor3fEXT((GLfloat) p0, (GLfloat) p1, (GLfloat) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: secondaryColor3fvEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_secondaryColor3fvEXT(JNIEnv * env, jobject obj, jint p0) +{ +//glSecondaryColor3fvEXT((const GLfloat *) p0); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: secondaryColor3iEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_secondaryColor3iEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glSecondaryColor3iEXT((GLint) p0, (GLint) p1, (GLint) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: secondaryColor3ivEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_secondaryColor3ivEXT(JNIEnv * env, jobject obj, jint p0) +{ +//glSecondaryColor3ivEXT((const GLint *) p0); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: secondaryColor3sEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_secondaryColor3sEXT(JNIEnv * env, jobject obj, jshort p0, jshort p1, jshort p2) +{ +//glSecondaryColor3sEXT((GLshort) p0, (GLshort) p1, (GLshort) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: secondaryColor3svEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_secondaryColor3svEXT(JNIEnv * env, jobject obj, jint p0) +{ +//glSecondaryColor3svEXT((const GLshort *) p0); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: secondaryColor3ubEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_secondaryColor3ubEXT(JNIEnv * env, jobject obj, jbyte p0, jbyte p1, jbyte p2) +{ +//glSecondaryColor3ubEXT((GLbyte) p0, (GLbyte) p1, (GLbyte) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: secondaryColor3ubvEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_secondaryColor3ubvEXT(JNIEnv * env, jobject obj, jint p0) +{ +//glSecondaryColor3ubvEXT((const GLubyte *) p0); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: secondaryColor3uiEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_secondaryColor3uiEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glSecondaryColor3uiEXT((GLint) p0, (GLint) p1, (GLint) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: secondaryColor3uivEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_secondaryColor3uivEXT(JNIEnv * env, jobject obj, jint p0) +{ +//glSecondaryColor3uivEXT((const GLuint *) p0); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: secondaryColor3usEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_secondaryColor3usEXT(JNIEnv * env, jobject obj, jshort p0, jshort p1, jshort p2) +{ +//glSecondaryColor3usEXT((GLshort) p0, (GLshort) p1, (GLshort) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: secondaryColor3usvEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_secondaryColor3usvEXT(JNIEnv * env, jobject obj, jint p0) +{ +//glSecondaryColor3usvEXT((const GLushort *) p0); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: secondaryColorPointerEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_secondaryColorPointerEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glSecondaryColorPointerEXT((GLint) p0, (GLuint) p1, (GLint) p2, (void *) p3); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: setFenceNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_setFenceNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glSetFenceNV((GLint) p0, (GLint) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: setFragmentShaderConstantATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_setFragmentShaderConstantATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glSetFragmentShaderConstantATI((GLuint) p0, (const GLfloat *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: setInvariantEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_setInvariantEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glSetInvariantEXT((GLuint) p0, (GLuint) p1, (void *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: setLocalConstantEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_setLocalConstantEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glSetLocalConstantEXT((GLuint) p0, (GLuint) p1, (void *) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: shaderOp1EXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_shaderOp1EXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glShaderOp1EXT((GLint) p0, (GLint) p1, (GLint) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: shaderOp2EXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_shaderOp2EXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glShaderOp2EXT((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: shaderOp3EXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_shaderOp3EXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4) +{ +//glShaderOp3EXT((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: swizzleEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_swizzleEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5) +{ +//glSwizzleEXT((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: testFenceNV + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL_testFenceNV(JNIEnv * env, jobject obj, jint p0) +{ +//jboolean ret = (jboolean) glTestFenceNV((GLint) p0); +//CHECK_GL_ERROR +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: texBumpParameterfvATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_texBumpParameterfvATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glTexBumpParameterfvATI((GLuint) p0, (GLfloat *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: texBumpParameterivATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_texBumpParameterivATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glTexBumpParameterivATI((GLuint) p0, (GLint *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: trackMatrixNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_trackMatrixNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glTrackMatrixNV((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: unlockArraysEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_unlockArraysEXT(JNIEnv * env, jobject obj) +{ +//glUnlockArraysEXT(); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: updateObjectBufferATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_updateObjectBufferATI(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4) +{ +//glUpdateObjectBufferATI((GLuint) p0, (GLuint) p1, (GLint) p2, (const void *) p3, (GLuint) p4); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: variantArrayObjectATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_variantArrayObjectATI(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4) +{ +//glVariantArrayObjectATI((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: variantbvEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_variantbvEXT(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVariantbvEXT((GLuint) p0, (GLbyte *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: variantdvEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_variantdvEXT(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVariantdvEXT((GLuint) p0, (GLdouble *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: variantfvEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_variantfvEXT(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVariantfvEXT((GLuint) p0, (GLfloat *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: variantivEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_variantivEXT(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVariantivEXT((GLuint) p0, (GLint *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: variantPointerEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_variantPointerEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glVariantPointerEXT((GLuint) p0, (GLuint) p1, (GLint) p2, (void *) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: variantsvEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_variantsvEXT(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVariantsvEXT((GLuint) p0, (GLshort *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: variantubvEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_variantubvEXT(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVariantubvEXT((GLuint) p0, (GLubyte *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: variantuivEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_variantuivEXT(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVariantuivEXT((GLuint) p0, (GLuint *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: variantusvEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_variantusvEXT(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVariantusvEXT((GLuint) p0, (GLushort *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexArrayRangeNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexArrayRangeNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexArrayRangeNV((GLint) p0, (const void *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib1dARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib1dARB(JNIEnv * env, jobject obj, jint p0, jdouble p1) +{ +//glVertexAttrib1dARB((GLint) p0, (GLdouble) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib1dNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib1dNV(JNIEnv * env, jobject obj, jint p0, jdouble p1) +{ +//glVertexAttrib1dNV((GLint) p0, (GLdouble) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib1dvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib1dvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib1dvARB((GLuint) p0, (const GLdouble *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib1dvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib1dvNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib1dvNV((GLuint) p0, (const GLdouble *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib1fARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib1fARB(JNIEnv * env, jobject obj, jint p0, jfloat p1) +{ +//glVertexAttrib1fARB((GLint) p0, (GLfloat) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib1fNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib1fNV(JNIEnv * env, jobject obj, jint p0, jfloat p1) +{ +//glVertexAttrib1fNV((GLint) p0, (GLfloat) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib1fvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib1fvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib1fvARB((GLuint) p0, (const GLfloat *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib1fvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib1fvNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib1fvNV((GLuint) p0, (const GLfloat *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib1sARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib1sARB(JNIEnv * env, jobject obj, jint p0, jshort p1) +{ +//glVertexAttrib1sARB((GLint) p0, (GLshort) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib1sNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib1sNV(JNIEnv * env, jobject obj, jint p0, jshort p1) +{ +//glVertexAttrib1sNV((GLint) p0, (GLshort) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib1svARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib1svARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib1svARB((GLuint) p0, (const GLshort *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib1svNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib1svNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib1svNV((GLuint) p0, (const GLshort *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib2dARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib2dARB(JNIEnv * env, jobject obj, jint p0, jdouble p1, jdouble p2) +{ +//glVertexAttrib2dARB((GLint) p0, (GLdouble) p1, (GLdouble) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib2dNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib2dNV(JNIEnv * env, jobject obj, jint p0, jdouble p1, jdouble p2) +{ +//glVertexAttrib2dNV((GLint) p0, (GLdouble) p1, (GLdouble) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib2dvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib2dvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib2dvARB((GLuint) p0, (const GLdouble *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib2dvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib2dvNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib2dvNV((GLuint) p0, (const GLdouble *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib2fARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib2fARB(JNIEnv * env, jobject obj, jint p0, jfloat p1, jfloat p2) +{ +//glVertexAttrib2fARB((GLint) p0, (GLfloat) p1, (GLfloat) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib2fNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib2fNV(JNIEnv * env, jobject obj, jint p0, jfloat p1, jfloat p2) +{ +//glVertexAttrib2fNV((GLint) p0, (GLfloat) p1, (GLfloat) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib2fvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib2fvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib2fvARB((GLuint) p0, (const GLfloat *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib2fvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib2fvNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib2fvNV((GLuint) p0, (const GLfloat *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib2sARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib2sARB(JNIEnv * env, jobject obj, jint p0, jshort p1, jshort p2) +{ +//glVertexAttrib2sARB((GLint) p0, (GLshort) p1, (GLshort) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib2sNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib2sNV(JNIEnv * env, jobject obj, jint p0, jshort p1, jshort p2) +{ +//glVertexAttrib2sNV((GLint) p0, (GLshort) p1, (GLshort) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib2svARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib2svARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib2svARB((GLuint) p0, (const GLshort *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib2svNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib2svNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib2svNV((GLuint) p0, (const GLshort *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib3dARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib3dARB(JNIEnv * env, jobject obj, jint p0, jdouble p1, jdouble p2, jdouble p3) +{ +//glVertexAttrib3dARB((GLint) p0, (GLdouble) p1, (GLdouble) p2, (GLdouble) p3); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib3dNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib3dNV(JNIEnv * env, jobject obj, jint p0, jdouble p1, jdouble p2, jdouble p3) +{ +//glVertexAttrib3dNV((GLint) p0, (GLdouble) p1, (GLdouble) p2, (GLdouble) p3); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib3dvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib3dvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib3dvARB((GLuint) p0, (const GLdouble *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib3dvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib3dvNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib3dvNV((GLuint) p0, (const GLdouble *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib3fARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib3fARB(JNIEnv * env, jobject obj, jint p0, jfloat p1, jfloat p2, jfloat p3) +{ +//glVertexAttrib3fARB((GLint) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib3fNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib3fNV(JNIEnv * env, jobject obj, jint p0, jfloat p1, jfloat p2, jfloat p3) +{ +//glVertexAttrib3fNV((GLint) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib3fvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib3fvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib3fvARB((GLuint) p0, (const GLfloat *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib3fvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib3fvNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib3fvNV((GLuint) p0, (const GLfloat *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib3sARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib3sARB(JNIEnv * env, jobject obj, jint p0, jshort p1, jshort p2, jshort p3) +{ +//glVertexAttrib3sARB((GLint) p0, (GLshort) p1, (GLshort) p2, (GLshort) p3); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib3sNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib3sNV(JNIEnv * env, jobject obj, jint p0, jshort p1, jshort p2, jshort p3) +{ +//glVertexAttrib3sNV((GLint) p0, (GLshort) p1, (GLshort) p2, (GLshort) p3); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib3svARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib3svARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib3svARB((GLuint) p0, (const GLshort *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib3svNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib3svNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib3svNV((GLuint) p0, (const GLshort *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4bvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4bvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib4bvARB((GLuint) p0, (const GLbyte *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4dARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4dARB(JNIEnv * env, jobject obj, jint p0, jdouble p1, jdouble p2, jdouble p3, jdouble p4) +{ +//glVertexAttrib4dARB((GLint) p0, (GLdouble) p1, (GLdouble) p2, (GLdouble) p3, (GLdouble) p4); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4dNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4dNV(JNIEnv * env, jobject obj, jint p0, jdouble p1, jdouble p2, jdouble p3, jdouble p4) +{ +//glVertexAttrib4dNV((GLint) p0, (GLdouble) p1, (GLdouble) p2, (GLdouble) p3, (GLdouble) p4); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4dvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4dvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib4dvARB((GLuint) p0, (const GLdouble *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4dvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4dvNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib4dvNV((GLuint) p0, (const GLdouble *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4fARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4fARB(JNIEnv * env, jobject obj, jint p0, jfloat p1, jfloat p2, jfloat p3, jfloat p4) +{ +//glVertexAttrib4fARB((GLint) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3, (GLfloat) p4); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4fNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4fNV(JNIEnv * env, jobject obj, jint p0, jfloat p1, jfloat p2, jfloat p3, jfloat p4) +{ +//glVertexAttrib4fNV((GLint) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3, (GLfloat) p4); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4fvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4fvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib4fvARB((GLuint) p0, (const GLfloat *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4fvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4fvNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib4fvNV((GLuint) p0, (const GLfloat *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4ivARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4ivARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib4ivARB((GLuint) p0, (const GLint *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4NbvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4NbvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib4NbvARB((GLuint) p0, (const GLbyte *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4NivARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4NivARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib4NivARB((GLuint) p0, (const GLint *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4NsvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4NsvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib4NsvARB((GLuint) p0, (const GLshort *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4NubARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4NubARB(JNIEnv * env, jobject obj, jint p0, jbyte p1, jbyte p2, jbyte p3, jbyte p4) +{ +//glVertexAttrib4NubARB((GLint) p0, (GLbyte) p1, (GLbyte) p2, (GLbyte) p3, (GLbyte) p4); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4NubvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4NubvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib4NubvARB((GLuint) p0, (const GLubyte *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4NuivARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4NuivARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib4NuivARB((GLuint) p0, (const GLuint *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4NusvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4NusvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib4NusvARB((GLuint) p0, (const GLushort *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4sARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4sARB(JNIEnv * env, jobject obj, jint p0, jshort p1, jshort p2, jshort p3, jshort p4) +{ +//glVertexAttrib4sARB((GLint) p0, (GLshort) p1, (GLshort) p2, (GLshort) p3, (GLshort) p4); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4sNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4sNV(JNIEnv * env, jobject obj, jint p0, jshort p1, jshort p2, jshort p3, jshort p4) +{ +//glVertexAttrib4sNV((GLint) p0, (GLshort) p1, (GLshort) p2, (GLshort) p3, (GLshort) p4); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4svARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4svARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib4svARB((GLuint) p0, (const GLshort *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4svNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4svNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib4svNV((GLuint) p0, (const GLshort *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4ubNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4ubNV(JNIEnv * env, jobject obj, jint p0, jbyte p1, jbyte p2, jbyte p3, jbyte p4) +{ +//glVertexAttrib4ubNV((GLint) p0, (GLbyte) p1, (GLbyte) p2, (GLbyte) p3, (GLbyte) p4); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4ubvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4ubvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib4ubvARB((GLuint) p0, (const GLubyte *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4ubvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4ubvNV(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib4ubvNV((GLuint) p0, (const GLubyte *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4uivARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4uivARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib4uivARB((GLuint) p0, (const GLuint *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttrib4usvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttrib4usvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexAttrib4usvARB((GLuint) p0, (const GLushort *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttribPointerARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttribPointerARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jboolean p3, jint p4, jint p5) +{ +//glVertexAttribPointerARB((GLuint) p0, (GLint) p1, (GLuint) p2, (GLboolean) p3, (GLint) p4, (const void *) p5); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttribPointerNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttribPointerNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4) +{ +//glVertexAttribPointerNV((GLuint) p0, (GLint) p1, (GLuint) p2, (GLint) p3, (const void *) p4); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttribs1dvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttribs1dvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glVertexAttribs1dvNV((GLuint) p0, (GLint) p1, (const GLdouble *) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttribs1fvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttribs1fvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glVertexAttribs1fvNV((GLuint) p0, (GLint) p1, (const GLfloat *) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttribs1svNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttribs1svNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glVertexAttribs1svNV((GLuint) p0, (GLint) p1, (const GLshort *) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttribs2dvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttribs2dvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glVertexAttribs2dvNV((GLuint) p0, (GLint) p1, (const GLdouble *) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttribs2fvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttribs2fvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glVertexAttribs2fvNV((GLuint) p0, (GLint) p1, (const GLfloat *) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttribs2svNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttribs2svNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glVertexAttribs2svNV((GLuint) p0, (GLint) p1, (const GLshort *) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttribs3dvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttribs3dvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glVertexAttribs3dvNV((GLuint) p0, (GLint) p1, (const GLdouble *) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttribs3fvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttribs3fvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glVertexAttribs3fvNV((GLuint) p0, (GLint) p1, (const GLfloat *) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttribs3svNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttribs3svNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glVertexAttribs3svNV((GLuint) p0, (GLint) p1, (const GLshort *) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttribs4dvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttribs4dvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glVertexAttribs4dvNV((GLuint) p0, (GLint) p1, (const GLdouble *) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttribs4fvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttribs4fvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glVertexAttribs4fvNV((GLuint) p0, (GLint) p1, (const GLfloat *) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttribs4svNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttribs4svNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glVertexAttribs4svNV((GLuint) p0, (GLint) p1, (const GLshort *) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexAttribs4ubvNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexAttribs4ubvNV(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glVertexAttribs4ubvNV((GLuint) p0, (GLint) p1, (const GLubyte *) p2); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexBlendARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexBlendARB(JNIEnv * env, jobject obj, jint p0) +{ +//glVertexBlendARB((GLint) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexBlendEnvfATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexBlendEnvfATI(JNIEnv * env, jobject obj, jint p0, jfloat p1) +{ +//glVertexBlendEnvfATI((GLint) p0, (GLfloat) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexBlendEnviATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexBlendEnviATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexBlendEnviATI((GLint) p0, (GLint) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream2dATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream2dATI(JNIEnv * env, jobject obj, jint p0, jdouble p1, jdouble p2) +{ +//glVertexStream2dATI((GLint) p0, (GLdouble) p1, (GLdouble) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream2dvATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream2dvATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexStream2dvATI((GLuint) p0, (const GLdouble *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream2fATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream2fATI(JNIEnv * env, jobject obj, jint p0, jfloat p1, jfloat p2) +{ +//glVertexStream2fATI((GLint) p0, (GLfloat) p1, (GLfloat) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream2fvATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream2fvATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexStream2fvATI((GLuint) p0, (const GLfloat *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream2iATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream2iATI(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glVertexStream2iATI((GLint) p0, (GLint) p1, (GLint) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream2ivATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream2ivATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexStream2ivATI((GLuint) p0, (const GLint *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream2sATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream2sATI(JNIEnv * env, jobject obj, jint p0, jshort p1, jshort p2) +{ +//glVertexStream2sATI((GLint) p0, (GLshort) p1, (GLshort) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream2svATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream2svATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexStream2svATI((GLuint) p0, (const GLshort *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream3dATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream3dATI(JNIEnv * env, jobject obj, jint p0, jdouble p1, jdouble p2, jdouble p3) +{ +//glVertexStream3dATI((GLint) p0, (GLdouble) p1, (GLdouble) p2, (GLdouble) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream3dvATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream3dvATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexStream3dvATI((GLuint) p0, (const GLdouble *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream3fATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream3fATI(JNIEnv * env, jobject obj, jint p0, jfloat p1, jfloat p2, jfloat p3) +{ +//glVertexStream3fATI((GLint) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream3fvATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream3fvATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexStream3fvATI((GLuint) p0, (const GLfloat *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream3iATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream3iATI(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glVertexStream3iATI((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream3ivATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream3ivATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexStream3ivATI((GLuint) p0, (const GLint *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream3sATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream3sATI(JNIEnv * env, jobject obj, jint p0, jshort p1, jshort p2, jshort p3) +{ +//glVertexStream3sATI((GLint) p0, (GLshort) p1, (GLshort) p2, (GLshort) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream3svATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream3svATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexStream3svATI((GLuint) p0, (const GLshort *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream4dATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream4dATI(JNIEnv * env, jobject obj, jint p0, jdouble p1, jdouble p2, jdouble p3, jdouble p4) +{ +//glVertexStream4dATI((GLint) p0, (GLdouble) p1, (GLdouble) p2, (GLdouble) p3, (GLdouble) p4); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream4dvATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream4dvATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexStream4dvATI((GLuint) p0, (const GLdouble *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream4fATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream4fATI(JNIEnv * env, jobject obj, jint p0, jfloat p1, jfloat p2, jfloat p3, jfloat p4) +{ +//glVertexStream4fATI((GLint) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3, (GLfloat) p4); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream4fvATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream4fvATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexStream4fvATI((GLuint) p0, (const GLfloat *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream4iATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream4iATI(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4) +{ +//glVertexStream4iATI((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream4ivATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream4ivATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexStream4ivATI((GLuint) p0, (const GLint *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream4sATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream4sATI(JNIEnv * env, jobject obj, jint p0, jshort p1, jshort p2, jshort p3, jshort p4) +{ +//glVertexStream4sATI((GLint) p0, (GLshort) p1, (GLshort) p2, (GLshort) p3, (GLshort) p4); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexStream4svATI + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexStream4svATI(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glVertexStream4svATI((GLuint) p0, (const GLshort *) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexWeightfEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexWeightfEXT(JNIEnv * env, jobject obj, jfloat p0) +{ +//glVertexWeightfEXT((GLfloat) p0); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexWeightfvEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexWeightfvEXT(JNIEnv * env, jobject obj, jint p0) +{ +//glVertexWeightfvEXT((const GLfloat *) p0); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: vertexWeightPointerEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_vertexWeightPointerEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glVertexWeightPointerEXT((GLint) p0, (GLuint) p1, (GLint) p2, (const void *) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: weightbvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_weightbvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glWeightbvARB((GLint) p0, (GLbyte *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: weightdvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_weightdvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glWeightdvARB((GLint) p0, (GLdouble *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: weightfvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_weightfvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glWeightfvARB((GLint) p0, (GLfloat *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: weightivARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_weightivARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glWeightivARB((GLint) p0, (GLint *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: weightPointerARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_weightPointerARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3) +{ +//glWeightPointerARB((GLint) p0, (GLuint) p1, (GLint) p2, (void *) p3); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: weightsvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_weightsvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glWeightsvARB((GLint) p0, (GLshort *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: weightubvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_weightubvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glWeightubvARB((GLint) p0, (GLubyte *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: weightuivARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_weightuivARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glWeightuivARB((GLint) p0, (GLuint *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: weightusvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_weightusvARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glWeightusvARB((GLint) p0, (GLushort *) p1); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: wglAllocateMemoryNV + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL_wglAllocateMemoryNV(JNIEnv * env, jclass clazz, jint p0, jfloat p1, jfloat p2, jfloat p3) +{ +//jint ret = (jint) wglAllocateMemoryNV((GLint) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3); +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: wglBindTexImageARB + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL_wglBindTexImageARB(JNIEnv * env, jclass clazz, jint p0, jint p1) +{ +//jboolean ret = (jboolean) wglBindTexImageARB((HPBUFFERARB) p0, (GLint) p1); +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: wglChoosePixelFormatARB + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL_wglChoosePixelFormatARB(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5) +{ +//jboolean ret = (jboolean) wglChoosePixelFormatARB((HDC) p0, (const GLint *) p1, (const GLfloat *) p2, (GLuint) p3, (GLint *) p4, (GLuint *) p5); +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: wglCreateBufferRegionARB + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL_wglCreateBufferRegionARB(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2) +{ +//jint ret = (jint) wglCreateBufferRegionARB((HDC) p0, (GLint) p1, (GLint) p2); +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: wglCreatePbufferARB + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL_wglCreatePbufferARB(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3, jint p4) +{ +//jint ret = (jint) wglCreatePbufferARB((HDC) p0, (GLint) p1, (GLint) p2, (GLint) p3, (const GLint *) p4); +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: wglDeleteBufferRegionARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_wglDeleteBufferRegionARB(JNIEnv * env, jclass clazz, jint p0) +{ +//wglDeleteBufferRegionARB((void *) p0); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: wglDestroyPbufferARB + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL_wglDestroyPbufferARB(JNIEnv * env, jclass clazz, jint p0) +{ +//jboolean ret = (jboolean) wglDestroyPbufferARB((HPBUFFERARB) p0); +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: wglFreeMemoryNV + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_wglFreeMemoryNV(JNIEnv * env, jclass clazz, jint p0) +{ +//wglFreeMemoryNV((void *) p0); +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: wglGetCurrentReadDCARB + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL_wglGetCurrentReadDCARB(JNIEnv * env, jclass clazz) +{ +//jint ret = (jint) wglGetCurrentReadDCARB(); +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: wglGetExtensionsStringARB + */ +JNIEXPORT jstring JNICALL Java_org_lwjgl_opengl_GL_wglGetExtensionsStringARB(JNIEnv * env, jclass clazz, jint p0) +{ +//if (wglGetExtensionsStringARB) +// return env->NewStringUTF(wglGetExtensionsStringARB(GetDC((HWND) p0))); +//else +// return NULL; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: wglGetExtensionsStringEXT + */ +JNIEXPORT jstring JNICALL Java_org_lwjgl_opengl_GL_wglGetExtensionsStringEXT(JNIEnv * env, jclass clazz) +{ +//jstring ret = env->NewStringUTF(wglGetExtensionsStringEXT()); +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: wglGetPbufferDCARB + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL_wglGetPbufferDCARB(JNIEnv * env, jclass clazz, jint p0) +{ +//jint ret = (jint) wglGetPbufferDCARB((HPBUFFERARB) p0); +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: wglGetPixelFormatAttribfvARB + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL_wglGetPixelFormatAttribfvARB(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5) +{ +//jboolean ret = (jboolean) wglGetPixelFormatAttribfvARB((HDC) p0, (GLint) p1, (GLint) p2, (GLuint) p3, (const GLint *) p4, (GLfloat *) p5); +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: wglGetPixelFormatAttribivARB + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL_wglGetPixelFormatAttribivARB(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5) +{ +//jboolean ret = (jboolean) wglGetPixelFormatAttribivARB((HDC) p0, (GLint) p1, (GLint) p2, (GLuint) p3, (const GLint *) p4, (GLint *) p5); +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: wglGetSwapIntervalEXT + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL_wglGetSwapIntervalEXT(JNIEnv * env, jclass clazz) +{ +//jint ret = (jint) wglGetSwapIntervalEXT(); +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: wglMakeContextCurrentARB + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL_wglMakeContextCurrentARB(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2) +{ +//jboolean ret = (jboolean) wglMakeContextCurrentARB((HDC) p0, (HDC) p1, (HGLRC) p2); +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: wglQueryPbufferARB + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL_wglQueryPbufferARB(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2) +{ +//jboolean ret = (jboolean) wglQueryPbufferARB((HPBUFFERARB) p0, (GLint) p1, (GLint *) p2); +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: wglReleasePbufferDCARB + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL_wglReleasePbufferDCARB(JNIEnv * env, jclass clazz, jint p0, jint p1) +{ +//jint ret = (jint) wglReleasePbufferDCARB((HPBUFFERARB) p0, (HDC) p1); +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: wglReleaseTexImageARB + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL_wglReleaseTexImageARB(JNIEnv * env, jclass clazz, jint p0, jint p1) +{ +//jboolean ret = (jboolean) wglReleaseTexImageARB((HPBUFFERARB) p0, (GLint) p1); +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: wglRestoreBufferRegionARB + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL_wglRestoreBufferRegionARB(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6) +{ +//jboolean ret = (jboolean) wglRestoreBufferRegionARB((void *) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6); +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: wglSaveBufferRegionARB + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL_wglSaveBufferRegionARB(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3, jint p4) +{ +//jboolean ret = (jboolean) wglSaveBufferRegionARB((void *) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4); +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: wglSetPbufferAttribARB + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL_wglSetPbufferAttribARB(JNIEnv * env, jclass clazz, jint p0, jint p1) +{ +//jboolean ret = (jboolean) wglSetPbufferAttribARB((HPBUFFERARB) p0, (const GLint *) p1); +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: wglSwapIntervalEXT + */ +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL_wglSwapIntervalEXT(JNIEnv * env, jclass clazz, jint p0) +{ +//jboolean ret = (jboolean) wglSwapIntervalEXT((GLint) p0); +//return ret; +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: windowPos2dARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_windowPos2dARB(JNIEnv * env, jobject obj, jdouble p0, jdouble p1) +{ +//glWindowPos2dARB((GLdouble) p0, (GLdouble) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: windowPos2dvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_windowPos2dvARB(JNIEnv * env, jobject obj, jint p0) +{ +//glWindowPos2dvARB((const GLdouble *) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: windowPos2fARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_windowPos2fARB(JNIEnv * env, jobject obj, jfloat p0, jfloat p1) +{ +//glWindowPos2fARB((GLfloat) p0, (GLfloat) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: windowPos2fvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_windowPos2fvARB(JNIEnv * env, jobject obj, jint p0) +{ +//glWindowPos2fvARB((const GLfloat *) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: windowPos2iARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_windowPos2iARB(JNIEnv * env, jobject obj, jint p0, jint p1) +{ +//glWindowPos2iARB((GLint) p0, (GLint) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: windowPos2ivARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_windowPos2ivARB(JNIEnv * env, jobject obj, jint p0) +{ +//glWindowPos2ivARB((const GLint *) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: windowPos2sARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_windowPos2sARB(JNIEnv * env, jobject obj, jshort p0, jshort p1) +{ +//glWindowPos2sARB((GLshort) p0, (GLshort) p1); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: windowPos2svARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_windowPos2svARB(JNIEnv * env, jobject obj, jint p0) +{ +//glWindowPos2svARB((const GLshort *) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: windowPos3dARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_windowPos3dARB(JNIEnv * env, jobject obj, jdouble p0, jdouble p1, jdouble p2) +{ +//glWindowPos3dARB((GLdouble) p0, (GLdouble) p1, (GLdouble) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: windowPos3dvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_windowPos3dvARB(JNIEnv * env, jobject obj, jint p0) +{ +//glWindowPos3dvARB((const GLdouble *) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: windowPos3fARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_windowPos3fARB(JNIEnv * env, jobject obj, jfloat p0, jfloat p1, jfloat p2) +{ +//glWindowPos3fARB((GLfloat) p0, (GLfloat) p1, (GLfloat) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: windowPos3fvARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_windowPos3fvARB(JNIEnv * env, jobject obj, jint p0) +{ +//glWindowPos3fvARB((const GLfloat *) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: windowPos3iARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_windowPos3iARB(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2) +{ +//glWindowPos3iARB((GLint) p0, (GLint) p1, (GLint) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: windowPos3ivARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_windowPos3ivARB(JNIEnv * env, jobject obj, jint p0) +{ +//glWindowPos3ivARB((const GLint *) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: windowPos3sARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_windowPos3sARB(JNIEnv * env, jobject obj, jshort p0, jshort p1, jshort p2) +{ +//glWindowPos3sARB((GLshort) p0, (GLshort) p1, (GLshort) p2); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: windowPos3svARB + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_windowPos3svARB(JNIEnv * env, jobject obj, jint p0) +{ +//glWindowPos3svARB((const GLshort *) p0); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: writeMaskEXT + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_writeMaskEXT(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5) +{ +//glWriteMaskEXT((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5); +//CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GL + * Method: checkWGLExtensionsString + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL_checkWGLExtensionsString(JNIEnv * env, jclass clazz) +{ + +//jfieldID fid_WGL_ARB_extensions_string = env->GetStaticFieldID(clazz, "WGL_ARB_extensions_string", "Z"); +//jfieldID fid_WGL_EXT_extensions_string = env->GetStaticFieldID(clazz, "WGL_EXT_extensions_string", "Z"); + +//if (wglGetExtensionsStringARB) +// env->SetStaticBooleanField(clazz, fid_WGL_ARB_extensions_string, JNI_TRUE); +//if (wglGetExtensionsStringEXT) +// env->SetStaticBooleanField(clazz, fid_WGL_EXT_extensions_string, JNI_TRUE); + +} + diff --git a/src/native/linux/org_lwjgl_opengl_GLU.c b/src/native/linux/org_lwjgl_opengl_GLU.c new file mode 100644 index 00000000..2c03352f --- /dev/null +++ b/src/native/linux/org_lwjgl_opengl_GLU.c @@ -0,0 +1,162 @@ +/* + * 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. + */ + +/** + * $Id$ + * + * GLU library. + * + * @author cix_foo + * @version $Revision$ + */ + +#include "org_lwjgl_opengl_GLU.h" +#include "checkGLerror.h" +#include + +/* + * Class: org_lwjgl_opengl_GLU + * Method: getString + */ +JNIEXPORT jstring JNICALL Java_org_lwjgl_opengl_GLU_getString(JNIEnv * env, jobject obj, jint p0) +{ + const char * msg = (const char *) gluGetString((GLint) p0); + jstring ret = (*env)->NewStringUTF(env, msg); + return ret; +} + +/* + * Class: org_lwjgl_opengl_GLU + * Method: errorString + */ +JNIEXPORT jstring JNICALL Java_org_lwjgl_opengl_GLU_errorString(JNIEnv * env, jobject obj, jint p0) +{ + const GLubyte * msg = gluErrorString((GLint) p0); + jstring ret = (*env)->NewStringUTF(env, (const char *) msg); + return ret; +} + +/* + * Class: org_lwjgl_opengl_GLU + * Method: ortho2D + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GLU_ortho2D(JNIEnv * env, jobject obj, jdouble p0, jdouble p1, jdouble p2, jdouble p3) +{ + gluOrtho2D((GLdouble) p0, (GLdouble) p1, (GLdouble) p2, (GLdouble) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GLU + * Method: perspective + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GLU_perspective(JNIEnv * env, jobject obj, jdouble p0, jdouble p1, jdouble p2, jdouble p3) +{ + gluPerspective((GLdouble) p0, (GLdouble) p1, (GLdouble) p2, (GLdouble) p3); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GLU + * Method: pickMatrix + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GLU_pickMatrix(JNIEnv * env, jobject obj, jdouble p0, jdouble p1, jdouble p2, jdouble p3, jint p4) +{ + gluPickMatrix((GLdouble) p0, (GLdouble) p1, (GLdouble) p2, (GLdouble) p3, (GLint *) p4); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GLU + * Method: lookAt + */ +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GLU_lookAt(JNIEnv * env, jobject obj, jdouble p0, jdouble p1, jdouble p2, jdouble p3, jdouble p4, jdouble p5, jdouble p6, jdouble p7, jdouble p8) +{ + gluLookAt((GLdouble) p0, (GLdouble) p1, (GLdouble) p2, (GLdouble) p3, (GLdouble) p4, (GLdouble) p5, (GLdouble) p6, (GLdouble) p7, (GLdouble) p8); + CHECK_GL_ERROR +} + +/* + * Class: org_lwjgl_opengl_GLU + * Method: project + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GLU_project(JNIEnv * env, jobject obj, jdouble p0, jdouble p1, jdouble p2, jint p3, jint p4, jint p5, jint p6, jint p7, jint p8) +{ + jint ret = (jint) gluProject((GLdouble) p0, (GLdouble) p1, (GLdouble) p2, (const GLdouble *) p3, (const GLdouble *) p4, (const GLint *) p5, (GLdouble *) p6, (GLdouble *) p7, (GLdouble *) p8); + CHECK_GL_ERROR + return ret; +} + +/* + * Class: org_lwjgl_opengl_GLU + * Method: unProject + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GLU_unProject(JNIEnv * env, jobject obj, jdouble p0, jdouble p1, jdouble p2, jint p3, jint p4, jint p5, jint p6, jint p7, jint p8) +{ + jint ret = (jint) gluUnProject((GLdouble) p0, (GLdouble) p1, (GLdouble) p2, (const GLdouble *) p3, (const GLdouble *) p4, (const GLint *) p5, (GLdouble *) p6, (GLdouble *) p7, (GLdouble *) p8); + CHECK_GL_ERROR + return ret; +} + +/* + * Class: org_lwjgl_opengl_GLU + * Method: scaleImage + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GLU_scaleImage(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6, jint p7, jint p8) +{ + jint ret = (jint) gluScaleImage((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (const void *) p4, (GLint) p5, (GLint) p6, (GLint) p7, (void *) p8); + CHECK_GL_ERROR + return ret; +} + +/* + * Class: org_lwjgl_opengl_GLU + * Method: build1DMipmaps + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GLU_build1DMipmaps(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5) +{ + jint ret = (jint) gluBuild1DMipmaps((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (const void *) p5); + CHECK_GL_ERROR + return ret; +} + +/* + * Class: org_lwjgl_opengl_GLU + * Method: build2DMipmaps + */ +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GLU_build2DMipmaps(JNIEnv * env, jobject obj, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6) +{ + jint ret = (jint) gluBuild2DMipmaps((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (const void *) p6); + CHECK_GL_ERROR + return ret; +} +