<HTML>

<TITLE>Mesa Release Notes</TITLE>

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

<BODY>

<body bgcolor="#eeeeee">

<H1>Mesa 7.2 Release Notes / 20 September 2008</H1>

<p>
Mesa 7.2 is a stable release fixing bugs found in 7.1, which was a
new development release.
</p>
<p>
Mesa 7.2 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>
Note that this version of Mesa does not use the GEM memory manager.
The master branch of git uses GEM.
The prototype DRI2 code that was in 7.1 has also been removed.
</p>
<p>
DRM version 2.3.1 should be used with Mesa 7.2
</p>


<h2>MD5 checksums</h2>
<pre>
tbd
</pre>


<h2>New features</h2>
<ul>
<li>i965 driver: added support for G41 chipset (Intel)
</ul>


<h2>Bug fixes</h2>
<ul>
<li>Fixed display list bug involving primitives split across lists (bug 17564)
<li>Fixed some issues with glBindAttribLocation()
<li>Fixed crash in _tnl_InvalidateState() found with Amira (bug 15834)
<li>Assorted bug fixes for Ming build
<li>Fixed some vertex/pixel buffer object reference counting bugs
<li>Fixed depth/stencil bug in i915/945 driver
<li>Fixed some shader flow control bugs in i965 driver
<li>Fixed a few tdfx driver bugs which prevented driver from working
<li>Fixed multisample enable/disable bug
</ul>

<h2>Changes</h2>
<ul>
<li>Updated SGI header files with new license terms.
</ul>



<h2>To Do (someday) items</h2>
<ul>
<li>Remove the MEMCPY() and _mesa_memcpy() wrappers and just use memcpy().
Probably do the same for malloc, calloc, etc.
The wrappers were useful in the past for memory debugging but now we
have valgrind.  Not worried about SunOS 4 support anymore either...
<li>Switch to freeglut
<li>Fix linux-glide target/driver.
<li>Improved lambda and derivative calculation for frag progs.
</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>
