shadowfacts/lwjgl2-arm64
1
0
Fork 0
mirror of https://github.com/shadowfacts/lwjgl2-arm64.git synced 2026-04-21 06:14:10 +00:00
Code Issues Projects Releases Packages Wiki Activity

Removed generated files from version control - all platforms have support for the java 1.5 apt tool

Browse source
This commit is contained in:
Elias Naur 2007-04-03 10:06:12 +00:00
parent fe196168ea
commit 81564102c3
238 changed files with 2 additions and 28467 deletions
Download patch file Download diff file Expand all files Collapse all files

408
src/native/generated/org_lwjgl_openal_AL10.c
View file

@ -1,408 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extal.h"
typedef ALvoid (ALAPIENTRY *alEnablePROC) (ALint capability);
typedef ALvoid (ALAPIENTRY *alDisablePROC) (ALenum capability);
typedef ALboolean (ALAPIENTRY *alIsEnabledPROC) (ALenum capability);
typedef ALboolean (ALAPIENTRY *alGetBooleanPROC) (ALenum pname);
typedef ALint (ALAPIENTRY *alGetIntegerPROC) (ALenum pname);
typedef ALfloat (ALAPIENTRY *alGetFloatPROC) (ALenum pname);
typedef ALdouble (ALAPIENTRY *alGetDoublePROC) (ALenum pname);
typedef ALvoid (ALAPIENTRY *alGetIntegervPROC) (ALenum pname, ALint * data);
typedef ALvoid (ALAPIENTRY *alGetFloatvPROC) (ALenum pname, ALfloat * data);
typedef ALvoid (ALAPIENTRY *alGetDoublevPROC) (ALenum pname, ALdouble * data);
typedef ALubyte * (ALAPIENTRY *alGetStringPROC) (ALenum pname);
typedef ALenum (ALAPIENTRY *alGetErrorPROC) ();
typedef ALboolean (ALAPIENTRY *alIsExtensionPresentPROC) (ALubyte * fname);
typedef ALenum (ALAPIENTRY *alGetEnumValuePROC) (ALubyte * ename);
typedef ALvoid (ALAPIENTRY *alListeneriPROC) (ALenum pname, ALint value);
typedef ALvoid (ALAPIENTRY *alListenerfPROC) (ALenum pname, ALfloat value);
typedef ALvoid (ALAPIENTRY *alListenerfvPROC) (ALenum pname, const ALfloat * value);
typedef ALvoid (ALAPIENTRY *alListener3fPROC) (ALenum pname, ALfloat v1, ALfloat v2, ALfloat v3);
typedef void (ALAPIENTRY *alGetListeneriPROC) (ALenum pname, ALint* value);
typedef void (ALAPIENTRY *alGetListenerfPROC) (ALenum pname, ALfloat* value);
typedef ALvoid (ALAPIENTRY *alGetListenerfvPROC) (ALenum pname, ALfloat * floatdata);
typedef ALvoid (ALAPIENTRY *alGenSourcesPROC) (ALsizei n, ALuint * sources);
typedef ALvoid (ALAPIENTRY *alDeleteSourcesPROC) (ALsizei n, ALuint * sources);
typedef ALboolean (ALAPIENTRY *alIsSourcePROC) (ALuint id);
typedef ALvoid (ALAPIENTRY *alSourceiPROC) (ALuint source, ALenum pname, ALint value);
typedef ALvoid (ALAPIENTRY *alSourcefPROC) (ALuint source, ALenum pname, ALfloat value);
typedef ALvoid (ALAPIENTRY *alSourcefvPROC) (ALuint source, ALenum pname, const ALfloat * value);
typedef ALvoid (ALAPIENTRY *alSource3fPROC) (ALuint source, ALenum pname, ALfloat v1, ALfloat v2, ALfloat v3);
typedef ALvoid (ALAPIENTRY *alGetSourceiPROC) (ALuint source, ALenum pname, ALint* value);
typedef ALvoid (ALAPIENTRY *alGetSourcefPROC) (ALuint source, ALenum pname, ALfloat* value);
typedef ALvoid (ALAPIENTRY *alGetSourcefvPROC) (ALuint source, ALenum pname, ALfloat * floatdata);
typedef ALvoid (ALAPIENTRY *alSourcePlayvPROC) (ALsizei n, ALuint * sources);
typedef ALvoid (ALAPIENTRY *alSourcePausevPROC) (ALsizei n, ALuint * sources);
typedef ALvoid (ALAPIENTRY *alSourceStopvPROC) (ALsizei n, ALuint * sources);
typedef ALvoid (ALAPIENTRY *alSourceRewindvPROC) (ALsizei n, ALuint * sources);
typedef ALvoid (ALAPIENTRY *alSourcePlayPROC) (ALuint source);
typedef ALvoid (ALAPIENTRY *alSourcePausePROC) (ALuint source);
typedef ALvoid (ALAPIENTRY *alSourceStopPROC) (ALuint source);
typedef ALvoid (ALAPIENTRY *alSourceRewindPROC) (ALuint source);
typedef ALvoid (ALAPIENTRY *alGenBuffersPROC) (ALsizei n, ALuint * buffers);
typedef ALvoid (ALAPIENTRY *alDeleteBuffersPROC) (ALsizei n, ALuint * buffers);
typedef ALboolean (ALAPIENTRY *alIsBufferPROC) (ALuint buffer);
typedef ALvoid (ALAPIENTRY *alBufferDataPROC) (ALuint buffer, ALenum format, ALvoid * data, ALsizei size, ALsizei freq);
typedef ALvoid (ALAPIENTRY *alGetBufferiPROC) (ALuint buffer, ALenum pname, ALint* value);
typedef ALvoid (ALAPIENTRY *alGetBufferfPROC) (ALuint buffer, ALenum pname, ALfloat* value);
typedef ALvoid (ALAPIENTRY *alSourceQueueBuffersPROC) (ALuint source, ALsizei n, ALuint * buffers);
typedef ALvoid (ALAPIENTRY *alSourceUnqueueBuffersPROC) (ALuint source, ALsizei n, ALuint * buffers);
typedef ALvoid (ALAPIENTRY *alDistanceModelPROC) (ALenum value);
typedef ALvoid (ALAPIENTRY *alDopplerFactorPROC) (ALfloat value);
typedef ALvoid (ALAPIENTRY *alDopplerVelocityPROC) (ALfloat value);
static alEnablePROC alEnable;
static alDisablePROC alDisable;
static alIsEnabledPROC alIsEnabled;
static alGetBooleanPROC alGetBoolean;
static alGetIntegerPROC alGetInteger;
static alGetFloatPROC alGetFloat;
static alGetDoublePROC alGetDouble;
static alGetIntegervPROC alGetIntegerv;
static alGetFloatvPROC alGetFloatv;
static alGetDoublevPROC alGetDoublev;
static alGetStringPROC alGetString;
static alGetErrorPROC alGetError;
static alIsExtensionPresentPROC alIsExtensionPresent;
static alGetEnumValuePROC alGetEnumValue;
static alListeneriPROC alListeneri;
static alListenerfPROC alListenerf;
static alListenerfvPROC alListenerfv;
static alListener3fPROC alListener3f;
static alGetListeneriPROC alGetListeneri;
static alGetListenerfPROC alGetListenerf;
static alGetListenerfvPROC alGetListenerfv;
static alGenSourcesPROC alGenSources;
static alDeleteSourcesPROC alDeleteSources;
static alIsSourcePROC alIsSource;
static alSourceiPROC alSourcei;
static alSourcefPROC alSourcef;
static alSourcefvPROC alSourcefv;
static alSource3fPROC alSource3f;
static alGetSourceiPROC alGetSourcei;
static alGetSourcefPROC alGetSourcef;
static alGetSourcefvPROC alGetSourcefv;
static alSourcePlayvPROC alSourcePlayv;
static alSourcePausevPROC alSourcePausev;
static alSourceStopvPROC alSourceStopv;
static alSourceRewindvPROC alSourceRewindv;
static alSourcePlayPROC alSourcePlay;
static alSourcePausePROC alSourcePause;
static alSourceStopPROC alSourceStop;
static alSourceRewindPROC alSourceRewind;
static alGenBuffersPROC alGenBuffers;
static alDeleteBuffersPROC alDeleteBuffers;
static alIsBufferPROC alIsBuffer;
static alBufferDataPROC alBufferData;
static alGetBufferiPROC alGetBufferi;
static alGetBufferfPROC alGetBufferf;
static alSourceQueueBuffersPROC alSourceQueueBuffers;
static alSourceUnqueueBuffersPROC alSourceUnqueueBuffers;
static alDistanceModelPROC alDistanceModel;
static alDopplerFactorPROC alDopplerFactor;
static alDopplerVelocityPROC alDopplerVelocity;
static void JNICALL Java_org_lwjgl_openal_AL10_nalEnable(JNIEnv *env, jclass clazz, jint capability) {
alEnable(capability);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalDisable(JNIEnv *env, jclass clazz, jint capability) {
alDisable(capability);
}
static jboolean JNICALL Java_org_lwjgl_openal_AL10_nalIsEnabled(JNIEnv *env, jclass clazz, jint capability) {
ALboolean __result = alIsEnabled(capability);
return __result;
}
static jboolean JNICALL Java_org_lwjgl_openal_AL10_nalGetBoolean(JNIEnv *env, jclass clazz, jint pname) {
ALboolean __result = alGetBoolean(pname);
return __result;
}
static jint JNICALL Java_org_lwjgl_openal_AL10_nalGetInteger(JNIEnv *env, jclass clazz, jint pname) {
ALint __result = alGetInteger(pname);
return __result;
}
static jfloat JNICALL Java_org_lwjgl_openal_AL10_nalGetFloat(JNIEnv *env, jclass clazz, jint pname) {
ALfloat __result = alGetFloat(pname);
return __result;
}
static jdouble JNICALL Java_org_lwjgl_openal_AL10_nalGetDouble(JNIEnv *env, jclass clazz, jint pname) {
ALdouble __result = alGetDouble(pname);
return __result;
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalGetIntegerv(JNIEnv *env, jclass clazz, jint pname, jobject data, jint data_position) {
ALint *data_address = ((ALint *)(*env)->GetDirectBufferAddress(env, data)) + data_position;
alGetIntegerv(pname, data_address);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalGetFloatv(JNIEnv *env, jclass clazz, jint pname, jobject data, jint data_position) {
ALfloat *data_address = ((ALfloat *)(*env)->GetDirectBufferAddress(env, data)) + data_position;
alGetFloatv(pname, data_address);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalGetDoublev(JNIEnv *env, jclass clazz, jint pname, jobject data, jint data_position) {
ALdouble *data_address = ((ALdouble *)(*env)->GetDirectBufferAddress(env, data)) + data_position;
alGetDoublev(pname, data_address);
}
static jobject JNICALL Java_org_lwjgl_openal_AL10_alGetString(JNIEnv *env, jclass clazz, jint pname) {
ALubyte * __result = alGetString(pname);
return NewStringNativeUnsigned(env, __result);
}
static jint JNICALL Java_org_lwjgl_openal_AL10_alGetError(JNIEnv *env, jclass clazz) {
ALenum __result = alGetError();
return __result;
}
static jboolean JNICALL Java_org_lwjgl_openal_AL10_nalIsExtensionPresent(JNIEnv *env, jclass clazz, jobject fname) {
ALubyte *fname_address = ((ALubyte *)GetStringNativeChars(env, fname));
ALboolean __result = alIsExtensionPresent(fname_address);
free(fname_address);
return __result;
}
static jint JNICALL Java_org_lwjgl_openal_AL10_nalGetEnumValue(JNIEnv *env, jclass clazz, jobject ename) {
ALubyte *ename_address = ((ALubyte *)GetStringNativeChars(env, ename));
ALenum __result = alGetEnumValue(ename_address);
free(ename_address);
return __result;
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalListeneri(JNIEnv *env, jclass clazz, jint pname, jint value) {
alListeneri(pname, value);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalListenerf(JNIEnv *env, jclass clazz, jint pname, jfloat value) {
alListenerf(pname, value);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalListenerfv(JNIEnv *env, jclass clazz, jint pname, jobject value, jint value_position) {
const ALfloat *value_address = ((const ALfloat *)(*env)->GetDirectBufferAddress(env, value)) + value_position;
alListenerfv(pname, value_address);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalListener3f(JNIEnv *env, jclass clazz, jint pname, jfloat v1, jfloat v2, jfloat v3) {
alListener3f(pname, v1, v2, v3);
}
static jint JNICALL Java_org_lwjgl_openal_AL10_nalGetListeneri(JNIEnv *env, jclass clazz, jint pname) {
ALint __result;
alGetListeneri(pname, &__result);
return __result;
}
static jfloat JNICALL Java_org_lwjgl_openal_AL10_nalGetListenerf(JNIEnv *env, jclass clazz, jint pname) {
ALfloat __result;
alGetListenerf(pname, &__result);
return __result;
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalGetListenerfv(JNIEnv *env, jclass clazz, jint pname, jobject floatdata, jint floatdata_position) {
ALfloat *floatdata_address = ((ALfloat *)(*env)->GetDirectBufferAddress(env, floatdata)) + floatdata_position;
alGetListenerfv(pname, floatdata_address);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalGenSources(JNIEnv *env, jclass clazz, jint n, jobject sources, jint sources_position) {
ALuint *sources_address = ((ALuint *)(*env)->GetDirectBufferAddress(env, sources)) + sources_position;
alGenSources(n, sources_address);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalDeleteSources(JNIEnv *env, jclass clazz, jint n, jobject sources, jint sources_position) {
ALuint *sources_address = ((ALuint *)(*env)->GetDirectBufferAddress(env, sources)) + sources_position;
alDeleteSources(n, sources_address);
}
static jboolean JNICALL Java_org_lwjgl_openal_AL10_nalIsSource(JNIEnv *env, jclass clazz, jint id) {
ALboolean __result = alIsSource(id);
return __result;
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalSourcei(JNIEnv *env, jclass clazz, jint source, jint pname, jint value) {
alSourcei(source, pname, value);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalSourcef(JNIEnv *env, jclass clazz, jint source, jint pname, jfloat value) {
alSourcef(source, pname, value);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalSourcefv(JNIEnv *env, jclass clazz, jint source, jint pname, jobject value, jint value_position) {
const ALfloat *value_address = ((const ALfloat *)(*env)->GetDirectBufferAddress(env, value)) + value_position;
alSourcefv(source, pname, value_address);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalSource3f(JNIEnv *env, jclass clazz, jint source, jint pname, jfloat v1, jfloat v2, jfloat v3) {
alSource3f(source, pname, v1, v2, v3);
}
static jint JNICALL Java_org_lwjgl_openal_AL10_nalGetSourcei(JNIEnv *env, jclass clazz, jint source, jint pname) {
ALint __result;
alGetSourcei(source, pname, &__result);
return __result;
}
static jfloat JNICALL Java_org_lwjgl_openal_AL10_nalGetSourcef(JNIEnv *env, jclass clazz, jint source, jint pname) {
ALfloat __result;
alGetSourcef(source, pname, &__result);
return __result;
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalGetSourcefv(JNIEnv *env, jclass clazz, jint source, jint pname, jobject floatdata, jint floatdata_position) {
ALfloat *floatdata_address = ((ALfloat *)(*env)->GetDirectBufferAddress(env, floatdata)) + floatdata_position;
alGetSourcefv(source, pname, floatdata_address);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalSourcePlayv(JNIEnv *env, jclass clazz, jint n, jobject sources, jint sources_position) {
ALuint *sources_address = ((ALuint *)(*env)->GetDirectBufferAddress(env, sources)) + sources_position;
alSourcePlayv(n, sources_address);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalSourcePausev(JNIEnv *env, jclass clazz, jint n, jobject sources, jint sources_position) {
ALuint *sources_address = ((ALuint *)(*env)->GetDirectBufferAddress(env, sources)) + sources_position;
alSourcePausev(n, sources_address);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalSourceStopv(JNIEnv *env, jclass clazz, jint n, jobject sources, jint sources_position) {
ALuint *sources_address = ((ALuint *)(*env)->GetDirectBufferAddress(env, sources)) + sources_position;
alSourceStopv(n, sources_address);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalSourceRewindv(JNIEnv *env, jclass clazz, jint n, jobject sources, jint sources_position) {
ALuint *sources_address = ((ALuint *)(*env)->GetDirectBufferAddress(env, sources)) + sources_position;
alSourceRewindv(n, sources_address);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalSourcePlay(JNIEnv *env, jclass clazz, jint source) {
alSourcePlay(source);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalSourcePause(JNIEnv *env, jclass clazz, jint source) {
alSourcePause(source);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalSourceStop(JNIEnv *env, jclass clazz, jint source) {
alSourceStop(source);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalSourceRewind(JNIEnv *env, jclass clazz, jint source) {
alSourceRewind(source);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalGenBuffers(JNIEnv *env, jclass clazz, jint n, jobject buffers, jint buffers_position) {
ALuint *buffers_address = ((ALuint *)(*env)->GetDirectBufferAddress(env, buffers)) + buffers_position;
alGenBuffers(n, buffers_address);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalDeleteBuffers(JNIEnv *env, jclass clazz, jint n, jobject buffers, jint buffers_position) {
ALuint *buffers_address = ((ALuint *)(*env)->GetDirectBufferAddress(env, buffers)) + buffers_position;
alDeleteBuffers(n, buffers_address);
}
static jboolean JNICALL Java_org_lwjgl_openal_AL10_nalIsBuffer(JNIEnv *env, jclass clazz, jint buffer) {
ALboolean __result = alIsBuffer(buffer);
return __result;
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalBufferData(JNIEnv *env, jclass clazz, jint buffer, jint format, jobject data, jint data_position, jint size, jint freq) {
ALvoid *data_address = ((ALvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
alBufferData(buffer, format, data_address, size, freq);
}
static jint JNICALL Java_org_lwjgl_openal_AL10_nalGetBufferi(JNIEnv *env, jclass clazz, jint buffer, jint pname) {
ALint __result;
alGetBufferi(buffer, pname, &__result);
return __result;
}
static jfloat JNICALL Java_org_lwjgl_openal_AL10_nalGetBufferf(JNIEnv *env, jclass clazz, jint buffer, jint pname) {
ALfloat __result;
alGetBufferf(buffer, pname, &__result);
return __result;
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalSourceQueueBuffers(JNIEnv *env, jclass clazz, jint source, jint n, jobject buffers, jint buffers_position) {
ALuint *buffers_address = ((ALuint *)(*env)->GetDirectBufferAddress(env, buffers)) + buffers_position;
alSourceQueueBuffers(source, n, buffers_address);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalSourceUnqueueBuffers(JNIEnv *env, jclass clazz, jint source, jint n, jobject buffers, jint buffers_position) {
ALuint *buffers_address = ((ALuint *)(*env)->GetDirectBufferAddress(env, buffers)) + buffers_position;
alSourceUnqueueBuffers(source, n, buffers_address);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalDistanceModel(JNIEnv *env, jclass clazz, jint value) {
alDistanceModel(value);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalDopplerFactor(JNIEnv *env, jclass clazz, jfloat value) {
alDopplerFactor(value);
}
static void JNICALL Java_org_lwjgl_openal_AL10_nalDopplerVelocity(JNIEnv *env, jclass clazz, jfloat value) {
alDopplerVelocity(value);
}
JNIEXPORT void JNICALL Java_org_lwjgl_openal_AL10_initNativeStubs(JNIEnv *env, jclass clazz) {
JavaMethodAndExtFunction functions[] = {
{"nalEnable", "(I)V", (void *)&Java_org_lwjgl_openal_AL10_nalEnable, "alEnable", (void *)&alEnable},
{"nalDisable", "(I)V", (void *)&Java_org_lwjgl_openal_AL10_nalDisable, "alDisable", (void *)&alDisable},
{"nalIsEnabled", "(I)Z", (void *)&Java_org_lwjgl_openal_AL10_nalIsEnabled, "alIsEnabled", (void *)&alIsEnabled},
{"nalGetBoolean", "(I)Z", (void *)&Java_org_lwjgl_openal_AL10_nalGetBoolean, "alGetBoolean", (void *)&alGetBoolean},
{"nalGetInteger", "(I)I", (void *)&Java_org_lwjgl_openal_AL10_nalGetInteger, "alGetInteger", (void *)&alGetInteger},
{"nalGetFloat", "(I)F", (void *)&Java_org_lwjgl_openal_AL10_nalGetFloat, "alGetFloat", (void *)&alGetFloat},
{"nalGetDouble", "(I)D", (void *)&Java_org_lwjgl_openal_AL10_nalGetDouble, "alGetDouble", (void *)&alGetDouble},
{"nalGetIntegerv", "(ILjava/nio/IntBuffer;I)V", (void *)&Java_org_lwjgl_openal_AL10_nalGetIntegerv, "alGetIntegerv", (void *)&alGetIntegerv},
{"nalGetFloatv", "(ILjava/nio/FloatBuffer;I)V", (void *)&Java_org_lwjgl_openal_AL10_nalGetFloatv, "alGetFloatv", (void *)&alGetFloatv},
{"nalGetDoublev", "(ILjava/nio/DoubleBuffer;I)V", (void *)&Java_org_lwjgl_openal_AL10_nalGetDoublev, "alGetDoublev", (void *)&alGetDoublev},
{"alGetString", "(I)Ljava/lang/String;", (void *)&Java_org_lwjgl_openal_AL10_alGetString, "alGetString", (void *)&alGetString},
{"alGetError", "()I", (void *)&Java_org_lwjgl_openal_AL10_alGetError, "alGetError", (void *)&alGetError},
{"nalIsExtensionPresent", "(Ljava/lang/String;)Z", (void *)&Java_org_lwjgl_openal_AL10_nalIsExtensionPresent, "alIsExtensionPresent", (void *)&alIsExtensionPresent},
{"nalGetEnumValue", "(Ljava/lang/String;)I", (void *)&Java_org_lwjgl_openal_AL10_nalGetEnumValue, "alGetEnumValue", (void *)&alGetEnumValue},
{"nalListeneri", "(II)V", (void *)&Java_org_lwjgl_openal_AL10_nalListeneri, "alListeneri", (void *)&alListeneri},
{"nalListenerf", "(IF)V", (void *)&Java_org_lwjgl_openal_AL10_nalListenerf, "alListenerf", (void *)&alListenerf},
{"nalListenerfv", "(ILjava/nio/FloatBuffer;I)V", (void *)&Java_org_lwjgl_openal_AL10_nalListenerfv, "alListenerfv", (void *)&alListenerfv},
{"nalListener3f", "(IFFF)V", (void *)&Java_org_lwjgl_openal_AL10_nalListener3f, "alListener3f", (void *)&alListener3f},
{"nalGetListeneri", "(I)I", (void *)&Java_org_lwjgl_openal_AL10_nalGetListeneri, "alGetListeneri", (void *)&alGetListeneri},
{"nalGetListenerf", "(I)F", (void *)&Java_org_lwjgl_openal_AL10_nalGetListenerf, "alGetListenerf", (void *)&alGetListenerf},
{"nalGetListenerfv", "(ILjava/nio/FloatBuffer;I)V", (void *)&Java_org_lwjgl_openal_AL10_nalGetListenerfv, "alGetListenerfv", (void *)&alGetListenerfv},
{"nalGenSources", "(ILjava/nio/IntBuffer;I)V", (void *)&Java_org_lwjgl_openal_AL10_nalGenSources, "alGenSources", (void *)&alGenSources},
{"nalDeleteSources", "(ILjava/nio/IntBuffer;I)V", (void *)&Java_org_lwjgl_openal_AL10_nalDeleteSources, "alDeleteSources", (void *)&alDeleteSources},
{"nalIsSource", "(I)Z", (void *)&Java_org_lwjgl_openal_AL10_nalIsSource, "alIsSource", (void *)&alIsSource},
{"nalSourcei", "(III)V", (void *)&Java_org_lwjgl_openal_AL10_nalSourcei, "alSourcei", (void *)&alSourcei},
{"nalSourcef", "(IIF)V", (void *)&Java_org_lwjgl_openal_AL10_nalSourcef, "alSourcef", (void *)&alSourcef},
{"nalSourcefv", "(IILjava/nio/FloatBuffer;I)V", (void *)&Java_org_lwjgl_openal_AL10_nalSourcefv, "alSourcefv", (void *)&alSourcefv},
{"nalSource3f", "(IIFFF)V", (void *)&Java_org_lwjgl_openal_AL10_nalSource3f, "alSource3f", (void *)&alSource3f},
{"nalGetSourcei", "(II)I", (void *)&Java_org_lwjgl_openal_AL10_nalGetSourcei, "alGetSourcei", (void *)&alGetSourcei},
{"nalGetSourcef", "(II)F", (void *)&Java_org_lwjgl_openal_AL10_nalGetSourcef, "alGetSourcef", (void *)&alGetSourcef},
{"nalGetSourcefv", "(IILjava/nio/FloatBuffer;I)V", (void *)&Java_org_lwjgl_openal_AL10_nalGetSourcefv, "alGetSourcefv", (void *)&alGetSourcefv},
{"nalSourcePlayv", "(ILjava/nio/IntBuffer;I)V", (void *)&Java_org_lwjgl_openal_AL10_nalSourcePlayv, "alSourcePlayv", (void *)&alSourcePlayv},
{"nalSourcePausev", "(ILjava/nio/IntBuffer;I)V", (void *)&Java_org_lwjgl_openal_AL10_nalSourcePausev, "alSourcePausev", (void *)&alSourcePausev},
{"nalSourceStopv", "(ILjava/nio/IntBuffer;I)V", (void *)&Java_org_lwjgl_openal_AL10_nalSourceStopv, "alSourceStopv", (void *)&alSourceStopv},
{"nalSourceRewindv", "(ILjava/nio/IntBuffer;I)V", (void *)&Java_org_lwjgl_openal_AL10_nalSourceRewindv, "alSourceRewindv", (void *)&alSourceRewindv},
{"nalSourcePlay", "(I)V", (void *)&Java_org_lwjgl_openal_AL10_nalSourcePlay, "alSourcePlay", (void *)&alSourcePlay},
{"nalSourcePause", "(I)V", (void *)&Java_org_lwjgl_openal_AL10_nalSourcePause, "alSourcePause", (void *)&alSourcePause},
{"nalSourceStop", "(I)V", (void *)&Java_org_lwjgl_openal_AL10_nalSourceStop, "alSourceStop", (void *)&alSourceStop},
{"nalSourceRewind", "(I)V", (void *)&Java_org_lwjgl_openal_AL10_nalSourceRewind, "alSourceRewind", (void *)&alSourceRewind},
{"nalGenBuffers", "(ILjava/nio/IntBuffer;I)V", (void *)&Java_org_lwjgl_openal_AL10_nalGenBuffers, "alGenBuffers", (void *)&alGenBuffers},
{"nalDeleteBuffers", "(ILjava/nio/IntBuffer;I)V", (void *)&Java_org_lwjgl_openal_AL10_nalDeleteBuffers, "alDeleteBuffers", (void *)&alDeleteBuffers},
{"nalIsBuffer", "(I)Z", (void *)&Java_org_lwjgl_openal_AL10_nalIsBuffer, "alIsBuffer", (void *)&alIsBuffer},
{"nalBufferData", "(IILjava/nio/Buffer;III)V", (void *)&Java_org_lwjgl_openal_AL10_nalBufferData, "alBufferData", (void *)&alBufferData},
{"nalGetBufferi", "(II)I", (void *)&Java_org_lwjgl_openal_AL10_nalGetBufferi, "alGetBufferi", (void *)&alGetBufferi},
{"nalGetBufferf", "(II)F", (void *)&Java_org_lwjgl_openal_AL10_nalGetBufferf, "alGetBufferf", (void *)&alGetBufferf},
{"nalSourceQueueBuffers", "(IILjava/nio/IntBuffer;I)V", (void *)&Java_org_lwjgl_openal_AL10_nalSourceQueueBuffers, "alSourceQueueBuffers", (void *)&alSourceQueueBuffers},
{"nalSourceUnqueueBuffers", "(IILjava/nio/IntBuffer;I)V", (void *)&Java_org_lwjgl_openal_AL10_nalSourceUnqueueBuffers, "alSourceUnqueueBuffers", (void *)&alSourceUnqueueBuffers},
{"nalDistanceModel", "(I)V", (void *)&Java_org_lwjgl_openal_AL10_nalDistanceModel, "alDistanceModel", (void *)&alDistanceModel},
{"nalDopplerFactor", "(F)V", (void *)&Java_org_lwjgl_openal_AL10_nalDopplerFactor, "alDopplerFactor", (void *)&alDopplerFactor},
{"nalDopplerVelocity", "(F)V", (void *)&Java_org_lwjgl_openal_AL10_nalDopplerVelocity, "alDopplerVelocity", (void *)&alDopplerVelocity}
};
int num_functions = NUMFUNCTIONS(functions);
extal_InitializeClass(env, clazz, num_functions, functions);
}

83
src/native/generated/org_lwjgl_opengl_ARBBufferObject.c
View file

@ -1,83 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glBindBufferARBPROC) (GLenum target, GLuint buffer);
typedef void (APIENTRY *glDeleteBuffersARBPROC) (GLsizei n, const GLuint * buffers);
typedef void (APIENTRY *glGenBuffersARBPROC) (GLint n, GLuint * buffers);
typedef GLboolean (APIENTRY *glIsBufferARBPROC) (GLuint buffer);
typedef void (APIENTRY *glBufferDataARBPROC) (GLenum target, GLsizeiptrARB size, const GLvoid * data, GLenum usage);
typedef void (APIENTRY *glBufferSubDataARBPROC) (GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid * data);
typedef void (APIENTRY *glGetBufferSubDataARBPROC) (GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid * data);
typedef GLvoid * (APIENTRY *glMapBufferARBPROC) (GLenum target, GLenum access);
typedef GLboolean (APIENTRY *glUnmapBufferARBPROC) (GLenum target);
typedef void (APIENTRY *glGetBufferParameterivARBPROC) (GLenum target, GLenum pname, GLint * params);
typedef void (APIENTRY *glGetBufferPointervARBPROC) (GLenum target, GLenum pname, GLvoid ** pointer);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBBufferObject_nglBindBufferARB(JNIEnv *env, jclass clazz, jint target, jint buffer, jlong function_pointer) {
glBindBufferARBPROC glBindBufferARB = (glBindBufferARBPROC)((intptr_t)function_pointer);
glBindBufferARB(target, buffer);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBBufferObject_nglDeleteBuffersARB(JNIEnv *env, jclass clazz, jint n, jobject buffers, jint buffers_position, jlong function_pointer) {
const GLuint *buffers_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, buffers)) + buffers_position;
glDeleteBuffersARBPROC glDeleteBuffersARB = (glDeleteBuffersARBPROC)((intptr_t)function_pointer);
glDeleteBuffersARB(n, buffers_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBBufferObject_nglGenBuffersARB(JNIEnv *env, jclass clazz, jint n, jobject buffers, jint buffers_position, jlong function_pointer) {
GLuint *buffers_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, buffers)) + buffers_position;
glGenBuffersARBPROC glGenBuffersARB = (glGenBuffersARBPROC)((intptr_t)function_pointer);
glGenBuffersARB(n, buffers_address);
}
JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_ARBBufferObject_nglIsBufferARB(JNIEnv *env, jclass clazz, jint buffer, jlong function_pointer) {
glIsBufferARBPROC glIsBufferARB = (glIsBufferARBPROC)((intptr_t)function_pointer);
GLboolean __result = glIsBufferARB(buffer);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBBufferObject_nglBufferDataARB(JNIEnv *env, jclass clazz, jint target, jlong size, jobject data, jint data_position, jint usage, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)(((char *)safeGetBufferAddress(env, data)) + data_position));
glBufferDataARBPROC glBufferDataARB = (glBufferDataARBPROC)((intptr_t)function_pointer);
glBufferDataARB(target, size, data_address, usage);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBBufferObject_nglBufferSubDataARB(JNIEnv *env, jclass clazz, jint target, jlong offset, jlong size, jobject data, jint data_position, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
glBufferSubDataARBPROC glBufferSubDataARB = (glBufferSubDataARBPROC)((intptr_t)function_pointer);
glBufferSubDataARB(target, offset, size, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBBufferObject_nglGetBufferSubDataARB(JNIEnv *env, jclass clazz, jint target, jlong offset, jlong size, jobject data, jint data_position, jlong function_pointer) {
GLvoid *data_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
glGetBufferSubDataARBPROC glGetBufferSubDataARB = (glGetBufferSubDataARBPROC)((intptr_t)function_pointer);
glGetBufferSubDataARB(target, offset, size, data_address);
}
JNIEXPORT jobject JNICALL Java_org_lwjgl_opengl_ARBBufferObject_nglMapBufferARB(JNIEnv *env, jclass clazz, jint target, jint access, jlong result_size, jobject old_buffer, jlong function_pointer) {
glMapBufferARBPROC glMapBufferARB = (glMapBufferARBPROC)((intptr_t)function_pointer);
GLvoid * __result = glMapBufferARB(target, access);
return safeNewBufferCached(env, __result, result_size, old_buffer);
}
JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_ARBBufferObject_nglUnmapBufferARB(JNIEnv *env, jclass clazz, jint target, jlong function_pointer) {
glUnmapBufferARBPROC glUnmapBufferARB = (glUnmapBufferARBPROC)((intptr_t)function_pointer);
GLboolean __result = glUnmapBufferARB(target);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBBufferObject_nglGetBufferParameterivARB(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetBufferParameterivARBPROC glGetBufferParameterivARB = (glGetBufferParameterivARBPROC)((intptr_t)function_pointer);
glGetBufferParameterivARB(target, pname, params_address);
}
JNIEXPORT jobject JNICALL Java_org_lwjgl_opengl_ARBBufferObject_nglGetBufferPointervARB(JNIEnv *env, jclass clazz, jint target, jint pname, jlong result_size, jlong function_pointer) {
glGetBufferPointervARBPROC glGetBufferPointervARB = (glGetBufferPointervARBPROC)((intptr_t)function_pointer);
GLvoid * __result;
glGetBufferPointervARB(target, pname, &__result);
return safeNewBuffer(env, __result, result_size);
}

12
src/native/generated/org_lwjgl_opengl_ARBColorBufferFloat.c
View file

@ -1,12 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glClampColorARBPROC) (GLenum target, GLenum clamp);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBColorBufferFloat_nglClampColorARB(JNIEnv *env, jclass clazz, jint target, jint clamp, jlong function_pointer) {
glClampColorARBPROC glClampColorARB = (glClampColorARBPROC)((intptr_t)function_pointer);
glClampColorARB(target, clamp);
}

13
src/native/generated/org_lwjgl_opengl_ARBDrawBuffers.c
View file

@ -1,13 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glDrawBuffersARBPROC) (GLsizei size, const GLenum * buffers);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBDrawBuffers_nglDrawBuffersARB(JNIEnv *env, jclass clazz, jint size, jobject buffers, jint buffers_position, jlong function_pointer) {
const GLenum *buffers_address = ((const GLenum *)(*env)->GetDirectBufferAddress(env, buffers)) + buffers_position;
glDrawBuffersARBPROC glDrawBuffersARB = (glDrawBuffersARBPROC)((intptr_t)function_pointer);
glDrawBuffersARB(size, buffers_address);
}

292
src/native/generated/org_lwjgl_opengl_ARBImaging.c
View file

@ -1,292 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glColorTablePROC) (GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid * data);
typedef void (APIENTRY *glColorSubTablePROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data);
typedef void (APIENTRY *glColorTableParameterivPROC) (GLenum target, GLenum pname, const GLint * params);
typedef void (APIENTRY *glColorTableParameterfvPROC) (GLenum target, GLenum pname, const GLfloat * params);
typedef void (APIENTRY *glCopyColorSubTablePROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
typedef void (APIENTRY *glCopyColorTablePROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
typedef void (APIENTRY *glGetColorTablePROC) (GLenum target, GLenum format, GLenum type, GLvoid * data);
typedef void (APIENTRY *glGetColorTableParameterivPROC) (GLenum target, GLenum pname, GLint * params);
typedef void (APIENTRY *glGetColorTableParameterfvPROC) (GLenum target, GLenum pname, GLfloat * params);
typedef void (APIENTRY *glBlendEquationPROC) (GLenum mode);
typedef void (APIENTRY *glBlendColorPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
typedef void (APIENTRY *glHistogramPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
typedef void (APIENTRY *glResetHistogramPROC) (GLenum target);
typedef void (APIENTRY *glGetHistogramPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values);
typedef void (APIENTRY *glGetHistogramParameterfvPROC) (GLenum target, GLenum pname, GLfloat * params);
typedef void (APIENTRY *glGetHistogramParameterivPROC) (GLenum target, GLenum pname, GLint * params);
typedef void (APIENTRY *glMinmaxPROC) (GLenum target, GLenum internalformat, GLboolean sink);
typedef void (APIENTRY *glResetMinmaxPROC) (GLenum target);
typedef void (APIENTRY *glGetMinmaxPROC) (GLenum target, GLboolean reset, GLenum format, GLenum types, GLvoid * values);
typedef void (APIENTRY *glGetMinmaxParameterfvPROC) (GLenum target, GLenum pname, GLfloat * params);
typedef void (APIENTRY *glGetMinmaxParameterivPROC) (GLenum target, GLenum pname, GLint * params);
typedef void (APIENTRY *glConvolutionFilter1DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image);
typedef void (APIENTRY *glConvolutionFilter2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image);
typedef void (APIENTRY *glConvolutionParameterfPROC) (GLenum target, GLenum pname, GLfloat params);
typedef void (APIENTRY *glConvolutionParameterfvPROC) (GLenum target, GLenum pname, const GLfloat * params);
typedef void (APIENTRY *glConvolutionParameteriPROC) (GLenum target, GLenum pname, GLint params);
typedef void (APIENTRY *glConvolutionParameterivPROC) (GLenum target, GLenum pname, const GLint * params);
typedef void (APIENTRY *glCopyConvolutionFilter1DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
typedef void (APIENTRY *glCopyConvolutionFilter2DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
typedef void (APIENTRY *glGetConvolutionFilterPROC) (GLenum target, GLenum format, GLenum type, GLvoid * image);
typedef void (APIENTRY *glGetConvolutionParameterfvPROC) (GLenum target, GLenum pname, GLfloat * params);
typedef void (APIENTRY *glGetConvolutionParameterivPROC) (GLenum target, GLenum pname, GLint * params);
typedef void (APIENTRY *glSeparableFilter2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column);
typedef void (APIENTRY *glGetSeparableFilterPROC) (GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglColorTable(JNIEnv *env, jclass clazz, jint target, jint internalFormat, jint width, jint format, jint type, jobject data, jint data_position, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
glColorTablePROC glColorTable = (glColorTablePROC)((intptr_t)function_pointer);
glColorTable(target, internalFormat, width, format, type, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglColorTableBO(JNIEnv *env, jclass clazz, jint target, jint internalFormat, jint width, jint format, jint type, jlong data_buffer_offset, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)offsetToPointer(data_buffer_offset));
glColorTablePROC glColorTable = (glColorTablePROC)((intptr_t)function_pointer);
glColorTable(target, internalFormat, width, format, type, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglColorSubTable(JNIEnv *env, jclass clazz, jint target, jint start, jint count, jint format, jint type, jobject data, jint data_position, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
glColorSubTablePROC glColorSubTable = (glColorSubTablePROC)((intptr_t)function_pointer);
glColorSubTable(target, start, count, format, type, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglColorSubTableBO(JNIEnv *env, jclass clazz, jint target, jint start, jint count, jint format, jint type, jlong data_buffer_offset, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)offsetToPointer(data_buffer_offset));
glColorSubTablePROC glColorSubTable = (glColorSubTablePROC)((intptr_t)function_pointer);
glColorSubTable(target, start, count, format, type, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglColorTableParameteriv(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
const GLint *params_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glColorTableParameterivPROC glColorTableParameteriv = (glColorTableParameterivPROC)((intptr_t)function_pointer);
glColorTableParameteriv(target, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglColorTableParameterfv(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
const GLfloat *params_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glColorTableParameterfvPROC glColorTableParameterfv = (glColorTableParameterfvPROC)((intptr_t)function_pointer);
glColorTableParameterfv(target, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglCopyColorSubTable(JNIEnv *env, jclass clazz, jint target, jint start, jint x, jint y, jint width, jlong function_pointer) {
glCopyColorSubTablePROC glCopyColorSubTable = (glCopyColorSubTablePROC)((intptr_t)function_pointer);
glCopyColorSubTable(target, start, x, y, width);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglCopyColorTable(JNIEnv *env, jclass clazz, jint target, jint internalformat, jint x, jint y, jint width, jlong function_pointer) {
glCopyColorTablePROC glCopyColorTable = (glCopyColorTablePROC)((intptr_t)function_pointer);
glCopyColorTable(target, internalformat, x, y, width);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetColorTable(JNIEnv *env, jclass clazz, jint target, jint format, jint type, jobject data, jint data_position, jlong function_pointer) {
GLvoid *data_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
glGetColorTablePROC glGetColorTable = (glGetColorTablePROC)((intptr_t)function_pointer);
glGetColorTable(target, format, type, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetColorTableParameteriv(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetColorTableParameterivPROC glGetColorTableParameteriv = (glGetColorTableParameterivPROC)((intptr_t)function_pointer);
glGetColorTableParameteriv(target, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetColorTableParameterfv(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetColorTableParameterfvPROC glGetColorTableParameterfv = (glGetColorTableParameterfvPROC)((intptr_t)function_pointer);
glGetColorTableParameterfv(target, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglBlendEquation(JNIEnv *env, jclass clazz, jint mode, jlong function_pointer) {
glBlendEquationPROC glBlendEquation = (glBlendEquationPROC)((intptr_t)function_pointer);
glBlendEquation(mode);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglBlendColor(JNIEnv *env, jclass clazz, jfloat red, jfloat green, jfloat blue, jfloat alpha, jlong function_pointer) {
glBlendColorPROC glBlendColor = (glBlendColorPROC)((intptr_t)function_pointer);
glBlendColor(red, green, blue, alpha);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglHistogram(JNIEnv *env, jclass clazz, jint target, jint width, jint internalformat, jboolean sink, jlong function_pointer) {
glHistogramPROC glHistogram = (glHistogramPROC)((intptr_t)function_pointer);
glHistogram(target, width, internalformat, sink);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglResetHistogram(JNIEnv *env, jclass clazz, jint target, jlong function_pointer) {
glResetHistogramPROC glResetHistogram = (glResetHistogramPROC)((intptr_t)function_pointer);
glResetHistogram(target);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetHistogram(JNIEnv *env, jclass clazz, jint target, jboolean reset, jint format, jint type, jobject values, jint values_position, jlong function_pointer) {
GLvoid *values_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, values)) + values_position));
glGetHistogramPROC glGetHistogram = (glGetHistogramPROC)((intptr_t)function_pointer);
glGetHistogram(target, reset, format, type, values_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetHistogramBO(JNIEnv *env, jclass clazz, jint target, jboolean reset, jint format, jint type, jlong values_buffer_offset, jlong function_pointer) {
GLvoid *values_address = ((GLvoid *)offsetToPointer(values_buffer_offset));
glGetHistogramPROC glGetHistogram = (glGetHistogramPROC)((intptr_t)function_pointer);
glGetHistogram(target, reset, format, type, values_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetHistogramParameterfv(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetHistogramParameterfvPROC glGetHistogramParameterfv = (glGetHistogramParameterfvPROC)((intptr_t)function_pointer);
glGetHistogramParameterfv(target, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetHistogramParameteriv(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetHistogramParameterivPROC glGetHistogramParameteriv = (glGetHistogramParameterivPROC)((intptr_t)function_pointer);
glGetHistogramParameteriv(target, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglMinmax(JNIEnv *env, jclass clazz, jint target, jint internalformat, jboolean sink, jlong function_pointer) {
glMinmaxPROC glMinmax = (glMinmaxPROC)((intptr_t)function_pointer);
glMinmax(target, internalformat, sink);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglResetMinmax(JNIEnv *env, jclass clazz, jint target, jlong function_pointer) {
glResetMinmaxPROC glResetMinmax = (glResetMinmaxPROC)((intptr_t)function_pointer);
glResetMinmax(target);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetMinmax(JNIEnv *env, jclass clazz, jint target, jboolean reset, jint format, jint types, jobject values, jint values_position, jlong function_pointer) {
GLvoid *values_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, values)) + values_position));
glGetMinmaxPROC glGetMinmax = (glGetMinmaxPROC)((intptr_t)function_pointer);
glGetMinmax(target, reset, format, types, values_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetMinmaxBO(JNIEnv *env, jclass clazz, jint target, jboolean reset, jint format, jint types, jlong values_buffer_offset, jlong function_pointer) {
GLvoid *values_address = ((GLvoid *)offsetToPointer(values_buffer_offset));
glGetMinmaxPROC glGetMinmax = (glGetMinmaxPROC)((intptr_t)function_pointer);
glGetMinmax(target, reset, format, types, values_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetMinmaxParameterfv(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetMinmaxParameterfvPROC glGetMinmaxParameterfv = (glGetMinmaxParameterfvPROC)((intptr_t)function_pointer);
glGetMinmaxParameterfv(target, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetMinmaxParameteriv(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetMinmaxParameterivPROC glGetMinmaxParameteriv = (glGetMinmaxParameterivPROC)((intptr_t)function_pointer);
glGetMinmaxParameteriv(target, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglConvolutionFilter1D(JNIEnv *env, jclass clazz, jint target, jint internalformat, jint width, jint format, jint type, jobject image, jint image_position, jlong function_pointer) {
const GLvoid *image_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, image)) + image_position));
glConvolutionFilter1DPROC glConvolutionFilter1D = (glConvolutionFilter1DPROC)((intptr_t)function_pointer);
glConvolutionFilter1D(target, internalformat, width, format, type, image_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglConvolutionFilter1DBO(JNIEnv *env, jclass clazz, jint target, jint internalformat, jint width, jint format, jint type, jlong image_buffer_offset, jlong function_pointer) {
const GLvoid *image_address = ((const GLvoid *)offsetToPointer(image_buffer_offset));
glConvolutionFilter1DPROC glConvolutionFilter1D = (glConvolutionFilter1DPROC)((intptr_t)function_pointer);
glConvolutionFilter1D(target, internalformat, width, format, type, image_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglConvolutionFilter2D(JNIEnv *env, jclass clazz, jint target, jint internalformat, jint width, jint height, jint format, jint type, jobject image, jint image_position, jlong function_pointer) {
const GLvoid *image_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, image)) + image_position));
glConvolutionFilter2DPROC glConvolutionFilter2D = (glConvolutionFilter2DPROC)((intptr_t)function_pointer);
glConvolutionFilter2D(target, internalformat, width, height, format, type, image_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglConvolutionFilter2DBO(JNIEnv *env, jclass clazz, jint target, jint internalformat, jint width, jint height, jint format, jint type, jlong image_buffer_offset, jlong function_pointer) {
const GLvoid *image_address = ((const GLvoid *)offsetToPointer(image_buffer_offset));
glConvolutionFilter2DPROC glConvolutionFilter2D = (glConvolutionFilter2DPROC)((intptr_t)function_pointer);
glConvolutionFilter2D(target, internalformat, width, height, format, type, image_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglConvolutionParameterf(JNIEnv *env, jclass clazz, jint target, jint pname, jfloat params, jlong function_pointer) {
glConvolutionParameterfPROC glConvolutionParameterf = (glConvolutionParameterfPROC)((intptr_t)function_pointer);
glConvolutionParameterf(target, pname, params);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglConvolutionParameterfv(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
const GLfloat *params_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glConvolutionParameterfvPROC glConvolutionParameterfv = (glConvolutionParameterfvPROC)((intptr_t)function_pointer);
glConvolutionParameterfv(target, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglConvolutionParameteri(JNIEnv *env, jclass clazz, jint target, jint pname, jint params, jlong function_pointer) {
glConvolutionParameteriPROC glConvolutionParameteri = (glConvolutionParameteriPROC)((intptr_t)function_pointer);
glConvolutionParameteri(target, pname, params);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglConvolutionParameteriv(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
const GLint *params_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glConvolutionParameterivPROC glConvolutionParameteriv = (glConvolutionParameterivPROC)((intptr_t)function_pointer);
glConvolutionParameteriv(target, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglCopyConvolutionFilter1D(JNIEnv *env, jclass clazz, jint target, jint internalformat, jint x, jint y, jint width, jlong function_pointer) {
glCopyConvolutionFilter1DPROC glCopyConvolutionFilter1D = (glCopyConvolutionFilter1DPROC)((intptr_t)function_pointer);
glCopyConvolutionFilter1D(target, internalformat, x, y, width);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglCopyConvolutionFilter2D(JNIEnv *env, jclass clazz, jint target, jint internalformat, jint x, jint y, jint width, jint height, jlong function_pointer) {
glCopyConvolutionFilter2DPROC glCopyConvolutionFilter2D = (glCopyConvolutionFilter2DPROC)((intptr_t)function_pointer);
glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetConvolutionFilter(JNIEnv *env, jclass clazz, jint target, jint format, jint type, jobject image, jint image_position, jlong function_pointer) {
GLvoid *image_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, image)) + image_position));
glGetConvolutionFilterPROC glGetConvolutionFilter = (glGetConvolutionFilterPROC)((intptr_t)function_pointer);
glGetConvolutionFilter(target, format, type, image_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetConvolutionFilterBO(JNIEnv *env, jclass clazz, jint target, jint format, jint type, jlong image_buffer_offset, jlong function_pointer) {
GLvoid *image_address = ((GLvoid *)offsetToPointer(image_buffer_offset));
glGetConvolutionFilterPROC glGetConvolutionFilter = (glGetConvolutionFilterPROC)((intptr_t)function_pointer);
glGetConvolutionFilter(target, format, type, image_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetConvolutionParameterfv(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetConvolutionParameterfvPROC glGetConvolutionParameterfv = (glGetConvolutionParameterfvPROC)((intptr_t)function_pointer);
glGetConvolutionParameterfv(target, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetConvolutionParameteriv(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetConvolutionParameterivPROC glGetConvolutionParameteriv = (glGetConvolutionParameterivPROC)((intptr_t)function_pointer);
glGetConvolutionParameteriv(target, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglSeparableFilter2D(JNIEnv *env, jclass clazz, jint target, jint internalformat, jint width, jint height, jint format, jint type, jobject row, jint row_position, jobject column, jint column_position, jlong function_pointer) {
const GLvoid *row_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, row)) + row_position));
const GLvoid *column_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, column)) + column_position));
glSeparableFilter2DPROC glSeparableFilter2D = (glSeparableFilter2DPROC)((intptr_t)function_pointer);
glSeparableFilter2D(target, internalformat, width, height, format, type, row_address, column_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglSeparableFilter2DBO(JNIEnv *env, jclass clazz, jint target, jint internalformat, jint width, jint height, jint format, jint type, jlong row_buffer_offset, jlong column_buffer_offset, jlong function_pointer) {
const GLvoid *row_address = ((const GLvoid *)offsetToPointer(row_buffer_offset));
const GLvoid *column_address = ((const GLvoid *)offsetToPointer(column_buffer_offset));
glSeparableFilter2DPROC glSeparableFilter2D = (glSeparableFilter2DPROC)((intptr_t)function_pointer);
glSeparableFilter2D(target, internalformat, width, height, format, type, row_address, column_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetSeparableFilter(JNIEnv *env, jclass clazz, jint target, jint format, jint type, jobject row, jint row_position, jobject column, jint column_position, jobject span, jint span_position, jlong function_pointer) {
GLvoid *row_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, row)) + row_position));
GLvoid *column_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, column)) + column_position));
GLvoid *span_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, span)) + span_position));
glGetSeparableFilterPROC glGetSeparableFilter = (glGetSeparableFilterPROC)((intptr_t)function_pointer);
glGetSeparableFilter(target, format, type, row_address, column_address, span_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetSeparableFilterBO(JNIEnv *env, jclass clazz, jint target, jint format, jint type, jlong row_buffer_offset, jlong column_buffer_offset, jlong span_buffer_offset, jlong function_pointer) {
GLvoid *row_address = ((GLvoid *)offsetToPointer(row_buffer_offset));
GLvoid *column_address = ((GLvoid *)offsetToPointer(column_buffer_offset));
GLvoid *span_address = ((GLvoid *)offsetToPointer(span_buffer_offset));
glGetSeparableFilterPROC glGetSeparableFilter = (glGetSeparableFilterPROC)((intptr_t)function_pointer);
glGetSeparableFilter(target, format, type, row_address, column_address, span_address);
}

46
src/native/generated/org_lwjgl_opengl_ARBMatrixPalette.c
View file

@ -1,46 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glCurrentPaletteMatrixARBPROC) (GLint index);
typedef void (APIENTRY *glMatrixIndexPointerARBPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid * pPointer);
typedef void (APIENTRY *glMatrixIndexubvARBPROC) (GLint size, GLubyte * pIndices);
typedef void (APIENTRY *glMatrixIndexusvARBPROC) (GLint size, GLushort * pIndices);
typedef void (APIENTRY *glMatrixIndexuivARBPROC) (GLint size, GLuint * pIndices);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMatrixPalette_nglCurrentPaletteMatrixARB(JNIEnv *env, jclass clazz, jint index, jlong function_pointer) {
glCurrentPaletteMatrixARBPROC glCurrentPaletteMatrixARB = (glCurrentPaletteMatrixARBPROC)((intptr_t)function_pointer);
glCurrentPaletteMatrixARB(index);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMatrixPalette_nglMatrixIndexPointerARB(JNIEnv *env, jclass clazz, jint size, jint type, jint stride, jobject pPointer, jint pPointer_position, jlong function_pointer) {
const GLvoid *pPointer_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pPointer)) + pPointer_position));
glMatrixIndexPointerARBPROC glMatrixIndexPointerARB = (glMatrixIndexPointerARBPROC)((intptr_t)function_pointer);
glMatrixIndexPointerARB(size, type, stride, pPointer_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMatrixPalette_nglMatrixIndexPointerARBBO(JNIEnv *env, jclass clazz, jint size, jint type, jint stride, jlong pPointer_buffer_offset, jlong function_pointer) {
const GLvoid *pPointer_address = ((const GLvoid *)offsetToPointer(pPointer_buffer_offset));
glMatrixIndexPointerARBPROC glMatrixIndexPointerARB = (glMatrixIndexPointerARBPROC)((intptr_t)function_pointer);
glMatrixIndexPointerARB(size, type, stride, pPointer_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMatrixPalette_nglMatrixIndexubvARB(JNIEnv *env, jclass clazz, jint size, jobject pIndices, jint pIndices_position, jlong function_pointer) {
GLubyte *pIndices_address = ((GLubyte *)(*env)->GetDirectBufferAddress(env, pIndices)) + pIndices_position;
glMatrixIndexubvARBPROC glMatrixIndexubvARB = (glMatrixIndexubvARBPROC)((intptr_t)function_pointer);
glMatrixIndexubvARB(size, pIndices_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMatrixPalette_nglMatrixIndexusvARB(JNIEnv *env, jclass clazz, jint size, jobject pIndices, jint pIndices_position, jlong function_pointer) {
GLushort *pIndices_address = ((GLushort *)(*env)->GetDirectBufferAddress(env, pIndices)) + pIndices_position;
glMatrixIndexusvARBPROC glMatrixIndexusvARB = (glMatrixIndexusvARBPROC)((intptr_t)function_pointer);
glMatrixIndexusvARB(size, pIndices_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMatrixPalette_nglMatrixIndexuivARB(JNIEnv *env, jclass clazz, jint size, jobject pIndices, jint pIndices_position, jlong function_pointer) {
GLuint *pIndices_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, pIndices)) + pIndices_position;
glMatrixIndexuivARBPROC glMatrixIndexuivARB = (glMatrixIndexuivARBPROC)((intptr_t)function_pointer);
glMatrixIndexuivARB(size, pIndices_address);
}

12
src/native/generated/org_lwjgl_opengl_ARBMultisample.c
View file

@ -1,12 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glSampleCoverageARBPROC) (GLclampf value, GLboolean invert);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMultisample_nglSampleCoverageARB(JNIEnv *env, jclass clazz, jfloat value, jboolean invert, jlong function_pointer) {
glSampleCoverageARBPROC glSampleCoverageARB = (glSampleCoverageARBPROC)((intptr_t)function_pointer);
glSampleCoverageARB(value, invert);
}

114
src/native/generated/org_lwjgl_opengl_ARBMultitexture.c
View file

@ -1,114 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glClientActiveTextureARBPROC) (GLenum texture);
typedef void (APIENTRY *glActiveTextureARBPROC) (GLenum texture);
typedef void (APIENTRY *glMultiTexCoord1fARBPROC) (GLenum target, GLfloat s);
typedef void (APIENTRY *glMultiTexCoord1dARBPROC) (GLenum target, GLdouble s);
typedef void (APIENTRY *glMultiTexCoord1iARBPROC) (GLenum target, GLint s);
typedef void (APIENTRY *glMultiTexCoord1sARBPROC) (GLenum target, GLshort s);
typedef void (APIENTRY *glMultiTexCoord2fARBPROC) (GLenum target, GLfloat s, GLfloat t);
typedef void (APIENTRY *glMultiTexCoord2dARBPROC) (GLenum target, GLdouble s, GLdouble t);
typedef void (APIENTRY *glMultiTexCoord2iARBPROC) (GLenum target, GLint s, GLint t);
typedef void (APIENTRY *glMultiTexCoord2sARBPROC) (GLenum target, GLshort s, GLshort t);
typedef void (APIENTRY *glMultiTexCoord3fARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r);
typedef void (APIENTRY *glMultiTexCoord3dARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r);
typedef void (APIENTRY *glMultiTexCoord3iARBPROC) (GLenum target, GLint s, GLint t, GLint r);
typedef void (APIENTRY *glMultiTexCoord3sARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r);
typedef void (APIENTRY *glMultiTexCoord4fARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
typedef void (APIENTRY *glMultiTexCoord4dARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
typedef void (APIENTRY *glMultiTexCoord4iARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q);
typedef void (APIENTRY *glMultiTexCoord4sARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMultitexture_nglClientActiveTextureARB(JNIEnv *env, jclass clazz, jint texture, jlong function_pointer) {
glClientActiveTextureARBPROC glClientActiveTextureARB = (glClientActiveTextureARBPROC)((intptr_t)function_pointer);
glClientActiveTextureARB(texture);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMultitexture_nglActiveTextureARB(JNIEnv *env, jclass clazz, jint texture, jlong function_pointer) {
glActiveTextureARBPROC glActiveTextureARB = (glActiveTextureARBPROC)((intptr_t)function_pointer);
glActiveTextureARB(texture);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMultitexture_nglMultiTexCoord1fARB(JNIEnv *env, jclass clazz, jint target, jfloat s, jlong function_pointer) {
glMultiTexCoord1fARBPROC glMultiTexCoord1fARB = (glMultiTexCoord1fARBPROC)((intptr_t)function_pointer);
glMultiTexCoord1fARB(target, s);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMultitexture_nglMultiTexCoord1dARB(JNIEnv *env, jclass clazz, jint target, jdouble s, jlong function_pointer) {
glMultiTexCoord1dARBPROC glMultiTexCoord1dARB = (glMultiTexCoord1dARBPROC)((intptr_t)function_pointer);
glMultiTexCoord1dARB(target, s);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMultitexture_nglMultiTexCoord1iARB(JNIEnv *env, jclass clazz, jint target, jint s, jlong function_pointer) {
glMultiTexCoord1iARBPROC glMultiTexCoord1iARB = (glMultiTexCoord1iARBPROC)((intptr_t)function_pointer);
glMultiTexCoord1iARB(target, s);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMultitexture_nglMultiTexCoord1sARB(JNIEnv *env, jclass clazz, jint target, jshort s, jlong function_pointer) {
glMultiTexCoord1sARBPROC glMultiTexCoord1sARB = (glMultiTexCoord1sARBPROC)((intptr_t)function_pointer);
glMultiTexCoord1sARB(target, s);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMultitexture_nglMultiTexCoord2fARB(JNIEnv *env, jclass clazz, jint target, jfloat s, jfloat t, jlong function_pointer) {
glMultiTexCoord2fARBPROC glMultiTexCoord2fARB = (glMultiTexCoord2fARBPROC)((intptr_t)function_pointer);
glMultiTexCoord2fARB(target, s, t);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMultitexture_nglMultiTexCoord2dARB(JNIEnv *env, jclass clazz, jint target, jdouble s, jdouble t, jlong function_pointer) {
glMultiTexCoord2dARBPROC glMultiTexCoord2dARB = (glMultiTexCoord2dARBPROC)((intptr_t)function_pointer);
glMultiTexCoord2dARB(target, s, t);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMultitexture_nglMultiTexCoord2iARB(JNIEnv *env, jclass clazz, jint target, jint s, jint t, jlong function_pointer) {
glMultiTexCoord2iARBPROC glMultiTexCoord2iARB = (glMultiTexCoord2iARBPROC)((intptr_t)function_pointer);
glMultiTexCoord2iARB(target, s, t);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMultitexture_nglMultiTexCoord2sARB(JNIEnv *env, jclass clazz, jint target, jshort s, jshort t, jlong function_pointer) {
glMultiTexCoord2sARBPROC glMultiTexCoord2sARB = (glMultiTexCoord2sARBPROC)((intptr_t)function_pointer);
glMultiTexCoord2sARB(target, s, t);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMultitexture_nglMultiTexCoord3fARB(JNIEnv *env, jclass clazz, jint target, jfloat s, jfloat t, jfloat r, jlong function_pointer) {
glMultiTexCoord3fARBPROC glMultiTexCoord3fARB = (glMultiTexCoord3fARBPROC)((intptr_t)function_pointer);
glMultiTexCoord3fARB(target, s, t, r);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMultitexture_nglMultiTexCoord3dARB(JNIEnv *env, jclass clazz, jint target, jdouble s, jdouble t, jdouble r, jlong function_pointer) {
glMultiTexCoord3dARBPROC glMultiTexCoord3dARB = (glMultiTexCoord3dARBPROC)((intptr_t)function_pointer);
glMultiTexCoord3dARB(target, s, t, r);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMultitexture_nglMultiTexCoord3iARB(JNIEnv *env, jclass clazz, jint target, jint s, jint t, jint r, jlong function_pointer) {
glMultiTexCoord3iARBPROC glMultiTexCoord3iARB = (glMultiTexCoord3iARBPROC)((intptr_t)function_pointer);
glMultiTexCoord3iARB(target, s, t, r);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMultitexture_nglMultiTexCoord3sARB(JNIEnv *env, jclass clazz, jint target, jshort s, jshort t, jshort r, jlong function_pointer) {
glMultiTexCoord3sARBPROC glMultiTexCoord3sARB = (glMultiTexCoord3sARBPROC)((intptr_t)function_pointer);
glMultiTexCoord3sARB(target, s, t, r);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMultitexture_nglMultiTexCoord4fARB(JNIEnv *env, jclass clazz, jint target, jfloat s, jfloat t, jfloat r, jfloat q, jlong function_pointer) {
glMultiTexCoord4fARBPROC glMultiTexCoord4fARB = (glMultiTexCoord4fARBPROC)((intptr_t)function_pointer);
glMultiTexCoord4fARB(target, s, t, r, q);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMultitexture_nglMultiTexCoord4dARB(JNIEnv *env, jclass clazz, jint target, jdouble s, jdouble t, jdouble r, jdouble q, jlong function_pointer) {
glMultiTexCoord4dARBPROC glMultiTexCoord4dARB = (glMultiTexCoord4dARBPROC)((intptr_t)function_pointer);
glMultiTexCoord4dARB(target, s, t, r, q);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMultitexture_nglMultiTexCoord4iARB(JNIEnv *env, jclass clazz, jint target, jint s, jint t, jint r, jint q, jlong function_pointer) {
glMultiTexCoord4iARBPROC glMultiTexCoord4iARB = (glMultiTexCoord4iARBPROC)((intptr_t)function_pointer);
glMultiTexCoord4iARB(target, s, t, r, q);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMultitexture_nglMultiTexCoord4sARB(JNIEnv *env, jclass clazz, jint target, jshort s, jshort t, jshort r, jshort q, jlong function_pointer) {
glMultiTexCoord4sARBPROC glMultiTexCoord4sARB = (glMultiTexCoord4sARBPROC)((intptr_t)function_pointer);
glMultiTexCoord4sARB(target, s, t, r, q);
}

60
src/native/generated/org_lwjgl_opengl_ARBOcclusionQuery.c
View file

@ -1,60 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glGenQueriesARBPROC) (GLsizei n, GLuint * ids);
typedef void (APIENTRY *glDeleteQueriesARBPROC) (GLsizei n, GLuint * ids);
typedef GLboolean (APIENTRY *glIsQueryARBPROC) (GLuint id);
typedef void (APIENTRY *glBeginQueryARBPROC) (GLenum target, GLuint id);
typedef void (APIENTRY *glEndQueryARBPROC) (GLenum target);
typedef void (APIENTRY *glGetQueryivARBPROC) (GLenum target, GLenum pname, GLint * params);
typedef void (APIENTRY *glGetQueryObjectivARBPROC) (GLuint id, GLenum pname, GLint * params);
typedef void (APIENTRY *glGetQueryObjectuivARBPROC) (GLuint id, GLenum pname, GLint * params);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBOcclusionQuery_nglGenQueriesARB(JNIEnv *env, jclass clazz, jint n, jobject ids, jint ids_position, jlong function_pointer) {
GLuint *ids_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, ids)) + ids_position;
glGenQueriesARBPROC glGenQueriesARB = (glGenQueriesARBPROC)((intptr_t)function_pointer);
glGenQueriesARB(n, ids_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBOcclusionQuery_nglDeleteQueriesARB(JNIEnv *env, jclass clazz, jint n, jobject ids, jint ids_position, jlong function_pointer) {
GLuint *ids_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, ids)) + ids_position;
glDeleteQueriesARBPROC glDeleteQueriesARB = (glDeleteQueriesARBPROC)((intptr_t)function_pointer);
glDeleteQueriesARB(n, ids_address);
}
JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_ARBOcclusionQuery_nglIsQueryARB(JNIEnv *env, jclass clazz, jint id, jlong function_pointer) {
glIsQueryARBPROC glIsQueryARB = (glIsQueryARBPROC)((intptr_t)function_pointer);
GLboolean __result = glIsQueryARB(id);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBOcclusionQuery_nglBeginQueryARB(JNIEnv *env, jclass clazz, jint target, jint id, jlong function_pointer) {
glBeginQueryARBPROC glBeginQueryARB = (glBeginQueryARBPROC)((intptr_t)function_pointer);
glBeginQueryARB(target, id);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBOcclusionQuery_nglEndQueryARB(JNIEnv *env, jclass clazz, jint target, jlong function_pointer) {
glEndQueryARBPROC glEndQueryARB = (glEndQueryARBPROC)((intptr_t)function_pointer);
glEndQueryARB(target);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBOcclusionQuery_nglGetQueryivARB(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetQueryivARBPROC glGetQueryivARB = (glGetQueryivARBPROC)((intptr_t)function_pointer);
glGetQueryivARB(target, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBOcclusionQuery_nglGetQueryObjectivARB(JNIEnv *env, jclass clazz, jint id, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetQueryObjectivARBPROC glGetQueryObjectivARB = (glGetQueryObjectivARBPROC)((intptr_t)function_pointer);
glGetQueryObjectivARB(id, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBOcclusionQuery_nglGetQueryObjectuivARB(JNIEnv *env, jclass clazz, jint id, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetQueryObjectuivARBPROC glGetQueryObjectuivARB = (glGetQueryObjectuivARBPROC)((intptr_t)function_pointer);
glGetQueryObjectuivARB(id, pname, params_address);
}

19
src/native/generated/org_lwjgl_opengl_ARBPointParameters.c
View file

@ -1,19 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glPointParameterfARBPROC) (GLenum pname, GLfloat param);
typedef void (APIENTRY *glPointParameterfvARBPROC) (GLenum pname, const GLfloat * pfParams);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBPointParameters_nglPointParameterfARB(JNIEnv *env, jclass clazz, jint pname, jfloat param, jlong function_pointer) {
glPointParameterfARBPROC glPointParameterfARB = (glPointParameterfARBPROC)((intptr_t)function_pointer);
glPointParameterfARB(pname, param);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBPointParameters_nglPointParameterfvARB(JNIEnv *env, jclass clazz, jint pname, jobject pfParams, jint pfParams_position, jlong function_pointer) {
const GLfloat *pfParams_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, pfParams)) + pfParams_position;
glPointParameterfvARBPROC glPointParameterfvARB = (glPointParameterfvARBPROC)((intptr_t)function_pointer);
glPointParameterfvARB(pname, pfParams_address);
}

134
src/native/generated/org_lwjgl_opengl_ARBProgram.c
View file

@ -1,134 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glProgramStringARBPROC) (GLenum target, GLenum format, GLsizei length, const GLvoid * string);
typedef void (APIENTRY *glBindProgramARBPROC) (GLenum target, GLuint program);
typedef void (APIENTRY *glDeleteProgramsARBPROC) (GLsizei n, const GLuint * programs);
typedef void (APIENTRY *glGenProgramsARBPROC) (GLsizei n, GLuint * programs);
typedef void (APIENTRY *glProgramEnvParameter4fARBPROC) (GLint target, GLint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
typedef void (APIENTRY *glProgramEnvParameter4dARBPROC) (GLint target, GLint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
typedef void (APIENTRY *glProgramEnvParameter4fvARBPROC) (GLenum target, GLuint index, const GLfloat * params);
typedef void (APIENTRY *glProgramEnvParameter4dvARBPROC) (GLenum target, GLuint index, const GLdouble * params);
typedef void (APIENTRY *glProgramLocalParameter4fARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
typedef void (APIENTRY *glProgramLocalParameter4dARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
typedef void (APIENTRY *glProgramLocalParameter4fvARBPROC) (GLenum target, GLuint index, const GLfloat * params);
typedef void (APIENTRY *glProgramLocalParameter4dvARBPROC) (GLenum target, GLuint index, const GLdouble * params);
typedef void (APIENTRY *glGetProgramEnvParameterfvARBPROC) (GLenum target, GLuint index, GLfloat * params);
typedef void (APIENTRY *glGetProgramEnvParameterdvARBPROC) (GLenum target, GLuint index, GLdouble * params);
typedef void (APIENTRY *glGetProgramLocalParameterfvARBPROC) (GLenum target, GLuint index, GLfloat * params);
typedef void (APIENTRY *glGetProgramLocalParameterdvARBPROC) (GLenum target, GLuint index, GLdouble * params);
typedef void (APIENTRY *glGetProgramivARBPROC) (GLenum target, GLenum parameterName, GLint * params);
typedef void (APIENTRY *glGetProgramStringARBPROC) (GLenum target, GLenum parameterName, GLvoid * paramString);
typedef GLboolean (APIENTRY *glIsProgramARBPROC) (GLuint program);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBProgram_nglProgramStringARB(JNIEnv *env, jclass clazz, jint target, jint format, jint length, jobject string, jint string_position, jlong function_pointer) {
const GLvoid *string_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, string)) + string_position));
glProgramStringARBPROC glProgramStringARB = (glProgramStringARBPROC)((intptr_t)function_pointer);
glProgramStringARB(target, format, length, string_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBProgram_nglBindProgramARB(JNIEnv *env, jclass clazz, jint target, jint program, jlong function_pointer) {
glBindProgramARBPROC glBindProgramARB = (glBindProgramARBPROC)((intptr_t)function_pointer);
glBindProgramARB(target, program);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBProgram_nglDeleteProgramsARB(JNIEnv *env, jclass clazz, jint n, jobject programs, jint programs_position, jlong function_pointer) {
const GLuint *programs_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, programs)) + programs_position;
glDeleteProgramsARBPROC glDeleteProgramsARB = (glDeleteProgramsARBPROC)((intptr_t)function_pointer);
glDeleteProgramsARB(n, programs_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBProgram_nglGenProgramsARB(JNIEnv *env, jclass clazz, jint n, jobject programs, jint programs_position, jlong function_pointer) {
GLuint *programs_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, programs)) + programs_position;
glGenProgramsARBPROC glGenProgramsARB = (glGenProgramsARBPROC)((intptr_t)function_pointer);
glGenProgramsARB(n, programs_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBProgram_nglProgramEnvParameter4fARB(JNIEnv *env, jclass clazz, jint target, jint index, jfloat x, jfloat y, jfloat z, jfloat w, jlong function_pointer) {
glProgramEnvParameter4fARBPROC glProgramEnvParameter4fARB = (glProgramEnvParameter4fARBPROC)((intptr_t)function_pointer);
glProgramEnvParameter4fARB(target, index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBProgram_nglProgramEnvParameter4dARB(JNIEnv *env, jclass clazz, jint target, jint index, jdouble x, jdouble y, jdouble z, jdouble w, jlong function_pointer) {
glProgramEnvParameter4dARBPROC glProgramEnvParameter4dARB = (glProgramEnvParameter4dARBPROC)((intptr_t)function_pointer);
glProgramEnvParameter4dARB(target, index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBProgram_nglProgramEnvParameter4fvARB(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) {
const GLfloat *params_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glProgramEnvParameter4fvARBPROC glProgramEnvParameter4fvARB = (glProgramEnvParameter4fvARBPROC)((intptr_t)function_pointer);
glProgramEnvParameter4fvARB(target, index, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBProgram_nglProgramEnvParameter4dvARB(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) {
const GLdouble *params_address = ((const GLdouble *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glProgramEnvParameter4dvARBPROC glProgramEnvParameter4dvARB = (glProgramEnvParameter4dvARBPROC)((intptr_t)function_pointer);
glProgramEnvParameter4dvARB(target, index, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBProgram_nglProgramLocalParameter4fARB(JNIEnv *env, jclass clazz, jint target, jint index, jfloat x, jfloat y, jfloat z, jfloat w, jlong function_pointer) {
glProgramLocalParameter4fARBPROC glProgramLocalParameter4fARB = (glProgramLocalParameter4fARBPROC)((intptr_t)function_pointer);
glProgramLocalParameter4fARB(target, index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBProgram_nglProgramLocalParameter4dARB(JNIEnv *env, jclass clazz, jint target, jint index, jdouble x, jdouble y, jdouble z, jdouble w, jlong function_pointer) {
glProgramLocalParameter4dARBPROC glProgramLocalParameter4dARB = (glProgramLocalParameter4dARBPROC)((intptr_t)function_pointer);
glProgramLocalParameter4dARB(target, index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBProgram_nglProgramLocalParameter4fvARB(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) {
const GLfloat *params_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glProgramLocalParameter4fvARBPROC glProgramLocalParameter4fvARB = (glProgramLocalParameter4fvARBPROC)((intptr_t)function_pointer);
glProgramLocalParameter4fvARB(target, index, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBProgram_nglProgramLocalParameter4dvARB(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) {
const GLdouble *params_address = ((const GLdouble *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glProgramLocalParameter4dvARBPROC glProgramLocalParameter4dvARB = (glProgramLocalParameter4dvARBPROC)((intptr_t)function_pointer);
glProgramLocalParameter4dvARB(target, index, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBProgram_nglGetProgramEnvParameterfvARB(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetProgramEnvParameterfvARBPROC glGetProgramEnvParameterfvARB = (glGetProgramEnvParameterfvARBPROC)((intptr_t)function_pointer);
glGetProgramEnvParameterfvARB(target, index, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBProgram_nglGetProgramEnvParameterdvARB(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) {
GLdouble *params_address = ((GLdouble *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetProgramEnvParameterdvARBPROC glGetProgramEnvParameterdvARB = (glGetProgramEnvParameterdvARBPROC)((intptr_t)function_pointer);
glGetProgramEnvParameterdvARB(target, index, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBProgram_nglGetProgramLocalParameterfvARB(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetProgramLocalParameterfvARBPROC glGetProgramLocalParameterfvARB = (glGetProgramLocalParameterfvARBPROC)((intptr_t)function_pointer);
glGetProgramLocalParameterfvARB(target, index, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBProgram_nglGetProgramLocalParameterdvARB(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) {
GLdouble *params_address = ((GLdouble *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetProgramLocalParameterdvARBPROC glGetProgramLocalParameterdvARB = (glGetProgramLocalParameterdvARBPROC)((intptr_t)function_pointer);
glGetProgramLocalParameterdvARB(target, index, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBProgram_nglGetProgramivARB(JNIEnv *env, jclass clazz, jint target, jint parameterName, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetProgramivARBPROC glGetProgramivARB = (glGetProgramivARBPROC)((intptr_t)function_pointer);
glGetProgramivARB(target, parameterName, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBProgram_nglGetProgramStringARB(JNIEnv *env, jclass clazz, jint target, jint parameterName, jobject paramString, jint paramString_position, jlong function_pointer) {
GLvoid *paramString_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, paramString)) + paramString_position));
glGetProgramStringARBPROC glGetProgramStringARB = (glGetProgramStringARBPROC)((intptr_t)function_pointer);
glGetProgramStringARB(target, parameterName, paramString_address);
}
JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_ARBProgram_nglIsProgramARB(JNIEnv *env, jclass clazz, jint program, jlong function_pointer) {
glIsProgramARBPROC glIsProgramARB = (glIsProgramARBPROC)((intptr_t)function_pointer);
GLboolean __result = glIsProgramARB(program);
return __result;
}

271
src/native/generated/org_lwjgl_opengl_ARBShaderObjects.c
View file

@ -1,271 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glDeleteObjectARBPROC) (GLhandleARB obj);
typedef GLhandleARB (APIENTRY *glGetHandleARBPROC) (GLenum pname);
typedef void (APIENTRY *glDetachObjectARBPROC) (GLhandleARB containerObj, GLhandleARB attachedObj);
typedef GLhandleARB (APIENTRY *glCreateShaderObjectARBPROC) (GLenum shaderType);
typedef void (APIENTRY *glShaderSourceARBPROC) (GLhandleARB shader, GLsizei count, const GLcharARB ** string, const GLint* length);
typedef void (APIENTRY *glCompileShaderARBPROC) (GLhandleARB shaderObj);
typedef GLhandleARB (APIENTRY *glCreateProgramObjectARBPROC) ();
typedef void (APIENTRY *glAttachObjectARBPROC) (GLhandleARB containerObj, GLhandleARB obj);
typedef void (APIENTRY *glLinkProgramARBPROC) (GLhandleARB programObj);
typedef void (APIENTRY *glUseProgramObjectARBPROC) (GLhandleARB programObj);
typedef void (APIENTRY *glValidateProgramARBPROC) (GLhandleARB programObj);
typedef void (APIENTRY *glUniform1fARBPROC) (GLint location, GLfloat v0);
typedef void (APIENTRY *glUniform2fARBPROC) (GLint location, GLfloat v0, GLfloat v1);
typedef void (APIENTRY *glUniform3fARBPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
typedef void (APIENTRY *glUniform4fARBPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
typedef void (APIENTRY *glUniform1iARBPROC) (GLint location, GLint v0);
typedef void (APIENTRY *glUniform2iARBPROC) (GLint location, GLint v0, GLint v1);
typedef void (APIENTRY *glUniform3iARBPROC) (GLint location, GLint v0, GLint v1, GLint v2);
typedef void (APIENTRY *glUniform4iARBPROC) (GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
typedef void (APIENTRY *glUniform1fvARBPROC) (GLint location, GLsizei count, GLfloat * values);
typedef void (APIENTRY *glUniform2fvARBPROC) (GLint location, GLsizei count, GLfloat * values);
typedef void (APIENTRY *glUniform3fvARBPROC) (GLint location, GLsizei count, GLfloat * values);
typedef void (APIENTRY *glUniform4fvARBPROC) (GLint location, GLsizei count, GLfloat * values);
typedef void (APIENTRY *glUniform1ivARBPROC) (GLint location, GLsizei count, GLint * values);
typedef void (APIENTRY *glUniform2ivARBPROC) (GLint location, GLsizei count, GLint * values);
typedef void (APIENTRY *glUniform3ivARBPROC) (GLint location, GLsizei count, GLint * values);
typedef void (APIENTRY *glUniform4ivARBPROC) (GLint location, GLsizei count, GLint * values);
typedef void (APIENTRY *glUniformMatrix2fvARBPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat * matrices);
typedef void (APIENTRY *glUniformMatrix3fvARBPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat * matrices);
typedef void (APIENTRY *glUniformMatrix4fvARBPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat * matrices);
typedef void (APIENTRY *glGetObjectParameterfvARBPROC) (GLhandleARB obj, GLenum pname, GLfloat * params);
typedef void (APIENTRY *glGetObjectParameterivARBPROC) (GLhandleARB obj, GLenum pname, GLint * params);
typedef void (APIENTRY *glGetInfoLogARBPROC) (GLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * infoLog);
typedef void (APIENTRY *glGetAttachedObjectsARBPROC) (GLhandleARB containerObj, GLsizei maxCount, GLsizei * count, GLhandleARB * obj);
typedef GLint (APIENTRY *glGetUniformLocationARBPROC) (GLhandleARB programObj, const GLcharARB * name);
typedef void (APIENTRY *glGetActiveUniformARBPROC) (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei * length, GLint * size, GLenum * type, GLcharARB * name);
typedef void (APIENTRY *glGetUniformfvARBPROC) (GLhandleARB programObj, GLint location, GLfloat * params);
typedef void (APIENTRY *glGetUniformivARBPROC) (GLhandleARB programObj, GLint location, GLint * params);
typedef void (APIENTRY *glGetShaderSourceARBPROC) (GLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * source);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglDeleteObjectARB(JNIEnv *env, jclass clazz, jint obj, jlong function_pointer) {
glDeleteObjectARBPROC glDeleteObjectARB = (glDeleteObjectARBPROC)((intptr_t)function_pointer);
glDeleteObjectARB(obj);
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglGetHandleARB(JNIEnv *env, jclass clazz, jint pname, jlong function_pointer) {
glGetHandleARBPROC glGetHandleARB = (glGetHandleARBPROC)((intptr_t)function_pointer);
GLhandleARB __result = glGetHandleARB(pname);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglDetachObjectARB(JNIEnv *env, jclass clazz, jint containerObj, jint attachedObj, jlong function_pointer) {
glDetachObjectARBPROC glDetachObjectARB = (glDetachObjectARBPROC)((intptr_t)function_pointer);
glDetachObjectARB(containerObj, attachedObj);
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglCreateShaderObjectARB(JNIEnv *env, jclass clazz, jint shaderType, jlong function_pointer) {
glCreateShaderObjectARBPROC glCreateShaderObjectARB = (glCreateShaderObjectARBPROC)((intptr_t)function_pointer);
GLhandleARB __result = glCreateShaderObjectARB(shaderType);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglShaderSourceARB(JNIEnv *env, jclass clazz, jint shader, jint count, jobject string, jint string_position, jint length, jlong function_pointer) {
const GLcharARB *string_address = ((const GLcharARB *)(*env)->GetDirectBufferAddress(env, string)) + string_position;
glShaderSourceARBPROC glShaderSourceARB = (glShaderSourceARBPROC)((intptr_t)function_pointer);
glShaderSourceARB(shader, count, (const GLcharARB **)&string_address, (const GLint*)&length);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglCompileShaderARB(JNIEnv *env, jclass clazz, jint shaderObj, jlong function_pointer) {
glCompileShaderARBPROC glCompileShaderARB = (glCompileShaderARBPROC)((intptr_t)function_pointer);
glCompileShaderARB(shaderObj);
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglCreateProgramObjectARB(JNIEnv *env, jclass clazz, jlong function_pointer) {
glCreateProgramObjectARBPROC glCreateProgramObjectARB = (glCreateProgramObjectARBPROC)((intptr_t)function_pointer);
GLhandleARB __result = glCreateProgramObjectARB();
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglAttachObjectARB(JNIEnv *env, jclass clazz, jint containerObj, jint obj, jlong function_pointer) {
glAttachObjectARBPROC glAttachObjectARB = (glAttachObjectARBPROC)((intptr_t)function_pointer);
glAttachObjectARB(containerObj, obj);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglLinkProgramARB(JNIEnv *env, jclass clazz, jint programObj, jlong function_pointer) {
glLinkProgramARBPROC glLinkProgramARB = (glLinkProgramARBPROC)((intptr_t)function_pointer);
glLinkProgramARB(programObj);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUseProgramObjectARB(JNIEnv *env, jclass clazz, jint programObj, jlong function_pointer) {
glUseProgramObjectARBPROC glUseProgramObjectARB = (glUseProgramObjectARBPROC)((intptr_t)function_pointer);
glUseProgramObjectARB(programObj);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglValidateProgramARB(JNIEnv *env, jclass clazz, jint programObj, jlong function_pointer) {
glValidateProgramARBPROC glValidateProgramARB = (glValidateProgramARBPROC)((intptr_t)function_pointer);
glValidateProgramARB(programObj);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniform1fARB(JNIEnv *env, jclass clazz, jint location, jfloat v0, jlong function_pointer) {
glUniform1fARBPROC glUniform1fARB = (glUniform1fARBPROC)((intptr_t)function_pointer);
glUniform1fARB(location, v0);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniform2fARB(JNIEnv *env, jclass clazz, jint location, jfloat v0, jfloat v1, jlong function_pointer) {
glUniform2fARBPROC glUniform2fARB = (glUniform2fARBPROC)((intptr_t)function_pointer);
glUniform2fARB(location, v0, v1);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniform3fARB(JNIEnv *env, jclass clazz, jint location, jfloat v0, jfloat v1, jfloat v2, jlong function_pointer) {
glUniform3fARBPROC glUniform3fARB = (glUniform3fARBPROC)((intptr_t)function_pointer);
glUniform3fARB(location, v0, v1, v2);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniform4fARB(JNIEnv *env, jclass clazz, jint location, jfloat v0, jfloat v1, jfloat v2, jfloat v3, jlong function_pointer) {
glUniform4fARBPROC glUniform4fARB = (glUniform4fARBPROC)((intptr_t)function_pointer);
glUniform4fARB(location, v0, v1, v2, v3);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniform1iARB(JNIEnv *env, jclass clazz, jint location, jint v0, jlong function_pointer) {
glUniform1iARBPROC glUniform1iARB = (glUniform1iARBPROC)((intptr_t)function_pointer);
glUniform1iARB(location, v0);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniform2iARB(JNIEnv *env, jclass clazz, jint location, jint v0, jint v1, jlong function_pointer) {
glUniform2iARBPROC glUniform2iARB = (glUniform2iARBPROC)((intptr_t)function_pointer);
glUniform2iARB(location, v0, v1);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniform3iARB(JNIEnv *env, jclass clazz, jint location, jint v0, jint v1, jint v2, jlong function_pointer) {
glUniform3iARBPROC glUniform3iARB = (glUniform3iARBPROC)((intptr_t)function_pointer);
glUniform3iARB(location, v0, v1, v2);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniform4iARB(JNIEnv *env, jclass clazz, jint location, jint v0, jint v1, jint v2, jint v3, jlong function_pointer) {
glUniform4iARBPROC glUniform4iARB = (glUniform4iARBPROC)((intptr_t)function_pointer);
glUniform4iARB(location, v0, v1, v2, v3);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniform1fvARB(JNIEnv *env, jclass clazz, jint location, jint count, jobject values, jint values_position, jlong function_pointer) {
GLfloat *values_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, values)) + values_position;
glUniform1fvARBPROC glUniform1fvARB = (glUniform1fvARBPROC)((intptr_t)function_pointer);
glUniform1fvARB(location, count, values_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniform2fvARB(JNIEnv *env, jclass clazz, jint location, jint count, jobject values, jint values_position, jlong function_pointer) {
GLfloat *values_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, values)) + values_position;
glUniform2fvARBPROC glUniform2fvARB = (glUniform2fvARBPROC)((intptr_t)function_pointer);
glUniform2fvARB(location, count, values_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniform3fvARB(JNIEnv *env, jclass clazz, jint location, jint count, jobject values, jint values_position, jlong function_pointer) {
GLfloat *values_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, values)) + values_position;
glUniform3fvARBPROC glUniform3fvARB = (glUniform3fvARBPROC)((intptr_t)function_pointer);
glUniform3fvARB(location, count, values_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniform4fvARB(JNIEnv *env, jclass clazz, jint location, jint count, jobject values, jint values_position, jlong function_pointer) {
GLfloat *values_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, values)) + values_position;
glUniform4fvARBPROC glUniform4fvARB = (glUniform4fvARBPROC)((intptr_t)function_pointer);
glUniform4fvARB(location, count, values_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniform1ivARB(JNIEnv *env, jclass clazz, jint location, jint count, jobject values, jint values_position, jlong function_pointer) {
GLint *values_address = ((GLint *)(*env)->GetDirectBufferAddress(env, values)) + values_position;
glUniform1ivARBPROC glUniform1ivARB = (glUniform1ivARBPROC)((intptr_t)function_pointer);
glUniform1ivARB(location, count, values_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniform2ivARB(JNIEnv *env, jclass clazz, jint location, jint count, jobject values, jint values_position, jlong function_pointer) {
GLint *values_address = ((GLint *)(*env)->GetDirectBufferAddress(env, values)) + values_position;
glUniform2ivARBPROC glUniform2ivARB = (glUniform2ivARBPROC)((intptr_t)function_pointer);
glUniform2ivARB(location, count, values_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniform3ivARB(JNIEnv *env, jclass clazz, jint location, jint count, jobject values, jint values_position, jlong function_pointer) {
GLint *values_address = ((GLint *)(*env)->GetDirectBufferAddress(env, values)) + values_position;
glUniform3ivARBPROC glUniform3ivARB = (glUniform3ivARBPROC)((intptr_t)function_pointer);
glUniform3ivARB(location, count, values_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniform4ivARB(JNIEnv *env, jclass clazz, jint location, jint count, jobject values, jint values_position, jlong function_pointer) {
GLint *values_address = ((GLint *)(*env)->GetDirectBufferAddress(env, values)) + values_position;
glUniform4ivARBPROC glUniform4ivARB = (glUniform4ivARBPROC)((intptr_t)function_pointer);
glUniform4ivARB(location, count, values_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniformMatrix2fvARB(JNIEnv *env, jclass clazz, jint location, jint count, jboolean transpose, jobject matrices, jint matrices_position, jlong function_pointer) {
GLfloat *matrices_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, matrices)) + matrices_position;
glUniformMatrix2fvARBPROC glUniformMatrix2fvARB = (glUniformMatrix2fvARBPROC)((intptr_t)function_pointer);
glUniformMatrix2fvARB(location, count, transpose, matrices_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniformMatrix3fvARB(JNIEnv *env, jclass clazz, jint location, jint count, jboolean transpose, jobject matrices, jint matrices_position, jlong function_pointer) {
GLfloat *matrices_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, matrices)) + matrices_position;
glUniformMatrix3fvARBPROC glUniformMatrix3fvARB = (glUniformMatrix3fvARBPROC)((intptr_t)function_pointer);
glUniformMatrix3fvARB(location, count, transpose, matrices_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglUniformMatrix4fvARB(JNIEnv *env, jclass clazz, jint location, jint count, jboolean transpose, jobject matrices, jint matrices_position, jlong function_pointer) {
GLfloat *matrices_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, matrices)) + matrices_position;
glUniformMatrix4fvARBPROC glUniformMatrix4fvARB = (glUniformMatrix4fvARBPROC)((intptr_t)function_pointer);
glUniformMatrix4fvARB(location, count, transpose, matrices_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglGetObjectParameterfvARB(JNIEnv *env, jclass clazz, jint obj, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetObjectParameterfvARBPROC glGetObjectParameterfvARB = (glGetObjectParameterfvARBPROC)((intptr_t)function_pointer);
glGetObjectParameterfvARB(obj, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglGetObjectParameterivARB(JNIEnv *env, jclass clazz, jint obj, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetObjectParameterivARBPROC glGetObjectParameterivARB = (glGetObjectParameterivARBPROC)((intptr_t)function_pointer);
glGetObjectParameterivARB(obj, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglGetInfoLogARB(JNIEnv *env, jclass clazz, jint obj, jint maxLength, jobject length, jint length_position, jobject infoLog, jint infoLog_position, jlong function_pointer) {
GLsizei *length_address = ((GLsizei *)safeGetBufferAddress(env, length)) + length_position;
GLcharARB *infoLog_address = ((GLcharARB *)(*env)->GetDirectBufferAddress(env, infoLog)) + infoLog_position;
glGetInfoLogARBPROC glGetInfoLogARB = (glGetInfoLogARBPROC)((intptr_t)function_pointer);
glGetInfoLogARB(obj, maxLength, length_address, infoLog_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglGetAttachedObjectsARB(JNIEnv *env, jclass clazz, jint containerObj, jint maxCount, jobject count, jint count_position, jobject obj, jint obj_position, jlong function_pointer) {
GLsizei *count_address = ((GLsizei *)safeGetBufferAddress(env, count)) + count_position;
GLhandleARB *obj_address = ((GLhandleARB *)(*env)->GetDirectBufferAddress(env, obj)) + obj_position;
glGetAttachedObjectsARBPROC glGetAttachedObjectsARB = (glGetAttachedObjectsARBPROC)((intptr_t)function_pointer);
glGetAttachedObjectsARB(containerObj, maxCount, count_address, obj_address);
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglGetUniformLocationARB(JNIEnv *env, jclass clazz, jint programObj, jobject name, jint name_position, jlong function_pointer) {
const GLcharARB *name_address = ((const GLcharARB *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
glGetUniformLocationARBPROC glGetUniformLocationARB = (glGetUniformLocationARBPROC)((intptr_t)function_pointer);
GLint __result = glGetUniformLocationARB(programObj, name_address);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglGetActiveUniformARB(JNIEnv *env, jclass clazz, jint programObj, jint index, jint maxLength, jobject length, jint length_position, jobject size, jint size_position, jobject type, jint type_position, jobject name, jint name_position, jlong function_pointer) {
GLsizei *length_address = ((GLsizei *)safeGetBufferAddress(env, length)) + length_position;
GLint *size_address = ((GLint *)(*env)->GetDirectBufferAddress(env, size)) + size_position;
GLenum *type_address = ((GLenum *)(*env)->GetDirectBufferAddress(env, type)) + type_position;
GLcharARB *name_address = ((GLcharARB *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
glGetActiveUniformARBPROC glGetActiveUniformARB = (glGetActiveUniformARBPROC)((intptr_t)function_pointer);
glGetActiveUniformARB(programObj, index, maxLength, length_address, size_address, type_address, name_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglGetUniformfvARB(JNIEnv *env, jclass clazz, jint programObj, jint location, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetUniformfvARBPROC glGetUniformfvARB = (glGetUniformfvARBPROC)((intptr_t)function_pointer);
glGetUniformfvARB(programObj, location, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglGetUniformivARB(JNIEnv *env, jclass clazz, jint programObj, jint location, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetUniformivARBPROC glGetUniformivARB = (glGetUniformivARBPROC)((intptr_t)function_pointer);
glGetUniformivARB(programObj, location, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglGetShaderSourceARB(JNIEnv *env, jclass clazz, jint obj, jint maxLength, jobject length, jint length_position, jobject source, jint source_position, jlong function_pointer) {
GLsizei *length_address = ((GLsizei *)safeGetBufferAddress(env, length)) + length_position;
GLcharARB *source_address = ((GLcharARB *)(*env)->GetDirectBufferAddress(env, source)) + source_position;
glGetShaderSourceARBPROC glGetShaderSourceARB = (glGetShaderSourceARBPROC)((intptr_t)function_pointer);
glGetShaderSourceARB(obj, maxLength, length_address, source_address);
}

97
src/native/generated/org_lwjgl_opengl_ARBTextureCompression.c
View file

@ -1,97 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glCompressedTexImage1DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * pData);
typedef void (APIENTRY *glCompressedTexImage2DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * pData);
typedef void (APIENTRY *glCompressedTexImage3DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * pData);
typedef void (APIENTRY *glCompressedTexSubImage1DARBPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * pData);
typedef void (APIENTRY *glCompressedTexSubImage2DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * pData);
typedef void (APIENTRY *glCompressedTexSubImage3DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * pData);
typedef void (APIENTRY *glGetCompressedTexImageARBPROC) (GLenum target, GLint lod, GLvoid * pImg);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBTextureCompression_nglCompressedTexImage1DARB(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint border, jint imageSize, jobject pData, jint pData_position, jlong function_pointer) {
const GLvoid *pData_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pData)) + pData_position));
glCompressedTexImage1DARBPROC glCompressedTexImage1DARB = (glCompressedTexImage1DARBPROC)((intptr_t)function_pointer);
glCompressedTexImage1DARB(target, level, internalformat, width, border, imageSize, pData_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBTextureCompression_nglCompressedTexImage1DARBBO(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint border, jint imageSize, jlong pData_buffer_offset, jlong function_pointer) {
const GLvoid *pData_address = ((const GLvoid *)offsetToPointer(pData_buffer_offset));
glCompressedTexImage1DARBPROC glCompressedTexImage1DARB = (glCompressedTexImage1DARBPROC)((intptr_t)function_pointer);
glCompressedTexImage1DARB(target, level, internalformat, width, border, imageSize, pData_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBTextureCompression_nglCompressedTexImage2DARB(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint imageSize, jobject pData, jint pData_position, jlong function_pointer) {
const GLvoid *pData_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pData)) + pData_position));
glCompressedTexImage2DARBPROC glCompressedTexImage2DARB = (glCompressedTexImage2DARBPROC)((intptr_t)function_pointer);
glCompressedTexImage2DARB(target, level, internalformat, width, height, border, imageSize, pData_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBTextureCompression_nglCompressedTexImage2DARBBO(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint imageSize, jlong pData_buffer_offset, jlong function_pointer) {
const GLvoid *pData_address = ((const GLvoid *)offsetToPointer(pData_buffer_offset));
glCompressedTexImage2DARBPROC glCompressedTexImage2DARB = (glCompressedTexImage2DARBPROC)((intptr_t)function_pointer);
glCompressedTexImage2DARB(target, level, internalformat, width, height, border, imageSize, pData_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBTextureCompression_nglCompressedTexImage3DARB(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint height, jint depth, jint border, jint imageSize, jobject pData, jint pData_position, jlong function_pointer) {
const GLvoid *pData_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pData)) + pData_position));
glCompressedTexImage3DARBPROC glCompressedTexImage3DARB = (glCompressedTexImage3DARBPROC)((intptr_t)function_pointer);
glCompressedTexImage3DARB(target, level, internalformat, width, height, depth, border, imageSize, pData_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBTextureCompression_nglCompressedTexImage3DARBBO(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint height, jint depth, jint border, jint imageSize, jlong pData_buffer_offset, jlong function_pointer) {
const GLvoid *pData_address = ((const GLvoid *)offsetToPointer(pData_buffer_offset));
glCompressedTexImage3DARBPROC glCompressedTexImage3DARB = (glCompressedTexImage3DARBPROC)((intptr_t)function_pointer);
glCompressedTexImage3DARB(target, level, internalformat, width, height, depth, border, imageSize, pData_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBTextureCompression_nglCompressedTexSubImage1DARB(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint width, jint format, jint imageSize, jobject pData, jint pData_position, jlong function_pointer) {
const GLvoid *pData_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pData)) + pData_position));
glCompressedTexSubImage1DARBPROC glCompressedTexSubImage1DARB = (glCompressedTexSubImage1DARBPROC)((intptr_t)function_pointer);
glCompressedTexSubImage1DARB(target, level, xoffset, width, format, imageSize, pData_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBTextureCompression_nglCompressedTexSubImage1DARBBO(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint width, jint format, jint imageSize, jlong pData_buffer_offset, jlong function_pointer) {
const GLvoid *pData_address = ((const GLvoid *)offsetToPointer(pData_buffer_offset));
glCompressedTexSubImage1DARBPROC glCompressedTexSubImage1DARB = (glCompressedTexSubImage1DARBPROC)((intptr_t)function_pointer);
glCompressedTexSubImage1DARB(target, level, xoffset, width, format, imageSize, pData_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBTextureCompression_nglCompressedTexSubImage2DARB(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint yoffset, jint width, jint height, jint format, jint imageSize, jobject pData, jint pData_position, jlong function_pointer) {
const GLvoid *pData_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pData)) + pData_position));
glCompressedTexSubImage2DARBPROC glCompressedTexSubImage2DARB = (glCompressedTexSubImage2DARBPROC)((intptr_t)function_pointer);
glCompressedTexSubImage2DARB(target, level, xoffset, yoffset, width, height, format, imageSize, pData_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBTextureCompression_nglCompressedTexSubImage2DARBBO(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint yoffset, jint width, jint height, jint format, jint imageSize, jlong pData_buffer_offset, jlong function_pointer) {
const GLvoid *pData_address = ((const GLvoid *)offsetToPointer(pData_buffer_offset));
glCompressedTexSubImage2DARBPROC glCompressedTexSubImage2DARB = (glCompressedTexSubImage2DARBPROC)((intptr_t)function_pointer);
glCompressedTexSubImage2DARB(target, level, xoffset, yoffset, width, height, format, imageSize, pData_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBTextureCompression_nglCompressedTexSubImage3DARB(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint yoffset, jint zoffset, jint width, jint height, jint depth, jint format, jint imageSize, jobject pData, jint pData_position, jlong function_pointer) {
const GLvoid *pData_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pData)) + pData_position));
glCompressedTexSubImage3DARBPROC glCompressedTexSubImage3DARB = (glCompressedTexSubImage3DARBPROC)((intptr_t)function_pointer);
glCompressedTexSubImage3DARB(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pData_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBTextureCompression_nglCompressedTexSubImage3DARBBO(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint yoffset, jint zoffset, jint width, jint height, jint depth, jint format, jint imageSize, jlong pData_buffer_offset, jlong function_pointer) {
const GLvoid *pData_address = ((const GLvoid *)offsetToPointer(pData_buffer_offset));
glCompressedTexSubImage3DARBPROC glCompressedTexSubImage3DARB = (glCompressedTexSubImage3DARBPROC)((intptr_t)function_pointer);
glCompressedTexSubImage3DARB(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pData_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBTextureCompression_nglGetCompressedTexImageARB(JNIEnv *env, jclass clazz, jint target, jint lod, jobject pImg, jint pImg_position, jlong function_pointer) {
GLvoid *pImg_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pImg)) + pImg_position));
glGetCompressedTexImageARBPROC glGetCompressedTexImageARB = (glGetCompressedTexImageARBPROC)((intptr_t)function_pointer);
glGetCompressedTexImageARB(target, lod, pImg_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBTextureCompression_nglGetCompressedTexImageARBBO(JNIEnv *env, jclass clazz, jint target, jint lod, jlong pImg_buffer_offset, jlong function_pointer) {
GLvoid *pImg_address = ((GLvoid *)offsetToPointer(pImg_buffer_offset));
glGetCompressedTexImageARBPROC glGetCompressedTexImageARB = (glGetCompressedTexImageARBPROC)((intptr_t)function_pointer);
glGetCompressedTexImageARB(target, lod, pImg_address);
}

20
src/native/generated/org_lwjgl_opengl_ARBTransposeMatrix.c
View file

@ -1,20 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glLoadTransposeMatrixfARBPROC) (const GLfloat * pfMtx);
typedef void (APIENTRY *glMultTransposeMatrixfARBPROC) (const GLfloat * pfMtx);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBTransposeMatrix_nglLoadTransposeMatrixfARB(JNIEnv *env, jclass clazz, jobject pfMtx, jint pfMtx_position, jlong function_pointer) {
const GLfloat *pfMtx_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, pfMtx)) + pfMtx_position;
glLoadTransposeMatrixfARBPROC glLoadTransposeMatrixfARB = (glLoadTransposeMatrixfARBPROC)((intptr_t)function_pointer);
glLoadTransposeMatrixfARB(pfMtx_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBTransposeMatrix_nglMultTransposeMatrixfARB(JNIEnv *env, jclass clazz, jobject pfMtx, jint pfMtx_position, jlong function_pointer) {
const GLfloat *pfMtx_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, pfMtx)) + pfMtx_position;
glMultTransposeMatrixfARBPROC glMultTransposeMatrixfARB = (glMultTransposeMatrixfARBPROC)((intptr_t)function_pointer);
glMultTransposeMatrixfARB(pfMtx_address);
}

81
src/native/generated/org_lwjgl_opengl_ARBVertexBlend.c
View file

@ -1,81 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glWeightbvARBPROC) (GLint size, GLbyte * pWeights);
typedef void (APIENTRY *glWeightsvARBPROC) (GLint size, GLshort * pWeights);
typedef void (APIENTRY *glWeightivARBPROC) (GLint size, GLint * pWeights);
typedef void (APIENTRY *glWeightfvARBPROC) (GLint size, GLfloat * pWeights);
typedef void (APIENTRY *glWeightdvARBPROC) (GLint size, GLdouble * pWeights);
typedef void (APIENTRY *glWeightubvARBPROC) (GLint size, GLubyte * pWeights);
typedef void (APIENTRY *glWeightusvARBPROC) (GLint size, GLushort * pWeights);
typedef void (APIENTRY *glWeightuivARBPROC) (GLint size, GLuint * pWeights);
typedef void (APIENTRY *glWeightPointerARBPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid * pPointer);
typedef void (APIENTRY *glVertexBlendARBPROC) (GLint count);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightbvARB(JNIEnv *env, jclass clazz, jint size, jobject pWeights, jint pWeights_position, jlong function_pointer) {
GLbyte *pWeights_address = ((GLbyte *)(*env)->GetDirectBufferAddress(env, pWeights)) + pWeights_position;
glWeightbvARBPROC glWeightbvARB = (glWeightbvARBPROC)((intptr_t)function_pointer);
glWeightbvARB(size, pWeights_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightsvARB(JNIEnv *env, jclass clazz, jint size, jobject pWeights, jint pWeights_position, jlong function_pointer) {
GLshort *pWeights_address = ((GLshort *)(*env)->GetDirectBufferAddress(env, pWeights)) + pWeights_position;
glWeightsvARBPROC glWeightsvARB = (glWeightsvARBPROC)((intptr_t)function_pointer);
glWeightsvARB(size, pWeights_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightivARB(JNIEnv *env, jclass clazz, jint size, jobject pWeights, jint pWeights_position, jlong function_pointer) {
GLint *pWeights_address = ((GLint *)(*env)->GetDirectBufferAddress(env, pWeights)) + pWeights_position;
glWeightivARBPROC glWeightivARB = (glWeightivARBPROC)((intptr_t)function_pointer);
glWeightivARB(size, pWeights_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightfvARB(JNIEnv *env, jclass clazz, jint size, jobject pWeights, jint pWeights_position, jlong function_pointer) {
GLfloat *pWeights_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, pWeights)) + pWeights_position;
glWeightfvARBPROC glWeightfvARB = (glWeightfvARBPROC)((intptr_t)function_pointer);
glWeightfvARB(size, pWeights_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightdvARB(JNIEnv *env, jclass clazz, jint size, jobject pWeights, jint pWeights_position, jlong function_pointer) {
GLdouble *pWeights_address = ((GLdouble *)(*env)->GetDirectBufferAddress(env, pWeights)) + pWeights_position;
glWeightdvARBPROC glWeightdvARB = (glWeightdvARBPROC)((intptr_t)function_pointer);
glWeightdvARB(size, pWeights_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightubvARB(JNIEnv *env, jclass clazz, jint size, jobject pWeights, jint pWeights_position, jlong function_pointer) {
GLubyte *pWeights_address = ((GLubyte *)(*env)->GetDirectBufferAddress(env, pWeights)) + pWeights_position;
glWeightubvARBPROC glWeightubvARB = (glWeightubvARBPROC)((intptr_t)function_pointer);
glWeightubvARB(size, pWeights_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightusvARB(JNIEnv *env, jclass clazz, jint size, jobject pWeights, jint pWeights_position, jlong function_pointer) {
GLushort *pWeights_address = ((GLushort *)(*env)->GetDirectBufferAddress(env, pWeights)) + pWeights_position;
glWeightusvARBPROC glWeightusvARB = (glWeightusvARBPROC)((intptr_t)function_pointer);
glWeightusvARB(size, pWeights_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightuivARB(JNIEnv *env, jclass clazz, jint size, jobject pWeights, jint pWeights_position, jlong function_pointer) {
GLuint *pWeights_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, pWeights)) + pWeights_position;
glWeightuivARBPROC glWeightuivARB = (glWeightuivARBPROC)((intptr_t)function_pointer);
glWeightuivARB(size, pWeights_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightPointerARB(JNIEnv *env, jclass clazz, jint size, jint type, jint stride, jobject pPointer, jint pPointer_position, jlong function_pointer) {
const GLvoid *pPointer_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pPointer)) + pPointer_position));
glWeightPointerARBPROC glWeightPointerARB = (glWeightPointerARBPROC)((intptr_t)function_pointer);
glWeightPointerARB(size, type, stride, pPointer_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightPointerARBBO(JNIEnv *env, jclass clazz, jint size, jint type, jint stride, jlong pPointer_buffer_offset, jlong function_pointer) {
const GLvoid *pPointer_address = ((const GLvoid *)offsetToPointer(pPointer_buffer_offset));
glWeightPointerARBPROC glWeightPointerARB = (glWeightPointerARBPROC)((intptr_t)function_pointer);
glWeightPointerARB(size, type, stride, pPointer_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglVertexBlendARB(JNIEnv *env, jclass clazz, jint count, jlong function_pointer) {
glVertexBlendARBPROC glVertexBlendARB = (glVertexBlendARBPROC)((intptr_t)function_pointer);
glVertexBlendARB(count);
}

138
src/native/generated/org_lwjgl_opengl_ARBVertexProgram.c
View file

@ -1,138 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glVertexAttrib1sARBPROC) (GLuint index, GLshort x);
typedef void (APIENTRY *glVertexAttrib1fARBPROC) (GLuint index, GLfloat x);
typedef void (APIENTRY *glVertexAttrib1dARBPROC) (GLuint index, GLdouble x);
typedef void (APIENTRY *glVertexAttrib2sARBPROC) (GLuint index, GLshort x, GLshort y);
typedef void (APIENTRY *glVertexAttrib2fARBPROC) (GLuint index, GLfloat x, GLfloat y);
typedef void (APIENTRY *glVertexAttrib2dARBPROC) (GLuint index, GLdouble x, GLdouble y);
typedef void (APIENTRY *glVertexAttrib3sARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z);
typedef void (APIENTRY *glVertexAttrib3fARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z);
typedef void (APIENTRY *glVertexAttrib3dARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z);
typedef void (APIENTRY *glVertexAttrib4sARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
typedef void (APIENTRY *glVertexAttrib4fARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
typedef void (APIENTRY *glVertexAttrib4dARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
typedef void (APIENTRY *glVertexAttrib4NubARBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
typedef void (APIENTRY *glVertexAttribPointerARBPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * buffer);
typedef void (APIENTRY *glEnableVertexAttribArrayARBPROC) (GLuint index);
typedef void (APIENTRY *glDisableVertexAttribArrayARBPROC) (GLuint index);
typedef void (APIENTRY *glGetVertexAttribfvARBPROC) (GLuint index, GLenum pname, GLfloat * params);
typedef void (APIENTRY *glGetVertexAttribdvARBPROC) (GLuint index, GLenum pname, GLdouble * params);
typedef void (APIENTRY *glGetVertexAttribivARBPROC) (GLuint index, GLenum pname, GLint * params);
typedef void (APIENTRY *glGetVertexAttribPointervARBPROC) (GLuint index, GLenum pname, GLvoid ** result);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttrib1sARB(JNIEnv *env, jclass clazz, jint index, jshort x, jlong function_pointer) {
glVertexAttrib1sARBPROC glVertexAttrib1sARB = (glVertexAttrib1sARBPROC)((intptr_t)function_pointer);
glVertexAttrib1sARB(index, x);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttrib1fARB(JNIEnv *env, jclass clazz, jint index, jfloat x, jlong function_pointer) {
glVertexAttrib1fARBPROC glVertexAttrib1fARB = (glVertexAttrib1fARBPROC)((intptr_t)function_pointer);
glVertexAttrib1fARB(index, x);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttrib1dARB(JNIEnv *env, jclass clazz, jint index, jdouble x, jlong function_pointer) {
glVertexAttrib1dARBPROC glVertexAttrib1dARB = (glVertexAttrib1dARBPROC)((intptr_t)function_pointer);
glVertexAttrib1dARB(index, x);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttrib2sARB(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jlong function_pointer) {
glVertexAttrib2sARBPROC glVertexAttrib2sARB = (glVertexAttrib2sARBPROC)((intptr_t)function_pointer);
glVertexAttrib2sARB(index, x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttrib2fARB(JNIEnv *env, jclass clazz, jint index, jfloat x, jfloat y, jlong function_pointer) {
glVertexAttrib2fARBPROC glVertexAttrib2fARB = (glVertexAttrib2fARBPROC)((intptr_t)function_pointer);
glVertexAttrib2fARB(index, x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttrib2dARB(JNIEnv *env, jclass clazz, jint index, jdouble x, jdouble y, jlong function_pointer) {
glVertexAttrib2dARBPROC glVertexAttrib2dARB = (glVertexAttrib2dARBPROC)((intptr_t)function_pointer);
glVertexAttrib2dARB(index, x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttrib3sARB(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jshort z, jlong function_pointer) {
glVertexAttrib3sARBPROC glVertexAttrib3sARB = (glVertexAttrib3sARBPROC)((intptr_t)function_pointer);
glVertexAttrib3sARB(index, x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttrib3fARB(JNIEnv *env, jclass clazz, jint index, jfloat x, jfloat y, jfloat z, jlong function_pointer) {
glVertexAttrib3fARBPROC glVertexAttrib3fARB = (glVertexAttrib3fARBPROC)((intptr_t)function_pointer);
glVertexAttrib3fARB(index, x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttrib3dARB(JNIEnv *env, jclass clazz, jint index, jdouble x, jdouble y, jdouble z, jlong function_pointer) {
glVertexAttrib3dARBPROC glVertexAttrib3dARB = (glVertexAttrib3dARBPROC)((intptr_t)function_pointer);
glVertexAttrib3dARB(index, x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttrib4sARB(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jshort z, jshort w, jlong function_pointer) {
glVertexAttrib4sARBPROC glVertexAttrib4sARB = (glVertexAttrib4sARBPROC)((intptr_t)function_pointer);
glVertexAttrib4sARB(index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttrib4fARB(JNIEnv *env, jclass clazz, jint index, jfloat x, jfloat y, jfloat z, jfloat w, jlong function_pointer) {
glVertexAttrib4fARBPROC glVertexAttrib4fARB = (glVertexAttrib4fARBPROC)((intptr_t)function_pointer);
glVertexAttrib4fARB(index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttrib4dARB(JNIEnv *env, jclass clazz, jint index, jdouble x, jdouble y, jdouble z, jdouble w, jlong function_pointer) {
glVertexAttrib4dARBPROC glVertexAttrib4dARB = (glVertexAttrib4dARBPROC)((intptr_t)function_pointer);
glVertexAttrib4dARB(index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttrib4NubARB(JNIEnv *env, jclass clazz, jint index, jbyte x, jbyte y, jbyte z, jbyte w, jlong function_pointer) {
glVertexAttrib4NubARBPROC glVertexAttrib4NubARB = (glVertexAttrib4NubARBPROC)((intptr_t)function_pointer);
glVertexAttrib4NubARB(index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttribPointerARB(JNIEnv *env, jclass clazz, jint index, jint size, jint type, jboolean normalized, jint stride, jobject buffer, jint buffer_position, jlong function_pointer) {
const GLvoid *buffer_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, buffer)) + buffer_position));
glVertexAttribPointerARBPROC glVertexAttribPointerARB = (glVertexAttribPointerARBPROC)((intptr_t)function_pointer);
glVertexAttribPointerARB(index, size, type, normalized, stride, buffer_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttribPointerARBBO(JNIEnv *env, jclass clazz, jint index, jint size, jint type, jboolean normalized, jint stride, jlong buffer_buffer_offset, jlong function_pointer) {
const GLvoid *buffer_address = ((const GLvoid *)offsetToPointer(buffer_buffer_offset));
glVertexAttribPointerARBPROC glVertexAttribPointerARB = (glVertexAttribPointerARBPROC)((intptr_t)function_pointer);
glVertexAttribPointerARB(index, size, type, normalized, stride, buffer_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglEnableVertexAttribArrayARB(JNIEnv *env, jclass clazz, jint index, jlong function_pointer) {
glEnableVertexAttribArrayARBPROC glEnableVertexAttribArrayARB = (glEnableVertexAttribArrayARBPROC)((intptr_t)function_pointer);
glEnableVertexAttribArrayARB(index);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglDisableVertexAttribArrayARB(JNIEnv *env, jclass clazz, jint index, jlong function_pointer) {
glDisableVertexAttribArrayARBPROC glDisableVertexAttribArrayARB = (glDisableVertexAttribArrayARBPROC)((intptr_t)function_pointer);
glDisableVertexAttribArrayARB(index);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglGetVertexAttribfvARB(JNIEnv *env, jclass clazz, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetVertexAttribfvARBPROC glGetVertexAttribfvARB = (glGetVertexAttribfvARBPROC)((intptr_t)function_pointer);
glGetVertexAttribfvARB(index, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglGetVertexAttribdvARB(JNIEnv *env, jclass clazz, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLdouble *params_address = ((GLdouble *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetVertexAttribdvARBPROC glGetVertexAttribdvARB = (glGetVertexAttribdvARBPROC)((intptr_t)function_pointer);
glGetVertexAttribdvARB(index, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglGetVertexAttribivARB(JNIEnv *env, jclass clazz, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetVertexAttribivARBPROC glGetVertexAttribivARB = (glGetVertexAttribivARBPROC)((intptr_t)function_pointer);
glGetVertexAttribivARB(index, pname, params_address);
}
JNIEXPORT jobject JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglGetVertexAttribPointervARB(JNIEnv *env, jclass clazz, jint index, jint pname, jlong result_size, jlong function_pointer) {
glGetVertexAttribPointervARBPROC glGetVertexAttribPointervARB = (glGetVertexAttribPointervARBPROC)((intptr_t)function_pointer);
GLvoid * __result;
glGetVertexAttribPointervARB(index, pname, &__result);
return safeNewBuffer(env, __result, result_size);
}

163
src/native/generated/org_lwjgl_opengl_ARBVertexShader.c
View file

@ -1,163 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glVertexAttrib1sARBPROC) (GLuint index, GLshort v0);
typedef void (APIENTRY *glVertexAttrib1fARBPROC) (GLuint index, GLfloat v0);
typedef void (APIENTRY *glVertexAttrib1dARBPROC) (GLuint index, GLdouble v0);
typedef void (APIENTRY *glVertexAttrib2sARBPROC) (GLuint index, GLshort v0, GLshort v1);
typedef void (APIENTRY *glVertexAttrib2fARBPROC) (GLuint index, GLfloat v0, GLfloat v1);
typedef void (APIENTRY *glVertexAttrib2dARBPROC) (GLuint index, GLdouble v0, GLdouble v1);
typedef void (APIENTRY *glVertexAttrib3sARBPROC) (GLuint index, GLshort v0, GLshort v1, GLshort v2);
typedef void (APIENTRY *glVertexAttrib3fARBPROC) (GLuint index, GLfloat v0, GLfloat v1, GLfloat v2);
typedef void (APIENTRY *glVertexAttrib3dARBPROC) (GLuint index, GLdouble v0, GLdouble v1, GLdouble v2);
typedef void (APIENTRY *glVertexAttrib4sARBPROC) (GLuint index, GLshort v0, GLshort v1, GLshort v2, GLshort v3);
typedef void (APIENTRY *glVertexAttrib4fARBPROC) (GLuint index, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
typedef void (APIENTRY *glVertexAttrib4dARBPROC) (GLuint index, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);
typedef void (APIENTRY *glVertexAttrib4NubARBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
typedef void (APIENTRY *glVertexAttribPointerARBPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * buffer);
typedef void (APIENTRY *glEnableVertexAttribArrayARBPROC) (GLuint index);
typedef void (APIENTRY *glDisableVertexAttribArrayARBPROC) (GLuint index);
typedef void (APIENTRY *glBindAttribLocationARBPROC) (GLhandleARB programObj, GLuint index, const GLcharARB * name);
typedef void (APIENTRY *glGetActiveAttribARBPROC) (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei * length, GLint * size, GLenum * type, GLcharARB * name);
typedef GLint (APIENTRY *glGetAttribLocationARBPROC) (GLhandleARB programObj, const GLcharARB * name);
typedef void (APIENTRY *glGetVertexAttribfvARBPROC) (GLuint index, GLenum pname, GLfloat * params);
typedef void (APIENTRY *glGetVertexAttribdvARBPROC) (GLuint index, GLenum pname, GLdouble * params);
typedef void (APIENTRY *glGetVertexAttribivARBPROC) (GLuint index, GLenum pname, GLint * params);
typedef void (APIENTRY *glGetVertexAttribPointervARBPROC) (GLuint index, GLenum pname, GLvoid ** result);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglVertexAttrib1sARB(JNIEnv *env, jclass clazz, jint index, jshort v0, jlong function_pointer) {
glVertexAttrib1sARBPROC glVertexAttrib1sARB = (glVertexAttrib1sARBPROC)((intptr_t)function_pointer);
glVertexAttrib1sARB(index, v0);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglVertexAttrib1fARB(JNIEnv *env, jclass clazz, jint index, jfloat v0, jlong function_pointer) {
glVertexAttrib1fARBPROC glVertexAttrib1fARB = (glVertexAttrib1fARBPROC)((intptr_t)function_pointer);
glVertexAttrib1fARB(index, v0);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglVertexAttrib1dARB(JNIEnv *env, jclass clazz, jint index, jdouble v0, jlong function_pointer) {
glVertexAttrib1dARBPROC glVertexAttrib1dARB = (glVertexAttrib1dARBPROC)((intptr_t)function_pointer);
glVertexAttrib1dARB(index, v0);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglVertexAttrib2sARB(JNIEnv *env, jclass clazz, jint index, jshort v0, jshort v1, jlong function_pointer) {
glVertexAttrib2sARBPROC glVertexAttrib2sARB = (glVertexAttrib2sARBPROC)((intptr_t)function_pointer);
glVertexAttrib2sARB(index, v0, v1);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglVertexAttrib2fARB(JNIEnv *env, jclass clazz, jint index, jfloat v0, jfloat v1, jlong function_pointer) {
glVertexAttrib2fARBPROC glVertexAttrib2fARB = (glVertexAttrib2fARBPROC)((intptr_t)function_pointer);
glVertexAttrib2fARB(index, v0, v1);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglVertexAttrib2dARB(JNIEnv *env, jclass clazz, jint index, jdouble v0, jdouble v1, jlong function_pointer) {
glVertexAttrib2dARBPROC glVertexAttrib2dARB = (glVertexAttrib2dARBPROC)((intptr_t)function_pointer);
glVertexAttrib2dARB(index, v0, v1);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglVertexAttrib3sARB(JNIEnv *env, jclass clazz, jint index, jshort v0, jshort v1, jshort v2, jlong function_pointer) {
glVertexAttrib3sARBPROC glVertexAttrib3sARB = (glVertexAttrib3sARBPROC)((intptr_t)function_pointer);
glVertexAttrib3sARB(index, v0, v1, v2);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglVertexAttrib3fARB(JNIEnv *env, jclass clazz, jint index, jfloat v0, jfloat v1, jfloat v2, jlong function_pointer) {
glVertexAttrib3fARBPROC glVertexAttrib3fARB = (glVertexAttrib3fARBPROC)((intptr_t)function_pointer);
glVertexAttrib3fARB(index, v0, v1, v2);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglVertexAttrib3dARB(JNIEnv *env, jclass clazz, jint index, jdouble v0, jdouble v1, jdouble v2, jlong function_pointer) {
glVertexAttrib3dARBPROC glVertexAttrib3dARB = (glVertexAttrib3dARBPROC)((intptr_t)function_pointer);
glVertexAttrib3dARB(index, v0, v1, v2);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglVertexAttrib4sARB(JNIEnv *env, jclass clazz, jint index, jshort v0, jshort v1, jshort v2, jshort v3, jlong function_pointer) {
glVertexAttrib4sARBPROC glVertexAttrib4sARB = (glVertexAttrib4sARBPROC)((intptr_t)function_pointer);
glVertexAttrib4sARB(index, v0, v1, v2, v3);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglVertexAttrib4fARB(JNIEnv *env, jclass clazz, jint index, jfloat v0, jfloat v1, jfloat v2, jfloat v3, jlong function_pointer) {
glVertexAttrib4fARBPROC glVertexAttrib4fARB = (glVertexAttrib4fARBPROC)((intptr_t)function_pointer);
glVertexAttrib4fARB(index, v0, v1, v2, v3);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglVertexAttrib4dARB(JNIEnv *env, jclass clazz, jint index, jdouble v0, jdouble v1, jdouble v2, jdouble v3, jlong function_pointer) {
glVertexAttrib4dARBPROC glVertexAttrib4dARB = (glVertexAttrib4dARBPROC)((intptr_t)function_pointer);
glVertexAttrib4dARB(index, v0, v1, v2, v3);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglVertexAttrib4NubARB(JNIEnv *env, jclass clazz, jint index, jbyte x, jbyte y, jbyte z, jbyte w, jlong function_pointer) {
glVertexAttrib4NubARBPROC glVertexAttrib4NubARB = (glVertexAttrib4NubARBPROC)((intptr_t)function_pointer);
glVertexAttrib4NubARB(index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglVertexAttribPointerARB(JNIEnv *env, jclass clazz, jint index, jint size, jint type, jboolean normalized, jint stride, jobject buffer, jint buffer_position, jlong function_pointer) {
const GLvoid *buffer_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, buffer)) + buffer_position));
glVertexAttribPointerARBPROC glVertexAttribPointerARB = (glVertexAttribPointerARBPROC)((intptr_t)function_pointer);
glVertexAttribPointerARB(index, size, type, normalized, stride, buffer_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglVertexAttribPointerARBBO(JNIEnv *env, jclass clazz, jint index, jint size, jint type, jboolean normalized, jint stride, jlong buffer_buffer_offset, jlong function_pointer) {
const GLvoid *buffer_address = ((const GLvoid *)offsetToPointer(buffer_buffer_offset));
glVertexAttribPointerARBPROC glVertexAttribPointerARB = (glVertexAttribPointerARBPROC)((intptr_t)function_pointer);
glVertexAttribPointerARB(index, size, type, normalized, stride, buffer_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglEnableVertexAttribArrayARB(JNIEnv *env, jclass clazz, jint index, jlong function_pointer) {
glEnableVertexAttribArrayARBPROC glEnableVertexAttribArrayARB = (glEnableVertexAttribArrayARBPROC)((intptr_t)function_pointer);
glEnableVertexAttribArrayARB(index);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglDisableVertexAttribArrayARB(JNIEnv *env, jclass clazz, jint index, jlong function_pointer) {
glDisableVertexAttribArrayARBPROC glDisableVertexAttribArrayARB = (glDisableVertexAttribArrayARBPROC)((intptr_t)function_pointer);
glDisableVertexAttribArrayARB(index);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglBindAttribLocationARB(JNIEnv *env, jclass clazz, jint programObj, jint index, jobject name, jint name_position, jlong function_pointer) {
const GLcharARB *name_address = ((const GLcharARB *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
glBindAttribLocationARBPROC glBindAttribLocationARB = (glBindAttribLocationARBPROC)((intptr_t)function_pointer);
glBindAttribLocationARB(programObj, index, name_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglGetActiveAttribARB(JNIEnv *env, jclass clazz, jint programObj, jint index, jint maxLength, jobject length, jint length_position, jobject size, jint size_position, jobject type, jint type_position, jobject name, jint name_position, jlong function_pointer) {
GLsizei *length_address = ((GLsizei *)safeGetBufferAddress(env, length)) + length_position;
GLint *size_address = ((GLint *)(*env)->GetDirectBufferAddress(env, size)) + size_position;
GLenum *type_address = ((GLenum *)(*env)->GetDirectBufferAddress(env, type)) + type_position;
GLcharARB *name_address = ((GLcharARB *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
glGetActiveAttribARBPROC glGetActiveAttribARB = (glGetActiveAttribARBPROC)((intptr_t)function_pointer);
glGetActiveAttribARB(programObj, index, maxLength, length_address, size_address, type_address, name_address);
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglGetAttribLocationARB(JNIEnv *env, jclass clazz, jint programObj, jobject name, jint name_position, jlong function_pointer) {
const GLcharARB *name_address = ((const GLcharARB *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
glGetAttribLocationARBPROC glGetAttribLocationARB = (glGetAttribLocationARBPROC)((intptr_t)function_pointer);
GLint __result = glGetAttribLocationARB(programObj, name_address);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglGetVertexAttribfvARB(JNIEnv *env, jclass clazz, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetVertexAttribfvARBPROC glGetVertexAttribfvARB = (glGetVertexAttribfvARBPROC)((intptr_t)function_pointer);
glGetVertexAttribfvARB(index, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglGetVertexAttribdvARB(JNIEnv *env, jclass clazz, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLdouble *params_address = ((GLdouble *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetVertexAttribdvARBPROC glGetVertexAttribdvARB = (glGetVertexAttribdvARBPROC)((intptr_t)function_pointer);
glGetVertexAttribdvARB(index, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglGetVertexAttribivARB(JNIEnv *env, jclass clazz, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetVertexAttribivARBPROC glGetVertexAttribivARB = (glGetVertexAttribivARBPROC)((intptr_t)function_pointer);
glGetVertexAttribivARB(index, pname, params_address);
}
JNIEXPORT jobject JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglGetVertexAttribPointervARB(JNIEnv *env, jclass clazz, jint index, jint pname, jlong result_size, jlong function_pointer) {
glGetVertexAttribPointervARBPROC glGetVertexAttribPointervARB = (glGetVertexAttribPointervARBPROC)((intptr_t)function_pointer);
GLvoid * __result;
glGetVertexAttribPointervARB(index, pname, &__result);
return safeNewBuffer(env, __result, result_size);
}

54
src/native/generated/org_lwjgl_opengl_ARBWindowPos.c
View file

@ -1,54 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glWindowPos2fARBPROC) (GLfloat x, GLfloat y);
typedef void (APIENTRY *glWindowPos2dARBPROC) (GLdouble x, GLdouble y);
typedef void (APIENTRY *glWindowPos2iARBPROC) (GLint x, GLint y);
typedef void (APIENTRY *glWindowPos2sARBPROC) (GLshort x, GLshort y);
typedef void (APIENTRY *glWindowPos3fARBPROC) (GLfloat x, GLfloat y, GLfloat z);
typedef void (APIENTRY *glWindowPos3dARBPROC) (GLdouble x, GLdouble y, GLdouble z);
typedef void (APIENTRY *glWindowPos3iARBPROC) (GLint x, GLint y, GLint z);
typedef void (APIENTRY *glWindowPos3sARBPROC) (GLshort x, GLshort y, GLshort z);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBWindowPos_nglWindowPos2fARB(JNIEnv *env, jclass clazz, jfloat x, jfloat y, jlong function_pointer) {
glWindowPos2fARBPROC glWindowPos2fARB = (glWindowPos2fARBPROC)((intptr_t)function_pointer);
glWindowPos2fARB(x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBWindowPos_nglWindowPos2dARB(JNIEnv *env, jclass clazz, jdouble x, jdouble y, jlong function_pointer) {
glWindowPos2dARBPROC glWindowPos2dARB = (glWindowPos2dARBPROC)((intptr_t)function_pointer);
glWindowPos2dARB(x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBWindowPos_nglWindowPos2iARB(JNIEnv *env, jclass clazz, jint x, jint y, jlong function_pointer) {
glWindowPos2iARBPROC glWindowPos2iARB = (glWindowPos2iARBPROC)((intptr_t)function_pointer);
glWindowPos2iARB(x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBWindowPos_nglWindowPos2sARB(JNIEnv *env, jclass clazz, jshort x, jshort y, jlong function_pointer) {
glWindowPos2sARBPROC glWindowPos2sARB = (glWindowPos2sARBPROC)((intptr_t)function_pointer);
glWindowPos2sARB(x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBWindowPos_nglWindowPos3fARB(JNIEnv *env, jclass clazz, jfloat x, jfloat y, jfloat z, jlong function_pointer) {
glWindowPos3fARBPROC glWindowPos3fARB = (glWindowPos3fARBPROC)((intptr_t)function_pointer);
glWindowPos3fARB(x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBWindowPos_nglWindowPos3dARB(JNIEnv *env, jclass clazz, jdouble x, jdouble y, jdouble z, jlong function_pointer) {
glWindowPos3dARBPROC glWindowPos3dARB = (glWindowPos3dARBPROC)((intptr_t)function_pointer);
glWindowPos3dARB(x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBWindowPos_nglWindowPos3iARB(JNIEnv *env, jclass clazz, jint x, jint y, jint z, jlong function_pointer) {
glWindowPos3iARBPROC glWindowPos3iARB = (glWindowPos3iARBPROC)((intptr_t)function_pointer);
glWindowPos3iARB(x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBWindowPos_nglWindowPos3sARB(JNIEnv *env, jclass clazz, jshort x, jshort y, jshort z, jlong function_pointer) {
glWindowPos3sARBPROC glWindowPos3sARB = (glWindowPos3sARBPROC)((intptr_t)function_pointer);
glWindowPos3sARB(x, y, z);
}

13
src/native/generated/org_lwjgl_opengl_ATIDrawBuffers.c
View file

@ -1,13 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glDrawBuffersATIPROC) (GLsizei size, const GLenum * buffers);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIDrawBuffers_nglDrawBuffersATI(JNIEnv *env, jclass clazz, jint size, jobject buffers, jint buffers_position, jlong function_pointer) {
const GLenum *buffers_address = ((const GLenum *)(*env)->GetDirectBufferAddress(env, buffers)) + buffers_position;
glDrawBuffersATIPROC glDrawBuffersATI = (glDrawBuffersATIPROC)((intptr_t)function_pointer);
glDrawBuffersATI(size, buffers_address);
}

31
src/native/generated/org_lwjgl_opengl_ATIElementArray.c
View file

@ -1,31 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glElementPointerATIPROC) (GLenum type, const GLvoid * pPointer);
typedef void (APIENTRY *glDrawElementArrayATIPROC) (GLenum mode, GLsizei count);
typedef void (APIENTRY *glDrawRangeElementArrayATIPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIElementArray_nglElementPointerATI(JNIEnv *env, jclass clazz, jint type, jobject pPointer, jint pPointer_position, jlong function_pointer) {
const GLvoid *pPointer_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pPointer)) + pPointer_position));
glElementPointerATIPROC glElementPointerATI = (glElementPointerATIPROC)((intptr_t)function_pointer);
glElementPointerATI(type, pPointer_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIElementArray_nglElementPointerATIBO(JNIEnv *env, jclass clazz, jint type, jlong pPointer_buffer_offset, jlong function_pointer) {
const GLvoid *pPointer_address = ((const GLvoid *)offsetToPointer(pPointer_buffer_offset));
glElementPointerATIPROC glElementPointerATI = (glElementPointerATIPROC)((intptr_t)function_pointer);
glElementPointerATI(type, pPointer_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIElementArray_nglDrawElementArrayATI(JNIEnv *env, jclass clazz, jint mode, jint count, jlong function_pointer) {
glDrawElementArrayATIPROC glDrawElementArrayATI = (glDrawElementArrayATIPROC)((intptr_t)function_pointer);
glDrawElementArrayATI(mode, count);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIElementArray_nglDrawRangeElementArrayATI(JNIEnv *env, jclass clazz, jint mode, jint start, jint end, jint count, jlong function_pointer) {
glDrawRangeElementArrayATIPROC glDrawRangeElementArrayATI = (glDrawRangeElementArrayATIPROC)((intptr_t)function_pointer);
glDrawRangeElementArrayATI(mode, start, end, count);
}

34
src/native/generated/org_lwjgl_opengl_ATIEnvmapBumpmap.c
View file

@ -1,34 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glTexBumpParameterfvATIPROC) (GLenum pname, const GLfloat * param);
typedef void (APIENTRY *glTexBumpParameterivATIPROC) (GLenum pname, const GLint * param);
typedef void (APIENTRY *glGetTexBumpParameterfvATIPROC) (GLenum pname, GLfloat * param);
typedef void (APIENTRY *glGetTexBumpParameterivATIPROC) (GLenum pname, GLint * param);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIEnvmapBumpmap_nglTexBumpParameterfvATI(JNIEnv *env, jclass clazz, jint pname, jobject param, jint param_position, jlong function_pointer) {
const GLfloat *param_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, param)) + param_position;
glTexBumpParameterfvATIPROC glTexBumpParameterfvATI = (glTexBumpParameterfvATIPROC)((intptr_t)function_pointer);
glTexBumpParameterfvATI(pname, param_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIEnvmapBumpmap_nglTexBumpParameterivATI(JNIEnv *env, jclass clazz, jint pname, jobject param, jint param_position, jlong function_pointer) {
const GLint *param_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, param)) + param_position;
glTexBumpParameterivATIPROC glTexBumpParameterivATI = (glTexBumpParameterivATIPROC)((intptr_t)function_pointer);
glTexBumpParameterivATI(pname, param_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIEnvmapBumpmap_nglGetTexBumpParameterfvATI(JNIEnv *env, jclass clazz, jint pname, jobject param, jint param_position, jlong function_pointer) {
GLfloat *param_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, param)) + param_position;
glGetTexBumpParameterfvATIPROC glGetTexBumpParameterfvATI = (glGetTexBumpParameterfvATIPROC)((intptr_t)function_pointer);
glGetTexBumpParameterfvATI(pname, param_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIEnvmapBumpmap_nglGetTexBumpParameterivATI(JNIEnv *env, jclass clazz, jint pname, jobject param, jint param_position, jlong function_pointer) {
GLint *param_address = ((GLint *)(*env)->GetDirectBufferAddress(env, param)) + param_position;
glGetTexBumpParameterivATIPROC glGetTexBumpParameterivATI = (glGetTexBumpParameterivATIPROC)((intptr_t)function_pointer);
glGetTexBumpParameterivATI(pname, param_address);
}

92
src/native/generated/org_lwjgl_opengl_ATIFragmentShader.c
View file

@ -1,92 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef GLuint (APIENTRY *glGenFragmentShadersATIPROC) (GLuint range);
typedef void (APIENTRY *glBindFragmentShaderATIPROC) (GLuint id);
typedef void (APIENTRY *glDeleteFragmentShaderATIPROC) (GLuint id);
typedef void (APIENTRY *glBeginFragmentShaderATIPROC) ();
typedef void (APIENTRY *glEndFragmentShaderATIPROC) ();
typedef void (APIENTRY *glPassTexCoordATIPROC) (GLuint dst, GLuint coord, GLenum swizzle);
typedef void (APIENTRY *glSampleMapATIPROC) (GLuint dst, GLuint interp, GLenum swizzle);
typedef void (APIENTRY *glColorFragmentOp1ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
typedef void (APIENTRY *glColorFragmentOp2ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
typedef void (APIENTRY *glColorFragmentOp3ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod);
typedef void (APIENTRY *glAlphaFragmentOp1ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
typedef void (APIENTRY *glAlphaFragmentOp2ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
typedef void (APIENTRY *glAlphaFragmentOp3ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod);
typedef void (APIENTRY *glSetFragmentShaderConstantATIPROC) (GLuint dst, const GLfloat * pfValue);
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglGenFragmentShadersATI(JNIEnv *env, jclass clazz, jint range, jlong function_pointer) {
glGenFragmentShadersATIPROC glGenFragmentShadersATI = (glGenFragmentShadersATIPROC)((intptr_t)function_pointer);
GLuint __result = glGenFragmentShadersATI(range);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglBindFragmentShaderATI(JNIEnv *env, jclass clazz, jint id, jlong function_pointer) {
glBindFragmentShaderATIPROC glBindFragmentShaderATI = (glBindFragmentShaderATIPROC)((intptr_t)function_pointer);
glBindFragmentShaderATI(id);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglDeleteFragmentShaderATI(JNIEnv *env, jclass clazz, jint id, jlong function_pointer) {
glDeleteFragmentShaderATIPROC glDeleteFragmentShaderATI = (glDeleteFragmentShaderATIPROC)((intptr_t)function_pointer);
glDeleteFragmentShaderATI(id);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglBeginFragmentShaderATI(JNIEnv *env, jclass clazz, jlong function_pointer) {
glBeginFragmentShaderATIPROC glBeginFragmentShaderATI = (glBeginFragmentShaderATIPROC)((intptr_t)function_pointer);
glBeginFragmentShaderATI();
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglEndFragmentShaderATI(JNIEnv *env, jclass clazz, jlong function_pointer) {
glEndFragmentShaderATIPROC glEndFragmentShaderATI = (glEndFragmentShaderATIPROC)((intptr_t)function_pointer);
glEndFragmentShaderATI();
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglPassTexCoordATI(JNIEnv *env, jclass clazz, jint dst, jint coord, jint swizzle, jlong function_pointer) {
glPassTexCoordATIPROC glPassTexCoordATI = (glPassTexCoordATIPROC)((intptr_t)function_pointer);
glPassTexCoordATI(dst, coord, swizzle);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglSampleMapATI(JNIEnv *env, jclass clazz, jint dst, jint interp, jint swizzle, jlong function_pointer) {
glSampleMapATIPROC glSampleMapATI = (glSampleMapATIPROC)((intptr_t)function_pointer);
glSampleMapATI(dst, interp, swizzle);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglColorFragmentOp1ATI(JNIEnv *env, jclass clazz, jint op, jint dst, jint dstMask, jint dstMod, jint arg1, jint arg1Rep, jint arg1Mod, jlong function_pointer) {
glColorFragmentOp1ATIPROC glColorFragmentOp1ATI = (glColorFragmentOp1ATIPROC)((intptr_t)function_pointer);
glColorFragmentOp1ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglColorFragmentOp2ATI(JNIEnv *env, jclass clazz, jint op, jint dst, jint dstMask, jint dstMod, jint arg1, jint arg1Rep, jint arg1Mod, jint arg2, jint arg2Rep, jint arg2Mod, jlong function_pointer) {
glColorFragmentOp2ATIPROC glColorFragmentOp2ATI = (glColorFragmentOp2ATIPROC)((intptr_t)function_pointer);
glColorFragmentOp2ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglColorFragmentOp3ATI(JNIEnv *env, jclass clazz, jint op, jint dst, jint dstMask, jint dstMod, jint arg1, jint arg1Rep, jint arg1Mod, jint arg2, jint arg2Rep, jint arg2Mod, jint arg3, jint arg3Rep, jint arg3Mod, jlong function_pointer) {
glColorFragmentOp3ATIPROC glColorFragmentOp3ATI = (glColorFragmentOp3ATIPROC)((intptr_t)function_pointer);
glColorFragmentOp3ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglAlphaFragmentOp1ATI(JNIEnv *env, jclass clazz, jint op, jint dst, jint dstMod, jint arg1, jint arg1Rep, jint arg1Mod, jlong function_pointer) {
glAlphaFragmentOp1ATIPROC glAlphaFragmentOp1ATI = (glAlphaFragmentOp1ATIPROC)((intptr_t)function_pointer);
glAlphaFragmentOp1ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglAlphaFragmentOp2ATI(JNIEnv *env, jclass clazz, jint op, jint dst, jint dstMod, jint arg1, jint arg1Rep, jint arg1Mod, jint arg2, jint arg2Rep, jint arg2Mod, jlong function_pointer) {
glAlphaFragmentOp2ATIPROC glAlphaFragmentOp2ATI = (glAlphaFragmentOp2ATIPROC)((intptr_t)function_pointer);
glAlphaFragmentOp2ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglAlphaFragmentOp3ATI(JNIEnv *env, jclass clazz, jint op, jint dst, jint dstMod, jint arg1, jint arg1Rep, jint arg1Mod, jint arg2, jint arg2Rep, jint arg2Mod, jint arg3, jint arg3Rep, jint arg3Mod, jlong function_pointer) {
glAlphaFragmentOp3ATIPROC glAlphaFragmentOp3ATI = (glAlphaFragmentOp3ATIPROC)((intptr_t)function_pointer);
glAlphaFragmentOp3ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglSetFragmentShaderConstantATI(JNIEnv *env, jclass clazz, jint dst, jobject pfValue, jint pfValue_position, jlong function_pointer) {
const GLfloat *pfValue_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, pfValue)) + pfValue_position;
glSetFragmentShaderConstantATIPROC glSetFragmentShaderConstantATI = (glSetFragmentShaderConstantATIPROC)((intptr_t)function_pointer);
glSetFragmentShaderConstantATI(dst, pfValue_address);
}

19
src/native/generated/org_lwjgl_opengl_ATIMapObjectBuffer.c
View file

@ -1,19 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef GLvoid * (APIENTRY *glMapObjectBufferATIPROC) (GLuint buffer);
typedef void (APIENTRY *glUnmapObjectBufferATIPROC) (GLuint buffer);
JNIEXPORT jobject JNICALL Java_org_lwjgl_opengl_ATIMapObjectBuffer_nglMapObjectBufferATI(JNIEnv *env, jclass clazz, jint buffer, jlong result_size, jobject old_buffer, jlong function_pointer) {
glMapObjectBufferATIPROC glMapObjectBufferATI = (glMapObjectBufferATIPROC)((intptr_t)function_pointer);
GLvoid * __result = glMapObjectBufferATI(buffer);
return safeNewBufferCached(env, __result, result_size, old_buffer);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIMapObjectBuffer_nglUnmapObjectBufferATI(JNIEnv *env, jclass clazz, jint buffer, jlong function_pointer) {
glUnmapObjectBufferATIPROC glUnmapObjectBufferATI = (glUnmapObjectBufferATIPROC)((intptr_t)function_pointer);
glUnmapObjectBufferATI(buffer);
}

18
src/native/generated/org_lwjgl_opengl_ATIPnTriangles.c
View file

@ -1,18 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glPNTrianglesfATIPROC) (GLenum pname, GLfloat param);
typedef void (APIENTRY *glPNTrianglesiATIPROC) (GLenum pname, GLint param);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIPnTriangles_nglPNTrianglesfATI(JNIEnv *env, jclass clazz, jint pname, jfloat param, jlong function_pointer) {
glPNTrianglesfATIPROC glPNTrianglesfATI = (glPNTrianglesfATIPROC)((intptr_t)function_pointer);
glPNTrianglesfATI(pname, param);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIPnTriangles_nglPNTrianglesiATI(JNIEnv *env, jclass clazz, jint pname, jint param, jlong function_pointer) {
glPNTrianglesiATIPROC glPNTrianglesiATI = (glPNTrianglesiATIPROC)((intptr_t)function_pointer);
glPNTrianglesiATI(pname, param);
}

18
src/native/generated/org_lwjgl_opengl_ATISeparateStencil.c
View file

@ -1,18 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glStencilOpSeparateATIPROC) (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
typedef void (APIENTRY *glStencilFuncSeparateATIPROC) (GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATISeparateStencil_nglStencilOpSeparateATI(JNIEnv *env, jclass clazz, jint face, jint sfail, jint dpfail, jint dppass, jlong function_pointer) {
glStencilOpSeparateATIPROC glStencilOpSeparateATI = (glStencilOpSeparateATIPROC)((intptr_t)function_pointer);
glStencilOpSeparateATI(face, sfail, dpfail, dppass);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATISeparateStencil_nglStencilFuncSeparateATI(JNIEnv *env, jclass clazz, jint frontfunc, jint backfunc, jint ref, jint mask, jlong function_pointer) {
glStencilFuncSeparateATIPROC glStencilFuncSeparateATI = (glStencilFuncSeparateATIPROC)((intptr_t)function_pointer);
glStencilFuncSeparateATI(frontfunc, backfunc, ref, mask);
}

88
src/native/generated/org_lwjgl_opengl_ATIVertexArrayObject.c
View file

@ -1,88 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef GLuint (APIENTRY *glNewObjectBufferATIPROC) (GLsizei size, const GLvoid * pPointer, GLenum usage);
typedef GLboolean (APIENTRY *glIsObjectBufferATIPROC) (GLuint buffer);
typedef void (APIENTRY *glUpdateObjectBufferATIPROC) (GLuint buffer, GLuint offset, GLsizei size, const GLvoid * pPointer, GLenum preserve);
typedef void (APIENTRY *glGetObjectBufferfvATIPROC) (GLuint buffer, GLenum pname, GLfloat * params);
typedef void (APIENTRY *glGetObjectBufferivATIPROC) (GLuint buffer, GLenum pname, GLint * params);
typedef void (APIENTRY *glFreeObjectBufferATIPROC) (GLuint buffer);
typedef void (APIENTRY *glArrayObjectATIPROC) (GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset);
typedef void (APIENTRY *glGetArrayObjectfvATIPROC) (GLenum array, GLenum pname, GLfloat * params);
typedef void (APIENTRY *glGetArrayObjectivATIPROC) (GLenum array, GLenum pname, GLint * params);
typedef void (APIENTRY *glVariantArrayObjectATIPROC) (GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset);
typedef void (APIENTRY *glGetVariantArrayObjectfvATIPROC) (GLuint id, GLenum pname, GLfloat * params);
typedef void (APIENTRY *glGetVariantArrayObjectivATIPROC) (GLuint id, GLenum pname, GLint * params);
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglNewObjectBufferATI(JNIEnv *env, jclass clazz, jint size, jobject pPointer, jint pPointer_position, jint usage, jlong function_pointer) {
const GLvoid *pPointer_address = ((const GLvoid *)(((char *)safeGetBufferAddress(env, pPointer)) + pPointer_position));
glNewObjectBufferATIPROC glNewObjectBufferATI = (glNewObjectBufferATIPROC)((intptr_t)function_pointer);
GLuint __result = glNewObjectBufferATI(size, pPointer_address, usage);
return __result;
}
JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglIsObjectBufferATI(JNIEnv *env, jclass clazz, jint buffer, jlong function_pointer) {
glIsObjectBufferATIPROC glIsObjectBufferATI = (glIsObjectBufferATIPROC)((intptr_t)function_pointer);
GLboolean __result = glIsObjectBufferATI(buffer);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglUpdateObjectBufferATI(JNIEnv *env, jclass clazz, jint buffer, jint offset, jint size, jobject pPointer, jint pPointer_position, jint preserve, jlong function_pointer) {
const GLvoid *pPointer_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pPointer)) + pPointer_position));
glUpdateObjectBufferATIPROC glUpdateObjectBufferATI = (glUpdateObjectBufferATIPROC)((intptr_t)function_pointer);
glUpdateObjectBufferATI(buffer, offset, size, pPointer_address, preserve);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglGetObjectBufferfvATI(JNIEnv *env, jclass clazz, jint buffer, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetObjectBufferfvATIPROC glGetObjectBufferfvATI = (glGetObjectBufferfvATIPROC)((intptr_t)function_pointer);
glGetObjectBufferfvATI(buffer, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglGetObjectBufferivATI(JNIEnv *env, jclass clazz, jint buffer, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetObjectBufferivATIPROC glGetObjectBufferivATI = (glGetObjectBufferivATIPROC)((intptr_t)function_pointer);
glGetObjectBufferivATI(buffer, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglFreeObjectBufferATI(JNIEnv *env, jclass clazz, jint buffer, jlong function_pointer) {
glFreeObjectBufferATIPROC glFreeObjectBufferATI = (glFreeObjectBufferATIPROC)((intptr_t)function_pointer);
glFreeObjectBufferATI(buffer);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglArrayObjectATI(JNIEnv *env, jclass clazz, jint array, jint size, jint type, jint stride, jint buffer, jint offset, jlong function_pointer) {
glArrayObjectATIPROC glArrayObjectATI = (glArrayObjectATIPROC)((intptr_t)function_pointer);
glArrayObjectATI(array, size, type, stride, buffer, offset);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglGetArrayObjectfvATI(JNIEnv *env, jclass clazz, jint array, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetArrayObjectfvATIPROC glGetArrayObjectfvATI = (glGetArrayObjectfvATIPROC)((intptr_t)function_pointer);
glGetArrayObjectfvATI(array, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglGetArrayObjectivATI(JNIEnv *env, jclass clazz, jint array, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetArrayObjectivATIPROC glGetArrayObjectivATI = (glGetArrayObjectivATIPROC)((intptr_t)function_pointer);
glGetArrayObjectivATI(array, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglVariantArrayObjectATI(JNIEnv *env, jclass clazz, jint id, jint type, jint stride, jint buffer, jint offset, jlong function_pointer) {
glVariantArrayObjectATIPROC glVariantArrayObjectATI = (glVariantArrayObjectATIPROC)((intptr_t)function_pointer);
glVariantArrayObjectATI(id, type, stride, buffer, offset);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglGetVariantArrayObjectfvATI(JNIEnv *env, jclass clazz, jint id, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetVariantArrayObjectfvATIPROC glGetVariantArrayObjectfvATI = (glGetVariantArrayObjectfvATIPROC)((intptr_t)function_pointer);
glGetVariantArrayObjectfvATI(id, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglGetVariantArrayObjectivATI(JNIEnv *env, jclass clazz, jint id, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetVariantArrayObjectivATIPROC glGetVariantArrayObjectivATI = (glGetVariantArrayObjectivATIPROC)((intptr_t)function_pointer);
glGetVariantArrayObjectivATI(id, pname, params_address);
}

26
src/native/generated/org_lwjgl_opengl_ATIVertexAttribArrayObject.c
View file

@ -1,26 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glVertexAttribArrayObjectATIPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset);
typedef void (APIENTRY *glGetVertexAttribArrayObjectfvATIPROC) (GLuint index, GLenum pname, GLfloat * params);
typedef void (APIENTRY *glGetVertexAttribArrayObjectivATIPROC) (GLuint index, GLenum pname, GLint * params);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexAttribArrayObject_nglVertexAttribArrayObjectATI(JNIEnv *env, jclass clazz, jint index, jint size, jint type, jboolean normalized, jint stride, jint buffer, jint offset, jlong function_pointer) {
glVertexAttribArrayObjectATIPROC glVertexAttribArrayObjectATI = (glVertexAttribArrayObjectATIPROC)((intptr_t)function_pointer);
glVertexAttribArrayObjectATI(index, size, type, normalized, stride, buffer, offset);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexAttribArrayObject_nglGetVertexAttribArrayObjectfvATI(JNIEnv *env, jclass clazz, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetVertexAttribArrayObjectfvATIPROC glGetVertexAttribArrayObjectfvATI = (glGetVertexAttribArrayObjectfvATIPROC)((intptr_t)function_pointer);
glGetVertexAttribArrayObjectfvATI(index, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexAttribArrayObject_nglGetVertexAttribArrayObjectivATI(JNIEnv *env, jclass clazz, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetVertexAttribArrayObjectivATIPROC glGetVertexAttribArrayObjectivATI = (glGetVertexAttribArrayObjectivATIPROC)((intptr_t)function_pointer);
glGetVertexAttribArrayObjectivATI(index, pname, params_address);
}

126
src/native/generated/org_lwjgl_opengl_ATIVertexStreams.c
View file

@ -1,126 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glVertexStream2fATIPROC) (GLenum stream, GLfloat x, GLfloat y);
typedef void (APIENTRY *glVertexStream2dATIPROC) (GLenum stream, GLdouble x, GLdouble y);
typedef void (APIENTRY *glVertexStream2iATIPROC) (GLenum stream, GLint x, GLint y);
typedef void (APIENTRY *glVertexStream2sATIPROC) (GLenum stream, GLshort x, GLshort y);
typedef void (APIENTRY *glVertexStream3fATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z);
typedef void (APIENTRY *glVertexStream3dATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z);
typedef void (APIENTRY *glVertexStream3iATIPROC) (GLenum stream, GLint x, GLint y, GLint z);
typedef void (APIENTRY *glVertexStream3sATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z);
typedef void (APIENTRY *glVertexStream4fATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
typedef void (APIENTRY *glVertexStream4dATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
typedef void (APIENTRY *glVertexStream4iATIPROC) (GLenum stream, GLint x, GLint y, GLint z, GLint w);
typedef void (APIENTRY *glVertexStream4sATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w);
typedef void (APIENTRY *glNormalStream3bATIPROC) (GLenum stream, GLbyte x, GLbyte y, GLbyte z);
typedef void (APIENTRY *glNormalStream3fATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z);
typedef void (APIENTRY *glNormalStream3dATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z);
typedef void (APIENTRY *glNormalStream3iATIPROC) (GLenum stream, GLint x, GLint y, GLint z);
typedef void (APIENTRY *glNormalStream3sATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z);
typedef void (APIENTRY *glClientActiveVertexStreamATIPROC) (GLenum stream);
typedef void (APIENTRY *glVertexBlendEnvfATIPROC) (GLenum pname, GLfloat param);
typedef void (APIENTRY *glVertexBlendEnviATIPROC) (GLenum pname, GLint param);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream2fATI(JNIEnv *env, jclass clazz, jint stream, jfloat x, jfloat y, jlong function_pointer) {
glVertexStream2fATIPROC glVertexStream2fATI = (glVertexStream2fATIPROC)((intptr_t)function_pointer);
glVertexStream2fATI(stream, x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream2dATI(JNIEnv *env, jclass clazz, jint stream, jdouble x, jdouble y, jlong function_pointer) {
glVertexStream2dATIPROC glVertexStream2dATI = (glVertexStream2dATIPROC)((intptr_t)function_pointer);
glVertexStream2dATI(stream, x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream2iATI(JNIEnv *env, jclass clazz, jint stream, jint x, jint y, jlong function_pointer) {
glVertexStream2iATIPROC glVertexStream2iATI = (glVertexStream2iATIPROC)((intptr_t)function_pointer);
glVertexStream2iATI(stream, x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream2sATI(JNIEnv *env, jclass clazz, jint stream, jshort x, jshort y, jlong function_pointer) {
glVertexStream2sATIPROC glVertexStream2sATI = (glVertexStream2sATIPROC)((intptr_t)function_pointer);
glVertexStream2sATI(stream, x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream3fATI(JNIEnv *env, jclass clazz, jint stream, jfloat x, jfloat y, jfloat z, jlong function_pointer) {
glVertexStream3fATIPROC glVertexStream3fATI = (glVertexStream3fATIPROC)((intptr_t)function_pointer);
glVertexStream3fATI(stream, x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream3dATI(JNIEnv *env, jclass clazz, jint stream, jdouble x, jdouble y, jdouble z, jlong function_pointer) {
glVertexStream3dATIPROC glVertexStream3dATI = (glVertexStream3dATIPROC)((intptr_t)function_pointer);
glVertexStream3dATI(stream, x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream3iATI(JNIEnv *env, jclass clazz, jint stream, jint x, jint y, jint z, jlong function_pointer) {
glVertexStream3iATIPROC glVertexStream3iATI = (glVertexStream3iATIPROC)((intptr_t)function_pointer);
glVertexStream3iATI(stream, x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream3sATI(JNIEnv *env, jclass clazz, jint stream, jshort x, jshort y, jshort z, jlong function_pointer) {
glVertexStream3sATIPROC glVertexStream3sATI = (glVertexStream3sATIPROC)((intptr_t)function_pointer);
glVertexStream3sATI(stream, x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream4fATI(JNIEnv *env, jclass clazz, jint stream, jfloat x, jfloat y, jfloat z, jfloat w, jlong function_pointer) {
glVertexStream4fATIPROC glVertexStream4fATI = (glVertexStream4fATIPROC)((intptr_t)function_pointer);
glVertexStream4fATI(stream, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream4dATI(JNIEnv *env, jclass clazz, jint stream, jdouble x, jdouble y, jdouble z, jdouble w, jlong function_pointer) {
glVertexStream4dATIPROC glVertexStream4dATI = (glVertexStream4dATIPROC)((intptr_t)function_pointer);
glVertexStream4dATI(stream, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream4iATI(JNIEnv *env, jclass clazz, jint stream, jint x, jint y, jint z, jint w, jlong function_pointer) {
glVertexStream4iATIPROC glVertexStream4iATI = (glVertexStream4iATIPROC)((intptr_t)function_pointer);
glVertexStream4iATI(stream, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream4sATI(JNIEnv *env, jclass clazz, jint stream, jshort x, jshort y, jshort z, jshort w, jlong function_pointer) {
glVertexStream4sATIPROC glVertexStream4sATI = (glVertexStream4sATIPROC)((intptr_t)function_pointer);
glVertexStream4sATI(stream, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglNormalStream3bATI(JNIEnv *env, jclass clazz, jint stream, jbyte x, jbyte y, jbyte z, jlong function_pointer) {
glNormalStream3bATIPROC glNormalStream3bATI = (glNormalStream3bATIPROC)((intptr_t)function_pointer);
glNormalStream3bATI(stream, x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglNormalStream3fATI(JNIEnv *env, jclass clazz, jint stream, jfloat x, jfloat y, jfloat z, jlong function_pointer) {
glNormalStream3fATIPROC glNormalStream3fATI = (glNormalStream3fATIPROC)((intptr_t)function_pointer);
glNormalStream3fATI(stream, x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglNormalStream3dATI(JNIEnv *env, jclass clazz, jint stream, jdouble x, jdouble y, jdouble z, jlong function_pointer) {
glNormalStream3dATIPROC glNormalStream3dATI = (glNormalStream3dATIPROC)((intptr_t)function_pointer);
glNormalStream3dATI(stream, x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglNormalStream3iATI(JNIEnv *env, jclass clazz, jint stream, jint x, jint y, jint z, jlong function_pointer) {
glNormalStream3iATIPROC glNormalStream3iATI = (glNormalStream3iATIPROC)((intptr_t)function_pointer);
glNormalStream3iATI(stream, x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglNormalStream3sATI(JNIEnv *env, jclass clazz, jint stream, jshort x, jshort y, jshort z, jlong function_pointer) {
glNormalStream3sATIPROC glNormalStream3sATI = (glNormalStream3sATIPROC)((intptr_t)function_pointer);
glNormalStream3sATI(stream, x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglClientActiveVertexStreamATI(JNIEnv *env, jclass clazz, jint stream, jlong function_pointer) {
glClientActiveVertexStreamATIPROC glClientActiveVertexStreamATI = (glClientActiveVertexStreamATIPROC)((intptr_t)function_pointer);
glClientActiveVertexStreamATI(stream);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexBlendEnvfATI(JNIEnv *env, jclass clazz, jint pname, jfloat param, jlong function_pointer) {
glVertexBlendEnvfATIPROC glVertexBlendEnvfATI = (glVertexBlendEnvfATIPROC)((intptr_t)function_pointer);
glVertexBlendEnvfATI(pname, param);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexBlendEnviATI(JNIEnv *env, jclass clazz, jint pname, jint param, jlong function_pointer) {
glVertexBlendEnviATIPROC glVertexBlendEnviATI = (glVertexBlendEnviATIPROC)((intptr_t)function_pointer);
glVertexBlendEnviATI(pname, param);
}

26
src/native/generated/org_lwjgl_opengl_EXTBindableUniform.c
View file

@ -1,26 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glUniformBufferEXTPROC) (GLuint program, GLint location, GLuint buffer);
typedef GLint (APIENTRY *glGetUniformBufferSizeEXTPROC) (GLuint program, GLint location);
typedef GLintptr (APIENTRY *glGetUniformOffsetEXTPROC) (GLuint program, GLint location);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTBindableUniform_nglUniformBufferEXT(JNIEnv *env, jclass clazz, jint program, jint location, jint buffer, jlong function_pointer) {
glUniformBufferEXTPROC glUniformBufferEXT = (glUniformBufferEXTPROC)((intptr_t)function_pointer);
glUniformBufferEXT(program, location, buffer);
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_EXTBindableUniform_nglGetUniformBufferSizeEXT(JNIEnv *env, jclass clazz, jint program, jint location, jlong function_pointer) {
glGetUniformBufferSizeEXTPROC glGetUniformBufferSizeEXT = (glGetUniformBufferSizeEXTPROC)((intptr_t)function_pointer);
GLint __result = glGetUniformBufferSizeEXT(program, location);
return __result;
}
JNIEXPORT jlong JNICALL Java_org_lwjgl_opengl_EXTBindableUniform_nglGetUniformOffsetEXT(JNIEnv *env, jclass clazz, jint program, jint location, jlong function_pointer) {
glGetUniformOffsetEXTPROC glGetUniformOffsetEXT = (glGetUniformOffsetEXTPROC)((intptr_t)function_pointer);
GLintptr __result = glGetUniformOffsetEXT(program, location);
return __result;
}

12
src/native/generated/org_lwjgl_opengl_EXTBlendColor.c
View file

@ -1,12 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glBlendColorEXTPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTBlendColor_nglBlendColorEXT(JNIEnv *env, jclass clazz, jfloat red, jfloat green, jfloat blue, jfloat alpha, jlong function_pointer) {
glBlendColorEXTPROC glBlendColorEXT = (glBlendColorEXTPROC)((intptr_t)function_pointer);
glBlendColorEXT(red, green, blue, alpha);
}

12
src/native/generated/org_lwjgl_opengl_EXTBlendEquationSeparate.c
View file

@ -1,12 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glBlendEquationSeparateEXTPROC) (GLenum modeRGB, GLenum modeAlpha);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTBlendEquationSeparate_nglBlendEquationSeparateEXT(JNIEnv *env, jclass clazz, jint modeRGB, jint modeAlpha, jlong function_pointer) {
glBlendEquationSeparateEXTPROC glBlendEquationSeparateEXT = (glBlendEquationSeparateEXTPROC)((intptr_t)function_pointer);
glBlendEquationSeparateEXT(modeRGB, modeAlpha);
}

12
src/native/generated/org_lwjgl_opengl_EXTBlendFuncSeparate.c
View file

@ -1,12 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glBlendFuncSeparateEXTPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTBlendFuncSeparate_nglBlendFuncSeparateEXT(JNIEnv *env, jclass clazz, jint sfactorRGB, jint dfactorRGB, jint sfactorAlpha, jint dfactorAlpha, jlong function_pointer) {
glBlendFuncSeparateEXTPROC glBlendFuncSeparateEXT = (glBlendFuncSeparateEXTPROC)((intptr_t)function_pointer);
glBlendFuncSeparateEXT(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}

12
src/native/generated/org_lwjgl_opengl_EXTBlendMinmax.c
View file

@ -1,12 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glBlendEquationEXTPROC) (GLenum mode);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTBlendMinmax_nglBlendEquationEXT(JNIEnv *env, jclass clazz, jint mode, jlong function_pointer) {
glBlendEquationEXTPROC glBlendEquationEXT = (glBlendEquationEXTPROC)((intptr_t)function_pointer);
glBlendEquationEXT(mode);
}

18
src/native/generated/org_lwjgl_opengl_EXTCompiledVertexArray.c
View file

@ -1,18 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glLockArraysEXTPROC) (GLint first, GLsizei count);
typedef void (APIENTRY *glUnlockArraysEXTPROC) ();
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTCompiledVertexArray_nglLockArraysEXT(JNIEnv *env, jclass clazz, jint first, jint count, jlong function_pointer) {
glLockArraysEXTPROC glLockArraysEXT = (glLockArraysEXTPROC)((intptr_t)function_pointer);
glLockArraysEXT(first, count);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTCompiledVertexArray_nglUnlockArraysEXT(JNIEnv *env, jclass clazz, jlong function_pointer) {
glUnlockArraysEXTPROC glUnlockArraysEXT = (glUnlockArraysEXTPROC)((intptr_t)function_pointer);
glUnlockArraysEXT();
}

12
src/native/generated/org_lwjgl_opengl_EXTDepthBoundsTest.c
View file

@ -1,12 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glDepthBoundsEXTPROC) (GLclampd zmin, GLclampd zmax);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTDepthBoundsTest_nglDepthBoundsEXT(JNIEnv *env, jclass clazz, jdouble zmin, jdouble zmax, jlong function_pointer) {
glDepthBoundsEXTPROC glDepthBoundsEXT = (glDepthBoundsEXTPROC)((intptr_t)function_pointer);
glDepthBoundsEXT(zmin, zmax);
}

45
src/native/generated/org_lwjgl_opengl_EXTDrawBuffers2.c
View file

@ -1,45 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glColorMaskIndexedEXTPROC) (GLuint buf, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
typedef void (APIENTRY *glGetBooleanIndexedvEXTPROC) (GLenum value, GLuint index, GLboolean * data);
typedef void (APIENTRY *glGetIntegerIndexedvEXTPROC) (GLenum value, GLuint index, GLint * data);
typedef void (APIENTRY *glEnableIndexedEXTPROC) (GLenum target, GLuint index);
typedef void (APIENTRY *glDisableIndexedEXTPROC) (GLenum target, GLuint index);
typedef GLboolean (APIENTRY *glIsEnabledIndexedEXTPROC) (GLenum target, GLuint index);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTDrawBuffers2_nglColorMaskIndexedEXT(JNIEnv *env, jclass clazz, jint buf, jboolean r, jboolean g, jboolean b, jboolean a, jlong function_pointer) {
glColorMaskIndexedEXTPROC glColorMaskIndexedEXT = (glColorMaskIndexedEXTPROC)((intptr_t)function_pointer);
glColorMaskIndexedEXT(buf, r, g, b, a);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTDrawBuffers2_nglGetBooleanIndexedvEXT(JNIEnv *env, jclass clazz, jint value, jint index, jobject data, jint data_position, jlong function_pointer) {
GLboolean *data_address = ((GLboolean *)(*env)->GetDirectBufferAddress(env, data)) + data_position;
glGetBooleanIndexedvEXTPROC glGetBooleanIndexedvEXT = (glGetBooleanIndexedvEXTPROC)((intptr_t)function_pointer);
glGetBooleanIndexedvEXT(value, index, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTDrawBuffers2_nglGetIntegerIndexedvEXT(JNIEnv *env, jclass clazz, jint value, jint index, jobject data, jint data_position, jlong function_pointer) {
GLint *data_address = ((GLint *)(*env)->GetDirectBufferAddress(env, data)) + data_position;
glGetIntegerIndexedvEXTPROC glGetIntegerIndexedvEXT = (glGetIntegerIndexedvEXTPROC)((intptr_t)function_pointer);
glGetIntegerIndexedvEXT(value, index, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTDrawBuffers2_nglEnableIndexedEXT(JNIEnv *env, jclass clazz, jint target, jint index, jlong function_pointer) {
glEnableIndexedEXTPROC glEnableIndexedEXT = (glEnableIndexedEXTPROC)((intptr_t)function_pointer);
glEnableIndexedEXT(target, index);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTDrawBuffers2_nglDisableIndexedEXT(JNIEnv *env, jclass clazz, jint target, jint index, jlong function_pointer) {
glDisableIndexedEXTPROC glDisableIndexedEXT = (glDisableIndexedEXTPROC)((intptr_t)function_pointer);
glDisableIndexedEXT(target, index);
}
JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_EXTDrawBuffers2_nglIsEnabledIndexedEXT(JNIEnv *env, jclass clazz, jint target, jint index, jlong function_pointer) {
glIsEnabledIndexedEXTPROC glIsEnabledIndexedEXT = (glIsEnabledIndexedEXTPROC)((intptr_t)function_pointer);
GLboolean __result = glIsEnabledIndexedEXT(target, index);
return __result;
}

25
src/native/generated/org_lwjgl_opengl_EXTDrawInstanced.c
View file

@ -1,25 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glDrawArraysInstancedEXTPROC) (GLenum mode, GLint first, GLsizei count, GLsizei primcount);
typedef void (APIENTRY *glDrawElementsInstancedEXTPROC) (GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLsizei primcount);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTDrawInstanced_nglDrawArraysInstancedEXT(JNIEnv *env, jclass clazz, jint mode, jint first, jint count, jint primcount, jlong function_pointer) {
glDrawArraysInstancedEXTPROC glDrawArraysInstancedEXT = (glDrawArraysInstancedEXTPROC)((intptr_t)function_pointer);
glDrawArraysInstancedEXT(mode, first, count, primcount);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTDrawInstanced_nglDrawElementsInstancedEXT(JNIEnv *env, jclass clazz, jint mode, jint count, jint type, jobject indices, jint indices_position, jint primcount, jlong function_pointer) {
const GLvoid *indices_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, indices)) + indices_position));
glDrawElementsInstancedEXTPROC glDrawElementsInstancedEXT = (glDrawElementsInstancedEXTPROC)((intptr_t)function_pointer);
glDrawElementsInstancedEXT(mode, count, type, indices_address, primcount);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTDrawInstanced_nglDrawElementsInstancedEXTBO(JNIEnv *env, jclass clazz, jint mode, jint count, jint type, jlong indices_buffer_offset, jint primcount, jlong function_pointer) {
const GLvoid *indices_address = ((const GLvoid *)offsetToPointer(indices_buffer_offset));
glDrawElementsInstancedEXTPROC glDrawElementsInstancedEXT = (glDrawElementsInstancedEXTPROC)((intptr_t)function_pointer);
glDrawElementsInstancedEXT(mode, count, type, indices_address, primcount);
}

19
src/native/generated/org_lwjgl_opengl_EXTDrawRangeElements.c
View file

@ -1,19 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glDrawRangeElementsEXTPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * pIndices);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTDrawRangeElements_nglDrawRangeElementsEXT(JNIEnv *env, jclass clazz, jint mode, jint start, jint end, jint count, jint type, jobject pIndices, jint pIndices_position, jlong function_pointer) {
const GLvoid *pIndices_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pIndices)) + pIndices_position));
glDrawRangeElementsEXTPROC glDrawRangeElementsEXT = (glDrawRangeElementsEXTPROC)((intptr_t)function_pointer);
glDrawRangeElementsEXT(mode, start, end, count, type, pIndices_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTDrawRangeElements_nglDrawRangeElementsEXTBO(JNIEnv *env, jclass clazz, jint mode, jint start, jint end, jint count, jint type, jlong pIndices_buffer_offset, jlong function_pointer) {
const GLvoid *pIndices_address = ((const GLvoid *)offsetToPointer(pIndices_buffer_offset));
glDrawRangeElementsEXTPROC glDrawRangeElementsEXT = (glDrawRangeElementsEXTPROC)((intptr_t)function_pointer);
glDrawRangeElementsEXT(mode, start, end, count, type, pIndices_address);
}

31
src/native/generated/org_lwjgl_opengl_EXTFogCoord.c
View file

@ -1,31 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glFogCoordfEXTPROC) (GLfloat coord);
typedef void (APIENTRY *glFogCoorddEXTPROC) (GLdouble coord);
typedef void (APIENTRY *glFogCoordPointerEXTPROC) (GLenum type, GLsizei stride, const GLvoid * data);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTFogCoord_nglFogCoordfEXT(JNIEnv *env, jclass clazz, jfloat coord, jlong function_pointer) {
glFogCoordfEXTPROC glFogCoordfEXT = (glFogCoordfEXTPROC)((intptr_t)function_pointer);
glFogCoordfEXT(coord);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTFogCoord_nglFogCoorddEXT(JNIEnv *env, jclass clazz, jdouble coord, jlong function_pointer) {
glFogCoorddEXTPROC glFogCoorddEXT = (glFogCoorddEXTPROC)((intptr_t)function_pointer);
glFogCoorddEXT(coord);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTFogCoord_nglFogCoordPointerEXT(JNIEnv *env, jclass clazz, jint type, jint stride, jobject data, jint data_position, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
glFogCoordPointerEXTPROC glFogCoordPointerEXT = (glFogCoordPointerEXTPROC)((intptr_t)function_pointer);
glFogCoordPointerEXT(type, stride, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTFogCoord_nglFogCoordPointerEXTBO(JNIEnv *env, jclass clazz, jint type, jint stride, jlong data_buffer_offset, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)offsetToPointer(data_buffer_offset));
glFogCoordPointerEXTPROC glFogCoordPointerEXT = (glFogCoordPointerEXTPROC)((intptr_t)function_pointer);
glFogCoordPointerEXT(type, stride, data_address);
}

12
src/native/generated/org_lwjgl_opengl_EXTFramebufferBlit.c
View file

@ -1,12 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glBlitFramebufferEXTPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTFramebufferBlit_nglBlitFramebufferEXT(JNIEnv *env, jclass clazz, jint srcX0, jint srcY0, jint srcX1, jint srcY1, jint dstX0, jint dstY0, jint dstX1, jint dstY1, jint mask, jint filter, jlong function_pointer) {
glBlitFramebufferEXTPROC glBlitFramebufferEXT = (glBlitFramebufferEXTPROC)((intptr_t)function_pointer);
glBlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}

12
src/native/generated/org_lwjgl_opengl_EXTFramebufferMultisample.c
View file

@ -1,12 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glRenderbufferStorageMultisampleEXTPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTFramebufferMultisample_nglRenderbufferStorageMultisampleEXT(JNIEnv *env, jclass clazz, jint target, jint samples, jint internalformat, jint width, jint height, jlong function_pointer) {
glRenderbufferStorageMultisampleEXTPROC glRenderbufferStorageMultisampleEXT = (glRenderbufferStorageMultisampleEXTPROC)((intptr_t)function_pointer);
glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height);
}

117
src/native/generated/org_lwjgl_opengl_EXTFramebufferObject.c
View file

@ -1,117 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef GLboolean (APIENTRY *glIsRenderbufferEXTPROC) (GLuint renderbuffer);
typedef void (APIENTRY *glBindRenderbufferEXTPROC) (GLenum target, GLuint renderbuffer);
typedef void (APIENTRY *glDeleteRenderbuffersEXTPROC) (GLint n, const GLuint * renderbuffers);
typedef void (APIENTRY *glGenRenderbuffersEXTPROC) (GLint n, GLuint * renderbuffers);
typedef void (APIENTRY *glRenderbufferStorageEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
typedef void (APIENTRY *glGetRenderbufferParameterivEXTPROC) (GLenum target, GLenum pname, GLint * params);
typedef GLboolean (APIENTRY *glIsFramebufferEXTPROC) (GLuint framebuffer);
typedef void (APIENTRY *glBindFramebufferEXTPROC) (GLenum target, GLuint framebuffer);
typedef void (APIENTRY *glDeleteFramebuffersEXTPROC) (GLint n, const GLuint * framebuffers);
typedef void (APIENTRY *glGenFramebuffersEXTPROC) (GLint n, const GLuint * framebuffers);
typedef GLenum (APIENTRY *glCheckFramebufferStatusEXTPROC) (GLenum target);
typedef void (APIENTRY *glFramebufferTexture1DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
typedef void (APIENTRY *glFramebufferTexture2DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
typedef void (APIENTRY *glFramebufferTexture3DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
typedef void (APIENTRY *glFramebufferRenderbufferEXTPROC) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
typedef void (APIENTRY *glGetFramebufferAttachmentParameterivEXTPROC) (GLenum target, GLenum attachment, GLenum pname, GLint * params);
typedef void (APIENTRY *glGenerateMipmapEXTPROC) (GLenum target);
JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_EXTFramebufferObject_nglIsRenderbufferEXT(JNIEnv *env, jclass clazz, jint renderbuffer, jlong function_pointer) {
glIsRenderbufferEXTPROC glIsRenderbufferEXT = (glIsRenderbufferEXTPROC)((intptr_t)function_pointer);
GLboolean __result = glIsRenderbufferEXT(renderbuffer);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTFramebufferObject_nglBindRenderbufferEXT(JNIEnv *env, jclass clazz, jint target, jint renderbuffer, jlong function_pointer) {
glBindRenderbufferEXTPROC glBindRenderbufferEXT = (glBindRenderbufferEXTPROC)((intptr_t)function_pointer);
glBindRenderbufferEXT(target, renderbuffer);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTFramebufferObject_nglDeleteRenderbuffersEXT(JNIEnv *env, jclass clazz, jint n, jobject renderbuffers, jint renderbuffers_position, jlong function_pointer) {
const GLuint *renderbuffers_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, renderbuffers)) + renderbuffers_position;
glDeleteRenderbuffersEXTPROC glDeleteRenderbuffersEXT = (glDeleteRenderbuffersEXTPROC)((intptr_t)function_pointer);
glDeleteRenderbuffersEXT(n, renderbuffers_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTFramebufferObject_nglGenRenderbuffersEXT(JNIEnv *env, jclass clazz, jint n, jobject renderbuffers, jint renderbuffers_position, jlong function_pointer) {
GLuint *renderbuffers_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, renderbuffers)) + renderbuffers_position;
glGenRenderbuffersEXTPROC glGenRenderbuffersEXT = (glGenRenderbuffersEXTPROC)((intptr_t)function_pointer);
glGenRenderbuffersEXT(n, renderbuffers_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTFramebufferObject_nglRenderbufferStorageEXT(JNIEnv *env, jclass clazz, jint target, jint internalformat, jint width, jint height, jlong function_pointer) {
glRenderbufferStorageEXTPROC glRenderbufferStorageEXT = (glRenderbufferStorageEXTPROC)((intptr_t)function_pointer);
glRenderbufferStorageEXT(target, internalformat, width, height);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTFramebufferObject_nglGetRenderbufferParameterivEXT(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetRenderbufferParameterivEXTPROC glGetRenderbufferParameterivEXT = (glGetRenderbufferParameterivEXTPROC)((intptr_t)function_pointer);
glGetRenderbufferParameterivEXT(target, pname, params_address);
}
JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_EXTFramebufferObject_nglIsFramebufferEXT(JNIEnv *env, jclass clazz, jint framebuffer, jlong function_pointer) {
glIsFramebufferEXTPROC glIsFramebufferEXT = (glIsFramebufferEXTPROC)((intptr_t)function_pointer);
GLboolean __result = glIsFramebufferEXT(framebuffer);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTFramebufferObject_nglBindFramebufferEXT(JNIEnv *env, jclass clazz, jint target, jint framebuffer, jlong function_pointer) {
glBindFramebufferEXTPROC glBindFramebufferEXT = (glBindFramebufferEXTPROC)((intptr_t)function_pointer);
glBindFramebufferEXT(target, framebuffer);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTFramebufferObject_nglDeleteFramebuffersEXT(JNIEnv *env, jclass clazz, jint n, jobject framebuffers, jint framebuffers_position, jlong function_pointer) {
const GLuint *framebuffers_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, framebuffers)) + framebuffers_position;
glDeleteFramebuffersEXTPROC glDeleteFramebuffersEXT = (glDeleteFramebuffersEXTPROC)((intptr_t)function_pointer);
glDeleteFramebuffersEXT(n, framebuffers_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTFramebufferObject_nglGenFramebuffersEXT(JNIEnv *env, jclass clazz, jint n, jobject framebuffers, jint framebuffers_position, jlong function_pointer) {
const GLuint *framebuffers_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, framebuffers)) + framebuffers_position;
glGenFramebuffersEXTPROC glGenFramebuffersEXT = (glGenFramebuffersEXTPROC)((intptr_t)function_pointer);
glGenFramebuffersEXT(n, framebuffers_address);
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_EXTFramebufferObject_nglCheckFramebufferStatusEXT(JNIEnv *env, jclass clazz, jint target, jlong function_pointer) {
glCheckFramebufferStatusEXTPROC glCheckFramebufferStatusEXT = (glCheckFramebufferStatusEXTPROC)((intptr_t)function_pointer);
GLenum __result = glCheckFramebufferStatusEXT(target);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTFramebufferObject_nglFramebufferTexture1DEXT(JNIEnv *env, jclass clazz, jint target, jint attachment, jint textarget, jint texture, jint level, jlong function_pointer) {
glFramebufferTexture1DEXTPROC glFramebufferTexture1DEXT = (glFramebufferTexture1DEXTPROC)((intptr_t)function_pointer);
glFramebufferTexture1DEXT(target, attachment, textarget, texture, level);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTFramebufferObject_nglFramebufferTexture2DEXT(JNIEnv *env, jclass clazz, jint target, jint attachment, jint textarget, jint texture, jint level, jlong function_pointer) {
glFramebufferTexture2DEXTPROC glFramebufferTexture2DEXT = (glFramebufferTexture2DEXTPROC)((intptr_t)function_pointer);
glFramebufferTexture2DEXT(target, attachment, textarget, texture, level);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTFramebufferObject_nglFramebufferTexture3DEXT(JNIEnv *env, jclass clazz, jint target, jint attachment, jint textarget, jint texture, jint level, jint zoffset, jlong function_pointer) {
glFramebufferTexture3DEXTPROC glFramebufferTexture3DEXT = (glFramebufferTexture3DEXTPROC)((intptr_t)function_pointer);
glFramebufferTexture3DEXT(target, attachment, textarget, texture, level, zoffset);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTFramebufferObject_nglFramebufferRenderbufferEXT(JNIEnv *env, jclass clazz, jint target, jint attachment, jint renderbuffertarget, jint renderbuffer, jlong function_pointer) {
glFramebufferRenderbufferEXTPROC glFramebufferRenderbufferEXT = (glFramebufferRenderbufferEXTPROC)((intptr_t)function_pointer);
glFramebufferRenderbufferEXT(target, attachment, renderbuffertarget, renderbuffer);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTFramebufferObject_nglGetFramebufferAttachmentParameterivEXT(JNIEnv *env, jclass clazz, jint target, jint attachment, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetFramebufferAttachmentParameterivEXTPROC glGetFramebufferAttachmentParameterivEXT = (glGetFramebufferAttachmentParameterivEXTPROC)((intptr_t)function_pointer);
glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTFramebufferObject_nglGenerateMipmapEXT(JNIEnv *env, jclass clazz, jint target, jlong function_pointer) {
glGenerateMipmapEXTPROC glGenerateMipmapEXT = (glGenerateMipmapEXTPROC)((intptr_t)function_pointer);
glGenerateMipmapEXT(target);
}

30
src/native/generated/org_lwjgl_opengl_EXTGeometryShader4.c
View file

@ -1,30 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glProgramParameteriEXTPROC) (GLuint program, GLenum pname, GLint value);
typedef void (APIENTRY *glFramebufferTextureEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level);
typedef void (APIENTRY *glFramebufferTextureLayerEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
typedef void (APIENTRY *glFramebufferTextureFaceEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGeometryShader4_nglProgramParameteriEXT(JNIEnv *env, jclass clazz, jint program, jint pname, jint value, jlong function_pointer) {
glProgramParameteriEXTPROC glProgramParameteriEXT = (glProgramParameteriEXTPROC)((intptr_t)function_pointer);
glProgramParameteriEXT(program, pname, value);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGeometryShader4_nglFramebufferTextureEXT(JNIEnv *env, jclass clazz, jint target, jint attachment, jint texture, jint level, jlong function_pointer) {
glFramebufferTextureEXTPROC glFramebufferTextureEXT = (glFramebufferTextureEXTPROC)((intptr_t)function_pointer);
glFramebufferTextureEXT(target, attachment, texture, level);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGeometryShader4_nglFramebufferTextureLayerEXT(JNIEnv *env, jclass clazz, jint target, jint attachment, jint texture, jint level, jint layer, jlong function_pointer) {
glFramebufferTextureLayerEXTPROC glFramebufferTextureLayerEXT = (glFramebufferTextureLayerEXTPROC)((intptr_t)function_pointer);
glFramebufferTextureLayerEXT(target, attachment, texture, level, layer);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGeometryShader4_nglFramebufferTextureFaceEXT(JNIEnv *env, jclass clazz, jint target, jint attachment, jint texture, jint level, jint face, jlong function_pointer) {
glFramebufferTextureFaceEXTPROC glFramebufferTextureFaceEXT = (glFramebufferTextureFaceEXTPROC)((intptr_t)function_pointer);
glFramebufferTextureFaceEXT(target, attachment, texture, level, face);
}

20
src/native/generated/org_lwjgl_opengl_EXTGpuProgramParameters.c
View file

@ -1,20 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glProgramEnvParameters4fvEXTPROC) (GLenum target, GLuint index, GLsizei count, const GLfloat * params);
typedef void (APIENTRY *glProgramLocalParameters4fvEXTPROC) (GLenum target, GLuint index, GLsizei count, const GLfloat * params);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuProgramParameters_nglProgramEnvParameters4fvEXT(JNIEnv *env, jclass clazz, jint target, jint index, jint count, jobject params, jint params_position, jlong function_pointer) {
const GLfloat *params_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glProgramEnvParameters4fvEXTPROC glProgramEnvParameters4fvEXT = (glProgramEnvParameters4fvEXTPROC)((intptr_t)function_pointer);
glProgramEnvParameters4fvEXT(target, index, count, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuProgramParameters_nglProgramLocalParameters4fvEXT(JNIEnv *env, jclass clazz, jint target, jint index, jint count, jobject params, jint params_position, jlong function_pointer) {
const GLfloat *params_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glProgramLocalParameters4fvEXTPROC glProgramLocalParameters4fvEXT = (glProgramLocalParameters4fvEXTPROC)((intptr_t)function_pointer);
glProgramLocalParameters4fvEXT(target, index, count, params_address);
}

239
src/native/generated/org_lwjgl_opengl_EXTGpuShader4.c
View file

@ -1,239 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glVertexAttribI1iEXTPROC) (GLuint index, GLint x);
typedef void (APIENTRY *glVertexAttribI2iEXTPROC) (GLuint index, GLint x, GLint y);
typedef void (APIENTRY *glVertexAttribI3iEXTPROC) (GLuint index, GLint x, GLint y, GLint z);
typedef void (APIENTRY *glVertexAttribI4iEXTPROC) (GLuint index, GLint x, GLint y, GLint z, GLint w);
typedef void (APIENTRY *glVertexAttribI1uiEXTPROC) (GLuint index, GLuint x);
typedef void (APIENTRY *glVertexAttribI2uiEXTPROC) (GLuint index, GLuint x, GLuint y);
typedef void (APIENTRY *glVertexAttribI3uiEXTPROC) (GLuint index, GLuint x, GLuint y, GLuint z);
typedef void (APIENTRY *glVertexAttribI4uiEXTPROC) (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
typedef void (APIENTRY *glVertexAttribI1ivEXTPROC) (GLuint index, const GLint * v);
typedef void (APIENTRY *glVertexAttribI2ivEXTPROC) (GLuint index, const GLint * v);
typedef void (APIENTRY *glVertexAttribI3ivEXTPROC) (GLuint index, const GLint * v);
typedef void (APIENTRY *glVertexAttribI4ivEXTPROC) (GLuint index, const GLint * v);
typedef void (APIENTRY *glVertexAttribI1uivEXTPROC) (GLuint index, const GLuint * v);
typedef void (APIENTRY *glVertexAttribI2uivEXTPROC) (GLuint index, const GLuint * v);
typedef void (APIENTRY *glVertexAttribI3uivEXTPROC) (GLuint index, const GLuint * v);
typedef void (APIENTRY *glVertexAttribI4uivEXTPROC) (GLuint index, const GLuint * v);
typedef void (APIENTRY *glVertexAttribI4bvEXTPROC) (GLuint index, const GLbyte * v);
typedef void (APIENTRY *glVertexAttribI4svEXTPROC) (GLuint index, const GLshort * v);
typedef void (APIENTRY *glVertexAttribI4ubvEXTPROC) (GLuint index, const GLubyte * v);
typedef void (APIENTRY *glVertexAttribI4usvEXTPROC) (GLuint index, const GLushort * v);
typedef void (APIENTRY *glVertexAttribIPointerEXTPROC) (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * buffer);
typedef void (APIENTRY *glGetVertexAttribIivEXTPROC) (GLuint index, GLenum pname, GLint * params);
typedef void (APIENTRY *glGetVertexAttribIuivEXTPROC) (GLuint index, GLenum pname, GLuint * params);
typedef void (APIENTRY *glUniform1uiEXTPROC) (GLint location, GLuint v0);
typedef void (APIENTRY *glUniform2uiEXTPROC) (GLint location, GLuint v0, GLuint v1);
typedef void (APIENTRY *glUniform3uiEXTPROC) (GLint location, GLuint v0, GLuint v1, GLuint v2);
typedef void (APIENTRY *glUniform4uiEXTPROC) (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
typedef void (APIENTRY *glUniform1uivEXTPROC) (GLint location, GLsizei count, const GLuint * value);
typedef void (APIENTRY *glUniform2uivEXTPROC) (GLint location, GLsizei count, const GLuint * value);
typedef void (APIENTRY *glUniform3uivEXTPROC) (GLint location, GLsizei count, const GLuint * value);
typedef void (APIENTRY *glUniform4uivEXTPROC) (GLint location, GLsizei count, const GLuint * value);
typedef void (APIENTRY *glGetUniformuivEXTPROC) (GLuint program, GLint location, GLuint * params);
typedef void (APIENTRY *glBindFragDataLocationEXTPROC) (GLuint program, GLuint colorNumber, const GLchar * name);
typedef GLint (APIENTRY *glGetFragDataLocationEXTPROC) (GLuint program, const GLchar * name);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI1iEXT(JNIEnv *env, jclass clazz, jint index, jint x, jlong function_pointer) {
glVertexAttribI1iEXTPROC glVertexAttribI1iEXT = (glVertexAttribI1iEXTPROC)((intptr_t)function_pointer);
glVertexAttribI1iEXT(index, x);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI2iEXT(JNIEnv *env, jclass clazz, jint index, jint x, jint y, jlong function_pointer) {
glVertexAttribI2iEXTPROC glVertexAttribI2iEXT = (glVertexAttribI2iEXTPROC)((intptr_t)function_pointer);
glVertexAttribI2iEXT(index, x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI3iEXT(JNIEnv *env, jclass clazz, jint index, jint x, jint y, jint z, jlong function_pointer) {
glVertexAttribI3iEXTPROC glVertexAttribI3iEXT = (glVertexAttribI3iEXTPROC)((intptr_t)function_pointer);
glVertexAttribI3iEXT(index, x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI4iEXT(JNIEnv *env, jclass clazz, jint index, jint x, jint y, jint z, jint w, jlong function_pointer) {
glVertexAttribI4iEXTPROC glVertexAttribI4iEXT = (glVertexAttribI4iEXTPROC)((intptr_t)function_pointer);
glVertexAttribI4iEXT(index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI1uiEXT(JNIEnv *env, jclass clazz, jint index, jint x, jlong function_pointer) {
glVertexAttribI1uiEXTPROC glVertexAttribI1uiEXT = (glVertexAttribI1uiEXTPROC)((intptr_t)function_pointer);
glVertexAttribI1uiEXT(index, x);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI2uiEXT(JNIEnv *env, jclass clazz, jint index, jint x, jint y, jlong function_pointer) {
glVertexAttribI2uiEXTPROC glVertexAttribI2uiEXT = (glVertexAttribI2uiEXTPROC)((intptr_t)function_pointer);
glVertexAttribI2uiEXT(index, x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI3uiEXT(JNIEnv *env, jclass clazz, jint index, jint x, jint y, jint z, jlong function_pointer) {
glVertexAttribI3uiEXTPROC glVertexAttribI3uiEXT = (glVertexAttribI3uiEXTPROC)((intptr_t)function_pointer);
glVertexAttribI3uiEXT(index, x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI4uiEXT(JNIEnv *env, jclass clazz, jint index, jint x, jint y, jint z, jint w, jlong function_pointer) {
glVertexAttribI4uiEXTPROC glVertexAttribI4uiEXT = (glVertexAttribI4uiEXTPROC)((intptr_t)function_pointer);
glVertexAttribI4uiEXT(index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI1ivEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) {
const GLint *v_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribI1ivEXTPROC glVertexAttribI1ivEXT = (glVertexAttribI1ivEXTPROC)((intptr_t)function_pointer);
glVertexAttribI1ivEXT(index, v_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI2ivEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) {
const GLint *v_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribI2ivEXTPROC glVertexAttribI2ivEXT = (glVertexAttribI2ivEXTPROC)((intptr_t)function_pointer);
glVertexAttribI2ivEXT(index, v_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI3ivEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) {
const GLint *v_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribI3ivEXTPROC glVertexAttribI3ivEXT = (glVertexAttribI3ivEXTPROC)((intptr_t)function_pointer);
glVertexAttribI3ivEXT(index, v_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI4ivEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) {
const GLint *v_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribI4ivEXTPROC glVertexAttribI4ivEXT = (glVertexAttribI4ivEXTPROC)((intptr_t)function_pointer);
glVertexAttribI4ivEXT(index, v_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI1uivEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) {
const GLuint *v_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribI1uivEXTPROC glVertexAttribI1uivEXT = (glVertexAttribI1uivEXTPROC)((intptr_t)function_pointer);
glVertexAttribI1uivEXT(index, v_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI2uivEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) {
const GLuint *v_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribI2uivEXTPROC glVertexAttribI2uivEXT = (glVertexAttribI2uivEXTPROC)((intptr_t)function_pointer);
glVertexAttribI2uivEXT(index, v_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI3uivEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) {
const GLuint *v_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribI3uivEXTPROC glVertexAttribI3uivEXT = (glVertexAttribI3uivEXTPROC)((intptr_t)function_pointer);
glVertexAttribI3uivEXT(index, v_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI4uivEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) {
const GLuint *v_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribI4uivEXTPROC glVertexAttribI4uivEXT = (glVertexAttribI4uivEXTPROC)((intptr_t)function_pointer);
glVertexAttribI4uivEXT(index, v_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI4bvEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) {
const GLbyte *v_address = ((const GLbyte *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribI4bvEXTPROC glVertexAttribI4bvEXT = (glVertexAttribI4bvEXTPROC)((intptr_t)function_pointer);
glVertexAttribI4bvEXT(index, v_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI4svEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) {
const GLshort *v_address = ((const GLshort *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribI4svEXTPROC glVertexAttribI4svEXT = (glVertexAttribI4svEXTPROC)((intptr_t)function_pointer);
glVertexAttribI4svEXT(index, v_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI4ubvEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) {
const GLubyte *v_address = ((const GLubyte *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribI4ubvEXTPROC glVertexAttribI4ubvEXT = (glVertexAttribI4ubvEXTPROC)((intptr_t)function_pointer);
glVertexAttribI4ubvEXT(index, v_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI4usvEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) {
const GLushort *v_address = ((const GLushort *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribI4usvEXTPROC glVertexAttribI4usvEXT = (glVertexAttribI4usvEXTPROC)((intptr_t)function_pointer);
glVertexAttribI4usvEXT(index, v_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribIPointerEXT(JNIEnv *env, jclass clazz, jint index, jint size, jint type, jint stride, jobject buffer, jint buffer_position, jlong function_pointer) {
const GLvoid *buffer_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, buffer)) + buffer_position));
glVertexAttribIPointerEXTPROC glVertexAttribIPointerEXT = (glVertexAttribIPointerEXTPROC)((intptr_t)function_pointer);
glVertexAttribIPointerEXT(index, size, type, stride, buffer_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribIPointerEXTBO(JNIEnv *env, jclass clazz, jint index, jint size, jint type, jint stride, jlong buffer_buffer_offset, jlong function_pointer) {
const GLvoid *buffer_address = ((const GLvoid *)offsetToPointer(buffer_buffer_offset));
glVertexAttribIPointerEXTPROC glVertexAttribIPointerEXT = (glVertexAttribIPointerEXTPROC)((intptr_t)function_pointer);
glVertexAttribIPointerEXT(index, size, type, stride, buffer_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglGetVertexAttribIivEXT(JNIEnv *env, jclass clazz, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetVertexAttribIivEXTPROC glGetVertexAttribIivEXT = (glGetVertexAttribIivEXTPROC)((intptr_t)function_pointer);
glGetVertexAttribIivEXT(index, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglGetVertexAttribIuivEXT(JNIEnv *env, jclass clazz, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLuint *params_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetVertexAttribIuivEXTPROC glGetVertexAttribIuivEXT = (glGetVertexAttribIuivEXTPROC)((intptr_t)function_pointer);
glGetVertexAttribIuivEXT(index, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglUniform1uiEXT(JNIEnv *env, jclass clazz, jint location, jint v0, jlong function_pointer) {
glUniform1uiEXTPROC glUniform1uiEXT = (glUniform1uiEXTPROC)((intptr_t)function_pointer);
glUniform1uiEXT(location, v0);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglUniform2uiEXT(JNIEnv *env, jclass clazz, jint location, jint v0, jint v1, jlong function_pointer) {
glUniform2uiEXTPROC glUniform2uiEXT = (glUniform2uiEXTPROC)((intptr_t)function_pointer);
glUniform2uiEXT(location, v0, v1);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglUniform3uiEXT(JNIEnv *env, jclass clazz, jint location, jint v0, jint v1, jint v2, jlong function_pointer) {
glUniform3uiEXTPROC glUniform3uiEXT = (glUniform3uiEXTPROC)((intptr_t)function_pointer);
glUniform3uiEXT(location, v0, v1, v2);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglUniform4uiEXT(JNIEnv *env, jclass clazz, jint location, jint v0, jint v1, jint v2, jint v3, jlong function_pointer) {
glUniform4uiEXTPROC glUniform4uiEXT = (glUniform4uiEXTPROC)((intptr_t)function_pointer);
glUniform4uiEXT(location, v0, v1, v2, v3);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglUniform1uivEXT(JNIEnv *env, jclass clazz, jint location, jint count, jobject value, jint value_position, jlong function_pointer) {
const GLuint *value_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, value)) + value_position;
glUniform1uivEXTPROC glUniform1uivEXT = (glUniform1uivEXTPROC)((intptr_t)function_pointer);
glUniform1uivEXT(location, count, value_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglUniform2uivEXT(JNIEnv *env, jclass clazz, jint location, jint count, jobject value, jint value_position, jlong function_pointer) {
const GLuint *value_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, value)) + value_position;
glUniform2uivEXTPROC glUniform2uivEXT = (glUniform2uivEXTPROC)((intptr_t)function_pointer);
glUniform2uivEXT(location, count, value_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglUniform3uivEXT(JNIEnv *env, jclass clazz, jint location, jint count, jobject value, jint value_position, jlong function_pointer) {
const GLuint *value_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, value)) + value_position;
glUniform3uivEXTPROC glUniform3uivEXT = (glUniform3uivEXTPROC)((intptr_t)function_pointer);
glUniform3uivEXT(location, count, value_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglUniform4uivEXT(JNIEnv *env, jclass clazz, jint location, jint count, jobject value, jint value_position, jlong function_pointer) {
const GLuint *value_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, value)) + value_position;
glUniform4uivEXTPROC glUniform4uivEXT = (glUniform4uivEXTPROC)((intptr_t)function_pointer);
glUniform4uivEXT(location, count, value_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglGetUniformuivEXT(JNIEnv *env, jclass clazz, jint program, jint location, jobject params, jint params_position, jlong function_pointer) {
GLuint *params_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetUniformuivEXTPROC glGetUniformuivEXT = (glGetUniformuivEXTPROC)((intptr_t)function_pointer);
glGetUniformuivEXT(program, location, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglBindFragDataLocationEXT(JNIEnv *env, jclass clazz, jint program, jint colorNumber, jobject name, jint name_position, jlong function_pointer) {
const GLchar *name_address = ((const GLchar *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
glBindFragDataLocationEXTPROC glBindFragDataLocationEXT = (glBindFragDataLocationEXTPROC)((intptr_t)function_pointer);
glBindFragDataLocationEXT(program, colorNumber, name_address);
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglGetFragDataLocationEXT(JNIEnv *env, jclass clazz, jint program, jobject name, jint name_position, jlong function_pointer) {
const GLchar *name_address = ((const GLchar *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
glGetFragDataLocationEXTPROC glGetFragDataLocationEXT = (glGetFragDataLocationEXTPROC)((intptr_t)function_pointer);
GLint __result = glGetFragDataLocationEXT(program, name_address);
return __result;
}

14
src/native/generated/org_lwjgl_opengl_EXTMultiDrawArrays.c
View file

@ -1,14 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glMultiDrawArraysEXTPROC) (GLenum mode, GLint * piFirst, GLsizei * piCount, GLint primcount);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTMultiDrawArrays_nglMultiDrawArraysEXT(JNIEnv *env, jclass clazz, jint mode, jobject piFirst, jint piFirst_position, jobject piCount, jint piCount_position, jint primcount, jlong function_pointer) {
GLint *piFirst_address = ((GLint *)(*env)->GetDirectBufferAddress(env, piFirst)) + piFirst_position;
GLsizei *piCount_address = ((GLsizei *)(*env)->GetDirectBufferAddress(env, piCount)) + piCount_position;
glMultiDrawArraysEXTPROC glMultiDrawArraysEXT = (glMultiDrawArraysEXTPROC)((intptr_t)function_pointer);
glMultiDrawArraysEXT(mode, piFirst_address, piCount_address, primcount);
}

41
src/native/generated/org_lwjgl_opengl_EXTPalettedTexture.c
View file

@ -1,41 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glColorTableEXTPROC) (GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid * data);
typedef void (APIENTRY *glColorSubTableEXTPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data);
typedef void (APIENTRY *glGetColorTableEXTPROC) (GLenum target, GLenum format, GLenum type, GLvoid * data);
typedef void (APIENTRY *glGetColorTableParameterivEXTPROC) (GLenum target, GLenum pname, GLint * params);
typedef void (APIENTRY *glGetColorTableParameterfvEXTPROC) (GLenum target, GLenum pname, GLfloat * params);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTPalettedTexture_nglColorTableEXT(JNIEnv *env, jclass clazz, jint target, jint internalFormat, jint width, jint format, jint type, jobject data, jint data_position, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
glColorTableEXTPROC glColorTableEXT = (glColorTableEXTPROC)((intptr_t)function_pointer);
glColorTableEXT(target, internalFormat, width, format, type, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTPalettedTexture_nglColorSubTableEXT(JNIEnv *env, jclass clazz, jint target, jint start, jint count, jint format, jint type, jobject data, jint data_position, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
glColorSubTableEXTPROC glColorSubTableEXT = (glColorSubTableEXTPROC)((intptr_t)function_pointer);
glColorSubTableEXT(target, start, count, format, type, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTPalettedTexture_nglGetColorTableEXT(JNIEnv *env, jclass clazz, jint target, jint format, jint type, jobject data, jint data_position, jlong function_pointer) {
GLvoid *data_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
glGetColorTableEXTPROC glGetColorTableEXT = (glGetColorTableEXTPROC)((intptr_t)function_pointer);
glGetColorTableEXT(target, format, type, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTPalettedTexture_nglGetColorTableParameterivEXT(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetColorTableParameterivEXTPROC glGetColorTableParameterivEXT = (glGetColorTableParameterivEXTPROC)((intptr_t)function_pointer);
glGetColorTableParameterivEXT(target, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTPalettedTexture_nglGetColorTableParameterfvEXT(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetColorTableParameterfvEXTPROC glGetColorTableParameterfvEXT = (glGetColorTableParameterfvEXTPROC)((intptr_t)function_pointer);
glGetColorTableParameterfvEXT(target, pname, params_address);
}

19
src/native/generated/org_lwjgl_opengl_EXTPointParameters.c
View file

@ -1,19 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glPointParameterfEXTPROC) (GLenum pname, GLfloat param);
typedef void (APIENTRY *glPointParameterfvEXTPROC) (GLenum pname, const GLfloat * pfParams);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTPointParameters_nglPointParameterfEXT(JNIEnv *env, jclass clazz, jint pname, jfloat param, jlong function_pointer) {
glPointParameterfEXTPROC glPointParameterfEXT = (glPointParameterfEXTPROC)((intptr_t)function_pointer);
glPointParameterfEXT(pname, param);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTPointParameters_nglPointParameterfvEXT(JNIEnv *env, jclass clazz, jint pname, jobject pfParams, jint pfParams_position, jlong function_pointer) {
const GLfloat *pfParams_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, pfParams)) + pfParams_position;
glPointParameterfvEXTPROC glPointParameterfvEXT = (glPointParameterfvEXTPROC)((intptr_t)function_pointer);
glPointParameterfvEXT(pname, pfParams_address);
}

43
src/native/generated/org_lwjgl_opengl_EXTSecondaryColor.c
View file

@ -1,43 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glSecondaryColor3bEXTPROC) (GLbyte red, GLbyte green, GLbyte blue);
typedef void (APIENTRY *glSecondaryColor3fEXTPROC) (GLfloat red, GLfloat green, GLfloat blue);
typedef void (APIENTRY *glSecondaryColor3dEXTPROC) (GLdouble red, GLdouble green, GLdouble blue);
typedef void (APIENTRY *glSecondaryColor3ubEXTPROC) (GLubyte red, GLubyte green, GLubyte blue);
typedef void (APIENTRY *glSecondaryColorPointerEXTPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid * pPointer);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTSecondaryColor_nglSecondaryColor3bEXT(JNIEnv *env, jclass clazz, jbyte red, jbyte green, jbyte blue, jlong function_pointer) {
glSecondaryColor3bEXTPROC glSecondaryColor3bEXT = (glSecondaryColor3bEXTPROC)((intptr_t)function_pointer);
glSecondaryColor3bEXT(red, green, blue);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTSecondaryColor_nglSecondaryColor3fEXT(JNIEnv *env, jclass clazz, jfloat red, jfloat green, jfloat blue, jlong function_pointer) {
glSecondaryColor3fEXTPROC glSecondaryColor3fEXT = (glSecondaryColor3fEXTPROC)((intptr_t)function_pointer);
glSecondaryColor3fEXT(red, green, blue);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTSecondaryColor_nglSecondaryColor3dEXT(JNIEnv *env, jclass clazz, jdouble red, jdouble green, jdouble blue, jlong function_pointer) {
glSecondaryColor3dEXTPROC glSecondaryColor3dEXT = (glSecondaryColor3dEXTPROC)((intptr_t)function_pointer);
glSecondaryColor3dEXT(red, green, blue);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTSecondaryColor_nglSecondaryColor3ubEXT(JNIEnv *env, jclass clazz, jbyte red, jbyte green, jbyte blue, jlong function_pointer) {
glSecondaryColor3ubEXTPROC glSecondaryColor3ubEXT = (glSecondaryColor3ubEXTPROC)((intptr_t)function_pointer);
glSecondaryColor3ubEXT(red, green, blue);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTSecondaryColor_nglSecondaryColorPointerEXT(JNIEnv *env, jclass clazz, jint size, jint type, jint stride, jobject pPointer, jint pPointer_position, jlong function_pointer) {
const GLvoid *pPointer_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pPointer)) + pPointer_position));
glSecondaryColorPointerEXTPROC glSecondaryColorPointerEXT = (glSecondaryColorPointerEXTPROC)((intptr_t)function_pointer);
glSecondaryColorPointerEXT(size, type, stride, pPointer_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTSecondaryColor_nglSecondaryColorPointerEXTBO(JNIEnv *env, jclass clazz, jint size, jint type, jint stride, jlong pPointer_buffer_offset, jlong function_pointer) {
const GLvoid *pPointer_address = ((const GLvoid *)offsetToPointer(pPointer_buffer_offset));
glSecondaryColorPointerEXTPROC glSecondaryColorPointerEXT = (glSecondaryColorPointerEXTPROC)((intptr_t)function_pointer);
glSecondaryColorPointerEXT(size, type, stride, pPointer_address);
}

12
src/native/generated/org_lwjgl_opengl_EXTStencilClearTag.c
View file

@ -1,12 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glStencilClearTagEXTPROC) (GLsizei stencilTagBits, GLuint stencilClearTag);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTStencilClearTag_nglStencilClearTagEXT(JNIEnv *env, jclass clazz, jint stencilTagBits, jint stencilClearTag, jlong function_pointer) {
glStencilClearTagEXTPROC glStencilClearTagEXT = (glStencilClearTagEXTPROC)((intptr_t)function_pointer);
glStencilClearTagEXT(stencilTagBits, stencilClearTag);
}

12
src/native/generated/org_lwjgl_opengl_EXTStencilTwoSide.c
View file

@ -1,12 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glActiveStencilFaceEXTPROC) (GLenum face);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTStencilTwoSide_nglActiveStencilFaceEXT(JNIEnv *env, jclass clazz, jint face, jlong function_pointer) {
glActiveStencilFaceEXTPROC glActiveStencilFaceEXT = (glActiveStencilFaceEXTPROC)((intptr_t)function_pointer);
glActiveStencilFaceEXT(face);
}

12
src/native/generated/org_lwjgl_opengl_EXTTextureArray.c
View file

@ -1,12 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glFramebufferTextureLayerEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTTextureArray_nglFramebufferTextureLayerEXT(JNIEnv *env, jclass clazz, jint target, jint attachment, jint texture, jint level, jint layer, jlong function_pointer) {
glFramebufferTextureLayerEXTPROC glFramebufferTextureLayerEXT = (glFramebufferTextureLayerEXTPROC)((intptr_t)function_pointer);
glFramebufferTextureLayerEXT(target, attachment, texture, level, layer);
}

12
src/native/generated/org_lwjgl_opengl_EXTTextureBufferObject.c
View file

@ -1,12 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glTexBufferEXTPROC) (GLenum target, GLenum internalformat, GLuint buffer);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTTextureBufferObject_nglTexBufferEXT(JNIEnv *env, jclass clazz, jint target, jint internalformat, jint buffer, jlong function_pointer) {
glTexBufferEXTPROC glTexBufferEXT = (glTexBufferEXTPROC)((intptr_t)function_pointer);
glTexBufferEXT(target, internalformat, buffer);
}

46
src/native/generated/org_lwjgl_opengl_EXTTextureInteger.c
View file

@ -1,46 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glClearColorIiEXTPROC) (GLint r, GLint g, GLint b, GLint a);
typedef void (APIENTRY *glClearColorIuiEXTPROC) (GLuint r, GLuint g, GLuint b, GLuint a);
typedef void (APIENTRY *glTexParameterIivEXTPROC) (GLenum target, GLenum pname, GLint * params);
typedef void (APIENTRY *glTexParameterIuivEXTPROC) (GLenum target, GLenum pname, GLuint * params);
typedef void (APIENTRY *glGetTexParameterIivEXTPROC) (GLenum target, GLenum pname, GLint * params);
typedef void (APIENTRY *glGetTexParameterIuivEXTPROC) (GLenum target, GLenum pname, GLuint * params);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTTextureInteger_nglClearColorIiEXT(JNIEnv *env, jclass clazz, jint r, jint g, jint b, jint a, jlong function_pointer) {
glClearColorIiEXTPROC glClearColorIiEXT = (glClearColorIiEXTPROC)((intptr_t)function_pointer);
glClearColorIiEXT(r, g, b, a);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTTextureInteger_nglClearColorIuiEXT(JNIEnv *env, jclass clazz, jint r, jint g, jint b, jint a, jlong function_pointer) {
glClearColorIuiEXTPROC glClearColorIuiEXT = (glClearColorIuiEXTPROC)((intptr_t)function_pointer);
glClearColorIuiEXT(r, g, b, a);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTTextureInteger_nglTexParameterIivEXT(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glTexParameterIivEXTPROC glTexParameterIivEXT = (glTexParameterIivEXTPROC)((intptr_t)function_pointer);
glTexParameterIivEXT(target, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTTextureInteger_nglTexParameterIuivEXT(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLuint *params_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glTexParameterIuivEXTPROC glTexParameterIuivEXT = (glTexParameterIuivEXTPROC)((intptr_t)function_pointer);
glTexParameterIuivEXT(target, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTTextureInteger_nglGetTexParameterIivEXT(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetTexParameterIivEXTPROC glGetTexParameterIivEXT = (glGetTexParameterIivEXTPROC)((intptr_t)function_pointer);
glGetTexParameterIivEXT(target, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTTextureInteger_nglGetTexParameterIuivEXT(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLuint *params_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetTexParameterIuivEXTPROC glGetTexParameterIuivEXT = (glGetTexParameterIuivEXTPROC)((intptr_t)function_pointer);
glGetTexParameterIuivEXT(target, pname, params_address);
}

20
src/native/generated/org_lwjgl_opengl_EXTTimerQuery.c
View file

@ -1,20 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glGetQueryObjecti64vEXTPROC) (GLuint id, GLenum pname, GLint64EXT * params);
typedef void (APIENTRY *glGetQueryObjectui64vEXTPROC) (GLuint id, GLenum pname, GLuint64EXT * params);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTTimerQuery_nglGetQueryObjecti64vEXT(JNIEnv *env, jclass clazz, jint id, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint64EXT *params_address = ((GLint64EXT *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetQueryObjecti64vEXTPROC glGetQueryObjecti64vEXT = (glGetQueryObjecti64vEXTPROC)((intptr_t)function_pointer);
glGetQueryObjecti64vEXT(id, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTTimerQuery_nglGetQueryObjectui64vEXT(JNIEnv *env, jclass clazz, jint id, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLuint64EXT *params_address = ((GLuint64EXT *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetQueryObjectui64vEXTPROC glGetQueryObjectui64vEXT = (glGetQueryObjectui64vEXTPROC)((intptr_t)function_pointer);
glGetQueryObjectui64vEXT(id, pname, params_address);
}

294
src/native/generated/org_lwjgl_opengl_EXTVertexShader.c
View file

@ -1,294 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glBeginVertexShaderEXTPROC) ();
typedef void (APIENTRY *glEndVertexShaderEXTPROC) ();
typedef void (APIENTRY *glBindVertexShaderEXTPROC) (GLuint id);
typedef GLuint (APIENTRY *glGenVertexShadersEXTPROC) (GLuint range);
typedef void (APIENTRY *glDeleteVertexShaderEXTPROC) (GLuint id);
typedef void (APIENTRY *glShaderOp1EXTPROC) (GLenum op, GLuint res, GLuint arg1);
typedef void (APIENTRY *glShaderOp2EXTPROC) (GLenum op, GLuint res, GLuint arg1, GLuint arg2);
typedef void (APIENTRY *glShaderOp3EXTPROC) (GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3);
typedef void (APIENTRY *glSwizzleEXTPROC) (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW);
typedef void (APIENTRY *glWriteMaskEXTPROC) (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW);
typedef void (APIENTRY *glInsertComponentEXTPROC) (GLuint res, GLuint src, GLuint num);
typedef void (APIENTRY *glExtractComponentEXTPROC) (GLuint res, GLuint src, GLuint num);
typedef GLuint (APIENTRY *glGenSymbolsEXTPROC) (GLenum dataType, GLenum storageType, GLenum range, GLuint components);
typedef void (APIENTRY *glSetInvariantEXTPROC) (GLuint id, GLenum type, const GLvoid * pAddr);
typedef void (APIENTRY *glSetLocalConstantEXTPROC) (GLuint id, GLenum type, const GLvoid * pAddr);
typedef void (APIENTRY *glVariantbvEXTPROC) (GLuint id, const GLbyte * pAddr);
typedef void (APIENTRY *glVariantsvEXTPROC) (GLuint id, const GLshort * pAddr);
typedef void (APIENTRY *glVariantivEXTPROC) (GLuint id, const GLint * pAddr);
typedef void (APIENTRY *glVariantfvEXTPROC) (GLuint id, const GLfloat * pAddr);
typedef void (APIENTRY *glVariantdvEXTPROC) (GLuint id, const GLdouble * pAddr);
typedef void (APIENTRY *glVariantubvEXTPROC) (GLuint id, const GLubyte * pAddr);
typedef void (APIENTRY *glVariantusvEXTPROC) (GLuint id, const GLushort * pAddr);
typedef void (APIENTRY *glVariantuivEXTPROC) (GLuint id, const GLuint * pAddr);
typedef void (APIENTRY *glVariantPointerEXTPROC) (GLuint id, GLenum type, GLuint stride, const GLvoid * pAddr);
typedef void (APIENTRY *glEnableVariantClientStateEXTPROC) (GLuint id);
typedef void (APIENTRY *glDisableVariantClientStateEXTPROC) (GLuint id);
typedef GLuint (APIENTRY *glBindLightParameterEXTPROC) (GLenum light, GLenum value);
typedef GLuint (APIENTRY *glBindMaterialParameterEXTPROC) (GLenum face, GLenum value);
typedef GLuint (APIENTRY *glBindTexGenParameterEXTPROC) (GLenum unit, GLenum coord, GLenum value);
typedef GLuint (APIENTRY *glBindTextureUnitParameterEXTPROC) (GLenum unit, GLenum value);
typedef GLuint (APIENTRY *glBindParameterEXTPROC) (GLenum value);
typedef GLboolean (APIENTRY *glIsVariantEnabledEXTPROC) (GLuint id, GLenum cap);
typedef void (APIENTRY *glGetVariantBooleanvEXTPROC) (GLuint id, GLenum value, GLbyte * pbData);
typedef void (APIENTRY *glGetVariantIntegervEXTPROC) (GLuint id, GLenum value, GLint * pbData);
typedef void (APIENTRY *glGetVariantFloatvEXTPROC) (GLuint id, GLenum value, GLfloat * pbData);
typedef void (APIENTRY *glGetVariantPointervEXTPROC) (GLuint id, GLenum value, GLvoid ** pbData);
typedef void (APIENTRY *glGetInvariantBooleanvEXTPROC) (GLuint id, GLenum value, GLbyte * pbData);
typedef void (APIENTRY *glGetInvariantIntegervEXTPROC) (GLuint id, GLenum value, GLint * pbData);
typedef void (APIENTRY *glGetInvariantFloatvEXTPROC) (GLuint id, GLenum value, GLfloat * pbData);
typedef void (APIENTRY *glGetLocalConstantBooleanvEXTPROC) (GLuint id, GLenum value, GLbyte * pbData);
typedef void (APIENTRY *glGetLocalConstantIntegervEXTPROC) (GLuint id, GLenum value, GLint * pbData);
typedef void (APIENTRY *glGetLocalConstantFloatvEXTPROC) (GLuint id, GLenum value, GLfloat * pbData);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglBeginVertexShaderEXT(JNIEnv *env, jclass clazz, jlong function_pointer) {
glBeginVertexShaderEXTPROC glBeginVertexShaderEXT = (glBeginVertexShaderEXTPROC)((intptr_t)function_pointer);
glBeginVertexShaderEXT();
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglEndVertexShaderEXT(JNIEnv *env, jclass clazz, jlong function_pointer) {
glEndVertexShaderEXTPROC glEndVertexShaderEXT = (glEndVertexShaderEXTPROC)((intptr_t)function_pointer);
glEndVertexShaderEXT();
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglBindVertexShaderEXT(JNIEnv *env, jclass clazz, jint id, jlong function_pointer) {
glBindVertexShaderEXTPROC glBindVertexShaderEXT = (glBindVertexShaderEXTPROC)((intptr_t)function_pointer);
glBindVertexShaderEXT(id);
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGenVertexShadersEXT(JNIEnv *env, jclass clazz, jint range, jlong function_pointer) {
glGenVertexShadersEXTPROC glGenVertexShadersEXT = (glGenVertexShadersEXTPROC)((intptr_t)function_pointer);
GLuint __result = glGenVertexShadersEXT(range);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglDeleteVertexShaderEXT(JNIEnv *env, jclass clazz, jint id, jlong function_pointer) {
glDeleteVertexShaderEXTPROC glDeleteVertexShaderEXT = (glDeleteVertexShaderEXTPROC)((intptr_t)function_pointer);
glDeleteVertexShaderEXT(id);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglShaderOp1EXT(JNIEnv *env, jclass clazz, jint op, jint res, jint arg1, jlong function_pointer) {
glShaderOp1EXTPROC glShaderOp1EXT = (glShaderOp1EXTPROC)((intptr_t)function_pointer);
glShaderOp1EXT(op, res, arg1);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglShaderOp2EXT(JNIEnv *env, jclass clazz, jint op, jint res, jint arg1, jint arg2, jlong function_pointer) {
glShaderOp2EXTPROC glShaderOp2EXT = (glShaderOp2EXTPROC)((intptr_t)function_pointer);
glShaderOp2EXT(op, res, arg1, arg2);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglShaderOp3EXT(JNIEnv *env, jclass clazz, jint op, jint res, jint arg1, jint arg2, jint arg3, jlong function_pointer) {
glShaderOp3EXTPROC glShaderOp3EXT = (glShaderOp3EXTPROC)((intptr_t)function_pointer);
glShaderOp3EXT(op, res, arg1, arg2, arg3);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglSwizzleEXT(JNIEnv *env, jclass clazz, jint res, jint in, jint outX, jint outY, jint outZ, jint outW, jlong function_pointer) {
glSwizzleEXTPROC glSwizzleEXT = (glSwizzleEXTPROC)((intptr_t)function_pointer);
glSwizzleEXT(res, in, outX, outY, outZ, outW);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglWriteMaskEXT(JNIEnv *env, jclass clazz, jint res, jint in, jint outX, jint outY, jint outZ, jint outW, jlong function_pointer) {
glWriteMaskEXTPROC glWriteMaskEXT = (glWriteMaskEXTPROC)((intptr_t)function_pointer);
glWriteMaskEXT(res, in, outX, outY, outZ, outW);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglInsertComponentEXT(JNIEnv *env, jclass clazz, jint res, jint src, jint num, jlong function_pointer) {
glInsertComponentEXTPROC glInsertComponentEXT = (glInsertComponentEXTPROC)((intptr_t)function_pointer);
glInsertComponentEXT(res, src, num);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglExtractComponentEXT(JNIEnv *env, jclass clazz, jint res, jint src, jint num, jlong function_pointer) {
glExtractComponentEXTPROC glExtractComponentEXT = (glExtractComponentEXTPROC)((intptr_t)function_pointer);
glExtractComponentEXT(res, src, num);
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGenSymbolsEXT(JNIEnv *env, jclass clazz, jint dataType, jint storageType, jint range, jint components, jlong function_pointer) {
glGenSymbolsEXTPROC glGenSymbolsEXT = (glGenSymbolsEXTPROC)((intptr_t)function_pointer);
GLuint __result = glGenSymbolsEXT(dataType, storageType, range, components);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglSetInvariantEXT(JNIEnv *env, jclass clazz, jint id, jint type, jobject pAddr, jint pAddr_position, jlong function_pointer) {
const GLvoid *pAddr_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pAddr)) + pAddr_position));
glSetInvariantEXTPROC glSetInvariantEXT = (glSetInvariantEXTPROC)((intptr_t)function_pointer);
glSetInvariantEXT(id, type, pAddr_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglSetLocalConstantEXT(JNIEnv *env, jclass clazz, jint id, jint type, jobject pAddr, jint pAddr_position, jlong function_pointer) {
const GLvoid *pAddr_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pAddr)) + pAddr_position));
glSetLocalConstantEXTPROC glSetLocalConstantEXT = (glSetLocalConstantEXTPROC)((intptr_t)function_pointer);
glSetLocalConstantEXT(id, type, pAddr_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglVariantbvEXT(JNIEnv *env, jclass clazz, jint id, jobject pAddr, jint pAddr_position, jlong function_pointer) {
const GLbyte *pAddr_address = ((const GLbyte *)(*env)->GetDirectBufferAddress(env, pAddr)) + pAddr_position;
glVariantbvEXTPROC glVariantbvEXT = (glVariantbvEXTPROC)((intptr_t)function_pointer);
glVariantbvEXT(id, pAddr_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglVariantsvEXT(JNIEnv *env, jclass clazz, jint id, jobject pAddr, jint pAddr_position, jlong function_pointer) {
const GLshort *pAddr_address = ((const GLshort *)(*env)->GetDirectBufferAddress(env, pAddr)) + pAddr_position;
glVariantsvEXTPROC glVariantsvEXT = (glVariantsvEXTPROC)((intptr_t)function_pointer);
glVariantsvEXT(id, pAddr_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglVariantivEXT(JNIEnv *env, jclass clazz, jint id, jobject pAddr, jint pAddr_position, jlong function_pointer) {
const GLint *pAddr_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, pAddr)) + pAddr_position;
glVariantivEXTPROC glVariantivEXT = (glVariantivEXTPROC)((intptr_t)function_pointer);
glVariantivEXT(id, pAddr_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglVariantfvEXT(JNIEnv *env, jclass clazz, jint id, jobject pAddr, jint pAddr_position, jlong function_pointer) {
const GLfloat *pAddr_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, pAddr)) + pAddr_position;
glVariantfvEXTPROC glVariantfvEXT = (glVariantfvEXTPROC)((intptr_t)function_pointer);
glVariantfvEXT(id, pAddr_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglVariantdvEXT(JNIEnv *env, jclass clazz, jint id, jobject pAddr, jint pAddr_position, jlong function_pointer) {
const GLdouble *pAddr_address = ((const GLdouble *)(*env)->GetDirectBufferAddress(env, pAddr)) + pAddr_position;
glVariantdvEXTPROC glVariantdvEXT = (glVariantdvEXTPROC)((intptr_t)function_pointer);
glVariantdvEXT(id, pAddr_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglVariantubvEXT(JNIEnv *env, jclass clazz, jint id, jobject pAddr, jint pAddr_position, jlong function_pointer) {
const GLubyte *pAddr_address = ((const GLubyte *)(*env)->GetDirectBufferAddress(env, pAddr)) + pAddr_position;
glVariantubvEXTPROC glVariantubvEXT = (glVariantubvEXTPROC)((intptr_t)function_pointer);
glVariantubvEXT(id, pAddr_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglVariantusvEXT(JNIEnv *env, jclass clazz, jint id, jobject pAddr, jint pAddr_position, jlong function_pointer) {
const GLushort *pAddr_address = ((const GLushort *)(*env)->GetDirectBufferAddress(env, pAddr)) + pAddr_position;
glVariantusvEXTPROC glVariantusvEXT = (glVariantusvEXTPROC)((intptr_t)function_pointer);
glVariantusvEXT(id, pAddr_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglVariantuivEXT(JNIEnv *env, jclass clazz, jint id, jobject pAddr, jint pAddr_position, jlong function_pointer) {
const GLuint *pAddr_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, pAddr)) + pAddr_position;
glVariantuivEXTPROC glVariantuivEXT = (glVariantuivEXTPROC)((intptr_t)function_pointer);
glVariantuivEXT(id, pAddr_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglVariantPointerEXT(JNIEnv *env, jclass clazz, jint id, jint type, jint stride, jobject pAddr, jint pAddr_position, jlong function_pointer) {
const GLvoid *pAddr_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pAddr)) + pAddr_position));
glVariantPointerEXTPROC glVariantPointerEXT = (glVariantPointerEXTPROC)((intptr_t)function_pointer);
glVariantPointerEXT(id, type, stride, pAddr_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglVariantPointerEXTBO(JNIEnv *env, jclass clazz, jint id, jint type, jint stride, jlong pAddr_buffer_offset, jlong function_pointer) {
const GLvoid *pAddr_address = ((const GLvoid *)offsetToPointer(pAddr_buffer_offset));
glVariantPointerEXTPROC glVariantPointerEXT = (glVariantPointerEXTPROC)((intptr_t)function_pointer);
glVariantPointerEXT(id, type, stride, pAddr_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglEnableVariantClientStateEXT(JNIEnv *env, jclass clazz, jint id, jlong function_pointer) {
glEnableVariantClientStateEXTPROC glEnableVariantClientStateEXT = (glEnableVariantClientStateEXTPROC)((intptr_t)function_pointer);
glEnableVariantClientStateEXT(id);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglDisableVariantClientStateEXT(JNIEnv *env, jclass clazz, jint id, jlong function_pointer) {
glDisableVariantClientStateEXTPROC glDisableVariantClientStateEXT = (glDisableVariantClientStateEXTPROC)((intptr_t)function_pointer);
glDisableVariantClientStateEXT(id);
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglBindLightParameterEXT(JNIEnv *env, jclass clazz, jint light, jint value, jlong function_pointer) {
glBindLightParameterEXTPROC glBindLightParameterEXT = (glBindLightParameterEXTPROC)((intptr_t)function_pointer);
GLuint __result = glBindLightParameterEXT(light, value);
return __result;
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglBindMaterialParameterEXT(JNIEnv *env, jclass clazz, jint face, jint value, jlong function_pointer) {
glBindMaterialParameterEXTPROC glBindMaterialParameterEXT = (glBindMaterialParameterEXTPROC)((intptr_t)function_pointer);
GLuint __result = glBindMaterialParameterEXT(face, value);
return __result;
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglBindTexGenParameterEXT(JNIEnv *env, jclass clazz, jint unit, jint coord, jint value, jlong function_pointer) {
glBindTexGenParameterEXTPROC glBindTexGenParameterEXT = (glBindTexGenParameterEXTPROC)((intptr_t)function_pointer);
GLuint __result = glBindTexGenParameterEXT(unit, coord, value);
return __result;
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglBindTextureUnitParameterEXT(JNIEnv *env, jclass clazz, jint unit, jint value, jlong function_pointer) {
glBindTextureUnitParameterEXTPROC glBindTextureUnitParameterEXT = (glBindTextureUnitParameterEXTPROC)((intptr_t)function_pointer);
GLuint __result = glBindTextureUnitParameterEXT(unit, value);
return __result;
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglBindParameterEXT(JNIEnv *env, jclass clazz, jint value, jlong function_pointer) {
glBindParameterEXTPROC glBindParameterEXT = (glBindParameterEXTPROC)((intptr_t)function_pointer);
GLuint __result = glBindParameterEXT(value);
return __result;
}
JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglIsVariantEnabledEXT(JNIEnv *env, jclass clazz, jint id, jint cap, jlong function_pointer) {
glIsVariantEnabledEXTPROC glIsVariantEnabledEXT = (glIsVariantEnabledEXTPROC)((intptr_t)function_pointer);
GLboolean __result = glIsVariantEnabledEXT(id, cap);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGetVariantBooleanvEXT(JNIEnv *env, jclass clazz, jint id, jint value, jobject pbData, jint pbData_position, jlong function_pointer) {
GLbyte *pbData_address = ((GLbyte *)(*env)->GetDirectBufferAddress(env, pbData)) + pbData_position;
glGetVariantBooleanvEXTPROC glGetVariantBooleanvEXT = (glGetVariantBooleanvEXTPROC)((intptr_t)function_pointer);
glGetVariantBooleanvEXT(id, value, pbData_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGetVariantIntegervEXT(JNIEnv *env, jclass clazz, jint id, jint value, jobject pbData, jint pbData_position, jlong function_pointer) {
GLint *pbData_address = ((GLint *)(*env)->GetDirectBufferAddress(env, pbData)) + pbData_position;
glGetVariantIntegervEXTPROC glGetVariantIntegervEXT = (glGetVariantIntegervEXTPROC)((intptr_t)function_pointer);
glGetVariantIntegervEXT(id, value, pbData_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGetVariantFloatvEXT(JNIEnv *env, jclass clazz, jint id, jint value, jobject pbData, jint pbData_position, jlong function_pointer) {
GLfloat *pbData_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, pbData)) + pbData_position;
glGetVariantFloatvEXTPROC glGetVariantFloatvEXT = (glGetVariantFloatvEXTPROC)((intptr_t)function_pointer);
glGetVariantFloatvEXT(id, value, pbData_address);
}
JNIEXPORT jobject JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGetVariantPointervEXT(JNIEnv *env, jclass clazz, jint id, jint value, jlong result_size, jlong function_pointer) {
glGetVariantPointervEXTPROC glGetVariantPointervEXT = (glGetVariantPointervEXTPROC)((intptr_t)function_pointer);
GLvoid * __result;
glGetVariantPointervEXT(id, value, &__result);
return safeNewBuffer(env, __result, result_size);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGetInvariantBooleanvEXT(JNIEnv *env, jclass clazz, jint id, jint value, jobject pbData, jint pbData_position, jlong function_pointer) {
GLbyte *pbData_address = ((GLbyte *)(*env)->GetDirectBufferAddress(env, pbData)) + pbData_position;
glGetInvariantBooleanvEXTPROC glGetInvariantBooleanvEXT = (glGetInvariantBooleanvEXTPROC)((intptr_t)function_pointer);
glGetInvariantBooleanvEXT(id, value, pbData_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGetInvariantIntegervEXT(JNIEnv *env, jclass clazz, jint id, jint value, jobject pbData, jint pbData_position, jlong function_pointer) {
GLint *pbData_address = ((GLint *)(*env)->GetDirectBufferAddress(env, pbData)) + pbData_position;
glGetInvariantIntegervEXTPROC glGetInvariantIntegervEXT = (glGetInvariantIntegervEXTPROC)((intptr_t)function_pointer);
glGetInvariantIntegervEXT(id, value, pbData_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGetInvariantFloatvEXT(JNIEnv *env, jclass clazz, jint id, jint value, jobject pbData, jint pbData_position, jlong function_pointer) {
GLfloat *pbData_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, pbData)) + pbData_position;
glGetInvariantFloatvEXTPROC glGetInvariantFloatvEXT = (glGetInvariantFloatvEXTPROC)((intptr_t)function_pointer);
glGetInvariantFloatvEXT(id, value, pbData_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGetLocalConstantBooleanvEXT(JNIEnv *env, jclass clazz, jint id, jint value, jobject pbData, jint pbData_position, jlong function_pointer) {
GLbyte *pbData_address = ((GLbyte *)(*env)->GetDirectBufferAddress(env, pbData)) + pbData_position;
glGetLocalConstantBooleanvEXTPROC glGetLocalConstantBooleanvEXT = (glGetLocalConstantBooleanvEXTPROC)((intptr_t)function_pointer);
glGetLocalConstantBooleanvEXT(id, value, pbData_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGetLocalConstantIntegervEXT(JNIEnv *env, jclass clazz, jint id, jint value, jobject pbData, jint pbData_position, jlong function_pointer) {
GLint *pbData_address = ((GLint *)(*env)->GetDirectBufferAddress(env, pbData)) + pbData_position;
glGetLocalConstantIntegervEXTPROC glGetLocalConstantIntegervEXT = (glGetLocalConstantIntegervEXTPROC)((intptr_t)function_pointer);
glGetLocalConstantIntegervEXT(id, value, pbData_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGetLocalConstantFloatvEXT(JNIEnv *env, jclass clazz, jint id, jint value, jobject pbData, jint pbData_position, jlong function_pointer) {
GLfloat *pbData_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, pbData)) + pbData_position;
glGetLocalConstantFloatvEXTPROC glGetLocalConstantFloatvEXT = (glGetLocalConstantFloatvEXTPROC)((intptr_t)function_pointer);
glGetLocalConstantFloatvEXT(id, value, pbData_address);
}

25
src/native/generated/org_lwjgl_opengl_EXTVertexWeighting.c
View file

@ -1,25 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glVertexWeightfEXTPROC) (GLfloat weight);
typedef void (APIENTRY *glVertexWeightPointerEXTPROC) (GLsizei size, GLenum type, GLsizei stride, const GLvoid * pPointer);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexWeighting_nglVertexWeightfEXT(JNIEnv *env, jclass clazz, jfloat weight, jlong function_pointer) {
glVertexWeightfEXTPROC glVertexWeightfEXT = (glVertexWeightfEXTPROC)((intptr_t)function_pointer);
glVertexWeightfEXT(weight);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexWeighting_nglVertexWeightPointerEXT(JNIEnv *env, jclass clazz, jint size, jint type, jint stride, jobject pPointer, jint pPointer_position, jlong function_pointer) {
const GLvoid *pPointer_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pPointer)) + pPointer_position));
glVertexWeightPointerEXTPROC glVertexWeightPointerEXT = (glVertexWeightPointerEXTPROC)((intptr_t)function_pointer);
glVertexWeightPointerEXT(size, type, stride, pPointer_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexWeighting_nglVertexWeightPointerEXTBO(JNIEnv *env, jclass clazz, jint size, jint type, jint stride, jlong pPointer_buffer_offset, jlong function_pointer) {
const GLvoid *pPointer_address = ((const GLvoid *)offsetToPointer(pPointer_buffer_offset));
glVertexWeightPointerEXTPROC glVertexWeightPointerEXT = (glVertexWeightPointerEXTPROC)((intptr_t)function_pointer);
glVertexWeightPointerEXT(size, type, stride, pPointer_address);
}

1599
src/native/generated/org_lwjgl_opengl_GL11.c
View file

File diff suppressed because it is too large Load diff

51
src/native/generated/org_lwjgl_opengl_GL12.c
View file

@ -1,51 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glDrawRangeElementsPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices);
typedef void (APIENTRY *glTexImage3DPROC) (GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels);
typedef void (APIENTRY *glTexSubImage3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels);
typedef void (APIENTRY *glCopyTexSubImage3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL12_nglDrawRangeElements(JNIEnv *env, jclass clazz, jint mode, jint start, jint end, jint count, jint type, jobject indices, jint indices_position, jlong function_pointer) {
const GLvoid *indices_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, indices)) + indices_position));
glDrawRangeElementsPROC glDrawRangeElements = (glDrawRangeElementsPROC)((intptr_t)function_pointer);
glDrawRangeElements(mode, start, end, count, type, indices_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL12_nglDrawRangeElementsBO(JNIEnv *env, jclass clazz, jint mode, jint start, jint end, jint count, jint type, jlong indices_buffer_offset, jlong function_pointer) {
const GLvoid *indices_address = ((const GLvoid *)offsetToPointer(indices_buffer_offset));
glDrawRangeElementsPROC glDrawRangeElements = (glDrawRangeElementsPROC)((intptr_t)function_pointer);
glDrawRangeElements(mode, start, end, count, type, indices_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL12_nglTexImage3D(JNIEnv *env, jclass clazz, jint target, jint level, jint internalFormat, jint width, jint height, jint depth, jint border, jint format, jint type, jobject pixels, jint pixels_position, jlong function_pointer) {
const GLvoid *pixels_address = ((const GLvoid *)(((char *)safeGetBufferAddress(env, pixels)) + pixels_position));
glTexImage3DPROC glTexImage3D = (glTexImage3DPROC)((intptr_t)function_pointer);
glTexImage3D(target, level, internalFormat, width, height, depth, border, format, type, pixels_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL12_nglTexImage3DBO(JNIEnv *env, jclass clazz, jint target, jint level, jint internalFormat, jint width, jint height, jint depth, jint border, jint format, jint type, jlong pixels_buffer_offset, jlong function_pointer) {
const GLvoid *pixels_address = ((const GLvoid *)offsetToPointer(pixels_buffer_offset));
glTexImage3DPROC glTexImage3D = (glTexImage3DPROC)((intptr_t)function_pointer);
glTexImage3D(target, level, internalFormat, width, height, depth, border, format, type, pixels_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL12_nglTexSubImage3D(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint yoffset, jint zoffset, jint width, jint height, jint depth, jint format, jint type, jobject pixels, jint pixels_position, jlong function_pointer) {
const GLvoid *pixels_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pixels)) + pixels_position));
glTexSubImage3DPROC glTexSubImage3D = (glTexSubImage3DPROC)((intptr_t)function_pointer);
glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL12_nglTexSubImage3DBO(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint yoffset, jint zoffset, jint width, jint height, jint depth, jint format, jint type, jlong pixels_buffer_offset, jlong function_pointer) {
const GLvoid *pixels_address = ((const GLvoid *)offsetToPointer(pixels_buffer_offset));
glTexSubImage3DPROC glTexSubImage3D = (glTexSubImage3DPROC)((intptr_t)function_pointer);
glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL12_nglCopyTexSubImage3D(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint yoffset, jint zoffset, jint x, jint y, jint width, jint height, jlong function_pointer) {
glCopyTexSubImage3DPROC glCopyTexSubImage3D = (glCopyTexSubImage3DPROC)((intptr_t)function_pointer);
glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}

191
src/native/generated/org_lwjgl_opengl_GL13.c
View file

@ -1,191 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glActiveTexturePROC) (GLenum texture);
typedef void (APIENTRY *glClientActiveTexturePROC) (GLenum texture);
typedef void (APIENTRY *glCompressedTexImage1DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * data);
typedef void (APIENTRY *glCompressedTexImage2DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data);
typedef void (APIENTRY *glCompressedTexImage3DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data);
typedef void (APIENTRY *glCompressedTexSubImage1DPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * data);
typedef void (APIENTRY *glCompressedTexSubImage2DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data);
typedef void (APIENTRY *glCompressedTexSubImage3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data);
typedef void (APIENTRY *glGetCompressedTexImagePROC) (GLenum target, GLint lod, GLvoid * img);
typedef void (APIENTRY *glMultiTexCoord1fPROC) (GLenum target, GLfloat s);
typedef void (APIENTRY *glMultiTexCoord1dPROC) (GLenum target, GLdouble s);
typedef void (APIENTRY *glMultiTexCoord2fPROC) (GLenum target, GLfloat s, GLfloat t);
typedef void (APIENTRY *glMultiTexCoord2dPROC) (GLenum target, GLdouble s, GLdouble t);
typedef void (APIENTRY *glMultiTexCoord3fPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r);
typedef void (APIENTRY *glMultiTexCoord3dPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r);
typedef void (APIENTRY *glMultiTexCoord4fPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
typedef void (APIENTRY *glMultiTexCoord4dPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
typedef void (APIENTRY *glLoadTransposeMatrixfPROC) (const GLfloat * m);
typedef void (APIENTRY *glLoadTransposeMatrixdPROC) (const GLdouble * m);
typedef void (APIENTRY *glMultTransposeMatrixfPROC) (const GLfloat * m);
typedef void (APIENTRY *glMultTransposeMatrixdPROC) (const GLdouble * m);
typedef void (APIENTRY *glSampleCoveragePROC) (GLclampf value, GLboolean invert);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglActiveTexture(JNIEnv *env, jclass clazz, jint texture, jlong function_pointer) {
glActiveTexturePROC glActiveTexture = (glActiveTexturePROC)((intptr_t)function_pointer);
glActiveTexture(texture);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglClientActiveTexture(JNIEnv *env, jclass clazz, jint texture, jlong function_pointer) {
glClientActiveTexturePROC glClientActiveTexture = (glClientActiveTexturePROC)((intptr_t)function_pointer);
glClientActiveTexture(texture);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexImage1D(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint border, jint imageSize, jobject data, jint data_position, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
glCompressedTexImage1DPROC glCompressedTexImage1D = (glCompressedTexImage1DPROC)((intptr_t)function_pointer);
glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexImage1DBO(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint border, jint imageSize, jlong data_buffer_offset, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)offsetToPointer(data_buffer_offset));
glCompressedTexImage1DPROC glCompressedTexImage1D = (glCompressedTexImage1DPROC)((intptr_t)function_pointer);
glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexImage2D(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint imageSize, jobject data, jint data_position, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
glCompressedTexImage2DPROC glCompressedTexImage2D = (glCompressedTexImage2DPROC)((intptr_t)function_pointer);
glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexImage2DBO(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint imageSize, jlong data_buffer_offset, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)offsetToPointer(data_buffer_offset));
glCompressedTexImage2DPROC glCompressedTexImage2D = (glCompressedTexImage2DPROC)((intptr_t)function_pointer);
glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexImage3D(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint height, jint depth, jint border, jint imageSize, jobject data, jint data_position, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
glCompressedTexImage3DPROC glCompressedTexImage3D = (glCompressedTexImage3DPROC)((intptr_t)function_pointer);
glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexImage3DBO(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint height, jint depth, jint border, jint imageSize, jlong data_buffer_offset, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)offsetToPointer(data_buffer_offset));
glCompressedTexImage3DPROC glCompressedTexImage3D = (glCompressedTexImage3DPROC)((intptr_t)function_pointer);
glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexSubImage1D(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint width, jint format, jint imageSize, jobject data, jint data_position, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
glCompressedTexSubImage1DPROC glCompressedTexSubImage1D = (glCompressedTexSubImage1DPROC)((intptr_t)function_pointer);
glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexSubImage1DBO(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint width, jint format, jint imageSize, jlong data_buffer_offset, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)offsetToPointer(data_buffer_offset));
glCompressedTexSubImage1DPROC glCompressedTexSubImage1D = (glCompressedTexSubImage1DPROC)((intptr_t)function_pointer);
glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexSubImage2D(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint yoffset, jint width, jint height, jint format, jint imageSize, jobject data, jint data_position, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
glCompressedTexSubImage2DPROC glCompressedTexSubImage2D = (glCompressedTexSubImage2DPROC)((intptr_t)function_pointer);
glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexSubImage2DBO(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint yoffset, jint width, jint height, jint format, jint imageSize, jlong data_buffer_offset, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)offsetToPointer(data_buffer_offset));
glCompressedTexSubImage2DPROC glCompressedTexSubImage2D = (glCompressedTexSubImage2DPROC)((intptr_t)function_pointer);
glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexSubImage3D(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint yoffset, jint zoffset, jint width, jint height, jint depth, jint format, jint imageSize, jobject data, jint data_position, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
glCompressedTexSubImage3DPROC glCompressedTexSubImage3D = (glCompressedTexSubImage3DPROC)((intptr_t)function_pointer);
glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexSubImage3DBO(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint yoffset, jint zoffset, jint width, jint height, jint depth, jint format, jint imageSize, jlong data_buffer_offset, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)offsetToPointer(data_buffer_offset));
glCompressedTexSubImage3DPROC glCompressedTexSubImage3D = (glCompressedTexSubImage3DPROC)((intptr_t)function_pointer);
glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglGetCompressedTexImage(JNIEnv *env, jclass clazz, jint target, jint lod, jobject img, jint img_position, jlong function_pointer) {
GLvoid *img_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, img)) + img_position));
glGetCompressedTexImagePROC glGetCompressedTexImage = (glGetCompressedTexImagePROC)((intptr_t)function_pointer);
glGetCompressedTexImage(target, lod, img_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglGetCompressedTexImageBO(JNIEnv *env, jclass clazz, jint target, jint lod, jlong img_buffer_offset, jlong function_pointer) {
GLvoid *img_address = ((GLvoid *)offsetToPointer(img_buffer_offset));
glGetCompressedTexImagePROC glGetCompressedTexImage = (glGetCompressedTexImagePROC)((intptr_t)function_pointer);
glGetCompressedTexImage(target, lod, img_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglMultiTexCoord1f(JNIEnv *env, jclass clazz, jint target, jfloat s, jlong function_pointer) {
glMultiTexCoord1fPROC glMultiTexCoord1f = (glMultiTexCoord1fPROC)((intptr_t)function_pointer);
glMultiTexCoord1f(target, s);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglMultiTexCoord1d(JNIEnv *env, jclass clazz, jint target, jdouble s, jlong function_pointer) {
glMultiTexCoord1dPROC glMultiTexCoord1d = (glMultiTexCoord1dPROC)((intptr_t)function_pointer);
glMultiTexCoord1d(target, s);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglMultiTexCoord2f(JNIEnv *env, jclass clazz, jint target, jfloat s, jfloat t, jlong function_pointer) {
glMultiTexCoord2fPROC glMultiTexCoord2f = (glMultiTexCoord2fPROC)((intptr_t)function_pointer);
glMultiTexCoord2f(target, s, t);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglMultiTexCoord2d(JNIEnv *env, jclass clazz, jint target, jdouble s, jdouble t, jlong function_pointer) {
glMultiTexCoord2dPROC glMultiTexCoord2d = (glMultiTexCoord2dPROC)((intptr_t)function_pointer);
glMultiTexCoord2d(target, s, t);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglMultiTexCoord3f(JNIEnv *env, jclass clazz, jint target, jfloat s, jfloat t, jfloat r, jlong function_pointer) {
glMultiTexCoord3fPROC glMultiTexCoord3f = (glMultiTexCoord3fPROC)((intptr_t)function_pointer);
glMultiTexCoord3f(target, s, t, r);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglMultiTexCoord3d(JNIEnv *env, jclass clazz, jint target, jdouble s, jdouble t, jdouble r, jlong function_pointer) {
glMultiTexCoord3dPROC glMultiTexCoord3d = (glMultiTexCoord3dPROC)((intptr_t)function_pointer);
glMultiTexCoord3d(target, s, t, r);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglMultiTexCoord4f(JNIEnv *env, jclass clazz, jint target, jfloat s, jfloat t, jfloat r, jfloat q, jlong function_pointer) {
glMultiTexCoord4fPROC glMultiTexCoord4f = (glMultiTexCoord4fPROC)((intptr_t)function_pointer);
glMultiTexCoord4f(target, s, t, r, q);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglMultiTexCoord4d(JNIEnv *env, jclass clazz, jint target, jdouble s, jdouble t, jdouble r, jdouble q, jlong function_pointer) {
glMultiTexCoord4dPROC glMultiTexCoord4d = (glMultiTexCoord4dPROC)((intptr_t)function_pointer);
glMultiTexCoord4d(target, s, t, r, q);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglLoadTransposeMatrixf(JNIEnv *env, jclass clazz, jobject m, jint m_position, jlong function_pointer) {
const GLfloat *m_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, m)) + m_position;
glLoadTransposeMatrixfPROC glLoadTransposeMatrixf = (glLoadTransposeMatrixfPROC)((intptr_t)function_pointer);
glLoadTransposeMatrixf(m_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglLoadTransposeMatrixd(JNIEnv *env, jclass clazz, jobject m, jint m_position, jlong function_pointer) {
const GLdouble *m_address = ((const GLdouble *)(*env)->GetDirectBufferAddress(env, m)) + m_position;
glLoadTransposeMatrixdPROC glLoadTransposeMatrixd = (glLoadTransposeMatrixdPROC)((intptr_t)function_pointer);
glLoadTransposeMatrixd(m_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglMultTransposeMatrixf(JNIEnv *env, jclass clazz, jobject m, jint m_position, jlong function_pointer) {
const GLfloat *m_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, m)) + m_position;
glMultTransposeMatrixfPROC glMultTransposeMatrixf = (glMultTransposeMatrixfPROC)((intptr_t)function_pointer);
glMultTransposeMatrixf(m_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglMultTransposeMatrixd(JNIEnv *env, jclass clazz, jobject m, jint m_position, jlong function_pointer) {
const GLdouble *m_address = ((const GLdouble *)(*env)->GetDirectBufferAddress(env, m)) + m_position;
glMultTransposeMatrixdPROC glMultTransposeMatrixd = (glMultTransposeMatrixdPROC)((intptr_t)function_pointer);
glMultTransposeMatrixd(m_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglSampleCoverage(JNIEnv *env, jclass clazz, jfloat value, jboolean invert, jlong function_pointer) {
glSampleCoveragePROC glSampleCoverage = (glSampleCoveragePROC)((intptr_t)function_pointer);
glSampleCoverage(value, invert);
}

156
src/native/generated/org_lwjgl_opengl_GL14.c
View file

@ -1,156 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glBlendEquationPROC) (GLenum mode);
typedef void (APIENTRY *glBlendColorPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
typedef void (APIENTRY *glFogCoordfPROC) (GLfloat coord);
typedef void (APIENTRY *glFogCoorddPROC) (GLdouble coord);
typedef void (APIENTRY *glFogCoordPointerPROC) (GLenum type, GLsizei stride, const GLvoid * data);
typedef void (APIENTRY *glMultiDrawArraysPROC) (GLenum mode, GLint * piFirst, GLsizei * piCount, GLsizei primcount);
typedef void (APIENTRY *glPointParameteriPROC) (GLenum pname, GLint param);
typedef void (APIENTRY *glPointParameterfPROC) (GLenum pname, GLfloat param);
typedef void (APIENTRY *glPointParameterivPROC) (GLenum pname, const GLint * params);
typedef void (APIENTRY *glPointParameterfvPROC) (GLenum pname, const GLfloat * params);
typedef void (APIENTRY *glSecondaryColor3bPROC) (GLbyte red, GLbyte green, GLbyte blue);
typedef void (APIENTRY *glSecondaryColor3fPROC) (GLfloat red, GLfloat green, GLfloat blue);
typedef void (APIENTRY *glSecondaryColor3dPROC) (GLdouble red, GLdouble green, GLdouble blue);
typedef void (APIENTRY *glSecondaryColor3ubPROC) (GLubyte red, GLubyte green, GLubyte blue);
typedef void (APIENTRY *glSecondaryColorPointerPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid * data);
typedef void (APIENTRY *glBlendFuncSeparatePROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
typedef void (APIENTRY *glWindowPos2fPROC) (GLfloat x, GLfloat y);
typedef void (APIENTRY *glWindowPos2dPROC) (GLdouble x, GLdouble y);
typedef void (APIENTRY *glWindowPos2iPROC) (GLint x, GLint y);
typedef void (APIENTRY *glWindowPos3fPROC) (GLfloat x, GLfloat y, GLfloat z);
typedef void (APIENTRY *glWindowPos3dPROC) (GLdouble x, GLdouble y, GLdouble z);
typedef void (APIENTRY *glWindowPos3iPROC) (GLint x, GLint y, GLint z);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglBlendEquation(JNIEnv *env, jclass clazz, jint mode, jlong function_pointer) {
glBlendEquationPROC glBlendEquation = (glBlendEquationPROC)((intptr_t)function_pointer);
glBlendEquation(mode);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglBlendColor(JNIEnv *env, jclass clazz, jfloat red, jfloat green, jfloat blue, jfloat alpha, jlong function_pointer) {
glBlendColorPROC glBlendColor = (glBlendColorPROC)((intptr_t)function_pointer);
glBlendColor(red, green, blue, alpha);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglFogCoordf(JNIEnv *env, jclass clazz, jfloat coord, jlong function_pointer) {
glFogCoordfPROC glFogCoordf = (glFogCoordfPROC)((intptr_t)function_pointer);
glFogCoordf(coord);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglFogCoordd(JNIEnv *env, jclass clazz, jdouble coord, jlong function_pointer) {
glFogCoorddPROC glFogCoordd = (glFogCoorddPROC)((intptr_t)function_pointer);
glFogCoordd(coord);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglFogCoordPointer(JNIEnv *env, jclass clazz, jint type, jint stride, jobject data, jint data_position, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
glFogCoordPointerPROC glFogCoordPointer = (glFogCoordPointerPROC)((intptr_t)function_pointer);
glFogCoordPointer(type, stride, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglFogCoordPointerBO(JNIEnv *env, jclass clazz, jint type, jint stride, jlong data_buffer_offset, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)offsetToPointer(data_buffer_offset));
glFogCoordPointerPROC glFogCoordPointer = (glFogCoordPointerPROC)((intptr_t)function_pointer);
glFogCoordPointer(type, stride, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglMultiDrawArrays(JNIEnv *env, jclass clazz, jint mode, jobject piFirst, jint piFirst_position, jobject piCount, jint piCount_position, jint primcount, jlong function_pointer) {
GLint *piFirst_address = ((GLint *)(*env)->GetDirectBufferAddress(env, piFirst)) + piFirst_position;
GLsizei *piCount_address = ((GLsizei *)(*env)->GetDirectBufferAddress(env, piCount)) + piCount_position;
glMultiDrawArraysPROC glMultiDrawArrays = (glMultiDrawArraysPROC)((intptr_t)function_pointer);
glMultiDrawArrays(mode, piFirst_address, piCount_address, primcount);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglPointParameteri(JNIEnv *env, jclass clazz, jint pname, jint param, jlong function_pointer) {
glPointParameteriPROC glPointParameteri = (glPointParameteriPROC)((intptr_t)function_pointer);
glPointParameteri(pname, param);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglPointParameterf(JNIEnv *env, jclass clazz, jint pname, jfloat param, jlong function_pointer) {
glPointParameterfPROC glPointParameterf = (glPointParameterfPROC)((intptr_t)function_pointer);
glPointParameterf(pname, param);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglPointParameteriv(JNIEnv *env, jclass clazz, jint pname, jobject params, jint params_position, jlong function_pointer) {
const GLint *params_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glPointParameterivPROC glPointParameteriv = (glPointParameterivPROC)((intptr_t)function_pointer);
glPointParameteriv(pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglPointParameterfv(JNIEnv *env, jclass clazz, jint pname, jobject params, jint params_position, jlong function_pointer) {
const GLfloat *params_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glPointParameterfvPROC glPointParameterfv = (glPointParameterfvPROC)((intptr_t)function_pointer);
glPointParameterfv(pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglSecondaryColor3b(JNIEnv *env, jclass clazz, jbyte red, jbyte green, jbyte blue, jlong function_pointer) {
glSecondaryColor3bPROC glSecondaryColor3b = (glSecondaryColor3bPROC)((intptr_t)function_pointer);
glSecondaryColor3b(red, green, blue);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglSecondaryColor3f(JNIEnv *env, jclass clazz, jfloat red, jfloat green, jfloat blue, jlong function_pointer) {
glSecondaryColor3fPROC glSecondaryColor3f = (glSecondaryColor3fPROC)((intptr_t)function_pointer);
glSecondaryColor3f(red, green, blue);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglSecondaryColor3d(JNIEnv *env, jclass clazz, jdouble red, jdouble green, jdouble blue, jlong function_pointer) {
glSecondaryColor3dPROC glSecondaryColor3d = (glSecondaryColor3dPROC)((intptr_t)function_pointer);
glSecondaryColor3d(red, green, blue);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglSecondaryColor3ub(JNIEnv *env, jclass clazz, jbyte red, jbyte green, jbyte blue, jlong function_pointer) {
glSecondaryColor3ubPROC glSecondaryColor3ub = (glSecondaryColor3ubPROC)((intptr_t)function_pointer);
glSecondaryColor3ub(red, green, blue);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglSecondaryColorPointer(JNIEnv *env, jclass clazz, jint size, jint type, jint stride, jobject data, jint data_position, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
glSecondaryColorPointerPROC glSecondaryColorPointer = (glSecondaryColorPointerPROC)((intptr_t)function_pointer);
glSecondaryColorPointer(size, type, stride, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglSecondaryColorPointerBO(JNIEnv *env, jclass clazz, jint size, jint type, jint stride, jlong data_buffer_offset, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)offsetToPointer(data_buffer_offset));
glSecondaryColorPointerPROC glSecondaryColorPointer = (glSecondaryColorPointerPROC)((intptr_t)function_pointer);
glSecondaryColorPointer(size, type, stride, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglBlendFuncSeparate(JNIEnv *env, jclass clazz, jint sfactorRGB, jint dfactorRGB, jint sfactorAlpha, jint dfactorAlpha, jlong function_pointer) {
glBlendFuncSeparatePROC glBlendFuncSeparate = (glBlendFuncSeparatePROC)((intptr_t)function_pointer);
glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglWindowPos2f(JNIEnv *env, jclass clazz, jfloat x, jfloat y, jlong function_pointer) {
glWindowPos2fPROC glWindowPos2f = (glWindowPos2fPROC)((intptr_t)function_pointer);
glWindowPos2f(x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglWindowPos2d(JNIEnv *env, jclass clazz, jdouble x, jdouble y, jlong function_pointer) {
glWindowPos2dPROC glWindowPos2d = (glWindowPos2dPROC)((intptr_t)function_pointer);
glWindowPos2d(x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglWindowPos2i(JNIEnv *env, jclass clazz, jint x, jint y, jlong function_pointer) {
glWindowPos2iPROC glWindowPos2i = (glWindowPos2iPROC)((intptr_t)function_pointer);
glWindowPos2i(x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglWindowPos3f(JNIEnv *env, jclass clazz, jfloat x, jfloat y, jfloat z, jlong function_pointer) {
glWindowPos3fPROC glWindowPos3f = (glWindowPos3fPROC)((intptr_t)function_pointer);
glWindowPos3f(x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglWindowPos3d(JNIEnv *env, jclass clazz, jdouble x, jdouble y, jdouble z, jlong function_pointer) {
glWindowPos3dPROC glWindowPos3d = (glWindowPos3dPROC)((intptr_t)function_pointer);
glWindowPos3d(x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglWindowPos3i(JNIEnv *env, jclass clazz, jint x, jint y, jint z, jlong function_pointer) {
glWindowPos3iPROC glWindowPos3i = (glWindowPos3iPROC)((intptr_t)function_pointer);
glWindowPos3i(x, y, z);
}

137
src/native/generated/org_lwjgl_opengl_GL15.c
View file

@ -1,137 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glBindBufferPROC) (GLenum target, GLuint buffer);
typedef void (APIENTRY *glDeleteBuffersPROC) (GLsizei n, const GLuint * buffers);
typedef void (APIENTRY *glGenBuffersPROC) (GLsizei n, GLuint * buffers);
typedef GLboolean (APIENTRY *glIsBufferPROC) (GLuint buffer);
typedef void (APIENTRY *glBufferDataPROC) (GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage);
typedef void (APIENTRY *glBufferSubDataPROC) (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data);
typedef void (APIENTRY *glGetBufferSubDataPROC) (GLenum target, GLintptr offset, GLsizeiptr size, GLvoid * data);
typedef GLvoid * (APIENTRY *glMapBufferPROC) (GLenum target, GLenum access);
typedef GLboolean (APIENTRY *glUnmapBufferPROC) (GLenum target);
typedef void (APIENTRY *glGetBufferParameterivPROC) (GLenum target, GLenum pname, GLint * params);
typedef void (APIENTRY *glGetBufferPointervPROC) (GLenum target, GLenum pname, GLvoid ** pointer);
typedef void (APIENTRY *glGenQueriesPROC) (GLsizei n, GLuint * ids);
typedef void (APIENTRY *glDeleteQueriesPROC) (GLsizei n, GLuint * ids);
typedef GLboolean (APIENTRY *glIsQueryPROC) (GLuint id);
typedef void (APIENTRY *glBeginQueryPROC) (GLenum target, GLuint id);
typedef void (APIENTRY *glEndQueryPROC) (GLenum target);
typedef void (APIENTRY *glGetQueryivPROC) (GLenum target, GLenum pname, GLint * params);
typedef void (APIENTRY *glGetQueryObjectivPROC) (GLenum id, GLenum pname, GLint * params);
typedef void (APIENTRY *glGetQueryObjectuivPROC) (GLenum id, GLenum pname, GLuint * params);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglBindBuffer(JNIEnv *env, jclass clazz, jint target, jint buffer, jlong function_pointer) {
glBindBufferPROC glBindBuffer = (glBindBufferPROC)((intptr_t)function_pointer);
glBindBuffer(target, buffer);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglDeleteBuffers(JNIEnv *env, jclass clazz, jint n, jobject buffers, jint buffers_position, jlong function_pointer) {
const GLuint *buffers_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, buffers)) + buffers_position;
glDeleteBuffersPROC glDeleteBuffers = (glDeleteBuffersPROC)((intptr_t)function_pointer);
glDeleteBuffers(n, buffers_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglGenBuffers(JNIEnv *env, jclass clazz, jint n, jobject buffers, jint buffers_position, jlong function_pointer) {
GLuint *buffers_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, buffers)) + buffers_position;
glGenBuffersPROC glGenBuffers = (glGenBuffersPROC)((intptr_t)function_pointer);
glGenBuffers(n, buffers_address);
}
JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL15_nglIsBuffer(JNIEnv *env, jclass clazz, jint buffer, jlong function_pointer) {
glIsBufferPROC glIsBuffer = (glIsBufferPROC)((intptr_t)function_pointer);
GLboolean __result = glIsBuffer(buffer);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglBufferData(JNIEnv *env, jclass clazz, jint target, jlong size, jobject data, jint data_position, jint usage, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)(((char *)safeGetBufferAddress(env, data)) + data_position));
glBufferDataPROC glBufferData = (glBufferDataPROC)((intptr_t)function_pointer);
glBufferData(target, size, data_address, usage);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglBufferSubData(JNIEnv *env, jclass clazz, jint target, jlong offset, jlong size, jobject data, jint data_position, jlong function_pointer) {
const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
glBufferSubDataPROC glBufferSubData = (glBufferSubDataPROC)((intptr_t)function_pointer);
glBufferSubData(target, offset, size, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglGetBufferSubData(JNIEnv *env, jclass clazz, jint target, jlong offset, jlong size, jobject data, jint data_position, jlong function_pointer) {
GLvoid *data_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
glGetBufferSubDataPROC glGetBufferSubData = (glGetBufferSubDataPROC)((intptr_t)function_pointer);
glGetBufferSubData(target, offset, size, data_address);
}
JNIEXPORT jobject JNICALL Java_org_lwjgl_opengl_GL15_nglMapBuffer(JNIEnv *env, jclass clazz, jint target, jint access, jlong result_size, jobject old_buffer, jlong function_pointer) {
glMapBufferPROC glMapBuffer = (glMapBufferPROC)((intptr_t)function_pointer);
GLvoid * __result = glMapBuffer(target, access);
return safeNewBufferCached(env, __result, result_size, old_buffer);
}
JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL15_nglUnmapBuffer(JNIEnv *env, jclass clazz, jint target, jlong function_pointer) {
glUnmapBufferPROC glUnmapBuffer = (glUnmapBufferPROC)((intptr_t)function_pointer);
GLboolean __result = glUnmapBuffer(target);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglGetBufferParameteriv(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetBufferParameterivPROC glGetBufferParameteriv = (glGetBufferParameterivPROC)((intptr_t)function_pointer);
glGetBufferParameteriv(target, pname, params_address);
}
JNIEXPORT jobject JNICALL Java_org_lwjgl_opengl_GL15_nglGetBufferPointerv(JNIEnv *env, jclass clazz, jint target, jint pname, jlong result_size, jlong function_pointer) {
glGetBufferPointervPROC glGetBufferPointerv = (glGetBufferPointervPROC)((intptr_t)function_pointer);
GLvoid * __result;
glGetBufferPointerv(target, pname, &__result);
return safeNewBuffer(env, __result, result_size);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglGenQueries(JNIEnv *env, jclass clazz, jint n, jobject ids, jint ids_position, jlong function_pointer) {
GLuint *ids_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, ids)) + ids_position;
glGenQueriesPROC glGenQueries = (glGenQueriesPROC)((intptr_t)function_pointer);
glGenQueries(n, ids_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglDeleteQueries(JNIEnv *env, jclass clazz, jint n, jobject ids, jint ids_position, jlong function_pointer) {
GLuint *ids_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, ids)) + ids_position;
glDeleteQueriesPROC glDeleteQueries = (glDeleteQueriesPROC)((intptr_t)function_pointer);
glDeleteQueries(n, ids_address);
}
JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL15_nglIsQuery(JNIEnv *env, jclass clazz, jint id, jlong function_pointer) {
glIsQueryPROC glIsQuery = (glIsQueryPROC)((intptr_t)function_pointer);
GLboolean __result = glIsQuery(id);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglBeginQuery(JNIEnv *env, jclass clazz, jint target, jint id, jlong function_pointer) {
glBeginQueryPROC glBeginQuery = (glBeginQueryPROC)((intptr_t)function_pointer);
glBeginQuery(target, id);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglEndQuery(JNIEnv *env, jclass clazz, jint target, jlong function_pointer) {
glEndQueryPROC glEndQuery = (glEndQueryPROC)((intptr_t)function_pointer);
glEndQuery(target);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglGetQueryiv(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetQueryivPROC glGetQueryiv = (glGetQueryivPROC)((intptr_t)function_pointer);
glGetQueryiv(target, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglGetQueryObjectiv(JNIEnv *env, jclass clazz, jint id, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetQueryObjectivPROC glGetQueryObjectiv = (glGetQueryObjectivPROC)((intptr_t)function_pointer);
glGetQueryObjectiv(id, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglGetQueryObjectuiv(JNIEnv *env, jclass clazz, jint id, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLuint *params_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetQueryObjectuivPROC glGetQueryObjectuiv = (glGetQueryObjectuivPROC)((intptr_t)function_pointer);
glGetQueryObjectuiv(id, pname, params_address);
}

480
src/native/generated/org_lwjgl_opengl_GL20.c
View file

@ -1,480 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glShaderSourcePROC) (GLuint shader, GLsizei count, const GLchar ** string, const GLint* length);
typedef GLint (APIENTRY *glCreateShaderPROC) (GLuint type);
typedef GLboolean (APIENTRY *glIsShaderPROC) (GLuint shader);
typedef void (APIENTRY *glCompileShaderPROC) (GLuint shader);
typedef void (APIENTRY *glDeleteShaderPROC) (GLuint shader);
typedef GLint (APIENTRY *glCreateProgramPROC) ();
typedef GLboolean (APIENTRY *glIsProgramPROC) (GLint program);
typedef void (APIENTRY *glAttachShaderPROC) (GLuint program, GLuint shader);
typedef void (APIENTRY *glDetachShaderPROC) (GLuint program, GLuint shader);
typedef void (APIENTRY *glLinkProgramPROC) (GLuint program);
typedef void (APIENTRY *glUseProgramPROC) (GLuint program);
typedef void (APIENTRY *glValidateProgramPROC) (GLuint program);
typedef void (APIENTRY *glDeleteProgramPROC) (GLuint program);
typedef void (APIENTRY *glUniform1fPROC) (GLint location, GLfloat v0);
typedef void (APIENTRY *glUniform2fPROC) (GLint location, GLfloat v0, GLfloat v1);
typedef void (APIENTRY *glUniform3fPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
typedef void (APIENTRY *glUniform4fPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
typedef void (APIENTRY *glUniform1iPROC) (GLint location, GLint v0);
typedef void (APIENTRY *glUniform2iPROC) (GLint location, GLint v0, GLint v1);
typedef void (APIENTRY *glUniform3iPROC) (GLint location, GLint v0, GLint v1, GLint v2);
typedef void (APIENTRY *glUniform4iPROC) (GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
typedef void (APIENTRY *glUniform1fvPROC) (GLint location, GLsizei count, GLfloat * values);
typedef void (APIENTRY *glUniform2fvPROC) (GLint location, GLsizei count, GLfloat * values);
typedef void (APIENTRY *glUniform3fvPROC) (GLint location, GLsizei count, GLfloat * values);
typedef void (APIENTRY *glUniform4fvPROC) (GLint location, GLsizei count, GLfloat * values);
typedef void (APIENTRY *glUniform1ivPROC) (GLint location, GLsizei count, GLint * values);
typedef void (APIENTRY *glUniform2ivPROC) (GLint location, GLsizei count, GLint * values);
typedef void (APIENTRY *glUniform3ivPROC) (GLint location, GLsizei count, GLint * values);
typedef void (APIENTRY *glUniform4ivPROC) (GLint location, GLsizei count, GLint * values);
typedef void (APIENTRY *glUniformMatrix2fvPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat * matrices);
typedef void (APIENTRY *glUniformMatrix3fvPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat * matrices);
typedef void (APIENTRY *glUniformMatrix4fvPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat * matrices);
typedef void (APIENTRY *glGetShaderivPROC) (GLuint shader, GLenum pname, GLint * params);
typedef void (APIENTRY *glGetProgramivPROC) (GLuint program, GLenum pname, GLint * params);
typedef void (APIENTRY *glGetShaderInfoLogPROC) (GLuint shader, GLsizei maxLength, GLsizei * length, GLchar * infoLog);
typedef void (APIENTRY *glGetProgramInfoLogPROC) (GLuint program, GLsizei maxLength, GLsizei * length, GLchar * infoLog);
typedef void (APIENTRY *glGetAttachedShadersPROC) (GLuint program, GLsizei maxCount, GLsizei * count, GLuint * shaders);
typedef GLint (APIENTRY *glGetUniformLocationPROC) (GLuint program, const GLchar * name);
typedef void (APIENTRY *glGetActiveUniformPROC) (GLuint program, GLuint index, GLsizei maxLength, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name);
typedef void (APIENTRY *glGetUniformfvPROC) (GLuint program, GLint location, GLfloat * params);
typedef void (APIENTRY *glGetUniformivPROC) (GLuint program, GLint location, GLint * params);
typedef void (APIENTRY *glGetShaderSourcePROC) (GLuint shader, GLsizei maxLength, GLsizei * length, GLchar * source);
typedef void (APIENTRY *glVertexAttrib1sPROC) (GLuint index, GLshort x);
typedef void (APIENTRY *glVertexAttrib1fPROC) (GLuint index, GLfloat x);
typedef void (APIENTRY *glVertexAttrib1dPROC) (GLuint index, GLdouble x);
typedef void (APIENTRY *glVertexAttrib2sPROC) (GLuint index, GLshort x, GLshort y);
typedef void (APIENTRY *glVertexAttrib2fPROC) (GLuint index, GLfloat x, GLfloat y);
typedef void (APIENTRY *glVertexAttrib2dPROC) (GLuint index, GLdouble x, GLdouble y);
typedef void (APIENTRY *glVertexAttrib3sPROC) (GLuint index, GLshort x, GLshort y, GLshort z);
typedef void (APIENTRY *glVertexAttrib3fPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z);
typedef void (APIENTRY *glVertexAttrib3dPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z);
typedef void (APIENTRY *glVertexAttrib4sPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
typedef void (APIENTRY *glVertexAttrib4fPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
typedef void (APIENTRY *glVertexAttrib4dPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
typedef void (APIENTRY *glVertexAttrib4NubPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
typedef void (APIENTRY *glVertexAttribPointerPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * buffer);
typedef void (APIENTRY *glEnableVertexAttribArrayPROC) (GLuint index);
typedef void (APIENTRY *glDisableVertexAttribArrayPROC) (GLuint index);
typedef void (APIENTRY *glGetVertexAttribfvPROC) (GLuint index, GLenum pname, GLfloat * params);
typedef void (APIENTRY *glGetVertexAttribdvPROC) (GLuint index, GLenum pname, GLdouble * params);
typedef void (APIENTRY *glGetVertexAttribivPROC) (GLuint index, GLenum pname, GLint * params);
typedef void (APIENTRY *glGetVertexAttribPointervPROC) (GLuint index, GLenum pname, GLvoid ** pointer);
typedef void (APIENTRY *glBindAttribLocationPROC) (GLuint program, GLuint index, const GLchar * name);
typedef void (APIENTRY *glGetActiveAttribPROC) (GLuint program, GLuint index, GLsizei maxLength, GLsizei * length, GLint * size, GLenum * type, const GLchar * name);
typedef GLint (APIENTRY *glGetAttribLocationPROC) (GLuint program, const GLchar * name);
typedef void (APIENTRY *glDrawBuffersPROC) (GLsizei size, const GLenum * buffers);
typedef void (APIENTRY *glStencilOpSeparatePROC) (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
typedef void (APIENTRY *glStencilFuncSeparatePROC) (GLenum face, GLenum func, GLint ref, GLuint mask);
typedef void (APIENTRY *glStencilMaskSeparatePROC) (GLenum face, GLuint mask);
typedef void (APIENTRY *glBlendEquationSeparatePROC) (GLenum modeRGB, GLenum modeAlpha);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglShaderSource(JNIEnv *env, jclass clazz, jint shader, jint count, jobject string, jint string_position, jint length, jlong function_pointer) {
const GLchar *string_address = ((const GLchar *)(*env)->GetDirectBufferAddress(env, string)) + string_position;
glShaderSourcePROC glShaderSource = (glShaderSourcePROC)((intptr_t)function_pointer);
glShaderSource(shader, count, (const GLchar **)&string_address, (const GLint*)&length);
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL20_nglCreateShader(JNIEnv *env, jclass clazz, jint type, jlong function_pointer) {
glCreateShaderPROC glCreateShader = (glCreateShaderPROC)((intptr_t)function_pointer);
GLint __result = glCreateShader(type);
return __result;
}
JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL20_nglIsShader(JNIEnv *env, jclass clazz, jint shader, jlong function_pointer) {
glIsShaderPROC glIsShader = (glIsShaderPROC)((intptr_t)function_pointer);
GLboolean __result = glIsShader(shader);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglCompileShader(JNIEnv *env, jclass clazz, jint shader, jlong function_pointer) {
glCompileShaderPROC glCompileShader = (glCompileShaderPROC)((intptr_t)function_pointer);
glCompileShader(shader);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglDeleteShader(JNIEnv *env, jclass clazz, jint shader, jlong function_pointer) {
glDeleteShaderPROC glDeleteShader = (glDeleteShaderPROC)((intptr_t)function_pointer);
glDeleteShader(shader);
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL20_nglCreateProgram(JNIEnv *env, jclass clazz, jlong function_pointer) {
glCreateProgramPROC glCreateProgram = (glCreateProgramPROC)((intptr_t)function_pointer);
GLint __result = glCreateProgram();
return __result;
}
JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL20_nglIsProgram(JNIEnv *env, jclass clazz, jint program, jlong function_pointer) {
glIsProgramPROC glIsProgram = (glIsProgramPROC)((intptr_t)function_pointer);
GLboolean __result = glIsProgram(program);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglAttachShader(JNIEnv *env, jclass clazz, jint program, jint shader, jlong function_pointer) {
glAttachShaderPROC glAttachShader = (glAttachShaderPROC)((intptr_t)function_pointer);
glAttachShader(program, shader);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglDetachShader(JNIEnv *env, jclass clazz, jint program, jint shader, jlong function_pointer) {
glDetachShaderPROC glDetachShader = (glDetachShaderPROC)((intptr_t)function_pointer);
glDetachShader(program, shader);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglLinkProgram(JNIEnv *env, jclass clazz, jint program, jlong function_pointer) {
glLinkProgramPROC glLinkProgram = (glLinkProgramPROC)((intptr_t)function_pointer);
glLinkProgram(program);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglUseProgram(JNIEnv *env, jclass clazz, jint program, jlong function_pointer) {
glUseProgramPROC glUseProgram = (glUseProgramPROC)((intptr_t)function_pointer);
glUseProgram(program);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglValidateProgram(JNIEnv *env, jclass clazz, jint program, jlong function_pointer) {
glValidateProgramPROC glValidateProgram = (glValidateProgramPROC)((intptr_t)function_pointer);
glValidateProgram(program);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglDeleteProgram(JNIEnv *env, jclass clazz, jint program, jlong function_pointer) {
glDeleteProgramPROC glDeleteProgram = (glDeleteProgramPROC)((intptr_t)function_pointer);
glDeleteProgram(program);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglUniform1f(JNIEnv *env, jclass clazz, jint location, jfloat v0, jlong function_pointer) {
glUniform1fPROC glUniform1f = (glUniform1fPROC)((intptr_t)function_pointer);
glUniform1f(location, v0);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglUniform2f(JNIEnv *env, jclass clazz, jint location, jfloat v0, jfloat v1, jlong function_pointer) {
glUniform2fPROC glUniform2f = (glUniform2fPROC)((intptr_t)function_pointer);
glUniform2f(location, v0, v1);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglUniform3f(JNIEnv *env, jclass clazz, jint location, jfloat v0, jfloat v1, jfloat v2, jlong function_pointer) {
glUniform3fPROC glUniform3f = (glUniform3fPROC)((intptr_t)function_pointer);
glUniform3f(location, v0, v1, v2);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglUniform4f(JNIEnv *env, jclass clazz, jint location, jfloat v0, jfloat v1, jfloat v2, jfloat v3, jlong function_pointer) {
glUniform4fPROC glUniform4f = (glUniform4fPROC)((intptr_t)function_pointer);
glUniform4f(location, v0, v1, v2, v3);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglUniform1i(JNIEnv *env, jclass clazz, jint location, jint v0, jlong function_pointer) {
glUniform1iPROC glUniform1i = (glUniform1iPROC)((intptr_t)function_pointer);
glUniform1i(location, v0);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglUniform2i(JNIEnv *env, jclass clazz, jint location, jint v0, jint v1, jlong function_pointer) {
glUniform2iPROC glUniform2i = (glUniform2iPROC)((intptr_t)function_pointer);
glUniform2i(location, v0, v1);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglUniform3i(JNIEnv *env, jclass clazz, jint location, jint v0, jint v1, jint v2, jlong function_pointer) {
glUniform3iPROC glUniform3i = (glUniform3iPROC)((intptr_t)function_pointer);
glUniform3i(location, v0, v1, v2);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglUniform4i(JNIEnv *env, jclass clazz, jint location, jint v0, jint v1, jint v2, jint v3, jlong function_pointer) {
glUniform4iPROC glUniform4i = (glUniform4iPROC)((intptr_t)function_pointer);
glUniform4i(location, v0, v1, v2, v3);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglUniform1fv(JNIEnv *env, jclass clazz, jint location, jint count, jobject values, jint values_position, jlong function_pointer) {
GLfloat *values_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, values)) + values_position;
glUniform1fvPROC glUniform1fv = (glUniform1fvPROC)((intptr_t)function_pointer);
glUniform1fv(location, count, values_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglUniform2fv(JNIEnv *env, jclass clazz, jint location, jint count, jobject values, jint values_position, jlong function_pointer) {
GLfloat *values_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, values)) + values_position;
glUniform2fvPROC glUniform2fv = (glUniform2fvPROC)((intptr_t)function_pointer);
glUniform2fv(location, count, values_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglUniform3fv(JNIEnv *env, jclass clazz, jint location, jint count, jobject values, jint values_position, jlong function_pointer) {
GLfloat *values_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, values)) + values_position;
glUniform3fvPROC glUniform3fv = (glUniform3fvPROC)((intptr_t)function_pointer);
glUniform3fv(location, count, values_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglUniform4fv(JNIEnv *env, jclass clazz, jint location, jint count, jobject values, jint values_position, jlong function_pointer) {
GLfloat *values_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, values)) + values_position;
glUniform4fvPROC glUniform4fv = (glUniform4fvPROC)((intptr_t)function_pointer);
glUniform4fv(location, count, values_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglUniform1iv(JNIEnv *env, jclass clazz, jint location, jint count, jobject values, jint values_position, jlong function_pointer) {
GLint *values_address = ((GLint *)(*env)->GetDirectBufferAddress(env, values)) + values_position;
glUniform1ivPROC glUniform1iv = (glUniform1ivPROC)((intptr_t)function_pointer);
glUniform1iv(location, count, values_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglUniform2iv(JNIEnv *env, jclass clazz, jint location, jint count, jobject values, jint values_position, jlong function_pointer) {
GLint *values_address = ((GLint *)(*env)->GetDirectBufferAddress(env, values)) + values_position;
glUniform2ivPROC glUniform2iv = (glUniform2ivPROC)((intptr_t)function_pointer);
glUniform2iv(location, count, values_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglUniform3iv(JNIEnv *env, jclass clazz, jint location, jint count, jobject values, jint values_position, jlong function_pointer) {
GLint *values_address = ((GLint *)(*env)->GetDirectBufferAddress(env, values)) + values_position;
glUniform3ivPROC glUniform3iv = (glUniform3ivPROC)((intptr_t)function_pointer);
glUniform3iv(location, count, values_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglUniform4iv(JNIEnv *env, jclass clazz, jint location, jint count, jobject values, jint values_position, jlong function_pointer) {
GLint *values_address = ((GLint *)(*env)->GetDirectBufferAddress(env, values)) + values_position;
glUniform4ivPROC glUniform4iv = (glUniform4ivPROC)((intptr_t)function_pointer);
glUniform4iv(location, count, values_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglUniformMatrix2fv(JNIEnv *env, jclass clazz, jint location, jint count, jboolean transpose, jobject matrices, jint matrices_position, jlong function_pointer) {
GLfloat *matrices_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, matrices)) + matrices_position;
glUniformMatrix2fvPROC glUniformMatrix2fv = (glUniformMatrix2fvPROC)((intptr_t)function_pointer);
glUniformMatrix2fv(location, count, transpose, matrices_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglUniformMatrix3fv(JNIEnv *env, jclass clazz, jint location, jint count, jboolean transpose, jobject matrices, jint matrices_position, jlong function_pointer) {
GLfloat *matrices_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, matrices)) + matrices_position;
glUniformMatrix3fvPROC glUniformMatrix3fv = (glUniformMatrix3fvPROC)((intptr_t)function_pointer);
glUniformMatrix3fv(location, count, transpose, matrices_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglUniformMatrix4fv(JNIEnv *env, jclass clazz, jint location, jint count, jboolean transpose, jobject matrices, jint matrices_position, jlong function_pointer) {
GLfloat *matrices_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, matrices)) + matrices_position;
glUniformMatrix4fvPROC glUniformMatrix4fv = (glUniformMatrix4fvPROC)((intptr_t)function_pointer);
glUniformMatrix4fv(location, count, transpose, matrices_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglGetShaderiv(JNIEnv *env, jclass clazz, jint shader, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetShaderivPROC glGetShaderiv = (glGetShaderivPROC)((intptr_t)function_pointer);
glGetShaderiv(shader, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglGetProgramiv(JNIEnv *env, jclass clazz, jint program, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetProgramivPROC glGetProgramiv = (glGetProgramivPROC)((intptr_t)function_pointer);
glGetProgramiv(program, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglGetShaderInfoLog(JNIEnv *env, jclass clazz, jint shader, jint maxLength, jobject length, jint length_position, jobject infoLog, jint infoLog_position, jlong function_pointer) {
GLsizei *length_address = ((GLsizei *)safeGetBufferAddress(env, length)) + length_position;
GLchar *infoLog_address = ((GLchar *)(*env)->GetDirectBufferAddress(env, infoLog)) + infoLog_position;
glGetShaderInfoLogPROC glGetShaderInfoLog = (glGetShaderInfoLogPROC)((intptr_t)function_pointer);
glGetShaderInfoLog(shader, maxLength, length_address, infoLog_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglGetProgramInfoLog(JNIEnv *env, jclass clazz, jint program, jint maxLength, jobject length, jint length_position, jobject infoLog, jint infoLog_position, jlong function_pointer) {
GLsizei *length_address = ((GLsizei *)safeGetBufferAddress(env, length)) + length_position;
GLchar *infoLog_address = ((GLchar *)(*env)->GetDirectBufferAddress(env, infoLog)) + infoLog_position;
glGetProgramInfoLogPROC glGetProgramInfoLog = (glGetProgramInfoLogPROC)((intptr_t)function_pointer);
glGetProgramInfoLog(program, maxLength, length_address, infoLog_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglGetAttachedShaders(JNIEnv *env, jclass clazz, jint program, jint maxCount, jobject count, jint count_position, jobject shaders, jint shaders_position, jlong function_pointer) {
GLsizei *count_address = ((GLsizei *)safeGetBufferAddress(env, count)) + count_position;
GLuint *shaders_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, shaders)) + shaders_position;
glGetAttachedShadersPROC glGetAttachedShaders = (glGetAttachedShadersPROC)((intptr_t)function_pointer);
glGetAttachedShaders(program, maxCount, count_address, shaders_address);
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL20_nglGetUniformLocation(JNIEnv *env, jclass clazz, jint program, jobject name, jint name_position, jlong function_pointer) {
const GLchar *name_address = ((const GLchar *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
glGetUniformLocationPROC glGetUniformLocation = (glGetUniformLocationPROC)((intptr_t)function_pointer);
GLint __result = glGetUniformLocation(program, name_address);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglGetActiveUniform(JNIEnv *env, jclass clazz, jint program, jint index, jint maxLength, jobject length, jint length_position, jobject size, jint size_position, jobject type, jint type_position, jobject name, jint name_position, jlong function_pointer) {
GLsizei *length_address = ((GLsizei *)safeGetBufferAddress(env, length)) + length_position;
GLsizei *size_address = ((GLsizei *)(*env)->GetDirectBufferAddress(env, size)) + size_position;
GLenum *type_address = ((GLenum *)(*env)->GetDirectBufferAddress(env, type)) + type_position;
GLchar *name_address = ((GLchar *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
glGetActiveUniformPROC glGetActiveUniform = (glGetActiveUniformPROC)((intptr_t)function_pointer);
glGetActiveUniform(program, index, maxLength, length_address, size_address, type_address, name_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglGetUniformfv(JNIEnv *env, jclass clazz, jint program, jint location, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetUniformfvPROC glGetUniformfv = (glGetUniformfvPROC)((intptr_t)function_pointer);
glGetUniformfv(program, location, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglGetUniformiv(JNIEnv *env, jclass clazz, jint program, jint location, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetUniformivPROC glGetUniformiv = (glGetUniformivPROC)((intptr_t)function_pointer);
glGetUniformiv(program, location, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglGetShaderSource(JNIEnv *env, jclass clazz, jint shader, jint maxLength, jobject length, jint length_position, jobject source, jint source_position, jlong function_pointer) {
GLsizei *length_address = ((GLsizei *)safeGetBufferAddress(env, length)) + length_position;
GLchar *source_address = ((GLchar *)(*env)->GetDirectBufferAddress(env, source)) + source_position;
glGetShaderSourcePROC glGetShaderSource = (glGetShaderSourcePROC)((intptr_t)function_pointer);
glGetShaderSource(shader, maxLength, length_address, source_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglVertexAttrib1s(JNIEnv *env, jclass clazz, jint index, jshort x, jlong function_pointer) {
glVertexAttrib1sPROC glVertexAttrib1s = (glVertexAttrib1sPROC)((intptr_t)function_pointer);
glVertexAttrib1s(index, x);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglVertexAttrib1f(JNIEnv *env, jclass clazz, jint index, jfloat x, jlong function_pointer) {
glVertexAttrib1fPROC glVertexAttrib1f = (glVertexAttrib1fPROC)((intptr_t)function_pointer);
glVertexAttrib1f(index, x);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglVertexAttrib1d(JNIEnv *env, jclass clazz, jint index, jdouble x, jlong function_pointer) {
glVertexAttrib1dPROC glVertexAttrib1d = (glVertexAttrib1dPROC)((intptr_t)function_pointer);
glVertexAttrib1d(index, x);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglVertexAttrib2s(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jlong function_pointer) {
glVertexAttrib2sPROC glVertexAttrib2s = (glVertexAttrib2sPROC)((intptr_t)function_pointer);
glVertexAttrib2s(index, x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglVertexAttrib2f(JNIEnv *env, jclass clazz, jint index, jfloat x, jfloat y, jlong function_pointer) {
glVertexAttrib2fPROC glVertexAttrib2f = (glVertexAttrib2fPROC)((intptr_t)function_pointer);
glVertexAttrib2f(index, x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglVertexAttrib2d(JNIEnv *env, jclass clazz, jint index, jdouble x, jdouble y, jlong function_pointer) {
glVertexAttrib2dPROC glVertexAttrib2d = (glVertexAttrib2dPROC)((intptr_t)function_pointer);
glVertexAttrib2d(index, x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglVertexAttrib3s(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jshort z, jlong function_pointer) {
glVertexAttrib3sPROC glVertexAttrib3s = (glVertexAttrib3sPROC)((intptr_t)function_pointer);
glVertexAttrib3s(index, x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglVertexAttrib3f(JNIEnv *env, jclass clazz, jint index, jfloat x, jfloat y, jfloat z, jlong function_pointer) {
glVertexAttrib3fPROC glVertexAttrib3f = (glVertexAttrib3fPROC)((intptr_t)function_pointer);
glVertexAttrib3f(index, x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglVertexAttrib3d(JNIEnv *env, jclass clazz, jint index, jdouble x, jdouble y, jdouble z, jlong function_pointer) {
glVertexAttrib3dPROC glVertexAttrib3d = (glVertexAttrib3dPROC)((intptr_t)function_pointer);
glVertexAttrib3d(index, x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglVertexAttrib4s(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jshort z, jshort w, jlong function_pointer) {
glVertexAttrib4sPROC glVertexAttrib4s = (glVertexAttrib4sPROC)((intptr_t)function_pointer);
glVertexAttrib4s(index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglVertexAttrib4f(JNIEnv *env, jclass clazz, jint index, jfloat x, jfloat y, jfloat z, jfloat w, jlong function_pointer) {
glVertexAttrib4fPROC glVertexAttrib4f = (glVertexAttrib4fPROC)((intptr_t)function_pointer);
glVertexAttrib4f(index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglVertexAttrib4d(JNIEnv *env, jclass clazz, jint index, jdouble x, jdouble y, jdouble z, jdouble w, jlong function_pointer) {
glVertexAttrib4dPROC glVertexAttrib4d = (glVertexAttrib4dPROC)((intptr_t)function_pointer);
glVertexAttrib4d(index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglVertexAttrib4Nub(JNIEnv *env, jclass clazz, jint index, jbyte x, jbyte y, jbyte z, jbyte w, jlong function_pointer) {
glVertexAttrib4NubPROC glVertexAttrib4Nub = (glVertexAttrib4NubPROC)((intptr_t)function_pointer);
glVertexAttrib4Nub(index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglVertexAttribPointer(JNIEnv *env, jclass clazz, jint index, jint size, jint type, jboolean normalized, jint stride, jobject buffer, jint buffer_position, jlong function_pointer) {
const GLvoid *buffer_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, buffer)) + buffer_position));
glVertexAttribPointerPROC glVertexAttribPointer = (glVertexAttribPointerPROC)((intptr_t)function_pointer);
glVertexAttribPointer(index, size, type, normalized, stride, buffer_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglVertexAttribPointerBO(JNIEnv *env, jclass clazz, jint index, jint size, jint type, jboolean normalized, jint stride, jlong buffer_buffer_offset, jlong function_pointer) {
const GLvoid *buffer_address = ((const GLvoid *)offsetToPointer(buffer_buffer_offset));
glVertexAttribPointerPROC glVertexAttribPointer = (glVertexAttribPointerPROC)((intptr_t)function_pointer);
glVertexAttribPointer(index, size, type, normalized, stride, buffer_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglEnableVertexAttribArray(JNIEnv *env, jclass clazz, jint index, jlong function_pointer) {
glEnableVertexAttribArrayPROC glEnableVertexAttribArray = (glEnableVertexAttribArrayPROC)((intptr_t)function_pointer);
glEnableVertexAttribArray(index);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglDisableVertexAttribArray(JNIEnv *env, jclass clazz, jint index, jlong function_pointer) {
glDisableVertexAttribArrayPROC glDisableVertexAttribArray = (glDisableVertexAttribArrayPROC)((intptr_t)function_pointer);
glDisableVertexAttribArray(index);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglGetVertexAttribfv(JNIEnv *env, jclass clazz, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetVertexAttribfvPROC glGetVertexAttribfv = (glGetVertexAttribfvPROC)((intptr_t)function_pointer);
glGetVertexAttribfv(index, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglGetVertexAttribdv(JNIEnv *env, jclass clazz, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLdouble *params_address = ((GLdouble *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetVertexAttribdvPROC glGetVertexAttribdv = (glGetVertexAttribdvPROC)((intptr_t)function_pointer);
glGetVertexAttribdv(index, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglGetVertexAttribiv(JNIEnv *env, jclass clazz, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetVertexAttribivPROC glGetVertexAttribiv = (glGetVertexAttribivPROC)((intptr_t)function_pointer);
glGetVertexAttribiv(index, pname, params_address);
}
JNIEXPORT jobject JNICALL Java_org_lwjgl_opengl_GL20_nglGetVertexAttribPointerv(JNIEnv *env, jclass clazz, jint index, jint pname, jlong result_size, jlong function_pointer) {
glGetVertexAttribPointervPROC glGetVertexAttribPointerv = (glGetVertexAttribPointervPROC)((intptr_t)function_pointer);
GLvoid * __result;
glGetVertexAttribPointerv(index, pname, &__result);
return safeNewBuffer(env, __result, result_size);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglBindAttribLocation(JNIEnv *env, jclass clazz, jint program, jint index, jobject name, jint name_position, jlong function_pointer) {
const GLchar *name_address = ((const GLchar *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
glBindAttribLocationPROC glBindAttribLocation = (glBindAttribLocationPROC)((intptr_t)function_pointer);
glBindAttribLocation(program, index, name_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglGetActiveAttrib(JNIEnv *env, jclass clazz, jint program, jint index, jint maxLength, jobject length, jint length_position, jobject size, jint size_position, jobject type, jint type_position, jobject name, jint name_position, jlong function_pointer) {
GLsizei *length_address = ((GLsizei *)safeGetBufferAddress(env, length)) + length_position;
GLint *size_address = ((GLint *)(*env)->GetDirectBufferAddress(env, size)) + size_position;
GLenum *type_address = ((GLenum *)(*env)->GetDirectBufferAddress(env, type)) + type_position;
const GLchar *name_address = ((const GLchar *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
glGetActiveAttribPROC glGetActiveAttrib = (glGetActiveAttribPROC)((intptr_t)function_pointer);
glGetActiveAttrib(program, index, maxLength, length_address, size_address, type_address, name_address);
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL20_nglGetAttribLocation(JNIEnv *env, jclass clazz, jint program, jobject name, jint name_position, jlong function_pointer) {
const GLchar *name_address = ((const GLchar *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
glGetAttribLocationPROC glGetAttribLocation = (glGetAttribLocationPROC)((intptr_t)function_pointer);
GLint __result = glGetAttribLocation(program, name_address);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglDrawBuffers(JNIEnv *env, jclass clazz, jint size, jobject buffers, jint buffers_position, jlong function_pointer) {
const GLenum *buffers_address = ((const GLenum *)(*env)->GetDirectBufferAddress(env, buffers)) + buffers_position;
glDrawBuffersPROC glDrawBuffers = (glDrawBuffersPROC)((intptr_t)function_pointer);
glDrawBuffers(size, buffers_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglStencilOpSeparate(JNIEnv *env, jclass clazz, jint face, jint sfail, jint dpfail, jint dppass, jlong function_pointer) {
glStencilOpSeparatePROC glStencilOpSeparate = (glStencilOpSeparatePROC)((intptr_t)function_pointer);
glStencilOpSeparate(face, sfail, dpfail, dppass);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglStencilFuncSeparate(JNIEnv *env, jclass clazz, jint face, jint func, jint ref, jint mask, jlong function_pointer) {
glStencilFuncSeparatePROC glStencilFuncSeparate = (glStencilFuncSeparatePROC)((intptr_t)function_pointer);
glStencilFuncSeparate(face, func, ref, mask);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglStencilMaskSeparate(JNIEnv *env, jclass clazz, jint face, jint mask, jlong function_pointer) {
glStencilMaskSeparatePROC glStencilMaskSeparate = (glStencilMaskSeparatePROC)((intptr_t)function_pointer);
glStencilMaskSeparate(face, mask);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglBlendEquationSeparate(JNIEnv *env, jclass clazz, jint modeRGB, jint modeAlpha, jlong function_pointer) {
glBlendEquationSeparatePROC glBlendEquationSeparate = (glBlendEquationSeparatePROC)((intptr_t)function_pointer);
glBlendEquationSeparate(modeRGB, modeAlpha);
}

48
src/native/generated/org_lwjgl_opengl_GL21.c
View file

@ -1,48 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glUniformMatrix2x3fvPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat * matrices);
typedef void (APIENTRY *glUniformMatrix3x2fvPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat * matrices);
typedef void (APIENTRY *glUniformMatrix2x4fvPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat * matrices);
typedef void (APIENTRY *glUniformMatrix4x2fvPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat * matrices);
typedef void (APIENTRY *glUniformMatrix3x4fvPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat * matrices);
typedef void (APIENTRY *glUniformMatrix4x3fvPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat * matrices);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL21_nglUniformMatrix2x3fv(JNIEnv *env, jclass clazz, jint location, jint count, jboolean transpose, jobject matrices, jint matrices_position, jlong function_pointer) {
GLfloat *matrices_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, matrices)) + matrices_position;
glUniformMatrix2x3fvPROC glUniformMatrix2x3fv = (glUniformMatrix2x3fvPROC)((intptr_t)function_pointer);
glUniformMatrix2x3fv(location, count, transpose, matrices_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL21_nglUniformMatrix3x2fv(JNIEnv *env, jclass clazz, jint location, jint count, jboolean transpose, jobject matrices, jint matrices_position, jlong function_pointer) {
GLfloat *matrices_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, matrices)) + matrices_position;
glUniformMatrix3x2fvPROC glUniformMatrix3x2fv = (glUniformMatrix3x2fvPROC)((intptr_t)function_pointer);
glUniformMatrix3x2fv(location, count, transpose, matrices_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL21_nglUniformMatrix2x4fv(JNIEnv *env, jclass clazz, jint location, jint count, jboolean transpose, jobject matrices, jint matrices_position, jlong function_pointer) {
GLfloat *matrices_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, matrices)) + matrices_position;
glUniformMatrix2x4fvPROC glUniformMatrix2x4fv = (glUniformMatrix2x4fvPROC)((intptr_t)function_pointer);
glUniformMatrix2x4fv(location, count, transpose, matrices_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL21_nglUniformMatrix4x2fv(JNIEnv *env, jclass clazz, jint location, jint count, jboolean transpose, jobject matrices, jint matrices_position, jlong function_pointer) {
GLfloat *matrices_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, matrices)) + matrices_position;
glUniformMatrix4x2fvPROC glUniformMatrix4x2fv = (glUniformMatrix4x2fvPROC)((intptr_t)function_pointer);
glUniformMatrix4x2fv(location, count, transpose, matrices_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL21_nglUniformMatrix3x4fv(JNIEnv *env, jclass clazz, jint location, jint count, jboolean transpose, jobject matrices, jint matrices_position, jlong function_pointer) {
GLfloat *matrices_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, matrices)) + matrices_position;
glUniformMatrix3x4fvPROC glUniformMatrix3x4fv = (glUniformMatrix3x4fvPROC)((intptr_t)function_pointer);
glUniformMatrix3x4fv(location, count, transpose, matrices_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL21_nglUniformMatrix4x3fv(JNIEnv *env, jclass clazz, jint location, jint count, jboolean transpose, jobject matrices, jint matrices_position, jlong function_pointer) {
GLfloat *matrices_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, matrices)) + matrices_position;
glUniformMatrix4x3fvPROC glUniformMatrix4x3fv = (glUniformMatrix4x3fvPROC)((intptr_t)function_pointer);
glUniformMatrix4x3fv(location, count, transpose, matrices_address);
}

24
src/native/generated/org_lwjgl_opengl_NVDepthBufferFloat.c
View file

@ -1,24 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glDepthRangedNVPROC) (GLdouble n, GLdouble f);
typedef void (APIENTRY *glClearDepthdNVPROC) (GLdouble d);
typedef void (APIENTRY *glDepthBoundsdNVPROC) (GLdouble zmin, GLdouble zmax);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVDepthBufferFloat_nglDepthRangedNV(JNIEnv *env, jclass clazz, jdouble n, jdouble f, jlong function_pointer) {
glDepthRangedNVPROC glDepthRangedNV = (glDepthRangedNVPROC)((intptr_t)function_pointer);
glDepthRangedNV(n, f);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVDepthBufferFloat_nglClearDepthdNV(JNIEnv *env, jclass clazz, jdouble d, jlong function_pointer) {
glClearDepthdNVPROC glClearDepthdNV = (glClearDepthdNVPROC)((intptr_t)function_pointer);
glClearDepthdNV(d);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVDepthBufferFloat_nglDepthBoundsdNV(JNIEnv *env, jclass clazz, jdouble zmin, jdouble zmax, jlong function_pointer) {
glDepthBoundsdNVPROC glDepthBoundsdNV = (glDepthBoundsdNVPROC)((intptr_t)function_pointer);
glDepthBoundsdNV(zmin, zmax);
}

68
src/native/generated/org_lwjgl_opengl_NVEvaluators.c
View file

@ -1,68 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glGetMapControlPointsNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, const GLvoid * pPoints);
typedef void (APIENTRY *glMapControlPointsNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid * pPoints);
typedef void (APIENTRY *glMapParameterfvNVPROC) (GLenum target, GLenum pname, const GLfloat * params);
typedef void (APIENTRY *glMapParameterivNVPROC) (GLenum target, GLenum pname, const GLint * params);
typedef void (APIENTRY *glGetMapParameterfvNVPROC) (GLenum target, GLenum pname, const GLfloat * params);
typedef void (APIENTRY *glGetMapParameterivNVPROC) (GLenum target, GLenum pname, const GLint * params);
typedef void (APIENTRY *glGetMapAttribParameterfvNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat * params);
typedef void (APIENTRY *glGetMapAttribParameterivNVPROC) (GLenum target, GLuint index, GLenum pname, GLint * params);
typedef void (APIENTRY *glEvalMapsNVPROC) (GLenum target, GLenum mode);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapControlPointsNV(JNIEnv *env, jclass clazz, jint target, jint index, jint type, jint ustride, jint vstride, jboolean packed, jobject pPoints, jint pPoints_position, jlong function_pointer) {
const GLvoid *pPoints_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pPoints)) + pPoints_position));
glGetMapControlPointsNVPROC glGetMapControlPointsNV = (glGetMapControlPointsNVPROC)((intptr_t)function_pointer);
glGetMapControlPointsNV(target, index, type, ustride, vstride, packed, pPoints_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglMapControlPointsNV(JNIEnv *env, jclass clazz, jint target, jint index, jint type, jint ustride, jint vstride, jint uorder, jint vorder, jboolean packed, jobject pPoints, jint pPoints_position, jlong function_pointer) {
const GLvoid *pPoints_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pPoints)) + pPoints_position));
glMapControlPointsNVPROC glMapControlPointsNV = (glMapControlPointsNVPROC)((intptr_t)function_pointer);
glMapControlPointsNV(target, index, type, ustride, vstride, uorder, vorder, packed, pPoints_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglMapParameterfvNV(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
const GLfloat *params_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glMapParameterfvNVPROC glMapParameterfvNV = (glMapParameterfvNVPROC)((intptr_t)function_pointer);
glMapParameterfvNV(target, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglMapParameterivNV(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
const GLint *params_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glMapParameterivNVPROC glMapParameterivNV = (glMapParameterivNVPROC)((intptr_t)function_pointer);
glMapParameterivNV(target, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapParameterfvNV(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
const GLfloat *params_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetMapParameterfvNVPROC glGetMapParameterfvNV = (glGetMapParameterfvNVPROC)((intptr_t)function_pointer);
glGetMapParameterfvNV(target, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapParameterivNV(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
const GLint *params_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetMapParameterivNVPROC glGetMapParameterivNV = (glGetMapParameterivNVPROC)((intptr_t)function_pointer);
glGetMapParameterivNV(target, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapAttribParameterfvNV(JNIEnv *env, jclass clazz, jint target, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetMapAttribParameterfvNVPROC glGetMapAttribParameterfvNV = (glGetMapAttribParameterfvNVPROC)((intptr_t)function_pointer);
glGetMapAttribParameterfvNV(target, index, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapAttribParameterivNV(JNIEnv *env, jclass clazz, jint target, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetMapAttribParameterivNVPROC glGetMapAttribParameterivNV = (glGetMapAttribParameterivNVPROC)((intptr_t)function_pointer);
glGetMapAttribParameterivNV(target, index, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglEvalMapsNV(JNIEnv *env, jclass clazz, jint target, jint mode, jlong function_pointer) {
glEvalMapsNVPROC glEvalMapsNV = (glEvalMapsNVPROC)((intptr_t)function_pointer);
glEvalMapsNV(target, mode);
}

53
src/native/generated/org_lwjgl_opengl_NVFence.c
View file

@ -1,53 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glGenFencesNVPROC) (GLsizei n, GLuint * piFences);
typedef void (APIENTRY *glDeleteFencesNVPROC) (GLsizei n, const GLuint * piFences);
typedef void (APIENTRY *glSetFenceNVPROC) (GLuint fence, GLenum condition);
typedef GLboolean (APIENTRY *glTestFenceNVPROC) (GLuint fence);
typedef void (APIENTRY *glFinishFenceNVPROC) (GLuint fence);
typedef GLboolean (APIENTRY *glIsFenceNVPROC) (GLuint fence);
typedef void (APIENTRY *glGetFenceivNVPROC) (GLuint fence, GLenum pname, GLint * piParams);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_nglGenFencesNV(JNIEnv *env, jclass clazz, jint n, jobject piFences, jint piFences_position, jlong function_pointer) {
GLuint *piFences_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, piFences)) + piFences_position;
glGenFencesNVPROC glGenFencesNV = (glGenFencesNVPROC)((intptr_t)function_pointer);
glGenFencesNV(n, piFences_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_nglDeleteFencesNV(JNIEnv *env, jclass clazz, jint n, jobject piFences, jint piFences_position, jlong function_pointer) {
const GLuint *piFences_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, piFences)) + piFences_position;
glDeleteFencesNVPROC glDeleteFencesNV = (glDeleteFencesNVPROC)((intptr_t)function_pointer);
glDeleteFencesNV(n, piFences_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_nglSetFenceNV(JNIEnv *env, jclass clazz, jint fence, jint condition, jlong function_pointer) {
glSetFenceNVPROC glSetFenceNV = (glSetFenceNVPROC)((intptr_t)function_pointer);
glSetFenceNV(fence, condition);
}
JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_NVFence_nglTestFenceNV(JNIEnv *env, jclass clazz, jint fence, jlong function_pointer) {
glTestFenceNVPROC glTestFenceNV = (glTestFenceNVPROC)((intptr_t)function_pointer);
GLboolean __result = glTestFenceNV(fence);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_nglFinishFenceNV(JNIEnv *env, jclass clazz, jint fence, jlong function_pointer) {
glFinishFenceNVPROC glFinishFenceNV = (glFinishFenceNVPROC)((intptr_t)function_pointer);
glFinishFenceNV(fence);
}
JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_NVFence_nglIsFenceNV(JNIEnv *env, jclass clazz, jint fence, jlong function_pointer) {
glIsFenceNVPROC glIsFenceNV = (glIsFenceNVPROC)((intptr_t)function_pointer);
GLboolean __result = glIsFenceNV(fence);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_nglGetFenceivNV(JNIEnv *env, jclass clazz, jint fence, jint pname, jobject piParams, jint piParams_position, jlong function_pointer) {
GLint *piParams_address = ((GLint *)(*env)->GetDirectBufferAddress(env, piParams)) + piParams_position;
glGetFenceivNVPROC glGetFenceivNV = (glGetFenceivNVPROC)((intptr_t)function_pointer);
glGetFenceivNV(fence, pname, piParams_address);
}

36
src/native/generated/org_lwjgl_opengl_NVFragmentProgram.c
View file

@ -1,36 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glProgramNamedParameter4fNVPROC) (GLuint id, GLsizei length, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
typedef void (APIENTRY *glProgramNamedParameter4dNVPROC) (GLuint id, GLsizei length, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
typedef void (APIENTRY *glGetProgramNamedParameterfvNVPROC) (GLuint id, GLsizei length, const GLubyte * name, GLfloat * params);
typedef void (APIENTRY *glGetProgramNamedParameterdvNVPROC) (GLuint id, GLsizei length, const GLubyte * name, GLdouble * params);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFragmentProgram_nglProgramNamedParameter4fNV(JNIEnv *env, jclass clazz, jint id, jint length, jobject name, jint name_position, jfloat x, jfloat y, jfloat z, jfloat w, jlong function_pointer) {
const GLubyte *name_address = ((const GLubyte *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
glProgramNamedParameter4fNVPROC glProgramNamedParameter4fNV = (glProgramNamedParameter4fNVPROC)((intptr_t)function_pointer);
glProgramNamedParameter4fNV(id, length, name_address, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFragmentProgram_nglProgramNamedParameter4dNV(JNIEnv *env, jclass clazz, jint id, jint length, jobject name, jint name_position, jdouble x, jdouble y, jdouble z, jdouble w, jlong function_pointer) {
const GLubyte *name_address = ((const GLubyte *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
glProgramNamedParameter4dNVPROC glProgramNamedParameter4dNV = (glProgramNamedParameter4dNVPROC)((intptr_t)function_pointer);
glProgramNamedParameter4dNV(id, length, name_address, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFragmentProgram_nglGetProgramNamedParameterfvNV(JNIEnv *env, jclass clazz, jint id, jint length, jobject name, jint name_position, jobject params, jint params_position, jlong function_pointer) {
const GLubyte *name_address = ((const GLubyte *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetProgramNamedParameterfvNVPROC glGetProgramNamedParameterfvNV = (glGetProgramNamedParameterfvNVPROC)((intptr_t)function_pointer);
glGetProgramNamedParameterfvNV(id, length, name_address, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFragmentProgram_nglGetProgramNamedParameterdvNV(JNIEnv *env, jclass clazz, jint id, jint length, jobject name, jint name_position, jobject params, jint params_position, jlong function_pointer) {
const GLubyte *name_address = ((const GLubyte *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
GLdouble *params_address = ((GLdouble *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetProgramNamedParameterdvNVPROC glGetProgramNamedParameterdvNV = (glGetProgramNamedParameterdvNVPROC)((intptr_t)function_pointer);
glGetProgramNamedParameterdvNV(id, length, name_address, params_address);
}

12
src/native/generated/org_lwjgl_opengl_NVFramebufferMultisampleCoverage.c
View file

@ -1,12 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glRenderbufferStorageMultisampleCoverageNVPROC) (GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFramebufferMultisampleCoverage_nglRenderbufferStorageMultisampleCoverageNV(JNIEnv *env, jclass clazz, jint target, jint coverageSamples, jint colorSamples, jint internalformat, jint width, jint height, jlong function_pointer) {
glRenderbufferStorageMultisampleCoverageNVPROC glRenderbufferStorageMultisampleCoverageNV = (glRenderbufferStorageMultisampleCoverageNVPROC)((intptr_t)function_pointer);
glRenderbufferStorageMultisampleCoverageNV(target, coverageSamples, colorSamples, internalformat, width, height);
}

24
src/native/generated/org_lwjgl_opengl_NVGeometryProgram4.c
View file

@ -1,24 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glProgramVertexLimitNVPROC) (GLenum target, GLint limit);
typedef void (APIENTRY *glFramebufferTextureEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level);
typedef void (APIENTRY *glFramebufferTextureLayerEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGeometryProgram4_nglProgramVertexLimitNV(JNIEnv *env, jclass clazz, jint target, jint limit, jlong function_pointer) {
glProgramVertexLimitNVPROC glProgramVertexLimitNV = (glProgramVertexLimitNVPROC)((intptr_t)function_pointer);
glProgramVertexLimitNV(target, limit);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGeometryProgram4_nglFramebufferTextureEXT(JNIEnv *env, jclass clazz, jint target, jint attachment, jint texture, jint level, jlong function_pointer) {
glFramebufferTextureEXTPROC glFramebufferTextureEXT = (glFramebufferTextureEXTPROC)((intptr_t)function_pointer);
glFramebufferTextureEXT(target, attachment, texture, level);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGeometryProgram4_nglFramebufferTextureLayerEXT(JNIEnv *env, jclass clazz, jint target, jint attachment, jint texture, jint level, jint layer, jlong function_pointer) {
glFramebufferTextureLayerEXTPROC glFramebufferTextureLayerEXT = (glFramebufferTextureLayerEXTPROC)((intptr_t)function_pointer);
glFramebufferTextureLayerEXT(target, attachment, texture, level, layer);
}

114
src/native/generated/org_lwjgl_opengl_NVGpuProgram4.c
View file

@ -1,114 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glProgramLocalParameterI4iNVPROC) (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w);
typedef void (APIENTRY *glProgramLocalParameterI4ivNVPROC) (GLenum target, GLuint index, const GLint * params);
typedef void (APIENTRY *glProgramLocalParametersI4ivNVPROC) (GLenum target, GLuint index, GLsizei count, const GLint * params);
typedef void (APIENTRY *glProgramLocalParameterI4uiNVPROC) (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
typedef void (APIENTRY *glProgramLocalParameterI4uivNVPROC) (GLenum target, GLuint index, const GLuint * params);
typedef void (APIENTRY *glProgramLocalParametersI4uivNVPROC) (GLenum target, GLuint index, GLsizei count, const GLuint * params);
typedef void (APIENTRY *glProgramEnvParameterI4iNVPROC) (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w);
typedef void (APIENTRY *glProgramEnvParameterI4ivNVPROC) (GLenum target, GLuint index, const GLint * params);
typedef void (APIENTRY *glProgramEnvParametersI4ivNVPROC) (GLenum target, GLuint index, GLsizei count, const GLint * params);
typedef void (APIENTRY *glProgramEnvParameterI4uiNVPROC) (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
typedef void (APIENTRY *glProgramEnvParameterI4uivNVPROC) (GLenum target, GLuint index, const GLuint * params);
typedef void (APIENTRY *glProgramEnvParametersI4uivNVPROC) (GLenum target, GLuint index, GLsizei count, const GLuint * params);
typedef void (APIENTRY *glGetProgramLocalParameterIivNVPROC) (GLenum target, GLuint index, GLint * params);
typedef void (APIENTRY *glGetProgramLocalParameterIuivNVPROC) (GLenum target, GLuint index, GLuint * params);
typedef void (APIENTRY *glGetProgramEnvParameterIivNVPROC) (GLenum target, GLuint index, GLint * params);
typedef void (APIENTRY *glGetProgramEnvParameterIuivNVPROC) (GLenum target, GLuint index, GLuint * params);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramLocalParameterI4iNV(JNIEnv *env, jclass clazz, jint target, jint index, jint x, jint y, jint z, jint w, jlong function_pointer) {
glProgramLocalParameterI4iNVPROC glProgramLocalParameterI4iNV = (glProgramLocalParameterI4iNVPROC)((intptr_t)function_pointer);
glProgramLocalParameterI4iNV(target, index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramLocalParameterI4ivNV(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) {
const GLint *params_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glProgramLocalParameterI4ivNVPROC glProgramLocalParameterI4ivNV = (glProgramLocalParameterI4ivNVPROC)((intptr_t)function_pointer);
glProgramLocalParameterI4ivNV(target, index, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramLocalParametersI4ivNV(JNIEnv *env, jclass clazz, jint target, jint index, jint count, jobject params, jint params_position, jlong function_pointer) {
const GLint *params_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glProgramLocalParametersI4ivNVPROC glProgramLocalParametersI4ivNV = (glProgramLocalParametersI4ivNVPROC)((intptr_t)function_pointer);
glProgramLocalParametersI4ivNV(target, index, count, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramLocalParameterI4uiNV(JNIEnv *env, jclass clazz, jint target, jint index, jint x, jint y, jint z, jint w, jlong function_pointer) {
glProgramLocalParameterI4uiNVPROC glProgramLocalParameterI4uiNV = (glProgramLocalParameterI4uiNVPROC)((intptr_t)function_pointer);
glProgramLocalParameterI4uiNV(target, index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramLocalParameterI4uivNV(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) {
const GLuint *params_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glProgramLocalParameterI4uivNVPROC glProgramLocalParameterI4uivNV = (glProgramLocalParameterI4uivNVPROC)((intptr_t)function_pointer);
glProgramLocalParameterI4uivNV(target, index, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramLocalParametersI4uivNV(JNIEnv *env, jclass clazz, jint target, jint index, jint count, jobject params, jint params_position, jlong function_pointer) {
const GLuint *params_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glProgramLocalParametersI4uivNVPROC glProgramLocalParametersI4uivNV = (glProgramLocalParametersI4uivNVPROC)((intptr_t)function_pointer);
glProgramLocalParametersI4uivNV(target, index, count, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramEnvParameterI4iNV(JNIEnv *env, jclass clazz, jint target, jint index, jint x, jint y, jint z, jint w, jlong function_pointer) {
glProgramEnvParameterI4iNVPROC glProgramEnvParameterI4iNV = (glProgramEnvParameterI4iNVPROC)((intptr_t)function_pointer);
glProgramEnvParameterI4iNV(target, index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramEnvParameterI4ivNV(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) {
const GLint *params_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glProgramEnvParameterI4ivNVPROC glProgramEnvParameterI4ivNV = (glProgramEnvParameterI4ivNVPROC)((intptr_t)function_pointer);
glProgramEnvParameterI4ivNV(target, index, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramEnvParametersI4ivNV(JNIEnv *env, jclass clazz, jint target, jint index, jint count, jobject params, jint params_position, jlong function_pointer) {
const GLint *params_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glProgramEnvParametersI4ivNVPROC glProgramEnvParametersI4ivNV = (glProgramEnvParametersI4ivNVPROC)((intptr_t)function_pointer);
glProgramEnvParametersI4ivNV(target, index, count, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramEnvParameterI4uiNV(JNIEnv *env, jclass clazz, jint target, jint index, jint x, jint y, jint z, jint w, jlong function_pointer) {
glProgramEnvParameterI4uiNVPROC glProgramEnvParameterI4uiNV = (glProgramEnvParameterI4uiNVPROC)((intptr_t)function_pointer);
glProgramEnvParameterI4uiNV(target, index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramEnvParameterI4uivNV(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) {
const GLuint *params_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glProgramEnvParameterI4uivNVPROC glProgramEnvParameterI4uivNV = (glProgramEnvParameterI4uivNVPROC)((intptr_t)function_pointer);
glProgramEnvParameterI4uivNV(target, index, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramEnvParametersI4uivNV(JNIEnv *env, jclass clazz, jint target, jint index, jint count, jobject params, jint params_position, jlong function_pointer) {
const GLuint *params_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glProgramEnvParametersI4uivNVPROC glProgramEnvParametersI4uivNV = (glProgramEnvParametersI4uivNVPROC)((intptr_t)function_pointer);
glProgramEnvParametersI4uivNV(target, index, count, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglGetProgramLocalParameterIivNV(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetProgramLocalParameterIivNVPROC glGetProgramLocalParameterIivNV = (glGetProgramLocalParameterIivNVPROC)((intptr_t)function_pointer);
glGetProgramLocalParameterIivNV(target, index, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglGetProgramLocalParameterIuivNV(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) {
GLuint *params_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetProgramLocalParameterIuivNVPROC glGetProgramLocalParameterIuivNV = (glGetProgramLocalParameterIuivNVPROC)((intptr_t)function_pointer);
glGetProgramLocalParameterIuivNV(target, index, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglGetProgramEnvParameterIivNV(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetProgramEnvParameterIivNVPROC glGetProgramEnvParameterIivNV = (glGetProgramEnvParameterIivNVPROC)((intptr_t)function_pointer);
glGetProgramEnvParameterIivNV(target, index, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglGetProgramEnvParameterIuivNV(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) {
GLuint *params_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetProgramEnvParameterIuivNVPROC glGetProgramEnvParameterIuivNV = (glGetProgramEnvParameterIuivNVPROC)((intptr_t)function_pointer);
glGetProgramEnvParameterIuivNV(target, index, params_address);
}

154
src/native/generated/org_lwjgl_opengl_NVHalfFloat.c
View file

@ -1,154 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glVertex2hNVPROC) (GLhalf x, GLhalf y);
typedef void (APIENTRY *glVertex3hNVPROC) (GLhalf x, GLhalf y, GLhalf z);
typedef void (APIENTRY *glVertex4hNVPROC) (GLhalf x, GLhalf y, GLhalf z, GLhalf w);
typedef void (APIENTRY *glNormal3hNVPROC) (GLhalf nx, GLhalf ny, GLhalf nz);
typedef void (APIENTRY *glColor3hNVPROC) (GLhalf red, GLhalf green, GLhalf blue);
typedef void (APIENTRY *glColor4hNVPROC) (GLhalf red, GLhalf green, GLhalf blue, GLhalf alpha);
typedef void (APIENTRY *glTexCoord1hNVPROC) (GLhalf s);
typedef void (APIENTRY *glTexCoord2hNVPROC) (GLhalf s, GLhalf t);
typedef void (APIENTRY *glTexCoord3hNVPROC) (GLhalf s, GLhalf t, GLhalf r);
typedef void (APIENTRY *glTexCoord4hNVPROC) (GLhalf s, GLhalf t, GLhalf r, GLhalf q);
typedef void (APIENTRY *glMultiTexCoord1hNVPROC) (GLenum target, GLhalf s);
typedef void (APIENTRY *glMultiTexCoord2hNVPROC) (GLenum target, GLhalf s, GLhalf t);
typedef void (APIENTRY *glMultiTexCoord3hNVPROC) (GLenum target, GLhalf s, GLhalf t, GLhalf r);
typedef void (APIENTRY *glMultiTexCoord4hNVPROC) (GLenum target, GLhalf s, GLhalf t, GLhalf r, GLhalf q);
typedef void (APIENTRY *glFogCoordhNVPROC) (GLhalf fog);
typedef void (APIENTRY *glSecondaryColor3hNVPROC) (GLhalf red, GLhalf green, GLhalf blue);
typedef void (APIENTRY *glVertexAttrib1hNVPROC) (GLuint index, GLhalf x);
typedef void (APIENTRY *glVertexAttrib2hNVPROC) (GLuint index, GLhalf x, GLhalf y);
typedef void (APIENTRY *glVertexAttrib3hNVPROC) (GLuint index, GLhalf x, GLhalf y, GLhalf z);
typedef void (APIENTRY *glVertexAttrib4hNVPROC) (GLuint index, GLhalf x, GLhalf y, GLhalf z, GLhalf w);
typedef void (APIENTRY *glVertexAttribs1hvNVPROC) (GLuint index, GLsizei n, const GLhalf * attribs);
typedef void (APIENTRY *glVertexAttribs2hvNVPROC) (GLuint index, GLsizei n, const GLhalf * attribs);
typedef void (APIENTRY *glVertexAttribs3hvNVPROC) (GLuint index, GLsizei n, const GLhalf * attribs);
typedef void (APIENTRY *glVertexAttribs4hvNVPROC) (GLuint index, GLsizei n, const GLhalf * attribs);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertex2hNV(JNIEnv *env, jclass clazz, jshort x, jshort y, jlong function_pointer) {
glVertex2hNVPROC glVertex2hNV = (glVertex2hNVPROC)((intptr_t)function_pointer);
glVertex2hNV(x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertex3hNV(JNIEnv *env, jclass clazz, jshort x, jshort y, jshort z, jlong function_pointer) {
glVertex3hNVPROC glVertex3hNV = (glVertex3hNVPROC)((intptr_t)function_pointer);
glVertex3hNV(x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertex4hNV(JNIEnv *env, jclass clazz, jshort x, jshort y, jshort z, jshort w, jlong function_pointer) {
glVertex4hNVPROC glVertex4hNV = (glVertex4hNVPROC)((intptr_t)function_pointer);
glVertex4hNV(x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglNormal3hNV(JNIEnv *env, jclass clazz, jshort nx, jshort ny, jshort nz, jlong function_pointer) {
glNormal3hNVPROC glNormal3hNV = (glNormal3hNVPROC)((intptr_t)function_pointer);
glNormal3hNV(nx, ny, nz);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglColor3hNV(JNIEnv *env, jclass clazz, jshort red, jshort green, jshort blue, jlong function_pointer) {
glColor3hNVPROC glColor3hNV = (glColor3hNVPROC)((intptr_t)function_pointer);
glColor3hNV(red, green, blue);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglColor4hNV(JNIEnv *env, jclass clazz, jshort red, jshort green, jshort blue, jshort alpha, jlong function_pointer) {
glColor4hNVPROC glColor4hNV = (glColor4hNVPROC)((intptr_t)function_pointer);
glColor4hNV(red, green, blue, alpha);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglTexCoord1hNV(JNIEnv *env, jclass clazz, jshort s, jlong function_pointer) {
glTexCoord1hNVPROC glTexCoord1hNV = (glTexCoord1hNVPROC)((intptr_t)function_pointer);
glTexCoord1hNV(s);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglTexCoord2hNV(JNIEnv *env, jclass clazz, jshort s, jshort t, jlong function_pointer) {
glTexCoord2hNVPROC glTexCoord2hNV = (glTexCoord2hNVPROC)((intptr_t)function_pointer);
glTexCoord2hNV(s, t);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglTexCoord3hNV(JNIEnv *env, jclass clazz, jshort s, jshort t, jshort r, jlong function_pointer) {
glTexCoord3hNVPROC glTexCoord3hNV = (glTexCoord3hNVPROC)((intptr_t)function_pointer);
glTexCoord3hNV(s, t, r);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglTexCoord4hNV(JNIEnv *env, jclass clazz, jshort s, jshort t, jshort r, jshort q, jlong function_pointer) {
glTexCoord4hNVPROC glTexCoord4hNV = (glTexCoord4hNVPROC)((intptr_t)function_pointer);
glTexCoord4hNV(s, t, r, q);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglMultiTexCoord1hNV(JNIEnv *env, jclass clazz, jint target, jshort s, jlong function_pointer) {
glMultiTexCoord1hNVPROC glMultiTexCoord1hNV = (glMultiTexCoord1hNVPROC)((intptr_t)function_pointer);
glMultiTexCoord1hNV(target, s);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglMultiTexCoord2hNV(JNIEnv *env, jclass clazz, jint target, jshort s, jshort t, jlong function_pointer) {
glMultiTexCoord2hNVPROC glMultiTexCoord2hNV = (glMultiTexCoord2hNVPROC)((intptr_t)function_pointer);
glMultiTexCoord2hNV(target, s, t);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglMultiTexCoord3hNV(JNIEnv *env, jclass clazz, jint target, jshort s, jshort t, jshort r, jlong function_pointer) {
glMultiTexCoord3hNVPROC glMultiTexCoord3hNV = (glMultiTexCoord3hNVPROC)((intptr_t)function_pointer);
glMultiTexCoord3hNV(target, s, t, r);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglMultiTexCoord4hNV(JNIEnv *env, jclass clazz, jint target, jshort s, jshort t, jshort r, jshort q, jlong function_pointer) {
glMultiTexCoord4hNVPROC glMultiTexCoord4hNV = (glMultiTexCoord4hNVPROC)((intptr_t)function_pointer);
glMultiTexCoord4hNV(target, s, t, r, q);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglFogCoordhNV(JNIEnv *env, jclass clazz, jshort fog, jlong function_pointer) {
glFogCoordhNVPROC glFogCoordhNV = (glFogCoordhNVPROC)((intptr_t)function_pointer);
glFogCoordhNV(fog);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglSecondaryColor3hNV(JNIEnv *env, jclass clazz, jshort red, jshort green, jshort blue, jlong function_pointer) {
glSecondaryColor3hNVPROC glSecondaryColor3hNV = (glSecondaryColor3hNVPROC)((intptr_t)function_pointer);
glSecondaryColor3hNV(red, green, blue);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttrib1hNV(JNIEnv *env, jclass clazz, jint index, jshort x, jlong function_pointer) {
glVertexAttrib1hNVPROC glVertexAttrib1hNV = (glVertexAttrib1hNVPROC)((intptr_t)function_pointer);
glVertexAttrib1hNV(index, x);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttrib2hNV(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jlong function_pointer) {
glVertexAttrib2hNVPROC glVertexAttrib2hNV = (glVertexAttrib2hNVPROC)((intptr_t)function_pointer);
glVertexAttrib2hNV(index, x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttrib3hNV(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jshort z, jlong function_pointer) {
glVertexAttrib3hNVPROC glVertexAttrib3hNV = (glVertexAttrib3hNVPROC)((intptr_t)function_pointer);
glVertexAttrib3hNV(index, x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttrib4hNV(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jshort z, jshort w, jlong function_pointer) {
glVertexAttrib4hNVPROC glVertexAttrib4hNV = (glVertexAttrib4hNVPROC)((intptr_t)function_pointer);
glVertexAttrib4hNV(index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs1hvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject attribs, jint attribs_position, jlong function_pointer) {
const GLhalf *attribs_address = ((const GLhalf *)(*env)->GetDirectBufferAddress(env, attribs)) + attribs_position;
glVertexAttribs1hvNVPROC glVertexAttribs1hvNV = (glVertexAttribs1hvNVPROC)((intptr_t)function_pointer);
glVertexAttribs1hvNV(index, n, attribs_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs2hvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject attribs, jint attribs_position, jlong function_pointer) {
const GLhalf *attribs_address = ((const GLhalf *)(*env)->GetDirectBufferAddress(env, attribs)) + attribs_position;
glVertexAttribs2hvNVPROC glVertexAttribs2hvNV = (glVertexAttribs2hvNVPROC)((intptr_t)function_pointer);
glVertexAttribs2hvNV(index, n, attribs_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs3hvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject attribs, jint attribs_position, jlong function_pointer) {
const GLhalf *attribs_address = ((const GLhalf *)(*env)->GetDirectBufferAddress(env, attribs)) + attribs_position;
glVertexAttribs3hvNVPROC glVertexAttribs3hvNV = (glVertexAttribs3hvNVPROC)((intptr_t)function_pointer);
glVertexAttribs3hvNV(index, n, attribs_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs4hvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject attribs, jint attribs_position, jlong function_pointer) {
const GLhalf *attribs_address = ((const GLhalf *)(*env)->GetDirectBufferAddress(env, attribs)) + attribs_position;
glVertexAttribs4hvNVPROC glVertexAttribs4hvNV = (glVertexAttribs4hvNVPROC)((intptr_t)function_pointer);
glVertexAttribs4hvNV(index, n, attribs_address);
}

53
src/native/generated/org_lwjgl_opengl_NVOcclusionQuery.c
View file

@ -1,53 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glGenOcclusionQueriesNVPROC) (GLsizei n, GLuint * piIDs);
typedef void (APIENTRY *glDeleteOcclusionQueriesNVPROC) (GLsizei n, const GLuint * piIDs);
typedef GLboolean (APIENTRY *glIsOcclusionQueryNVPROC) (GLuint id);
typedef void (APIENTRY *glBeginOcclusionQueryNVPROC) (GLuint id);
typedef void (APIENTRY *glEndOcclusionQueryNVPROC) ();
typedef void (APIENTRY *glGetOcclusionQueryuivNVPROC) (GLuint id, GLenum pname, GLuint * params);
typedef void (APIENTRY *glGetOcclusionQueryivNVPROC) (GLuint id, GLenum pname, GLint * params);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_nglGenOcclusionQueriesNV(JNIEnv *env, jclass clazz, jint n, jobject piIDs, jint piIDs_position, jlong function_pointer) {
GLuint *piIDs_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, piIDs)) + piIDs_position;
glGenOcclusionQueriesNVPROC glGenOcclusionQueriesNV = (glGenOcclusionQueriesNVPROC)((intptr_t)function_pointer);
glGenOcclusionQueriesNV(n, piIDs_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_nglDeleteOcclusionQueriesNV(JNIEnv *env, jclass clazz, jint n, jobject piIDs, jint piIDs_position, jlong function_pointer) {
const GLuint *piIDs_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, piIDs)) + piIDs_position;
glDeleteOcclusionQueriesNVPROC glDeleteOcclusionQueriesNV = (glDeleteOcclusionQueriesNVPROC)((intptr_t)function_pointer);
glDeleteOcclusionQueriesNV(n, piIDs_address);
}
JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_nglIsOcclusionQueryNV(JNIEnv *env, jclass clazz, jint id, jlong function_pointer) {
glIsOcclusionQueryNVPROC glIsOcclusionQueryNV = (glIsOcclusionQueryNVPROC)((intptr_t)function_pointer);
GLboolean __result = glIsOcclusionQueryNV(id);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_nglBeginOcclusionQueryNV(JNIEnv *env, jclass clazz, jint id, jlong function_pointer) {
glBeginOcclusionQueryNVPROC glBeginOcclusionQueryNV = (glBeginOcclusionQueryNVPROC)((intptr_t)function_pointer);
glBeginOcclusionQueryNV(id);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_nglEndOcclusionQueryNV(JNIEnv *env, jclass clazz, jlong function_pointer) {
glEndOcclusionQueryNVPROC glEndOcclusionQueryNV = (glEndOcclusionQueryNVPROC)((intptr_t)function_pointer);
glEndOcclusionQueryNV();
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_nglGetOcclusionQueryuivNV(JNIEnv *env, jclass clazz, jint id, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLuint *params_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetOcclusionQueryuivNVPROC glGetOcclusionQueryuivNV = (glGetOcclusionQueryuivNVPROC)((intptr_t)function_pointer);
glGetOcclusionQueryuivNV(id, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_nglGetOcclusionQueryivNV(JNIEnv *env, jclass clazz, jint id, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetOcclusionQueryivNVPROC glGetOcclusionQueryivNV = (glGetOcclusionQueryivNVPROC)((intptr_t)function_pointer);
glGetOcclusionQueryivNV(id, pname, params_address);
}

27
src/native/generated/org_lwjgl_opengl_NVParameterBufferObject.c
View file

@ -1,27 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glProgramBufferParametersfvNVPROC) (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLfloat * params);
typedef void (APIENTRY *glProgramBufferParametersIivNVPROC) (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLint * params);
typedef void (APIENTRY *glProgramBufferParametersIuivNVPROC) (GLenum target, GLuint buffer, GLuint index, GLuint count, const GLuint * params);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVParameterBufferObject_nglProgramBufferParametersfvNV(JNIEnv *env, jclass clazz, jint target, jint buffer, jint index, jint count, jobject params, jint params_position, jlong function_pointer) {
const GLfloat *params_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glProgramBufferParametersfvNVPROC glProgramBufferParametersfvNV = (glProgramBufferParametersfvNVPROC)((intptr_t)function_pointer);
glProgramBufferParametersfvNV(target, buffer, index, count, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVParameterBufferObject_nglProgramBufferParametersIivNV(JNIEnv *env, jclass clazz, jint target, jint buffer, jint index, jint count, jobject params, jint params_position, jlong function_pointer) {
const GLint *params_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glProgramBufferParametersIivNVPROC glProgramBufferParametersIivNV = (glProgramBufferParametersIivNVPROC)((intptr_t)function_pointer);
glProgramBufferParametersIivNV(target, buffer, index, count, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVParameterBufferObject_nglProgramBufferParametersIuivNV(JNIEnv *env, jclass clazz, jint target, jint buffer, jint index, jint count, jobject params, jint params_position, jlong function_pointer) {
const GLuint *params_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glProgramBufferParametersIuivNVPROC glProgramBufferParametersIuivNV = (glProgramBufferParametersIuivNVPROC)((intptr_t)function_pointer);
glProgramBufferParametersIuivNV(target, buffer, index, count, params_address);
}

19
src/native/generated/org_lwjgl_opengl_NVPixelDataRange.c
View file

@ -1,19 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glPixelDataRangeNVPROC) (GLenum target, GLsizei length, GLvoid * data);
typedef void (APIENTRY *glFlushPixelDataRangeNVPROC) (GLenum target);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPixelDataRange_nglPixelDataRangeNV(JNIEnv *env, jclass clazz, jint target, jint length, jobject data, jint data_position, jlong function_pointer) {
GLvoid *data_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
glPixelDataRangeNVPROC glPixelDataRangeNV = (glPixelDataRangeNVPROC)((intptr_t)function_pointer);
glPixelDataRangeNV(target, length, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPixelDataRange_nglFlushPixelDataRangeNV(JNIEnv *env, jclass clazz, jint target, jlong function_pointer) {
glFlushPixelDataRangeNVPROC glFlushPixelDataRangeNV = (glFlushPixelDataRangeNVPROC)((intptr_t)function_pointer);
glFlushPixelDataRangeNV(target);
}

19
src/native/generated/org_lwjgl_opengl_NVPointSprite.c
View file

@ -1,19 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glPointParameteriNVPROC) (GLenum pname, GLint param);
typedef void (APIENTRY *glPointParameterivNVPROC) (GLenum pname, const GLint * params);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPointSprite_nglPointParameteriNV(JNIEnv *env, jclass clazz, jint pname, jint param, jlong function_pointer) {
glPointParameteriNVPROC glPointParameteriNV = (glPointParameteriNVPROC)((intptr_t)function_pointer);
glPointParameteriNV(pname, param);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPointSprite_nglPointParameterivNV(JNIEnv *env, jclass clazz, jint pname, jobject params, jint params_position, jlong function_pointer) {
const GLint *params_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glPointParameterivNVPROC glPointParameterivNV = (glPointParameterivNVPROC)((intptr_t)function_pointer);
glPointParameterivNV(pname, params_address);
}

18
src/native/generated/org_lwjgl_opengl_NVPrimitiveRestart.c
View file

@ -1,18 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glPrimitiveRestartNVPROC) ();
typedef void (APIENTRY *glPrimitiveRestartIndexNVPROC) (GLuint index);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPrimitiveRestart_nglPrimitiveRestartNV(JNIEnv *env, jclass clazz, jlong function_pointer) {
glPrimitiveRestartNVPROC glPrimitiveRestartNV = (glPrimitiveRestartNVPROC)((intptr_t)function_pointer);
glPrimitiveRestartNV();
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPrimitiveRestart_nglPrimitiveRestartIndexNV(JNIEnv *env, jclass clazz, jint index, jlong function_pointer) {
glPrimitiveRestartIndexNVPROC glPrimitiveRestartIndexNV = (glPrimitiveRestartIndexNVPROC)((intptr_t)function_pointer);
glPrimitiveRestartIndexNV(index);
}

70
src/native/generated/org_lwjgl_opengl_NVProgram.c
View file

@ -1,70 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glLoadProgramNVPROC) (GLenum target, GLuint programID, GLsizei length, const GLvoid * string);
typedef void (APIENTRY *glBindProgramNVPROC) (GLenum target, GLuint programID);
typedef void (APIENTRY *glDeleteProgramsNVPROC) (GLsizei n, const GLuint * programs);
typedef void (APIENTRY *glGenProgramsNVPROC) (GLsizei n, GLuint * programs);
typedef void (APIENTRY *glGetProgramivNVPROC) (GLuint programID, GLenum parameterName, GLint * params);
typedef void (APIENTRY *glGetProgramStringNVPROC) (GLuint programID, GLenum parameterName, GLvoid * paramString);
typedef GLboolean (APIENTRY *glIsProgramNVPROC) (GLuint programID);
typedef GLboolean (APIENTRY *glAreProgramsResidentNVPROC) (GLsizei n, const GLuint * programIDs, GLboolean * programResidences);
typedef void (APIENTRY *glRequestResidentProgramsNVPROC) (GLsizei n, GLuint * programIDs);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglLoadProgramNV(JNIEnv *env, jclass clazz, jint target, jint programID, jint length, jobject string, jint string_position, jlong function_pointer) {
const GLvoid *string_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, string)) + string_position));
glLoadProgramNVPROC glLoadProgramNV = (glLoadProgramNVPROC)((intptr_t)function_pointer);
glLoadProgramNV(target, programID, length, string_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglBindProgramNV(JNIEnv *env, jclass clazz, jint target, jint programID, jlong function_pointer) {
glBindProgramNVPROC glBindProgramNV = (glBindProgramNVPROC)((intptr_t)function_pointer);
glBindProgramNV(target, programID);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglDeleteProgramsNV(JNIEnv *env, jclass clazz, jint n, jobject programs, jint programs_position, jlong function_pointer) {
const GLuint *programs_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, programs)) + programs_position;
glDeleteProgramsNVPROC glDeleteProgramsNV = (glDeleteProgramsNVPROC)((intptr_t)function_pointer);
glDeleteProgramsNV(n, programs_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglGenProgramsNV(JNIEnv *env, jclass clazz, jint n, jobject programs, jint programs_position, jlong function_pointer) {
GLuint *programs_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, programs)) + programs_position;
glGenProgramsNVPROC glGenProgramsNV = (glGenProgramsNVPROC)((intptr_t)function_pointer);
glGenProgramsNV(n, programs_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglGetProgramivNV(JNIEnv *env, jclass clazz, jint programID, jint parameterName, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetProgramivNVPROC glGetProgramivNV = (glGetProgramivNVPROC)((intptr_t)function_pointer);
glGetProgramivNV(programID, parameterName, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglGetProgramStringNV(JNIEnv *env, jclass clazz, jint programID, jint parameterName, jobject paramString, jint paramString_position, jlong function_pointer) {
GLvoid *paramString_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, paramString)) + paramString_position));
glGetProgramStringNVPROC glGetProgramStringNV = (glGetProgramStringNVPROC)((intptr_t)function_pointer);
glGetProgramStringNV(programID, parameterName, paramString_address);
}
JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_NVProgram_nglIsProgramNV(JNIEnv *env, jclass clazz, jint programID, jlong function_pointer) {
glIsProgramNVPROC glIsProgramNV = (glIsProgramNVPROC)((intptr_t)function_pointer);
GLboolean __result = glIsProgramNV(programID);
return __result;
}
JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_NVProgram_nglAreProgramsResidentNV(JNIEnv *env, jclass clazz, jint n, jobject programIDs, jint programIDs_position, jobject programResidences, jint programResidences_position, jlong function_pointer) {
const GLuint *programIDs_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, programIDs)) + programIDs_position;
GLboolean *programResidences_address = ((GLboolean *)(*env)->GetDirectBufferAddress(env, programResidences)) + programResidences_position;
glAreProgramsResidentNVPROC glAreProgramsResidentNV = (glAreProgramsResidentNVPROC)((intptr_t)function_pointer);
GLboolean __result = glAreProgramsResidentNV(n, programIDs_address, programResidences_address);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglRequestResidentProgramsNV(JNIEnv *env, jclass clazz, jint n, jobject programIDs, jint programIDs_position, jlong function_pointer) {
GLuint *programIDs_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, programIDs)) + programIDs_position;
glRequestResidentProgramsNVPROC glRequestResidentProgramsNV = (glRequestResidentProgramsNVPROC)((intptr_t)function_pointer);
glRequestResidentProgramsNV(n, programIDs_address);
}

92
src/native/generated/org_lwjgl_opengl_NVRegisterCombiners.c
View file

@ -1,92 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glCombinerParameterfNVPROC) (GLenum pname, GLfloat param);
typedef void (APIENTRY *glCombinerParameterfvNVPROC) (GLenum pname, const GLfloat * params);
typedef void (APIENTRY *glCombinerParameteriNVPROC) (GLenum pname, GLint param);
typedef void (APIENTRY *glCombinerParameterivNVPROC) (GLenum pname, const GLint * params);
typedef void (APIENTRY *glCombinerInputNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
typedef void (APIENTRY *glCombinerOutputNVPROC) (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum);
typedef void (APIENTRY *glFinalCombinerInputNVPROC) (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
typedef void (APIENTRY *glGetCombinerInputParameterfvNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat * params);
typedef void (APIENTRY *glGetCombinerInputParameterivNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint * params);
typedef void (APIENTRY *glGetCombinerOutputParameterfvNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLfloat * params);
typedef void (APIENTRY *glGetCombinerOutputParameterivNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLint * params);
typedef void (APIENTRY *glGetFinalCombinerInputParameterfvNVPROC) (GLenum variable, GLenum pname, GLfloat * params);
typedef void (APIENTRY *glGetFinalCombinerInputParameterivNVPROC) (GLenum variable, GLenum pname, GLint * params);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVRegisterCombiners_nglCombinerParameterfNV(JNIEnv *env, jclass clazz, jint pname, jfloat param, jlong function_pointer) {
glCombinerParameterfNVPROC glCombinerParameterfNV = (glCombinerParameterfNVPROC)((intptr_t)function_pointer);
glCombinerParameterfNV(pname, param);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVRegisterCombiners_nglCombinerParameterfvNV(JNIEnv *env, jclass clazz, jint pname, jobject params, jint params_position, jlong function_pointer) {
const GLfloat *params_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glCombinerParameterfvNVPROC glCombinerParameterfvNV = (glCombinerParameterfvNVPROC)((intptr_t)function_pointer);
glCombinerParameterfvNV(pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVRegisterCombiners_nglCombinerParameteriNV(JNIEnv *env, jclass clazz, jint pname, jint param, jlong function_pointer) {
glCombinerParameteriNVPROC glCombinerParameteriNV = (glCombinerParameteriNVPROC)((intptr_t)function_pointer);
glCombinerParameteriNV(pname, param);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVRegisterCombiners_nglCombinerParameterivNV(JNIEnv *env, jclass clazz, jint pname, jobject params, jint params_position, jlong function_pointer) {
const GLint *params_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glCombinerParameterivNVPROC glCombinerParameterivNV = (glCombinerParameterivNVPROC)((intptr_t)function_pointer);
glCombinerParameterivNV(pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVRegisterCombiners_nglCombinerInputNV(JNIEnv *env, jclass clazz, jint stage, jint portion, jint variable, jint input, jint mapping, jint componentUsage, jlong function_pointer) {
glCombinerInputNVPROC glCombinerInputNV = (glCombinerInputNVPROC)((intptr_t)function_pointer);
glCombinerInputNV(stage, portion, variable, input, mapping, componentUsage);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVRegisterCombiners_nglCombinerOutputNV(JNIEnv *env, jclass clazz, jint stage, jint portion, jint abOutput, jint cdOutput, jint sumOutput, jint scale, jint bias, jboolean abDotProduct, jboolean cdDotProduct, jboolean muxSum, jlong function_pointer) {
glCombinerOutputNVPROC glCombinerOutputNV = (glCombinerOutputNVPROC)((intptr_t)function_pointer);
glCombinerOutputNV(stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVRegisterCombiners_nglFinalCombinerInputNV(JNIEnv *env, jclass clazz, jint variable, jint input, jint mapping, jint componentUsage, jlong function_pointer) {
glFinalCombinerInputNVPROC glFinalCombinerInputNV = (glFinalCombinerInputNVPROC)((intptr_t)function_pointer);
glFinalCombinerInputNV(variable, input, mapping, componentUsage);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVRegisterCombiners_nglGetCombinerInputParameterfvNV(JNIEnv *env, jclass clazz, jint stage, jint portion, jint variable, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetCombinerInputParameterfvNVPROC glGetCombinerInputParameterfvNV = (glGetCombinerInputParameterfvNVPROC)((intptr_t)function_pointer);
glGetCombinerInputParameterfvNV(stage, portion, variable, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVRegisterCombiners_nglGetCombinerInputParameterivNV(JNIEnv *env, jclass clazz, jint stage, jint portion, jint variable, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetCombinerInputParameterivNVPROC glGetCombinerInputParameterivNV = (glGetCombinerInputParameterivNVPROC)((intptr_t)function_pointer);
glGetCombinerInputParameterivNV(stage, portion, variable, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVRegisterCombiners_nglGetCombinerOutputParameterfvNV(JNIEnv *env, jclass clazz, jint stage, jint portion, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetCombinerOutputParameterfvNVPROC glGetCombinerOutputParameterfvNV = (glGetCombinerOutputParameterfvNVPROC)((intptr_t)function_pointer);
glGetCombinerOutputParameterfvNV(stage, portion, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVRegisterCombiners_nglGetCombinerOutputParameterivNV(JNIEnv *env, jclass clazz, jint stage, jint portion, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetCombinerOutputParameterivNVPROC glGetCombinerOutputParameterivNV = (glGetCombinerOutputParameterivNVPROC)((intptr_t)function_pointer);
glGetCombinerOutputParameterivNV(stage, portion, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVRegisterCombiners_nglGetFinalCombinerInputParameterfvNV(JNIEnv *env, jclass clazz, jint variable, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetFinalCombinerInputParameterfvNVPROC glGetFinalCombinerInputParameterfvNV = (glGetFinalCombinerInputParameterfvNVPROC)((intptr_t)function_pointer);
glGetFinalCombinerInputParameterfvNV(variable, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVRegisterCombiners_nglGetFinalCombinerInputParameterivNV(JNIEnv *env, jclass clazz, jint variable, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetFinalCombinerInputParameterivNVPROC glGetFinalCombinerInputParameterivNV = (glGetFinalCombinerInputParameterivNVPROC)((intptr_t)function_pointer);
glGetFinalCombinerInputParameterivNV(variable, pname, params_address);
}

20
src/native/generated/org_lwjgl_opengl_NVRegisterCombiners2.c
View file

@ -1,20 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glCombinerStageParameterfvNVPROC) (GLenum stage, GLenum pname, const GLfloat * params);
typedef void (APIENTRY *glGetCombinerStageParameterfvNVPROC) (GLenum stage, GLenum pname, GLfloat * params);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVRegisterCombiners2_nglCombinerStageParameterfvNV(JNIEnv *env, jclass clazz, jint stage, jint pname, jobject params, jint params_position, jlong function_pointer) {
const GLfloat *params_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glCombinerStageParameterfvNVPROC glCombinerStageParameterfvNV = (glCombinerStageParameterfvNVPROC)((intptr_t)function_pointer);
glCombinerStageParameterfvNV(stage, pname, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVRegisterCombiners2_nglGetCombinerStageParameterfvNV(JNIEnv *env, jclass clazz, jint stage, jint pname, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetCombinerStageParameterfvNVPROC glGetCombinerStageParameterfvNV = (glGetCombinerStageParameterfvNVPROC)((intptr_t)function_pointer);
glGetCombinerStageParameterfvNV(stage, pname, params_address);
}

82
src/native/generated/org_lwjgl_opengl_NVTransformFeedback.c
View file

@ -1,82 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glBindBufferRangeNVPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
typedef void (APIENTRY *glBindBufferOffsetNVPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset);
typedef void (APIENTRY *glBindBufferBaseNVPROC) (GLenum target, GLuint index, GLuint buffer);
typedef void (APIENTRY *glTransformFeedbackAttribsNVPROC) (GLsizei count, const GLint * attribs, GLenum bufferMode);
typedef void (APIENTRY *glTransformFeedbackVaryingsNVPROC) (GLuint program, GLsizei count, const GLint * locations, GLenum bufferMode);
typedef void (APIENTRY *glBeginTransformFeedbackNVPROC) (GLenum primitiveMode);
typedef void (APIENTRY *glEndTransformFeedbackNVPROC) ();
typedef GLint (APIENTRY *glGetVaryingLocationNVPROC) (GLuint program, const GLchar * name);
typedef void (APIENTRY *glGetActiveVaryingNVPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name);
typedef void (APIENTRY *glActiveVaryingNVPROC) (GLuint program, const GLchar * name);
typedef void (APIENTRY *glGetTransformFeedbackVaryingNVPROC) (GLuint program, GLuint index, GLint * location);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVTransformFeedback_nglBindBufferRangeNV(JNIEnv *env, jclass clazz, jint target, jint index, jint buffer, jlong offset, jlong size, jlong function_pointer) {
glBindBufferRangeNVPROC glBindBufferRangeNV = (glBindBufferRangeNVPROC)((intptr_t)function_pointer);
glBindBufferRangeNV(target, index, buffer, offset, size);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVTransformFeedback_nglBindBufferOffsetNV(JNIEnv *env, jclass clazz, jint target, jint index, jint buffer, jlong offset, jlong function_pointer) {
glBindBufferOffsetNVPROC glBindBufferOffsetNV = (glBindBufferOffsetNVPROC)((intptr_t)function_pointer);
glBindBufferOffsetNV(target, index, buffer, offset);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVTransformFeedback_nglBindBufferBaseNV(JNIEnv *env, jclass clazz, jint target, jint index, jint buffer, jlong function_pointer) {
glBindBufferBaseNVPROC glBindBufferBaseNV = (glBindBufferBaseNVPROC)((intptr_t)function_pointer);
glBindBufferBaseNV(target, index, buffer);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVTransformFeedback_nglTransformFeedbackAttribsNV(JNIEnv *env, jclass clazz, jint count, jobject attribs, jint attribs_position, jint bufferMode, jlong function_pointer) {
const GLint *attribs_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, attribs)) + attribs_position;
glTransformFeedbackAttribsNVPROC glTransformFeedbackAttribsNV = (glTransformFeedbackAttribsNVPROC)((intptr_t)function_pointer);
glTransformFeedbackAttribsNV(count, attribs_address, bufferMode);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVTransformFeedback_nglTransformFeedbackVaryingsNV(JNIEnv *env, jclass clazz, jint program, jint count, jobject locations, jint locations_position, jint bufferMode, jlong function_pointer) {
const GLint *locations_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, locations)) + locations_position;
glTransformFeedbackVaryingsNVPROC glTransformFeedbackVaryingsNV = (glTransformFeedbackVaryingsNVPROC)((intptr_t)function_pointer);
glTransformFeedbackVaryingsNV(program, count, locations_address, bufferMode);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVTransformFeedback_nglBeginTransformFeedbackNV(JNIEnv *env, jclass clazz, jint primitiveMode, jlong function_pointer) {
glBeginTransformFeedbackNVPROC glBeginTransformFeedbackNV = (glBeginTransformFeedbackNVPROC)((intptr_t)function_pointer);
glBeginTransformFeedbackNV(primitiveMode);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVTransformFeedback_nglEndTransformFeedbackNV(JNIEnv *env, jclass clazz, jlong function_pointer) {
glEndTransformFeedbackNVPROC glEndTransformFeedbackNV = (glEndTransformFeedbackNVPROC)((intptr_t)function_pointer);
glEndTransformFeedbackNV();
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_NVTransformFeedback_nglGetVaryingLocationNV(JNIEnv *env, jclass clazz, jint program, jobject name, jint name_position, jlong function_pointer) {
const GLchar *name_address = ((const GLchar *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
glGetVaryingLocationNVPROC glGetVaryingLocationNV = (glGetVaryingLocationNVPROC)((intptr_t)function_pointer);
GLint __result = glGetVaryingLocationNV(program, name_address);
return __result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVTransformFeedback_nglGetActiveVaryingNV(JNIEnv *env, jclass clazz, jint program, jint index, jint bufSize, jobject length, jint length_position, jobject size, jint size_position, jobject type, jint type_position, jobject name, jint name_position, jlong function_pointer) {
GLsizei *length_address = ((GLsizei *)(*env)->GetDirectBufferAddress(env, length)) + length_position;
GLsizei *size_address = ((GLsizei *)(*env)->GetDirectBufferAddress(env, size)) + size_position;
GLenum *type_address = ((GLenum *)(*env)->GetDirectBufferAddress(env, type)) + type_position;
GLchar *name_address = ((GLchar *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
glGetActiveVaryingNVPROC glGetActiveVaryingNV = (glGetActiveVaryingNVPROC)((intptr_t)function_pointer);
glGetActiveVaryingNV(program, index, bufSize, length_address, size_address, type_address, name_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVTransformFeedback_nglActiveVaryingNV(JNIEnv *env, jclass clazz, jint program, jobject name, jint name_position, jlong function_pointer) {
const GLchar *name_address = ((const GLchar *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
glActiveVaryingNVPROC glActiveVaryingNV = (glActiveVaryingNVPROC)((intptr_t)function_pointer);
glActiveVaryingNV(program, name_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVTransformFeedback_nglGetTransformFeedbackVaryingNV(JNIEnv *env, jclass clazz, jint program, jint index, jobject location, jint location_position, jlong function_pointer) {
GLint *location_address = ((GLint *)(*env)->GetDirectBufferAddress(env, location)) + location_position;
glGetTransformFeedbackVaryingNVPROC glGetTransformFeedbackVaryingNV = (glGetTransformFeedbackVaryingNVPROC)((intptr_t)function_pointer);
glGetTransformFeedbackVaryingNV(program, index, location_address);
}

33
src/native/generated/org_lwjgl_opengl_NVVertexArrayRange.c
View file

@ -1,33 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glVertexArrayRangeNVPROC) (GLsizei size, const GLvoid * pPointer);
typedef void (APIENTRY *glFlushVertexArrayRangeNVPROC) ();
typedef GLvoid * (APIENTRY *glAllocateMemoryNVPROC) (GLint size, GLfloat readFrequency, GLfloat writeFrequency, GLfloat priority);
typedef void (APIENTRY *glFreeMemoryNVPROC) (GLvoid * pointer);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexArrayRange_nglVertexArrayRangeNV(JNIEnv *env, jclass clazz, jint size, jobject pPointer, jint pPointer_position, jlong function_pointer) {
const GLvoid *pPointer_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pPointer)) + pPointer_position));
glVertexArrayRangeNVPROC glVertexArrayRangeNV = (glVertexArrayRangeNVPROC)((intptr_t)function_pointer);
glVertexArrayRangeNV(size, pPointer_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexArrayRange_nglFlushVertexArrayRangeNV(JNIEnv *env, jclass clazz, jlong function_pointer) {
glFlushVertexArrayRangeNVPROC glFlushVertexArrayRangeNV = (glFlushVertexArrayRangeNVPROC)((intptr_t)function_pointer);
glFlushVertexArrayRangeNV();
}
JNIEXPORT jobject JNICALL Java_org_lwjgl_opengl_NVVertexArrayRange_nglAllocateMemoryNV(JNIEnv *env, jclass clazz, jint size, jfloat readFrequency, jfloat writeFrequency, jfloat priority, jlong result_size, jlong function_pointer) {
glAllocateMemoryNVPROC glAllocateMemoryNV = (glAllocateMemoryNVPROC)((intptr_t)function_pointer);
GLvoid * __result = glAllocateMemoryNV(size, readFrequency, writeFrequency, priority);
return safeNewBuffer(env, __result, result_size);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexArrayRange_nglFreeMemoryNV(JNIEnv *env, jclass clazz, jobject pointer, jint pointer_position, jlong function_pointer) {
GLvoid *pointer_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pointer)) + pointer_position));
glFreeMemoryNVPROC glFreeMemoryNV = (glFreeMemoryNVPROC)((intptr_t)function_pointer);
glFreeMemoryNV(pointer_address);
}

270
src/native/generated/org_lwjgl_opengl_NVVertexProgram.c
View file

@ -1,270 +0,0 @@
/* MACHINE GENERATED FILE, DO NOT EDIT */
#include <jni.h>
#include "extgl.h"
typedef void (APIENTRY *glExecuteProgramNVPROC) (GLenum target, GLuint id, const GLfloat * params);
typedef void (APIENTRY *glGetProgramParameterfvNVPROC) (GLenum target, GLuint index, GLenum parameterName, GLfloat * params);
typedef void (APIENTRY *glGetProgramParameterdvNVPROC) (GLenum target, GLuint index, GLenum parameterName, GLdouble * params);
typedef void (APIENTRY *glGetTrackMatrixivNVPROC) (GLenum target, GLuint address, GLenum parameterName, GLint * params);
typedef void (APIENTRY *glGetVertexAttribfvNVPROC) (GLuint index, GLenum parameterName, GLfloat * params);
typedef void (APIENTRY *glGetVertexAttribdvNVPROC) (GLuint index, GLenum parameterName, GLdouble * params);
typedef void (APIENTRY *glGetVertexAttribivNVPROC) (GLuint index, GLenum parameterName, GLint * params);
typedef void (APIENTRY *glGetVertexAttribPointervNVPROC) (GLuint index, GLenum parameterName, GLvoid ** pointer);
typedef void (APIENTRY *glProgramParameter4fNVPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
typedef void (APIENTRY *glProgramParameter4dNVPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
typedef void (APIENTRY *glProgramParameters4fvNVPROC) (GLenum target, GLuint index, GLuint count, const GLfloat * params);
typedef void (APIENTRY *glProgramParameters4dvNVPROC) (GLenum target, GLuint index, GLuint count, const GLdouble * params);
typedef void (APIENTRY *glTrackMatrixNVPROC) (GLenum target, GLuint address, GLenum matrix, GLenum transform);
typedef void (APIENTRY *glVertexAttribPointerNVPROC) (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * buffer);
typedef void (APIENTRY *glVertexAttrib1sNVPROC) (GLuint index, GLshort x);
typedef void (APIENTRY *glVertexAttrib1fNVPROC) (GLuint index, GLfloat x);
typedef void (APIENTRY *glVertexAttrib1dNVPROC) (GLuint index, GLdouble x);
typedef void (APIENTRY *glVertexAttrib2sNVPROC) (GLuint index, GLshort x, GLshort y);
typedef void (APIENTRY *glVertexAttrib2fNVPROC) (GLuint index, GLfloat x, GLfloat y);
typedef void (APIENTRY *glVertexAttrib2dNVPROC) (GLuint index, GLdouble x, GLdouble y);
typedef void (APIENTRY *glVertexAttrib3sNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z);
typedef void (APIENTRY *glVertexAttrib3fNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z);
typedef void (APIENTRY *glVertexAttrib3dNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z);
typedef void (APIENTRY *glVertexAttrib4sNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
typedef void (APIENTRY *glVertexAttrib4fNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
typedef void (APIENTRY *glVertexAttrib4dNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
typedef void (APIENTRY *glVertexAttrib4ubNVPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
typedef void (APIENTRY *glVertexAttribs1svNVPROC) (GLuint index, GLsizei n, const GLshort * v);
typedef void (APIENTRY *glVertexAttribs1fvNVPROC) (GLuint index, GLsizei n, const GLfloat * v);
typedef void (APIENTRY *glVertexAttribs1dvNVPROC) (GLuint index, GLsizei n, const GLdouble * v);
typedef void (APIENTRY *glVertexAttribs2svNVPROC) (GLuint index, GLsizei n, const GLshort * v);
typedef void (APIENTRY *glVertexAttribs2fvNVPROC) (GLuint index, GLsizei n, const GLfloat * v);
typedef void (APIENTRY *glVertexAttribs2dvNVPROC) (GLuint index, GLsizei n, const GLdouble * v);
typedef void (APIENTRY *glVertexAttribs3svNVPROC) (GLuint index, GLsizei n, const GLshort * v);
typedef void (APIENTRY *glVertexAttribs3fvNVPROC) (GLuint index, GLsizei n, const GLfloat * v);
typedef void (APIENTRY *glVertexAttribs3dvNVPROC) (GLuint index, GLsizei n, const GLdouble * v);
typedef void (APIENTRY *glVertexAttribs4svNVPROC) (GLuint index, GLsizei n, const GLshort * v);
typedef void (APIENTRY *glVertexAttribs4fvNVPROC) (GLuint index, GLsizei n, const GLfloat * v);
typedef void (APIENTRY *glVertexAttribs4dvNVPROC) (GLuint index, GLsizei n, const GLdouble * v);
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglExecuteProgramNV(JNIEnv *env, jclass clazz, jint target, jint id, jobject params, jint params_position, jlong function_pointer) {
const GLfloat *params_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glExecuteProgramNVPROC glExecuteProgramNV = (glExecuteProgramNVPROC)((intptr_t)function_pointer);
glExecuteProgramNV(target, id, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglGetProgramParameterfvNV(JNIEnv *env, jclass clazz, jint target, jint index, jint parameterName, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetProgramParameterfvNVPROC glGetProgramParameterfvNV = (glGetProgramParameterfvNVPROC)((intptr_t)function_pointer);
glGetProgramParameterfvNV(target, index, parameterName, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglGetProgramParameterdvNV(JNIEnv *env, jclass clazz, jint target, jint index, jint parameterName, jobject params, jint params_position, jlong function_pointer) {
GLdouble *params_address = ((GLdouble *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetProgramParameterdvNVPROC glGetProgramParameterdvNV = (glGetProgramParameterdvNVPROC)((intptr_t)function_pointer);
glGetProgramParameterdvNV(target, index, parameterName, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglGetTrackMatrixivNV(JNIEnv *env, jclass clazz, jint target, jint address, jint parameterName, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetTrackMatrixivNVPROC glGetTrackMatrixivNV = (glGetTrackMatrixivNVPROC)((intptr_t)function_pointer);
glGetTrackMatrixivNV(target, address, parameterName, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglGetVertexAttribfvNV(JNIEnv *env, jclass clazz, jint index, jint parameterName, jobject params, jint params_position, jlong function_pointer) {
GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetVertexAttribfvNVPROC glGetVertexAttribfvNV = (glGetVertexAttribfvNVPROC)((intptr_t)function_pointer);
glGetVertexAttribfvNV(index, parameterName, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglGetVertexAttribdvNV(JNIEnv *env, jclass clazz, jint index, jint parameterName, jobject params, jint params_position, jlong function_pointer) {
GLdouble *params_address = ((GLdouble *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetVertexAttribdvNVPROC glGetVertexAttribdvNV = (glGetVertexAttribdvNVPROC)((intptr_t)function_pointer);
glGetVertexAttribdvNV(index, parameterName, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglGetVertexAttribivNV(JNIEnv *env, jclass clazz, jint index, jint parameterName, jobject params, jint params_position, jlong function_pointer) {
GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glGetVertexAttribivNVPROC glGetVertexAttribivNV = (glGetVertexAttribivNVPROC)((intptr_t)function_pointer);
glGetVertexAttribivNV(index, parameterName, params_address);
}
JNIEXPORT jobject JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglGetVertexAttribPointervNV(JNIEnv *env, jclass clazz, jint index, jint parameterName, jlong result_size, jlong function_pointer) {
glGetVertexAttribPointervNVPROC glGetVertexAttribPointervNV = (glGetVertexAttribPointervNVPROC)((intptr_t)function_pointer);
GLvoid * __result;
glGetVertexAttribPointervNV(index, parameterName, &__result);
return safeNewBuffer(env, __result, result_size);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglProgramParameter4fNV(JNIEnv *env, jclass clazz, jint target, jint index, jfloat x, jfloat y, jfloat z, jfloat w, jlong function_pointer) {
glProgramParameter4fNVPROC glProgramParameter4fNV = (glProgramParameter4fNVPROC)((intptr_t)function_pointer);
glProgramParameter4fNV(target, index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglProgramParameter4dNV(JNIEnv *env, jclass clazz, jint target, jint index, jdouble x, jdouble y, jdouble z, jdouble w, jlong function_pointer) {
glProgramParameter4dNVPROC glProgramParameter4dNV = (glProgramParameter4dNVPROC)((intptr_t)function_pointer);
glProgramParameter4dNV(target, index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglProgramParameters4fvNV(JNIEnv *env, jclass clazz, jint target, jint index, jint count, jobject params, jint params_position, jlong function_pointer) {
const GLfloat *params_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glProgramParameters4fvNVPROC glProgramParameters4fvNV = (glProgramParameters4fvNVPROC)((intptr_t)function_pointer);
glProgramParameters4fvNV(target, index, count, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglProgramParameters4dvNV(JNIEnv *env, jclass clazz, jint target, jint index, jint count, jobject params, jint params_position, jlong function_pointer) {
const GLdouble *params_address = ((const GLdouble *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glProgramParameters4dvNVPROC glProgramParameters4dvNV = (glProgramParameters4dvNVPROC)((intptr_t)function_pointer);
glProgramParameters4dvNV(target, index, count, params_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglTrackMatrixNV(JNIEnv *env, jclass clazz, jint target, jint address, jint matrix, jint transform, jlong function_pointer) {
glTrackMatrixNVPROC glTrackMatrixNV = (glTrackMatrixNVPROC)((intptr_t)function_pointer);
glTrackMatrixNV(target, address, matrix, transform);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttribPointerNV(JNIEnv *env, jclass clazz, jint index, jint size, jint type, jint stride, jobject buffer, jint buffer_position, jlong function_pointer) {
const GLvoid *buffer_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, buffer)) + buffer_position));
glVertexAttribPointerNVPROC glVertexAttribPointerNV = (glVertexAttribPointerNVPROC)((intptr_t)function_pointer);
glVertexAttribPointerNV(index, size, type, stride, buffer_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttribPointerNVBO(JNIEnv *env, jclass clazz, jint index, jint size, jint type, jint stride, jlong buffer_buffer_offset, jlong function_pointer) {
const GLvoid *buffer_address = ((const GLvoid *)offsetToPointer(buffer_buffer_offset));
glVertexAttribPointerNVPROC glVertexAttribPointerNV = (glVertexAttribPointerNVPROC)((intptr_t)function_pointer);
glVertexAttribPointerNV(index, size, type, stride, buffer_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttrib1sNV(JNIEnv *env, jclass clazz, jint index, jshort x, jlong function_pointer) {
glVertexAttrib1sNVPROC glVertexAttrib1sNV = (glVertexAttrib1sNVPROC)((intptr_t)function_pointer);
glVertexAttrib1sNV(index, x);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttrib1fNV(JNIEnv *env, jclass clazz, jint index, jfloat x, jlong function_pointer) {
glVertexAttrib1fNVPROC glVertexAttrib1fNV = (glVertexAttrib1fNVPROC)((intptr_t)function_pointer);
glVertexAttrib1fNV(index, x);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttrib1dNV(JNIEnv *env, jclass clazz, jint index, jdouble x, jlong function_pointer) {
glVertexAttrib1dNVPROC glVertexAttrib1dNV = (glVertexAttrib1dNVPROC)((intptr_t)function_pointer);
glVertexAttrib1dNV(index, x);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttrib2sNV(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jlong function_pointer) {
glVertexAttrib2sNVPROC glVertexAttrib2sNV = (glVertexAttrib2sNVPROC)((intptr_t)function_pointer);
glVertexAttrib2sNV(index, x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttrib2fNV(JNIEnv *env, jclass clazz, jint index, jfloat x, jfloat y, jlong function_pointer) {
glVertexAttrib2fNVPROC glVertexAttrib2fNV = (glVertexAttrib2fNVPROC)((intptr_t)function_pointer);
glVertexAttrib2fNV(index, x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttrib2dNV(JNIEnv *env, jclass clazz, jint index, jdouble x, jdouble y, jlong function_pointer) {
glVertexAttrib2dNVPROC glVertexAttrib2dNV = (glVertexAttrib2dNVPROC)((intptr_t)function_pointer);
glVertexAttrib2dNV(index, x, y);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttrib3sNV(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jshort z, jlong function_pointer) {
glVertexAttrib3sNVPROC glVertexAttrib3sNV = (glVertexAttrib3sNVPROC)((intptr_t)function_pointer);
glVertexAttrib3sNV(index, x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttrib3fNV(JNIEnv *env, jclass clazz, jint index, jfloat x, jfloat y, jfloat z, jlong function_pointer) {
glVertexAttrib3fNVPROC glVertexAttrib3fNV = (glVertexAttrib3fNVPROC)((intptr_t)function_pointer);
glVertexAttrib3fNV(index, x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttrib3dNV(JNIEnv *env, jclass clazz, jint index, jdouble x, jdouble y, jdouble z, jlong function_pointer) {
glVertexAttrib3dNVPROC glVertexAttrib3dNV = (glVertexAttrib3dNVPROC)((intptr_t)function_pointer);
glVertexAttrib3dNV(index, x, y, z);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttrib4sNV(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jshort z, jshort w, jlong function_pointer) {
glVertexAttrib4sNVPROC glVertexAttrib4sNV = (glVertexAttrib4sNVPROC)((intptr_t)function_pointer);
glVertexAttrib4sNV(index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttrib4fNV(JNIEnv *env, jclass clazz, jint index, jfloat x, jfloat y, jfloat z, jfloat w, jlong function_pointer) {
glVertexAttrib4fNVPROC glVertexAttrib4fNV = (glVertexAttrib4fNVPROC)((intptr_t)function_pointer);
glVertexAttrib4fNV(index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttrib4dNV(JNIEnv *env, jclass clazz, jint index, jdouble x, jdouble y, jdouble z, jdouble w, jlong function_pointer) {
glVertexAttrib4dNVPROC glVertexAttrib4dNV = (glVertexAttrib4dNVPROC)((intptr_t)function_pointer);
glVertexAttrib4dNV(index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttrib4ubNV(JNIEnv *env, jclass clazz, jint index, jbyte x, jbyte y, jbyte z, jbyte w, jlong function_pointer) {
glVertexAttrib4ubNVPROC glVertexAttrib4ubNV = (glVertexAttrib4ubNVPROC)((intptr_t)function_pointer);
glVertexAttrib4ubNV(index, x, y, z, w);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttribs1svNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject v, jint v_position, jlong function_pointer) {
const GLshort *v_address = ((const GLshort *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribs1svNVPROC glVertexAttribs1svNV = (glVertexAttribs1svNVPROC)((intptr_t)function_pointer);
glVertexAttribs1svNV(index, n, v_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttribs1fvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject v, jint v_position, jlong function_pointer) {
const GLfloat *v_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribs1fvNVPROC glVertexAttribs1fvNV = (glVertexAttribs1fvNVPROC)((intptr_t)function_pointer);
glVertexAttribs1fvNV(index, n, v_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttribs1dvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject v, jint v_position, jlong function_pointer) {
const GLdouble *v_address = ((const GLdouble *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribs1dvNVPROC glVertexAttribs1dvNV = (glVertexAttribs1dvNVPROC)((intptr_t)function_pointer);
glVertexAttribs1dvNV(index, n, v_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttribs2svNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject v, jint v_position, jlong function_pointer) {
const GLshort *v_address = ((const GLshort *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribs2svNVPROC glVertexAttribs2svNV = (glVertexAttribs2svNVPROC)((intptr_t)function_pointer);
glVertexAttribs2svNV(index, n, v_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttribs2fvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject v, jint v_position, jlong function_pointer) {
const GLfloat *v_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribs2fvNVPROC glVertexAttribs2fvNV = (glVertexAttribs2fvNVPROC)((intptr_t)function_pointer);
glVertexAttribs2fvNV(index, n, v_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttribs2dvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject v, jint v_position, jlong function_pointer) {
const GLdouble *v_address = ((const GLdouble *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribs2dvNVPROC glVertexAttribs2dvNV = (glVertexAttribs2dvNVPROC)((intptr_t)function_pointer);
glVertexAttribs2dvNV(index, n, v_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttribs3svNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject v, jint v_position, jlong function_pointer) {
const GLshort *v_address = ((const GLshort *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribs3svNVPROC glVertexAttribs3svNV = (glVertexAttribs3svNVPROC)((intptr_t)function_pointer);
glVertexAttribs3svNV(index, n, v_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttribs3fvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject v, jint v_position, jlong function_pointer) {
const GLfloat *v_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribs3fvNVPROC glVertexAttribs3fvNV = (glVertexAttribs3fvNVPROC)((intptr_t)function_pointer);
glVertexAttribs3fvNV(index, n, v_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttribs3dvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject v, jint v_position, jlong function_pointer) {
const GLdouble *v_address = ((const GLdouble *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribs3dvNVPROC glVertexAttribs3dvNV = (glVertexAttribs3dvNVPROC)((intptr_t)function_pointer);
glVertexAttribs3dvNV(index, n, v_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttribs4svNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject v, jint v_position, jlong function_pointer) {
const GLshort *v_address = ((const GLshort *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribs4svNVPROC glVertexAttribs4svNV = (glVertexAttribs4svNVPROC)((intptr_t)function_pointer);
glVertexAttribs4svNV(index, n, v_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttribs4fvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject v, jint v_position, jlong function_pointer) {
const GLfloat *v_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribs4fvNVPROC glVertexAttribs4fvNV = (glVertexAttribs4fvNVPROC)((intptr_t)function_pointer);
glVertexAttribs4fvNV(index, n, v_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglVertexAttribs4dvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject v, jint v_position, jlong function_pointer) {
const GLdouble *v_address = ((const GLdouble *)(*env)->GetDirectBufferAddress(env, v)) + v_position;
glVertexAttribs4dvNVPROC glVertexAttribs4dvNV = (glVertexAttribs4dvNVPROC)((intptr_t)function_pointer);
glVertexAttribs4dvNV(index, n, v_address);
}