<HTML>

<TITLE>Mesa Release Notes</TITLE>

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

<BODY>

<body bgcolor="#eeeeee">

<H1>Mesa 7.5 Release Notes / date TBD</H1>

<p>
Mesa 7.5 is a new development release.
People who are concerned with stability and reliability should stick
with the 7.4.x branch or wait for Mesa 7.5.1.
</p>
<p>
The main new feature of Mesa 7.5 is the
<a href="http://www.tungstengraphics.com/wiki/index.php/Gallium3D"
target="_parent">Gallium3D</a> infrastructure.
</p>
<p>
Mesa 7.5 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>
<p>
Note that the Mesa project is no longer using odd/even version numbers
to indicate development/stable releases.
The so-called development releases have been fairly stable.
If you're especially concerned with stability you should probably look for
"point" releases such as 7.5.1 which will be a bug-fix release.
</p>


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


<h2>New features</h2>
<ul>
<li>Gallium3D - this is the new architecture for OS-independent and
    API-independent 3D drivers.
    Gallium3D is intended for GPUs that fully support  vertex/fragment shaders.
    The Gallium3D drivers currently included are:
    <ul>
    <li>softpipe - a software/reference driver
    <li>i915 - Intel 915/945 driver
    <li><a href="cell.html">Cell</a> - IBM/Sony/Toshiba Cell processor driver
    <li>nouveau (for NVIDIA GPUs) and R300 for (AMD/ATI R300).
        <b>PLEASE NOTE: these drivers are incomplete and still under development.
        It's probably NOT worthwhile to report any bugs unless you have patches.
        </b>
    </ul>
<li>GL_ARB_framebuffer_object extension (software drivers, i965 driver)
<li>Reworked two-sided stencil support.
This allows a driver to support all three variations of two-sided stencil
including GL_ATI_separate_stencil, GL_EXT_stencil_two_side and OpenGL 2.0
<li>GL_EXT_vertex_array_bgra extension (software drivers, i965 driver)
<li>GL_NV_texture_env_combine4 extension (software drivers, i965/i915 drivers)
<li>GL_EXT_texture_swizzle extension (software drivers, i965 driver)
<li>Updated SPARC assembly optimizations (David S. Miller)
<li>Initial support for separate compilation units in GLSL compiler.
<li>Increased max number of generic GLSL varying variables to 16 (formerly 8).
<li>GLSL linker now detects when too many varying variables are used.
</ul>


<h2>Bug fixes</h2>
<ul>
<li>Lots of i965 driver bug fixes
<li>Fixed some GLSL preprocessor bugs
<li>GLSL: continue inside of a for-loop didn't work
</ul>


<h2>Changes</h2>
<ul>
<li>Remove support for GL_SGIX_shadow, GL_SGIX_shadow_ambient and
GL_SGIX_depth_texture extensions.  Superseded by the ARB versions.
<li>Omitted some old Mesa demos from the release tarballs, added some others.
</ul>

</body>
</html>
