java-game-lib-cvs Mailing List for Lightweight Java Game Library

Update of /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/opengl
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv22422/src/java/org/lwjgl/opengl

Modified Files:
	Display.java 
Log Message:
automatic polling via Display.update();

Index: Display.java
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/opengl/Display.java,v
retrieving revision 1.52
retrieving revision 1.53
diff -u -d -r1.52 -r1.53
--- Display.java	16 Jun 2005 20:59:55 -0000	1.52
+++ Display.java	29 Jun 2005 20:48:58 -0000	1.53
@@ -54,6 +54,7 @@
 import org.lwjgl.LWJGLException;
 import org.lwjgl.LWJGLUtil;
 import org.lwjgl.Sys;
+import org.lwjgl.input.Controllers;
 import org.lwjgl.input.Keyboard;
 import org.lwjgl.input.Mouse;
 
@@ -569,9 +570,14 @@
 			Mouse.poll();
 			Mouse.updateCursor();
 		}
+		
 		if (Keyboard.isCreated()) {
 			Keyboard.poll();
 		}
+		
+		if(Controllers.isCreated()) {
+			Controllers.poll();
+		}
 	}
 
 	/**

Update of /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/input
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv21520/src/java/org/lwjgl/input

Modified Files:
	Controllers.java 
Log Message:
support isCreated and destroy (destroy currently ignored)

Index: Controllers.java
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/input/Controllers.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- Controllers.java	29 Jun 2005 20:11:15 -0000	1.1
+++ Controllers.java	29 Jun 2005 20:47:18 -0000	1.2
@@ -29,12 +29,18 @@
 	/** The current event */
 	private static ControllerEvent event;
 	
+	/** Whether controllers were created */
+	private static boolean created;
+	
 	/**
 	 * Initialise the controllers collection
 	 * 
 	 * @throws LWJGLException Indicates a failure to initialise the controller library.
 	 */
 	public static void create() throws LWJGLException {
+		if (created)
+			return;
+		
 		try {
 			String plugins = System.getProperty("jinput.plugins");
 			
@@ -70,6 +76,8 @@
 	
 				createController(c);
 			}
+			
+			created = true;
 		} catch (Throwable e) {
 			throw new LWJGLException("Failed to initialise controllers",e);
 		}
@@ -146,6 +154,35 @@
 	}
 	
 	/**
+	 * @return True if Controllers has been created
+	 */
+	public static boolean isCreated() {
+		return created;
+	}	
+	
+	/**
+	 * Destroys any resources used by the controllers
+	 */
+	public static void destroy() {
+// 		FIXME! not currently possible to destroy a controller
+
+//		if (!created)
+//			return;
+//		created = false;
+//
+//		// nuke each controller
+//		for (int i=0;i<controllers.size();i++) {
+//			//
+//		}
+//		
+//		// cleanup
+//		event = null;
+//		events.clear();
+//		controllers.clear();
+//		controllerCount = 0;
+	}
+	
+	/**
 	 * Get the source of the current event
 	 * 
 	 * @return The source of the current event

Update of /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/input
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv16848/src/java/org/lwjgl/input

Modified Files:
	JInputController.java ControllerEvent.java 
Log Message:
decrease visibility of classes

Index: JInputController.java
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/input/JInputController.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- JInputController.java	29 Jun 2005 20:11:15 -0000	1.1
+++ JInputController.java	29 Jun 2005 20:38:20 -0000	1.2
@@ -10,7 +10,7 @@
  * 
  * @author Kevin Glass
  */
-public class JInputController implements Controller {
+class JInputController implements Controller {
 	/** The JInput controller this class is wrapping */
 	private net.java.games.input.Controller target;
 	/** The index that has been assigned to this controller */

Index: ControllerEvent.java
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/input/ControllerEvent.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- ControllerEvent.java	29 Jun 2005 20:11:15 -0000	1.1
+++ ControllerEvent.java	29 Jun 2005 20:38:21 -0000	1.2
@@ -5,7 +5,7 @@
  * 
  * @author Kevin Glass
  */
-public class ControllerEvent {
+class ControllerEvent {
 	/** Indicates the event was caused by a button */
 	public static final int BUTTON = 1;
 	/** Indicates the event was caused by a axis */

Update of /cvsroot/java-game-lib/LWJGL/libs/win32
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv13178/win32

Added Files:
	DevIL.dll ILU.dll ILUT.dll lwjglaudio.dll 
Log Message:
added 3rd party native libs

--- NEW FILE: ILU.dll ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: ILUT.dll ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: lwjglaudio.dll ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: DevIL.dll ---
(This appears to be a binary file; contents omitted.)

Update of /cvsroot/java-game-lib/LWJGL/libs/macosx
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv13178/macosx

Added Files:
	libIL.dylib libILU.dylib libILUT.dylib openal.dylib 
Log Message:
added 3rd party native libs

--- NEW FILE: libILUT.dylib ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: libILU.dylib ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: libIL.dylib ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: openal.dylib ---
(This appears to be a binary file; contents omitted.)

Update of /cvsroot/java-game-lib/LWJGL/libs/linux
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv13178/linux

Added Files:
	libIL.so libILU.so libILUT.so libopenal.so 
Log Message:
added 3rd party native libs

--- NEW FILE: libILU.so ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: libILUT.so ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: libopenal.so ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: libIL.so ---
(This appears to be a binary file; contents omitted.)

Update of /cvsroot/java-game-lib/LWJGL/doc/3rdparty
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv4709

Added Files:
	jinput_license.txt openal_license.txt openil_license.txt 
Log Message:
added licenses

--- NEW FILE: jinput_license.txt ---
/*****************************************************************************
 * Copyright (c) 2003 Sun Microsystems, Inc.  All Rights Reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * - Redistribution of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 *
 * - Redistribution in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materails provided with the distribution.
 *
 * Neither the name Sun Microsystems, Inc. or the names of the contributors
 * may be used to endorse or promote products derived from this software
 * without specific prior written permission.
 *
 * This software is provided "AS IS," without a warranty of any kind.
 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
 * ANY IMPLIED WARRANT OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
 * NON-INFRINGEMEN, ARE HEREBY EXCLUDED.  SUN MICROSYSTEMS, INC. ("SUN") AND
 * ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS
 * A RESULT OF USING, MODIFYING OR DESTRIBUTING THIS SOFTWARE OR ITS 
 * DERIVATIVES.  IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
 * REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
 * INCIDENTAL OR PUNITIVE DAMAGES.  HOWEVER CAUSED AND REGARDLESS OF THE THEORY
 * OF LIABILITY, ARISING OUT OF THE USE OF OUR INABILITY TO USE THIS SOFTWARE,
 * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 *
 * You acknowledge that this software is not designed or intended for us in
 * the design, construction, operation or maintenance of any nuclear facility
 *
 *****************************************************************************/
--- NEW FILE: openal_license.txt ---
		  GNU LIBRARY GENERAL PUBLIC LICENSE
		       Version 2, June 1991

 Copyright (C) 1991 Free Software Foundation, Inc.
    		    59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

[This is the first released version of the library GPL.  It is
 numbered 2 because it goes with version 2 of the ordinary GPL.]

			    Preamble

  The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.

  This license, the Library General Public License, applies to some
specially designated Free Software Foundation software, and to any
other libraries whose authors decide to use it.  You can use it for
your libraries, too.

  When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.

  To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if
you distribute copies of the library, or if you modify it.

  For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you.  You must make sure that they, too, receive or can get the source
code.  If you link a program with the library, you must provide
complete object files to the recipients so that they can relink them
with the library, after making changes to the library and recompiling
it.  And you must show them these terms so they know their rights.

  Our method of protecting your rights has two steps: (1) copyright
the library, and (2) offer you this license which gives you legal
permission to copy, distribute and/or modify the library.

  Also, for each distributor's protection, we want to make certain
that everyone understands that there is no warranty for this free
library.  If the library is modified by someone else and passed on, we
want its recipients to know that what they have is not the original
version, so that any problems introduced by others will not reflect on
the original authors' reputations.

  Finally, any free program is threatened constantly by software
patents.  We wish to avoid the danger that companies distributing free
software will individually obtain patent licenses, thus in effect
transforming the program into proprietary software.  To prevent this,
we have made it clear that any patent must be licensed for everyone's
free use or not licensed at all.

  Most GNU software, including some libraries, is covered by the ordinary
GNU General Public License, which was designed for utility programs.  This
license, the GNU Library General Public License, applies to certain
designated libraries.  This license is quite different from the ordinary
one; be sure to read it in full, and don't assume that anything in it is
the same as in the ordinary license.

  The reason we have a separate public license for some libraries is that
they blur the distinction we usually make between modifying or adding to a
program and simply using it.  Linking a program with a library, without
changing the library, is in some sense simply using the library, and is
analogous to running a utility program or application program.  However, in
a textual and legal sense, the linked executable is a combined work, a
derivative of the original library, and the ordinary General Public License
treats it as such.

  Because of this blurred distinction, using the ordinary General
Public License for libraries did not effectively promote software
sharing, because most developers did not use the libraries.  We
concluded that weaker conditions might promote sharing better.

  However, unrestricted linking of non-free programs would deprive the
users of those programs of all benefit from the free status of the
libraries themselves.  This Library General Public License is intended to
permit developers of non-free programs to use free libraries, while
preserving your freedom as a user of such programs to change the free
libraries that are incorporated in them.  (We have not seen how to achieve
this as regards changes in header files, but we have achieved it as regards
changes in the actual functions of the Library.)  The hope is that this
will lead to faster development of free libraries.

  The precise terms and conditions for copying, distribution and
modification follow.  Pay close attention to the difference between a
"work based on the library" and a "work that uses the library".  The
former contains code derived from the library, while the latter only
works together with the library.

  Note that it is possible for a library to be covered by the ordinary
General Public License rather than by this special one.

		  GNU LIBRARY GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

  0. This License Agreement applies to any software library which
contains a notice placed by the copyright holder or other authorized
party saying it may be distributed under the terms of this Library
General Public License (also called "this License").  Each licensee is
addressed as "you".

  A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.

  The "Library", below, refers to any such software library or work
which has been distributed under these terms.  A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language.  (Hereinafter, translation is
included without limitation in the term "modification".)

  "Source code" for a work means the preferred form of the work for
making modifications to it.  For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.

  Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it).  Whether that is true depends on what the Library does
and what the program that uses the Library does.
  
  1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.

  You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.

  2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

    a) The modified work must itself be a software library.

    b) You must cause the files modified to carry prominent notices
    stating that you changed the files and the date of any change.

    c) You must cause the whole of the work to be licensed at no
    charge to all third parties under the terms of this License.

    d) If a facility in the modified Library refers to a function or a
    table of data to be supplied by an application program that uses
    the facility, other than as an argument passed when the facility
    is invoked, then you must make a good faith effort to ensure that,
    in the event an application does not supply such function or
    table, the facility still operates, and performs whatever part of
    its purpose remains meaningful.

    (For example, a function in a library to compute square roots has
    a purpose that is entirely well-defined independent of the
    application.  Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must
    be optional: if the application does not supply it, the square
    root function must still compute square roots.)

These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works.  But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.

Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.

In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.

  3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library.  To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License.  (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.)  Do not make any other change in
these notices.

  Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.

  This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.

  4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.

  If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.

  5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library".  Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.

  However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library".  The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.

  When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library.  The
threshold for this to be true is not precisely defined by law.

  If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work.  (Executables containing this object code plus portions of the
Library will still fall under Section 6.)

  Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.

  6. As an exception to the Sections above, you may also compile or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.

  You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License.  You must supply a copy of this License.  If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License.  Also, you must do one
of these things:

    a) Accompany the work with the complete corresponding
    machine-readable source code for the Library including whatever
    changes were used in the work (which must be distributed under
    Sections 1 and 2 above); and, if the work is an executable linked
    with the Library, with the complete machine-readable "work that
    uses the Library", as object code and/or source code, so that the
    user can modify the Library and then relink to produce a modified
    executable containing the modified Library.  (It is understood
    that the user who changes the contents of definitions files in the
    Library will not necessarily be able to recompile the application
    to use the modified definitions.)

    b) Accompany the work with a written offer, valid for at
    least three years, to give the same user the materials
    specified in Subsection 6a, above, for a charge no more
    than the cost of performing this distribution.

    c) If distribution of the work is made by offering access to copy
    from a designated place, offer equivalent access to copy the above
    specified materials from the same place.

    d) Verify that the user has already received a copy of these
    materials or that you have already sent this user a copy.

  For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it.  However, as a special exception,
the source code distributed need not include anything that is normally
distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.

  It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system.  Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.

  7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:

    a) Accompany the combined library with a copy of the same work
    based on the Library, uncombined with any other library
    facilities.  This must be distributed under the terms of the
    Sections above.

    b) Give prominent notice with the combined library of the fact
    that part of it is a work based on the Library, and explaining
    where to find the accompanying uncombined form of the same work.

  8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License.  Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License.  However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.

  9. You are not required to accept this License, since you have not
signed it.  However, nothing else grants you permission to modify or
distribute the Library or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.

  10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions.  You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.

  11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all.  For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.

If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.

It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.

This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.

  12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded.  In such case, this License incorporates the limitation as if
written in the body of this License.

  13. The Free Software Foundation may publish revised and/or new
versions of the Library General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.

Each version is given a distinguishing version number.  If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation.  If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.

  14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission.  For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this.  Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.

			    NO WARRANTY

  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.

		     END OF TERMS AND CONDITIONS

--- NEW FILE: openil_license.txt ---
		  GNU LESSER GENERAL PUBLIC LICENSE
		       Version 2.1, February 1999

 Copyright (C) 1991, 1999 Free Software Foundation, Inc.
     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

[This is the first released version of the Lesser GPL.  It also counts
 as the successor of the GNU Library Public License, version 2, hence
 the version number 2.1.]

			    Preamble

  The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.

  This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it.  You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.

  When we speak of free software, we are referring to freedom of use,
not price.  Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.

  To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights.  These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.

  For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you.  You must make sure that they, too, receive or can get the source
code.  If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it.  And you must show them these terms so they know their rights.

  We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.

  To protect each distributor, we want to make it very clear that
there is no warranty for the free library.  Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.

  Finally, software patents pose a constant threat to the existence of
any free program.  We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder.  Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.

  Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License.  This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License.  We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.

  When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library.  The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom.  The Lesser General
Public License permits more lax criteria for linking other code with
the library.

  We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License.  It also provides other free software developers Less
of an advantage over competing non-free programs.  These disadvantages
are the reason we use the ordinary General Public License for many
libraries.  However, the Lesser license provides advantages in certain
special circumstances.

  For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard.  To achieve this, non-free programs must be
allowed to use the library.  A more frequent case is that a free
library does the same job as widely used non-free libraries.  In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.

  In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software.  For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.

  Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.

  The precise terms and conditions for copying, distribution and
modification follow.  Pay close attention to the difference between a
"work based on the library" and a "work that uses the library".  The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.

		  GNU LESSER GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

  0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".

  A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.

  The "Library", below, refers to any such software library or work
which has been distributed under these terms.  A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language.  (Hereinafter, translation is
included without limitation in the term "modification".)

  "Source code" for a work means the preferred form of the work for
making modifications to it.  For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.

  Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it).  Whether that is true depends on what the Library does
and what the program that uses the Library does.
  
  1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.

  You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.

  2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

    a) The modified work must itself be a software library.

    b) You must cause the files modified to carry prominent notices
    stating that you changed the files and the date of any change.

    c) You must cause the whole of the work to be licensed at no
    charge to all third parties under the terms of this License.

    d) If a facility in the modified Library refers to a function or a
    table of data to be supplied by an application program that uses
    the facility, other than as an argument passed when the facility
    is invoked, then you must make a good faith effort to ensure that,
    in the event an application does not supply such function or
    table, the facility still operates, and performs whatever part of
    its purpose remains meaningful.

    (For example, a function in a library to compute square roots has
    a purpose that is entirely well-defined independent of the
    application.  Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must
    be optional: if the application does not supply it, the square
    root function must still compute square roots.)

These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works.  But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.

Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.

In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.

  3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library.  To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License.  (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.)  Do not make any other change in
these notices.

  Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.

  This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.

  4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.

  If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.

  5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library".  Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.

  However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library".  The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.

  When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library.  The
threshold for this to be true is not precisely defined by law.

  If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work.  (Executables containing this object code plus portions of the
Library will still fall under Section 6.)

  Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.

  6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.

  You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License.  You must supply a copy of this License.  If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License.  Also, you must do one
of these things:

    a) Accompany the work with the complete corresponding
    machine-readable source code for the Library including whatever
    changes were used in the work (which must be distributed under
    Sections 1 and 2 above); and, if the work is an executable linked
    with the Library, with the complete machine-readable "work that
    uses the Library", as object code and/or source code, so that the
    user can modify the Library and then relink to produce a modified
    executable containing the modified Library.  (It is understood
    that the user who changes the contents of definitions files in the
    Library will not necessarily be able to recompile the application
    to use the modified definitions.)

    b) Use a suitable shared library mechanism for linking with the
    Library.  A suitable mechanism is one that (1) uses at run time a
    copy of the library already present on the user's computer system,
    rather than copying library functions into the executable, and (2)
    will operate properly with a modified version of the library, if
    the user installs one, as long as the modified version is
    interface-compatible with the version that the work was made with.

    c) Accompany the work with a written offer, valid for at
    least three years, to give the same user the materials
    specified in Subsection 6a, above, for a charge no more
    than the cost of performing this distribution.

    d) If distribution of the work is made by offering access to copy
    from a designated place, offer equivalent access to copy the above
    specified materials from the same place.

    e) Verify that the user has already received a copy of these
    materials or that you have already sent this user a copy.

  For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it.  However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.

  It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system.  Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.

  7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:

    a) Accompany the combined library with a copy of the same work
    based on the Library, uncombined with any other library
    facilities.  This must be distributed under the terms of the
    Sections above.

    b) Give prominent notice with the combined library of the fact
    that part of it is a work based on the Library, and explaining
    where to find the accompanying uncombined form of the same work.

  8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License.  Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License.  However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.

  9. You are not required to accept this License, since you have not
signed it.  However, nothing else grants you permission to modify or
distribute the Library or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.

  10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions.  You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.

  11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all.  For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.

If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.

It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.

This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.

  12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded.  In such case, this License incorporates the limitation as if
written in the body of this License.

  13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.

Each version is given a distinguishing version number.  If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation.  If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.

  14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission.  For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this.  Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.

			    NO WARRANTY

  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.

		     END OF TERMS AND CONDITIONS

           How to Apply These Terms to Your New Libraries

  If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change.  You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).

  To apply these terms, attach the following notices to the library.  It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.

    <one line to give the library's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

Also add information on how to contact you by electronic and paper mail.

You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary.  Here is a sample; alter the names:

  Yoyodyne, Inc., hereby disclaims all copyright interest in the
  library `Frob' (a library for tweaking knobs) written by James Random Hacker.

  <signature of Ty Coon>, 1 April 1990
  Ty Coon, President of Vice

That's all there is to it!

Update of /cvsroot/java-game-lib/LWJGL/doc
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv4409

Modified Files:
	CREDITS 
Log Message:
added comment about 3rd party library usage and dependency

Index: CREDITS
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/doc/CREDITS,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -d -r1.5 -r1.6
--- CREDITS	27 Oct 2004 17:00:23 -0000	1.5
+++ CREDITS	29 Jun 2005 20:16:11 -0000	1.6
@@ -15,4 +15,15 @@
  
 additional credits goes to:
  - Joseph I. Valenzuela [OpenAL stuff]
- - Lev Povalahev [OpenGL Extensions]
\ No newline at end of file
+ - Lev Povalahev [OpenGL Extensions]
+
+The LWJGL project includes files from or depends on the following projects:
+ - OpenGL, SGI - http://opengl.org/
+ - OpenAL, Creative Labs - http://openal.org/
+ - FMOD, Firelight Technologies - http://fmod.org
+ - DevIL, <no company> - http://openil.sourceforge.net/
+ - jinput, Sun - https://jinput.dev.java.net/
+
+Please see the /doc/3rdparty/ directory for licenses.
+
+All trademarks and registered trademarks are the property of their respective owners.
\ No newline at end of file

Update of /cvsroot/java-game-lib/LWJGL/doc/3rdparty
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv3646/3rdparty

Log Message:
Directory /cvsroot/java-game-lib/LWJGL/doc/3rdparty added to the repository

Update of /cvsroot/java-game-lib/LWJGL
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv3088

Modified Files:
	build.xml 
Log Message:
Initial controller input checkin. Updates to add classpath to javac task for building input.

Index: build.xml
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/build.xml,v
retrieving revision 1.82
retrieving revision 1.83
diff -u -d -r1.82 -r1.83
--- build.xml	5 Jun 2005 12:12:34 -0000	1.82
+++ build.xml	29 Jun 2005 20:13:10 -0000	1.83
@@ -319,7 +319,7 @@
 	<!-- Compiles the Java source code -->
 	<target name="compile" description="Compiles the java source code">
 		<javac debug="yes" srcdir="${lwjgl.src}/java/" destdir="${lwjgl.bin}" includes="org/lwjgl/*.java" source="1.4" target="1.4" taskname="lwjgl" />
-		<javac debug="yes" srcdir="${lwjgl.src}/java/" destdir="${lwjgl.bin}" includes="org/lwjgl/input/**" source="1.4" target="1.4" taskname="input" />
+		<javac debug="yes" srcdir="${lwjgl.src}/java/" destdir="${lwjgl.bin}" includes="org/lwjgl/input/**" source="1.4" target="1.4" classpath="${lwjgl.lib}/jinput.jar" taskname="input" />
 		<javac debug="yes" srcdir="${lwjgl.src}/java/" destdir="${lwjgl.bin}" includes="org/lwjgl/openal/**" source="1.4" target="1.4" taskname="openal" />
 		<javac debug="yes" srcdir="${lwjgl.src}/java/" destdir="${lwjgl.bin}" includes="org/lwjgl/opengl/**" source="1.4" target="1.4" taskname="opengl" />
 		<javac debug="yes" srcdir="${lwjgl.src}/java/" destdir="${lwjgl.bin}" includes="org/lwjgl/test/**" source="1.4" target="1.4" taskname="test" />

Update of /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/test/input
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv2126/src/java/org/lwjgl/test/input

Added Files:
	TestControllers.java 
Log Message:
Initial controller input checkin. Source for the wrapper round JInput including the test tool.

--- NEW FILE: TestControllers.java ---
package org.lwjgl.test.input;

import java.awt.Dimension;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextField;

import org.lwjgl.input.Controller;
import org.lwjgl.input.Controllers;

/**
 * Oops. Forgot to document this one.
 * 
 * @author Kevin Glass
 */
public class TestControllers extends JPanel {
	public static int total = 0;
	
	private JTextField[] values;
	private JTextField[] names;
	private Controller controller;
	private int buttonCount;
	private int itemCount;
	
	public TestControllers(int index) {
		controller = Controllers.getController(index);
		setLayout(null);
		
		buttonCount = controller.getButtonCount();
		itemCount = controller.getButtonCount() + controller.getAxisCount() + 2;
		values = new JTextField[itemCount];
		names = new JTextField[itemCount];
		
		for (int i=0;i<controller.getButtonCount();i++) {
			names[i] = new JTextField();
			names[i].setEditable(false);
			names[i].setBounds(0,i*30,100,30);
			names[i].setText(controller.getButtonName(i));
			add(names[i]);
			values[i] = new JTextField();
			values[i].setEditable(false);
			values[i].setBounds(100,i*30,100,30);
			add(values[i]);
		}
		for (int i=buttonCount;i<buttonCount+controller.getAxisCount();i++) {
			names[i] = new JTextField();
			names[i].setEditable(false);
			names[i].setBounds(0,i*30,100,30);
			names[i].setText(controller.getAxisName(i-buttonCount));
			add(names[i]);
			values[i] = new JTextField();
			values[i].setEditable(false);
			values[i].setBounds(100,i*30,100,30);
			add(values[i]);
		}
		
		int i = itemCount - 2;
		names[i] = new JTextField();
		names[i].setEditable(false);
		names[i].setBounds(0,i*30,100,30);
		names[i].setText("POV X");
		add(names[i]);
		values[i] = new JTextField();
		values[i].setEditable(false);
		values[i].setBounds(100,i*30,100,30);
		add(values[i]);

		i = itemCount - 1;
		names[i] = new JTextField();
		names[i].setEditable(false);
		names[i].setBounds(0,i*30,100,30);
		names[i].setText("POV Y");
		add(names[i]);
		values[i] = new JTextField();
		values[i].setEditable(false);
		values[i].setBounds(100,i*30,100,30);
		add(values[i]);
		
		total++;
		
		setPreferredSize(new Dimension(200,30*itemCount));
		JFrame frame = new JFrame(controller.getName());
		frame.setContentPane(new JScrollPane(this));
		frame.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				total--;
				if (total == 0) {
					System.exit(0);
				}
			}
		});
		frame.setSize(230,400);
		frame.setLocation(index*30,index*30);
		frame.setVisible(true);
		
		Thread t = new Thread() {
			public void run() {
				while (true) {
					try { Thread.sleep(100); } catch (Exception e) {};
					pollAndUpdate();
				}
			}
		};
		t.start();
	}
	
	public void pollAndUpdate() {
		Controllers.poll();
		
		for (int i=0;i<controller.getButtonCount();i++) {
			values[i].setText(""+controller.isButtonPressed(i));
		}
		for (int i=buttonCount;i<buttonCount+controller.getAxisCount();i++) {
			values[i].setText(""+controller.getAxisValue(i-buttonCount));
		}
		
		values[itemCount-2].setText(""+controller.getPovX());
		values[itemCount-1].setText(""+controller.getPovY());
		
		while (Controllers.next()) {
			System.out.println("Event Fired: ");
			System.out.println("\t"+Controllers.getEventSource()+":"+Controllers.getEventControlIndex()+":"+Controllers.isEventButton());
			System.out.println("\t"+Controllers.isEventXAxis()+":"+Controllers.isEventYAxis());
		}
	}
	
	public static void main(String[] argv) {
		try {
			Controllers.create();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(0);
		}
		
		int count = Controllers.getControllerCount();
		System.out.println(count+" Controllers Found");
		for (int i=0;i<count;i++) {
			Controller controller = Controllers.getController(i);
			System.out.println(controller.getName());
		}
		
		if (count == 0) {
			System.exit(0);
		}
		
		for (int i=0;i<count;i++) {
			new TestControllers(i);
		}
	}
}

Update of /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/input
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv2126/src/java/org/lwjgl/input

Added Files:
	Controller.java JInputController.java Controllers.java 
	ControllerEvent.java 
Log Message:
Initial controller input checkin. Source for the wrapper round JInput including the test tool.

--- NEW FILE: JInputController.java ---
package org.lwjgl.input;

import java.util.ArrayList;

import net.java.games.input.Component;

/**
 * A wrapper round a JInput controller that attempts to make the interface
 * more useable.
 * 
 * @author Kevin Glass
 */
public class JInputController implements Controller {
	/** The JInput controller this class is wrapping */
	private net.java.games.input.Controller target;
	/** The index that has been assigned to this controller */
	private int index;
	/** The Buttons that have been detected on the JInput controller */
	private ArrayList buttons = new ArrayList();
	/** The Axes that have been detected on the JInput controller */
	private ArrayList axes = new ArrayList();
	/** The POVs that have been detected on the JInput controller */
	private ArrayList pov = new ArrayList();
	/** The state of the buttons last check */
	private boolean[] buttonState;
	/** The values that were read from the pov last check */
	private float[] povValues;
	/** The values that were read from the axes last check */
	private float[] axesValue;
	/** The maximum values read for each axis */
	private float[] axesMax;
	/** The dead zones for each axis */
	private float[] deadZones;
	/** The index of the X axis or -1 if no X axis is defined */
	private int xaxis = -1;
	/** The index of the Y axis or -1 if no Y axis is defined */
	private int yaxis = -1;
	/** The index of the X axis or -1 if no Z axis is defined */
	private int zaxis = -1;
	/** The index of the RX axis or -1 if no RX axis is defined */
	private int rxaxis = -1;
	/** The index of the RY axis or -1 if no RY axis is defined */
	private int ryaxis = -1;
	/** The index of the RZ axis or -1 if no RZ axis is defined */
	private int rzaxis = -1;
	
	/**
	 * Create a new controller that wraps round a JInput controller and hopefully
	 * makes it easier to use.
	 * 
	 * @param index The index this controller has been assigned to
	 * @param target The target JInput controller this class is wrapping
	 */
	public JInputController(int index,net.java.games.input.Controller target) {
		this.target = target;
		this.index = index;
		
		Component[] sourceAxes = target.getComponents();
		
		for (int i=0;i<sourceAxes.length;i++) {
			if (sourceAxes[i].getIdentifier() instanceof Component.Identifier.Button) {
				buttons.add(sourceAxes[i]);		
			} else if (sourceAxes[i].getIdentifier().equals(Component.Identifier.Axis.POV)) {
				pov.add(sourceAxes[i]);
			} else {
				axes.add(sourceAxes[i]);
			}
		}
		
		buttonState = new boolean[buttons.size()];
		povValues = new float[pov.size()];
		axesValue = new float[axes.size()];
		int buttonsCount = 0;
		int axesCount = 0;
		
		// initialise the state
		for (int i=0;i<sourceAxes.length;i++) {
			if (sourceAxes[i].getIdentifier() instanceof Component.Identifier.Button) {
				buttonState[buttonsCount] = sourceAxes[i].getPollData() != 0;
				buttonsCount++;
			} else if (sourceAxes[i].getIdentifier().equals(Component.Identifier.Axis.POV)) {
				// no account for POV yet
				// pov.add(sourceAxes[i]);
			} else {
				axesValue[axesCount] = sourceAxes[i].getPollData();
				if (sourceAxes[i].getIdentifier().equals(Component.Identifier.Axis.X)) {
					xaxis = axesCount;
				}
				if (sourceAxes[i].getIdentifier().equals(Component.Identifier.Axis.Y)) {
					yaxis = axesCount;
				}
				if (sourceAxes[i].getIdentifier().equals(Component.Identifier.Axis.Z)) {
					zaxis = axesCount;
				}
				if (sourceAxes[i].getIdentifier().equals(Component.Identifier.Axis.RX)) {
					rxaxis = axesCount;
				}
				if (sourceAxes[i].getIdentifier().equals(Component.Identifier.Axis.RY)) {
					ryaxis = axesCount;
				}
				if (sourceAxes[i].getIdentifier().equals(Component.Identifier.Axis.RZ)) {
					rzaxis = axesCount;
				}
				
				axesCount++;
			}
		}
		
		axesMax = new float[axes.size()];
		deadZones = new float[axes.size()];
		
		for (int i=0;i<axesMax.length;i++) {
			axesMax[i] = 1.0f;
			deadZones[i] = 0.05f;
		}
	}

	/*
	 * @see org.lwjgl.input.Controller#getName()
	 */
	public String getName() {
		String name = target.getName();
		return name.substring(0,name.length()/2);
	}

	/*
	 * @see org.lwjgl.input.Controller#getIndex()
	 */
	public int getIndex() {
		return index;
	}

	/*
	 * @see org.lwjgl.input.Controller#getButtonCount()
	 */
	public int getButtonCount() {
		return buttons.size();
	}

	/*
	 * @see org.lwjgl.input.Controller#getButtonName(int)
	 */
	public String getButtonName(int index) {
		Component button = (Component) buttons.get(index);
		
		return button.getName();
	}

	/*
	 * @see org.lwjgl.input.Controller#isButtonPressed(int)
	 */
	public boolean isButtonPressed(int index) {
		return buttonState[index];
	}

	/*
	 * @see org.lwjgl.input.Controller#poll()
	 */
	public void poll() {
		target.poll();
		
		// read buttons to update events
		for (int i=0;i<getButtonCount();i++) {
			Component button = (Component) buttons.get(i);
			
			float data = button.getPollData();

			if (buttonState[i] != (data != 0)) {
				// fire button pressed event
				Controllers.addEvent(new ControllerEvent(this,ControllerEvent.BUTTON,i,false,false));
			}
			
			buttonState[i] = data != 0;
		}

		// read povs to update events
		for (int i=0;i<pov.size();i++) {
			Component p = (Component) pov.get(i);
			
			float data = p.getPollData();

			if (povValues[i] != data) {
				float prevX = getPovX();
				float prevY = getPovY();
				
				povValues[i] = data;
				
				if (prevX != getPovX()) {
					Controllers.addEvent(new ControllerEvent(this,ControllerEvent.POVX,0,false,false));
				}
				if (prevY != getPovY()) {
					Controllers.addEvent(new ControllerEvent(this,ControllerEvent.POVY,0,false,false));
				}
			}
			
			povValues[i] = data;
		}
		
		// read axis to update events
		for (int i=0;i<getAxisCount();i++) {
			Component axis = (Component) axes.get(i);
			
			float value = axis.getPollData();
			
			// fixed dead zone since most axis don't report it :(
			if (Math.abs(value) < deadZones[i]) {
				value = 0;
			}
			if (Math.abs(value) < axis.getDeadZone()) {
				value = 0;
			}
			if (Math.abs(value) > axesMax[i]) {
				axesMax[i] = Math.abs(value);
			}
			
			// normalize the value based on maximum value read in the past
			value /= axesMax[i];
			
			if (axesValue[i] != value) {
				// fire event
				Controllers.addEvent(new ControllerEvent(this,ControllerEvent.AXIS,i,i == xaxis,i == yaxis));
			}
			axesValue[i] = value;
		}
	}

	/*
	 * @see org.lwjgl.input.Controller#getAxisCount()
	 */
	public int getAxisCount() {
		return axes.size();
	}

	/*
	 * @see org.lwjgl.input.Controller#getAxisName(int)
	 */
	public String getAxisName(int index) {
		Component axis = (Component) axes.get(index);
		
		return axis.getName();
	}

	/*
	 * @see org.lwjgl.input.Controller#getAxisValue(int)
	 */
	public float getAxisValue(int index) {
		return axesValue[index];
	}

	/*
	 * @see org.lwjgl.input.Controller#getXAxisValue()
	 */
	public float getXAxisValue() {
		if (xaxis == -1) {
			return 0;
		}
		
		return getAxisValue(xaxis);
	}

	/*
	 * @see org.lwjgl.input.Controller#getYAxisValue()
	 */
	public float getYAxisValue() {
		if (yaxis == -1) {
			return 0;
		}
		
		return getAxisValue(yaxis);
	}

	/*
	 * @see org.lwjgl.input.Controller#getXAxisDeadZone()
	 */
	public float getXAxisDeadZone() {
		if (xaxis == -1) {
			return 0;
		}
		
		return getDeadZone(xaxis);
	}

	/*
	 * @see org.lwjgl.input.Controller#getYAxisDeadZone()
	 */
	public float getYAxisDeadZone() {
		if (yaxis == -1) {
			return 0;
		}
		
		return getDeadZone(yaxis);
	}

	/*
	 * @see org.lwjgl.input.Controller#setXAxisDeadZone(float)
	 */
	public void setXAxisDeadZone(float zone) {
		setDeadZone(xaxis,zone);
	}

	/*
	 * @see org.lwjgl.input.Controller#setYAxisDeadZone(float)
	 */
	public void setYAxisDeadZone(float zone) {
		setDeadZone(yaxis,zone);
	}

	/*
	 * @see org.lwjgl.input.Controller#getDeadZone(int)
	 */
	public float getDeadZone(int index) {
		return deadZones[index];
	}

	/*
	 * @see org.lwjgl.input.Controller#setDeadZone(int, float)
	 */
	public void setDeadZone(int index, float zone) {
		deadZones[index] = zone;
	}

	/*
	 * @see org.lwjgl.input.Controller#getZAxisValue()
	 */
	public float getZAxisValue() {
		if (zaxis == -1) {
			return 0;
		}
		
		return getAxisValue(zaxis);
	}

	/*
	 * @see org.lwjgl.input.Controller#getZAxisDeadZone()
	 */
	public float getZAxisDeadZone() {
		if (zaxis == -1) {
			return 0;
		}
		
		return getDeadZone(zaxis);
	}

	/*
	 * @see org.lwjgl.input.Controller#setZAxisDeadZone(float)
	 */
	public void setZAxisDeadZone(float zone) {
		setDeadZone(zaxis,zone);
	}

	/*
	 * @see org.lwjgl.input.Controller#getRXAxisValue()
	 */
	public float getRXAxisValue() {
		if (rxaxis == -1) {
			return 0;
		}
		
		return getAxisValue(rxaxis);
	}

	/*
	 * @see org.lwjgl.input.Controller#getRXAxisDeadZone()
	 */
	public float getRXAxisDeadZone() {
		if (rxaxis == -1) {
			return 0;
		}
		
		return getDeadZone(rxaxis);
	}

	/*
	 * @see org.lwjgl.input.Controller#setRXAxisDeadZone(float)
	 */
	public void setRXAxisDeadZone(float zone) {
		setDeadZone(rxaxis,zone);
	}

	/*
	 * @see org.lwjgl.input.Controller#getRYAxisValue()
	 */
	public float getRYAxisValue() {
		if (ryaxis == -1) {
			return 0;
		}
		
		return getAxisValue(ryaxis);
	}

	/*
	 * @see org.lwjgl.input.Controller#getRYAxisDeadZone()
	 */
	public float getRYAxisDeadZone() {
		if (ryaxis == -1) {
			return 0;
		}
		
		return getDeadZone(ryaxis);
	}

	/*
	 * @see org.lwjgl.input.Controller#setRYAxisDeadZone(float)
	 */
	public void setRYAxisDeadZone(float zone) {
		setDeadZone(ryaxis,zone);
	}

	/*
	 * @see org.lwjgl.input.Controller#getRZAxisValue()
	 */
	public float getRZAxisValue() {
		if (rzaxis == -1) {
			return 0;
		}
		
		return getAxisValue(rzaxis);
	}

	/*
	 * @see org.lwjgl.input.Controller#getRZAxisDeadZone()
	 */
	public float getRZAxisDeadZone() {
		if (rzaxis == -1) {
			return 0;
		}
		
		return getDeadZone(rzaxis);
	}

	/*
	 * @see org.lwjgl.input.Controller#setRZAxisDeadZone(float)
	 */
	public void setRZAxisDeadZone(float zone) {
		setDeadZone(rzaxis,zone);
	}

	/*
	 * @see org.lwjgl.input.Controller#getPovX()
	 */
	public float getPovX() {
		if (pov.size() == 0) {
			return 0;
		}
		
		float value = povValues[0];
		
		if ((value == Component.POV.DOWN_LEFT) || 
		    (value == Component.POV.UP_LEFT) ||
		    (value == Component.POV.LEFT)) {
			return -1;
		}
		if ((value == Component.POV.DOWN_RIGHT) || 
		    (value == Component.POV.UP_RIGHT) ||
		    (value == Component.POV.RIGHT)) {
			return 1;
		}
		
		return 0;
	}

	/*
	 * @see org.lwjgl.input.Controller#getPovY()
	 */
	public float getPovY() {
		if (pov.size() == 0) {
			return 0;
		}
		
		float value = povValues[0];
		
		if ((value == Component.POV.DOWN_LEFT) || 
		    (value == Component.POV.DOWN_RIGHT) ||
		    (value == Component.POV.DOWN)) {
			return 1;
		}
		if ((value == Component.POV.UP_LEFT) || 
		    (value == Component.POV.UP_RIGHT) ||
		    (value == Component.POV.UP)) {
			return -1;
		}
		
		return 0;
	}
	
	
}

--- NEW FILE: ControllerEvent.java ---
package org.lwjgl.input;

/**
 * An event occuring on a controller.
 * 
 * @author Kevin Glass
 */
public class ControllerEvent {
	/** Indicates the event was caused by a button */
	public static final int BUTTON = 1;
	/** Indicates the event was caused by a axis */
	public static final int AXIS = 2;
	/** Indicates the event was caused by a pov X */
	public static final int POVX = 3;
	/** Indicates the event was caused by a pov Y */
	public static final int POVY = 4;
	
	/** The controller generating the event */
	private Controller source;
	/** The index of the input (axis or button) that generated the event */
	private int index;
	/** Type of control that generated the event */
	private int type;
	/** True if this event was caused by the x axis */
	private boolean xaxis;
	/** True if this event was caused by the y axis */
	private boolean yaxis;
	
	/**
	 * Create a new event
	 * 
	 * @param source The source of the event
	 * @param type The type of control generating this event
	 * @param index The index of the input that generated the event
	 * @param xaxis True if this event was caused by the x-axis
	 * @param yaxis True if this event was caused by the y-axis
	 */
	public ControllerEvent(Controller source,int type,int index,boolean xaxis,boolean yaxis) {
		this.source = source;
		this.type = type;
		this.index = index;
		this.xaxis = xaxis;
		this.yaxis = yaxis;
	}
	
	/**
	 * Get the controller that generated this event
	 * 
	 * @return The controller that generated this event
	 */
	public Controller getSource() {
		return source;
	}
	
	/**
	 * Get the index of the control generating this event
	 * 
	 * @return The index of the control generating this event
	 */
	public int getControlIndex() {
		return index;
	}
	
	/**
	 * Check if this event was generated by a button
	 * 
	 * @return True if this event was generated by a button
	 */
	public boolean isButton() {
		return type == BUTTON;
	}

	/**
	 * Check if this event was generated by a axis
	 * 
	 * @return True if this event was generated by a axis
	 */
	public boolean isAxis() {
		return type == AXIS;
	}

	/**
	 * Check if this event was generated by a pov
	 * 
	 * @return True if this event was generated by a pov
	 */
	public boolean isPovY() {
		return type == POVY;
	}
	/**
	 * 
	 * Check if this event was generated by a pov
	 * 
	 * @return True if this event was generated by a pov
	 */
	public boolean isPovX() {
		return type == POVX;
	}
	
	/**
	 * Check if this event was caused by the X axis
	 * 
	 * @return True if this event was caused by the X axis
	 */
	public boolean isXAxis() {
		return xaxis;
	}

	/**
	 * Check if this event was caused by the Y axis
	 * 
	 * @return True if this event was caused by the Y axis
	 */
	public boolean isYAxis() {
		return yaxis;
	}
	
	/*
	 * @see java.lang.Object#toString()
	 */
	public String toString() {
		return "["+source+" type="+type+" xaxis="+xaxis+" yaxis="+yaxis+"]";
	}
}

--- NEW FILE: Controller.java ---
package org.lwjgl.input;

/**
 * A game controller of some sort that will provide input. The controller
 * presents buttons and axes. Buttons are either pressed or not pressed. Axis
 * provide analogue values.
 * 
 * @author Kevin Glass
 */
public interface Controller {
	/**
	 * Get the name assigned to this controller.
	 * 
	 * @return The name assigned to this controller
	 */
	public String getName();

	/**
	 * Get the index of this controller in the collection
	 * 
	 * @return The index of this controller in the collection
	 */
	public int getIndex();
	
	/**
	 * Retrieve the number of buttons available on this controller
	 * 
	 * @return The number of butotns available on this controller
	 */
	public int getButtonCount();
	
	/**
	 * Get the name of the specified button. Be warned, often this is 
	 * as exciting as "Button X"
	 * 
	 * @param index The index of the button whose name should be retrieved
	 * @return The name of the button requested
	 */
	public String getButtonName(int index);
	
	/**
	 * Check if a button is currently pressed
	 * 
	 * @param index The button to check
	 * @return True if the button is currently pressed
	 */
	public boolean isButtonPressed(int index);
	
	/**
	 * Poll the controller for new data. This will also update
	 * events
	 */
	public void poll();
	
	/** 
	 * Get the X-Axis value of the POV on this controller
	 * 
	 * @return The X-Axis value of the POV on this controller
	 */
	public float getPovX();
	
	/** 
	 * Get the Y-Axis value of the POV on this controller
	 * 
	 * @return The Y-Axis value of the POV on this controller
	 */
	public float getPovY();
	
	/**
	 * Get the dead zone for a specified axis
	 * 
	 * @param index The index of the axis for which to retrieve the dead zone
	 * @return The dead zone for the specified axis
	 */
	public float getDeadZone(int index);
	
	/**
	 * Set the dead zone for the specified axis
	 * 
	 * @param index The index of hte axis for which to set the dead zone
	 * @param zone The dead zone to use for the specified axis
	 */
	public void setDeadZone(int index,float zone);
	
	/**
	 * Retrieve the number of axes available on this controller. 
	 * 
	 * @return The number of axes available on this controller.
	 */
	public int getAxisCount();
	
	/**
	 * Get the name that's given to the specified axis
	 * 
	 * @param index The index of the axis whose name should be retrieved
	 * @return The name of the specified axis.
	 */
	public String getAxisName(int index);
	
	/**
	 * Retrieve the value thats currently available on a specified axis. The
	 * value will always be between 1.0 and -1.0 and will calibrate as values
	 * are passed read. It may be useful to get the player to wiggle the joystick
	 * from side to side to get the calibration right. 
	 * 
	 * @param index The index of axis to be read
	 * @return The value from the specified axis.
	 */
	public float getAxisValue(int index);
	
	/**
	 * Get the value from the X axis if there is one. If no X axis is 
	 * defined a zero value will be returned.
	 * 
	 * @return The value from the X axis
	 */
	public float getXAxisValue();
	
	/**
	 * Get the dead zone for the X axis.
	 * 
	 * @return The dead zone for the X axis
	 */
	public float getXAxisDeadZone();
	
	/**
	 * Set the dead zone for the X axis
	 * 
	 * @param zone The dead zone to use for the X axis
	 */
	public void setXAxisDeadZone(float zone);

	/**
	 * Get the value from the Y axis if there is one. If no Y axis is 
	 * defined a zero value will be returned.
	 * 
	 * @return The value from the Y axis
	 */
	public float getYAxisValue();
	
	/**
	 * Get the dead zone for the Y axis.
	 * 
	 * @return The dead zone for the Y axis
	 */
	public float getYAxisDeadZone();

	/**
	 * Set the dead zone for the Y axis
	 * 
	 * @param zone The dead zone to use for the Y axis
	 */
	public void setYAxisDeadZone(float zone);
	
	/**
	 * Get the value from the Z axis if there is one. If no Z axis is 
	 * defined a zero value will be returned.
	 * 
	 * @return The value from the Z axis
	 */
	public float getZAxisValue();
	
	/**
	 * Get the dead zone for the Z axis.
	 * 
	 * @return The dead zone for the Z axis
	 */
	public float getZAxisDeadZone();

	/**
	 * Set the dead zone for the Z axis
	 * 
	 * @param zone The dead zone to use for the Z axis
	 */
	public void setZAxisDeadZone(float zone);
	
	/**
	 * Get the value from the RX axis if there is one. If no RX axis is 
	 * defined a zero value will be returned.
	 * 
	 * @return The value from the RX axis
	 */
	public float getRXAxisValue();
	
	/**
	 * Get the dead zone for the RX axis.
	 * 
	 * @return The dead zone for the RX axis
	 */
	public float getRXAxisDeadZone();

	/**
	 * Set the dead zone for the RX axis
	 * 
	 * @param zone The dead zone to use for the RX axis
	 */
	public void setRXAxisDeadZone(float zone);
	
	/**
	 * Get the value from the RY axis if there is one. If no RY axis is 
	 * defined a zero value will be returned.
	 * 
	 * @return The value from the RY axis
	 */
	public float getRYAxisValue();
	
	/**
	 * Get the dead zone for the RY axis.
	 * 
	 * @return The dead zone for the RY axis
	 */
	public float getRYAxisDeadZone();

	/**
	 * Set the dead zone for the RY axis
	 * 
	 * @param zone The dead zone to use for the RY axis
	 */
	public void setRYAxisDeadZone(float zone);
	
	/**
	 * Get the value from the RZ axis if there is one. If no RZ axis is 
	 * defined a zero value will be returned.
	 * 
	 * @return The value from the RZ axis
	 */
	public float getRZAxisValue();
	
	/**
	 * Get the dead zone for the RZ axis.
	 * 
	 * @return The dead zone for the RZ axis
	 */
	public float getRZAxisDeadZone();

	/**
	 * Set the dead zone for the RZ axis
	 * 
	 * @param zone The dead zone to use for the RZ axis
	 */
	public void setRZAxisDeadZone(float zone);
}

--- NEW FILE: Controllers.java ---
package org.lwjgl.input;

import java.util.ArrayList;

import net.java.games.input.ControllerEnvironment;

import org.lwjgl.LWJGLException;

/**
 * The collection of controllers currently connected.
 * 
 * @author Kevin Glass
 */
public class Controllers {
	/** The name of the plugin used on windows */
	private static final String WINDOWS_PLUGIN = "net.java.games.input.DirectInputEnvironmentPlugin";
	/** The name of the plugin used on linux */
	private static final String LINUX_PLUGIN = "net.java.games.input.LinuxEnvironmentPlugin";
	/** The name of the plugin used on macos */
	private static final String MACOS_PLUGIN = "net.java.games.input.OSXEnvironmentPlugin";
	
	/** The controllers available */
	private static ArrayList controllers = new ArrayList();
	/** The number of controllers */
	private static int controllerCount;
	
	/** The current list of events */
	private static ArrayList events = new ArrayList();
	/** The current event */
	private static ControllerEvent event;
	
	/**
	 * Initialise the controllers collection
	 * 
	 * @throws LWJGLException Indicates a failure to initialise the controller library.
	 */
	public static void create() throws LWJGLException {
		try {
			String plugins = System.getProperty("jinput.plugins");
			
			if (plugins == null) {
				if (System.getProperty("os.name").startsWith("Win")) {
					System.setProperty("jinput.plugins",WINDOWS_PLUGIN);
				}
				if (System.getProperty("os.name").startsWith("Lin")) {
					System.setProperty("jinput.plugins",LINUX_PLUGIN);
				}
				if (System.getProperty("os.name").startsWith("Mac")) {
					System.setProperty("jinput.plugins",MACOS_PLUGIN);
				}
			}
			
			ControllerEnvironment env = ControllerEnvironment.getDefaultEnvironment();
			
			net.java.games.input.Controller[] found = env.getControllers();
			ArrayList lollers = new ArrayList();
			for (int i=0;i<found.length;i++) {
				net.java.games.input.Controller c = found[i];
	
				if ((!c.getType().equals(net.java.games.input.Controller.Type.KEYBOARD)) &&
					(!c.getType().equals(net.java.games.input.Controller.Type.MOUSE))) {
					lollers.add(c);
				}
			}
				
			int length = lollers.size();
			
			for (int i=0;i<length;i++) {
				net.java.games.input.Controller c = (net.java.games.input.Controller) lollers.get(i);
	
				createController(c);
			}
		} catch (Throwable e) {
			throw new LWJGLException("Failed to initialise controllers",e);
		}
	}
	
	/**
	 * Utility to create a controller based on its potential sub-controllers
	 * 
	 * @param c The controller to add
	 */
	private static void createController(net.java.games.input.Controller c) {
		net.java.games.input.Controller[] sub = c.getControllers();
		if (sub.length == 0) {
			JInputController controller = new JInputController(controllerCount,c);
			controllers.add(controller);
			controllerCount++;
		} else {
			for (int i=0;i<sub.length;i++) {
				createController(sub[i]);
			}
		}
	}
	
	/**
	 * Get a controller from the collection
	 * 
	 * @param index The index of the controller to retrieve
	 * @return The controller requested
	 */
	public static Controller getController(int index) {
		return (Controller) controllers.get(index);
	}
	
	/**
	 * Retrieve a count of the number of controllers
	 * 
	 * @return The number of controllers available
	 */
	public static int getControllerCount() {
		return controllers.size();
	}
	
	/**
	 * Poll the controllers available. This will both update their state
	 * and generate events that must be cleared.
	 */
	public static void poll() {
		for (int i=0;i<controllers.size();i++) {
			getController(i).poll();
		}
	}
	
	/**
	 * Clear any events stored for the controllers in this set
	 */
	public static void clearEvents() {
		events.clear();
	}
	
	/**
	 * Move to the next event that has been stored.
	 * 
	 * @return True if there is still an event to process
	 */
	public static boolean next() {
		if (events.size() == 0) {
			event = null;
			return false;
		}
		
		event = (ControllerEvent) events.remove(0);
		
		return event != null;
	}
	
	/**
	 * Get the source of the current event
	 * 
	 * @return The source of the current event
	 */
	public static Controller getEventSource() {
		return event.getSource();
	}
	
	/**
	 * Get the index of the control that caused the current event
	 * 
	 * @return The index of the control that cause the current event
	 */
	public static int getEventControlIndex() {
		return event.getControlIndex();
	}
	
	/**
	 * Check if the current event was caused by a button
	 * 
	 * @return True if the current event was caused by a button
	 */
	public static boolean isEventButton() {
		return event.isButton();
	}

	/**
	 * Check if the current event was caused by a axis
	 * 
	 * @return True if the current event was caused by a axis
	 */
	public static boolean isEventAxis() {
		return event.isAxis();
	}
	
	/**
	 * Check if the current event was caused by movement on the x-axis
	 * 
	 * @return True if the current event was cause by movement on the x-axis
	 */
	public static boolean isEventXAxis() {
		return event.isXAxis();
	}

	/**
	 * Check if the current event was caused by movement on the y-axis
	 * 
	 * @return True if the current event was caused by movement on the y-axis
	 */
	public static boolean isEventYAxis() {
		return event.isYAxis();
	}
	
	/**
	 * Check if the current event was cause by the POV x-axis
	 * 
	 * @return True if the current event was caused by the POV x-axis
	 */
	public static boolean isEventPovX() {
		return event.isPovX();
	}
	
	/**
	 * Check if the current event was cause by the POV x-axis
	 * 
	 * @return True if the current event was caused by the POV x-axis
	 */
	public static boolean isEventPovY() {
		return event.isPovY();
	}
	
	/**
	 * Add an event to the stack of events that have been caused
	 * 
	 * @param event The event to add to the list
	 */
	static void addEvent(ControllerEvent event) {
		if (event != null) {
			events.add(event);
		}
	}
}

Update of /cvsroot/java-game-lib/LWJGL/libs/linux
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv32504/libs/linux

Added Files:
	libjinput-linux.so 
Log Message:
Initial controller input checkin. JInput native for linux.

--- NEW FILE: libjinput-linux.so ---
(This appears to be a binary file; contents omitted.)

Update of /cvsroot/java-game-lib/LWJGL/libs/linux
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv32018/libs/linux

Log Message:
Directory /cvsroot/java-game-lib/LWJGL/libs/linux added to the repository

Update of /cvsroot/java-game-lib/LWJGL/libs/win32
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv30271/libs/win32

Added Files:
	jinput-dxplugin.dll 
Log Message:
Initial controller input checkin. JInput native for win32

--- NEW FILE: jinput-dxplugin.dll ---
(This appears to be a binary file; contents omitted.)

Update of /cvsroot/java-game-lib/LWJGL/libs/win32
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv30185/libs/win32

Log Message:
Directory /cvsroot/java-game-lib/LWJGL/libs/win32 added to the repository

Update of /cvsroot/java-game-lib/LWJGL/libs/macosx
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29751/libs/macosx

Added Files:
	libjinput.jnilib 
Log Message:
Initial controller input checkin. JInput native for macosx

--- NEW FILE: libjinput.jnilib ---
(This appears to be a binary file; contents omitted.)

Update of /cvsroot/java-game-lib/LWJGL/libs/macosx
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29662/libs/macosx

Log Message:
Directory /cvsroot/java-game-lib/LWJGL/libs/macosx added to the repository

Update of /cvsroot/java-game-lib/LWJGL/libs
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv27908/libs

Added Files:
	jinput.jar 
Log Message:
Initial controller input checkin. Jar for jinput.

--- NEW FILE: jinput.jar ---
(This appears to be a binary file; contents omitted.)

Update of /cvsroot/java-game-lib/LWJGL/libs
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv27198/libs

Log Message:
Directory /cvsroot/java-game-lib/LWJGL/libs added to the repository

Update of /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/opengl
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv24153/src/java/org/lwjgl/opengl

Modified Files:
	ARBBufferObject.java ARBColorBufferFloat.java 
	ARBDepthTexture.java ARBDrawBuffers.java 
	ARBFragmentProgram.java ARBFragmentShader.java 
	ARBHalfFloatPixel.java ARBImaging.java ARBMatrixPalette.java 
	ARBMultisample.java ARBMultitexture.java 
	ARBOcclusionQuery.java ARBPixelBufferObject.java 
	ARBPointParameters.java ARBPointSprite.java ARBProgram.java 
	ARBShaderObjects.java ARBShadow.java 
	ARBTextureCompression.java ARBTextureCubeMap.java 
	ARBTextureEnvCombine.java ARBTextureEnvDot3.java 
	ARBTextureFloat.java ARBTextureRectangle.java 
	ARBTransposeMatrix.java ARBVertexBlend.java 
	ARBVertexBufferObject.java ARBVertexProgram.java 
	ARBVertexShader.java ARBWindowPos.java ATIDrawBuffers.java 
	ATIElementArray.java ATIEnvmapBumpmap.java 
	ATIFragmentShader.java ATIMapObjectBuffer.java 
	ATIPnTriangles.java ATISeparateStencil.java 
	ATITextureFloat.java ATITextureMirrorOnce.java 
	ATIVertexArrayObject.java ATIVertexAttribArrayObject.java 
	ATIVertexStreams.java ContextCapabilities.java EXTBgra.java 
	EXTBlendEquationSeparate.java EXTBlendFuncSeparate.java 
	EXTBlendSubtract.java EXTCgShader.java 
	EXTCompiledVertexArray.java EXTDepthBoundsTest.java 
	EXTDrawRangeElements.java EXTFogCoord.java 
	EXTFramebufferObject.java EXTPackedPixels.java 
	EXTPalettedTexture.java EXTPixelBufferObject.java 
	EXTPointParameters.java EXTSecondaryColor.java 
	EXTSeparateSpecularColor.java EXTStencilTwoSide.java 
	EXTStencilWrap.java EXTTextureCompressionS3TC.java 
	EXTTextureEnvCombine.java EXTTextureEnvDot3.java 
	EXTTextureFilterAnisotropic.java EXTTextureLODBias.java 
	EXTTextureMirrorClamp.java EXTTextureRectangle.java 
	EXTVertexShader.java EXTVertexWeighting.java GL11.java 
	GL12.java GL13.java GL14.java GL15.java GL20.java 
	HPOcclusionTest.java MouseEventQueue.java 
	NVCopyDepthToColor.java NVEvaluators.java NVFence.java 
	NVFloatBuffer.java NVFogDistance.java NVFragmentProgram.java 
	NVFragmentProgram2.java NVHalfFloat.java 
	NVLightMaxExponent.java NVOcclusionQuery.java 
	NVPackedDepthStencil.java NVPixelDataRange.java 
	NVPointSprite.java NVPrimitiveRestart.java NVProgram.java 
	NVRegisterCombiners.java NVRegisterCombiners2.java 
	NVTexgenReflection.java NVTextureCompressionVTC.java 
	NVTextureEnvCombine4.java NVTextureRectangle.java 
	NVTextureShader.java NVTextureShader2.java 
	NVTextureShader3.java NVVertexArrayRange.java 
	NVVertexProgram.java NVVertexProgram2Option.java 
	References.java 
Log Message:
Mac OS X: Handle MouseEvent.NOBUTTON case

Index: EXTTextureMirrorClamp.java
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/opengl/EXTTextureMirrorClamp.java,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -d -r1.7 -r1.8
--- EXTTextureMirrorClamp.java	5 May 2005 10:02:41 -0000	1.7
+++ EXTTextureMirrorClamp.java	29 Jun 2005 07:39:22 -0000	1.8
@@ -7,9 +7,9 @@
 import java.nio.*;
 
 public final class EXTTextureMirrorClamp {
-	public static final int GL_MIRROR_CLAMP_TO_BORDER_EXT = 0x8912;
-	public static final int GL_MIRROR_CLAMP_TO_EDGE_EXT = 0x8743;
 	public static final int GL_MIRROR_CLAMP_EXT = 0x8742;
+	public static final int GL_MIRROR_CLAMP_TO_EDGE_EXT = 0x8743;
+	public static final int GL_MIRROR_CLAMP_TO_BORDER_EXT = 0x8912;
 
 	private EXTTextureMirrorClamp() {
 	}

Index: EXTVertexShader.java
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/opengl/EXTVertexShader.java,v
retrieving revision 1.20
retrieving revision 1.21
diff -u -d -r1.20 -r1.21
--- EXTVertexShader.java	5 May 2005 10:02:41 -0000	1.20
+++ EXTVertexShader.java	29 Jun 2005 07:39:22 -0000	1.21
@@ -7,262 +7,321 @@
 import java.nio.*;
 
 public final class EXTVertexShader {
-	public static final int GL_LOCAL_CONSTANT_DATATYPE_EXT = 0x87ed;
-	public static final int GL_LOCAL_CONSTANT_VALUE_EXT = 0x87ec;
-	public static final int GL_INVARIANT_DATATYPE_EXT = 0x87eb;
-	public static final int GL_INVARIANT_VALUE_EXT = 0x87ea;
-	public static final int GL_VARIANT_ARRAY_POINTER_EXT = 0x87e9;
-	public static final int GL_VARIANT_ARRAY_EXT = 0x87e8;
-	public static final int GL_VARIANT_ARRAY_TYPE_EXT = 0x87e7;
-	public static final int GL_VARIANT_ARRAY_STRIDE_EXT = 0x87e6;
-	public static final int GL_VARIANT_DATATYPE_EXT = 0x87e5;
-	public static final int GL_VARIANT_VALUE_EXT = 0x87e4;
-	public static final int GL_MVP_MATRIX_EXT = 0x87e3;
-	public static final int GL_CURRENT_VERTEX_EXT = 0x87e2;
-	public static final int GL_FULL_RANGE_EXT = 0x87e1;
-	public static final int GL_NORMALIZED_RANGE_EXT = 0x87e0;
-	public static final int GL_NEGATIVE_ONE_EXT = 0x87df;
-	public static final int GL_ONE_EXT = 0x87de;
-	public static final int GL_ZERO_EXT = 0x87dd;
-	public static final int GL_NEGATIVE_W_EXT = 0x87dc;
-	public static final int GL_NEGATIVE_Z_EXT = 0x87db;
-	public static final int GL_NEGATIVE_Y_EXT = 0x87da;
-	public static final int GL_NEGATIVE_X_EXT = 0x87d9;
-	public static final int GL_W_EXT = 0x87d8;
-	public static final int GL_Z_EXT = 0x87d7;
-	public static final int GL_Y_EXT = 0x87d6;
-	public static final int GL_X_EXT = 0x87d5;
-	public static final int GL_VERTEX_SHADER_OPTIMIZED_EXT = 0x87d4;
-	public static final int GL_VERTEX_SHADER_LOCALS_EXT = 0x87d3;
-	public static final int GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87d2;
-	public static final int GL_VERTEX_SHADER_INVARIANTS_EXT = 0x87d1;
-	public static final int GL_VERTEX_SHADER_VARIANTS_EXT = 0x87d0;
-	public static final int GL_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87cf;
-	public static final int GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = 0x87ce;
-	public static final int GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87cd;
-	public static final int GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = 0x87cc;
-	public static final int GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = 0x87cb;
-	public static final int GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87ca;
-	public static final int GL_MAX_VERTEX_SHADER_LOCALS_EXT = 0x87c9;
-	public static final int GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87c8;
-	public static final int GL_MAX_VERTEX_SHADER_INVARIANTS_EXT = 0x87c7;
-	public static final int GL_MAX_VERTEX_SHADER_VARIANTS_EXT = 0x87c6;
-	public static final int GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87c5;
-	public static final int GL_LOCAL_EXT = 0x87c4;
-	public static final int GL_LOCAL_CONSTANT_EXT = 0x87c3;
-	public static final int GL_INVARIANT_EXT = 0x87c2;
-	public static final int GL_VARIANT_EXT = 0x87c1;
-	public static final int GL_MATRIX_EXT = 0x87c0;
-	public static final int GL_VECTOR_EXT = 0x87bf;
-	public static final int GL_SCALAR_EXT = 0x87be;
-	public static final int GL_OUTPUT_FOG_EXT = 0x87bd;
-	public static final int GL_OUTPUT_TEXTURE_COORD31_EXT = 0x87bc;
-	public static final int GL_OUTPUT_TEXTURE_COORD30_EXT = 0x87bb;
-	public static final int GL_OUTPUT_TEXTURE_COORD29_EXT = 0x87ba;
-	public static final int GL_OUTPUT_TEXTURE_COORD28_EXT = 0x87b9;
-	public static final int GL_OUTPUT_TEXTURE_COORD27_EXT = 0x87b8;
-	public static final int GL_OUTPUT_TEXTURE_COORD26_EXT = 0x87b7;
-	public static final int GL_OUTPUT_TEXTURE_COORD25_EXT = 0x87b6;
-	public static final int GL_OUTPUT_TEXTURE_COORD24_EXT = 0x87b5;
-	public static final int GL_OUTPUT_TEXTURE_COORD23_EXT = 0x87b4;
-	public static final int GL_OUTPUT_TEXTURE_COORD22_EXT = 0x87b3;
-	public static final int GL_OUTPUT_TEXTURE_COORD21_EXT = 0x87b2;
-	public static final int GL_OUTPUT_TEXTURE_COORD20_EXT = 0x87b1;
-	public static final int GL_OUTPUT_TEXTURE_COORD19_EXT = 0x87b0;
-	public static final int GL_OUTPUT_TEXTURE_COORD18_EXT = 0x87af;
-	public static final int GL_OUTPUT_TEXTURE_COORD17_EXT = 0x87ae;
-	public static final int GL_OUTPUT_TEXTURE_COORD16_EXT = 0x87ad;
-	public static final int GL_OUTPUT_TEXTURE_COORD15_EXT = 0x87ac;
-	public static final int GL_OUTPUT_TEXTURE_COORD14_EXT = 0x87ab;
-	public static final int GL_OUTPUT_TEXTURE_COORD13_EXT = 0x87aa;
-	public static final int GL_OUTPUT_TEXTURE_COORD12_EXT = 0x87a9;
-	public static final int GL_OUTPUT_TEXTURE_COORD11_EXT = 0x87a8;
-	public static final int GL_OUTPUT_TEXTURE_COORD10_EXT = 0x87a7;
-	public static final int GL_OUTPUT_TEXTURE_COORD9_EXT = 0x87a6;
-	public static final int GL_OUTPUT_TEXTURE_COORD8_EXT = 0x87a5;
-	public static final int GL_OUTPUT_TEXTURE_COORD7_EXT = 0x87a4;
-	public static final int GL_OUTPUT_TEXTURE_COORD6_EXT = 0x87a3;
-	public static final int GL_OUTPUT_TEXTURE_COORD5_EXT = 0x87a2;
-	public static final int GL_OUTPUT_TEXTURE_COORD4_EXT = 0x87a1;
-	public static final int GL_OUTPUT_TEXTURE_COORD3_EXT = 0x87a0;
-	public static final int GL_OUTPUT_TEXTURE_COORD2_EXT = 0x879f;
-	public static final int GL_OUTPUT_TEXTURE_COORD1_EXT = 0x879e;
-	public static final int GL_OUTPUT_TEXTURE_COORD0_EXT = 0x879d;
-	public static final int GL_OUTPUT_COLOR1_EXT = 0x879c;
-	public static final int GL_OUTPUT_COLOR0_EXT = 0x879b;
-	public static final int GL_OUTPUT_VERTEX_EXT = 0x879a;
-	public static final int GL_OP_MOV_EXT = 0x8799;
-	public static final int GL_OP_MULTIPLY_MATRIX_EXT = 0x8798;
-	public static final int GL_OP_CROSS_PRODUCT_EXT = 0x8797;
-	public static final int GL_OP_SUB_EXT = 0x8796;
-	public static final int GL_OP_RECIP_SQRT_EXT = 0x8795;
-	public static final int GL_OP_RECIP_EXT = 0x8794;
-	public static final int GL_OP_POWER_EXT = 0x8793;
-	public static final int GL_OP_LOG_BASE_2_EXT = 0x8792;
-	public static final int GL_OP_EXP_BASE_2_EXT = 0x8791;
-	public static final int GL_OP_ROUND_EXT = 0x8790;
-	public static final int GL_OP_FLOOR_EXT = 0x878f;
-	public static final int GL_OP_CLAMP_EXT = 0x878e;
-	public static final int GL_OP_SET_LT_EXT = 0x878d;
-	public static final int GL_OP_SET_GE_EXT = 0x878c;
-	public static final int GL_OP_MIN_EXT = 0x878b;
-	public static final int GL_OP_MAX_EXT = 0x878a;
-	public static final int GL_OP_FRAC_EXT = 0x8789;
-	public static final int GL_OP_MADD_EXT = 0x8788;
-	public static final int GL_OP_ADD_EXT = 0x8787;
-	public static final int GL_OP_MUL_EXT = 0x8786;
-	public static final int GL_OP_DOT4_EXT = 0x8785;
-	public static final int GL_OP_DOT3_EXT = 0x8784;
-	public static final int GL_OP_NEGATE_EXT = 0x8783;
-	public static final int GL_OP_INDEX_EXT = 0x8782;
-	public static final int GL_VERTEX_SHADER_BINDING_EXT = 0x8781;
 	public static final int GL_VERTEX_SHADER_EXT = 0x8780;
+	public static final int GL_VERTEX_SHADER_BINDING_EXT = 0x8781;
+	public static final int GL_OP_INDEX_EXT = 0x8782;
+	public static final int GL_OP_NEGATE_EXT = 0x8783;
+	public static final int GL_OP_DOT3_EXT = 0x8784;
+	public static final int GL_OP_DOT4_EXT = 0x8785;
+	public static final int GL_OP_MUL_EXT = 0x8786;
+	public static final int GL_OP_ADD_EXT = 0x8787;
+	public static final int GL_OP_MADD_EXT = 0x8788;
+	public static final int GL_OP_FRAC_EXT = 0x8789;
+	public static final int GL_OP_MAX_EXT = 0x878a;
+	public static final int GL_OP_MIN_EXT = 0x878b;
+	public static final int GL_OP_SET_GE_EXT = 0x878c;
+	public static final int GL_OP_SET_LT_EXT = 0x878d;
+	public static final int GL_OP_CLAMP_EXT = 0x878e;
+	public static final int GL_OP_FLOOR_EXT = 0x878f;
+	public static final int GL_OP_ROUND_EXT = 0x8790;
+	public static final int GL_OP_EXP_BASE_2_EXT = 0x8791;
+	public static final int GL_OP_LOG_BASE_2_EXT = 0x8792;
+	public static final int GL_OP_POWER_EXT = 0x8793;
+	public static final int GL_OP_RECIP_EXT = 0x8794;
+	public static final int GL_OP_RECIP_SQRT_EXT = 0x8795;
+	public static final int GL_OP_SUB_EXT = 0x8796;
+	public static final int GL_OP_CROSS_PRODUCT_EXT = 0x8797;
+	public static final int GL_OP_MULTIPLY_MATRIX_EXT = 0x8798;
+	public static final int GL_OP_MOV_EXT = 0x8799;
+	public static final int GL_OUTPUT_VERTEX_EXT = 0x879a;
+	public static final int GL_OUTPUT_COLOR0_EXT = 0x879b;
+	public static final int GL_OUTPUT_COLOR1_EXT = 0x879c;
+	public static final int GL_OUTPUT_TEXTURE_COORD0_EXT = 0x879d;
+	public static final int GL_OUTPUT_TEXTURE_COORD1_EXT = 0x879e;
+	public static final int GL_OUTPUT_TEXTURE_COORD2_EXT = 0x879f;
+	public static final int GL_OUTPUT_TEXTURE_COORD3_EXT = 0x87a0;
+	public static final int GL_OUTPUT_TEXTURE_COORD4_EXT = 0x87a1;
+	public static final int GL_OUTPUT_TEXTURE_COORD5_EXT = 0x87a2;
+	public static final int GL_OUTPUT_TEXTURE_COORD6_EXT = 0x87a3;
+	public static final int GL_OUTPUT_TEXTURE_COORD7_EXT = 0x87a4;
+	public static final int GL_OUTPUT_TEXTURE_COORD8_EXT = 0x87a5;
+	public static final int GL_OUTPUT_TEXTURE_COORD9_EXT = 0x87a6;
+	public static final int GL_OUTPUT_TEXTURE_COORD10_EXT = 0x87a7;
+	public static final int GL_OUTPUT_TEXTURE_COORD11_EXT = 0x87a8;
+	public static final int GL_OUTPUT_TEXTURE_COORD12_EXT = 0x87a9;
+	public static final int GL_OUTPUT_TEXTURE_COORD13_EXT = 0x87aa;
+	public static final int GL_OUTPUT_TEXTURE_COORD14_EXT = 0x87ab;
+	public static final int GL_OUTPUT_TEXTURE_COORD15_EXT = 0x87ac;
+	public static final int GL_OUTPUT_TEXTURE_COORD16_EXT = 0x87ad;
+	public static final int GL_OUTPUT_TEXTURE_COORD17_EXT = 0x87ae;
+	public static final int GL_OUTPUT_TEXTURE_COORD18_EXT = 0x87af;
+	public static final int GL_OUTPUT_TEXTURE_COORD19_EXT = 0x87b0;
+	public static final int GL_OUTPUT_TEXTURE_COORD20_EXT = 0x87b1;
+	public static final int GL_OUTPUT_TEXTURE_COORD21_EXT = 0x87b2;
+	public static final int GL_OUTPUT_TEXTURE_COORD22_EXT = 0x87b3;
+	public static final int GL_OUTPUT_TEXTURE_COORD23_EXT = 0x87b4;
+	public static final int GL_OUTPUT_TEXTURE_COORD24_EXT = 0x87b5;
+	public static final int GL_OUTPUT_TEXTURE_COORD25_EXT = 0x87b6;
+	public static final int GL_OUTPUT_TEXTURE_COORD26_EXT = 0x87b7;
+	public static final int GL_OUTPUT_TEXTURE_COORD27_EXT = 0x87b8;
+	public static final int GL_OUTPUT_TEXTURE_COORD28_EXT = 0x87b9;
+	public static final int GL_OUTPUT_TEXTURE_COORD29_EXT = 0x87ba;
+	public static final int GL_OUTPUT_TEXTURE_COORD30_EXT = 0x87bb;
+	public static final int GL_OUTPUT_TEXTURE_COORD31_EXT = 0x87bc;
+	public static final int GL_OUTPUT_FOG_EXT = 0x87bd;
+	public static final int GL_SCALAR_EXT = 0x87be;
+	public static final int GL_VECTOR_EXT = 0x87bf;
+	public static final int GL_MATRIX_EXT = 0x87c0;
+	public static final int GL_VARIANT_EXT = 0x87c1;
+	public static final int GL_INVARIANT_EXT = 0x87c2;
+	public static final int GL_LOCAL_CONSTANT_EXT = 0x87c3;
+	public static final int GL_LOCAL_EXT = 0x87c4;
+	public static final int GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87c5;
+	public static final int GL_MAX_VERTEX_SHADER_VARIANTS_EXT = 0x87c6;
+	public static final int GL_MAX_VERTEX_SHADER_INVARIANTS_EXT = 0x87c7;
+	public static final int GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87c8;
+	public static final int GL_MAX_VERTEX_SHADER_LOCALS_EXT = 0x87c9;
+	public static final int GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87ca;
+	public static final int GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = 0x87cb;
+	public static final int GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = 0x87cc;
+	public static final int GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87cd;
+	public static final int GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = 0x87ce;
+	public static final int GL_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87cf;
+	public static final int GL_VERTEX_SHADER_VARIANTS_EXT = 0x87d0;
+	public static final int GL_VERTEX_SHADER_INVARIANTS_EXT = 0x87d1;
+	public static final int GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87d2;
+	public static final int GL_VERTEX_SHADER_LOCALS_EXT = 0x87d3;
+	public static final int GL_VERTEX_SHADER_OPTIMIZED_EXT = 0x87d4;
+	public static final int GL_X_EXT = 0x87d5;
+	public static final int GL_Y_EXT = 0x87d6;
+	public static final int GL_Z_EXT = 0x87d7;
+	public static final int GL_W_EXT = 0x87d8;
+	public static final int GL_NEGATIVE_X_EXT = 0x87d9;
+	public static final int GL_NEGATIVE_Y_EXT = 0x87da;
+	public static final int GL_NEGATIVE_Z_EXT = 0x87db;
+	public static final int GL_NEGATIVE_W_EXT = 0x87dc;
+	public static final int GL_ZERO_EXT = 0x87dd;
+	public static final int GL_ONE_EXT = 0x87de;
+	public static final int GL_NEGATIVE_ONE_EXT = 0x87df;
+	public static final int GL_NORMALIZED_RANGE_EXT = 0x87e0;
+	public static final int GL_FULL_RANGE_EXT = 0x87e1;
+	public static final int GL_CURRENT_VERTEX_EXT = 0x87e2;
+	public static final int GL_MVP_MATRIX_EXT = 0x87e3;
+	public static final int GL_VARIANT_VALUE_EXT = 0x87e4;
+	public static final int GL_VARIANT_DATATYPE_EXT = 0x87e5;
+	public static final int GL_VARIANT_ARRAY_STRIDE_EXT = 0x87e6;
+	public static final int GL_VARIANT_ARRAY_TYPE_EXT = 0x87e7;
+	public static final int GL_VARIANT_ARRAY_EXT = 0x87e8;
+	public static final int GL_VARIANT_ARRAY_POINTER_EXT = 0x87e9;
+	public static final int GL_INVARIANT_VALUE_EXT = 0x87ea;
+	public static final int GL_INVARIANT_DATATYPE_EXT = 0x87eb;
+	public static final int GL_LOCAL_CONSTANT_VALUE_EXT = 0x87ec;
+	public static final int GL_LOCAL_CONSTANT_DATATYPE_EXT = 0x87ed;
 
 	private EXTVertexShader() {
 	}
 
 
-	public static void glGetLocalConstantFloatEXT(int id, int value, FloatBuffer pbData) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGetLocalConstantFloatvEXT_pointer;
+	public static void glBeginVertexShaderEXT() {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glBeginVertexShaderEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pbData, 4);
-		nglGetLocalConstantFloatvEXT(id, value, pbData, pbData.position(), function_pointer);
+		nglBeginVertexShaderEXT(function_pointer);
 	}
-	private static native void nglGetLocalConstantFloatvEXT(int id, int value, FloatBuffer pbData, int pbData_position, long function_pointer);
+	private static native void nglBeginVertexShaderEXT(long function_pointer);
 
-	public static void glGetLocalConstantIntegerEXT(int id, int value, IntBuffer pbData) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGetLocalConstantIntegervEXT_pointer;
+	public static void glEndVertexShaderEXT() {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glEndVertexShaderEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pbData, 4);
-		nglGetLocalConstantIntegervEXT(id, value, pbData, pbData.position(), function_pointer);
+		nglEndVertexShaderEXT(function_pointer);
 	}
-	private static native void nglGetLocalConstantIntegervEXT(int id, int value, IntBuffer pbData, int pbData_position, long function_pointer);
+	private static native void nglEndVertexShaderEXT(long function_pointer);
 
-	public static void glGetLocalConstantBooleanEXT(int id, int value, ByteBuffer pbData) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGetLocalConstantBooleanvEXT_pointer;
+	public static void glBindVertexShaderEXT(int id) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glBindVertexShaderEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pbData, 4);
-		nglGetLocalConstantBooleanvEXT(id, value, pbData, pbData.position(), function_pointer);
+		nglBindVertexShaderEXT(id, function_pointer);
 	}
-	private static native void nglGetLocalConstantBooleanvEXT(int id, int value, ByteBuffer pbData, int pbData_position, long function_pointer);
+	private static native void nglBindVertexShaderEXT(int id, long function_pointer);
 
-	public static void glGetInvariantFloatEXT(int id, int value, FloatBuffer pbData) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGetInvariantFloatvEXT_pointer;
+	public static int glGenVertexShadersEXT(int range) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGenVertexShadersEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pbData, 4);
-		nglGetInvariantFloatvEXT(id, value, pbData, pbData.position(), function_pointer);
+		int __result = nglGenVertexShadersEXT(range, function_pointer);
+		return __result;
 	}
-	private static native void nglGetInvariantFloatvEXT(int id, int value, FloatBuffer pbData, int pbData_position, long function_pointer);
+	private static native int nglGenVertexShadersEXT(int range, long function_pointer);
 
-	public static void glGetInvariantIntegerEXT(int id, int value, IntBuffer pbData) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGetInvariantIntegervEXT_pointer;
+	public static void glDeleteVertexShaderEXT(int id) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glDeleteVertexShaderEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pbData, 4);
-		nglGetInvariantIntegervEXT(id, value, pbData, pbData.position(), function_pointer);
+		nglDeleteVertexShaderEXT(id, function_pointer);
 	}
-	private static native void nglGetInvariantIntegervEXT(int id, int value, IntBuffer pbData, int pbData_position, long function_pointer);
+	private static native void nglDeleteVertexShaderEXT(int id, long function_pointer);
 
-	public static void glGetInvariantBooleanEXT(int id, int value, ByteBuffer pbData) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGetInvariantBooleanvEXT_pointer;
+	public static void glShaderOp1EXT(int op, int res, int arg1) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glShaderOp1EXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pbData, 4);
-		nglGetInvariantBooleanvEXT(id, value, pbData, pbData.position(), function_pointer);
+		nglShaderOp1EXT(op, res, arg1, function_pointer);
 	}
-	private static native void nglGetInvariantBooleanvEXT(int id, int value, ByteBuffer pbData, int pbData_position, long function_pointer);
+	private static native void nglShaderOp1EXT(int op, int res, int arg1, long function_pointer);
 
-	public static java.nio.ByteBuffer glGetVariantPointerEXT(int id, int value, int result_size) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGetVariantPointervEXT_pointer;
+	public static void glShaderOp2EXT(int op, int res, int arg1, int arg2) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glShaderOp2EXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		java.nio.ByteBuffer __result = nglGetVariantPointervEXT(id, value, result_size, function_pointer);
-		return __result;
+		nglShaderOp2EXT(op, res, arg1, arg2, function_pointer);
 	}
-	private static native java.nio.ByteBuffer nglGetVariantPointervEXT(int id, int value, int result_size, long function_pointer);
+	private static native void nglShaderOp2EXT(int op, int res, int arg1, int arg2, long function_pointer);
 
-	public static void glGetVariantFloatEXT(int id, int value, FloatBuffer pbData) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGetVariantFloatvEXT_pointer;
+	public static void glShaderOp3EXT(int op, int res, int arg1, int arg2, int arg3) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glShaderOp3EXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pbData, 4);
-		nglGetVariantFloatvEXT(id, value, pbData, pbData.position(), function_pointer);
+		nglShaderOp3EXT(op, res, arg1, arg2, arg3, function_pointer);
 	}
-	private static native void nglGetVariantFloatvEXT(int id, int value, FloatBuffer pbData, int pbData_position, long function_pointer);
+	private static native void nglShaderOp3EXT(int op, int res, int arg1, int arg2, int arg3, long function_pointer);
 
-	public static void glGetVariantIntegerEXT(int id, int value, IntBuffer pbData) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGetVariantIntegervEXT_pointer;
+	public static void glSwizzleEXT(int res, int in, int outX, int outY, int outZ, int outW) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glSwizzleEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pbData, 4);
-		nglGetVariantIntegervEXT(id, value, pbData, pbData.position(), function_pointer);
+		nglSwizzleEXT(res, in, outX, outY, outZ, outW, function_pointer);
 	}
-	private static native void nglGetVariantIntegervEXT(int id, int value, IntBuffer pbData, int pbData_position, long function_pointer);
+	private static native void nglSwizzleEXT(int res, int in, int outX, int outY, int outZ, int outW, long function_pointer);
 
-	public static void glGetVariantBooleanEXT(int id, int value, ByteBuffer pbData) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGetVariantBooleanvEXT_pointer;
+	public static void glWriteMaskEXT(int res, int in, int outX, int outY, int outZ, int outW) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glWriteMaskEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pbData, 4);
-		nglGetVariantBooleanvEXT(id, value, pbData, pbData.position(), function_pointer);
+		nglWriteMaskEXT(res, in, outX, outY, outZ, outW, function_pointer);
 	}
-	private static native void nglGetVariantBooleanvEXT(int id, int value, ByteBuffer pbData, int pbData_position, long function_pointer);
+	private static native void nglWriteMaskEXT(int res, int in, int outX, int outY, int outZ, int outW, long function_pointer);
 
-	public static boolean glIsVariantEnabledEXT(int id, int cap) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glIsVariantEnabledEXT_pointer;
+	public static void glInsertComponentEXT(int res, int src, int num) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glInsertComponentEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		boolean __result = nglIsVariantEnabledEXT(id, cap, function_pointer);
-		return __result;
+		nglInsertComponentEXT(res, src, num, function_pointer);
 	}
-	private static native boolean nglIsVariantEnabledEXT(int id, int cap, long function_pointer);
+	private static native void nglInsertComponentEXT(int res, int src, int num, long function_pointer);
 
-	public static int glBindParameterEXT(int value) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glBindParameterEXT_pointer;
+	public static void glExtractComponentEXT(int res, int src, int num) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glExtractComponentEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		int __result = nglBindParameterEXT(value, function_pointer);
-		return __result;
+		nglExtractComponentEXT(res, src, num, function_pointer);
 	}
-	private static native int nglBindParameterEXT(int value, long function_pointer);
+	private static native void nglExtractComponentEXT(int res, int src, int num, long function_pointer);
 
-	public static int glBindTextureUnitParameterEXT(int unit, int value) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glBindTextureUnitParameterEXT_pointer;
+	public static int glGenSymbolsEXT(int dataType, int storageType, int range, int components) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGenSymbolsEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		int __result = nglBindTextureUnitParameterEXT(unit, value, function_pointer);
+		int __result = nglGenSymbolsEXT(dataType, storageType, range, components, function_pointer);
 		return __result;
 	}
-	private static native int nglBindTextureUnitParameterEXT(int unit, int value, long function_pointer);
+	private static native int nglGenSymbolsEXT(int dataType, int storageType, int range, int components, long function_pointer);
 
-	public static int glBindTexGenParameterEXT(int unit, int coord, int value) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glBindTexGenParameterEXT_pointer;
+	public static void glSetInvariantEXT(int id, FloatBuffer pAddr) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glSetInvariantEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		int __result = nglBindTexGenParameterEXT(unit, coord, value, function_pointer);
-		return __result;
+		BufferChecks.checkBuffer(pAddr, 4);
+		nglSetInvariantEXT(id, GL11.GL_FLOAT, pAddr, pAddr.position() << 2, function_pointer);
 	}
-	private static native int nglBindTexGenParameterEXT(int unit, int coord, int value, long function_pointer);
+	public static void glSetInvariantEXT(int id, boolean unsigned, ByteBuffer pAddr) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glSetInvariantEXT_pointer;
+		BufferChecks.checkFunctionAddress(function_pointer);
+		BufferChecks.checkBuffer(pAddr, 4);
+		nglSetInvariantEXT(id, unsigned ? GL11.GL_UNSIGNED_BYTE : GL11.GL_BYTE, pAddr, pAddr.position(), function_pointer);
+	}
+	public static void glSetInvariantEXT(int id, boolean unsigned, IntBuffer pAddr) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glSetInvariantEXT_pointer;
+		BufferChecks.checkFunctionAddress(function_pointer);
+		BufferChecks.checkBuffer(pAddr, 4);
+		nglSetInvariantEXT(id, unsigned ? GL11.GL_UNSIGNED_INT : GL11.GL_INT, pAddr, pAddr.position() << 2, function_pointer);
+	}
+	public static void glSetInvariantEXT(int id, boolean unsigned, ShortBuffer pAddr) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glSetInvariantEXT_pointer;
+		BufferChecks.checkFunctionAddress(function_pointer);
+		BufferChecks.checkBuffer(pAddr, 4);
+		nglSetInvariantEXT(id, unsigned ? GL11.GL_UNSIGNED_SHORT : GL11.GL_SHORT, pAddr, pAddr.position() << 1, function_pointer);
+	}
+	private static native void nglSetInvariantEXT(int id, int type, Buffer pAddr, int pAddr_position, long function_pointer);
 
-	public static int glBindMaterialParameterEXT(int face, int value) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glBindMaterialParameterEXT_pointer;
+	public static void glSetLocalConstantEXT(int id, FloatBuffer pAddr) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glSetLocalConstantEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		int __result = nglBindMaterialParameterEXT(face, value, function_pointer);
-		return __result;
+		BufferChecks.checkBuffer(pAddr, 4);
+		nglSetLocalConstantEXT(id, GL11.GL_FLOAT, pAddr, pAddr.position() << 2, function_pointer);
 	}
-	private static native int nglBindMaterialParameterEXT(int face, int value, long function_pointer);
+	public static void glSetLocalConstantEXT(int id, boolean unsigned, ByteBuffer pAddr) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glSetLocalConstantEXT_pointer;
+		BufferChecks.checkFunctionAddress(function_pointer);
+		BufferChecks.checkBuffer(pAddr, 4);
+		nglSetLocalConstantEXT(id, unsigned ? GL11.GL_UNSIGNED_BYTE : GL11.GL_BYTE, pAddr, pAddr.position(), function_pointer);
+	}
+	public static void glSetLocalConstantEXT(int id, boolean unsigned, IntBuffer pAddr) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glSetLocalConstantEXT_pointer;
+		BufferChecks.checkFunctionAddress(function_pointer);
+		BufferChecks.checkBuffer(pAddr, 4);
+		nglSetLocalConstantEXT(id, unsigned ? GL11.GL_UNSIGNED_INT : GL11.GL_INT, pAddr, pAddr.position() << 2, function_pointer);
+	}
+	public static void glSetLocalConstantEXT(int id, boolean unsigned, ShortBuffer pAddr) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glSetLocalConstantEXT_pointer;
+		BufferChecks.checkFunctionAddress(function_pointer);
+		BufferChecks.checkBuffer(pAddr, 4);
+		nglSetLocalConstantEXT(id, unsigned ? GL11.GL_UNSIGNED_SHORT : GL11.GL_SHORT, pAddr, pAddr.position() << 1, function_pointer);
+	}
+	private static native void nglSetLocalConstantEXT(int id, int type, Buffer pAddr, int pAddr_position, long function_pointer);
 
-	public static int glBindLightParameterEXT(int light, int value) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glBindLightParameterEXT_pointer;
+	public static void glVariantEXT(int id, ByteBuffer pAddr) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glVariantbvEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		int __result = nglBindLightParameterEXT(light, value, function_pointer);
-		return __result;
+		BufferChecks.checkBuffer(pAddr, 4);
+		nglVariantbvEXT(id, pAddr, pAddr.position(), function_pointer);
 	}
-	private static native int nglBindLightParameterEXT(int light, int value, long function_pointer);
+	private static native void nglVariantbvEXT(int id, ByteBuffer pAddr, int pAddr_position, long function_pointer);
 
-	public static void glDisableVariantClientStateEXT(int id) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glDisableVariantClientStateEXT_pointer;
+	public static void glVariantEXT(int id, ShortBuffer pAddr) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glVariantsvEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		nglDisableVariantClientStateEXT(id, function_pointer);
+		BufferChecks.checkBuffer(pAddr, 4);
+		nglVariantsvEXT(id, pAddr, pAddr.position(), function_pointer);
 	}
-	private static native void nglDisableVariantClientStateEXT(int id, long function_pointer);
+	private static native void nglVariantsvEXT(int id, ShortBuffer pAddr, int pAddr_position, long function_pointer);
 
-	public static void glEnableVariantClientStateEXT(int id) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glEnableVariantClientStateEXT_pointer;
+	public static void glVariantEXT(int id, IntBuffer pAddr) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glVariantivEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		nglEnableVariantClientStateEXT(id, function_pointer);
+		BufferChecks.checkBuffer(pAddr, 4);
+		nglVariantivEXT(id, pAddr, pAddr.position(), function_pointer);
 	}
-	private static native void nglEnableVariantClientStateEXT(int id, long function_pointer);
+	private static native void nglVariantivEXT(int id, IntBuffer pAddr, int pAddr_position, long function_pointer);
+
+	public static void glVariantEXT(int id, FloatBuffer pAddr) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glVariantfvEXT_pointer;
+		BufferChecks.checkFunctionAddress(function_pointer);
+		BufferChecks.checkBuffer(pAddr, 4);
+		nglVariantfvEXT(id, pAddr, pAddr.position(), function_pointer);
+	}
+	private static native void nglVariantfvEXT(int id, FloatBuffer pAddr, int pAddr_position, long function_pointer);
+
+	public static void glVariantuEXT(int id, ByteBuffer pAddr) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glVariantubvEXT_pointer;
+		BufferChecks.checkFunctionAddress(function_pointer);
+		BufferChecks.checkBuffer(pAddr, 4);
+		nglVariantubvEXT(id, pAddr, pAddr.position(), function_pointer);
+	}
+	private static native void nglVariantubvEXT(int id, ByteBuffer pAddr, int pAddr_position, long function_pointer);
+
+	public static void glVariantuEXT(int id, ShortBuffer pAddr) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glVariantusvEXT_pointer;
+		BufferChecks.checkFunctionAddress(function_pointer);
+		BufferChecks.checkBuffer(pAddr, 4);
+		nglVariantusvEXT(id, pAddr, pAddr.position(), function_pointer);
+	}
+	private static native void nglVariantusvEXT(int id, ShortBuffer pAddr, int pAddr_position, long function_pointer);
+
+	public static void glVariantuEXT(int id, IntBuffer pAddr) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glVariantuivEXT_pointer;
+		BufferChecks.checkFunctionAddress(function_pointer);
+		BufferChecks.checkBuffer(pAddr, 4);
+		nglVariantuivEXT(id, pAddr, pAddr.position(), function_pointer);
+	}
+	private static native void nglVariantuivEXT(int id, IntBuffer pAddr, int pAddr_position, long function_pointer);
 
 	public static void glVariantPointerEXT(int id, int stride, FloatBuffer pAddr) {
 		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glVariantPointerEXT_pointer;
@@ -305,204 +364,145 @@
 	}
 	private static native void nglVariantPointerEXTBO(int id, int type, int stride, int pAddr_buffer_offset, long function_pointer);
 
-	public static void glVariantuEXT(int id, IntBuffer pAddr) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glVariantuivEXT_pointer;
-		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pAddr, 4);
-		nglVariantuivEXT(id, pAddr, pAddr.position(), function_pointer);
-	}
-	private static native void nglVariantuivEXT(int id, IntBuffer pAddr, int pAddr_position, long function_pointer);
-
-	public static void glVariantuEXT(int id, ShortBuffer pAddr) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glVariantusvEXT_pointer;
-		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pAddr, 4);
-		nglVariantusvEXT(id, pAddr, pAddr.position(), function_pointer);
-	}
-	private static native void nglVariantusvEXT(int id, ShortBuffer pAddr, int pAddr_position, long function_pointer);
-
-	public static void glVariantuEXT(int id, ByteBuffer pAddr) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glVariantubvEXT_pointer;
-		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pAddr, 4);
-		nglVariantubvEXT(id, pAddr, pAddr.position(), function_pointer);
-	}
-	private static native void nglVariantubvEXT(int id, ByteBuffer pAddr, int pAddr_position, long function_pointer);
-
-	public static void glVariantEXT(int id, FloatBuffer pAddr) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glVariantfvEXT_pointer;
-		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pAddr, 4);
-		nglVariantfvEXT(id, pAddr, pAddr.position(), function_pointer);
-	}
-	private static native void nglVariantfvEXT(int id, FloatBuffer pAddr, int pAddr_position, long function_pointer);
-
-	public static void glVariantEXT(int id, IntBuffer pAddr) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glVariantivEXT_pointer;
+	public static void glEnableVariantClientStateEXT(int id) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glEnableVariantClientStateEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pAddr, 4);
-		nglVariantivEXT(id, pAddr, pAddr.position(), function_pointer);
+		nglEnableVariantClientStateEXT(id, function_pointer);
 	}
-	private static native void nglVariantivEXT(int id, IntBuffer pAddr, int pAddr_position, long function_pointer);
+	private static native void nglEnableVariantClientStateEXT(int id, long function_pointer);
 
-	public static void glVariantEXT(int id, ShortBuffer pAddr) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glVariantsvEXT_pointer;
+	public static void glDisableVariantClientStateEXT(int id) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glDisableVariantClientStateEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pAddr, 4);
-		nglVariantsvEXT(id, pAddr, pAddr.position(), function_pointer);
+		nglDisableVariantClientStateEXT(id, function_pointer);
 	}
-	private static native void nglVariantsvEXT(int id, ShortBuffer pAddr, int pAddr_position, long function_pointer);
+	private static native void nglDisableVariantClientStateEXT(int id, long function_pointer);
 
-	public static void glVariantEXT(int id, ByteBuffer pAddr) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glVariantbvEXT_pointer;
+	public static int glBindLightParameterEXT(int light, int value) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glBindLightParameterEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pAddr, 4);
-		nglVariantbvEXT(id, pAddr, pAddr.position(), function_pointer);
+		int __result = nglBindLightParameterEXT(light, value, function_pointer);
+		return __result;
 	}
-	private static native void nglVariantbvEXT(int id, ByteBuffer pAddr, int pAddr_position, long function_pointer);
+	private static native int nglBindLightParameterEXT(int light, int value, long function_pointer);
 
-	public static void glSetLocalConstantEXT(int id, FloatBuffer pAddr) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glSetLocalConstantEXT_pointer;
-		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pAddr, 4);
-		nglSetLocalConstantEXT(id, GL11.GL_FLOAT, pAddr, pAddr.position() << 2, function_pointer);
-	}
-	public static void glSetLocalConstantEXT(int id, boolean unsigned, ByteBuffer pAddr) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glSetLocalConstantEXT_pointer;
-		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pAddr, 4);
-		nglSetLocalConstantEXT(id, unsigned ? GL11.GL_UNSIGNED_BYTE : GL11.GL_BYTE, pAddr, pAddr.position(), function_pointer);
-	}
-	public static void glSetLocalConstantEXT(int id, boolean unsigned, IntBuffer pAddr) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glSetLocalConstantEXT_pointer;
-		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pAddr, 4);
-		nglSetLocalConstantEXT(id, unsigned ? GL11.GL_UNSIGNED_INT : GL11.GL_INT, pAddr, pAddr.position() << 2, function_pointer);
-	}
-	public static void glSetLocalConstantEXT(int id, boolean unsigned, ShortBuffer pAddr) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glSetLocalConstantEXT_pointer;
+	public static int glBindMaterialParameterEXT(int face, int value) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glBindMaterialParameterEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pAddr, 4);
-		nglSetLocalConstantEXT(id, unsigned ? GL11.GL_UNSIGNED_SHORT : GL11.GL_SHORT, pAddr, pAddr.position() << 1, function_pointer);
+		int __result = nglBindMaterialParameterEXT(face, value, function_pointer);
+		return __result;
 	}
-	private static native void nglSetLocalConstantEXT(int id, int type, Buffer pAddr, int pAddr_position, long function_pointer);
+	private static native int nglBindMaterialParameterEXT(int face, int value, long function_pointer);
 
-	public static void glSetInvariantEXT(int id, FloatBuffer pAddr) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glSetInvariantEXT_pointer;
-		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pAddr, 4);
-		nglSetInvariantEXT(id, GL11.GL_FLOAT, pAddr, pAddr.position() << 2, function_pointer);
-	}
-	public static void glSetInvariantEXT(int id, boolean unsigned, ByteBuffer pAddr) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glSetInvariantEXT_pointer;
-		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pAddr, 4);
-		nglSetInvariantEXT(id, unsigned ? GL11.GL_UNSIGNED_BYTE : GL11.GL_BYTE, pAddr, pAddr.position(), function_pointer);
-	}
-	public static void glSetInvariantEXT(int id, boolean unsigned, IntBuffer pAddr) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glSetInvariantEXT_pointer;
-		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pAddr, 4);
-		nglSetInvariantEXT(id, unsigned ? GL11.GL_UNSIGNED_INT : GL11.GL_INT, pAddr, pAddr.position() << 2, function_pointer);
-	}
-	public static void glSetInvariantEXT(int id, boolean unsigned, ShortBuffer pAddr) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glSetInvariantEXT_pointer;
+	public static int glBindTexGenParameterEXT(int unit, int coord, int value) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glBindTexGenParameterEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(pAddr, 4);
-		nglSetInvariantEXT(id, unsigned ? GL11.GL_UNSIGNED_SHORT : GL11.GL_SHORT, pAddr, pAddr.position() << 1, function_pointer);
+		int __result = nglBindTexGenParameterEXT(unit, coord, value, function_pointer);
+		return __result;
 	}
-	private static native void nglSetInvariantEXT(int id, int type, Buffer pAddr, int pAddr_position, long function_pointer);
+	private static native int nglBindTexGenParameterEXT(int unit, int coord, int value, long function_pointer);
 
-	public static int glGenSymbolsEXT(int dataType, int storageType, int range, int components) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGenSymbolsEXT_pointer;
+	public static int glBindTextureUnitParameterEXT(int unit, int value) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glBindTextureUnitParameterEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		int __result = nglGenSymbolsEXT(dataType, storageType, range, components, function_pointer);
+		int __result = nglBindTextureUnitParameterEXT(unit, value, function_pointer);
 		return __result;
 	}
-	private static native int nglGenSymbolsEXT(int dataType, int storageType, int range, int components, long function_pointer);
+	private static native int nglBindTextureUnitParameterEXT(int unit, int value, long function_pointer);
 
-	public static void glExtractComponentEXT(int res, int src, int num) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glExtractComponentEXT_pointer;
+	public static int glBindParameterEXT(int value) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glBindParameterEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		nglExtractComponentEXT(res, src, num, function_pointer);
+		int __result = nglBindParameterEXT(value, function_pointer);
+		return __result;
 	}
-	private static native void nglExtractComponentEXT(int res, int src, int num, long function_pointer);
+	private static native int nglBindParameterEXT(int value, long function_pointer);
 
-	public static void glInsertComponentEXT(int res, int src, int num) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glInsertComponentEXT_pointer;
+	public static boolean glIsVariantEnabledEXT(int id, int cap) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glIsVariantEnabledEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		nglInsertComponentEXT(res, src, num, function_pointer);
+		boolean __result = nglIsVariantEnabledEXT(id, cap, function_pointer);
+		return __result;
 	}
-	private static native void nglInsertComponentEXT(int res, int src, int num, long function_pointer);
+	private static native boolean nglIsVariantEnabledEXT(int id, int cap, long function_pointer);
 
-	public static void glWriteMaskEXT(int res, int in, int outX, int outY, int outZ, int outW) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glWriteMaskEXT_pointer;
+	public static void glGetVariantBooleanEXT(int id, int value, ByteBuffer pbData) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGetVariantBooleanvEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		nglWriteMaskEXT(res, in, outX, outY, outZ, outW, function_pointer);
+		BufferChecks.checkBuffer(pbData, 4);
+		nglGetVariantBooleanvEXT(id, value, pbData, pbData.position(), function_pointer);
 	}
-	private static native void nglWriteMaskEXT(int res, int in, int outX, int outY, int outZ, int outW, long function_pointer);
+	private static native void nglGetVariantBooleanvEXT(int id, int value, ByteBuffer pbData, int pbData_position, long function_pointer);
 
-	public static void glSwizzleEXT(int res, int in, int outX, int outY, int outZ, int outW) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glSwizzleEXT_pointer;
+	public static void glGetVariantIntegerEXT(int id, int value, IntBuffer pbData) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGetVariantIntegervEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		nglSwizzleEXT(res, in, outX, outY, outZ, outW, function_pointer);
+		BufferChecks.checkBuffer(pbData, 4);
+		nglGetVariantIntegervEXT(id, value, pbData, pbData.position(), function_pointer);
 	}
-	private static native void nglSwizzleEXT(int res, int in, int outX, int outY, int outZ, int outW, long function_pointer);
+	private static native void nglGetVariantIntegervEXT(int id, int value, IntBuffer pbData, int pbData_position, long function_pointer);
 
-	public static void glShaderOp3EXT(int op, int res, int arg1, int arg2, int arg3) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glShaderOp3EXT_pointer;
+	public static void glGetVariantFloatEXT(int id, int value, FloatBuffer pbData) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGetVariantFloatvEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		nglShaderOp3EXT(op, res, arg1, arg2, arg3, function_pointer);
+		BufferChecks.checkBuffer(pbData, 4);
+		nglGetVariantFloatvEXT(id, value, pbData, pbData.position(), function_pointer);
 	}
-	private static native void nglShaderOp3EXT(int op, int res, int arg1, int arg2, int arg3, long function_pointer);
+	private static native void nglGetVariantFloatvEXT(int id, int value, FloatBuffer pbData, int pbData_position, long function_pointer);
 
-	public static void glShaderOp2EXT(int op, int res, int arg1, int arg2) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glShaderOp2EXT_pointer;
+	public static java.nio.ByteBuffer glGetVariantPointerEXT(int id, int value, int result_size) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGetVariantPointervEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		nglShaderOp2EXT(op, res, arg1, arg2, function_pointer);
+		java.nio.ByteBuffer __result = nglGetVariantPointervEXT(id, value, result_size, function_pointer);
+		return __result;
 	}
-	private static native void nglShaderOp2EXT(int op, int res, int arg1, int arg2, long function_pointer);
+	private static native java.nio.ByteBuffer nglGetVariantPointervEXT(int id, int value, int result_size, long function_pointer);
 
-	public static void glShaderOp1EXT(int op, int res, int arg1) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glShaderOp1EXT_pointer;
+	public static void glGetInvariantBooleanEXT(int id, int value, ByteBuffer pbData) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGetInvariantBooleanvEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		nglShaderOp1EXT(op, res, arg1, function_pointer);
+		BufferChecks.checkBuffer(pbData, 4);
+		nglGetInvariantBooleanvEXT(id, value, pbData, pbData.position(), function_pointer);
 	}
-	private static native void nglShaderOp1EXT(int op, int res, int arg1, long function_pointer);
+	private static native void nglGetInvariantBooleanvEXT(int id, int value, ByteBuffer pbData, int pbData_position, long function_pointer);
 
-	public static void glDeleteVertexShaderEXT(int id) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glDeleteVertexShaderEXT_pointer;
+	public static void glGetInvariantIntegerEXT(int id, int value, IntBuffer pbData) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGetInvariantIntegervEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		nglDeleteVertexShaderEXT(id, function_pointer);
+		BufferChecks.checkBuffer(pbData, 4);
+		nglGetInvariantIntegervEXT(id, value, pbData, pbData.position(), function_pointer);
 	}
-	private static native void nglDeleteVertexShaderEXT(int id, long function_pointer);
+	private static native void nglGetInvariantIntegervEXT(int id, int value, IntBuffer pbData, int pbData_position, long function_pointer);
 
-	public static int glGenVertexShadersEXT(int range) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGenVertexShadersEXT_pointer;
+	public static void glGetInvariantFloatEXT(int id, int value, FloatBuffer pbData) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGetInvariantFloatvEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		int __result = nglGenVertexShadersEXT(range, function_pointer);
-		return __result;
+		BufferChecks.checkBuffer(pbData, 4);
+		nglGetInvariantFloatvEXT(id, value, pbData, pbData.position(), function_pointer);
 	}
-	private static native int nglGenVertexShadersEXT(int range, long function_pointer);
+	private static native void nglGetInvariantFloatvEXT(int id, int value, FloatBuffer pbData, int pbData_position, long function_pointer);
 
-	public static void glBindVertexShaderEXT(int id) {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glBindVertexShaderEXT_pointer;
+	public static void glGetLocalConstantBooleanEXT(int id, int value, ByteBuffer pbData) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGetLocalConstantBooleanvEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		nglBindVertexShaderEXT(id, function_pointer);
+		BufferChecks.checkBuffer(pbData, 4);
+		nglGetLocalConstantBooleanvEXT(id, value, pbData, pbData.position(), function_pointer);
 	}
-	private static native void nglBindVertexShaderEXT(int id, long function_pointer);
+	private static native void nglGetLocalConstantBooleanvEXT(int id, int value, ByteBuffer pbData, int pbData_position, long function_pointer);
 
-	public static void glEndVertexShaderEXT() {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glEndVertexShaderEXT_pointer;
+	public static void glGetLocalConstantIntegerEXT(int id, int value, IntBuffer pbData) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGetLocalConstantIntegervEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		nglEndVertexShaderEXT(function_pointer);
+		BufferChecks.checkBuffer(pbData, 4);
+		nglGetLocalConstantIntegervEXT(id, value, pbData, pbData.position(), function_pointer);
 	}
-	private static native void nglEndVertexShaderEXT(long function_pointer);
+	private static native void nglGetLocalConstantIntegervEXT(int id, int value, IntBuffer pbData, int pbData_position, long function_pointer);
 
-	public static void glBeginVertexShaderEXT() {
-		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glBeginVertexShaderEXT_pointer;
+	public static void glGetLocalConstantFloatEXT(int id, int value, FloatBuffer pbData) {
+		long function_pointer = GLContext.getCapabilities().EXT_vertex_shader_glGetLocalConstantFloatvEXT_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
-		nglBeginVertexShaderEXT(function_pointer);
+		BufferChecks.checkBuffer(pbData, 4);
+		nglGetLocalConstantFloatvEXT(id, value, pbData, pbData.position(), function_pointer);
 	}
-	private static native void nglBeginVertexShaderEXT(long function_pointer);
+	private static native void nglGetLocalConstantFloatvEXT(int id, int value, FloatBuffer pbData, int pbData_position, long function_pointer);
 }

Index: ARBPixelBufferObject.java
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/opengl/ARBPixelBufferObject.java,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- ARBPixelBufferObject.java	5 May 2005 10:02:38 -0000	1.4
+++ ARBPixelBufferObject.java	29 Jun 2005 07:39:20 -0000	1.5
@@ -7,10 +7,10 @@
 import java.nio.*;
 
 public final class ARBPixelBufferObject extends ARBBufferObject {
-	public static final int PIXEL_UNPACK_BUFFER_BINDING_ARB = 0x88ef;
-	public static final int PIXEL_PACK_BUFFER_BINDING_ARB = 0x88ed;
-	public static final int GL_PIXEL_UNPACK_BUFFER_ARB = 0x88ec;
 	public static final int GL_PIXEL_PACK_BUFFER_ARB = 0x88eb;
+	public static final int GL_PIXEL_UNPACK_BUFFER_ARB = 0x88ec;
+	public static final int GL_PIXEL_PACK_BUFFER_BINDING_ARB = 0x88ed;
+	public static final int GL_PIXEL_UNPACK_BUFFER_BINDING_ARB = 0x88ef;
 
 	private ARBPixelBufferObject() {
 	}

Index: ATIEnvmapBumpmap.java
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/opengl/ATIEnvmapBumpmap.java,v
retrieving revision 1.15
retrieving revision 1.16
diff -u -d -r1.15 -r1.16
--- ATIEnvmapBumpmap.java	5 May 2005 10:02:39 -0000	1.15
+++ ATIEnvmapBumpmap.java	29 Jun 2005 07:39:21 -0000	1.16
@@ -7,34 +7,26 @@
 import java.nio.*;
 
 public final class ATIEnvmapBumpmap {
-	public static final int GL_BUMP_TARGET_ATI = 0x877c;
-	public static final int GL_BUMP_ENVMAP_ATI = 0x877b;
-	public static final int GL_DU8DV8_ATI = 0x877a;
-	public static final int GL_DUDV_ATI = 0x8779;
-	public static final int GL_BUMP_TEX_UNITS_ATI = 0x8778;
-	public static final int GL_BUMP_NUM_TEX_UNITS_ATI = 0x8777;
-	public static final int GL_BUMP_ROT_MATRIX_SIZE_ATI = 0x8776;
 	public static final int GL_BUMP_ROT_MATRIX_ATI = 0x8775;
+	public static final int GL_BUMP_ROT_MATRIX_SIZE_ATI = 0x8776;
+	public static final int GL_BUMP_NUM_TEX_UNITS_ATI = 0x8777;
+	public static final int GL_BUMP_TEX_UNITS_ATI = 0x8778;
+	public static final int GL_DUDV_ATI = 0x8779;
+	public static final int GL_DU8DV8_ATI = 0x877a;
+	public static final int GL_BUMP_ENVMAP_ATI = 0x877b;
+	public static final int GL_BUMP_TARGET_ATI = 0x877c;
 
 	private ATIEnvmapBumpmap() {
 	}
 
 
-	public static void glGetTexBumpParameterATI(int pname, IntBuffer param) {
-		long function_pointer = GLContext.getCapabilities().ATI_envmap_bumpmap_glGetTexBumpParameterivATI_pointer;
-		BufferChecks.checkFunctionAddress(function_pointer);
-		BufferChecks.checkBuffer(param, 4);
-		nglGetTexBumpParameterivATI(pname, param, param.position(), function_pointer);
-	}
-	private static native void nglGetTexBumpParameterivATI(int pname, IntBuffer param, int param_position, long function_pointer);
-
-	public static void glGetTexBumpParameterATI(int pname, FloatBuffer param) {
-		long function_pointer = GLContext.getCapabilities().ATI_envmap_bumpmap_glGetTexBumpParameterfvATI_pointer;
+	public static void glTexBumpParameterATI(int pname, FloatBuffer param) {
+		long function_pointer = GLContext.getCapabilities().ATI_envmap_bumpmap_glTexBumpParameterfvATI_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
 		BufferChecks.checkBuffer(param, 4);
-		nglGetTexBumpParameterfvATI(pname, param, param.position(), function_pointer);
+		nglTexBumpParameterfvATI(pname, param, param.position(), function_pointer);
 	}
-	private static native void nglGetTexBumpParameterfvATI(int pname, FloatBuffer param, int param_position, long function_pointer);
+	private static native void nglTexBumpParameterfvATI(int pname, FloatBuffer param, int param_position, long function_pointer);
 
 	public static void glTexBumpParameterATI(int pname, IntBuffer param) {
 		long function_pointer = GLContext.getCapabilities().ATI_envmap_bumpmap_glTexBumpParameterivATI_pointer;
@@ -44,11 +36,19 @@
 	}
 	private static native void nglTexBumpParameterivATI(int pname, IntBuffer param, int param_position, long function_pointer);
 
-	public static void glTexBumpParameterATI(int pname, FloatBuffer param) {
-		long function_pointer = GLContext.getCapabilities().ATI_envmap_bumpmap_glTexBumpParameterfvATI_pointer;
+	public static void glGetTexBumpParameterATI(int pname, FloatBuffer param) {
+		long function_pointer = GLContext.getCapabilities().ATI_envmap_bumpmap_glGetTexBumpParameterfvATI_pointer;
 		BufferChecks.checkFunctionAddress(function_pointer);
 		BufferChecks.checkBuffer(param, 4);
-		nglTexBumpParameterfvATI(pname, param, param.position(), function_pointer);
+		nglGetTexBumpParameterfvATI(pname, param, param.position(), function_pointer);
 	}
-	private static native void nglTexBumpParameterfvATI(int pname, FloatBuffer param, int param_position, long function_pointer);
+	private static...
 
[truncated message content]

Update of /cvsroot/java-game-lib/LWJGL/src/native/common
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv24153/src/native/common

Modified Files:
	org_lwjgl_openal_AL10.c org_lwjgl_opengl_GL11.c 
	org_lwjgl_opengl_GL12.c org_lwjgl_opengl_GL13.c 
	org_lwjgl_opengl_GL14.c org_lwjgl_opengl_GL15.c 
	org_lwjgl_opengl_GL20.c 
Log Message:
Mac OS X: Handle MouseEvent.NOBUTTON case

Index: org_lwjgl_opengl_GL14.c
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/org_lwjgl_opengl_GL14.c,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -d -r1.5 -r1.6
--- org_lwjgl_opengl_GL14.c	16 Feb 2005 20:25:04 -0000	1.5
+++ org_lwjgl_opengl_GL14.c	29 Jun 2005 07:39:25 -0000	1.6
@@ -3,81 +3,67 @@
 #include <jni.h>
 #include "extgl.h"
 
-typedef void (APIENTRY *glWindowPos3iPROC) (GLint x, GLint y, GLint z);
-typedef void (APIENTRY *glWindowPos3fPROC) (GLfloat x, GLfloat y, GLfloat z);
-typedef void (APIENTRY *glWindowPos2iPROC) (GLint x, GLint y);
-typedef void (APIENTRY *glWindowPos2fPROC) (GLfloat x, GLfloat y);
-typedef void (APIENTRY *glBlendFuncSeparatePROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-typedef void (APIENTRY *glSecondaryColorPointerPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid * data);
-typedef void (APIENTRY *glSecondaryColor3ubPROC) (GLubyte red, GLubyte green, GLubyte blue);
-typedef void (APIENTRY *glSecondaryColor3fPROC) (GLfloat red, GLfloat green, GLfloat blue);
-typedef void (APIENTRY *glSecondaryColor3bPROC) (GLbyte red, GLbyte green, GLbyte blue);
-typedef void (APIENTRY *glPointParameterfvPROC) (GLenum pname, GLfloat * params);
-typedef void (APIENTRY *glPointParameterivPROC) (GLenum pname, GLint * params);
-typedef void (APIENTRY *glPointParameterfPROC) (GLenum pname, GLfloat param);
-typedef void (APIENTRY *glPointParameteriPROC) (GLenum pname, GLint param);
-typedef void (APIENTRY *glMultiDrawArraysPROC) (GLenum mode, GLint * piFirst, GLsizei * piCount, GLsizei primcount);
-typedef void (APIENTRY *glFogCoordPointerPROC) (GLenum type, GLsizei stride, const GLvoid * data);
-typedef void (APIENTRY *glFogCoordfPROC) (GLfloat coord);
-typedef void (APIENTRY *glBlendColorPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
 typedef void (APIENTRY *glBlendEquationPROC) (GLenum mode);
+typedef void (APIENTRY *glBlendColorPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+typedef void (APIENTRY *glFogCoordfPROC) (GLfloat coord);
+typedef void (APIENTRY *glFogCoordPointerPROC) (GLenum type, GLsizei stride, const GLvoid * data);
+typedef void (APIENTRY *glMultiDrawArraysPROC) (GLenum mode, GLint * piFirst, GLsizei * piCount, GLsizei primcount);
+typedef void (APIENTRY *glPointParameteriPROC) (GLenum pname, GLint param);
+typedef void (APIENTRY *glPointParameterfPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY *glPointParameterivPROC) (GLenum pname, GLint * params);
+typedef void (APIENTRY *glPointParameterfvPROC) (GLenum pname, GLfloat * params);
+typedef void (APIENTRY *glSecondaryColor3bPROC) (GLbyte red, GLbyte green, GLbyte blue);
+typedef void (APIENTRY *glSecondaryColor3fPROC) (GLfloat red, GLfloat green, GLfloat blue);
+typedef void (APIENTRY *glSecondaryColor3ubPROC) (GLubyte red, GLubyte green, GLubyte blue);
+typedef void (APIENTRY *glSecondaryColorPointerPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid * data);
+typedef void (APIENTRY *glBlendFuncSeparatePROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+typedef void (APIENTRY *glWindowPos2fPROC) (GLfloat x, GLfloat y);
+typedef void (APIENTRY *glWindowPos2iPROC) (GLint x, GLint y);
+typedef void (APIENTRY *glWindowPos3fPROC) (GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY *glWindowPos3iPROC) (GLint x, GLint y, GLint z);
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglWindowPos3i(JNIEnv *env, jclass clazz, jint x, jint y, jint z, jlong function_pointer) {
-	glWindowPos3iPROC glWindowPos3i = (glWindowPos3iPROC)((intptr_t)function_pointer);
-	glWindowPos3i(x, y, z);
-}
-
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglWindowPos3f(JNIEnv *env, jclass clazz, jfloat x, jfloat y, jfloat z, jlong function_pointer) {
-	glWindowPos3fPROC glWindowPos3f = (glWindowPos3fPROC)((intptr_t)function_pointer);
-	glWindowPos3f(x, y, z);
-}
-
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglWindowPos2i(JNIEnv *env, jclass clazz, jint x, jint y, jlong function_pointer) {
-	glWindowPos2iPROC glWindowPos2i = (glWindowPos2iPROC)((intptr_t)function_pointer);
-	glWindowPos2i(x, y);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglBlendEquation(JNIEnv *env, jclass clazz, jint mode, jlong function_pointer) {
+	glBlendEquationPROC glBlendEquation = (glBlendEquationPROC)((intptr_t)function_pointer);
+	glBlendEquation(mode);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglWindowPos2f(JNIEnv *env, jclass clazz, jfloat x, jfloat y, jlong function_pointer) {
-	glWindowPos2fPROC glWindowPos2f = (glWindowPos2fPROC)((intptr_t)function_pointer);
-	glWindowPos2f(x, y);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglBlendColor(JNIEnv *env, jclass clazz, jfloat red, jfloat green, jfloat blue, jfloat alpha, jlong function_pointer) {
+	glBlendColorPROC glBlendColor = (glBlendColorPROC)((intptr_t)function_pointer);
+	glBlendColor(red, green, blue, alpha);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglBlendFuncSeparate(JNIEnv *env, jclass clazz, jint sfactorRGB, jint dfactorRGB, jint sfactorAlpha, jint dfactorAlpha, jlong function_pointer) {
-	glBlendFuncSeparatePROC glBlendFuncSeparate = (glBlendFuncSeparatePROC)((intptr_t)function_pointer);
-	glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglFogCoordf(JNIEnv *env, jclass clazz, jfloat coord, jlong function_pointer) {
+	glFogCoordfPROC glFogCoordf = (glFogCoordfPROC)((intptr_t)function_pointer);
+	glFogCoordf(coord);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglSecondaryColorPointer(JNIEnv *env, jclass clazz, jint size, jint type, jint stride, jobject data, jint data_position, jlong function_pointer) {
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglFogCoordPointer(JNIEnv *env, jclass clazz, jint type, jint stride, jobject data, jint data_position, jlong function_pointer) {
 	const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
-	glSecondaryColorPointerPROC glSecondaryColorPointer = (glSecondaryColorPointerPROC)((intptr_t)function_pointer);
-	glSecondaryColorPointer(size, type, stride, data_address);
+	glFogCoordPointerPROC glFogCoordPointer = (glFogCoordPointerPROC)((intptr_t)function_pointer);
+	glFogCoordPointer(type, stride, data_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglSecondaryColorPointerBO(JNIEnv *env, jclass clazz, jint size, jint type, jint stride, jint data_buffer_offset, jlong function_pointer) {
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglFogCoordPointerBO(JNIEnv *env, jclass clazz, jint type, jint stride, jint data_buffer_offset, jlong function_pointer) {
 	const GLvoid *data_address = ((const GLvoid *)offsetToPointer(data_buffer_offset));
-	glSecondaryColorPointerPROC glSecondaryColorPointer = (glSecondaryColorPointerPROC)((intptr_t)function_pointer);
-	glSecondaryColorPointer(size, type, stride, data_address);
-}
-
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglSecondaryColor3ub(JNIEnv *env, jclass clazz, jbyte red, jbyte green, jbyte blue, jlong function_pointer) {
-	glSecondaryColor3ubPROC glSecondaryColor3ub = (glSecondaryColor3ubPROC)((intptr_t)function_pointer);
-	glSecondaryColor3ub(red, green, blue);
+	glFogCoordPointerPROC glFogCoordPointer = (glFogCoordPointerPROC)((intptr_t)function_pointer);
+	glFogCoordPointer(type, stride, data_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglSecondaryColor3f(JNIEnv *env, jclass clazz, jfloat red, jfloat green, jfloat blue, jlong function_pointer) {
-	glSecondaryColor3fPROC glSecondaryColor3f = (glSecondaryColor3fPROC)((intptr_t)function_pointer);
-	glSecondaryColor3f(red, green, blue);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglMultiDrawArrays(JNIEnv *env, jclass clazz, jint mode, jobject piFirst, jint piFirst_position, jobject piCount, jint piCount_position, jint primcount, jlong function_pointer) {
+	GLint *piFirst_address = ((GLint *)(*env)->GetDirectBufferAddress(env, piFirst)) + piFirst_position;
+	GLsizei *piCount_address = ((GLsizei *)(*env)->GetDirectBufferAddress(env, piCount)) + piCount_position;
+	glMultiDrawArraysPROC glMultiDrawArrays = (glMultiDrawArraysPROC)((intptr_t)function_pointer);
+	glMultiDrawArrays(mode, piFirst_address, piCount_address, primcount);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglSecondaryColor3b(JNIEnv *env, jclass clazz, jbyte red, jbyte green, jbyte blue, jlong function_pointer) {
-	glSecondaryColor3bPROC glSecondaryColor3b = (glSecondaryColor3bPROC)((intptr_t)function_pointer);
-	glSecondaryColor3b(red, green, blue);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglPointParameteri(JNIEnv *env, jclass clazz, jint pname, jint param, jlong function_pointer) {
+	glPointParameteriPROC glPointParameteri = (glPointParameteriPROC)((intptr_t)function_pointer);
+	glPointParameteri(pname, param);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglPointParameterfv(JNIEnv *env, jclass clazz, jint pname, jobject params, jint params_position, jlong function_pointer) {
-	GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
-	glPointParameterfvPROC glPointParameterfv = (glPointParameterfvPROC)((intptr_t)function_pointer);
-	glPointParameterfv(pname, params_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglPointParameterf(JNIEnv *env, jclass clazz, jint pname, jfloat param, jlong function_pointer) {
+	glPointParameterfPROC glPointParameterf = (glPointParameterfPROC)((intptr_t)function_pointer);
+	glPointParameterf(pname, param);
 }
 
 JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglPointParameteriv(JNIEnv *env, jclass clazz, jint pname, jobject params, jint params_position, jlong function_pointer) {
@@ -86,47 +72,61 @@
 	glPointParameteriv(pname, params_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglPointParameterf(JNIEnv *env, jclass clazz, jint pname, jfloat param, jlong function_pointer) {
-	glPointParameterfPROC glPointParameterf = (glPointParameterfPROC)((intptr_t)function_pointer);
-	glPointParameterf(pname, param);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglPointParameterfv(JNIEnv *env, jclass clazz, jint pname, jobject params, jint params_position, jlong function_pointer) {
+	GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
+	glPointParameterfvPROC glPointParameterfv = (glPointParameterfvPROC)((intptr_t)function_pointer);
+	glPointParameterfv(pname, params_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglPointParameteri(JNIEnv *env, jclass clazz, jint pname, jint param, jlong function_pointer) {
-	glPointParameteriPROC glPointParameteri = (glPointParameteriPROC)((intptr_t)function_pointer);
-	glPointParameteri(pname, param);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglSecondaryColor3b(JNIEnv *env, jclass clazz, jbyte red, jbyte green, jbyte blue, jlong function_pointer) {
+	glSecondaryColor3bPROC glSecondaryColor3b = (glSecondaryColor3bPROC)((intptr_t)function_pointer);
+	glSecondaryColor3b(red, green, blue);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglMultiDrawArrays(JNIEnv *env, jclass clazz, jint mode, jobject piFirst, jint piFirst_position, jobject piCount, jint piCount_position, jint primcount, jlong function_pointer) {
-	GLint *piFirst_address = ((GLint *)(*env)->GetDirectBufferAddress(env, piFirst)) + piFirst_position;
-	GLsizei *piCount_address = ((GLsizei *)(*env)->GetDirectBufferAddress(env, piCount)) + piCount_position;
-	glMultiDrawArraysPROC glMultiDrawArrays = (glMultiDrawArraysPROC)((intptr_t)function_pointer);
-	glMultiDrawArrays(mode, piFirst_address, piCount_address, primcount);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglSecondaryColor3f(JNIEnv *env, jclass clazz, jfloat red, jfloat green, jfloat blue, jlong function_pointer) {
+	glSecondaryColor3fPROC glSecondaryColor3f = (glSecondaryColor3fPROC)((intptr_t)function_pointer);
+	glSecondaryColor3f(red, green, blue);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglFogCoordPointer(JNIEnv *env, jclass clazz, jint type, jint stride, jobject data, jint data_position, jlong function_pointer) {
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglSecondaryColor3ub(JNIEnv *env, jclass clazz, jbyte red, jbyte green, jbyte blue, jlong function_pointer) {
+	glSecondaryColor3ubPROC glSecondaryColor3ub = (glSecondaryColor3ubPROC)((intptr_t)function_pointer);
+	glSecondaryColor3ub(red, green, blue);
+}
+
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglSecondaryColorPointer(JNIEnv *env, jclass clazz, jint size, jint type, jint stride, jobject data, jint data_position, jlong function_pointer) {
 	const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
-	glFogCoordPointerPROC glFogCoordPointer = (glFogCoordPointerPROC)((intptr_t)function_pointer);
-	glFogCoordPointer(type, stride, data_address);
+	glSecondaryColorPointerPROC glSecondaryColorPointer = (glSecondaryColorPointerPROC)((intptr_t)function_pointer);
+	glSecondaryColorPointer(size, type, stride, data_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglFogCoordPointerBO(JNIEnv *env, jclass clazz, jint type, jint stride, jint data_buffer_offset, jlong function_pointer) {
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglSecondaryColorPointerBO(JNIEnv *env, jclass clazz, jint size, jint type, jint stride, jint data_buffer_offset, jlong function_pointer) {
 	const GLvoid *data_address = ((const GLvoid *)offsetToPointer(data_buffer_offset));
-	glFogCoordPointerPROC glFogCoordPointer = (glFogCoordPointerPROC)((intptr_t)function_pointer);
-	glFogCoordPointer(type, stride, data_address);
+	glSecondaryColorPointerPROC glSecondaryColorPointer = (glSecondaryColorPointerPROC)((intptr_t)function_pointer);
+	glSecondaryColorPointer(size, type, stride, data_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglFogCoordf(JNIEnv *env, jclass clazz, jfloat coord, jlong function_pointer) {
-	glFogCoordfPROC glFogCoordf = (glFogCoordfPROC)((intptr_t)function_pointer);
-	glFogCoordf(coord);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglBlendFuncSeparate(JNIEnv *env, jclass clazz, jint sfactorRGB, jint dfactorRGB, jint sfactorAlpha, jint dfactorAlpha, jlong function_pointer) {
+	glBlendFuncSeparatePROC glBlendFuncSeparate = (glBlendFuncSeparatePROC)((intptr_t)function_pointer);
+	glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglBlendColor(JNIEnv *env, jclass clazz, jfloat red, jfloat green, jfloat blue, jfloat alpha, jlong function_pointer) {
-	glBlendColorPROC glBlendColor = (glBlendColorPROC)((intptr_t)function_pointer);
-	glBlendColor(red, green, blue, alpha);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglWindowPos2f(JNIEnv *env, jclass clazz, jfloat x, jfloat y, jlong function_pointer) {
+	glWindowPos2fPROC glWindowPos2f = (glWindowPos2fPROC)((intptr_t)function_pointer);
+	glWindowPos2f(x, y);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglBlendEquation(JNIEnv *env, jclass clazz, jint mode, jlong function_pointer) {
-	glBlendEquationPROC glBlendEquation = (glBlendEquationPROC)((intptr_t)function_pointer);
-	glBlendEquation(mode);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglWindowPos2i(JNIEnv *env, jclass clazz, jint x, jint y, jlong function_pointer) {
+	glWindowPos2iPROC glWindowPos2i = (glWindowPos2iPROC)((intptr_t)function_pointer);
+	glWindowPos2i(x, y);
+}
+
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglWindowPos3f(JNIEnv *env, jclass clazz, jfloat x, jfloat y, jfloat z, jlong function_pointer) {
+	glWindowPos3fPROC glWindowPos3f = (glWindowPos3fPROC)((intptr_t)function_pointer);
+	glWindowPos3f(x, y, z);
+}
+
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL14_nglWindowPos3i(JNIEnv *env, jclass clazz, jint x, jint y, jint z, jlong function_pointer) {
+	glWindowPos3iPROC glWindowPos3i = (glWindowPos3iPROC)((intptr_t)function_pointer);
+	glWindowPos3i(x, y, z);
 }
 

Index: org_lwjgl_opengl_GL11.c
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/org_lwjgl_opengl_GL11.c,v
retrieving revision 1.13
retrieving revision 1.14
diff -u -d -r1.13 -r1.14
--- org_lwjgl_opengl_GL11.c	16 Feb 2005 20:25:00 -0000	1.13
+++ org_lwjgl_opengl_GL11.c	29 Jun 2005 07:39:25 -0000	1.14
@@ -3,800 +3,810 @@
 #include <jni.h>
 #include "extgl.h"
 
-typedef void (APIENTRY *glViewportPROC) (GLint x, GLint y, GLsizei width, GLsizei height);
-typedef void (APIENTRY *glStencilMaskPROC) (GLuint mask);
-typedef void (APIENTRY *glStencilOpPROC) (GLenum fail, GLenum zfail, GLenum zpass);
-typedef void (APIENTRY *glTexCoord4fPROC) (GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-typedef void (APIENTRY *glTexCoord3fPROC) (GLfloat s, GLfloat t, GLfloat r);
-typedef void (APIENTRY *glTexCoord2fPROC) (GLfloat s, GLfloat t);
-typedef void (APIENTRY *glTexCoord1fPROC) (GLfloat s);
-typedef void (APIENTRY *glTexCoordPointerPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid * pointer);
[...2339 lines suppressed...]
-	glAlphaFuncPROC glAlphaFunc = (glAlphaFuncPROC)((intptr_t)function_pointer);
-	glAlphaFunc(func, ref);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglStencilOp(JNIEnv *env, jclass clazz, jint fail, jint zfail, jint zpass, jlong function_pointer) {
+	glStencilOpPROC glStencilOp = (glStencilOpPROC)((intptr_t)function_pointer);
+	glStencilOp(fail, zfail, zpass);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglAccum(JNIEnv *env, jclass clazz, jint op, jfloat value, jlong function_pointer) {
-	glAccumPROC glAccum = (glAccumPROC)((intptr_t)function_pointer);
-	glAccum(op, value);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglStencilMask(JNIEnv *env, jclass clazz, jint mask, jlong function_pointer) {
+	glStencilMaskPROC glStencilMask = (glStencilMaskPROC)((intptr_t)function_pointer);
+	glStencilMask(mask);
+}
+
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglViewport(JNIEnv *env, jclass clazz, jint x, jint y, jint width, jint height, jlong function_pointer) {
+	glViewportPROC glViewport = (glViewportPROC)((intptr_t)function_pointer);
+	glViewport(x, y, width, height);
 }
 

Index: org_lwjgl_opengl_GL13.c
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/org_lwjgl_opengl_GL13.c,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -d -r1.5 -r1.6
--- org_lwjgl_opengl_GL13.c	16 Feb 2005 20:25:04 -0000	1.5
+++ org_lwjgl_opengl_GL13.c	29 Jun 2005 07:39:25 -0000	1.6
@@ -3,82 +3,79 @@
 #include <jni.h>
 #include "extgl.h"
 
-typedef void (APIENTRY *glSampleCoveragePROC) (GLclampf value, GLboolean invert);
-typedef void (APIENTRY *glMultTransposeMatrixfPROC) (const GLfloat * m);
-typedef void (APIENTRY *glLoadTransposeMatrixfPROC) (const GLfloat * m);
-typedef void (APIENTRY *glMultiTexCoord4fPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-typedef void (APIENTRY *glMultiTexCoord3fPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r);
-typedef void (APIENTRY *glMultiTexCoord2fPROC) (GLenum target, GLfloat s, GLfloat t);
-typedef void (APIENTRY *glMultiTexCoord1fPROC) (GLenum target, GLfloat s);
-typedef void (APIENTRY *glGetCompressedTexImagePROC) (GLenum target, GLint lod, GLvoid * img);
-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 *glCompressedTexSubImage2DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, 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 *glCompressedTexImage3DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, 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 *glCompressedTexImage1DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * data);
-typedef void (APIENTRY *glClientActiveTexturePROC) (GLenum texture);
 typedef void (APIENTRY *glActiveTexturePROC) (GLenum texture);
+typedef void (APIENTRY *glClientActiveTexturePROC) (GLenum texture);
+typedef void (APIENTRY *glCompressedTexImage1DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * data);
+typedef void (APIENTRY *glCompressedTexImage2DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data);
+typedef void (APIENTRY *glCompressedTexImage3DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data);
+typedef void (APIENTRY *glCompressedTexSubImage1DPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * data);
+typedef void (APIENTRY *glCompressedTexSubImage2DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data);
+typedef void (APIENTRY *glCompressedTexSubImage3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data);
+typedef void (APIENTRY *glGetCompressedTexImagePROC) (GLenum target, GLint lod, GLvoid * img);
+typedef void (APIENTRY *glMultiTexCoord1fPROC) (GLenum target, GLfloat s);
+typedef void (APIENTRY *glMultiTexCoord2fPROC) (GLenum target, GLfloat s, GLfloat t);
+typedef void (APIENTRY *glMultiTexCoord3fPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r);
+typedef void (APIENTRY *glMultiTexCoord4fPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+typedef void (APIENTRY *glLoadTransposeMatrixfPROC) (const GLfloat * m);
+typedef void (APIENTRY *glMultTransposeMatrixfPROC) (const GLfloat * m);
+typedef void (APIENTRY *glSampleCoveragePROC) (GLclampf value, GLboolean invert);
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglSampleCoverage(JNIEnv *env, jclass clazz, jfloat value, jboolean invert, jlong function_pointer) {
-	glSampleCoveragePROC glSampleCoverage = (glSampleCoveragePROC)((intptr_t)function_pointer);
-	glSampleCoverage(value, invert);
-}
-
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglMultTransposeMatrixf(JNIEnv *env, jclass clazz, jobject m, jint m_position, jlong function_pointer) {
-	const GLfloat *m_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, m)) + m_position;
-	glMultTransposeMatrixfPROC glMultTransposeMatrixf = (glMultTransposeMatrixfPROC)((intptr_t)function_pointer);
-	glMultTransposeMatrixf(m_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglActiveTexture(JNIEnv *env, jclass clazz, jint texture, jlong function_pointer) {
+	glActiveTexturePROC glActiveTexture = (glActiveTexturePROC)((intptr_t)function_pointer);
+	glActiveTexture(texture);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglLoadTransposeMatrixf(JNIEnv *env, jclass clazz, jobject m, jint m_position, jlong function_pointer) {
-	const GLfloat *m_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, m)) + m_position;
-	glLoadTransposeMatrixfPROC glLoadTransposeMatrixf = (glLoadTransposeMatrixfPROC)((intptr_t)function_pointer);
-	glLoadTransposeMatrixf(m_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglClientActiveTexture(JNIEnv *env, jclass clazz, jint texture, jlong function_pointer) {
+	glClientActiveTexturePROC glClientActiveTexture = (glClientActiveTexturePROC)((intptr_t)function_pointer);
+	glClientActiveTexture(texture);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglMultiTexCoord4f(JNIEnv *env, jclass clazz, jint target, jfloat s, jfloat t, jfloat r, jfloat q, jlong function_pointer) {
-	glMultiTexCoord4fPROC glMultiTexCoord4f = (glMultiTexCoord4fPROC)((intptr_t)function_pointer);
-	glMultiTexCoord4f(target, s, t, r, q);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexImage1D(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint border, jint imageSize, jobject data, jint data_position, jlong function_pointer) {
+	const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
+	glCompressedTexImage1DPROC glCompressedTexImage1D = (glCompressedTexImage1DPROC)((intptr_t)function_pointer);
+	glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglMultiTexCoord3f(JNIEnv *env, jclass clazz, jint target, jfloat s, jfloat t, jfloat r, jlong function_pointer) {
-	glMultiTexCoord3fPROC glMultiTexCoord3f = (glMultiTexCoord3fPROC)((intptr_t)function_pointer);
-	glMultiTexCoord3f(target, s, t, r);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexImage1DBO(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint border, jint imageSize, jint data_buffer_offset, jlong function_pointer) {
+	const GLvoid *data_address = ((const GLvoid *)offsetToPointer(data_buffer_offset));
+	glCompressedTexImage1DPROC glCompressedTexImage1D = (glCompressedTexImage1DPROC)((intptr_t)function_pointer);
+	glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglMultiTexCoord2f(JNIEnv *env, jclass clazz, jint target, jfloat s, jfloat t, jlong function_pointer) {
-	glMultiTexCoord2fPROC glMultiTexCoord2f = (glMultiTexCoord2fPROC)((intptr_t)function_pointer);
-	glMultiTexCoord2f(target, s, t);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexImage2D(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint imageSize, jobject data, jint data_position, jlong function_pointer) {
+	const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
+	glCompressedTexImage2DPROC glCompressedTexImage2D = (glCompressedTexImage2DPROC)((intptr_t)function_pointer);
+	glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglMultiTexCoord1f(JNIEnv *env, jclass clazz, jint target, jfloat s, jlong function_pointer) {
-	glMultiTexCoord1fPROC glMultiTexCoord1f = (glMultiTexCoord1fPROC)((intptr_t)function_pointer);
-	glMultiTexCoord1f(target, s);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexImage2DBO(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint imageSize, jint data_buffer_offset, jlong function_pointer) {
+	const GLvoid *data_address = ((const GLvoid *)offsetToPointer(data_buffer_offset));
+	glCompressedTexImage2DPROC glCompressedTexImage2D = (glCompressedTexImage2DPROC)((intptr_t)function_pointer);
+	glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglGetCompressedTexImage(JNIEnv *env, jclass clazz, jint target, jint lod, jobject img, jint img_position, jlong function_pointer) {
-	GLvoid *img_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, img)) + img_position));
-	glGetCompressedTexImagePROC glGetCompressedTexImage = (glGetCompressedTexImagePROC)((intptr_t)function_pointer);
-	glGetCompressedTexImage(target, lod, img_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexImage3D(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint height, jint depth, jint border, jint imageSize, jobject data, jint data_position, jlong function_pointer) {
+	const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
+	glCompressedTexImage3DPROC glCompressedTexImage3D = (glCompressedTexImage3DPROC)((intptr_t)function_pointer);
+	glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglGetCompressedTexImageBO(JNIEnv *env, jclass clazz, jint target, jint lod, jint img_buffer_offset, jlong function_pointer) {
-	GLvoid *img_address = ((GLvoid *)offsetToPointer(img_buffer_offset));
-	glGetCompressedTexImagePROC glGetCompressedTexImage = (glGetCompressedTexImagePROC)((intptr_t)function_pointer);
-	glGetCompressedTexImage(target, lod, img_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexImage3DBO(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint height, jint depth, jint border, jint imageSize, jint data_buffer_offset, jlong function_pointer) {
+	const GLvoid *data_address = ((const GLvoid *)offsetToPointer(data_buffer_offset));
+	glCompressedTexImage3DPROC glCompressedTexImage3D = (glCompressedTexImage3DPROC)((intptr_t)function_pointer);
+	glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexSubImage3D(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint yoffset, jint zoffset, jint width, jint height, jint depth, jint format, jint imageSize, jobject data, jint data_position, jlong function_pointer) {
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexSubImage1D(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint width, jint format, jint imageSize, jobject data, jint data_position, jlong function_pointer) {
 	const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
-	glCompressedTexSubImage3DPROC glCompressedTexSubImage3D = (glCompressedTexSubImage3DPROC)((intptr_t)function_pointer);
-	glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data_address);
+	glCompressedTexSubImage1DPROC glCompressedTexSubImage1D = (glCompressedTexSubImage1DPROC)((intptr_t)function_pointer);
+	glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexSubImage3DBO(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint yoffset, jint zoffset, jint width, jint height, jint depth, jint format, jint imageSize, jint data_buffer_offset, jlong function_pointer) {
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexSubImage1DBO(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint width, jint format, jint imageSize, jint data_buffer_offset, jlong function_pointer) {
 	const GLvoid *data_address = ((const GLvoid *)offsetToPointer(data_buffer_offset));
-	glCompressedTexSubImage3DPROC glCompressedTexSubImage3D = (glCompressedTexSubImage3DPROC)((intptr_t)function_pointer);
-	glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data_address);
+	glCompressedTexSubImage1DPROC glCompressedTexSubImage1D = (glCompressedTexSubImage1DPROC)((intptr_t)function_pointer);
+	glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data_address);
 }
 
 JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexSubImage2D(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint yoffset, jint width, jint height, jint format, jint imageSize, jobject data, jint data_position, jlong function_pointer) {
@@ -93,61 +90,64 @@
 	glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexSubImage1D(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint width, jint format, jint imageSize, jobject data, jint data_position, jlong function_pointer) {
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexSubImage3D(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint yoffset, jint zoffset, jint width, jint height, jint depth, jint format, jint imageSize, jobject data, jint data_position, jlong function_pointer) {
 	const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
-	glCompressedTexSubImage1DPROC glCompressedTexSubImage1D = (glCompressedTexSubImage1DPROC)((intptr_t)function_pointer);
-	glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data_address);
+	glCompressedTexSubImage3DPROC glCompressedTexSubImage3D = (glCompressedTexSubImage3DPROC)((intptr_t)function_pointer);
+	glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexSubImage1DBO(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint width, jint format, jint imageSize, jint data_buffer_offset, jlong function_pointer) {
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexSubImage3DBO(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint yoffset, jint zoffset, jint width, jint height, jint depth, jint format, jint imageSize, jint data_buffer_offset, jlong function_pointer) {
 	const GLvoid *data_address = ((const GLvoid *)offsetToPointer(data_buffer_offset));
-	glCompressedTexSubImage1DPROC glCompressedTexSubImage1D = (glCompressedTexSubImage1DPROC)((intptr_t)function_pointer);
-	glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data_address);
+	glCompressedTexSubImage3DPROC glCompressedTexSubImage3D = (glCompressedTexSubImage3DPROC)((intptr_t)function_pointer);
+	glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexImage3D(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint height, jint depth, jint border, jint imageSize, jobject data, jint data_position, jlong function_pointer) {
-	const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
-	glCompressedTexImage3DPROC glCompressedTexImage3D = (glCompressedTexImage3DPROC)((intptr_t)function_pointer);
-	glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglGetCompressedTexImage(JNIEnv *env, jclass clazz, jint target, jint lod, jobject img, jint img_position, jlong function_pointer) {
+	GLvoid *img_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, img)) + img_position));
+	glGetCompressedTexImagePROC glGetCompressedTexImage = (glGetCompressedTexImagePROC)((intptr_t)function_pointer);
+	glGetCompressedTexImage(target, lod, img_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexImage3DBO(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint height, jint depth, jint border, jint imageSize, jint data_buffer_offset, jlong function_pointer) {
-	const GLvoid *data_address = ((const GLvoid *)offsetToPointer(data_buffer_offset));
-	glCompressedTexImage3DPROC glCompressedTexImage3D = (glCompressedTexImage3DPROC)((intptr_t)function_pointer);
-	glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglGetCompressedTexImageBO(JNIEnv *env, jclass clazz, jint target, jint lod, jint img_buffer_offset, jlong function_pointer) {
+	GLvoid *img_address = ((GLvoid *)offsetToPointer(img_buffer_offset));
+	glGetCompressedTexImagePROC glGetCompressedTexImage = (glGetCompressedTexImagePROC)((intptr_t)function_pointer);
+	glGetCompressedTexImage(target, lod, img_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexImage2D(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint imageSize, jobject data, jint data_position, jlong function_pointer) {
-	const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
-	glCompressedTexImage2DPROC glCompressedTexImage2D = (glCompressedTexImage2DPROC)((intptr_t)function_pointer);
-	glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglMultiTexCoord1f(JNIEnv *env, jclass clazz, jint target, jfloat s, jlong function_pointer) {
+	glMultiTexCoord1fPROC glMultiTexCoord1f = (glMultiTexCoord1fPROC)((intptr_t)function_pointer);
+	glMultiTexCoord1f(target, s);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexImage2DBO(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint imageSize, jint data_buffer_offset, jlong function_pointer) {
-	const GLvoid *data_address = ((const GLvoid *)offsetToPointer(data_buffer_offset));
-	glCompressedTexImage2DPROC glCompressedTexImage2D = (glCompressedTexImage2DPROC)((intptr_t)function_pointer);
-	glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglMultiTexCoord2f(JNIEnv *env, jclass clazz, jint target, jfloat s, jfloat t, jlong function_pointer) {
+	glMultiTexCoord2fPROC glMultiTexCoord2f = (glMultiTexCoord2fPROC)((intptr_t)function_pointer);
+	glMultiTexCoord2f(target, s, t);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexImage1D(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint border, jint imageSize, jobject data, jint data_position, jlong function_pointer) {
-	const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
-	glCompressedTexImage1DPROC glCompressedTexImage1D = (glCompressedTexImage1DPROC)((intptr_t)function_pointer);
-	glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglMultiTexCoord3f(JNIEnv *env, jclass clazz, jint target, jfloat s, jfloat t, jfloat r, jlong function_pointer) {
+	glMultiTexCoord3fPROC glMultiTexCoord3f = (glMultiTexCoord3fPROC)((intptr_t)function_pointer);
+	glMultiTexCoord3f(target, s, t, r);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexImage1DBO(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, jint width, jint border, jint imageSize, jint data_buffer_offset, jlong function_pointer) {
-	const GLvoid *data_address = ((const GLvoid *)offsetToPointer(data_buffer_offset));
-	glCompressedTexImage1DPROC glCompressedTexImage1D = (glCompressedTexImage1DPROC)((intptr_t)function_pointer);
-	glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglMultiTexCoord4f(JNIEnv *env, jclass clazz, jint target, jfloat s, jfloat t, jfloat r, jfloat q, jlong function_pointer) {
+	glMultiTexCoord4fPROC glMultiTexCoord4f = (glMultiTexCoord4fPROC)((intptr_t)function_pointer);
+	glMultiTexCoord4f(target, s, t, r, q);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglClientActiveTexture(JNIEnv *env, jclass clazz, jint texture, jlong function_pointer) {
-	glClientActiveTexturePROC glClientActiveTexture = (glClientActiveTexturePROC)((intptr_t)function_pointer);
-	glClientActiveTexture(texture);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglLoadTransposeMatrixf(JNIEnv *env, jclass clazz, jobject m, jint m_position, jlong function_pointer) {
+	const GLfloat *m_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, m)) + m_position;
+	glLoadTransposeMatrixfPROC glLoadTransposeMatrixf = (glLoadTransposeMatrixfPROC)((intptr_t)function_pointer);
+	glLoadTransposeMatrixf(m_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglActiveTexture(JNIEnv *env, jclass clazz, jint texture, jlong function_pointer) {
-	glActiveTexturePROC glActiveTexture = (glActiveTexturePROC)((intptr_t)function_pointer);
-	glActiveTexture(texture);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglMultTransposeMatrixf(JNIEnv *env, jclass clazz, jobject m, jint m_position, jlong function_pointer) {
+	const GLfloat *m_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, m)) + m_position;
+	glMultTransposeMatrixfPROC glMultTransposeMatrixf = (glMultTransposeMatrixfPROC)((intptr_t)function_pointer);
+	glMultTransposeMatrixf(m_address);
+}
+
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglSampleCoverage(JNIEnv *env, jclass clazz, jfloat value, jboolean invert, jlong function_pointer) {
+	glSampleCoveragePROC glSampleCoverage = (glSampleCoveragePROC)((intptr_t)function_pointer);
+	glSampleCoverage(value, invert);
 }
 

Index: org_lwjgl_opengl_GL15.c
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/org_lwjgl_opengl_GL15.c,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -d -r1.6 -r1.7
--- org_lwjgl_opengl_GL15.c	16 Feb 2005 20:25:04 -0000	1.6
+++ org_lwjgl_opengl_GL15.c	29 Jun 2005 07:39:25 -0000	1.7
@@ -3,77 +3,77 @@
 #include <jni.h>
 #include "extgl.h"
 
-typedef void (APIENTRY *glGetQueryObjectuivPROC) (GLenum id, GLenum pname, GLuint * params);
-typedef void (APIENTRY *glGetQueryObjectivPROC) (GLenum id, GLenum pname, GLint * params);
-typedef void (APIENTRY *glGetQueryivPROC) (GLenum target, GLenum pname, GLint * params);
-typedef void (APIENTRY *glEndQueryPROC) (GLenum target);
-typedef void (APIENTRY *glBeginQueryPROC) (GLenum target, GLuint id);
-typedef GLboolean (APIENTRY *glIsQueryPROC) (GLuint id);
-typedef void (APIENTRY *glDeleteQueriesPROC) (GLsizei n, GLuint * ids);
-typedef void (APIENTRY *glGenQueriesPROC) (GLsizei n, GLuint * ids);
-typedef void (APIENTRY *glGetBufferPointervPROC) (GLenum target, GLenum pname, GLvoid ** pointer);
-typedef void (APIENTRY *glGetBufferParameterivPROC) (GLenum target, GLenum pname, GLint * params);
-typedef GLboolean (APIENTRY *glUnmapBufferPROC) (GLenum target);
-typedef GLvoid * (APIENTRY *glMapBufferPROC) (GLenum target, GLenum access);
-typedef void (APIENTRY *glGetBufferSubDataPROC) (GLenum target, GLintptr offset, GLsizeiptr size, GLvoid * data);
-typedef void (APIENTRY *glBufferSubDataPROC) (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data);
-typedef void (APIENTRY *glBufferDataPROC) (GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage);
-typedef GLboolean (APIENTRY *glIsBufferPROC) (GLuint buffer);
-typedef void (APIENTRY *glGenBuffersPROC) (GLsizei n, GLuint * buffers);
-typedef void (APIENTRY *glDeleteBuffersPROC) (GLsizei n, const GLuint * buffers);
 typedef void (APIENTRY *glBindBufferPROC) (GLenum target, GLuint buffer);
+typedef void (APIENTRY *glDeleteBuffersPROC) (GLsizei n, const GLuint * buffers);
+typedef void (APIENTRY *glGenBuffersPROC) (GLsizei n, GLuint * buffers);
+typedef GLboolean (APIENTRY *glIsBufferPROC) (GLuint buffer);
+typedef void (APIENTRY *glBufferDataPROC) (GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage);
+typedef void (APIENTRY *glBufferSubDataPROC) (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data);
+typedef void (APIENTRY *glGetBufferSubDataPROC) (GLenum target, GLintptr offset, GLsizeiptr size, GLvoid * data);
+typedef GLvoid * (APIENTRY *glMapBufferPROC) (GLenum target, GLenum access);
+typedef GLboolean (APIENTRY *glUnmapBufferPROC) (GLenum target);
+typedef void (APIENTRY *glGetBufferParameterivPROC) (GLenum target, GLenum pname, GLint * params);
+typedef void (APIENTRY *glGetBufferPointervPROC) (GLenum target, GLenum pname, GLvoid ** pointer);
+typedef void (APIENTRY *glGenQueriesPROC) (GLsizei n, GLuint * ids);
+typedef void (APIENTRY *glDeleteQueriesPROC) (GLsizei n, GLuint * ids);
+typedef GLboolean (APIENTRY *glIsQueryPROC) (GLuint id);
+typedef void (APIENTRY *glBeginQueryPROC) (GLenum target, GLuint id);
+typedef void (APIENTRY *glEndQueryPROC) (GLenum target);
+typedef void (APIENTRY *glGetQueryivPROC) (GLenum target, GLenum pname, GLint * params);
+typedef void (APIENTRY *glGetQueryObjectivPROC) (GLenum id, GLenum pname, GLint * params);
+typedef void (APIENTRY *glGetQueryObjectuivPROC) (GLenum id, GLenum pname, GLuint * params);
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglGetQueryObjectuiv(JNIEnv *env, jclass clazz, jint id, jint pname, jobject params, jint params_position, jlong function_pointer) {
-	GLuint *params_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
-	glGetQueryObjectuivPROC glGetQueryObjectuiv = (glGetQueryObjectuivPROC)((intptr_t)function_pointer);
-	glGetQueryObjectuiv(id, pname, params_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglBindBuffer(JNIEnv *env, jclass clazz, jint target, jint buffer, jlong function_pointer) {
+	glBindBufferPROC glBindBuffer = (glBindBufferPROC)((intptr_t)function_pointer);
+	glBindBuffer(target, buffer);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglGetQueryObjectiv(JNIEnv *env, jclass clazz, jint id, jint pname, jobject params, jint params_position, jlong function_pointer) {
-	GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
-	glGetQueryObjectivPROC glGetQueryObjectiv = (glGetQueryObjectivPROC)((intptr_t)function_pointer);
-	glGetQueryObjectiv(id, pname, params_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglDeleteBuffers(JNIEnv *env, jclass clazz, jint n, jobject buffers, jint buffers_position, jlong function_pointer) {
+	const GLuint *buffers_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, buffers)) + buffers_position;
+	glDeleteBuffersPROC glDeleteBuffers = (glDeleteBuffersPROC)((intptr_t)function_pointer);
+	glDeleteBuffers(n, buffers_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglGetQueryiv(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
-	GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
-	glGetQueryivPROC glGetQueryiv = (glGetQueryivPROC)((intptr_t)function_pointer);
-	glGetQueryiv(target, pname, params_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglGenBuffers(JNIEnv *env, jclass clazz, jint n, jobject buffers, jint buffers_position, jlong function_pointer) {
+	GLuint *buffers_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, buffers)) + buffers_position;
+	glGenBuffersPROC glGenBuffers = (glGenBuffersPROC)((intptr_t)function_pointer);
+	glGenBuffers(n, buffers_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglEndQuery(JNIEnv *env, jclass clazz, jint target, jlong function_pointer) {
-	glEndQueryPROC glEndQuery = (glEndQueryPROC)((intptr_t)function_pointer);
-	glEndQuery(target);
+JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL15_nglIsBuffer(JNIEnv *env, jclass clazz, jint buffer, jlong function_pointer) {
+	glIsBufferPROC glIsBuffer = (glIsBufferPROC)((intptr_t)function_pointer);
+	GLboolean __result = glIsBuffer(buffer);
+	return __result;
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglBeginQuery(JNIEnv *env, jclass clazz, jint target, jint id, jlong function_pointer) {
-	glBeginQueryPROC glBeginQuery = (glBeginQueryPROC)((intptr_t)function_pointer);
-	glBeginQuery(target, id);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglBufferData(JNIEnv *env, jclass clazz, jint target, jint size, jobject data, jint data_position, jint usage, jlong function_pointer) {
+	const GLvoid *data_address = ((const GLvoid *)(((char *)safeGetBufferAddress(env, data)) + data_position));
+	glBufferDataPROC glBufferData = (glBufferDataPROC)((intptr_t)function_pointer);
+	glBufferData(target, size, data_address, usage);
 }
 
-JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL15_nglIsQuery(JNIEnv *env, jclass clazz, jint id, jlong function_pointer) {
-	glIsQueryPROC glIsQuery = (glIsQueryPROC)((intptr_t)function_pointer);
-	GLboolean __result = glIsQuery(id);
-	return __result;
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglBufferSubData(JNIEnv *env, jclass clazz, jint target, jint offset, jint size, jobject data, jint data_position, jlong function_pointer) {
+	const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
+	glBufferSubDataPROC glBufferSubData = (glBufferSubDataPROC)((intptr_t)function_pointer);
+	glBufferSubData(target, offset, size, data_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglDeleteQueries(JNIEnv *env, jclass clazz, jint n, jobject ids, jint ids_position, jlong function_pointer) {
-	GLuint *ids_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, ids)) + ids_position;
-	glDeleteQueriesPROC glDeleteQueries = (glDeleteQueriesPROC)((intptr_t)function_pointer);
-	glDeleteQueries(n, ids_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglGetBufferSubData(JNIEnv *env, jclass clazz, jint target, jint offset, jint size, jobject data, jint data_position, jlong function_pointer) {
+	GLvoid *data_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
+	glGetBufferSubDataPROC glGetBufferSubData = (glGetBufferSubDataPROC)((intptr_t)function_pointer);
+	glGetBufferSubData(target, offset, size, data_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglGenQueries(JNIEnv *env, jclass clazz, jint n, jobject ids, jint ids_position, jlong function_pointer) {
-	GLuint *ids_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, ids)) + ids_position;
-	glGenQueriesPROC glGenQueries = (glGenQueriesPROC)((intptr_t)function_pointer);
-	glGenQueries(n, ids_address);
+JNIEXPORT jobject JNICALL Java_org_lwjgl_opengl_GL15_nglMapBuffer(JNIEnv *env, jclass clazz, jint target, jint access, jint result_size, jobject old_buffer, jlong function_pointer) {
+	glMapBufferPROC glMapBuffer = (glMapBufferPROC)((intptr_t)function_pointer);
+	GLvoid * __result = glMapBuffer(target, access);
+	return safeNewBufferCached(env, __result, result_size, old_buffer);
 }
 
-JNIEXPORT jobject JNICALL Java_org_lwjgl_opengl_GL15_nglGetBufferPointerv(JNIEnv *env, jclass clazz, jint target, jint pname, jint result_size, jlong function_pointer) {
-	glGetBufferPointervPROC glGetBufferPointerv = (glGetBufferPointervPROC)((intptr_t)function_pointer);
-	GLvoid * __result;
-	glGetBufferPointerv(target, pname, &__result);
-	return safeNewBuffer(env, __result, result_size);
+JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL15_nglUnmapBuffer(JNIEnv *env, jclass clazz, jint target, jlong function_pointer) {
+	glUnmapBufferPROC glUnmapBuffer = (glUnmapBufferPROC)((intptr_t)function_pointer);
+	GLboolean __result = glUnmapBuffer(target);
+	return __result;
 }
 
 JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglGetBufferParameteriv(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
@@ -82,56 +82,56 @@
 	glGetBufferParameteriv(target, pname, params_address);
 }
 
-JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL15_nglUnmapBuffer(JNIEnv *env, jclass clazz, jint target, jlong function_pointer) {
-	glUnmapBufferPROC glUnmapBuffer = (glUnmapBufferPROC)((intptr_t)function_pointer);
-	GLboolean __result = glUnmapBuffer(target);
-	return __result;
+JNIEXPORT jobject JNICALL Java_org_lwjgl_opengl_GL15_nglGetBufferPointerv(JNIEnv *env, jclass clazz, jint target, jint pname, jint result_size, jlong function_pointer) {
+	glGetBufferPointervPROC glGetBufferPointerv = (glGetBufferPointervPROC)((intptr_t)function_pointer);
+	GLvoid * __result;
+	glGetBufferPointerv(target, pname, &__result);
+	return safeNewBuffer(env, __result, result_size);
 }
 
-JNIEXPORT jobject JNICALL Java_org_lwjgl_opengl_GL15_nglMapBuffer(JNIEnv *env, jclass clazz, jint target, jint access, jint result_size, jobject old_buffer, jlong function_pointer) {
-	glMapBufferPROC glMapBuffer = (glMapBufferPROC)((intptr_t)function_pointer);
-	GLvoid * __result = glMapBuffer(target, access);
-	return safeNewBufferCached(env, __result, result_size, old_buffer);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglGenQueries(JNIEnv *env, jclass clazz, jint n, jobject ids, jint ids_position, jlong function_pointer) {
+	GLuint *ids_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, ids)) + ids_position;
+	glGenQueriesPROC glGenQueries = (glGenQueriesPROC)((intptr_t)function_pointer);
+	glGenQueries(n, ids_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglGetBufferSubData(JNIEnv *env, jclass clazz, jint target, jint offset, jint size, jobject data, jint data_position, jlong function_pointer) {
-	GLvoid *data_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
-	glGetBufferSubDataPROC glGetBufferSubData = (glGetBufferSubDataPROC)((intptr_t)function_pointer);
-	glGetBufferSubData(target, offset, size, data_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglDeleteQueries(JNIEnv *env, jclass clazz, jint n, jobject ids, jint ids_position, jlong function_pointer) {
+	GLuint *ids_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, ids)) + ids_position;
+	glDeleteQueriesPROC glDeleteQueries = (glDeleteQueriesPROC)((intptr_t)function_pointer);
+	glDeleteQueries(n, ids_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglBufferSubData(JNIEnv *env, jclass clazz, jint target, jint offset, jint size, jobject data, jint data_position, jlong function_pointer) {
-	const GLvoid *data_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
-	glBufferSubDataPROC glBufferSubData = (glBufferSubDataPROC)((intptr_t)function_pointer);
-	glBufferSubData(target, offset, size, data_address);
+JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL15_nglIsQuery(JNIEnv *env, jclass clazz, jint id, jlong function_pointer) {
+	glIsQueryPROC glIsQuery = (glIsQueryPROC)((intptr_t)function_pointer);
+	GLboolean __result = glIsQuery(id);
+	return __result;
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglBufferData(JNIEnv *env, jclass clazz, jint target, jint size, jobject data, jint data_position, jint usage, jlong function_pointer) {
-	const GLvoid *data_address = ((const GLvoid *)(((char *)safeGetBufferAddress(env, data)) + data_position));
-	glBufferDataPROC glBufferData = (glBufferDataPROC)((intptr_t)function_pointer);
-	glBufferData(target, size, data_address, usage);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglBeginQuery(JNIEnv *env, jclass clazz, jint target, jint id, jlong function_pointer) {
+	glBeginQueryPROC glBeginQuery = (glBeginQueryPROC)((intptr_t)function_pointer);
+	glBeginQuery(target, id);
 }
 
-JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL15_nglIsBuffer(JNIEnv *env, jclass clazz, jint buffer, jlong function_pointer) {
-	glIsBufferPROC glIsBuffer = (glIsBufferPROC)((intptr_t)function_pointer);
-	GLboolean __result = glIsBuffer(buffer);
-	return __result;
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglEndQuery(JNIEnv *env, jclass clazz, jint target, jlong function_pointer) {
+	glEndQueryPROC glEndQuery = (glEndQueryPROC)((intptr_t)function_pointer);
+	glEndQuery(target);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglGenBuffers(JNIEnv *env, jclass clazz, jint n, jobject buffers, jint buffers_position, jlong function_pointer) {
-	GLuint *buffers_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, buffers)) + buffers_position;
-	glGenBuffersPROC glGenBuffers = (glGenBuffersPROC)((intptr_t)function_pointer);
-	glGenBuffers(n, buffers_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglGetQueryiv(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
+	GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
+	glGetQueryivPROC glGetQueryiv = (glGetQueryivPROC)((intptr_t)function_pointer);
+	glGetQueryiv(target, pname, params_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglDeleteBuffers(JNIEnv *env, jclass clazz, jint n, jobject buffers, jint buffers_position, jlong function_pointer) {
-	const GLuint *buffers_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, buffers)) + buffers_position;
-	glDeleteBuffersPROC glDeleteBuffers = (glDeleteBuffersPROC)((intptr_t)function_pointer);
-	glDeleteBuffers(n, buffers_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglGetQueryObjectiv(JNIEnv *env, jclass clazz, jint id, jint pname, jobject params, jint params_position, jlong function_pointer) {
+	GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
+	glGetQueryObjectivPROC glGetQueryObjectiv = (glGetQueryObjectivPROC)((intptr_t)function_pointer);
+	glGetQueryObjectiv(id, pname, params_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglBindBuffer(JNIEnv *env, jclass clazz, jint target, jint buffer, jlong function_pointer) {
-	glBindBufferPROC glBindBuffer = (glBindBufferPROC)((intptr_t)function_pointer);
-	glBindBuffer(target, buffer);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglGetQueryObjectuiv(JNIEnv *env, jclass clazz, jint id, jint pname, jobject params, jint params_position, jlong function_pointer) {
+	GLuint *params_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
+	glGetQueryObjectuivPROC glGetQueryObjectuiv = (glGetQueryObjectuivPROC)((intptr_t)function_pointer);
+	glGetQueryObjectuiv(id, pname, params_address);
 }
 

Index: org_lwjgl_openal_AL10.c
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/org_lwjgl_openal_AL10.c,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -d -r1.7 -r1.8
--- org_lwjgl_openal_AL10.c	12 Apr 2005 10:55:23 -0000	1.7
+++ org_lwjgl_openal_AL10.c	29 Jun 2005 07:39:24 -0000	1.8
@@ -3,213 +3,219 @@
 #include <jni.h>
 #include "extal.h"
 
-typedef ALvoid (ALAPIENTRY *alDopplerVelocityPROC) (ALfloat value);
-typedef ALvoid (ALAPIENTRY *alDopplerFactorPROC) (ALfloat value);
-typedef ALvoid (ALAPIENTRY *alDistanceModelPROC) (ALenum value);
-typedef ALvoid (ALAPIENTRY *alSourceUnqueueBuffersPROC) (ALuint source, ALsizei n, ALuint * buffers);
-typedef ALvoid (ALAPIENTRY *alSourceQueueBuffersPROC) (ALuint source, ALsizei n, ALuint * buffers);
-typedef ALvoid (ALAPIENTRY *alGetBufferfPROC) (ALuint buffer, ALenum pname, ALfloat* value);
-typedef ALvoid (ALAPIENTRY *alGetBufferiPROC) (ALuint buffer, ALenum pname, ALint* value);
-typedef ALvoid (ALAPIENTRY *alBufferDataPROC) (ALuint buffer, ALenum format, ALvoid * data, ALsizei size, ALsizei freq);
-typedef ALboolean (ALAPIENTRY *alIsBufferPROC) (ALuint buffer);
-typ...
 
[truncated message content]

Update of /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/openal
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv24153/src/java/org/lwjgl/openal

Modified Files:
	AL10.java 
Log Message:
Mac OS X: Handle MouseEvent.NOBUTTON case

Index: AL10.java
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/openal/AL10.java,v
retrieving revision 1.15
retrieving revision 1.16
diff -u -d -r1.15 -r1.16
--- AL10.java	5 May 2005 10:02:36 -0000	1.15
+++ AL10.java	29 Jun 2005 07:39:18 -0000	1.16
@@ -8,310 +8,310 @@
 
 public final class AL10 {
 	/**
-	 *Distance model 
+	 *Bad value 
 	 */
-	public static final int AL_INVERSE_DISTANCE_CLAMPED = 0xd002;
+	public static final int AL_INVALID = 0xffffffff;
 	/**
-	 *Distance model 
+	 *Disable value 
[...2127 lines suppressed...]
+	 * AL_DOPPLER_VELOCITY allows the application to change the reference (propagation)
+	 * velocity used in the Doppler Effect calculation. This permits the application to use a
+	 * velocity scale appropriate to its purposes.
+	 * </p>
+	 * <p>
+	 * A negative or zero value will result in an AL_INVALID_VALUE error, the command is
+	 * then ignored. The default value is 1. The current setting can be queried using
+	 * GetFloatv and AL_DOPPLER_VELOCITY.
+	 * </p>
+	 * @param value Doppler velocity value to set
 	 */
-	public static void alEnable(int capability) {
-		nalEnable(capability);
+	public static void alDopplerVelocity(float value) {
+		nalDopplerVelocity(value);
 		Util.checkALError();
 	}
-	private static native void nalEnable(int capability);
+	private static native void nalDopplerVelocity(float value);
 }

Update of /cvsroot/java-game-lib/LWJGL/src/native/common/ati
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv24153/src/native/common/ati

Modified Files:
	org_lwjgl_opengl_ATIElementArray.c 
	org_lwjgl_opengl_ATIEnvmapBumpmap.c 
	org_lwjgl_opengl_ATIFragmentShader.c 
	org_lwjgl_opengl_ATIMapObjectBuffer.c 
	org_lwjgl_opengl_ATIPnTriangles.c 
	org_lwjgl_opengl_ATISeparateStencil.c 
	org_lwjgl_opengl_ATIVertexArrayObject.c 
	org_lwjgl_opengl_ATIVertexAttribArrayObject.c 
	org_lwjgl_opengl_ATIVertexStreams.c 
Log Message:
Mac OS X: Handle MouseEvent.NOBUTTON case

Index: org_lwjgl_opengl_ATIElementArray.c
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/ati/org_lwjgl_opengl_ATIElementArray.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- org_lwjgl_opengl_ATIElementArray.c	16 Feb 2005 20:24:53 -0000	1.4
+++ org_lwjgl_opengl_ATIElementArray.c	29 Jun 2005 07:39:26 -0000	1.5
@@ -3,19 +3,9 @@
 #include <jni.h>
 #include "extgl.h"
 
-typedef void (APIENTRY *glDrawRangeElementArrayATIPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count);
-typedef void (APIENTRY *glDrawElementArrayATIPROC) (GLenum mode, GLsizei count);
 typedef void (APIENTRY *glElementPointerATIPROC) (GLenum type, const GLvoid * pPointer);
-
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIElementArray_nglDrawRangeElementArrayATI(JNIEnv *env, jclass clazz, jint mode, jint start, jint end, jint count, jlong function_pointer) {
-	glDrawRangeElementArrayATIPROC glDrawRangeElementArrayATI = (glDrawRangeElementArrayATIPROC)((intptr_t)function_pointer);
-	glDrawRangeElementArrayATI(mode, start, end, count);
-}
-
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIElementArray_nglDrawElementArrayATI(JNIEnv *env, jclass clazz, jint mode, jint count, jlong function_pointer) {
-	glDrawElementArrayATIPROC glDrawElementArrayATI = (glDrawElementArrayATIPROC)((intptr_t)function_pointer);
-	glDrawElementArrayATI(mode, count);
-}
+typedef void (APIENTRY *glDrawElementArrayATIPROC) (GLenum mode, GLsizei count);
+typedef void (APIENTRY *glDrawRangeElementArrayATIPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count);
 
 JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIElementArray_nglElementPointerATI(JNIEnv *env, jclass clazz, jint type, jobject pPointer, jint pPointer_position, jlong function_pointer) {
 	const GLvoid *pPointer_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pPointer)) + pPointer_position));
@@ -29,3 +19,13 @@
 	glElementPointerATI(type, pPointer_address);
 }
 
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIElementArray_nglDrawElementArrayATI(JNIEnv *env, jclass clazz, jint mode, jint count, jlong function_pointer) {
+	glDrawElementArrayATIPROC glDrawElementArrayATI = (glDrawElementArrayATIPROC)((intptr_t)function_pointer);
+	glDrawElementArrayATI(mode, count);
+}
+
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIElementArray_nglDrawRangeElementArrayATI(JNIEnv *env, jclass clazz, jint mode, jint start, jint end, jint count, jlong function_pointer) {
+	glDrawRangeElementArrayATIPROC glDrawRangeElementArrayATI = (glDrawRangeElementArrayATIPROC)((intptr_t)function_pointer);
+	glDrawRangeElementArrayATI(mode, start, end, count);
+}
+

Index: org_lwjgl_opengl_ATIEnvmapBumpmap.c
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/ati/org_lwjgl_opengl_ATIEnvmapBumpmap.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- org_lwjgl_opengl_ATIEnvmapBumpmap.c	16 Feb 2005 20:24:53 -0000	1.4
+++ org_lwjgl_opengl_ATIEnvmapBumpmap.c	29 Jun 2005 07:39:26 -0000	1.5
@@ -3,21 +3,15 @@
 #include <jni.h>
 #include "extgl.h"
 
-typedef void (APIENTRY *glGetTexBumpParameterivATIPROC) (GLenum pname, GLint * param);
-typedef void (APIENTRY *glGetTexBumpParameterfvATIPROC) (GLenum pname, GLfloat * param);
-typedef void (APIENTRY *glTexBumpParameterivATIPROC) (GLenum pname, GLint * param);
 typedef void (APIENTRY *glTexBumpParameterfvATIPROC) (GLenum pname, GLfloat * param);
+typedef void (APIENTRY *glTexBumpParameterivATIPROC) (GLenum pname, GLint * param);
+typedef void (APIENTRY *glGetTexBumpParameterfvATIPROC) (GLenum pname, GLfloat * param);
+typedef void (APIENTRY *glGetTexBumpParameterivATIPROC) (GLenum pname, GLint * param);
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIEnvmapBumpmap_nglGetTexBumpParameterivATI(JNIEnv *env, jclass clazz, jint pname, jobject param, jint param_position, jlong function_pointer) {
-	GLint *param_address = ((GLint *)(*env)->GetDirectBufferAddress(env, param)) + param_position;
-	glGetTexBumpParameterivATIPROC glGetTexBumpParameterivATI = (glGetTexBumpParameterivATIPROC)((intptr_t)function_pointer);
-	glGetTexBumpParameterivATI(pname, param_address);
-}
-
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIEnvmapBumpmap_nglGetTexBumpParameterfvATI(JNIEnv *env, jclass clazz, jint pname, jobject param, jint param_position, jlong function_pointer) {
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIEnvmapBumpmap_nglTexBumpParameterfvATI(JNIEnv *env, jclass clazz, jint pname, jobject param, jint param_position, jlong function_pointer) {
 	GLfloat *param_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, param)) + param_position;
-	glGetTexBumpParameterfvATIPROC glGetTexBumpParameterfvATI = (glGetTexBumpParameterfvATIPROC)((intptr_t)function_pointer);
-	glGetTexBumpParameterfvATI(pname, param_address);
+	glTexBumpParameterfvATIPROC glTexBumpParameterfvATI = (glTexBumpParameterfvATIPROC)((intptr_t)function_pointer);
+	glTexBumpParameterfvATI(pname, param_address);
 }
 
 JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIEnvmapBumpmap_nglTexBumpParameterivATI(JNIEnv *env, jclass clazz, jint pname, jobject param, jint param_position, jlong function_pointer) {
@@ -26,9 +20,15 @@
 	glTexBumpParameterivATI(pname, param_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIEnvmapBumpmap_nglTexBumpParameterfvATI(JNIEnv *env, jclass clazz, jint pname, jobject param, jint param_position, jlong function_pointer) {
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIEnvmapBumpmap_nglGetTexBumpParameterfvATI(JNIEnv *env, jclass clazz, jint pname, jobject param, jint param_position, jlong function_pointer) {
 	GLfloat *param_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, param)) + param_position;
-	glTexBumpParameterfvATIPROC glTexBumpParameterfvATI = (glTexBumpParameterfvATIPROC)((intptr_t)function_pointer);
-	glTexBumpParameterfvATI(pname, param_address);
+	glGetTexBumpParameterfvATIPROC glGetTexBumpParameterfvATI = (glGetTexBumpParameterfvATIPROC)((intptr_t)function_pointer);
+	glGetTexBumpParameterfvATI(pname, param_address);
+}
+
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIEnvmapBumpmap_nglGetTexBumpParameterivATI(JNIEnv *env, jclass clazz, jint pname, jobject param, jint param_position, jlong function_pointer) {
+	GLint *param_address = ((GLint *)(*env)->GetDirectBufferAddress(env, param)) + param_position;
+	glGetTexBumpParameterivATIPROC glGetTexBumpParameterivATI = (glGetTexBumpParameterivATIPROC)((intptr_t)function_pointer);
+	glGetTexBumpParameterivATI(pname, param_address);
 }
 

Index: org_lwjgl_opengl_ATIVertexAttribArrayObject.c
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/ati/org_lwjgl_opengl_ATIVertexAttribArrayObject.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- org_lwjgl_opengl_ATIVertexAttribArrayObject.c	16 Feb 2005 20:24:55 -0000	1.4
+++ org_lwjgl_opengl_ATIVertexAttribArrayObject.c	29 Jun 2005 07:39:26 -0000	1.5
@@ -3,14 +3,13 @@
 #include <jni.h>
 #include "extgl.h"
 
-typedef void (APIENTRY *glGetVertexAttribArrayObjectivATIPROC) (GLuint index, GLenum pname, GLint * params);
-typedef void (APIENTRY *glGetVertexAttribArrayObjectfvATIPROC) (GLuint index, GLenum pname, GLfloat * params);
 typedef void (APIENTRY *glVertexAttribArrayObjectATIPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset);
+typedef void (APIENTRY *glGetVertexAttribArrayObjectfvATIPROC) (GLuint index, GLenum pname, GLfloat * params);
+typedef void (APIENTRY *glGetVertexAttribArrayObjectivATIPROC) (GLuint index, GLenum pname, GLint * params);
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexAttribArrayObject_nglGetVertexAttribArrayObjectivATI(JNIEnv *env, jclass clazz, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
-	GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
-	glGetVertexAttribArrayObjectivATIPROC glGetVertexAttribArrayObjectivATI = (glGetVertexAttribArrayObjectivATIPROC)((intptr_t)function_pointer);
-	glGetVertexAttribArrayObjectivATI(index, pname, params_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexAttribArrayObject_nglVertexAttribArrayObjectATI(JNIEnv *env, jclass clazz, jint index, jint size, jint type, jboolean normalized, jint stride, jint buffer, jint offset, jlong function_pointer) {
+	glVertexAttribArrayObjectATIPROC glVertexAttribArrayObjectATI = (glVertexAttribArrayObjectATIPROC)((intptr_t)function_pointer);
+	glVertexAttribArrayObjectATI(index, size, type, normalized, stride, buffer, offset);
 }
 
 JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexAttribArrayObject_nglGetVertexAttribArrayObjectfvATI(JNIEnv *env, jclass clazz, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
@@ -19,8 +18,9 @@
 	glGetVertexAttribArrayObjectfvATI(index, pname, params_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexAttribArrayObject_nglVertexAttribArrayObjectATI(JNIEnv *env, jclass clazz, jint index, jint size, jint type, jboolean normalized, jint stride, jint buffer, jint offset, jlong function_pointer) {
-	glVertexAttribArrayObjectATIPROC glVertexAttribArrayObjectATI = (glVertexAttribArrayObjectATIPROC)((intptr_t)function_pointer);
-	glVertexAttribArrayObjectATI(index, size, type, normalized, stride, buffer, offset);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexAttribArrayObject_nglGetVertexAttribArrayObjectivATI(JNIEnv *env, jclass clazz, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
+	GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
+	glGetVertexAttribArrayObjectivATIPROC glGetVertexAttribArrayObjectivATI = (glGetVertexAttribArrayObjectivATIPROC)((intptr_t)function_pointer);
+	glGetVertexAttribArrayObjectivATI(index, pname, params_address);
 }
 

Index: org_lwjgl_opengl_ATIPnTriangles.c
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/ati/org_lwjgl_opengl_ATIPnTriangles.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- org_lwjgl_opengl_ATIPnTriangles.c	16 Feb 2005 20:24:55 -0000	1.4
+++ org_lwjgl_opengl_ATIPnTriangles.c	29 Jun 2005 07:39:26 -0000	1.5
@@ -3,16 +3,16 @@
 #include <jni.h>
 #include "extgl.h"
 
-typedef void (APIENTRY *glPNTrianglesiATIPROC) (GLenum pname, GLint param);
 typedef void (APIENTRY *glPNTrianglesfATIPROC) (GLenum pname, GLfloat param);
-
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIPnTriangles_nglPNTrianglesiATI(JNIEnv *env, jclass clazz, jint pname, jint param, jlong function_pointer) {
-	glPNTrianglesiATIPROC glPNTrianglesiATI = (glPNTrianglesiATIPROC)((intptr_t)function_pointer);
-	glPNTrianglesiATI(pname, param);
-}
+typedef void (APIENTRY *glPNTrianglesiATIPROC) (GLenum pname, GLint param);
 
 JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIPnTriangles_nglPNTrianglesfATI(JNIEnv *env, jclass clazz, jint pname, jfloat param, jlong function_pointer) {
 	glPNTrianglesfATIPROC glPNTrianglesfATI = (glPNTrianglesfATIPROC)((intptr_t)function_pointer);
 	glPNTrianglesfATI(pname, param);
 }
 
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIPnTriangles_nglPNTrianglesiATI(JNIEnv *env, jclass clazz, jint pname, jint param, jlong function_pointer) {
+	glPNTrianglesiATIPROC glPNTrianglesiATI = (glPNTrianglesiATIPROC)((intptr_t)function_pointer);
+	glPNTrianglesiATI(pname, param);
+}
+

Index: org_lwjgl_opengl_ATIMapObjectBuffer.c
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/ati/org_lwjgl_opengl_ATIMapObjectBuffer.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- org_lwjgl_opengl_ATIMapObjectBuffer.c	16 Feb 2005 20:24:55 -0000	1.4
+++ org_lwjgl_opengl_ATIMapObjectBuffer.c	29 Jun 2005 07:39:26 -0000	1.5
@@ -3,13 +3,8 @@
 #include <jni.h>
 #include "extgl.h"
 
-typedef void (APIENTRY *glUnmapObjectBufferATIPROC) (GLuint buffer);
 typedef GLvoid * (APIENTRY *glMapObjectBufferATIPROC) (GLuint buffer);
-
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIMapObjectBuffer_nglUnmapObjectBufferATI(JNIEnv *env, jclass clazz, jint buffer, jlong function_pointer) {
-	glUnmapObjectBufferATIPROC glUnmapObjectBufferATI = (glUnmapObjectBufferATIPROC)((intptr_t)function_pointer);
-	glUnmapObjectBufferATI(buffer);
-}
+typedef void (APIENTRY *glUnmapObjectBufferATIPROC) (GLuint buffer);
 
 JNIEXPORT jobject JNICALL Java_org_lwjgl_opengl_ATIMapObjectBuffer_nglMapObjectBufferATI(JNIEnv *env, jclass clazz, jint buffer, jint result_size, jobject old_buffer, jlong function_pointer) {
 	glMapObjectBufferATIPROC glMapObjectBufferATI = (glMapObjectBufferATIPROC)((intptr_t)function_pointer);
@@ -17,3 +12,8 @@
 	return safeNewBufferCached(env, __result, result_size, old_buffer);
 }
 
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIMapObjectBuffer_nglUnmapObjectBufferATI(JNIEnv *env, jclass clazz, jint buffer, jlong function_pointer) {
+	glUnmapObjectBufferATIPROC glUnmapObjectBufferATI = (glUnmapObjectBufferATIPROC)((intptr_t)function_pointer);
+	glUnmapObjectBufferATI(buffer);
+}
+

Index: org_lwjgl_opengl_ATISeparateStencil.c
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/ati/org_lwjgl_opengl_ATISeparateStencil.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- org_lwjgl_opengl_ATISeparateStencil.c	16 Feb 2005 20:24:55 -0000	1.4
+++ org_lwjgl_opengl_ATISeparateStencil.c	29 Jun 2005 07:39:26 -0000	1.5
@@ -3,16 +3,16 @@
 #include <jni.h>
 #include "extgl.h"
 
-typedef void (APIENTRY *glStencilFuncSeparateATIPROC) (GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask);
 typedef void (APIENTRY *glStencilOpSeparateATIPROC) (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATISeparateStencil_nglStencilFuncSeparateATI(JNIEnv *env, jclass clazz, jint frontfunc, jint backfunc, jint ref, jint mask, jlong function_pointer) {
-	glStencilFuncSeparateATIPROC glStencilFuncSeparateATI = (glStencilFuncSeparateATIPROC)((intptr_t)function_pointer);
-	glStencilFuncSeparateATI(frontfunc, backfunc, ref, mask);
-}
+typedef void (APIENTRY *glStencilFuncSeparateATIPROC) (GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask);
 
 JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATISeparateStencil_nglStencilOpSeparateATI(JNIEnv *env, jclass clazz, jint face, jint sfail, jint dpfail, jint dppass, jlong function_pointer) {
 	glStencilOpSeparateATIPROC glStencilOpSeparateATI = (glStencilOpSeparateATIPROC)((intptr_t)function_pointer);
 	glStencilOpSeparateATI(face, sfail, dpfail, dppass);
 }
 
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATISeparateStencil_nglStencilFuncSeparateATI(JNIEnv *env, jclass clazz, jint frontfunc, jint backfunc, jint ref, jint mask, jlong function_pointer) {
+	glStencilFuncSeparateATIPROC glStencilFuncSeparateATI = (glStencilFuncSeparateATIPROC)((intptr_t)function_pointer);
+	glStencilFuncSeparateATI(frontfunc, backfunc, ref, mask);
+}
+

Index: org_lwjgl_opengl_ATIVertexArrayObject.c
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/ati/org_lwjgl_opengl_ATIVertexArrayObject.c,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -d -r1.6 -r1.7
--- org_lwjgl_opengl_ATIVertexArrayObject.c	16 Feb 2005 20:24:55 -0000	1.6
+++ org_lwjgl_opengl_ATIVertexArrayObject.c	29 Jun 2005 07:39:26 -0000	1.7
@@ -3,51 +3,48 @@
 #include <jni.h>
 #include "extgl.h"
 
-typedef void (APIENTRY *glGetVariantArrayObjectivATIPROC) (GLuint id, GLenum pname, GLint * params);
-typedef void (APIENTRY *glGetVariantArrayObjectfvATIPROC) (GLuint id, GLenum pname, GLfloat * params);
-typedef void (APIENTRY *glVariantArrayObjectATIPROC) (GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset);
-typedef void (APIENTRY *glGetArrayObjectivATIPROC) (GLenum array, GLenum pname, GLint * params);
-typedef void (APIENTRY *glGetArrayObjectfvATIPROC) (GLenum array, GLenum pname, GLfloat * params);
-typedef void (APIENTRY *glArrayObjectATIPROC) (GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset);
-typedef void (APIENTRY *glFreeObjectBufferATIPROC) (GLuint buffer);
-typedef void (APIENTRY *glGetObjectBufferivATIPROC) (GLuint buffer, GLenum pname, GLint * params);
-typedef void (APIENTRY *glGetObjectBufferfvATIPROC) (GLuint buffer, GLenum pname, GLfloat * params);
-typedef void (APIENTRY *glUpdateObjectBufferATIPROC) (GLuint buffer, GLuint offset, GLsizei size, const GLvoid * pPointer, GLenum preserve);
-typedef GLboolean (APIENTRY *glIsObjectBufferATIPROC) (GLuint buffer);
 typedef GLuint (APIENTRY *glNewObjectBufferATIPROC) (GLsizei size, const GLvoid * pPointer, GLenum usage);
+typedef GLboolean (APIENTRY *glIsObjectBufferATIPROC) (GLuint buffer);
+typedef void (APIENTRY *glUpdateObjectBufferATIPROC) (GLuint buffer, GLuint offset, GLsizei size, const GLvoid * pPointer, GLenum preserve);
+typedef void (APIENTRY *glGetObjectBufferfvATIPROC) (GLuint buffer, GLenum pname, GLfloat * params);
+typedef void (APIENTRY *glGetObjectBufferivATIPROC) (GLuint buffer, GLenum pname, GLint * params);
+typedef void (APIENTRY *glFreeObjectBufferATIPROC) (GLuint buffer);
+typedef void (APIENTRY *glArrayObjectATIPROC) (GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset);
+typedef void (APIENTRY *glGetArrayObjectfvATIPROC) (GLenum array, GLenum pname, GLfloat * params);
+typedef void (APIENTRY *glGetArrayObjectivATIPROC) (GLenum array, GLenum pname, GLint * params);
+typedef void (APIENTRY *glVariantArrayObjectATIPROC) (GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset);
+typedef void (APIENTRY *glGetVariantArrayObjectfvATIPROC) (GLuint id, GLenum pname, GLfloat * params);
+typedef void (APIENTRY *glGetVariantArrayObjectivATIPROC) (GLuint id, GLenum pname, GLint * params);
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglGetVariantArrayObjectivATI(JNIEnv *env, jclass clazz, jint id, jint pname, jobject params, jint params_position, jlong function_pointer) {
-	GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
-	glGetVariantArrayObjectivATIPROC glGetVariantArrayObjectivATI = (glGetVariantArrayObjectivATIPROC)((intptr_t)function_pointer);
-	glGetVariantArrayObjectivATI(id, pname, params_address);
-}
-
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglGetVariantArrayObjectfvATI(JNIEnv *env, jclass clazz, jint id, jint pname, jobject params, jint params_position, jlong function_pointer) {
-	GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
-	glGetVariantArrayObjectfvATIPROC glGetVariantArrayObjectfvATI = (glGetVariantArrayObjectfvATIPROC)((intptr_t)function_pointer);
-	glGetVariantArrayObjectfvATI(id, pname, params_address);
+JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglNewObjectBufferATI(JNIEnv *env, jclass clazz, jint size, jobject pPointer, jint pPointer_position, jint usage, jlong function_pointer) {
+	const GLvoid *pPointer_address = ((const GLvoid *)(((char *)safeGetBufferAddress(env, pPointer)) + pPointer_position));
+	glNewObjectBufferATIPROC glNewObjectBufferATI = (glNewObjectBufferATIPROC)((intptr_t)function_pointer);
+	GLuint __result = glNewObjectBufferATI(size, pPointer_address, usage);
+	return __result;
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglVariantArrayObjectATI(JNIEnv *env, jclass clazz, jint id, jint type, jint stride, jint buffer, jint offset, jlong function_pointer) {
-	glVariantArrayObjectATIPROC glVariantArrayObjectATI = (glVariantArrayObjectATIPROC)((intptr_t)function_pointer);
-	glVariantArrayObjectATI(id, type, stride, buffer, offset);
+JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglIsObjectBufferATI(JNIEnv *env, jclass clazz, jint buffer, jlong function_pointer) {
+	glIsObjectBufferATIPROC glIsObjectBufferATI = (glIsObjectBufferATIPROC)((intptr_t)function_pointer);
+	GLboolean __result = glIsObjectBufferATI(buffer);
+	return __result;
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglGetArrayObjectivATI(JNIEnv *env, jclass clazz, jint array, jint pname, jobject params, jint params_position, jlong function_pointer) {
-	GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
-	glGetArrayObjectivATIPROC glGetArrayObjectivATI = (glGetArrayObjectivATIPROC)((intptr_t)function_pointer);
-	glGetArrayObjectivATI(array, pname, params_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglUpdateObjectBufferATI(JNIEnv *env, jclass clazz, jint buffer, jint offset, jint size, jobject pPointer, jint pPointer_position, jint preserve, jlong function_pointer) {
+	const GLvoid *pPointer_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pPointer)) + pPointer_position));
+	glUpdateObjectBufferATIPROC glUpdateObjectBufferATI = (glUpdateObjectBufferATIPROC)((intptr_t)function_pointer);
+	glUpdateObjectBufferATI(buffer, offset, size, pPointer_address, preserve);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglGetArrayObjectfvATI(JNIEnv *env, jclass clazz, jint array, jint pname, jobject params, jint params_position, jlong function_pointer) {
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglGetObjectBufferfvATI(JNIEnv *env, jclass clazz, jint buffer, jint pname, jobject params, jint params_position, jlong function_pointer) {
 	GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
-	glGetArrayObjectfvATIPROC glGetArrayObjectfvATI = (glGetArrayObjectfvATIPROC)((intptr_t)function_pointer);
-	glGetArrayObjectfvATI(array, pname, params_address);
+	glGetObjectBufferfvATIPROC glGetObjectBufferfvATI = (glGetObjectBufferfvATIPROC)((intptr_t)function_pointer);
+	glGetObjectBufferfvATI(buffer, pname, params_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglArrayObjectATI(JNIEnv *env, jclass clazz, jint array, jint size, jint type, jint stride, jint buffer, jint offset, jlong function_pointer) {
-	glArrayObjectATIPROC glArrayObjectATI = (glArrayObjectATIPROC)((intptr_t)function_pointer);
-	glArrayObjectATI(array, size, type, stride, buffer, offset);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglGetObjectBufferivATI(JNIEnv *env, jclass clazz, jint buffer, jint pname, jobject params, jint params_position, jlong function_pointer) {
+	GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
+	glGetObjectBufferivATIPROC glGetObjectBufferivATI = (glGetObjectBufferivATIPROC)((intptr_t)function_pointer);
+	glGetObjectBufferivATI(buffer, pname, params_address);
 }
 
 JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglFreeObjectBufferATI(JNIEnv *env, jclass clazz, jint buffer, jlong function_pointer) {
@@ -55,34 +52,37 @@
 	glFreeObjectBufferATI(buffer);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglGetObjectBufferivATI(JNIEnv *env, jclass clazz, jint buffer, jint pname, jobject params, jint params_position, jlong function_pointer) {
-	GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
-	glGetObjectBufferivATIPROC glGetObjectBufferivATI = (glGetObjectBufferivATIPROC)((intptr_t)function_pointer);
-	glGetObjectBufferivATI(buffer, pname, params_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglArrayObjectATI(JNIEnv *env, jclass clazz, jint array, jint size, jint type, jint stride, jint buffer, jint offset, jlong function_pointer) {
+	glArrayObjectATIPROC glArrayObjectATI = (glArrayObjectATIPROC)((intptr_t)function_pointer);
+	glArrayObjectATI(array, size, type, stride, buffer, offset);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglGetObjectBufferfvATI(JNIEnv *env, jclass clazz, jint buffer, jint pname, jobject params, jint params_position, jlong function_pointer) {
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglGetArrayObjectfvATI(JNIEnv *env, jclass clazz, jint array, jint pname, jobject params, jint params_position, jlong function_pointer) {
 	GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
-	glGetObjectBufferfvATIPROC glGetObjectBufferfvATI = (glGetObjectBufferfvATIPROC)((intptr_t)function_pointer);
-	glGetObjectBufferfvATI(buffer, pname, params_address);
+	glGetArrayObjectfvATIPROC glGetArrayObjectfvATI = (glGetArrayObjectfvATIPROC)((intptr_t)function_pointer);
+	glGetArrayObjectfvATI(array, pname, params_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglUpdateObjectBufferATI(JNIEnv *env, jclass clazz, jint buffer, jint offset, jint size, jobject pPointer, jint pPointer_position, jint preserve, jlong function_pointer) {
-	const GLvoid *pPointer_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pPointer)) + pPointer_position));
-	glUpdateObjectBufferATIPROC glUpdateObjectBufferATI = (glUpdateObjectBufferATIPROC)((intptr_t)function_pointer);
-	glUpdateObjectBufferATI(buffer, offset, size, pPointer_address, preserve);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglGetArrayObjectivATI(JNIEnv *env, jclass clazz, jint array, jint pname, jobject params, jint params_position, jlong function_pointer) {
+	GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
+	glGetArrayObjectivATIPROC glGetArrayObjectivATI = (glGetArrayObjectivATIPROC)((intptr_t)function_pointer);
+	glGetArrayObjectivATI(array, pname, params_address);
 }
 
-JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglIsObjectBufferATI(JNIEnv *env, jclass clazz, jint buffer, jlong function_pointer) {
-	glIsObjectBufferATIPROC glIsObjectBufferATI = (glIsObjectBufferATIPROC)((intptr_t)function_pointer);
-	GLboolean __result = glIsObjectBufferATI(buffer);
-	return __result;
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglVariantArrayObjectATI(JNIEnv *env, jclass clazz, jint id, jint type, jint stride, jint buffer, jint offset, jlong function_pointer) {
+	glVariantArrayObjectATIPROC glVariantArrayObjectATI = (glVariantArrayObjectATIPROC)((intptr_t)function_pointer);
+	glVariantArrayObjectATI(id, type, stride, buffer, offset);
 }
 
-JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglNewObjectBufferATI(JNIEnv *env, jclass clazz, jint size, jobject pPointer, jint pPointer_position, jint usage, jlong function_pointer) {
-	const GLvoid *pPointer_address = ((const GLvoid *)(((char *)safeGetBufferAddress(env, pPointer)) + pPointer_position));
-	glNewObjectBufferATIPROC glNewObjectBufferATI = (glNewObjectBufferATIPROC)((intptr_t)function_pointer);
-	GLuint __result = glNewObjectBufferATI(size, pPointer_address, usage);
-	return __result;
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglGetVariantArrayObjectfvATI(JNIEnv *env, jclass clazz, jint id, jint pname, jobject params, jint params_position, jlong function_pointer) {
+	GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
+	glGetVariantArrayObjectfvATIPROC glGetVariantArrayObjectfvATI = (glGetVariantArrayObjectfvATIPROC)((intptr_t)function_pointer);
+	glGetVariantArrayObjectfvATI(id, pname, params_address);
+}
+
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexArrayObject_nglGetVariantArrayObjectivATI(JNIEnv *env, jclass clazz, jint id, jint pname, jobject params, jint params_position, jlong function_pointer) {
+	GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
+	glGetVariantArrayObjectivATIPROC glGetVariantArrayObjectivATI = (glGetVariantArrayObjectivATIPROC)((intptr_t)function_pointer);
+	glGetVariantArrayObjectivATI(id, pname, params_address);
 }
 

Index: org_lwjgl_opengl_ATIVertexStreams.c
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/ati/org_lwjgl_opengl_ATIVertexStreams.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- org_lwjgl_opengl_ATIVertexStreams.c	16 Feb 2005 20:24:55 -0000	1.4
+++ org_lwjgl_opengl_ATIVertexStreams.c	29 Jun 2005 07:39:26 -0000	1.5
@@ -3,61 +3,56 @@
 #include <jni.h>
 #include "extgl.h"
 
-typedef void (APIENTRY *glVertexBlendEnviATIPROC) (GLenum pname, GLint param);
-typedef void (APIENTRY *glVertexBlendEnvfATIPROC) (GLenum pname, GLfloat param);
-typedef void (APIENTRY *glClientActiveVertexStreamATIPROC) (GLenum stream);
-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);
-typedef void (APIENTRY *glNormalStream3bATIPROC) (GLenum stream, GLbyte x, GLbyte y, GLbyte 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 *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 *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 *glVertexStream2iATIPROC) (GLenum stream, GLint x, GLint y);
+typedef void (APIENTRY *glVertexStream2sATIPROC) (GLenum stream, GLshort x, GLshort y);
+typedef void (APIENTRY *glVertexStream3fATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY *glVertexStream3iATIPROC) (GLenum stream, GLint x, GLint y, GLint z);
+typedef void (APIENTRY *glVertexStream3sATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRY *glVertexStream4fATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY *glVertexStream4iATIPROC) (GLenum stream, GLint x, GLint y, GLint z, GLint w);
+typedef void (APIENTRY *glVertexStream4sATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w);
+typedef void (APIENTRY *glNormalStream3bATIPROC) (GLenum stream, GLbyte x, GLbyte y, GLbyte z);
+typedef void (APIENTRY *glNormalStream3fATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY *glNormalStream3iATIPROC) (GLenum stream, GLint x, GLint y, GLint z);
+typedef void (APIENTRY *glNormalStream3sATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRY *glClientActiveVertexStreamATIPROC) (GLenum stream);
+typedef void (APIENTRY *glVertexBlendEnvfATIPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY *glVertexBlendEnviATIPROC) (GLenum pname, GLint param);
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexBlendEnviATI(JNIEnv *env, jclass clazz, jint pname, jint param, jlong function_pointer) {
-	glVertexBlendEnviATIPROC glVertexBlendEnviATI = (glVertexBlendEnviATIPROC)((intptr_t)function_pointer);
-	glVertexBlendEnviATI(pname, param);
-}
-
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexBlendEnvfATI(JNIEnv *env, jclass clazz, jint pname, jfloat param, jlong function_pointer) {
-	glVertexBlendEnvfATIPROC glVertexBlendEnvfATI = (glVertexBlendEnvfATIPROC)((intptr_t)function_pointer);
-	glVertexBlendEnvfATI(pname, param);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream2fATI(JNIEnv *env, jclass clazz, jint stream, jfloat x, jfloat y, jlong function_pointer) {
+	glVertexStream2fATIPROC glVertexStream2fATI = (glVertexStream2fATIPROC)((intptr_t)function_pointer);
+	glVertexStream2fATI(stream, x, y);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglClientActiveVertexStreamATI(JNIEnv *env, jclass clazz, jint stream, jlong function_pointer) {
-	glClientActiveVertexStreamATIPROC glClientActiveVertexStreamATI = (glClientActiveVertexStreamATIPROC)((intptr_t)function_pointer);
-	glClientActiveVertexStreamATI(stream);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream2iATI(JNIEnv *env, jclass clazz, jint stream, jint x, jint y, jlong function_pointer) {
+	glVertexStream2iATIPROC glVertexStream2iATI = (glVertexStream2iATIPROC)((intptr_t)function_pointer);
+	glVertexStream2iATI(stream, x, y);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglNormalStream3sATI(JNIEnv *env, jclass clazz, jint stream, jshort x, jshort y, jshort z, jlong function_pointer) {
-	glNormalStream3sATIPROC glNormalStream3sATI = (glNormalStream3sATIPROC)((intptr_t)function_pointer);
-	glNormalStream3sATI(stream, x, y, z);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream2sATI(JNIEnv *env, jclass clazz, jint stream, jshort x, jshort y, jlong function_pointer) {
+	glVertexStream2sATIPROC glVertexStream2sATI = (glVertexStream2sATIPROC)((intptr_t)function_pointer);
+	glVertexStream2sATI(stream, x, y);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglNormalStream3iATI(JNIEnv *env, jclass clazz, jint stream, jint x, jint y, jint z, jlong function_pointer) {
-	glNormalStream3iATIPROC glNormalStream3iATI = (glNormalStream3iATIPROC)((intptr_t)function_pointer);
-	glNormalStream3iATI(stream, x, y, z);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream3fATI(JNIEnv *env, jclass clazz, jint stream, jfloat x, jfloat y, jfloat z, jlong function_pointer) {
+	glVertexStream3fATIPROC glVertexStream3fATI = (glVertexStream3fATIPROC)((intptr_t)function_pointer);
+	glVertexStream3fATI(stream, x, y, z);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglNormalStream3fATI(JNIEnv *env, jclass clazz, jint stream, jfloat x, jfloat y, jfloat z, jlong function_pointer) {
-	glNormalStream3fATIPROC glNormalStream3fATI = (glNormalStream3fATIPROC)((intptr_t)function_pointer);
-	glNormalStream3fATI(stream, x, y, z);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream3iATI(JNIEnv *env, jclass clazz, jint stream, jint x, jint y, jint z, jlong function_pointer) {
+	glVertexStream3iATIPROC glVertexStream3iATI = (glVertexStream3iATIPROC)((intptr_t)function_pointer);
+	glVertexStream3iATI(stream, x, y, z);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglNormalStream3bATI(JNIEnv *env, jclass clazz, jint stream, jbyte x, jbyte y, jbyte z, jlong function_pointer) {
-	glNormalStream3bATIPROC glNormalStream3bATI = (glNormalStream3bATIPROC)((intptr_t)function_pointer);
-	glNormalStream3bATI(stream, x, y, z);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream3sATI(JNIEnv *env, jclass clazz, jint stream, jshort x, jshort y, jshort z, jlong function_pointer) {
+	glVertexStream3sATIPROC glVertexStream3sATI = (glVertexStream3sATIPROC)((intptr_t)function_pointer);
+	glVertexStream3sATI(stream, x, y, z);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream4sATI(JNIEnv *env, jclass clazz, jint stream, jshort x, jshort y, jshort z, jshort w, jlong function_pointer) {
-	glVertexStream4sATIPROC glVertexStream4sATI = (glVertexStream4sATIPROC)((intptr_t)function_pointer);
-	glVertexStream4sATI(stream, x, y, z, w);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream4fATI(JNIEnv *env, jclass clazz, jint stream, jfloat x, jfloat y, jfloat z, jfloat w, jlong function_pointer) {
+	glVertexStream4fATIPROC glVertexStream4fATI = (glVertexStream4fATIPROC)((intptr_t)function_pointer);
+	glVertexStream4fATI(stream, x, y, z, w);
 }
 
 JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream4iATI(JNIEnv *env, jclass clazz, jint stream, jint x, jint y, jint z, jint w, jlong function_pointer) {
@@ -65,38 +60,43 @@
 	glVertexStream4iATI(stream, x, y, z, w);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream4fATI(JNIEnv *env, jclass clazz, jint stream, jfloat x, jfloat y, jfloat z, jfloat w, jlong function_pointer) {
-	glVertexStream4fATIPROC glVertexStream4fATI = (glVertexStream4fATIPROC)((intptr_t)function_pointer);
-	glVertexStream4fATI(stream, x, y, z, w);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream4sATI(JNIEnv *env, jclass clazz, jint stream, jshort x, jshort y, jshort z, jshort w, jlong function_pointer) {
+	glVertexStream4sATIPROC glVertexStream4sATI = (glVertexStream4sATIPROC)((intptr_t)function_pointer);
+	glVertexStream4sATI(stream, x, y, z, w);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream3sATI(JNIEnv *env, jclass clazz, jint stream, jshort x, jshort y, jshort z, jlong function_pointer) {
-	glVertexStream3sATIPROC glVertexStream3sATI = (glVertexStream3sATIPROC)((intptr_t)function_pointer);
-	glVertexStream3sATI(stream, x, y, z);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglNormalStream3bATI(JNIEnv *env, jclass clazz, jint stream, jbyte x, jbyte y, jbyte z, jlong function_pointer) {
+	glNormalStream3bATIPROC glNormalStream3bATI = (glNormalStream3bATIPROC)((intptr_t)function_pointer);
+	glNormalStream3bATI(stream, x, y, z);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream3iATI(JNIEnv *env, jclass clazz, jint stream, jint x, jint y, jint z, jlong function_pointer) {
-	glVertexStream3iATIPROC glVertexStream3iATI = (glVertexStream3iATIPROC)((intptr_t)function_pointer);
-	glVertexStream3iATI(stream, x, y, z);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglNormalStream3fATI(JNIEnv *env, jclass clazz, jint stream, jfloat x, jfloat y, jfloat z, jlong function_pointer) {
+	glNormalStream3fATIPROC glNormalStream3fATI = (glNormalStream3fATIPROC)((intptr_t)function_pointer);
+	glNormalStream3fATI(stream, x, y, z);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream3fATI(JNIEnv *env, jclass clazz, jint stream, jfloat x, jfloat y, jfloat z, jlong function_pointer) {
-	glVertexStream3fATIPROC glVertexStream3fATI = (glVertexStream3fATIPROC)((intptr_t)function_pointer);
-	glVertexStream3fATI(stream, x, y, z);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglNormalStream3iATI(JNIEnv *env, jclass clazz, jint stream, jint x, jint y, jint z, jlong function_pointer) {
+	glNormalStream3iATIPROC glNormalStream3iATI = (glNormalStream3iATIPROC)((intptr_t)function_pointer);
+	glNormalStream3iATI(stream, x, y, z);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream2sATI(JNIEnv *env, jclass clazz, jint stream, jshort x, jshort y, jlong function_pointer) {
-	glVertexStream2sATIPROC glVertexStream2sATI = (glVertexStream2sATIPROC)((intptr_t)function_pointer);
-	glVertexStream2sATI(stream, x, y);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglNormalStream3sATI(JNIEnv *env, jclass clazz, jint stream, jshort x, jshort y, jshort z, jlong function_pointer) {
+	glNormalStream3sATIPROC glNormalStream3sATI = (glNormalStream3sATIPROC)((intptr_t)function_pointer);
+	glNormalStream3sATI(stream, x, y, z);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream2iATI(JNIEnv *env, jclass clazz, jint stream, jint x, jint y, jlong function_pointer) {
-	glVertexStream2iATIPROC glVertexStream2iATI = (glVertexStream2iATIPROC)((intptr_t)function_pointer);
-	glVertexStream2iATI(stream, x, y);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglClientActiveVertexStreamATI(JNIEnv *env, jclass clazz, jint stream, jlong function_pointer) {
+	glClientActiveVertexStreamATIPROC glClientActiveVertexStreamATI = (glClientActiveVertexStreamATIPROC)((intptr_t)function_pointer);
+	glClientActiveVertexStreamATI(stream);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexStream2fATI(JNIEnv *env, jclass clazz, jint stream, jfloat x, jfloat y, jlong function_pointer) {
-	glVertexStream2fATIPROC glVertexStream2fATI = (glVertexStream2fATIPROC)((intptr_t)function_pointer);
-	glVertexStream2fATI(stream, x, y);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexBlendEnvfATI(JNIEnv *env, jclass clazz, jint pname, jfloat param, jlong function_pointer) {
+	glVertexBlendEnvfATIPROC glVertexBlendEnvfATI = (glVertexBlendEnvfATIPROC)((intptr_t)function_pointer);
+	glVertexBlendEnvfATI(pname, param);
+}
+
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexStreams_nglVertexBlendEnviATI(JNIEnv *env, jclass clazz, jint pname, jint param, jlong function_pointer) {
+	glVertexBlendEnviATIPROC glVertexBlendEnviATI = (glVertexBlendEnviATIPROC)((intptr_t)function_pointer);
+	glVertexBlendEnviATI(pname, param);
 }
 

Index: org_lwjgl_opengl_ATIFragmentShader.c
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/ati/org_lwjgl_opengl_ATIFragmentShader.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- org_lwjgl_opengl_ATIFragmentShader.c	16 Feb 2005 20:24:53 -0000	1.4
+++ org_lwjgl_opengl_ATIFragmentShader.c	29 Jun 2005 07:39:26 -0000	1.5
@@ -3,55 +3,50 @@
 #include <jni.h>
 #include "extgl.h"
 
-typedef void (APIENTRY *glSetFragmentShaderConstantATIPROC) (GLuint dst, const GLfloat * pfValue);
-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 *glAlphaFragmentOp2ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
-typedef void (APIENTRY *glAlphaFragmentOp1ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
-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 *glColorFragmentOp2ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
-typedef void (APIENTRY *glColorFragmentOp1ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
-typedef void (APIENTRY *glSampleMapATIPROC) (GLuint dst, GLuint interp, GLenum swizzle);
-typedef void (APIENTRY *glPassTexCoordATIPROC) (GLuint dst, GLuint coord, GLenum swizzle);
-typedef void (APIENTRY *glEndFragmentShaderATIPROC) ();
-typedef void (APIENTRY *glBeginFragmentShaderATIPROC) ();
-typedef void (APIENTRY *glDeleteFragmentShaderATIPROC) (GLuint id);
-typedef void (APIENTRY *glBindFragmentShaderATIPROC) (GLuint id);
 typedef GLuint (APIENTRY *glGenFragmentShadersATIPROC) (GLuint range);
+typedef void (APIENTRY *glBindFragmentShaderATIPROC) (GLuint id);
+typedef void (APIENTRY *glDeleteFragmentShaderATIPROC) (GLuint id);
+typedef void (APIENTRY *glBeginFragmentShaderATIPROC) ();
+typedef void (APIENTRY *glEndFragmentShaderATIPROC) ();
+typedef void (APIENTRY *glPassTexCoordATIPROC) (GLuint dst, GLuint coord, GLenum swizzle);
+typedef void (APIENTRY *glSampleMapATIPROC) (GLuint dst, GLuint interp, GLenum swizzle);
+typedef void (APIENTRY *glColorFragmentOp1ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
+typedef void (APIENTRY *glColorFragmentOp2ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
+typedef void (APIENTRY *glColorFragmentOp3ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod);
+typedef void (APIENTRY *glAlphaFragmentOp1ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
+typedef void (APIENTRY *glAlphaFragmentOp2ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
+typedef void (APIENTRY *glAlphaFragmentOp3ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod);
+typedef void (APIENTRY *glSetFragmentShaderConstantATIPROC) (GLuint dst, const GLfloat * pfValue);
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglSetFragmentShaderConstantATI(JNIEnv *env, jclass clazz, jint dst, jobject pfValue, jint pfValue_position, jlong function_pointer) {
-	const GLfloat *pfValue_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, pfValue)) + pfValue_position;
-	glSetFragmentShaderConstantATIPROC glSetFragmentShaderConstantATI = (glSetFragmentShaderConstantATIPROC)((intptr_t)function_pointer);
-	glSetFragmentShaderConstantATI(dst, pfValue_address);
-}
-
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglAlphaFragmentOp3ATI(JNIEnv *env, jclass clazz, jint op, jint dst, jint dstMod, jint arg1, jint arg1Rep, jint arg1Mod, jint arg2, jint arg2Rep, jint arg2Mod, jint arg3, jint arg3Rep, jint arg3Mod, jlong function_pointer) {
-	glAlphaFragmentOp3ATIPROC glAlphaFragmentOp3ATI = (glAlphaFragmentOp3ATIPROC)((intptr_t)function_pointer);
-	glAlphaFragmentOp3ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
+JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglGenFragmentShadersATI(JNIEnv *env, jclass clazz, jint range, jlong function_pointer) {
+	glGenFragmentShadersATIPROC glGenFragmentShadersATI = (glGenFragmentShadersATIPROC)((intptr_t)function_pointer);
+	GLuint __result = glGenFragmentShadersATI(range);
+	return __result;
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglAlphaFragmentOp2ATI(JNIEnv *env, jclass clazz, jint op, jint dst, jint dstMod, jint arg1, jint arg1Rep, jint arg1Mod, jint arg2, jint arg2Rep, jint arg2Mod, jlong function_pointer) {
-	glAlphaFragmentOp2ATIPROC glAlphaFragmentOp2ATI = (glAlphaFragmentOp2ATIPROC)((intptr_t)function_pointer);
-	glAlphaFragmentOp2ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglBindFragmentShaderATI(JNIEnv *env, jclass clazz, jint id, jlong function_pointer) {
+	glBindFragmentShaderATIPROC glBindFragmentShaderATI = (glBindFragmentShaderATIPROC)((intptr_t)function_pointer);
+	glBindFragmentShaderATI(id);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglAlphaFragmentOp1ATI(JNIEnv *env, jclass clazz, jint op, jint dst, jint dstMod, jint arg1, jint arg1Rep, jint arg1Mod, jlong function_pointer) {
-	glAlphaFragmentOp1ATIPROC glAlphaFragmentOp1ATI = (glAlphaFragmentOp1ATIPROC)((intptr_t)function_pointer);
-	glAlphaFragmentOp1ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglDeleteFragmentShaderATI(JNIEnv *env, jclass clazz, jint id, jlong function_pointer) {
+	glDeleteFragmentShaderATIPROC glDeleteFragmentShaderATI = (glDeleteFragmentShaderATIPROC)((intptr_t)function_pointer);
+	glDeleteFragmentShaderATI(id);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglColorFragmentOp3ATI(JNIEnv *env, jclass clazz, jint op, jint dst, jint dstMask, jint dstMod, jint arg1, jint arg1Rep, jint arg1Mod, jint arg2, jint arg2Rep, jint arg2Mod, jint arg3, jint arg3Rep, jint arg3Mod, jlong function_pointer) {
-	glColorFragmentOp3ATIPROC glColorFragmentOp3ATI = (glColorFragmentOp3ATIPROC)((intptr_t)function_pointer);
-	glColorFragmentOp3ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglBeginFragmentShaderATI(JNIEnv *env, jclass clazz, jlong function_pointer) {
+	glBeginFragmentShaderATIPROC glBeginFragmentShaderATI = (glBeginFragmentShaderATIPROC)((intptr_t)function_pointer);
+	glBeginFragmentShaderATI();
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglColorFragmentOp2ATI(JNIEnv *env, jclass clazz, jint op, jint dst, jint dstMask, jint dstMod, jint arg1, jint arg1Rep, jint arg1Mod, jint arg2, jint arg2Rep, jint arg2Mod, jlong function_pointer) {
-	glColorFragmentOp2ATIPROC glColorFragmentOp2ATI = (glColorFragmentOp2ATIPROC)((intptr_t)function_pointer);
-	glColorFragmentOp2ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglEndFragmentShaderATI(JNIEnv *env, jclass clazz, jlong function_pointer) {
+	glEndFragmentShaderATIPROC glEndFragmentShaderATI = (glEndFragmentShaderATIPROC)((intptr_t)function_pointer);
+	glEndFragmentShaderATI();
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglColorFragmentOp1ATI(JNIEnv *env, jclass clazz, jint op, jint dst, jint dstMask, jint dstMod, jint arg1, jint arg1Rep, jint arg1Mod, jlong function_pointer) {
-	glColorFragmentOp1ATIPROC glColorFragmentOp1ATI = (glColorFragmentOp1ATIPROC)((intptr_t)function_pointer);
-	glColorFragmentOp1ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglPassTexCoordATI(JNIEnv *env, jclass clazz, jint dst, jint coord, jint swizzle, jlong function_pointer) {
+	glPassTexCoordATIPROC glPassTexCoordATI = (glPassTexCoordATIPROC)((intptr_t)function_pointer);
+	glPassTexCoordATI(dst, coord, swizzle);
 }
 
 JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglSampleMapATI(JNIEnv *env, jclass clazz, jint dst, jint interp, jint swizzle, jlong function_pointer) {
@@ -59,34 +54,39 @@
 	glSampleMapATI(dst, interp, swizzle);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglPassTexCoordATI(JNIEnv *env, jclass clazz, jint dst, jint coord, jint swizzle, jlong function_pointer) {
-	glPassTexCoordATIPROC glPassTexCoordATI = (glPassTexCoordATIPROC)((intptr_t)function_pointer);
-	glPassTexCoordATI(dst, coord, swizzle);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglColorFragmentOp1ATI(JNIEnv *env, jclass clazz, jint op, jint dst, jint dstMask, jint dstMod, jint arg1, jint arg1Rep, jint arg1Mod, jlong function_pointer) {
+	glColorFragmentOp1ATIPROC glColorFragmentOp1ATI = (glColorFragmentOp1ATIPROC)((intptr_t)function_pointer);
+	glColorFragmentOp1ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglEndFragmentShaderATI(JNIEnv *env, jclass clazz, jlong function_pointer) {
-	glEndFragmentShaderATIPROC glEndFragmentShaderATI = (glEndFragmentShaderATIPROC)((intptr_t)function_pointer);
-	glEndFragmentShaderATI();
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglColorFragmentOp2ATI(JNIEnv *env, jclass clazz, jint op, jint dst, jint dstMask, jint dstMod, jint arg1, jint arg1Rep, jint arg1Mod, jint arg2, jint arg2Rep, jint arg2Mod, jlong function_pointer) {
+	glColorFragmentOp2ATIPROC glColorFragmentOp2ATI = (glColorFragmentOp2ATIPROC)((intptr_t)function_pointer);
+	glColorFragmentOp2ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglBeginFragmentShaderATI(JNIEnv *env, jclass clazz, jlong function_pointer) {
-	glBeginFragmentShaderATIPROC glBeginFragmentShaderATI = (glBeginFragmentShaderATIPROC)((intptr_t)function_pointer);
-	glBeginFragmentShaderATI();
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglColorFragmentOp3ATI(JNIEnv *env, jclass clazz, jint op, jint dst, jint dstMask, jint dstMod, jint arg1, jint arg1Rep, jint arg1Mod, jint arg2, jint arg2Rep, jint arg2Mod, jint arg3, jint arg3Rep, jint arg3Mod, jlong function_pointer) {
+	glColorFragmentOp3ATIPROC glColorFragmentOp3ATI = (glColorFragmentOp3ATIPROC)((intptr_t)function_pointer);
+	glColorFragmentOp3ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglDeleteFragmentShaderATI(JNIEnv *env, jclass clazz, jint id, jlong function_pointer) {
-	glDeleteFragmentShaderATIPROC glDeleteFragmentShaderATI = (glDeleteFragmentShaderATIPROC)((intptr_t)function_pointer);
-	glDeleteFragmentShaderATI(id);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglAlphaFragmentOp1ATI(JNIEnv *env, jclass clazz, jint op, jint dst, jint dstMod, jint arg1, jint arg1Rep, jint arg1Mod, jlong function_pointer) {
+	glAlphaFragmentOp1ATIPROC glAlphaFragmentOp1ATI = (glAlphaFragmentOp1ATIPROC)((intptr_t)function_pointer);
+	glAlphaFragmentOp1ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglBindFragmentShaderATI(JNIEnv *env, jclass clazz, jint id, jlong function_pointer) {
-	glBindFragmentShaderATIPROC glBindFragmentShaderATI = (glBindFragmentShaderATIPROC)((intptr_t)function_pointer);
-	glBindFragmentShaderATI(id);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglAlphaFragmentOp2ATI(JNIEnv *env, jclass clazz, jint op, jint dst, jint dstMod, jint arg1, jint arg1Rep, jint arg1Mod, jint arg2, jint arg2Rep, jint arg2Mod, jlong function_pointer) {
+	glAlphaFragmentOp2ATIPROC glAlphaFragmentOp2ATI = (glAlphaFragmentOp2ATIPROC)((intptr_t)function_pointer);
+	glAlphaFragmentOp2ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
 }
 
-JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglGenFragmentShadersATI(JNIEnv *env, jclass clazz, jint range, jlong function_pointer) {
-	glGenFragmentShadersATIPROC glGenFragmentShadersATI = (glGenFragmentShadersATIPROC)((intptr_t)function_pointer);
-	GLuint __result = glGenFragmentShadersATI(range);
-	return __result;
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglAlphaFragmentOp3ATI(JNIEnv *env, jclass clazz, jint op, jint dst, jint dstMod, jint arg1, jint arg1Rep, jint arg1Mod, jint arg2, jint arg2Rep, jint arg2Mod, jint arg3, jint arg3Rep, jint arg3Mod, jlong function_pointer) {
+	glAlphaFragmentOp3ATIPROC glAlphaFragmentOp3ATI = (glAlphaFragmentOp3ATIPROC)((intptr_t)function_pointer);
+	glAlphaFragmentOp3ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
+}
+
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIFragmentShader_nglSetFragmentShaderConstantATI(JNIEnv *env, jclass clazz, jint dst, jobject pfValue, jint pfValue_position, jlong function_pointer) {
+	const GLfloat *pfValue_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, pfValue)) + pfValue_position;
+	glSetFragmentShaderConstantATIPROC glSetFragmentShaderConstantATI = (glSetFragmentShaderConstantATIPROC)((intptr_t)function_pointer);
+	glSetFragmentShaderConstantATI(dst, pfValue_address);
 }
 

Update of /cvsroot/java-game-lib/LWJGL/src/native/common/nv
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv24153/src/native/common/nv

Modified Files:
	org_lwjgl_opengl_NVEvaluators.c org_lwjgl_opengl_NVFence.c 
	org_lwjgl_opengl_NVFragmentProgram.c 
	org_lwjgl_opengl_NVHalfFloat.c 
	org_lwjgl_opengl_NVOcclusionQuery.c 
	org_lwjgl_opengl_NVPixelDataRange.c 
	org_lwjgl_opengl_NVPointSprite.c 
	org_lwjgl_opengl_NVPrimitiveRestart.c 
	org_lwjgl_opengl_NVProgram.c 
	org_lwjgl_opengl_NVRegisterCombiners.c 
	org_lwjgl_opengl_NVRegisterCombiners2.c 
	org_lwjgl_opengl_NVVertexArrayRange.c 
	org_lwjgl_opengl_NVVertexProgram.c 
Log Message:
Mac OS X: Handle MouseEvent.NOBUTTON case

Index: org_lwjgl_opengl_NVHalfFloat.c
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/nv/org_lwjgl_opengl_NVHalfFloat.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- org_lwjgl_opengl_NVHalfFloat.c	16 Feb 2005 20:25:20 -0000	1.4
+++ org_lwjgl_opengl_NVHalfFloat.c	29 Jun 2005 07:39:28 -0000	1.5
@@ -3,93 +3,84 @@
 #include <jni.h>
 #include "extgl.h"
 
-typedef void (APIENTRY *glVertexAttribs4hvNVPROC) (GLuint index, GLsizei n, const GLhalf * attribs);
-typedef void (APIENTRY *glVertexAttribs3hvNVPROC) (GLuint index, GLsizei n, const GLhalf * attribs);
-typedef void (APIENTRY *glVertexAttribs2hvNVPROC) (GLuint index, GLsizei n, const GLhalf * attribs);
-typedef void (APIENTRY *glVertexAttribs1hvNVPROC) (GLuint index, GLsizei n, const GLhalf * attribs);
-typedef void (APIENTRY *glVertexAttrib4hNVPROC) (GLuint index, GLhalf x, GLhalf y, GLhalf z, GLhalf w);
-typedef void (APIENTRY *glVertexAttrib3hNVPROC) (GLuint index, GLhalf x, GLhalf y, GLhalf z);
-typedef void (APIENTRY *glVertexAttrib2hNVPROC) (GLuint index, GLhalf x, GLhalf y);
-typedef void (APIENTRY *glVertexAttrib1hNVPROC) (GLuint index, GLhalf x);
-typedef void (APIENTRY *glSecondaryColor3hNVPROC) (GLhalf red, GLhalf green, GLhalf blue);
-typedef void (APIENTRY *glFogCoordhNVPROC) (GLhalf fog);
-typedef void (APIENTRY *glMultiTexCoord4hNVPROC) (GLenum target, GLhalf s, GLhalf t, GLhalf r, GLhalf q);
-typedef void (APIENTRY *glMultiTexCoord3hNVPROC) (GLenum target, GLhalf s, GLhalf t, GLhalf r);
-typedef void (APIENTRY *glMultiTexCoord2hNVPROC) (GLenum target, GLhalf s, GLhalf t);
-typedef void (APIENTRY *glMultiTexCoord1hNVPROC) (GLenum target, GLhalf s);
-typedef void (APIENTRY *glTexCoord4hNVPROC) (GLhalf s, GLhalf t, GLhalf r, GLhalf q);
-typedef void (APIENTRY *glTexCoord3hNVPROC) (GLhalf s, GLhalf t, GLhalf r);
-typedef void (APIENTRY *glTexCoord2hNVPROC) (GLhalf s, GLhalf t);
-typedef void (APIENTRY *glTexCoord1hNVPROC) (GLhalf s);
-typedef void (APIENTRY *glColor4hNVPROC) (GLhalf red, GLhalf green, GLhalf blue, GLhalf alpha);
-typedef void (APIENTRY *glColor3hNVPROC) (GLhalf red, GLhalf green, GLhalf blue);
-typedef void (APIENTRY *glNormal3hNVPROC) (GLhalf nx, GLhalf ny, GLhalf nz);
-typedef void (APIENTRY *glVertex4hNVPROC) (GLhalf x, GLhalf y, GLhalf z, GLhalf w);
-typedef void (APIENTRY *glVertex3hNVPROC) (GLhalf x, GLhalf y, GLhalf z);
 typedef void (APIENTRY *glVertex2hNVPROC) (GLhalf x, GLhalf y);
+typedef void (APIENTRY *glVertex3hNVPROC) (GLhalf x, GLhalf y, GLhalf z);
+typedef void (APIENTRY *glVertex4hNVPROC) (GLhalf x, GLhalf y, GLhalf z, GLhalf w);
+typedef void (APIENTRY *glNormal3hNVPROC) (GLhalf nx, GLhalf ny, GLhalf nz);
+typedef void (APIENTRY *glColor3hNVPROC) (GLhalf red, GLhalf green, GLhalf blue);
+typedef void (APIENTRY *glColor4hNVPROC) (GLhalf red, GLhalf green, GLhalf blue, GLhalf alpha);
+typedef void (APIENTRY *glTexCoord1hNVPROC) (GLhalf s);
+typedef void (APIENTRY *glTexCoord2hNVPROC) (GLhalf s, GLhalf t);
+typedef void (APIENTRY *glTexCoord3hNVPROC) (GLhalf s, GLhalf t, GLhalf r);
+typedef void (APIENTRY *glTexCoord4hNVPROC) (GLhalf s, GLhalf t, GLhalf r, GLhalf q);
+typedef void (APIENTRY *glMultiTexCoord1hNVPROC) (GLenum target, GLhalf s);
+typedef void (APIENTRY *glMultiTexCoord2hNVPROC) (GLenum target, GLhalf s, GLhalf t);
+typedef void (APIENTRY *glMultiTexCoord3hNVPROC) (GLenum target, GLhalf s, GLhalf t, GLhalf r);
+typedef void (APIENTRY *glMultiTexCoord4hNVPROC) (GLenum target, GLhalf s, GLhalf t, GLhalf r, GLhalf q);
+typedef void (APIENTRY *glFogCoordhNVPROC) (GLhalf fog);
+typedef void (APIENTRY *glSecondaryColor3hNVPROC) (GLhalf red, GLhalf green, GLhalf blue);
+typedef void (APIENTRY *glVertexAttrib1hNVPROC) (GLuint index, GLhalf x);
+typedef void (APIENTRY *glVertexAttrib2hNVPROC) (GLuint index, GLhalf x, GLhalf y);
+typedef void (APIENTRY *glVertexAttrib3hNVPROC) (GLuint index, GLhalf x, GLhalf y, GLhalf z);
+typedef void (APIENTRY *glVertexAttrib4hNVPROC) (GLuint index, GLhalf x, GLhalf y, GLhalf z, GLhalf w);
+typedef void (APIENTRY *glVertexAttribs1hvNVPROC) (GLuint index, GLsizei n, const GLhalf * attribs);
+typedef void (APIENTRY *glVertexAttribs2hvNVPROC) (GLuint index, GLsizei n, const GLhalf * attribs);
+typedef void (APIENTRY *glVertexAttribs3hvNVPROC) (GLuint index, GLsizei n, const GLhalf * attribs);
+typedef void (APIENTRY *glVertexAttribs4hvNVPROC) (GLuint index, GLsizei n, const GLhalf * attribs);
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs4hvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject attribs, jint attribs_position, jlong function_pointer) {
-	const GLhalf *attribs_address = ((const GLhalf *)(*env)->GetDirectBufferAddress(env, attribs)) + attribs_position;
-	glVertexAttribs4hvNVPROC glVertexAttribs4hvNV = (glVertexAttribs4hvNVPROC)((intptr_t)function_pointer);
-	glVertexAttribs4hvNV(index, n, attribs_address);
-}
-
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs3hvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject attribs, jint attribs_position, jlong function_pointer) {
-	const GLhalf *attribs_address = ((const GLhalf *)(*env)->GetDirectBufferAddress(env, attribs)) + attribs_position;
-	glVertexAttribs3hvNVPROC glVertexAttribs3hvNV = (glVertexAttribs3hvNVPROC)((intptr_t)function_pointer);
-	glVertexAttribs3hvNV(index, n, attribs_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertex2hNV(JNIEnv *env, jclass clazz, jshort x, jshort y, jlong function_pointer) {
+	glVertex2hNVPROC glVertex2hNV = (glVertex2hNVPROC)((intptr_t)function_pointer);
+	glVertex2hNV(x, y);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs2hvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject attribs, jint attribs_position, jlong function_pointer) {
-	const GLhalf *attribs_address = ((const GLhalf *)(*env)->GetDirectBufferAddress(env, attribs)) + attribs_position;
-	glVertexAttribs2hvNVPROC glVertexAttribs2hvNV = (glVertexAttribs2hvNVPROC)((intptr_t)function_pointer);
-	glVertexAttribs2hvNV(index, n, attribs_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertex3hNV(JNIEnv *env, jclass clazz, jshort x, jshort y, jshort z, jlong function_pointer) {
+	glVertex3hNVPROC glVertex3hNV = (glVertex3hNVPROC)((intptr_t)function_pointer);
+	glVertex3hNV(x, y, z);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs1hvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject attribs, jint attribs_position, jlong function_pointer) {
-	const GLhalf *attribs_address = ((const GLhalf *)(*env)->GetDirectBufferAddress(env, attribs)) + attribs_position;
-	glVertexAttribs1hvNVPROC glVertexAttribs1hvNV = (glVertexAttribs1hvNVPROC)((intptr_t)function_pointer);
-	glVertexAttribs1hvNV(index, n, attribs_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertex4hNV(JNIEnv *env, jclass clazz, jshort x, jshort y, jshort z, jshort w, jlong function_pointer) {
+	glVertex4hNVPROC glVertex4hNV = (glVertex4hNVPROC)((intptr_t)function_pointer);
+	glVertex4hNV(x, y, z, w);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttrib4hNV(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jshort z, jshort w, jlong function_pointer) {
-	glVertexAttrib4hNVPROC glVertexAttrib4hNV = (glVertexAttrib4hNVPROC)((intptr_t)function_pointer);
-	glVertexAttrib4hNV(index, x, y, z, w);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglNormal3hNV(JNIEnv *env, jclass clazz, jshort nx, jshort ny, jshort nz, jlong function_pointer) {
+	glNormal3hNVPROC glNormal3hNV = (glNormal3hNVPROC)((intptr_t)function_pointer);
+	glNormal3hNV(nx, ny, nz);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttrib3hNV(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jshort z, jlong function_pointer) {
-	glVertexAttrib3hNVPROC glVertexAttrib3hNV = (glVertexAttrib3hNVPROC)((intptr_t)function_pointer);
-	glVertexAttrib3hNV(index, x, y, z);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglColor3hNV(JNIEnv *env, jclass clazz, jshort red, jshort green, jshort blue, jlong function_pointer) {
+	glColor3hNVPROC glColor3hNV = (glColor3hNVPROC)((intptr_t)function_pointer);
+	glColor3hNV(red, green, blue);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttrib2hNV(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jlong function_pointer) {
-	glVertexAttrib2hNVPROC glVertexAttrib2hNV = (glVertexAttrib2hNVPROC)((intptr_t)function_pointer);
-	glVertexAttrib2hNV(index, x, y);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglColor4hNV(JNIEnv *env, jclass clazz, jshort red, jshort green, jshort blue, jshort alpha, jlong function_pointer) {
+	glColor4hNVPROC glColor4hNV = (glColor4hNVPROC)((intptr_t)function_pointer);
+	glColor4hNV(red, green, blue, alpha);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttrib1hNV(JNIEnv *env, jclass clazz, jint index, jshort x, jlong function_pointer) {
-	glVertexAttrib1hNVPROC glVertexAttrib1hNV = (glVertexAttrib1hNVPROC)((intptr_t)function_pointer);
-	glVertexAttrib1hNV(index, x);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglTexCoord1hNV(JNIEnv *env, jclass clazz, jshort s, jlong function_pointer) {
+	glTexCoord1hNVPROC glTexCoord1hNV = (glTexCoord1hNVPROC)((intptr_t)function_pointer);
+	glTexCoord1hNV(s);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglSecondaryColor3hNV(JNIEnv *env, jclass clazz, jshort red, jshort green, jshort blue, jlong function_pointer) {
-	glSecondaryColor3hNVPROC glSecondaryColor3hNV = (glSecondaryColor3hNVPROC)((intptr_t)function_pointer);
-	glSecondaryColor3hNV(red, green, blue);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglTexCoord2hNV(JNIEnv *env, jclass clazz, jshort s, jshort t, jlong function_pointer) {
+	glTexCoord2hNVPROC glTexCoord2hNV = (glTexCoord2hNVPROC)((intptr_t)function_pointer);
+	glTexCoord2hNV(s, t);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglFogCoordhNV(JNIEnv *env, jclass clazz, jshort fog, jlong function_pointer) {
-	glFogCoordhNVPROC glFogCoordhNV = (glFogCoordhNVPROC)((intptr_t)function_pointer);
-	glFogCoordhNV(fog);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglTexCoord3hNV(JNIEnv *env, jclass clazz, jshort s, jshort t, jshort r, jlong function_pointer) {
+	glTexCoord3hNVPROC glTexCoord3hNV = (glTexCoord3hNVPROC)((intptr_t)function_pointer);
+	glTexCoord3hNV(s, t, r);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglMultiTexCoord4hNV(JNIEnv *env, jclass clazz, jint target, jshort s, jshort t, jshort r, jshort q, jlong function_pointer) {
-	glMultiTexCoord4hNVPROC glMultiTexCoord4hNV = (glMultiTexCoord4hNVPROC)((intptr_t)function_pointer);
-	glMultiTexCoord4hNV(target, s, t, r, q);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglTexCoord4hNV(JNIEnv *env, jclass clazz, jshort s, jshort t, jshort r, jshort q, jlong function_pointer) {
+	glTexCoord4hNVPROC glTexCoord4hNV = (glTexCoord4hNVPROC)((intptr_t)function_pointer);
+	glTexCoord4hNV(s, t, r, q);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglMultiTexCoord3hNV(JNIEnv *env, jclass clazz, jint target, jshort s, jshort t, jshort r, jlong function_pointer) {
-	glMultiTexCoord3hNVPROC glMultiTexCoord3hNV = (glMultiTexCoord3hNVPROC)((intptr_t)function_pointer);
-	glMultiTexCoord3hNV(target, s, t, r);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglMultiTexCoord1hNV(JNIEnv *env, jclass clazz, jint target, jshort s, jlong function_pointer) {
+	glMultiTexCoord1hNVPROC glMultiTexCoord1hNV = (glMultiTexCoord1hNVPROC)((intptr_t)function_pointer);
+	glMultiTexCoord1hNV(target, s);
 }
 
 JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglMultiTexCoord2hNV(JNIEnv *env, jclass clazz, jint target, jshort s, jshort t, jlong function_pointer) {
@@ -97,58 +88,67 @@
 	glMultiTexCoord2hNV(target, s, t);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglMultiTexCoord1hNV(JNIEnv *env, jclass clazz, jint target, jshort s, jlong function_pointer) {
-	glMultiTexCoord1hNVPROC glMultiTexCoord1hNV = (glMultiTexCoord1hNVPROC)((intptr_t)function_pointer);
-	glMultiTexCoord1hNV(target, s);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglMultiTexCoord3hNV(JNIEnv *env, jclass clazz, jint target, jshort s, jshort t, jshort r, jlong function_pointer) {
+	glMultiTexCoord3hNVPROC glMultiTexCoord3hNV = (glMultiTexCoord3hNVPROC)((intptr_t)function_pointer);
+	glMultiTexCoord3hNV(target, s, t, r);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglTexCoord4hNV(JNIEnv *env, jclass clazz, jshort s, jshort t, jshort r, jshort q, jlong function_pointer) {
-	glTexCoord4hNVPROC glTexCoord4hNV = (glTexCoord4hNVPROC)((intptr_t)function_pointer);
-	glTexCoord4hNV(s, t, r, q);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglMultiTexCoord4hNV(JNIEnv *env, jclass clazz, jint target, jshort s, jshort t, jshort r, jshort q, jlong function_pointer) {
+	glMultiTexCoord4hNVPROC glMultiTexCoord4hNV = (glMultiTexCoord4hNVPROC)((intptr_t)function_pointer);
+	glMultiTexCoord4hNV(target, s, t, r, q);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglTexCoord3hNV(JNIEnv *env, jclass clazz, jshort s, jshort t, jshort r, jlong function_pointer) {
-	glTexCoord3hNVPROC glTexCoord3hNV = (glTexCoord3hNVPROC)((intptr_t)function_pointer);
-	glTexCoord3hNV(s, t, r);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglFogCoordhNV(JNIEnv *env, jclass clazz, jshort fog, jlong function_pointer) {
+	glFogCoordhNVPROC glFogCoordhNV = (glFogCoordhNVPROC)((intptr_t)function_pointer);
+	glFogCoordhNV(fog);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglTexCoord2hNV(JNIEnv *env, jclass clazz, jshort s, jshort t, jlong function_pointer) {
-	glTexCoord2hNVPROC glTexCoord2hNV = (glTexCoord2hNVPROC)((intptr_t)function_pointer);
-	glTexCoord2hNV(s, t);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglSecondaryColor3hNV(JNIEnv *env, jclass clazz, jshort red, jshort green, jshort blue, jlong function_pointer) {
+	glSecondaryColor3hNVPROC glSecondaryColor3hNV = (glSecondaryColor3hNVPROC)((intptr_t)function_pointer);
+	glSecondaryColor3hNV(red, green, blue);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglTexCoord1hNV(JNIEnv *env, jclass clazz, jshort s, jlong function_pointer) {
-	glTexCoord1hNVPROC glTexCoord1hNV = (glTexCoord1hNVPROC)((intptr_t)function_pointer);
-	glTexCoord1hNV(s);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttrib1hNV(JNIEnv *env, jclass clazz, jint index, jshort x, jlong function_pointer) {
+	glVertexAttrib1hNVPROC glVertexAttrib1hNV = (glVertexAttrib1hNVPROC)((intptr_t)function_pointer);
+	glVertexAttrib1hNV(index, x);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglColor4hNV(JNIEnv *env, jclass clazz, jshort red, jshort green, jshort blue, jshort alpha, jlong function_pointer) {
-	glColor4hNVPROC glColor4hNV = (glColor4hNVPROC)((intptr_t)function_pointer);
-	glColor4hNV(red, green, blue, alpha);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttrib2hNV(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jlong function_pointer) {
+	glVertexAttrib2hNVPROC glVertexAttrib2hNV = (glVertexAttrib2hNVPROC)((intptr_t)function_pointer);
+	glVertexAttrib2hNV(index, x, y);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglColor3hNV(JNIEnv *env, jclass clazz, jshort red, jshort green, jshort blue, jlong function_pointer) {
-	glColor3hNVPROC glColor3hNV = (glColor3hNVPROC)((intptr_t)function_pointer);
-	glColor3hNV(red, green, blue);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttrib3hNV(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jshort z, jlong function_pointer) {
+	glVertexAttrib3hNVPROC glVertexAttrib3hNV = (glVertexAttrib3hNVPROC)((intptr_t)function_pointer);
+	glVertexAttrib3hNV(index, x, y, z);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglNormal3hNV(JNIEnv *env, jclass clazz, jshort nx, jshort ny, jshort nz, jlong function_pointer) {
-	glNormal3hNVPROC glNormal3hNV = (glNormal3hNVPROC)((intptr_t)function_pointer);
-	glNormal3hNV(nx, ny, nz);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttrib4hNV(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jshort z, jshort w, jlong function_pointer) {
+	glVertexAttrib4hNVPROC glVertexAttrib4hNV = (glVertexAttrib4hNVPROC)((intptr_t)function_pointer);
+	glVertexAttrib4hNV(index, x, y, z, w);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertex4hNV(JNIEnv *env, jclass clazz, jshort x, jshort y, jshort z, jshort w, jlong function_pointer) {
-	glVertex4hNVPROC glVertex4hNV = (glVertex4hNVPROC)((intptr_t)function_pointer);
-	glVertex4hNV(x, y, z, w);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs1hvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject attribs, jint attribs_position, jlong function_pointer) {
+	const GLhalf *attribs_address = ((const GLhalf *)(*env)->GetDirectBufferAddress(env, attribs)) + attribs_position;
+	glVertexAttribs1hvNVPROC glVertexAttribs1hvNV = (glVertexAttribs1hvNVPROC)((intptr_t)function_pointer);
+	glVertexAttribs1hvNV(index, n, attribs_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertex3hNV(JNIEnv *env, jclass clazz, jshort x, jshort y, jshort z, jlong function_pointer) {
-	glVertex3hNVPROC glVertex3hNV = (glVertex3hNVPROC)((intptr_t)function_pointer);
-	glVertex3hNV(x, y, z);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs2hvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject attribs, jint attribs_position, jlong function_pointer) {
+	const GLhalf *attribs_address = ((const GLhalf *)(*env)->GetDirectBufferAddress(env, attribs)) + attribs_position;
+	glVertexAttribs2hvNVPROC glVertexAttribs2hvNV = (glVertexAttribs2hvNVPROC)((intptr_t)function_pointer);
+	glVertexAttribs2hvNV(index, n, attribs_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertex2hNV(JNIEnv *env, jclass clazz, jshort x, jshort y, jlong function_pointer) {
-	glVertex2hNVPROC glVertex2hNV = (glVertex2hNVPROC)((intptr_t)function_pointer);
-	glVertex2hNV(x, y);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs3hvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject attribs, jint attribs_position, jlong function_pointer) {
+	const GLhalf *attribs_address = ((const GLhalf *)(*env)->GetDirectBufferAddress(env, attribs)) + attribs_position;
+	glVertexAttribs3hvNVPROC glVertexAttribs3hvNV = (glVertexAttribs3hvNVPROC)((intptr_t)function_pointer);
+	glVertexAttribs3hvNV(index, n, attribs_address);
+}
+
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs4hvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject attribs, jint attribs_position, jlong function_pointer) {
+	const GLhalf *attribs_address = ((const GLhalf *)(*env)->GetDirectBufferAddress(env, attribs)) + attribs_position;
+	glVertexAttribs4hvNVPROC glVertexAttribs4hvNV = (glVertexAttribs4hvNVPROC)((intptr_t)function_pointer);
+	glVertexAttribs4hvNV(index, n, attribs_address);
 }
 

Index: org_lwjgl_opengl_NVFence.c
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/nv/org_lwjgl_opengl_NVFence.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- org_lwjgl_opengl_NVFence.c	16 Feb 2005 20:25:18 -0000	1.4
+++ org_lwjgl_opengl_NVFence.c	29 Jun 2005 07:39:28 -0000	1.5
@@ -3,29 +3,29 @@
 #include <jni.h>
 #include "extgl.h"
 
-typedef void (APIENTRY *glGetFenceivNVPROC) (GLuint fence, GLenum pname, GLint * piParams);
-typedef GLboolean (APIENTRY *glIsFenceNVPROC) (GLuint fence);
-typedef void (APIENTRY *glFinishFenceNVPROC) (GLuint fence);
-typedef GLboolean (APIENTRY *glTestFenceNVPROC) (GLuint fence);
-typedef void (APIENTRY *glSetFenceNVPROC) (GLuint fence, GLenum condition);
-typedef void (APIENTRY *glDeleteFencesNVPROC) (GLsizei n, const GLuint * piFences);
 typedef void (APIENTRY *glGenFencesNVPROC) (GLsizei n, GLuint * piFences);
+typedef void (APIENTRY *glDeleteFencesNVPROC) (GLsizei n, const GLuint * piFences);
+typedef void (APIENTRY *glSetFenceNVPROC) (GLuint fence, GLenum condition);
+typedef GLboolean (APIENTRY *glTestFenceNVPROC) (GLuint fence);
+typedef void (APIENTRY *glFinishFenceNVPROC) (GLuint fence);
+typedef GLboolean (APIENTRY *glIsFenceNVPROC) (GLuint fence);
+typedef void (APIENTRY *glGetFenceivNVPROC) (GLuint fence, GLenum pname, GLint * piParams);
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_nglGetFenceivNV(JNIEnv *env, jclass clazz, jint fence, jint pname, jobject piParams, jint piParams_position, jlong function_pointer) {
-	GLint *piParams_address = ((GLint *)(*env)->GetDirectBufferAddress(env, piParams)) + piParams_position;
-	glGetFenceivNVPROC glGetFenceivNV = (glGetFenceivNVPROC)((intptr_t)function_pointer);
-	glGetFenceivNV(fence, pname, piParams_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_nglGenFencesNV(JNIEnv *env, jclass clazz, jint n, jobject piFences, jint piFences_position, jlong function_pointer) {
+	GLuint *piFences_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, piFences)) + piFences_position;
+	glGenFencesNVPROC glGenFencesNV = (glGenFencesNVPROC)((intptr_t)function_pointer);
+	glGenFencesNV(n, piFences_address);
 }
 
-JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_NVFence_nglIsFenceNV(JNIEnv *env, jclass clazz, jint fence, jlong function_pointer) {
-	glIsFenceNVPROC glIsFenceNV = (glIsFenceNVPROC)((intptr_t)function_pointer);
-	GLboolean __result = glIsFenceNV(fence);
-	return __result;
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_nglDeleteFencesNV(JNIEnv *env, jclass clazz, jint n, jobject piFences, jint piFences_position, jlong function_pointer) {
+	const GLuint *piFences_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, piFences)) + piFences_position;
+	glDeleteFencesNVPROC glDeleteFencesNV = (glDeleteFencesNVPROC)((intptr_t)function_pointer);
+	glDeleteFencesNV(n, piFences_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_nglFinishFenceNV(JNIEnv *env, jclass clazz, jint fence, jlong function_pointer) {
-	glFinishFenceNVPROC glFinishFenceNV = (glFinishFenceNVPROC)((intptr_t)function_pointer);
-	glFinishFenceNV(fence);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_nglSetFenceNV(JNIEnv *env, jclass clazz, jint fence, jint condition, jlong function_pointer) {
+	glSetFenceNVPROC glSetFenceNV = (glSetFenceNVPROC)((intptr_t)function_pointer);
+	glSetFenceNV(fence, condition);
 }
 
 JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_NVFence_nglTestFenceNV(JNIEnv *env, jclass clazz, jint fence, jlong function_pointer) {
@@ -34,20 +34,20 @@
 	return __result;
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_nglSetFenceNV(JNIEnv *env, jclass clazz, jint fence, jint condition, jlong function_pointer) {
-	glSetFenceNVPROC glSetFenceNV = (glSetFenceNVPROC)((intptr_t)function_pointer);
-	glSetFenceNV(fence, condition);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_nglFinishFenceNV(JNIEnv *env, jclass clazz, jint fence, jlong function_pointer) {
+	glFinishFenceNVPROC glFinishFenceNV = (glFinishFenceNVPROC)((intptr_t)function_pointer);
+	glFinishFenceNV(fence);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_nglDeleteFencesNV(JNIEnv *env, jclass clazz, jint n, jobject piFences, jint piFences_position, jlong function_pointer) {
-	const GLuint *piFences_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, piFences)) + piFences_position;
-	glDeleteFencesNVPROC glDeleteFencesNV = (glDeleteFencesNVPROC)((intptr_t)function_pointer);
-	glDeleteFencesNV(n, piFences_address);
+JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_NVFence_nglIsFenceNV(JNIEnv *env, jclass clazz, jint fence, jlong function_pointer) {
+	glIsFenceNVPROC glIsFenceNV = (glIsFenceNVPROC)((intptr_t)function_pointer);
+	GLboolean __result = glIsFenceNV(fence);
+	return __result;
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_nglGenFencesNV(JNIEnv *env, jclass clazz, jint n, jobject piFences, jint piFences_position, jlong function_pointer) {
-	GLuint *piFences_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, piFences)) + piFences_position;
-	glGenFencesNVPROC glGenFencesNV = (glGenFencesNVPROC)((intptr_t)function_pointer);
-	glGenFencesNV(n, piFences_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_nglGetFenceivNV(JNIEnv *env, jclass clazz, jint fence, jint pname, jobject piParams, jint piParams_position, jlong function_pointer) {
+	GLint *piParams_address = ((GLint *)(*env)->GetDirectBufferAddress(env, piParams)) + piParams_position;
+	glGetFenceivNVPROC glGetFenceivNV = (glGetFenceivNVPROC)((intptr_t)function_pointer);
+	glGetFenceivNV(fence, pname, piParams_address);
 }
 

Index: org_lwjgl_opengl_NVPrimitiveRestart.c
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/nv/org_lwjgl_opengl_NVPrimitiveRestart.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- org_lwjgl_opengl_NVPrimitiveRestart.c	16 Feb 2005 20:25:21 -0000	1.4
+++ org_lwjgl_opengl_NVPrimitiveRestart.c	29 Jun 2005 07:39:28 -0000	1.5
@@ -3,16 +3,16 @@
 #include <jni.h>
 #include "extgl.h"
 
-typedef void (APIENTRY *glPrimitiveRestartIndexNVPROC) (GLuint index);
 typedef void (APIENTRY *glPrimitiveRestartNVPROC) ();
-
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPrimitiveRestart_nglPrimitiveRestartIndexNV(JNIEnv *env, jclass clazz, jint index, jlong function_pointer) {
-	glPrimitiveRestartIndexNVPROC glPrimitiveRestartIndexNV = (glPrimitiveRestartIndexNVPROC)((intptr_t)function_pointer);
-	glPrimitiveRestartIndexNV(index);
-}
+typedef void (APIENTRY *glPrimitiveRestartIndexNVPROC) (GLuint index);
 
 JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPrimitiveRestart_nglPrimitiveRestartNV(JNIEnv *env, jclass clazz, jlong function_pointer) {
 	glPrimitiveRestartNVPROC glPrimitiveRestartNV = (glPrimitiveRestartNVPROC)((intptr_t)function_pointer);
 	glPrimitiveRestartNV();
 }
 
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPrimitiveRestart_nglPrimitiveRestartIndexNV(JNIEnv *env, jclass clazz, jint index, jlong function_pointer) {
+	glPrimitiveRestartIndexNVPROC glPrimitiveRestartIndexNV = (glPrimitiveRestartIndexNVPROC)((intptr_t)function_pointer);
+	glPrimitiveRestartIndexNV(index);
+}
+

Index: org_lwjgl_opengl_NVEvaluators.c
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/nv/org_lwjgl_opengl_NVEvaluators.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- org_lwjgl_opengl_NVEvaluators.c	16 Feb 2005 20:25:17 -0000	1.4
+++ org_lwjgl_opengl_NVEvaluators.c	29 Jun 2005 07:39:27 -0000	1.5
@@ -3,37 +3,38 @@
 #include <jni.h>
 #include "extgl.h"
 
-typedef void (APIENTRY *glEvalMapsNVPROC) (GLenum target, GLenum mode);
-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 *glGetMapParameterivNVPROC) (GLenum target, GLenum pname, const GLint * params);
-typedef void (APIENTRY *glGetMapParameterfvNVPROC) (GLenum target, GLenum pname, const GLfloat * params);
-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 *glMapControlPointsNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid * pPoints);
 typedef void (APIENTRY *glGetMapControlPointsNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, const GLvoid * pPoints);
+typedef void (APIENTRY *glMapControlPointsNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid * pPoints);
+typedef void (APIENTRY *glMapParameterfvNVPROC) (GLenum target, GLenum pname, const GLfloat * params);
+typedef void (APIENTRY *glMapParameterivNVPROC) (GLenum target, GLenum pname, const GLint * params);
+typedef void (APIENTRY *glGetMapParameterfvNVPROC) (GLenum target, GLenum pname, const GLfloat * params);
+typedef void (APIENTRY *glGetMapParameterivNVPROC) (GLenum target, GLenum pname, const GLint * params);
+typedef void (APIENTRY *glGetMapAttribParameterfvNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat * params);
+typedef void (APIENTRY *glGetMapAttribParameterivNVPROC) (GLenum target, GLuint index, GLenum pname, GLint * params);
+typedef void (APIENTRY *glEvalMapsNVPROC) (GLenum target, GLenum mode);
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglEvalMapsNV(JNIEnv *env, jclass clazz, jint target, jint mode, jlong function_pointer) {
-	glEvalMapsNVPROC glEvalMapsNV = (glEvalMapsNVPROC)((intptr_t)function_pointer);
-	glEvalMapsNV(target, mode);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapControlPointsNV(JNIEnv *env, jclass clazz, jint target, jint index, jint type, jint ustride, jint vstride, jboolean packed, jobject pPoints, jint pPoints_position, jlong function_pointer) {
+	const GLvoid *pPoints_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pPoints)) + pPoints_position));
+	glGetMapControlPointsNVPROC glGetMapControlPointsNV = (glGetMapControlPointsNVPROC)((intptr_t)function_pointer);
+	glGetMapControlPointsNV(target, index, type, ustride, vstride, packed, pPoints_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapAttribParameterivNV(JNIEnv *env, jclass clazz, jint target, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
-	GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
-	glGetMapAttribParameterivNVPROC glGetMapAttribParameterivNV = (glGetMapAttribParameterivNVPROC)((intptr_t)function_pointer);
-	glGetMapAttribParameterivNV(target, index, pname, params_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglMapControlPointsNV(JNIEnv *env, jclass clazz, jint target, jint index, jint type, jint ustride, jint vstride, jint uorder, jint vorder, jboolean packed, jobject pPoints, jint pPoints_position, jlong function_pointer) {
+	const GLvoid *pPoints_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pPoints)) + pPoints_position));
+	glMapControlPointsNVPROC glMapControlPointsNV = (glMapControlPointsNVPROC)((intptr_t)function_pointer);
+	glMapControlPointsNV(target, index, type, ustride, vstride, uorder, vorder, packed, pPoints_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapAttribParameterfvNV(JNIEnv *env, jclass clazz, jint target, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
-	GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
-	glGetMapAttribParameterfvNVPROC glGetMapAttribParameterfvNV = (glGetMapAttribParameterfvNVPROC)((intptr_t)function_pointer);
-	glGetMapAttribParameterfvNV(target, index, pname, params_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglMapParameterfvNV(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
+	const GLfloat *params_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
+	glMapParameterfvNVPROC glMapParameterfvNV = (glMapParameterfvNVPROC)((intptr_t)function_pointer);
+	glMapParameterfvNV(target, pname, params_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapParameterivNV(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglMapParameterivNV(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
 	const GLint *params_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
-	glGetMapParameterivNVPROC glGetMapParameterivNV = (glGetMapParameterivNVPROC)((intptr_t)function_pointer);
-	glGetMapParameterivNV(target, pname, params_address);
+	glMapParameterivNVPROC glMapParameterivNV = (glMapParameterivNVPROC)((intptr_t)function_pointer);
+	glMapParameterivNV(target, pname, params_address);
 }
 
 JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapParameterfvNV(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
@@ -42,27 +43,26 @@
 	glGetMapParameterfvNV(target, pname, params_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglMapParameterivNV(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapParameterivNV(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
 	const GLint *params_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
-	glMapParameterivNVPROC glMapParameterivNV = (glMapParameterivNVPROC)((intptr_t)function_pointer);
-	glMapParameterivNV(target, pname, params_address);
+	glGetMapParameterivNVPROC glGetMapParameterivNV = (glGetMapParameterivNVPROC)((intptr_t)function_pointer);
+	glGetMapParameterivNV(target, pname, params_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglMapParameterfvNV(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) {
-	const GLfloat *params_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
-	glMapParameterfvNVPROC glMapParameterfvNV = (glMapParameterfvNVPROC)((intptr_t)function_pointer);
-	glMapParameterfvNV(target, pname, params_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapAttribParameterfvNV(JNIEnv *env, jclass clazz, jint target, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
+	GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
+	glGetMapAttribParameterfvNVPROC glGetMapAttribParameterfvNV = (glGetMapAttribParameterfvNVPROC)((intptr_t)function_pointer);
+	glGetMapAttribParameterfvNV(target, index, pname, params_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglMapControlPointsNV(JNIEnv *env, jclass clazz, jint target, jint index, jint type, jint ustride, jint vstride, jint uorder, jint vorder, jboolean packed, jobject pPoints, jint pPoints_position, jlong function_pointer) {
-	const GLvoid *pPoints_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pPoints)) + pPoints_position));
-	glMapControlPointsNVPROC glMapControlPointsNV = (glMapControlPointsNVPROC)((intptr_t)function_pointer);
-	glMapControlPointsNV(target, index, type, ustride, vstride, uorder, vorder, packed, pPoints_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapAttribParameterivNV(JNIEnv *env, jclass clazz, jint target, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
+	GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
+	glGetMapAttribParameterivNVPROC glGetMapAttribParameterivNV = (glGetMapAttribParameterivNVPROC)((intptr_t)function_pointer);
+	glGetMapAttribParameterivNV(target, index, pname, params_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapControlPointsNV(JNIEnv *env, jclass clazz, jint target, jint index, jint type, jint ustride, jint vstride, jboolean packed, jobject pPoints, jint pPoints_position, jlong function_pointer) {
-	const GLvoid *pPoints_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pPoints)) + pPoints_position));
-	glGetMapControlPointsNVPROC glGetMapControlPointsNV = (glGetMapControlPointsNVPROC)((intptr_t)function_pointer);
-	glGetMapControlPointsNV(target, index, type, ustride, vstride, packed, pPoints_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglEvalMapsNV(JNIEnv *env, jclass clazz, jint target, jint mode, jlong function_pointer) {
+	glEvalMapsNVPROC glEvalMapsNV = (glEvalMapsNVPROC)((intptr_t)function_pointer);
+	glEvalMapsNV(target, mode);
 }
 

Index: org_lwjgl_opengl_NVFragmentProgram.c
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/nv/org_lwjgl_opengl_NVFragmentProgram.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- org_lwjgl_opengl_NVFragmentProgram.c	16 Feb 2005 20:25:18 -0000	1.4
+++ org_lwjgl_opengl_NVFragmentProgram.c	29 Jun 2005 07:39:28 -0000	1.5
@@ -3,8 +3,14 @@
 #include <jni.h>
 #include "extgl.h"
 
-typedef void (APIENTRY *glGetProgramNamedParameterfvNVPROC) (GLuint id, GLsizei length, const GLubyte * name, GLfloat * params);
 typedef void (APIENTRY *glProgramNamedParameter4fNVPROC) (GLuint id, GLsizei length, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY *glGetProgramNamedParameterfvNVPROC) (GLuint id, GLsizei length, const GLubyte * name, GLfloat * params);
+
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFragmentProgram_nglProgramNamedParameter4fNV(JNIEnv *env, jclass clazz, jint id, jint length, jobject name, jint name_position, jfloat x, jfloat y, jfloat z, jfloat w, jlong function_pointer) {
+	const GLubyte *name_address = ((const GLubyte *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
+	glProgramNamedParameter4fNVPROC glProgramNamedParameter4fNV = (glProgramNamedParameter4fNVPROC)((intptr_t)function_pointer);
+	glProgramNamedParameter4fNV(id, length, name_address, x, y, z, w);
+}
 
 JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFragmentProgram_nglGetProgramNamedParameterfvNV(JNIEnv *env, jclass clazz, jint id, jint length, jobject name, jint name_position, jobject params, jint params_position, jlong function_pointer) {
 	const GLubyte *name_address = ((const GLubyte *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
@@ -13,9 +19,3 @@
 	glGetProgramNamedParameterfvNV(id, length, name_address, params_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFragmentProgram_nglProgramNamedParameter4fNV(JNIEnv *env, jclass clazz, jint id, jint length, jobject name, jint name_position, jfloat x, jfloat y, jfloat z, jfloat w, jlong function_pointer) {
-	const GLubyte *name_address = ((const GLubyte *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
-	glProgramNamedParameter4fNVPROC glProgramNamedParameter4fNV = (glProgramNamedParameter4fNVPROC)((intptr_t)function_pointer);
-	glProgramNamedParameter4fNV(id, length, name_address, x, y, z, w);
-}
-

Index: org_lwjgl_opengl_NVPointSprite.c
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/nv/org_lwjgl_opengl_NVPointSprite.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- org_lwjgl_opengl_NVPointSprite.c	16 Feb 2005 20:25:21 -0000	1.4
+++ org_lwjgl_opengl_NVPointSprite.c	29 Jun 2005 07:39:28 -0000	1.5
@@ -3,8 +3,13 @@
 #include <jni.h>
 #include "extgl.h"
 
-typedef void (APIENTRY *glPointParameterivNVPROC) (GLenum pname, const GLint * params);
 typedef void (APIENTRY *glPointParameteriNVPROC) (GLenum pname, GLint param);
+typedef void (APIENTRY *glPointParameterivNVPROC) (GLenum pname, const GLint * params);
+
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPointSprite_nglPointParameteriNV(JNIEnv *env, jclass clazz, jint pname, jint param, jlong function_pointer) {
+	glPointParameteriNVPROC glPointParameteriNV = (glPointParameteriNVPROC)((intptr_t)function_pointer);
+	glPointParameteriNV(pname, param);
+}
 
 JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPointSprite_nglPointParameterivNV(JNIEnv *env, jclass clazz, jint pname, jobject params, jint params_position, jlong function_pointer) {
 	const GLint *params_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
@@ -12,8 +17,3 @@
 	glPointParameterivNV(pname, params_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPointSprite_nglPointParameteriNV(JNIEnv *env, jclass clazz, jint pname, jint param, jlong function_pointer) {
-	glPointParameteriNVPROC glPointParameteriNV = (glPointParameteriNVPROC)((intptr_t)function_pointer);
-	glPointParameteriNV(pname, param);
-}
-

Index: org_lwjgl_opengl_NVProgram.c
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/nv/org_lwjgl_opengl_NVProgram.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- org_lwjgl_opengl_NVProgram.c	16 Feb 2005 20:25:21 -0000	1.4
+++ org_lwjgl_opengl_NVProgram.c	29 Jun 2005 07:39:28 -0000	1.5
@@ -3,40 +3,37 @@
 #include <jni.h>
 #include "extgl.h"
 
-typedef void (APIENTRY *glRequestResidentProgramsNVPROC) (GLsizei n, GLuint * programIDs);
-typedef GLboolean (APIENTRY *glAreProgramsResidentNVPROC) (GLsizei n, const GLuint * programIDs, GLboolean * programResidences);
-typedef GLboolean (APIENTRY *glIsProgramNVPROC) (GLuint programID);
-typedef void (APIENTRY *glGetProgramStringNVPROC) (GLuint programID, GLenum parameterName, GLvoid * paramString);
-typedef void (APIENTRY *glGetProgramivNVPROC) (GLuint programID, GLenum parameterName, GLint * params);
-typedef void (APIENTRY *glGenProgramsNVPROC) (GLsizei n, GLuint * programs);
-typedef void (APIENTRY *glDeleteProgramsNVPROC) (GLsizei n, const GLuint * programs);
-typedef void (APIENTRY *glBindProgramNVPROC) (GLenum target, GLuint programID);
 typedef void (APIENTRY *glLoadProgramNVPROC) (GLenum target, GLuint programID, GLsizei length, const GLvoid * string);
+typedef void (APIENTRY *glBindProgramNVPROC) (GLenum target, GLuint programID);
+typedef void (APIENTRY *glDeleteProgramsNVPROC) (GLsizei n, const GLuint * programs);
+typedef void (APIENTRY *glGenProgramsNVPROC) (GLsizei n, GLuint * programs);
+typedef void (APIENTRY *glGetProgramivNVPROC) (GLuint programID, GLenum parameterName, GLint * params);
+typedef void (APIENTRY *glGetProgramStringNVPROC) (GLuint programID, GLenum parameterName, GLvoid * paramString);
+typedef GLboolean (APIENTRY *glIsProgramNVPROC) (GLuint programID);
+typedef GLboolean (APIENTRY *glAreProgramsResidentNVPROC) (GLsizei n, const GLuint * programIDs, GLboolean * programResidences);
+typedef void (APIENTRY *glRequestResidentProgramsNVPROC) (GLsizei n, GLuint * programIDs);
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglRequestResidentProgramsNV(JNIEnv *env, jclass clazz, jint n, jobject programIDs, jint programIDs_position, jlong function_pointer) {
-	GLuint *programIDs_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, programIDs)) + programIDs_position;
-	glRequestResidentProgramsNVPROC glRequestResidentProgramsNV = (glRequestResidentProgramsNVPROC)((intptr_t)function_pointer);
-	glRequestResidentProgramsNV(n, programIDs_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglLoadProgramNV(JNIEnv *env, jclass clazz, jint target, jint programID, jint length, jobject string, jint string_position, jlong function_pointer) {
+	const GLvoid *string_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, string)) + string_position));
+	glLoadProgramNVPROC glLoadProgramNV = (glLoadProgramNVPROC)((intptr_t)function_pointer);
+	glLoadProgramNV(target, programID, length, string_address);
 }
 
-JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_NVProgram_nglAreProgramsResidentNV(JNIEnv *env, jclass clazz, jint n, jobject programIDs, jint programIDs_position, jobject programResidences, jint programResidences_position, jlong function_pointer) {
-	const GLuint *programIDs_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, programIDs)) + programIDs_position;
-	GLboolean *programResidences_address = ((GLboolean *)(*env)->GetDirectBufferAddress(env, programResidences)) + programResidences_position;
-	glAreProgramsResidentNVPROC glAreProgramsResidentNV = (glAreProgramsResidentNVPROC)((intptr_t)function_pointer);
-	GLboolean __result = glAreProgramsResidentNV(n, programIDs_address, programResidences_address);
-	return __result;
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglBindProgramNV(JNIEnv *env, jclass clazz, jint target, jint programID, jlong function_pointer) {
+	glBindProgramNVPROC glBindProgramNV = (glBindProgramNVPROC)((intptr_t)function_pointer);
+	glBindProgramNV(target, programID);
 }
 
-JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_NVProgram_nglIsProgramNV(JNIEnv *env, jclass clazz, jint programID, jlong function_pointer) {
-	glIsProgramNVPROC glIsProgramNV = (glIsProgramNVPROC)((intptr_t)function_pointer);
-	GLboolean __result = glIsProgramNV(programID);
-	return __result;
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglDeleteProgramsNV(JNIEnv *env, jclass clazz, jint n, jobject programs, jint programs_position, jlong function_pointer) {
+	const GLuint *programs_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, programs)) + programs_position;
+	glDeleteProgramsNVPROC glDeleteProgramsNV = (glDeleteProgramsNVPROC)((intptr_t)function_pointer);
+	glDeleteProgramsNV(n, programs_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglGetProgramStringNV(JNIEnv *env, jclass clazz, jint programID, jint parameterName, jobject paramString, jint paramString_position, jlong function_pointer) {
-	GLvoid *paramString_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, paramString)) + paramString_position));
-	glGetProgramStringNVPROC glGetProgramStringNV = (glGetProgramStringNVPROC)((intptr_t)function_pointer);
-	glGetProgramStringNV(programID, parameterName, paramString_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglGenProgramsNV(JNIEnv *env, jclass clazz, jint n, jobject programs, jint programs_position, jlong function_pointer) {
+	GLuint *programs_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, programs)) + programs_position;
+	glGenProgramsNVPROC glGenProgramsNV = (glGenProgramsNVPROC)((intptr_t)function_pointer);
+	glGenProgramsNV(n, programs_address);
 }
 
 JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglGetProgramivNV(JNIEnv *env, jclass clazz, jint programID, jint parameterName, jobject params, jint params_position, jlong function_pointer) {
@@ -45,26 +42,29 @@
 	glGetProgramivNV(programID, parameterName, params_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglGenProgramsNV(JNIEnv *env, jclass clazz, jint n, jobject programs, jint programs_position, jlong function_pointer) {
-	GLuint *programs_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, programs)) + programs_position;
-	glGenProgramsNVPROC glGenProgramsNV = (glGenProgramsNVPROC)((intptr_t)function_pointer);
-	glGenProgramsNV(n, programs_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglGetProgramStringNV(JNIEnv *env, jclass clazz, jint programID, jint parameterName, jobject paramString, jint paramString_position, jlong function_pointer) {
+	GLvoid *paramString_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, paramString)) + paramString_position));
+	glGetProgramStringNVPROC glGetProgramStringNV = (glGetProgramStringNVPROC)((intptr_t)function_pointer);
+	glGetProgramStringNV(programID, parameterName, paramString_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglDeleteProgramsNV(JNIEnv *env, jclass clazz, jint n, jobject programs, jint programs_position, jlong function_pointer) {
-	const GLuint *programs_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, programs)) + programs_position;
-	glDeleteProgramsNVPROC glDeleteProgramsNV = (glDeleteProgramsNVPROC)((intptr_t)function_pointer);
-	glDeleteProgramsNV(n, programs_address);
+JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_NVProgram_nglIsProgramNV(JNIEnv *env, jclass clazz, jint programID, jlong function_pointer) {
+	glIsProgramNVPROC glIsProgramNV = (glIsProgramNVPROC)((intptr_t)function_pointer);
+	GLboolean __result = glIsProgramNV(programID);
+	return __result;
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglBindProgramNV(JNIEnv *env, jclass clazz, jint target, jint programID, jlong function_pointer) {
-	glBindProgramNVPROC glBindProgramNV = (glBindProgramNVPROC)((intptr_t)function_pointer);
-	glBindProgramNV(target, programID);
+JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_NVProgram_nglAreProgramsResidentNV(JNIEnv *env, jclass clazz, jint n, jobject programIDs, jint programIDs_position, jobject programResidences, jint programResidences_position, jlong function_pointer) {
+	const GLuint *programIDs_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, programIDs)) + programIDs_position;
+	GLboolean *programResidences_address = ((GLboolean *)(*env)->GetDirectBufferAddress(env, programResidences)) + programResidences_position;
+	glAreProgramsResidentNVPROC glAreProgramsResidentNV = (glAreProgramsResidentNVPROC)((intptr_t)function_pointer);
+	GLboolean __result = glAreProgramsResidentNV(n, programIDs_address, programResidences_address);
+	return __result;
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglLoadProgramNV(JNIEnv *env, jclass clazz, jint target, jint programID, jint length, jobject string, jint string_position, jlong function_pointer) {
-	const GLvoid *string_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, string)) + string_position));
-	glLoadProgramNVPROC glLoadProgramNV = (glLoadProgramNVPROC)((intptr_t)function_pointer);
-	glLoadProgramNV(target, programID, length, string_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglRequestResidentProgramsNV(JNIEnv *env, jclass clazz, jint n, jobject programIDs, jint programIDs_position, jlong function_pointer) {
+	GLuint *programIDs_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, programIDs)) + programIDs_position;
+	glRequestResidentProgramsNVPROC glRequestResidentProgramsNV = (glRequestResidentProgramsNVPROC)((intptr_t)function_pointer);
+	glRequestResidentProgramsNV(n, programIDs_address);
 }
 

Index: org_lwjgl_opengl_NVPixelDataRange.c
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/nv/org_lwjgl_opengl_NVPixelDataRange.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- org_lwjgl_opengl_NVPixelDataRange.c	16 Feb 2005 20:25:21 -0000	1.4
+++ org_lwjgl_opengl_NVPixelDataRange.c	29 Jun 2005 07:39:28 -0000	1.5
@@ -3,13 +3,8 @@
 #include <jni.h>
 #include "extgl.h"
 
-typedef void (APIENTRY *glFlushPixelDataRangeNVPROC) (GLenum target);
 typedef void (APIENTRY *glPixelDataRangeNVPROC) (GLenum target, GLsizei length, GLvoid * data);
-
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPixelDataRange_nglFlushPixelDataRangeNV(JNIEnv *env, jclass clazz, jint target, jlong function_pointer) {
-	glFlushPixelDataRangeNVPROC glFlushPixelDataRangeNV = (glFlushPixelDataRangeNVPROC)((intptr_t)function_pointer);
-	glFlushPixelDataRangeNV(target);
-}
+typedef void (APIENTRY *glFlushPixelDataRangeNVPROC) (GLenum target);
 
 JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPixelDataRange_nglPixelDataRangeNV(JNIEnv *env, jclass clazz, jint target, jint length, jobject data, jint data_position, jlong function_pointer) {
 	GLvoid *data_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
@@ -17,3 +12,8 @@
 	glPixelDataRangeNV(target, length, data_address);
 }
 
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPixelDataRange_nglFlushPixelDataRangeNV(JNIEnv *env, jclass clazz, jint target, jlong function_pointer) {
+	glFlushPixelDataRangeNVPROC glFlushPixelDataRangeNV = (glFlushPixelDataRangeNVPROC)((intptr_t)function_pointer);
+	glFlushPixelDataRangeNV(target);
+}
+

Index: org_lwjgl_opengl_NVRegisterCombiners.c
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/nv/org_lwjgl_opengl_NVRegisterCombiners.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- org_lwjgl_opengl_NVRegisterCombiners.c	16 Feb 2005 20:25:21 -0000	1.4
+++ org_lwjgl_opengl_NVRegisterCombiners.c	29 Jun 2005 07:39:28 -0000	1.5
@@ -3,54 +3,50 @@
 #include <jni.h>
 #include "extgl.h"
 
-typedef void (APIENTRY *glGetFinalCombinerInputParameterivNVPROC) (GLenum variable, GLenum pname, GLint * params);
-typedef void (APIENTRY *glGetFinalCombinerInputParameterfvNVPROC) (GLenum variable, GLenum pname, GLfloat * params);
-typedef void (APIENTRY *glGetCombinerOutputParameterivNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLint * params);
-typedef void (APIENTRY *glGetCombinerOutputParameterfvNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLfloat * params);
-typedef void (APIENTRY *glGetCombinerInputParameterivNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint * params);
-typedef void (APIENTRY *glGetCombinerInputParameterfvNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat * params);
-typedef void (APIENTRY *glFinalCombinerInputNVPROC) (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 *glCombinerInputNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
-typedef void (APIENTRY *glCombinerParameterivNVPROC) (GLenum pname, const GLint * params);
-typedef void (APIENTRY *glCombinerParameteriNVPROC) (GLenum pname, GLint param);
-typedef void (APIENTRY *glCombinerParameterfvNVPROC) (GLenum pname, const GLfloat * params);
 typedef void (APIENTRY *glCombinerParameterfNVPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY *glCombinerParameterfvNVPROC) (GLenum pname, const GLfloat * params);
+typedef void (APIENTRY *glCombinerParameteriNVPROC) (GLenum pname, GLint param);
+typedef void (APIENTRY *glCombinerParameterivNVPROC) (GLenum pname, const GLint * params);
+typedef void (APIENTRY *glCombinerInputNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
+typedef void (APIENTRY *glCombinerOutputNVPROC) (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum);
+typedef void (APIENTRY *glFinalCombinerInputNVPROC) (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
+typedef void (APIENTRY *glGetCombinerInputParameterfvNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat * params);
+typedef void (APIENTRY *glGetCombinerInputParameterivNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint * params);
+typedef void (APIENTRY *glGetCombinerOutputParameterfvNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLfloat * params);
+typedef void (APIENTRY *glGetCombinerOutputParameterivNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLint * params);
+typedef void (APIENTRY *glGetFinalCombinerInputParameterfvNVPROC) (GLenum variable, GLenum pname, GLfloat * params);
+typedef void (APIENTRY *glGetFinalCombinerInputParameterivNVPROC) (GLenum variable, GLenum pname, GLint * params);
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVRegisterCombiners_nglGetFinalCombinerInputParameterivNV(JNIEnv *env, jclass clazz, jint variable, jint pname, jobject params, jint params_position, jlong function_pointer) {
-	GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
-	glGetFinalCombinerInputParameterivNVPROC glGetFinalCombinerInputParameterivNV = (glGetFinalCombinerInputParameterivNVPROC)((intptr_t)function_pointer);
-	glGetFinalCombinerInputParameterivNV(variable, pname, params_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVRegisterCombiners_nglCombinerParameterfNV(JNIEnv *env, jclass clazz, jint pname, jfloat param, jlong function_pointer) {
+	glCombinerParameterfNVPROC glCombinerParameterfNV = (glCombinerParameterfNVPROC)((intptr_t)function_pointer);
+	glCombinerParameterfNV(pname, param);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVRegisterCombiners_nglGetFinalCombinerInputParameterfvNV(JNIEnv *env, jclass clazz, jint variable, jint pname, jobject params, jint params_position, jlong function_pointer) {
-	GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
-	glGetFinalCombinerInputParameterfvNVPROC glGetFinalCombinerInputParameterfvNV = (glGetFinalCombinerInputParameterfvNVPROC)((intptr_t)function_pointer);
-	glGetFinalCombinerInputParameterfvNV(variable, pname, params_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVRegisterCombiners_nglCombinerParameterfvNV(JNIEnv *env, jclass clazz, jint pname, jobject params, jint params_position, jlong function_pointer) {
+	const GLfloat *params_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
+	glCombinerParameterfvNVPROC glCombinerParameterfvNV = (glCombinerParameterfvNVPROC)((intptr_t)function_pointer);
+	glCombinerParameterfvNV(pname, params_address);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVRegisterCombiners_nglGetCombinerOutputParameterivNV(JNIEnv *env, jclass clazz, jint stage, jint portion, jint pname, jobject params, jint params_position, jlong function_pointer) {
-	GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
-	glGetCombinerOutputParameterivNVPROC glGetCombinerOutputParameterivNV = (glGetCombinerOutputParameterivNVPROC)((intptr_t)function_pointer);
-	glGetCombinerOutputParameterivNV(stage, portion, pname, params_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVRegisterCombiners_nglCombinerParameteriNV(JNIEnv *env, jclass clazz, jint pname, jint param, jlong function_pointer) {
+	glCombinerParameteriNVPROC glCombinerParameteriNV = (glCombinerParameteriNVPROC)((intptr_t)function_pointer);
+	glCombinerParameteriNV(pname, param);
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVRegisterCombiners_nglGetCombinerOutputParameterfvNV(JNIEnv *env, jclass clazz, jint stage, jint portion, jint pname, jobject params, jint params_position, jlong function_pointer) {
-	GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
-	glGetCombinerOutputParameterfvNVPROC glGetCombinerOutputParameterfvNV = (glGetCombinerOutputParameterfvNVPROC)((intptr_t)function_pointer);
-	glGetCombinerOutputParameterfvNV(stage, portion, pname, params_address);
+JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVRegisterCombiners_nglCombinerParameterivNV(JNIEnv *env, jclass clazz, jint pname, jobject params, jint params_position, jlong function_pointer) {
+	const GLint *params_addres...
 
[truncated message content]