<!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 10.4.1 Release Notes / December 29, 2014</h1>

<p>
Mesa 10.4.1 is a bug fix release which fixes bugs found since the 10.4.0 release.
</p>
<p>
Mesa 10.4.1 implements the OpenGL 3.3 API, but the version reported by
glGetString(GL_VERSION) or glGetIntegerv(GL_MAJOR_VERSION) /
glGetIntegerv(GL_MINOR_VERSION) depends on the particular driver being used.
Some drivers don't support all the features required in OpenGL 3.3.  OpenGL
3.3 is <strong>only</strong> available if requested at context creation
because compatibility contexts are not supported.
</p>

<h2>SHA256 checksums</h2>
<pre>
5311285e791a6bfaa468ad002bd1e1164acb3eaa040b5a1bf958bdb7c27e0a9d  MesaLib-10.4.1.tar.gz
91e8b71c8aff4cb92022a09a872b1c5d1ae5bfec8c6c84dbc4221333da5bf1ca  MesaLib-10.4.1.tar.bz2
e09c8135f5a86ecb21182c6f8959aafd39ae2f98858fdf7c0e25df65b5abcdb8  MesaLib-10.4.1.zip
</pre>

<h2>New features</h2>
<p>None</p>

<h2>Bug fixes</h2>

<p>This list is likely incomplete.</p>

<ul>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=82585">Bug 82585</a> - geometry shader with optional out variable segfaults</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=82991">Bug 82991</a> - Inverted bumpmap in webgl applications</li>

<li><a href="https://bugs.freedesktop.org/show_bug.cgi?id=83908">Bug 83908</a> - [i965] Incorrect icon colors in Steam Big Picture</li>

</ul>


<h2>Changes</h2>

<p>Andres Gomez (1):</p>
<ul>
  <li>i965/brw_reg: struct constructor now needs explicit negate and abs values.</li>
</ul>

<p>Cody Northrop (1):</p>
<ul>
  <li>i965: Require pixel alignment for GPU copy blit</li>
</ul>

<p>Emil Velikov (3):</p>
<ul>
  <li>docs: Add 10.4 sha256 sums, news item and link release notes</li>
  <li>Revert "glx/dri3: Request non-vsynced Present for swapinterval zero. (v3)"</li>
  <li>Update version to 10.4.1</li>
</ul>

<p>Ian Romanick (2):</p>
<ul>
  <li>linker: Wrap access of producer_var with a NULL check</li>
  <li>linker: Assign varying locations geometry shader inputs for SSO</li>
</ul>

<p>Mario Kleiner (4):</p>
<ul>
  <li>glx/dri3: Fix glXWaitForSbcOML() to handle targetSBC==0 correctly. (v2)</li>
  <li>glx/dri3: Track separate (ust, msc) for PresentPixmap vs. PresentNotifyMsc (v2)</li>
  <li>glx/dri3: Request non-vsynced Present for swapinterval zero. (v3)</li>
  <li>glx/dri3: Don't fail on glXSwapBuffersMscOML(dpy, window, 0, 0, 0) (v2)</li>
</ul>

<p>Maxence Le Doré (1):</p>
<ul>
  <li>glsl: Add gl_MaxViewports to available builtin constants</li>
</ul>


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