Zengtudor/glew
1
0
Fork 0
mirror of https://github.com/nigels-com/glew.git synced 2024-11-21 21:35:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

Initial revision

Browse Source 
git-svn-id: https://glew.svn.sourceforge.net/svnroot/glew/trunk/glew@2 783a27ee-832a-0410-bc00-9f386506c6dd
This commit is contained in:
ikits 2002-12-13 08:31:58 +00:00
commit 5713df7d72
13 changed files with 12944 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

63
GNUmakefile Normal file
View File

@ -0,0 +1,63 @@
## The OpenGL Extension Wrangler Library
## Copyright (C) 2002 Milan Ikits
##
## This library is free software; you can redistribute it and/or
## modify it under the terms of the GNU Lesser General Public
## License as published by the Free Software Foundation; either
## version 2.1 of the License, or (at your option) any later version.
##
## This library is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
## Lesser General Public License for more details.
##
## You should have received a copy of the GNU Lesser General Public
## License along with this library; if not, write to the Free Software
## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
GLEW_TARGET ?= /usr
CC = \cc
LD = \ld
INSTALL = \install
RM = \rm -f
OPT = -O2
INCLUDE = -Iinclude
CFLAGS = $(OPT) $(INCLUDE)
LIB = lib/libGLEW.so
LIB.SRCS = src/glew.c
LIB.OBJS = $(LIB.SRCS:.c=.o)
LIB.LIBS =
BIN = bin/glewinfo
BIN.SRCS = src/glewinfo.c
BIN.OBJS = $(BIN.SRCS:.c=.o)
BIN.LIBS = -Llib -L/usr/X11R6/lib -lglut -lGLEW -lGL -lXmu -lX11
all: $(LIB) $(BIN)
$(LIB): $(LIB.OBJS)
$(LD) -shared -o $@ $^ $(LIB.LIBS)
$(BIN): $(BIN.SRCS)
$(CC) $(CFLAGS) -o $@ $^ $(BIN.LIBS)
%.o: %.c
$(CC) -c $(CFLAGS) -o $@ $<
install: all
$(INSTALL) -d -m 755 $(GLEW_TARGET)/include/GL
$(INSTALL) -m 644 include/GL/glew.h include/GL/glxew.h $(GLEW_TARGET)/include/GL
$(INSTALL) -d -m 755 $(GLEW_TARGET)/lib
$(INSTALL) -s -m 755 lib/libGLEW.so $(GLEW_TARGET)/lib
$(INSTALL) -d -m 755 $(GLEW_TARGET)/bin
$(INSTALL) -s -m 755 lib/glewinfo $(GLEW_TARGET)/bin
uninstall:
$(RM) $(GLEW_TARGET)/include/GL/glew.h $(GLEW_TARGET)/include/GL/glxew.h
$(RM) $(GLEW_TARGET)/lib/libGLEW.so
$(RM) $(GLEW_TARGET)/bin/glewinfo
clean:
$(RM) $(LIB.OBJS) $(LIB) $(BIN.OBJS) $(BIN)

0
bin/.do.not.remove Normal file
View File

382
doc/README.html Normal file
View File

@ -0,0 +1,382 @@
<!--
Copyright (C) 2002 Milan Ikits
This documentation may not be modified or redistributed in any
form, except by the copyright holder.
-->
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html/4/loose.dtd">
<html>
<head>
<title>
GLEW: The OpenGL Extension Wrangler Library
</title>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
</head>
<body bgcolor="#ffffff" text="#000000" link="#1010f0" vlink="#000080" alink="#800000">
<center>
<table border=0 width="50%" cellpadding="5" cellspacing="10">
<tr>
<td align=center><img src="./glew.png" alt="glew" width="97" height="75"></td>
</tr>
<tr>
<td align=center><font size="+2"><b>The OpenGL Extension Wrangler Library</b></font></td>
</tr>
<tr>
<td width="80%">
<table border=0 cellpadding=0 cellspacing=0 align=center>
<tr><td align=center><a href="#Introduction"><font size="-1">Introduction</font></a></td></tr>
<tr><td align=center><a href="#Download"><font size="-1">Obtaining GLEW</font></a></td></tr>
<tr><td align=center><a href="#Build"><font size="-1">How to Build Your Project with GLEW</font></a></td></tr>
<tr><td align=center><a href="#Install"><font size="-1">How to Install GLEW</font></a></td></tr>
<tr><td align=center><a href="#Use"><font size="-1">How to Use GLEW</font></a></td></tr>
<tr><td align=center><a href="#Issues"><font size="-1">Known Issues</font></a></td></tr>
<tr><td align=center><a href="#Credits"><font size="-1">Credits, Copyright</font></a></td></tr>
</table>
<br>
</td>
</tr>
<tr>
<td bgcolor="#FFF0D0" align="center"><a
name="Introduction"><font size="+1"><b>Introduction</b></font></a>
</td>
</tr>
<tr>
<td>
The goal of the OpenGL Extension Wrangler Library (GLEW) is to assist
C/C++ OpenGL developers with two tedious tasks: initializing and
using extensions and writing portable applications. GLEW provides
an efficient run-time mechanism to determine whether a certain
extension is supported by the driver or not. OpenGL core and
extension functionality is exposed via a single header file. GLEW
currently supports the products of two commodity graphics card
vendors, NVIDIA and ATI, on two operating systems, Windows and Linux.
<p>
</td>
</tr>
<tr>
<td bgcolor="#FFF0D0" align="center"><a
name="Download"><font size="+1"><b>Obtaining GLEW</b></font></a>
</td>
</tr>
<tr>
<td>
The source and precompiled binaries are available at the <a
href="http://glew.sourceforge.net/">project website</a>.
<p>
</td>
</tr>
<tr>
<td bgcolor="#FFF0D0" align="center"><a
name="Build"><font size="+1"><b>How to Build Your Project with GLEW</b></font></a>
</td>
</tr>
<tr>
<td>
There are two ways to build your project with GLEW.
<p>
<font size="+1"><b>Including the source files / project file</b></font>
<p>
The simpler but less flexible way is to include <tt>glew.h</tt> and
<tt>glew.c</tt> into your project and define the <tt>GLEW_STATIC</tt>
preprocessor constant for the static library or executable you are
building together with GLEW. You also need to replace
<tt>&lt;GL/gl.h&gt;</tt> and <tt>&lt;GL/glu.h&gt;</tt> with
<tt>&lt;glew.h&gt;</tt> and set the appropriate include flag
(<tt>-I</tt>) to tell the compiler where to look for it.
For example:
<blockquote><pre>#include &lt;glew.h&gt;
#include &lt;GL/glut.h&gt;
&lt;gl, glu, and glut functionality is available here&gt;
</pre></blockquote>
Note that if you are using GLEW together with GLUT, you have to
include <tt>glew.h</tt> first. In addition, <tt>glew.h</tt> includes
<tt>glu.h</tt>, so you don't need to include it separately.
<p>
On Windows you can also add the supplied project file
(<tt>glew.dsp</tt> or <tt>glew.vcproj</tt>) to your workspace or
solution and compile it together with your other projects. In this
case you need to change the <tt>GLEW_BUILD</tt> preprocessor constant
to <tt>GLEW_STATIC</tt>, otherwise you get build errors. <b>Note that
GLEW does not use the C runtime library, so it does not matter
which version (single-threaded, multi-threaded or multi-threaded DLL) it
is linked with</b>.
<p>
<font size="+1"><b>Using GLEW as a shared library</b></font>
<p>
Alternatively, you can use the provided project files / makefile to
build a separate shared library you can link your projects with later.
In this case the best practice is to install <tt>glew.h</tt>,
<tt>glew32.lib</tt>, and <tt>glew32.dll</tt> / <tt>libGLEW.so</tt> to
where the OpenGL equivalents <tt>gl.h</tt>, <tt>opengl32.lib</tt>, and
<tt>opengl32.dll</tt> / <tt>libGL.so</tt> are located. Note that you
need administrative privileges to do this. If you do not have
administrator access and your system administrator will not do it for
you, you can install GLEW into your own lib and include subdirectories
and tell the compiler where to find it. Then you can just replace
<tt>&lt;GL/gl.h&gt;</tt> with <tt>&lt;GL/glew.h&gt;</tt> in your
program:
<blockquote><pre>#include &lt;GL/glew.h&gt;
#include &lt;GL/glut.h&gt;
&lt;gl, glu, and glut functionality is available here&gt;
</pre></blockquote>
or:
<blockquote><pre>#include &lt;GL/glew.h&gt;
&lt;gl and glu functionality is available here&gt;
</pre></blockquote>
<p>
Don't forget to link your project with <tt>glew32.lib</tt>,
<tt>glu32.lib</tt>, and <tt>opengl32.lib</tt> on Windows and
<tt>libGLEW.so</tt>, <tt>libGLU.so</tt>, and <tt>libGL.so</tt> on
Linux (<tt>-lGLEW -lGLU -lGL</tt>).
<p>
It is important to keep in mind that <tt>glew.h</tt> includes neither
<tt>windows.h</tt> nor <tt>gl.h</tt>. Also, GLEW will warn you by
issuing a preprocessor error in case you have included <tt>gl.h</tt>,
<tt>glext.h</tt>, or <tt>glATI.h</tt> before <tt>glew.h</tt>.
<p>
</td>
</tr>
<tr>
<td bgcolor="#FFF0D0" align="center"><a
name="Install"><font size="+1"><b>How to Install GLEW</b></font></a>
</td>
</tr>
<tr>
<td>
<p>
To install the shared library version of GLEW you need to copy the
headers and libraries into their destination directories. On Windows
this boils down to copying (no, we will not write a Windows installer
for you).
<p>
<center>
<table border=0 cellpadding=0 cellspacing=0>
<tr><td><tt>lib/glew32.dll</tt></td><td>&nbsp;&nbsp;&nbsp;&nbsp;to&nbsp;&nbsp;&nbsp;&nbsp;</td>
<td><tt>%SystemRoot%/system32</tt>, usually <tt>C:/WINDOWS/system32</tt></td></tr>
<tr><td><tt>lib/glew32.lib</tt></td><td>&nbsp;&nbsp;&nbsp;&nbsp;to&nbsp;&nbsp;&nbsp;&nbsp;</td>
<td><tt>{VC Root}/Lib</tt></td></tr>
<tr><td><tt>include/GL/glew.h</tt></td><td>&nbsp;&nbsp;&nbsp;&nbsp;to&nbsp;&nbsp;&nbsp;&nbsp;</td>
<td><tt>{VC Root}/Include/GL</tt></td></tr>
<tr><td><tt>include/GL/wglew.h</tt></td><td>&nbsp;&nbsp;&nbsp;&nbsp;to&nbsp;&nbsp;&nbsp;&nbsp;</td>
<td><tt>{VC Root}/Include/GL</tt></td></tr>
</table>
</center>
<p>
where <tt>{VC Root}</tt> is your Visual C++ directory, typically
<tt>C:/Program Files/Microsoft Visual Studio/VC98</tt> for Visual
Studio 6.0 or <tt>C:/Program Files/Microsoft Visual
Studio/Vc7/PlatformSDK</tt> for Visual Studio .NET. <b>However, if you
build GLEW with Visual Studio .NET, the project file will
automatically install it into these directories, so you
don't have to worry about installation at all</b>.
<p>
On Linux, typing <tt>"make install"</tt> will attempt to install GLEW
into <tt>/usr/include/GL</tt> and <tt>/usr/lib</tt>. You can
customize the installation target via the <tt>GLEW_TARGET</tt>
environment variable if you do not have write access
to these directories.
<p>
</td>
</tr>
<tr>
<td bgcolor="#FFF0D0" align="center"><a
name="Use"><font size="+1"><b>How to Use GLEW</b></font></a>
</td>
</tr>
<tr>
<td>
<font size="+1"><b>Initializing GLEW</b></font>
<p>
First you need to create a valid OpenGL rendering context and call
<tt>glewInit()</tt> to initialize the extension entry points. If
<tt>glewInit()</tt> returns <tt>GLEW_OK</tt> the initialization
succeeded and you can use the available extensions as well as core
OpenGL functionality. For example:
<blockquote><pre>#include &lt;GL/glew.h&gt;
#include &lt;GL/glut.h&gt;
...
glutInit(&amp;argc, argv);
glutCreateWindow("GLEW Test");
int err = glewInit();
if (GLEW_OK != err)
{
/* problem: glewInit failed, something is seriously wrong */
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
...
}
</pre></blockquote>
<p>
<font size="+1"><b>Querying the available OpenGL extensions</b></font>
<p>
To find out if a particular extension is available on your
platform, use the globally defined structure <tt>glew</tt>:
<blockquote><pre>if (glew.ARB_vertex_program)
{
/* it is safe to use the ARB_vertex_program extension here */
glGenProgramsARB(...);
}
</pre></blockquote>
You can also check for core OpenGL functionality. For example, to
see if OpenGL 1.3 is supported you can use the following:
<blockquote><pre>if (glew.GL_13)
{
/* Yay! OpenGL 1.3 is supported! */
}
</pre></blockquote>
In general, you can check if <tt>glew.{extension_name}</tt> or
<tt>glew.GL_{version}</tt> is set or not.
<p>
<font size="+1"><b>Experimental drivers</b></font>
<p>
GLEW works by querying the supported extensions from the graphics
driver. Experimental drivers, however, might not report every
available extension through the standard mechanism, in which case GLEW
will report it unsupported. To circumvent this situation, the
<tt>glewExperimental</tt> global switch can be turned on by setting it
to <tt>GL_TRUE</tt> before calling <tt>glewInit()</tt>. This makes
sure that all extensions with valid entry points will be exposed.
<p>
<font size="+1"><b>Platform specific extensions</b></font>
<p>
Platform specific extensions are separated into two header files:
<tt>wglew.h</tt> and <tt>glxew.h</tt>. These files define the
available <tt>WGL</tt> and <tt>GLX</tt> extensions as well as the
global <tt>wglew</tt> and <tt>glxew</tt> structs, which work similarly
to the <tt>glew</tt> structure. To determine if a given <tt>WGL</tt> or
<tt>GLX</tt> extension is supported, query <tt>wglew.{extension name}</tt> or
<tt>glxew.{extension_name}</tt>. For example:
<blockquote><pre>#include &lt;GL/wglew.h&gt;
if (wglew.ARB_pbuffer)
{
/* OK, we can use pbuffers */
}
else
{
/* Sorry, pbuffers will not work on this platform */
}
</pre></blockquote>
<p>
<font size="+1"><b>glewinfo: a command line extension reporting utility</b></font>
<p>
GLEW comes with a command line utility called <tt>glewinfo</tt> that
allows you to make a list of the extensions supported on your platform.
The <tt>glewinfo</tt> utility uses GLEW to find out which extensions
and entry points are available and reports the results to a text file
called <tt>glewinfo.txt</tt>.
<p>
</td>
</tr>
<tr>
<td bgcolor="#FFF0D0" align="center"><a
name="Issues"><font size="+1"><b>Known Issues</b></font></a>
</td>
</tr>
<tr>
<td>
GLEW requires GLX 1.2 to assure compatibility with GLUT. In addition,
the SGI GLX video extensions are not supported, because they depend on
external libraries.
<p>
Note that according to the WGL and GLX specifications you have to
initialize the entry points for every rendering context you create.
GLEW ignores this requirement, and does not define per context entry
points. This means that you need to call <tt>glewInit()</tt> only
once in your program. We have not noticed any problems so far from
ignoring this requirement.
<p>
</td>
</tr>
<tr>
<td bgcolor="#FFF0D0" align="center"><a
name="Credits"><font size="+1"><b>Credits, Copyright</b></font></a>
</td>
</tr>
<tr>
<td>
Aaron Lefohn, Joe Kniss,
and Chris Wyman were the first users of GLEW and also assisted with
the design and debugging process. The acronym GLEW originates from
Aaron Lefohn.
<p>
GLEW is derived from the EXTGL project by Lev Povalahev. It is
licensed under the LGPL, the BSD license, the SGI Free Software
License B, and the GLX Public License. We encourage those who are not
in favor of the LGPL to read <a
href="http://www.cs.utah.edu/~gk/teem/lgpl.html">this</a> excellent
tutorial.
<blockquote><pre></pre></blockquote>
<tr>
<td bgcolor="#FFF0D0">
<table border="0" cellspacing="0" cellpadding="0" width="100%">
<tr>
<td align="left">
<i>Last update: 12-12-02</i></td>
</tr>
</table>
</td>
</tr>
</table>
</center>
</body>

BIN
doc/glew.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 9.1 KiB

206
doc/glx.txt Normal file
View File

@ -0,0 +1,206 @@
GLX PUBLIC LICENSE (Version 1.0 (2/11/99)) ("License")
Subject to any third party claims, Silicon Graphics, Inc. ("SGI") hereby
grants permission to Recipient (defined below), under Recipient's
copyrights in the Original Software (defined below), to use, copy,
modify, merge, publish, distribute, sublicense and/or sell copies of
Subject Software (defined below), and to permit persons to whom the
Subject Software is furnished in accordance with this License to do the
same, subject to all of the following terms and conditions, which
Recipient accepts by engaging in any such use, copying, modifying,
merging, publishing, distributing, sublicensing or selling:
1. Definitions.
(a) "Original Software" means source code of computer software code
which is described in Exhibit A as Original Software.
(b) "Modifications" means any addition to or deletion from the
substance or structure of either the Original Software or any
previous Modifications. When Subject Software is released as a
series of files, a Modification means (i) any addition to or
deletion from the contents of a file containing Original Software or
previous Modifications and (ii) any new file that contains any part
of the Original Code or previous Modifications.
(c) "Subject Software" means the Original Software or Modifications
or the combination of the Original Software and Modifications, or
portions of any of the foregoing.
(d) "Recipient" means an individual or a legal entity exercising
rights under, and complying with all of the terms of, this License.
For legal entities, "Recipient" includes any entity which controls,
is controlled by, or is under common control with Recipient. For
purposes of this definition, "control" of an entity means (a) the
power, direct or indirect, to direct or manage such entity, or (b)
ownership of fifty percent (50%) or more of the outstanding shares
or beneficial ownership of such entity.
2. Redistribution of Source Code Subject to These Terms. Redistributions
of Subject Software in source code form must retain the notice set forth
in Exhibit A, below, in every file. A copy of this License must be
included in any documentation for such Subject Software where the
recipients' rights relating to Subject Software are described. Recipient
may distribute the source code version of Subject Software under a
license of Recipient's choice, which may contain terms different from
this License, provided that (i) Recipient is in compliance with the
terms of this License, and (ii) the license terms include this Section 2
and Sections 3, 4, 7, 8, 10, 12 and 13 of this License, which terms may
not be modified or superseded by any other terms of such license. If
Recipient distributes the source code version under a different license
Recipient must make it absolutely clear that any terms which differ from
this License are offered by Recipient alone, not by SGI. Recipient
hereby agrees to indemnify SGI for any liability incurred by SGI as a
result of any such terms Recipient offers.
3. Redistribution in Executable Form. The notice set forth in Exhibit A
must be conspicuously included in any notice in an executable version of
Subject Software, related documentation or collateral in which Recipient
describes the user's rights relating to the Subject Software. Recipient
may distribute the executable version of Subject Software under a
license of Recipient's choice, which may contain terms different from
this License, provided that (i) Recipient is in compliance with the
terms of this License, and (ii) the license terms include this Section 3
and Sections 4, 7, 8, 10, 12 and 13 of this License, which terms may not
be modified or superseded by any other terms of such license. If
Recipient distributes the executable version under a different license
Recipient must make it absolutely clear that any terms which differ from
this License are offered by Recipient alone, not by SGI. Recipient
hereby agrees to indemnify SGI for any liability incurred by SGI as a
result of any such terms Recipient offers.
4. Termination. This License and the rights granted hereunder will
terminate automatically if Recipient fails to comply with terms herein
and fails to cure such breach within 30 days of the breach. Any
sublicense to the Subject Software which is properly granted shall
survive any termination of this License absent termination by the terms
of such sublicense. Provisions which, by their nature, must remain in
effect beyond the termination of this License shall survive.
5. No Trademark Rights. This License does not grant any rights to use
any trade name, trademark or service mark whatsoever. No trade name,
trademark or service mark of SGI may be used to endorse or promote
products derived from the Subject Software without prior written
permission of SGI.
6. No Other Rights. This License does not grant any rights with respect
to the OpenGL API or to any software or hardware implementation thereof
or to any other software whatsoever, nor shall any other rights or
licenses not expressly granted hereunder arise by implication, estoppel
or otherwise with respect to the Subject Software. Title to and
ownership of the Original Software at all times remains with SGI. All
rights in the Original Software not expressly granted under this License
are reserved.
7. Compliance with Laws; Non-Infringement. Recipient shall comply with
all applicable laws and regulations in connection with use and
distribution of the Subject Software, including but not limited to, all
export and import control laws and regulations of the U.S. government
and other countries. Recipient may not distribute Subject Software that
(i) in any way infringes (directly or contributorily) the rights
(including patent, copyright, trade secret, trademark or other
intellectual property rights of any kind) of any other person or entity
or (ii) breaches any representation or warranty, express, implied or
statutory, which under any applicable law it might be deemed to have
been distributed.
8. Claims of Infringement. If Recipient at any time has knowledge of any
one or more third party claims that reproduction, modification, use,
distribution, import or sale of Subject Software (including particular
functionality or code incorporated in Subject Software) infringes the
third party's intellectual property rights, Recipient must place in a
well-identified web page bearing the title "LEGAL" a description of each
such claim and a description of the party making each such claim in
sufficient detail that a user of the Subject Software will know whom to
contact regarding the claim. Also, upon gaining such knowledge of any
such claim, Recipient must conspicuously include the URL for such web
page in the Exhibit A notice required under Sections 2 and 3, above, and
in the text of any related documentation, license agreement or
collateral in which Recipient describes end user's rights relating to
the Subject Software. If Recipient obtains such knowledge after it makes
Subject Software available to any other person or entity, Recipient
shall take other steps (such as notifying appropriate mailing lists or
newsgroups) reasonably calculated to inform those who received the
Subject Software that new knowledge has been obtained.
9. DISCLAIMER OF WARRANTY. SUBJECT SOFTWARE IS PROVIDED ON AN "AS IS"
BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE SUBJECT SOFTWARE IS
FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-
INFRINGING. SGI ASSUMES NO RISK AS TO THE QUALITY AND PERFORMANCE OF THE
SOFTWARE. SHOULD ANY SOFTWARE PROVE DEFECTIVE IN ANY RESPECT, SGI
ASSUMES NO COST OR LIABILITY FOR ANY SERVICING, REPAIR OR CORRECTION.
THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
LICENSE. NO USE OF ANY SUBJECT SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT
UNDER THIS DISCLAIMER.
10. LIMITATION OF LIABILITY. UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL
THEORY, WHETHER TORT (INCLUDING, WITHOUT LIMITATION, NEGLIGENCE OR
STRICT LIABILITY), CONTRACT, OR OTHERWISE, SHALL SGI OR ANY SGI LICENSOR
BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR
CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION,
DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, LOSS OF DATA, COMPUTER
FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR
LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY
OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO
LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SGI's NEGLIGENCE
TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME
JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR
CONSEQUENTIAL DAMAGES, SO THAT EXCLUSION AND LIMITATION MAY NOT APPLY TO
RECIPIENT.
11. Indemnity. Recipient shall be solely responsible for damages
arising, directly or indirectly, out of its utilization of rights under
this License. Recipient will defend, indemnify and hold harmless Silicon
Graphics, Inc. from and against any loss, liability, damages, costs or
expenses (including the payment of reasonable attorneys fees) arising
out of Recipient's use, modification, reproduction and distribution of
the Subject Software or out of any representation or warranty made by
Recipient.
12. U.S. Government End Users. The Subject Software is a "commercial
item" consisting of "commercial computer software" as such terms are
defined in title 48 of the Code of Federal Regulations and all U.S.
Government End Users acquire only the rights set forth in this License
and are subject to the terms of this License.
13. Miscellaneous. This License represents the complete agreement
concerning subject matter hereof. If any provision of this License is
held to be unenforceable, such provision shall be reformed so as to
achieve as nearly as possible the same economic effect as the original
provision and the remainder of this License will remain in effect. This
License shall be governed by and construed in accordance with the laws
of the United States and the State of California as applied to
agreements entered into and to be performed entirely within California
between California residents. Any litigation relating to this License
shall be subject to the exclusive jurisdiction of the Federal Courts of
the Northern District of California (or, absent subject matter
jurisdiction in such courts, the courts of the State of California),
with venue lying exclusively in Santa Clara County, California, with the
losing party responsible for costs, including without limitation, court
costs and reasonable attorneys fees and expenses. The application of the
United Nations Convention on Contracts for the International Sale of
Goods is expressly excluded. Any law or regulation which provides that
the language of a contract shall be construed against the drafter shall
not apply to this License.
Exhibit A
The contents of this file are subject to Sections 2, 3, 4, 7, 8, 10, 12
and 13 of the GLX Public License Version 1.0 (the "License"). You may
not use this file except in compliance with those sections of the
License. You may obtain a copy of the License at Silicon Graphics, Inc.,
attn: Legal Services, 2011 N. Shoreline Blvd., Mountain View, CA 94043
or at http://www.sgi.com/software/opensource/glx/license.html.
Software distributed under the License is distributed on an "AS IS"
basis. ALL WARRANTIES ARE DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY
IMPLIED WARRANTIES OF MERCHANTABILITY, OF FITNESS FOR A PARTICULAR
PURPOSE OR OF NON- INFRINGEMENT. See the License for the specific
language governing rights and limitations under the License.
The Original Software is GLX version 1.2 source code, released February,
1999. The developer of the Original Software is Silicon Graphics, Inc.
Those portions of the Subject Software created by Silicon Graphics, Inc.
are Copyright (c) 1991-9 Silicon Graphics, Inc. All Rights Reserved.

502
doc/lgpl.txt Normal file
View File

@ -0,0 +1,502 @@
GNU LESSER GENERAL PUBLIC LICENSE
Version 2.1, February 1999
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the Lesser GPL. It also counts
as the successor of the GNU Library Public License, version 2, hence
the version number 2.1.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it. You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.
When we speak of free software, we are referring to freedom of use,
not price. Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.
To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights. These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.
To protect each distributor, we want to make it very clear that
there is no warranty for the free library. Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.
Finally, software patents pose a constant threat to the existence of
any free program. We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder. Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.
Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License. This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License. We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.
When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library. The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom. The Lesser General
Public License permits more lax criteria for linking other code with
the library.
We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License. It also provides other free software developers Less
of an advantage over competing non-free programs. These disadvantages
are the reason we use the ordinary General Public License for many
libraries. However, the Lesser license provides advantages in certain
special circumstances.
For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard. To achieve this, non-free programs must be
allowed to use the library. A more frequent case is that a free
library does the same job as widely used non-free libraries. In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.
In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software. For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.
Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.
GNU LESSER GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (1) uses at run time a
copy of the library already present on the user's computer system,
rather than copying library functions into the executable, and (2)
will operate properly with a modified version of the library, if
the user installs one, as long as the modified version is
interface-compatible with the version that the work was made with.
c) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
d) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
e) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Libraries
If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change. You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).
To apply these terms, attach the following notices to the library. It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.
<one line to give the library's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Also add information on how to contact you by electronic and paper mail.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
<signature of Ty Coon>, 1 April 1990
Ty Coon, President of Vice
That's all there is to it!

42
doc/sgi.txt Normal file
View File

@ -0,0 +1,42 @@
SGI FREE SOFTWARE LICENSE B (Version 1.1 [02/22/2000])
1. Definitions.
1.1. "Additional Notice Provisions" means such additional provisions as appear in the Notice in Original Code under the heading "Additional Notice Provisions."
1.2. "Covered Code" means the Original Code or Modifications, or any combination thereof.
1.3. "Hardware" means any physical device that accepts input, processes input, stores the results of processing, and/or provides output.
1.4. "Larger Work" means a work that combines Covered Code or portions thereof with code not governed by the terms of this License.
1.5. "Licensable" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently acquired, any and all of the rights conveyed herein.
1.6. "License" means this document.
1.7. "Licensed Patents" means patent claims Licensable by SGI that are infringed by the use or sale of Original Code or any Modifications provided by SGI, or any combination thereof.
1.8. "Modifications" means any addition to or deletion from the substance or structure of the Original Code or any previous Modifications. When Covered Code is released as a series of files, a Modification is:
A. Any addition to the contents of a file containing Original Code and/or addition to or deletion from the contents of a file containing previous Modifications.
B. Any new file that contains any part of the Original Code or previous Modifications.
1.9. "Notice" means any notice in Original Code or Covered Code, as required by and in compliance with this License.
1.10. "Original Code" means source code of computer software code that is described in the source code Notice required by Exhibit A as Original Code, and updates and error corrections specifically thereto.
1.11. "Recipient" means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 8. For legal entities, "Recipient" includes any entity that controls, is controlled by, or is under common control with Recipient. For purposes of this definition, "control" of an entity means (a) the power, direct or indirect, to direct or manage such entity, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity.
1.12. "Recipient Patents" means patent claims Licensable by a Recipient that are infringed by the use or sale of Original Code or any Modifications provided by SGI, or any combination thereof.
1.13. "SGI" means Silicon Graphics, Inc.
1.14. "SGI Patents" means patent claims Licensable by SGI other than the Licensed Patents.
2. License Grant and Restrictions.
2.1. SGI License Grant. Subject to the terms of this License and any third party intellectual property claims, for the duration of intellectual property protections inherent in the Original Code, SGI hereby grants Recipient a worldwide, royalty-free, non-exclusive license, to do the following: (i) under copyrights Licensable by SGI, to reproduce, distribute, create derivative works from, and, to the extent applicable, display and perform the Original Code and/or any Modifications provided by SGI alone and/or as part of a Larger Work; and (ii) under any Licensable Patents, to make, have made, use, sell, offer for sale, import and/or otherwise transfer the Original Code and/or any Modifications provided by SGI. Recipient accepts the terms and conditions of this License by undertaking any of the aforementioned actions. The patent license shall apply to the Covered Code if, at the time any related Modification is added, such addition of the Modification causes such combination to be covered by the Licensed Patents. The patent license in Section 2.1(ii) shall not apply to any other combinations that include the Modification. No patent license is provided under SGI Patents for infringements of SGI Patents by Modifications not provided by SGI or combinations of Original Code and Modifications not provided by SGI.
2.2. Recipient License Grant. Subject to the terms of this License and any third party intellectual property claims, Recipient hereby grants SGI and any other Recipients a worldwide, royalty-free, non-exclusive license, under any Recipient Patents, to make, have made, use, sell, offer for sale, import and/or otherwise transfer the Original Code and/or any Modifications provided by SGI.
2.3. No License For Hardware Implementations. The licenses granted in Section 2.1 and 2.2 are not applicable to implementation in Hardware of the algorithms embodied in the Original Code or any Modifications provided by SGI .
3. Redistributions.
3.1. Retention of Notice/Copy of License. The Notice set forth in Exhibit A, below, must be conspicuously retained or included in any and all redistributions of Covered Code. For distributions of the Covered Code in source code form, the Notice must appear in every file that can include a text comments field; in executable form, the Notice and a copy of this License must appear in related documentation or collateral where the Recipient's rights relating to Covered Code are described. Any Additional Notice Provisions which actually appears in the Original Code must also be retained or included in any and all redistributions of Covered Code.
3.2. Alternative License. Provided that Recipient is in compliance with the terms of this License, Recipient may, so long as without derogation of any of SGI's rights in and to the Original Code, distribute the source code and/or executable version(s) of Covered Code under (1) this License; (2) a license identical to this License but for only such changes as are necessary in order to clarify Recipient's role as licensor of Modifications; and/or (3) a license of Recipient's choosing, containing terms different from this License, provided that the license terms include this Section 3 and Sections 4, 6, 7, 10, 12, and 13, which terms may not be modified or superseded by any other terms of such license. If Recipient elects to use any license other than this License, Recipient must make it absolutely clear that any of its terms which differ from this License are offered by Recipient alone, and not by SGI. It is emphasized that this License is a limited license, and, regardless of the license form employed by Recipient in accordance with this Section 3.2, Recipient may relicense only such rights, in Original Code and Modifications by SGI, as it has actually been granted by SGI in this License.
3.3. Indemnity. Recipient hereby agrees to indemnify SGI for any liability incurred by SGI as a result of any such alternative license terms Recipient offers.
4. Termination. This License and the rights granted hereunder will terminate automatically if Recipient breaches any term herein and fails to cure such breach within 30 days thereof. Any sublicense to the Covered Code that is properly granted shall survive any termination of this License, absent termination by the terms of such sublicense. Provisions that, by their nature, must remain in effect beyond the termination of this License, shall survive.
5. No Trademark Or Other Rights. This License does not grant any rights to: (i) any software apart from the Covered Code, nor shall any other rights or licenses not expressly granted hereunder arise by implication, estoppel or otherwise with respect to the Covered Code; (ii) any trade name, trademark or service mark whatsoever, including without limitation any related right for purposes of endorsement or promotion of products derived from the Covered Code, without prior written permission of SGI; or (iii) any title to or ownership of the Original Code, which shall at all times remains with SGI. All rights in the Original Code not expressly granted under this License are reserved.
6. Compliance with Laws; Non-Infringement. There are various worldwide laws, regulations, and executive orders applicable to dispositions of Covered Code, including without limitation export, re-export, and import control laws, regulations, and executive orders, of the U.S. government and other countries, and Recipient is reminded it is obliged to obey such laws, regulations, and executive orders. Recipient may not distribute Covered Code that (i) in any way infringes (directly or contributorily) any intellectual property rights of any kind of any other person or entity or (ii) breaches any representation or warranty, express, implied or statutory, to which, under any applicable law, it might be deemed to have been subject.
7. Claims of Infringement. If Recipient learns of any third party claim that any disposition of Covered Code and/or functionality wholly or partially infringes the third party's intellectual property rights, Recipient will promptly notify SGI of such claim.
8. Versions of the License. SGI may publish revised and/or new versions of the License from time to time, each with a distinguishing version number. Once Covered Code has been published under a particular version of the License, Recipient may, for the duration of the license, continue to use it under the terms of that version, or choose to use such Covered Code under the terms of any subsequent version published by SGI. Subject to the provisions of Sections 3 and 4 of this License, only SGI may modify the terms applicable to Covered Code created under this License.
9. DISCLAIMER OF WARRANTY. COVERED CODE IS PROVIDED "AS IS." ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS ARE DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. SGI ASSUMES NO RISK AS TO THE QUALITY AND PERFORMANCE OF THE SOFTWARE. SHOULD THE SOFTWARE PROVE DEFECTIVE IN ANY RESPECT, SGI ASSUMES NO COST OR LIABILITY FOR SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY IS AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT SUBJECT TO THIS DISCLAIMER.
10. LIMITATION OF LIABILITY. UNDER NO CIRCUMSTANCES NOR LEGAL THEORY, WHETHER TORT (INCLUDING, WITHOUT LIMITATION, NEGLIGENCE OR STRICT LIABILITY), CONTRACT, OR OTHERWISE, SHALL SGI OR ANY SGI LICENSOR BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, LOSS OF DATA, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SGI's NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THAT EXCLUSION AND LIMITATION MAY NOT APPLY TO RECIPIENT.
11. Indemnity. Recipient shall be solely responsible for damages arising, directly or indirectly, out of its utilization of rights under this License. Recipient will defend, indemnify and hold harmless Silicon Graphics, Inc. from and against any loss, liability, damages, costs or expenses (including the payment of reasonable attorneys fees) arising out of Recipient's use, modification, reproduction and distribution of the Covered Code or out of any representation or warranty made by Recipient.
12. U.S. Government End Users. The Covered Code is a "commercial item" consisting of "commercial computer software" as such terms are defined in title 48 of the Code of Federal Regulations and all U.S. Government End Users acquire only the rights set forth in this License and are subject to the terms of this License.
13. Miscellaneous. This License represents the complete agreement concerning the its subject matter. If any provision of this License is held to be unenforceable, such provision shall be reformed so as to achieve as nearly as possible the same legal and economic effect as the original provision and the remainder of this License will remain in effect. This License shall be governed by and construed in accordance with the laws of the United States and the State of California as applied to agreements entered into and to be performed entirely within California between California residents. Any litigation relating to this License shall be subject to the exclusive jurisdiction of the Federal Courts of the Northern District of California (or, absent subject matter jurisdiction in such courts, the courts of the State of California), with venue lying exclusively in Santa Clara County, California, with the losing party responsible for costs, including without limitation, court costs and reasonable attorneys fees and expenses. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any law or regulation that provides that the language of a contract shall be construed against the drafter shall not apply to this License.
Exhibit A
License Applicability. Except to the extent portions of this file are made subject to an alternative license as permitted in the SGI Free Software License B, Version 1.1 (the "License"), the contents of this file are subject only to the provisions of the License. You may not use this file except in compliance with the License. You may obtain a copy of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
http://oss.sgi.com/projects/FreeB
Note that, as provided in the License, the Software is distributed on an "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
Original Code. The Original Code is: [name of software, version number, and release date], developed by Silicon Graphics, Inc. The Original Code is Copyright (c) [dates of first publication, as appearing in the Notice in the Original Code] Silicon Graphics, Inc. Copyright in any portions created by third parties is as indicated elsewhere herein. All Rights Reserved.
Additional Notice Provisions: [such additional provisions, if any, as appear in the Notice in the Original Code under the heading "Additional Notice Provisions"]

4575
include/GL/glew.h Normal file
View File

File diff suppressed because it is too large Load Diff

796
include/GL/glxew.h Normal file
View File

@ -0,0 +1,796 @@
/*
** The contents of this file are subject to the GLX Public License Version 1.0
** (the "License"). You may not use this file except in compliance with the
** License. You may obtain a copy of the License at Silicon Graphics, Inc.,
** attn: Legal Services, 2011 N. Shoreline Blvd., Mountain View, CA 94043
** or at http://www.sgi.com/software/opensource/glx/license.html.
**
** Software distributed under the License is distributed on an "AS IS"
** basis. ALL WARRANTIES ARE DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY
** IMPLIED WARRANTIES OF MERCHANTABILITY, OF FITNESS FOR A PARTICULAR
** PURPOSE OR OF NON- INFRINGEMENT. See the License for the specific
** language governing rights and limitations under the License.
**
** The Original Software is GLX version 1.2 source code, released February,
** 1999. The developer of the Original Software is Silicon Graphics, Inc.
** Those portions of the Subject Software created by Silicon Graphics, Inc.
** are Copyright (c) 1991-9 Silicon Graphics, Inc. All Rights Reserved.
*/
/*
** The OpenGL Extension Wrangler Library
** Copyright (C) 2002 Milan Ikits
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __glxew_h__
#define __glxew_h__
#ifdef __glxext_h_
#error glxext.h included before glxew.h
#endif
#define __glxext_h_
#ifndef _WIN32
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xmd.h>
#include <GL/glew.h>
#ifdef __cplusplus
extern "C" {
#endif
/* core GLX */
#define GLX_VERSION_1_0 1
#define GLX_VERSION_1_1 1
#define GLX_VERSION_1_2 1
#define GLX_VERSION_1_3 1
#define GLX_VERSION_1_4 1
/* ARB extensions */
#define GLX_ARB_get_proc_address 1
#define GLX_ARB_multisample 1
/* multi-vendor extensions */
#define GLX_EXT_import_context 1
#define GLX_EXT_visual_info 1
#define GLX_EXT_visual_rating 1
/* MESA extensions */
#define GLX_MESA_copy_sub_buffer 1
#define GLX_MESA_pixmap_colormap 1
#define GLX_MESA_release_buffers 1
#define GLX_MESA_set_3dfx_mode 1
/* NVIDIA extensions */
#define GLX_NV_vertex_array_range 1
/* OML extensions */
#define GLX_OML_swap_method 1
#define GLX_OML_sync_control 1
/* SGI extensions */
#define GLX_SGI_cushion 1
#define GLX_SGI_make_current_read 1
#define GLX_SGI_swap_control 1
#define GLX_SGI_video_sync 1
#define GLX_SGIS_blended_overlay 1
#define GLX_SGIS_multisample 1
#define GLX_SGIS_shared_multisample 1
/* #define GLX_SGIX_dm_buffer 1 */
#define GLX_SGIX_fbconfig 1
#define GLX_SGIX_pbuffer 1
#define GLX_SGIX_swap_group 1
#define GLX_SGIX_swap_barrier 1
/* #define GLX_SGIX_video_source 1*/
/* #define GLX_SGIX_video_resize 1*/
#define GLX_SGIX_visual_select_group 1
/* SUN extensions */
#define GLX_SUN_get_transparent_index 1
/* -------------------------------- GLX 1.0 ------------------------------- */
#ifdef GLX_VERSION_1_0
#define GLX_USE_GL 1
#define GLX_BUFFER_SIZE 2
#define GLX_LEVEL 3
#define GLX_RGBA 4
#define GLX_DOUBLEBUFFER 5
#define GLX_STEREO 6
#define GLX_AUX_BUFFERS 7
#define GLX_RED_SIZE 8
#define GLX_GREEN_SIZE 9
#define GLX_BLUE_SIZE 10
#define GLX_ALPHA_SIZE 11
#define GLX_DEPTH_SIZE 12
#define GLX_STENCIL_SIZE 13
#define GLX_ACCUM_RED_SIZE 14
#define GLX_ACCUM_GREEN_SIZE 15
#define GLX_ACCUM_BLUE_SIZE 16
#define GLX_ACCUM_ALPHA_SIZE 17
#define GLX_BAD_SCREEN 1
#define GLX_BAD_ATTRIBUTE 2
#define GLX_NO_EXTENSION 3
#define GLX_BAD_VISUAL 4
#define GLX_BAD_CONTEXT 5
#define GLX_BAD_VALUE 6
#define GLX_BAD_ENUM 7
typedef XID GLXDrawable;
typedef XID GLXPixmap;
typedef struct __GLXcontextRec *GLXContext;
#ifdef GLEW_PROTOTYPES
typedef Bool ( * glXQueryExtensionPROC) (Display *dpy, int *errorBase, int *eventBase);
typedef Bool ( * glXQueryVersionPROC) (Display *dpy, int *major, int *minor);
typedef int ( * glXGetConfigPROC) (Display *dpy, XVisualInfo *vis, int attrib, int *value);
typedef XVisualInfo* ( * glXChooseVisualPROC) (Display *dpy, int screen, int *attribList);
typedef GLXPixmap ( * glXCreateGLXPixmapPROC) (Display *dpy, XVisualInfo *vis, Pixmap pixmap);
typedef void ( * glXDestroyGLXPixmapPROC) (Display *dpy, GLXPixmap pix);
typedef GLXContext ( * glXCreateContextPROC) (Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
typedef void ( * glXDestroyContextPROC) (Display *dpy, GLXContext ctx);
typedef Bool ( * glXIsDirectPROC) (Display *dpy, GLXContext ctx);
typedef void ( * glXCopyContextPROC) (Display *dpy, GLXContext src, GLXContext dst, GLuint mask);
typedef Bool ( * glXMakeCurrentPROC) (Display *dpy, GLXDrawable drawable, GLXContext ctx);
typedef GLXContext ( * glXGetCurrentContextPROC) (void);
typedef GLXDrawable ( * glXGetCurrentDrawablePROC) (void);
typedef void ( * glXWaitGLPROC) (void);
typedef void ( * glXWaitXPROC) (void);
typedef void ( * glXSwapBuffersPROC) (Display *dpy, GLXDrawable drawable);
typedef void ( * glXUseXFontPROC) (Font font, int first, int count, int listBase);
extern glXQueryExtensionPROC glXQueryExtension;
extern glXQueryVersionPROC glXQueryVersion;
extern glXGetConfigPROC glXGetConfig;
extern glXChooseVisualPROC glXChooseVisual;
extern glXCreateGLXPixmapPROC glXCreateGLXPixmap;
extern glXDestroyGLXPixmapPROC glXDestroyGLXPixmap;
extern glXCreateContextPROC glXCreateContext;
extern glXDestroyContextPROC glXDestroyContext;
extern glXIsDirectPROC glXIsDirect;
extern glXCopyContextPROC glXCopyContext;
extern glXMakeCurrentPROC glXMakeCurrent;
extern glXGetCurrentContextPROC glXGetCurrentContext;
extern glXGetCurrentDrawablePROC glXGetCurrentDrawable;
extern glXWaitGLPROC glXWaitGL;
extern glXWaitXPROC glXWaitX;
extern glXSwapBuffersPROC glXSwapBuffers;
extern glXUseXFontPROC glXUseXFont;
#else
extern Bool glXQueryExtension (Display *dpy, int *errorBase, int *eventBase);
extern Bool glXQueryVersion (Display *dpy, int *major, int *minor);
extern int glXGetConfig (Display *dpy, XVisualInfo *vis, int attrib, int *value);
extern XVisualInfo* glXChooseVisual (Display *dpy, int screen, int *attribList);
extern GLXPixmap glXCreateGLXPixmap (Display *dpy, XVisualInfo *vis, Pixmap pixmap);
extern void glXDestroyGLXPixmap (Display *dpy, GLXPixmap pix);
extern GLXContext glXCreateContext (Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
extern void glXDestroyContext (Display *dpy, GLXContext ctx);
extern Bool glXIsDirect (Display *dpy, GLXContext ctx);
extern void glXCopyContext (Display *dpy, GLXContext src, GLXContext dst, GLuint mask);
extern Bool glXMakeCurrent (Display *dpy, GLXDrawable drawable, GLXContext ctx);
extern GLXContext glXGetCurrentContext (void);
extern GLXDrawable glXGetCurrentDrawable (void);
extern void glXWaitGL (void);
extern void glXWaitX (void);
extern void glXSwapBuffers (Display *dpy, GLXDrawable drawable);
extern void glXUseXFont (Font font, int first, int count, int listBase);
#endif
#endif /* GLX_VERSION_1_0 */
/* -------------------------------- GLX 1.1 ------------------------------- */
#ifdef GLX_VERSION_1_1
#define GLX_VENDOR 0x1
#define GLX_VERSION 0x2
#define GLX_EXTENSIONS 0x3
#ifdef GLEW_PROTOTYPES
typedef const char* ( * glXQueryExtensionsStringPROC) (Display *dpy, int screen);
typedef const char* ( * glXGetClientStringPROC) (Display *dpy, int name);
typedef const char* ( * glXQueryServerStringPROC) (Display *dpy, int screen, int name);
extern glXQueryExtensionsStringPROC glXQueryExtensionsString;
extern glXGetClientStringPROC glXGetClientString;
extern glXQueryServerStringPROC glXQueryServerString;
#else
extern const char* glXQueryExtensionsString (Display *dpy, int screen);
extern const char* glXGetClientString (Display *dpy, int name);
extern const char* glXQueryServerString (Display *dpy, int screen, int name);
#endif
#endif /* GLX_VERSION_1_1 */
/* -------------------------------- GLX 1.2 ------------------------------- */
#ifdef GLX_VERSION_1_2
typedef Display* ( * glXGetCurrentDisplayPROC) (void);
extern glXGetCurrentDisplayPROC glXGetCurrentDisplay;
#endif /* GLX_VERSION_1_2 */
/* -------------------------------- GLX 1.3 ------------------------------- */
#ifdef GLX_VERSION_1_3
#define GLX_WINDOW_BIT 0x00000001
#define GLX_PIXMAP_BIT 0x00000002
#define GLX_PBUFFER_BIT 0x00000004
#define GLX_RGBA_BIT 0x00000001
#define GLX_COLOR_INDEX_BIT 0x00000002
#define GLX_PBUFFER_CLOBBER_MASK 0x08000000
#define GLX_FRONT_LEFT_BUFFER_BIT 0x00000001
#define GLX_FRONT_RIGHT_BUFFER_BIT 0x00000002
#define GLX_BACK_LEFT_BUFFER_BIT 0x00000004
#define GLX_BACK_RIGHT_BUFFER_BIT 0x00000008
#define GLX_AUX_BUFFERS_BIT 0x00000010
#define GLX_DEPTH_BUFFER_BIT 0x00000020
#define GLX_STENCIL_BUFFER_BIT 0x00000040
#define GLX_ACCUM_BUFFER_BIT 0x00000080
#define GLX_CONFIG_CAVEAT 0x20
#define GLX_X_VISUAL_TYPE 0x22
#define GLX_TRANSPARENT_TYPE 0x23
#define GLX_TRANSPARENT_INDEX_VALUE 0x24
#define GLX_TRANSPARENT_RED_VALUE 0x25
#define GLX_TRANSPARENT_GREEN_VALUE 0x26
#define GLX_TRANSPARENT_BLUE_VALUE 0x27
#define GLX_TRANSPARENT_ALPHA_VALUE 0x28
#define GLX_DONT_CARE 0xFFFFFFFF
#define GLX_NONE 0x8000
#define GLX_SLOW_CONFIG 0x8001
#define GLX_TRUE_COLOR 0x8002
#define GLX_DIRECT_COLOR 0x8003
#define GLX_PSEUDO_COLOR 0x8004
#define GLX_STATIC_COLOR 0x8005
#define GLX_GRAY_SCALE 0x8006
#define GLX_STATIC_GRAY 0x8007
#define GLX_TRANSPARENT_RGB 0x8008
#define GLX_TRANSPARENT_INDEX 0x8009
#define GLX_VISUAL_ID 0x800B
#define GLX_SCREEN 0x800C
#define GLX_NON_CONFORMANT_CONFIG 0x800D
#define GLX_DRAWABLE_TYPE 0x8010
#define GLX_RENDER_TYPE 0x8011
#define GLX_X_RENDERABLE 0x8012
#define GLX_FBCONFIG_ID 0x8013
#define GLX_RGBA_TYPE 0x8014
#define GLX_COLOR_INDEX_TYPE 0x8015
#define GLX_MAX_PBUFFER_WIDTH 0x8016
#define GLX_MAX_PBUFFER_HEIGHT 0x8017
#define GLX_MAX_PBUFFER_PIXELS 0x8018
#define GLX_PRESERVED_CONTENTS 0x801B
#define GLX_LARGEST_PBUFFER 0x801C
#define GLX_WIDTH 0x801D
#define GLX_HEIGHT 0x801E
#define GLX_EVENT_MASK 0x801F
#define GLX_DAMAGED 0x8020
#define GLX_SAVED 0x8021
#define GLX_WINDOW 0x8022
#define GLX_PBUFFER 0x8023
#define GLX_PBUFFER_HEIGHT 0x8040
#define GLX_PBUFFER_WIDTH 0x8041
typedef XID GLXWindow;
typedef XID GLXPbuffer;
typedef XID GLXFBConfigID;
typedef struct __GLXFBConfigRec *GLXFBConfig;
typedef struct {
int event_type;
int draw_type;
unsigned long serial;
Bool send_event;
Display *display;
GLXDrawable drawable;
unsigned int buffer_mask;
unsigned int aux_buffer;
int x, y;
int width, height;
int count;
} GLXPbufferClobberEvent;
typedef union __GLXEvent {
GLXPbufferClobberEvent glxpbufferclobber;
long pad[24];
} GLXEvent;
typedef GLXFBConfig* ( * glXChooseFBConfigPROC) (Display *dpy, int screen, const int *attrib_list, int *nelements);
typedef GLXFBConfig* ( * glXGetFBConfigsPROC) (Display *dpy, int screen, int *nelements);
typedef XVisualInfo* ( * glXGetVisualFromFBConfigPROC) (Display *dpy, GLXFBConfig config);
typedef int ( * glXGetFBConfigAttribPROC) (Display *dpy, GLXFBConfig config, int attribute, int *value);
typedef GLXWindow ( * glXCreateWindowPROC) (Display *dpy, GLXFBConfig config, Window win, const int *attrib_list);
typedef void ( * glXDestroyWindowPROC) (Display *dpy, GLXWindow win);
typedef GLXPixmap ( * glXCreatePixmapPROC) (Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attrib_list);
typedef void ( * glXDestroyPixmapPROC) (Display *dpy, GLXPixmap pixmap);
typedef GLXPbuffer ( * glXCreatePbufferPROC) (Display *dpy, GLXFBConfig config, const int *attrib_list);
typedef void ( * glXDestroyPbufferPROC) (Display *dpy, GLXPbuffer pbuf);
typedef void ( * glXQueryDrawablePROC) (Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
typedef GLXContext ( * glXCreateNewContextPROC) (Display *dpy, GLXFBConfig config, int render_type, GLXContext share_list, Bool direct);
typedef Bool ( * glXMakeContextCurrentPROC) (Display *display, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
typedef GLXDrawable ( * glXGetCurrentReadDrawablePROC) (void);
typedef int ( * glXQueryContextPROC) (Display *dpy, GLXContext ctx, int attribute, int *value);
typedef void ( * glXSelectEventPROC) (Display *dpy, GLXDrawable draw, unsigned long event_mask);
typedef void ( * glXGetSelectedEventPROC) (Display *dpy, GLXDrawable draw, unsigned long *event_mask);
extern glXChooseFBConfigPROC glXChooseFBConfig;
extern glXGetFBConfigsPROC glXGetFBConfigs;
extern glXGetVisualFromFBConfigPROC glXGetVisualFromFBConfig;
extern glXGetFBConfigAttribPROC glXGetFBConfigAttrib;
extern glXCreateWindowPROC glXCreateWindow;
extern glXDestroyWindowPROC glXDestroyWindow;
extern glXCreatePixmapPROC glXCreatePixmap;
extern glXDestroyPixmapPROC glXDestroyPixmap;
extern glXCreatePbufferPROC glXCreatePbuffer;
extern glXDestroyPbufferPROC glXDestroyPbuffer;
extern glXQueryDrawablePROC glXQueryDrawable;
extern glXCreateNewContextPROC glXCreateNewContext;
extern glXMakeContextCurrentPROC glXMakeContextCurrent;
extern glXGetCurrentReadDrawablePROC glXGetCurrentReadDrawable;
extern glXQueryContextPROC glXQueryContext;
extern glXSelectEventPROC glXSelectEvent;
extern glXGetSelectedEventPROC glXGetSelectedEvent;
#if 0
extern GLXFBConfig* glXChooseFBConfig (Display *dpy, int screen, const int *attrib_list, int *nelements);
extern GLXFBConfig* glXGetFBConfigs (Display *dpy, int screen, int *nelements);
extern XVisualInfo* glXGetVisualFromFBConfig (Display *dpy, GLXFBConfig config);
extern int glXGetFBConfigAttrib (Display *dpy, GLXFBConfig config, int attribute, int *value);
extern GLXWindow glXCreateWindow (Display *dpy, GLXFBConfig config, Window win, const int *attrib_list);
extern void glXDestroyWindow (Display *dpy, GLXWindow win);
extern GLXPixmap glXCreatePixmap (Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attrib_list);
extern void glXDestroyPixmap (Display *dpy, GLXPixmap pixmap);
extern GLXPbuffer glXCreatePbuffer (Display *dpy, GLXFBConfig config, const int *attrib_list);
extern void glXDestroyPbuffer (Display *dpy, GLXPbuffer pbuf);
extern void glXQueryDrawable (Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
extern GLXContext glXCreateNewContext (Display *dpy, GLXFBConfig config, int render_type, GLXContext share_list, Bool direct);
extern Bool glXMakeContextCurrent (Display *display, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
extern GLXDrawable glXGetCurrentReadDrawable (void);
extern int glXQueryContext (Display *dpy, GLXContext ctx, int attribute, int *value);
extern void glXSelectEvent (Display *dpy, GLXDrawable draw, unsigned long event_mask);
extern void glXGetSelectedEvent (Display *dpy, GLXDrawable draw, unsigned long *event_mask);
#endif
#endif /* GLX_VERSION_1_3 */
/* -------------------------------- GLX 1.4 ------------------------------- */
#ifdef GLX_VERSION_1_4
#define GLX_SAMPLE_BUFFERS 100000
#define GLX_SAMPLES 100001
extern void ( * glXGetProcAddress(const GLubyte *procName))(void);
#endif /* GLX_VERSION_1_4 */
/* ------------------------- ARB_get_proc_address ------------------------- */
#ifdef GLX_ARB_get_proc_address
extern void ( * glXGetProcAddressARB(const GLubyte *procName))(void);
#endif /* GLX_ARB_get_proc_address */
/* ---------------------------- ARB_multisample --------------------------- */
#ifdef GLX_ARB_multisample
#define GLX_SAMPLE_BUFFERS_ARB 100000
#define GLX_SAMPLES_ARB 100001
#endif /* GLX_ARB_multisample */
/* ---------------------------- EXT_visual_info --------------------------- */
#ifdef GLX_EXT_visual_info
#define GLX_X_VISUAL_TYPE_EXT 0x22
#define GLX_TRANSPARENT_TYPE_EXT 0x23
#define GLX_TRANSPARENT_INDEX_VALUE_EXT 0x24
#define GLX_TRANSPARENT_RED_VALUE_EXT 0x25
#define GLX_TRANSPARENT_GREEN_VALUE_EXT 0x26
#define GLX_TRANSPARENT_BLUE_VALUE_EXT 0x27
#define GLX_TRANSPARENT_ALPHA_VALUE_EXT 0x28
#define GLX_NONE_EXT 0x8000
#define GLX_TRUE_COLOR_EXT 0x8002
#define GLX_DIRECT_COLOR_EXT 0x8003
#define GLX_PSEUDO_COLOR_EXT 0x8004
#define GLX_STATIC_COLOR_EXT 0x8005
#define GLX_GRAY_SCALE_EXT 0x8006
#define GLX_STATIC_GRAY_EXT 0x8007
#define GLX_TRANSPARENT_RGB_EXT 0x8008
#define GLX_TRANSPARENT_INDEX_EXT 0x8009
#endif /* GLX_EXT_visual_info */
/* --------------------------- EXT_visual_rating -------------------------- */
#ifdef GLX_EXT_visual_rating
#define GLX_VISUAL_CAVEAT_EXT 0x20
#define GLX_SLOW_VISUAL_EXT 0x8001
#define GLX_NON_CONFORMANT_VISUAL_EXT 0x800D
#endif /* GLX_EXT_visual_rating */
/* --------------------------- EXT_import_context -------------------------- */
#ifdef GLX_EXT_import_context
#define GLX_SHARE_CONTEXT_EXT 0x800A
#define GLX_VISUAL_ID_EXT 0x800B
#define GLX_SCREEN_EXT 0x800C
typedef XID GLXContextID;
typedef Display * ( * glXGetCurrentDisplayEXTPROC) (void);
typedef int ( * glXQueryContextInfoEXTPROC) (Display *dpy, GLXContext context, int attribute, int *value);
typedef GLXContextID ( * glXGetContextIDEXTPROC) (const GLXContext context);
typedef GLXContext ( * glXImportContextEXTPROC) (Display *dpy, GLXContextID contextID);
typedef void ( * glXFreeContextEXTPROC) (Display *dpy, GLXContext context);
extern glXGetCurrentDisplayEXTPROC glXGetCurrentDisplayEXT;
extern glXQueryContextInfoEXTPROC glXQueryContextInfoEXT;
extern glXGetContextIDEXTPROC glXGetContextIDEXT;
extern glXImportContextEXTPROC glXImportContextEXT;
extern glXFreeContextEXTPROC glXFreeContextEXT;
#endif /* GLX_EXT_import_context */
/* --------------------------- MESA_copy_sub_buffer ----------------------- */
#ifdef GLX_MESA_copy_sub_buffer
typedef void ( * glXCopySubBufferMESAPROC) (Display *dpy, GLXDrawable drawable, int x, int y, int width, int height);
extern glXCopySubBufferMESAPROC glXCopySubBufferMESA;
#endif /* GLX_MESA_copy_sub_buffer */
/* -------------------------- MESA_pixmap_colormap ------------------------ */
#ifdef GLX_MESA_pixmap_colormap
typedef GLXPixmap ( * glXCreateGLXPixmapMESAPROC) (Display *dpy, XVisualInfo *visual, Pixmap pixmap, Colormap cmap);
extern glXCreateGLXPixmapMESAPROC glXCreateGLXPixmapMESA;
#endif /* GLX_MESA_pixmap_colormap */
/* -------------------------- MESA_release_buffers ------------------------ */
#ifdef GLX_MESA_release_buffers
typedef Bool ( * glXReleaseBuffersMESAPROC) (Display *dpy, GLXDrawable drawable);
extern glXReleaseBuffersMESAPROC glXReleaseBuffersMESA;
#endif /* GLX_MESA_release_buffers */
/* --------------------------- MESA_set_3dfx_mode ------------------------- */
#ifdef GLX_MESA_set_3dfx_mode
typedef Bool ( * glXSet3DfxModeMESAPROC) (int mode);
extern glXSet3DfxModeMESAPROC glXSet3DfxModeMESA;
#endif /* GLX_MESA_set_3dfx_mode */
/* ---------------------------- OML_swap_method --------------------------- */
#ifdef GLX_OML_swap_method
#define GLX_SWAP_METHOD_OML 0x8060
#define GLX_SWAP_EXCHANGE_OML 0x8061
#define GLX_SWAP_COPY_OML 0x8062
#define GLX_SWAP_UNDEFINED_OML 0x8063
#endif /* GLX_OML_swap_method */
/* ---------------------------- OML_sync_control -------------------------- */
#ifdef GLX_OML_sync_control
#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
#include <inttypes.h>
typedef Bool ( * glXGetSyncValuesOMLPROC) (Display *dpy, GLXDrawable drawable, int64_t *ust, int64_t *msc, int64_t *sbc);
typedef Bool ( * glXGetMscRateOMLPROC) (Display *dpy, GLXDrawable drawable, int32_t *numerator, int32_t *denominator);
typedef int64_t ( * glXSwapBuffersMscOMLPROC) (Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder);
typedef Bool ( * glXWaitForMscOMLPROC) (Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder, int64_t *ust, int64_t *msc, int64_t *sbc);
typedef Bool ( * glXWaitForSbcOMLPROC) (Display *dpy, GLXDrawable drawable, int64_t target_sbc, int64_t *ust, int64_t *msc, int64_t *sbc);
extern glXGetSyncValuesOMLPROC glXGetSyncValuesOML;
extern glXGetMscRateOMLPROC glXGetMscRateOML;
extern glXSwapBuffersMscOMLPROC glXSwapBuffersMscOML;
extern glXWaitForMscOMLPROC glXWaitForMscOML;
extern glXWaitForSbcOMLPROC glXWaitForSbcOML;
#endif /* __STDC_VERSION__ */
#endif /* GLX_OML_sync_control */
/* ------------------------- NV_vertex_array_range ------------------------ */
#ifdef GLX_NV_vertex_array_range
typedef void * ( * glXAllocateMemoryNVPROC) (GLsizei size, GLfloat readFrequency, GLfloat writeFrequency, GLfloat priority);
typedef void ( * glXFreeMemoryNVPROC) (void *pointer);
extern glXAllocateMemoryNVPROC glXAllocateMemoryNV;
extern glXFreeMemoryNVPROC glXFreeMemoryNV;
#endif /* GLX_NV_vertex_array_range */
/* ------------------------------- SGI_cushion ---------------------------- */
#ifdef GLX_SGI_cushion
typedef void ( * glXCushionSGIPROC) (Display *dpy, Window window, float cushion);
extern glXCushionSGIPROC glXCushionSGI;
#endif /* GLX_SGI_cushion */
/* -------------------------- SGI_make_current_read ----------------------- */
#ifdef GLX_SGI_make_current_read
typedef Bool ( * glXMakeCurrentReadSGIPROC) (Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
typedef GLXDrawable ( * glXGetCurrentReadDrawableSGIPROC) (void);
extern glXMakeCurrentReadSGIPROC glXMakeCurrentReadSGI;
extern glXGetCurrentReadDrawableSGIPROC glXGetCurrentReadDrawableSGI;
#endif /* GLX_SGI_make_current_read */
/* ---------------------------- SGI_swap_control -------------------------- */
#ifdef GLX_SGI_swap_control
typedef int ( * glXSwapIntervalSGIPROC) (int interval);
extern glXSwapIntervalSGIPROC glXSwapIntervalSGI;
#endif /* GLX_SGI_swap_control */
/* ----------------------------- SGI_video_sync --------------------------- */
#ifdef GLX_SGI_video_sync
typedef int ( * glXGetVideoSyncSGIPROC) (unsigned int *count);
typedef int ( * glXWaitVideoSyncSGIPROC) (int divisor, int remainder, unsigned int *count);
typedef int ( * glXGetRefreshRateSGIPROC) (unsigned int *rate);
extern glXGetVideoSyncSGIPROC glXGetVideoSyncSGI;
extern glXWaitVideoSyncSGIPROC glXWaitVideoSyncSGI;
extern glXGetRefreshRateSGIPROC glXGetRefreshRateSGI;
#endif /* GLX_SGI_video_sync */
/* -------------------------- SGIS_blended_overlay ------------------------ */
#ifdef GLX_SGIS_blended_overlay
#define GLX_BLENDED_RGBA_SGIS 0x8025
#endif
/* ---------------------------- SGIS_multisample -------------------------- */
#ifdef GLX_SGIS_multisample
#define GLX_SAMPLE_BUFFERS_SGIS 100000
#define GLX_SAMPLES_SGIS 100001
#endif
/* ------------------------ SGIS_shared_multisample ----------------------- */
#ifdef GLX_SGIS_shared_multisample
#define GLX_MULTISAMPLE_SUB_RECT_WIDTH_SGIS 0x8026
#define GLX_MULTISAMPLE_SUB_RECT_HEIGHT_SGIS 0x8027
#endif
/* ------------------------------ SGIX_fbconfig --------------------------- */
#ifdef GLX_SGIX_fbconfig
#define GLX_WINDOW_BIT_SGIX 0x00000001
#define GLX_PIXMAP_BIT_SGIX 0x00000002
#define GLX_RGBA_BIT_SGIX 0x00000001
#define GLX_COLOR_INDEX_BIT_SGIX 0x00000002
#define GLX_DRAWABLE_TYPE_SGIX 0x8010
#define GLX_RENDER_TYPE_SGIX 0x8011
#define GLX_X_RENDERABLE_SGIX 0x8012
#define GLX_FBCONFIG_ID_SGIX 0x8013
#define GLX_RGBA_TYPE_SGIX 0x8014
#define GLX_COLOR_INDEX_TYPE_SGIX 0x8015
typedef XID GLXFBConfigIDSGIX;
typedef struct __GLXFBConfigRec *GLXFBConfigSGIX;
typedef int ( * glXGetFBConfigAttribSGIXPROC) (Display *dpy, GLXFBConfigSGIX config, int attribute, int *value);
typedef GLXFBConfigSGIX * ( * glXChooseFBConfigSGIXPROC) (Display *dpy, int screen, int *attrib_list, int *nelements);
typedef GLXPixmap ( * glXCreateGLXPixmapWithConfigSGIXPROC) (Display *dpy, GLXFBConfigSGIX config, Pixmap pixmap);
typedef GLXContext ( * glXCreateContextWithConfigSGIXPROC) (Display *dpy, GLXFBConfigSGIX config, int render_type, GLXContext share_list, Bool direct);
typedef XVisualInfo * ( * glXGetVisualFromFBConfigSGIXPROC) (Display *dpy, GLXFBConfigSGIX config);
typedef GLXFBConfigSGIX ( * glXGetFBConfigFromVisualSGIXPROC) (Display *dpy, XVisualInfo *vis);
extern glXGetFBConfigAttribSGIXPROC glXGetFBConfigAttribSGIX;
extern glXChooseFBConfigSGIXPROC glXChooseFBConfigSGIX;
extern glXCreateGLXPixmapWithConfigSGIXPROC glXCreateGLXPixmapWithConfigSGIX;
extern glXCreateContextWithConfigSGIXPROC glXCreateContextWithConfigSGIX;
extern glXGetVisualFromFBConfigSGIXPROC glXGetVisualFromFBConfigSGIX;
extern glXGetFBConfigFromVisualSGIXPROC glXGetFBConfigFromVisualSGIX;
#endif /* GLX_SGIX_fbconfig */
/* ------------------------------- SGIX_pbuffer --------------------------- */
#ifdef GLX_SGIX_pbuffer
#define GLX_PBUFFER_BIT_SGIX 0x00000004
#define GLX_BUFFER_CLOBBER_MASK_SGIX 0x08000000
#define GLX_FRONT_LEFT_BUFFER_BIT_SGIX 0x00000001
#define GLX_FRONT_RIGHT_BUFFER_BIT_SGIX 0x00000002
#define GLX_BACK_LEFT_BUFFER_BIT_SGIX 0x00000004
#define GLX_BACK_RIGHT_BUFFER_BIT_SGIX 0x00000008
#define GLX_AUX_BUFFERS_BIT_SGIX 0x00000010
#define GLX_DEPTH_BUFFER_BIT_SGIX 0x00000020
#define GLX_STENCIL_BUFFER_BIT_SGIX 0x00000040
#define GLX_ACCUM_BUFFER_BIT_SGIX 0x00000080
#define GLX_SAMPLE_BUFFERS_BIT_SGIX 0x00000100
#define GLX_MAX_PBUFFER_WIDTH_SGIX 0x8016
#define GLX_MAX_PBUFFER_HEIGHT_SGIX 0x8017
#define GLX_MAX_PBUFFER_PIXELS_SGIX 0x8018
#define GLX_OPTIMAL_PBUFFER_WIDTH_SGIX 0x8019
#define GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX 0x801A
#define GLX_PRESERVED_CONTENTS_SGIX 0x801B
#define GLX_LARGEST_PBUFFER_SGIX 0x801C
#define GLX_WIDTH_SGIX 0x801D
#define GLX_HEIGHT_SGIX 0x801E
#define GLX_EVENT_MASK_SGIX 0x801F
#define GLX_DAMAGED_SGIX 0x8020
#define GLX_SAVED_SGIX 0x8021
#define GLX_WINDOW_SGIX 0x8022
#define GLX_PBUFFER_SGIX 0x8023
typedef XID GLXPbufferSGIX;
typedef struct {
int type;
unsigned long serial;
Bool send_event;
Display *display;
GLXDrawable drawable;
int event_type;
int draw_type;
unsigned int mask;
int x, y;
int width, height;
int count;
} GLXBufferClobberEventSGIX;
typedef GLXPbufferSGIX ( * glXCreateGLXPbufferSGIXPROC) (Display *dpy, GLXFBConfigSGIX config, unsigned int width, unsigned int height, int *attrib_list);
typedef void ( * glXDestroyGLXPbufferSGIXPROC) (Display *dpy, GLXPbufferSGIX pbuf);
typedef int ( * glXQueryGLXPbufferSGIXPROC) (Display *dpy, GLXPbufferSGIX pbuf, int attribute, unsigned int *value);
typedef void ( * glXSelectEventSGIXPROC) (Display *dpy, GLXDrawable drawable, unsigned long mask);
typedef void ( * glXGetSelectedEventSGIXPROC) (Display *dpy, GLXDrawable drawable, unsigned long *mask);
extern glXCreateGLXPbufferSGIXPROC glXCreateGLXPbufferSGIX;
extern glXDestroyGLXPbufferSGIXPROC glXDestroyGLXPbufferSGIX;
extern glXQueryGLXPbufferSGIXPROC glXQueryGLXPbufferSGIX;
extern glXSelectEventSGIXPROC glXSelectEventSGIX;
extern glXGetSelectedEventSGIXPROC glXGetSelectedEventSGIX;
#endif /* GLX_SGIX_pbuffer */
/* ---------------------------- SGIX_swap_barrier ------------------------- */
#ifdef GLX_SGIX_swap_barrier
typedef void ( * glXBindSwapBarrierSGIXPROC) (Display *dpy, GLXDrawable drawable, int barrier);
typedef Bool ( * glXQueryMaxSwapBarriersSGIXPROC) (Display *dpy, int screen, int *max);
extern glXBindSwapBarrierSGIXPROC glXBindSwapBarrierSGIX;
extern glXQueryMaxSwapBarriersSGIXPROC glXQueryMaxSwapBarriersSGIX;
#endif /* GLX_SGIX_swap_barrier */
/* ----------------------------- SGIX_swap_group -------------------------- */
#ifdef GLX_SGIX_swap_group
typedef void ( * glXJoinSwapGroupSGIXPROC) (Display *dpy, GLXDrawable drawable, GLXDrawable member);
extern glXJoinSwapGroupSGIXPROC glXJoinSwapGroupSGIX;
#endif /* GLX_SGIX_swap_group */
/* ------------------------- SGIX_visual_select_group --------------------- */
#ifndef GLX_SGIX_visual_select_group
#define GLX_VISUAL_SELECT_GROUP_SGIX 0x8028
#endif
/* ------------------------ SUN_get_transparent_index --------------------- */
#ifdef GLX_SUN_get_transparent_index
typedef Status ( * glXGetTransparentIndexSUNPROC) (Display *dpy, Window overlay, Window underlay, long *pTransparentIndex);
extern glXGetTransparentIndexSUNPROC glXGetTransparentIndexSUN;
#endif /* GLX_SUN_get_transparent_index */
/* ------------------------------------------------------------------------ */
struct GLXEW
{
unsigned int GLX_10 : 1;
unsigned int GLX_11 : 1;
unsigned int GLX_12 : 1;
unsigned int GLX_13 : 1;
unsigned int GLX_14 : 1;
unsigned int ARB_get_proc_address : 1;
unsigned int ARB_multisample : 1;
unsigned int EXT_import_context : 1;
unsigned int EXT_visual_info : 1;
unsigned int EXT_visual_rating : 1;
unsigned int MESA_copy_sub_buffer : 1;
unsigned int MESA_pixmap_colormap : 1;
unsigned int MESA_release_buffers : 1;
unsigned int MESA_set_3dfx_mode : 1;
unsigned int NV_vertex_array_range : 1;
unsigned int OML_swap_method : 1;
unsigned int OML_sync_control : 1;
unsigned int SGI_cushion : 1;
unsigned int SGI_make_current_read : 1;
unsigned int SGI_swap_control : 1;
unsigned int SGI_video_sync : 1;
unsigned int SGIS_blended_overlay : 1;
unsigned int SGIS_multisample : 1;
unsigned int SGIS_shared_multisample : 1;
/* unsigned int SGIX_dm_buffer : 1; */
unsigned int SGIX_fbconfig : 1;
unsigned int SGIX_pbuffer : 1;
unsigned int SGIX_swap_group : 1;
unsigned int SGIX_swap_barrier : 1;
/* unsigned int SGIX_video_source : 1; */
/* unsigned int SGIX_video_resize : 1; */
unsigned int SGIX_visual_select_group : 1;
unsigned int SUN_get_transparent_index : 1;
};
extern struct GLXEW glxew;
#ifdef __cplusplus
}
#endif
#endif /* _WIN32 */
#endif /* __glxew_h__ */

757
include/GL/wglew.h Normal file
View File

@ -0,0 +1,757 @@
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: This software was created using the
** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
** not been independently verified as being compliant with the OpenGL(R)
** version 1.2.1 Specification.
*/
/*
** Copyright (C) 2002, Lev Povalahev
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without modification,
** are permitted provided that the following conditions are met:
**
** * Redistributions of source code must retain the above copyright notice,
** this list of conditions and the following disclaimer.
** * Redistributions in binary form must reproduce the above copyright notice,
** this list of conditions and the following disclaimer in the documentation
** and/or other materials provided with the distribution.
** * The name of the authors may be used to endorse or promote products
** derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
** IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
** INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
** BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
** OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
** WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
** THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
** The OpenGL Extension Wrangler Library
** Copyright (C) 2002 Milan Ikits
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __wglew_h__
#define __wglew_h__
#ifdef __wglext_h_
#error wglext.h included before wglew.h
#endif
#define __wglext_h_
#ifdef _WIN32
#if !defined(APIENTRY) && !defined(__CYGWIN__)
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#endif
/*
* GLEW_STATIC needs to be set when including the
* source directly in the project.
* GLEW_BUILD is set when building the dll version.
*/
#ifdef GLEW_STATIC
#define GLEW_EXPORT
#else
#ifdef GLEW_BUILD
#define GLEW_EXPORT __declspec(dllexport)
#else
#define GLEW_EXPORT __declspec(dllimport)
#endif
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* ARB extensions */
#define WGL_ARB_buffer_region 1
#define WGL_ARB_extensions_string 1
#define WGL_ARB_make_current_read 1
#define WGL_ARB_multisample 1
#define WGL_ARB_pbuffer 1
#define WGL_ARB_pixel_format 1
#define WGL_ARB_render_texture 1
/* multi-vendor extensions */
#define WGL_EXT_depth_float 1
#define WGL_EXT_display_color_table 1
#define WGL_EXT_extensions_string 1
#define WGL_EXT_make_current_read 1
#define WGL_EXT_multisample 1
#define WGL_EXT_swap_control 1
#define WGL_EXT_pixel_format 1
#define WGL_EXT_pbuffer 1
/* vendor-specific extensions */
#define WGL_I3D_digital_video_control 1
#define WGL_I3D_gamma 1
#define WGL_I3D_genlock 1
#define WGL_I3D_image_buffer 1
#define WGL_I3D_swap_frame_lock 1
#define WGL_I3D_swap_frame_usage 1
#define WGL_OML_sync_control 1
/* ATI extensions */
#define WGL_ATI_pixel_format_float 1
/* NVIDIA extensions */
#define WGL_NV_float_buffer 1
#define WGL_NV_render_depth_texture 1
#define WGL_NV_render_texture_rectangle 1
#define WGL_NV_vertex_array_range 1
/* ---------------------------- ARB_buffer_region ------------------------- */
#ifdef WGL_ARB_buffer_region
#define WGL_FRONT_COLOR_BUFFER_BIT_ARB 0x00000001
#define WGL_BACK_COLOR_BUFFER_BIT_ARB 0x00000002
#define WGL_DEPTH_BUFFER_BIT_ARB 0x00000004
#define WGL_STENCIL_BUFFER_BIT_ARB 0x00000008
typedef HANDLE (APIENTRY * wglCreateBufferRegionARBPROC) (HDC hDC, int iLayerPlane, UINT uType);
typedef VOID (APIENTRY * wglDeleteBufferRegionARBPROC) (HANDLE hRegion);
typedef BOOL (APIENTRY * wglSaveBufferRegionARBPROC) (HANDLE hRegion, int x, int y, int width, int height);
typedef BOOL (APIENTRY * wglRestoreBufferRegionARBPROC) (HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc);
extern GLEW_EXPORT wglCreateBufferRegionARBPROC wglCreateBufferRegionARB;
extern GLEW_EXPORT wglDeleteBufferRegionARBPROC wglDeleteBufferRegionARB;
extern GLEW_EXPORT wglSaveBufferRegionARBPROC wglSaveBufferRegionARB;
extern GLEW_EXPORT wglRestoreBufferRegionARBPROC wglRestoreBufferRegionARB;
#endif /* WGL_ARB_buffer_region */
/* -------------------------- ARB_extensions_string ----------------------- */
#ifdef WGL_ARB_extensions_string
typedef const char* (APIENTRY * wglGetExtensionsStringARBPROC) (HDC hdc);
extern GLEW_EXPORT wglGetExtensionsStringARBPROC wglGetExtensionsStringARB;
#endif /* WGL_ARB_extensions_string */
/* -------------------------- ARB_make_current_read ----------------------- */
#ifdef WGL_ARB_make_current_read
#define ERROR_INVALID_PIXEL_TYPE_ARB 0x2043
#define ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB 0x2054
typedef BOOL (APIENTRY * wglMakeContextCurrentARBPROC) (HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
typedef HDC (APIENTRY * wglGetCurrentReadDCARBPROC) (void);
extern GLEW_EXPORT wglMakeContextCurrentARBPROC wglMakeContextCurrentARB;
extern GLEW_EXPORT wglGetCurrentReadDCARBPROC wglGetCurrentReadDCARB;
#endif /* WGL_ARB_make_current_read */
/* ----------------------------- ARB_multisample -------------------------- */
#ifdef WGL_ARB_multisample
#define WGL_SAMPLE_BUFFERS_ARB 0x2041
#define WGL_SAMPLES_ARB 0x2042
#endif /* WGL_ARB_multisample */
/* ------------------------------- ARB_pbuffer ---------------------------- */
#ifdef WGL_ARB_pbuffer
#define WGL_DRAW_TO_PBUFFER_ARB 0x202D
#define WGL_MAX_PBUFFER_PIXELS_ARB 0x202E
#define WGL_MAX_PBUFFER_WIDTH_ARB 0x202F
#define WGL_MAX_PBUFFER_HEIGHT_ARB 0x2030
#define WGL_PBUFFER_LARGEST_ARB 0x2033
#define WGL_PBUFFER_WIDTH_ARB 0x2034
#define WGL_PBUFFER_HEIGHT_ARB 0x2035
#define WGL_PBUFFER_LOST_ARB 0x2036
DECLARE_HANDLE(HPBUFFERARB);
typedef HPBUFFERARB (APIENTRY * wglCreatePbufferARBPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
typedef HDC (APIENTRY * wglGetPbufferDCARBPROC) (HPBUFFERARB hPbuffer);
typedef int (APIENTRY * wglReleasePbufferDCARBPROC) (HPBUFFERARB hPbuffer, HDC hDC);
typedef BOOL (APIENTRY * wglDestroyPbufferARBPROC) (HPBUFFERARB hPbuffer);
typedef BOOL (APIENTRY * wglQueryPbufferARBPROC) (HPBUFFERARB hPbuffer, int iAttribute, int *piValue);
extern GLEW_EXPORT wglCreatePbufferARBPROC wglCreatePbufferARB;
extern GLEW_EXPORT wglGetPbufferDCARBPROC wglGetPbufferDCARB;
extern GLEW_EXPORT wglReleasePbufferDCARBPROC wglReleasePbufferDCARB;
extern GLEW_EXPORT wglDestroyPbufferARBPROC wglDestroyPbufferARB;
extern GLEW_EXPORT wglQueryPbufferARBPROC wglQueryPbufferARB;
#endif /* WGL_ARB_pbuffer */
/* ---------------------------- ARB_pixel_format -------------------------- */
#ifdef WGL_ARB_pixel_format
#define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000
#define WGL_DRAW_TO_WINDOW_ARB 0x2001
#define WGL_DRAW_TO_BITMAP_ARB 0x2002
#define WGL_ACCELERATION_ARB 0x2003
#define WGL_NEED_PALETTE_ARB 0x2004
#define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005
#define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006
#define WGL_SWAP_METHOD_ARB 0x2007
#define WGL_NUMBER_OVERLAYS_ARB 0x2008
#define WGL_NUMBER_UNDERLAYS_ARB 0x2009
#define WGL_TRANSPARENT_ARB 0x200A
#define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037
#define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038
#define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039
#define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A
#define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B
#define WGL_SHARE_DEPTH_ARB 0x200C
#define WGL_SHARE_STENCIL_ARB 0x200D
#define WGL_SHARE_ACCUM_ARB 0x200E
#define WGL_SUPPORT_GDI_ARB 0x200F
#define WGL_SUPPORT_OPENGL_ARB 0x2010
#define WGL_DOUBLE_BUFFER_ARB 0x2011
#define WGL_STEREO_ARB 0x2012
#define WGL_PIXEL_TYPE_ARB 0x2013
#define WGL_COLOR_BITS_ARB 0x2014
#define WGL_RED_BITS_ARB 0x2015
#define WGL_RED_SHIFT_ARB 0x2016
#define WGL_GREEN_BITS_ARB 0x2017
#define WGL_GREEN_SHIFT_ARB 0x2018
#define WGL_BLUE_BITS_ARB 0x2019
#define WGL_BLUE_SHIFT_ARB 0x201A
#define WGL_ALPHA_BITS_ARB 0x201B
#define WGL_ALPHA_SHIFT_ARB 0x201C
#define WGL_ACCUM_BITS_ARB 0x201D
#define WGL_ACCUM_RED_BITS_ARB 0x201E
#define WGL_ACCUM_GREEN_BITS_ARB 0x201F
#define WGL_ACCUM_BLUE_BITS_ARB 0x2020
#define WGL_ACCUM_ALPHA_BITS_ARB 0x2021
#define WGL_DEPTH_BITS_ARB 0x2022
#define WGL_STENCIL_BITS_ARB 0x2023
#define WGL_AUX_BUFFERS_ARB 0x2024
#define WGL_NO_ACCELERATION_ARB 0x2025
#define WGL_GENERIC_ACCELERATION_ARB 0x2026
#define WGL_FULL_ACCELERATION_ARB 0x2027
#define WGL_SWAP_EXCHANGE_ARB 0x2028
#define WGL_SWAP_COPY_ARB 0x2029
#define WGL_SWAP_UNDEFINED_ARB 0x202A
#define WGL_TYPE_RGBA_ARB 0x202B
#define WGL_TYPE_COLORINDEX_ARB 0x202C
typedef BOOL (APIENTRY * wglGetPixelFormatAttribivARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues);
typedef BOOL (APIENTRY * wglGetPixelFormatAttribfvARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues);
typedef BOOL (APIENTRY * wglChoosePixelFormatARBPROC) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
extern GLEW_EXPORT wglGetPixelFormatAttribivARBPROC wglGetPixelFormatAttribivARB;
extern GLEW_EXPORT wglGetPixelFormatAttribfvARBPROC wglGetPixelFormatAttribfvARB;
extern GLEW_EXPORT wglChoosePixelFormatARBPROC wglChoosePixelFormatARB;
#endif /* WGL_ARB_pixel_format */
/* --------------------------- ARB_render_texture ------------------------- */
#ifdef WGL_ARB_render_texture
#define WGL_BIND_TO_TEXTURE_RGB_ARB 0x2070
#define WGL_BIND_TO_TEXTURE_RGBA_ARB 0x2071
#define WGL_TEXTURE_FORMAT_ARB 0x2072
#define WGL_TEXTURE_TARGET_ARB 0x2073
#define WGL_MIPMAP_TEXTURE_ARB 0x2074
#define WGL_TEXTURE_RGB_ARB 0x2075
#define WGL_TEXTURE_RGBA_ARB 0x2076
#define WGL_NO_TEXTURE_ARB 0x2077
#define WGL_TEXTURE_CUBE_MAP_ARB 0x2078
#define WGL_TEXTURE_1D_ARB 0x2079
#define WGL_TEXTURE_2D_ARB 0x207A
#define WGL_NO_TEXTURE_ARB 0x2077
#define WGL_MIPMAP_LEVEL_ARB 0x207B
#define WGL_CUBE_MAP_FACE_ARB 0x207C
#define WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x207D
#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x207E
#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x207F
#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x2080
#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x2081
#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x2082
#define WGL_FRONT_LEFT_ARB 0x2083
#define WGL_FRONT_RIGHT_ARB 0x2084
#define WGL_BACK_LEFT_ARB 0x2085
#define WGL_BACK_RIGHT_ARB 0x2086
#define WGL_AUX0_ARB 0x2087
#define WGL_AUX1_ARB 0x2088
#define WGL_AUX2_ARB 0x2089
#define WGL_AUX3_ARB 0x208A
#define WGL_AUX4_ARB 0x208B
#define WGL_AUX5_ARB 0x208C
#define WGL_AUX6_ARB 0x208D
#define WGL_AUX7_ARB 0x208E
#define WGL_AUX8_ARB 0x208F
#define WGL_AUX9_ARB 0x2090
typedef BOOL (APIENTRY * wglBindTexImageARBPROC) (HPBUFFERARB hPbuffer, int iBuffer);
typedef BOOL (APIENTRY * wglReleaseTexImageARBPROC) (HPBUFFERARB hPbuffer, int iBuffer);
typedef BOOL (APIENTRY * wglSetPbufferAttribARBPROC) (HPBUFFERARB hPbuffer, const int *piAttribList);
extern GLEW_EXPORT wglBindTexImageARBPROC wglBindTexImageARB;
extern GLEW_EXPORT wglReleaseTexImageARBPROC wglReleaseTexImageARB;
extern GLEW_EXPORT wglSetPbufferAttribARBPROC wglSetPbufferAttribARB;
#endif /* WGL_ARB_render_texture */
/* ----------------------------- EXT_depth_float -------------------------- */
#ifdef WGL_EXT_depth_float
#define WGL_DEPTH_FLOAT_EXT 0x2040
#endif /* WGL_EXT_depth_float */
/* ------------------------- EXT_display_color_table ---------------------- */
#ifdef WGL_EXT_display_color_table
typedef GLboolean (APIENTRY * wglCreateDisplayColorTableEXTPROC) (GLushort id);
typedef GLboolean (APIENTRY * wglLoadDisplayColorTableEXTPROC) (const GLushort *table, GLuint length);
typedef GLboolean (APIENTRY * wglBindDisplayColorTableEXTPROC) (GLushort id);
typedef void (APIENTRY * wglDestroyDisplayColorTableEXTPROC) (GLushort id);
extern GLEW_EXPORT wglCreateDisplayColorTableEXTPROC wglCreateDisplayColorTableEXT;
extern GLEW_EXPORT wglLoadDisplayColorTableEXTPROC wglLoadDisplayColorTableEXT;
extern GLEW_EXPORT wglBindDisplayColorTableEXTPROC wglBindDisplayColorTableEXT;
extern GLEW_EXPORT wglDestroyDisplayColorTableEXTPROC wglDestroyDisplayColorTableEXT;
#endif /* WGL_EXT_display_color_table */
/* -------------------------- EXT_extensions_string ----------------------- */
#ifdef WGL_EXT_extensions_string
typedef const char* (APIENTRY * wglGetExtensionsStringEXTPROC) ();
extern GLEW_EXPORT wglGetExtensionsStringEXTPROC wglGetExtensionsStringEXT;
#endif /* WGL_EXT_extensions_string */
/* -------------------------- EXT_make_current_read ----------------------- */
#ifdef WGL_EXT_make_current_read
#define ERROR_INVALID_PIXEL_TYPE_EXT 0x2043
typedef BOOL (APIENTRY * wglMakeContextCurrentEXTPROC) (HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
typedef HDC (APIENTRY * wglGetCurrentReadDCEXTPROC) (void);
extern GLEW_EXPORT wglMakeContextCurrentEXTPROC wglMakeContextCurrentEXT;
extern GLEW_EXPORT wglGetCurrentReadDCEXTPROC wglGetCurrentReadDCEXT;
#endif /* WGL_EXT_make_current_read */
/* ----------------------------- EXT_multisample -------------------------- */
#ifdef WGL_EXT_multisample
#define WGL_SAMPLE_BUFFERS_EXT 0x2041
#define WGL_SAMPLES_EXT 0x2042
#endif /* WGL_EXT_multisample */
/* ----------------------------- EXT_pixel_format ------------------------- */
#ifdef WGL_EXT_pixel_format
#define WGL_NUMBER_PIXEL_FORMATS_EXT 0x2000
#define WGL_DRAW_TO_WINDOW_EXT 0x2001
#define WGL_DRAW_TO_BITMAP_EXT 0x2002
#define WGL_ACCELERATION_EXT 0x2003
#define WGL_NEED_PALETTE_EXT 0x2004
#define WGL_NEED_SYSTEM_PALETTE_EXT 0x2005
#define WGL_SWAP_LAYER_BUFFERS_EXT 0x2006
#define WGL_SWAP_METHOD_EXT 0x2007
#define WGL_NUMBER_OVERLAYS_EXT 0x2008
#define WGL_NUMBER_UNDERLAYS_EXT 0x2009
#define WGL_TRANSPARENT_EXT 0x200A
#define WGL_TRANSPARENT_VALUE_EXT 0x200B
#define WGL_SHARE_DEPTH_EXT 0x200C
#define WGL_SHARE_STENCIL_EXT 0x200D
#define WGL_SHARE_ACCUM_EXT 0x200E
#define WGL_SUPPORT_GDI_EXT 0x200F
#define WGL_SUPPORT_OPENGL_EXT 0x2010
#define WGL_DOUBLE_BUFFER_EXT 0x2011
#define WGL_STEREO_EXT 0x2012
#define WGL_PIXEL_TYPE_EXT 0x2013
#define WGL_COLOR_BITS_EXT 0x2014
#define WGL_RED_BITS_EXT 0x2015
#define WGL_RED_SHIFT_EXT 0x2016
#define WGL_GREEN_BITS_EXT 0x2017
#define WGL_GREEN_SHIFT_EXT 0x2018
#define WGL_BLUE_BITS_EXT 0x2019
#define WGL_BLUE_SHIFT_EXT 0x201A
#define WGL_ALPHA_BITS_EXT 0x201B
#define WGL_ALPHA_SHIFT_EXT 0x201C
#define WGL_ACCUM_BITS_EXT 0x201D
#define WGL_ACCUM_RED_BITS_EXT 0x201E
#define WGL_ACCUM_GREEN_BITS_EXT 0x201F
#define WGL_ACCUM_BLUE_BITS_EXT 0x2020
#define WGL_ACCUM_ALPHA_BITS_EXT 0x2021
#define WGL_DEPTH_BITS_EXT 0x2022
#define WGL_STENCIL_BITS_EXT 0x2023
#define WGL_AUX_BUFFERS_EXT 0x2024
#define WGL_NO_ACCELERATION_EXT 0x2025
#define WGL_GENERIC_ACCELERATION_EXT 0x2026
#define WGL_FULL_ACCELERATION_EXT 0x2027
#define WGL_SWAP_EXCHANGE_EXT 0x2028
#define WGL_SWAP_COPY_EXT 0x2029
#define WGL_SWAP_UNDEFINED_EXT 0x202A
#define WGL_TYPE_RGBA_EXT 0x202B
#define WGL_TYPE_COLORINDEX_EXT 0x202C
typedef BOOL (APIENTRY * wglGetPixelFormatAttribivEXTPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, int *piValues);
typedef BOOL (APIENTRY * wglGetPixelFormatAttribfvEXTPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, FLOAT *pfValues);
typedef BOOL (APIENTRY * wglChoosePixelFormatEXTPROC) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
extern GLEW_EXPORT wglGetPixelFormatAttribivEXTPROC wglGetPixelFormatAttribivEXT;
extern GLEW_EXPORT wglGetPixelFormatAttribfvEXTPROC wglGetPixelFormatAttribfvEXT;
extern GLEW_EXPORT wglChoosePixelFormatEXTPROC wglChoosePixelFormatEXT;
#endif /* WGL_EXT_pixel_format */
/* ------------------------------- EXT_pbuffer ---------------------------- */
#ifdef WGL_EXT_pbuffer
#define WGL_DRAW_TO_PBUFFER_EXT 0x202D
#define WGL_MAX_PBUFFER_PIXELS_EXT 0x202E
#define WGL_MAX_PBUFFER_WIDTH_EXT 0x202F
#define WGL_MAX_PBUFFER_HEIGHT_EXT 0x2030
#define WGL_OPTIMAL_PBUFFER_WIDTH_EXT 0x2031
#define WGL_OPTIMAL_PBUFFER_HEIGHT_EXT 0x2032
#define WGL_PBUFFER_LARGEST_EXT 0x2033
#define WGL_PBUFFER_WIDTH_EXT 0x2034
#define WGL_PBUFFER_HEIGHT_EXT 0x2035
DECLARE_HANDLE(HPBUFFEREXT);
typedef HPBUFFEREXT (APIENTRY * wglCreatePbufferEXTPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
typedef HDC (APIENTRY * wglGetPbufferDCEXTPROC) (HPBUFFEREXT hPbuffer);
typedef int (APIENTRY * wglReleasePbufferDCEXTPROC) (HPBUFFEREXT hPbuffer, HDC hDC);
typedef BOOL (APIENTRY * wglDestroyPbufferEXTPROC) (HPBUFFEREXT hPbuffer);
typedef BOOL (APIENTRY * wglQueryPbufferEXTPROC) (HPBUFFEREXT hPbuffer, int iAttribute, int *piValue);
extern GLEW_EXPORT wglCreatePbufferEXTPROC wglCreatePbufferEXT;
extern GLEW_EXPORT wglGetPbufferDCEXTPROC wglGetPbufferDCEXT;
extern GLEW_EXPORT wglReleasePbufferDCEXTPROC wglReleasePbufferDCEXT;
extern GLEW_EXPORT wglDestroyPbufferEXTPROC wglDestroyPbufferEXT;
extern GLEW_EXPORT wglQueryPbufferEXTPROC wglQueryPbufferEXT;
#endif /* WGL_EXT_pbuffer */
/* ---------------------------- EXT_swap_control -------------------------- */
#ifdef WGL_EXT_swap_control
typedef BOOL (APIENTRY * wglSwapIntervalEXTPROC) (int interval);
typedef int (APIENTRY * wglGetSwapIntervalEXTPROC) (void);
extern GLEW_EXPORT wglSwapIntervalEXTPROC wglSwapIntervalEXT;
extern GLEW_EXPORT wglGetSwapIntervalEXTPROC wglGetSwapIntervalEXT;
#endif /* WGL_EXT_swap_control */
/* ------------------------ I3D_digital_video_control --------------------- */
#ifdef WGL_I3D_digital_video_control
#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D 0x2050
#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D 0x2051
#define WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D 0x2052
#define WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D 0x2053
typedef BOOL (APIENTRY * wglGetDigitalVideoParametersI3DPROC) (HDC hDC, int iAttribute, int *piValue);
typedef BOOL (APIENTRY * wglSetDigitalVideoParametersI3DPROC) (HDC hDC, int iAttribute, const int *piValue);
extern GLEW_EXPORT wglGetDigitalVideoParametersI3DPROC wglGetDigitalVideoParametersI3D;
extern GLEW_EXPORT wglSetDigitalVideoParametersI3DPROC wglSetDigitalVideoParametersI3D;
#endif /* WGL_I3D_digital_video_control */
/* -------------------------------- I3D_gamma ----------------------------- */
#ifdef WGL_I3D_gamma
#define WGL_GAMMA_TABLE_SIZE_I3D 0x204E
#define WGL_GAMMA_EXCLUDE_DESKTOP_I3D 0x204F
typedef BOOL (APIENTRY * wglGetGammaTableParametersI3DPROC) (HDC hDC, int iAttribute, int *piValue);
typedef BOOL (APIENTRY * wglSetGammaTableParametersI3DPROC) (HDC hDC, int iAttribute, const int *piValue);
typedef BOOL (APIENTRY * wglGetGammaTableI3DPROC) (HDC hDC, int iEntries, USHORT *puRed, USHORT *puGreen, USHORT *puBlue);
typedef BOOL (APIENTRY * wglSetGammaTableI3DPROC) (HDC hDC, int iEntries, const USHORT *puRed, const USHORT *puGreen, const USHORT *puBlue);
extern GLEW_EXPORT wglGetGammaTableParametersI3DPROC wglGetGammaTableParametersI3D;
extern GLEW_EXPORT wglSetGammaTableParametersI3DPROC wglSetGammaTableParametersI3D;
extern GLEW_EXPORT wglGetGammaTableI3DPROC wglGetGammaTableI3D;
extern GLEW_EXPORT wglSetGammaTableI3DPROC wglSetGammaTableI3D;
#endif /* WGL_I3D_gamma */
/* ------------------------------- I3D_genlock ---------------------------- */
#ifdef WGL_I3D_genlock
#define WGL_GENLOCK_SOURCE_MULTIVIEW_I3D 0x2044
#define WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D 0x2045
#define WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D 0x2046
#define WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D 0x2047
#define WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D 0x2048
#define WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D 0x2049
#define WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D 0x204A
#define WGL_GENLOCK_SOURCE_EDGE_RISING_I3D 0x204B
#define WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D 0x204C
typedef BOOL (APIENTRY * wglEnableGenlockI3DPROC) (HDC hDC);
typedef BOOL (APIENTRY * wglDisableGenlockI3DPROC) (HDC hDC);
typedef BOOL (APIENTRY * wglIsEnabledGenlockI3DPROC) (HDC hDC, BOOL *pFlag);
typedef BOOL (APIENTRY * wglGenlockSourceI3DPROC) (HDC hDC, UINT uSource);
typedef BOOL (APIENTRY * wglGetGenlockSourceI3DPROC) (HDC hDC, UINT *uSource);
typedef BOOL (APIENTRY * wglGenlockSourceEdgeI3DPROC) (HDC hDC, UINT uEdge);
typedef BOOL (APIENTRY * wglGetGenlockSourceEdgeI3DPROC) (HDC hDC, UINT *uEdge);
typedef BOOL (APIENTRY * wglGenlockSampleRateI3DPROC) (HDC hDC, UINT uRate);
typedef BOOL (APIENTRY * wglGetGenlockSampleRateI3DPROC) (HDC hDC, UINT *uRate);
typedef BOOL (APIENTRY * wglGenlockSourceDelayI3DPROC) (HDC hDC, UINT uDelay);
typedef BOOL (APIENTRY * wglGetGenlockSourceDelayI3DPROC) (HDC hDC, UINT *uDelay);
typedef BOOL (APIENTRY * wglQueryGenlockMaxSourceDelayI3DPROC) (HDC hDC, UINT *uMaxLineDelay, UINT *uMaxPixelDelay);
extern GLEW_EXPORT wglEnableGenlockI3DPROC wglEnableGenlockI3D;
extern GLEW_EXPORT wglDisableGenlockI3DPROC wglDisableGenlockI3D;
extern GLEW_EXPORT wglIsEnabledGenlockI3DPROC wglIsEnabledGenlockI3D;
extern GLEW_EXPORT wglGenlockSourceI3DPROC wglGenlockSourceI3D;
extern GLEW_EXPORT wglGetGenlockSourceI3DPROC wglGetGenlockSourceI3D;
extern GLEW_EXPORT wglGenlockSourceEdgeI3DPROC wglGenlockSourceEdgeI3D;
extern GLEW_EXPORT wglGetGenlockSourceEdgeI3DPROC wglGetGenlockSourceEdgeI3D;
extern GLEW_EXPORT wglGenlockSampleRateI3DPROC wglGenlockSampleRateI3D;
extern GLEW_EXPORT wglGetGenlockSampleRateI3DPROC wglGetGenlockSampleRateI3D;
extern GLEW_EXPORT wglGenlockSourceDelayI3DPROC wglGenlockSourceDelayI3D;
extern GLEW_EXPORT wglGetGenlockSourceDelayI3DPROC wglGetGenlockSourceDelayI3D;
extern GLEW_EXPORT wglQueryGenlockMaxSourceDelayI3DPROC wglQueryGenlockMaxSourceDelayI3D;
#endif /* WGL_I3D_genlock */
/* ---------------------------- I3D_image_buffer -------------------------- */
#ifdef WGL_I3D_image_buffer
#define WGL_IMAGE_BUFFER_MIN_ACCESS_I3D 0x00000001
#define WGL_IMAGE_BUFFER_LOCK_I3D 0x00000002
typedef LPVOID (APIENTRY * wglCreateImageBufferI3DPROC) (HDC hDC, DWORD dwSize, UINT uFlags);
typedef BOOL (APIENTRY * wglDestroyImageBufferI3DPROC) (HDC hDC, LPVOID pAddress);
typedef BOOL (APIENTRY * wglAssociateImageBufferEventsI3DPROC) (HDC hDC, const HANDLE *pEvent, const LPVOID *pAddress, const DWORD *pSize, UINT count);
typedef BOOL (APIENTRY * wglReleaseImageBufferEventsI3DPROC) (HDC hDC, const LPVOID *pAddress, UINT count);
extern GLEW_EXPORT wglCreateImageBufferI3DPROC wglCreateImageBufferI3D;
extern GLEW_EXPORT wglDestroyImageBufferI3DPROC wglDestroyImageBufferI3D;
extern GLEW_EXPORT wglAssociateImageBufferEventsI3DPROC wglAssociateImageBufferEventsI3D;
extern GLEW_EXPORT wglReleaseImageBufferEventsI3DPROC wglReleaseImageBufferEventsI3D;
#endif /* WGL_I3D_image_buffer */
/* --------------------------- I3D_swap_frame_lock ------------------------ */
#ifdef WGL_I3D_swap_frame_lock
typedef BOOL (APIENTRY * wglEnableFrameLockI3DPROC) (void);
typedef BOOL (APIENTRY * wglDisableFrameLockI3DPROC) (void);
typedef BOOL (APIENTRY * wglIsEnabledFrameLockI3DPROC) (BOOL *pFlag);
typedef BOOL (APIENTRY * wglQueryFrameLockMasterI3DPROC) (BOOL *pFlag);
extern GLEW_EXPORT wglEnableFrameLockI3DPROC wglEnableFrameLockI3D;
extern GLEW_EXPORT wglDisableFrameLockI3DPROC wglDisableFrameLockI3D;
extern GLEW_EXPORT wglIsEnabledFrameLockI3DPROC wglIsEnabledFrameLockI3D;
extern GLEW_EXPORT wglQueryFrameLockMasterI3DPROC wglQueryFrameLockMasterI3D;
#endif /* WGL_I3D_swap_frame_lock */
/* -------------------------- I3D_swap_frame_usage ------------------------ */
#ifdef WGL_I3D_swap_frame_usage
typedef BOOL (APIENTRY * wglGetFrameUsageI3DPROC) (float *pUsage);
typedef BOOL (APIENTRY * wglBeginFrameTrackingI3DPROC) (void);
typedef BOOL (APIENTRY * wglEndFrameTrackingI3DPROC) (void);
typedef BOOL (APIENTRY * wglQueryFrameTrackingI3DPROC) (DWORD *pFrameCount, DWORD *pMissedFrames, float *pLastMissedUsage);
extern GLEW_EXPORT wglGetFrameUsageI3DPROC wglGetFrameUsageI3D;
extern GLEW_EXPORT wglBeginFrameTrackingI3DPROC wglBeginFrameTrackingI3D;
extern GLEW_EXPORT wglEndFrameTrackingI3DPROC wglEndFrameTrackingI3D;
extern GLEW_EXPORT wglQueryFrameTrackingI3DPROC wglQueryFrameTrackingI3D;
#endif /* WGL_I3D_swap_frame_usage */
/* ---------------------------- OML_sync_control -------------------------- */
#ifdef WGL_OML_sync_control
typedef BOOL (APIENTRY * wglGetSyncValuesOMLPROC) (HDC hdc, INT64 *ust, INT64 *msc, INT64 *sbc);
typedef BOOL (APIENTRY * wglGetMscRateOMLPROC) (HDC hdc, INT32 *numerator, INT32 *denominator);
typedef INT64 (APIENTRY * wglSwapBuffersMscOMLPROC) (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder);
typedef INT64 (APIENTRY * wglSwapLayerBuffersMscOMLPROC) (HDC hdc, int fuPlanes, INT64 target_msc, INT64 divisor, INT64 remainder);
typedef BOOL (APIENTRY * wglWaitForMscOMLPROC) (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder, INT64 *ust, INT64 *msc, INT64 *sbc);
typedef BOOL (APIENTRY * wglWaitForSbcOMLPROC) (HDC hdc, INT64 target_sbc, INT64 *ust, INT64 *msc, INT64 *sbc);
extern GLEW_EXPORT wglGetSyncValuesOMLPROC wglGetSyncValuesOML;
extern GLEW_EXPORT wglGetMscRateOMLPROC wglGetMscRateOML;
extern GLEW_EXPORT wglSwapBuffersMscOMLPROC wglSwapBuffersMscOML;
extern GLEW_EXPORT wglSwapLayerBuffersMscOMLPROC wglSwapLayerBuffersMscOML;
extern GLEW_EXPORT wglWaitForMscOMLPROC wglWaitForMscOML;
extern GLEW_EXPORT wglWaitForSbcOMLPROC wglWaitForSbcOML;
#endif /* WGL_OML_sync_control */
/* ------------------------- ATI_pixel_format_float ----------------------- */
#ifdef WGL_ATI_pixel_format_float
#define WGL_TYPE_RGBA_FLOAT_ATI 0x21A0
#define GL_TYPE_RGBA_FLOAT_ATI 0x8820
#define GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI 0x8835
#endif /* WGL_ATI_pixel_format_float */
/* ---------------------------- NV_float_buffer --------------------------- */
#ifdef WGL_NV_float_buffer
#define WGL_FLOAT_COMPONENTS_NV 0x20B0
#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV 0x20B1
#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV 0x20B2
#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV 0x20B3
#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV 0x20B4
#define WGL_TEXTURE_FLOAT_R_NV 0x20B5
#define WGL_TEXTURE_FLOAT_RG_NV 0x20B6
#define WGL_TEXTURE_FLOAT_RGB_NV 0x20B7
#define WGL_TEXTURE_FLOAT_RGBA_NV 0x20B8
#endif /* WGL_NV_float_buffer */
/* ------------------------- NV_render_depth_texture ---------------------- */
#ifdef WGL_NV_render_depth_texture
#define WGL_BIND_TO_TEXTURE_DEPTH_NV 0x20A3
#define WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV 0x20A4
#define WGL_DEPTH_TEXTURE_FORMAT_NV 0x20A5
#define WGL_TEXTURE_DEPTH_COMPONENT_NV 0x20A6
#define WGL_NO_TEXTURE_ARB 0x2077
#define WGL_DEPTH_COMPONENT_NV 0x20A7
#endif /* WGL_NV_render_depth_texture */
/* ----------------------- NV_render_texture_rectangle -------------------- */
#ifdef WGL_NV_render_texture_rectangle
#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV 0x20A0
#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV 0x20A1
#define WGL_TEXTURE_RECTANGLE_NV 0x20A2
#endif /* WGL_NV_render_texture_rectangle */
/* ------------------------- NV_vertex_array_range ------------------------ */
#ifdef WGL_NV_vertex_array_range
typedef void * (APIENTRY * wglAllocateMemoryNVPROC) (GLsizei size, GLfloat readFrequency, GLfloat writeFrequency, GLfloat priority);
typedef void (APIENTRY * wglFreeMemoryNVPROC) (void *pointer);
extern GLEW_EXPORT wglAllocateMemoryNVPROC wglAllocateMemoryNV;
extern GLEW_EXPORT wglFreeMemoryNVPROC wglFreeMemoryNV;
#endif /* WGL_NV_vertex_array_range */
/* ------------------------------------------------------------------------ */
struct WGLEW
{
unsigned int ARB_buffer_region : 1;
unsigned int ARB_extensions_string : 1;
unsigned int ARB_make_current_read : 1;
unsigned int ARB_multisample : 1;
unsigned int ARB_pbuffer : 1;
unsigned int ARB_pixel_format : 1;
unsigned int ARB_render_texture : 1;
unsigned int EXT_depth_float : 1;
unsigned int EXT_display_color_table : 1;
unsigned int EXT_extensions_string : 1;
unsigned int EXT_make_current_read : 1;
unsigned int EXT_multisample : 1;
unsigned int EXT_pixel_format : 1;
unsigned int EXT_pbuffer : 1;
unsigned int EXT_swap_control : 1;
unsigned int I3D_digital_video_control : 1;
unsigned int I3D_gamma : 1;
unsigned int I3D_genlock : 1;
unsigned int I3D_image_buffer : 1;
unsigned int I3D_swap_frame_lock : 1;
unsigned int I3D_swap_frame_usage : 1;
unsigned int OML_sync_control : 1;
unsigned int ATI_pixel_format_float : 1;
unsigned int NV_float_buffer : 1;
unsigned int NV_render_depth_texture : 1;
unsigned int NV_render_texture_rectangle : 1;
unsigned int NV_vertex_array_range : 1;
};
extern GLEW_EXPORT struct WGLEW wglew;
#ifdef __cplusplus
}
#endif
#undef GLEW_EXPORT
#endif /* _WIN32 */
#endif /* __wglew_h__ */

0
lib/.do.not.remove Normal file
View File

3383
src/glew.c Normal file
View File

File diff suppressed because it is too large Load Diff

2238
src/glewinfo.c Normal file
View File

File diff suppressed because it is too large Load Diff