<HTML>

<TITLE>Mesa Release Notes</TITLE>

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

<BODY>

<body bgcolor="#eeeeee">

<H1>Mesa 7.0.4 Release Notes / August 16, 2008</H1>

<p>
Mesa 7.0.4 is a stable release with bug fixes since version 7.0.3.
</p>


<h2>MD5 checksums</h2>
<pre>
909afa3a01ae31478d363837681415ac  MesaLib-7.0.4.tar.gz
8d7bacbe0234742a5d08c8088c4619e9  MesaLib-7.0.4.tar.bz2
5e44261ef85b049a868e1785d9adc276  MesaLib-7.0.4.zip
53dcd77d37a819feaf50b5fcdd0a6e0f  MesaDemos-7.0.4.tar.gz
c1215b31c5f7b85f81eed3bfba07d556  MesaDemos-7.0.4.tar.bz2
b1825a7361f116b28d82d328077630b4  MesaDemos-7.0.4.zip
d7677d015f52602d1bf8b837fb717848  MesaGLUT-7.0.4.tar.gz
f5f8b46f7e763d9f7b7d1d115c1c44ee  MesaGLUT-7.0.4.tar.bz2
a786775271a02c62a3370b13b26bf48d  MesaGLUT-7.0.4.zip
</pre>


<h2>Bug fixes</h2>
<ul>
<li>define #extension GL_ARB_texture_rectangle in shading language
<li>fixed WIN32 compile problem in libGLU
<li>Fixed a per-vertex glMaterial bug which could cause bad lighting
<li>Fixed potential crash in AA/smoothed triangle rendering when using a fragment shader
<li>Fixed glDrawElement + VBO segfault (bug 16156)
<li>Fixed GLSL linker bug causing generic vertex attributes to get aliased
<li>Fixed stack overflow when using glPixelZoom on Windows
<li>Fixed broken all(bvec2) GLSL function, added misc missing bvec constructors
<li>ARB program "state.clip[n].plane" didn't parse correctly
<li>Fixed broken glGetUniformiv() (bug 13774)
</ul>

<h2>Changes</h2>
<ul>
<li>Including the latest glext.h and glxext.h header files from Khronos
<li>Added support for DragonFly OS
<li>Added a build config for FreeBSD static libs (Anatolij Shkodin)
<li>Enabled GL_EXT_multi_draw_arrays extension in R200/R300 drivers
<li>Enabled GL_ARB_point_sprite extension in I965 driver
<li>Enabled GL_EXT_texture_sRGB extension in I965 driver
<li>Added support for GL shading language in I965 driver
</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>
