Commit d62c5606 authored by Nicolai Hähnle's avatar Nicolai Hähnle
Browse files

New test: texturing/tex3d

This is a very basic test that creates 3D textures of varying sizes,
renders them and compares the results with expected results.

It's still quite incomplete, e.g. a test for TexSubImage and mipmapped
textures is still missing.
parent 4534ddc2
......@@ -87,6 +87,7 @@ texturing = Group()
texturing['copytexsubimage'] = PlainExecTest([testBinDir + 'copytexsubimage', '-auto'])
texturing['cubemap'] = PlainExecTest([testBinDir + 'cubemap', '-auto'])
texturing['lodbias'] = PlainExecTest([testBinDir + 'lodbias', '-auto'])
texturing['tex3d'] = PlainExecTest([testBinDir + 'tex3d'])
texturing['texdepth'] = PlainExecTest([testBinDir + 'texdepth', '-auto'])
texturing['texrect-many'] = PlainExecTest([testBinDir + 'texrect-many', '-auto'])
texturing['texredefine'] = PlainExecTest([testBinDir + 'texredefine', '-auto'])
......
......@@ -21,6 +21,7 @@ link_libraries (
add_executable (copytexsubimage copytexsubimage.c)
add_executable (cubemap cubemap.c)
add_executable (lodbias lodbias.c)
add_executable (tex3d tex3d.c)
add_executable (texdepth texdepth.c)
add_executable (texrect-many texrect-many.c)
add_executable (texredefine texredefine.c)
/*
* Copyright (c) The Piglit project 2008
*
* 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
* on the rights to use, copy, modify, merge, publish, distribute, sub
* license, 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 NON-INFRINGEMENT. IN NO EVENT SHALL
* VA LINUX SYSTEM, IBM AND/OR THEIR SUPPLIERS 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.
*/
/**
* @file
* Tests 3D textures.
*/
#include <assert.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <GL/glut.h>
#include "piglit-util.h"
static int Width = 128, Height = 128;
static GLuint Texture;
static int nrcomponents(GLenum format)
{
switch(format) {
case GL_RGBA: return 4;
case GL_RGB: return 3;
case GL_ALPHA: return 1;
default: abort();
}
}
static const char* formatname(GLenum format)
{
switch(format) {
case GL_RGBA: return "GL_RGBA";
case GL_RGB: return "GL_RGB";
case GL_ALPHA: return "GL_ALPHA";
default: abort();
}
}
static void expected_rgba(GLenum format, const unsigned char* texdata, unsigned char* expected)
{
switch(format) {
case GL_RGBA:
expected[0] = texdata[0];
expected[1] = texdata[1];
expected[2] = texdata[2];
expected[3] = texdata[3];
return;
case GL_RGB:
expected[0] = texdata[0];
expected[1] = texdata[1];
expected[2] = texdata[2];
expected[3] = 255;
return;
case GL_ALPHA:
expected[0] = 255;
expected[1] = 255;
expected[2] = 255;
expected[3] = texdata[0];
return;
}
}
static int render_and_check(int w, int h, int d, GLenum format, float q, unsigned char* data, const char* test)
{
int x, y, z;
int layer;
unsigned char* readback;
unsigned char* texp;
unsigned char* readp;
int ncomp;
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
glEnable(GL_TEXTURE_3D);
x = y = 0;
for(layer = 0; layer < d; ++layer) {
float r = (layer+0.5)/d;
glBegin(GL_QUADS);
glTexCoord4f(0, 0, r*q, q);
glVertex2f(x, y);
glTexCoord4f(q, 0, r*q, q);
glVertex2f(x+w, y);
glTexCoord4f(q, q, r*q, q);
glVertex2f(x+w, y+h);
glTexCoord4f(0, q, r*q, q);
glVertex2f(x, y+h);
glEnd();
x += w;
if (x >= Width) {
y += h;
x = 0;
}
}
glutSwapBuffers();
readback = (unsigned char*)malloc(w*h*d*4);
x = y = 0;
for(layer = 0; layer < d; ++layer) {
glReadPixels(x, y, w, h, GL_RGBA, GL_UNSIGNED_BYTE, readback+layer*w*h*4);
x += w;
if (x >= Width) {
y += h;
x = 0;
}
}
texp = data;
readp = readback;
ncomp = nrcomponents(format);
for(z = 0; z < d; ++z) {
for(y = 0; y < h; ++y) {
for(x = 0; x < w; ++x, readp += 4, texp += ncomp) {
unsigned char expected[4];
int i;
expected_rgba(format, texp, expected);
for(i = 0; i < 4; ++i) {
if (expected[i] != readp[i]) {
fprintf(stderr, "%s: Mismatch at %ix%ix%i\n", test, x, y, z);
fprintf(stderr, " Expected: %i,%i,%i,%i\n",
expected[0], expected[1], expected[2], expected[3]);
fprintf(stderr, " Readback: %i,%i,%i,%i\n",
readp[0], readp[1], readp[2], readp[3]);
free(readback);
return 0;
}
}
}
}
}
free(readback);
return 1;
}
/**
* Load non-mipmapped 3D texture of the given size
* and check whether it is rendered correctly.
*/
static void test_simple(int w, int h, int d, GLenum format)
{
int size;
unsigned char *data;
int i;
int success = 1;
assert(1 <= w && w <= 16);
assert(1 <= h && h <= 16);
assert(1 <= d && d <= 16);
assert(format == GL_RGBA || format == GL_RGB || format == GL_ALPHA);
size = w*h*d*nrcomponents(format);
data = (unsigned char*)malloc(size);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
srand(size); /* Generate reproducible image data */
for(i = 0; i < size; ++i)
data[i] = rand() & 255;
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage3D(GL_TEXTURE_3D, 0, format, w, h, d, 0, format, GL_UNSIGNED_BYTE, data);
success = success && render_and_check(w, h, d, format, 1.0, data, "Render 3D texture");
success = success && render_and_check(w, h, d, format, 1.4, data, "Render 3D texture (q != 1.0)");
free(data);
if (!success) {
fprintf(stderr, "Failure with texture size %ix%ix%i, format = %s\n",
w, h, d, formatname(format));
piglit_report_result(PIGLIT_FAILURE);
}
}
static void Redisplay(void)
{
GLenum formats[] = { GL_RGBA, GL_RGB, GL_ALPHA };
int w, h, d, fmt;
for(fmt = 0; fmt < sizeof(formats)/sizeof(formats[0]); ++fmt) {
for(w = 1; w <= 16; w *= 2) {
for(h = 1; h <= 16; h *= 2) {
for(d = 1; d <= 16; d *= 2) {
test_simple(w, h, d, formats[fmt]);
}
}
}
}
piglit_report_result(PIGLIT_SUCCESS);
}
static void Reshape(int width, int height)
{
glViewport(0, 0, Width, Height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0, Width, 0.0, Height, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
static void Init(void)
{
glGenTextures(1, &Texture);
glBindTexture(GL_TEXTURE_3D, Texture);
Reshape(Width,Height);
}
int main(int argc, char *argv[])
{
int i;
glutInit(&argc, argv);
glutInitWindowPosition(0, 0);
glutInitWindowSize(Width, Height);
glutInitDisplayMode(GLUT_RGB | GLUT_ALPHA);
glutCreateWindow(argv[0]);
glutReshapeFunc(Reshape);
glutDisplayFunc(Redisplay);
Init();
glutMainLoop();
return 0;
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment