<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.1 Release Notes / August 3, 2007</H1>

<p>
Mesa 7.0.1 is a stable release with bug fixes since version 7.0.
</p>


<h2>MD5 checksums</h2>
<pre>
db55141a44b902fcc61d9265b7862c06  MesaLib-7.0.1.tar.gz
c056abd763e899114bf745c9eedbf9ad  MesaLib-7.0.1.tar.bz2
ecc2637547fae2b38271ae362d013afa  MesaLib-7.0.1.zip
b85a4a5be4e829f4a1165e4514b13183  MesaDemos-7.0.1.tar.gz
3b66b3268df12ca8a6c4e0c4c457912c  MesaDemos-7.0.1.tar.bz2
b1c18006f16e44e80fea66774c59b391  MesaDemos-7.0.1.zip
b87a69986839ae43ce12fc8e3dc1ebb4  MesaGLUT-7.0.1.tar.gz
25f30d0c1651997b4412366ba0572f7f  MesaGLUT-7.0.1.tar.bz2
676ee6682a6ce78a5540554fd975c03e  MesaGLUT-7.0.1.zip
</pre>


<h2>New features</h2>
<ul>
<li>Added a bluegene-osmesa build config
</ul>

<h2>Bug fixes</h2>
<ul>
<li>Fixed some MingW build issues
<li>Added a few missing OpenGL 2.0 API entrypoints:
  <ul>
  <li>glVertexAttrib4bv
  <li>glVertexAttrib4iv
  <li>glVertexAttrib4ubv
  <li>glVertexAttrib4uiv
  <li>glVertexAttrib4usv
  </ul>
<li>Fixed glDrawPixels(GL_STENCIL_INDEX) pixel transfer bug 11457
<li>GLSL bug fix: added vec2(vec4) constructor
<li>GLSL bug fix: .strq and .rgba writemasks didn't always work
<li>Stencil pixel map didn't always work for glDrawPixels (bug 11475)
<li>Fixed polygon stipple bug in i915 driver
<li>Binding a zero-sized texture didn't disable texturing (bug 11309)
<li>Queries of GL_INFO_LOG_LENGTH, GL_SHADER_SOURCE_LENGTH didn't include
the terminating zero (bug 11588)
<li>glXChooseFBConfig() in Xlib driver didn't handle GLX_STEREO flag properly
<li>Fixed a GLSL function call bug (#11731)
<li>glPointParameteriv(GL_DISTANCE_ATTENUATION_EXT) didn't work (bug 11754)
<li>glGetAttribLocation() always returned 1 (bug 11774)
<li>Fixed a few memory-related bugs in GLU library
</ul>


<h2>Changes</h2>
<ul>
<li>The libOSMesa library version has been reverted to 6.5.3 (soname=6)
in order to avoid application linking issues.  Otherwise, applications
previously linked with libOSMesa.so.6 would no longer link with libOSMesa.so.7
<li>Dropped obsolete, unmaintained Windows project files for VC6 and VC7.
</ul>


<h2>To Do (someday) items</h2>
<ul>
<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>
