michael/lwjgl
michael
/
lwjgl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Split extgl functions into separate cpp files. Added some extensions

This commit is contained in:
Elias Naur 2004-01-29 22:08:59 +00:00
parent f874cd8fc3
commit 4510847487
51 changed files with 3013 additions and 4434 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/java/org/lwjgl/opengl/GLCaps.java
View File

@ -129,6 +129,7 @@ public abstract class GLCaps {
public static boolean GL_NV_texture_shader3;
public static boolean GL_NV_vertex_array_range;
public static boolean GL_NV_vertex_array_range2;
public static boolean GL_NV_texture_compression_vtc;
public static boolean GL_NV_vertex_program;
public static boolean GL_NV_vertex_program1_1;
public static boolean GL_NV_vertex_program2;

170
src/java/org/lwjgl/opengl/arb/ARBVertexProgram.java
View File

@ -114,176 +114,6 @@ public class ARBVertexProgram extends ARBProgram {
public static native void glVertexAttrib4NubARB(int index, byte x, byte y, byte z, byte w);
// ---------------------------
public static void glVertexAttrib1ARB(int index, ShortBuffer values) {
nglVertexAttrib1svARB(index, values, values.position());
}
private static native void nglVertexAttrib1svARB(int index, ShortBuffer values, int valuesOffset);
// ---------------------------
// ---------------------------
public static void glVertexAttrib1ARB(int index, FloatBuffer values) {
nglVertexAttrib1fvARB(index, values, values.position());
}
private static native void nglVertexAttrib1fvARB(int index, FloatBuffer values, int valuesOffset);
// ---------------------------
// ---------------------------
public static void glVertexAttrib2ARB(int index, ShortBuffer values) {
assert values.remaining() >= 2: "<values> must have 2 shorts available.";
nglVertexAttrib2svARB(index, values, values.position());
}
private static native void nglVertexAttrib2svARB(int index, ShortBuffer values, int valuesOffset);
// ---------------------------
// ---------------------------
public static void glVertexAttrib2ARB(int index, FloatBuffer values) {
assert values.remaining() >= 2: "<values> must have 2 floats available.";
nglVertexAttrib2fvARB(index, values, values.position());
}
private static native void nglVertexAttrib2fvARB(int index, FloatBuffer values, int valuesOffset);
// ---------------------------
// ---------------------------
public static void glVertexAttrib3ARB(int index, ShortBuffer values) {
assert values.remaining() >= 3: "<values> must have 3 shorts available.";
nglVertexAttrib3svARB(index, values, values.position());
}
private static native void nglVertexAttrib3svARB(int index, ShortBuffer values, int valuesOffset);
// ---------------------------
// ---------------------------
public static void glVertexAttrib3ARB(int index, FloatBuffer values) {
assert values.remaining() >= 3: "<values> must have 3 floats available.";
nglVertexAttrib3fvARB(index, values, values.position());
}
private static native void nglVertexAttrib3fvARB(int index, FloatBuffer values, int valuesOffset);
// ---------------------------
// ---------------------------
public static void glVertexAttrib4ARB(int index, ByteBuffer values) {
assert values.remaining() >= 4: "<values> must have 4 bytes available.";
nglVertexAttrib4bvARB(index, values, values.position());
}
private static native void nglVertexAttrib4bvARB(int index, ByteBuffer values, int valuesOffset);
// ---------------------------
// ---------------------------
public static void glVertexAttrib4ARB(int index, ShortBuffer values) {
assert values.remaining() >= 4: "<values> must have 4 shorts available.";
nglVertexAttrib4svARB(index, values, values.position());
}
private static native void nglVertexAttrib4svARB(int index, ShortBuffer values, int valuesOffset);
// ---------------------------
// ---------------------------
public static void glVertexAttrib4ARB(int index, IntBuffer values) {
assert values.remaining() >= 4: "<values> must have 4 ints available.";
nglVertexAttrib4ivARB(index, values, values.position());
}
private static native void nglVertexAttrib4ivARB(int index, IntBuffer values, int valuesOffset);
// ---------------------------
// ---------------------------
public static void glVertexAttrib4uARB(int index, ByteBuffer values) {
assert values.remaining() >= 4: "<values> must have 4 bytes available.";
nglVertexAttrib4ubvARB(index, values, values.position());
}
private static native void nglVertexAttrib4ubvARB(int index, ByteBuffer values, int valuesOffset);
// ---------------------------
// ---------------------------
public static void glVertexAttrib4uARB(int index, ShortBuffer values) {
assert values.remaining() >= 4: "<values> must have 4 shorts available.";
nglVertexAttrib4usvARB(index, values, values.position());
}
private static native void nglVertexAttrib4usvARB(int index, ShortBuffer values, int valuesOffset);
// ---------------------------
// ---------------------------
public static void glVertexAttrib4uARB(int index, IntBuffer values) {
assert values.remaining() >= 4: "<values> must have 4 ints available.";
nglVertexAttrib4uivARB(index, values, values.position());
}
private static native void nglVertexAttrib4uivARB(int index, IntBuffer values, int valuesOffset);
// ---------------------------
// ---------------------------
public static void glVertexAttrib4ARB(int index, FloatBuffer values) {
assert values.remaining() >= 4: "<values> must have 4 floats available.";
nglVertexAttrib4fvARB(index, values, values.position());
}
private static native void nglVertexAttrib4fvARB(int index, FloatBuffer values, int valuesOffset);
// ---------------------------
// ---------------------------
public static void glVertexAttrib4NARB(int index, ByteBuffer values) {
assert values.remaining() >= 4: "<values> must have 4 bytes available.";
nglVertexAttrib4NbvARB(index, values, values.position());
}
private static native void nglVertexAttrib4NbvARB(int index, ByteBuffer values, int valuesOffset);
// ---------------------------
// ---------------------------
public static void glVertexAttrib4NARB(int index, ShortBuffer values) {
assert values.remaining() >= 4: "<values> must have 4 shorts available.";
nglVertexAttrib4NsvARB(index, values, values.position());
}
private static native void nglVertexAttrib4NsvARB(int index, ShortBuffer values, int valuesOffset);
// ---------------------------
// ---------------------------
public static void glVertexAttrib4NARB(int index, IntBuffer values) {
assert values.remaining() >= 4: "<values> must have 4 ints available.";
nglVertexAttrib4NivARB(index, values, values.position());
}
private static native void nglVertexAttrib4NivARB(int index, IntBuffer values, int valuesOffset);
// ---------------------------
// ---------------------------
public static void glVertexAttrib4NuARB(int index, ByteBuffer values) {
assert values.remaining() >= 4: "<values> must have 4 bytes available.";
nglVertexAttrib4NubvARB(index, values, values.position());
}
private static native void nglVertexAttrib4NubvARB(int index, ByteBuffer values, int valuesOffset);
// ---------------------------
// ---------------------------
public static void glVertexAttrib4NuARB(int index, ShortBuffer values) {
assert values.remaining() >= 4: "<values> must have 4 shorts available.";
nglVertexAttrib4NusvARB(index, values, values.position());
}
private static native void nglVertexAttrib4NusvARB(int index, ShortBuffer values, int valuesOffset);
// ---------------------------
// ---------------------------
public static void glVertexAttrib4NuARB(int index, IntBuffer values) {
assert values.remaining() >= 4: "<values> must have 4 ints available.";
nglVertexAttrib4NuivARB(index, values, values.position());
}
private static native void nglVertexAttrib4NuivARB(int index, IntBuffer values, int valuesOffset);
// ---------------------------
public static void glVertexAttribPointerARB(int index, int size, boolean unsigned, boolean normalized, int stride, ByteBuffer buffer) {
assert VBOTracker.getVBOArrayStack().getState() == 0: "Cannot use Buffers when VBO is enabled";
nglVertexAttribPointerARB(index, size, unsigned ? GL11.GL_UNSIGNED_BYTE : GL11.GL_BYTE, normalized, stride, buffer, buffer.position());

8
src/java/org/lwjgl/opengl/nv/NVRegisterCombiners.java
View File

@ -158,12 +158,4 @@ public class NVRegisterCombiners {
nglGetFinalCombinerInputParameterivNV(variable, pname, piParams, piParams.position());
}
private static native void nglGetFinalCombinerInputParameterivNV(int variable, int pname, IntBuffer piParams, int piParams_offset);
public static void glCombinerStageParameterNV(int stage, int pname, FloatBuffer pfParams) {
nglCombinerStageParameterfvNV(stage, pname, pfParams, pfParams.position());
}
private static native void nglCombinerStageParameterfvNV(int stage, int pname, FloatBuffer pfParams, int pfParams_offset);
public static void glGetCombinerStageParameterNV(int stage, int pname, FloatBuffer pfParams) {
nglGetCombinerStageParameterfvNV(stage, pname, pfParams, pfParams.position());
}
private static native void nglGetCombinerStageParameterfvNV(int stage, int pname, FloatBuffer pfParams, int pfParams_offset);
}

11
src/java/org/lwjgl/opengl/nv/NVRegisterCombiners2.java
View File

@ -39,7 +39,18 @@
*/
package org.lwjgl.opengl.nv;
import java.nio.FloatBuffer;
public class NVRegisterCombiners2
{
public static final int GL_PER_STAGE_CONSTANTS_NV = 0x8535;
public static void glCombinerStageParameterNV(int stage, int pname, FloatBuffer pfParams) {
nglCombinerStageParameterfvNV(stage, pname, pfParams, pfParams.position());
}
private static native void nglCombinerStageParameterfvNV(int stage, int pname, FloatBuffer pfParams, int pfParams_offset);
public static void glGetCombinerStageParameterNV(int stage, int pname, FloatBuffer pfParams) {
nglGetCombinerStageParameterfvNV(stage, pname, pfParams, pfParams.position());
}
private static native void nglGetCombinerStageParameterfvNV(int stage, int pname, FloatBuffer pfParams, int pfParams_offset);
}

53
src/java/org/lwjgl/opengl/nv/NVTextureCompressionVTC.java Normal file
View File

@ -0,0 +1,53 @@
/*
* Copyright (c) 2002 Lightweight Java Game Library Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'Light Weight Java Game Library' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* Created by LWJGL.
* User: spasi
* Date: 2004-01-29
* Time: 3:20:43 pm
*/
package org.lwjgl.opengl.nv;
public class NVTextureCompressionVTC {
/*
* Accepted by the <internalformat> parameter of TexImage3D and
* CompressedTexImage3DARB and the <format> parameter of
* CompressedTexSubImage2DARB:
*/
public static final int COMPRESSED_RGB_S3TC_DXT1_EXT =0x83F0;
public static final int COMPRESSED_RGBA_S3TC_DXT1_EXT =0x83F1;
public static final int COMPRESSED_RGBA_S3TC_DXT3_EXT =0x83F2;
public static final int COMPRESSED_RGBA_S3TC_DXT5_EXT =0x83F3;
}

24
src/native/common/arb/org_lwjgl_opengl_arb_ARBMatrixPalette.cpp
View File

@ -38,6 +38,30 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glCurrentPaletteMatrixARBPROC) (GLint index);
typedef void (APIENTRY * glMatrixIndexubvARBPROC) (GLint size, GLubyte *indices);
typedef void (APIENTRY * glMatrixIndexusvARBPROC) (GLint size, GLushort *indices);
typedef void (APIENTRY * glMatrixIndexuivARBPROC) (GLint size, GLuint *indices);
typedef void (APIENTRY * glMatrixIndexPointerARBPROC) (GLint size, GLenum type, GLsizei stride, GLvoid *pointer);
static glCurrentPaletteMatrixARBPROC glCurrentPaletteMatrixARB;
static glMatrixIndexubvARBPROC glMatrixIndexubvARB;
static glMatrixIndexusvARBPROC glMatrixIndexusvARB;
static glMatrixIndexuivARBPROC glMatrixIndexuivARB;
static glMatrixIndexPointerARBPROC glMatrixIndexPointerARB;
void extgl_InitARBMatrixPalette(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_ARB_matrix_palette)
return;
glCurrentPaletteMatrixARB = (glCurrentPaletteMatrixARBPROC) extgl_GetProcAddress("glCurrentPaletteMatrixARB");
glMatrixIndexubvARB = (glMatrixIndexubvARBPROC) extgl_GetProcAddress("glMatrixIndexubvARB");
glMatrixIndexusvARB = (glMatrixIndexusvARBPROC) extgl_GetProcAddress("glMatrixIndexusvARB");
glMatrixIndexuivARB = (glMatrixIndexuivARBPROC) extgl_GetProcAddress("glMatrixIndexuivARB");
glMatrixIndexPointerARB = (glMatrixIndexPointerARBPROC) extgl_GetProcAddress("glMatrixIndexPointerARB");
EXTGL_SANITY_CHECK(env, ext_set, GL_ARB_matrix_palette)
}
/*
* Class: org.lwjgl.opengl.arb.ARBMatrixPalette
* Method: glCurrentPaletteMatrixARB

12
src/native/common/arb/org_lwjgl_opengl_arb_ARBMultisample.cpp
View File

@ -38,6 +38,18 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glSampleCoverageARBPROC) (GLclampf value, GLboolean invert );
static glSampleCoverageARBPROC glSampleCoverageARB;
void extgl_InitARBMultisample(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_ARB_multisample)
return;
glSampleCoverageARB = (glSampleCoverageARBPROC) extgl_GetProcAddress("glSampleCoverageARB");
EXTGL_SANITY_CHECK(env, ext_set, GL_ARB_multisample)
}
/*
* Class: org.lwjgl.opengl.arb.ARBMultisample
* Method: glSampleCoverageARB

55
src/native/common/arb/org_lwjgl_opengl_arb_ARBMultitexture.cpp
View File

@ -38,6 +38,61 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glActiveTextureARBPROC) (GLenum texture );
typedef void (APIENTRY * glClientActiveTextureARBPROC) (GLenum texture );
typedef void (APIENTRY * glMultiTexCoord1fARBPROC) (GLenum target, GLfloat 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 * 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 * 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 * 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 );
static glActiveTextureARBPROC glActiveTextureARB;
static glClientActiveTextureARBPROC glClientActiveTextureARB;
static glMultiTexCoord1fARBPROC glMultiTexCoord1fARB;
static glMultiTexCoord1iARBPROC glMultiTexCoord1iARB;
static glMultiTexCoord1sARBPROC glMultiTexCoord1sARB;
static glMultiTexCoord2fARBPROC glMultiTexCoord2fARB;
static glMultiTexCoord2iARBPROC glMultiTexCoord2iARB;
static glMultiTexCoord2sARBPROC glMultiTexCoord2sARB;
static glMultiTexCoord3fARBPROC glMultiTexCoord3fARB;
static glMultiTexCoord3iARBPROC glMultiTexCoord3iARB;
static glMultiTexCoord3sARBPROC glMultiTexCoord3sARB;
static glMultiTexCoord4fARBPROC glMultiTexCoord4fARB;
static glMultiTexCoord4iARBPROC glMultiTexCoord4iARB;
static glMultiTexCoord4sARBPROC glMultiTexCoord4sARB;
void extgl_InitARBMultitexture(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_ARB_multitexture)
return;
glActiveTextureARB = (glActiveTextureARBPROC) extgl_GetProcAddress("glActiveTextureARB");
glClientActiveTextureARB = (glClientActiveTextureARBPROC) extgl_GetProcAddress("glClientActiveTextureARB");
glMultiTexCoord1fARB = (glMultiTexCoord1fARBPROC) extgl_GetProcAddress("glMultiTexCoord1fARB");
glMultiTexCoord1iARB = (glMultiTexCoord1iARBPROC) extgl_GetProcAddress("glMultiTexCoord1iARB");
glMultiTexCoord1sARB = (glMultiTexCoord1sARBPROC) extgl_GetProcAddress("glMultiTexCoord1sARB");
glMultiTexCoord2fARB = (glMultiTexCoord2fARBPROC) extgl_GetProcAddress("glMultiTexCoord2fARB");
glMultiTexCoord2iARB = (glMultiTexCoord2iARBPROC) extgl_GetProcAddress("glMultiTexCoord2iARB");
glMultiTexCoord2sARB = (glMultiTexCoord2sARBPROC) extgl_GetProcAddress("glMultiTexCoord2sARB");
glMultiTexCoord3fARB = (glMultiTexCoord3fARBPROC) extgl_GetProcAddress("glMultiTexCoord3fARB");
glMultiTexCoord3iARB = (glMultiTexCoord3iARBPROC) extgl_GetProcAddress("glMultiTexCoord3iARB");
glMultiTexCoord3sARB = (glMultiTexCoord3sARBPROC) extgl_GetProcAddress("glMultiTexCoord3sARB");
glMultiTexCoord4fARB = (glMultiTexCoord4fARBPROC) extgl_GetProcAddress("glMultiTexCoord4fARB");
glMultiTexCoord4iARB = (glMultiTexCoord4iARBPROC) extgl_GetProcAddress("glMultiTexCoord4iARB");
glMultiTexCoord4sARB = (glMultiTexCoord4sARBPROC) extgl_GetProcAddress("glMultiTexCoord4sARB");
EXTGL_SANITY_CHECK(env, ext_set, GL_ARB_multitexture)
}
/*
* Class: org.lwjgl.opengl.arb.ARBMultitexture
* Method: glClientActiveTextureARB

15
src/native/common/arb/org_lwjgl_opengl_arb_ARBPointParameters.cpp
View File

@ -38,6 +38,21 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glPointParameterfARBPROC) (GLenum pname, GLfloat param);
typedef void (APIENTRY * glPointParameterfvARBPROC) (GLenum pname, GLfloat *params);
static glPointParameterfARBPROC glPointParameterfARB;
static glPointParameterfvARBPROC glPointParameterfvARB;
void extgl_InitARBPointParameters(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_ARB_point_parameters)
return;
glPointParameterfARB = (glPointParameterfARBPROC) extgl_GetProcAddress("glPointParameterfARB");
glPointParameterfvARB = (glPointParameterfvARBPROC) extgl_GetProcAddress("glPointParameterfvARB");
EXTGL_SANITY_CHECK(env, ext_set, GL_ARB_point_parameters)
}
/*
* Class: org.lwjgl.opengl.arb.ARBPointParameters
* Method: glPointParameterfARB

49
src/native/common/arb/org_lwjgl_opengl_arb_ARBProgram.cpp
View File

@ -38,6 +38,55 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glProgramStringARBPROC) (GLenum target, GLenum format, GLsizei len, 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) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
typedef void (APIENTRY * glProgramEnvParameter4fvARBPROC) (GLenum target, GLuint index, const GLfloat *params);
typedef void (APIENTRY * glProgramLocalParameter4fARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
typedef void (APIENTRY * glProgramLocalParameter4fvARBPROC) (GLenum target, GLuint index, const GLfloat *params);
typedef void (APIENTRY * glGetProgramEnvParameterfvARBPROC) (GLenum target, GLuint index, GLfloat *params);
typedef void (APIENTRY * glGetProgramLocalParameterfvARBPROC) (GLenum target, GLuint index, GLfloat *params);
typedef void (APIENTRY * glGetProgramivARBPROC) (GLenum target, GLenum pname, GLint *params);
typedef void (APIENTRY * glGetProgramStringARBPROC) (GLenum target, GLenum pname, GLvoid *string);
typedef GLboolean (APIENTRY * glIsProgramARBPROC) (GLuint program);
static glProgramStringARBPROC glProgramStringARB;
static glBindProgramARBPROC glBindProgramARB;
static glDeleteProgramsARBPROC glDeleteProgramsARB;
static glGenProgramsARBPROC glGenProgramsARB;
static glProgramEnvParameter4fARBPROC glProgramEnvParameter4fARB;
static glProgramEnvParameter4fvARBPROC glProgramEnvParameter4fvARB;
static glProgramLocalParameter4fARBPROC glProgramLocalParameter4fARB;
static glProgramLocalParameter4fvARBPROC glProgramLocalParameter4fvARB;
static glGetProgramEnvParameterfvARBPROC glGetProgramEnvParameterfvARB;
static glGetProgramLocalParameterfvARBPROC glGetProgramLocalParameterfvARB;
static glGetProgramivARBPROC glGetProgramivARB;
static glGetProgramStringARBPROC glGetProgramStringARB;
static glIsProgramARBPROC glIsProgramARB;
void extgl_InitARBProgram(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_ARB_fragment_program)
return;
glProgramStringARB = (glProgramStringARBPROC) extgl_GetProcAddress("glProgramStringARB");
glBindProgramARB = (glBindProgramARBPROC) extgl_GetProcAddress("glBindProgramARB");
glDeleteProgramsARB = (glDeleteProgramsARBPROC) extgl_GetProcAddress("glDeleteProgramsARB");
glGenProgramsARB = (glGenProgramsARBPROC) extgl_GetProcAddress("glGenProgramsARB");
glProgramEnvParameter4fARB = (glProgramEnvParameter4fARBPROC) extgl_GetProcAddress("glProgramEnvParameter4fARB");
glProgramEnvParameter4fvARB = (glProgramEnvParameter4fvARBPROC) extgl_GetProcAddress("glProgramEnvParameter4fvARB");
glProgramLocalParameter4fARB = (glProgramLocalParameter4fARBPROC) extgl_GetProcAddress("glProgramLocalParameter4fARB");
glProgramLocalParameter4fvARB = (glProgramLocalParameter4fvARBPROC) extgl_GetProcAddress("glProgramLocalParameter4fvARB");
glGetProgramEnvParameterfvARB = (glGetProgramEnvParameterfvARBPROC) extgl_GetProcAddress("glGetProgramEnvParameterfvARB");
glGetProgramLocalParameterfvARB = (glGetProgramLocalParameterfvARBPROC) extgl_GetProcAddress("glGetProgramLocalParameterfvARB");
glGetProgramivARB = (glGetProgramivARBPROC) extgl_GetProcAddress("glGetProgramivARB");
glGetProgramStringARB = (glGetProgramStringARBPROC) extgl_GetProcAddress("glGetProgramStringARB");
glIsProgramARB = (glIsProgramARBPROC) extgl_GetProcAddress("glIsProgramARB");
EXTGL_SANITY_CHECK(env, ext_set, GL_ARB_fragment_program)
}
/*
* Class: org.lwjgl.opengl.arb.ARBProgram
* Method: nglProgramStringARB

30
src/native/common/arb/org_lwjgl_opengl_arb_ARBTextureCompression.cpp
View File

@ -38,6 +38,36 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glCompressedTexImage1DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data );
typedef void (APIENTRY * glCompressedTexImage2DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data );
typedef void (APIENTRY * glCompressedTexImage3DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data );
typedef void (APIENTRY * glCompressedTexSubImage1DARBPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data );
typedef void (APIENTRY * glCompressedTexSubImage2DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data );
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 *data );
typedef void (APIENTRY * glGetCompressedTexImageARBPROC) (GLenum target, GLint lod, GLvoid *img );
static glCompressedTexImage3DARBPROC glCompressedTexImage3DARB;
static glCompressedTexImage2DARBPROC glCompressedTexImage2DARB;
static glCompressedTexImage1DARBPROC glCompressedTexImage1DARB;
static glCompressedTexSubImage3DARBPROC glCompressedTexSubImage3DARB;
static glCompressedTexSubImage2DARBPROC glCompressedTexSubImage2DARB;
static glCompressedTexSubImage1DARBPROC glCompressedTexSubImage1DARB;
static glGetCompressedTexImageARBPROC glGetCompressedTexImageARB;
void extgl_InitARBTextureCompression(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_ARB_texture_compression)
return;
glCompressedTexImage3DARB = (glCompressedTexImage3DARBPROC) extgl_GetProcAddress("glCompressedTexImage3DARB");
glCompressedTexImage2DARB = (glCompressedTexImage2DARBPROC) extgl_GetProcAddress("glCompressedTexImage2DARB");
glCompressedTexImage1DARB = (glCompressedTexImage1DARBPROC) extgl_GetProcAddress("glCompressedTexImage1DARB");
glCompressedTexSubImage3DARB = (glCompressedTexSubImage3DARBPROC) extgl_GetProcAddress("glCompressedTexSubImage3DARB");
glCompressedTexSubImage2DARB = (glCompressedTexSubImage2DARBPROC) extgl_GetProcAddress("glCompressedTexSubImage2DARB");
glCompressedTexSubImage1DARB = (glCompressedTexSubImage1DARBPROC) extgl_GetProcAddress("glCompressedTexSubImage1DARB");
glGetCompressedTexImageARB = (glGetCompressedTexImageARBPROC) extgl_GetProcAddress("glGetCompressedTexImageARB");
EXTGL_SANITY_CHECK(env, ext_set, GL_ARB_texture_compression)
}
/*
* Class: org.lwjgl.opengl.arb.ARBTextureCompression
* Method: nglCompressedTexImage1DARB

15
src/native/common/arb/org_lwjgl_opengl_arb_ARBTransposeMatrix.cpp
View File

@ -38,6 +38,21 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glLoadTransposeMatrixfARBPROC) (const GLfloat m[16] );
typedef void (APIENTRY * glMultTransposeMatrixfARBPROC) (const GLfloat m[16] );
static glLoadTransposeMatrixfARBPROC glLoadTransposeMatrixfARB;
static glMultTransposeMatrixfARBPROC glMultTransposeMatrixfARB;
void extgl_InitARBTransposeMatrix(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_ARB_transpose_matrix)
return;
glLoadTransposeMatrixfARB = (glLoadTransposeMatrixfARBPROC) extgl_GetProcAddress("glLoadTransposeMatrixfARB");
glMultTransposeMatrixfARB = (glMultTransposeMatrixfARBPROC) extgl_GetProcAddress("glMultTransposeMatrixfARB");
EXTGL_SANITY_CHECK(env, ext_set, GL_ARB_transpose_matrix)
}
/*
* Class: org.lwjgl.opengl.arb.ARBTransposeMatrix
* Method: nglLoadTransposeMatrixfARB

36
src/native/common/arb/org_lwjgl_opengl_arb_ARBVertexBlend.cpp
View File

@ -38,6 +38,42 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glWeightbvARBPROC) (GLint size, GLbyte *weights);
typedef void (APIENTRY * glWeightsvARBPROC) (GLint size, GLshort *weights);
typedef void (APIENTRY * glWeightivARBPROC) (GLint size, GLint *weights);
typedef void (APIENTRY * glWeightfvARBPROC) (GLint size, GLfloat *weights);
typedef void (APIENTRY * glWeightubvARBPROC) (GLint size, GLubyte *weights);
typedef void (APIENTRY * glWeightusvARBPROC) (GLint size, GLushort *weights);
typedef void (APIENTRY * glWeightuivARBPROC) (GLint size, GLuint *weights);
typedef void (APIENTRY * glWeightPointerARBPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
typedef void (APIENTRY * glVertexBlendARBPROC) (GLint count);
static glWeightbvARBPROC glWeightbvARB;
static glWeightsvARBPROC glWeightsvARB;
static glWeightivARBPROC glWeightivARB;
static glWeightfvARBPROC glWeightfvARB;
static glWeightubvARBPROC glWeightubvARB;
static glWeightusvARBPROC glWeightusvARB;
static glWeightuivARBPROC glWeightuivARB;
static glWeightPointerARBPROC glWeightPointerARB;
static glVertexBlendARBPROC glVertexBlendARB;
void extgl_InitARBVertexBlend(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_ARB_vertex_blend)
return;
glWeightbvARB = (glWeightbvARBPROC) extgl_GetProcAddress("glWeightbvARB");
glWeightsvARB = (glWeightsvARBPROC) extgl_GetProcAddress("glWeightsvARB");
glWeightivARB = (glWeightivARBPROC) extgl_GetProcAddress("glWeightivARB");
glWeightfvARB = (glWeightfvARBPROC) extgl_GetProcAddress("glWeightfvARB");
glWeightubvARB = (glWeightubvARBPROC) extgl_GetProcAddress("glWeightubvARB");
glWeightusvARB = (glWeightusvARBPROC) extgl_GetProcAddress("glWeightusvARB");
glWeightuivARB = (glWeightuivARBPROC) extgl_GetProcAddress("glWeightuivARB");
glWeightPointerARB = (glWeightPointerARBPROC) extgl_GetProcAddress("glWeightPointerARB");
glVertexBlendARB = (glVertexBlendARBPROC) extgl_GetProcAddress("glVertexBlendARB");
EXTGL_SANITY_CHECK(env, ext_set, GL_ARB_vertex_blend)
}
/*
* Class: org.lwjgl.opengl.arb.ARBVertexBlend
* Method: nglWeightbvARB

45
src/native/common/arb/org_lwjgl_opengl_arb_ARBVertexBufferObject.cpp
View File

@ -38,6 +38,51 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef int GLintptrARB;
typedef unsigned int GLsizeiptrARB;
typedef void (APIENTRY * glBindBufferARBPROC) (GLenum target, GLuint buffer);
typedef void (APIENTRY * glDeleteBuffersARBPROC) (GLsizei n, const GLuint *buffers);
typedef void (APIENTRY * glGenBuffersARBPROC) (GLsizei 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 void * (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 **params);
static glBindBufferARBPROC glBindBufferARB;
static glDeleteBuffersARBPROC glDeleteBuffersARB;
static glGenBuffersARBPROC glGenBuffersARB;
static glIsBufferARBPROC glIsBufferARB;
static glBufferDataARBPROC glBufferDataARB;
static glBufferSubDataARBPROC glBufferSubDataARB;
static glGetBufferSubDataARBPROC glGetBufferSubDataARB;
static glMapBufferARBPROC glMapBufferARB;
static glUnmapBufferARBPROC glUnmapBufferARB;
static glGetBufferParameterivARBPROC glGetBufferParameterivARB;
static glGetBufferPointervARBPROC glGetBufferPointervARB;
void extgl_InitARBVertexBufferObject(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_ARB_vertex_buffer_object)
return;
glBindBufferARB = (glBindBufferARBPROC) extgl_GetProcAddress("glBindBufferARB");
glDeleteBuffersARB = (glDeleteBuffersARBPROC) extgl_GetProcAddress("glDeleteBuffersARB");
glGenBuffersARB = (glGenBuffersARBPROC) extgl_GetProcAddress("glGenBuffersARB");
glIsBufferARB = (glIsBufferARBPROC) extgl_GetProcAddress("glIsBufferARB");
glBufferDataARB = (glBufferDataARBPROC) extgl_GetProcAddress("glBufferDataARB");
glBufferSubDataARB = (glBufferSubDataARBPROC) extgl_GetProcAddress("glBufferSubDataARB");
glGetBufferSubDataARB = (glGetBufferSubDataARBPROC) extgl_GetProcAddress("glGetBufferSubDataARB");
glMapBufferARB = (glMapBufferARBPROC) extgl_GetProcAddress("glMapBufferARB");
glUnmapBufferARB = (glUnmapBufferARBPROC) extgl_GetProcAddress("glUnmapBufferARB");
glGetBufferParameterivARB = (glGetBufferParameterivARBPROC) extgl_GetProcAddress("glGetBufferParameterivARB");
glGetBufferPointervARB = (glGetBufferPointervARBPROC) extgl_GetProcAddress("glGetBufferPointervARB");
EXTGL_SANITY_CHECK(env, ext_set, GL_ARB_vertex_buffer_object)
}
/*
* Class: org.lwjgl.opengl.arb.ARBVertexBufferObject
* Method: nglBindBufferARB

324
src/native/common/arb/org_lwjgl_opengl_arb_ARBVertexProgram.cpp
View File

@ -38,6 +38,83 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glVertexAttrib1sARBPROC) (GLuint index, GLshort x);
typedef void (APIENTRY * glVertexAttrib1fARBPROC) (GLuint index, GLfloat x);
typedef void (APIENTRY * glVertexAttrib2sARBPROC) (GLuint index, GLshort x, GLshort y);
typedef void (APIENTRY * glVertexAttrib2fARBPROC) (GLuint index, GLfloat x, GLfloat 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 * 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 * glVertexAttrib4NubARBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
typedef void (APIENTRY * glVertexAttrib1svARBPROC) (GLuint index, const GLshort *v);
typedef void (APIENTRY * glVertexAttrib1fvARBPROC) (GLuint index, const GLfloat *v);
typedef void (APIENTRY * glVertexAttrib2svARBPROC) (GLuint index, const GLshort *v);
typedef void (APIENTRY * glVertexAttrib2fvARBPROC) (GLuint index, const GLfloat *v);
typedef void (APIENTRY * glVertexAttrib2dvARBPROC) (GLuint index, const GLdouble *v);
typedef void (APIENTRY * glVertexAttrib3svARBPROC) (GLuint index, const GLshort *v);
typedef void (APIENTRY * glVertexAttrib3fvARBPROC) (GLuint index, const GLfloat *v);
typedef void (APIENTRY * glVertexAttrib3dvARBPROC) (GLuint index, const GLdouble *v);
typedef void (APIENTRY * glVertexAttrib4bvARBPROC) (GLuint index, const GLbyte *v);
typedef void (APIENTRY * glVertexAttrib4svARBPROC) (GLuint index, const GLshort *v);
typedef void (APIENTRY * glVertexAttrib4ivARBPROC) (GLuint index, const GLint *v);
typedef void (APIENTRY * glVertexAttrib4ubvARBPROC) (GLuint index, const GLubyte *v);
typedef void (APIENTRY * glVertexAttrib4usvARBPROC) (GLuint index, const GLushort *v);
typedef void (APIENTRY * glVertexAttrib4uivARBPROC) (GLuint index, const GLuint *v);
typedef void (APIENTRY * glVertexAttrib4fvARBPROC) (GLuint index, const GLfloat *v);
typedef void (APIENTRY * glVertexAttrib4dvARBPROC) (GLuint index, const GLdouble *v);
typedef void (APIENTRY * glVertexAttrib4NbvARBPROC) (GLuint index, const GLbyte *v);
typedef void (APIENTRY * glVertexAttrib4NsvARBPROC) (GLuint index, const GLshort *v);
typedef void (APIENTRY * glVertexAttrib4NivARBPROC) (GLuint index, const GLint *v);
typedef void (APIENTRY * glVertexAttrib4NubvARBPROC) (GLuint index, const GLubyte *v);
typedef void (APIENTRY * glVertexAttrib4NusvARBPROC) (GLuint index, const GLushort *v);
typedef void (APIENTRY * glVertexAttrib4NuivARBPROC) (GLuint index, const GLuint *v);
typedef void (APIENTRY * glVertexAttribPointerARBPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
typedef void (APIENTRY * glEnableVertexAttribArrayARBPROC) (GLuint index);
typedef void (APIENTRY * glDisableVertexAttribArrayARBPROC) (GLuint index);
typedef void (APIENTRY * glGetVertexAttribdvARBPROC) (GLuint index, GLenum pname, GLdouble *params);
typedef void (APIENTRY * glGetVertexAttribfvARBPROC) (GLuint index, GLenum pname, GLfloat *params);
typedef void (APIENTRY * glGetVertexAttribivARBPROC) (GLuint index, GLenum pname, GLint *params);
typedef void (APIENTRY * glGetVertexAttribPointervARBPROC) (GLuint index, GLenum pname, GLvoid **pointer);
static glVertexAttrib1sARBPROC glVertexAttrib1sARB;
static glVertexAttrib1fARBPROC glVertexAttrib1fARB;
static glVertexAttrib2sARBPROC glVertexAttrib2sARB;
static glVertexAttrib2fARBPROC glVertexAttrib2fARB;
static glVertexAttrib3sARBPROC glVertexAttrib3sARB;
static glVertexAttrib3fARBPROC glVertexAttrib3fARB;
static glVertexAttrib4sARBPROC glVertexAttrib4sARB;
static glVertexAttrib4fARBPROC glVertexAttrib4fARB;
static glVertexAttrib4NubARBPROC glVertexAttrib4NubARB;
static glVertexAttribPointerARBPROC glVertexAttribPointerARB;
static glEnableVertexAttribArrayARBPROC glEnableVertexAttribArrayARB;
static glDisableVertexAttribArrayARBPROC glDisableVertexAttribArrayARB;
static glGetVertexAttribfvARBPROC glGetVertexAttribfvARB;
static glGetVertexAttribivARBPROC glGetVertexAttribivARB;
static glGetVertexAttribPointervARBPROC glGetVertexAttribPointervARB;
void extgl_InitARBVertexProgram(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_ARB_vertex_program)
return;
glVertexAttrib1sARB = (glVertexAttrib1sARBPROC) extgl_GetProcAddress("glVertexAttrib1sARB");
glVertexAttrib1fARB = (glVertexAttrib1fARBPROC) extgl_GetProcAddress("glVertexAttrib1fARB");
glVertexAttrib2sARB = (glVertexAttrib2sARBPROC) extgl_GetProcAddress("glVertexAttrib2sARB");
glVertexAttrib2fARB = (glVertexAttrib2fARBPROC) extgl_GetProcAddress("glVertexAttrib2fARB");
glVertexAttrib3sARB = (glVertexAttrib3sARBPROC) extgl_GetProcAddress("glVertexAttrib3sARB");
glVertexAttrib3fARB = (glVertexAttrib3fARBPROC) extgl_GetProcAddress("glVertexAttrib3fARB");
glVertexAttrib4sARB = (glVertexAttrib4sARBPROC) extgl_GetProcAddress("glVertexAttrib4sARB");
glVertexAttrib4fARB = (glVertexAttrib4fARBPROC) extgl_GetProcAddress("glVertexAttrib4fARB");
glVertexAttrib4NubARB = (glVertexAttrib4NubARBPROC) extgl_GetProcAddress("glVertexAttrib4NubARB");
glVertexAttribPointerARB = (glVertexAttribPointerARBPROC) extgl_GetProcAddress("glVertexAttribPointerARB");
glEnableVertexAttribArrayARB = (glEnableVertexAttribArrayARBPROC) extgl_GetProcAddress("glEnableVertexAttribArrayARB");
glDisableVertexAttribArrayARB = (glDisableVertexAttribArrayARBPROC) extgl_GetProcAddress("glDisableVertexAttribArrayARB");
glGetVertexAttribfvARB = (glGetVertexAttribfvARBPROC) extgl_GetProcAddress("glGetVertexAttribfvARB");
glGetVertexAttribivARB = (glGetVertexAttribivARBPROC) extgl_GetProcAddress("glGetVertexAttribivARB");
glGetVertexAttribPointervARB = (glGetVertexAttribPointervARBPROC) extgl_GetProcAddress("glGetVertexAttribPointervARB");
EXTGL_SANITY_CHECK(env, ext_set, GL_ARB_vertex_program)
}
/*
* Class: org.lwjgl.opengl.arb.ARBVertexProgram
* Method: glVertexAttrib1sARB
@ -146,253 +223,6 @@ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_arb_ARBVertexProgram_glVertexAttrib
CHECK_GL_ERROR
}
/*
* Class: org.lwjgl.opengl.arb.ARBVertexProgram
* Method: nglVertexAttrib1svARB
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_arb_ARBVertexProgram_nglVertexAttrib1svARB
(JNIEnv * env, jclass clazz, jint index, jobject values, jint valuesOffset)
{
CHECK_EXISTS(glVertexAttrib1svARB)
GLshort *values_ptr = (GLshort *)env->GetDirectBufferAddress(values) + valuesOffset;
glVertexAttrib1svARB(index, values_ptr);
CHECK_GL_ERROR
}
/*
* Class: org.lwjgl.opengl.arb.ARBVertexProgram
* Method: nglVertexAttrib1fvARB
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_arb_ARBVertexProgram_nglVertexAttrib1fvARB
(JNIEnv * env, jclass clazz, jint index, jobject values, jint valuesOffset)
{
CHECK_EXISTS(glVertexAttrib1fvARB)
GLfloat *values_ptr = (GLfloat *)env->GetDirectBufferAddress(values) + valuesOffset;
glVertexAttrib1fvARB(index, values_ptr);
CHECK_GL_ERROR
}
/*
* Class: org.lwjgl.opengl.arb.ARBVertexProgram
* Method: nglVertexAttrib2svARB
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_arb_ARBVertexProgram_nglVertexAttrib2svARB
(JNIEnv * env, jclass clazz, jint index, jobject values, jint valuesOffset)
{
CHECK_EXISTS(glVertexAttrib2svARB)
GLshort *values_ptr = (GLshort *)env->GetDirectBufferAddress(values) + valuesOffset;
glVertexAttrib2svARB(index, values_ptr);
CHECK_GL_ERROR
}
/*
* Class: org.lwjgl.opengl.arb.ARBVertexProgram
* Method: nglVertexAttrib2fvARB
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_arb_ARBVertexProgram_nglVertexAttrib2fvARB
(JNIEnv * env, jclass clazz, jint index, jobject values, jint valuesOffset)
{
CHECK_EXISTS(glVertexAttrib2fvARB)
GLfloat *values_ptr = (GLfloat *)env->GetDirectBufferAddress(values) + valuesOffset;
glVertexAttrib2fvARB(index, values_ptr);
CHECK_GL_ERROR
}
/*
* Class: org.lwjgl.opengl.arb.ARBVertexProgram
* Method: nglVertexAttrib3svARB
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_arb_ARBVertexProgram_nglVertexAttrib3svARB
(JNIEnv * env, jclass clazz, jint index, jobject values, jint valuesOffset)
{
CHECK_EXISTS(glVertexAttrib3svARB)
GLshort *values_ptr = (GLshort *)env->GetDirectBufferAddress(values) + valuesOffset;
glVertexAttrib3svARB(index, values_ptr);
CHECK_GL_ERROR
}
/*
* Class: org.lwjgl.opengl.arb.ARBVertexProgram
* Method: nglVertexAttrib3fvARB
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_arb_ARBVertexProgram_nglVertexAttrib3fvARB
(JNIEnv * env, jclass clazz, jint index, jobject values, jint valuesOffset)
{
CHECK_EXISTS(glVertexAttrib3fvARB)
GLfloat *values_ptr = (GLfloat *)env->GetDirectBufferAddress(values) + valuesOffset;
glVertexAttrib3fvARB(index, values_ptr);
CHECK_GL_ERROR
}
/*
* Class: org.lwjgl.opengl.arb.ARBVertexProgram
* Method: nglVertexAttrib4bvARB
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_arb_ARBVertexProgram_nglVertexAttrib4bvARB
(JNIEnv * env, jclass clazz, jint index, jobject values, jint valuesOffset)
{
CHECK_EXISTS(glVertexAttrib4bvARB)
GLbyte *values_ptr = (GLbyte *)env->GetDirectBufferAddress(values) + valuesOffset;
glVertexAttrib4bvARB(index, values_ptr);
CHECK_GL_ERROR
}
/*
* Class: org.lwjgl.opengl.arb.ARBVertexProgram
* Method: nglVertexAttrib4svARB
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_arb_ARBVertexProgram_nglVertexAttrib4svARB
(JNIEnv * env, jclass clazz, jint index, jobject values, jint valuesOffset)
{
CHECK_EXISTS(glVertexAttrib4svARB)
GLshort *values_ptr = (GLshort *)env->GetDirectBufferAddress(values) + valuesOffset;
glVertexAttrib4svARB(index, values_ptr);
CHECK_GL_ERROR
}
/*
* Class: org.lwjgl.opengl.arb.ARBVertexProgram
* Method: nglVertexAttrib4ivARB
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_arb_ARBVertexProgram_nglVertexAttrib4ivARB
(JNIEnv * env, jclass clazz, jint index, jobject values, jint valuesOffset)
{
CHECK_EXISTS(glVertexAttrib4ivARB)
GLint *values_ptr = (GLint *)env->GetDirectBufferAddress(values) + valuesOffset;
glVertexAttrib4ivARB(index, values_ptr);
CHECK_GL_ERROR
}
/*
* Class: org.lwjgl.opengl.arb.ARBVertexProgram
* Method: nglVertexAttrib4ubvARB
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_arb_ARBVertexProgram_nglVertexAttrib4ubvARB
(JNIEnv * env, jclass clazz, jint index, jobject values, jint valuesOffset)
{
CHECK_EXISTS(glVertexAttrib4ubvARB)
GLubyte *values_ptr = (GLubyte *)env->GetDirectBufferAddress(values) + valuesOffset;
glVertexAttrib4ubvARB(index, values_ptr);
CHECK_GL_ERROR
}
/*
* Class: org.lwjgl.opengl.arb.ARBVertexProgram
* Method: nglVertexAttrib4usvARB
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_arb_ARBVertexProgram_nglVertexAttrib4usvARB
(JNIEnv * env, jclass clazz, jint index, jobject values, jint valuesOffset)
{
CHECK_EXISTS(glVertexAttrib4usvARB)
GLushort *values_ptr = (GLushort *)env->GetDirectBufferAddress(values) + valuesOffset;
glVertexAttrib4usvARB(index, values_ptr);
CHECK_GL_ERROR
}
/*
* Class: org.lwjgl.opengl.arb.ARBVertexProgram
* Method: nglVertexAttrib4uivARB
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_arb_ARBVertexProgram_nglVertexAttrib4uivARB
(JNIEnv * env, jclass clazz, jint index, jobject values, jint valuesOffset)
{
CHECK_EXISTS(glVertexAttrib4uivARB)
GLuint *values_ptr = (GLuint *)env->GetDirectBufferAddress(values) + valuesOffset;
glVertexAttrib4uivARB(index, values_ptr);
CHECK_GL_ERROR
}
/*
* Class: org.lwjgl.opengl.arb.ARBVertexProgram
* Method: nglVertexAttrib4fvARB
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_arb_ARBVertexProgram_nglVertexAttrib4fvARB
(JNIEnv * env, jclass clazz, jint index, jobject values, jint valuesOffset)
{
CHECK_EXISTS(glVertexAttrib4fvARB)
GLfloat *values_ptr = (GLfloat *)env->GetDirectBufferAddress(values) + valuesOffset;
glVertexAttrib4fvARB(index, values_ptr);
CHECK_GL_ERROR
}
/*
* Class: org.lwjgl.opengl.arb.ARBVertexProgram
* Method: nglVertexAttrib4NbvARB
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_arb_ARBVertexProgram_nglVertexAttrib4NbvARB
(JNIEnv * env, jclass clazz, jint index, jobject values, jint valuesOffset)
{
CHECK_EXISTS(glVertexAttrib4NbvARB)
GLbyte *values_ptr = (GLbyte *)env->GetDirectBufferAddress(values) + valuesOffset;
glVertexAttrib4NbvARB(index, values_ptr);
CHECK_GL_ERROR
}
/*
* Class: org.lwjgl.opengl.arb.ARBVertexProgram
* Method: nglVertexAttrib4NsvARB
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_arb_ARBVertexProgram_nglVertexAttrib4NsvARB
(JNIEnv * env, jclass clazz, jint index, jobject values, jint valuesOffset)
{
CHECK_EXISTS(glVertexAttrib4NsvARB)
GLshort *values_ptr = (GLshort *)env->GetDirectBufferAddress(values) + valuesOffset;
glVertexAttrib4NsvARB(index, values_ptr);
CHECK_GL_ERROR
}
/*
* Class: org.lwjgl.opengl.arb.ARBVertexProgram
* Method: nglVertexAttrib4NivARB
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_arb_ARBVertexProgram_nglVertexAttrib4NivARB
(JNIEnv * env, jclass clazz, jint index, jobject values, jint valuesOffset)
{
CHECK_EXISTS(glVertexAttrib4NivARB)
GLint *values_ptr = (GLint *)env->GetDirectBufferAddress(values) + valuesOffset;
glVertexAttrib4NivARB(index, values_ptr);
CHECK_GL_ERROR
}
/*
* Class: org.lwjgl.opengl.arb.ARBVertexProgram
* Method: nglVertexAttrib4NubvARB
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_arb_ARBVertexProgram_nglVertexAttrib4NubvARB
(JNIEnv * env, jclass clazz, jint index, jobject values, jint valuesOffset)
{
CHECK_EXISTS(glVertexAttrib4NubvARB)
GLubyte *values_ptr = (GLubyte *)env->GetDirectBufferAddress(values) + valuesOffset;
glVertexAttrib4NubvARB(index, values_ptr);
CHECK_GL_ERROR
}
/*
* Class: org.lwjgl.opengl.arb.ARBVertexProgram
* Method: nglVertexAttrib4NusvARB
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_arb_ARBVertexProgram_nglVertexAttrib4NusvARB
(JNIEnv * env, jclass clazz, jint index, jobject values, jint valuesOffset)
{
CHECK_EXISTS(glVertexAttrib4NusvARB)
GLushort *values_ptr = (GLushort *)env->GetDirectBufferAddress(values) + valuesOffset;
glVertexAttrib4NusvARB(index, values_ptr);
CHECK_GL_ERROR
}
/*
* Class: org.lwjgl.opengl.arb.ARBVertexProgram
* Method: nglVertexAttrib4NuivARB
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_arb_ARBVertexProgram_nglVertexAttrib4NuivARB
(JNIEnv * env, jclass clazz, jint index, jobject values, jint valuesOffset)
{
CHECK_EXISTS(glVertexAttrib4NuivARB)
GLuint *values_ptr = (GLuint *)env->GetDirectBufferAddress(values) + valuesOffset;
glVertexAttrib4NuivARB(index, values_ptr);
CHECK_GL_ERROR
}
/*
* Class: org.lwjgl.opengl.arb.ARBVertexProgram
* Method: nglVertexAttribPointerARB

27
src/native/common/arb/org_lwjgl_opengl_arb_ARBWindowPos.cpp
View File

@ -38,6 +38,33 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glWindowPos2fARBPROC) (GLfloat x, GLfloat 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 * glWindowPos3iARBPROC) (GLint x, GLint y, GLint z);
typedef void (APIENTRY * glWindowPos3sARBPROC) (GLshort x, GLshort y, GLshort z);
static glWindowPos2fARBPROC glWindowPos2fARB;
static glWindowPos2iARBPROC glWindowPos2iARB;
static glWindowPos2sARBPROC glWindowPos2sARB;
static glWindowPos3fARBPROC glWindowPos3fARB;
static glWindowPos3iARBPROC glWindowPos3iARB;
static glWindowPos3sARBPROC glWindowPos3sARB;
void extgl_InitARBWindowPos(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_ARB_window_pos)
return;
glWindowPos2fARB = (glWindowPos2fARBPROC) extgl_GetProcAddress("glWindowPos2fARB");
glWindowPos2iARB = (glWindowPos2iARBPROC) extgl_GetProcAddress("glWindowPos2iARB");
glWindowPos2sARB = (glWindowPos2sARBPROC) extgl_GetProcAddress("glWindowPos2sARB");
glWindowPos3fARB = (glWindowPos3fARBPROC) extgl_GetProcAddress("glWindowPos3fARB");
glWindowPos3iARB = (glWindowPos3iARBPROC) extgl_GetProcAddress("glWindowPos3iARB");
glWindowPos3sARB = (glWindowPos3sARBPROC) extgl_GetProcAddress("glWindowPos3sARB");
EXTGL_SANITY_CHECK(env, ext_set, GL_ARB_window_pos)
}
/*
* Class: org.lwjgl.opengl.arb.ARBWindowPos
* Method: glWindowPos2fARB

18
src/native/common/ati/org_lwjgl_opengl_ati_ATIElementArray.cpp
View File

@ -38,6 +38,24 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glElementPointerATIPROC) (GLenum type, const GLvoid *pointer);
typedef void (APIENTRY * glDrawElementArrayATIPROC) (GLenum mode, GLsizei count);
typedef void (APIENTRY * glDrawRangeElementArrayATIPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count);
static glElementPointerATIPROC glElementPointerATI;
static glDrawElementArrayATIPROC glDrawElementArrayATI;
static glDrawRangeElementArrayATIPROC glDrawRangeElementArrayATI;
void extgl_InitATIElementArray(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_ATI_element_array)
return;
glElementPointerATI = (glElementPointerATIPROC) extgl_GetProcAddress("glElementPointerATI");
glDrawElementArrayATI = (glDrawElementArrayATIPROC) extgl_GetProcAddress("glDrawElementArrayATI");
glDrawRangeElementArrayATI = (glDrawRangeElementArrayATIPROC) extgl_GetProcAddress("glDrawRangeElementArrayATI");
EXTGL_SANITY_CHECK(env, ext_set, GL_ATI_element_array)
}
/*
* Class: org.lwjgl.opengl.ati.ATIElementArray
* Method: nglElementPointerATI

21
src/native/common/ati/org_lwjgl_opengl_ati_ATIEnvmapBumpmap.cpp
View File

@ -38,6 +38,27 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glTexBumpParameterivATIPROC) (GLenum pname, GLint *param);
typedef void (APIENTRY * glTexBumpParameterfvATIPROC) (GLenum pname, GLfloat *param);
typedef void (APIENTRY * glGetTexBumpParameterivATIPROC) (GLenum pname, GLint *param);
typedef void (APIENTRY * glGetTexBumpParameterfvATIPROC) (GLenum pname, GLfloat *param);
static glTexBumpParameterivATIPROC glTexBumpParameterivATI;
static glTexBumpParameterfvATIPROC glTexBumpParameterfvATI;
static glGetTexBumpParameterivATIPROC glGetTexBumpParameterivATI;
static glGetTexBumpParameterfvATIPROC glGetTexBumpParameterfvATI;
void extgl_InitATIEnvmapBumpmap(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_ATI_envmap_bumpmap)
return;
glTexBumpParameterivATI = (glTexBumpParameterivATIPROC) extgl_GetProcAddress("glTexBumpParameterivATI");
glTexBumpParameterfvATI = (glTexBumpParameterfvATIPROC) extgl_GetProcAddress("glTexBumpParameterfvATI");
glGetTexBumpParameterivATI = (glGetTexBumpParameterivATIPROC) extgl_GetProcAddress("glGetTexBumpParameterivATI");
glGetTexBumpParameterfvATI = (glGetTexBumpParameterfvATIPROC) extgl_GetProcAddress("glGetTexBumpParameterfvATI");
EXTGL_SANITY_CHECK(env, ext_set, GL_ATI_envmap_bumpmap)
}
/*
* Class: org.lwjgl.opengl.ati.ATIEnvmapBumpmap
* Method: nglTexBumpParameterfvATI

51
src/native/common/ati/org_lwjgl_opengl_ati_ATIFragmentShader.cpp
View File

@ -38,6 +38,57 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef GLuint (APIENTRY * glGenFragmentShadersATIPROC) (GLuint range);
typedef void (APIENTRY * glBindFragmentShaderATIPROC) (GLuint id);
typedef void (APIENTRY * glDeleteFragmentShaderATIPROC) (GLuint id);
typedef void (APIENTRY * glBeginFragmentShaderATIPROC) (GLvoid);
typedef void (APIENTRY * glEndFragmentShaderATIPROC) (GLvoid);
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 *value);
static glGenFragmentShadersATIPROC glGenFragmentShadersATI;
static glBindFragmentShaderATIPROC glBindFragmentShaderATI;
static glDeleteFragmentShaderATIPROC glDeleteFragmentShaderATI;
static glBeginFragmentShaderATIPROC glBeginFragmentShaderATI;
static glEndFragmentShaderATIPROC glEndFragmentShaderATI;
static glPassTexCoordATIPROC glPassTexCoordATI;
static glSampleMapATIPROC glSampleMapATI;
static glColorFragmentOp1ATIPROC glColorFragmentOp1ATI;
static glColorFragmentOp2ATIPROC glColorFragmentOp2ATI;
static glColorFragmentOp3ATIPROC glColorFragmentOp3ATI;
static glAlphaFragmentOp1ATIPROC glAlphaFragmentOp1ATI;
static glAlphaFragmentOp2ATIPROC glAlphaFragmentOp2ATI;
static glAlphaFragmentOp3ATIPROC glAlphaFragmentOp3ATI;
static glSetFragmentShaderConstantATIPROC glSetFragmentShaderConstantATI;
void extgl_InitATIFragmentShader(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_ATI_fragment_shader)
return;
glGenFragmentShadersATI = (glGenFragmentShadersATIPROC) extgl_GetProcAddress("glGenFragmentShadersATI");
glBindFragmentShaderATI = (glBindFragmentShaderATIPROC) extgl_GetProcAddress("glBindFragmentShaderATI");
glDeleteFragmentShaderATI = (glDeleteFragmentShaderATIPROC) extgl_GetProcAddress("glDeleteFragmentShaderATI");
glBeginFragmentShaderATI = (glBeginFragmentShaderATIPROC) extgl_GetProcAddress("glBeginFragmentShaderATI");
glEndFragmentShaderATI = (glEndFragmentShaderATIPROC) extgl_GetProcAddress("glEndFragmentShaderATI");
glPassTexCoordATI = (glPassTexCoordATIPROC) extgl_GetProcAddress("glPassTexCoordATI");
glSampleMapATI = (glSampleMapATIPROC) extgl_GetProcAddress("glSampleMapATI");
glColorFragmentOp1ATI = (glColorFragmentOp1ATIPROC) extgl_GetProcAddress("glColorFragmentOp1ATI");
glColorFragmentOp2ATI = (glColorFragmentOp2ATIPROC) extgl_GetProcAddress("glColorFragmentOp2ATI");
glColorFragmentOp3ATI = (glColorFragmentOp3ATIPROC) extgl_GetProcAddress("glColorFragmentOp3ATI");
glAlphaFragmentOp1ATI = (glAlphaFragmentOp1ATIPROC) extgl_GetProcAddress("glAlphaFragmentOp1ATI");
glAlphaFragmentOp2ATI = (glAlphaFragmentOp2ATIPROC) extgl_GetProcAddress("glAlphaFragmentOp2ATI");
glAlphaFragmentOp3ATI = (glAlphaFragmentOp3ATIPROC) extgl_GetProcAddress("glAlphaFragmentOp3ATI");
glSetFragmentShaderConstantATI = (glSetFragmentShaderConstantATIPROC) extgl_GetProcAddress("glSetFragmentShaderConstantATI");
EXTGL_SANITY_CHECK(env, ext_set, GL_ATI_fragment_shader)
}
/*
* Class: org.lwjgl.opengl.ati.ATIFragmentShader
* Method: glGenFragmentShadersATI

15
src/native/common/ati/org_lwjgl_opengl_ati_ATIPnTriangles.cpp
View File

@ -38,6 +38,21 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glPNTrianglesiATIPROC) (GLenum pname, GLint param);
typedef void (APIENTRY * glPNTrianglesfATIPROC) (GLenum pname, GLfloat param);
static glPNTrianglesiATIPROC glPNTrianglesiATI;
static glPNTrianglesfATIPROC glPNTrianglesfATI;
void extgl_InitATIPNTriangles(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_ATI_pn_triangles)
return;
glPNTrianglesiATI = (glPNTrianglesiATIPROC) extgl_GetProcAddress("glPNTrianglesiATI");
glPNTrianglesfATI = (glPNTrianglesfATIPROC) extgl_GetProcAddress("glPNTrianglesfATI");
EXTGL_SANITY_CHECK(env, ext_set, GL_ATI_pn_triangles)
}
/*
* Class: org.lwjgl.opengl.ati.ATIPnTriangles
* Method: glPNTrianglesfATI

15
src/native/common/ati/org_lwjgl_opengl_ati_ATISeparateStencil.cpp
View File

@ -38,6 +38,21 @@
#include "extgl.h"
#include "checkGLerror.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);
static glStencilOpSeparateATIPROC glStencilOpSeparateATI;
static glStencilFuncSeparateATIPROC glStencilFuncSeparateATI;
void extgl_InitATISeparateStencil(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_ATI_separate_stencil)
return;
glStencilOpSeparateATI = (glStencilOpSeparateATIPROC)extgl_GetProcAddress("glStencilOpSeparateATI");
glStencilFuncSeparateATI = (glStencilFuncSeparateATIPROC)extgl_GetProcAddress("glStencilFuncSeparateATI");
EXTGL_SANITY_CHECK(env, ext_set, GL_ATI_separate_stencil)
}
/*
* Class: org.lwjgl.opengl.ati.ATISeparateStencil
* Method: glStencilOpSeparateATI

45
src/native/common/ati/org_lwjgl_opengl_ati_ATIVertexArrayObject.cpp
View File

@ -38,6 +38,51 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef GLuint (APIENTRY * glNewObjectBufferATIPROC) (GLsizei size, const GLvoid *pointer, GLenum usage);
typedef GLboolean (APIENTRY * glIsObjectBufferATIPROC) (GLuint buffer);
typedef void (APIENTRY * glUpdateObjectBufferATIPROC) (GLuint buffer, GLuint offset, GLsizei size, const GLvoid *pointer, 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);
static glNewObjectBufferATIPROC glNewObjectBufferATI;
static glIsObjectBufferATIPROC glIsObjectBufferATI;
static glUpdateObjectBufferATIPROC glUpdateObjectBufferATI;
static glGetObjectBufferfvATIPROC glGetObjectBufferfvATI;
static glGetObjectBufferivATIPROC glGetObjectBufferivATI;
static glFreeObjectBufferATIPROC glFreeObjectBufferATI;
static glArrayObjectATIPROC glArrayObjectATI;
static glGetArrayObjectfvATIPROC glGetArrayObjectfvATI;
static glGetArrayObjectivATIPROC glGetArrayObjectivATI;
static glVariantArrayObjectATIPROC glVariantArrayObjectATI;
static glGetVariantArrayObjectfvATIPROC glGetVariantArrayObjectfvATI;
static glGetVariantArrayObjectivATIPROC glGetVariantArrayObjectivATI;
void extgl_InitATIVertexArrayObject(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_ATI_vertex_array_object)
return;
glNewObjectBufferATI = (glNewObjectBufferATIPROC) extgl_GetProcAddress("glNewObjectBufferATI");
glIsObjectBufferATI = (glIsObjectBufferATIPROC) extgl_GetProcAddress("glIsObjectBufferATI");
glUpdateObjectBufferATI = (glUpdateObjectBufferATIPROC) extgl_GetProcAddress("glUpdateObjectBufferATI");
glGetObjectBufferfvATI = (glGetObjectBufferfvATIPROC) extgl_GetProcAddress("glGetObjectBufferfvATI");
glGetObjectBufferivATI = (glGetObjectBufferivATIPROC) extgl_GetProcAddress("glGetObjectBufferivATI");
glFreeObjectBufferATI = (glFreeObjectBufferATIPROC) extgl_GetProcAddress("glFreeObjectBufferATI");
glArrayObjectATI = (glArrayObjectATIPROC) extgl_GetProcAddress("glArrayObjectATI");
glGetArrayObjectfvATI = (glGetArrayObjectfvATIPROC) extgl_GetProcAddress("glGetArrayObjectfvATI");
glGetArrayObjectivATI = (glGetArrayObjectivATIPROC) extgl_GetProcAddress("glGetArrayObjectivATI");
glVariantArrayObjectATI = (glVariantArrayObjectATIPROC) extgl_GetProcAddress("glVariantArrayObjectATI");
glGetVariantArrayObjectfvATI = (glGetVariantArrayObjectfvATIPROC) extgl_GetProcAddress("glGetVariantArrayObjectfvATI");
glGetVariantArrayObjectivATI = (glGetVariantArrayObjectivATIPROC) extgl_GetProcAddress("glGetVariantArrayObjectivATI");
EXTGL_SANITY_CHECK(env, ext_set, GL_ATI_vertex_array_object)
}
/*
* Class: org.lwjgl.opengl.ati.ATIVertexArrayObject
* Method: nglNewObjectBufferATI

66
src/native/common/ati/org_lwjgl_opengl_ati_ATIVertexStreams.cpp
View File

@ -38,6 +38,72 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glClientActiveVertexStreamATIPROC) (GLenum stream);
typedef void (APIENTRY * glVertexBlendEnviATIPROC) (GLenum pname, GLint param);
typedef void (APIENTRY * glVertexBlendEnvfATIPROC) (GLenum pname, GLfloat param);
typedef void (APIENTRY * glVertexStream1sATIPROC) (GLenum stream, GLshort x);
typedef void (APIENTRY * glVertexStream1iATIPROC) (GLenum stream, GLint x);
typedef void (APIENTRY * glVertexStream1fATIPROC) (GLenum stream, GLfloat x);
typedef void (APIENTRY * glVertexStream2sATIPROC) (GLenum stream, GLshort x, GLshort y);
typedef void (APIENTRY * glVertexStream2iATIPROC) (GLenum stream, GLint x, GLint y);
typedef void (APIENTRY * glVertexStream2fATIPROC) (GLenum stream, GLfloat x, GLfloat y);
typedef void (APIENTRY * glVertexStream3sATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z);
typedef void (APIENTRY * glVertexStream3iATIPROC) (GLenum stream, GLint x, GLint y, GLint z);
typedef void (APIENTRY * glVertexStream3fATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z);
typedef void (APIENTRY * glVertexStream4sATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w);
typedef void (APIENTRY * glVertexStream4iATIPROC) (GLenum stream, GLint x, GLint y, GLint z, GLint w);
typedef void (APIENTRY * glVertexStream4fATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
typedef void (APIENTRY * glNormalStream3bATIPROC) (GLenum stream, GLbyte x, GLbyte y, GLbyte z);
typedef void (APIENTRY * glNormalStream3sATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z);
typedef void (APIENTRY * glNormalStream3iATIPROC) (GLenum stream, GLint x, GLint y, GLint z);
typedef void (APIENTRY * glNormalStream3fATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z);
static glClientActiveVertexStreamATIPROC glClientActiveVertexStreamATI;
static glVertexBlendEnviATIPROC glVertexBlendEnviATI;
static glVertexBlendEnvfATIPROC glVertexBlendEnvfATI;
static glVertexStream1sATIPROC glVertexStream1sATI;
static glVertexStream1iATIPROC glVertexStream1iATI;
static glVertexStream1fATIPROC glVertexStream1fATI;
static glVertexStream2sATIPROC glVertexStream2sATI;
static glVertexStream2iATIPROC glVertexStream2iATI;
static glVertexStream2fATIPROC glVertexStream2fATI;
static glVertexStream3sATIPROC glVertexStream3sATI;
static glVertexStream3iATIPROC glVertexStream3iATI;
static glVertexStream3fATIPROC glVertexStream3fATI;
static glVertexStream4sATIPROC glVertexStream4sATI;
static glVertexStream4iATIPROC glVertexStream4iATI;
static glVertexStream4fATIPROC glVertexStream4fATI;
static glNormalStream3bATIPROC glNormalStream3bATI;
static glNormalStream3sATIPROC glNormalStream3sATI;
static glNormalStream3iATIPROC glNormalStream3iATI;
static glNormalStream3fATIPROC glNormalStream3fATI;
void extgl_InitATIVertexStreams(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_ATI_vertex_streams)
return;
glClientActiveVertexStreamATI = (glClientActiveVertexStreamATIPROC) extgl_GetProcAddress("glClientActiveVertexStreamATI");
glVertexBlendEnviATI = (glVertexBlendEnviATIPROC) extgl_GetProcAddress("glVertexBlendEnviATI");
glVertexBlendEnvfATI = (glVertexBlendEnvfATIPROC) extgl_GetProcAddress("glVertexBlendEnvfATI");
glVertexStream1sATI = (glVertexStream1sATIPROC) extgl_GetProcAddress("glVertexStream1sATI");
glVertexStream1iATI = (glVertexStream1iATIPROC) extgl_GetProcAddress("glVertexStream1iATI");
glVertexStream1fATI = (glVertexStream1fATIPROC) extgl_GetProcAddress("glVertexStream1fATI");
glVertexStream2sATI = (glVertexStream2sATIPROC) extgl_GetProcAddress("glVertexStream2sATI");
glVertexStream2iATI = (glVertexStream2iATIPROC) extgl_GetProcAddress("glVertexStream2iATI");
glVertexStream2fATI = (glVertexStream2fATIPROC) extgl_GetProcAddress("glVertexStream2fATI");
glVertexStream3sATI = (glVertexStream3sATIPROC) extgl_GetProcAddress("glVertexStream3sATI");
glVertexStream3iATI = (glVertexStream3iATIPROC) extgl_GetProcAddress("glVertexStream3iATI");
glVertexStream3fATI = (glVertexStream3fATIPROC) extgl_GetProcAddress("glVertexStream3fATI");
glVertexStream4sATI = (glVertexStream4sATIPROC) extgl_GetProcAddress("glVertexStream4sATI");
glVertexStream4iATI = (glVertexStream4iATIPROC) extgl_GetProcAddress("glVertexStream4iATI");
glVertexStream4fATI = (glVertexStream4fATIPROC) extgl_GetProcAddress("glVertexStream4fATI");
glNormalStream3bATI = (glNormalStream3bATIPROC) extgl_GetProcAddress("glNormalStream3bATI");
glNormalStream3sATI = (glNormalStream3sATIPROC) extgl_GetProcAddress("glNormalStream3sATI");
glNormalStream3iATI = (glNormalStream3iATIPROC) extgl_GetProcAddress("glNormalStream3iATI");
glNormalStream3fATI = (glNormalStream3fATIPROC) extgl_GetProcAddress("glNormalStream3fATI");
EXTGL_SANITY_CHECK(env, ext_set, GL_ATI_vertex_streams)
}
/*
* Class: org.lwjgl.opengl.ati.ATIVertexStreams
* Method: glVertexStream1fATI

12
src/native/common/ext/org_lwjgl_opengl_ext_EXTBlendFuncSeparate.cpp
View File

@ -38,6 +38,18 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glBlendFuncSeparateEXTPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
static glBlendFuncSeparateEXTPROC glBlendFuncSeparateEXT;
void extgl_InitEXTBlendFuncSeparate(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_EXT_blend_func_separate)
return;
glBlendFuncSeparateEXT = (glBlendFuncSeparateEXTPROC) extgl_GetProcAddress("glBlendFuncSeparateEXT");
EXTGL_SANITY_CHECK(env, ext_set, GL_EXT_blend_func_separate)
}
/*
* Class: org.lwjgl.opengl.ext.EXTBlendFuncSeparate
* Method: glBlendFuncSeparateEXT

15
src/native/common/ext/org_lwjgl_opengl_ext_EXTCompiledVertexArray.cpp
View File

@ -38,6 +38,21 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glLockArraysEXTPROC) (GLint first, GLsizei count);
typedef void (APIENTRY * glUnlockArraysEXTPROC) ();
static glLockArraysEXTPROC glLockArraysEXT;
static glUnlockArraysEXTPROC glUnlockArraysEXT;
void extgl_InitEXTCompiledVertexArray(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_EXT_compiled_vertex_array)
return;
glLockArraysEXT = (glLockArraysEXTPROC) extgl_GetProcAddress("glLockArraysEXT");
glUnlockArraysEXT = (glUnlockArraysEXTPROC) extgl_GetProcAddress("glUnlockArraysEXT");
EXTGL_SANITY_CHECK(env, ext_set, GL_EXT_compiled_vertex_array)
}
/*
* Class: org.lwjgl.opengl.ext.EXTCompiledVertexArray
* Method: glLockArraysEXT

12
src/native/common/ext/org_lwjgl_opengl_ext_EXTDrawRangeElements.cpp
View File

@ -38,6 +38,18 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glDrawRangeElementsEXTPROC) ( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
static glDrawRangeElementsEXTPROC glDrawRangeElementsEXT;
void extgl_InitEXTDrawRangeElements(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_EXT_draw_range_elements)
return;
glDrawRangeElementsEXT = (glDrawRangeElementsEXTPROC) extgl_GetProcAddress("glDrawRangeElementsEXT");
EXTGL_SANITY_CHECK(env, ext_set, GL_EXT_draw_range_elements)
}
/*
* Class: org.lwjgl.opengl.ext.EXTDrawRangeElements
* Method: nglDrawRangeElementsEXT

18
src/native/common/ext/org_lwjgl_opengl_ext_EXTFogCoord.cpp
View File

@ -38,6 +38,24 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glFogCoordfEXTPROC) (GLfloat coord);
typedef void (APIENTRY * glFogCoordfvEXTPROC) (const GLfloat *coord);
typedef void (APIENTRY * glFogCoordPointerEXTPROC) (GLenum type, GLsizei stride, const GLvoid *pointer);
static glFogCoordfEXTPROC glFogCoordfEXT;
static glFogCoordfvEXTPROC glFogCoordfvEXT;
static glFogCoordPointerEXTPROC glFogCoordPointerEXT;
void extgl_InitEXTFogCoord(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_EXT_fog_coord)
return;
glFogCoordfEXT = (glFogCoordfEXTPROC) extgl_GetProcAddress("glFogCoordfEXT");
glFogCoordfvEXT = (glFogCoordfvEXTPROC) extgl_GetProcAddress("glFogCoordfvEXT");
glFogCoordPointerEXT = (glFogCoordPointerEXTPROC) extgl_GetProcAddress("glFogCoordPointerEXT");
EXTGL_SANITY_CHECK(env, ext_set, GL_EXT_fog_coord)
}
/*
* Class: org.lwjgl.opengl.ext.EXTFogCoord
* Method: glFogCoordfEXT

15
src/native/common/ext/org_lwjgl_opengl_ext_EXTMultiDrawArrays.cpp
View File

@ -38,6 +38,21 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glMultiDrawArraysEXTPROC) (GLenum mode, GLint *first, GLsizei *count, GLsizei primcount);
typedef void (APIENTRY * glMultiDrawElementsEXTPROC) (GLenum mode, GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount);
static glMultiDrawArraysEXTPROC glMultiDrawArraysEXT;
static glMultiDrawElementsEXTPROC glMultiDrawElementsEXT;
void extgl_InitEXTMultiDrawArrays(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_EXT_multi_draw_arrays)
return;
glMultiDrawArraysEXT = (glMultiDrawArraysEXTPROC) extgl_GetProcAddress("glMultiDrawArraysEXT");
glMultiDrawElementsEXT = (glMultiDrawElementsEXTPROC) extgl_GetProcAddress("glMultiDrawElementsEXT");
EXTGL_SANITY_CHECK(env, ext_set, GL_EXT_multi_draw_arrays)
}
/*
* Class: org.lwjgl.opengl.ext.EXTMultiDrawArrays
* Method: nglMultiDrawArraysEXT

15
src/native/common/ext/org_lwjgl_opengl_ext_EXTPointParameters.cpp
View File

@ -38,6 +38,21 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glPointParameterfEXTPROC) (GLenum pname, GLfloat param);
typedef void (APIENTRY * glPointParameterfvEXTPROC) (GLenum pname, const GLfloat *params);
static glPointParameterfEXTPROC glPointParameterfEXT;
static glPointParameterfvEXTPROC glPointParameterfvEXT;
void extgl_InitEXTPointParameters(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_EXT_point_parameters)
return;
glPointParameterfEXT = (glPointParameterfEXTPROC) extgl_GetProcAddress("glPointParameterfEXT");
glPointParameterfvEXT = (glPointParameterfvEXTPROC) extgl_GetProcAddress("glPointParameterfvEXT");
EXTGL_SANITY_CHECK(env, ext_set, GL_EXT_point_parameters)
}
/*
* Class: org.lwjgl.opengl.ext.EXTPointParameters
* Method: glPointParameterfEXT

33
src/native/common/ext/org_lwjgl_opengl_ext_EXTSecondaryColor.cpp
View File

@ -38,6 +38,39 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glSecondaryColor3bEXTPROC) (GLbyte red, GLbyte green, GLbyte blue);
typedef void (APIENTRY * glSecondaryColor3fEXTPROC) (GLfloat red, GLfloat green, GLfloat blue);
typedef void (APIENTRY * glSecondaryColor3iEXTPROC) (GLint red, GLint green, GLint blue);
typedef void (APIENTRY * glSecondaryColor3sEXTPROC) (GLshort red, GLshort green, GLshort blue);
typedef void (APIENTRY * glSecondaryColor3ubEXTPROC) (GLubyte red, GLubyte green, GLubyte blue);
typedef void (APIENTRY * glSecondaryColor3uiEXTPROC) (GLuint red, GLuint green, GLuint blue);
typedef void (APIENTRY * glSecondaryColor3usEXTPROC) (GLushort red, GLushort green, GLushort blue);
typedef void (APIENTRY * glSecondaryColorPointerEXTPROC) (GLint size, GLenum type, GLsizei stride, GLvoid *pointer);
static glSecondaryColor3bEXTPROC glSecondaryColor3bEXT;
static glSecondaryColor3fEXTPROC glSecondaryColor3fEXT;
static glSecondaryColor3iEXTPROC glSecondaryColor3iEXT;
static glSecondaryColor3sEXTPROC glSecondaryColor3sEXT;
static glSecondaryColor3ubEXTPROC glSecondaryColor3ubEXT;
static glSecondaryColor3uiEXTPROC glSecondaryColor3uiEXT;
static glSecondaryColor3usEXTPROC glSecondaryColor3usEXT;
static glSecondaryColorPointerEXTPROC glSecondaryColorPointerEXT;
void extgl_InitEXTSecondaryColor(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_EXT_secondary_color)
return;
glSecondaryColor3bEXT = (glSecondaryColor3bEXTPROC) extgl_GetProcAddress("glSecondaryColor3bEXT");
glSecondaryColor3fEXT = (glSecondaryColor3fEXTPROC) extgl_GetProcAddress("glSecondaryColor3fEXT");
glSecondaryColor3iEXT = (glSecondaryColor3iEXTPROC) extgl_GetProcAddress("glSecondaryColor3iEXT");
glSecondaryColor3sEXT = (glSecondaryColor3sEXTPROC) extgl_GetProcAddress("glSecondaryColor3sEXT");
glSecondaryColor3ubEXT = (glSecondaryColor3ubEXTPROC) extgl_GetProcAddress("glSecondaryColor3ubEXT");
glSecondaryColor3uiEXT = (glSecondaryColor3uiEXTPROC) extgl_GetProcAddress("glSecondaryColor3uiEXT");
glSecondaryColor3usEXT = (glSecondaryColor3usEXTPROC) extgl_GetProcAddress("glSecondaryColor3usEXT");
glSecondaryColorPointerEXT = (glSecondaryColorPointerEXTPROC) extgl_GetProcAddress("glSecondaryColorPointerEXT");
EXTGL_SANITY_CHECK(env, ext_set, GL_EXT_secondary_color)
}
/*
* Class: org.lwjgl.opengl.ext.EXTSecondaryColor
* Method: glSecondaryColor3bEXT

12
src/native/common/ext/org_lwjgl_opengl_ext_EXTStencilTwoSide.cpp
View File

@ -38,6 +38,18 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glActiveStencilFaceEXTPROC) (GLenum face);
static glActiveStencilFaceEXTPROC glActiveStencilFaceEXT;
void extgl_InitEXTStencilTwoSide(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_EXT_stencil_two_side)
return;
glActiveStencilFaceEXT = (glActiveStencilFaceEXTPROC) extgl_GetProcAddress("glActiveStencilFaceEXT");
EXTGL_SANITY_CHECK(env, ext_set, GL_EXT_stencil_two_side)
}
/*
* Class: org.lwjgl.opengl.ext.EXTStencilTwoSide
* Method: glActiveStencilFaceEXT

135
src/native/common/ext/org_lwjgl_opengl_ext_EXTVertexShader.cpp
View File

@ -38,6 +38,141 @@
#include "extgl.h"
#include "checkGLerror.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, GLvoid *addr);
typedef void (APIENTRY * glSetLocalConstantEXTPROC) (GLuint id, GLenum type, GLvoid *addr);
typedef void (APIENTRY * glVariantbvEXTPROC) (GLuint id, GLbyte *addr);
typedef void (APIENTRY * glVariantsvEXTPROC) (GLuint id, GLshort *addr);
typedef void (APIENTRY * glVariantivEXTPROC) (GLuint id, GLint *addr);
typedef void (APIENTRY * glVariantfvEXTPROC) (GLuint id, GLfloat *addr);
typedef void (APIENTRY * glVariantdvEXTPROC) (GLuint id, GLdouble *addr);
typedef void (APIENTRY * glVariantubvEXTPROC) (GLuint id, GLubyte *addr);
typedef void (APIENTRY * glVariantusvEXTPROC) (GLuint id, GLushort *addr);
typedef void (APIENTRY * glVariantuivEXTPROC) (GLuint id, GLuint *addr);
typedef void (APIENTRY * glVariantPointerEXTPROC) (GLuint id, GLenum type, GLuint stride, GLvoid *addr);
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, GLboolean *data);
typedef void (APIENTRY * glGetVariantIntegervEXTPROC) (GLuint id, GLenum value, GLint *data);
typedef void (APIENTRY * glGetVariantFloatvEXTPROC) (GLuint id, GLenum value, GLfloat *data);
typedef void (APIENTRY * glGetVariantPointervEXTPROC) (GLuint id, GLenum value, GLvoid **data);
typedef void (APIENTRY * glGetInvariantBooleanvEXTPROC) (GLuint id, GLenum value, GLboolean *data);
typedef void (APIENTRY * glGetInvariantIntegervEXTPROC) (GLuint id, GLenum value, GLint *data);
typedef void (APIENTRY * glGetInvariantFloatvEXTPROC) (GLuint id, GLenum value, GLfloat *data);
typedef void (APIENTRY * glGetLocalConstantBooleanvEXTPROC) (GLuint id, GLenum value, GLboolean *data);
typedef void (APIENTRY * glGetLocalConstantIntegervEXTPROC) (GLuint id, GLenum value, GLint *data);
typedef void (APIENTRY * glGetLocalConstantFloatvEXTPROC) (GLuint id, GLenum value, GLfloat *data);
static glBeginVertexShaderEXTPROC glBeginVertexShaderEXT;
static glEndVertexShaderEXTPROC glEndVertexShaderEXT;
static glBindVertexShaderEXTPROC glBindVertexShaderEXT;
static glGenVertexShadersEXTPROC glGenVertexShadersEXT;
static glDeleteVertexShaderEXTPROC glDeleteVertexShaderEXT;
static glShaderOp1EXTPROC glShaderOp1EXT;
static glShaderOp2EXTPROC glShaderOp2EXT;
static glShaderOp3EXTPROC glShaderOp3EXT;
static glSwizzleEXTPROC glSwizzleEXT;
static glWriteMaskEXTPROC glWriteMaskEXT;
static glInsertComponentEXTPROC glInsertComponentEXT;
static glExtractComponentEXTPROC glExtractComponentEXT;
static glGenSymbolsEXTPROC glGenSymbolsEXT;
static glSetInvariantEXTPROC glSetInvariantEXT;
static glSetLocalConstantEXTPROC glSetLocalConstantEXT;
static glVariantbvEXTPROC glVariantbvEXT;
static glVariantsvEXTPROC glVariantsvEXT;
static glVariantivEXTPROC glVariantivEXT;
static glVariantfvEXTPROC glVariantfvEXT;
static glVariantdvEXTPROC glVariantdvEXT;
static glVariantubvEXTPROC glVariantubvEXT;
static glVariantusvEXTPROC glVariantusvEXT;
static glVariantuivEXTPROC glVariantuivEXT;
static glVariantPointerEXTPROC glVariantPointerEXT;
static glEnableVariantClientStateEXTPROC glEnableVariantClientStateEXT;
static glDisableVariantClientStateEXTPROC glDisableVariantClientStateEXT;
static glBindLightParameterEXTPROC glBindLightParameterEXT;
static glBindMaterialParameterEXTPROC glBindMaterialParameterEXT;
static glBindTexGenParameterEXTPROC glBindTexGenParameterEXT;
static glBindTextureUnitParameterEXTPROC glBindTextureUnitParameterEXT;
static glBindParameterEXTPROC glBindParameterEXT;
static glIsVariantEnabledEXTPROC glIsVariantEnabledEXT;
static glGetVariantBooleanvEXTPROC glGetVariantBooleanvEXT;
static glGetVariantIntegervEXTPROC glGetVariantIntegervEXT;
static glGetVariantFloatvEXTPROC glGetVariantFloatvEXT;
static glGetVariantPointervEXTPROC glGetVariantPointervEXT;
static glGetInvariantBooleanvEXTPROC glGetInvariantBooleanvEXT;
static glGetInvariantIntegervEXTPROC glGetInvariantIntegervEXT;
static glGetInvariantFloatvEXTPROC glGetInvariantFloatvEXT;
static glGetLocalConstantBooleanvEXTPROC glGetLocalConstantBooleanvEXT;
static glGetLocalConstantIntegervEXTPROC glGetLocalConstantIntegervEXT;
static glGetLocalConstantFloatvEXTPROC glGetLocalConstantFloatvEXT;
void extgl_InitEXTVertexShader(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_EXT_vertex_shader)
return;
glBeginVertexShaderEXT = (glBeginVertexShaderEXTPROC) extgl_GetProcAddress("glBeginVertexShaderEXT");
glEndVertexShaderEXT = (glEndVertexShaderEXTPROC) extgl_GetProcAddress("glEndVertexShaderEXT");
glBindVertexShaderEXT = (glBindVertexShaderEXTPROC) extgl_GetProcAddress("glBindVertexShaderEXT");
glGenVertexShadersEXT = (glGenVertexShadersEXTPROC) extgl_GetProcAddress("glGenVertexShadersEXT");
glDeleteVertexShaderEXT = (glDeleteVertexShaderEXTPROC) extgl_GetProcAddress("glDeleteVertexShaderEXT");
glShaderOp1EXT = (glShaderOp1EXTPROC) extgl_GetProcAddress("glShaderOp1EXT");
glShaderOp2EXT = (glShaderOp2EXTPROC) extgl_GetProcAddress("glShaderOp2EXT");
glShaderOp3EXT = (glShaderOp3EXTPROC) extgl_GetProcAddress("glShaderOp3EXT");
glSwizzleEXT = (glSwizzleEXTPROC) extgl_GetProcAddress("glSwizzleEXT");
glWriteMaskEXT = (glWriteMaskEXTPROC) extgl_GetProcAddress("glWriteMaskEXT");
glInsertComponentEXT = (glInsertComponentEXTPROC) extgl_GetProcAddress("glInsertComponentEXT");
glExtractComponentEXT = (glExtractComponentEXTPROC) extgl_GetProcAddress("glExtractComponentEXT");
glGenSymbolsEXT = (glGenSymbolsEXTPROC) extgl_GetProcAddress("glGenSymbolsEXT");
glSetInvariantEXT = (glSetInvariantEXTPROC) extgl_GetProcAddress("glSetInvarianceEXT");
glSetLocalConstantEXT = (glSetLocalConstantEXTPROC) extgl_GetProcAddress("glSetLocalConstantEXT");
glVariantbvEXT = (glVariantbvEXTPROC) extgl_GetProcAddress("glVariantbvEXT");
glVariantsvEXT = (glVariantsvEXTPROC) extgl_GetProcAddress("glVariantsvEXT");
glVariantivEXT = (glVariantivEXTPROC) extgl_GetProcAddress("glVariantivEXT");
glVariantfvEXT = (glVariantfvEXTPROC) extgl_GetProcAddress("glVariantfvEXT");
glVariantdvEXT = (glVariantdvEXTPROC) extgl_GetProcAddress("glVariantdvEXT");
glVariantubvEXT = (glVariantubvEXTPROC) extgl_GetProcAddress("glVariantubvEXT");
glVariantusvEXT = (glVariantusvEXTPROC) extgl_GetProcAddress("glVariantusvEXT");
glVariantuivEXT = (glVariantuivEXTPROC) extgl_GetProcAddress("glVariantuivEXT");
glVariantPointerEXT = (glVariantPointerEXTPROC) extgl_GetProcAddress("glVariantPointerEXT");
glEnableVariantClientStateEXT = (glEnableVariantClientStateEXTPROC) extgl_GetProcAddress("glEnableVariantClientStateEXT");
glDisableVariantClientStateEXT = (glDisableVariantClientStateEXTPROC) extgl_GetProcAddress("glDisableVariantClientStateEXT");
glBindLightParameterEXT = (glBindLightParameterEXTPROC) extgl_GetProcAddress("glBindLightParameterEXT");
glBindMaterialParameterEXT = (glBindMaterialParameterEXTPROC) extgl_GetProcAddress("glBindMaterialParameterEXT");
glBindTexGenParameterEXT = (glBindTexGenParameterEXTPROC) extgl_GetProcAddress("glBindTexGenParameterEXT");
glBindTextureUnitParameterEXT = (glBindTextureUnitParameterEXTPROC) extgl_GetProcAddress("glBindTextureUnitParameterEXT");
glBindParameterEXT = (glBindParameterEXTPROC) extgl_GetProcAddress("glBindParameterEXT");
glIsVariantEnabledEXT = (glIsVariantEnabledEXTPROC) extgl_GetProcAddress("glIsVariantEnabledEXT");
glGetVariantBooleanvEXT = (glGetVariantBooleanvEXTPROC) extgl_GetProcAddress("glGetVariantBooleanvEXT");
glGetVariantIntegervEXT = (glGetVariantIntegervEXTPROC) extgl_GetProcAddress("glGetVariantIntegervEXT");
glGetVariantFloatvEXT = (glGetVariantFloatvEXTPROC) extgl_GetProcAddress("glGetVariantFloatvEXT");
glGetVariantPointervEXT = (glGetVariantPointervEXTPROC) extgl_GetProcAddress("glGetVariantPointervEXT");
glGetInvariantBooleanvEXT = (glGetInvariantBooleanvEXTPROC) extgl_GetProcAddress("glGetInvariantBooleanvEXT");
glGetInvariantIntegervEXT = (glGetInvariantIntegervEXTPROC) extgl_GetProcAddress("glGetInvariantIntegervEXT");
glGetInvariantFloatvEXT = (glGetInvariantFloatvEXTPROC) extgl_GetProcAddress("glGetInvariantFloatvEXT");
glGetLocalConstantBooleanvEXT = (glGetLocalConstantBooleanvEXTPROC) extgl_GetProcAddress("glGetLocalConstantBooleanvEXT");
glGetLocalConstantIntegervEXT = (glGetLocalConstantIntegervEXTPROC) extgl_GetProcAddress("glGetLocalConstantIntegervEXT");
glGetLocalConstantFloatvEXT = (glGetLocalConstantFloatvEXTPROC) extgl_GetProcAddress("glGetLocalConstantFloatvEXT");
EXTGL_SANITY_CHECK(env, ext_set, GL_EXT_vertex_shader)
}
/*
* Class: org.lwjgl.opengl.ext.EXTVertexShader
* Method: glBeginVertexShaderEXT

18
src/native/common/ext/org_lwjgl_opengl_ext_EXTVertexWeighting.cpp
View File

@ -38,6 +38,24 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glVertexWeightfEXTPROC) (GLfloat weight);
typedef void (APIENTRY * glVertexWeightfvEXTPROC) (const GLfloat *weight);
typedef void (APIENTRY * glVertexWeightPointerEXTPROC) (GLsizei size, GLenum type, GLsizei stride, const GLvoid *pointer);
static glVertexWeightfEXTPROC glVertexWeightfEXT;
static glVertexWeightfvEXTPROC glVertexWeightfvEXT;
static glVertexWeightPointerEXTPROC glVertexWeightPointerEXT;
void extgl_InitEXTVertexWeighting(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_EXT_vertex_weighting)
return;
glVertexWeightfEXT = (glVertexWeightfEXTPROC) extgl_GetProcAddress("glVertexWeightfEXT");
glVertexWeightfvEXT = (glVertexWeightfvEXTPROC) extgl_GetProcAddress("glVertexWeightfvEXT");
glVertexWeightPointerEXT = (glVertexWeightPointerEXTPROC) extgl_GetProcAddress("glVertexWeightPointerEXT");
EXTGL_SANITY_CHECK(env, ext_set, GL_EXT_vertex_weighting)
}
/*
* Class: org.lwjgl.opengl.ext.EXTVertexWeighting
* Method: glVertexWeightfEXT

1999
src/native/common/extgl.cpp
View File

File diff suppressed because it is too large Load Diff

2071
src/native/common/extgl.h
View File

File diff suppressed because it is too large Load Diff

1
src/native/common/nv/Makefile.am
View File

@ -9,5 +9,6 @@ SRC=org_lwjgl_opengl_nv_NVEvaluators.cpp \
org_lwjgl_opengl_nv_NVPointSprite.cpp \
org_lwjgl_opengl_nv_NVProgram.cpp \
org_lwjgl_opengl_nv_NVRegisterCombiners.cpp \
org_lwjgl_opengl_nv_NVRegisterCombiners2.cpp \
org_lwjgl_opengl_nv_NVVertexArrayRange.cpp \
org_lwjgl_opengl_nv_NVVertexProgram.cpp

36
src/native/common/nv/org_lwjgl_opengl_nv_NVEvaluators.cpp
View File

@ -38,6 +38,42 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glMapControlPointsNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid *points);
typedef void (APIENTRY * glMapParameterivNVPROC) (GLenum target, GLenum pname, const GLint *params);
typedef void (APIENTRY * glMapParameterfvNVPROC) (GLenum target, GLenum pname, const GLfloat *params);
typedef void (APIENTRY * glGetMapControlPointsNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, GLvoid *points);
typedef void (APIENTRY * glGetMapParameterivNVPROC) (GLenum target, GLenum pname, GLint *params);
typedef void (APIENTRY * glGetMapParameterfvNVPROC) (GLenum target, GLenum pname, GLfloat *params);
typedef void (APIENTRY * glGetMapAttribParameterivNVPROC) (GLenum target, GLuint index, GLenum pname, GLint *params);
typedef void (APIENTRY * glGetMapAttribParameterfvNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat *params);
typedef void (APIENTRY * glEvalMapsNVPROC) (GLenum target, GLenum mode);
static glMapControlPointsNVPROC glMapControlPointsNV;
static glMapParameterivNVPROC glMapParameterivNV;
static glMapParameterfvNVPROC glMapParameterfvNV;
static glGetMapControlPointsNVPROC glGetMapControlPointsNV;
static glGetMapParameterivNVPROC glGetMapParameterivNV;
static glGetMapParameterfvNVPROC glGetMapParameterfvNV;
static glGetMapAttribParameterivNVPROC glGetMapAttribParameterivNV;
static glGetMapAttribParameterfvNVPROC glGetMapAttribParameterfvNV;
static glEvalMapsNVPROC glEvalMapsNV;
void extgl_InitNVEvaluators(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_NV_evaluators)
return;
glMapControlPointsNV = (glMapControlPointsNVPROC) extgl_GetProcAddress("glMapControlPointsNV");
glMapParameterivNV = (glMapParameterivNVPROC) extgl_GetProcAddress("glMapParameterivNV");
glMapParameterfvNV = (glMapParameterfvNVPROC) extgl_GetProcAddress("glMapParameterfvNV");
glGetMapControlPointsNV = (glGetMapControlPointsNVPROC) extgl_GetProcAddress("glGetMapControlPointsNV");
glGetMapParameterivNV = (glGetMapParameterivNVPROC) extgl_GetProcAddress("glGetMapParameterivNV");
glGetMapParameterfvNV = (glGetMapParameterfvNVPROC) extgl_GetProcAddress("glGetMapParameterfvNV");
glGetMapAttribParameterivNV = (glGetMapAttribParameterivNVPROC) extgl_GetProcAddress("glGetMapAttribParameterivNV");
glGetMapAttribParameterfvNV = (glGetMapAttribParameterfvNVPROC) extgl_GetProcAddress("glGetMapAttribParameterfvNV");
glEvalMapsNV = (glEvalMapsNVPROC) extgl_GetProcAddress("glEvalMapsNV");
EXTGL_SANITY_CHECK(env, ext_set, GL_NV_evaluators)
}
/*
* Class: org.lwjgl.opengl.nv.NVEvaluators
* Method: nglGetMapControlPointsNV

30
src/native/common/nv/org_lwjgl_opengl_nv_NVFence.cpp
View File

@ -38,6 +38,36 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glGenFencesNVPROC) (GLsizei n, GLuint *fences);
typedef void (APIENTRY * glDeleteFencesNVPROC) (GLsizei n, const GLuint *fences);
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 *params);
static glGenFencesNVPROC glGenFencesNV;
static glDeleteFencesNVPROC glDeleteFencesNV;
static glSetFenceNVPROC glSetFenceNV;
static glTestFenceNVPROC glTestFenceNV;
static glFinishFenceNVPROC glFinishFenceNV;
static glIsFenceNVPROC glIsFenceNV;
static glGetFenceivNVPROC glGetFenceivNV;
void extgl_InitNVFence(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_NV_fence)
return;
glGenFencesNV = (glGenFencesNVPROC) extgl_GetProcAddress("glGenFencesNV");
glDeleteFencesNV = (glDeleteFencesNVPROC) extgl_GetProcAddress("glDeleteFencesNV");
glSetFenceNV = (glSetFenceNVPROC) extgl_GetProcAddress("glSetFenceNV");
glTestFenceNV = (glTestFenceNVPROC) extgl_GetProcAddress("glTestFenceNV");
glFinishFenceNV = (glFinishFenceNVPROC) extgl_GetProcAddress("glFinishFenceNV");
glIsFenceNV = (glIsFenceNVPROC) extgl_GetProcAddress("glIsFenceNV");
glGetFenceivNV = (glGetFenceivNVPROC) extgl_GetProcAddress("glGetFenceivNV");
EXTGL_SANITY_CHECK(env, ext_set, GL_NV_fence)
}
/*
* Class: org.lwjgl.opengl.nv.NVFence
* Method: nglGenFencesNV

27
src/native/common/nv/org_lwjgl_opengl_nv_NVFragmentProgram.cpp
View File

@ -38,6 +38,33 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glProgramNamedParameter4fNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
typedef void (APIENTRY * glProgramNamedParameter4fvNVPROC) (GLuint id, GLsizei len, const GLubyte *name, const GLfloat v[]);
typedef void (APIENTRY * glProgramLocalParameter4fNVPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
typedef void (APIENTRY * glProgramLocalParameter4fvNVPROC) (GLenum target, GLuint index, const GLfloat *params);
typedef void (APIENTRY * glGetProgramNamedParameterfvNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLfloat *params);
typedef void (APIENTRY * glGetProgramLocalParameterfvNVPROC) (GLenum target, GLuint index, GLfloat *params);
static glProgramNamedParameter4fNVPROC glProgramNamedParameter4fNV;
static glProgramNamedParameter4fvNVPROC glProgramNamedParameter4fvNV;
static glProgramLocalParameter4fNVPROC glProgramLocalParameter4fNV;
static glProgramLocalParameter4fvNVPROC glProgramLocalParameter4fvNV;
static glGetProgramNamedParameterfvNVPROC glGetProgramNamedParameterfvNV;
static glGetProgramLocalParameterfvNVPROC glGetProgramLocalParameterfvNV;
void extgl_InitNVFragmentProgram(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_NV_fragment_program)
return;
glProgramNamedParameter4fNV = (glProgramNamedParameter4fNVPROC) extgl_GetProcAddress("glProgramNamedParameter4fNV");
glProgramNamedParameter4fvNV = (glProgramNamedParameter4fvNVPROC) extgl_GetProcAddress("glProgramNamedParameter4fvNV");
glGetProgramNamedParameterfvNV = (glGetProgramNamedParameterfvNVPROC) extgl_GetProcAddress("glGetProgramNamedParameterfvNV");
glProgramLocalParameter4fNV = (glProgramLocalParameter4fNVPROC) extgl_GetProcAddress("glProgramLocalParameter4fNV");
glProgramLocalParameter4fvNV = (glProgramLocalParameter4fvNVPROC) extgl_GetProcAddress("glProgramLocalParameter4fvNV");
glGetProgramLocalParameterfvNV = (glGetProgramLocalParameterfvNVPROC) extgl_GetProcAddress("glGetProgramLocalParameterfvNV");
EXTGL_SANITY_CHECK(env, ext_set, GL_NV_fragment_program)
}
/*
* Class: org.lwjgl.opengl.nv.NVFragmentProgram
* Method: nglProgramNamedParameter4fNV

30
src/native/common/nv/org_lwjgl_opengl_nv_NVOcclusionQuery.cpp
View File

@ -38,6 +38,36 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glGenOcclusionQueriesNVPROC) (GLsizei n, GLuint *ids);
typedef void (APIENTRY * glDeleteOcclusionQueriesNVPROC) (GLsizei n, const GLuint *ids);
typedef GLboolean (APIENTRY * glIsOcclusionQueryNVPROC) (GLuint id);
typedef void (APIENTRY * glBeginOcclusionQueryNVPROC) (GLuint id);
typedef void (APIENTRY * glEndOcclusionQueryNVPROC) (void);
typedef void (APIENTRY * glGetOcclusionQueryivNVPROC) (GLuint id, GLenum pname, GLint *params);
typedef void (APIENTRY * glGetOcclusionQueryuivNVPROC) (GLuint id, GLenum pname, GLuint *params);
static glGenOcclusionQueriesNVPROC glGenOcclusionQueriesNV;
static glDeleteOcclusionQueriesNVPROC glDeleteOcclusionQueriesNV;
static glIsOcclusionQueryNVPROC glIsOcclusionQueryNV;
static glBeginOcclusionQueryNVPROC glBeginOcclusionQueryNV;
static glEndOcclusionQueryNVPROC glEndOcclusionQueryNV;
static glGetOcclusionQueryivNVPROC glGetOcclusionQueryivNV;
static glGetOcclusionQueryuivNVPROC glGetOcclusionQueryuivNV;
void extgl_InitNVOcclusionQuery(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_NV_occlusion_query)
return;
glGenOcclusionQueriesNV = (glGenOcclusionQueriesNVPROC) extgl_GetProcAddress("glGenOcclusionQueriesNV");
glDeleteOcclusionQueriesNV = (glDeleteOcclusionQueriesNVPROC) extgl_GetProcAddress("glDeleteOcclusionQueriesNV");
glIsOcclusionQueryNV = (glIsOcclusionQueryNVPROC) extgl_GetProcAddress("glIsOcclusionQueryNV");
glBeginOcclusionQueryNV = (glBeginOcclusionQueryNVPROC) extgl_GetProcAddress("glBeginOcclusionQueryNV");
glEndOcclusionQueryNV = (glEndOcclusionQueryNVPROC) extgl_GetProcAddress("glEndOcclusionQueryNV");
glGetOcclusionQueryivNV = (glGetOcclusionQueryivNVPROC) extgl_GetProcAddress("glGetOcclusionQueryivNV");
glGetOcclusionQueryuivNV = (glGetOcclusionQueryuivNVPROC) extgl_GetProcAddress("glGetOcclusionQueryuivNV");
EXTGL_SANITY_CHECK(env, ext_set, GL_NV_occlusion_query)
}
/*
* Class: org.lwjgl.opengl.nv.NVOcclusionQuery
* Method: nglGenOcclusionQueriesNV

15
src/native/common/nv/org_lwjgl_opengl_nv_NVPointSprite.cpp
View File

@ -38,6 +38,21 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glPointParameteriNVPROC) (GLenum pname, GLint param);
typedef void (APIENTRY * glPointParameterivNVPROC) (GLenum pname, const GLint *params);
static glPointParameteriNVPROC glPointParameteriNV;
static glPointParameterivNVPROC glPointParameterivNV;
void extgl_InitNVPointSprite(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_NV_point_sprite)
return;
glPointParameteriNV = (glPointParameteriNVPROC) extgl_GetProcAddress("glPointParameteriNV");
glPointParameterivNV = (glPointParameterivNVPROC) extgl_GetProcAddress("glPointParameterivNV");
EXTGL_SANITY_CHECK(env, ext_set, GL_NV_point_sprite)
}
/*
* Class: org.lwjgl.opengl.nv.NVPointSprite
* Method: glPointParameteriNV

36
src/native/common/nv/org_lwjgl_opengl_nv_NVProgram.cpp
View File

@ -38,6 +38,42 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glLoadProgramNVPROC) (GLenum target, GLuint id, GLsizei len, const GLubyte *program);
typedef void (APIENTRY * glBindProgramNVPROC) (GLenum target, GLuint id);
typedef void (APIENTRY * glDeleteProgramsNVPROC) (GLsizei n, const GLuint *ids);
typedef void (APIENTRY * glGenProgramsNVPROC) (GLsizei n, GLuint *ids);
typedef void (APIENTRY * glGetProgramStringNVPROC) (GLuint id, GLenum pname, GLubyte *program);
typedef GLboolean (APIENTRY * glIsProgramNVPROC) (GLuint id);
typedef GLboolean (APIENTRY * glAreProgramsResidentNVPROC) (GLsizei n, const GLuint *ids, GLboolean *residences);
typedef void (APIENTRY * glRequestResidentProgramsNVPROC) (GLsizei n, GLuint *ids);
typedef void (APIENTRY * glGetProgramivNVPROC) (GLuint id, GLenum pname, GLint *params);
static glLoadProgramNVPROC glLoadProgramNV;
static glBindProgramNVPROC glBindProgramNV;
static glDeleteProgramsNVPROC glDeleteProgramsNV;
static glGenProgramsNVPROC glGenProgramsNV;
static glGetProgramStringNVPROC glGetProgramStringNV;
static glIsProgramNVPROC glIsProgramNV;
static glAreProgramsResidentNVPROC glAreProgramsResidentNV;
static glRequestResidentProgramsNVPROC glRequestResidentProgramsNV;
static glGetProgramivNVPROC glGetProgramivNV;
void extgl_InitNVProgram(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_NV_vertex_program)
return;
glLoadProgramNV = (glLoadProgramNVPROC) extgl_GetProcAddress("glLoadProgramNV");
glBindProgramNV = (glBindProgramNVPROC) extgl_GetProcAddress("glBindProgramNV");
glDeleteProgramsNV = (glDeleteProgramsNVPROC) extgl_GetProcAddress("glDeleteProgramsNV");
glGenProgramsNV = (glGenProgramsNVPROC) extgl_GetProcAddress("glGenProgramsNV");
glGetProgramivNV = (glGetProgramivNVPROC) extgl_GetProcAddress("glGetProgramivNV");
glGetProgramStringNV = (glGetProgramStringNVPROC) extgl_GetProcAddress("glGetProgramStringNV");
glIsProgramNV = (glIsProgramNVPROC) extgl_GetProcAddress("glIsProgramNV");
glAreProgramsResidentNV = (glAreProgramsResidentNVPROC) extgl_GetProcAddress("glAreProgramsResidentNV");
glRequestResidentProgramsNV = (glRequestResidentProgramsNVPROC) extgl_GetProcAddress("glRequestResidentProgramsNV");
EXTGL_SANITY_CHECK(env, ext_set, GL_NV_vertex_program)
}
/*
* Class: org.lwjgl.opengl.nv.NVProgram
* Method: nglLoadProgramNV

73
src/native/common/nv/org_lwjgl_opengl_nv_NVRegisterCombiners.cpp
View File

@ -38,6 +38,54 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glCombinerParameterfvNVPROC) (GLenum pname, const GLfloat *params);
typedef void (APIENTRY * glCombinerParameterfNVPROC) (GLenum pname, GLfloat param);
typedef void (APIENTRY * glCombinerParameterivNVPROC) (GLenum pname, const GLint *params);
typedef void (APIENTRY * glCombinerParameteriNVPROC) (GLenum pname, GLint param);
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);
static glCombinerParameterfvNVPROC glCombinerParameterfvNV;
static glCombinerParameterfNVPROC glCombinerParameterfNV;
static glCombinerParameterivNVPROC glCombinerParameterivNV;
static glCombinerParameteriNVPROC glCombinerParameteriNV;
static glCombinerInputNVPROC glCombinerInputNV;
static glCombinerOutputNVPROC glCombinerOutputNV;
static glFinalCombinerInputNVPROC glFinalCombinerInputNV;
static glGetCombinerInputParameterfvNVPROC glGetCombinerInputParameterfvNV;
static glGetCombinerInputParameterivNVPROC glGetCombinerInputParameterivNV;
static glGetCombinerOutputParameterfvNVPROC glGetCombinerOutputParameterfvNV;
static glGetCombinerOutputParameterivNVPROC glGetCombinerOutputParameterivNV;
static glGetFinalCombinerInputParameterfvNVPROC glGetFinalCombinerInputParameterfvNV;
static glGetFinalCombinerInputParameterivNVPROC glGetFinalCombinerInputParameterivNV;
void extgl_InitNVRegisterCombiners(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_NV_register_combiners)
return;
glCombinerParameterfvNV = (glCombinerParameterfvNVPROC) extgl_GetProcAddress("glCombinerParameterfvNV");
glCombinerParameterfNV = (glCombinerParameterfNVPROC) extgl_GetProcAddress("glCombinerParameterfNV");
glCombinerParameterivNV = (glCombinerParameterivNVPROC) extgl_GetProcAddress("glCombinerParameterivNV");
glCombinerParameteriNV = (glCombinerParameteriNVPROC) extgl_GetProcAddress("glCombinerParameteriNV");
glCombinerInputNV = (glCombinerInputNVPROC) extgl_GetProcAddress("glCombinerInputNV");
glCombinerOutputNV = (glCombinerOutputNVPROC) extgl_GetProcAddress("glCombinerOutputNV");
glFinalCombinerInputNV = (glFinalCombinerInputNVPROC) extgl_GetProcAddress("glFinalCombinerInputNV");
glGetCombinerInputParameterfvNV = (glGetCombinerInputParameterfvNVPROC) extgl_GetProcAddress("glGetCombinerInputParameterfvNV");
glGetCombinerInputParameterivNV = (glGetCombinerInputParameterivNVPROC) extgl_GetProcAddress("glGetCombinerInputParameterivNV");
glGetCombinerOutputParameterfvNV = (glGetCombinerOutputParameterfvNVPROC) extgl_GetProcAddress("glGetCombinerOutputParameterfvNV");
glGetCombinerOutputParameterivNV = (glGetCombinerOutputParameterivNVPROC) extgl_GetProcAddress("glGetCombinerOutputParameterivNV");
glGetFinalCombinerInputParameterfvNV = (glGetFinalCombinerInputParameterfvNVPROC) extgl_GetProcAddress("glGetFinalCombinerInputParameterfvNV");
glGetFinalCombinerInputParameterivNV = (glGetFinalCombinerInputParameterivNVPROC) extgl_GetProcAddress("glGetFinalCombinerInputParameterivNV");
EXTGL_SANITY_CHECK(env, ext_set, GL_NV_register_combiners)
}
/*
* Class: org.lwjgl.opengl.nv.NVRegisterCombiners
* Method: glCombinerParameterfNV
@ -202,28 +250,3 @@ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_nv_NVRegisterCombiners_nglGetFinalC
CHECK_GL_ERROR
}
/*
* Class: org.lwjgl.opengl.nv.NVRegisterCombiners
* Method: nglCombinerStageParameterfvNV
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_nv_NVRegisterCombiners_nglCombinerStageParameterfvNV
(JNIEnv * env, jclass clazz, jint stage, jint pname, jobject pfParams, jint pfParams_offset)
{
CHECK_EXISTS(glCombinerStageParameterfvNV)
GLfloat *pfParams_ptr = (GLfloat *)env->GetDirectBufferAddress(pfParams) + pfParams_offset;
glCombinerStageParameterfvNV(stage, pname, pfParams_ptr);
CHECK_GL_ERROR
}
/*
* Class: org.lwjgl.opengl.nv.NVRegisterCombiners
* Method: nglGetCombinerStageParameterfvNV
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_nv_NVRegisterCombiners_nglGetCombinerStageParameterfvNV
(JNIEnv * env, jclass clazz, jint stage, jint pname, jobject pfParams, jint pfParams_offset)
{
CHECK_EXISTS(glGetCombinerStageParameterfvNV)
GLfloat *pfParams_ptr = (GLfloat *)env->GetDirectBufferAddress(pfParams) + pfParams_offset;
glGetCombinerStageParameterfvNV(stage, pname, pfParams_ptr);
CHECK_GL_ERROR
}

80
src/native/common/nv/org_lwjgl_opengl_nv_NVRegisterCombiners2.cpp Normal file
View File

@ -0,0 +1,80 @@
/*
* Copyright (c) 2002 Lightweight Java Game Library Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'Light Weight Java Game Library' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// ----------------------------------
// IMPLEMENTATION OF NATIVE METHODS FOR CLASS: org.lwjgl.opengl.nv.NVRegisterCombiners2
// ----------------------------------
#include "org_lwjgl_opengl_nv_NVRegisterCombiners2.h"
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glCombinerStageParameterfvNVPROC) (GLenum stage, GLenum pname, const GLfloat *params);
typedef void (APIENTRY * glGetCombinerStageParameterfvNVPROC) (GLenum stage, GLenum pname, GLfloat *params);
static glCombinerStageParameterfvNVPROC glCombinerStageParameterfvNV;
static glGetCombinerStageParameterfvNVPROC glGetCombinerStageParameterfvNV;
void extgl_InitNVRegisterCombiners2(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_NV_register_combiners2)
return;
glCombinerStageParameterfvNV = (glCombinerStageParameterfvNVPROC) extgl_GetProcAddress("glCombinerStageParameterfvNV");
glGetCombinerStageParameterfvNV = (glGetCombinerStageParameterfvNVPROC) extgl_GetProcAddress("glGetCombinerStageParameterfvNV");
EXTGL_SANITY_CHECK(env, ext_set, GL_NV_register_combiners2)
}
/*
* Class: org.lwjgl.opengl.nv.NVRegisterCombiners2
* Method: nglCombinerStageParameterfvNV
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_nv_NVRegisterCombiners2_nglCombinerStageParameterfvNV
(JNIEnv * env, jclass clazz, jint stage, jint pname, jobject pfParams, jint pfParams_offset)
{
CHECK_EXISTS(glCombinerStageParameterfvNV)
GLfloat *pfParams_ptr = (GLfloat *)env->GetDirectBufferAddress(pfParams) + pfParams_offset;
glCombinerStageParameterfvNV(stage, pname, pfParams_ptr);
CHECK_GL_ERROR
}
/*
* Class: org.lwjgl.opengl.nv.NVRegisterCombiners2
* Method: nglGetCombinerStageParameterfvNV
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_nv_NVRegisterCombiners2_nglGetCombinerStageParameterfvNV
(JNIEnv * env, jclass clazz, jint stage, jint pname, jobject pfParams, jint pfParams_offset)
{
CHECK_EXISTS(glGetCombinerStageParameterfvNV)
GLfloat *pfParams_ptr = (GLfloat *)env->GetDirectBufferAddress(pfParams) + pfParams_offset;
glGetCombinerStageParameterfvNV(stage, pname, pfParams_ptr);
CHECK_GL_ERROR
}

31
src/native/common/nv/org_lwjgl_opengl_nv_NVRegisterCombiners2.h Normal file
View File

@ -0,0 +1,31 @@
/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class org_lwjgl_opengl_nv_NVRegisterCombiners2 */
#ifndef _Included_org_lwjgl_opengl_nv_NVRegisterCombiners2
#define _Included_org_lwjgl_opengl_nv_NVRegisterCombiners2
#ifdef __cplusplus
extern "C" {
#endif
#undef org_lwjgl_opengl_nv_NVRegisterCombiners2_GL_PER_STAGE_CONSTANTS_NV
#define org_lwjgl_opengl_nv_NVRegisterCombiners2_GL_PER_STAGE_CONSTANTS_NV 34101L
/*
* Class: org_lwjgl_opengl_nv_NVRegisterCombiners2
* Method: nglCombinerStageParameterfvNV
* Signature: (IILjava/nio/FloatBuffer;I)V
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_nv_NVRegisterCombiners2_nglCombinerStageParameterfvNV
(JNIEnv *, jclass, jint, jint, jobject, jint);
/*
* Class: org_lwjgl_opengl_nv_NVRegisterCombiners2
* Method: nglGetCombinerStageParameterfvNV
* Signature: (IILjava/nio/FloatBuffer;I)V
*/
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_nv_NVRegisterCombiners2_nglGetCombinerStageParameterfvNV
(JNIEnv *, jclass, jint, jint, jobject, jint);
#ifdef __cplusplus
}
#endif
#endif

43
src/native/common/nv/org_lwjgl_opengl_nv_NVVertexArrayRange.cpp
View File

@ -38,6 +38,49 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glFlushVertexArrayRangeNVPROC) (void);
typedef void (APIENTRY * glVertexArrayRangeNVPROC) (GLsizei size, const GLvoid *pointer);
static glFlushVertexArrayRangeNVPROC glFlushVertexArrayRangeNV;
static glVertexArrayRangeNVPROC glVertexArrayRangeNV;
#ifdef _WIN32
typedef void * (APIENTRY * wglAllocateMemoryNVPROC) (GLsizei size, GLfloat readFrequency, GLfloat writeFrequency, GLfloat priority);
typedef void (APIENTRY * wglFreeMemoryNVPROC) (void *pointer);
static wglAllocateMemoryNVPROC wglAllocateMemoryNV;
static wglFreeMemoryNVPROC wglFreeMemoryNV;
#endif /* WIN32 */
#ifdef _X11
typedef void * (APIENTRY * glXAllocateMemoryNVPROC) (GLsizei size, GLfloat readFrequency, GLfloat writeFrequency, GLfloat priority);
typedef void (APIENTRY * glXFreeMemoryNVPROC) (void *pointer);
static glXAllocateMemoryNVPROC glXAllocateMemoryNV;
static glXFreeMemoryNVPROC glXFreeMemoryNV;
#endif /* X11 */
void extgl_InitNVVertexArrayRange(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_NV_vertex_array_range)
return;
glFlushVertexArrayRangeNV = (glFlushVertexArrayRangeNVPROC) extgl_GetProcAddress("glFlushVertexArrayRangeNV");
glVertexArrayRangeNV = (glVertexArrayRangeNVPROC) extgl_GetProcAddress("glVertexArrayRangeNV");
#ifdef _WIN32
wglAllocateMemoryNV = (wglAllocateMemoryNVPROC) extgl_GetProcAddress("wglAllocateMemoryNV");
wglFreeMemoryNV = (wglFreeMemoryNVPROC) extgl_GetProcAddress("wglFreeMemoryNV");
#endif /* WIN32 */
#ifdef _X11
glXAllocateMemoryNV = (glXAllocateMemoryNVPROC) extgl_GetProcAddress("glXAllocateMemoryNV");
glXFreeMemoryNV = (glXFreeMemoryNVPROC) extgl_GetProcAddress("glXFreeMemoryNV");
#endif /* X11 */
EXTGL_SANITY_CHECK(env, ext_set, GL_NV_vertex_array_range)
}
/*
* Class: org.lwjgl.opengl.nv.NVVertexArrayRange
* Method: nglVertexArrayRangeNV

123
src/native/common/nv/org_lwjgl_opengl_nv_NVVertexProgram.cpp
View File

@ -38,6 +38,129 @@
#include "extgl.h"
#include "checkGLerror.h"
typedef void (APIENTRY * glExecuteProgramNVPROC) (GLenum target, GLuint id, const GLfloat *params);
typedef void (APIENTRY * glGetProgramParameterfvNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat *params);
typedef void (APIENTRY * glGetTrackMatrixivNVPROC) (GLenum target, GLuint address, GLenum pname, GLint *params);
typedef void (APIENTRY * glGetVertexAttribfvNVPROC) (GLuint index, GLenum pname, GLfloat *params);
typedef void (APIENTRY * glGetVertexAttribivNVPROC) (GLuint index, GLenum pname, GLint *params);
typedef void (APIENTRY * glGetVertexAttribPointervNVPROC) (GLuint index, GLenum pname, GLvoid **pointer);
typedef void (APIENTRY * glProgramParameter4fNVPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
typedef void (APIENTRY * glProgramParameter4fvNVPROC) (GLenum target, GLuint index, const GLfloat *params);
typedef void (APIENTRY * glProgramParameters4fvNVPROC) (GLenum target, GLuint index, GLuint num, const GLfloat *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 *pointer);
typedef void (APIENTRY * glVertexAttrib1sNVPROC) (GLuint index, GLshort x);
typedef void (APIENTRY * glVertexAttrib1fNVPROC) (GLuint index, GLfloat x);
typedef void (APIENTRY * glVertexAttrib2sNVPROC) (GLuint index, GLshort x, GLshort y);
typedef void (APIENTRY * glVertexAttrib2fNVPROC) (GLuint index, GLfloat x, GLfloat 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 * 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 * glVertexAttrib4ubNVPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
typedef void (APIENTRY * glVertexAttrib1svNVPROC) (GLuint index, const GLshort *v);
typedef void (APIENTRY * glVertexAttrib1fvNVPROC) (GLuint index, const GLfloat *v);
typedef void (APIENTRY * glVertexAttrib2svNVPROC) (GLuint index, const GLshort *v);
typedef void (APIENTRY * glVertexAttrib2fvNVPROC) (GLuint index, const GLfloat *v);
typedef void (APIENTRY * glVertexAttrib3svNVPROC) (GLuint index, const GLshort *v);
typedef void (APIENTRY * glVertexAttrib3fvNVPROC) (GLuint index, const GLfloat *v);
typedef void (APIENTRY * glVertexAttrib4svNVPROC) (GLuint index, const GLshort *v);
typedef void (APIENTRY * glVertexAttrib4fvNVPROC) (GLuint index, const GLfloat *v);
typedef void (APIENTRY * glVertexAttrib4ubvNVPROC) (GLuint index, const GLubyte *v);
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 * glVertexAttribs2svNVPROC) (GLuint index, GLsizei n, const GLshort *v);
typedef void (APIENTRY * glVertexAttribs2fvNVPROC) (GLuint index, GLsizei n, const GLfloat *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 * glVertexAttribs4svNVPROC) (GLuint index, GLsizei n, const GLshort *v);
typedef void (APIENTRY * glVertexAttribs4fvNVPROC) (GLuint index, GLsizei n, const GLfloat *v);
typedef void (APIENTRY * glVertexAttribs4ubvNVPROC) (GLuint index, GLsizei n, const GLubyte *v);
static glExecuteProgramNVPROC glExecuteProgramNV;
static glGetProgramParameterfvNVPROC glGetProgramParameterfvNV;
static glGetTrackMatrixivNVPROC glGetTrackMatrixivNV;
static glGetVertexAttribfvNVPROC glGetVertexAttribfvNV;
static glGetVertexAttribivNVPROC glGetVertexAttribivNV;
static glGetVertexAttribPointervNVPROC glGetVertexAttribPointervNV;
static glProgramParameter4fNVPROC glProgramParameter4fNV;
static glProgramParameter4fvNVPROC glProgramParameter4fvNV;
static glProgramParameters4fvNVPROC glProgramParameters4fvNV;
static glTrackMatrixNVPROC glTrackMatrixNV;
static glVertexAttribPointerNVPROC glVertexAttribPointerNV;
static glVertexAttrib1sNVPROC glVertexAttrib1sNV;
static glVertexAttrib1fNVPROC glVertexAttrib1fNV;
static glVertexAttrib2sNVPROC glVertexAttrib2sNV;
static glVertexAttrib2fNVPROC glVertexAttrib2fNV;
static glVertexAttrib3sNVPROC glVertexAttrib3sNV;
static glVertexAttrib3fNVPROC glVertexAttrib3fNV;
static glVertexAttrib4sNVPROC glVertexAttrib4sNV;
static glVertexAttrib4fNVPROC glVertexAttrib4fNV;
static glVertexAttrib4ubNVPROC glVertexAttrib4ubNV;
static glVertexAttrib1svNVPROC glVertexAttrib1svNV;
static glVertexAttrib1fvNVPROC glVertexAttrib1fvNV;
static glVertexAttrib2svNVPROC glVertexAttrib2svNV;
static glVertexAttrib2fvNVPROC glVertexAttrib2fvNV;
static glVertexAttrib3svNVPROC glVertexAttrib3svNV;
static glVertexAttrib3fvNVPROC glVertexAttrib3fvNV;
static glVertexAttrib4svNVPROC glVertexAttrib4svNV;
static glVertexAttrib4fvNVPROC glVertexAttrib4fvNV;
static glVertexAttrib4ubvNVPROC glVertexAttrib4ubvNV;
static glVertexAttribs1svNVPROC glVertexAttribs1svNV;
static glVertexAttribs1fvNVPROC glVertexAttribs1fvNV;
static glVertexAttribs2svNVPROC glVertexAttribs2svNV;
static glVertexAttribs2fvNVPROC glVertexAttribs2fvNV;
static glVertexAttribs3svNVPROC glVertexAttribs3svNV;
static glVertexAttribs3fvNVPROC glVertexAttribs3fvNV;
static glVertexAttribs4svNVPROC glVertexAttribs4svNV;
static glVertexAttribs4fvNVPROC glVertexAttribs4fvNV;
static glVertexAttribs4ubvNVPROC glVertexAttribs4ubvNV;
void extgl_InitNVVertexProgram(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_NV_vertex_program)
return;
glExecuteProgramNV = (glExecuteProgramNVPROC) extgl_GetProcAddress("glExecuteProgramNV");
glGetProgramParameterfvNV = (glGetProgramParameterfvNVPROC) extgl_GetProcAddress("glGetProgramParameterfvNV");
glGetTrackMatrixivNV = (glGetTrackMatrixivNVPROC) extgl_GetProcAddress("glGetTrackMatrixivNV");
glGetVertexAttribfvNV = (glGetVertexAttribfvNVPROC) extgl_GetProcAddress("glGetVertexAttribfvNV");
glGetVertexAttribivNV = (glGetVertexAttribivNVPROC) extgl_GetProcAddress("glGetVertexAttribivNV");
glGetVertexAttribPointervNV = (glGetVertexAttribPointervNVPROC) extgl_GetProcAddress("glGetVertexAttribPointervNV");
glProgramParameter4fNV = (glProgramParameter4fNVPROC) extgl_GetProcAddress("glProgramParameter4fNV");
glProgramParameter4fvNV = (glProgramParameter4fvNVPROC) extgl_GetProcAddress("glProgramParameter4fvNV");
glProgramParameters4fvNV = (glProgramParameters4fvNVPROC) extgl_GetProcAddress("glProgramParameters4fvNV");
glTrackMatrixNV = (glTrackMatrixNVPROC) extgl_GetProcAddress("glTrackMatrixNV");
glVertexAttribPointerNV = (glVertexAttribPointerNVPROC) extgl_GetProcAddress("glVertexAttribPointerNV");
glVertexAttrib1sNV = (glVertexAttrib1sNVPROC) extgl_GetProcAddress("glVertexAttrib1sNV");
glVertexAttrib1fNV = (glVertexAttrib1fNVPROC) extgl_GetProcAddress("glVertexAttrib1fNV");
glVertexAttrib2sNV = (glVertexAttrib2sNVPROC) extgl_GetProcAddress("glVertexAttrib2sNV");
glVertexAttrib2fNV = (glVertexAttrib2fNVPROC) extgl_GetProcAddress("glVertexAttrib2fNV");
glVertexAttrib3sNV = (glVertexAttrib3sNVPROC) extgl_GetProcAddress("glVertexAttrib3sNV");
glVertexAttrib3fNV = (glVertexAttrib3fNVPROC) extgl_GetProcAddress("glVertexAttrib3fNV");
glVertexAttrib4sNV = (glVertexAttrib4sNVPROC) extgl_GetProcAddress("glVertexAttrib4sNV");
glVertexAttrib4fNV = (glVertexAttrib4fNVPROC) extgl_GetProcAddress("glVertexAttrib4fNV");
glVertexAttrib4ubNV = (glVertexAttrib4ubNVPROC) extgl_GetProcAddress("glVertexAttrib4ubNV");
glVertexAttrib1svNV = (glVertexAttrib1svNVPROC) extgl_GetProcAddress("glVertexAttrib1svNV");
glVertexAttrib1fvNV = (glVertexAttrib1fvNVPROC) extgl_GetProcAddress("glVertexAttrib1fvNV");
glVertexAttrib2svNV = (glVertexAttrib2svNVPROC) extgl_GetProcAddress("glVertexAttrib2svNV");
glVertexAttrib2fvNV = (glVertexAttrib2fvNVPROC) extgl_GetProcAddress("glVertexAttrib2fvNV");
glVertexAttrib3svNV = (glVertexAttrib3svNVPROC) extgl_GetProcAddress("glVertexAttrib3svNV");
glVertexAttrib3fvNV = (glVertexAttrib3fvNVPROC) extgl_GetProcAddress("glVertexAttrib3fvNV");
glVertexAttrib4svNV = (glVertexAttrib4svNVPROC) extgl_GetProcAddress("glVertexAttrib4svNV");
glVertexAttrib4fvNV = (glVertexAttrib4fvNVPROC) extgl_GetProcAddress("glVertexAttrib4fvNV");
glVertexAttrib4ubvNV = (glVertexAttrib4ubvNVPROC) extgl_GetProcAddress("glVertexAttrib4ubvNV");
glVertexAttribs1svNV = (glVertexAttribs1svNVPROC) extgl_GetProcAddress("glVertexAttribs1svNV");
glVertexAttribs1fvNV = (glVertexAttribs1fvNVPROC) extgl_GetProcAddress("glVertexAttribs1fvNV");
glVertexAttribs2svNV = (glVertexAttribs2svNVPROC) extgl_GetProcAddress("glVertexAttribs2svNV");
glVertexAttribs2fvNV = (glVertexAttribs2fvNVPROC) extgl_GetProcAddress("glVertexAttribs2fvNV");
glVertexAttribs3svNV = (glVertexAttribs3svNVPROC) extgl_GetProcAddress("glVertexAttribs3svNV");
glVertexAttribs3fvNV = (glVertexAttribs3fvNVPROC) extgl_GetProcAddress("glVertexAttribs3fvNV");
glVertexAttribs4svNV = (glVertexAttribs4svNVPROC) extgl_GetProcAddress("glVertexAttribs4svNV");
glVertexAttribs4fvNV = (glVertexAttribs4fvNVPROC) extgl_GetProcAddress("glVertexAttribs4fvNV");
glVertexAttribs4ubvNV = (glVertexAttribs4ubvNVPROC) extgl_GetProcAddress("glVertexAttribs4ubvNV");
EXTGL_SANITY_CHECK(env, ext_set, GL_NV_vertex_program)
}
/*
* Class: org.lwjgl.opengl.nv.NVVertexProgram
* Method: nglExecuteProgramNV

1021
src/native/common/org_lwjgl_opengl_GL11.cpp
View File

File diff suppressed because it is too large Load Diff

135
src/native/common/org_lwjgl_opengl_GL12.cpp
View File

@ -39,14 +39,141 @@
* @version $Revision$
*/
#ifdef _WIN32
#include <windows.h>
#endif
#include "org_lwjgl_opengl_GL12.h"
#include "checkGLerror.h"
#include "extgl.h"
typedef void (APIENTRY * glBlendColorPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha );
typedef void (APIENTRY * glBlendEquationPROC) (GLenum mode );
typedef void (APIENTRY * glColorTablePROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table );
typedef void (APIENTRY * glColorTableParameterfvPROC) (GLenum target, GLenum pname, const GLfloat *params);
typedef void (APIENTRY * glColorTableParameterivPROC) (GLenum target, GLenum pname, const GLint *params);
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 *table );
typedef void (APIENTRY * glGetColorTableParameterfvPROC) (GLenum target, GLenum pname, GLfloat *params );
typedef void (APIENTRY * glGetColorTableParameterivPROC) (GLenum target, GLenum pname, GLint *params );
typedef void (APIENTRY * glColorSubTablePROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data );
typedef void (APIENTRY * glCopyColorSubTablePROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width );
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 * 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 * 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 * glHistogramPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink );
typedef void (APIENTRY * glResetHistogramPROC) (GLenum target );
typedef void (APIENTRY * glMinmaxPROC) (GLenum target, GLenum internalformat, GLboolean sink );
typedef void (APIENTRY * glResetMinmaxPROC) (GLenum target );
typedef void (APIENTRY * glGetSeparableFilterPROC) (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span );
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 );
static glDrawRangeElementsPROC glDrawRangeElements;
static glTexImage3DPROC glTexImage3D;
static glTexSubImage3DPROC glTexSubImage3D;
static glCopyTexSubImage3DPROC glCopyTexSubImage3D;
static glBlendColorPROC glBlendColor;
static glBlendEquationPROC glBlendEquation;
static glColorTablePROC glColorTable;
static glColorTableParameterfvPROC glColorTableParameterfv;
static glColorTableParameterivPROC glColorTableParameteriv;
static glCopyColorTablePROC glCopyColorTable;
static glGetColorTablePROC glGetColorTable;
static glGetColorTableParameterfvPROC glGetColorTableParameterfv;
static glGetColorTableParameterivPROC glGetColorTableParameteriv;
static glColorSubTablePROC glColorSubTable;
static glCopyColorSubTablePROC glCopyColorSubTable;
static glConvolutionFilter1DPROC glConvolutionFilter1D;
static glConvolutionFilter2DPROC glConvolutionFilter2D;
static glConvolutionParameterfPROC glConvolutionParameterf;
static glConvolutionParameterfvPROC glConvolutionParameterfv;
static glConvolutionParameteriPROC glConvolutionParameteri;
static glConvolutionParameterivPROC glConvolutionParameteriv;
static glCopyConvolutionFilter1DPROC glCopyConvolutionFilter1D;
static glCopyConvolutionFilter2DPROC glCopyConvolutionFilter2D;
static glGetConvolutionFilterPROC glGetConvolutionFilter;
static glGetConvolutionParameterfvPROC glGetConvolutionParameterfv;
static glGetConvolutionParameterivPROC glGetConvolutionParameteriv;
static glGetSeparableFilterPROC glGetSeparableFilter;
static glSeparableFilter2DPROC glSeparableFilter2D;
static glGetHistogramPROC glGetHistogram;
static glGetHistogramParameterfvPROC glGetHistogramParameterfv;
static glGetHistogramParameterivPROC glGetHistogramParameteriv;
static glGetMinmaxPROC glGetMinmax;
static glGetMinmaxParameterfvPROC glGetMinmaxParameterfv;
static glGetMinmaxParameterivPROC glGetMinmaxParameteriv;
static glHistogramPROC glHistogram;
static glMinmaxPROC glMinmax;
static glResetHistogramPROC glResetHistogram;
static glResetMinmaxPROC glResetMinmax;
void extgl_InitOpenGL1_2(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.OpenGL12)
return;
glTexImage3D = (glTexImage3DPROC) extgl_GetProcAddress("glTexImage3D");
glTexSubImage3D = (glTexSubImage3DPROC) extgl_GetProcAddress("glTexSubImage3D");
glCopyTexSubImage3D = (glCopyTexSubImage3DPROC) extgl_GetProcAddress("glCopyTexSubImage3D");
glDrawRangeElements = (glDrawRangeElementsPROC) extgl_GetProcAddress("glDrawRangeElements");
EXTGL_SANITY_CHECK(env, ext_set, OpenGL12)
}
void extgl_InitARBImaging(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.GL_ARB_imaging)
return;
glBlendColor = (glBlendColorPROC) extgl_GetProcAddress("glBlendColor");
glBlendEquation = (glBlendEquationPROC) extgl_GetProcAddress("glBlendEquation");
glColorTable = (glColorTablePROC) extgl_GetProcAddress("glColorTable");
glColorTableParameterfv = (glColorTableParameterfvPROC) extgl_GetProcAddress("glColorTableParameterfv");
glColorTableParameteriv = (glColorTableParameterivPROC) extgl_GetProcAddress("glColorTableParameteriv");
glCopyColorTable = (glCopyColorTablePROC) extgl_GetProcAddress("glCopyColorTable");
glGetColorTable = (glGetColorTablePROC) extgl_GetProcAddress("glGetColorTable");
glGetColorTableParameterfv = (glGetColorTableParameterfvPROC) extgl_GetProcAddress("glGetColorTableParameterfv");
glGetColorTableParameteriv = (glGetColorTableParameterivPROC) extgl_GetProcAddress("glGetColorTableParameteriv");
glColorSubTable = (glColorSubTablePROC) extgl_GetProcAddress("glColorSubTable");
glCopyColorSubTable = (glCopyColorSubTablePROC) extgl_GetProcAddress("glCopyColorSubTable");
glConvolutionFilter1D = (glConvolutionFilter1DPROC) extgl_GetProcAddress("glConvolutionFilter1D");
glConvolutionFilter2D = (glConvolutionFilter2DPROC) extgl_GetProcAddress("glConvolutionFilter2D");
glConvolutionParameterf = (glConvolutionParameterfPROC) extgl_GetProcAddress("glConvolutionParameterf");
glConvolutionParameterfv = (glConvolutionParameterfvPROC) extgl_GetProcAddress("glConvolutionParameterfv");
glConvolutionParameteri = (glConvolutionParameteriPROC) extgl_GetProcAddress("glConvolutionParameteri");
glConvolutionParameteriv = (glConvolutionParameterivPROC) extgl_GetProcAddress("glConvolutionParameteriv");
glCopyConvolutionFilter1D = (glCopyConvolutionFilter1DPROC) extgl_GetProcAddress("glCopyConvolutionFilter1D");
glCopyConvolutionFilter2D = (glCopyConvolutionFilter2DPROC) extgl_GetProcAddress("glCopyConvolutionFilter2D");
glGetConvolutionFilter = (glGetConvolutionFilterPROC) extgl_GetProcAddress("glGetConvolutionFilter");
glGetConvolutionParameterfv = (glGetConvolutionParameterfvPROC) extgl_GetProcAddress("glGetConvolutionParameterfv");
glGetConvolutionParameteriv = (glGetConvolutionParameterivPROC) extgl_GetProcAddress("glGetConvolutionParameteriv");
glGetSeparableFilter = (glGetSeparableFilterPROC) extgl_GetProcAddress("glGetSeparableFilter");
glSeparableFilter2D = (glSeparableFilter2DPROC) extgl_GetProcAddress("glSeparableFilter2D");
glGetHistogram = (glGetHistogramPROC) extgl_GetProcAddress("glGetHistogram");
glGetHistogramParameterfv = (glGetHistogramParameterfvPROC) extgl_GetProcAddress("glGetHistogramParameterfv");
glGetHistogramParameteriv = (glGetHistogramParameterivPROC) extgl_GetProcAddress("glGetHistogramParameteriv");
glGetMinmax = (glGetMinmaxPROC) extgl_GetProcAddress("glGetMinmax");
glGetMinmaxParameterfv = (glGetMinmaxParameterfvPROC) extgl_GetProcAddress("glGetMinmaxParameterfv");
glGetMinmaxParameteriv = (glGetMinmaxParameterivPROC) extgl_GetProcAddress("glGetMinmaxParameteriv");
glHistogram = (glHistogramPROC) extgl_GetProcAddress("glHistogram");
glMinmax = (glMinmaxPROC) extgl_GetProcAddress("glMinmax");
glResetHistogram = (glResetHistogramPROC) extgl_GetProcAddress("glResetHistogram");
glResetMinmax = (glResetMinmaxPROC) extgl_GetProcAddress("glResetMinmax");
EXTGL_SANITY_CHECK(env, ext_set, GL_ARB_imaging)
}
/*
* Class: org_lwjgl_opengl_GL12
* Method: glColorTable

157
src/native/common/org_lwjgl_opengl_GL13.cpp
View File

@ -39,14 +39,163 @@
* @version $Revision$
*/
#ifdef _WIN32
#include <windows.h>
#endif
#include "org_lwjgl_opengl_GL13.h"
#include "checkGLerror.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 * glMultiTexCoord1dPROC) (GLenum target, GLdouble s );
typedef void (APIENTRY * glMultiTexCoord1dvPROC) (GLenum target, const GLdouble *v );
typedef void (APIENTRY * glMultiTexCoord1fPROC) (GLenum target, GLfloat s );
typedef void (APIENTRY * glMultiTexCoord1fvPROC) (GLenum target, const GLfloat *v );
typedef void (APIENTRY * glMultiTexCoord1iPROC) (GLenum target, GLint s );
typedef void (APIENTRY * glMultiTexCoord1ivPROC) (GLenum target, const GLint *v );
typedef void (APIENTRY * glMultiTexCoord1sPROC) (GLenum target, GLshort s );
typedef void (APIENTRY * glMultiTexCoord1svPROC) (GLenum target, const GLshort *v );
typedef void (APIENTRY * glMultiTexCoord2dPROC) (GLenum target, GLdouble s, GLdouble t );
typedef void (APIENTRY * glMultiTexCoord2dvPROC) (GLenum target, const GLdouble *v );
typedef void (APIENTRY * glMultiTexCoord2fPROC) (GLenum target, GLfloat s, GLfloat t );
typedef void (APIENTRY * glMultiTexCoord2fvPROC) (GLenum target, const GLfloat *v );
typedef void (APIENTRY * glMultiTexCoord2iPROC) (GLenum target, GLint s, GLint t );
typedef void (APIENTRY * glMultiTexCoord2ivPROC) (GLenum target, const GLint *v );
typedef void (APIENTRY * glMultiTexCoord2sPROC) (GLenum target, GLshort s, GLshort t );
typedef void (APIENTRY * glMultiTexCoord2svPROC) (GLenum target, const GLshort *v );
typedef void (APIENTRY * glMultiTexCoord3dPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r );
typedef void (APIENTRY * glMultiTexCoord3dvPROC) (GLenum target, const GLdouble *v );
typedef void (APIENTRY * glMultiTexCoord3fPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r );
typedef void (APIENTRY * glMultiTexCoord3fvPROC) (GLenum target, const GLfloat *v );
typedef void (APIENTRY * glMultiTexCoord3iPROC) (GLenum target, GLint s, GLint t, GLint r );
typedef void (APIENTRY * glMultiTexCoord3ivPROC) (GLenum target, const GLint *v );
typedef void (APIENTRY * glMultiTexCoord3sPROC) (GLenum target, GLshort s, GLshort t, GLshort r );
typedef void (APIENTRY * glMultiTexCoord3svPROC) (GLenum target, const GLshort *v );
typedef void (APIENTRY * glMultiTexCoord4dPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q );
typedef void (APIENTRY * glMultiTexCoord4dvPROC) (GLenum target, const GLdouble *v );
typedef void (APIENTRY * glMultiTexCoord4fPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q );
typedef void (APIENTRY * glMultiTexCoord4fvPROC) (GLenum target, const GLfloat *v );
typedef void (APIENTRY * glMultiTexCoord4iPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q );
typedef void (APIENTRY * glMultiTexCoord4ivPROC) (GLenum target, const GLint *v );
typedef void (APIENTRY * glMultiTexCoord4sPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q );
typedef void (APIENTRY * glMultiTexCoord4svPROC) (GLenum target, const GLshort *v );
typedef void (APIENTRY * glLoadTransposeMatrixdPROC) (const GLdouble m[16] );
typedef void (APIENTRY * glLoadTransposeMatrixfPROC) (const GLfloat m[16] );
typedef void (APIENTRY * glMultTransposeMatrixdPROC) (const GLdouble m[16] );
typedef void (APIENTRY * glMultTransposeMatrixfPROC) (const GLfloat m[16] );
typedef void (APIENTRY * glSampleCoveragePROC) (GLclampf value, GLboolean invert );
static glActiveTexturePROC glActiveTexture;
static glClientActiveTexturePROC glClientActiveTexture;
static glMultiTexCoord1dPROC glMultiTexCoord1d;
static glMultiTexCoord1dvPROC glMultiTexCoord1dv;
static glMultiTexCoord1fPROC glMultiTexCoord1f;
static glMultiTexCoord1fvPROC glMultiTexCoord1fv;
static glMultiTexCoord1iPROC glMultiTexCoord1i;
static glMultiTexCoord1ivPROC glMultiTexCoord1iv;
static glMultiTexCoord1sPROC glMultiTexCoord1s;
static glMultiTexCoord1svPROC glMultiTexCoord1sv;
static glMultiTexCoord2dPROC glMultiTexCoord2d;
static glMultiTexCoord2dvPROC glMultiTexCoord2dv;
static glMultiTexCoord2fPROC glMultiTexCoord2f;
static glMultiTexCoord2fvPROC glMultiTexCoord2fv;
static glMultiTexCoord2iPROC glMultiTexCoord2i;
static glMultiTexCoord2ivPROC glMultiTexCoord2iv;
static glMultiTexCoord2sPROC glMultiTexCoord2s;
static glMultiTexCoord2svPROC glMultiTexCoord2sv;
static glMultiTexCoord3dPROC glMultiTexCoord3d;
static glMultiTexCoord3dvPROC glMultiTexCoord3dv;
static glMultiTexCoord3fPROC glMultiTexCoord3f;
static glMultiTexCoord3fvPROC glMultiTexCoord3fv;
static glMultiTexCoord3iPROC glMultiTexCoord3i;
static glMultiTexCoord3ivPROC glMultiTexCoord3iv;
static glMultiTexCoord3sPROC glMultiTexCoord3s;
static glMultiTexCoord3svPROC glMultiTexCoord3sv;
static glMultiTexCoord4dPROC glMultiTexCoord4d;
static glMultiTexCoord4dvPROC glMultiTexCoord4dv;
static glMultiTexCoord4fPROC glMultiTexCoord4f;
static glMultiTexCoord4fvPROC glMultiTexCoord4fv;
static glMultiTexCoord4iPROC glMultiTexCoord4i;
static glMultiTexCoord4ivPROC glMultiTexCoord4iv;
static glMultiTexCoord4sPROC glMultiTexCoord4s;
static glMultiTexCoord4svPROC glMultiTexCoord4sv;
static glLoadTransposeMatrixfPROC glLoadTransposeMatrixf;
static glLoadTransposeMatrixdPROC glLoadTransposeMatrixd;
static glMultTransposeMatrixfPROC glMultTransposeMatrixf;
static glMultTransposeMatrixdPROC glMultTransposeMatrixd;
static glCompressedTexImage3DPROC glCompressedTexImage3D;
static glCompressedTexImage2DPROC glCompressedTexImage2D;
static glCompressedTexImage1DPROC glCompressedTexImage1D;
static glCompressedTexSubImage3DPROC glCompressedTexSubImage3D;
static glCompressedTexSubImage2DPROC glCompressedTexSubImage2D;
static glCompressedTexSubImage1DPROC glCompressedTexSubImage1D;
static glGetCompressedTexImagePROC glGetCompressedTexImage;
static glSampleCoveragePROC glSampleCoverage;
void extgl_InitOpenGL1_3(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.OpenGL13)
return;
glActiveTexture = (glActiveTexturePROC) extgl_GetProcAddress("glActiveTexture");
glClientActiveTexture = (glClientActiveTexturePROC) extgl_GetProcAddress("glClientActiveTexture");
glMultiTexCoord1d = (glMultiTexCoord1dPROC) extgl_GetProcAddress("glMultiTexCoord1d");
glMultiTexCoord1dv = (glMultiTexCoord1dvPROC) extgl_GetProcAddress("glMultiTexCoord1dv");
glMultiTexCoord1f = (glMultiTexCoord1fPROC) extgl_GetProcAddress("glMultiTexCoord1f");
glMultiTexCoord1fv = (glMultiTexCoord1fvPROC) extgl_GetProcAddress("glMultiTexCoord1fv");
glMultiTexCoord1i = (glMultiTexCoord1iPROC) extgl_GetProcAddress("glMultiTexCoord1i");
glMultiTexCoord1iv = (glMultiTexCoord1ivPROC) extgl_GetProcAddress("glMultiTexCoord1iv");
glMultiTexCoord1s = (glMultiTexCoord1sPROC) extgl_GetProcAddress("glMultiTexCoord1s");
glMultiTexCoord1sv = (glMultiTexCoord1svPROC) extgl_GetProcAddress("glMultiTexCoord1sv");
glMultiTexCoord2d = (glMultiTexCoord2dPROC) extgl_GetProcAddress("glMultiTexCoord2d");
glMultiTexCoord2dv = (glMultiTexCoord2dvPROC) extgl_GetProcAddress("glMultiTexCoord2dv");
glMultiTexCoord2f = (glMultiTexCoord2fPROC) extgl_GetProcAddress("glMultiTexCoord2f");
glMultiTexCoord2fv = (glMultiTexCoord2fvPROC) extgl_GetProcAddress("glMultiTexCoord2fv");
glMultiTexCoord2i = (glMultiTexCoord2iPROC) extgl_GetProcAddress("glMultiTexCoord2i");
glMultiTexCoord2iv = (glMultiTexCoord2ivPROC) extgl_GetProcAddress("glMultiTexCoord2iv");
glMultiTexCoord2s = (glMultiTexCoord2sPROC) extgl_GetProcAddress("glMultiTexCoord2s");
glMultiTexCoord2sv = (glMultiTexCoord2svPROC) extgl_GetProcAddress("glMultiTexCoord2sv");
glMultiTexCoord3d = (glMultiTexCoord3dPROC) extgl_GetProcAddress("glMultiTexCoord3d");
glMultiTexCoord3dv = (glMultiTexCoord3dvPROC) extgl_GetProcAddress("glMultiTexCoord3dv");
glMultiTexCoord3f = (glMultiTexCoord3fPROC) extgl_GetProcAddress("glMultiTexCoord3f");
glMultiTexCoord3fv = (glMultiTexCoord3fvPROC) extgl_GetProcAddress("glMultiTexCoord3fv");
glMultiTexCoord3i = (glMultiTexCoord3iPROC) extgl_GetProcAddress("glMultiTexCoord3i");
glMultiTexCoord3iv = (glMultiTexCoord3ivPROC) extgl_GetProcAddress("glMultiTexCoord3iv");
glMultiTexCoord3s = (glMultiTexCoord3sPROC) extgl_GetProcAddress("glMultiTexCoord3s");
glMultiTexCoord3sv = (glMultiTexCoord3svPROC) extgl_GetProcAddress("glMultiTexCoord3sv");
glMultiTexCoord4d = (glMultiTexCoord4dPROC) extgl_GetProcAddress("glMultiTexCoord4d");
glMultiTexCoord4dv = (glMultiTexCoord4dvPROC) extgl_GetProcAddress("glMultiTexCoord4dv");
glMultiTexCoord4f = (glMultiTexCoord4fPROC) extgl_GetProcAddress("glMultiTexCoord4f");
glMultiTexCoord4fv = (glMultiTexCoord4fvPROC) extgl_GetProcAddress("glMultiTexCoord4fv");
glMultiTexCoord4i = (glMultiTexCoord4iPROC) extgl_GetProcAddress("glMultiTexCoord4i");
glMultiTexCoord4iv = (glMultiTexCoord4ivPROC) extgl_GetProcAddress("glMultiTexCoord4iv");
glMultiTexCoord4s = (glMultiTexCoord4sPROC) extgl_GetProcAddress("glMultiTexCoord4s");
glMultiTexCoord4sv = (glMultiTexCoord4svPROC) extgl_GetProcAddress("glMultiTexCoord4sv");
glLoadTransposeMatrixf = (glLoadTransposeMatrixfPROC) extgl_GetProcAddress("glLoadTransposeMatrixf");
glLoadTransposeMatrixd = (glLoadTransposeMatrixdPROC) extgl_GetProcAddress("glLoadTransposeMatrixd");
glMultTransposeMatrixf = (glMultTransposeMatrixfPROC) extgl_GetProcAddress("glMultTransposeMatrixf");
glMultTransposeMatrixd = (glMultTransposeMatrixdPROC) extgl_GetProcAddress("glMultTransposeMatrixd");
glCompressedTexImage3D = (glCompressedTexImage3DPROC) extgl_GetProcAddress("glCompressedTexImage3D");
glCompressedTexImage2D = (glCompressedTexImage2DPROC) extgl_GetProcAddress("glCompressedTexImage2D");
glCompressedTexImage1D = (glCompressedTexImage1DPROC) extgl_GetProcAddress("glCompressedTexImage1D");
glCompressedTexSubImage3D = (glCompressedTexSubImage3DPROC) extgl_GetProcAddress("glCompressedTexSubImage3D");
glCompressedTexSubImage2D = (glCompressedTexSubImage2DPROC) extgl_GetProcAddress("glCompressedTexSubImage2D");
glCompressedTexSubImage1D = (glCompressedTexSubImage1DPROC) extgl_GetProcAddress("glCompressedTexSubImage1D");
glGetCompressedTexImage = (glGetCompressedTexImagePROC) extgl_GetProcAddress("glGetCompressedTexImage");
glSampleCoverage = (glSampleCoveragePROC) extgl_GetProcAddress("glSampleCoverage");
EXTGL_SANITY_CHECK(env, ext_set, OpenGL13)
}
/*
* Class: org_lwjgl_opengl_GL13
* Method: glActiveTexture

148
src/native/common/org_lwjgl_opengl_GL14.cpp
View File

@ -39,14 +39,154 @@
* @version $Revision$
*/
#ifdef _WIN32
#include <windows.h>
#endif
#include "org_lwjgl_opengl_GL14.h"
#include "checkGLerror.h"
#include "extgl.h"
typedef void (APIENTRY * glBlendColorPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha );
typedef void (APIENTRY * glBlendEquationPROC) (GLenum mode );
typedef void (APIENTRY * glFogCoordfPROC) (GLfloat coord);
typedef void (APIENTRY * glFogCoordfvPROC) (const GLfloat *coord);
typedef void (APIENTRY * glFogCoorddPROC) (GLdouble coord);
typedef void (APIENTRY * glFogCoorddvPROC) (const GLdouble *coord);
typedef void (APIENTRY * glFogCoordPointerPROC) (GLenum type, GLsizei stride, const GLvoid *pointer);
typedef void (APIENTRY * glMultiDrawArraysPROC) (GLenum mode, GLint *first, GLsizei *count, GLsizei primcount);
typedef void (APIENTRY * glMultiDrawElementsPROC) (GLenum mode, GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount);
typedef void (APIENTRY * glPointParameterfPROC) (GLenum pname, GLfloat param);
typedef void (APIENTRY * glPointParameterfvPROC) (GLenum pname, GLfloat *params);
typedef void (APIENTRY * glSecondaryColor3bPROC) (GLbyte red, GLbyte green, GLbyte blue);
typedef void (APIENTRY * glSecondaryColor3bvPROC) (const GLbyte *v);
typedef void (APIENTRY * glSecondaryColor3dPROC) (GLdouble red, GLdouble green, GLdouble blue);
typedef void (APIENTRY * glSecondaryColor3dvPROC) (const GLdouble *v);
typedef void (APIENTRY * glSecondaryColor3fPROC) (GLfloat red, GLfloat green, GLfloat blue);
typedef void (APIENTRY * glSecondaryColor3fvPROC) (const GLfloat *v);
typedef void (APIENTRY * glSecondaryColor3iPROC) (GLint red, GLint green, GLint blue);
typedef void (APIENTRY * glSecondaryColor3ivPROC) (const GLint *v);
typedef void (APIENTRY * glSecondaryColor3sPROC) (GLshort red, GLshort green, GLshort blue);
typedef void (APIENTRY * glSecondaryColor3svPROC) (const GLshort *v);
typedef void (APIENTRY * glSecondaryColor3ubPROC) (GLubyte red, GLubyte green, GLubyte blue);
typedef void (APIENTRY * glSecondaryColor3ubvPROC) (const GLubyte *v);
typedef void (APIENTRY * glSecondaryColor3uiPROC) (GLuint red, GLuint green, GLuint blue);
typedef void (APIENTRY * glSecondaryColor3uivPROC) (const GLuint *v);
typedef void (APIENTRY * glSecondaryColor3usPROC) (GLushort red, GLushort green, GLushort blue);
typedef void (APIENTRY * glSecondaryColor3usvPROC) (const GLushort *v);
typedef void (APIENTRY * glSecondaryColorPointerPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
typedef void (APIENTRY * glBlendFuncSeparatePROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
typedef void (APIENTRY * glWindowPos2dPROC) (GLdouble x, GLdouble y);
typedef void (APIENTRY * glWindowPos2fPROC) (GLfloat x, GLfloat y);
typedef void (APIENTRY * glWindowPos2iPROC) (GLint x, GLint y);
typedef void (APIENTRY * glWindowPos2sPROC) (GLshort x, GLshort y);
typedef void (APIENTRY * glWindowPos2dvPROC) (const GLdouble *p);
typedef void (APIENTRY * glWindowPos2fvPROC) (const GLfloat *p);
typedef void (APIENTRY * glWindowPos2ivPROC) (const GLint *p);
typedef void (APIENTRY * glWindowPos2svPROC) (const GLshort *p);
typedef void (APIENTRY * glWindowPos3dPROC) (GLdouble x, GLdouble y, GLdouble z);
typedef void (APIENTRY * glWindowPos3fPROC) (GLfloat x, GLfloat y, GLfloat z);
typedef void (APIENTRY * glWindowPos3iPROC) (GLint x, GLint y, GLint z);
typedef void (APIENTRY * glWindowPos3sPROC) (GLshort x, GLshort y, GLshort z);
typedef void (APIENTRY * glWindowPos3dvPROC) (const GLdouble *p);
typedef void (APIENTRY * glWindowPos3fvPROC) (const GLfloat *p);
typedef void (APIENTRY * glWindowPos3ivPROC) (const GLint *p);
typedef void (APIENTRY * glWindowPos3svPROC) (const GLshort *p);
static glFogCoordfPROC glFogCoordf;
static glFogCoordfvPROC glFogCoordfv;
static glFogCoorddPROC glFogCoordd;
static glFogCoorddvPROC glFogCoorddv;
static glFogCoordPointerPROC glFogCoordPointer;
static glMultiDrawArraysPROC glMultiDrawArrays;
static glMultiDrawElementsPROC glMultiDrawElements;
static glPointParameterfPROC glPointParameterf;
static glPointParameterfvPROC glPointParameterfv;
static glSecondaryColor3bPROC glSecondaryColor3b;
static glSecondaryColor3bvPROC glSecondaryColor3bv;
static glSecondaryColor3dPROC glSecondaryColor3d;
static glSecondaryColor3dvPROC glSecondaryColor3dv;
static glSecondaryColor3fPROC glSecondaryColor3f;
static glSecondaryColor3fvPROC glSecondaryColor3fv;
static glSecondaryColor3iPROC glSecondaryColor3i;
static glSecondaryColor3ivPROC glSecondaryColor3iv;
static glSecondaryColor3sPROC glSecondaryColor3s;
static glSecondaryColor3svPROC glSecondaryColor3sv;
static glSecondaryColor3ubPROC glSecondaryColor3ub;
static glSecondaryColor3ubvPROC glSecondaryColor3ubv;
static glSecondaryColor3uiPROC glSecondaryColor3ui;
static glSecondaryColor3uivPROC glSecondaryColor3uiv;
static glSecondaryColor3usPROC glSecondaryColor3us;
static glSecondaryColor3usvPROC glSecondaryColor3usv;
static glSecondaryColorPointerPROC glSecondaryColorPointer;
static glBlendFuncSeparatePROC glBlendFuncSeparate;
static glWindowPos2dPROC glWindowPos2d;
static glWindowPos2fPROC glWindowPos2f;
static glWindowPos2iPROC glWindowPos2i;
static glWindowPos2sPROC glWindowPos2s;
static glWindowPos2dvPROC glWindowPos2dv;
static glWindowPos2fvPROC glWindowPos2fv;
static glWindowPos2ivPROC glWindowPos2iv;
static glWindowPos2svPROC glWindowPos2sv;
static glWindowPos3dPROC glWindowPos3d;
static glWindowPos3fPROC glWindowPos3f;
static glWindowPos3iPROC glWindowPos3i;
static glWindowPos3sPROC glWindowPos3s;
static glWindowPos3dvPROC glWindowPos3dv;
static glWindowPos3fvPROC glWindowPos3fv;
static glWindowPos3ivPROC glWindowPos3iv;
static glWindowPos3svPROC glWindowPos3sv;
static glBlendColorPROC glBlendColor;
static glBlendEquationPROC glBlendEquation;
void extgl_InitOpenGL1_4(JNIEnv *env, jobject ext_set)
{
if (!extgl_Extensions.OpenGL14)
return;
glBlendColor = (glBlendColorPROC) extgl_GetProcAddress("glBlendColor");
glBlendEquation = (glBlendEquationPROC) extgl_GetProcAddress("glBlendEquation");
glFogCoordf = (glFogCoordfPROC) extgl_GetProcAddress("glFogCoordf");
glFogCoordfv = (glFogCoordfvPROC) extgl_GetProcAddress("glFogCoordfv");
glFogCoordd = (glFogCoorddPROC) extgl_GetProcAddress("glFogCoordd");
glFogCoorddv = (glFogCoorddvPROC) extgl_GetProcAddress("glFogCoorddv");
glFogCoordPointer = (glFogCoordPointerPROC) extgl_GetProcAddress("glFogCoordPointer");
glMultiDrawArrays = (glMultiDrawArraysPROC) extgl_GetProcAddress("glMultiDrawArrays");
glMultiDrawElements = (glMultiDrawElementsPROC) extgl_GetProcAddress("glMultiDrawElements");
glPointParameterf = (glPointParameterfPROC) extgl_GetProcAddress("glPointParameterf");
glPointParameterfv = (glPointParameterfvPROC) extgl_GetProcAddress("glPointParameterfv");
glSecondaryColor3b = (glSecondaryColor3bPROC) extgl_GetProcAddress("glSecondaryColor3b");
glSecondaryColor3bv = (glSecondaryColor3bvPROC) extgl_GetProcAddress("glSecondaryColor3bv");
glSecondaryColor3d = (glSecondaryColor3dPROC) extgl_GetProcAddress("glSecondaryColor3d");
glSecondaryColor3dv = (glSecondaryColor3dvPROC) extgl_GetProcAddress("glSecondaryColor3dv");
glSecondaryColor3f = (glSecondaryColor3fPROC) extgl_GetProcAddress("glSecondaryColor3f");
glSecondaryColor3fv = (glSecondaryColor3fvPROC) extgl_GetProcAddress("glSecondaryColor3fv");
glSecondaryColor3i = (glSecondaryColor3iPROC) extgl_GetProcAddress("glSecondaryColor3i");
glSecondaryColor3iv = (glSecondaryColor3ivPROC) extgl_GetProcAddress("glSecondaryColor3iv");
glSecondaryColor3s = (glSecondaryColor3sPROC) extgl_GetProcAddress("glSecondaryColor3s");
glSecondaryColor3sv = (glSecondaryColor3svPROC) extgl_GetProcAddress("glSecondaryColor3sv");
glSecondaryColor3ub = (glSecondaryColor3ubPROC) extgl_GetProcAddress("glSecondaryColor3ub");
glSecondaryColor3ubv = (glSecondaryColor3ubvPROC) extgl_GetProcAddress("glSecondaryColor3ubv");
glSecondaryColor3ui = (glSecondaryColor3uiPROC) extgl_GetProcAddress("glSecondaryColor3ui");
glSecondaryColor3uiv = (glSecondaryColor3uivPROC) extgl_GetProcAddress("glSecondaryColor3uiv");
glSecondaryColor3us = (glSecondaryColor3usPROC) extgl_GetProcAddress("glSecondaryColor3us");
glSecondaryColor3usv = (glSecondaryColor3usvPROC) extgl_GetProcAddress("glSecondaryColor3usv");
glSecondaryColorPointer = (glSecondaryColorPointerPROC) extgl_GetProcAddress("glSecondaryColorPointer");
glBlendFuncSeparate = (glBlendFuncSeparatePROC) extgl_GetProcAddress("glBlendFuncSeparate");
glWindowPos2d = (glWindowPos2dPROC) extgl_GetProcAddress("glWindowPos2d");
glWindowPos2f = (glWindowPos2fPROC) extgl_GetProcAddress("glWindowPos2f");
glWindowPos2i = (glWindowPos2iPROC) extgl_GetProcAddress("glWindowPos2i");
glWindowPos2s = (glWindowPos2sPROC) extgl_GetProcAddress("glWindowPos2s");
glWindowPos2dv = (glWindowPos2dvPROC) extgl_GetProcAddress("glWindowPos2dv");
glWindowPos2fv = (glWindowPos2fvPROC) extgl_GetProcAddress("glWindowPos2fv");
glWindowPos2iv = (glWindowPos2ivPROC) extgl_GetProcAddress("glWindowPos2iv");
glWindowPos2sv = (glWindowPos2svPROC) extgl_GetProcAddress("glWindowPos2sv");
glWindowPos3d = (glWindowPos3dPROC) extgl_GetProcAddress("glWindowPos3d");
glWindowPos3f = (glWindowPos3fPROC) extgl_GetProcAddress("glWindowPos3f");
glWindowPos3i = (glWindowPos3iPROC) extgl_GetProcAddress("glWindowPos3i");
glWindowPos3s = (glWindowPos3sPROC) extgl_GetProcAddress("glWindowPos3s");
glWindowPos3dv = (glWindowPos3dvPROC) extgl_GetProcAddress("glWindowPos3dv");
glWindowPos3fv = (glWindowPos3fvPROC) extgl_GetProcAddress("glWindowPos3fv");
glWindowPos3iv = (glWindowPos3ivPROC) extgl_GetProcAddress("glWindowPos3iv");
glWindowPos3sv = (glWindowPos3svPROC) extgl_GetProcAddress("glWindowPos3sv");
EXTGL_SANITY_CHECK(env, ext_set, OpenGL14)
}
/*
* Class: org_lwjgl_opengl_GL14
* Method: glFogCoordf