gt: 		long __functionAddress = getInstance().VertexAttrib4ubvARB;
context: /*
   * Copyright LWJGL. All rights reserved.
   * License terms: http://lwjgl.org/license.php
   * MACHINE GENERATED FILE, DO NOT EDIT
   */
  package org.lwjgl.opengl;
  
  import org.lwjgl.*;
  import org.lwjgl.system.*;
  
  import java.nio.*;
  
  import static org.lwjgl.system.Checks.*;
  import static org.lwjgl.Pointer.*;
  import static org.lwjgl.system.MemoryUtil.*;
  import static org.lwjgl.system.APIUtil.*;
  
  /**
   * Native bindings to the <a href="http://www.opengl.org/registry/specs/ARB/vertex_shader.txt">ARB_vertex_shader</a> extension.
   * 
   * <p>This extension adds programmable vertex level processing to OpenGL. The application can write vertex shaders in a high level language as defined in the
   * OpenGL Shading Language specification. A vertex shader replaces the transformation, texture coordinate generation and lighting parts of OpenGL, and it
   * also adds texture access at the vertex level. Furthermore, management of vertex shader objects and loading generic attributes are discussed. A vertex
   * shader object, attached to a program object, can be compiled and linked to produce an executable that runs on the vertex processor in OpenGL.
   * This extension also defines how such an executable interacts with the fixed functionality vertex processing of OpenGL 1.4.</p>
   * 
   * <p>Promoted to core in {@link GL20 OpenGL 2.0}.</p>
   */
  public final class ARBVertexShader {
  
  	/** Accepted by the {@code shaderType} argument of CreateShaderObjectARB and returned by the {@code params} parameter of GetObjectParameter{if}vARB. */
  	public static final int GL_VERTEX_SHADER_ARB = 0x8B31;
  
  	/** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev. */
  	public static final int
  		GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB    = 0x8B4A,
  		GL_MAX_VARYING_FLOATS_ARB               = 0x8B4B,
  		GL_MAX_VERTEX_ATTRIBS_ARB               = 0x8869,
  		GL_MAX_TEXTURE_IMAGE_UNITS_ARB          = 0x8872,
  		GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB   = 0x8B4C,
  		GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = 0x8B4D,
  		GL_MAX_TEXTURE_COORDS_ARB               = 0x8871;
  
  	/**
  	 * Accepted by the {@code cap} parameter of Disable, Enable, and IsEnabled, and by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and
  	 * GetDoublev.
  	 */
  	public static final int
  		GL_VERTEX_PROGRAM_POINT_SIZE_ARB = 0x8642,
  		GL_VERTEX_PROGRAM_TWO_SIDE_ARB   = 0x8643;
  
  	/** Accepted by the {@code pname} parameter GetObjectParameter{if}vARB. */
  	public static final int
  		GL_OBJECT_ACTIVE_ATTRIBUTES_ARB           = 0x8B89,
  		GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = 0x8B8A;
  
  	/** Accepted by the {@code pname} parameter of GetVertexAttrib{dfi}vARB. */
  	public static final int
  		GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB    = 0x8622,
  		GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB       = 0x8623,
  		GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB     = 0x8624,
  		GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB       = 0x8625,
  		GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = 0x886A,
  		GL_CURRENT_VERTEX_ATTRIB_ARB          = 0x8626;
  
  	/** Accepted by the {@code pname} parameter of GetVertexAttribPointervARB. */
  	public static final int GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB = 0x8645;
  
  	/** Returned by the {@code type} parameter of GetActiveAttribARB. */
  	public static final int
  		GL_FLOAT          = 0x1406,
  		GL_FLOAT_VEC2_ARB = 0x8B50,
  		GL_FLOAT_VEC3_ARB = 0x8B51,
  		GL_FLOAT_VEC4_ARB = 0x8B52,
  		GL_FLOAT_MAT2_ARB = 0x8B5A,
  		GL_FLOAT_MAT3_ARB = 0x8B5B,
  		GL_FLOAT_MAT4_ARB = 0x8B5C;
  
  	/** Function address. */
  	@JavadocExclude
  	public final long
  		VertexAttrib1fARB,
  		VertexAttrib1sARB,
  		VertexAttrib1dARB,
  		VertexAttrib2fARB,
  		VertexAttrib2sARB,
  		VertexAttrib2dARB,
  		VertexAttrib3fARB,
  		VertexAttrib3sARB,
  		VertexAttrib3dARB,
  		VertexAttrib4fARB,
  		VertexAttrib4sARB,
  		VertexAttrib4dARB,
  		VertexAttrib4NubARB,
  		VertexAttrib1fvARB,
  		VertexAttrib1svARB,
  		VertexAttrib1dvARB,
  		VertexAttrib2fvARB,
  		VertexAttrib2svARB,
  		VertexAttrib2dvARB,
  		VertexAttrib3fvARB,
  		VertexAttrib3svARB,
  		VertexAttrib3dvARB,
  		VertexAttrib4fvARB,
  		VertexAttrib4svARB,
  		VertexAttrib4dvARB,
  		VertexAttrib4ivARB,
  		VertexAttrib4bvARB,
  		VertexAttrib4ubvARB,
  		VertexAttrib4usvARB,
  		VertexAttrib4uivARB,
  		VertexAttrib4NbvARB,
  		VertexAttrib4NsvARB,
  		VertexAttrib4NivARB,
  		VertexAttrib4NubvARB,
  		VertexAttrib4NusvARB,
  		VertexAttrib4NuivARB,
  		VertexAttribPointerARB,
  		EnableVertexAttribArrayARB,
  		DisableVertexAttribArrayARB,
  		BindAttribLocationARB,
  		GetActiveAttribARB,
  		GetAttribLocationARB,
  		GetVertexAttribivARB,
  		GetVertexAttribfvARB,
  		GetVertexAttribdvARB,
  		GetVertexAttribPointervARB;
  
  	@JavadocExclude
  	public ARBVertexShader(FunctionProvider provider) {
  		VertexAttrib1fARB = provider.getFunctionAddress("glVertexAttrib1fARB");
  		VertexAttrib1sARB = provider.getFunctionAddress("glVertexAttrib1sARB");
  		VertexAttrib1dARB = provider.getFunctionAddress("glVertexAttrib1dARB");
  		VertexAttrib2fARB = provider.getFunctionAddress("glVertexAttrib2fARB");
  		VertexAttrib2sARB = provider.getFunctionAddress("glVertexAttrib2sARB");
  		VertexAttrib2dARB = provider.getFunctionAddress("glVertexAttrib2dARB");
  		VertexAttrib3fARB = provider.getFunctionAddress("glVertexAttrib3fARB");
  		VertexAttrib3sARB = provider.getFunctionAddress("glVertexAttrib3sARB");
  		VertexAttrib3dARB = provider.getFunctionAddress("glVertexAttrib3dARB");
  		VertexAttrib4fARB = provider.getFunctionAddress("glVertexAttrib4fARB");
  		VertexAttrib4sARB = provider.getFunctionAddress("glVertexAttrib4sARB");
  		VertexAttrib4dARB = provider.getFunctionAddress("glVertexAttrib4dARB");
  		VertexAttrib4NubARB = provider.getFunctionAddress("glVertexAttrib4NubARB");
  		VertexAttrib1fvARB = provider.getFunctionAddress("glVertexAttrib1fvARB");
  		VertexAttrib1svARB = provider.getFunctionAddress("glVertexAttrib1svARB");
  		VertexAttrib1dvARB = provider.getFunctionAddress("glVertexAttrib1dvARB");
  		VertexAttrib2fvARB = provider.getFunctionAddress("glVertexAttrib2fvARB");
  		VertexAttrib2svARB = provider.getFunctionAddress("glVertexAttrib2svARB");
  		VertexAttrib2dvARB = provider.getFunctionAddress("glVertexAttrib2dvARB");
  		VertexAttrib3fvARB = provider.getFunctionAddress("glVertexAttrib3fvARB");
  		VertexAttrib3svARB = provider.getFunctionAddress("glVertexAttrib3svARB");
  		VertexAttrib3dvARB = provider.getFunctionAddress("glVertexAttrib3dvARB");
  		VertexAttrib4fvARB = provider.getFunctionAddress("glVertexAttrib4fvARB");
  		VertexAttrib4svARB = provider.getFunctionAddress("glVertexAttrib4svARB");
  		VertexAttrib4dvARB = provider.getFunctionAddress("glVertexAttrib4dvARB");
  		VertexAttrib4ivARB = provider.getFunctionAddress("glVertexAttrib4ivARB");
  		VertexAttrib4bvARB = provider.getFunctionAddress("glVertexAttrib4bvARB");
  		VertexAttrib4ubvARB = provider.getFunctionAddress("glVertexAttrib4ubvARB");
  		VertexAttrib4usvARB = provider.getFunctionAddress("glVertexAttrib4usvARB");
  		VertexAttrib4uivARB = provider.getFunctionAddress("glVertexAttrib4uivARB");
  		VertexAttrib4NbvARB = provider.getFunctionAddress("glVertexAttrib4NbvARB");
  		VertexAttrib4NsvARB = provider.getFunctionAddress("glVertexAttrib4NsvARB");
  		VertexAttrib4NivARB = provider.getFunctionAddress("glVertexAttrib4NivARB");
  		VertexAttrib4NubvARB = provider.getFunctionAddress("glVertexAttrib4NubvARB");
  		VertexAttrib4NusvARB = provider.getFunctionAddress("glVertexAttrib4NusvARB");
  		VertexAttrib4NuivARB = provider.getFunctionAddress("glVertexAttrib4NuivARB");
  		VertexAttribPointerARB = provider.getFunctionAddress("glVertexAttribPointerARB");
  		EnableVertexAttribArrayARB = provider.getFunctionAddress("glEnableVertexAttribArrayARB");
  		DisableVertexAttribArrayARB = provider.getFunctionAddress("glDisableVertexAttribArrayARB");
  		BindAttribLocationARB = provider.getFunctionAddress("glBindAttribLocationARB");
  		GetActiveAttribARB = provider.getFunctionAddress("glGetActiveAttribARB");
  		GetAttribLocationARB = provider.getFunctionAddress("glGetAttribLocationARB");
  		GetVertexAttribivARB = provider.getFunctionAddress("glGetVertexAttribivARB");
  		GetVertexAttribfvARB = provider.getFunctionAddress("glGetVertexAttribfvARB");
  		GetVertexAttribdvARB = provider.getFunctionAddress("glGetVertexAttribdvARB");
  		GetVertexAttribPointervARB = provider.getFunctionAddress("glGetVertexAttribPointervARB");
  	}
  
  	// --- [ Function Addresses ] ---
  
  	/** Returns the {@link ARBVertexShader} instance for the current context. */
  	public static ARBVertexShader getInstance() {
  		return checkFunctionality(GL.getCapabilities().__ARBVertexShader);
  	}
  
  	static ARBVertexShader create(java.util.Set<String> ext, FunctionProvider provider) {
  		if ( !ext.contains("GL_ARB_vertex_shader") ) return null;
  
  		ARBVertexShader funcs = new ARBVertexShader(provider);
  
  		boolean supported = checkFunctions(
  			funcs.VertexAttrib1fARB, funcs.VertexAttrib1sARB, funcs.VertexAttrib1dARB, funcs.VertexAttrib2fARB, funcs.VertexAttrib2sARB, 
  			funcs.VertexAttrib2dARB, funcs.VertexAttrib3fARB, funcs.VertexAttrib3sARB, funcs.VertexAttrib3dARB, funcs.VertexAttrib4fARB, 
  			funcs.VertexAttrib4sARB, funcs.VertexAttrib4dARB, funcs.VertexAttrib4NubARB, funcs.VertexAttrib1fvARB, funcs.VertexAttrib1svARB, 
  			funcs.VertexAttrib1dvARB, funcs.VertexAttrib2fvARB, funcs.VertexAttrib2svARB, funcs.VertexAttrib2dvARB, funcs.VertexAttrib3fvARB, 
  			funcs.VertexAttrib3svARB, funcs.VertexAttrib3dvARB, funcs.VertexAttrib4fvARB, funcs.VertexAttrib4svARB, funcs.VertexAttrib4dvARB, 
  			funcs.VertexAttrib4ivARB, funcs.VertexAttrib4bvARB, funcs.VertexAttrib4ubvARB, funcs.VertexAttrib4usvARB, funcs.VertexAttrib4uivARB, 
  			funcs.VertexAttrib4NbvARB, funcs.VertexAttrib4NsvARB, funcs.VertexAttrib4NivARB, funcs.VertexAttrib4NubvARB, funcs.VertexAttrib4NusvARB, 
  			funcs.VertexAttrib4NuivARB, funcs.VertexAttribPointerARB, funcs.EnableVertexAttribArrayARB, funcs.DisableVertexAttribArrayARB, 
  			funcs.BindAttribLocationARB, funcs.GetActiveAttribARB, funcs.GetAttribLocationARB, funcs.GetVertexAttribivARB, funcs.GetVertexAttribfvARB, 
  			funcs.GetVertexAttribdvARB, funcs.GetVertexAttribPointervARB
  		);
  
  		return GL.checkExtension("GL_ARB_vertex_shader", funcs, supported);
  	}
  
  	// --- [ glVertexAttrib1fARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib1fARB VertexAttrib1fARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib1fARB(int index, float v0, long __functionAddress);
  
  	/**
  	 * Specifies the value of a generic vertex attribute. The y and z components are implicitly set to 0.0f and w to 1.0f.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v0    the vertex attribute x component
  	 */
  	public static void glVertexAttrib1fARB(int index, float v0) {
  		long __functionAddress = getInstance().VertexAttrib1fARB;
  		nglVertexAttrib1fARB(index, v0, __functionAddress);
  	}
  
  	// --- [ glVertexAttrib1sARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib1sARB VertexAttrib1sARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib1sARB(int index, short v0, long __functionAddress);
  
  	/**
  	 * Short version of {@link #glVertexAttrib1fARB VertexAttrib1fARB}.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v0    the vertex attribute x component
  	 */
  	public static void glVertexAttrib1sARB(int index, short v0) {
  		long __functionAddress = getInstance().VertexAttrib1sARB;
  		nglVertexAttrib1sARB(index, v0, __functionAddress);
  	}
  
  	// --- [ glVertexAttrib1dARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib1dARB VertexAttrib1dARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib1dARB(int index, double v0, long __functionAddress);
  
  	/**
  	 * Double version of {@link #glVertexAttrib1fARB VertexAttrib1fARB}.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v0    the vertex attribute x component
  	 */
  	public static void glVertexAttrib1dARB(int index, double v0) {
  		long __functionAddress = getInstance().VertexAttrib1dARB;
  		nglVertexAttrib1dARB(index, v0, __functionAddress);
  	}
  
  	// --- [ glVertexAttrib2fARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib2fARB VertexAttrib2fARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib2fARB(int index, float v0, float v1, long __functionAddress);
  
  	/**
  	 * Specifies the value of a generic vertex attribute. The y component is implicitly set to 0.0f and w to 1.0f.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v0    the vertex attribute x component
  	 * @param v1    the vertex attribute y component
  	 */
  	public static void glVertexAttrib2fARB(int index, float v0, float v1) {
  		long __functionAddress = getInstance().VertexAttrib2fARB;
  		nglVertexAttrib2fARB(index, v0, v1, __functionAddress);
  	}
  
  	// --- [ glVertexAttrib2sARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib2sARB VertexAttrib2sARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib2sARB(int index, short v0, short v1, long __functionAddress);
  
  	/**
  	 * Short version of {@link #glVertexAttrib2fARB VertexAttrib2fARB}.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v0    the vertex attribute x component
  	 * @param v1    the vertex attribute y component
  	 */
  	public static void glVertexAttrib2sARB(int index, short v0, short v1) {
  		long __functionAddress = getInstance().VertexAttrib2sARB;
  		nglVertexAttrib2sARB(index, v0, v1, __functionAddress);
  	}
  
  	// --- [ glVertexAttrib2dARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib2dARB VertexAttrib2dARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib2dARB(int index, double v0, double v1, long __functionAddress);
  
  	/**
  	 * Double version of {@link #glVertexAttrib2fARB VertexAttrib2fARB}.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v0    the vertex attribute x component
  	 * @param v1    the vertex attribute y component
  	 */
  	public static void glVertexAttrib2dARB(int index, double v0, double v1) {
  		long __functionAddress = getInstance().VertexAttrib2dARB;
  		nglVertexAttrib2dARB(index, v0, v1, __functionAddress);
  	}
  
  	// --- [ glVertexAttrib3fARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib3fARB VertexAttrib3fARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib3fARB(int index, float v0, float v1, float v2, long __functionAddress);
  
  	/**
  	 * Specifies the value of a generic vertex attribute. The w is implicitly set to 1.0f.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v0    the vertex attribute x component
  	 * @param v1    the vertex attribute y component
  	 * @param v2    the vertex attribute z component
  	 */
  	public static void glVertexAttrib3fARB(int index, float v0, float v1, float v2) {
  		long __functionAddress = getInstance().VertexAttrib3fARB;
  		nglVertexAttrib3fARB(index, v0, v1, v2, __functionAddress);
  	}
  
  	// --- [ glVertexAttrib3sARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib3sARB VertexAttrib3sARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib3sARB(int index, short v0, short v1, short v2, long __functionAddress);
  
  	/**
  	 * Short version of {@link #glVertexAttrib3fARB VertexAttrib3fARB}.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v0    the vertex attribute x component
  	 * @param v1    the vertex attribute y component
  	 * @param v2    the vertex attribute z component
  	 */
  	public static void glVertexAttrib3sARB(int index, short v0, short v1, short v2) {
  		long __functionAddress = getInstance().VertexAttrib3sARB;
  		nglVertexAttrib3sARB(index, v0, v1, v2, __functionAddress);
  	}
  
  	// --- [ glVertexAttrib3dARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib3dARB VertexAttrib3dARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib3dARB(int index, double v0, double v1, double v2, long __functionAddress);
  
  	/**
  	 * Double version of {@link #glVertexAttrib3fARB VertexAttrib3fARB}.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v0    the vertex attribute x component
  	 * @param v1    the vertex attribute y component
  	 * @param v2    the vertex attribute z component
  	 */
  	public static void glVertexAttrib3dARB(int index, double v0, double v1, double v2) {
  		long __functionAddress = getInstance().VertexAttrib3dARB;
  		nglVertexAttrib3dARB(index, v0, v1, v2, __functionAddress);
  	}
  
  	// --- [ glVertexAttrib4fARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib4fARB VertexAttrib4fARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib4fARB(int index, float v0, float v1, float v2, float v3, long __functionAddress);
  
  	/**
  	 * Specifies the value of a generic vertex attribute.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v0    the vertex attribute x component
  	 * @param v1    the vertex attribute y component
  	 * @param v2    the vertex attribute z component
  	 * @param v3    the vertex attribute w component
  	 */
  	public static void glVertexAttrib4fARB(int index, float v0, float v1, float v2, float v3) {
  		long __functionAddress = getInstance().VertexAttrib4fARB;
  		nglVertexAttrib4fARB(index, v0, v1, v2, v3, __functionAddress);
  	}
  
  	// --- [ glVertexAttrib4sARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib4sARB VertexAttrib4sARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib4sARB(int index, short v0, short v1, short v2, short v3, long __functionAddress);
  
  	/**
  	 * Short version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v0    the vertex attribute x component
  	 * @param v1    the vertex attribute y component
  	 * @param v2    the vertex attribute z component
  	 * @param v3    the vertex attribute w component
  	 */
  	public static void glVertexAttrib4sARB(int index, short v0, short v1, short v2, short v3) {
  		long __functionAddress = getInstance().VertexAttrib4sARB;
  		nglVertexAttrib4sARB(index, v0, v1, v2, v3, __functionAddress);
  	}
  
  	// --- [ glVertexAttrib4dARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib4dARB VertexAttrib4dARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib4dARB(int index, double v0, double v1, double v2, double v3, long __functionAddress);
  
  	/**
  	 * Double version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v0    the vertex attribute x component
  	 * @param v1    the vertex attribute y component
  	 * @param v2    the vertex attribute z component
  	 * @param v3    the vertex attribute w component
  	 */
  	public static void glVertexAttrib4dARB(int index, double v0, double v1, double v2, double v3) {
  		long __functionAddress = getInstance().VertexAttrib4dARB;
  		nglVertexAttrib4dARB(index, v0, v1, v2, v3, __functionAddress);
  	}
  
  	// --- [ glVertexAttrib4NubARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib4NubARB VertexAttrib4NubARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib4NubARB(int index, byte x, byte y, byte z, byte w, long __functionAddress);
  
  	/**
  	 * Normalized unsigned byte version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param x     the vertex attribute x component
  	 * @param y     the vertex attribute y component
  	 * @param z     the vertex attribute z component
  	 * @param w     the vertex attribute w component
  	 */
  	public static void glVertexAttrib4NubARB(int index, byte x, byte y, byte z, byte w) {
  		long __functionAddress = getInstance().VertexAttrib4NubARB;
  		nglVertexAttrib4NubARB(index, x, y, z, w, __functionAddress);
  	}
  
  	// --- [ glVertexAttrib1fvARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib1fvARB VertexAttrib1fvARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib1fvARB(int index, long v, long __functionAddress);
  
  	/** Unsafe version of {@link #glVertexAttrib1fvARB VertexAttrib1fvARB} */
  	@JavadocExclude
  	public static void nglVertexAttrib1fvARB(int index, long v) {
  		long __functionAddress = getInstance().VertexAttrib1fvARB;
  		nglVertexAttrib1fvARB(index, v, __functionAddress);
  	}
  
  	/**
  	 * Pointer version of {@link #glVertexAttrib1fARB VertexAttrib1fARB}.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v     the vertex attribute buffer
  	 */
  	public static void glVertexAttrib1fvARB(int index, ByteBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 1 << 2);
  		nglVertexAttrib1fvARB(index, memAddress(v));
  	}
  
  	/** Alternative version of: {@link #glVertexAttrib1fvARB VertexAttrib1fvARB} */
  	public static void glVertexAttrib1fvARB(int index, FloatBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 1);
  		nglVertexAttrib1fvARB(index, memAddress(v));
  	}
  
  	// --- [ glVertexAttrib1svARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib1svARB VertexAttrib1svARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib1svARB(int index, long v, long __functionAddress);
  
  	/** Unsafe version of {@link #glVertexAttrib1svARB VertexAttrib1svARB} */
  	@JavadocExclude
  	public static void nglVertexAttrib1svARB(int index, long v) {
  		long __functionAddress = getInstance().VertexAttrib1svARB;
  		nglVertexAttrib1svARB(index, v, __functionAddress);
  	}
  
  	/**
  	 * Pointer version of {@link #glVertexAttrib1sARB VertexAttrib1sARB}.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v     the vertex attribute buffer
  	 */
  	public static void glVertexAttrib1svARB(int index, ByteBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 1 << 1);
  		nglVertexAttrib1svARB(index, memAddress(v));
  	}
  
  	/** Alternative version of: {@link #glVertexAttrib1svARB VertexAttrib1svARB} */
  	public static void glVertexAttrib1svARB(int index, ShortBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 1);
  		nglVertexAttrib1svARB(index, memAddress(v));
  	}
  
  	// --- [ glVertexAttrib1dvARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib1dvARB VertexAttrib1dvARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib1dvARB(int index, long v, long __functionAddress);
  
  	/** Unsafe version of {@link #glVertexAttrib1dvARB VertexAttrib1dvARB} */
  	@JavadocExclude
  	public static void nglVertexAttrib1dvARB(int index, long v) {
  		long __functionAddress = getInstance().VertexAttrib1dvARB;
  		nglVertexAttrib1dvARB(index, v, __functionAddress);
  	}
  
  	/**
  	 * Pointer version of {@link #glVertexAttrib1dARB VertexAttrib1dARB}.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v     the vertex attribute buffer
  	 */
  	public static void glVertexAttrib1dvARB(int index, ByteBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 1 << 3);
  		nglVertexAttrib1dvARB(index, memAddress(v));
  	}
  
  	/** Alternative version of: {@link #glVertexAttrib1dvARB VertexAttrib1dvARB} */
  	public static void glVertexAttrib1dvARB(int index, DoubleBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 1);
  		nglVertexAttrib1dvARB(index, memAddress(v));
  	}
  
  	// --- [ glVertexAttrib2fvARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib2fvARB VertexAttrib2fvARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib2fvARB(int index, long v, long __functionAddress);
  
  	/** Unsafe version of {@link #glVertexAttrib2fvARB VertexAttrib2fvARB} */
  	@JavadocExclude
  	public static void nglVertexAttrib2fvARB(int index, long v) {
  		long __functionAddress = getInstance().VertexAttrib2fvARB;
  		nglVertexAttrib2fvARB(index, v, __functionAddress);
  	}
  
  	/**
  	 * Pointer version of {@link #glVertexAttrib2fARB VertexAttrib2fARB}.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v     the vertex attribute buffer
  	 */
  	public static void glVertexAttrib2fvARB(int index, ByteBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 2 << 2);
  		nglVertexAttrib2fvARB(index, memAddress(v));
  	}
  
  	/** Alternative version of: {@link #glVertexAttrib2fvARB VertexAttrib2fvARB} */
  	public static void glVertexAttrib2fvARB(int index, FloatBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 2);
  		nglVertexAttrib2fvARB(index, memAddress(v));
  	}
  
  	// --- [ glVertexAttrib2svARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib2svARB VertexAttrib2svARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib2svARB(int index, long v, long __functionAddress);
  
  	/** Unsafe version of {@link #glVertexAttrib2svARB VertexAttrib2svARB} */
  	@JavadocExclude
  	public static void nglVertexAttrib2svARB(int index, long v) {
  		long __functionAddress = getInstance().VertexAttrib2svARB;
  		nglVertexAttrib2svARB(index, v, __functionAddress);
  	}
  
  	/**
  	 * Pointer version of {@link #glVertexAttrib2sARB VertexAttrib2sARB}.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v     the vertex attribute buffer
  	 */
  	public static void glVertexAttrib2svARB(int index, ByteBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 2 << 1);
  		nglVertexAttrib2svARB(index, memAddress(v));
  	}
  
  	/** Alternative version of: {@link #glVertexAttrib2svARB VertexAttrib2svARB} */
  	public static void glVertexAttrib2svARB(int index, ShortBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 2);
  		nglVertexAttrib2svARB(index, memAddress(v));
  	}
  
  	// --- [ glVertexAttrib2dvARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib2dvARB VertexAttrib2dvARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib2dvARB(int index, long v, long __functionAddress);
  
  	/** Unsafe version of {@link #glVertexAttrib2dvARB VertexAttrib2dvARB} */
  	@JavadocExclude
  	public static void nglVertexAttrib2dvARB(int index, long v) {
  		long __functionAddress = getInstance().VertexAttrib2dvARB;
  		nglVertexAttrib2dvARB(index, v, __functionAddress);
  	}
  
  	/**
  	 * Pointer version of {@link #glVertexAttrib2dARB VertexAttrib2dARB}.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v     the vertex attribute buffer
  	 */
  	public static void glVertexAttrib2dvARB(int index, ByteBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 2 << 3);
  		nglVertexAttrib2dvARB(index, memAddress(v));
  	}
  
  	/** Alternative version of: {@link #glVertexAttrib2dvARB VertexAttrib2dvARB} */
  	public static void glVertexAttrib2dvARB(int index, DoubleBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 2);
  		nglVertexAttrib2dvARB(index, memAddress(v));
  	}
  
  	// --- [ glVertexAttrib3fvARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib3fvARB VertexAttrib3fvARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib3fvARB(int index, long v, long __functionAddress);
  
  	/** Unsafe version of {@link #glVertexAttrib3fvARB VertexAttrib3fvARB} */
  	@JavadocExclude
  	public static void nglVertexAttrib3fvARB(int index, long v) {
  		long __functionAddress = getInstance().VertexAttrib3fvARB;
  		nglVertexAttrib3fvARB(index, v, __functionAddress);
  	}
  
  	/**
  	 * Pointer version of {@link #glVertexAttrib3fARB VertexAttrib3fARB}.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v     the vertex attribute buffer
  	 */
  	public static void glVertexAttrib3fvARB(int index, ByteBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 3 << 2);
  		nglVertexAttrib3fvARB(index, memAddress(v));
  	}
  
  	/** Alternative version of: {@link #glVertexAttrib3fvARB VertexAttrib3fvARB} */
  	public static void glVertexAttrib3fvARB(int index, FloatBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 3);
  		nglVertexAttrib3fvARB(index, memAddress(v));
  	}
  
  	// --- [ glVertexAttrib3svARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib3svARB VertexAttrib3svARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib3svARB(int index, long v, long __functionAddress);
  
  	/** Unsafe version of {@link #glVertexAttrib3svARB VertexAttrib3svARB} */
  	@JavadocExclude
  	public static void nglVertexAttrib3svARB(int index, long v) {
  		long __functionAddress = getInstance().VertexAttrib3svARB;
  		nglVertexAttrib3svARB(index, v, __functionAddress);
  	}
  
  	/**
  	 * Pointer version of {@link #glVertexAttrib3sARB VertexAttrib3sARB}.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v     the vertex attribute buffer
  	 */
  	public static void glVertexAttrib3svARB(int index, ByteBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 3 << 1);
  		nglVertexAttrib3svARB(index, memAddress(v));
  	}
  
  	/** Alternative version of: {@link #glVertexAttrib3svARB VertexAttrib3svARB} */
  	public static void glVertexAttrib3svARB(int index, ShortBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 3);
  		nglVertexAttrib3svARB(index, memAddress(v));
  	}
  
  	// --- [ glVertexAttrib3dvARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib3dvARB VertexAttrib3dvARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib3dvARB(int index, long v, long __functionAddress);
  
  	/** Unsafe version of {@link #glVertexAttrib3dvARB VertexAttrib3dvARB} */
  	@JavadocExclude
  	public static void nglVertexAttrib3dvARB(int index, long v) {
  		long __functionAddress = getInstance().VertexAttrib3dvARB;
  		nglVertexAttrib3dvARB(index, v, __functionAddress);
  	}
  
  	/**
  	 * Pointer version of {@link #glVertexAttrib3dARB VertexAttrib3dARB}.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v     the vertex attribute buffer
  	 */
  	public static void glVertexAttrib3dvARB(int index, ByteBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 3 << 3);
  		nglVertexAttrib3dvARB(index, memAddress(v));
  	}
  
  	/** Alternative version of: {@link #glVertexAttrib3dvARB VertexAttrib3dvARB} */
  	public static void glVertexAttrib3dvARB(int index, DoubleBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 3);
  		nglVertexAttrib3dvARB(index, memAddress(v));
  	}
  
  	// --- [ glVertexAttrib4fvARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib4fvARB VertexAttrib4fvARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib4fvARB(int index, long v, long __functionAddress);
  
  	/** Unsafe version of {@link #glVertexAttrib4fvARB VertexAttrib4fvARB} */
  	@JavadocExclude
  	public static void nglVertexAttrib4fvARB(int index, long v) {
  		long __functionAddress = getInstance().VertexAttrib4fvARB;
  		nglVertexAttrib4fvARB(index, v, __functionAddress);
  	}
  
  	/**
  	 * Pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v     the vertex attribute buffer
  	 */
  	public static void glVertexAttrib4fvARB(int index, ByteBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 4 << 2);
  		nglVertexAttrib4fvARB(index, memAddress(v));
  	}
  
  	/** Alternative version of: {@link #glVertexAttrib4fvARB VertexAttrib4fvARB} */
  	public static void glVertexAttrib4fvARB(int index, FloatBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 4);
  		nglVertexAttrib4fvARB(index, memAddress(v));
  	}
  
  	// --- [ glVertexAttrib4svARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib4svARB VertexAttrib4svARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib4svARB(int index, long v, long __functionAddress);
  
  	/** Unsafe version of {@link #glVertexAttrib4svARB VertexAttrib4svARB} */
  	@JavadocExclude
  	public static void nglVertexAttrib4svARB(int index, long v) {
  		long __functionAddress = getInstance().VertexAttrib4svARB;
  		nglVertexAttrib4svARB(index, v, __functionAddress);
  	}
  
  	/**
  	 * Pointer version of {@link #glVertexAttrib4sARB VertexAttrib4sARB}.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v     the vertex attribute buffer
  	 */
  	public static void glVertexAttrib4svARB(int index, ByteBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 4 << 1);
  		nglVertexAttrib4svARB(index, memAddress(v));
  	}
  
  	/** Alternative version of: {@link #glVertexAttrib4svARB VertexAttrib4svARB} */
  	public static void glVertexAttrib4svARB(int index, ShortBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 4);
  		nglVertexAttrib4svARB(index, memAddress(v));
  	}
  
  	// --- [ glVertexAttrib4dvARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib4dvARB VertexAttrib4dvARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib4dvARB(int index, long v, long __functionAddress);
  
  	/** Unsafe version of {@link #glVertexAttrib4dvARB VertexAttrib4dvARB} */
  	@JavadocExclude
  	public static void nglVertexAttrib4dvARB(int index, long v) {
  		long __functionAddress = getInstance().VertexAttrib4dvARB;
  		nglVertexAttrib4dvARB(index, v, __functionAddress);
  	}
  
  	/**
  	 * Pointer version of {@link #glVertexAttrib4dARB VertexAttrib4dARB}.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v     the vertex attribute buffer
  	 */
  	public static void glVertexAttrib4dvARB(int index, ByteBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 4 << 3);
  		nglVertexAttrib4dvARB(index, memAddress(v));
  	}
  
  	/** Alternative version of: {@link #glVertexAttrib4dvARB VertexAttrib4dvARB} */
  	public static void glVertexAttrib4dvARB(int index, DoubleBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 4);
  		nglVertexAttrib4dvARB(index, memAddress(v));
  	}
  
  	// --- [ glVertexAttrib4ivARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib4ivARB VertexAttrib4ivARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib4ivARB(int index, long v, long __functionAddress);
  
  	/** Unsafe version of {@link #glVertexAttrib4ivARB VertexAttrib4ivARB} */
  	@JavadocExclude
  	public static void nglVertexAttrib4ivARB(int index, long v) {
  		long __functionAddress = getInstance().VertexAttrib4ivARB;
  		nglVertexAttrib4ivARB(index, v, __functionAddress);
  	}
  
  	/**
  	 * Integer pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v     the vertex attribute buffer
  	 */
  	public static void glVertexAttrib4ivARB(int index, ByteBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 4 << 2);
  		nglVertexAttrib4ivARB(index, memAddress(v));
  	}
  
  	/** Alternative version of: {@link #glVertexAttrib4ivARB VertexAttrib4ivARB} */
  	public static void glVertexAttrib4ivARB(int index, IntBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 4);
  		nglVertexAttrib4ivARB(index, memAddress(v));
  	}
  
  	// --- [ glVertexAttrib4bvARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib4bvARB VertexAttrib4bvARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib4bvARB(int index, long v, long __functionAddress);
  
  	/** Unsafe version of {@link #glVertexAttrib4bvARB VertexAttrib4bvARB} */
  	@JavadocExclude
  	public static void nglVertexAttrib4bvARB(int index, long v) {
  		long __functionAddress = getInstance().VertexAttrib4bvARB;
  		nglVertexAttrib4bvARB(index, v, __functionAddress);
  	}
  
  	/**
  	 * Byte pointer version of {@link #glVertexAttrib4fARB VertexAttrib4fARB}.
  	 *
  	 * @param index the index of the generic vertex attribute to be modified
  	 * @param v     the vertex attribute buffer
  	 */
  	public static void glVertexAttrib4bvARB(int index, ByteBuffer v) {
  		if ( LWJGLUtil.CHECKS )
  			checkBuffer(v, 4);
  		nglVertexAttrib4bvARB(index, memAddress(v));
  	}
  
  	// --- [ glVertexAttrib4ubvARB ] ---
  
  	/** JNI method for {@link #glVertexAttrib4ubvARB VertexAttrib4ubvARB} */
  	@JavadocExclude
  	public static native void nglVertexAttrib4ubvARB(int index, long v, long __functionAddress);
  
  	/** Unsafe version of {@link #glVertexAttrib4ubvARB VertexAttrib4ubvARB} */
  	@JavadocExclude
  	public static void nglVertexAttrib4ubvARB(int index, long v) {
  