<HTML>

<TITLE>Mesa Release Notes</TITLE>

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

<BODY>

<body bgcolor="#eeeeee">

<H1>Mesa 7.4.1 Release Notes / 18 April 2009</H1>

<p>
Mesa 7.4.1 is a stable development release fixing bugs since the 7.4 release.
</p>
<p>
Mesa 7.4.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>
0c3a72f3295a53a134c04bd7d209ea62  MesaLib-7.4.1.tar.gz
423260578b653818ba66c2fcbde6d7ad  MesaLib-7.4.1.tar.bz2
84f78b154d4bd5c3ecc42eeff2e56676  MesaLib-7.4.1.zip
aa0ad323e59d6d10ff33ac0dde462a60  MesaDemos-7.4.1.tar.gz
1e169fb6abc2b45613f1c98a82dfe690  MesaDemos-7.4.1.tar.bz2
294e42be2d74176596c994ec23322fcf  MesaDemos-7.4.1.zip
92373bfa48e7b68dddf356e86b0e5699  MesaGLUT-7.4.1.tar.gz
336f3824b578b072211e0beecf4f04f4  MesaGLUT-7.4.1.tar.bz2
20751388d8ef16b42d25d9e3d705d101  MesaGLUT-7.4.1.zip
</pre>


<h2>Bug fixes</h2>
<ul>
<li>Fixed a two-sided lighting bug in fixed-function-to-GPU code generation
<li>Fixed some Darwin issues (Jeremy Huddleston)
<li>Indexing the GLSL gl_EyePlane[] or gl_ObjectPlane[] arrays with a variable
    was broken, bug 20986
<li>Fixed incorrect texture unit bias in TXB instruction
<li>glTexParameter settings weren't always propogated to drivers
<li>Assorted vertex/fragment program bug fixes
<li>Fixed point rendering in software rasterizer
<li>Fixed potential deadlock in object hash functions
<li>Fix a couple bugs surrounding front-buffer rendering with DRI2, but this
    is not quite complete.
<li>Fixed glPopAttrib() bug when restoring user clip planes
</ul>



<h2>Driver Status</h2>

<pre>
Driver			Status
----------------------	----------------------
DRI drivers		varies with the driver
XMesa/GLX (on Xlib)	implements OpenGL 2.1
OSMesa (off-screen)	implements OpenGL 2.1
Windows/Win32		implements OpenGL 2.1
Glide (3dfx Voodoo1/2)	implements OpenGL 1.3
SVGA			unsupported
Wind River UGL		unsupported
DJGPP			unsupported
GGI			unsupported
BeOS			unsupported
Allegro			unsupported
D3D			unsupported
</pre>

</body>
</html>
