<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html lang="en">
<head>
  <meta http-equiv="content-type" content="text/html; charset=utf-8">
  <title>Mesa Release Notes</title>
  <link rel="stylesheet" type="text/css" href="../mesa.css">
</head>
<body>

<div class="header">
  <h1>The Mesa 3D Graphics Library</h1>
</div>

<iframe src="../contents.html"></iframe>
<div class="content">

<h1>Mesa 6.5.1 Release Notes / September 15, 2006</h1>

<p>
Mesa 6.5.1 is a 6.5 follow-on development release mostly consisting of
bug fixes.
</p>


<h2>MD5 checksums</h2>
<pre>
d9a555297319bb932a3192952d53d073  MesaLib-6.5.1.tar.gz
c46f2c6646a270911b791dd8e1c2d977  MesaLib-6.5.1.tar.bz2
939eaaff33322bfeafac784402b45f4f  MesaLib-6.5.1.zip
9e4bbe83c007bfbaa67449a81cc3d36a  MesaDemos-6.5.1.tar.gz
0f2794baf7a9d98b22caea9f78c6942d  MesaDemos-6.5.1.tar.bz2
14c77eab9cc7a265c331abf239927c1c  MesaDemos-6.5.1.zip
c5f87c23aaf4eaf1bda0d007ea98366c  MesaGLUT-6.5.1.tar.gz
2525642fe7f454e3e1a1aad01359b406  MesaGLUT-6.5.1.tar.bz2
e33b165c22551e23b58ede8767378543  MesaGLUT-6.5.1.zip
</pre>


<h2>New Features</h2>
<ul>
<li>Intel i965 "broadwater" DRI driver

<li>GL_APPLE_vertex_array_object - allows encapsulation of a set of vertex
	arrays in an object.

<li>GL_EXT_texture_sRGB - non-linearly mapped texture formats

<li>GL_EXT_gpu_program_parameters - addes a few new functions for setting
	multiple vertex/fragment program parameters with one call.
<li>"engine" demo
<li>updated fbdev driver and GLUT for fbdev (Sean D'Epagnier)
<li>many updates to the DRI drivers
</ul>

<h2>Changes</h2>
<ul>
<li>The glVertexAttribARB functions no longer alias the conventional
	vertex attributes.
<li>glxinfo program prints more info with -l option
<li>GL_FRAGMENT_PROGRAM_NV and GL_FRAGMENT_PROGRAM_ARB are now
	compatible, in terms of glBindProgramARB()
<li>The GL_ARB_vertex_program attribute <code>vertex.weight</code> is now
	accepted by the parser, even though the	GL_ARB_vertex_blend and
	GL_EXT_vertex_weighting extensions aren't supported.
	Allows Warcraft to run.
</ul>

<h2>Bug fixes</h2>
<ul>
<li>fixed broken texture border handling for depth textures (bug 6498)
<li>removed the test for duplicated framebuffer attachments, per
	version 117 of the GL_EXT_framebuffer_object specification
<li>fixed a few render-to-texture bugs, including render to depth texture
<li>clipping of lines against user-defined clip planes was broken (6512)
<li>assembly language dispatch for SPARC was broken (bug 6484)
<li>assorted compilation fixes on various Unix platforms (Dan Schikore)
<li>glPopAttrib could restore an invalid value for GL_DRAW_BUFFER
<li>assorted minor fixes for 16 and 32 bit/channel modes
<li>fixed assorted bugs in texture compression paths
<li>fixed indirect rendering vertex array crashes (bug 6863)
<li>glDrawPixels GL_INDEX_OFFSET didn't always work
<li>fixed convolution memory leak (bug 7077)
<li>rectangular depth textures didn't work
<li>invalid mode to glBegin didn't generate an error (bug 7142)
<li>'normalized' parameter to glVertexAttribPointerARB didn't work
<li>disable bogus GLX_SGI_video_sync extension in xlib driver
<li>fixed R128 driver locking bug (Martijn van Oosterhout)
<li>using evaluators with vertex programs caused crashes (bug 7564)
<li>fragment.position wasn't set correctly for point/line primitives
<li>fixed parser bug for scalar sources for GL_NV_fragment_program
<li>max fragment program length was incorrectly 128, now 1024
<li>writes to result.depth in fragment programs weren't clamped to [0,1]
<li>fixed potential dangling pointer bug in glBindProgram()
<li>fixed some memory leaks (and potential crashes) in Xlib driver
<li>fixed a number of build issues on HP-UX (Christopher Bell)
<li>accum buffer didn't work with OSMesa interface
</ul>


<h2>Internal code changes</h2>

<p>
A number of Mesa program-related structs were renamed.
For example <i>struct vertex_program</i> is now <i>struct gl_vertex_program</i>.
All the effected drivers have been updated.
</p>

<p>Ian Romanick updated the GL API dispatch code in a number of ways.
First, many old/unused extensions were removed.
Second, the static entrypoints for some extensions were removed.
This means GL function pointers will have to be used more often
(e.g. use glXGetProcAddressARB()).
</p>


<h2>To Do (someday) items</h2>
<ul>
<li>Switch to freeglut
<li>Increase MAX_DRAWBUFFERS
<li>Fix linux-glide target/driver.
<li>Fix lambda calculation for frag progs.
</ul>


<h2>Driver Status</h2>

<pre>
Driver			Status
----------------------	----------------------
DRI drivers		varies with the driver
XMesa/GLX (on Xlib)	implements OpenGL 1.5
OSMesa (off-screen)	implements OpenGL 1.5
Glide (3dfx Voodoo1/2)	implements OpenGL 1.3
SVGA			implements OpenGL 1.3
Wind River UGL		implements OpenGL 1.3
Windows/Win32		implements OpenGL 1.5
DJGPP			implements OpenGL 1.5
GGI			implements OpenGL 1.3
BeOS			implements OpenGL 1.5
Allegro			needs updating
D3D			needs updating
</pre>

</div>
</body>
</html>
