<HTML>

<TITLE>Mesa Release Notes</TITLE>

<head><link rel="stylesheet" type="text/css" href="mesa.css"></head>

<BODY>

<body bgcolor="#eeeeee">

<H1>Mesa 7.6.1 Release Notes, 21 December 2009</H1>

<p>
Mesa 7.6.1 is a bug-fix release fixing issues since version 7.6.
</p>
<p>
Mesa 7.6.1 implements the OpenGL 2.1 API, but the version reported by
glGetString(GL_VERSION) depends on the particular driver being used.
Some drivers don't support all the features required in OpenGL 2.1.
</p>
<p>
See the <a href="install.html">Compiling/Installing page</a> for prerequisites
for DRI hardware acceleration.
</p>


<h2>MD5 checksums</h2>
<pre>
e80fabad2e3eb7990adae773d6aeacba  MesaLib-7.6.1.tar.gz
7db4617e9e10ad3aca1b64339fd71b7d  MesaLib-7.6.1.tar.bz2
dd3275dbf9833480d2e92d0c69b22abd  MesaLib-7.6.1.zip
f7fdcfe3c0f363e571c60f02f74368fb  MesaDemos-7.6.1.tar.gz
a4226f06732a02556fcf6be290b86dff  MesaDemos-7.6.1.tar.bz2
849425f356bd940726cebedfa79de176  MesaDemos-7.6.1.zip
d40cc7c5e337a85b674e27a8e494f52f  MesaGLUT-7.6.1.tar.gz
ca9aecb91f05b1da9fd7d5eeb19d47d7  MesaGLUT-7.6.1.tar.bz2
23fad8398004c977a1d8953079b72ca6  MesaGLUT-7.6.1.zip
</pre>


<h2>New features</h2>
<ul>
<li>Upgraded GL/glext.h to version 56, GL/glxext.h to version 25,
    GL/wglext.h to version 17
<li>New 3D driver, r600, for Radeon R6xx, R7xx hardware
</ul>


<h2>Bug fixes</h2>
<ul>
<li>Fixed crash caused by glXCopyContext() and glXDestroyContext(), bug 24217
<li>glXQueryContext(GLX_RENDER_TYPE) returned wrong values (bug 24211)
<li>GLSL sqrt(0) returned unpredictable results
<li>Fixed default texture binding bug when a bound texture was deleted.
<li>r300: Work around an issue with very large fragment programs on R500.
<li>Fake glXQueryDrawable() didn't return good values (bug 24320)
<li>Fixed AUX buffer breakage (bug 24426).
<li>Fixed locale-dependent float parsing bug in GLSL compiler (bug 24531)
<li>Fixed Gallium Cell driver compilation failure.
<li>Fixed glGetTexLevelParameter(GL_TEXTURE_INTERNAL_FORMAT) query so that
    it returns the actual compressed format chosen.
<li>Fixed glBitmap bugs in Intel drivers.
<li>Fixed a number of Microsoft Visual Studio compilation problems.
<li>Fixed clipping / provoking vertex bugs in i965 driver.
<li>Assorted build fixes for AIX.
<li>Endianness fixes for the DRI swrast driver (bug 22767).</li>
<li>Point sprite fixes for i915/945 driver.
<li>Fixed assorted memory leaks (usually on error paths)
<li>Fixed some GLSL compiler bugs (ex: 25579)
<li>Assorted build fixes for BlueGene
</ul>

<h2>Changes</h2>
<ul>
<li>Removed old VC6, VC7 project files for Windows
</ul>


</body>
</html>
