Merge branch 'gallium-0.1' into gallium-0.2

A first attempt at moving gallium onto a branch directly off master...

It will be interesting to see how much work this takes to get running.

Have resolved the conflicts semi-arbitarily, not compiled or tested.

Conflicts:

	.gitignore
	Makefile
	configs/config.mgw
	configs/darwin
	configs/darwin-x86ppc
	configs/default
	configs/freebsd-dri
	configs/linux-dri
	configs/linux-dri-xcb
	configs/linux-fbdev
	configs/linux-static
	configs/linux-x86-64-static
	configs/linux-x86-static
	doxygen/Makefile
	include/GL/gl.h
	progs/demos/Makefile
	progs/demos/descrip.mms
	progs/demos/texenv.c
	progs/egl/.gitignore
	progs/egl/Makefile
	progs/glsl/.gitignore
	progs/glsl/Makefile
	progs/glsl/convolutions.c
	progs/samples/Makefile.mgw
	progs/tests/.gitignore
	progs/trivial/.gitignore
	progs/trivial/point-param.c
	progs/trivial/tri.c
	progs/xdemos/.gitignore
	progs/xdemos/glthreads.c
	src/egl/drivers/demo/Makefile
	src/egl/drivers/dri/Makefile
	src/egl/main/Makefile
	src/glu/Makefile
	src/glu/sgi/Makefile
	src/glu/sgi/Makefile.mgw
	src/glut/glx/Makefile.mgw
	src/glut/os2/WarpWin.cpp
	src/glut/os2/glut_cindex.cpp
	src/glut/os2/glut_gamemode.cpp
	src/glut/os2/glut_win.cpp
	src/glut/os2/glut_winmisc.cpp
	src/glut/os2/os2_glx.cpp
	src/glut/os2/os2_menu.cpp
	src/glut/os2/os2_winproc.cpp
	src/glw/Makefile
	src/glx/x11/dri_glx.c
	src/glx/x11/glxext.c
	src/mesa/Makefile
	src/mesa/Makefile.mgw
	src/mesa/descrip.mms
	src/mesa/drivers/beos/Makefile
	src/mesa/drivers/common/descrip.mms
	src/mesa/drivers/common/driverfuncs.c
	src/mesa/drivers/directfb/Makefile
	src/mesa/drivers/dri/Makefile.template
	src/mesa/drivers/dri/common/dri_bufmgr.c
	src/mesa/drivers/dri/common/dri_bufmgr.h
	src/mesa/drivers/dri/common/dri_util.c
	src/mesa/drivers/dri/common/extension_helper.h
	src/mesa/drivers/dri/common/mmio.h
	src/mesa/drivers/dri/common/utils.c
	src/mesa/drivers/dri/common/utils.h
	src/mesa/drivers/dri/glcore/Makefile
	src/mesa/drivers/dri/i810/i810screen.c
	src/mesa/drivers/dri/i915/intel_ioctl.c
	src/mesa/drivers/dri/i915/intel_ioctl.h
	src/mesa/drivers/dri/i915/intel_screen.c
	src/mesa/drivers/dri/i915/server/i830_common.h
	src/mesa/drivers/dri/i915/server/i830_dri.h
	src/mesa/drivers/dri/i965/intel_screen.c
	src/mesa/drivers/dri/i965/server/i830_common.h
	src/mesa/drivers/dri/i965/server/i830_dri.h
	src/mesa/drivers/dri/mach64/mach64_screen.c
	src/mesa/drivers/dri/nouveau/nouveau_context.h
	src/mesa/drivers/dri/nouveau/nouveau_fifo.c
	src/mesa/drivers/dri/nouveau/nouveau_fifo.h
	src/mesa/drivers/dri/nouveau/nouveau_screen.c
	src/mesa/drivers/dri/nouveau/nouveau_screen.h
	src/mesa/drivers/dri/r128/r128_tex.h
	src/mesa/drivers/dri/savage/savageioctl.h
	src/mesa/drivers/fbdev/Makefile
	src/mesa/drivers/osmesa/Makefile
	src/mesa/drivers/osmesa/descrip.mms
	src/mesa/drivers/x11/Makefile
	src/mesa/drivers/x11/descrip.mms
	src/mesa/drivers/x11/xm_dd.c
	src/mesa/glapi/glapi.c
	src/mesa/glapi/glthread.c
	src/mesa/main/api_validate.c
	src/mesa/main/attrib.c
	src/mesa/main/bufferobj.c
	src/mesa/main/bufferobj.h
	src/mesa/main/buffers.c
	src/mesa/main/config.h
	src/mesa/main/context.c
	src/mesa/main/descrip.mms
	src/mesa/main/drawpix.c
	src/mesa/main/enums.c
	src/mesa/main/fbobject.c
	src/mesa/main/glheader.h
	src/mesa/main/imports.c
	src/mesa/main/mipmap.c
	src/mesa/main/mm.c
	src/mesa/main/mm.h
	src/mesa/main/mtypes.h
	src/mesa/main/points.c
	src/mesa/main/sources
	src/mesa/main/state.c
	src/mesa/main/texcompress_fxt1.c
	src/mesa/main/texenvprogram.c
	src/mesa/main/texobj.c
	src/mesa/main/texstate.c
	src/mesa/main/texstore.c
	src/mesa/math/descrip.mms
	src/mesa/shader/arbprogram.c
	src/mesa/shader/descrip.mms
	src/mesa/shader/prog_execute.c
	src/mesa/shader/prog_statevars.c
	src/mesa/shader/prog_statevars.h
	src/mesa/shader/prog_uniform.c
	src/mesa/shader/program.c
	src/mesa/shader/program.h
	src/mesa/shader/shader_api.c
	src/mesa/shader/slang/descrip.mms
	src/mesa/shader/slang/library/slang_vertex_builtin_gc.h
	src/mesa/sources
	src/mesa/swrast/descrip.mms
	src/mesa/swrast/s_drawpix.c
	src/mesa/swrast/s_fragprog.c
	src/mesa/swrast/s_readpix.c
	src/mesa/swrast/s_span.c
	src/mesa/swrast_setup/descrip.mms
	src/mesa/tnl/descrip.mms
	src/mesa/tnl/t_context.h
	src/mesa/tnl/t_vp_build.c
	src/mesa/tnl/tnl.h
	src/mesa/vbo/descrip.mms
	src/mesa/vbo/vbo_context.c
	src/mesa/vbo/vbo_exec_array.c
	src/mesa/x86-64/xform4.S
	src/mesa/x86/rtasm/x86sse.c
	src/mesa/x86/rtasm/x86sse.h
	windows/VC6/progs/glut/glut.dsp
	windows/VC7/mesa/gdi/gdi.vcproj
	windows/VC7/mesa/glu/glu.vcproj
	windows/VC7/mesa/mesa.sln
	windows/VC7/mesa/mesa/mesa.vcproj
	windows/VC7/mesa/osmesa/osmesa.vcproj
	windows/VC7/progs/glut/glut.vcproj
	windows/VC8/mesa/gdi/gdi.vcproj
	windows/VC8/mesa/glu/glu.vcproj
	windows/VC8/mesa/mesa.sln
	windows/VC8/mesa/mesa/mesa.vcproj
	windows/VC8/progs/glut/glut.vcproj

1 files changed, 395 insertions, 0 deletions

diff --git a/progs/tests/calibrate_rast.c b/progs/tests/calibrate_rast.c
new file mode 100644
index 0000000000..37d8ac85e5
--- /dev/null
+++ b/progs/tests/calibrate_rast.c
@@ -0,0 +1,395 @@
+/*
+ * Automatic primitive rasterization precision test.
+ *
+ * Draw prims at various sub-pixel offsets and examine where the quad is
+ * actually drawn.
+ * Check if the range of offsets which paint the right pixels falls within
+ * OpenGL's specification.
+ * In case of failures, report the coordinate bias needed to fix the problem.
+ *
+ * Note that even Mesa/swrast fails some line tests.  This is because some
+ * window coordinates wind up as 53.9999 instead of 54, for example.  Enabling
+ * the small translation factor below fixes that.  Revisit someday...
+ *
+ * Brian Paul
+ * 28 Feb 2008
+ */
+
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <GL/glut.h>
+
+
+static int Width = 100, Height = 100;
+static int Win;
+static float Step = 0.125;
+#if 0
+/* This tiny offset fixes errors in Mesa/Xlib */
+static float Xtrans = 0.5 * 0.125;
+static float Ytrans = 0.5 * 0.125;
+#else
+static float Xtrans = 0.0;
+static float Ytrans = 0.0;
+#endif
+
+
+static void
+PointCalibrate(int xpos, int ypos)
+{
+   GLfloat rgba[4];
+   float x, y;
+   float xmin, ymin, xmax, ymax;
+
+   xmin = ymin = 1000.0;
+   xmax = ymax = -1000.0;
+
+   for (y = -1.0; y <= 1.0; y += Step) {
+      for (x = -1.0; x <= 1.0; x += Step) {
+         glClear(GL_COLOR_BUFFER_BIT);
+         glBegin(GL_POINTS);
+         glVertex2f(xpos + x, ypos + y);
+         glEnd();
+         glReadPixels(xpos, ypos, 1, 1, GL_RGBA, GL_FLOAT, rgba);
+         if (rgba[0] == 1.0 && rgba[1] == 1.0 && rgba[2] == 1.0) {
+            /* hit */
+            if (x < xmin)
+               xmin = x;
+            if (y < ymin)
+               ymin = y;
+            if (x > xmax)
+               xmax = x;
+            if (y > ymax)
+               ymax = y;
+         }
+      }
+   }
+
+   printf("Point at (%2d, %2d) drawn for x in [%6.3f, %6.3f] and y in [%6.3f, %6.3f]\n",
+          xpos, ypos,
+          xpos + xmin, xpos + xmax,
+          ypos + ymin, ypos + ymax);
+
+   if (xmax - xmin != 1.0 - Step) {
+      printf("  => Inconsistant X-axis rasterization!\n");
+   }
+   if (ymax - ymin != 1.0 - Step) {
+      printf("  => Inconsistant Y-axis rasterization!\n");
+   }
+   if (xmin < 0.0) {
+      printf("  => Points should be X biased by about %f\n", xmin);
+   }
+   if (ymin < 0.0) {
+      printf("  => Points should be Y biased by about %f\n", ymin);
+   }
+   if (xmax > 1.0) {
+      printf("  => Points should be X biased by about %f\n", 1.0 - xmax);
+   }
+   if (ymax > 1.0) {
+      printf("  => Points should be Y biased by about %f\n", 1.0 - ymax);
+   }
+
+}
+
+
+/**
+ * XXX Implement VLineCalibrate() someday
+ */
+static void
+HLineCalibrate(int xpos, int ypos, int len)
+{
+   GLfloat rgba[2][4];
+   float x, y;
+   float ymin, ymax;
+   float xmin_left, xmax_left, xmin_right, xmax_right;
+
+   xmin_left = xmin_right = 1000.0;
+   xmax_left = xmax_right = -1000.0;
+   ymin = 1000;
+   ymax = -1000.0;
+
+   /*
+    * First, check vertical positioning of the horizontal line
+    */
+   for (y = -1.0; y <= 1.0; y += Step) {
+      glClear(GL_COLOR_BUFFER_BIT);
+      glBegin(GL_LINES);
+      glVertex2f(xpos,       ypos + y);
+      glVertex2f(xpos + len, ypos + y);
+      glEnd();
+
+      glReadPixels(xpos + len / 2, ypos, 1, 1, GL_RGBA, GL_FLOAT, rgba);
+      if (rgba[0][0] == 1.0) {
+         /* hit */
+         if (y < ymin)
+            ymin = y;
+         if (y > ymax)
+            ymax = y;
+      }
+   }
+
+   printf("H-line at Y=%2d drawn for y in [%6.3f, %6.3f]\n",
+          ypos,
+          ypos + ymin, ypos + ymax);
+
+   if (ymax - ymin != 1.0 - Step) {
+      printf("  => Inconsistant Y-axis rasterization!\n");
+   }
+
+   if (ymin > 0.5 ) {
+      printf("  => Lines should be Y biased by about %f\n", ymin - 0.5);
+   }
+
+   if (ymax < 0.5 ) {
+      printf("  => Lines should be Y biased by about %f\n", 0.5 - ymax);
+   }
+
+   /*
+    * Second, check endpoints  (for Y at 1/2 pixel)
+    */
+   for (x = -1.0; x <= 1.0; x += Step) {
+      glClear(GL_COLOR_BUFFER_BIT);
+      glBegin(GL_LINES);
+      glVertex2f(xpos + x,       ypos + 0.5f);
+      glVertex2f(xpos + x + len, ypos + 0.5f);
+      glEnd();
+
+      /* left end */
+      glReadPixels(xpos - 1, ypos, 2, 1, GL_RGBA, GL_FLOAT, rgba);
+      if (rgba[0][0] == 0.0 && rgba[1][0] == 1.0) {
+         /* hit */
+         if (x < xmin_left)
+            xmin_left = x;
+         if (x > xmax_left)
+            xmax_left = x;
+      }
+
+      /* right end */
+      glReadPixels(xpos + len - 1, ypos, 2, 1, GL_RGBA, GL_FLOAT, rgba);
+      if (rgba[0][0] == 1.0 && rgba[1][0] == 0.0) {
+         /* hit */
+         if (x < xmin_right)
+            xmin_right = x;
+         if (x > xmax_right)
+            xmax_right = x;
+      }
+   }
+
+   printf("H-line [%d..%d) hit left end for x in [%6.3f, %6.3f] "
+          "hit right end for x in [%6.3f, %6.3f]\n",
+          xpos, xpos + len,
+          xpos + xmin_left, xpos + xmax_left,
+          xpos + len + xmin_right, xpos + len + xmax_right);
+
+   if (xmax_left - xmin_left > 1.0 - Step) {
+      printf("  => Inconsistant left-end rasterization!\n");
+   }
+   if (xmax_right - xmin_right > 1.0 - Step) {
+      printf("  => Inconsistant right-end rasterization!\n");
+   }
+
+   if (xmin_left != xmin_right ||
+       xmax_left != xmax_right) {
+      printf("  => Inconsistant length!\n");
+   }
+
+   if (xmin_left < 0.0) {
+      printf("  => Coords should be X biased by about %f\n", xmin_left );
+   }
+   if (xmin_right < 0.0) {
+      printf("  => Coords should be X biased by about %f\n", xmin_right );
+   }
+   if (xmax_left >= 1.0) {
+      printf("  => Coords should be X biased by about %f\n", -xmax_right + 1.0);
+   }
+   if (xmax_right >= 1.0) {
+      printf("  => Coords should be X biased by about %f\n", -xmax_right + 1.0);
+   }
+
+}
+
+
+static void
+QuadCalibrate(int xpos, int ypos, int width, int height)
+{
+   GLfloat rgba1[2][4];
+   GLfloat rgba2[2][4];
+   float x, y;
+   float xmin, ymin, xmax, ymax;
+
+   xmin = ymin = 1000.0;
+   xmax = ymax = -1000.0;
+
+   for (y = -1.0; y <= 1.0; y += Step) {
+      for (x = -1.0; x <= 1.0; x += Step) {
+         glClear(GL_COLOR_BUFFER_BIT);
+         glBegin(GL_QUADS);
+         glVertex2f(xpos + x,         ypos + y);
+         glVertex2f(xpos + x + width, ypos + y);
+         glVertex2f(xpos + x + width, ypos + y + height);
+         glVertex2f(xpos + x,         ypos + y + height);
+         glEnd();
+
+         /* horizontal measurement */
+         glReadPixels(xpos - 1, ypos + 2, 2, 1, GL_RGBA, GL_FLOAT, rgba1);
+         glReadPixels(xpos + width - 1, ypos + 2, 2, 1, GL_RGBA, GL_FLOAT, rgba2);
+         if (rgba1[0][0] == 0.0 && rgba1[1][0] == 1.0 &&
+             rgba2[0][0] == 1.0 && rgba2[1][0] == 0.0) {
+            if (x < xmin)
+               xmin = x;
+            if (x > xmax)
+               xmax = x;
+         }
+
+         /* vertical measurement */
+         glReadPixels(xpos + 2, ypos - 1, 1, 2, GL_RGBA, GL_FLOAT, rgba1);
+         glReadPixels(xpos + 2, ypos + height - 1, 1, 2, GL_RGBA, GL_FLOAT, rgba2);
+         if (rgba1[0][0] == 0.0 && rgba1[1][0] == 1.0 &&
+             rgba2[0][0] == 1.0 && rgba2[1][0] == 0.0) {
+            if (y < ymin)
+               ymin = y;
+            if (y > ymax)
+               ymax = y;
+         }
+      }
+   }
+
+   printf("Quad at (%2d, %2d)..(%2d, %2d) drawn"
+          " for x in [%6.3f, %6.3f] and y in [%6.3f, %6.3f]\n",
+          xpos, ypos,
+          xpos + width, ypos + height,
+          xpos + xmin, xpos + xmax,
+          ypos + ymin, ypos + ymax);
+
+   if (xmax - xmin != 1.0 - Step) {
+      printf("  => Inconsistant X-axis rasterization/size!\n");
+   }
+   if (ymax - ymin != 1.0 - Step) {
+      printf("  => Inconsistant Y-axis rasterization/size!\n");
+   }
+
+   if (xmin < -0.5) {
+      printf("  => Coords should be X biased by about %f\n", 0.5 + xmin );
+   }
+   if (ymin < -0.5) {
+      printf("  => Coords should be Y biased by about %f\n", 0.5 + ymin);
+   }
+   if (xmax > 0.5) {
+      printf("  => Coords should be X biased by about %f\n", -xmax + 0.5);
+   }
+   if (ymax > 0.5) {
+      printf("  => Coords should be Y biased by about %f\n", -ymax + 0.5);
+   }
+}
+
+
+/**
+ * Misc/disabled code for debugging.
+ */
+static void
+DebugTest(void)
+{
+   glClear(GL_COLOR_BUFFER_BIT);
+   glEnable(GL_BLEND);
+   glBlendFunc(GL_ONE, GL_ONE);
+
+   glColor3f(.5, .5, .5);
+
+   glBegin(GL_LINES);
+   glVertex2f(30, 35.5);
+   glVertex2f(54, 35.5);
+   glVertex2f(54, 35.5);
+   glVertex2f(66, 35.5);
+   glEnd();
+
+   glDisable(GL_BLEND);
+   glColor3f(1,1,1);
+}
+
+
+static void
+Draw(void)
+{
+   glClear(GL_COLOR_BUFFER_BIT);
+
+   glPushMatrix();
+   glTranslatef(Xtrans, Ytrans, 0);
+
+   PointCalibrate(1, 1);
+   PointCalibrate(50, 50);
+   PointCalibrate(28, 17);
+   PointCalibrate(17, 18);
+   printf("\n");
+
+   HLineCalibrate(5, 10, 10);
+   HLineCalibrate(25, 22, 12);
+   HLineCalibrate(54, 33, 12);
+   HLineCalibrate(54+12, 33, 12);
+   printf("\n");
+
+   QuadCalibrate(2, 2, 10, 10);
+   QuadCalibrate(50, 50, 10, 10);
+   QuadCalibrate(28, 17, 12, 12);
+   QuadCalibrate(17, 28, 12, 12);
+
+   (void) DebugTest;
+
+   glPopMatrix();
+
+   glutSwapBuffers();
+}
+
+
+static void
+Reshape(int width, int height)
+{
+   Width = width;
+   Height = height;
+   glViewport(0, 0, width, height);
+   glMatrixMode(GL_PROJECTION);
+   glLoadIdentity();
+   glOrtho(0, width, 0, height, -1, 1);
+   glMatrixMode(GL_MODELVIEW);
+   glLoadIdentity();
+}
+
+
+static void
+Key(unsigned char key, int x, int y)
+{
+   (void) x;
+   (void) y;
+   switch (key) {
+   case 27:
+      glutDestroyWindow(Win);
+      exit(0);
+      break;
+   }
+   glutPostRedisplay();
+}
+
+
+static void
+Init(void)
+{
+   printf("Measurement/callibration for basic prim rasterization...\n");
+   printf("GL_RENDERER: %s\n", (char*) glGetString(GL_RENDERER));
+}
+
+
+int
+main(int argc, char *argv[])
+{
+   glutInit(&argc, argv);
+   glutInitWindowPosition(0, 0);
+   glutInitWindowSize(Width, Height);
+   glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
+   Win = glutCreateWindow(argv[0]);
+   glutReshapeFunc(Reshape);
+   glutKeyboardFunc(Key);
+   glutDisplayFunc(Draw);
+   Init();
+   glutMainLoop();
+   return 0;
+}