Import from upstream.
authorSimon 'corecode' Schubert <corecode@fs.ei.tum.de>
Tue, 8 Jan 2008 21:45:55 +0000 (22:45 +0100)
committerSimon 'corecode' Schubert <corecode@fs.ei.tum.de>
Tue, 8 Jan 2008 21:45:55 +0000 (22:45 +0100)
107 files changed:
Makefile [new file with mode: 0644]
doc/Copyrights [new file with mode: 0644]
doc/Makefile [new file with mode: 0644]
doc/README [new file with mode: 0644]
doc/XF86Config.sample [new file with mode: 0644]
doc/gl.h [new file with mode: 0755]
doc/glext.h [new file with mode: 0755]
doc/glx.h [new file with mode: 0755]
doc/glxtokens.h [new file with mode: 0755]
doc/html/appendix-a.html [new file with mode: 0644]
doc/html/appendix-b.html [new file with mode: 0644]
doc/html/appendix-c.html [new file with mode: 0644]
doc/html/appendix-d.html [new file with mode: 0644]
doc/html/appendix-e.html [new file with mode: 0644]
doc/html/appendix-f.html [new file with mode: 0644]
doc/html/appendix-g.html [new file with mode: 0644]
doc/html/appendix-h.html [new file with mode: 0644]
doc/html/appendix-i.html [new file with mode: 0644]
doc/html/appendix-j.html [new file with mode: 0644]
doc/html/chapter-01.html [new file with mode: 0644]
doc/html/chapter-02.html [new file with mode: 0644]
doc/html/chapter-03.html [new file with mode: 0644]
doc/html/chapter-04-section-02.html [new file with mode: 0644]
doc/html/chapter-04.html [new file with mode: 0644]
doc/html/chapter-05.html [new file with mode: 0644]
doc/html/chapter-06.html [new file with mode: 0644]
doc/html/chapter-07.html [new file with mode: 0644]
doc/html/chapter-08.html [new file with mode: 0644]
doc/html/chapter-09.html [new file with mode: 0644]
doc/html/chapter-10.html [new file with mode: 0644]
doc/html/chapter-11.html [new file with mode: 0644]
doc/html/chapter-12.html [new file with mode: 0644]
doc/html/chapter-13.html [new file with mode: 0644]
doc/html/chapter-14.html [new file with mode: 0644]
doc/html/chapter-15.html [new file with mode: 0644]
doc/html/chapter-16.html [new file with mode: 0644]
doc/html/chapter-17.html [new file with mode: 0644]
doc/html/chapter-18.html [new file with mode: 0644]
doc/html/chapter-19.html [new file with mode: 0644]
doc/html/chapter-20.html [new file with mode: 0644]
doc/html/chapter-21.html [new file with mode: 0644]
doc/html/chapter-22.html [new file with mode: 0644]
doc/html/chapter-23.html [new file with mode: 0644]
doc/html/chapter-24.html [new file with mode: 0644]
doc/html/chapter-25.html [new file with mode: 0644]
doc/html/index.html [new file with mode: 0644]
doc/html/part-01.html [new file with mode: 0644]
doc/html/part-02.html [new file with mode: 0644]
doc/license.txt [new file with mode: 0644]
lib/Makefile [new file with mode: 0644]
lib/compat/Makefile [new file with mode: 0644]
lib/compat/libGL/Makefile [new file with mode: 0644]
lib/compat/libGLcore/Makefile [new file with mode: 0644]
lib/compat/libnvidia-tls/Makefile [new file with mode: 0644]
lib/libGL/Makefile [new file with mode: 0644]
lib/libGLcore/Makefile [new file with mode: 0644]
lib/libXvMCNVIDIA/Makefile [new file with mode: 0644]
lib/libnvidia-cfg/Makefile [new file with mode: 0644]
lib/libnvidia-tls/Makefile [new file with mode: 0644]
mk/nvidia.lib.mk [new file with mode: 0644]
obj/libGL.so.1 [new file with mode: 0644]
obj/libGLcore.so.1 [new file with mode: 0755]
obj/libXvMCNVIDIA.a [new file with mode: 0755]
obj/libXvMCNVIDIA.so.1 [new file with mode: 0755]
obj/libglx.so.1 [new file with mode: 0644]
obj/libnvidia-cfg.so.1 [new file with mode: 0644]
obj/libnvidia-tls.so.1 [new file with mode: 0644]
obj/libnvidia-wfb.so.1 [new file with mode: 0755]
obj/linux/libGL.so.169.07 [new file with mode: 0755]
obj/linux/libGLcore.so.169.07 [new file with mode: 0755]
obj/linux/libcuda.so.169.07 [new file with mode: 0755]
obj/linux/libnvidia-cfg.so.169.07 [new file with mode: 0755]
obj/linux/libnvidia-tls.so.169.07 [new file with mode: 0755]
obj/nvidia-bug-report.sh [new file with mode: 0755]
obj/nvidia-settings [new file with mode: 0755]
obj/nvidia-xconfig [new file with mode: 0755]
obj/nvidia_drv.so [new file with mode: 0755]
scripts/linux.sh [new file with mode: 0755]
scripts/setup.sh [new file with mode: 0755]
src/Makefile [new file with mode: 0644]
src/cpuopsys.h [new file with mode: 0644]
src/nv-freebsd.h [new file with mode: 0644]
src/nv-kernel.o [new file with mode: 0644]
src/nv-misc.h [new file with mode: 0644]
src/nv-reg.h [new file with mode: 0644]
src/nv.h [new file with mode: 0644]
src/nvidia_ctl.c [new file with mode: 0644]
src/nvidia_dev.c [new file with mode: 0644]
src/nvidia_i2c.c [new file with mode: 0644]
src/nvidia_linux.c [new file with mode: 0644]
src/nvidia_os.c [new file with mode: 0644]
src/nvidia_os_pci.c [new file with mode: 0644]
src/nvidia_os_registry.c [new file with mode: 0644]
src/nvidia_pci.c [new file with mode: 0644]
src/nvidia_subr.c [new file with mode: 0644]
src/nvidia_sysctl.c [new file with mode: 0644]
src/nvtypes.h [new file with mode: 0644]
src/os-interface.h [new file with mode: 0644]
src/rmretval.h [new file with mode: 0644]
x11/Makefile [new file with mode: 0644]
x11/bin/Makefile [new file with mode: 0644]
x11/driver/Makefile [new file with mode: 0644]
x11/extension/Makefile [new file with mode: 0755]
x11/lib/Makefile [new file with mode: 0644]
x11/man/Makefile [new file with mode: 0644]
x11/man/nvidia-settings.1 [new file with mode: 0644]
x11/man/nvidia-xconfig.1 [new file with mode: 0644]

diff --git a/Makefile b/Makefile
new file mode 100644 (file)
index 0000000..ce8dc43
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,20 @@
+SUBDIR=        src \
+       lib \
+       x11 \
+       doc
+
+afterinstall:
+       @${.CURDIR}/scripts/setup.sh
+       @${.CURDIR}/scripts/linux.sh
+       @echo
+       @echo "Installation of the NVIDIA Accelerated Graphics Driver"
+       @echo "169.07 for FreeBSD is now complete.  You can now"
+       @echo "run the nvidia-xconfig utility to automatically update"
+       @echo "your X server configuration file.  Please see the README"
+       @echo "for details if you wish to update your X configuration"
+       @echo "file manually."
+       @echo
+
+setup: install
+
+.include <bsd.subdir.mk>
diff --git a/doc/Copyrights b/doc/Copyrights
new file mode 100644 (file)
index 0000000..b3f1263
--- /dev/null
@@ -0,0 +1,37 @@
+ The NVIDIA graphics driver uses the NetBSD implementation of
+__udivdi3, which carries the following copyright notice:
+
+Copyright (c) 1992, 1993
+       The Regents of the University of California.  All rights reserved.
+
+This software was developed by the Computer Systems Engineering group
+at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
+contributed to Berkeley.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. All advertising materials mentioning features or use of this software
+   must display the following acknowledgement:
+       This product includes software developed by the University of
+       California, Berkeley and its contributors.
+4. Neither the name of the University nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.
diff --git a/doc/Makefile b/doc/Makefile
new file mode 100644 (file)
index 0000000..4ca8a8e
--- /dev/null
@@ -0,0 +1,41 @@
+NVIDIA_ROOT=   ${.CURDIR}/..
+
+.if !defined(X11BASE)
+X11BASE=       /usr/X11R6
+.endif
+
+BSDVER!=       /sbin/sysctl -n kern.osreldate
+.if ${BSDVER} >= 600000
+NO_OBJ=        noobj
+.else
+NOOBJ= noobj
+.endif
+
+DOCS=  README \
+       XF86Config.sample \
+       license.txt \
+       gl.h glx.h glext.h \
+       glxtokens.h
+
+HTMLDOCS!=(ls ${NVIDIA_ROOT}/doc/html/)
+
+DOCDIR=        ${X11BASE}/share/doc/NVIDIA_GLX-1.0
+
+all:   # dummy rule
+clean: # dummy rule
+
+install:
+       @mkdir -p ${DESTDIR}${DOCDIR}
+.for doc in ${DOCS}
+       @${INSTALL} -o ${DOCOWN} -g ${DOCGRP} -m ${DOCMODE} \
+               ${NVIDIA_ROOT}/doc/${doc} \
+               ${DESTDIR}${DOCDIR}
+.endfor
+       @mkdir -p ${DESTDIR}${DOCDIR}/html
+.for doc in ${HTMLDOCS}
+       @${INSTALL} -o ${DOCOWN} -g ${DOCGRP} -m ${DOCMODE} \
+               ${NVIDIA_ROOT}/doc/html/${doc} \
+               ${DESTDIR}${DOCDIR}/html
+.endfor
+
+.include <bsd.prog.mk>
diff --git a/doc/README b/doc/README
new file mode 100644 (file)
index 0000000..4b704c9
--- /dev/null
@@ -0,0 +1,5129 @@
+NVIDIA Accelerated FreeBSD Graphics Driver README and Installation Guide
+
+    NVIDIA Corporation
+    Last Updated: 2007/11/16
+    Most Recent Driver Version: 169.07
+
+Published by
+NVIDIA Corporation
+2701 San Tomas Expressway
+Santa Clara, CA
+95050
+
+
+NOTICE:
+
+ALL NVIDIA DESIGN SPECIFICATIONS, REFERENCE BOARDS, FILES, DRAWINGS,
+DIAGNOSTICS, LISTS, AND OTHER DOCUMENTS (TOGETHER AND SEPARATELY, "MATERIALS")
+ARE BEING PROVIDED "AS IS." NVIDIA MAKES NO WARRANTIES, EXPRESSED, IMPLIED,
+STATUTORY, OR OTHERWISE WITH RESPECT TO THE MATERIALS, AND EXPRESSLY DISCLAIMS
+ALL IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTABILITY, AND FITNESS FOR A
+PARTICULAR PURPOSE. Information furnished is believed to be accurate and
+reliable. However, NVIDIA Corporation assumes no responsibility for the
+consequences of use of such information or for any infringement of patents or
+other rights of third parties that may result from its use. No license is
+granted by implication or otherwise under any patent or patent rights of
+NVIDIA Corporation. Specifications mentioned in this publication are subject
+to change without notice. This publication supersedes and replaces all
+information previously supplied. NVIDIA Corporation products are not
+authorized for use as critical components in life support devices or systems
+without express written approval of NVIDIA Corporation.
+
+NVIDIA, the NVIDIA logo, NVIDIA nForce, GeForce, NVIDIA Quadro, Vanta, TNT2,
+TNT, RIVA, RIVA TNT, Quincunx Antialiasing, and TwinView are registered
+trademarks or trademarks of NVIDIA Corporation in the United States and/or
+other countries.
+
+FreeBSD is a registered trademark of the FreeBSD Foundation. Linux is a
+registered trademark of Linus Torvalds. Intel and Pentium are registered
+trademarks of Intel Corporation. Athlon is a registered trademark of Advanced
+Micro Devices. OpenGL is a registered trademark of Silicon Graphics Inc. PCI
+Express is a registered trademarks and/or service marks of PCI-SIG. Windows is
+a registered trademark of Microsoft Corporation in the United States and other
+countries. Other company and product names may be trademarks or registered
+trademarks of the respective owners with which they are associated.
+
+
+Copyright 2006 NVIDIA Corporation. All rights reserved.
+
+______________________________________________________________________________
+
+TABLE OF CONTENTS
+______________________________________________________________________________
+
+Chapter 1. Introduction
+Chapter 2. Installing the NVIDIA Driver
+Chapter 3. Using Linux Compatibility Support
+Chapter 4. Configuring X for the NVIDIA Driver
+Chapter 5. Frequently Asked Questions
+Chapter 6. Common Problems
+Chapter 7. Known Issues
+Chapter 8. Specifying OpenGL Environment Variable Settings
+Chapter 9. Configuring AGP
+Chapter 10. Configuring TwinView
+Chapter 11. Configuring GLX in Xinerama
+Chapter 12. Configuring Multiple X Screens on One Card
+Chapter 13. Configuring TV-Out
+Chapter 14. Using the XRandR Extension
+Chapter 15. Configuring a Notebook
+Chapter 16. Programming Modes
+Chapter 17. Configuring Flipping and UBB
+Chapter 18. Using the X Composite Extension
+Chapter 19. Using the nvidia-settings Utility
+Chapter 20. Configuring SLI and Multi-GPU FrameRendering
+Chapter 21. Configuring Frame Lock and Genlock
+Chapter 22. Configuring Depth 30 Displays
+Chapter 23. NVIDIA Contact Info and Additional Resources
+Chapter 24. Credits
+Chapter 25. Acknowledgements
+
+Appendix A. Minimum Software Requirements
+Appendix B. Installed Components
+Appendix C. The Sysctl Interface
+Appendix D. Configuring Low-level Parameters
+Appendix A. Supported NVIDIA GPU Products
+Appendix B. X Config Options
+Appendix C. Display Device Names
+Appendix D. GLX Support
+Appendix E. Dots Per Inch
+Appendix F. XvMC Support
+
+______________________________________________________________________________
+
+Chapter 1. Introduction
+______________________________________________________________________________
+
+
+1A. ABOUT THE NVIDIA ACCELERATED FREEBSD GRAPHICS DRIVER
+
+The NVIDIA Accelerated FreeBSD Graphics Driver brings accelerated 2D
+functionality and high-performance OpenGL support to FreeBSD x86 with the use
+of NVIDIA graphics processing units (GPUs).
+
+These drivers provide optimized hardware acceleration for OpenGL and X
+applications and support nearly all recent NVIDIA GPU products (see Appendix E
+for a complete list of supported GPUs). TwinView, TV-Out and flat panel
+displays are also supported.
+
+
+1B. ABOUT THIS DOCUMENT
+
+This document provides instructions for the installation and use of the NVIDIA
+Accelerated FreeBSD Graphics Driver. Chapter 2, Chapter 3 and Chapter 4 walk
+the user through the process of downloading, installing and configuring the
+driver. Chapter 5 addresses frequently asked questions about the installation
+process, and Chapter 6 provides solutions to common problems. The remaining
+chapters include details on different features of the NVIDIA FreeBSD Driver.
+Frequently asked questions about specific tasks are included in the relevant
+chapters.
+
+
+1C. ABOUT THE AUDIENCE
+
+It is assumed that the user and reader of this document has at least a basic
+understanding of FreeBSD techniques and terminology. However, new FreeBSD
+users can refer to  for details on parts of the installation process.
+
+
+1D. ADDITIONAL INFORMATION
+
+In case additional information is required, Chapter 23 provides contact
+information for NVIDIA FreeBSD driver resources, as well as a brief listing of
+external resources.
+
+______________________________________________________________________________
+
+Appendix A. Minimum Software Requirements
+______________________________________________________________________________
+
+The official minimum software requirements for the NVIDIA FreeBSD Graphics
+Driver are as follows:
+
+    Software Element                      Min Requirement
+    ----------------------------------    ----------------------------------
+    Kernel                                FreeBSD 5-STABLE (5.3 or later)
+    XFree86/X.Org                         4.2/6.7.0
+
+Additionally, the kernel source tree must be installed in /usr/src/sys
+(package 'ssys' installed)
+
+Note that FreeBSD -STABLE versions older than FreeBSD 5.3 and FreeBSD 6.x/7.x
+-CURRENT development snapshots are not supported.
+
+______________________________________________________________________________
+
+Chapter 2. Installing the NVIDIA Driver
+______________________________________________________________________________
+
+This installation procedure will likely be simplified further in the future,
+but for the moment you will need to download the NVIDIA FreeBSD Graphics
+Driver archives from the NVIDIA website, extract them to a temporary location
+of your choice, and run the following from the root of the extracted directory
+hierarchy:
+
+    % make install
+
+This will compile the NVIDIA FreeBSD kernel module, install it, and kldload
+it. It will also remove any conflicting OpenGL libraries, and install the
+NVIDIA OpenGL libraries. The '/dev/nvidia' device files will be created
+(unless the system is using devfs), and your '/boot/loader.conf' file will be
+updated to automatically load the NVIDIA kernel module on boot, as well as the
+Linux ABI compatiability module should you not have it compiled into your
+kernel.
+
+______________________________________________________________________________
+
+Appendix B. Installed Components
+______________________________________________________________________________
+
+The NVIDIA Accelerated FreeBSD Graphics Driver consists of the following
+components.
+
+    Installed File                        Location
+    ----------------------------------    ----------------------------------
+    nvidia.ko                             /boot/modules
+    libGL.so                              /usr/X11R6/lib
+    libGL.so.1                            /usr/X11R6/lib
+    libnvidia-tls.so                      /usr/X11R6/lib
+    libnvidia-tls.so.1                    /usr/X11R6/lib
+    libnvidia-cfg.so                      /usr/X11R6/lib
+    libnvidia-cfg.so.1                    /usr/X11R6/lib
+    libGLcore.so                          /usr/X11R6/lib
+    libGLcore.so.1                        /usr/X11R6/lib
+    nvidia_drv.so                         /usr/X11R6/lib/modules/drivers
+    libglx.so                             /usr/X11R6/lib/modules/extensions
+    libglx.so.1                           /usr/X11R6/lib/modules/extensions
+    nvidia-xconfig                        /usr/X11R6/bin
+    nvidia-xconfig.1                      /usr/X11R6/man/man1
+    nvidia-settings                       /usr/X11R6/bin
+    nvidia-settings.1                     /usr/X11R6/man/man1
+    nvidia0                               /dev
+    nvidia1                               /dev
+    nvidia2                               /dev
+    nvidia3                               /dev
+    nvidiactl                             /dev
+    libGL.so.169.07                       /compat/linux/usr/lib
+    libnvidia-tls.so.169.07               /compat/linux/usr/lib
+    libGLcore.so.169.07                   /compat/linux/usr/lib
+
+
+______________________________________________________________________________
+
+Chapter 3. Using Linux Compatibility Support
+______________________________________________________________________________
+
+If you wish to run Linux OpenGL applications on your FreeBSD computer, you
+will need to make sure that several prerequisites are met.
+
+First, you should follow the basic Linux compatibility installation guide in
+the FreeBSD Handbook (install the linux_base package, etc). Once the basic
+components are in place, you will need to install the NVIDIA Linux OpenGL
+libraries in '/compat/linux/usr/lib' (do not brandelf them!); if the
+'/compat/linux/usr/lib/' directory exists when you install the FreeBSD driver,
+the Linux compatibility OpenGL libraries will automatically be installed.
+
+Additionally, the 'nvidia.ko' kernel module needs to be built with support for
+the Linux ABI compatibility layer. This is the case by default; as a
+consequence, the 'nvidia.ko' kernel module requires the 'linux.ko' module to
+be loaded.
+
+Note: If you have no need for Linux ABI compatibility and do not wish to load
+'linux.ko', you can build the 'nvidia.ko' kernel module without support for
+the Linux ABI compatibility layer (see 'nv-freebsd.h' for details).
+
+______________________________________________________________________________
+
+Chapter 4. Configuring X for the NVIDIA Driver
+______________________________________________________________________________
+
+The X configuration file provides a means to configure the X server. This
+section describes the settings necessary to enable the NVIDIA driver. A
+comprehensive list of parameters is provided in Appendix F.
+
+The NVIDIA Driver includes a utility called nvidia-xconfig, which is designed
+to make editing the X configuration file easy. You can also edit it by hand.
+
+
+4A. USING NVIDIA-XCONFIG TO CONFIGURE THE X SERVER
+
+nvidia-xconfig will find the X configuration file and modify it to use the
+NVIDIA X driver. In most cases, you can simply answer "Yes" when the installer
+asks if it should run it. If you need to reconfigure your X server later, you
+can run nvidia-xconfig again from a terminal. nvidia-xconfig will make a
+backup copy of your configuration file before modifying it.
+
+Note that the X server must be restarted for any changes to its configuration
+file to take effect.
+
+More information about nvidia-xconfig can be found in the nvidia-xconfig
+manual page by running.
+
+    % man nvidia-xconfig
+
+
+
+
+4B. MANUALLY EDITING THE CONFIGURATION FILE
+
+In April 2004 the X.Org Foundation released an X server based on the XFree86
+server. While your release may use the X.Org X server, rather than XFree86,
+the differences between the two should have no impact on NVIDIA FreeBSD users
+with two exceptions:
+
+   o The X.Org configuration file is '/etc/X11/xorg.conf' while the XFree86
+     configuration file is '/etc/X11/XF86Config'. The files use the same
+     syntax. This document refers to both files as "the X config file".
+
+   o The X.Org log file is '/var/log/Xorg.#.log' while the XFree86 log file is
+     '/var/log/XFree86.#.log' (where '#' is the server number -- usually 0).
+     The format of the log files is nearly identical. This document refers to
+     both files as "the X log file".
+
+In order for any changes to be read into the X server, you must edit the file
+used by the server. While it is not unreasonable to simply edit both files, it
+is easy to determine the correct file by searching for the line
+
+    (==) Using config file:
+
+in the X log file. This line indicates the name of the X config file in use.
+
+If you do not have a working X config file, there are a few different ways to
+obtain one. A sample config file is included both with the XFree86
+distribution and with the NVIDIA driver package (at
+'/usr/X11R6/share/doc/NVIDIA_GLX-1.0/'). Tools for generating a config file
+(such as 'xf86config') are generally included with FreeBSD. Additional
+information on the X config syntax can be found in the XF86Config manual page
+(`man XF86Config` or `man xorg.conf`).
+
+If you have a working X config file for a different driver (such as the "nv"
+or "vesa" driver), then simply edit the file as follows.
+
+Remove the line:
+
+      Driver "nv"
+  (or Driver "vesa")
+  (or Driver "fbdev")
+
+and replace it with the line:
+
+    Driver "nvidia"
+
+Remove the following lines:
+
+    Load "dri"
+    Load "GLCore"
+
+In the "Module" section of the file, add the line (if it does not already
+exist):
+
+    Load "glx"
+
+There are numerous options that may be added to the X config file to tune the
+NVIDIA X driver. See Appendix F for a complete list of these options.
+
+Once you have completed these edits to the X config file, you may restart X
+and begin using the accelerated OpenGL libraries. After restarting X, any
+OpenGL application should automatically use the new NVIDIA libraries. (NOTE:
+If you encounter any problems, see Chapter 6 for common problem diagnoses.)
+
+______________________________________________________________________________
+
+Chapter 5. Frequently Asked Questions
+______________________________________________________________________________
+
+This section provides answers to frequently asked questions associated with
+the NVIDIA FreeBSD x86 Driver and its installation. Common problem diagnoses
+can be found in Chapter 6 and tips for new users can be found in . Also,
+detailed information for specific setups is provided in the Appendices.
+
+
+NVIDIA DRIVER
+
+Q. Where should I start when diagnosing display problems?
+
+A. One of the most useful tools for diagnosing problems is the X log file in
+   '/var/log'. Lines that begin with "(II)" are information, "(WW)" are
+   warnings, and "(EE)" are errors. You should make sure that the correct
+   config file (i.e. the config file you are editing) is being used; look for
+   the line that begins with:
+   
+       (==) Using config file:
+   
+   Also make sure that the NVIDIA driver is being used, rather than the "nv"
+   or "vesa" driver. Search for
+   
+       (II) LoadModule: "nvidia"
+   
+   Lines from the driver should begin with:
+   
+       (II) NVIDIA(0)
+   
+   
+
+Q. How can I increase the amount of data printed in the X log file?
+
+A. By default, the NVIDIA X driver prints relatively few messages to stderr
+   and the X log file. If you need to troubleshoot, then it may be helpful to
+   enable more verbose output by using the X command line options -verbose and
+   -logverbose, which can be used to set the verbosity level for the 'stderr'
+   and log file messages, respectively. The NVIDIA X driver will output more
+   messages when the verbosity level is at or above 5 (X defaults to verbosity
+   level 1 for 'stderr' and level 3 for the log file). So, to enable verbose
+   messaging from the NVIDIA X driver to both the log file and 'stderr', you
+   could start X with the verbosity level set to 5, by doing the following
+   
+       % startx -- -verbose 5 -logverbose 5
+   
+   
+
+Q. I have read that the NVIDIA FreeBSD Driver is not a native driver, but sits
+   on top of the Linux ABI compatibility layer. Is this true?
+
+A. No, the NVIDIA FreeBSD Graphics Driver is a native driver. It does provide
+   Linux OpenGL libraries in addition to the native, FreeBSD libraries to
+   enable users to run Linux OpenGL applications.
+
+
+Q. Is the NVIDIA FreeBSD Accelerated Graphics Driver thread-safe?
+
+A. This release is thread-safe on FreeBSD 5.3 or later systems making use of
+   the libpthread or libthr KSE threading libraries. On these systems, the
+   NVIDIA Linux ABI compatibility libraries are fully thread-safe as well.
+
+
+Q. Why can't the Linux compatibility libraries correctly determine if they are
+   used in a multithreaded application?
+
+A. The Linux compatibility libraries are not able to correctly determine if
+   they are used in a multithreaded application because the %gs segment
+   register is not initialized correctly for Linux compatibility.
+
+   The '__GL_SINGLE_THREADED' environment variable (set to "1") can be used to
+   work around this issue, but at the cost of thread-safeness.
+
+
+Q. Why do applications that use DGA graphics fail?
+
+A. The NVIDIA driver does not support the graphics component of the
+   XFree86-DGA (Direct Graphics Access) extension. Applications can use the
+   XDGASelectInput() function to acquire relative pointer motion, but
+   graphics-related functions such as XDGASetMode() and XDGAOpenFramebuffer()
+   will fail.
+
+   The graphics component of XFree86-DGA is not supported because it requires
+   a CPU mapping of framebuffer memory. As graphics cards ship with increasing
+   quantities of video memory, the NVIDIA X driver has had to switch to a more
+   dynamic memory mapping scheme that is incompatible with DGA. Furthermore,
+   DGA does not cooperate with other graphics rendering libraries such as Xlib
+   and OpenGL because it accesses GPU resources directly.
+
+   NVIDIA recommends that applications use OpenGL or Xlib, rather than DGA,
+   for graphics rendering. Using rendering libraries other than DGA will yield
+   better performance and improve interoperability with other X applications.
+
+
+Q. My kernel log contains messages that are prefixed with "Xid"; what do these
+   messages mean?
+
+A. "Xid" messages indicate that a general GPU error occurred, most often due
+   to the driver misprogramming the GPU or to corruption of the commands sent
+   to the GPU. These messages provide diagnostic information that can be used
+   by NVIDIA to aid in debugging reported problems.
+
+
+Q. On what NVIDIA hardware is the EXT_framebuffer_object OpenGL extension
+   supported?
+
+A. EXT_framebuffer_object is supported on GeForce FX, Quadro FX, and newer
+   GPUs.
+
+
+Q. I use the Coolbits overclocking interface to adjust my graphics card's
+   clock frequencies, but the defaults are reset whenever X is restarted. How
+   do I make my changes persistent?
+
+A. Clock frequency settings are not saved/restored automatically by default to
+   avoid potential stability and other problems that may be encountered if the
+   chosen frequency settings differ from the defaults qualified by the
+   manufacturer. You can use the command line below in '~/.xinitrc' to
+   automatically apply custom clock frequency settings when the X server is
+   started:
+   
+       # nvidia-settings -a GPUOverclockingState=1 -a
+   GPU2DClockFreqs=<GPU>,<MEM> -a GPU3DClockFreqs=<GPU>,<MEM>
+   
+   Here '<GPU>' and '<MEM>' are the desired GPU and video memory frequencies
+   (in MHz), respectively.
+
+
+Q. Why is the refresh rate not reported correctly by utilities that use the
+   XRandR X extension (e.g., the GNOME "Screen Resolution Preferences" panel,
+   `xrandr -q`, etc)?
+
+A. The XRandR X extension is not presently aware of multiple display devices
+   on a single X screen; it only sees the MetaMode bounding box, which may
+   contain one or more actual modes. This means that if multiple MetaModes
+   have the same bounding box, XRandR will not be able to distinguish between
+   them.
+
+   In order to support DynamicTwinView, the NVIDIA X driver must make each
+   MetaMode appear to be unique to XRandR. Presently, the NVIDIA X driver
+   accomplishes this by using the refresh rate as a unique identifier.
+
+   You can use `nvidia-settings -q RefreshRate` to query the actual refresh
+   rate on each display device.
+
+   This behavior can be disabled by setting the X configuration option
+   "DynamicTwinView" to FALSE.
+
+   For details, see Chapter 10.
+
+
+______________________________________________________________________________
+
+Chapter 6. Common Problems
+______________________________________________________________________________
+
+This section provides solutions to common problems associated with the NVIDIA
+FreeBSD x86 Driver.
+
+Q. My X server fails to start, and my X log file contains the error:
+   
+   (EE) NVIDIA(0): The NVIDIA kernel module does not appear to
+   (EE) NVIDIA(0):      be receiving interrupts generated by the NVIDIA
+   graphics
+   (EE) NVIDIA(0):      device PCI:x:x:x. Please see the COMMON PROBLEMS
+   (EE) NVIDIA(0):      section in the README for additional information.
+   
+   
+A. This can be caused by a variety of problems, such as PCI IRQ routing
+   errors, I/O APIC problems or conflicts with other devices sharing the IRQ
+   (or their drivers).
+
+   If possible, configure your system such that your graphics card does not
+   share its IRQ with other devices (try moving the graphics card to another
+   slot if applicable, unload/disable the driver(s) for the device(s) sharing
+   the card's IRQ, or remove/disable the device(s)).
+
+
+Q. My X server fails to start, and my X log file contains the error:
+   
+   (EE) NVIDIA(0): The interrupt for NVIDIA graphics device PCI:x:x:x
+   (EE) NVIDIA(0):      appears to be edge-triggered. Please see the COMMON
+   (EE) NVIDIA(0):      PROBLEMS section in the README for additional
+   information.
+   
+   
+A. An edge-triggered interrupt means that the kernel has programmed the
+   interrupt as edge-triggered rather than level-triggered in the Advanced
+   Programmable Interrupt Controller (APIC). Edge-triggered interrupts are not
+   intended to be used for sharing an interrupt line between multiple devices;
+   level-triggered interrupts are the intended trigger for such usage. When
+   using edge-triggered interrupts, it is common for device drivers using that
+   interrupt line to stop receiving interrupts. This would appear to the end
+   user as those devices no longer working, and potentially as a full system
+   hang. These problems tend to be more common when multiple devices are
+   sharing that interrupt line.
+
+
+Q. X starts for me, but OpenGL applications terminate immediately.
+
+A. If X starts but you have trouble with OpenGL, you most likely have a
+   problem with other libraries in the way, or there are stale symlinks. See
+   Appendix B for details.
+
+   You should also check that the correct extensions are present;
+   
+       % xdpyinfo
+   
+   should show the "GLX" and "NV-GLX" extensions present. If these two
+   extensions are not present, then there is most likely a problem loading the
+   glx module, or it is unable to implicitly load GLcore. Check your X config
+   file and make sure that you are loading glx (see Chapter 4). If your X
+   config file is correct, then check the X log file for warnings/errors
+   pertaining to GLX. Also check that all of the necessary symlinks are in
+   place (refer to Appendix B).
+
+
+Q. When Xinerama is enabled, my stereo glasses are shuttering only when the
+   stereo application is displayed on one specific X screen. When the
+   application is displayed on the other X screens, the stereo glasses stop
+   shuttering.
+
+A. This problem occurs with DDC and "blue line" stereo glasses, that get the
+   stereo signal from one video port of the graphics card. When a X screen
+   does not display any stereo drawable the stereo signal is disabled on the
+   associated video port.
+
+   Forcing stereo flipping allows the stereo glasses to shutter continuously.
+   This can be done by enabling the OpenGL control "Force Stereo Flipping" in
+   nvidia-settings, or by setting the X configuration option
+   "ForceStereoFlipping" to "1".
+
+
+Q. Stereo is not in sync across multiple displays.
+
+A. There are two cases where this may occur. If the displays are attached to
+   the same GPU, and one of them is out of sync with the stereo glasses, you
+   will need to reconfigure your monitors to drive identical mode timings; see
+   Chapter 16 for details.
+
+   If the displays are attached to different GPUs, the only way to synchronize
+   stereo across the displays is with a G-Sync device, which is only supported
+   by certain Quadro cards. See Chapter 21 for details. This applies to
+   seperate GPUs on seperate cards as well as seperate GPUs on the same card,
+   such as Quadro FX 4500 X2. Note that the Quadro FX 4500 X2 only provides a
+   single DIN connector for stereo, tied to the bottommost GPU. In order to
+   synchronize onboard stereo on the other GPU you must use a G-Sync device.
+
+
+Q. X fails to start, and during bootup time I get error messages
+   
+   nvidia0: NVRM: NVIDIA REG resource alloc failed.
+   
+   or
+   
+   nvidia0: NVRM: NVIDIA IRQ resource alloc failed.
+   
+   
+A. The system bios has not properly setup your graphics card; FreeBSD can't
+   currently setup PCI devices that the BIOS leaves unconfigured. Uncheck
+   "PNP-OS" in your system bios.
+
+
+Q. X fails to start, and during bootup time I get the following error message:
+   
+   nvidia0: NVRM: NVIDIA MEM resource alloc failed.
+   
+   
+A. On certain FreeBSD kernels, it may be necessary to add the following line
+   to '/boot/loader.conf':
+   
+   hw.pci.allow_unsupported_io_range="1"
+   
+   This should allow the NVIDIA kernel module to attach.
+
+
+Q. My X server fails to start, and my X log file contains the error:
+   
+   (EE) NVIDIA(0): Failed to initialize the NVIDIA kernel module!
+   
+   
+A. Nothing will work if the NVIDIA kernel module does not function properly.
+   If you see anything in the X log file like
+   
+   (EE) NVIDIA(0): Failed to initialize the NVIDIA kernel module!
+   
+   then there is most likely a problem with the NVIDIA kernel module.
+
+   The NVIDIA kernel module may print error messages indicating a problem --
+   to view these messages check the output of `dmesg`, '/var/log/messages', or
+   wherever syslog is directed to place kernel messages. These messages are
+   prepended with "NVRM".
+
+
+Q. When I attempt to start `nvidia-settings`, I get an error message of the
+   form:
+   
+    Shared object "libgtk-x11-2.0.so.400" not found, required by
+   nvidia-settings
+   
+   
+A. Due to differences between the gtk+-2.x ports packages included with
+   different FreeBSD 5.x releases, the prebuilt nvidia-settings binary shipped
+   with the NVIDIA driver may not work with FreeBSD releases more recent than
+   FreeBSD 5.3.
+
+   If you have a recent ports package of gtk+-2.x and gmake installed on your
+   system, you can build the nvidia-installer utility from source to solve
+   this problem.
+
+   Download nvidia-settings-1.0.tar.gz (or the latest version) from
+   ftp://download.nvidia.com/XFree86/nvidia-settings You can then extract,
+   build and install it (to '/usr/local/bin') with:
+   
+       % gmake install
+   
+   
+
+Q. When I attempt to run `nvidia-xconfig` after the NVIDIA FreeBSD graphics
+   driver installation, I get an error message of the form:
+   
+   nvidia-xconfig: Command not found.
+   
+   
+A. Depending on the shell you are using, you may need to force it to recompute
+   its internal table of executable files present in the directories listed in
+   the '$PATH' variable. Assuming you are using the FreeBSD default shell you
+   can do so by issuing the command:
+   
+       % rehash
+   
+   
+
+Q. When I attempt to start a Linux application as 'root', I get the error
+   message:
+   
+   NVIDIA: failed to execute '/sbin/modprobe': No such file or directory.
+   
+   
+A. When initialized by an application executed with 'root' privileges, the
+   NVIDIA Linux OpenGL library, shipped with the NVIDIA FreeBSD graphics
+   driver for Linux ABI compatibility, will attempt to load the NVIDIA Linux
+   kernel module and fail because /sbin/modprobe is absent. You can work
+   around this problem by creating a symbolic link from '/usr/bin/true' to
+   '/compat/linux/sbin/modprobe':
+   
+       % ln -s /usr/bin/true /compat/linux/sbin/modprobe
+   
+   
+
+Q. My system runs, but seems unstable.
+
+A. Your stability problems may be AGP-related. See Chapter 9 for details.
+
+
+Q. OpenGL applications are running slowly
+
+A. The application is probably using a different library that still remains on
+   your system, rather than the NVIDIA supplied OpenGL library. See Appendix B
+   for details.
+
+
+Q. There are problems running Quake2.
+
+A. Quake2 requires some minor setup to get it going. First, in the Quake2
+   directory, the install creates a symlink called 'libGL.so' that points at
+   'libMesaGL.so'. This symlink should be removed or renamed. Second, in order
+   to run Quake2 in OpenGL mode, you must type
+   
+       % quake2 +set vid_ref glx +set gl_driver libGL.so
+   
+   Quake2 does not seem to support any kind of full-screen mode, but you can
+   run your X server at the same resolution as Quake2 to emulate full-screen
+   mode.
+
+
+Q. I am using either nForce of nForce2 internal graphics, and I see warnings
+   like this in my X log file:
+   
+   Not using mode "1600x1200" (exceeds valid memory bandwidth usage)
+   
+   
+A. Integrated graphics have more strict memory bandwidth limitations that
+   limit the resolution and refresh rate of the modes you request. To work
+   around this, you can reduce the maximum refresh rate by lowering the upper
+   value of the VertRefresh range in the 'Monitor' section of your X config
+   file. Though not recommended, you can disable the memory bandwidth test
+   with the NoBandWidthTest X config file option.
+
+
+Q. X takes a long time to start (possibly several minutes).
+
+A. Most of the X startup delay problems we have found are caused by incorrect
+   data in video BIOSes about what display devices are possibly connected or
+   what i2c port should be used for detection. You can work around these
+   problems with the X config option IgnoreDisplayDevices (see the description
+   in Appendix F).
+
+
+Q. Fonts are incorrectly sized after installing the NVIDIA driver.
+
+A. Incorrectly sized fonts are generally caused by incorrect DPI (Dots Per
+   Inch) information. You can check what X thinks the physical size of your
+   monitor is, by running:
+   
+    % xdpyinfo | grep dimensions
+   
+   This will report the size in pixels, and in millimeters.
+
+   If these numbers are wrong, you can correct them by modifying the X
+   server's DPI setting. See Appendix I for details.
+
+
+Q. General problems with ALi chipsets
+
+A. There are some known timing and signal integrity issues on ALi chipsets.
+   The following tips may help stabilize problematic ALI systems:
+   
+      o Disable TURBO AGP MODE in the BIOS.
+   
+      o When using a P5A upgrade to BIOS Revision 1002 BETA 2.
+   
+      o When using 1007, 1007A or 1009 adjust the IO Recovery Time to 4
+        cycles.
+   
+      o AGP is disabled by default on some ALi chipsets (ALi1541, ALi1647) to
+        work around severe system stability problems with these chipsets. See
+        the comments for EnableALiAGP in 'nv-reg.h' to force AGP on anyway.
+   
+   
+
+Q. Using GNOME configuration utilities, I am unable to get a resolution above
+   800x600.
+
+A. The installation of GNOME provided in operating systems such as Red Hat
+   Enterprise Linux 4 and Solaris 10 Update 2 contain several competing
+   interfaces for specifying resolution:
+   
+   
+       'System Settings' -> 'Display'
+   
+   
+   which will update the X configuration file, and
+   
+   
+       'Applications' -> 'Preferences' -> 'Screen Resolution'
+   
+   
+   which will update the per-user screen resolution using the XRandR
+   extension. Your desktop resolution will be limited to the smaller of the
+   two settings. Be sure to check the setting of each.
+
+
+Q. X does not restore the VGA console when run on a TV. I get this error
+   message in my X log file:
+   
+   Unable to initialize the X int10 module; the console may not be
+   restored correctly on your TV.
+   
+   
+A. The NVIDIA X driver uses the X Int10 module to save and restore console
+   state on TV out, and will not be able to restore the console correctly if
+   it cannot use the Int10 module. If you have built the X server yourself,
+   please be sure you have built the Int10 module. If you are using a build of
+   the X server provided by your operating system and are missing the Int10
+   module, contact your operating system distributor.
+
+
+Q. OpenGL applications don't work, and my X log file contains the error:
+   
+   (EE) NVIDIA(0): Unable to map device node /dev/zero with read, write, and
+   (EE) NVIDIA(0):     execute privileges.  The GLX extension will be disabled
+   (EE) NVIDIA(0):     on this X screen.  Please see the COMMON PROBLEMS
+   (EE) NVIDIA(0):     section in the README for more information.
+   
+   
+A. The NVIDIA OpenGL driver must be able to map the '/dev/zero' device node
+   with read, write, and execute privileges in order to function correctly.
+   The driver needs this ability to allocate executable memory, which is used
+   for optimizations that require generating code at run-time. Currently, GLX
+   cannot run without these optimizations.
+
+   Check that your '/dev' filesystem is set up correctly. In particular,
+   mounting the '/dev' file system with the 'noexec' option will cause this to
+   happen. If you haven't changed the configuration of your '/dev' filesystem,
+   please contact your operating system distributor.
+
+
+______________________________________________________________________________
+
+Chapter 7. Known Issues
+______________________________________________________________________________
+
+The following problems still exist in this release and are in the process of
+being resolved.
+
+Known Issues
+
+Notebooks
+
+    If you are using a notebook see the "Known Notebook Issues" in Chapter 15.
+
+FSAA
+
+    When FSAA is enabled (the __GL_FSAA_MODE environment variable is set to a
+    value that enables FSAA and a multisample visual is chosen), the rendering
+    may be corrupted when resizing the window.
+
+libGL DSO finalizer and pthreads
+
+    When a multithreaded OpenGL application exits, it is possible for libGL's
+    DSO finalizer (also known as the destructor, or "_fini") to be called
+    while other threads are executing OpenGL code. The finalizer needs to free
+    resources allocated by libGL. This can cause problems for threads that are
+    still using these resources. Setting the environment variable
+    "__GL_NO_DSO_FINALIZER" to "1" will work around this problem by forcing
+    libGL's finalizer to leave its resources in place. These resources will
+    still be reclaimed by the operating system when the process exits. Note
+    that the finalizer is also executed as part of dlclose(3), so if you have
+    an application that dlopens(3) and dlcloses(3) libGL repeatedly,
+    "__GL_NO_DSO_FINALIZER" will cause libGL to leak resources until the
+    process exits. Using this option can improve stability in some
+    multithreaded applications, including Java3D applications.
+
+XVideo and the Composite X extension
+
+    XVideo will not work correctly when Composite is enabled unless using
+    X.Org 7.1 or later. See Chapter 18.
+
+This section describes problems that will not be fixed. Usually, the source of
+the problem is beyond the control of NVIDIA. Following is the list of
+problems:
+
+Problems that Will Not Be Fixed
+
+Gigabyte GA-6BX Motherboard
+
+    This motherboard uses a LinFinity regulator on the 3.3 V rail that is only
+    rated to 5 A -- less than the AGP specification, which requires 6 A. When
+    diagnostics or applications are running, the temperature of the regulator
+    rises, causing the voltage to the NVIDIA GPU to drop as low as 2.2 V.
+    Under these circumstances, the regulator cannot supply the current on the
+    3.3 V rail that the NVIDIA GPU requires.
+
+    This problem does not occur when the graphics card has a switching
+    regulator or when an external power supply is connected to the 3.3 V rail.
+
+VIA KX133 and 694X Chip sets with AGP 2x
+
+    On Athlon motherboards with the VIA KX133 or 694X chip set, such as the
+    ASUS K7V motherboard, NVIDIA drivers default to AGP 2x mode to work around
+    insufficient drive strength on one of the signals.
+
+Irongate Chip sets with AGP 1x
+
+    AGP 1x transfers are used on Athlon motherboards with the Irongate chipset
+    to work around a problem with signal integrity.
+
+ALi chipsets, ALi1541 and ALi1647
+
+    On ALi1541 and ALi1647 chipsets, NVIDIA drivers disable AGP to work around
+    timing issues and signal integrity issues. See Chapter 6 for more
+    information on ALi chipsets.
+
+NV-CONTROL versions 1.8 and 1.9
+
+    Version 1.8 of the NV-CONTROL X Extension introduced target types for
+    setting and querying attributes as well as receiving event notification on
+    targets. Targets are objects like X Screens, GPUs and G-Sync devices.
+    Previously, all attributes were described relative to an X Screen. These
+    new bits of information (target type and target id) were packed in a
+    non-compatible way in the protocol stream such that addressing X Screen 1
+    or higher would generate an X protocol error when mixing NV-CONTROL client
+    and server versions.
+
+    This packing problem has been fixed in the NV-CONTROL 1.10 protocol,
+    making it possible for the older (1.7 and prior) clients to communicate
+    with NV-CONTROL 1.10 servers. Furthermore, the NV-CONTROL 1.10 client
+    library has been updated to accommodate the target protocol packing bug
+    when communicating with a 1.8 or 1.9 NV-CONTROL server. This means that
+    the NV-CONTROL 1.10 client library should be able to communicate with any
+    version of the NV-CONTROL server.
+
+    NVIDIA recommends that NV-CONTROL client applications relink with version
+    1.10 or later of the NV-CONTROL client library (libXNVCtrl.a, in the
+    nvidia-settings-1.0.tar.gz tarball). The version of the client library can
+    be determined by checking the NV_CONTROL_MAJOR and NV_CONTROL_MINOR
+    definitions in the accompanying nv_control.h.
+
+    The only web released NVIDIA FreeBSD driver that is affected by this
+    problem (i.e., the only driver to use either version 1.8 or 1.9 of the
+    NV-CONTROL X extension) is 1.0-8756.
+
+
+______________________________________________________________________________
+
+Chapter 8. Specifying OpenGL Environment Variable Settings
+______________________________________________________________________________
+
+
+8A. FULL SCENE ANTIALIASING
+
+Antialiasing is a technique used to smooth the edges of objects in a scene to
+reduce the jagged "stairstep" effect that sometimes appears. Full-scene
+antialiasing is supported on GeForce or newer hardware. By setting the
+appropriate environment variable, you can enable full-scene antialiasing in
+any OpenGL application on these GPUs.
+
+Several antialiasing methods are available and you can select between them by
+setting the __GL_FSAA_MODE environment variable appropriately. Note that
+increasing the number of samples taken during FSAA rendering may decrease
+performance.
+
+The following tables describe the possible values for __GL_FSAA_MODE and the
+effects that they have on various NVIDIA GPUs.
+
+
+
+    __GL_FSAA_MODE     GeForce, GeForce2, Quadro, and Quadro2 Pro
+    ---------------    ------------------------------------------------------
+    0                  FSAA disabled
+    1                  FSAA disabled
+    2                  FSAA disabled
+    3                  1.5 x 1.5 Supersampling
+    4                  2 x 2 Supersampling
+    5                  FSAA disabled
+    6                  FSAA disabled
+    7                  FSAA disabled
+
+
+
+
+    __GL_FSAA_MODE     GeForce4 MX, GeForce4 4xx Go, Quadro4 380,550,580
+                       XGL, and Quadro4 NVS
+    ---------------    ------------------------------------------------------
+    0                  FSAA disabled
+    1                  2x Bilinear Multisampling
+    2                  2x Quincunx Multisampling
+    3                  FSAA disabled
+    4                  2 x 2 Supersampling
+    5                  FSAA disabled
+    6                  FSAA disabled
+    7                  FSAA disabled
+
+
+
+
+    __GL_FSAA_MODE     GeForce3, Quadro DCC, GeForce4 Ti, GeForce4 4200 Go,
+                       and Quadro4 700,750,780,900,980 XGL
+    ---------------    ------------------------------------------------------
+    0                  FSAA disabled
+    1                  2x Bilinear Multisampling
+    2                  2x Quincunx Multisampling
+    3                  FSAA disabled
+    4                  4x Bilinear Multisampling
+    5                  4x Gaussian Multisampling
+    6                  2x Bilinear Multisampling by 4x Supersampling
+    7                  FSAA disabled
+
+
+
+
+    __GL_FSAA_MODE     GeForce FX, GeForce 6xxx, GeForce 7xxx, Quadro FX
+    ---------------    ------------------------------------------------------
+    0                  FSAA disabled
+    1                  2x Bilinear Multisampling
+    2                  2x Quincunx Multisampling
+    3                  FSAA disabled
+    4                  4x Bilinear Multisampling
+    5                  4x Gaussian Multisampling
+    6                  2x Bilinear Multisampling by 4x Supersampling
+    7                  4x Bilinear Multisampling by 4x Supersampling
+    8                  4x Bilinear Multisampling by 2x Supersampling
+                       (available on GeForce FX and later GPUs; not
+                       available on Quadro GPUs)
+
+
+
+
+    __GL_FSAA_MODE     GeForce 8xxx, G8xGL
+    ---------------    ------------------------------------------------------
+    0                  FSAA disabled
+    1                  2x Bilinear Multisampling
+    2                  FSAA disabled
+    3                  FSAA disabled
+    4                  4x Bilinear Multisampling
+    5                  FSAA disabled
+    6                  FSAA disabled
+    7                  4x Bilinear Multisampling by 4x Supersampling
+    8                  FSAA disabled
+    9                  8x Bilinear Multisampling
+    10                 8x
+    11                 16x
+    12                 16xQ
+    13                 8x Bilinear Multisampling by 4x Supersampling
+
+
+
+8B. ANISOTROPIC TEXTURE FILTERING
+
+Automatic anisotropic texture filtering can be enabled by setting the
+environment variable __GL_LOG_MAX_ANISO. The possible values are:
+
+    __GL_LOG_MAX_ANISO                    Filtering Type
+    ----------------------------------    ----------------------------------
+    0                                     No anisotropic filtering
+    1                                     2x anisotropic filtering
+    2                                     4x anisotropic filtering
+    3                                     8x anisotropic filtering
+    4                                     16x anisotropic filtering
+
+4x and greater are only available on GeForce3 or newer GPUs; 16x is only
+available on GeForce 6800 or newer GPUs.
+
+
+8C. VBLANK SYNCING
+
+Setting the environment variable __GL_SYNC_TO_VBLANK to a non-zero value will
+force glXSwapBuffers to sync to your monitor's vertical refresh (perform a
+swap only during the vertical blanking period).
+
+When using __GL_SYNC_TO_VBLANK with TwinView, OpenGL can only sync to one of
+the display devices; this may cause tearing corruption on the display device
+to which OpenGL is not syncing. You can use the environment variable
+__GL_SYNC_DISPLAY_DEVICE to specify to which display device OpenGL should
+sync. You should set this environment variable to the name of a display
+device; for example "CRT-1". Look for the line "Connected display device(s):"
+in your X log file for a list of the display devices present and their names.
+You may also find it useful to review Chapter 10 "Configuring Twinview" and
+the section on Ensuring Identical Mode Timings in Chapter 16.
+
+
+8D. DISABLING CPU-SPECIFIC FEATURES
+
+Setting the environment variable __GL_FORCE_GENERIC_CPU to a non-zero value
+will inhibit the use of CPU-specific features such as MMX, SSE, or 3DNOW!. Use
+of this option may result in performance loss.
+
+
+8E. CONTROLLING THE SORTING OF OPENGL FBCONFIGS
+
+The NVIDIA GLX implementation sorts FBConfigs returned by glXChooseFBConfig()
+as described in the GLX specification. To disable this behavior set
+__GL_SORT_FBCONFIGS to 0 (zero), then FBConfigs will be returned in the order
+they were received from the X server. To examine the order in which FBConfigs
+are returned by the X server run:
+
+nvidia-settings --glxinfo
+
+This option may be be useful to work around problems in which applications
+pick an unexpected FBConfig.
+
+
+8F. OPENGL YIELD BEHAVIOR
+
+There are several cases where the NVIDIA OpenGL driver needs to wait for
+external state to change before continuing. To avoid consuming too much CPU
+time in these cases, the driver will sometimes yield so the kernel can
+schedule other processes to run while the driver waits. For example, when
+waiting for free space in a command buffer, if the free space has not become
+available after a certain number of iterations, the driver will yield before
+it continues to loop.
+
+By default, the driver calls sched_yield() to do this. However, this can cause
+the calling process to be scheduled out for a relatively long period of time
+if there are other, same-priority processes competing for time on the CPU. One
+example of this is when an OpenGL-based composite manager is moving and
+repainting a window and the X server is trying to update the window as it
+moves, which are both CPU-intensive operations.
+
+You can use the __GL_YIELD environment variable to work around these
+scheduling problems. This variable allows the user to specify what the driver
+should do when it wants to yield. The possible values are:
+
+    __GL_YIELD         Behavior
+    ---------------    ------------------------------------------------------
+    <unset>            By default, OpenGL will call sched_yield() to yield.
+    "NOTHING"          OpenGL will never yield.
+    "USLEEP"           OpenGL will call usleep(0) to yield.
+
+
+
+8G. CONTROLLING WHICH OPENGL FBCONFIGS ARE AVAILABLE
+
+The NVIDIA GLX implementation will hide FBConfigs that are associated with a
+32-bit ARGB visual when the XLIB_SKIP_ARGB_VISUALS environment variable is
+defined. This matches the behavior of libX11, which will hide those visuals
+from XGetVisualInfo and XMatchVisualInfo. This environment variable is useful
+when applications are confused by the presence of these FBConfigs.
+
+______________________________________________________________________________
+
+Chapter 9. Configuring AGP
+______________________________________________________________________________
+
+There are several choices for configuring the NVIDIA kernel module's use of
+AGP: you can choose to either use the NVIDIA AGP module (NVAGP), or the AGP
+module that comes with the FreeBSD kernel (AGPGART). This is controlled
+through the "NvAGP" option in your X config file:
+
+    Option "NvAgp" "0"  ... disables AGP support
+    Option "NvAgp" "1"  ... use NVAGP, if possible
+    Option "NvAgp" "2"  ... use AGPGART, if possible
+    Option "NvAGP" "3"  ... try AGPGART; if that fails, try NVAGP
+
+Unlike other operating systems such as Linux, this option is not the only
+controlling factor at this point; because of known problems, 'nvidia.ko' is
+built without support for FreeBSD's AGP driver by default. This behavior can
+be changed, see 'nv-freebsd.h' for details.
+
+Note that if you built nvidia.ko with support for the FreeBSD driver it will
+not load unless 'agp.ko' is loaded. 'agp.ko' is special in that you can not
+load it after the system boot is complete, you need to append the following
+line to '/boot/loader.conf' to make sure it is pre-loaded:
+
+    # -- load FreeBSD AGP GART driver -- #
+    agp_load="YES"
+
+Also note that if 'agp.ko' is loaded, it could conflict with the NVIDIA AGP
+GART driver (NvAGP), resulting in stability problems; for this reason, the
+NVIDIA driver will abort NvAGP initialization when it detects 'agp.ko'.
+
+Current FreeBSD releases are shipped with 'agp.ko' built into the kernel; in
+order to allow NvAGP to work, the kernel can be rebuilt without 'device agp'
+or the following entry added to '/boot/device.hints':
+
+    hint.agp.0.disabled="1"
+
+When built with support for the FreeBSD AGP driver, 'nvidia.ko' will fall back
+to using NvAGP when it doesn't detect 'agp.ko' (this will be the case when
+'agp.ko' does not support your AGP chipset or was explicitely disabled with
+device hints).
+
+It is highly recommended that you use the NVIDIA AGP driver.
+
+The following AGP chipsets are supported by the NVIDIA AGP driver; for all
+other chipsets it is recommended that you use the AGPGART module.
+
+    Supported AGP Chipsets
+    ----------------------------------------------------------------------
+    Intel 440LX
+    Intel 440BX
+    Intel 440GX
+    Intel 815 ("Solano")
+    Intel 820 ("Camino")
+    Intel 830M
+    Intel 840 ("Carmel")
+    Intel 845 ("Brookdale")
+    Intel 845G
+    Intel 850 ("Tehama")
+    Intel 855 ("Odem")
+    Intel 860 ("Colusa")
+    Intel 865G ("Springdale")
+    Intel 875P ("Canterwood")
+    Intel E7205 ("Granite Bay")
+    Intel E7505 ("Placer")
+    AMD 751 ("Irongate")
+    AMD 761 ("IGD4")
+    AMD 762 ("IGD4 MP")
+    AMD 8151 ("Lokar")
+    VIA 8371
+    VIA 82C694X
+    VIA KT133
+    VIA KT266
+    VIA KT400
+    VIA P4M266
+    VIA P4M266A
+    VIA P4X400
+    VIA K8T800
+    VIA K8N800
+    VIA PT880
+    VIA KT880
+    RCC CNB20LE
+    RCC 6585HE
+    Micron SAMDDR ("Samurai")
+    Micron SCIDDR ("Scimitar")
+    NVIDIA nForce
+    NVIDIA nForce2
+    NVIDIA nForce3
+    ALi 1621
+    ALi 1631
+    ALi 1647
+    ALi 1651
+    ALi 1671
+    SiS 630
+    SiS 633
+    SiS 635
+    SiS 645
+    SiS 646
+    SiS 648
+    SiS 648FX
+    SiS 650
+    SiS 651
+    SiS 655
+    SiS 655FX
+    SiS 661
+    SiS 730
+    SiS 733
+    SiS 735
+    SiS 745
+    SiS 755
+    ATI RS200M
+
+
+If you are experiencing AGP stability problems, you should be aware of the
+following:
+
+Additional AGP Information
+
+AGP drive strength BIOS setting (Via-based motherboards)
+
+    Many Via-based motherboards allow adjusting the AGP drive strength in the
+    system BIOS. The setting of this option largely affects system stability,
+    the range between 0xEA and 0xEE seems to work best for NVIDIA hardware.
+    Setting either nibble to 0xF generally results in severe stability
+    problems.
+
+    If you decide to experiment with this, you need to be aware of the fact
+    that you are doing so at your own risk and that you may render your system
+    unbootable with improper settings until you reset the setting to a working
+    value (w/ a PCI graphics card or by resetting the BIOS to its default
+    values).
+
+System BIOS version
+
+    Make sure you have the latest system BIOS provided by the motherboard
+    manufacturer.
+
+    On ALi1541 and ALi1647 chipsets, NVIDIA drivers disable AGP to work around
+    timing and signal integrity problems. You can force AGP to be enabled on
+    these chipsets by setting NVreg_EnableALiAGP to 1. Note that this may
+    cause the system to become unstable.
+
+    Early system BIOS revisions for the ASUS A7V8X-X KT400 motherboard
+    misconfigure the chipset when an AGP 2.x graphics card is installed; if X
+    hangs on your ASUS KT400 system with NvAGP enabled and the installed
+    graphics card is not an AGP 8x device, make sure that you have the latest
+    system BIOS installed.
+
+
+______________________________________________________________________________
+
+Chapter 10. Configuring TwinView
+______________________________________________________________________________
+
+TwinView is a mode of operation where two display devices (digital flat
+panels, CRTs, and TVs) can display the contents of a single X screen in any
+arbitrary configuration. This method of multiple monitor use has several
+distinct advantages over other techniques (such as Xinerama):
+
+
+   o A single X screen is used. The NVIDIA driver conceals all information
+     about multiple display devices from the X server; as far as X is
+     concerned, there is only one screen.
+
+   o Both display devices share one frame buffer. Thus, all the functionality
+     present on a single display (e.g., accelerated OpenGL) is available with
+     TwinView.
+
+   o No additional overhead is needed to emulate having a single desktop.
+
+
+If you are interested in using each display device as a separate X screen, see
+Chapter 12.
+
+
+10A. X CONFIG TWINVIEW OPTIONS
+
+To enable TwinView, you must specify the following option in the Device
+section of your X Config file:
+
+    Option "TwinView"
+
+You may also use any of the following options, though they are not required:
+
+    Option "MetaModes"                "<list of MetaModes>"
+
+    Option "SecondMonitorHorizSync"   "<hsync range(s)>"
+    Option "SecondMonitorVertRefresh" "<vrefresh range(s)>"
+
+    Option "HorizSync"                "<hsync range(s)>"
+    Option "VertRefresh"              "<vrefresh range(s)>"
+
+    Option "TwinViewOrientation"      "<relationship of head 1 to head 0>"
+    Option "ConnectedMonitor"         "<list of connected display devices>"
+
+See detailed descriptions of each option below.
+
+Alternatively, you can enable TwinView by running
+
+    nvidia-xconfig --twinview
+
+and restarting your X server. Or, you can configure TwinView dynamically in
+the "Display Configuration" page in nvidia-settings.
+
+
+10B. DETAILED DESCRIPTION OF OPTIONS
+
+
+TwinView
+
+    This option is required to enable TwinView; without it, all other TwinView
+    related options are ignored.
+
+SecondMonitorHorizSync
+SecondMonitorVertRefresh
+
+    You specify the constraints of the second monitor through these options.
+    The values given should follow the same convention as the "HorizSync" and
+    "VertRefresh" entries in the Monitor section. As the XF86Config man page
+    explains it: the ranges may be a comma separated list of distinct values
+    and/or ranges of values, where a range is given by two distinct values
+    separated by a dash. The HorizSync is given in kHz, and the VertRefresh is
+    given in Hz.
+
+    These options are normally not needed: by default, the NVIDIA X driver
+    retrieves the valid frequency ranges from the display device's EDID (see
+    Appendix F for a description of the "UseEdidFreqs" option). The
+    SecondMonitor options will override any frequency ranges retrieved from
+    the EDID.
+
+HorizSync
+VertRefresh
+
+    Which display device is "first" and which is "second" is often unclear.
+    For this reason, you may use these options instead of the SecondMonitor
+    versions. With these options, you can specify a semicolon-separated list
+    of frequency ranges, each optionally prepended with a display device name.
+    For example:
+    
+        Option "HorizSync"   "CRT-0: 50-110;  DFP-0: 40-70"
+        Option "VertRefresh" "CRT-0: 60-120;  DFP-0: 60"
+    
+    See Appendix G on Display Device Names for more information.
+
+    These options are normally not needed: by default, the NVIDIA X driver
+    retrieves the valid frequency ranges from the display device's EDID (see
+    Appendix F for a description of the "UseEdidFreqs" option). The
+    "HorizSync" and "VertRefresh" options override any frequency ranges
+    retrieved from the EDID or any frequency ranges specified with the
+    "SecondMonitorHorizSync" and "SecondMonitorVertRefresh" options.
+
+MetaModes
+
+    MetaModes are "containers" that store information about what mode should
+    be used on each display device at any given time. Even if only one display
+    device is actively in use, the NVIDIA X driver always uses a MetaMode to
+    encapsulate the mode information per display device, so that it can
+    support dynamically enabling TwinView.
+
+    Multiple MetaModes list the combinations of modes and the sequence in
+    which they should be used. When the NVIDIA driver tells X what modes are
+    available, it is really the minimal bounding box of the MetaMode that is
+    communicated to X, while the "per display device" mode is kept internal to
+    the NVIDIA driver. In MetaMode syntax, modes within a MetaMode are comma
+    separated, and multiple MetaModes are separated by semicolons. For
+    example:
+    
+        "<mode name 0>, <mode name 1>; <mode name 2>, <mode name 3>"
+    
+    Where <mode name 0> is the name of the mode to be used on display device 0
+    concurrently with <mode name 1> used on display device 1. A mode switch
+    will then cause <mode name 2> to be used on display device 0 and <mode
+    name 3> to be used on display device 1. Here is an example MetaMode:
+    
+        Option "MetaModes" "1280x1024,1280x1024; 1024x768,1024x768"
+    
+    If you want a display device to not be active for a certain MetaMode, you
+    can use the mode name "NULL", or simply omit the mode name entirely:
+    
+        "1600x1200, NULL; NULL, 1024x768"
+    
+    or
+    
+        "1600x1200; , 1024x768"
+    
+    Optionally, mode names can be followed by offset information to control
+    the positioning of the display devices within the virtual screen space;
+    e.g.,
+    
+        "1600x1200 +0+0, 1024x768 +1600+0; ..."
+    
+    Offset descriptions follow the conventions used in the X "-geometry"
+    command line option; i.e., both positive and negative offsets are valid,
+    though negative offsets are only allowed when a virtual screen size is
+    explicitly given in the X config file.
+
+    When no offsets are given for a MetaMode, the offsets will be computed
+    following the value of the TwinViewOrientation option (see below). Note
+    that if offsets are given for any one of the modes in a single MetaMode,
+    then offsets will be expected for all modes within that single MetaMode;
+    in such a case offsets will be assumed to be +0+0 when not given.
+
+    When not explicitly given, the virtual screen size will be computed as the
+    the bounding box of all MetaMode bounding boxes. MetaModes with a bounding
+    box larger than an explicitly given virtual screen size will be discarded.
+
+    A MetaMode string can be further modified with a "Panning Domain"
+    specification; e.g.,
+    
+        "1024x768 @1600x1200, 800x600 @1600x1200"
+    
+    A panning domain is the area in which a display device's viewport will be
+    panned to follow the mouse. Panning actually happens on two levels with
+    TwinView: first, an individual display device's viewport will be panned
+    within its panning domain, as long as the viewport is contained by the
+    bounding box of the MetaMode. Once the mouse leaves the bounding box of
+    the MetaMode, the entire MetaMode (i.e., all display devices) will be
+    panned to follow the mouse within the virtual screen. Note that individual
+    display devices' panning domains default to being clamped to the position
+    of the display devices' viewports, thus the default behavior is just that
+    viewports remain "locked" together and only perform the second type of
+    panning.
+
+    The most beneficial use of panning domains is probably to eliminate dead
+    areas -- regions of the virtual screen that are inaccessible due to
+    display devices with different resolutions. For example:
+    
+        "1600x1200, 1024x768"
+    
+    produces an inaccessible region below the 1024x768 display. Specifying a
+    panning domain for the second display device:
+    
+        "1600x1200, 1024x768 @1024x1200"
+    
+    provides access to that dead area by allowing you to pan the 1024x768
+    viewport up and down in the 1024x1200 panning domain.
+
+    Offsets can be used in conjunction with panning domains to position the
+    panning domains in the virtual screen space (note that the offset
+    describes the panning domain, and only affects the viewport in that the
+    viewport must be contained within the panning domain). For example, the
+    following describes two modes, each with a panning domain width of 1900
+    pixels, and the second display is positioned below the first:
+    
+        "1600x1200 @1900x1200 +0+0, 1024x768 @1900x768 +0+1200"
+    
+    Because it is often unclear which mode within a MetaMode will be used on
+    each display device, mode descriptions within a MetaMode can be prepended
+    with a display device name. For example:
+    
+        "CRT-0: 1600x1200,  DFP-0: 1024x768"
+    
+    If no MetaMode string is specified, then the X driver uses the modes
+    listed in the relevant "Display" subsection, attempting to place matching
+    modes on each display device.
+
+TwinViewOrientation
+
+    This option controls the positioning of the second display device relative
+    to the first within the virtual X screen, when offsets are not explicitly
+    given in the MetaModes. The possible values are:
+    
+        "RightOf"  (the default)
+        "LeftOf"
+        "Above"
+        "Below"
+        "Clone"
+    
+    When "Clone" is specified, both display devices will be assigned an offset
+    of 0,0.
+
+    Because it is often unclear which display device is "first" and which is
+    "second", TwinViewOrientation can be confusing. You can further clarify
+    the TwinViewOrientation with display device names to indicate which
+    display device is positioned relative to which display device. For
+    example:
+    
+        "CRT-0 LeftOf DFP-0"
+    
+    
+ConnectedMonitor
+
+    With this option you can override what the NVIDIA kernel module detects is
+    connected to your graphics card. This may be useful, for example, if any
+    of your display devices do not support detection using Display Data
+    Channel (DDC) protocols. Valid values are a comma-separated list of
+    display device names; for example:
+    
+        "CRT-0, CRT-1"
+        "CRT"
+        "CRT-1, DFP-0"
+    
+    WARNING: this option overrides what display devices are detected by the
+    NVIDIA kernel module, and is very seldom needed. You really only need this
+    if a display device is not detected, either because it does not provide
+    DDC information, or because it is on the other side of a KVM
+    (Keyboard-Video-Mouse) switch. In most other cases, it is best not to
+    specify this option.
+
+
+Just as in all X config entries, spaces are ignored and all entries are case
+insensitive.
+
+
+10C. DYNAMIC TWINVIEW
+
+Using the NV-CONTROL X extension, the display devices in use by an X screen,
+the mode pool for each display device, and the MetaModes for each X screen can
+be dynamically manipulated. The "Display Configuration" page in
+nvidia-settings uses this functionality to modify the MetaMode list and then
+uses XRandR to switch between MetaModes. This gives the ability to dynamically
+configure TwinView.
+
+The details of how this works are documented in the nv-control-dpy.c sample
+NV-CONTROL client in the nvidia-settings source tarball.
+
+Because the NVIDIA X driver can now transition into and out of TwinView
+dynamically, MetaModes are always used internally by the NVIDIA X driver,
+regardless of how many display devices are currently in use by the X screen
+and regardless of whether the TwinView X configuration option was specified.
+
+One implication of this implementation is that each MetaMode must be uniquely
+identifiable to the XRandR X extension. Unfortunately, two MetaModes with the
+same bounding box will look the same to XRandR. For example, two MetaModes
+with different orientations:
+
+    "CRT: 1600x1200 +0+0, DFP: 1600x1200 +1600+0"
+    "CRT: 1600x1200 +1600+0, DFP: 1600x1200 +0+0"
+
+will look identical to the XRandR or XF86VidMode X extensions, because they
+have the same total size (3200x1200), and nvidia-settings would not be able to
+use XRandR to switch between these MetaModes. To work around this limitation,
+the NVIDIA X driver "lies" about the refresh rate of each MetaMode, using the
+refresh rate of the MetaMode as a unique identifier.
+
+The XRandR extension is currently being redesigned by the X.Org community, so
+the refresh rate workaround may be removed at some point in the future. This
+workaround can also be disabled by setting the "DynamicTwinView" X
+configuration option to FALSE, which will disable NV-CONTROL support for
+manipulating MetaModes, but will cause the XRandR and XF86VidMode visible
+refresh rate to be accurate.
+
+
+FREQUENTLY ASKED TWINVIEW QUESTIONS
+
+Q. Nothing gets displayed on my second monitor; what is wrong?
+
+A. Monitors that do not support monitor detection using Display Data Channel
+   (DDC) protocols (this includes most older monitors) are not detectable by
+   your NVIDIA card. You need to explicitly tell the NVIDIA X driver what you
+   have connected using the "ConnectedMonitor" option; e.g.,
+   
+       Option "ConnectedMonitor" "CRT, CRT"
+   
+   
+
+Q. Will window managers be able to appropriately place windows (e.g., avoiding
+   placing windows across both display devices, or in inaccessible regions of
+   the virtual desktop)?
+
+A. Yes. The NVIDIA X driver provides a Xinerama extension that X clients (such
+   as window managers) can use to discover the current TwinView configuration.
+   Note that the Xinerama protocol provides no way to notify clients when a
+   configuration change occurs, so if you modeswitch to a different MetaMode,
+   your window manager will still think you have the previous configuration.
+   Using the Xinerama extension, in conjunction with the XF86VidMode extension
+   to get modeswitch events, window managers should be able to determine the
+   TwinView configuration at any given time.
+
+   Unfortunately, the data provided by XineramaQueryScreens() appears to
+   confuse some window managers; to work around such broken window mangers,
+   you can disable communication of the TwinView screen layout with the
+   "NoTwinViewXineramaInfo" X config Option (see Appendix F for details).
+
+   The order that display devices are reported in via the TwinView Xinerama
+   information can be configured with the TwinViewXineramaInfoOrder X
+   configuration option.
+
+   Be aware that the NVIDIA driver cannot provide the Xinerama extension if
+   the X server's own Xinerama extension is being used. Explicitly specifying
+   Xinerama in the X config file or on the X server commandline will prohibit
+   NVIDIA's Xinerama extension from installing, so make sure that the X
+   server's log file does not contain:
+   
+       (++) Xinerama: enabled
+   
+   if you want the NVIDIA driver to be able to provide the Xinerama extension
+   while in TwinView.
+
+   Another solution is to use panning domains to eliminate inaccessible
+   regions of the virtual screen (see the MetaMode description above).
+
+   A third solution is to use two separate X screens, rather than use
+   TwinView. See Chapter 12.
+
+
+Q. Why can I not get a resolution of 1600x1200 on the second display device
+   when using a GeForce2 MX?
+
+A. Because the second display device on the GeForce2 MX was designed to be a
+   digital flat panel, the Pixel Clock for the second display device is only
+   150 MHz. This effectively limits the resolution on the second display
+   device to somewhere around 1280x1024 (for a description of how Pixel Clock
+   frequencies limit the programmable modes, see the XFree86 Video Timings
+   HOWTO). This constraint is not present on GeForce4 or GeForce FX GPUs --
+   the maximum pixel clock is the same on both heads.
+
+
+Q. Do video overlays work across both display devices?
+
+A. Hardware video overlays only work on the first display device. The current
+   solution is that blitted video is used instead on TwinView.
+
+
+Q. How are virtual screen dimensions determined in TwinView?
+
+A. After all requested modes have been validated, and the offsets for each
+   MetaMode's viewports have been computed, the NVIDIA driver computes the
+   bounding box of the panning domains for each MetaMode. The maximum bounding
+   box width and height is then found.
+
+   Note that one side effect of this is that the virtual width and virtual
+   height may come from different MetaModes. Given the following MetaMode
+   string:
+   
+       "1600x1200,NULL; 1024x768+0+0, 1024x768+0+768"
+   
+   the resulting virtual screen size will be 1600 x 1536.
+
+
+Q. Can I play full screen games across both display devices?
+
+A. Yes. While the details of configuration will vary from game to game, the
+   basic idea is that a MetaMode presents X with a mode whose resolution is
+   the bounding box of the viewports for that MetaMode. For example, the
+   following:
+   
+       Option "MetaModes" "1024x768,1024x768; 800x600,800x600"
+       Option "TwinViewOrientation" "RightOf"
+   
+   produce two modes: one whose resolution is 2048x768, and another whose
+   resolution is 1600x600. Games such as Quake 3 Arena use the VidMode
+   extension to discover the resolutions of the modes currently available. To
+   configure Quake 3 Arena to use the above MetaMode string, add the following
+   to your q3config.cfg file:
+   
+       seta r_customaspect "1"
+       seta r_customheight "600"
+       seta r_customwidth  "1600"
+       seta r_fullscreen   "1"
+       seta r_mode         "-1"
+   
+   Note that, given the above configuration, there is no mode with a
+   resolution of 800x600 (remember that the MetaMode "800x600, 800x600" has a
+   resolution of 1600x600"), so if you change Quake 3 Arena to use a
+   resolution of 800x600, it will display in the lower left corner of your
+   screen, with the rest of the screen grayed out. To have single head modes
+   available as well, an appropriate MetaMode string might be something like:
+   
+       "800x600,800x600; 1024x768,NULL; 800x600,NULL; 640x480,NULL"
+   
+   More precise configuration information for specific games is beyond the
+   scope of this document, but the above examples coupled with numerous online
+   sources should be enough to point you in the right direction.
+
+
+______________________________________________________________________________
+
+Chapter 11. Configuring GLX in Xinerama
+______________________________________________________________________________
+
+The NVIDIA FreeBSD Driver supports GLX when Xinerama is enabled on similar
+GPUs. The Xinerama extension takes multiple physical X screens (possibly
+spanning multiple GPUs), and binds them into one logical X screen. This allows
+windows to be dragged between GPUs and to span across multiple GPUs. The
+NVIDIA driver supports hardware accelerated OpenGL rendering across all NVIDIA
+GPUs when Xinerama is enabled.
+
+To configure Xinerama
+
+  1. Configure multiple X screens (refer to the XF86Config(5x) or
+     xorg.conf(5x) manpages for details).
+
+  2. Enable Xinerama by adding the line
+     
+         Option "Xinerama" "True"
+     
+     to the "ServerFlags" section of your X config file.
+
+
+Requirements:
+
+   o Using identical GPUs is recommended. Some combinations of non-identical,
+     but similar, GPUs are supported. If a GPU is incompatible with the rest
+     of a Xinerama desktop then no OpenGL rendering will appear on the screens
+     driven by that GPU. Rendering will still appear normally on screens
+     connected to other supported GPUs. In this situation the X log file will
+     include a message of the form:
+
+
+
+(WW) NVIDIA(2): The GPU driving screen 2 is incompatible with the rest of
+(WW) NVIDIA(2):      the GPUs composing the desktop.  OpenGL rendering will
+(WW) NVIDIA(2):      be disabled on screen 2.
+
+
+
+   o The NVIDIA X driver must be used for all X screens in the server.
+
+   o Only the intersection of capabilities across all GPUs will be advertised.
+
+     The maximum OpenGL viewport size depends on the hardware used, and is
+     described by the following table. If an OpenGL window is larger than the
+     maximum viewport, regions beyond the viewport will be blank.
+     
+         OpenGL Viewport Maximums in Xinerama
+         
+         GeForce GPUs before GeForce 8:      4096 x 4096 pixels
+         GeForce 8 and newer GPUs:           8192 x 8192 pixels
+         Quadro:                             as large as the Xinerama
+                                             desktop
+     
+     
+   o X configuration options that affect GLX operation (e.g.: stereo,
+     overlays) should be set consistently across all X screens in the X
+     server.
+
+
+Known Issues:
+
+   o Versions of XFree86 prior to 4.5 and versions of X.Org prior to 6.8.0
+     lack the required interfaces to properly implement overlays with the
+     Xinerama extension. On earlier server versions mixing overlays and
+     Xinerama will result in rendering corruption. If you are using the
+     Xinerama extension with overlays, it is recommended that you upgrade to
+     XFree86 4.5, X.Org 6.8.0, or newer.
+
+
+______________________________________________________________________________
+
+Chapter 12. Configuring Multiple X Screens on One Card
+______________________________________________________________________________
+
+GPUs that support TwinView (Chapter 10) can also be configured to treat each
+connected display device as a separate X screen.
+
+While there are several disadvantages to this approach as compared to TwinView
+(e.g.: windows cannot be dragged between X screens, hardware accelerated
+OpenGL cannot span the two X screens), it does offer several advantages over
+TwinView:
+
+   o If each display device is a separate X screen, then properties that may
+     vary between X screens may vary between displays (e.g.: depth, root
+     window size, etc).
+
+   o Hardware that can only be used on one display at a time (e.g.: video
+     overlays, hardware accelerated RGB overlays), and which consequently
+     cannot be used at all when in TwinView, can be exposed on the first X
+     screen when each display is a separate X screen.
+
+   o TwinView is a fairly new feature. X has historically used one screen per
+     display device.
+
+
+To configure two separate X screens to share one graphics card, here is what
+you will need to do:
+
+First, create two separate Device sections, each listing the BusID of the
+graphics card to be shared and listing the driver as "nvidia", and assign each
+a separate screen:
+
+    Section "Device"
+        Identifier  "nvidia0"
+        Driver      "nvidia"
+        # Edit the BusID with the location of your graphics card
+        BusID       "PCI:2:0:0"
+        Screen      0
+    EndSection
+
+    Section "Device"
+        Identifier  "nvidia1"
+        Driver      "nvidia"
+        # Edit the BusID with the location of your graphics card
+        BusId       "PCI:2:0:0"
+        Screen      1
+    EndSection
+
+Then, create two Screen sections, each using one of the Device sections:
+
+    Section "Screen"
+        Identifier  "Screen0"
+        Device      "nvidia0"
+        Monitor     "Monitor0"
+        DefaultDepth 24
+        Subsection "Display"
+            Depth       24
+            Modes       "1600x1200" "1024x768" "800x600" "640x480" 
+        EndSubsection
+    EndSection
+
+    Section "Screen"
+        Identifier  "Screen1"
+        Device      "nvidia1"
+        Monitor     "Monitor1"
+        DefaultDepth 24
+        Subsection "Display"
+            Depth       24
+            Modes       "1600x1200" "1024x768" "800x600" "640x480" 
+        EndSubsection
+    EndSection
+
+(Note: You'll also need to create a second Monitor section) Finally, update
+the ServerLayout section to use and position both Screen sections:
+
+    Section "ServerLayout"
+        ...
+        Screen         0 "Screen0" 
+        Screen         1 "Screen1" leftOf "Screen0"
+        ...
+    EndSection
+
+For further details, refer to the XF86Config(5x) or xorg.conf(5x) manpages.
+
+______________________________________________________________________________
+
+Chapter 13. Configuring TV-Out
+______________________________________________________________________________
+
+NVIDIA GPU-based graphics cards with a TV-Out connector can use a television
+as another display device (the same way that it would use a CRT or digital
+flat panel). The TV can be used by itself, or in conjunction with another
+display device in a TwinView or multiple X screen configuration. If a TV is
+the only display device connected to your graphics card, it will be used as
+the primary display when you boot your system (i.e. the console will come up
+on the TV just as if it were a CRT).
+
+The NVIDIA X driver populates the mode pool for the TV with all the mode sizes
+that the driver supports with the given TV standard and the TV encoder on the
+graphics card. These modes are given names that correspond to their
+resolution; e.g., "800x600".
+
+Because these TV modes only depend on the TV encoder and the TV standard, TV
+modes do not go through normal mode validation. The X configuration options
+HorizSync and VertRefresh are not used for TV mode validation.
+
+Additionally, the NVIDIA driver contains a hardcoded list of mode sizes that
+it can drive for each combination of TV encoder and TV standard. Therefore,
+custom modelines in your X configuration file are ignored for TVs.
+
+To use your TV with X, there are several relevant X configuration options:
+
+   o The Modes in the screen section of your X configuration file; you can use
+     these to request any of the modes in the mode pool which the X driver
+     created for this combination of TV standard and TV encoder. Examples
+     include "640x480" and "800x600". If in doubt, use "nvidia-auto-select".
+
+   o The "TVStandard" option should be added to your screen section; valid
+     values are:
+     
+         TVStandard       Description
+         -------------    --------------------------------------------------
+         "PAL-B"          used in Belgium, Denmark, Finland, Germany,
+                          Guinea, Hong Kong, India, Indonesia, Italy,
+                          Malaysia, The Netherlands, Norway, Portugal,
+                          Singapore, Spain, Sweden, and Switzerland
+         "PAL-D"          used in China and North Korea
+         "PAL-G"          used in Denmark, Finland, Germany, Italy,
+                          Malaysia, The Netherlands, Norway, Portugal,
+                          Spain, Sweden, and Switzerland
+         "PAL-H"          used in Belgium
+         "PAL-I"          used in Hong Kong and The United Kingdom
+         "PAL-K1"         used in Guinea
+         "PAL-M"          used in Brazil
+         "PAL-N"          used in France, Paraguay, and Uruguay
+         "PAL-NC"         used in Argentina
+         "NTSC-J"         used in Japan
+         "NTSC-M"         used in Canada, Chile, Colombia, Costa Rica,
+                          Ecuador, Haiti, Honduras, Mexico, Panama, Puerto
+                          Rico, South Korea, Taiwan, United States of
+                          America, and Venezuela
+         "HD480i"         480 line interlaced
+         "HD480p"         480 line progressive
+         "HD720p"         720 line progressive
+         "HD1080i"        1080 line interlaced
+         "HD1080p"        1080 line progressive
+         "HD576i"         576 line interlace
+         "HD576p"         576 line progressive
+     
+     The line in your X config file should be something like:
+     
+         Option "TVStandard" "NTSC-M"
+     
+     If you do not specify a TVStandard, or you specify an invalid value, the
+     default "NTSC-M" will be used. Note: if your country is not in the above
+     list, select the country closest to your location.
+
+   o The "UseDisplayDevice" option can be used if there are multiple display
+     devices connected, and you want the connected TV to be used instead of
+     the connected CRTs and/or DFPs. E.g.,
+     
+         Option "UseDisplayDevice" "TV"
+     
+     Using the "UseDisplayDevice" option, rather than the "ConnectedMonitor"
+     option, is recommended.
+
+   o The "TVOutFormat" option can be used to force the output format. Without
+     this option, the driver autodetects the output format. Unfortunately, it
+     does not always do this correctly. The output format can be forced with
+     the "TVOutFormat" option; valid values are:
+     
+         TVOutFormat            Description            Supported TV
+                                                       standards
+         -------------------    -------------------    -------------------
+         "AUTOSELECT"           The driver             PAL, NTSC, HD
+                                autodetects the    
+                                output format      
+                                (default value).   
+         "COMPOSITE"            Force Composite        PAL, NTSC
+                                output format      
+         "SVIDEO"               Force S-Video          PAL, NTSC
+                                output format      
+         "COMPONENT"            Force Component        HD
+                                output format, also
+                                called YPrPp       
+         "SCART"                Force Scart output     PAL, NTSC
+                                format, also called
+                                Peritel            
+     
+     The line in your X config file should be something like:
+     
+         Option "TVOutFormat" "SVIDEO"
+     
+     
+   o The "TVOverScan" option can be used to enable Overscan, when the TV
+     encoder supports it. Valid values are decimal values in the range 1.0
+     (which means overscan as much as possible: make the image as large as
+     possible) and 0.0 (which means disable overscanning: make the image as
+     small as possible). Overscanning is disabled (0.0) by default.
+
+The NVIDIA X driver may not restore the console correctly with XFree86
+versions older than 4.3 when the console is a TV. This is due to binary
+incompatibilities between XFree86 int10 modules. If you use a TV as your
+console it is recommended that you upgrade to XFree86 4.3 or later.
+
+______________________________________________________________________________
+
+Chapter 14. Using the XRandR Extension
+______________________________________________________________________________
+
+X.Org version X11R6.8.1 contains support for the rotation component of the
+XRandR extension, which allows screens to be rotated at 90 degree increments.
+
+The driver supports rotation with the extension when 'Option "RandRRotation"'
+is enabled in the X config file.
+
+Workstation RGB or CI overlay visuals will function at lower performance and
+the video overlay will not be available when RandRRotation is enabled.
+
+You can query the available rotations using the 'xrandr' command line
+interface to the RandR extension by running:
+
+    xrandr -q
+
+You can set the rotation orientation of the screen by running any of:
+
+    xrandr -o left
+    xrandr -o right
+    xrandr -o inverted
+    xrandr -o normal
+
+Rotation may also be set through the nvidia-settings configuration utility in
+the "Rotation Settings" panel.
+
+TwinView and rotation can be used together, but rotation affects the entire
+desktop. This means that the same rotation setting will apply to both display
+devices in a TwinView pair. Note also that the "TwinViewOrientation" option
+applies before rotation does. For example, if you have two screens
+side-by-side and you want to rotate them, you should set "TwinViewOrientation"
+to "Above" or "Below".
+
+______________________________________________________________________________
+
+Chapter 15. Configuring a Notebook
+______________________________________________________________________________
+
+
+15A. INSTALLATION AND CONFIGURATION
+
+Installation and configuration of the NVIDIA FreeBSD Driver Set on a notebook
+is the same as for any desktop environment, with a few additions, as described
+below.
+
+
+15B. POWER MANAGEMENT
+
+All notebook NVIDIA GPUs support power management, both S3 (also known as
+"Standby" or "Suspend to RAM") and S4 (also known as "Hibernate", "Suspend to
+Disk" or "SWSUSP"). Power management is system-specific and is dependent upon
+all the components in the system; some systems may be more problematic than
+other systems.
+
+Most recent notebook NVIDIA GPUs also support PowerMizer, which monitors
+application work load to adjust system parameters to deliver the optimal
+balance of performance and battery life. However, PowerMizer is only enabled
+by default on some notebooks. Please see the known issues below for more
+details.
+
+
+15C. HOTKEY SWITCHING OF DISPLAY DEVICES
+
+Mobile NVIDIA GPUs also have the capacity to react to a display change hotkey
+event, toggling between each of the connected display devices and each
+possible combination of the connected display devices (note that only 2
+display devices may be active at a time).
+
+Hotkey switching dynamically changes the TwinView configuration; a given
+hotkey event will indicate which display devices should be in use at that
+time, and all MetaModes currently configured on the X screen will be updated
+to use the new configuration of display devices.
+
+Another important aspect of hotkey functionality is that you can dynamically
+connect and remove display devices to/from your notebook and use the hotkey to
+activate and deactivate them without restarting X.
+
+Note that there are two approaches to implementing this hotkey support: ACPI
+events and polling.
+
+Most recent notebooks use ACPI events to deliver hotkeys from the System BIOS
+to the graphics driver. This is the preferred method of delivering hotkey
+events, but is still a new feature under most UNIX platforms and may not
+always function correctly.
+
+The polling mechanism requires checking during the vertical blanking interval
+for a hotkey status change. It is an older mechanism for handling hotkeys, and
+is therefore not supported on all notebooks and is not tested by notebook
+manufacturers. It also does not always report the same combinations of display
+devices that are reported by ACPI hotkey events.
+
+The NVIDIA FreeBSD Driver will attempt to use ACPI hotkey events, if possible.
+In the case that ACPI hotkey event support is not available, the driver will
+revert back to trying hotkey polling. In the case that the notebook does not
+support hotkey polling, hotkeys will not work. Please see the known issues
+section below for more details.
+
+When switching away from X to a virtual terminal, the VGA console will always
+be restored to the display device on which it was present when X was started.
+Similarly, when switching back into X, the same display device configuration
+will be used as when you switched away, regardless of what display change
+hotkey activity occurred while the virtual terminal was active.
+
+
+15D. DOCKING EVENTS
+
+All notebook NVIDIA GPUs support docking, however support may be limited by
+the OS or system. There are three types of notebook docking (hot, warm, and
+cold), which refer to the state of the system when the docking event occurs.
+hot refers to a powered on system with a live desktop, warm refers to a system
+that has entered a suspended power management state, and cold refers to a
+system that has been powered off. Only warm and cold docking are supported by
+the NVIDIA driver.
+
+
+15E. TWINVIEW
+
+All notebook NVIDIA GPUs support TwinView. TwinView on a notebook can be
+configured in the same way as on a desktop computer (refer to Chapter 10 );
+note that in a TwinView configuration using the notebook's internal flat panel
+and an external CRT, the CRT is the primary display device (specify its
+HorizSync and VertRefresh in the Monitor section of your X config file) and
+the flat panel is the secondary display device (specify its HorizSync and
+VertRefresh through the SecondMonitorHorizSync and SecondMonitorVertRefresh
+options).
+
+The "UseEdidFreqs" X config option is enabled by default, so normally you
+should not need to specify the "SecondMonitorHorizSync" and
+"SecondMonitorVertRefresh" options. See the description of the UseEdidFreqs
+option in Appendix F for details).
+
+
+15F. KNOWN NOTEBOOK ISSUES
+
+There are a few known issues associated with notebooks:
+
+   o Display change hotkey switching is not available on all notebooks. In
+     some cases, the ACPI infrastructure is not fully supported by the NVIDIA
+     FreeBSD Driver. Work is ongoing to increase the robustness of NVIDIA's
+     support in this area. Toshiba and Lenovo notebooks are known to be
+     problematic.
+
+   o ACPI Display change hotkey switching is not supported by X.Org X servers
+     earlier than 1.2.0; see EnableACPIHotkeys in Appendix F for details.
+
+   o In many cases, suspending and/or resuming will fail. As mentioned above,
+     this functionality is very system-specific. There are still many cases
+     that are problematic. Here are some tips that may help:
+     
+        o In some cases, hibernation can have bad interactions with the PCI
+          Express bus clocks, which can lead to system hangs when entering
+          hibernation. This issue is still being investigated, but a known
+          workaround is to leave an OpenGL application running when
+          hibernating.
+     
+     
+   o On some notebooks, PowerMizer is not enabled by default. This issue is
+     being investigated, and there is no known workaround.
+
+   o ACPI is not currently supported on FreeBSD As a result, ACPI hotkey
+     events are not supported.
+
+   o The video overlay only works on the first display device on which you
+     started X. For example, if you start X on the internal LCD, run a video
+     application that uses the video overlay (uses the "Video Overlay" adapter
+     advertised through the XV extension), and then hotkey switch to add a
+     second display device, the video will not appear on the second display
+     device. To work around this, you can either configure the video
+     application to use the "Video Blitter" adapter advertised through the XV
+     extension (this is always available), or hotkey switch to the display
+     device on which you want to use the video overlay *before* starting X.
+
+
+______________________________________________________________________________
+
+Chapter 16. Programming Modes
+______________________________________________________________________________
+
+The NVIDIA Accelerated FreeBSD Graphics Driver supports all standard VGA and
+VESA modes, as well as most user-written custom mode lines; double-scan modes
+are supported on all hardware. Interlaced modes are supported on all GeForce
+FX/Quadro FX and newer GPUs, and certain older GPUs; the X log file will
+contain a message "Interlaced video modes are supported on this GPU" if
+interlaced modes are supported.
+
+To request one or more standard modes for use in X, you can simply add a
+"Modes" line such as:
+
+    Modes "1600x1200" "1024x768" "640x480"
+
+in the appropriate Display subsection of your X config file (see the
+XF86Config(5x) or xorg.conf(5x) man pages for details). Or, the
+nvidia-xconfig(1) utility can be used to request additional modes; for
+example:
+
+    nvidia-xconfig --mode 1600x1200
+
+See the nvidia-xconfig(1) man page for details.
+
+
+16A. DEPTH, BITS PER PIXEL, AND PITCH
+
+While not directly a concern when programming modes, the bits used per pixel
+is an issue when considering the maximum programmable resolution; for this
+reason, it is worthwhile to address the confusion surrounding the terms
+"depth" and "bits per pixel". Depth is how many bits of data are stored per
+pixel. Supported depths are 8, 15, 16, and 24. Most video hardware, however,
+stores pixel data in sizes of 8, 16, or 32 bits; this is the amount of memory
+allocated per pixel. When you specify your depth, X selects the bits per pixel
+(bpp) size in which to store the data. Below is a table of what bpp is used
+for each possible depth:
+
+    Depth                                 BPP
+    ----------------------------------    ----------------------------------
+    8                                     8
+    15                                    16
+    16                                    16
+    24                                    32
+
+Lastly, the "pitch" is how many bytes in the linear frame buffer there are
+between one pixel's data, and the data of the pixel immediately below. You can
+think of this as the horizontal resolution multiplied by the bytes per pixel
+(bits per pixel divided by 8). In practice, the pitch may be more than this
+product due to alignment constraints.
+
+
+16B. MAXIMUM RESOLUTIONS
+
+The NVIDIA Accelerated FreeBSD Graphics Driver and NVIDIA GPU-based graphics
+cards support resolutions up to 8192x8192 pixels for the GeForce 8 series and
+above, and up to 4096x4096 pixels for the GeForce 7 series and below, though
+the maximum resolution your system can support is also limited by the amount
+of video memory (see USEFUL FORMULAS for details) and the maximum supported
+resolution of your display device (monitor/flat panel/television). Also note
+that while use of a video overlay does not limit the maximum resolution or
+refresh rate, video memory bandwidth used by a programmed mode does affect the
+overlay quality.
+
+
+16C. USEFUL FORMULAS
+
+The maximum resolution is a function both of the amount of video memory and
+the bits per pixel you elect to use:
+
+HR * VR * (bpp/8) = Video Memory Used
+
+In other words, the amount of video memory used is equal to the horizontal
+resolution (HR) multiplied by the vertical resolution (VR) multiplied by the
+bytes per pixel (bits per pixel divided by eight). Technically, the video
+memory used is actually the pitch times the vertical resolution, and the pitch
+may be slightly greater than (HR * (bpp/8)) to accommodate the hardware
+requirement that the pitch be a multiple of some value.
+
+Note that this is just memory usage for the frame buffer; video memory is also
+used by other things, such as OpenGL and pixmap caching.
+
+Another important relationship is that between the resolution, the pixel clock
+(aka dot clock) and the vertical refresh rate:
+
+RR = PCLK / (HFL * VFL)
+
+In other words, the refresh rate (RR) is equal to the pixel clock (PCLK)
+divided by the total number of pixels: the horizontal frame length (HFL)
+multiplied by the vertical frame length (VFL) (note that these are the frame
+lengths, and not just the visible resolutions). As described in the XFree86
+Video Timings HOWTO, the above formula can be rewritten as:
+
+PCLK = RR * HFL * VFL
+
+Given a maximum pixel clock, you can adjust the RR, HFL and VFL as desired, as
+long as the product of the three is consistent. The pixel clock is reported in
+the log file. Your X log should contain a line like this:
+
+    (--) NVIDIA(0): ViewSonic VPD150 (DFP-1): 165 MHz maximum pixel clock
+
+which indicates the maximum pixel clock for that display device.
+
+
+16D. HOW MODES ARE VALIDATED
+
+In traditional XFree86/X.Org mode validation, the X server takes as a starting
+point the X server's internal list of VESA standard modes, plus any modes
+specified with special ModeLines in the X configuration file's Monitor
+section. These modes are validated against criteria such as the valid
+HorizSync/VertRefresh frequency ranges for the user's monitor (as specified in
+the Monitor section of the X configuration file), as well as the maximum pixel
+clock of the GPU.
+
+Once the X server has determined the set of valid modes, it takes the list of
+user requested modes (i.e., the set of modes named in the "Modes" line in the
+Display subsection of the Screen section of X configuration file), and finds
+the "best" validated mode with the requested name.
+
+The NVIDIA X driver uses a variation on the above approach to perform mode
+validation. During X server initialization, the NVIDIA X driver builds a pool
+of valid modes for each display device. It gathers all possible modes from
+several sources:
+
+   o The display device's EDID
+
+   o The X server's built-in list
+
+   o Any user-specified ModeLines in the X configuration file
+
+   o The VESA standard modes
+
+For every possible mode, the mode is run through mode validation. The core of
+mode validation is still performed similarly to traditional XFree86/X.Org mode
+validation: the mode timings are checked against things such as the valid
+HorizSync and VertRefresh ranges and the maximum pixelclock. Note that each
+individual stage of mode validation can be independently controlled through
+the "ModeValidation" X configuration option.
+
+Note that when validating interlaced mode timings, VertRefresh specifies the
+field rate, rather than the frame rate. For example, the following modeline
+has a vertical refresh rate of 87 Hz:
+
+
+ # 1024x768i @ 87Hz (industry standard)
+ ModeLine "1024x768"  44.9  1024 1032 1208 1264  768 768 776 817 +hsync +vsync
+Interlace
+
+
+Invalid modes are discarded; valid modes are inserted into the mode pool. See
+MODE VALIDATION REPORTING for how to get more details on mode validation
+results for each considered mode.
+
+Valid modes are given a unique name that is guaranteed to be unique across the
+whole mode pool for this display device. This mode name is constructed
+approximately like this:
+
+    <width>x<height>_<refreshrate>
+
+(e.g., "1600x1200_85")
+
+The name may also be prepended with another number to ensure the mode is
+unique; e.g., "1600x1200_85_0".
+
+As validated modes are inserted into the mode pool, duplicate modes are
+removed, and the mode pool is sorted, such that the "best" modes are at the
+beginning of the mode pool. The sorting is based roughly on:
+
+   o Resolution
+
+   o Source (EDID-provided modes are prioritized higher than VESA-provided
+     modes, which are prioritized higher than modes that were in the X
+     server's built-in list)
+
+   o Refresh rate
+
+Once modes from all mode sources are validated and the mode pool is
+constructed, all modes with the same resolution are compared; the best mode
+with that resolution is added to the mode pool a second time, using just the
+resolution as its unique modename (e.g., "1600x1200"). In this way, when you
+request a mode using the traditional names (e.g., "1600x1200"), you still get
+what you got before (the 'best' 1600x1200 mode); the added benefit is that all
+modes in the mode pool can be addressed by a unique name.
+
+When verbose logging is enabled (see the FAQ section on increasing the amount
+of data printed in the X log file), the mode pool for each display device is
+printed to the X log file.
+
+After the mode pool is built for all display devices, the requested modes (as
+specified in the X configuration file), are looked up from the mode pool. Each
+requested mode that can be matched against a mode in the mode pool is then
+advertised to the X server and is available to the user through the X server's
+mode switching hotkeys (ctrl-alt-plus/minus) and the XRandR and XF86VidMode X
+extensions.
+
+If only one display device is in use by the X screen when the X server starts,
+all modes in the mode pool are implicitly made available to the X server. See
+the "IncludeImplicitMetaModes" X configuration option in Appendix F for
+details.
+
+
+16E. THE NVIDIA-AUTO-SELECT MODE
+
+You can request a special mode by name in the X config file, named
+"nvidia-auto-select". When the X driver builds the mode pool for a display
+device, it selects one of the modes as the "nvidia-auto-select" mode; a new
+entry is made in the mode pool, and "nvidia-auto-select" is used as the unique
+name for the mode.
+
+The "nvidia-auto-select" mode is intended to be a reasonable mode for the
+display device in question. For example, the "nvidia-auto-select" mode is
+normally the native resolution for flatpanels, as reported by the flatpanel's
+EDID, or one of the detailed timings from the EDID. The "nvidia-auto-select"
+mode is guaranteed to always be present, and to always be defined as something
+considered valid by the X driver for this display device.
+
+Note that the "nvidia-auto-select" mode is not necessarily the largest
+possible resolution, nor is it necessarily the mode with the highest refresh
+rate. Rather, the "nvidia-auto-select" mode is selected such that it is a
+reasonable default. The selection process is roughly:
+
+
+   o If the EDID for the display device reported a preferred mode timing, and
+     that mode timing is considered a valid mode, then that mode is used as
+     the "nvidia-auto-select" mode. You can check if the EDID reported a
+     preferred timing by starting X with logverbosity greater than or equal to
+     5 (see the FAQ section on increasing the amount of data printed in the X
+     log file), and looking at the EDID printout; if the EDID contains a line:
+     
+         Prefer first detailed timing : Yes
+     
+     Then the first mode listed under the "Detailed Timings" in the EDID will
+     be used.
+
+   o If the EDID did not provide a preferred timing, the best detailed timing
+     from the EDID is used as the "nvidia-auto-select" mode.
+
+   o If the EDID did not provide any detailed timings (or there was no EDID at
+     all), the best valid mode not larger than 1024x768 is used as the
+     "nvidia-auto-select" mode. The 1024x768 limit is imposed here to restrict
+     use of modes that may have been validated, but may be too large to be
+     considered a reasonable default, such as 2048x1536.
+
+   o If all else fails, the X driver will use a built-in 800 x 600 60Hz mode
+     as the "nvidia-auto-select" mode.
+
+
+If no modes are requested in the X configuration file, or none of the
+requested modes can be found in the mode pool, then the X driver falls back to
+the "nvidia-auto-select" mode, so that X can always start. Appropriate warning
+messages will be printed to the X log file in these fallback scenarios.
+
+You can add the "nvidia-auto-select" mode to your X configuration file by
+running the command
+
+    nvidia-xconfig --mode nvidia-auto-select
+
+and restarting your X server.
+
+The X driver can generally do a much better job of selecting the
+"nvidia-auto-select" mode if the display device's EDID is available. This is
+one reason why the "IgnoreEDID" X configuration option has been deprecated,
+and that it is recommended to only use the "UseEDID" X configuration option
+sparingly. Note that, rather than globally disable all uses of the EDID with
+the "UseEDID" option, you can individually disable each particular use of the
+EDID using the "UseEDIDFreqs", "UseEDIDDpi", and/or the "NoEDIDModes" argument
+in the "ModeValidation" X configuration option.
+
+
+16F. MODE VALIDATION REPORTING
+
+When log verbosity is set to 6 or higher (see FAQ
+section on increasing the amount of data printed in the X log file), the X log
+will record every mode that is considered for each display device's mode pool,
+and report whether the mode passed or failed. For modes that were considered
+invalid, the log will report why the mode was considered invalid.
+
+
+16G. ENSURING IDENTICAL MODE TIMINGS
+
+Some functionality, such as Active Stereo with TwinView, requires control over
+exactly which mode timings are used. For explicit control over which mode
+timings are used on each display device, you can specify the ModeLine you want
+to use (using one of the ModeLine generators available), and using a unique
+name. For example, if you wanted to use 1024x768 at 120 Hz on each monitor in
+TwinView with active stereo, you might add something like this to the monitor
+section of your X configuration file:
+
+    # 1024x768 @ 120.00 Hz (GTF) hsync: 98.76 kHz; pclk: 139.05 MHz
+    Modeline "1024x768_120"  139.05  1024 1104 1216 1408  768 769 772 823
+-HSync +Vsync
+
+Then, in the Screen section of your X config file, specify a MetaMode like
+this:
+
+    Option "MetaModes" "1024x768_120, 1024x768_120"
+
+
+
+16H. ADDITIONAL INFORMATION
+
+An XFree86 ModeLine generator, conforming to the GTF Standard is available at
+http://gtf.sourceforge.net/. Additional generators can be found by searching
+for "modeline" on freshmeat.net.
+
+______________________________________________________________________________
+
+Chapter 17. Configuring Flipping and UBB
+______________________________________________________________________________
+
+The NVIDIA Accelerated FreeBSD Graphics Driver supports Unified Back Buffer
+(UBB) and OpenGL Flipping. These features can provide performance gains in
+certain situations.
+
+   o Unified Back Buffer (UBB): UBB is available only on the Quadro family of
+     GPUs (Quadro4 NVS excluded) and is enabled by default when there is
+     sufficient video memory available. This can be disabled with the UBB X
+     config option described in Appendix F. When UBB is enabled, all windows
+     share the same back, stencil and depth buffers. When there are many
+     windows, the back, stencil and depth usage will never exceed the size of
+     that used by a full screen window. However, even for a single small
+     window, the back, stencil, and depth video memory usage is that of a full
+     screen window. In that case video memory may be used less efficiently
+     than in the non-UBB case.
+
+   o Flipping: When OpenGL flipping is enabled, OpenGL can perform buffer
+     swaps by changing which buffer the DAC scans out rather than copying the
+     back buffer contents to the front buffer; this is generally a much higher
+     performance mechanism and allows tearless swapping during the vertical
+     retrace (when __GL_SYNC_TO_VBLANK is set). The conditions under which
+     OpenGL can flip are slightly complicated, but in general: on GeForce or
+     newer hardware, OpenGL can flip when a single full screen unobscured
+     OpenGL application is running, and __GL_SYNC_TO_VBLANK is enabled.
+     Additionally, OpenGL can flip on Quadro hardware even when an OpenGL
+     window is partially obscured or not full screen or __GL_SYNC_TO_VBLANK is
+     not enabled.
+
+
+______________________________________________________________________________
+
+Appendix C. The Sysctl Interface
+______________________________________________________________________________
+
+The sysctl interface allows you to obtain run-time information about the
+driver, any installed NVIDIA graphics cards and the AGP status. It also allows
+you to control low-level configuration options and/or overrides.
+
+The various pieces of information are held in a hierarchy under hw.nvidia and
+are accessible with the sysctl(8) command.
+
+NVIDIA sysctl Entries
+
+hw.nvidia.version
+
+    Prints the installed driver revision
+
+hw.nvidia.cards.n.*
+
+    These OIDs provide information about NVIDIA device 'n':
+    
+        ID                                  Description
+        --------------------------------    --------------------------------
+        model                               the device's product name
+        irq                                 the IRQ claimed by this device
+        vbios                               the device's VBIOS revision
+        type                                the bus type of this device
+    
+    
+hw.nvidia.agp.host-bridge.*
+hw.nvidia.agp.card.*
+
+    These OIDs provide information about the AGP capabilities of the installed
+    AGP graphics card and host-bridge respectively. These values are most
+    likely to be correct after system boot and before the X server is started
+    (and the AGP subsystem intialized).
+    
+        ID                Description
+        --------------    ---------------------------------------------------
+        rates             the AGP rates supported by this device
+        fw                if the device suppoprts AGP fast-writes
+        sba               if the device supports AGP side-band-addressing
+        registers         the device's AGP registers, status:command
+    
+    
+hw.nvidia.agp.status.*
+
+    Prints AGP status information based on the AGP command registers of the
+    host-bridge and of the AGP card.
+    
+        ID                Description
+        --------------    ---------------------------------------------------
+        status            if AGP is enabled or disabled
+        driver            which driver is being used
+        rate              the programmed AGP rate
+        fw                if fast-writes are enabled or disabled
+        sba               if side-band-addressing is enabled or disabled
+    
+    
+hw.nvidia.registry.*
+
+    Low-level kernel module configuration options. Changing these is typically
+    not necessary and potentially dangerous. If you do need to change any of
+    these options, you will need to do so BEFORE you start the X server.
+    
+        ID                Description
+        --------------    ---------------------------------------------------
+        status            if AGP is enabled or disabled
+        driver            which driver is being used
+        rate              the programmed AGP rate
+        fw                if fast-writes are enabled or disabled
+        sba               if side-band-addressing is enabled or disabled
+    
+    
+
+______________________________________________________________________________
+
+Appendix D. Configuring Low-level Parameters
+______________________________________________________________________________
+
+The NVIDIA resource manager recognizes several low-level configuration
+parameters that can be set using the sysctl driver interface BEFORE the X
+server is started. Normally you should not need to modify any of these
+parameters, but it is sometimes necessary or desirable to do so.
+
+To view the current settings of these parameters, you need to issue this
+sysctl command ('nvidia.ko' needs to be loaded):
+
+    % sysctl -a hw.nvidia.registry
+
+To change any of the parameters, you need to pass the complete name of the OID
+followed by '=' and the new value, e.g.:
+
+    % sysctl hw.nvidia.registry.EnableVia4x=1
+
+It is possible to automate setting these paramaters by adding them to the
+'/etc/sysctl.conf' file. See `man 5 sysctl.conf` for details.
+
+The following parameters are recognized by 'nvidia.ko':
+
+Resource Manager Parameters
+
+VideoMemoryTypeOverride
+
+    We normally detect memory type on TNT cards by scanning the embedded BIOS.
+    Unfortunately, we've seen some cases where a TNT card has been flashed
+    with the wrong bios. For example, an SDRAM based TNT has been flashed with
+    an SGRAM bios, and therefore claims to be an SGRAM TNT. We've therefore
+    provided an override here. Make sure to set the value toe the type of
+    memory used on your card.
+    
+        Value                               Meaning
+        --------------------------------    --------------------------------
+        1                                   SDRAM
+        2                                   SGRAM
+    
+    Note that we can only do so much here. There are border cases where even
+    this fails. For example, if 2 TNT cards are in the same system, one SGRAM,
+    one SDRAM.
+
+    This option is disabled by default, see below for information on how to
+    enable it.
+
+EnableVia4x
+
+    We've had problems with some Via chipsets in 4x mode, we need force them
+    back down to 2x mode. If you'd like to experiment with retaining 4x mode,
+    you may try setting this value to 1 If that hangs the system, you're stuck
+    with 2x mode; there's nothing we can do about it.
+    
+        Value             Meaning
+        --------------    ---------------------------------------------------
+        0                 disable AGP 4x on Via chipsets (default)
+        1                 enable AGP 4x on Via chipsets
+    
+    
+EnableALiAGP
+
+    Some ALi chipsets (ALi1541, ALi1647) are known to cause severe system
+    stability problems with AGP enabled. To avoid lockups, we disable AGP on
+    systems with these chipsets by default. It appears that updating the
+    system BIOS and using recent versions of the kernel AGP Gart driver can
+    make such systems much more stable. If you own a system with one of the
+    aforementioned chipsets and had it working reasonably well previously, or
+    if you want to experiment with BIOS and AGPGART revisions, you can
+    re-enable AGP support by setting this option to 1.
+    
+        Value             Meaning
+        --------------    ---------------------------------------------------
+        0                 disable AGP on Ali1541 and ALi1647 (default)
+        1                 enable AGP on Ali1541 and ALi1647
+    
+    
+NvAGP
+
+    This options controls which AGP GART driver is used when no explicit
+    request is made to change the default (X server).
+    
+        Value             Meaning
+        --------------    ---------------------------------------------------
+        0                 disable AGP support
+        1                 use the NVIDIA builtin driver (if possible)
+        2                 use the kernel's AGPGART driver (if possible)
+        3                 use any available driver (try 2, then 1)
+    
+    Note that the NVIDIA internal AGP GART driver will not be used if AGPGART
+    was either statically linked into your kernel or built as a kernel module
+    and loaded before the NVIDIA kernel module.
+
+ReqAGPRate
+
+    Normally, the driver will compare speed modes of the chipset and the card,
+    picking the highest common rate. This key forces a maximum limit, to limit
+    the driver to lower speeds. The driver will not attempt a speed beyond
+    what the chipset and card claim they are capable of.
+
+    Make sure you really know what you're doing before you enable this
+    override. By default, AGP drivers will enable the fastest AGP rate your
+    card and motherboard chipset are capable of. Then, in some cases, our
+    driver will force this rate down to work around bugs in both our chipsets,
+    and motherboard chipsets. Using this variable will override our bug fixes.
+    This may be desirable in some cases, but not most. THIS IS COMPLETELY
+    UNSUPPORTED!
+
+    This option expects a bitmask (7 = 1|2|3|4, 3=1|2, etc.)
+
+    This option is disabled by default, see below for information on how to
+    enable it.
+
+EnableAGPSBA
+
+    For stability reasons, the driver will not Side Band Addressing even if
+    both the host chipset and the AGP card support it. You may override this
+    behaviour with the following registry key. THIS IS COMPLETELY UNSUPPORTED!
+    
+    
+        Value             Meaning
+        --------------    ---------------------------------------------------
+        0                 disable Side Band Addressing (default on x86, see
+                          below)
+        1                 enable Side Band Addressing (if supported)
+    
+    
+EnableAGPFW
+
+    Similar to Side Band Addressing, Fast Writes are disabled by default. If
+    you wish to enable them on systems that support them, you can do so with
+    this registry key. Note that this may render your system unstable with
+    many AGP chipsets. THIS IS COMPLETELY UNSUPPORTED! 
+    
+        Value                               Meaning
+        --------------------------------    --------------------------------
+        0                                   disable Fast Writes (default)
+        1                                   enable Fast Writes
+    
+    
+
+______________________________________________________________________________
+
+Chapter 18. Using the X Composite Extension
+______________________________________________________________________________
+
+X.Org X servers, beginning with X11R6.8.0, contain experimental support for a
+new X protocol extension called Composite. This extension allows windows to be
+drawn into pixmaps instead of directly onto the screen. In conjunction with
+the Damage and Render extensions, this allows a program called a composite
+manager to blend windows together to draw the screen.
+
+Performance will be degraded significantly if the "RenderAccel" option is
+disabled in xorg.conf. See Appendix F for more details.
+
+When the NVIDIA X driver is used with an X.Org X server X11R6.9.0 or newer and
+the Composite extension is enabled, NVIDIA's OpenGL implementation interacts
+properly with the Damage and Composite X extensions. This means that OpenGL
+rendering is drawn into offscreen pixmaps and the X server is notified of the
+Damage event when OpenGL renders to the pixmap. This allows OpenGL
+applications to behave properly in a composited X desktop.
+
+If the Composite extension is enabled on an X server older than X11R6.9.0,
+then GLX will be disabled. You can force GLX on while Composite is enabled on
+pre-X11R6.9.0 X servers with the "AllowGLXWithComposite" X configuration
+option. However, GLX will not render correctly in this environment. Upgrading
+your X server to X11R6.9.0 or newer is recommended.
+
+You can enable the Composite X extension by running 'nvidia-xconfig
+--composite'. Composite can be disabled with 'nvidia-xconfig --no-composite'.
+See the nvidia-xconfig(1) man page for details.
+
+If you are using Composite with GLX, it is recommended that you also enable
+the "DamageEvents" X option for enhanced performance. If you are using an
+OpenGL-based composite manager, you may also need the "DisableGLXRootClipping"
+option to obtain proper output.
+
+The Composite extension also causes problems with other driver components:
+
+   o In X servers prior to X.Org 7.1, Xv cannot draw into pixmaps that have
+     been redirected offscreen and will draw directly onto the screen instead.
+     For some programs you can work around this issue by using an alternative
+     video driver. For example, "mplayer -vo x11" will work correctly, as will
+     "xine -V xshm". If you must use Xv with an older server, you can also
+     disable the compositing manager and re-enable it when you are finished.
+
+     On X.Org 7.1 and higher, the driver will properly redirect video into
+     offscreen pixmaps. Note that the Xv adaptors will ignore the
+     sync-to-vblank option when drawing into a redirected window.
+
+   o Workstation overlays, stereo visuals, and the unified back buffer (UBB)
+     are incompatible with Composite. These features will be automatically
+     disabled when Composite is detected.
+
+
+This NVIDIA FreeBSD supports OpenGL rendering to 32-bit ARGB windows on X.Org
+7.2 and higher or when the "AddARGBGLXVisuals" X config file option is
+enabled. If you are an application developer, you can use these new visuals in
+conjunction with a composite manager to create translucent OpenGL
+applications:
+
+    int attrib[] = {
+        GLX_RENDER_TYPE, GLX_RGBA_BIT,
+        GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
+        GLX_RED_SIZE, 1,
+        GLX_GREEN_SIZE, 1,
+        GLX_BLUE_SIZE, 1,
+        GLX_ALPHA_SIZE, 1,
+        GLX_DOUBLEBUFFER, True,
+        GLX_DEPTH_SIZE, 1,
+        None };
+    GLXFBConfig *fbconfigs, fbconfig;
+    int numfbconfigs, render_event_base, render_error_base;
+    XVisualInfo *visinfo;
+    XRenderPictFormat *pictFormat;
+
+    /* Make sure we have the RENDER extension */
+    if(!XRenderQueryExtension(dpy, &render_event_base, &render_error_base)) {
+        fprintf(stderr, "No RENDER extension found\n");
+        exit(EXIT_FAILURE);
+    }
+
+    /* Get the list of FBConfigs that match our criteria */
+    fbconfigs = glXChooseFBConfig(dpy, scrnum, attrib, &numfbconfigs);
+    if (!fbconfigs) {
+        /* None matched */
+        exit(EXIT_FAILURE);
+    }
+
+    /* Find an FBConfig with a visual that has a RENDER picture format that
+     * has alpha */
+    for (i = 0; i < numfbconfigs; i++) {
+        visinfo = glXGetVisualFromFBConfig(dpy, fbconfigs[i]);
+        if (!visinfo) continue;
+        pictFormat = XRenderFindVisualFormat(dpy, visinfo->visual);
+        if (!pictFormat) continue;
+
+        if(pictFormat->direct.alphaMask > 0) {
+            fbconfig = fbconfigs[i];
+            break;
+        }
+
+        XFree(visinfo);
+    }
+
+    if (i == numfbconfigs) {
+        /* None of the FBConfigs have alpha.  Use a normal (opaque)
+         * FBConfig instead */
+        fbconfig = fbconfigs[0];
+        visinfo = glXGetVisualFromFBConfig(dpy, fbconfig);
+        pictFormat = XRenderFindVisualFormat(dpy, visinfo->visual);
+    }
+
+    XFree(fbconfigs);
+
+
+When rendering to a 32-bit window, keep in mind that the X RENDER extension,
+used by most composite managers, expects "premultiplied alpha" colors. This
+means that if your color has components (r,g,b) and alpha value a, then you
+must render (a*r, a*g, a*b, a) into the target window.
+
+More information about Composite can be found at
+http://freedesktop.org/Software/CompositeExt
+
+______________________________________________________________________________
+
+Chapter 19. Using the nvidia-settings Utility
+______________________________________________________________________________
+
+A graphical configuration utility, 'nvidia-settings', is included with the
+NVIDIA FreeBSD graphics driver. After installing the driver and starting X,
+you can run this configuration utility by running:
+
+    % nvidia-settings
+
+in a terminal window.
+
+Detailed information about the configuration options available are documented
+in the help window in the utility.
+
+For more information, see the nvidia-settings man page or the user guide
+available here:
+ftp://download.nvidia.com/XFree86/Linux-x86/nvidia-settings-user-guide.txt
+
+The source code to nvidia-settings is released as GPL and is available here:
+ftp://download.nvidia.com/XFree86/nvidia-settings/
+
+If you have trouble running the nvidia-settings binary shipped with the NVIDIA
+FreeBSD Graphics Driver, refer to the nvidia-settings entry in Chapter 6.
+
+______________________________________________________________________________
+
+Chapter 20. Configuring SLI and Multi-GPU FrameRendering
+______________________________________________________________________________
+
+The NVIDIA FreeBSD driver contains support for NVIDIA SLI FrameRendering and
+NVIDIA Multi-GPU FrameRendering. Both of these technologies allow an OpenGL
+application to take advantage of multiple GPUs to improve visual performance.
+
+The distinction between SLI and Multi-GPU is straightforward. SLI is used to
+leverage the processing power of GPUs across two or more graphics cards, while
+Multi-GPU is used to leverage the processing power of two GPUs colocated on
+the same graphics card. If you want to link together separate graphics cards,
+you should use the "SLI" X config option. Likewise, if you want to link
+together GPUs on the same graphics card, you should use the "MultiGPU" X
+config option. If you have two cards, each with two GPUs, and you wish to link
+them all together, you should use the "SLI" option.
+
+In FreeBSD, with two GPUs SLI and Multi-GPU can both operate in one of three
+modes: Alternate Frame Rendering (AFR), Split Frame Rendering (SFR), and
+Antialiasing (AA). When AFR mode is active, one GPU draws the next frame while
+the other one works on the frame after that. In SFR mode, each frame is split
+horizontally into two pieces, with one GPU rendering each piece. The split
+line is adjusted to balance the load between the two GPUs. AA mode splits
+antialiasing work between the two GPUs. Both GPUs work on the same scene and
+the result is blended together to produce the final frame. This mode is useful
+for applications that spend most of their time processing with the CPU and
+cannot benefit from AFR.
+
+With four GPUs, the same options are applicable. AFR mode cycles through all
+four GPUs, each GPU rendering a frame in turn. SFR mode splits the frame
+horizontally into four pieces. AA mode splits the work between the four GPUs,
+allowing antialiasing up to 64x. With four GPUs SLI can also operate in an
+additional mode, Alternate Frame Rendering of Antialiasing. (AFR of AA). With
+AFR of AA, pairs of GPUs render alternate frames, each GPU in a pair doing
+half of the antialiasing work. Note that these scenarios apply whether you
+have four separate cards or you have two cards, each with two GPUs.
+
+Multi-GPU is enabled by setting the "MultiGPU" option in the X configuration
+file; see Appendix F for details about the "MultiGPU" option.
+
+The nvidia-xconfig utility can be used to set the "MultiGPU" option, rather
+than modifying the X configuration file by hand. For example:
+
+    % nvidia-xconfig --multigpu=on
+
+
+SLI is enabled by setting the "SLI" option in the X configuration file; see
+Appendix F for details about the SLI option.
+
+The nvidia-xconfig utility can be used to set the SLI option, rather than
+modifying the X configuration file by hand. For example:
+
+    % nvidia-xconfig --sli=on
+
+
+
+20A. HARDWARE REQUIREMENTS
+
+SLI functionality requires:
+
+   o Identical PCI-Express graphics cards
+
+   o A supported motherboard
+
+   o In most cases, a video bridge connecting the two graphics cards
+
+For the latest in supported SLI and Multi-GPU configurations, including SLI-
+and Multi-GPU capable GPUs and SLI-capable motherboards, see
+http://www.slizone.com.
+
+
+20B. OTHER NOTES AND REQUIREMENTS
+
+The following other requirements apply to SLI and Multi-GPU:
+
+   o Mobile GPUs are NOT supported
+
+   o SLI on Quadro-based graphics cards always requires a video bridge
+
+   o TwinView is also not supported with SLI or Multi-GPU. Only one display
+     can be used when SLI or Multi-GPU is enabled.
+
+   o If X is configured to use multiple screens and screen 0 has SLI or
+     Multi-GPU enabled, the other screens will be disabled. Note that if SLI
+     or Multi-GPU is enabled, the GPUs used by that configuration will be
+     unavailable for single GPU rendering.
+
+
+
+FREQUENTLY ASKED SLI AND MULTI-GPU QUESTIONS
+
+Q. Why is glxgears slower when SLI or Multi-GPU is enabled?
+
+A. When SLI or Multi-GPU is enabled, the NVIDIA driver must coordinate the
+   operations of all GPUs when each new frame is swapped (made visible). For
+   most applications, this GPU synchronization overhead is negligible.
+   However, because glxgears renders so many frames per second, the GPU
+   synchronization overhead consumes a significant portion of the total time,
+   and the framerate is reduced.
+
+
+Q. Why is Doom 3 slower when SLI or Multi-GPU is enabled?
+
+A. The NVIDIA Accelerated FreeBSD Graphics Driver does not automatically
+   detect the optimal SLI or Multi-GPU settings for games such as Doom 3 and
+   Quake 4. To work around this issue, the environment variable __GL_DOOM3 can
+   be set to tell OpenGL that Doom 3's optimal settings should be used. In
+   Bash, this can be done in the same command that launches Doom 3 so the
+   environment variable does not remain set for other OpenGL applications
+   started in the same session:
+   
+       % __GL_DOOM3=1 doom3
+   
+   Doom 3's startup script can also be modified to set this environment
+   variable:
+   
+       #!/bin/sh
+       # Needed to make symlinks/shortcuts work.
+       # the binaries must run with correct working directory
+       cd "/usr/local/games/doom3/"
+       export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:.
+       export __GL_DOOM3=1
+       exec ./doom.x86 "$@"
+   
+   This environment variable is temporary and will be removed in the future.
+
+
+______________________________________________________________________________
+
+Chapter 21. Configuring Frame Lock and Genlock
+______________________________________________________________________________
+
+NOTE: Frame Lock and Genlock features are supported only on specific hardware,
+as noted below.
+
+Visual computing applications that involve multiple displays, or even multiple
+windows within a display, can require special signal processing and
+application controls in order to function properly. For example, in order to
+produce quality video recording of animated graphics, the graphics display
+must be synchronized with the video camera. As another example, applications
+presented on multiple displays must be synchronized in order to complete the
+illusion of a larger, virtual canvas.
+
+This synchronization is enabled through the frame lock and genlock
+capabilities of the NVIDIA driver. This section describes the setup and use of
+frame lock and genlock.
+
+
+21A. DEFINITION OF TERMS
+
+GENLOCK: Genlock refers to the process of synchronizing the pixel scanning of
+one or more displays to an external synchronization source. NVIDIA Genlock
+requires the external signal to be either TTL or composite, such as used for
+NTSC, PAL, or HDTV. It should be noted that the NVIDIA Genlock implementation
+is guaranteed only to be frame-synchronized, and not necessarily
+pixel-synchronized.
+
+FRAME LOCK: Frame Lock involves the use of hardware to synchronize the frames
+on each display in a connected system. When graphics and video are displayed
+across multiple monitors, frame locked systems help maintain image continuity
+to create a virtual canvas. Frame lock is especially critical for stereo
+viewing, where the left and right fields must be in sync across all displays.
+
+In short, to enable genlock means to sync to an external signal. To enable
+frame lock means to sync 2 or more display devices to a signal generated
+internally by the hardware, and to use both means to sync 2 or more display
+devices to an external signal.
+
+SWAP SYNC: Swap sync refers to the synchronization of buffer swaps of multiple
+application windows. By means of swap sync, applications running on multiple
+systems can synchronize the application buffer swaps between all the systems.
+In order to work across multiple systems, swap sync requires that the systems
+are frame locked.
+
+G-SYNC DEVICE: A G-Sync Device refers to devices capable of Frame
+lock/Genlock. This can be a graphics card (Quadro FX 3000G) or a stand alone
+device (Quadro FX G-Sync). See "Supported Hardware" below.
+
+
+21B. SUPPORTED HARDWARE
+
+Frame lock and genlock are supported for the following hardware:
+
+    Card
+    ----------------------------------------------------------------------
+    Quadro FX 3000G
+    Quadro FX G-Sync, used in conjunction with a Quadro FX 4400, Quadro FX
+    4500, or Quadro FX 5500
+
+
+
+21C. HARDWARE SETUP
+
+Before you begin, you should check that your hardware has been properly
+installed. If you are using the Quadro FX 3000G, the genlock/frame lock signal
+processing hardware is located on the dual-slot card itself, and after
+installing the card, no additional setup is necessary.
+
+If you are using the Quadro FX G-Sync card in conjunction with a graphics
+card, the following additional setup steps are required. These steps must be
+performed when the system is off.
+
+  1. On the Quadro FX G-Sync card, locate the fourteen-pin connector labeled
+     "primary". If the associated ribbon cable is not already joined to this
+     connector, do so now. If you plan to use frame lock or genlock in
+     conjunction with SLI FrameRendering or Multi-GPU FrameRendering (see
+     Chapter 20) or other multi-GPU configurations, you should connect the
+     fourteen-pin connector labeled "secondary" to the second GPU. A section
+     at the end of this appendix describes restrictions on such setups.
+
+  2. Install the Quadro FX G-Sync card in any available slot. Note that the
+     slot itself is only used for support, so even a known "bad" slot is
+     acceptable. The slot must be close enough to the graphics card that the
+     ribbon cable can reach.
+
+  3. Connect the other end of the ribbon cable to the fourteen-pin connector
+     on the graphics card.
+
+You may now boot the system and begin the software setup of genlock and/or
+frame lock. These instructions assume that you have already successfully
+installed the NVIDIA Accelerated FreeBSD Driver Set. If you have not done so,
+see Chapter 2.
+
+
+21D. CONFIGURATION WITH NVIDIA-SETTINGS GUI
+
+Frame lock and genlock are configured through the nvidia-settings utility. See
+the 'nvidia-settings(1)' man page, and the nvidia-settings online help (click
+the "Help" button in the lower right corner of the interface for per-page help
+information).
+
+From the nvidia-settings frame lock panel, you may control the addition of
+G-Sync (and display) devices to the frame lock/genlock group, monitor the
+status of that group, and enable/disable frame lock and genlock.
+
+After the system has booted and X Windows has been started, run
+nvidia-settings as
+
+    % nvidia-settings
+
+You may wish to start this utility before continuing, as we refer to it
+frequently in the subsequent discussion.
+
+The setup of genlock and frame lock are described separately. We then describe
+the use of genlock and frame lock together.
+
+
+21E. GENLOCK SETUP
+
+After the system has been booted, connect the external signal to the house
+sync connector (the BNC connector) on either the graphics card or the G-Sync
+card. There is a status LED next to the connector. A solid red LED indicates
+that the hardware cannot detect the timing signal. A green LED indicates that
+the hardware is detecting a timing signal. An occasional red flash is okay.
+The G-Sync device (graphics card or G-Sync card) will need to be configured
+correctly for the signal to be detected.
+
+In the frame lock panel of the nvidia-settings interface, add the X Server
+that contains the display and G-Sync devices that you would like to sync to
+this external source by clicking the "Add Devices..." button. An X Server is
+typically specified in the format "system:m", e.g.:
+
+    mycomputer.domain.com:0
+
+or
+
+    localhost:0
+
+After adding an X Server, rows will appear in the "G-Sync Devices" section on
+the frame lock panel that displays relevant status information about the
+G-Sync devices, GPUs attached to those G-Sync devices and the display devices
+driven by those GPUs. In particular, the G-Sync rows will display the server
+name and G-Sync device number along with "Receiving" LED, "Rate", "House" LED,
+"Port0"/"Port1" Images, and "Delay" information. The GPU rows will display the
+GPU product name information along with the GPU ID for the server. The Display
+Device rows will show the display device name and device type along with
+server/client checkboxes, refresh rate, "Timing" LED and "Stereo" LED.
+
+Once the G-Sync and display devices have been added to the frame lock/genlock
+group, a Server display device will need to be selected. This is done by
+selecting the "Server" checkbox of the desired display device.
+
+If you are using a G-Sync card, you must also click the "Use House Sync if
+Present" checkbox. To enable synchronization of this G-Sync device to the
+external source, click the "Enable Frame Lock" button. The display device(s)
+may take a moment to stabilize. If it does not stabilize, you may have
+selected a synchronization signal that the system cannot support. You should
+disable synchronization by clicking the "Disable Frame Lock" button and check
+the external sync signal.
+
+Modifications to genlock settings (e.g., "Use House Sync if Present", "Add
+Devices...") must be done while synchronization is disabled.
+
+
+21F. FRAME LOCK SETUP
+
+Frame Lock is supported across an arbitrary number of Quadro FX 3000 or Quadro
+FX G-Sync systems, although mixing the two in the same frame lock group is not
+supported. Additionally, each system to be included in the frame lock group
+must be configured with identical mode timings. See Chapter 16 for information
+on mode timings.
+
+Connect the systems through their RJ45 ports using standard CAT5 patch cables.
+These ports are located on the frame lock card itself (either the Quadro FX
+3000 or the Quadro FX G-Sync card). DO NOT CONNECT A FRAME LOCK PORT TO AN
+ETHERNET CARD OR HUB. DOING SO MAY PERMANENTLY DAMAGE THE HARDWARE. The
+connections should be made in a daisy-chain fashion: each card has two RJ45
+ports, call them 1 and 2. Connect port 1 of system A to port 2 of system B,
+connect port 1 of system B to port 2 of system C, etc. Note that you will
+always have two empty ports in your frame lock group.
+
+The ports self-configure as inputs or outputs once frame lock is enabled. Each
+port has a yellow and a green LED that reflect this state. A flashing yellow
+LED indicates an output and a flashing green LED indicates an input. A solid
+green LED indicates that the port has not yet configured.
+
+In the frame lock panel of the nvidia-settings interface, add the X server
+that contains the display devices that you would like to include in the frame
+lock group by clicking the "Add Devices..." button (see the description for
+adding display devices in the previous section on GENLOCK SETUP. Like the
+genlock status indicators, the "Port0" and "Port1" columns in the table on the
+frame lock panel contain indicators whose states mirror the states of the
+physical LEDs on the RJ45 ports. Thus, you may monitor the status of these
+ports from the software interface.
+
+Any X Server can be added to the frame lock group, provided that
+
+  1. The system supporting the X Server is configured to support frame lock
+     and is connected via RJ45 cable to the other systems in the frame lock
+     group.
+
+  2. The system driving nvidia-settings can locate and has display privileges
+     on the X server that is to be included for frame lock.
+
+A system can gain display privileges on a remote system by executing
+
+    % xhost +
+
+on the remote system. See the xhost(1) man page for details. Typically, frame
+lock is controlled through one of the systems that will be included in the
+frame lock group. While this is not a requirement, note that nvidia-settings
+will only display the frame lock panel when running on an X server that
+supports frame lock.
+
+To enable synchronization on these display devices, click the "Enable Frame
+Lock" button. The screens may take a moment to stabilize. If they do not
+stabilize, you may have selected mode timings that one or more of the systems
+cannot support. In this case you should disable synchronization by clicking
+the "Disable Frame Lock" button and refer to Chapter 16 for information on
+mode timings.
+
+Modifications to frame lock settings (e.g. "Add/Remove Devices...") must be
+done while synchronization is disabled.
+
+
+21G. FRAME LOCK + GENLOCK
+
+The use of frame lock and genlock together is a simple extension of the above
+instructions for using them separately. You should first follow the
+instructions for Frame Lock Setup, and then to one of the systems that will be
+included in the frame lock group, attach an external sync source. In order to
+sync the frame lock group to this single external source, you must select a
+display device driven by the GPU connected to the G-Sync card (through the
+primary connector) that is connected to the external source to be the signal
+server for the group. This is done by selecting the checkbox labeled "Server"
+of the tree on the frame lock panel in nvidia-settings. If you are using a
+G-Sync based frame lock group, you must also select the "Use House Sync if
+Present" checkbox. Enable synchronization by clicking the "Enable Frame Lock"
+button. As with other frame lock/genlock controls, you must select the signal
+server while synchronization is disabled.
+
+
+21H. CONFIGURATION WITH NVIDIA-SETTINGS COMMAND LINE
+
+Frame Lock may also be configured through the nvidia-settings command line.
+This method of configuring Frame Lock may be useful in a scripted environment
+to automate the setup process. (Note that the examples listed below depend on
+the actual hardware configuration and as such may not work as-is.)
+
+To properly configure Frame Lock, the following steps should be completed:
+
+  1. Make sure Frame Lock Sync is disabled on all GPUs.
+
+  2. Make sure all display devices that are to be frame locked have the same
+     refresh rate.
+
+  3. Configure which (display/GPU) device should be the master.
+
+  4. Configure house sync (if applicable).
+
+  5. Configure the slave display devices.
+
+  6. Enable frame lock sync on the master GPU.
+
+  7. Enable frame lock sync on the slave GPUs.
+
+  8. Toggle the test signal on the master GPU (for testing the hardware
+     connectivity.)
+
+
+For a full list of the nvidia-settings Frame Lock attributes, please see the
+'nvidia-settings(1)' man page. Examples:
+
+  1. 1 System, 1 Frame Lock board, 1 GPU, and 1 display device syncing to the
+     house signal:
+     
+       # - Make sure frame lock sync is disabled
+       nvidia-settings -a [gpu:0]/FrameLockEnable=0
+       nvidia-settings -q [gpu:0]/FrameLockEnable
+     
+       # - Query the enabled displays on the gpu
+       nvidia-settings -q [gpu:0]/EnabledDisplays
+     
+       # - Check that the refresh rate is the one we want
+       nvidia-settings -q [gpu:0]/RefreshRate
+     
+       # - Set the master display device to CRT-0.  The desired display
+       #   device(s) to be set are passed in as a hexadecimal number
+       #   in which specific bits denote which display devices to set.
+       #   examples:
+       #
+       #   0x00000001 - CRT-0
+       #   0x00000002 - CRT-1
+       #   0x00000003 - CRT-0 and CRT-1
+       #
+       #   0x00000100 - TV-0
+       #   0x00000200 - TV-1
+       #
+       #   0x00020000 - DFP-1
+       #
+       #   0x00010101 - CRT-0, TV-0 and DFP-0
+       #
+       #   0x000000FF - All CRTs
+       #   0x0000FF00 - All TVs
+       #   0x00FF0000 - All DFPs
+       #
+       #   Note that the following command:
+       # 
+       #     nvidia-settings -q [gpu:0]/EnabledDisplays
+       #
+       #   will list the available displays on the given GPU.
+     
+       nvidia-settings -a [gpu:0]/FrameLockMaster=0x00000001
+       nvidia-settings -q [gpu:0]/FrameLockMaster
+     
+       # - Enable use of house sync signal
+       nvidia-settings -a [framelock:0]/FrameLockUseHouseSync=1
+     
+       # - Configure the house sync signal video mode
+       nvidia-settings -a [framelock:0]/FrameLockVideoMode=0
+     
+       # - Set the slave display device to none (to avoid
+       #   having unwanted display devices locked to the
+       #   sync signal.)
+       nvidia-settings -a [gpu:0]/FrameLockSlaves=0x00000000
+       nvidia-settings -q [gpu:0]/FrameLockSlaves
+     
+       # - Enable framelocking
+       nvidia-settings -a [gpu:0]/FrameLockEnable=1
+     
+       # - Toggle the test signal
+       nvidia-settings -a [gpu:0]/FrameLockTestSignal=1
+       nvidia-settings -a [gpu:0]/FrameLockTestSignal=0
+     
+     
+  2. 2 Systems, each with 2 GPUs, 1 Frame Lock board and 1 display device per
+     GPU syncing from the first system's first display device:
+     
+       # - Make sure frame lock sync is disabled
+       nvidia-settings -a myserver:0[gpu:0]/FrameLockEnable=0
+       nvidia-settings -a myserver:0[gpu:1]/FrameLockEnable=0
+       nvidia-settings -a myslave1:0[gpu:0]/FrameLockEnable=0
+       nvidia-settings -a myslave1:0[gpu:1]/FrameLockEnable=0
+     
+       # - Query the enabled displays on the GPUs
+       nvidia-settings -q myserver:0[gpu:0]/EnabledDisplays
+       nvidia-settings -q myserver:0[gpu:1]/EnabledDisplays
+       nvidia-settings -q myslave1:0[gpu:0]/EnabledDisplays
+       nvidia-settings -q myslave1:0[gpu:1]/EnabledDisplays
+     
+       # - Check the refresh rate is the same for all displays
+       nvidia-settings -q myserver:0[gpu:0]/RefreshRate
+       nvidia-settings -q myserver:0[gpu:1]/RefreshRate
+       nvidia-settings -q myslave1:0[gpu:0]/RefreshRate
+       nvidia-settings -q myslave1:0[gpu:1]/RefreshRate
+     
+       # - Make sure the display device we want as master is masterable
+       nvidia-settings -q myserver:0[gpu:0]/FrameLockMasterable
+     
+       # - Set the master display device (CRT-0)
+       nvidia-settings -a myserver:0[gpu:0]/FrameLockMaster=0x00000001
+     
+       # - Disable the house sync signal on the master device
+       nvidia-settings -a myserver:0[framelock:0]/FrameLockUseHouseSync=0
+     
+       # - Set the slave display devices
+       nvidia-settings -a myserver:0[gpu:1]/FrameLockSlaves=0x00000001
+       nvidia-settings -a myslave1:0[gpu:0]/FrameLockSlaves=0x00000001
+       nvidia-settings -a myslave1:0[gpu:1]/FrameLockSlaves=0x00000001
+     
+       # - Enable framelocking on server
+       nvidia-settings -a myserver:0[gpu:0]/FrameLockEnable=1
+     
+       # - Enable framelocking on slave devices
+       nvidia-settings -a myserver:0[gpu:1]/FrameLockEnable=1
+       nvidia-settings -a myslave1:0[gpu:0]/FrameLockEnable=1
+       nvidia-settings -a myslave1:0[gpu:1]/FrameLockEnable=1
+     
+       # - Toggle the test signal
+       nvidia-settings -a myserver:0[gpu:0]/FrameLockTestSignal=1
+       nvidia-settings -a myserver:0[gpu:0]/FrameLockTestSignal=0
+     
+     
+  3. 1 System, 4 GPUs, 2 Frame Lock boards and 2 display devices per GPU
+     syncing from the first GPU's display device:
+     
+       # - Make sure frame lock sync is disabled
+       nvidia-settings -a [gpu:0]/FrameLockEnable=0
+       nvidia-settings -a [gpu:1]/FrameLockEnable=0
+       nvidia-settings -a [gpu:2]/FrameLockEnable=0
+       nvidia-settings -a [gpu:3]/FrameLockEnable=0
+     
+       # - Query the enabled displays on the GPUs
+       nvidia-settings -q [gpu:0]/EnabledDisplays
+       nvidia-settings -q [gpu:1]/EnabledDisplays
+       nvidia-settings -q [gpu:2]/EnabledDisplays
+       nvidia-settings -q [gpu:3]/EnabledDisplays
+     
+       # - Check the refresh rate is the same for all displays
+       nvidia-settings -q [gpu:0]/RefreshRate
+       nvidia-settings -q [gpu:1]/RefreshRate
+       nvidia-settings -q [gpu:2]/RefreshRate
+       nvidia-settings -q [gpu:3]/RefreshRate
+     
+       # - Make sure the display device we want as master is masterable
+       nvidia-settings -q myserver:0[gpu:0]/FrameLockMasterable
+     
+       # - Set the master display device (CRT-0)
+       nvidia-settings -a [gpu:0]/FrameLockMaster=0x00000001
+     
+       # - Disable the house sync signal on the master device
+       nvidia-settings -a [framelock:0]/FrameLockUseHouseSync=1
+     
+       # - Set the slave display devices
+       nvidia-settings -a [gpu:0]/FrameLockSlaves=0x00000002 # CRT-1
+       nvidia-settings -a [gpu:1]/FrameLockSlaves=0x00000003 # CRT-0 and CRT-1
+       nvidia-settings -a [gpu:2]/FrameLockSlaves=0x00000003 # CRT-0 and CRT-1
+       nvidia-settings -a [gpu:3]/FrameLockSlaves=0x00000003 # CRT-0 and CRT-1
+     
+       # - Enable framelocking on master GPU
+       nvidia-settings -a [gpu:0]/FrameLockEnable=1
+     
+       # - Enable framelocking on slave devices
+       nvidia-settings -a [gpu:1]/FrameLockEnable=1
+       nvidia-settings -a [gpu:2]/FrameLockEnable=1
+       nvidia-settings -a [gpu:3]/FrameLockEnable=1
+     
+       # - Toggle the test signal
+       nvidia-settings -a [gpu:0]/FrameLockTestSignal=1
+       nvidia-settings -a [gpu:0]/FrameLockTestSignal=0
+     
+     
+
+
+21I. LEVERAGING FRAME LOCK/GENLOCK IN OPENGL
+
+With the GLX_NV_swap_group extension, OpenGL applications can be implemented
+to join a group of applications within a system for local swap sync, and bind
+the group to a barrier for swap sync across a frame lock group. A universal
+frame counter is also provided to promote synchronization across applications.
+
+
+21J. FRAME LOCK RESTRICTIONS:
+
+The following restrictions must be met for enabling frame lock:
+
+  1. All display devices set as client in a frame lock group must have the
+     same mode timings as the server (master) display device. If a House Sync
+     signal is used (instead of internal timings), all client display devices
+     must be set to have the same refresh rate as the incoming house sync
+     signal.
+
+  2. All X Screens (driving the selected client/server display devices) must
+     have the same stereo setting. See Appendix F for instructions on how to
+     set the stereo X option.
+
+  3. The frame lock server (master) display device must be on a GPU on the
+     primary connector to a G-Sync device.
+
+  4. If connecting a single GPU to a G-Sync device, the primary connector must
+     be used.
+
+  5. In configurations with more than one display device per GPU, we recommend
+     enabling frame lock on all display devices on those GPUs.
+
+
+
+21K. SUPPORTED FRAME LOCK CONFIGURATIONS:
+
+The following configurations are currently supported:
+
+  1. Basic Frame Lock: Single GPU, Single X Screen, Single Display Device with
+     or without OpenGL applications that make use of Quad-Buffered Stereo
+     and/or the GLX_NV_swap_group extension.
+
+  2. Frame Lock + TwinView: Single GPU, Single X Screen, Multiple Display
+     Devices with or without OpenGL applications that make use of
+     Quad-Buffered Stereo and/or the GLX_NV_swap_group extension.
+
+  3. Frame Lock + Xinerama: 1 or more GPU(s), Multiple X Screens, Multiple
+     Display Devices with or without OpenGL applications that make use of
+     Quad-Buffered Stereo and/or the GLX_NV_swap_group extension.
+
+  4. Frame Lock + TwinView + Xinerama: 1 or more GPU(s), Multiple X Screens,
+     Multiple Display Devices with or without OpenGL applications that make
+     use of Quad-Buffered Stereo and/or the GLX_NV_swap_group extension.
+
+  5. Frame Lock + SLI SFR, AFR, or AA: 2 GPUs, Single X Screen, Single Display
+     Device with either OpenGL applications that make use of Quad-Buffered
+     Stereo or the GLX_NV_swap_group extension. Note that for Frame Lock + SLI
+     Frame Rendering applications that make use of both Quad-Buffered Stereo
+     and the GLX_NV_swap_group extension are not supported. Note that only
+     2-GPU SLI configurations are currently supported.
+
+  6. Frame Lock + Multi-GPU SFR, AFR, or AA: 2 GPUs, Single X Screen, Single
+     Display Device with either OpenGL applications that make use of
+     Quad-Buffered Stereo or the GLX_NV_swap_group extension. Note that for
+     Frame Lock + Multi-GPU Frame Rendering applications that make use of both
+     Quad-Buffered Stereo and the GLX_NV_swap_group extension are not
+     supported.
+
+
+______________________________________________________________________________
+
+Chapter 22. Configuring Depth 30 Displays
+______________________________________________________________________________
+
+This driver release supports X screens with screen depths of 30 bits per pixel
+(10 bits per color component) on NVIDIA Quadro GPUs based on G80 and higher
+chip architectures. This provides about 1 billion possible colors, allowing
+for higher color precision and smoother gradients.
+
+When displaying a depth 30 image on a digital flat panel, the color data will
+be dithered to 8 or 6 bits per pixel, depending on the capabilities of the
+flat panel. VGA outputs can display the full 10 bit range of colors.
+
+To work reliably, depth 30 requires X.org 7.3 or higher.
+
+NOTE: X servers starting with X.org 7.3 rely on a library called libpixman to
+perform software rendering. As of this writing, the officially released
+version of this library will crash when it encouters depth 30 drawables. To be
+able to run X at this depth, you will need to download, compile, and install
+the "wide-composite" development branch from the freedesktop.org pixman git
+repository. Please see the freedesktop.org and git documentation for
+instructions on how to download and compile development branches.
+
+In addition to the above software requirements, many X applications and
+toolkits do not understand depth 30 visuals as of this writing. Some programs
+may work correctly, some may work but display incorrect colors, and some may
+simply fail to run. In particular, many OpenGL applications request 8 bits of
+alpha when searching for FBConfigs. Since depth 30 visuals have only 2 bits of
+alpha, no suitable FBConfigs will be found and such applications will fail to
+start.
+
+______________________________________________________________________________
+
+Chapter 23. NVIDIA Contact Info and Additional Resources
+______________________________________________________________________________
+
+If you believe that you have found a bug or have a problem that you need
+assitance with and cannot find the solution elsewhere, or if you have found
+innaccuracies in this document, send email to freebsd-gfx-bugs@nvidia.com
+
+
+
+Additional Resources
+
+XFree86 Video Timings HOWTO
+
+     http://www.tldp.org/HOWTO/XFree86-Video-Timings-HOWTO/index.html
+
+The X.Org Foundation
+
+     http://www.x.org/
+
+OpenGL
+
+     http://www.opengl.org/
+
+
+______________________________________________________________________________
+
+Chapter 24. Credits
+______________________________________________________________________________
+
+The port of the NVIDIA driver to FreeBSD is due in no small part to the many
+contributions of Christian Zander <zander 'at' mail.minion.de> and Matthew N.
+Dodd <mdodd 'at' freebsd.org>.
+
+______________________________________________________________________________
+
+Chapter 25. Acknowledgements
+______________________________________________________________________________
+
+The driver splash screen is decoded using 'libpng':
+http://libpng.org/pub/png/libpng.html
+
+This NVIDIA FreeBSD driver contains code from the int10 module of the X.Org
+project.
+
+The BSD implementations of the following compiler intrinsics are used for
+better portability: __udivdi3, __umoddi3, __moddi3, __ucmpdi2, __cmpdi2,
+__fixunssfdi, and __fixunsdfdi.
+
+______________________________________________________________________________
+
+Appendix E. Supported NVIDIA GPU Products
+______________________________________________________________________________
+
+For the most complete and accurate listing of supported GPUs, please see the
+Supported Products List, available from the NVIDIA FreeBSD x86 Graphics Driver
+download page. Please go to http://www.nvidia.com/object/unix.html, follow the
+Archive link under the FreeBSD x86 heading, follow the link for the 169.07
+driver, and then go to the Supported Products List.
+
+
+E1. NVIDIA GEFORCE GPUS
+
+
+    NVIDIA GPU product                                        Device PCI ID
+    ------------------------------------------------------    ---------------
+    GeForce 6800 Ultra                                        0x0040
+    GeForce 6800                                              0x0041
+    GeForce 6800 LE                                           0x0042
+    GeForce 6800 XE                                           0x0043
+    GeForce 6800 XT                                           0x0044
+    GeForce 6800 GT                                           0x0045
+    GeForce 6800 GT                                           0x0046
+    GeForce 6800 GS                                           0x0047
+    GeForce 6800 XT                                           0x0048
+    GeForce 7800 GTX                                          0x0090
+    GeForce 7800 GTX                                          0x0091
+    GeForce 7800 GT                                           0x0092
+    GeForce 7800 GS                                           0x0093
+    GeForce 7800 SLI                                          0x0095
+    GeForce Go 7800                                           0x0098
+    GeForce Go 7800 GTX                                       0x0099
+    GeForce 6800 GS                                           0x00C0
+    GeForce 6800                                              0x00C1
+    GeForce 6800 LE                                           0x00C2
+    GeForce 6800 XT                                           0x00C3
+    GeForce Go 6800                                           0x00C8
+    GeForce Go 6800 Ultra                                     0x00C9
+    GeForce 6800                                              0x00F0
+    GeForce 6600 GT                                           0x00F1
+    GeForce 6600                                              0x00F2
+    GeForce 6200                                              0x00F3
+    GeForce 6600 LE                                           0x00F4
+    GeForce 7800 GS                                           0x00F5
+    GeForce 6800 GS                                           0x00F6
+    GeForce 6800 Ultra                                        0x00F9
+    GeForce PCX 5750                                          0x00FA
+    GeForce PCX 5900                                          0x00FB
+    GeForce PCX 5300                                          0x00FC
+    GeForce 6600 GT                                           0x0140
+    GeForce 6600                                              0x0141
+    GeForce 6600 LE                                           0x0142
+    GeForce 6600 VE                                           0x0143
+    GeForce Go 6600                                           0x0144
+    GeForce 6610 XL                                           0x0145
+    GeForce Go 6600 TE/6200 TE                                0x0146
+    GeForce 6700 XL                                           0x0147
+    GeForce Go 6600                                           0x0148
+    GeForce Go 6600 GT                                        0x0149
+    GeForce 6200                                              0x014F
+    GeForce 6500                                              0x0160
+    GeForce 6200 TurboCache(TM)                               0x0161
+    GeForce 6200SE TurboCache(TM)                             0x0162
+    GeForce 6200 LE                                           0x0163
+    GeForce Go 6200                                           0x0164
+    GeForce Go 6400                                           0x0166
+    GeForce Go 6200                                           0x0167
+    GeForce Go 6400                                           0x0168
+    GeForce 6250                                              0x0169
+    GeForce 7100 GS                                           0x016A
+    GeForce 8800 GTX                                          0x0191
+    GeForce 8800 GTS                                          0x0193
+    GeForce 8800 Ultra                                        0x0194
+    Tesla C870                                                0x0197
+    GeForce 7350 LE                                           0x01D0
+    GeForce 7300 LE                                           0x01D1
+    GeForce 7300 SE/7200 GS                                   0x01D3
+    GeForce Go 7200                                           0x01D6
+    GeForce Go 7300                                           0x01D7
+    GeForce Go 7400                                           0x01D8
+    GeForce 7500 LE                                           0x01DD
+    GeForce 7300 GS                                           0x01DF
+    GeForce 6800                                              0x0211
+    GeForce 6800 LE                                           0x0212
+    GeForce 6800 GT                                           0x0215
+    GeForce 6800 XT                                           0x0218
+    GeForce 6200                                              0x0221
+    GeForce 6200 A-LE                                         0x0222
+    GeForce 6150                                              0x0240
+    GeForce 6150 LE                                           0x0241
+    GeForce 6100                                              0x0242
+    GeForce Go 6150                                           0x0244
+    GeForce Go 6100                                           0x0247
+    GeForce 7900 GTX                                          0x0290
+    GeForce 7900 GT/GTO                                       0x0291
+    GeForce 7900 GS                                           0x0292
+    GeForce 7950 GX2                                          0x0293
+    GeForce 7950 GX2                                          0x0294
+    GeForce 7950 GT                                           0x0295
+    GeForce Go 7950 GTX                                       0x0297
+    GeForce Go 7900 GS                                        0x0298
+    GeForce Go 7900 GTX                                       0x0299
+    GeForce 7600 GT                                           0x02E0
+    GeForce 7600 GS                                           0x02E1
+    GeForce 7900 GS                                           0x02E3
+    GeForce 7950 GT                                           0x02E4
+    GeForce FX 5800 Ultra                                     0x0301
+    GeForce FX 5800                                           0x0302
+    GeForce FX 5600 Ultra                                     0x0311
+    GeForce FX 5600                                           0x0312
+    GeForce FX 5600XT                                         0x0314
+    GeForce FX Go5600                                         0x031A
+    GeForce FX Go5650                                         0x031B
+    GeForce FX 5200                                           0x0320
+    GeForce FX 5200 Ultra                                     0x0321
+    GeForce FX 5200                                           0x0322
+    GeForce FX 5200LE                                         0x0323
+    GeForce FX Go5200                                         0x0324
+    GeForce FX Go5250                                         0x0325
+    GeForce FX 5500                                           0x0326
+    GeForce FX 5100                                           0x0327
+    GeForce FX Go5200 32M/64M                                 0x0328
+    GeForce FX Go53xx                                         0x032C
+    GeForce FX Go5100                                         0x032D
+    GeForce FX 5900 Ultra                                     0x0330
+    GeForce FX 5900                                           0x0331
+    GeForce FX 5900XT                                         0x0332
+    GeForce FX 5950 Ultra                                     0x0333
+    GeForce FX 5900ZT                                         0x0334
+    GeForce FX 5700 Ultra                                     0x0341
+    GeForce FX 5700                                           0x0342
+    GeForce FX 5700LE                                         0x0343
+    GeForce FX 5700VE                                         0x0344
+    GeForce FX Go5700                                         0x0347
+    GeForce FX Go5700                                         0x0348
+    GeForce 7650 GS                                           0x0390
+    GeForce 7600 GT                                           0x0391
+    GeForce 7600 GS                                           0x0392
+    GeForce 7300 GT                                           0x0393
+    GeForce 7600 LE                                           0x0394
+    GeForce 7300 GT                                           0x0395
+    GeForce Go 7600                                           0x0398
+    GeForce Go 7600 GT                                        0x0399
+    GeForce 6150SE nForce 430                                 0x03D0
+    GeForce 6100 nForce 405                                   0x03D1
+    GeForce 6100 nForce 400                                   0x03D2
+    GeForce 6100 nForce 420                                   0x03D5
+    GeForce 8600 GTS                                          0x0400
+    GeForce 8600 GT                                           0x0402
+    GeForce 8400 GS                                           0x0404
+    GeForce 8600M GT                                          0x0407
+    GeForce 8700M GT                                          0x0409
+    GeForce 8400 SE                                           0x0420
+    GeForce 8500 GT                                           0x0421
+    GeForce 8400 GS                                           0x0422
+    GeForce 8300 GS                                           0x0423
+    GeForce 8600M GS                                          0x0425
+    GeForce 8400M GT                                          0x0426
+    GeForce 8400M GS                                          0x0427
+    GeForce 8400M G                                           0x0428
+    GeForce 7150M / nForce 630M                               0x0531
+    GeForce 7000M / nForce 610M                               0x0533
+    GeForce 7050 PV / NVIDIA nForce 630a                      0x053A
+    GeForce 7050 PV / NVIDIA nForce 630a                      0x053B
+    GeForce 7025 / NVIDIA nForce 630a                         0x053E
+    GeForce 8800 GTS 512                                      0x0600
+    GeForce 8800M GTS                                         0x0609
+    GeForce 8800M GTX                                         0x060C
+    GeForce 8800 GT                                           0x0611
+
+
+
+E2. NVIDIA QUADRO GPUS
+
+
+    NVIDIA GPU product                                        Device PCI ID
+    ------------------------------------------------------    ---------------
+    Quadro FX 4000                                            0x004E
+    Quadro FX 4500                                            0x009D
+    Quadro FX Go1400                                          0x00CC
+    Quadro FX 3450/4000 SDI                                   0x00CD
+    Quadro FX 1400                                            0x00CE
+    Quadro FX 4400/Quadro FX 3400                             0x00F8
+    Quadro FX 330                                             0x00FC
+    Quadro NVS 280 PCI-E/Quadro FX 330                        0x00FD
+    Quadro FX 1300                                            0x00FE
+    Quadro NVS 440                                            0x014A
+    Quadro FX 540M                                            0x014C
+    Quadro FX 550                                             0x014D
+    Quadro FX 540                                             0x014E
+    Quadro NVS 285                                            0x0165
+    Quadro FX 5600                                            0x019D
+    Quadro FX 4600                                            0x019E
+    Quadro NVS 110M                                           0x01D7
+    Quadro NVS 110M                                           0x01DA
+    Quadro NVS 120M                                           0x01DB
+    Quadro FX 350M                                            0x01DC
+    Quadro FX 350                                             0x01DE
+    Quadro NVS 210S / NVIDIA GeForce 6150LE                   0x0245
+    Quadro FX 2500M                                           0x029A
+    Quadro FX 1500M                                           0x029B
+    Quadro FX 5500                                            0x029C
+    Quadro FX 3500                                            0x029D
+    Quadro FX 1500                                            0x029E
+    Quadro FX 4500 X2                                         0x029F
+    Quadro FX 2000                                            0x0308
+    Quadro FX 1000                                            0x0309
+    Quadro FX Go700                                           0x031C
+    Quadro NVS 55/280 PCI                                     0x032A
+    Quadro FX 500/FX 600                                      0x032B
+    Quadro FX 3000                                            0x0338
+    Quadro FX 700                                             0x033F
+    Quadro FX Go1000                                          0x034C
+    Quadro FX 1100                                            0x034E
+    Quadro FX 560                                             0x039E
+    Quadro FX 370                                             0x040A
+    Quadro NVS 320M                                           0x040B
+    Quadro FX 570M                                            0x040C
+    Quadro FX 1600M                                           0x040D
+    Quadro FX 570                                             0x040E
+    Quadro FX 1700                                            0x040F
+    Quadro NVS 140M                                           0x0429
+    Quadro NVS 130M                                           0x042A
+    Quadro NVS 135M                                           0x042B
+    Quadro FX 360M                                            0x042D
+    Quadro NVS 290                                            0x042F
+    Quadro FX 3700                                            0x061A
+
+
+Below are the legacy GPUs that are no longer supported in the unified driver.
+These GPUs will continue to be maintained through the special legacy NVIDIA
+GPU driver releases.
+
+The 96.43.xx driver supports the following set of GPUs:
+
+
+    NVIDIA GPU product                    Device PCI ID
+    ----------------------------------    ----------------------------------
+    GeForce2 MX/MX 400                    0x0110
+    GeForce2 MX 100/200                   0x0111
+    GeForce2 Go                           0x0112
+    Quadro2 MXR/EX/Go                     0x0113
+    GeForce4 MX 460                       0x0170
+    GeForce4 MX 440                       0x0171
+    GeForce4 MX 420                       0x0172
+    GeForce4 MX 440-SE                    0x0173
+    GeForce4 440 Go                       0x0174
+    GeForce4 420 Go                       0x0175
+    GeForce4 420 Go 32M                   0x0176
+    GeForce4 460 Go                       0x0177
+    Quadro4 550 XGL                       0x0178
+    GeForce4 440 Go 64M                   0x0179
+    Quadro NVS 400                        0x017A
+    Quadro4 500 GoGL                      0x017C
+    GeForce4 410 Go 16M                   0x017D
+    GeForce4 MX 440 with AGP8X            0x0181
+    GeForce4 MX 440SE with AGP8X          0x0182
+    GeForce4 MX 420 with AGP8X            0x0183
+    GeForce4 MX 4000                      0x0185
+    Quadro4 580 XGL                       0x0188
+    Quadro NVS 280 SD                     0x018A
+    Quadro4 380 XGL                       0x018B
+    Quadro NVS 50 PCI                     0x018C
+    GeForce2 Integrated GPU               0x01A0
+    GeForce4 MX Integrated GPU            0x01F0
+    GeForce3                              0x0200
+    GeForce3 Ti 200                       0x0201
+    GeForce3 Ti 500                       0x0202
+    Quadro DCC                            0x0203
+    GeForce4 Ti 4600                      0x0250
+    GeForce4 Ti 4400                      0x0251
+    GeForce4 Ti 4200                      0x0253
+    Quadro4 900 XGL                       0x0258
+    Quadro4 750 XGL                       0x0259
+    Quadro4 700 XGL                       0x025B
+    GeForce4 Ti 4800                      0x0280
+    GeForce4 Ti 4200 with AGP8X           0x0281
+    GeForce4 Ti 4800 SE                   0x0282
+    GeForce4 4200 Go                      0x0286
+    Quadro4 980 XGL                       0x0288
+    Quadro4 780 XGL                       0x0289
+    Quadro4 700 GoGL                      0x028C
+
+
+The 71.86.xx driver supports the following set of GPUs:
+
+
+    NVIDIA GPU product                    Device PCI ID
+    ----------------------------------    ----------------------------------
+    RIVA TNT                              0x0020
+    RIVA TNT2/TNT2 Pro                    0x0028
+    RIVA TNT2 Ultra                       0x0029
+    Vanta/Vanta LT                        0x002C
+    RIVA TNT2 Model 64/Model 64 Pro       0x002D
+    Aladdin TNT2                          0x00A0
+    GeForce 256                           0x0100
+    GeForce DDR                           0x0101
+    Quadro                                0x0103
+    GeForce2 GTS/GeForce2 Pro             0x0150
+    GeForce2 Ti                           0x0151
+    GeForce2 Ultra                        0x0152
+    Quadro2 Pro                           0x0153
+
+
+______________________________________________________________________________
+
+Appendix F. X Config Options
+______________________________________________________________________________
+
+The following driver options are supported by the NVIDIA X driver. They may be
+specified either in the Screen or Device sections of the X config file.
+
+X Config Options
+
+Option "NvAGP" "integer"
+
+    Configure AGP support. Integer argument can be one of:
+    
+        Value             Behavior
+        --------------    ---------------------------------------------------
+        0                 disable AGP
+        1                 use NVIDIA internal AGP support, if possible
+        2                 use AGPGART, if possible
+        3                 use any AGP support (try AGPGART, then NVIDIA AGP)
+    
+    Note that NVIDIA internal AGP support cannot work if AGPGART is either
+    statically compiled into your kernel or is built as a module and loaded
+    into your kernel. See Chapter 9 for details. Default: 3.
+
+Option "NoLogo" "boolean"
+
+    Disable drawing of the NVIDIA logo splash screen at X startup. Default:
+    the logo is drawn for screens with depth 24.
+
+Option "LogoPath" "string"
+
+    Sets the path to the PNG file to be used as the logo splash screen at X
+    startup. If the PNG file specified has a bKGD (background color) chunk,
+    then the screen is cleared to the color it specifies. Otherwise, the
+    screen is cleared to black. The logo file must be owned by root and must
+    not be writable by a non-root group. Note that a logo is only displayed
+    for screens with depth 24. Default: The built-in NVIDIA logo is used.
+
+Option "RenderAccel" "boolean"
+
+    Enable or disable hardware acceleration of the RENDER extension. Default:
+    hardware acceleration of the RENDER extension is enabled.
+
+Option "NoRenderExtension" "boolean"
+
+    Disable the RENDER extension. Other than recompiling it, the X server does
+    not seem to have another way of disabling this. Fortunately, we can
+    control this from the driver so we export this option. This is useful in
+    depth 8 where RENDER would normally steal most of the default colormap.
+    Default: RENDER is offered when possible.
+
+Option "UBB" "boolean"
+
+    Enable or disable the Unified Back Buffer on Quadro-based GPUs (Quadro4
+    NVS excluded); see Chapter 17 for a description of UBB. This option has no
+    effect on non-Quadro GPU products. Default: UBB is on for Quadro GPUs.
+
+Option "NoFlip" "boolean"
+
+    Disable OpenGL flipping; see Chapter 17 for a description. Default: OpenGL
+    will swap by flipping when possible.
+
+Option "Dac8Bit" "boolean"
+
+    Most Quadro products by default use a 10-bit color look-up table (LUT);
+    setting this option to TRUE forces these GPUs to use an 8-bit (LUT).
+    Default: a 10-bit LUT is used, when available.
+
+Option "Overlay" "boolean"
+
+    Enables RGB workstation overlay visuals. This is only supported on Quadro
+    GPUs (Quadro NVS GPUs excluded) in depth 24. This option causes the server
+    to advertise the SERVER_OVERLAY_VISUALS root window property and GLX will
+    report single- and double-buffered, Z-buffered 16-bit overlay visuals. The
+    transparency key is pixel 0x0000 (hex). There is no gamma correction
+    support in the overlay plane. This feature requires XFree86 version 4.1.0
+    or newer, or the X.Org X server. When TwinView is enabled, or the X screen
+    is either wider than 2046 pixels or taller than 2047, the overlay may be
+    emulated with a substantial performance penalty. RGB workstation overlays
+    are not supported when the Composite extension is enabled. Dynamic
+    TwinView is disabled when Overlays are enabled. Default: off.
+
+    UBB must be enabled when overlays are enabled (this is the default
+    behavior).
+
+Option "CIOverlay" "boolean"
+
+    Enables Color Index workstation overlay visuals with identical
+    restrictions to Option "Overlay" above. The server will offer visuals both
+    with and without a transparency key. These are depth 8 PseudoColor
+    visuals. Enabling Color Index overlays on X servers older than XFree86 4.3
+    will force the RENDER extension to be disabled due to bugs in the RENDER
+    extension in older X servers. Color Index workstation overlays are not
+    supported when the Composite extension is enabled. Default: off.
+
+    UBB must be enabled when overlays are enabled (this is the default
+    behavior).
+
+Option "TransparentIndex" "integer"
+
+    When color index overlays are enabled, use this option to choose which
+    pixel is used for the transparent pixel in visuals featuring transparent
+    pixels. This value is clamped between 0 and 255 (Note: some applications
+    such as Alias's Maya require this to be zero in order to work correctly).
+    Default: 0.
+
+Option "OverlayDefaultVisual" "boolean"
+
+    When overlays are used, this option sets the default visual to an overlay
+    visual thereby putting the root window in the overlay. This option is not
+    recommended for RGB overlays. Default: off.
+
+Option "EmulatedOverlaysTimerMs" "integer"
+
+    Enables the use of a timer within the X server to perform the updates to
+    the emulated overlay or CI overlay. This option can be used to improve the
+    performance of the emulated or CI overlays by reducing the frequency of
+    the updates. The value specified indicates the desired number of
+    milliseconds between overlay updates. To disable the use of the timer
+    either leave the option unset or set it to 0. Default: off.
+
+Option "EmulatedOverlaysThreshold" "boolean"
+
+    Enables the use of a threshold within the X server to perform the updates
+    to the emulated overlay or CI overlay. The emulated or CI overlay updates
+    can be defered but this threshold will limit the number of defered OpenGL
+    updates allowed before the overlay is updated. This option can be used to
+    trade off performance and animation quality. Default: on.
+
+Option "EmulatedOverlaysThresholdValue" "integer"
+
+    Controls the threshold used in updating the emulated or CI overlays. This
+    is used in conjunction with the EmulatedOverlaysThreshold option to trade
+    off performance and animation quality. Higher values for this option favor
+    performance over quality. Setting low values of this option will not cause
+    the overlay to be updated more often than the frequence specified by the
+    EmulatedOverlaysTimerMs option. Default: 5.
+
+Option "RandRRotation" "boolean"
+
+    Enable rotation support for the XRandR extension. This allows use of the
+    XRandR X server extension for configuring the screen orientation through
+    rotation. This feature is supported using depth 24. This requires an X.Org
+    X 6.8.1 or newer X server. This feature does not work with hardware
+    overlays; emulated overlays will be used instead at a substantial
+    performance penalty. See Chapter 14 for details. Default: off.
+
+Option "Rotate" "string"
+
+    Enable static rotation support. Unlike the RandRRotation option above,
+    this option takes effect as soon as the X server is started and will work
+    with older versions of X. This feature is supported using depth 24. This
+    feature does not work with hardware overlays; emulated overlays will be
+    used instead at a substantial performance penalty. This option is not
+    compatible with the RandR extension. Valid rotations are "normal", "left",
+    "inverted", and "right". Default: off.
+
+Option "AllowDDCCI" "boolean"
+
+    Enables DDC/CI support in the NV-CONTROL X extension. DDC/CI is a
+    mechanism for communication between your computer and your display device.
+    This can be used to set the values normally controlled through your
+    display device's On Screen Display. See the DDC/CI NV-CONTROL attributes
+    in 'NVCtrl.h' and functions in 'NVCtrlLib.h' in the 'nvidia-settings'
+    source code. Default: off (DDC/CI is disabled).
+
+Option "SWCursor" "boolean"
+
+    Enable or disable software rendering of the X cursor. Default: off.
+
+Option "HWCursor" "boolean"
+
+    Enable or disable hardware rendering of the X cursor. Default: on.
+
+Option "CursorShadow" "boolean"
+
+    Enable or disable use of a shadow with the hardware accelerated cursor;
+    this is a black translucent replica of your cursor shape at a given offset
+    from the real cursor. Default: off (no cursor shadow).
+
+Option "CursorShadowAlpha" "integer"
+
+    The alpha value to use for the cursor shadow; only applicable if
+    CursorShadow is enabled. This value must be in the range [0, 255] -- 0 is
+    completely transparent; 255 is completely opaque. Default: 64.
+
+Option "CursorShadowXOffset" "integer"
+
+    The offset, in pixels, that the shadow image will be shifted to the right
+    from the real cursor image; only applicable if CursorShadow is enabled.
+    This value must be in the range [0, 32]. Default: 4.
+
+Option "CursorShadowYOffset" "integer"
+
+    The offset, in pixels, that the shadow image will be shifted down from the
+    real cursor image; only applicable if CursorShadow is enabled. This value
+    must be in the range [0, 32]. Default: 2.
+
+Option "ConnectedMonitor" "string"
+
+    Allows you to override what the NVIDIA kernel module detects is connected
+    to your graphics card. This may be useful, for example, if you use a KVM
+    (keyboard, video, mouse) switch and you are switched away when X is
+    started. In such a situation, the NVIDIA kernel module cannot detect what
+    display devices are connected, and the NVIDIA X driver assumes you have a
+    single CRT.
+
+    Valid values for this option are "CRT" (cathode ray tube), "DFP" (digital
+    flat panel), or "TV" (television); if using TwinView, this option may be a
+    comma-separated list of display devices; e.g.: "CRT, CRT" or "CRT, DFP".
+
+    It is generally recommended to not use this option, but instead use the
+    "UseDisplayDevice" option.
+
+    NOTE: anything attached to a 15 pin VGA connector is regarded by the
+    driver as a CRT. "DFP" should only be used to refer to digital flat panels
+    connected via a DVI port.
+
+    Default: string is NULL (the NVIDIA driver will detect the connected
+    display devices).
+
+Option "UseDisplayDevice" "string"
+
+    When assigning display devices to X screens, the NVIDIA X driver by
+    default assigns display devices in the order they are found (looking first
+    at CRTs, then at DFPs, and finally at TVs). This option can be used to
+    override this assignment. For example, if both a CRT and a DFP are
+    connected, you could specify:
+    
+        Option "UseDisplayDevice" "DFP"
+    
+    to make the X screen use the DFP, even though it would have used a CRT by
+    default.
+
+    Note the subtle difference between this option and the "ConnectedMonitor"
+    option: the "ConnectedMonitor" option overrides what display devices are
+    actually detected, while the "UseDisplayDevice" option controls which of
+    the detected display devices will be used on this X screen.
+
+    Additionally, the special value "none" can be specified for the
+    "UseDisplayDevice" option. When this value is given, any programming of
+    the display hardware is disabled. The NVIDIA driver will not perform any
+    mode validation or modesetting for this X screen. This is intended for use
+    in conjunction with CUDA or in remote graphics solutions such as VNC or
+    Hewlett Packard's Remote Graphics Software (RGS). This functionality is
+    only available on Quadro and Tesla GPUs.
+
+    Note the following restrictions for setting the "UseDisplayDevice" to
+    "none":
+    
+       o OpenGL SyncToVBlank will have no effect.
+    
+       o You must also explicitly specify the Virtual screen size for your X
+         screen (see the xorg.conf(5x) or XF86Config(5x) manpages for the
+         'Virtual' option, or the nvidia-xconfig(1) manpage for the
+         '--virtual' commandline option); the Virtual screen size must be at
+         least 304x200, and the width must be a multiple of 8.
+    
+       o None of Stereo, Overlay, CIOverlay, or SLI are allowed when
+         "UseDisplayDevice" is set to "none".
+    
+    
+Option "UseEdidFreqs" "boolean"
+
+    This option controls whether the NVIDIA X driver will use the HorizSync
+    and VertRefresh ranges given in a display device's EDID, if any. When
+    UseEdidFreqs is set to True, EDID-provided range information will override
+    the HorizSync and VertRefresh ranges specified in the Monitor section. If
+    a display device does not provide an EDID, or the EDID does not specify an
+    hsync or vrefresh range, then the X server will default to the HorizSync
+    and VertRefresh ranges specified in the Monitor section of your X config
+    file. These frequency ranges are used when validating modes for your
+    display device.
+
+    Default: True (EDID frequencies will be used)
+
+Option "UseEDID" "boolean"
+
+    By default, the NVIDIA X driver makes use of a display device's EDID, when
+    available, during construction of its mode pool. The EDID is used as a
+    source for possible modes, for valid frequency ranges, and for collecting
+    data on the physical dimensions of the display device for computing the
+    DPI (see Appendix I). However, if you wish to disable the driver's use of
+    the EDID, you can set this option to False:
+    
+        Option "UseEDID" "FALSE"
+    
+    Note that, rather than globally disable all uses of the EDID, you can
+    individually disable each particular use of the EDID; e.g.,
+    
+        Option "UseEDIDFreqs" "FALSE"
+        Option "UseEDIDDpi" "FALSE"
+        Option "ModeValidation" "NoEdidModes"
+    
+    Default: True (use EDID).
+
+Option "IgnoreEDID" "boolean"
+
+    This option is deprecated, and no longer affects behavior of the X driver.
+    See the "UseEDID" option for details.
+
+Option "NoDDC" "boolean"
+
+    Synonym for "IgnoreEDID". This option is deprecated, and no longer affects
+    behavior of the X driver. See the "UseEDID" option for details.
+
+Option "UseInt10Module" "boolean"
+
+    Enable use of the X Int10 module to soft-boot all secondary cards, rather
+    than POSTing the cards through the NVIDIA kernel module. Default: off
+    (POSTing is done through the NVIDIA kernel module).
+
+Option "TwinView" "boolean"
+
+    Enable or disable TwinView. See Chapter 10 for details. Default: off
+    (TwinView is disabled).
+
+Option "TwinViewOrientation" "string"
+
+    Controls the relationship between the two display devices when using
+    TwinView. Takes one of the following values: "RightOf" "LeftOf" "Above"
+    "Below" "Clone". See Chapter 10 for details. Default: string is NULL.
+
+Option "SecondMonitorHorizSync" "range(s)"
+
+    This option is like the HorizSync entry in the Monitor section, but is for
+    the second monitor when using TwinView. See Chapter 10 for details.
+    Default: none.
+
+Option "SecondMonitorVertRefresh" "range(s)"
+
+    This option is like the VertRefresh entry in the Monitor section, but is
+    for the second monitor when using TwinView. See Chapter 10 for details.
+    Default: none.
+
+Option "MetaModes" "string"
+
+    This option describes the combination of modes to use on each monitor when
+    using TwinView. See Chapter 10 for details. Default: string is NULL.
+
+Option "NoTwinViewXineramaInfo" "boolean"
+
+    When in TwinView, the NVIDIA X driver normally provides a Xinerama
+    extension that X clients (such as window managers) can use to discover the
+    current TwinView configuration, such as where each display device is
+    positioned within the X screen. Some window mangers get confused by this
+    information, so this option is provided to disable this behavior. Default:
+    false (TwinView Xinerama information is provided).
+
+Option "TwinViewXineramaInfoOrder" "string"
+
+    When the NVIDIA X driver provides TwinViewXineramaInfo (see the
+    NoTwinViewXineramaInfo X config option), it by default reports the
+    currently enabled display devices in the order "CRT, DFP, TV". The
+    TwinViewXineramaInfoOrder X config option can be used to override this
+    order.
+
+    The option string is a comma-separated list of display device names. The
+    display device names can either be general (e.g, "CRT", which identifies
+    all CRTs), or specific (e.g., "CRT-1", which identifies a particular CRT).
+    Not all display devices need to be identified in the option string;
+    display devices that are not listed will be implicitly appended to the end
+    of the list, in their default order.
+
+    Note that TwinViewXineramaInfoOrder tracks all display devices that could
+    possibly be connected to the GPU, not just the ones that are currently
+    enabled. When reporting the Xinerama information, the NVIDIA X driver
+    walks through the display devices in the order specified, only reporting
+    enabled display devices.
+
+    Examples:
+    
+            "DFP"
+            "TV, DFP"
+            "DFP-1, DFP-0, TV, CRT"
+    
+    In the first example, any enabled DFPs would be reported first (any
+    enabled CRTs or TVs would be reported afterwards). In the second example,
+    any enabled TVs would be reported first, then any enabled DFPs (any
+    enabled CRTs would be reported last). In the last example, if DFP-1 were
+    enabled, it would be reported first, then DFP-0, then any enabled TVs, and
+    then any enabled CRTs; finally, any other enabled DFPs would be reported.
+
+    Default: "CRT, DFP, TV"
+
+Option "TwinViewXineramaInfoOverride" "string"
+
+    This option overrides the values reported by NVIDIA's TwinView Xinerama
+    implementation. This disregards the actual display devices used by the X
+    screen and any order specified in TwinViewXineramaInfoOrder.
+
+    The option string is interpreted as a comma-separated list of regions,
+    specified as '[width]x[height]+[xoffset]+[yoffset]'. The regions' sizes
+    and offsets are not validated against the X screen size, but are directly
+    reported to any Xinerama client.
+
+    Examples:
+    
+            "1600x1200+0+0, 1600x1200+1600+0"
+            "1024x768+0+0, 1024x768+1024+0, 1024x768+0+768, 1024x768+1024+768"
+    
+    
+Option "TVStandard" "string"
+
+    See Chapter 13 for details on configuring TV-out.
+
+Option "TVOutFormat" "string"
+
+    See Chapter 13 for details on configuring TV-out.
+
+Option "TVOverScan" "Decimal value in the range 0.0 to 1.0"
+
+    Valid values are in the range 0.0 through 1.0; See Chapter 13 for details
+    on configuring TV-out.
+
+Option "Stereo" "integer"
+
+    Enable offering of quad-buffered stereo visuals on Quadro. Integer
+    indicates the type of stereo equipment being used:
+    
+        Value             Equipment
+        --------------    ---------------------------------------------------
+        1                 DDC glasses. The sync signal is sent to the
+                          glasses via the DDC signal to the monitor. These
+                          usually involve a passthrough cable between the
+                          monitor and the graphics card. This mode is not
+                          available on G8xGL and higher GPUs.
+        2                 "Blueline" glasses. These usually involve a
+                          passthrough cable between the monitor and graphics
+                          card. The glasses know which eye to display based
+                          on the length of a blue line visible at the bottom
+                          of the screen. When in this mode, the root window
+                          dimensions are one pixel shorter in the Y
+                          dimension than requested. This mode does not work
+                          with virtual root window sizes larger than the
+                          visible root window size (desktop panning). This
+                          mode is not available on G8xGL and higher GPUs.
+        3                 Onboard stereo support. This is usually only found
+                          on professional cards. The glasses connect via a
+                          DIN connector on the back of the graphics card.
+        4                 TwinView clone mode stereo (aka "passive" stereo).
+                          On graphics cards that support TwinView, the left
+                          eye is displayed on the first display, and the
+                          right eye is displayed on the second display. This
+                          is normally used in conjunction with special
+                          projectors to produce 2 polarized images which are
+                          then viewed with polarized glasses. To use this
+                          stereo mode, you must also configure TwinView in
+                          clone mode with the same resolution, panning
+                          offset, and panning domains on each display.
+        5                 Vertical interlaced stereo mode, for use with
+                          SeeReal Stereo Digital Flat Panels.
+        6                 Color interleaved stereo mode, for use with
+                          Sharp3D Stereo Digital Flat Panels.
+    
+    Stereo is only available on Quadro cards. Stereo options 1, 2, and 3 (aka
+    "active" stereo) may be used with TwinView if all modes within each
+    MetaMode have identical timing values. See Chapter 16 for suggestions on
+    making sure the modes within your MetaModes are identical. The identical
+    ModeLine requirement is not necessary for Stereo option 4 ("passive"
+    stereo). Currently, stereo operation may be "quirky" on the original
+    Quadro (NV10) GPU and left-right flipping may be erratic. We are trying to
+    resolve this issue for a future release. Default: 0 (Stereo is not
+    enabled).
+
+    UBB must be enabled when stereo is enabled (this is the default behavior).
+
+    Stereo options 1, 2, and 3 (aka "active" stereo) are not supported on
+    digital flat panels.
+
+    Multi-GPU cards (such as the Quadro FX 4500 X2) provide a single connector
+    for onboard stereo support (option 3), which is tied to the bottommost
+    GPU. In order to synchronize onboard stereo with the other GPU, you must
+    use a G-Sync device (see Chapter 21 for details).
+
+Option "AllowDFPStereo" "boolean"
+
+    By default, the NVIDIA X driver performs a check which disables active
+    stereo (stereo options 1, 2, and 3) if the X screen is driving a DFP. The
+    "AllowDFPStereo" option bypasses this check.
+
+Option "ForceStereoFlipping" "boolean"
+
+    Stereo flipping is the process by which left and right eyes are displayed
+    on alternating vertical refreshes. Normally, stereo flipping is only
+    performed when a stereo drawable is visible. This option forces stereo
+    flipping even when no stereo drawables are visible.
+
+    This is to be used in conjunction with the "Stereo" option. If "Stereo" is
+    0, the "ForceStereoFlipping" option has no effect. If otherwise, the
+    "ForceStereoFlipping" option will force the behavior indicated by the
+    "Stereo" option, even if no stereo drawables are visible. This option is
+    useful in a multiple-screen environment in which a stereo application is
+    run on a different screen than the stereo master.
+
+    Possible values:
+    
+        Value             Behavior
+        --------------    ---------------------------------------------------
+        0                 Stereo flipping is not forced. The default
+                          behavior as indicated by the "Stereo" option is
+                          used.
+        1                 Stereo flipping is forced. Stereo is running even
+                          if no stereo drawables are visible. The stereo
+                          mode depends on the value of the "Stereo" option.
+    
+    Default: 0 (Stereo flipping is not forced). Note that active stereo is not
+    supported on digital flat panels.
+
+Option "XineramaStereoFlipping" "boolean"
+
+    By default, when using Stereo with Xinerama, all physical X screens having
+    a visible stereo drawable will stereo flip. Use this option to allow only
+    one physical X screen to stereo flip at a time.
+
+    This is to be used in conjunction with the "Stereo" and "Xinerama"
+    options. If "Stereo" is 0 or "Xinerama" is 0, the "XineramaStereoFlipping"
+    option has no effect.
+
+    If you wish to have all X screens stereo flip all the time, see the
+    "ForceStereoFlipping" option.
+
+    Possible values:
+    
+        Value             Behavior
+        --------------    ---------------------------------------------------
+        0                 Stereo flipping is enabled on one X screen at a
+                          time. Stereo is enabled on the first X screen
+                          having the stereo drawable.
+        1                 Stereo flipping in enabled on all X screens.
+    
+    Default: 1 (Stereo flipping is enabled on all X screens).
+
+Option "NoBandWidthTest" "boolean"
+
+    As part of mode validation, the X driver tests if a given mode fits within
+    the hardware's memory bandwidth constraints. This option disables this
+    test. Default: false (the memory bandwidth test is performed).
+
+Option "IgnoreDisplayDevices" "string"
+
+    This option tells the NVIDIA kernel module to completely ignore the
+    indicated classes of display devices when checking what display devices
+    are connected. You may specify a comma-separated list containing any of
+    "CRT", "DFP", and "TV". For example:
+    
+    Option "IgnoreDisplayDevices" "DFP, TV"
+    
+    will cause the NVIDIA driver to not attempt to detect if any digital flat
+    panels or TVs are connected. This option is not normally necessary;
+    however, some video BIOSes contain incorrect information about what
+    display devices may be connected, or what i2c port should be used for
+    detection. These errors can cause long delays in starting X. If you are
+    experiencing such delays, you may be able to avoid this by telling the
+    NVIDIA driver to ignore display devices which you know are not connected.
+    NOTE: anything attached to a 15 pin VGA connector is regarded by the
+    driver as a CRT. "DFP" should only be used to refer to digital flat panels
+    connected via a DVI port.
+
+Option "MultisampleCompatibility" "boolean"
+
+    Enable or disable the use of separate front and back multisample buffers.
+    Enabling this will consume more memory but is necessary for correct output
+    when rendering to both the front and back buffers of a multisample or FSAA
+    drawable. This option is necessary for correct operation of SoftImage XSI.
+    Default: false (a single multisample buffer is shared between the front
+    and back buffers).
+
+Option "NoPowerConnectorCheck" "boolean"
+
+    The NVIDIA X driver will abort X server initialization if it detects that
+    a GPU that requires an external power connector does not have an external
+    power connector plugged in. This option can be used to bypass this test.
+    Default: false (the power connector test is performed).
+
+Option "XvmcUsesTextures" "boolean"
+
+    Forces XvMC to use the 3D engine for XvMCPutSurface requests rather than
+    the video overlay. Default: false (video overlay is used when available).
+
+Option "AllowGLXWithComposite" "boolean"
+
+    Enables GLX even when the Composite X extension is loaded. ENABLE AT YOUR
+    OWN RISK. OpenGL applications will not display correctly in many
+    circumstances with this setting enabled.
+
+    This option is intended for use on X.Org X servers older than X11R6.9.0.
+    On X11R6.9.0 or newer X servers, the NVIDIA OpenGL implementation
+    interacts properly by default with the Composite X extension and this
+    option should not be needed. However, on X11R6.9.0 or newer X servers,
+    support for GLX with Composite can be disabled by setting this option to
+    False.
+
+    Default: false (GLX is disabled when Composite is enabled on X servers
+    older than X11R6.9.0).
+
+Option "UseCompositeWrapper" "boolean"
+
+    Enables the X server's "composite wrapper", which performs coordinate
+    translations necessary for the Composite extension.
+
+    Default: false (the NVIDIA X driver performs its own coordinate
+    translation).
+
+Option "AddARGBGLXVisuals" "boolean"
+
+    Adds a 32-bit ARGB visual for each supported OpenGL configuration. This
+    allows applications to use OpenGL to render with alpha transparency into
+    32-bit windows and pixmaps. This option requires the Composite extension.
+    Default: ARGB GLX visuals are enabled on X servers new enough to support
+    them when the Composite extension is also enabled.
+
+Option "DisableGLXRootClipping" "boolean"
+
+    If enabled, no clipping will be performed on rendering done by OpenGL in
+    the root window. This option is deprecated. It is needed by older versions
+    of OpenGL-based composite managers that draw the contents of redirected
+    windows directly into the root window using OpenGL. Most OpenGL-based
+    composite managers have been updated to support the Composite Overlay
+    Window, a feature introduced in Xorg release 7.1. Using the Composite
+    Overlay Window is the preferred method for performing OpenGL-based
+    compositing.
+
+Option "DamageEvents" "boolean"
+
+    Use OS-level events to efficiently notify X when a client has performed
+    direct rendering to a window that needs to be composited. This will
+    significantly improve performance and interactivity when using GLX
+    applications with a composite manager running. It will also affect
+    applications using GLX when rotation is enabled. This option is currently
+    incompatible with SLI and Multi-GPU modes and will be disabled if either
+    are used. Enabled by default.
+
+Option "ExactModeTimingsDVI" "boolean"
+
+    Forces the initialization of the X server with the exact timings specified
+    in the ModeLine. Default: false (for DVI devices, the X server initializes
+    with the closest mode in the EDID list).
+
+Option "Coolbits" "integer"
+
+    Enables various unsupported features, such as support for GPU clock
+    manipulation in the NV-CONTROL X extension. This option accepts a bit mask
+    of features to enable.
+
+    When "1" (Bit 0) is set in the "Coolbits" option value, the
+    nvidia-settings utility will contain a page labeled "Clock Frequencies"
+    through which clock settings can be manipulated. "Coolbits" is only
+    available on GeForce FX, Quadro FX and newer desktop GPUs. On GeForce FX
+    and newer mobile GPUs, limited clock manipulation support is available
+    when "1" is set in the "Coolbits" option value: clocks can be lowered
+    relative to the default settings; overclocking is not supported due to the
+    thermal constraints of notebook designs.
+
+    WARNING: this may cause system damage and void warranties. This utility
+    can run your computer system out of the manufacturer's design
+    specifications, including, but not limited to: higher system voltages,
+    above normal temperatures, excessive frequencies, and changes to BIOS that
+    may corrupt the BIOS. Your computer's operating system may hang and result
+    in data loss or corrupted images. Depending on the manufacturer of your
+    computer system, the computer system, hardware and software warranties may
+    be voided, and you may not receive any further manufacturer support.
+    NVIDIA does not provide customer service support for the Coolbits option.
+    It is for these reasons that absolutely no warranty or guarantee is either
+    express or implied. Before enabling and using, you should determine the
+    suitability of the utility for your intended use, and you shall assume all
+    responsibility in connection therewith.
+
+    When "2" (Bit 1) is set in the "Coolbits" option value, the NVIDIA driver
+    will attempt to initialize SLI when using GPUs with different amounts of
+    video memory.
+
+    The default for this option is 0 (unsupported features are disabled).
+
+Option "MultiGPU" "string"
+
+    This option controls the configuration of Multi-GPU rendering in supported
+    configurations.
+    
+        Value                               Behavior
+        --------------------------------    --------------------------------
+        0, no, off, false, Single           Use only a single GPU when
+                                            rendering
+        1, yes, on, true, Auto              Enable Multi-GPU and allow the
+                                            driver to automatically select
+                                            the appropriate rendering mode.
+        AFR                                 Enable Multi-GPU and use the
+                                            Alternate Frame Rendering mode.
+        SFR                                 Enable Multi-GPU and use the
+                                            Split Frame Rendering mode.
+        AA                                  Enable Multi-GPU and use
+                                            antialiasing. Use this in
+                                            conjunction with full scene
+                                            antialiasing to improve visual
+                                            quality.
+    
+    
+Option "SLI" "string"
+
+    This option controls the configuration of SLI rendering in supported
+    configurations.
+    
+        Value                               Behavior
+        --------------------------------    --------------------------------
+        0, no, off, false, Single           Use only a single GPU when
+                                            rendering
+        1, yes, on, true, Auto              Enable SLI and allow the driver
+                                            to automatically select the
+                                            appropriate rendering mode.
+        AFR                                 Enable SLI and use the Alternate
+                                            Frame Rendering mode.
+        SFR                                 Enable SLI and use the Split
+                                            Frame Rendering mode.
+        AA                                  Enable SLI and use SLI
+                                            Antialiasing. Use this in
+                                            conjunction with full scene
+                                            antialiasing to improve visual
+                                            quality.
+        AFRofAA                             Enable SLI and use SLI Alternate
+                                            Frame Rendering of Antialiasing
+                                            mode. Use this in conjunction
+                                            with full scene antialiasing to
+                                            improve visual quality. This
+                                            option is only valid for SLI
+                                            configurations with 4 GPUs.
+    
+    
+Option "TripleBuffer" "boolean"
+
+    Enable or disable the use of triple buffering. If this option is enabled,
+    OpenGL windows that sync to vblank and are double-buffered will be given a
+    third buffer. This decreases the time an application stalls while waiting
+    for vblank events, but increases latency slightly (delay between user
+    input and displayed result).
+
+Option "DPI" "string"
+
+    This option specifies the Dots Per Inch for the X screen; for example:
+    
+        Option "DPI" "75 x 85"
+    
+    will set the horizontal DPI to 75 and the vertical DPI to 85. By default,
+    the X driver will compute the DPI of the X screen from the EDID of any
+    connected display devices. See Appendix I for details. Default: string is
+    NULL (disabled).
+
+Option "UseEdidDpi" "string"
+
+    By default, the NVIDIA X driver computes the DPI of an X screen based on
+    the physical size of the display device, as reported in the EDID, and the
+    size in pixels of the first mode to be used on the display device. If
+    multiple display devices are used by the X screen, then the NVIDIA X
+    screen will choose which display device to use. This option can be used to
+    specify which display device to use. The string argument can be a display
+    device name, such as:
+    
+        Option "UseEdidDpi" "DFP-0"
+    
+    or the argument can be "FALSE" to disable use of EDID-based DPI
+    calculations:
+    
+        Option "UseEdidDpi" "FALSE"
+    
+    See Appendix I for details. Default: string is NULL (the driver computes
+    the DPI from the EDID of a display device and selects the display device).
+
+Option "ConstantDPI" "boolean"
+
+    By default on X.Org 6.9 or newer X servers, the NVIDIA X driver recomputes
+    the size in millimeters of the X screen whenever the size in pixels of the
+    X screen is changed using XRandR, such that the DPI remains constant.
+
+    This behavior can be disabled (which means that the size in millimeters
+    will not change when the size in pixels of the X screen changes) by
+    setting the "ConstantDPI" option to "FALSE"; e.g.,
+    
+        Option "ConstantDPI" "FALSE"
+    
+    ConstantDPI defaults to True.
+
+    On X servers older than X.Org 6.9, the NVIDIA X driver cannot change the
+    size in millimeters of the X screen. Therefore the DPI of the X screen
+    will change when XRandR changes the size in pixels of the X screen. The
+    driver will behave as if ConstantDPI was forced to FALSE.
+
+Option "CustomEDID" "string"
+
+    This option forces the X driver to use the EDID specified in a file rather
+    than the display's EDID. You may specify a semicolon separated list of
+    display names and filename pairs. The display name is any of "CRT-0",
+    "CRT-1", "DFP-0", "DFP-1", "TV-0", "TV-1". The file contains a raw EDID
+    (e.g., a file generated by nvidia-settings).
+
+    For example:
+    
+        Option "CustomEDID" "CRT-0:/tmp/edid1.bin; DFP-0:/tmp/edid2.bin"
+    
+    will assign the EDID from the file /tmp/edid1.bin to the display device
+    CRT-0, and the EDID from the file /tmp/edid2.bin to the display device
+    DFP-0. Note that a display device name must always be specified even if
+    only one EDID is specified.
+
+Option "ModeValidation" "string"
+
+    This option provides fine-grained control over each stage of the mode
+    validation pipeline, disabling individual mode validation checks. This
+    option should only very rarely be used.
+
+    The option string is a semicolon-separated list of comma-separated lists
+    of mode validation arguments. Each list of mode validation arguments can
+    optionally be prepended with a display device name.
+    
+        "<dpy-0>: <tok>, <tok>; <dpy-1>: <tok>, <tok>, <tok>; ..."
+    
+    
+    Possible arguments:
+    
+       o "AllowNon60HzDFPModes": some lower quality TMDS encoders are only
+         rated to drive DFPs at 60Hz; the driver will determine when only 60Hz
+         DFP modes are allowed. This argument disables this stage of the mode
+         validation pipeline.
+    
+       o "NoMaxPClkCheck": each mode has a pixel clock; this pixel clock is
+         validated against the maximum pixel clock of the hardware (for a DFP,
+         this is the maximum pixel clock of the TMDS encoder, for a CRT, this
+         is the maximum pixel clock of the DAC). This argument disables the
+         maximum pixel clock checking stage of the mode validation pipeline.
+    
+       o "NoEdidMaxPClkCheck": a display device's EDID can specify the maximum
+         pixel clock that the display device supports; a mode's pixel clock is
+         validated against this pixel clock maximum. This argument disables
+         this stage of the mode validation pipeline.
+    
+       o "AllowInterlacedModes": interlaced modes are not supported on all
+         NVIDIA GPUs; the driver will discard interlaced modes on GPUs where
+         interlaced modes are not supported; this argument disables this stage
+         of the mode validation pipeline.
+    
+       o "NoMaxSizeCheck": each NVIDIA GPU has a maximum resolution that it
+         can drive; this argument disables this stage of the mode validation
+         pipeline.
+    
+       o "NoHorizSyncCheck": a mode's horizontal sync is validated against the
+         range of valid horizontal sync values; this argument disables this
+         stage of the mode validation pipeline.
+    
+       o "NoVertRefreshCheck": a mode's vertical refresh rate is validated
+         against the range of valid vertical refresh rate values; this
+         argument disables this stage of the mode validation pipeline.
+    
+       o "NoWidthAlignmentCheck": the alignment of a mode's visible width is
+         validated against the capabilities of the GPU; normally, a mode's
+         visible width must be a multiple of 8. This argument disables this
+         stage of the mode validation pipeline.
+    
+       o "NoDFPNativeResolutionCheck": when validating for a DFP, a mode's
+         size is validated against the native resolution of the DFP; this
+         argument disables this stage of the mode validation pipeline.
+    
+       o "NoVirtualSizeCheck": if the X configuration file requests a specific
+         virtual screen size, a mode cannot be larger than that virtual size;
+         this argument disables this stage of the mode validation pipeline.
+    
+       o "NoVesaModes": when constructing the mode pool for a display device,
+         the X driver uses a built-in list of VESA modes as one of the mode
+         sources; this argument disables use of these built-in VESA modes.
+    
+       o "NoEdidModes": when constructing the mode pool for a display device,
+         the X driver uses any modes listed in the display device's EDID as
+         one of the mode sources; this argument disables use of EDID-specified
+         modes.
+    
+       o "NoXServerModes": when constructing the mode pool for a display
+         device, the X driver uses the built-in modes provided by the core
+         XFree86/Xorg X server as one of the mode sources; this argument
+         disables use of these modes. Note that this argument does not disable
+         custom ModeLines specified in the X config file; see the
+         "NoCustomModes" argument for that.
+    
+       o "NoCustomModes": when constructing the mode pool for a display
+         device, the X driver uses custom ModeLines specified in the X config
+         file (through the "Mode" or "ModeLine" entries in the Monitor
+         Section) as one of the mode sources; this argument disables use of
+         these modes.
+    
+       o "NoPredefinedModes": when constructing the mode pool for a display
+         device, the X driver uses additional modes predefined by the NVIDIA X
+         driver; this argument disables use of these modes.
+    
+       o "NoUserModes": additional modes can be added to the mode pool
+         dynamically, using the NV-CONTROL X extension; this argument
+         prohibits user-specified modes via the NV-CONTROL X extension.
+    
+       o "NoExtendedGpuCapabilitiesCheck": allow mode timings that may exceed
+         the GPU's extended capability checks.
+    
+       o "ObeyEdidContradictions": an EDID may contradict itself by listing a
+         mode as supported, but the mode may exceed an EDID-specified valid
+         frequency range (HorizSync, VertRefresh, or maximum pixel clock).
+         Normally, the NVIDIA X driver prints a warning in this scenario, but
+         does not invalidate an EDID-specified mode just because it exceeds an
+         EDID-specified valid frequency range. However, the
+         "ObeyEdidContradictions" argument instructs the NVIDIA X driver to
+         invalidate these modes.
+    
+       o "NoTotalSizeCheck": allow modes in which the invididual visible or
+         sync pulse timings exceed the total raster size.
+    
+       o "DoubleScanPriority": on GPUs older than G80, doublescan modes are
+         sorted before non-doublescan modes of the same resolution for
+         purposes of modepool sorting; but on G80 and later GPUs, doublescan
+         modes are sorted after non-doublescan modes of the same resolution.
+         This token inverts that priority (i.e., doublescan modes will be
+         sorted after on pre-G80 GPUs, and sorted before on G80 and later
+         GPUs).
+    
+    
+    Examples:
+    
+        Option "ModeValidation" "NoMaxPClkCheck"
+    
+    disable the maximum pixel clock check when validating modes on all display
+    devices.
+    
+        Option "ModeValidation" "CRT-0: NoEdidModes, NoMaxPClkCheck; DFP-0:
+    NoVesaModes"
+    
+    do not use EDID modes and do not perform the maximum pixel clock check on
+    CRT-0, and do not use VESA modes on DFP-0.
+
+Option "UseEvents" "boolean"
+
+    Enables the use of system events in some cases when the X driver is
+    waiting for the hardware. The X driver can briefly spin through a tight
+    loop when waiting for the hardware. With this option the X driver instead
+    sets an event handler and waits for the hardware through the 'poll()'
+    system call. Default: the use of the events is disabled.
+
+Option "FlatPanelProperties" "string"
+
+    This option requests particular properties for all or a subset of the
+    connected flat panels.
+
+    The option string is a semicolon-separated list of comma-separated
+    property=value pairs. Each list of property=value pairs can optionally be
+    prepended with a flat panel name.
+    
+        "<DFP-0>: <property=value>, <property=value>; <DFP-1>:
+    <property=value>; ..."
+    
+    
+    Recognized properties:
+    
+       o "Scaling": controls the flat panel scaling mode; possible values are:
+         'Default' (the driver will use whichever scaling state is current),
+         'Native' (the driver will use the flat panel's scaler, if possible),
+         'Scaled' (the driver will use the NVIDIA GPU's scaler, if possible),
+         'Centered' (the driver will center the image, if possible), and
+         'aspect-scaled' (the X driver will scale with the NVIDIA GPU's
+         scaler, but keep the aspect ratio correct).
+    
+       o "Dithering": controls the flat panel dithering mode; possible values
+         are: 'Default' (the driver will decide when to dither), 'Enabled'
+         (the driver will always dither, if possible), and 'Disabled' (the
+         driver will never dither).
+    
+    
+    Examples:
+    
+        Option "FlatPanelProperties" "Scaling = Centered"
+    
+    set the flat panel scaling mode to centered on all flat panels.
+    
+        Option "FlatPanelProperties" "DFP-0: Scaling = Centered; DFP-1:
+    Scaling = Scaled, Dithering = Enabled"
+    
+    set DFP-0's scaling mode to centered, set DFP-1's scaling mode to scaled
+    and its dithering mode to enabled.
+
+Option "ProbeAllGpus" "boolean"
+
+    When the NVIDIA X driver initializes, it probes all GPUs in the system,
+    even if no X screens are configured on them. This is done so that the X
+    driver can report information about all the system's GPUs through the
+    NV-CONTROL X extension. This option can be set to FALSE to disable this
+    behavior, such that only GPUs with X screens configured on them will be
+    probed. Default: all GPUs in the system are probed.
+
+Option "DynamicTwinView" "boolean"
+
+    Enable or disable support for dynamically configuring TwinView on this X
+    screen. When DynamicTwinView is enabled (the default), the refresh rate of
+    a mode (reported through XF86VidMode or XRandR) does not correctly report
+    the refresh rate, but instead is a unique number such that each MetaMode
+    has a different value. This is to guarantee that MetaModes can be uniquely
+    identified by XRandR.
+
+    When DynamicTwinView is disabled, the refresh rate reported through XRandR
+    will be accurate, but NV-CONTROL clients such as nvidia-settings will not
+    be able to dynamically manipulate the X screen's MetaModes. TwinView can
+    still be configured from the X config file when DynamicTwinView is
+    disabled.
+
+    Default: DynamicTwinView is enabled.
+
+Option "IncludeImplicitMetaModes" "boolean"
+
+    When the X server starts, a mode pool is created per display device,
+    containing all the mode timings that the NVIDIA X driver determined to be
+    valid for the display device. However, the only MetaModes that are made
+    available to the X server are the ones explicitly requested in the X
+    configuration file.
+
+    It is convenient for fullscreen applications to be able to change between
+    the modes in the mode pool, even if a given target mode was not explicitly
+    requested in the X configuration file.
+
+    To facilitate this, the NVIDIA X driver will, if only one display device
+    is in use when the X server starts, implicitly add MetaModes for all modes
+    in the display device's mode pool. This makes all the modes in the mode
+    pool available to full screen applications that use the XF86VidMode or
+    XRandR X extensions.
+
+    To prevent this behavior, and only add MetaModes that are explicitly
+    requested in the X configuration file, set this option to FALSE.
+
+    Default: IncludeImplicitMetaModes is enabled.
+
+Option "AllowIndirectPixmaps" "boolean"
+
+    Some graphics cards have more video memory than can be mapped at once by
+    the CPU (generally only 256 MB of video memory can be CPU-mapped). On
+    graphics cards based on G80 and higher with such a memory configuration,
+    this option allows the driver to place more pixmaps in video memory which
+    will improve hardware rendering performance but will slow down software
+    rendering. On some systems, up to 768 megabytes of virtual address space
+    will be reserved in the X server for indirect pixmap access. This virtual
+    memory does not consume any physical resources.
+
+    Default: on (indirect pixmaps will be used, when available).
+
+Option "OnDemandVBlankInterrupts" "boolean"
+
+    Normally, VBlank interrupts are generated on every vertical refresh of
+    every display device connected to the GPU(s) installed in a given system.
+    This experimental option enables on-demand VBlank control, allowing the
+    driver to enable VBlank interrupt generation only when it is required.
+    This can help conserve power.
+
+    Default: off (on-demand VBlank control is disabled).
+
+
+______________________________________________________________________________
+
+Appendix G. Display Device Names
+______________________________________________________________________________
+
+A "display device" refers to some piece of hardware capable of displaying an
+image. There are three categories of display devices: analog displays (i.e.,
+CRTs), digital displays (i.e., digital flat panels (DFPs)), and televisions.
+Note that analog flat panels are considered the same as analog CRTs by the
+NVIDIA FreeBSD driver.
+
+A "display device name" is a string description that uniquely identifies a
+display device; it follows the format "<type>-<number>", for example: "CRT-0",
+"CRT-1", "DFP-0", or "TV-0". Note that the number indicates how the display
+device connector is wired on the graphics card, and has nothing to do with how
+many of that kind of display device are present. This means, for example, that
+you may have a "CRT-1", even if you do not have a "CRT-0". To determine which
+display devices are currently connected, you may check your X log file for a
+line similar to the following:
+
+    (II) NVIDIA(0): Connected display device(s): CRT-0, DFP-0
+
+Display device names can be used in the MetaMode, HorizSync, and VertRefresh X
+config options to indicate which display device a setting should be applied
+to. For example:
+
+    Option "MetaModes"   "CRT-0: 1600x1200,  DFP-0: 1024x768"
+    Option "HorizSync"   "CRT-0: 50-110;     DFP-0: 40-70"
+    Option "VertRefresh" "CRT-0: 60-120;     DFP-0: 60"
+
+Specifying the display device name in these options is not required; if
+display device names are not specified, then the driver attempts to infer
+which display device a setting applies to. In the case of MetaModes, for
+example, the first mode listed is applied to the "first" display device, and
+the second mode listed is applied to the "second" display device.
+Unfortunately, it is often unclear which display device is the "first" or
+"second". That is why specifying the display device name is preferable.
+
+When specifying display device names, you may also omit the number part of the
+name, though this is only useful if you only have one of that type of display
+device. For example, if you have one CRT and one DFP connected, you may
+reference them in the MetaMode string as follows:
+
+    Option "MetaModes"   "CRT: 1600x1200,  DFP: 1024x768"
+
+
+______________________________________________________________________________
+
+Appendix H. GLX Support
+______________________________________________________________________________
+
+This release supports GLX 1.4.
+
+Additionally, the following GLX extensions are supported on appropriate GPUs:
+
+   o GLX_EXT_visual_info
+
+   o GLX_EXT_visual_rating
+
+   o GLX_SGIX_fbconfig
+
+   o GLX_SGIX_pbuffer
+
+   o GLX_ARB_get_proc_address
+
+   o GLX_SGI_video_sync
+
+   o GLX_SGI_swap_control
+
+   o GLX_ARB_multisample
+
+   o GLX_NV_float_buffer
+
+   o GLX_ARB_fbconfig_float
+
+   o GLX_NV_swap_group
+
+   o GLX_NV_video_out
+
+   o GLX_EXT_texture_from_pixmap
+
+For a description of these extensions, see the OpenGL extension registry at
+http://www.opengl.org/registry/
+
+Some of the above extensions exist as part of core GLX 1.4 functionality,
+however, they are also exported as extensions for backwards compatibility.
+
+______________________________________________________________________________
+
+Appendix I. Dots Per Inch
+______________________________________________________________________________
+
+DPI (Dots Per Inch), also known as PPI (Pixels Per Inch), is a property of an
+X screen that describes the physical size of pixels. Some X applications, such
+as xterm, can use the DPI of an X screen to determine how large (in pixels) to
+draw an object in order for that object to be displayed at the desired
+physical size on the display device.
+
+The DPI of an X screen is computed by dividing the size of the X screen in
+pixels by the size of the X screen in inches:
+
+    DPI = SizeInPixels / SizeInInches
+
+Since the X screen stores its physical size in millimeters rather than inches
+(1 inch = 25.4 millimeters):
+
+    DPI = (SizeInPixels * 25.4) / SizeInMillimeters
+
+The NVIDIA X driver reports the size of the X screen in pixels and in
+millimeters. On X.Org 6.9 or newer, when the XRandR extension resizes the X
+screen in pixels, the NVIDIA X driver computes a new size in millimeters for
+the X screen, to maintain a constant DPI (see the "Physical Size" column of
+the `xrandr -q` output as an example). This is done because a changing DPI can
+cause interaction problems for some applications. To disable this behavior,
+and instead keep the same millimeter size for the X screen (and therefore have
+a changing DPI), set the ConstantDPI option to FALSE (see Appendix F for
+details).
+
+You can query the DPI of your X screen by running:
+
+
+    % xdpyinfo | grep -B1 dot
+
+
+which should generate output like this:
+
+
+    dimensions:    1280x1024 pixels (382x302 millimeters)
+    resolution:    85x86 dots per inch
+
+
+
+The NVIDIA X driver performs several steps during X screen initialization to
+determine the DPI of each X screen:
+
+
+   o If the display device provides an EDID, and the EDID contains information
+     about the physical size of the display device, that is used to compute
+     the DPI, along with the size in pixels of the first mode to be used on
+     the display device. If multiple display devices are used by this X
+     screen, then the NVIDIA X screen will choose which display device to use.
+     You can override this with the "UseEdidDpi" X configuration option: you
+     can specify a particular display device to use; e.g.:
+     
+         Option "UseEdidDpi" "DFP-1"
+     
+     or disable EDID-computed DPI by setting this option to false:
+     
+         Option "UseEdidDpi" "FALSE"
+     
+     EDID-based DPI computation is enabled by default when an EDID is
+     available.
+
+   o If the "-dpi" commandline option to the X server is specified, that is
+     used to set the DPI (see `X -h` for details). This will override the
+     "UseEdidDpi" option.
+
+   o If the "DPI" X configuration option is specified (see Appendix F for
+     details), that will be used to set the DPI. This will override the
+     "UseEdidDpi" option.
+
+   o If none of the above are available, then the "DisplaySize" X config file
+     Monitor section information will be used to determine the DPI, if
+     provided; see the xorg.conf or XF86Config man pages for details.
+
+   o If none of the above are available, the DPI defaults to 75x75.
+
+
+You can find how the NVIDIA X driver determined the DPI by looking in your X
+log file. There will be a line that looks something like the following:
+
+    (--) NVIDIA(0): DPI set to (101, 101); computed from "UseEdidDpi" X config
+option
+
+
+Note that the physical size of the X screen, as reported through `xdpyinfo` is
+computed based on the DPI and the size of the X screen in pixels.
+
+The DPI of an X screen can be confusing when TwinView is enabled: with
+TwinView, multiple display devices (possibly with different DPIs) display
+portions of the same X screen, yet DPI can only be advertised from the X
+server to the X application with X screen granularity. Solutions for this
+include:
+
+
+   o Use separate X screens, rather than TwinView; see Chapter 12 for details.
+
+   o Experiment with different DPI settings to find a DPI that is suitable for
+     both display devices.
+
+
+______________________________________________________________________________
+
+Appendix J. XvMC Support
+______________________________________________________________________________
+
+This release includes support for the XVideo Motion Compensation (XvMC)
+version 1.0 API on GeForce 5 series, GeForce 6 series and GeForce 7 series
+addin cards, as well as motherboard chipsets with integrated graphics that
+have PureVideo support. There is a static library, "libXvMCNVIDIA.a", and a
+dynamic one, "libXvMCNVIDIA_dynamic.so", which is suitable for dlopening.
+XvMC's "IDCT" and "motion-compensation" levels of acceleration, AI44 and IA44
+subpictures, and 4:2:0 Surfaces up to 2032x2032 are supported.
+
+libXvMCNVIDIA observes the XVMC_DEBUG environment variable and will provide
+some debug output to stderr when set to an appropriate integer value. '0'
+disables debug output. '1' enables debug output for failure conditions. '2' or
+higher enables output of warning messages.
+
diff --git a/doc/XF86Config.sample b/doc/XF86Config.sample
new file mode 100644 (file)
index 0000000..4a17c17
--- /dev/null
@@ -0,0 +1,292 @@
+##########################################################################
+# Sample XF86Config file for NVIDIA XFree86 drivers.
+#
+# Refer to the XF86Config(4/5) man page for details about the format of
+# this file.
+#
+# Be sure to replace the monitor values with correct values for your
+# monitor!
+##########################################################################
+
+
+Section "Files"
+
+    RgbPath    "/usr/X11R6/lib/X11/rgb"
+    FontPath   "unix/:-1"
+
+EndSection
+
+
+##########################################################################
+# Server flags section.
+##########################################################################
+
+Section "ServerFlags"
+
+    # Uncomment this to cause a core dump at the spot where a signal is
+    # received.  This may leave the console in an unusable state, but may
+    # provide a better stack trace in the core dump to aid in debugging
+    #NoTrapSignals
+
+    # Uncomment this to disable the <Crtl><Alt><BS> server abort sequence
+    # This allows clients to receive this key event.
+    #DontZap
+
+    # Uncomment this to disable the <Crtl><Alt><KP_+>/<KP_-> mode switching
+    # sequences.  This allows clients to receive these key events.
+    #DontZoom
+
+    # This  allows  the  server  to start up even if the
+    # mouse device can't be opened/initialised.
+    AllowMouseOpenFail
+
+EndSection
+
+
+##########################################################################
+# Input devices
+##########################################################################
+
+#
+# Keyboard section
+#
+Section "InputDevice"
+
+    Identifier "Keyboard1"
+    Driver     "Keyboard"
+    Option     "AutoRepeat"  "250 30"
+
+    Option "XkbRules"  "xfree86"
+    Option "XkbModel"  "pc105"
+    Option "XkbLayout" "us"
+
+EndSection
+
+
+#
+# Pointer section
+#
+Section "InputDevice"
+
+    Identifier  "Mouse1"
+    Driver      "mouse"
+    Option      "Protocol"    "IMPS/2"
+    Option      "Device"      "/dev/psaux"
+
+EndSection
+
+
+##########################################################################
+# Module section
+##########################################################################
+
+Section "Module"
+
+    Load        "dbe"
+
+    # Load the glx module.
+    Load       "glx"
+
+    Load        "extmod"
+
+    Load       "type1"
+    Load       "freetype"
+EndSection
+
+
+##########################################################################
+# Monitor section
+##########################################################################
+
+Section "Monitor"
+
+    Identifier "MyMonitor"
+    VendorName "Mitsubisi"
+    ModelName  "Diamond Plus 120u"
+
+    # be sure to replace these values with values appropriate for your
+    # monitor!
+    HorizSync  31-82
+    VertRefresh 55-120
+
+    # 3840x2400 @ 12Hz for IBM's T221 FlatPanel
+    Modeline "3840x2400" 148.0 3840 3944 4328 4816 2400 2401 2404 2418 
+
+EndSection
+
+
+##########################################################################
+# Graphics device section(s)
+##########################################################################
+
+Section "Device"
+    Identifier  "NV AGP"
+    VendorName  "nvidia"
+    Driver   "nvidia"
+    # update this with the PCI id of your card.  Consult the output
+    # of the 'lspci' command.  The BusID is usually optional when
+    # only using one graphics card.
+    BusID       "PCI:1:0:0"
+EndSection
+
+Section "Device"
+    Identifier "NV PCI"
+    VendorName "nvidia"
+    Driver "nvidia"
+    # update this with the PCI id of your card.  Consult the output
+    # of the 'lspci' command.  The BusID is usually optional when
+    # only using one graphics card.
+    BusID       "PCI:0:13:0"
+EndSection
+
+Section "Device"
+    Identifier "NV AGP TwinView"
+    VendorName "nvidia"
+    Driver "nvidia"
+    # update this with the PCI id of your card.  Consult the output
+    # of the 'lspci' command. The  BusID is usually optional when
+    # only using one graphics card.
+    BusID       "PCI:1:0:0"
+
+    # sample twinview setup
+    Option "TwinView"
+    # be sure to replace the HorizSync and VertRefresh with correct values
+    # for your monitor!  
+    Option "SecondMonitorHorizSync"   "31-82"
+    Option "SecondMonitorVertRefresh" "55-120"
+    Option "TwinViewOrientation"      "RightOf"
+    Option "MetaModes"                "1280x1024,1280x1024; 1024x768,1024x768"
+    Option "ConnectedMonitor"         "crt,crt"
+EndSection
+
+
+##########################################################################
+# Screen sections
+##########################################################################
+
+#
+# screen section for an nvidia AGP card
+#
+Section "Screen"
+    Identifier "Screen AGP"
+    Device      "NV AGP"
+    Monitor     "MyMonitor"
+    DefaultColorDepth 24
+    Subsection "Display"
+        Depth       8
+        Modes       "1280x1024" "1024x768" "800x600" "640x400"
+    EndSubsection
+    Subsection "Display"
+        Depth       16
+        Modes       "1280x1024" "1024x768" "800x600" "640x480"
+    EndSubsection
+    Subsection "Display"
+        Depth       24
+        Modes       "1280x1024" "1024x768" "800x600" "640x480"
+    EndSubsection
+
+EndSection
+
+
+#
+# screen section for an nvidia PCI card
+#
+Section "Screen"
+    Identifier "Screen PCI"
+    Device      "NV PCI"
+    Monitor     "MyMonitor"
+    DefaultColorDepth 24
+    Subsection "Display"
+        Depth       8
+        Modes       "1280x1024" "1024x768" "800x600" "640x400"
+    EndSubsection
+    Subsection "Display"
+        Depth       16
+        Modes       "1280x1024" "1024x768" "800x600" "640x480"
+    EndSubsection
+    Subsection "Display"
+        Depth       24
+        Modes       "1280x1024" "1024x768" "800x600" "640x480"
+    EndSubsection
+EndSection
+
+#
+# screen section for an nvidia AGP TwinView card
+# (look at the appropriate Device section)
+#
+Section "Screen"
+    Identifier "Screen AGP TwinView"
+    Device "NV AGP TwinView"
+    Monitor "MyMonitor"
+    DefaultColorDepth 24
+    Subsection "Display"
+        Depth       8
+        Modes       "1280x1024" "1024x768" "800x600" "640x400"
+    EndSubsection
+    Subsection "Display"
+        Depth       16
+        Modes       "1280x1024" "1024x768" "800x600" "640x480"
+    EndSubsection
+    Subsection "Display"
+        Depth       24
+        Modes       "1280x1024" "1024x768" "800x600" "640x480"
+    EndSubsection
+EndSection
+
+
+##########################################################################
+# ServerLayout sections
+# (invoke using the '-layout' option of 'startx'.
+##########################################################################
+
+#
+# just one agp card
+#
+Section "ServerLayout"
+    Identifier  "AGP"
+    Screen      "Screen AGP"
+    InputDevice "Mouse1" "CorePointer"
+    InputDevice "Keyboard1" "CoreKeyboard"
+EndSection
+
+#
+# just one pci card
+#
+Section "ServerLayout"
+    Identifier  "PCI"
+    Screen      "Screen PCI"
+    InputDevice "Mouse1" "CorePointer"
+    InputDevice "Keyboard1" "CoreKeyboard"
+EndSection
+
+#
+# 2 cards, non twinview
+#
+Section "ServerLayout"
+    Identifier  "Both"
+    Screen      "Screen AGP"
+    Screen      "Screen PCI" LeftOf "Screen AGP"
+    InputDevice "Mouse1" "CorePointer"
+    InputDevice "Keyboard1" "CoreKeyboard"
+EndSection
+
+#
+# just one agp twinview card
+#
+Section "ServerLayout"
+    Identifier  "AGPTwinView"
+    Screen      "Screen AGP TwinView"
+    InputDevice "Mouse1" "CorePointer"
+    InputDevice "Keyboard1" "CoreKeyboard"
+EndSection
+
+#
+# 2 cards, one agp twinview and one pci (3 monitors total)
+#
+Section "ServerLayout"
+    Identifier  "BothTwinView"
+    Screen      "Screen AGP TwinView"
+    Screen      "Screen PCI" LeftOf "Screen AGP TwinView"
+    InputDevice "Mouse1" "CorePointer"
+    InputDevice "Keyboard1" "CoreKeyboard"
+EndSection
diff --git a/doc/gl.h b/doc/gl.h
new file mode 100755 (executable)
index 0000000..4f78c54
--- /dev/null
+++ b/doc/gl.h
@@ -0,0 +1,2087 @@
+#ifndef __gl_h_
+#define __gl_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright 1998-2002, NVIDIA Corporation.
+** All Rights Reserved.
+** 
+** THE INFORMATION CONTAINED HEREIN IS PROPRIETARY AND CONFIDENTIAL TO
+** NVIDIA, CORPORATION.  USE, REPRODUCTION OR DISCLOSURE TO ANY THIRD PARTY
+** IS SUBJECT TO WRITTEN PRE-APPROVAL BY NVIDIA, CORPORATION.
+** 
+** 
+** Copyright 1992-1999, Silicon Graphics, Inc.
+** All Rights Reserved.
+** 
+** Portions of this file are UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon
+** Graphics, Inc.; the contents of this file may not be disclosed to third
+** parties, copied or duplicated in any form, in whole or in part, without
+** the prior written permission of Silicon Graphics, Inc.
+** 
+** RESTRICTED RIGHTS LEGEND:
+** Use, duplication or disclosure by the Government is subject to
+** restrictions as set forth in subdivision (c)(1)(ii) of the Rights in
+** Technical Data and Computer Software clause at DFARS 252.227-7013,
+** and/or in similar or successor clauses in the FAR, DOD or NASA FAR
+** Supplement.  Unpublished - rights reserved under the Copyright Laws of
+** the United States.
+*/
+
+#ifndef GLAPIENTRY
+# ifdef _WIN32
+#  if (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED)  /* Mimic <windef.h> */
+#   define GLAPIENTRY __stdcall
+#  else
+#   define GLAPIENTRY
+#  endif
+# else
+#  define GLAPIENTRY
+# endif
+#endif
+
+#ifndef GLAPI
+# define GLAPI extern
+#endif
+
+#ifndef GLAPIENTRYP
+# define GLAPIENTRYP GLAPIENTRY *
+#endif
+
+/*************************************************************/
+
+typedef unsigned int GLenum;
+typedef unsigned char GLboolean;
+typedef unsigned int GLbitfield;
+typedef signed char GLbyte;
+typedef short GLshort;
+typedef int GLint;
+typedef int GLsizei;
+typedef unsigned char GLubyte;
+typedef unsigned short GLushort;
+typedef unsigned int GLuint;
+typedef float GLfloat;
+typedef float GLclampf;
+typedef double GLdouble;
+typedef double GLclampd;
+typedef void GLvoid;
+
+#ifndef GL_TYPEDEFS_1_5
+# define GL_TYPEDEFS_1_5
+# if defined(_WIN64)
+    typedef __int64 GLintptr;
+    typedef __int64 GLsizeiptr;
+# elif defined(__x86_64__)
+    typedef long int GLintptr;
+    typedef long int GLsizeiptr;
+# else
+    typedef int GLintptr;
+    typedef int GLsizeiptr;
+# endif
+#endif
+
+#ifndef GL_TYPEDEFS_2_0
+# define GL_TYPEDEFS_2_0
+    typedef char GLchar;
+#endif
+
+#ifndef GL_GLEXT_LEGACY
+# include <GL/glext.h>
+#endif
+
+/*************************************************************/
+
+/* Version */
+#define GL_VERSION_1_1                    1
+#define GL_VERSION_1_2                    1
+#define GL_VERSION_1_3                    1
+#define GL_VERSION_1_4                    1
+#define GL_VERSION_1_5                    1
+#define GL_VERSION_2_0                    1
+#define GL_VERSION_2_1                    1
+
+/* AttribMask */
+#define GL_CURRENT_BIT                    0x00000001
+#define GL_POINT_BIT                      0x00000002
+#define GL_LINE_BIT                       0x00000004
+#define GL_POLYGON_BIT                    0x00000008
+#define GL_POLYGON_STIPPLE_BIT            0x00000010
+#define GL_PIXEL_MODE_BIT                 0x00000020
+#define GL_LIGHTING_BIT                   0x00000040
+#define GL_FOG_BIT                        0x00000080
+#define GL_DEPTH_BUFFER_BIT               0x00000100
+#define GL_ACCUM_BUFFER_BIT               0x00000200
+#define GL_STENCIL_BUFFER_BIT             0x00000400
+#define GL_VIEWPORT_BIT                   0x00000800
+#define GL_TRANSFORM_BIT                  0x00001000
+#define GL_ENABLE_BIT                     0x00002000
+#define GL_COLOR_BUFFER_BIT               0x00004000
+#define GL_HINT_BIT                       0x00008000
+#define GL_EVAL_BIT                       0x00010000
+#define GL_LIST_BIT                       0x00020000
+#define GL_TEXTURE_BIT                    0x00040000
+#define GL_SCISSOR_BIT                    0x00080000
+#define GL_ALL_ATTRIB_BITS                0xFFFFFFFF
+
+/* ClearBufferMask */
+/*      GL_COLOR_BUFFER_BIT */
+/*      GL_ACCUM_BUFFER_BIT */
+/*      GL_STENCIL_BUFFER_BIT */
+/*      GL_DEPTH_BUFFER_BIT */
+
+/* ClientAttribMask */
+#define GL_CLIENT_PIXEL_STORE_BIT         0x00000001
+#define GL_CLIENT_VERTEX_ARRAY_BIT        0x00000002
+#define GL_CLIENT_ALL_ATTRIB_BITS         0xFFFFFFFF
+
+/* Boolean */
+#define GL_FALSE                          0
+#define GL_TRUE                           1
+
+/* BeginMode */
+#define GL_POINTS                         0x0000
+#define GL_LINES                          0x0001
+#define GL_LINE_LOOP                      0x0002
+#define GL_LINE_STRIP                     0x0003
+#define GL_TRIANGLES                      0x0004
+#define GL_TRIANGLE_STRIP                 0x0005
+#define GL_TRIANGLE_FAN                   0x0006
+#define GL_QUADS                          0x0007
+#define GL_QUAD_STRIP                     0x0008
+#define GL_POLYGON                        0x0009
+
+/* AccumOp */
+#define GL_ACCUM                          0x0100
+#define GL_LOAD                           0x0101
+#define GL_RETURN                         0x0102
+#define GL_MULT                           0x0103
+#define GL_ADD                            0x0104
+
+/* AlphaFunction */
+#define GL_NEVER                          0x0200
+#define GL_LESS                           0x0201
+#define GL_EQUAL                          0x0202
+#define GL_LEQUAL                         0x0203
+#define GL_GREATER                        0x0204
+#define GL_NOTEQUAL                       0x0205
+#define GL_GEQUAL                         0x0206
+#define GL_ALWAYS                         0x0207
+
+/* BlendingFactorDest */
+#define GL_ZERO                           0
+#define GL_ONE                            1
+#define GL_SRC_COLOR                      0x0300
+#define GL_ONE_MINUS_SRC_COLOR            0x0301
+#define GL_SRC_ALPHA                      0x0302
+#define GL_ONE_MINUS_SRC_ALPHA            0x0303
+#define GL_DST_ALPHA                      0x0304
+#define GL_ONE_MINUS_DST_ALPHA            0x0305
+
+/* BlendingFactorSrc */
+/*      GL_ZERO */
+/*      GL_ONE */
+#define GL_DST_COLOR                      0x0306
+#define GL_ONE_MINUS_DST_COLOR            0x0307
+#define GL_SRC_ALPHA_SATURATE             0x0308
+/*      GL_SRC_ALPHA */
+/*      GL_ONE_MINUS_SRC_ALPHA */
+/*      GL_DST_ALPHA */
+/*      GL_ONE_MINUS_DST_ALPHA */
+
+/* ColorMaterialFace */
+/*      GL_FRONT */
+/*      GL_BACK */
+/*      GL_FRONT_AND_BACK */
+
+/* ColorMaterialParameter */
+/*      GL_AMBIENT */
+/*      GL_DIFFUSE */
+/*      GL_SPECULAR */
+/*      GL_EMISSION */
+/*      GL_AMBIENT_AND_DIFFUSE */
+
+/* ColorPointerType */
+/*      GL_BYTE */
+/*      GL_UNSIGNED_BYTE */
+/*      GL_SHORT */
+/*      GL_UNSIGNED_SHORT */
+/*      GL_INT */
+/*      GL_UNSIGNED_INT */
+/*      GL_FLOAT */
+/*      GL_DOUBLE */
+
+/* CullFaceMode */
+/*      GL_FRONT */
+/*      GL_BACK */
+/*      GL_FRONT_AND_BACK */
+
+/* DepthFunction */
+/*      GL_NEVER */
+/*      GL_LESS */
+/*      GL_EQUAL */
+/*      GL_LEQUAL */
+/*      GL_GREATER */
+/*      GL_NOTEQUAL */
+/*      GL_GEQUAL */
+/*      GL_ALWAYS */
+
+/* DrawBufferMode */
+#define GL_NONE                           0
+#define GL_FRONT_LEFT                     0x0400
+#define GL_FRONT_RIGHT                    0x0401
+#define GL_BACK_LEFT                      0x0402
+#define GL_BACK_RIGHT                     0x0403
+#define GL_FRONT                          0x0404
+#define GL_BACK                           0x0405
+#define GL_LEFT                           0x0406
+#define GL_RIGHT                          0x0407
+#define GL_FRONT_AND_BACK                 0x0408
+#define GL_AUX0                           0x0409
+#define GL_AUX1                           0x040A
+#define GL_AUX2                           0x040B
+#define GL_AUX3                           0x040C
+#define GL_AUX4                           0x040D
+#define GL_AUX5                           0x040E
+#define GL_AUX6                           0x040F
+#define GL_AUX7                           0x0410
+
+/* EnableCap */
+/*      GL_FOG */
+/*      GL_LIGHTING */
+/*      GL_TEXTURE_1D */
+/*      GL_TEXTURE_2D */
+/*      GL_LINE_STIPPLE */
+/*      GL_POLYGON_STIPPLE */
+/*      GL_CULL_FACE */
+/*      GL_ALPHA_TEST */
+/*      GL_BLEND */
+/*      GL_INDEX_LOGIC_OP */
+/*      GL_COLOR_LOGIC_OP */
+/*      GL_DITHER */
+/*      GL_STENCIL_TEST */
+/*      GL_DEPTH_TEST */
+/*      GL_CLIP_PLANE0 */
+/*      GL_CLIP_PLANE1 */
+/*      GL_CLIP_PLANE2 */
+/*      GL_CLIP_PLANE3 */
+/*      GL_CLIP_PLANE4 */
+/*      GL_CLIP_PLANE5 */
+/*      GL_LIGHT0 */
+/*      GL_LIGHT1 */
+/*      GL_LIGHT2 */
+/*      GL_LIGHT3 */
+/*      GL_LIGHT4 */
+/*      GL_LIGHT5 */
+/*      GL_LIGHT6 */
+/*      GL_LIGHT7 */
+/*      GL_TEXTURE_GEN_S */
+/*      GL_TEXTURE_GEN_T */
+/*      GL_TEXTURE_GEN_R */
+/*      GL_TEXTURE_GEN_Q */
+/*      GL_MAP1_VERTEX_3 */
+/*      GL_MAP1_VERTEX_4 */
+/*      GL_MAP1_COLOR_4 */
+/*      GL_MAP1_INDEX */
+/*      GL_MAP1_NORMAL */
+/*      GL_MAP1_TEXTURE_COORD_1 */
+/*      GL_MAP1_TEXTURE_COORD_2 */
+/*      GL_MAP1_TEXTURE_COORD_3 */
+/*      GL_MAP1_TEXTURE_COORD_4 */
+/*      GL_MAP2_VERTEX_3 */
+/*      GL_MAP2_VERTEX_4 */
+/*      GL_MAP2_COLOR_4 */
+/*      GL_MAP2_INDEX */
+/*      GL_MAP2_NORMAL */
+/*      GL_MAP2_TEXTURE_COORD_1 */
+/*      GL_MAP2_TEXTURE_COORD_2 */
+/*      GL_MAP2_TEXTURE_COORD_3 */
+/*      GL_MAP2_TEXTURE_COORD_4 */
+/*      GL_POINT_SMOOTH */
+/*      GL_LINE_SMOOTH */
+/*      GL_POLYGON_SMOOTH */
+/*      GL_SCISSOR_TEST */
+/*      GL_COLOR_MATERIAL */
+/*      GL_NORMALIZE */
+/*      GL_AUTO_NORMAL */
+/*      GL_POLYGON_OFFSET_POINT */
+/*      GL_POLYGON_OFFSET_LINE */
+/*      GL_POLYGON_OFFSET_FILL */
+/*      GL_VERTEX_ARRAY */
+/*      GL_NORMAL_ARRAY */
+/*      GL_COLOR_ARRAY */
+/*      GL_INDEX_ARRAY */
+/*      GL_TEXTURE_COORD_ARRAY */
+/*      GL_EDGE_FLAG_ARRAY */
+
+/* ErrorCode */
+#define GL_NO_ERROR                       0
+#define GL_INVALID_ENUM                   0x0500
+#define GL_INVALID_VALUE                  0x0501
+#define GL_INVALID_OPERATION              0x0502
+#define GL_STACK_OVERFLOW                 0x0503
+#define GL_STACK_UNDERFLOW                0x0504
+#define GL_OUT_OF_MEMORY                  0x0505
+#define GL_TABLE_TOO_LARGE                0x8031
+
+/* FeedbackType */
+#define GL_2D                             0x0600
+#define GL_3D                             0x0601
+#define GL_3D_COLOR                       0x0602
+#define GL_3D_COLOR_TEXTURE               0x0603
+#define GL_4D_COLOR_TEXTURE               0x0604
+
+/* FeedBackToken */
+#define GL_PASS_THROUGH_TOKEN             0x0700
+#define GL_POINT_TOKEN                    0x0701
+#define GL_LINE_TOKEN                     0x0702
+#define GL_POLYGON_TOKEN                  0x0703
+#define GL_BITMAP_TOKEN                   0x0704
+#define GL_DRAW_PIXEL_TOKEN               0x0705
+#define GL_COPY_PIXEL_TOKEN               0x0706
+#define GL_LINE_RESET_TOKEN               0x0707
+
+/* FogMode */
+/*      GL_LINEAR */
+#define GL_EXP                            0x0800
+#define GL_EXP2                           0x0801
+
+/* FogParameter */
+/*      GL_FOG_COLOR */
+/*      GL_FOG_DENSITY */
+/*      GL_FOG_END */
+/*      GL_FOG_INDEX */
+/*      GL_FOG_MODE */
+/*      GL_FOG_START */
+
+/* FrontFaceDirection */
+#define GL_CW                             0x0900
+#define GL_CCW                            0x0901
+
+/* GetMapQuery */
+#define GL_COEFF                          0x0A00
+#define GL_ORDER                          0x0A01
+#define GL_DOMAIN                         0x0A02
+
+/* GetPixelMap */
+#define GL_PIXEL_MAP_I_TO_I               0x0C70
+#define GL_PIXEL_MAP_S_TO_S               0x0C71
+#define GL_PIXEL_MAP_I_TO_R               0x0C72
+#define GL_PIXEL_MAP_I_TO_G               0x0C73
+#define GL_PIXEL_MAP_I_TO_B               0x0C74
+#define GL_PIXEL_MAP_I_TO_A               0x0C75
+#define GL_PIXEL_MAP_R_TO_R               0x0C76
+#define GL_PIXEL_MAP_G_TO_G               0x0C77
+#define GL_PIXEL_MAP_B_TO_B               0x0C78
+#define GL_PIXEL_MAP_A_TO_A               0x0C79
+
+/* GetPointervPName */
+#define GL_VERTEX_ARRAY_POINTER           0x808E
+#define GL_NORMAL_ARRAY_POINTER           0x808F
+#define GL_COLOR_ARRAY_POINTER            0x8090
+#define GL_INDEX_ARRAY_POINTER            0x8091
+#define GL_TEXTURE_COORD_ARRAY_POINTER    0x8092
+#define GL_EDGE_FLAG_ARRAY_POINTER        0x8093
+
+/* GetPName */
+#define GL_CURRENT_COLOR                  0x0B00
+#define GL_CURRENT_INDEX                  0x0B01
+#define GL_CURRENT_NORMAL                 0x0B02
+#define GL_CURRENT_TEXTURE_COORDS         0x0B03
+#define GL_CURRENT_RASTER_COLOR           0x0B04
+#define GL_CURRENT_RASTER_INDEX           0x0B05
+#define GL_CURRENT_RASTER_TEXTURE_COORDS  0x0B06
+#define GL_CURRENT_RASTER_POSITION        0x0B07
+#define GL_CURRENT_RASTER_POSITION_VALID  0x0B08
+#define GL_CURRENT_RASTER_DISTANCE        0x0B09
+#define GL_POINT_SMOOTH                   0x0B10
+#define GL_POINT_SIZE                     0x0B11
+#define GL_SMOOTH_POINT_SIZE_RANGE        0x0B12
+#define GL_SMOOTH_POINT_SIZE_GRANULARITY  0x0B13
+#define GL_POINT_SIZE_RANGE               GL_SMOOTH_POINT_SIZE_RANGE
+#define GL_POINT_SIZE_GRANULARITY         GL_SMOOTH_POINT_SIZE_GRANULARITY
+#define GL_LINE_SMOOTH                    0x0B20
+#define GL_LINE_WIDTH                     0x0B21
+#define GL_SMOOTH_LINE_WIDTH_RANGE        0x0B22
+#define GL_SMOOTH_LINE_WIDTH_GRANULARITY  0x0B23
+#define GL_LINE_WIDTH_RANGE               GL_SMOOTH_LINE_WIDTH_RANGE
+#define GL_LINE_WIDTH_GRANULARITY         GL_SMOOTH_LINE_WIDTH_GRANULARITY
+#define GL_LINE_STIPPLE                   0x0B24
+#define GL_LINE_STIPPLE_PATTERN           0x0B25
+#define GL_LINE_STIPPLE_REPEAT            0x0B26
+#define GL_LIST_MODE                      0x0B30
+#define GL_MAX_LIST_NESTING               0x0B31
+#define GL_LIST_BASE                      0x0B32
+#define GL_LIST_INDEX                     0x0B33
+#define GL_POLYGON_MODE                   0x0B40
+#define GL_POLYGON_SMOOTH                 0x0B41
+#define GL_POLYGON_STIPPLE                0x0B42
+#define GL_EDGE_FLAG                      0x0B43
+#define GL_CULL_FACE                      0x0B44
+#define GL_CULL_FACE_MODE                 0x0B45
+#define GL_FRONT_FACE                     0x0B46
+#define GL_LIGHTING                       0x0B50
+#define GL_LIGHT_MODEL_LOCAL_VIEWER       0x0B51
+#define GL_LIGHT_MODEL_TWO_SIDE           0x0B52
+#define GL_LIGHT_MODEL_AMBIENT            0x0B53
+#define GL_SHADE_MODEL                    0x0B54
+#define GL_COLOR_MATERIAL_FACE            0x0B55
+#define GL_COLOR_MATERIAL_PARAMETER       0x0B56
+#define GL_COLOR_MATERIAL                 0x0B57
+#define GL_FOG                            0x0B60
+#define GL_FOG_INDEX                      0x0B61
+#define GL_FOG_DENSITY                    0x0B62
+#define GL_FOG_START                      0x0B63
+#define GL_FOG_END                        0x0B64
+#define GL_FOG_MODE                       0x0B65
+#define GL_FOG_COLOR                      0x0B66
+#define GL_DEPTH_RANGE                    0x0B70
+#define GL_DEPTH_TEST                     0x0B71
+#define GL_DEPTH_WRITEMASK                0x0B72
+#define GL_DEPTH_CLEAR_VALUE              0x0B73
+#define GL_DEPTH_FUNC                     0x0B74
+#define GL_ACCUM_CLEAR_VALUE              0x0B80
+#define GL_STENCIL_TEST                   0x0B90
+#define GL_STENCIL_CLEAR_VALUE            0x0B91
+#define GL_STENCIL_FUNC                   0x0B92
+#define GL_STENCIL_VALUE_MASK             0x0B93
+#define GL_STENCIL_FAIL                   0x0B94
+#define GL_STENCIL_PASS_DEPTH_FAIL        0x0B95
+#define GL_STENCIL_PASS_DEPTH_PASS        0x0B96
+#define GL_STENCIL_REF                    0x0B97
+#define GL_STENCIL_WRITEMASK              0x0B98
+#define GL_MATRIX_MODE                    0x0BA0
+#define GL_NORMALIZE                      0x0BA1
+#define GL_VIEWPORT                       0x0BA2
+#define GL_MODELVIEW_STACK_DEPTH          0x0BA3
+#define GL_PROJECTION_STACK_DEPTH         0x0BA4
+#define GL_TEXTURE_STACK_DEPTH            0x0BA5
+#define GL_MODELVIEW_MATRIX               0x0BA6
+#define GL_PROJECTION_MATRIX              0x0BA7
+#define GL_TEXTURE_MATRIX                 0x0BA8
+#define GL_ATTRIB_STACK_DEPTH             0x0BB0
+#define GL_CLIENT_ATTRIB_STACK_DEPTH      0x0BB1
+#define GL_ALPHA_TEST                     0x0BC0
+#define GL_ALPHA_TEST_FUNC                0x0BC1
+#define GL_ALPHA_TEST_REF                 0x0BC2
+#define GL_DITHER                         0x0BD0
+#define GL_BLEND_DST                      0x0BE0
+#define GL_BLEND_SRC                      0x0BE1
+#define GL_BLEND                          0x0BE2
+#define GL_LOGIC_OP_MODE                  0x0BF0
+#define GL_INDEX_LOGIC_OP                 0x0BF1
+#define GL_LOGIC_OP                       GL_INDEX_LOGIC_OP
+#define GL_COLOR_LOGIC_OP                 0x0BF2
+#define GL_AUX_BUFFERS                    0x0C00
+#define GL_DRAW_BUFFER                    0x0C01
+#define GL_READ_BUFFER                    0x0C02
+#define GL_SCISSOR_BOX                    0x0C10
+#define GL_SCISSOR_TEST                   0x0C11
+#define GL_INDEX_CLEAR_VALUE              0x0C20
+#define GL_INDEX_WRITEMASK                0x0C21
+#define GL_COLOR_CLEAR_VALUE              0x0C22
+#define GL_COLOR_WRITEMASK                0x0C23
+#define GL_INDEX_MODE                     0x0C30
+#define GL_RGBA_MODE                      0x0C31
+#define GL_DOUBLEBUFFER                   0x0C32
+#define GL_STEREO                         0x0C33
+#define GL_RENDER_MODE                    0x0C40
+#define GL_PERSPECTIVE_CORRECTION_HINT    0x0C50
+#define GL_POINT_SMOOTH_HINT              0x0C51
+#define GL_LINE_SMOOTH_HINT               0x0C52
+#define GL_POLYGON_SMOOTH_HINT            0x0C53
+#define GL_FOG_HINT                       0x0C54
+#define GL_TEXTURE_GEN_S                  0x0C60
+#define GL_TEXTURE_GEN_T                  0x0C61
+#define GL_TEXTURE_GEN_R                  0x0C62
+#define GL_TEXTURE_GEN_Q                  0x0C63
+#define GL_PIXEL_MAP_I_TO_I_SIZE          0x0CB0
+#define GL_PIXEL_MAP_S_TO_S_SIZE          0x0CB1
+#define GL_PIXEL_MAP_I_TO_R_SIZE          0x0CB2
+#define GL_PIXEL_MAP_I_TO_G_SIZE          0x0CB3
+#define GL_PIXEL_MAP_I_TO_B_SIZE          0x0CB4
+#define GL_PIXEL_MAP_I_TO_A_SIZE          0x0CB5
+#define GL_PIXEL_MAP_R_TO_R_SIZE          0x0CB6
+#define GL_PIXEL_MAP_G_TO_G_SIZE          0x0CB7
+#define GL_PIXEL_MAP_B_TO_B_SIZE          0x0CB8
+#define GL_PIXEL_MAP_A_TO_A_SIZE          0x0CB9
+#define GL_UNPACK_SWAP_BYTES              0x0CF0
+#define GL_UNPACK_LSB_FIRST               0x0CF1
+#define GL_UNPACK_ROW_LENGTH              0x0CF2
+#define GL_UNPACK_SKIP_ROWS               0x0CF3
+#define GL_UNPACK_SKIP_PIXELS             0x0CF4
+#define GL_UNPACK_ALIGNMENT               0x0CF5
+#define GL_PACK_SWAP_BYTES                0x0D00
+#define GL_PACK_LSB_FIRST                 0x0D01
+#define GL_PACK_ROW_LENGTH                0x0D02
+#define GL_PACK_SKIP_ROWS                 0x0D03
+#define GL_PACK_SKIP_PIXELS               0x0D04
+#define GL_PACK_ALIGNMENT                 0x0D05
+#define GL_MAP_COLOR                      0x0D10
+#define GL_MAP_STENCIL                    0x0D11
+#define GL_INDEX_SHIFT                    0x0D12
+#define GL_INDEX_OFFSET                   0x0D13
+#define GL_RED_SCALE                      0x0D14
+#define GL_RED_BIAS                       0x0D15
+#define GL_ZOOM_X                         0x0D16
+#define GL_ZOOM_Y                         0x0D17
+#define GL_GREEN_SCALE                    0x0D18
+#define GL_GREEN_BIAS                     0x0D19
+#define GL_BLUE_SCALE                     0x0D1A
+#define GL_BLUE_BIAS                      0x0D1B
+#define GL_ALPHA_SCALE                    0x0D1C
+#define GL_ALPHA_BIAS                     0x0D1D
+#define GL_DEPTH_SCALE                    0x0D1E
+#define GL_DEPTH_BIAS                     0x0D1F
+#define GL_MAX_EVAL_ORDER                 0x0D30
+#define GL_MAX_LIGHTS                     0x0D31
+#define GL_MAX_CLIP_PLANES                0x0D32
+#define GL_MAX_TEXTURE_SIZE               0x0D33
+#define GL_MAX_PIXEL_MAP_TABLE            0x0D34
+#define GL_MAX_ATTRIB_STACK_DEPTH         0x0D35
+#define GL_MAX_MODELVIEW_STACK_DEPTH      0x0D36
+#define GL_MAX_NAME_STACK_DEPTH           0x0D37
+#define GL_MAX_PROJECTION_STACK_DEPTH     0x0D38
+#define GL_MAX_TEXTURE_STACK_DEPTH        0x0D39
+#define GL_MAX_VIEWPORT_DIMS              0x0D3A
+#define GL_MAX_CLIENT_ATTRIB_STACK_DEPTH  0x0D3B
+#define GL_SUBPIXEL_BITS                  0x0D50
+#define GL_INDEX_BITS                     0x0D51
+#define GL_RED_BITS                       0x0D52
+#define GL_GREEN_BITS                     0x0D53
+#define GL_BLUE_BITS                      0x0D54
+#define GL_ALPHA_BITS                     0x0D55
+#define GL_DEPTH_BITS                     0x0D56
+#define GL_STENCIL_BITS                   0x0D57
+#define GL_ACCUM_RED_BITS                 0x0D58
+#define GL_ACCUM_GREEN_BITS               0x0D59
+#define GL_ACCUM_BLUE_BITS                0x0D5A
+#define GL_ACCUM_ALPHA_BITS               0x0D5B
+#define GL_NAME_STACK_DEPTH               0x0D70
+#define GL_AUTO_NORMAL                    0x0D80
+#define GL_MAP1_COLOR_4                   0x0D90
+#define GL_MAP1_INDEX                     0x0D91
+#define GL_MAP1_NORMAL                    0x0D92
+#define GL_MAP1_TEXTURE_COORD_1           0x0D93
+#define GL_MAP1_TEXTURE_COORD_2           0x0D94
+#define GL_MAP1_TEXTURE_COORD_3           0x0D95
+#define GL_MAP1_TEXTURE_COORD_4           0x0D96
+#define GL_MAP1_VERTEX_3                  0x0D97
+#define GL_MAP1_VERTEX_4                  0x0D98
+#define GL_MAP2_COLOR_4                   0x0DB0
+#define GL_MAP2_INDEX                     0x0DB1
+#define GL_MAP2_NORMAL                    0x0DB2
+#define GL_MAP2_TEXTURE_COORD_1           0x0DB3
+#define GL_MAP2_TEXTURE_COORD_2           0x0DB4
+#define GL_MAP2_TEXTURE_COORD_3           0x0DB5
+#define GL_MAP2_TEXTURE_COORD_4           0x0DB6
+#define GL_MAP2_VERTEX_3                  0x0DB7
+#define GL_MAP2_VERTEX_4                  0x0DB8
+#define GL_MAP1_GRID_DOMAIN               0x0DD0
+#define GL_MAP1_GRID_SEGMENTS             0x0DD1
+#define GL_MAP2_GRID_DOMAIN               0x0DD2
+#define GL_MAP2_GRID_SEGMENTS             0x0DD3
+#define GL_TEXTURE_1D                     0x0DE0
+#define GL_TEXTURE_2D                     0x0DE1
+#define GL_FEEDBACK_BUFFER_POINTER        0x0DF0
+#define GL_FEEDBACK_BUFFER_SIZE           0x0DF1
+#define GL_FEEDBACK_BUFFER_TYPE           0x0DF2
+#define GL_SELECTION_BUFFER_POINTER       0x0DF3
+#define GL_SELECTION_BUFFER_SIZE          0x0DF4
+#define GL_POLYGON_OFFSET_UNITS           0x2A00
+#define GL_POLYGON_OFFSET_POINT           0x2A01
+#define GL_POLYGON_OFFSET_LINE            0x2A02
+#define GL_POLYGON_OFFSET_FILL            0x8037
+#define GL_POLYGON_OFFSET_FACTOR          0x8038
+#define GL_TEXTURE_BINDING_1D             0x8068
+#define GL_TEXTURE_BINDING_2D             0x8069
+#define GL_TEXTURE_BINDING_3D             0x806A
+#define GL_VERTEX_ARRAY                   0x8074
+#define GL_NORMAL_ARRAY                   0x8075
+#define GL_COLOR_ARRAY                    0x8076
+#define GL_INDEX_ARRAY                    0x8077
+#define GL_TEXTURE_COORD_ARRAY            0x8078
+#define GL_EDGE_FLAG_ARRAY                0x8079
+#define GL_VERTEX_ARRAY_SIZE              0x807A
+#define GL_VERTEX_ARRAY_TYPE              0x807B
+#define GL_VERTEX_ARRAY_STRIDE            0x807C
+#define GL_NORMAL_ARRAY_TYPE              0x807E
+#define GL_NORMAL_ARRAY_STRIDE            0x807F
+#define GL_COLOR_ARRAY_SIZE               0x8081
+#define GL_COLOR_ARRAY_TYPE               0x8082
+#define GL_COLOR_ARRAY_STRIDE             0x8083
+#define GL_INDEX_ARRAY_TYPE               0x8085
+#define GL_INDEX_ARRAY_STRIDE             0x8086
+#define GL_TEXTURE_COORD_ARRAY_SIZE       0x8088
+#define GL_TEXTURE_COORD_ARRAY_TYPE       0x8089
+#define GL_TEXTURE_COORD_ARRAY_STRIDE     0x808A
+#define GL_EDGE_FLAG_ARRAY_STRIDE         0x808C
+/*      GL_VERTEX_ARRAY_COUNT_EXT */
+/*      GL_NORMAL_ARRAY_COUNT_EXT */
+/*      GL_COLOR_ARRAY_COUNT_EXT */
+/*      GL_INDEX_ARRAY_COUNT_EXT */
+/*      GL_TEXTURE_COORD_ARRAY_COUNT_EXT */
+/*      GL_EDGE_FLAG_ARRAY_COUNT_EXT */
+
+/* GetTextureParameter */
+/*      GL_TEXTURE_MAG_FILTER */
+/*      GL_TEXTURE_MIN_FILTER */
+/*      GL_TEXTURE_WRAP_S */
+/*      GL_TEXTURE_WRAP_T */
+#define GL_TEXTURE_WIDTH                  0x1000
+#define GL_TEXTURE_HEIGHT                 0x1001
+#define GL_TEXTURE_INTERNAL_FORMAT        0x1003
+#define GL_TEXTURE_COMPONENTS             GL_TEXTURE_INTERNAL_FORMAT
+#define GL_TEXTURE_BORDER_COLOR           0x1004
+#define GL_TEXTURE_BORDER                 0x1005
+#define GL_TEXTURE_RED_SIZE               0x805C
+#define GL_TEXTURE_GREEN_SIZE             0x805D
+#define GL_TEXTURE_BLUE_SIZE              0x805E
+#define GL_TEXTURE_ALPHA_SIZE             0x805F
+#define GL_TEXTURE_LUMINANCE_SIZE         0x8060
+#define GL_TEXTURE_INTENSITY_SIZE         0x8061
+#define GL_TEXTURE_PRIORITY               0x8066
+#define GL_TEXTURE_RESIDENT               0x8067
+
+/* HintMode */
+#define GL_DONT_CARE                      0x1100
+#define GL_FASTEST                        0x1101
+#define GL_NICEST                         0x1102
+
+/* HintTarget */
+/*      GL_PERSPECTIVE_CORRECTION_HINT */
+/*      GL_POINT_SMOOTH_HINT */
+/*      GL_LINE_SMOOTH_HINT */
+/*      GL_POLYGON_SMOOTH_HINT */
+/*      GL_FOG_HINT */
+
+/* IndexMaterialParameterSGI */
+/*      GL_INDEX_OFFSET */
+
+/* IndexPointerType */
+/*      GL_SHORT */
+/*      GL_INT */
+/*      GL_FLOAT */
+/*      GL_DOUBLE */
+
+/* IndexFunctionSGI */
+/*      GL_NEVER */
+/*      GL_LESS */
+/*      GL_EQUAL */
+/*      GL_LEQUAL */
+/*      GL_GREATER */
+/*      GL_NOTEQUAL */
+/*      GL_GEQUAL */
+/*      GL_ALWAYS */
+
+/* LightModelParameter */
+/*      GL_LIGHT_MODEL_AMBIENT */
+/*      GL_LIGHT_MODEL_LOCAL_VIEWER */
+/*      GL_LIGHT_MODEL_TWO_SIDE */
+
+/* LightParameter */
+#define GL_AMBIENT                        0x1200
+#define GL_DIFFUSE                        0x1201
+#define GL_SPECULAR                       0x1202
+#define GL_POSITION                       0x1203
+#define GL_SPOT_DIRECTION                 0x1204
+#define GL_SPOT_EXPONENT                  0x1205
+#define GL_SPOT_CUTOFF                    0x1206
+#define GL_CONSTANT_ATTENUATION           0x1207
+#define GL_LINEAR_ATTENUATION             0x1208
+#define GL_QUADRATIC_ATTENUATION          0x1209
+
+/* ListMode */
+#define GL_COMPILE                        0x1300
+#define GL_COMPILE_AND_EXECUTE            0x1301
+
+/* DataType */
+#define GL_BYTE                           0x1400
+#define GL_UNSIGNED_BYTE                  0x1401
+#define GL_SHORT                          0x1402
+#define GL_UNSIGNED_SHORT                 0x1403
+#define GL_INT                            0x1404
+#define GL_UNSIGNED_INT                   0x1405
+#define GL_FLOAT                          0x1406
+#define GL_2_BYTES                        0x1407
+#define GL_3_BYTES                        0x1408
+#define GL_4_BYTES                        0x1409
+#define GL_DOUBLE                         0x140A
+#define GL_DOUBLE_EXT                     0x140A
+
+/* ListNameType */
+/*      GL_BYTE */
+/*      GL_UNSIGNED_BYTE */
+/*      GL_SHORT */
+/*      GL_UNSIGNED_SHORT */
+/*      GL_INT */
+/*      GL_UNSIGNED_INT */
+/*      GL_FLOAT */
+/*      GL_2_BYTES */
+/*      GL_3_BYTES */
+/*      GL_4_BYTES */
+
+/* LogicOp */
+#define GL_CLEAR                          0x1500
+#define GL_AND                            0x1501
+#define GL_AND_REVERSE                    0x1502
+#define GL_COPY                           0x1503
+#define GL_AND_INVERTED                   0x1504
+#define GL_NOOP                           0x1505
+#define GL_XOR                            0x1506
+#define GL_OR                             0x1507
+#define GL_NOR                            0x1508
+#define GL_EQUIV                          0x1509
+#define GL_INVERT                         0x150A
+#define GL_OR_REVERSE                     0x150B
+#define GL_COPY_INVERTED                  0x150C
+#define GL_OR_INVERTED                    0x150D
+#define GL_NAND                           0x150E
+#define GL_SET                            0x150F
+
+/* MapTarget */
+/*      GL_MAP1_COLOR_4 */
+/*      GL_MAP1_INDEX */
+/*      GL_MAP1_NORMAL */
+/*      GL_MAP1_TEXTURE_COORD_1 */
+/*      GL_MAP1_TEXTURE_COORD_2 */
+/*      GL_MAP1_TEXTURE_COORD_3 */
+/*      GL_MAP1_TEXTURE_COORD_4 */
+/*      GL_MAP1_VERTEX_3 */
+/*      GL_MAP1_VERTEX_4 */
+/*      GL_MAP2_COLOR_4 */
+/*      GL_MAP2_INDEX */
+/*      GL_MAP2_NORMAL */
+/*      GL_MAP2_TEXTURE_COORD_1 */
+/*      GL_MAP2_TEXTURE_COORD_2 */
+/*      GL_MAP2_TEXTURE_COORD_3 */
+/*      GL_MAP2_TEXTURE_COORD_4 */
+/*      GL_MAP2_VERTEX_3 */
+/*      GL_MAP2_VERTEX_4 */
+
+/* MaterialFace */
+/*      GL_FRONT */
+/*      GL_BACK */
+/*      GL_FRONT_AND_BACK */
+
+/* MaterialParameter */
+#define GL_EMISSION                       0x1600
+#define GL_SHININESS                      0x1601
+#define GL_AMBIENT_AND_DIFFUSE            0x1602
+#define GL_COLOR_INDEXES                  0x1603
+/*      GL_AMBIENT */
+/*      GL_DIFFUSE */
+/*      GL_SPECULAR */
+
+/* MatrixMode */
+#define GL_MODELVIEW                      0x1700
+#define GL_PROJECTION                     0x1701
+#define GL_TEXTURE                        0x1702
+
+/* MeshMode1 */
+/*      GL_POINT */
+/*      GL_LINE */
+
+/* MeshMode2 */
+/*      GL_POINT */
+/*      GL_LINE */
+/*      GL_FILL */
+
+/* NormalPointerType */
+/*      GL_BYTE */
+/*      GL_SHORT */
+/*      GL_INT */
+/*      GL_FLOAT */
+/*      GL_DOUBLE */
+
+/* PixelCopyType */
+#define GL_COLOR                          0x1800
+#define GL_DEPTH                          0x1801
+#define GL_STENCIL                        0x1802
+
+/* PixelFormat */
+#define GL_COLOR_INDEX                    0x1900
+#define GL_STENCIL_INDEX                  0x1901
+#define GL_DEPTH_COMPONENT                0x1902
+#define GL_RED                            0x1903
+#define GL_GREEN                          0x1904
+#define GL_BLUE                           0x1905
+#define GL_ALPHA                          0x1906
+#define GL_RGB                            0x1907
+#define GL_RGBA                           0x1908
+#define GL_LUMINANCE                      0x1909
+#define GL_LUMINANCE_ALPHA                0x190A
+/*      GL_ABGR_EXT */
+
+/* PixelMap */
+/*      GL_PIXEL_MAP_I_TO_I */
+/*      GL_PIXEL_MAP_S_TO_S */
+/*      GL_PIXEL_MAP_I_TO_R */
+/*      GL_PIXEL_MAP_I_TO_G */
+/*      GL_PIXEL_MAP_I_TO_B */
+/*      GL_PIXEL_MAP_I_TO_A */
+/*      GL_PIXEL_MAP_R_TO_R */
+/*      GL_PIXEL_MAP_G_TO_G */
+/*      GL_PIXEL_MAP_B_TO_B */
+/*      GL_PIXEL_MAP_A_TO_A */
+
+/* PixelStoreParameter */
+/*      GL_UNPACK_SWAP_BYTES */
+/*      GL_UNPACK_LSB_FIRST */
+/*      GL_UNPACK_ROW_LENGTH */
+/*      GL_UNPACK_SKIP_ROWS */
+/*      GL_UNPACK_SKIP_PIXELS */
+/*      GL_UNPACK_ALIGNMENT */
+/*      GL_PACK_SWAP_BYTES */
+/*      GL_PACK_LSB_FIRST */
+/*      GL_PACK_ROW_LENGTH */
+/*      GL_PACK_SKIP_ROWS */
+/*      GL_PACK_SKIP_PIXELS */
+/*      GL_PACK_ALIGNMENT */
+
+/* PixelTransferParameter */
+/*      GL_MAP_COLOR */
+/*      GL_MAP_STENCIL */
+/*      GL_INDEX_SHIFT */
+/*      GL_INDEX_OFFSET */
+/*      GL_RED_SCALE */
+/*      GL_RED_BIAS */
+/*      GL_GREEN_SCALE */
+/*      GL_GREEN_BIAS */
+/*      GL_BLUE_SCALE */
+/*      GL_BLUE_BIAS */
+/*      GL_ALPHA_SCALE */
+/*      GL_ALPHA_BIAS */
+/*      GL_DEPTH_SCALE */
+/*      GL_DEPTH_BIAS */
+
+/* PixelType */
+#define GL_BITMAP                         0x1A00
+/*      GL_BYTE */
+/*      GL_UNSIGNED_BYTE */
+/*      GL_SHORT */
+/*      GL_UNSIGNED_SHORT */
+/*      GL_INT */
+/*      GL_UNSIGNED_INT */
+/*      GL_FLOAT */
+/*      GL_UNSIGNED_BYTE_3_3_2_EXT */
+/*      GL_UNSIGNED_SHORT_4_4_4_4_EXT */
+/*      GL_UNSIGNED_SHORT_5_5_5_1_EXT */
+/*      GL_UNSIGNED_INT_8_8_8_8_EXT */
+/*      GL_UNSIGNED_INT_10_10_10_2_EXT */
+
+/* PolygonMode */
+#define GL_POINT                          0x1B00
+#define GL_LINE                           0x1B01
+#define GL_FILL                           0x1B02
+
+/* ReadBufferMode */
+/*      GL_FRONT_LEFT */
+/*      GL_FRONT_RIGHT */
+/*      GL_BACK_LEFT */
+/*      GL_BACK_RIGHT */
+/*      GL_FRONT */
+/*      GL_BACK */
+/*      GL_LEFT */
+/*      GL_RIGHT */
+/*      GL_AUX0 */
+/*      GL_AUX1 */
+/*      GL_AUX2 */
+/*      GL_AUX3 */
+/*      GL_AUX4 */
+/*      GL_AUX5 */
+/*      GL_AUX6 */
+/*      GL_AUX7 */
+
+/* RenderingMode */
+#define GL_RENDER                         0x1C00
+#define GL_FEEDBACK                       0x1C01
+#define GL_SELECT                         0x1C02
+
+/* ShadingModel */
+#define GL_FLAT                           0x1D00
+#define GL_SMOOTH                         0x1D01
+
+/* StencilFunction */
+/*      GL_NEVER */
+/*      GL_LESS */
+/*      GL_EQUAL */
+/*      GL_LEQUAL */
+/*      GL_GREATER */
+/*      GL_NOTEQUAL */
+/*      GL_GEQUAL */
+/*      GL_ALWAYS */
+
+/* StencilOp */
+/*      GL_ZERO */
+#define GL_KEEP                           0x1E00
+#define GL_REPLACE                        0x1E01
+#define GL_INCR                           0x1E02
+#define GL_DECR                           0x1E03
+/*      GL_INVERT */
+
+/* StringName */
+#define GL_VENDOR                         0x1F00
+#define GL_RENDERER                       0x1F01
+#define GL_VERSION                        0x1F02
+#define GL_EXTENSIONS                     0x1F03
+
+/* TexCoordPointerType */
+/*      GL_SHORT */
+/*      GL_INT */
+/*      GL_FLOAT */
+/*      GL_DOUBLE */
+
+/* TextureCoordName */
+#define GL_S                              0x2000
+#define GL_T                              0x2001
+#define GL_R                              0x2002
+#define GL_Q                              0x2003
+
+/* TextureEnvMode */
+#define GL_MODULATE                       0x2100
+#define GL_DECAL                          0x2101
+/*      GL_BLEND */
+/*      GL_REPLACE */
+/*      GL_ADD */
+
+/* TextureEnvParameter */
+#define GL_TEXTURE_ENV_MODE               0x2200
+#define GL_TEXTURE_ENV_COLOR              0x2201
+
+/* TextureEnvTarget */
+#define GL_TEXTURE_ENV                    0x2300
+
+/* TextureGenMode */
+#define GL_EYE_LINEAR                     0x2400
+#define GL_OBJECT_LINEAR                  0x2401
+#define GL_SPHERE_MAP                     0x2402
+
+/* TextureGenParameter */
+#define GL_TEXTURE_GEN_MODE               0x2500
+#define GL_OBJECT_PLANE                   0x2501
+#define GL_EYE_PLANE                      0x2502
+
+/* TextureMagFilter */
+#define GL_NEAREST                        0x2600
+#define GL_LINEAR                         0x2601
+
+/* TextureMinFilter */
+/*      GL_NEAREST */
+/*      GL_LINEAR */
+#define GL_NEAREST_MIPMAP_NEAREST         0x2700
+#define GL_LINEAR_MIPMAP_NEAREST          0x2701
+#define GL_NEAREST_MIPMAP_LINEAR          0x2702
+#define GL_LINEAR_MIPMAP_LINEAR           0x2703
+
+/* TextureParameterName */
+#define GL_TEXTURE_MAG_FILTER             0x2800
+#define GL_TEXTURE_MIN_FILTER             0x2801
+#define GL_TEXTURE_WRAP_S                 0x2802
+#define GL_TEXTURE_WRAP_T                 0x2803
+/*      GL_TEXTURE_BORDER_COLOR */
+/*      GL_TEXTURE_PRIORITY */
+
+/* TextureTarget */
+/*      GL_TEXTURE_1D */
+/*      GL_TEXTURE_2D */
+#define GL_PROXY_TEXTURE_1D               0x8063
+#define GL_PROXY_TEXTURE_2D               0x8064
+
+/* TextureWrapMode */
+#define GL_CLAMP                          0x2900
+#define GL_REPEAT                         0x2901
+
+/* PixelInternalFormat */
+#define GL_R3_G3_B2                       0x2A10
+#define GL_ALPHA4                         0x803B
+#define GL_ALPHA8                         0x803C
+#define GL_ALPHA12                        0x803D
+#define GL_ALPHA16                        0x803E
+#define GL_LUMINANCE4                     0x803F
+#define GL_LUMINANCE8                     0x8040
+#define GL_LUMINANCE12                    0x8041
+#define GL_LUMINANCE16                    0x8042
+#define GL_LUMINANCE4_ALPHA4              0x8043
+#define GL_LUMINANCE6_ALPHA2              0x8044
+#define GL_LUMINANCE8_ALPHA8              0x8045
+#define GL_LUMINANCE12_ALPHA4             0x8046
+#define GL_LUMINANCE12_ALPHA12            0x8047
+#define GL_LUMINANCE16_ALPHA16            0x8048
+#define GL_INTENSITY                      0x8049
+#define GL_INTENSITY4                     0x804A
+#define GL_INTENSITY8                     0x804B
+#define GL_INTENSITY12                    0x804C
+#define GL_INTENSITY16                    0x804D
+#define GL_RGB4                           0x804F
+#define GL_RGB5                           0x8050
+#define GL_RGB8                           0x8051
+#define GL_RGB10                          0x8052
+#define GL_RGB12                          0x8053
+#define GL_RGB16                          0x8054
+#define GL_RGBA2                          0x8055
+#define GL_RGBA4                          0x8056
+#define GL_RGB5_A1                        0x8057
+#define GL_RGBA8                          0x8058
+#define GL_RGB10_A2                       0x8059
+#define GL_RGBA12                         0x805A
+#define GL_RGBA16                         0x805B
+
+/* InterleavedArrayFormat */
+#define GL_V2F                            0x2A20
+#define GL_V3F                            0x2A21
+#define GL_C4UB_V2F                       0x2A22
+#define GL_C4UB_V3F                       0x2A23
+#define GL_C3F_V3F                        0x2A24
+#define GL_N3F_V3F                        0x2A25
+#define GL_C4F_N3F_V3F                    0x2A26
+#define GL_T2F_V3F                        0x2A27
+#define GL_T4F_V4F                        0x2A28
+#define GL_T2F_C4UB_V3F                   0x2A29
+#define GL_T2F_C3F_V3F                    0x2A2A
+#define GL_T2F_N3F_V3F                    0x2A2B
+#define GL_T2F_C4F_N3F_V3F                0x2A2C
+#define GL_T4F_C4F_N3F_V4F                0x2A2D
+
+/* VertexPointerType */
+/*      GL_SHORT */
+/*      GL_INT */
+/*      GL_FLOAT */
+/*      GL_DOUBLE */
+
+/* ClipPlaneName */
+#define GL_CLIP_PLANE0                    0x3000
+#define GL_CLIP_PLANE1                    0x3001
+#define GL_CLIP_PLANE2                    0x3002
+#define GL_CLIP_PLANE3                    0x3003
+#define GL_CLIP_PLANE4                    0x3004
+#define GL_CLIP_PLANE5                    0x3005
+
+/* LightName */
+#define GL_LIGHT0                         0x4000
+#define GL_LIGHT1                         0x4001
+#define GL_LIGHT2                         0x4002
+#define GL_LIGHT3                         0x4003
+#define GL_LIGHT4                         0x4004
+#define GL_LIGHT5                         0x4005
+#define GL_LIGHT6                         0x4006
+#define GL_LIGHT7                         0x4007
+
+/* EXT_abgr */
+#define GL_ABGR_EXT                       0x8000
+
+/* EXT_blend_subtract */
+#define GL_FUNC_SUBTRACT_EXT              0x800A
+#define GL_FUNC_REVERSE_SUBTRACT_EXT      0x800B
+
+/* EXT_packed_pixels */
+#define GL_UNSIGNED_BYTE_3_3_2_EXT        0x8032
+#define GL_UNSIGNED_SHORT_4_4_4_4_EXT     0x8033
+#define GL_UNSIGNED_SHORT_5_5_5_1_EXT     0x8034
+#define GL_UNSIGNED_INT_8_8_8_8_EXT       0x8035
+#define GL_UNSIGNED_INT_10_10_10_2_EXT    0x8036
+
+/* OpenGL12 */
+#define GL_PACK_SKIP_IMAGES               0x806B
+#define GL_PACK_IMAGE_HEIGHT              0x806C
+#define GL_UNPACK_SKIP_IMAGES             0x806D
+#define GL_UNPACK_IMAGE_HEIGHT            0x806E
+#define GL_TEXTURE_3D                     0x806F
+#define GL_PROXY_TEXTURE_3D               0x8070
+#define GL_TEXTURE_DEPTH                  0x8071
+#define GL_TEXTURE_WRAP_R                 0x8072
+#define GL_MAX_3D_TEXTURE_SIZE            0x8073
+#define GL_BGR                            0x80E0
+#define GL_BGRA                           0x80E1
+#define GL_UNSIGNED_BYTE_3_3_2            0x8032
+#define GL_UNSIGNED_BYTE_2_3_3_REV        0x8362
+#define GL_UNSIGNED_SHORT_5_6_5           0x8363
+#define GL_UNSIGNED_SHORT_5_6_5_REV       0x8364
+#define GL_UNSIGNED_SHORT_4_4_4_4         0x8033
+#define GL_UNSIGNED_SHORT_4_4_4_4_REV     0x8365
+#define GL_UNSIGNED_SHORT_5_5_5_1         0x8034
+#define GL_UNSIGNED_SHORT_1_5_5_5_REV     0x8366
+#define GL_UNSIGNED_INT_8_8_8_8           0x8035
+#define GL_UNSIGNED_INT_8_8_8_8_REV       0x8367
+#define GL_UNSIGNED_INT_10_10_10_2        0x8036
+#define GL_UNSIGNED_INT_2_10_10_10_REV    0x8368
+#define GL_RESCALE_NORMAL                 0x803A
+#define GL_LIGHT_MODEL_COLOR_CONTROL      0x81F8
+#define GL_SINGLE_COLOR                   0x81F9
+#define GL_SEPARATE_SPECULAR_COLOR        0x81FA
+#define GL_CLAMP_TO_EDGE                  0x812F
+#define GL_TEXTURE_MIN_LOD                0x813A
+#define GL_TEXTURE_MAX_LOD                0x813B
+#define GL_TEXTURE_BASE_LEVEL             0x813C
+#define GL_TEXTURE_MAX_LEVEL              0x813D
+#define GL_MAX_ELEMENTS_VERTICES          0x80E8
+#define GL_MAX_ELEMENTS_INDICES           0x80E9
+#define GL_ALIASED_POINT_SIZE_RANGE       0x846D
+#define GL_ALIASED_LINE_WIDTH_RANGE       0x846E
+
+/* OpenGL13 */
+#define GL_ACTIVE_TEXTURE                 0x84E0
+#define GL_CLIENT_ACTIVE_TEXTURE          0x84E1
+#define GL_MAX_TEXTURE_UNITS              0x84E2
+#define GL_TEXTURE0                       0x84C0
+#define GL_TEXTURE1                       0x84C1
+#define GL_TEXTURE2                       0x84C2
+#define GL_TEXTURE3                       0x84C3
+#define GL_TEXTURE4                       0x84C4
+#define GL_TEXTURE5                       0x84C5
+#define GL_TEXTURE6                       0x84C6
+#define GL_TEXTURE7                       0x84C7
+#define GL_TEXTURE8                       0x84C8
+#define GL_TEXTURE9                       0x84C9
+#define GL_TEXTURE10                      0x84CA
+#define GL_TEXTURE11                      0x84CB
+#define GL_TEXTURE12                      0x84CC
+#define GL_TEXTURE13                      0x84CD
+#define GL_TEXTURE14                      0x84CE
+#define GL_TEXTURE15                      0x84CF
+#define GL_TEXTURE16                      0x84D0
+#define GL_TEXTURE17                      0x84D1
+#define GL_TEXTURE18                      0x84D2
+#define GL_TEXTURE19                      0x84D3
+#define GL_TEXTURE20                      0x84D4
+#define GL_TEXTURE21                      0x84D5
+#define GL_TEXTURE22                      0x84D6
+#define GL_TEXTURE23                      0x84D7
+#define GL_TEXTURE24                      0x84D8
+#define GL_TEXTURE25                      0x84D9
+#define GL_TEXTURE26                      0x84DA
+#define GL_TEXTURE27                      0x84DB
+#define GL_TEXTURE28                      0x84DC
+#define GL_TEXTURE29                      0x84DD
+#define GL_TEXTURE30                      0x84DE
+#define GL_TEXTURE31                      0x84DF
+#define GL_NORMAL_MAP                     0x8511
+#define GL_REFLECTION_MAP                 0x8512
+#define GL_TEXTURE_CUBE_MAP               0x8513
+#define GL_TEXTURE_BINDING_CUBE_MAP       0x8514
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X    0x8515
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X    0x8516
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y    0x8517
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y    0x8518
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z    0x8519
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z    0x851A
+#define GL_PROXY_TEXTURE_CUBE_MAP         0x851B
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE      0x851C
+#define GL_COMBINE                        0x8570
+#define GL_COMBINE_RGB                    0x8571
+#define GL_COMBINE_ALPHA                  0x8572
+#define GL_RGB_SCALE                      0x8573
+#define GL_ADD_SIGNED                     0x8574
+#define GL_INTERPOLATE                    0x8575
+#define GL_CONSTANT                       0x8576
+#define GL_PRIMARY_COLOR                  0x8577
+#define GL_PREVIOUS                       0x8578
+#define GL_SOURCE0_RGB                    0x8580
+#define GL_SOURCE1_RGB                    0x8581
+#define GL_SOURCE2_RGB                    0x8582
+#define GL_SOURCE0_ALPHA                  0x8588
+#define GL_SOURCE1_ALPHA                  0x8589
+#define GL_SOURCE2_ALPHA                  0x858A
+#define GL_OPERAND0_RGB                   0x8590
+#define GL_OPERAND1_RGB                   0x8591
+#define GL_OPERAND2_RGB                   0x8592
+#define GL_OPERAND0_ALPHA                 0x8598
+#define GL_OPERAND1_ALPHA                 0x8599
+#define GL_OPERAND2_ALPHA                 0x859A
+#define GL_SUBTRACT                       0x84E7
+#define GL_TRANSPOSE_MODELVIEW_MATRIX     0x84E3
+#define GL_TRANSPOSE_PROJECTION_MATRIX    0x84E4
+#define GL_TRANSPOSE_TEXTURE_MATRIX       0x84E5
+#define GL_TRANSPOSE_COLOR_MATRIX         0x84E6
+#define GL_COMPRESSED_ALPHA               0x84E9
+#define GL_COMPRESSED_LUMINANCE           0x84EA
+#define GL_COMPRESSED_LUMINANCE_ALPHA     0x84EB
+#define GL_COMPRESSED_INTENSITY           0x84EC
+#define GL_COMPRESSED_RGB                 0x84ED
+#define GL_COMPRESSED_RGBA                0x84EE
+#define GL_TEXTURE_COMPRESSION_HINT       0x84EF
+#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE  0x86A0
+#define GL_TEXTURE_COMPRESSED             0x86A1
+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2
+#define GL_COMPRESSED_TEXTURE_FORMATS     0x86A3
+#define GL_DOT3_RGB                       0x86AE
+#define GL_DOT3_RGBA                      0x86AF
+#define GL_CLAMP_TO_BORDER                0x812D
+#define GL_MULTISAMPLE                    0x809D
+#define GL_SAMPLE_ALPHA_TO_COVERAGE       0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE            0x809F
+#define GL_SAMPLE_COVERAGE                0x80A0
+#define GL_SAMPLE_BUFFERS                 0x80A8
+#define GL_SAMPLES                        0x80A9
+#define GL_SAMPLE_COVERAGE_VALUE          0x80AA
+#define GL_SAMPLE_COVERAGE_INVERT         0x80AB
+#define GL_MULTISAMPLE_BIT                0x20000000
+
+/* EXT_vertex_array */
+#define GL_VERTEX_ARRAY_EXT               0x8074
+#define GL_NORMAL_ARRAY_EXT               0x8075
+#define GL_COLOR_ARRAY_EXT                0x8076
+#define GL_INDEX_ARRAY_EXT                0x8077
+#define GL_TEXTURE_COORD_ARRAY_EXT        0x8078
+#define GL_EDGE_FLAG_ARRAY_EXT            0x8079
+#define GL_VERTEX_ARRAY_SIZE_EXT          0x807A
+#define GL_VERTEX_ARRAY_TYPE_EXT          0x807B
+#define GL_VERTEX_ARRAY_STRIDE_EXT        0x807C
+#define GL_VERTEX_ARRAY_COUNT_EXT         0x807D
+#define GL_NORMAL_ARRAY_TYPE_EXT          0x807E
+#define GL_NORMAL_ARRAY_STRIDE_EXT        0x807F
+#define GL_NORMAL_ARRAY_COUNT_EXT         0x8080
+#define GL_COLOR_ARRAY_SIZE_EXT           0x8081
+#define GL_COLOR_ARRAY_TYPE_EXT           0x8082
+#define GL_COLOR_ARRAY_STRIDE_EXT         0x8083
+#define GL_COLOR_ARRAY_COUNT_EXT          0x8084
+#define GL_INDEX_ARRAY_TYPE_EXT           0x8085
+#define GL_INDEX_ARRAY_STRIDE_EXT         0x8086
+#define GL_INDEX_ARRAY_COUNT_EXT          0x8087
+#define GL_TEXTURE_COORD_ARRAY_SIZE_EXT   0x8088
+#define GL_TEXTURE_COORD_ARRAY_TYPE_EXT   0x8089
+#define GL_TEXTURE_COORD_ARRAY_STRIDE_EXT 0x808A
+#define GL_TEXTURE_COORD_ARRAY_COUNT_EXT  0x808B
+#define GL_EDGE_FLAG_ARRAY_STRIDE_EXT     0x808C
+#define GL_EDGE_FLAG_ARRAY_COUNT_EXT      0x808D
+#define GL_VERTEX_ARRAY_POINTER_EXT       0x808E
+#define GL_NORMAL_ARRAY_POINTER_EXT       0x808F
+#define GL_COLOR_ARRAY_POINTER_EXT        0x8090
+#define GL_INDEX_ARRAY_POINTER_EXT        0x8091
+#define GL_TEXTURE_COORD_ARRAY_POINTER_EXT 0x8092
+#define GL_EDGE_FLAG_ARRAY_POINTER_EXT    0x8093
+
+/* SGIS_texture_lod */
+#define GL_TEXTURE_MIN_LOD_SGIS           0x813A
+#define GL_TEXTURE_MAX_LOD_SGIS           0x813B
+#define GL_TEXTURE_BASE_LEVEL_SGIS        0x813C
+#define GL_TEXTURE_MAX_LEVEL_SGIS         0x813D
+
+/* EXT_shared_texture_palette */
+#define GL_SHARED_TEXTURE_PALETTE_EXT     0x81FB
+
+/* EXT_rescale_normal */
+#define GL_RESCALE_NORMAL_EXT             0x803A
+
+/* SGIX_shadow */
+#define GL_TEXTURE_COMPARE_SGIX           0x819A
+#define GL_TEXTURE_COMPARE_OPERATOR_SGIX  0x819B
+#define GL_TEXTURE_LEQUAL_R_SGIX          0x819C
+#define GL_TEXTURE_GEQUAL_R_SGIX          0x819D
+
+/* SGIX_depth_texture */
+#define GL_DEPTH_COMPONENT16_SGIX         0x81A5
+#define GL_DEPTH_COMPONENT24_SGIX         0x81A6
+#define GL_DEPTH_COMPONENT32_SGIX         0x81A7
+
+/* SGIS_generate_mipmap */
+#define GL_GENERATE_MIPMAP_SGIS           0x8191
+#define GL_GENERATE_MIPMAP_HINT_SGIS      0x8192
+
+/* OpenGL14 */
+#define GL_POINT_SIZE_MIN                 0x8126
+#define GL_POINT_SIZE_MAX                 0x8127
+#define GL_POINT_FADE_THRESHOLD_SIZE      0x8128
+#define GL_POINT_DISTANCE_ATTENUATION     0x8129
+#define GL_FOG_COORDINATE_SOURCE          0x8450
+#define GL_FOG_COORDINATE                 0x8451
+#define GL_FRAGMENT_DEPTH                 0x8452
+#define GL_CURRENT_FOG_COORDINATE         0x8453
+#define GL_FOG_COORDINATE_ARRAY_TYPE      0x8454
+#define GL_FOG_COORDINATE_ARRAY_STRIDE    0x8455
+#define GL_FOG_COORDINATE_ARRAY_POINTER   0x8456
+#define GL_FOG_COORDINATE_ARRAY           0x8457
+#define GL_COLOR_SUM                      0x8458
+#define GL_CURRENT_SECONDARY_COLOR        0x8459
+#define GL_SECONDARY_COLOR_ARRAY_SIZE     0x845A
+#define GL_SECONDARY_COLOR_ARRAY_TYPE     0x845B
+#define GL_SECONDARY_COLOR_ARRAY_STRIDE   0x845C
+#define GL_SECONDARY_COLOR_ARRAY_POINTER  0x845D
+#define GL_SECONDARY_COLOR_ARRAY          0x845E
+#define GL_INCR_WRAP                      0x8507
+#define GL_DECR_WRAP                      0x8508
+#define GL_MAX_TEXTURE_LOD_BIAS           0x84FD
+#define GL_TEXTURE_FILTER_CONTROL         0x8500
+#define GL_TEXTURE_LOD_BIAS               0x8501
+#define GL_GENERATE_MIPMAP                0x8191
+#define GL_GENERATE_MIPMAP_HINT           0x8192
+#define GL_CONSTANT_COLOR                 0x8001
+#define GL_ONE_MINUS_CONSTANT_COLOR       0x8002
+#define GL_CONSTANT_ALPHA                 0x8003
+#define GL_ONE_MINUS_CONSTANT_ALPHA       0x8004
+#define GL_BLEND_COLOR                    0x8005
+#define GL_BLEND_EQUATION                 0x8009
+#define GL_FUNC_ADD                       0x8006
+#define GL_MIN                            0x8007
+#define GL_MAX                            0x8008
+#define GL_FUNC_SUBTRACT                  0x800A
+#define GL_FUNC_REVERSE_SUBTRACT          0x800B
+#define GL_BLEND_DST_RGB                  0x80C8
+#define GL_BLEND_SRC_RGB                  0x80C9
+#define GL_BLEND_DST_ALPHA                0x80CA
+#define GL_BLEND_SRC_ALPHA                0x80CB
+#define GL_MIRRORED_REPEAT                0x8370
+#define GL_DEPTH_COMPONENT16              0x81A5
+#define GL_DEPTH_COMPONENT24              0x81A6
+#define GL_DEPTH_COMPONENT32              0x81A7
+#define GL_TEXTURE_DEPTH_SIZE             0x884A
+#define GL_DEPTH_TEXTURE_MODE             0x884B
+#define GL_TEXTURE_COMPARE_MODE           0x884C
+#define GL_TEXTURE_COMPARE_FUNC           0x884D
+#define GL_COMPARE_R_TO_TEXTURE           0x884E
+
+/* OpenGL15 */
+#define GL_FOG_COORD_SRC                  0x8450
+#define GL_FOG_COORD                      0x8451
+#define GL_CURRENT_FOG_COORD              0x8453
+#define GL_FOG_COORD_ARRAY_TYPE           0x8454
+#define GL_FOG_COORD_ARRAY_STRIDE         0x8455
+#define GL_FOG_COORD_ARRAY_POINTER        0x8456
+#define GL_FOG_COORD_ARRAY                0x8457
+#define GL_SRC0_RGB                       0x8580
+#define GL_SRC1_RGB                       0x8581
+#define GL_SRC2_RGB                       0x8582
+#define GL_SRC0_ALPHA                     0x8588
+#define GL_SRC1_ALPHA                     0x8589
+#define GL_SRC2_ALPHA                     0x858A
+#define GL_QUERY_COUNTER_BITS             0x8864
+#define GL_CURRENT_QUERY                  0x8865
+#define GL_QUERY_RESULT                   0x8866
+#define GL_QUERY_RESULT_AVAILABLE         0x8867
+#define GL_SAMPLES_PASSED                 0x8914
+#define GL_ARRAY_BUFFER                   0x8892
+#define GL_ELEMENT_ARRAY_BUFFER           0x8893
+#define GL_ARRAY_BUFFER_BINDING           0x8894
+#define GL_ELEMENT_ARRAY_BUFFER_BINDING   0x8895
+#define GL_VERTEX_ARRAY_BUFFER_BINDING    0x8896
+#define GL_NORMAL_ARRAY_BUFFER_BINDING    0x8897
+#define GL_COLOR_ARRAY_BUFFER_BINDING     0x8898
+#define GL_INDEX_ARRAY_BUFFER_BINDING     0x8899
+#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING 0x889A
+#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING 0x889B
+#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING 0x889C
+#define GL_FOG_COORD_ARRAY_BUFFER_BINDING 0x889D
+#define GL_STREAM_DRAW                    0x88E0
+#define GL_STREAM_READ                    0x88E1
+#define GL_STREAM_COPY                    0x88E2
+#define GL_STATIC_DRAW                    0x88E4
+#define GL_STATIC_READ                    0x88E5
+#define GL_STATIC_COPY                    0x88E6
+#define GL_DYNAMIC_DRAW                   0x88E8
+#define GL_DYNAMIC_READ                   0x88E9
+#define GL_DYNAMIC_COPY                   0x88EA
+#define GL_READ_ONLY                      0x88B8
+#define GL_WRITE_ONLY                     0x88B9
+#define GL_READ_WRITE                     0x88BA
+#define GL_BUFFER_SIZE                    0x8764
+#define GL_BUFFER_USAGE                   0x8765
+#define GL_BUFFER_ACCESS                  0x88BB
+#define GL_BUFFER_MAPPED                  0x88BC
+#define GL_BUFFER_MAP_POINTER             0x88BD
+
+/* OpenGL20 */
+#define GL_CURRENT_PROGRAM                0x8B8D
+#define GL_SHADER_TYPE                    0x8B4F
+#define GL_DELETE_STATUS                  0x8B80
+#define GL_COMPILE_STATUS                 0x8B81
+#define GL_LINK_STATUS                    0x8B82
+#define GL_VALIDATE_STATUS                0x8B83
+#define GL_INFO_LOG_LENGTH                0x8B84
+#define GL_ATTACHED_SHADERS               0x8B85
+#define GL_ACTIVE_UNIFORMS                0x8B86
+#define GL_ACTIVE_UNIFORM_MAX_LENGTH      0x8B87
+#define GL_SHADER_SOURCE_LENGTH           0x8B88
+#define GL_FLOAT_VEC2                     0x8B50
+#define GL_FLOAT_VEC3                     0x8B51
+#define GL_FLOAT_VEC4                     0x8B52
+#define GL_INT_VEC2                       0x8B53
+#define GL_INT_VEC3                       0x8B54
+#define GL_INT_VEC4                       0x8B55
+#define GL_BOOL                           0x8B56
+#define GL_BOOL_VEC2                      0x8B57
+#define GL_BOOL_VEC3                      0x8B58
+#define GL_BOOL_VEC4                      0x8B59
+#define GL_FLOAT_MAT2                     0x8B5A
+#define GL_FLOAT_MAT3                     0x8B5B
+#define GL_FLOAT_MAT4                     0x8B5C
+#define GL_SAMPLER_1D                     0x8B5D
+#define GL_SAMPLER_2D                     0x8B5E
+#define GL_SAMPLER_3D                     0x8B5F
+#define GL_SAMPLER_CUBE                   0x8B60
+#define GL_SAMPLER_1D_SHADOW              0x8B61
+#define GL_SAMPLER_2D_SHADOW              0x8B62
+#define GL_SHADING_LANGUAGE_VERSION       0x8B8C
+#define GL_VERTEX_SHADER                  0x8B31
+#define GL_MAX_VERTEX_UNIFORM_COMPONENTS  0x8B4A
+#define GL_MAX_VARYING_FLOATS             0x8B4B
+#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C
+#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D
+#define GL_ACTIVE_ATTRIBUTES              0x8B89
+#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH    0x8B8A
+#define GL_FRAGMENT_SHADER                0x8B30
+#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49
+#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B
+#define GL_MAX_VERTEX_ATTRIBS             0x8869
+#define GL_VERTEX_ATTRIB_ARRAY_ENABLED    0x8622
+#define GL_VERTEX_ATTRIB_ARRAY_SIZE       0x8623
+#define GL_VERTEX_ATTRIB_ARRAY_STRIDE     0x8624
+#define GL_VERTEX_ATTRIB_ARRAY_TYPE       0x8625
+#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A
+#define GL_CURRENT_VERTEX_ATTRIB          0x8626
+#define GL_VERTEX_ATTRIB_ARRAY_POINTER    0x8645
+#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F
+#define GL_VERTEX_PROGRAM_POINT_SIZE      0x8642
+#define GL_VERTEX_PROGRAM_TWO_SIDE        0x8643
+#define GL_MAX_TEXTURE_COORDS             0x8871
+#define GL_MAX_TEXTURE_IMAGE_UNITS        0x8872
+#define GL_MAX_DRAW_BUFFERS               0x8824
+#define GL_DRAW_BUFFER0                   0x8825
+#define GL_DRAW_BUFFER1                   0x8826
+#define GL_DRAW_BUFFER2                   0x8827
+#define GL_DRAW_BUFFER3                   0x8828
+#define GL_DRAW_BUFFER4                   0x8829
+#define GL_DRAW_BUFFER5                   0x882A
+#define GL_DRAW_BUFFER6                   0x882B
+#define GL_DRAW_BUFFER7                   0x882C
+#define GL_DRAW_BUFFER8                   0x882D
+#define GL_DRAW_BUFFER9                   0x882E
+#define GL_DRAW_BUFFER10                  0x882F
+#define GL_DRAW_BUFFER11                  0x8830
+#define GL_DRAW_BUFFER12                  0x8831
+#define GL_DRAW_BUFFER13                  0x8832
+#define GL_DRAW_BUFFER14                  0x8833
+#define GL_DRAW_BUFFER15                  0x8834
+#define GL_POINT_SPRITE                   0x8861
+#define GL_COORD_REPLACE                  0x8862
+#define GL_POINT_SPRITE_COORD_ORIGIN      0x8CA0
+#define GL_LOWER_LEFT                     0x8CA1
+#define GL_UPPER_LEFT                     0x8CA2
+#define GL_STENCIL_BACK_FUNC              0x8800
+#define GL_STENCIL_BACK_VALUE_MASK        0x8CA4
+#define GL_STENCIL_BACK_REF               0x8CA3
+#define GL_STENCIL_BACK_FAIL              0x8801
+#define GL_STENCIL_BACK_PASS_DEPTH_FAIL   0x8802
+#define GL_STENCIL_BACK_PASS_DEPTH_PASS   0x8803
+#define GL_STENCIL_BACK_WRITEMASK         0x8CA5
+#define GL_BLEND_EQUATION_RGB             0x8009
+#define GL_BLEND_EQUATION_ALPHA           0x883D
+
+/* OpenGL21 */
+#define GL_PIXEL_PACK_BUFFER              0x88EB
+#define GL_PIXEL_UNPACK_BUFFER            0x88EC
+#define GL_PIXEL_PACK_BUFFER_BINDING      0x88ED
+#define GL_PIXEL_UNPACK_BUFFER_BINDING    0x88EF
+#define GL_SRGB                           0x8C40
+#define GL_SRGB8                          0x8C41
+#define GL_SRGB_ALPHA                     0x8C42
+#define GL_SRGB8_ALPHA8                   0x8C43
+#define GL_SLUMINANCE_ALPHA               0x8C44
+#define GL_SLUMINANCE8_ALPHA8             0x8C45
+#define GL_SLUMINANCE                     0x8C46
+#define GL_SLUMINANCE8                    0x8C47
+#define GL_COMPRESSED_SRGB                0x8C48
+#define GL_COMPRESSED_SRGB_ALPHA          0x8C49
+#define GL_COMPRESSED_SLUMINANCE          0x8C4A
+#define GL_COMPRESSED_SLUMINANCE_ALPHA    0x8C4B
+#define GL_FLOAT_MAT2x3                   0x8B65
+#define GL_FLOAT_MAT2x4                   0x8B66
+#define GL_FLOAT_MAT3x2                   0x8B67
+#define GL_FLOAT_MAT3x4                   0x8B68
+#define GL_FLOAT_MAT4x2                   0x8B69
+#define GL_FLOAT_MAT4x3                   0x8B6A
+#define GL_CURRENT_RASTER_SECONDARY_COLOR 0x845F
+
+/*************************************************************/
+
+GLAPI void GLAPIENTRY glNewList (GLuint list, GLenum mode);
+GLAPI void GLAPIENTRY glEndList (void);
+GLAPI void GLAPIENTRY glCallList (GLuint list);
+GLAPI void GLAPIENTRY glCallLists (GLsizei n, GLenum type, const GLvoid *lists);
+GLAPI void GLAPIENTRY glDeleteLists (GLuint list, GLsizei range);
+GLAPI GLuint GLAPIENTRY glGenLists (GLsizei range);
+GLAPI void GLAPIENTRY glListBase (GLuint base);
+GLAPI void GLAPIENTRY glBegin (GLenum mode);
+GLAPI void GLAPIENTRY glBitmap (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
+GLAPI void GLAPIENTRY glColor3b (GLbyte red, GLbyte green, GLbyte blue);
+GLAPI void GLAPIENTRY glColor3bv (const GLbyte *v);
+GLAPI void GLAPIENTRY glColor3d (GLdouble red, GLdouble green, GLdouble blue);
+GLAPI void GLAPIENTRY glColor3dv (const GLdouble *v);
+GLAPI void GLAPIENTRY glColor3f (GLfloat red, GLfloat green, GLfloat blue);
+GLAPI void GLAPIENTRY glColor3fv (const GLfloat *v);
+GLAPI void GLAPIENTRY glColor3i (GLint red, GLint green, GLint blue);
+GLAPI void GLAPIENTRY glColor3iv (const GLint *v);
+GLAPI void GLAPIENTRY glColor3s (GLshort red, GLshort green, GLshort blue);
+GLAPI void GLAPIENTRY glColor3sv (const GLshort *v);
+GLAPI void GLAPIENTRY glColor3ub (GLubyte red, GLubyte green, GLubyte blue);
+GLAPI void GLAPIENTRY glColor3ubv (const GLubyte *v);
+GLAPI void GLAPIENTRY glColor3ui (GLuint red, GLuint green, GLuint blue);
+GLAPI void GLAPIENTRY glColor3uiv (const GLuint *v);
+GLAPI void GLAPIENTRY glColor3us (GLushort red, GLushort green, GLushort blue);
+GLAPI void GLAPIENTRY glColor3usv (const GLushort *v);
+GLAPI void GLAPIENTRY glColor4b (GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
+GLAPI void GLAPIENTRY glColor4bv (const GLbyte *v);
+GLAPI void GLAPIENTRY glColor4d (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
+GLAPI void GLAPIENTRY glColor4dv (const GLdouble *v);
+GLAPI void GLAPIENTRY glColor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+GLAPI void GLAPIENTRY glColor4fv (const GLfloat *v);
+GLAPI void GLAPIENTRY glColor4i (GLint red, GLint green, GLint blue, GLint alpha);
+GLAPI void GLAPIENTRY glColor4iv (const GLint *v);
+GLAPI void GLAPIENTRY glColor4s (GLshort red, GLshort green, GLshort blue, GLshort alpha);
+GLAPI void GLAPIENTRY glColor4sv (const GLshort *v);
+GLAPI void GLAPIENTRY glColor4ub (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+GLAPI void GLAPIENTRY glColor4ubv (const GLubyte *v);
+GLAPI void GLAPIENTRY glColor4ui (GLuint red, GLuint green, GLuint blue, GLuint alpha);
+GLAPI void GLAPIENTRY glColor4uiv (const GLuint *v);
+GLAPI void GLAPIENTRY glColor4us (GLushort red, GLushort green, GLushort blue, GLushort alpha);
+GLAPI void GLAPIENTRY glColor4usv (const GLushort *v);
+GLAPI void GLAPIENTRY glEdgeFlag (GLboolean flag);
+GLAPI void GLAPIENTRY glEdgeFlagv (const GLboolean *flag);
+GLAPI void GLAPIENTRY glEnd (void);
+GLAPI void GLAPIENTRY glIndexd (GLdouble c);
+GLAPI void GLAPIENTRY glIndexdv (const GLdouble *c);
+GLAPI void GLAPIENTRY glIndexf (GLfloat c);
+GLAPI void GLAPIENTRY glIndexfv (const GLfloat *c);
+GLAPI void GLAPIENTRY glIndexi (GLint c);
+GLAPI void GLAPIENTRY glIndexiv (const GLint *c);
+GLAPI void GLAPIENTRY glIndexs (GLshort c);
+GLAPI void GLAPIENTRY glIndexsv (const GLshort *c);
+GLAPI void GLAPIENTRY glNormal3b (GLbyte nx, GLbyte ny, GLbyte nz);
+GLAPI void GLAPIENTRY glNormal3bv (const GLbyte *v);
+GLAPI void GLAPIENTRY glNormal3d (GLdouble nx, GLdouble ny, GLdouble nz);
+GLAPI void GLAPIENTRY glNormal3dv (const GLdouble *v);
+GLAPI void GLAPIENTRY glNormal3f (GLfloat nx, GLfloat ny, GLfloat nz);
+GLAPI void GLAPIENTRY glNormal3fv (const GLfloat *v);
+GLAPI void GLAPIENTRY glNormal3i (GLint nx, GLint ny, GLint nz);
+GLAPI void GLAPIENTRY glNormal3iv (const GLint *v);
+GLAPI void GLAPIENTRY glNormal3s (GLshort nx, GLshort ny, GLshort nz);
+GLAPI void GLAPIENTRY glNormal3sv (const GLshort *v);
+GLAPI void GLAPIENTRY glRasterPos2d (GLdouble x, GLdouble y);
+GLAPI void GLAPIENTRY glRasterPos2dv (const GLdouble *v);
+GLAPI void GLAPIENTRY glRasterPos2f (GLfloat x, GLfloat y);
+GLAPI void GLAPIENTRY glRasterPos2fv (const GLfloat *v);
+GLAPI void GLAPIENTRY glRasterPos2i (GLint x, GLint y);
+GLAPI void GLAPIENTRY glRasterPos2iv (const GLint *v);
+GLAPI void GLAPIENTRY glRasterPos2s (GLshort x, GLshort y);
+GLAPI void GLAPIENTRY glRasterPos2sv (const GLshort *v);
+GLAPI void GLAPIENTRY glRasterPos3d (GLdouble x, GLdouble y, GLdouble z);
+GLAPI void GLAPIENTRY glRasterPos3dv (const GLdouble *v);
+GLAPI void GLAPIENTRY glRasterPos3f (GLfloat x, GLfloat y, GLfloat z);
+GLAPI void GLAPIENTRY glRasterPos3fv (const GLfloat *v);
+GLAPI void GLAPIENTRY glRasterPos3i (GLint x, GLint y, GLint z);
+GLAPI void GLAPIENTRY glRasterPos3iv (const GLint *v);
+GLAPI void GLAPIENTRY glRasterPos3s (GLshort x, GLshort y, GLshort z);
+GLAPI void GLAPIENTRY glRasterPos3sv (const GLshort *v);
+GLAPI void GLAPIENTRY glRasterPos4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+GLAPI void GLAPIENTRY glRasterPos4dv (const GLdouble *v);
+GLAPI void GLAPIENTRY glRasterPos4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GLAPI void GLAPIENTRY glRasterPos4fv (const GLfloat *v);
+GLAPI void GLAPIENTRY glRasterPos4i (GLint x, GLint y, GLint z, GLint w);
+GLAPI void GLAPIENTRY glRasterPos4iv (const GLint *v);
+GLAPI void GLAPIENTRY glRasterPos4s (GLshort x, GLshort y, GLshort z, GLshort w);
+GLAPI void GLAPIENTRY glRasterPos4sv (const GLshort *v);
+GLAPI void GLAPIENTRY glRectd (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
+GLAPI void GLAPIENTRY glRectdv (const GLdouble *v1, const GLdouble *v2);
+GLAPI void GLAPIENTRY glRectf (GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
+GLAPI void GLAPIENTRY glRectfv (const GLfloat *v1, const GLfloat *v2);
+GLAPI void GLAPIENTRY glRecti (GLint x1, GLint y1, GLint x2, GLint y2);
+GLAPI void GLAPIENTRY glRectiv (const GLint *v1, const GLint *v2);
+GLAPI void GLAPIENTRY glRects (GLshort x1, GLshort y1, GLshort x2, GLshort y2);
+GLAPI void GLAPIENTRY glRectsv (const GLshort *v1, const GLshort *v2);
+GLAPI void GLAPIENTRY glTexCoord1d (GLdouble s);
+GLAPI void GLAPIENTRY glTexCoord1dv (const GLdouble *v);
+GLAPI void GLAPIENTRY glTexCoord1f (GLfloat s);
+GLAPI void GLAPIENTRY glTexCoord1fv (const GLfloat *v);
+GLAPI void GLAPIENTRY glTexCoord1i (GLint s);
+GLAPI void GLAPIENTRY glTexCoord1iv (const GLint *v);
+GLAPI void GLAPIENTRY glTexCoord1s (GLshort s);
+GLAPI void GLAPIENTRY glTexCoord1sv (const GLshort *v);
+GLAPI void GLAPIENTRY glTexCoord2d (GLdouble s, GLdouble t);
+GLAPI void GLAPIENTRY glTexCoord2dv (const GLdouble *v);
+GLAPI void GLAPIENTRY glTexCoord2f (GLfloat s, GLfloat t);
+GLAPI void GLAPIENTRY glTexCoord2fv (const GLfloat *v);
+GLAPI void GLAPIENTRY glTexCoord2i (GLint s, GLint t);
+GLAPI void GLAPIENTRY glTexCoord2iv (const GLint *v);
+GLAPI void GLAPIENTRY glTexCoord2s (GLshort s, GLshort t);
+GLAPI void GLAPIENTRY glTexCoord2sv (const GLshort *v);
+GLAPI void GLAPIENTRY glTexCoord3d (GLdouble s, GLdouble t, GLdouble r);
+GLAPI void GLAPIENTRY glTexCoord3dv (const GLdouble *v);
+GLAPI void GLAPIENTRY glTexCoord3f (GLfloat s, GLfloat t, GLfloat r);
+GLAPI void GLAPIENTRY glTexCoord3fv (const GLfloat *v);
+GLAPI void GLAPIENTRY glTexCoord3i (GLint s, GLint t, GLint r);
+GLAPI void GLAPIENTRY glTexCoord3iv (const GLint *v);
+GLAPI void GLAPIENTRY glTexCoord3s (GLshort s, GLshort t, GLshort r);
+GLAPI void GLAPIENTRY glTexCoord3sv (const GLshort *v);
+GLAPI void GLAPIENTRY glTexCoord4d (GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+GLAPI void GLAPIENTRY glTexCoord4dv (const GLdouble *v);
+GLAPI void GLAPIENTRY glTexCoord4f (GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+GLAPI void GLAPIENTRY glTexCoord4fv (const GLfloat *v);
+GLAPI void GLAPIENTRY glTexCoord4i (GLint s, GLint t, GLint r, GLint q);
+GLAPI void GLAPIENTRY glTexCoord4iv (const GLint *v);
+GLAPI void GLAPIENTRY glTexCoord4s (GLshort s, GLshort t, GLshort r, GLshort q);
+GLAPI void GLAPIENTRY glTexCoord4sv (const GLshort *v);
+GLAPI void GLAPIENTRY glVertex2d (GLdouble x, GLdouble y);
+GLAPI void GLAPIENTRY glVertex2dv (const GLdouble *v);
+GLAPI void GLAPIENTRY glVertex2f (GLfloat x, GLfloat y);
+GLAPI void GLAPIENTRY glVertex2fv (const GLfloat *v);
+GLAPI void GLAPIENTRY glVertex2i (GLint x, GLint y);
+GLAPI void GLAPIENTRY glVertex2iv (const GLint *v);
+GLAPI void GLAPIENTRY glVertex2s (GLshort x, GLshort y);
+GLAPI void GLAPIENTRY glVertex2sv (const GLshort *v);
+GLAPI void GLAPIENTRY glVertex3d (GLdouble x, GLdouble y, GLdouble z);
+GLAPI void GLAPIENTRY glVertex3dv (const GLdouble *v);
+GLAPI void GLAPIENTRY glVertex3f (GLfloat x, GLfloat y, GLfloat z);
+GLAPI void GLAPIENTRY glVertex3fv (const GLfloat *v);
+GLAPI void GLAPIENTRY glVertex3i (GLint x, GLint y, GLint z);
+GLAPI void GLAPIENTRY glVertex3iv (const GLint *v);
+GLAPI void GLAPIENTRY glVertex3s (GLshort x, GLshort y, GLshort z);
+GLAPI void GLAPIENTRY glVertex3sv (const GLshort *v);
+GLAPI void GLAPIENTRY glVertex4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+GLAPI void GLAPIENTRY glVertex4dv (const GLdouble *v);
+GLAPI void GLAPIENTRY glVertex4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GLAPI void GLAPIENTRY glVertex4fv (const GLfloat *v);
+GLAPI void GLAPIENTRY glVertex4i (GLint x, GLint y, GLint z, GLint w);
+GLAPI void GLAPIENTRY glVertex4iv (const GLint *v);
+GLAPI void GLAPIENTRY glVertex4s (GLshort x, GLshort y, GLshort z, GLshort w);
+GLAPI void GLAPIENTRY glVertex4sv (const GLshort *v);
+GLAPI void GLAPIENTRY glClipPlane (GLenum plane, const GLdouble *equation);
+GLAPI void GLAPIENTRY glColorMaterial (GLenum face, GLenum mode);
+GLAPI void GLAPIENTRY glCullFace (GLenum mode);
+GLAPI void GLAPIENTRY glFogf (GLenum pname, GLfloat param);
+GLAPI void GLAPIENTRY glFogfv (GLenum pname, const GLfloat *params);
+GLAPI void GLAPIENTRY glFogi (GLenum pname, GLint param);
+GLAPI void GLAPIENTRY glFogiv (GLenum pname, const GLint *params);
+GLAPI void GLAPIENTRY glFrontFace (GLenum mode);
+GLAPI void GLAPIENTRY glHint (GLenum target, GLenum mode);
+GLAPI void GLAPIENTRY glLightf (GLenum light, GLenum pname, GLfloat param);
+GLAPI void GLAPIENTRY glLightfv (GLenum light, GLenum pname, const GLfloat *params);
+GLAPI void GLAPIENTRY glLighti (GLenum light, GLenum pname, GLint param);
+GLAPI void GLAPIENTRY glLightiv (GLenum light, GLenum pname, const GLint *params);
+GLAPI void GLAPIENTRY glLightModelf (GLenum pname, GLfloat param);
+GLAPI void GLAPIENTRY glLightModelfv (GLenum pname, const GLfloat *params);
+GLAPI void GLAPIENTRY glLightModeli (GLenum pname, GLint param);
+GLAPI void GLAPIENTRY glLightModeliv (GLenum pname, const GLint *params);
+GLAPI void GLAPIENTRY glLineStipple (GLint factor, GLushort pattern);
+GLAPI void GLAPIENTRY glLineWidth (GLfloat width);
+GLAPI void GLAPIENTRY glMaterialf (GLenum face, GLenum pname, GLfloat param);
+GLAPI void GLAPIENTRY glMaterialfv (GLenum face, GLenum pname, const GLfloat *params);
+GLAPI void GLAPIENTRY glMateriali (GLenum face, GLenum pname, GLint param);
+GLAPI void GLAPIENTRY glMaterialiv (GLenum face, GLenum pname, const GLint *params);
+GLAPI void GLAPIENTRY glPointSize (GLfloat size);
+GLAPI void GLAPIENTRY glPolygonMode (GLenum face, GLenum mode);
+GLAPI void GLAPIENTRY glPolygonStipple (const GLubyte *mask);
+GLAPI void GLAPIENTRY glScissor (GLint x, GLint y, GLsizei width, GLsizei height);
+GLAPI void GLAPIENTRY glShadeModel (GLenum mode);
+GLAPI void GLAPIENTRY glTexParameterf (GLenum target, GLenum pname, GLfloat param);
+GLAPI void GLAPIENTRY glTexParameterfv (GLenum target, GLenum pname, const GLfloat *params);
+GLAPI void GLAPIENTRY glTexParameteri (GLenum target, GLenum pname, GLint param);
+GLAPI void GLAPIENTRY glTexParameteriv (GLenum target, GLenum pname, const GLint *params);
+GLAPI void GLAPIENTRY glTexImage1D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI void GLAPIENTRY glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI void GLAPIENTRY glTexEnvf (GLenum target, GLenum pname, GLfloat param);
+GLAPI void GLAPIENTRY glTexEnvfv (GLenum target, GLenum pname, const GLfloat *params);
+GLAPI void GLAPIENTRY glTexEnvi (GLenum target, GLenum pname, GLint param);
+GLAPI void GLAPIENTRY glTexEnviv (GLenum target, GLenum pname, const GLint *params);
+GLAPI void GLAPIENTRY glTexGend (GLenum coord, GLenum pname, GLdouble param);
+GLAPI void GLAPIENTRY glTexGendv (GLenum coord, GLenum pname, const GLdouble *params);
+GLAPI void GLAPIENTRY glTexGenf (GLenum coord, GLenum pname, GLfloat param);
+GLAPI void GLAPIENTRY glTexGenfv (GLenum coord, GLenum pname, const GLfloat *params);
+GLAPI void GLAPIENTRY glTexGeni (GLenum coord, GLenum pname, GLint param);
+GLAPI void GLAPIENTRY glTexGeniv (GLenum coord, GLenum pname, const GLint *params);
+GLAPI void GLAPIENTRY glFeedbackBuffer (GLsizei size, GLenum type, GLfloat *buffer);
+GLAPI void GLAPIENTRY glSelectBuffer (GLsizei size, GLuint *buffer);
+GLAPI GLint GLAPIENTRY glRenderMode (GLenum mode);
+GLAPI void GLAPIENTRY glInitNames (void);
+GLAPI void GLAPIENTRY glLoadName (GLuint name);
+GLAPI void GLAPIENTRY glPassThrough (GLfloat token);
+GLAPI void GLAPIENTRY glPopName (void);
+GLAPI void GLAPIENTRY glPushName (GLuint name);
+GLAPI void GLAPIENTRY glDrawBuffer (GLenum mode);
+GLAPI void GLAPIENTRY glClear (GLbitfield mask);
+GLAPI void GLAPIENTRY glClearAccum (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+GLAPI void GLAPIENTRY glClearIndex (GLfloat c);
+GLAPI void GLAPIENTRY glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+GLAPI void GLAPIENTRY glClearStencil (GLint s);
+GLAPI void GLAPIENTRY glClearDepth (GLclampd depth);
+GLAPI void GLAPIENTRY glStencilMask (GLuint mask);
+GLAPI void GLAPIENTRY glColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+GLAPI void GLAPIENTRY glDepthMask (GLboolean flag);
+GLAPI void GLAPIENTRY glIndexMask (GLuint mask);
+GLAPI void GLAPIENTRY glAccum (GLenum op, GLfloat value);
+GLAPI void GLAPIENTRY glDisable (GLenum cap);
+GLAPI void GLAPIENTRY glEnable (GLenum cap);
+GLAPI void GLAPIENTRY glFinish (void);
+GLAPI void GLAPIENTRY glFlush (void);
+GLAPI void GLAPIENTRY glPopAttrib (void);
+GLAPI void GLAPIENTRY glPushAttrib (GLbitfield mask);
+GLAPI void GLAPIENTRY glMap1d (GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
+GLAPI void GLAPIENTRY glMap1f (GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
+GLAPI void GLAPIENTRY glMap2d (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
+GLAPI void GLAPIENTRY glMap2f (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
+GLAPI void GLAPIENTRY glMapGrid1d (GLint un, GLdouble u1, GLdouble u2);
+GLAPI void GLAPIENTRY glMapGrid1f (GLint un, GLfloat u1, GLfloat u2);
+GLAPI void GLAPIENTRY glMapGrid2d (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
+GLAPI void GLAPIENTRY glMapGrid2f (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
+GLAPI void GLAPIENTRY glEvalCoord1d (GLdouble u);
+GLAPI void GLAPIENTRY glEvalCoord1dv (const GLdouble *u);
+GLAPI void GLAPIENTRY glEvalCoord1f (GLfloat u);
+GLAPI void GLAPIENTRY glEvalCoord1fv (const GLfloat *u);
+GLAPI void GLAPIENTRY glEvalCoord2d (GLdouble u, GLdouble v);
+GLAPI void GLAPIENTRY glEvalCoord2dv (const GLdouble *u);
+GLAPI void GLAPIENTRY glEvalCoord2f (GLfloat u, GLfloat v);
+GLAPI void GLAPIENTRY glEvalCoord2fv (const GLfloat *u);
+GLAPI void GLAPIENTRY glEvalMesh1 (GLenum mode, GLint i1, GLint i2);
+GLAPI void GLAPIENTRY glEvalPoint1 (GLint i);
+GLAPI void GLAPIENTRY glEvalMesh2 (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
+GLAPI void GLAPIENTRY glEvalPoint2 (GLint i, GLint j);
+GLAPI void GLAPIENTRY glAlphaFunc (GLenum func, GLclampf ref);
+GLAPI void GLAPIENTRY glBlendFunc (GLenum sfactor, GLenum dfactor);
+GLAPI void GLAPIENTRY glLogicOp (GLenum opcode);
+GLAPI void GLAPIENTRY glStencilFunc (GLenum func, GLint ref, GLuint mask);
+GLAPI void GLAPIENTRY glStencilOp (GLenum fail, GLenum zfail, GLenum zpass);
+GLAPI void GLAPIENTRY glDepthFunc (GLenum func);
+GLAPI void GLAPIENTRY glPixelZoom (GLfloat xfactor, GLfloat yfactor);
+GLAPI void GLAPIENTRY glPixelTransferf (GLenum pname, GLfloat param);
+GLAPI void GLAPIENTRY glPixelTransferi (GLenum pname, GLint param);
+GLAPI void GLAPIENTRY glPixelStoref (GLenum pname, GLfloat param);
+GLAPI void GLAPIENTRY glPixelStorei (GLenum pname, GLint param);
+GLAPI void GLAPIENTRY glPixelMapfv (GLenum map, GLint mapsize, const GLfloat *values);
+GLAPI void GLAPIENTRY glPixelMapuiv (GLenum map, GLint mapsize, const GLuint *values);
+GLAPI void GLAPIENTRY glPixelMapusv (GLenum map, GLint mapsize, const GLushort *values);
+GLAPI void GLAPIENTRY glReadBuffer (GLenum mode);
+GLAPI void GLAPIENTRY glCopyPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
+GLAPI void GLAPIENTRY glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
+GLAPI void GLAPIENTRY glDrawPixels (GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI void GLAPIENTRY glGetBooleanv (GLenum pname, GLboolean *params);
+GLAPI void GLAPIENTRY glGetClipPlane (GLenum plane, GLdouble *equation);
+GLAPI void GLAPIENTRY glGetDoublev (GLenum pname, GLdouble *params);
+GLAPI GLenum GLAPIENTRY glGetError (void);
+GLAPI void GLAPIENTRY glGetFloatv (GLenum pname, GLfloat *params);
+GLAPI void GLAPIENTRY glGetIntegerv (GLenum pname, GLint *params);
+GLAPI void GLAPIENTRY glGetLightfv (GLenum light, GLenum pname, GLfloat *params);
+GLAPI void GLAPIENTRY glGetLightiv (GLenum light, GLenum pname, GLint *params);
+GLAPI void GLAPIENTRY glGetMapdv (GLenum target, GLenum query, GLdouble *v);
+GLAPI void GLAPIENTRY glGetMapfv (GLenum target, GLenum query, GLfloat *v);
+GLAPI void GLAPIENTRY glGetMapiv (GLenum target, GLenum query, GLint *v);
+GLAPI void GLAPIENTRY glGetMaterialfv (GLenum face, GLenum pname, GLfloat *params);
+GLAPI void GLAPIENTRY glGetMaterialiv (GLenum face, GLenum pname, GLint *params);
+GLAPI void GLAPIENTRY glGetPixelMapfv (GLenum map, GLfloat *values);
+GLAPI void GLAPIENTRY glGetPixelMapuiv (GLenum map, GLuint *values);
+GLAPI void GLAPIENTRY glGetPixelMapusv (GLenum map, GLushort *values);
+GLAPI void GLAPIENTRY glGetPolygonStipple (GLubyte *mask);
+GLAPI const GLubyte * GLAPIENTRY glGetString (GLenum name);
+GLAPI void GLAPIENTRY glGetTexEnvfv (GLenum target, GLenum pname, GLfloat *params);
+GLAPI void GLAPIENTRY glGetTexEnviv (GLenum target, GLenum pname, GLint *params);
+GLAPI void GLAPIENTRY glGetTexGendv (GLenum coord, GLenum pname, GLdouble *params);
+GLAPI void GLAPIENTRY glGetTexGenfv (GLenum coord, GLenum pname, GLfloat *params);
+GLAPI void GLAPIENTRY glGetTexGeniv (GLenum coord, GLenum pname, GLint *params);
+GLAPI void GLAPIENTRY glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
+GLAPI void GLAPIENTRY glGetTexParameterfv (GLenum target, GLenum pname, GLfloat *params);
+GLAPI void GLAPIENTRY glGetTexParameteriv (GLenum target, GLenum pname, GLint *params);
+GLAPI void GLAPIENTRY glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat *params);
+GLAPI void GLAPIENTRY glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint *params);
+GLAPI GLboolean GLAPIENTRY glIsEnabled (GLenum cap);
+GLAPI GLboolean GLAPIENTRY glIsList (GLuint list);
+GLAPI void GLAPIENTRY glDepthRange (GLclampd zNear, GLclampd zFar);
+GLAPI void GLAPIENTRY glFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+GLAPI void GLAPIENTRY glLoadIdentity (void);
+GLAPI void GLAPIENTRY glLoadMatrixf (const GLfloat *m);
+GLAPI void GLAPIENTRY glLoadMatrixd (const GLdouble *m);
+GLAPI void GLAPIENTRY glMatrixMode (GLenum mode);
+GLAPI void GLAPIENTRY glMultMatrixf (const GLfloat *m);
+GLAPI void GLAPIENTRY glMultMatrixd (const GLdouble *m);
+GLAPI void GLAPIENTRY glOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+GLAPI void GLAPIENTRY glPopMatrix (void);
+GLAPI void GLAPIENTRY glPushMatrix (void);
+GLAPI void GLAPIENTRY glRotated (GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+GLAPI void GLAPIENTRY glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void GLAPIENTRY glScaled (GLdouble x, GLdouble y, GLdouble z);
+GLAPI void GLAPIENTRY glScalef (GLfloat x, GLfloat y, GLfloat z);
+GLAPI void GLAPIENTRY glTranslated (GLdouble x, GLdouble y, GLdouble z);
+GLAPI void GLAPIENTRY glTranslatef (GLfloat x, GLfloat y, GLfloat z);
+GLAPI void GLAPIENTRY glViewport (GLint x, GLint y, GLsizei width, GLsizei height);
+GLAPI void GLAPIENTRY glArrayElement (GLint i);
+GLAPI void GLAPIENTRY glColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+GLAPI void GLAPIENTRY glDisableClientState (GLenum array);
+GLAPI void GLAPIENTRY glDrawArrays (GLenum mode, GLint first, GLsizei count);
+GLAPI void GLAPIENTRY glDrawElements (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
+GLAPI void GLAPIENTRY glEdgeFlagPointer (GLsizei stride, const GLboolean *pointer);
+GLAPI void GLAPIENTRY glEnableClientState (GLenum array);
+GLAPI void GLAPIENTRY glGetPointerv (GLenum pname, GLvoid* *params);
+GLAPI void GLAPIENTRY glIndexPointer (GLenum type, GLsizei stride, const GLvoid *pointer);
+GLAPI void GLAPIENTRY glInterleavedArrays (GLenum format, GLsizei stride, const GLvoid *pointer);
+GLAPI void GLAPIENTRY glNormalPointer (GLenum type, GLsizei stride, const GLvoid *pointer);
+GLAPI void GLAPIENTRY glTexCoordPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+GLAPI void GLAPIENTRY glVertexPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+GLAPI void GLAPIENTRY glPolygonOffset (GLfloat factor, GLfloat units);
+GLAPI void GLAPIENTRY glCopyTexImage1D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
+GLAPI void GLAPIENTRY glCopyTexImage2D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+GLAPI void GLAPIENTRY glCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+GLAPI void GLAPIENTRY glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+GLAPI void GLAPIENTRY glTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI void GLAPIENTRY glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI GLboolean GLAPIENTRY glAreTexturesResident (GLsizei n, const GLuint *textures, GLboolean *residences);
+GLAPI void GLAPIENTRY glBindTexture (GLenum target, GLuint texture);
+GLAPI void GLAPIENTRY glDeleteTextures (GLsizei n, const GLuint *textures);
+GLAPI void GLAPIENTRY glGenTextures (GLsizei n, GLuint *textures);
+GLAPI GLboolean GLAPIENTRY glIsTexture (GLuint texture);
+GLAPI void GLAPIENTRY glPrioritizeTextures (GLsizei n, const GLuint *textures, const GLclampf *priorities);
+GLAPI void GLAPIENTRY glIndexub (GLubyte c);
+GLAPI void GLAPIENTRY glIndexubv (const GLubyte *c);
+GLAPI void GLAPIENTRY glPopClientAttrib (void);
+GLAPI void GLAPIENTRY glPushClientAttrib (GLbitfield mask);
+GLAPI void GLAPIENTRY glBlendColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+GLAPI void GLAPIENTRY glBlendEquation (GLenum mode);
+GLAPI void GLAPIENTRY glDrawRangeElements (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
+GLAPI void GLAPIENTRY glColorTable (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
+GLAPI void GLAPIENTRY glColorTableParameterfv (GLenum target, GLenum pname, const GLfloat *params);
+GLAPI void GLAPIENTRY glColorTableParameteriv (GLenum target, GLenum pname, const GLint *params);
+GLAPI void GLAPIENTRY glCopyColorTable (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+GLAPI void GLAPIENTRY glGetColorTable (GLenum target, GLenum format, GLenum type, GLvoid *table);
+GLAPI void GLAPIENTRY glGetColorTableParameterfv (GLenum target, GLenum pname, GLfloat *params);
+GLAPI void GLAPIENTRY glGetColorTableParameteriv (GLenum target, GLenum pname, GLint *params);
+GLAPI void GLAPIENTRY glColorSubTable (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
+GLAPI void GLAPIENTRY glCopyColorSubTable (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
+GLAPI void GLAPIENTRY glConvolutionFilter1D (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
+GLAPI void GLAPIENTRY glConvolutionFilter2D (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
+GLAPI void GLAPIENTRY glConvolutionParameterf (GLenum target, GLenum pname, GLfloat params);
+GLAPI void GLAPIENTRY glConvolutionParameterfv (GLenum target, GLenum pname, const GLfloat *params);
+GLAPI void GLAPIENTRY glConvolutionParameteri (GLenum target, GLenum pname, GLint params);
+GLAPI void GLAPIENTRY glConvolutionParameteriv (GLenum target, GLenum pname, const GLint *params);
+GLAPI void GLAPIENTRY glCopyConvolutionFilter1D (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+GLAPI void GLAPIENTRY glCopyConvolutionFilter2D (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
+GLAPI void GLAPIENTRY glGetConvolutionFilter (GLenum target, GLenum format, GLenum type, GLvoid *image);
+GLAPI void GLAPIENTRY glGetConvolutionParameterfv (GLenum target, GLenum pname, GLfloat *params);
+GLAPI void GLAPIENTRY glGetConvolutionParameteriv (GLenum target, GLenum pname, GLint *params);
+GLAPI void GLAPIENTRY glGetSeparableFilter (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
+GLAPI void GLAPIENTRY glSeparableFilter2D (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
+GLAPI void GLAPIENTRY glGetHistogram (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
+GLAPI void GLAPIENTRY glGetHistogramParameterfv (GLenum target, GLenum pname, GLfloat *params);
+GLAPI void GLAPIENTRY glGetHistogramParameteriv (GLenum target, GLenum pname, GLint *params);
+GLAPI void GLAPIENTRY glGetMinmax (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
+GLAPI void GLAPIENTRY glGetMinmaxParameterfv (GLenum target, GLenum pname, GLfloat *params);
+GLAPI void GLAPIENTRY glGetMinmaxParameteriv (GLenum target, GLenum pname, GLint *params);
+GLAPI void GLAPIENTRY glHistogram (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
+GLAPI void GLAPIENTRY glMinmax (GLenum target, GLenum internalformat, GLboolean sink);
+GLAPI void GLAPIENTRY glResetHistogram (GLenum target);
+GLAPI void GLAPIENTRY glResetMinmax (GLenum target);
+GLAPI void GLAPIENTRY glTexImage3D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI void GLAPIENTRY glTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
+GLAPI void GLAPIENTRY glCopyTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+GLAPI void GLAPIENTRY glActiveTexture (GLenum texture);
+GLAPI void GLAPIENTRY glClientActiveTexture (GLenum texture);
+GLAPI void GLAPIENTRY glMultiTexCoord1d (GLenum target, GLdouble s);
+GLAPI void GLAPIENTRY glMultiTexCoord1dv (GLenum target, const GLdouble *v);
+GLAPI void GLAPIENTRY glMultiTexCoord1f (GLenum target, GLfloat s);
+GLAPI void GLAPIENTRY glMultiTexCoord1fv (GLenum target, const GLfloat *v);
+GLAPI void GLAPIENTRY glMultiTexCoord1i (GLenum target, GLint s);
+GLAPI void GLAPIENTRY glMultiTexCoord1iv (GLenum target, const GLint *v);
+GLAPI void GLAPIENTRY glMultiTexCoord1s (GLenum target, GLshort s);
+GLAPI void GLAPIENTRY glMultiTexCoord1sv (GLenum target, const GLshort *v);
+GLAPI void GLAPIENTRY glMultiTexCoord2d (GLenum target, GLdouble s, GLdouble t);
+GLAPI void GLAPIENTRY glMultiTexCoord2dv (GLenum target, const GLdouble *v);
+GLAPI void GLAPIENTRY glMultiTexCoord2f (GLenum target, GLfloat s, GLfloat t);
+GLAPI void GLAPIENTRY glMultiTexCoord2fv (GLenum target, const GLfloat *v);
+GLAPI void GLAPIENTRY glMultiTexCoord2i (GLenum target, GLint s, GLint t);
+GLAPI void GLAPIENTRY glMultiTexCoord2iv (GLenum target, const GLint *v);
+GLAPI void GLAPIENTRY glMultiTexCoord2s (GLenum target, GLshort s, GLshort t);
+GLAPI void GLAPIENTRY glMultiTexCoord2sv (GLenum target, const GLshort *v);
+GLAPI void GLAPIENTRY glMultiTexCoord3d (GLenum target, GLdouble s, GLdouble t, GLdouble r);
+GLAPI void GLAPIENTRY glMultiTexCoord3dv (GLenum target, const GLdouble *v);
+GLAPI void GLAPIENTRY glMultiTexCoord3f (GLenum target, GLfloat s, GLfloat t, GLfloat r);
+GLAPI void GLAPIENTRY glMultiTexCoord3fv (GLenum target, const GLfloat *v);
+GLAPI void GLAPIENTRY glMultiTexCoord3i (GLenum target, GLint s, GLint t, GLint r);
+GLAPI void GLAPIENTRY glMultiTexCoord3iv (GLenum target, const GLint *v);
+GLAPI void GLAPIENTRY glMultiTexCoord3s (GLenum target, GLshort s, GLshort t, GLshort r);
+GLAPI void GLAPIENTRY glMultiTexCoord3sv (GLenum target, const GLshort *v);
+GLAPI void GLAPIENTRY glMultiTexCoord4d (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+GLAPI void GLAPIENTRY glMultiTexCoord4dv (GLenum target, const GLdouble *v);
+GLAPI void GLAPIENTRY glMultiTexCoord4f (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+GLAPI void GLAPIENTRY glMultiTexCoord4fv (GLenum target, const GLfloat *v);
+GLAPI void GLAPIENTRY glMultiTexCoord4i (GLenum target, GLint s, GLint t, GLint r, GLint q);
+GLAPI void GLAPIENTRY glMultiTexCoord4iv (GLenum target, const GLint *v);
+GLAPI void GLAPIENTRY glMultiTexCoord4s (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
+GLAPI void GLAPIENTRY glMultiTexCoord4sv (GLenum target, const GLshort *v);
+GLAPI void GLAPIENTRY glLoadTransposeMatrixf (const GLfloat *m);
+GLAPI void GLAPIENTRY glLoadTransposeMatrixd (const GLdouble *m);
+GLAPI void GLAPIENTRY glMultTransposeMatrixf (const GLfloat *m);
+GLAPI void GLAPIENTRY glMultTransposeMatrixd (const GLdouble *m);
+GLAPI void GLAPIENTRY glCompressedTexImage3D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
+GLAPI void GLAPIENTRY glCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
+GLAPI void GLAPIENTRY glCompressedTexImage1D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
+GLAPI void GLAPIENTRY glCompressedTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
+GLAPI void GLAPIENTRY glCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
+GLAPI void GLAPIENTRY glCompressedTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
+GLAPI void GLAPIENTRY glGetCompressedTexImage (GLenum target, GLint lod, GLvoid *img);
+GLAPI void GLAPIENTRY glSampleCoverage (GLclampf value, GLboolean invert);
+GLAPI void GLAPIENTRY glPointParameterf (GLenum pname, GLfloat param);
+GLAPI void GLAPIENTRY glPointParameterfv (GLenum pname, const GLfloat *params);
+GLAPI void GLAPIENTRY glPointParameteri (GLenum pname, GLint param);
+GLAPI void GLAPIENTRY glPointParameteriv (GLenum pname, const GLint *params);
+GLAPI void GLAPIENTRY glWindowPos2d (GLdouble x, GLdouble y);
+GLAPI void GLAPIENTRY glWindowPos2f (GLfloat x, GLfloat y);
+GLAPI void GLAPIENTRY glWindowPos2i (GLint x, GLint y);
+GLAPI void GLAPIENTRY glWindowPos2s (GLshort x, GLshort y);
+GLAPI void GLAPIENTRY glWindowPos2dv (const GLdouble *p);
+GLAPI void GLAPIENTRY glWindowPos2fv (const GLfloat *p);
+GLAPI void GLAPIENTRY glWindowPos2iv (const GLint *p);
+GLAPI void GLAPIENTRY glWindowPos2sv (const GLshort *p);
+GLAPI void GLAPIENTRY glWindowPos3d (GLdouble x, GLdouble y, GLdouble z);
+GLAPI void GLAPIENTRY glWindowPos3f (GLfloat x, GLfloat y, GLfloat z);
+GLAPI void GLAPIENTRY glWindowPos3i (GLint x, GLint y, GLint z);
+GLAPI void GLAPIENTRY glWindowPos3s (GLshort x, GLshort y, GLshort z);
+GLAPI void GLAPIENTRY glWindowPos3dv (const GLdouble *p);
+GLAPI void GLAPIENTRY glWindowPos3fv (const GLfloat *p);
+GLAPI void GLAPIENTRY glWindowPos3iv (const GLint *p);
+GLAPI void GLAPIENTRY glWindowPos3sv (const GLshort *p);
+GLAPI void GLAPIENTRY glBlendFuncSeparate (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+GLAPI void GLAPIENTRY glFogCoordd (GLdouble fog);
+GLAPI void GLAPIENTRY glFogCoorddv (const GLdouble *fog);
+GLAPI void GLAPIENTRY glFogCoordf (GLfloat fog);
+GLAPI void GLAPIENTRY glFogCoordfv (const GLfloat *fog);
+GLAPI void GLAPIENTRY glFogCoordPointer (GLenum type, GLsizei stride, const GLvoid *pointer);
+GLAPI void GLAPIENTRY glMultiDrawArrays (GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount);
+GLAPI void GLAPIENTRY glMultiDrawElements (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount);
+GLAPI void GLAPIENTRY glSecondaryColor3b (GLbyte red, GLbyte green, GLbyte blue);
+GLAPI void GLAPIENTRY glSecondaryColor3bv (const GLbyte *v);
+GLAPI void GLAPIENTRY glSecondaryColor3d (GLdouble red, GLdouble green, GLdouble blue);
+GLAPI void GLAPIENTRY glSecondaryColor3dv (const GLdouble *v);
+GLAPI void GLAPIENTRY glSecondaryColor3f (GLfloat red, GLfloat green, GLfloat blue);
+GLAPI void GLAPIENTRY glSecondaryColor3fv (const GLfloat *v);
+GLAPI void GLAPIENTRY glSecondaryColor3i (GLint red, GLint green, GLint blue);
+GLAPI void GLAPIENTRY glSecondaryColor3iv (const GLint *v);
+GLAPI void GLAPIENTRY glSecondaryColor3s (GLshort red, GLshort green, GLshort blue);
+GLAPI void GLAPIENTRY glSecondaryColor3sv (const GLshort *v);
+GLAPI void GLAPIENTRY glSecondaryColor3ub (GLubyte red, GLubyte green, GLubyte blue);
+GLAPI void GLAPIENTRY glSecondaryColor3ubv (const GLubyte *v);
+GLAPI void GLAPIENTRY glSecondaryColor3ui (GLuint red, GLuint green, GLuint blue);
+GLAPI void GLAPIENTRY glSecondaryColor3uiv (const GLuint *v);
+GLAPI void GLAPIENTRY glSecondaryColor3us (GLushort red, GLushort green, GLushort blue);
+GLAPI void GLAPIENTRY glSecondaryColor3usv (const GLushort *v);
+GLAPI void GLAPIENTRY glSecondaryColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+GLAPI void GLAPIENTRY glBindBuffer (GLenum target, GLuint buffer);
+GLAPI void GLAPIENTRY glBufferData (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
+GLAPI void GLAPIENTRY glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
+GLAPI void GLAPIENTRY glDeleteBuffers (GLsizei n, const GLuint *buffers);
+GLAPI void GLAPIENTRY glGenBuffers (GLsizei n, GLuint *buffers);
+GLAPI void GLAPIENTRY glGetBufferParameteriv (GLenum target, GLenum pname, GLint *params);
+GLAPI void GLAPIENTRY glGetBufferPointerv (GLenum target, GLenum pname, GLvoid* *params);
+GLAPI void GLAPIENTRY glGetBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
+GLAPI GLboolean GLAPIENTRY glIsBuffer (GLuint buffer);
+GLAPI GLvoid* GLAPIENTRY glMapBuffer (GLenum target, GLenum access);
+GLAPI GLboolean GLAPIENTRY glUnmapBuffer (GLenum target);
+GLAPI void GLAPIENTRY glGenQueries (GLsizei n, GLuint *ids);
+GLAPI void GLAPIENTRY glDeleteQueries (GLsizei n, const GLuint *ids);
+GLAPI GLboolean GLAPIENTRY glIsQuery (GLuint id);
+GLAPI void GLAPIENTRY glBeginQuery (GLenum target, GLuint id);
+GLAPI void GLAPIENTRY glEndQuery (GLenum target);
+GLAPI void GLAPIENTRY glGetQueryObjectiv (GLuint id, GLenum pname, GLint *params);
+GLAPI void GLAPIENTRY glGetQueryObjectuiv (GLuint id, GLenum pname, GLuint *params);
+GLAPI void GLAPIENTRY glGetQueryiv (GLenum target, GLenum pname, GLint *params);
+GLAPI void GLAPIENTRY glDrawBuffers (GLsizei n, const GLenum *bufs);
+GLAPI void GLAPIENTRY glVertexAttrib1d (GLuint index, GLdouble x);
+GLAPI void GLAPIENTRY glVertexAttrib1dv (GLuint index, const GLdouble *v);
+GLAPI void GLAPIENTRY glVertexAttrib1f (GLuint index, GLfloat x);
+GLAPI void GLAPIENTRY glVertexAttrib1fv (GLuint index, const GLfloat *v);
+GLAPI void GLAPIENTRY glVertexAttrib1s (GLuint index, GLshort x);
+GLAPI void GLAPIENTRY glVertexAttrib1sv (GLuint index, const GLshort *v);
+GLAPI void GLAPIENTRY glVertexAttrib2d (GLuint index, GLdouble x, GLdouble y);
+GLAPI void GLAPIENTRY glVertexAttrib2dv (GLuint index, const GLdouble *v);
+GLAPI void GLAPIENTRY glVertexAttrib2f (GLuint index, GLfloat x, GLfloat y);
+GLAPI void GLAPIENTRY glVertexAttrib2fv (GLuint index, const GLfloat *v);
+GLAPI void GLAPIENTRY glVertexAttrib2s (GLuint index, GLshort x, GLshort y);
+GLAPI void GLAPIENTRY glVertexAttrib2sv (GLuint index, const GLshort *v);
+GLAPI void GLAPIENTRY glVertexAttrib3d (GLuint index, GLdouble x, GLdouble y, GLdouble z);
+GLAPI void GLAPIENTRY glVertexAttrib3dv (GLuint index, const GLdouble *v);
+GLAPI void GLAPIENTRY glVertexAttrib3f (GLuint index, GLfloat x, GLfloat y, GLfloat z);
+GLAPI void GLAPIENTRY glVertexAttrib3fv (GLuint index, const GLfloat *v);
+GLAPI void GLAPIENTRY glVertexAttrib3s (GLuint index, GLshort x, GLshort y, GLshort z);
+GLAPI void GLAPIENTRY glVertexAttrib3sv (GLuint index, const GLshort *v);
+GLAPI void GLAPIENTRY glVertexAttrib4Nbv (GLuint index, const GLbyte *v);
+GLAPI void GLAPIENTRY glVertexAttrib4Niv (GLuint index, const GLint *v);
+GLAPI void GLAPIENTRY glVertexAttrib4Nsv (GLuint index, const GLshort *v);
+GLAPI void GLAPIENTRY glVertexAttrib4Nub (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+GLAPI void GLAPIENTRY glVertexAttrib4Nubv (GLuint index, const GLubyte *v);
+GLAPI void GLAPIENTRY glVertexAttrib4Nuiv (GLuint index, const GLuint *v);
+GLAPI void GLAPIENTRY glVertexAttrib4Nusv (GLuint index, const GLushort *v);
+GLAPI void GLAPIENTRY glVertexAttrib4bv (GLuint index, const GLbyte *v);
+GLAPI void GLAPIENTRY glVertexAttrib4d (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+GLAPI void GLAPIENTRY glVertexAttrib4dv (GLuint index, const GLdouble *v);
+GLAPI void GLAPIENTRY glVertexAttrib4f (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GLAPI void GLAPIENTRY glVertexAttrib4fv (GLuint index, const GLfloat *v);
+GLAPI void GLAPIENTRY glVertexAttrib4iv (GLuint index, const GLint *v);
+GLAPI void GLAPIENTRY glVertexAttrib4s (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+GLAPI void GLAPIENTRY glVertexAttrib4sv (GLuint index, const GLshort *v);
+GLAPI void GLAPIENTRY glVertexAttrib4ubv (GLuint index, const GLubyte *v);
+GLAPI void GLAPIENTRY glVertexAttrib4uiv (GLuint index, const GLuint *v);
+GLAPI void GLAPIENTRY glVertexAttrib4usv (GLuint index, const GLushort *v);
+GLAPI void GLAPIENTRY glVertexAttribPointer (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
+GLAPI void GLAPIENTRY glEnableVertexAttribArray (GLuint index);
+GLAPI void GLAPIENTRY glDisableVertexAttribArray (GLuint index);
+GLAPI void GLAPIENTRY glGetVertexAttribdv (GLuint index, GLenum pname, GLdouble *params);
+GLAPI void GLAPIENTRY glGetVertexAttribfv (GLuint index, GLenum pname, GLfloat *params);
+GLAPI void GLAPIENTRY glGetVertexAttribiv (GLuint index, GLenum pname, GLint *params);
+GLAPI void GLAPIENTRY glGetVertexAttribPointerv (GLuint index, GLenum pname, GLvoid* *pointer);
+GLAPI void GLAPIENTRY glDeleteShader (GLuint shader);
+GLAPI void GLAPIENTRY glDetachShader (GLuint program, GLuint shader);
+GLAPI GLuint GLAPIENTRY glCreateShader (GLenum type);
+GLAPI void GLAPIENTRY glShaderSource (GLuint shader, GLsizei count, const GLchar* *string, const GLint *length);
+GLAPI void GLAPIENTRY glCompileShader (GLuint shader);
+GLAPI GLuint GLAPIENTRY glCreateProgram (void);
+GLAPI void GLAPIENTRY glAttachShader (GLuint program, GLuint shader);
+GLAPI void GLAPIENTRY glLinkProgram (GLuint program);
+GLAPI void GLAPIENTRY glUseProgram (GLuint program);
+GLAPI void GLAPIENTRY glDeleteProgram (GLuint program);
+GLAPI void GLAPIENTRY glValidateProgram (GLuint program);
+GLAPI void GLAPIENTRY glUniform1f (GLint location, GLfloat v0);
+GLAPI void GLAPIENTRY glUniform2f (GLint location, GLfloat v0, GLfloat v1);
+GLAPI void GLAPIENTRY glUniform3f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+GLAPI void GLAPIENTRY glUniform4f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+GLAPI void GLAPIENTRY glUniform1i (GLint location, GLint v0);
+GLAPI void GLAPIENTRY glUniform2i (GLint location, GLint v0, GLint v1);
+GLAPI void GLAPIENTRY glUniform3i (GLint location, GLint v0, GLint v1, GLint v2);
+GLAPI void GLAPIENTRY glUniform4i (GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+GLAPI void GLAPIENTRY glUniform1fv (GLint location, GLsizei count, const GLfloat *value);
+GLAPI void GLAPIENTRY glUniform2fv (GLint location, GLsizei count, const GLfloat *value);
+GLAPI void GLAPIENTRY glUniform3fv (GLint location, GLsizei count, const GLfloat *value);
+GLAPI void GLAPIENTRY glUniform4fv (GLint location, GLsizei count, const GLfloat *value);
+GLAPI void GLAPIENTRY glUniform1iv (GLint location, GLsizei count, const GLint *value);
+GLAPI void GLAPIENTRY glUniform2iv (GLint location, GLsizei count, const GLint *value);
+GLAPI void GLAPIENTRY glUniform3iv (GLint location, GLsizei count, const GLint *value);
+GLAPI void GLAPIENTRY glUniform4iv (GLint location, GLsizei count, const GLint *value);
+GLAPI void GLAPIENTRY glUniformMatrix2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void GLAPIENTRY glUniformMatrix3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void GLAPIENTRY glUniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI GLboolean GLAPIENTRY glIsShader (GLuint shader);
+GLAPI GLboolean GLAPIENTRY glIsProgram (GLuint program);
+GLAPI void GLAPIENTRY glGetShaderiv (GLuint program, GLenum pname, GLint *params);
+GLAPI void GLAPIENTRY glGetProgramiv (GLuint program, GLenum pname, GLint *params);
+GLAPI void GLAPIENTRY glGetAttachedShaders (GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders);
+GLAPI void GLAPIENTRY glGetShaderInfoLog (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+GLAPI void GLAPIENTRY glGetProgramInfoLog (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+GLAPI GLint GLAPIENTRY glGetUniformLocation (GLuint program, const GLchar *name);
+GLAPI void GLAPIENTRY glGetActiveUniform (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
+GLAPI void GLAPIENTRY glGetUniformfv (GLuint program, GLint location, GLfloat *params);
+GLAPI void GLAPIENTRY glGetUniformiv (GLuint program, GLint location, GLint *params);
+GLAPI void GLAPIENTRY glGetShaderSource (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
+GLAPI void GLAPIENTRY glBindAttribLocation (GLuint program, GLuint index, const GLchar *name);
+GLAPI void GLAPIENTRY glGetActiveAttrib (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
+GLAPI GLint GLAPIENTRY glGetAttribLocation (GLuint program, const GLchar *name);
+GLAPI void GLAPIENTRY glStencilFuncSeparate (GLenum face, GLenum func, GLint ref, GLuint mask);
+GLAPI void GLAPIENTRY glStencilOpSeparate (GLenum face, GLenum fail, GLenum zfail, GLenum zpass);
+GLAPI void GLAPIENTRY glStencilMaskSeparate (GLenum face, GLuint mask);
+GLAPI void GLAPIENTRY glBlendEquationSeparate (GLenum modeRGB, GLenum modeAlpha);
+GLAPI void GLAPIENTRY glUniformMatrix2x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void GLAPIENTRY glUniformMatrix3x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void GLAPIENTRY glUniformMatrix2x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void GLAPIENTRY glUniformMatrix4x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void GLAPIENTRY glUniformMatrix3x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void GLAPIENTRY glUniformMatrix4x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __gl_h_ */
diff --git a/doc/glext.h b/doc/glext.h
new file mode 100755 (executable)
index 0000000..9619d78
--- /dev/null
@@ -0,0 +1,4789 @@
+#ifndef __glext_h_
+#define __glext_h_
+
+/*
+** Copyright 1998-2002, NVIDIA Corporation.
+** All Rights Reserved.
+** 
+** THE INFORMATION CONTAINED HEREIN IS PROPRIETARY AND CONFIDENTIAL TO
+** NVIDIA, CORPORATION.  USE, REPRODUCTION OR DISCLOSURE TO ANY THIRD PARTY
+** IS SUBJECT TO WRITTEN PRE-APPROVAL BY NVIDIA, CORPORATION.
+** 
+** 
+** Copyright 1992-1999, Silicon Graphics, Inc.
+** All Rights Reserved.
+** 
+** Portions of this file are UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon
+** Graphics, Inc.; the contents of this file may not be disclosed to third
+** parties, copied or duplicated in any form, in whole or in part, without
+** the prior written permission of Silicon Graphics, Inc.
+** 
+** RESTRICTED RIGHTS LEGEND:
+** Use, duplication or disclosure by the Government is subject to
+** restrictions as set forth in subdivision (c)(1)(ii) of the Rights in
+** Technical Data and Computer Software clause at DFARS 252.227-7013,
+** and/or in similar or successor clauses in the FAR, DOD or NASA FAR
+** Supplement.  Unpublished - rights reserved under the Copyright Laws of
+** the United States.
+*/
+
+#ifndef GLAPIENTRY
+# ifdef _WIN32
+#  if (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED)  /* Mimic <windef.h> */
+#   define GLAPIENTRY __stdcall
+#  else
+#   define GLAPIENTRY
+#  endif
+# else
+#  define GLAPIENTRY
+# endif
+#endif
+
+#ifndef GLAPI
+# define GLAPI extern
+#endif
+
+#ifndef GLAPIENTRYP
+# define GLAPIENTRYP GLAPIENTRY *
+#endif
+
+/*************************************************************/
+
+#ifndef GL_TYPEDEFS_1_5
+#define GL_TYPEDEFS_1_5
+#if defined(_WIN64)
+    typedef __int64 GLintptr;
+    typedef __int64 GLsizeiptr;
+#elif defined(__x86_64__)
+    typedef long int GLintptr;
+    typedef long int GLsizeiptr;
+#else
+    typedef int GLintptr;
+    typedef int GLsizeiptr;
+#endif
+#endif
+
+#ifndef GL_TYPEDEFS_2_0
+# define GL_TYPEDEFS_2_0
+    typedef char GLchar;
+#endif
+
+typedef unsigned short GLhalf;
+typedef unsigned int GLhandleARB;
+typedef char GLcharARB;
+#if defined(_WIN64)
+    typedef __int64 GLintptrARB;
+    typedef __int64 GLsizeiptrARB;
+#elif defined(__x86_64__)
+    typedef long int GLintptrARB;
+    typedef long int GLsizeiptrARB;
+#else
+    typedef int GLintptrARB;
+    typedef int GLsizeiptrARB;
+#endif
+
+typedef signed long long GLint64EXT;
+typedef unsigned long long GLuint64EXT;
+
+
+#ifndef GL_VERSION_1_2
+#define GL_VERSION_1_2 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void GLAPIENTRY glBlendColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+GLAPI void GLAPIENTRY glBlendEquation (GLenum mode);
+GLAPI&