<HTML>

<TITLE>Mesa Release Notes</TITLE>

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

<BODY>

<body bgcolor="#eeeeee">

<H1>Mesa 7.1 Release Notes / August 26, 2008</H1>

<p>
Mesa 7.1 is a new development release.
There have been many internal code changes since Mesa 7.0.x.
It should be relatively stable, but those who are especially concerned about
stability should wait for Mesa 7.2 or use Mesa 7.0.4 (the previous stable
release).
</p>
</>
Note that this version of Mesa does not use the GEM memory manager.
The master branch of git uses GEM.
</p>
<p>
DRM version 2.3.1 should be used with Mesa 7.1
</p>


<h2>MD5 checksums</h2>
<pre>
971c2fe6e6949dc5ba200a6f97a6dc81  MesaLib-7.1.tar.gz
6bff7f532d16f90f944a400c8bd7074d  MesaLib-7.1.tar.bz2
d48224bf9d54c3da6776adb4869ba024  MesaLib-7.1.zip
3de268420efca43e9a19ab506cdfc993  MesaDemos-7.1.tar.gz
abfc9775e1462363af8ec160d1feb01f  MesaDemos-7.1.tar.bz2
f7b3623387c4036e9895cd9ac0dfad99  MesaDemos-7.1.zip
fdf348f78cd09304b6ff801ef8acc8eb  MesaGLUT-7.1.tar.gz
f6d88a4eeb02e98c7e92f1c895d3c76b  MesaGLUT-7.1.tar.bz2
4dc102a5ca51e1c41dde87d3f8c7b22a  MesaGLUT-7.1.zip
</pre>


<h2>New features</h2>
<ul>
<li>autoconf-based configuration (and clean-up of Makefiles)
<li>Assorted DRI driver enhancements
<li>Reduced dependencies between X server and Mesa
<li>GL_EXT_texture_from_pixmap extension for Xlib driver
<li>Support for the GL shading language with i965 driver (implemented by Intel)
<li>ATI R500 series support (Radeon X1300&#8211;X1950) in r300 DRI driver
</ul>


<h2>Bug fixes</h2>
<ul>
<li>Numerous GLSL fixes
<li>Fixed some error code/detection bugs in the GLSL-related API functions
<li>Lots of DRI driver fixes.
</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>
