texture-packed-formats: test packed texture formats

Adapted from mesa-demos/tests/packedpixels.c

3 files changed, 421 insertions, 0 deletions

diff --git a/tests/all.tests b/tests/all.tests
index 12b236f9..2364017f 100644
--- a/tests/all.tests
+++ b/tests/all.tests
@@ -600,6 +600,7 @@ add_plain_test(texturing, 'texrect-many')
 add_plain_test(texturing, 'texredefine')
 add_plain_test(texturing, 'texture-al')
 add_plain_test(texturing, 'texture-integer')
+add_plain_test(texturing, 'texture-packed-formats')
 add_plain_test(texturing, 'texture-rg')
 add_plain_test(texturing, 'tex-srgb')
 
diff --git a/tests/texturing/CMakeLists.gl.txt b/tests/texturing/CMakeLists.gl.txt
index cb4a83ad..360c1c86 100644
--- a/tests/texturing/CMakeLists.gl.txt
+++ b/tests/texturing/CMakeLists.gl.txt
@@ -55,6 +55,7 @@ add_executable (texdepth texdepth.c)
 add_executable (teximage-errors teximage-errors.c)
 add_executable (texrect-many texrect-many.c)
 add_executable (texredefine texredefine.c)
+add_executable (texture-packed-formats texture-packed-formats.c)
 add_executable (texture-integer texture-integer.c)
 add_executable (depth-tex-modes      depth-tex-modes.c depth-tex-modes-common.c)
 add_executable (depth-tex-modes-rg   depth-tex-modes-rg.c depth-tex-modes-common.c)
diff --git a/tests/texturing/texture-packed-formats.c b/tests/texturing/texture-packed-formats.c
new file mode 100644
index 00000000..46c9d127
--- /dev/null
+++ b/tests/texturing/texture-packed-formats.c
@@ -0,0 +1,419 @@
+/*
+ * Copyright (c) 2004 Brian Paul
+ * Copyright (c) 2011 VMware, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+/*
+ * Test packed pixel formats for textures.  Try a bunch of combinations
+ * of various internal texture formats with combinations of packed user
+ * formats/types.  Also test glPixelStore byte swapping.
+ *
+ * Based on mesa-demos/tests/packedpixels.c.
+ * Brian Paul
+ * June 2011
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#include "piglit-util.h"
+
+int piglit_width = 700;
+int piglit_height = 620;
+int piglit_window_mode = GLUT_RGB | GLUT_DOUBLE;
+
+static GLboolean PrintInfo = GL_TRUE;
+
+
+struct pixel_format {
+   const char *name;
+   GLenum format;
+   GLenum type;
+   GLint bytes;
+   GLuint redTexel, greenTexel; /* with approx 51% alpha, when applicable */
+};
+
+static const struct pixel_format Formats[] = {
+
+   { "GL_RGBA/GL_UNSIGNED_INT_8_8_8_8",
+     GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, 4, 0xff000080, 0x00ff0080 },
+   { "GL_RGBA/GL_UNSIGNED_INT_8_8_8_8_REV",
+     GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, 4, 0x800000ff, 0x8000ff00 },
+   { "GL_RGBA/GL_UNSIGNED_INT_10_10_10_2",
+     GL_RGBA, GL_UNSIGNED_INT_10_10_10_2, 4, 0xffc00002, 0x3ff002 },
+   { "GL_RGBA/GL_UNSIGNED_INT_2_10_10_10_REV",
+     GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, 4, 0xc00003ff, 0xc00ffc00 },
+   { "GL_RGBA/GL_UNSIGNED_SHORT_4_4_4_4",
+     GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, 2, 0xf008, 0x0f08 },
+   { "GL_RGBA/GL_UNSIGNED_SHORT_4_4_4_4_REV",
+     GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4_REV, 2, 0x800f, 0x80f0 },
+   { "GL_RGBA/GL_UNSIGNED_SHORT_5_5_5_1",
+     GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, 2, 0xf801, 0x7c1 },
+   { "GL_RGBA/GL_UNSIGNED_SHORT_1_5_5_5_REV",
+     GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV, 2, 0x801f, 0x83e0 },
+
+   { "GL_BGRA/GL_UNSIGNED_INT_8_8_8_8",
+     GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, 4, 0x0000ff80, 0x00ff0080 },
+   { "GL_BGRA/GL_UNSIGNED_INT_8_8_8_8_REV",
+     GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, 4, 0x80ff0000, 0x8000ff00 },
+   { "GL_BGRA/GL_UNSIGNED_SHORT_4_4_4_4",
+     GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4, 2, 0x00f8, 0x0f08 },
+   { "GL_BGRA/GL_UNSIGNED_SHORT_4_4_4_4_REV",
+     GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4_REV, 2, 0x8f00, 0x80f0 },
+   { "GL_BGRA/GL_UNSIGNED_SHORT_5_5_5_1",
+     GL_BGRA, GL_UNSIGNED_SHORT_5_5_5_1, 2, 0x3f, 0x7c1 },
+   { "GL_BGRA/GL_UNSIGNED_SHORT_1_5_5_5_REV",
+     GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV, 2, 0xfc00, 0x83e0 },
+
+   { "GL_ABGR_EXT/GL_UNSIGNED_INT_8_8_8_8",
+     GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8, 4, 0x800000ff, 0x8000ff00 },
+   { "GL_ABGR_EXT/GL_UNSIGNED_INT_8_8_8_8_REV",
+     GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8_REV, 4, 0xff000080, 0x00ff0080 },
+   { "GL_ABGR_EXT/GL_UNSIGNED_SHORT_4_4_4_4",
+     GL_ABGR_EXT, GL_UNSIGNED_SHORT_4_4_4_4, 2, 0x800f, 0x80f0 },
+   { "GL_ABGR_EXT/GL_UNSIGNED_SHORT_4_4_4_4_REV",
+     GL_ABGR_EXT, GL_UNSIGNED_SHORT_4_4_4_4_REV, 2, 0xf008, 0x0f08 },
+   { "GL_ABGR_EXT/GL_UNSIGNED_SHORT_5_5_5_1",
+     GL_ABGR_EXT, GL_UNSIGNED_SHORT_5_5_5_1, 2, 0xf801, 0xf83e },
+   { "GL_ABGR_EXT/GL_UNSIGNED_SHORT_1_5_5_5_REV",
+     GL_ABGR_EXT, GL_UNSIGNED_SHORT_1_5_5_5_REV, 2, 0x800f, 0x7c0f },
+
+   { "GL_RGB/GL_UNSIGNED_SHORT_5_6_5",
+     GL_RGB, GL_UNSIGNED_SHORT_5_6_5, 2, 0xf800, 0x7e0 },
+   { "GL_RGB/GL_UNSIGNED_SHORT_5_6_5_REV",
+     GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV, 2, 0x1f, 0x7e0 },
+   { "GL_RGB/GL_UNSIGNED_BYTE_3_3_2",
+     GL_RGB, GL_UNSIGNED_BYTE_3_3_2, 1, 0xe0, 0x1c },
+   { "GL_RGB/GL_UNSIGNED_BYTE_2_3_3_REV",
+     GL_RGB, GL_UNSIGNED_BYTE_2_3_3_REV, 1, 0x7, 0x38 }
+};
+
+#define NUM_FORMATS (sizeof(Formats) / sizeof(Formats[0]))
+
+struct name_format {
+   const char *name;
+   GLenum format;
+};
+
+static const struct name_format IntFormats[] = {
+   { "GL_RGBA", GL_RGBA },
+   { "GL_RGBA2", GL_RGBA2 },
+   { "GL_RGBA4", GL_RGBA4 },
+   { "GL_RGB5_A1", GL_RGB5_A1 },
+   { "GL_RGBA8", GL_RGBA8 },
+   { "GL_RGBA12", GL_RGBA12 },
+   { "GL_RGBA16", GL_RGBA16 },
+   { "GL_RGB10_A2", GL_RGB10_A2 },
+
+   { "GL_RGB", GL_RGB },
+   { "GL_R3_G3_B2", GL_R3_G3_B2 },
+   { "GL_RGB4", GL_RGB4 },
+   { "GL_RGB5", GL_RGB5 },
+   { "GL_RGB8", GL_RGB8 },
+   { "GL_RGB10", GL_RGB10 },
+   { "GL_RGB12", GL_RGB12 },
+   { "GL_RGB16", GL_RGB16 },
+
+};
+
+#define NUM_INT_FORMATS (sizeof(IntFormats) / sizeof(IntFormats[0]))
+
+static GLboolean Blend = GL_FALSE;  /* XXX not used at this time */
+
+
+static void
+PrintString(const char *s)
+{
+   while (*s) {
+      glutBitmapCharacter(GLUT_BITMAP_8_BY_13, (int) *s);
+      s++;
+   }
+}
+
+
+static void
+MakeTexture(GLuint dims, const struct pixel_format *format,
+            GLenum intFormat, GLboolean swap)
+{
+   GLubyte texBuffer[1000];
+   int i;
+
+   assert(dims == 2 || dims == 3);
+
+   glPixelStorei(GL_UNPACK_SWAP_BYTES, swap);
+
+   if (format->bytes == 1) {
+      for (i = 0; i < 8; i++) {
+         texBuffer[i] = format->redTexel;
+      }
+      for (i = 8; i < 16; i++) {
+         texBuffer[i] = format->greenTexel;
+      }
+   }
+   else if (format->bytes == 2) {
+      GLushort *us = (GLushort *) texBuffer;
+      for (i = 0; i < 8; i++) {
+         us[i] = format->redTexel;
+      }
+      for (i = 8; i < 16; i++) {
+         us[i] = format->greenTexel;
+      }
+      if (swap) {
+         for (i = 0; i < 16; i++)
+            us[i] = (us[i] << 8) | (us[i] >> 8);
+      }
+   }
+   else if (format->bytes == 4) {
+      GLuint *ui = (GLuint *) texBuffer;
+      for (i = 0; i < 8; i++) {
+         ui[i] = format->redTexel;
+      }
+      for (i = 8; i < 16; i++) {
+         ui[i] = format->greenTexel;
+      }
+      if (swap) {
+         for (i = 0; i < 16; i++) {
+            GLuint b = ui[i];
+            ui[i] =  (b >> 24)
+                  | ((b >> 8) & 0xff00)
+                  | ((b << 8) & 0xff0000)
+                  | ((b << 24) & 0xff000000);
+         }
+      }
+   }
+   else {
+      abort();
+   }
+
+   if (dims == 3) {
+      /* 4 x 4 x 4 texture, undefined data */
+      glTexImage3D(GL_TEXTURE_3D, 0, intFormat, 4, 4, 4, 0,
+                   format->format, format->type, NULL);
+      /* fill in Z=1 and Z=2 slices with the real texture data */
+      glTexSubImage3D(GL_TEXTURE_3D, 0,
+                      0, 0, 1,  /* offset */
+                      4, 4, 1,  /* size */
+                      format->format, format->type, texBuffer);
+      glTexSubImage3D(GL_TEXTURE_3D, 0,
+                      0, 0, 2,  /* offset */
+                      4, 4, 1,  /* size */
+                      format->format, format->type, texBuffer);
+   }
+   else {
+      glTexImage2D(GL_TEXTURE_2D, 0, intFormat, 4, 4, 0,
+                   format->format, format->type, texBuffer);
+   }
+
+   if (0) {
+      GLint r, g, b, a, l, i;
+      glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_RED_SIZE, &r);
+      glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_GREEN_SIZE, &g);
+      glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_BLUE_SIZE, &b);
+      glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_ALPHA_SIZE, &a);
+      glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_LUMINANCE_SIZE, &l);
+      glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTENSITY_SIZE, &i);
+      printf("IntFormat: 0x%x  R %d  G %d  B %d  A %d  L %d  I %d\n",
+             intFormat, r, g, b, a, l, i);
+      glGetError();
+   }                              
+}
+
+
+static void
+Reshape(int width, int height)
+{
+   glViewport(0, 0, width, height);
+   glMatrixMode(GL_PROJECTION);
+   glLoadIdentity();
+   glOrtho(0, width, 0, height, -1, 1);
+   glMatrixMode(GL_MODELVIEW);
+   glLoadIdentity();
+}
+
+
+/**
+ * Test a particular internal texture format.  2D or 3D texture.
+ */
+static GLboolean
+Test(GLuint intFmt, GLuint dims)
+{
+   static const float red[4] = {1, 0, 0, 1};
+   static const float green[4] = {0, 1, 0, 1};
+   char s[1000];
+   int w = 350, h = 20;
+   int i, swap;
+   GLboolean pass = GL_TRUE;
+
+   Reshape(piglit_width, piglit_height);
+
+   glClear(GL_COLOR_BUFFER_BIT);
+
+   /* Loop over byteswapping */
+   for (swap = 0; swap < 2; swap++) {
+      /* Loop over texture formats */
+      for (i = 0; i < NUM_FORMATS; i++) {
+         int x = swap * (w + 2);
+         int y = i * (h + 2);
+
+         glPushMatrix();
+         glTranslatef(x, y, 0);
+
+         MakeTexture(dims, Formats + i, IntFormats[intFmt].format, swap);
+
+         if (glGetError()) {
+            printf("Unexpected GL Error for %s\n", IntFormats[intFmt].name);
+            return GL_FALSE;
+         }
+
+         if (dims == 3)
+            glEnable(GL_TEXTURE_3D);
+         else
+            glEnable(GL_TEXTURE_2D);
+
+         if (Blend)
+            glEnable(GL_BLEND);
+
+         glBegin(GL_POLYGON);
+         glTexCoord3f(0, 0, 0.5);  glVertex2f(0, 0);
+         glTexCoord3f(1, 0, 0.5);  glVertex2f(w, 0);
+         glTexCoord3f(1, 1, 0.5);  glVertex2f(w, h);
+         glTexCoord3f(0, 1, 0.5);  glVertex2f(0, h);
+         glEnd();
+
+         if (dims == 3)
+            glDisable(GL_TEXTURE_3D);
+         else
+            glDisable(GL_TEXTURE_2D);
+
+         glDisable(GL_BLEND);
+
+         if (PrintInfo) {
+            glColor3f(0, 0, 0);
+            glRasterPos2i(8, 6);
+            PrintString(Formats[i].name);
+         }
+
+         glPopMatrix();
+
+         /* test rendering */
+         if (!piglit_probe_pixel_rgb(x+2, y+2, red)) {
+            printf("Failure for format=%s, swap=%u, textureDims=%u\n",
+                   Formats[i].name, swap, dims);
+            pass = GL_FALSE;
+         }
+
+         if (!piglit_probe_pixel_rgb(x+2, y+12, green)) {
+            printf("Failure for format=%s, swap=%u, textureDims=%u\n",
+                   Formats[i].name, swap, dims);
+            pass = GL_FALSE;
+         }
+      }
+   }
+
+   if (PrintInfo) {
+      i = NUM_FORMATS;
+      glPushMatrix();
+      glTranslatef(2, i * (h + 2), 0);
+      glColor3f(1, 1, 1);
+      glRasterPos2i(8, 6);
+      PrintString("Normal");
+      glRasterPos2i(w + 2, 6);
+      PrintString("Byte Swapped");
+      glPopMatrix();
+
+      glPushMatrix();
+      glTranslatef(2, (i + 1) * (h + 2), 0);
+      glRasterPos2i(8, 6);
+      sprintf(s, "Internal Texture Format: %s (%d of %u)",
+              IntFormats[intFmt].name, intFmt + 1,
+              (unsigned) NUM_INT_FORMATS);
+      PrintString(s);
+      glPopMatrix();
+
+      glPushMatrix();
+      glTranslatef(2, (i + 2) * (h + 2), 0);
+      glRasterPos2i(8, 6);
+      if (dims == 3)
+         PrintString("Target: GL_TEXTURE_3D");
+      else
+         PrintString("Target: GL_TEXTURE_2D");
+      glPopMatrix();
+
+      glPushMatrix();
+      glTranslatef(2, (i + 3) * (h + 2), 0);
+      glRasterPos2i(8, 6);
+      if (Blend)
+         PrintString("Blend: Yes");
+      else
+         PrintString("Blend: No");
+      glPopMatrix();
+   }
+
+   glutSwapBuffers();
+
+   return pass;
+}
+
+
+enum piglit_result
+piglit_display(void)
+{
+   GLboolean pass = 1;
+   int i;
+
+   /* 2D texture */
+   for (i = 0; i < NUM_INT_FORMATS; i++) {
+      pass = Test(i, 2) && pass;
+      if (!pass && !piglit_automatic)
+         break;
+   }
+
+   /* 3D texture */
+   for (i = 0; i < NUM_INT_FORMATS; i++) {
+      pass = Test(i, 3) && pass;
+      if (!pass && !piglit_automatic)
+         break;
+   }
+
+   return pass ? PIGLIT_PASS : PIGLIT_FAIL;
+}
+
+
+void
+piglit_init(int argc, char **argv)
+{
+   if (0) {
+      printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
+      printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION));
+   }
+   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+   glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+   glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+   glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+   PrintInfo = !piglit_automatic;
+}
+