[Piglit] [PATCH 6/6] Remove Glean arb_vertex_program test.
Fabian Bieler
fabianbieler at fastmail.fm
Sat Dec 2 20:49:20 UTC 2017
---
tests/all.py | 46 +-
tests/glean/CMakeLists.gl.txt | 1 -
tests/glean/tvertprog1.cpp | 1115 -----------------------------------------
tests/glean/tvertprog1.h | 88 ----
4 files changed, 1 insertion(+), 1249 deletions(-)
delete mode 100644 tests/glean/tvertprog1.cpp
delete mode 100644 tests/glean/tvertprog1.h
diff --git a/tests/all.py b/tests/all.py
index 5301146..1da676b 100644
--- a/tests/all.py
+++ b/tests/all.py
@@ -440,51 +440,7 @@ glean_fp_tests = ['ABS test',
'ARB_fog_exp2 test',
'Computed fog exp2 test']
-glean_vp_tests = ['ABS test',
- 'ADD test',
- 'ARL test',
- 'DP3 test',
- 'DP4 test',
- 'DPH test',
- 'DST test',
- 'EX2 test',
- 'EXP test',
- 'FLR test',
- 'FRC test',
- 'LG2 test',
- 'LIT test 1',
- 'LIT test 2 (degenerate case: 0 ^ 0 -> 1)',
- 'LIT test 3 (case x < 0)',
- 'LOG test',
- 'MAD test',
- 'MAX test',
- 'MIN test',
- 'MOV test (with swizzle)',
- 'MUL test (with swizzle and masking)',
- 'POW test (exponentiation)',
- 'RCP test (reciprocal)',
- 'RSQ test 1 (reciprocal square root)',
- 'RSQ test 2 (reciprocal square root of negative value)',
- 'SGE test',
- 'SLT test',
- 'SUB test (with swizzle)',
- 'SWZ test 1',
- 'SWZ test 2',
- 'SWZ test 3',
- 'SWZ test 4',
- 'SWZ test 5',
- 'XPD test 1',
- 'XPD test 2 (same src and dst arg)',
- 'Position write test (compute position from texcoord)',
- 'Z-write test',
- 'State reference test 1 (material ambient)',
- 'State reference test 2 (light products)',
- 'State reference test 3 (fog params)',
- 'Divide by zero test',
- 'Infinity and nan test']
-
-for pairs in [(['fragProg1'], glean_fp_tests),
- (['vertProg1'], glean_vp_tests)]:
+for pairs in [(['fragProg1'], glean_fp_tests)]:
for prefix, name in itertools.product(*pairs):
groupname = grouptools.join('glean', '{0}-{1}'.format(prefix, name))
profile.test_list[groupname] = GleanTest(prefix)
diff --git a/tests/glean/CMakeLists.gl.txt b/tests/glean/CMakeLists.gl.txt
index 2ede8ed..9250dfe 100644
--- a/tests/glean/CMakeLists.gl.txt
+++ b/tests/glean/CMakeLists.gl.txt
@@ -39,7 +39,6 @@ piglit_add_executable (glean
ttexture_srgb.cpp
tvertarraybgra.cpp
tvertattrib.cpp
- tvertprog1.cpp
winsys.cpp
gl.cpp
image_misc.cpp
diff --git a/tests/glean/tvertprog1.cpp b/tests/glean/tvertprog1.cpp
deleted file mode 100644
index 68ad828..0000000
--- a/tests/glean/tvertprog1.cpp
+++ /dev/null
@@ -1,1115 +0,0 @@
-// BEGIN_COPYRIGHT -*- glean -*-
-//
-// Copyright (C) 1999 Allen Akin All Rights Reserved.
-//
-// 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 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 ALLEN AKIN 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.
-//
-// END_COPYRIGHT
-
-// tvertprog1.cpp: Test GL_ARB_vertex_program extension.
-// Brian Paul 22 October 2005
-//
-// See tfragprog.cpp for comments (this test is very similar).
-
-#include <cstdlib>
-#include <cassert>
-#include <cmath>
-#include <cstring>
-#include <math.h>
-#include "tvertprog1.h"
-
-
-namespace GLEAN {
-
-static GLuint progID;
-
-
-// Clamp X to [0, 1]
-#define CLAMP01( X ) ( (X)<(0.0) ? (0.0) : ((X)>(1.0) ? (1.0) : (X)) )
-// Absolute value
-#define ABS(X) ( (X) < 0.0 ? -(X) : (X) )
-// Max
-#define MAX( A, B ) ( (A) > (B) ? (A) : (B) )
-// Min
-#define MIN( A, B ) ( (A) < (B) ? (A) : (B) )
-// Duplicate value four times
-#define SMEAR(X) (X), (X), (X), (X)
-
-#define DONT_CARE_Z -1.0
-#define DONT_CARE_COLOR -1.0
-
-#define VERTCOLOR { 0.25, 0.75, 0.5, 0.25 }
-#define PARAM0 { 0.0, 0.0, 0.0, 0.0 } // all zero
-#define PARAM1 { 0.5, 0.25, 0.9, 0.5 } // in [0,1]
-#define PARAM2 { -1.0, 0.0, 0.25, -0.5 } // in [-1,1]
-#define AMBIENT { 0.2, 0.4, 0.6, 0.8 }
-#define DIFFUSE { 0.1, 0.3, 0.5, 0.7 }
-static const GLfloat VertColor[4] = VERTCOLOR;
-static const GLfloat Param0[4] = PARAM0;
-static const GLfloat Param1[4] = PARAM1;
-static const GLfloat Param2[4] = PARAM2;
-static const GLfloat Ambient[4] = AMBIENT;
-static const GLfloat Diffuse[4] = DIFFUSE;
-static const GLfloat FogDensity = 0.5;
-static const GLfloat FogStart = 0.2;
-static const GLfloat FogEnd = 0.9;
-static GLfloat InfNan[4];
-
-
-// These are the specific vertex programs which we'll test.
-// Alphabetical order, please.
-static const VertexProgram Programs[] = {
- // ============= Basic instructions tests =============================
- {
- "ABS test",
- "!!ARBvp1.0\n"
- "PARAM p2 = program.local[2]; \n"
- "MOV result.position, vertex.position; \n"
- "ABS result.color, p2; \n"
- "END \n",
- { CLAMP01(ABS(Param2[0])),
- CLAMP01(ABS(Param2[1])),
- CLAMP01(ABS(Param2[2])),
- CLAMP01(ABS(Param2[3])),
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "ADD test",
- "!!ARBvp1.0\n"
- "PARAM p = program.local[1]; \n"
- "MOV result.position, vertex.position; \n"
- "ADD result.color, vertex.color, p; \n"
- "END \n",
- { CLAMP01(VertColor[0] + Param1[0]),
- CLAMP01(VertColor[1] + Param1[1]),
- CLAMP01(VertColor[2] + Param1[2]),
- CLAMP01(VertColor[3] + Param1[3])
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "ARL test",
- "!!ARBvp1.0\n"
- "ADDRESS addr; \n"
- "PARAM indexes = {-1, 0, 1, 2}; \n"
- "PARAM myArray[4] = {{0.11, 0.12, 0.13, 0.14}, \n"
- " {0.21, 0.22, 0.23, 0.24}, \n"
- " {0.31, 0.32, 0.33, 0.34}, \n"
- " {0.41, 0.42, 0.43, 0.44}}; \n"
- "MOV result.position, vertex.position; \n"
- ""
- "# Load ARL with -1, get array[0].x \n"
- "ARL addr.x, indexes.x; \n"
- "MOV result.color.x, myArray[addr.x + 1]; \n"
- ""
- "# Load ARL with 0, get array[1].y \n"
- "ARL addr.x, indexes.y; \n"
- "MOV result.color.y, myArray[addr.x + 1]; \n"
- ""
- "# Load ARL with 1, get array[2].z \n"
- "ARL addr.x, indexes.z; \n"
- "MOV result.color.z, myArray[addr.x + 1]; \n"
- ""
- "# Load ARL with 2, get array[3].w\n"
- "ARL addr.x, indexes.w; \n"
- "MOV result.color.w, myArray[addr.x + 1]; \n"
- "END \n",
- { 0.11,
- 0.22,
- 0.33,
- 0.44
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "DP3 test",
- "!!ARBvp1.0\n"
- "PARAM p2 = program.local[2]; \n"
- "PARAM bias = { 0.5, 0.5, 0.5, 0.5 }; \n"
- "TEMP t; \n"
- "MOV result.position, vertex.position; \n"
- "DP3 t, p2, vertex.color; \n"
- "ADD result.color, t, bias; \n"
- "END \n",
- { SMEAR(Param2[0] * VertColor[0] +
- Param2[1] * VertColor[1] +
- Param2[2] * VertColor[2] + 0.5)
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "DP4 test",
- "!!ARBvp1.0\n"
- "PARAM p2 = program.local[2]; \n"
- "PARAM bias = { 0.5, 0.5, 0.5, 0.5 }; \n"
- "TEMP t; \n"
- "MOV result.position, vertex.position; \n"
- "DP4 t, p2, vertex.color; \n"
- "ADD result.color, t, bias; \n"
- "END \n",
- { SMEAR(Param2[0] * VertColor[0] +
- Param2[1] * VertColor[1] +
- Param2[2] * VertColor[2] +
- Param2[3] * VertColor[3] + 0.5)
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "DPH test",
- "!!ARBvp1.0\n"
- "PARAM p2 = program.local[2]; \n"
- "TEMP t; \n"
- "MOV result.position, vertex.position; \n"
- "DPH result.color, p2, vertex.color; \n"
- "END \n",
- { SMEAR(CLAMP01(Param2[0] * VertColor[0] +
- Param2[1] * VertColor[1] +
- Param2[2] * VertColor[2] +
- VertColor[3]))
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "DST test",
- "!!ARBvp1.0\n"
- "# let d = 0.4 \n"
- "PARAM v1 = {9.9, 0.16, 0.16, 9.9}; \n"
- "PARAM v2 = {9.9, 2.5, 9.9, 2.5}; \n"
- "MOV result.position, vertex.position; \n"
- "DST result.color, v1, v2; \n"
- "END \n",
- { 1.0,
- 0.4, // v1.y * v2.y
- 0.16, // v1.z
- CLAMP01(2.5) // v2.w
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "EX2 test",
- "!!ARBvp1.0\n"
- "PARAM scale = {0.01, 0.01, 0.01, 0.01}; \n"
- "PARAM values = {0.0, 1.0, 4.0, -2.0 }; \n"
- "TEMP t; \n"
- "MOV result.position, vertex.position; \n"
- "EX2 t.x, values.x; \n"
- "EX2 t.y, values.y; \n"
- "EX2 t.z, values.z; \n"
- "EX2 t.w, values.w; \n"
- "MUL result.color, t, scale; \n"
- "END \n",
- { 1.0 * 0.01,
- 2.0 * 0.01,
- 16.0 * 0.01,
- 0.25 * 0.01 },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "EXP test",
- "!!ARBvp1.0\n"
- "PARAM scale = {0.01, 0.01, 0.01, 0.01}; \n"
- "PARAM values = {4.5, 0, 0, 0}; \n"
- "TEMP t; \n"
- "MOV result.position, vertex.position; \n"
- "EXP t, values.x; \n"
- "MUL result.color, t, scale; \n"
- "END \n",
- { 16.0 * 0.01,
- 0.5 * 0.01,
- 22.627 * 0.01,
- 1.0 * 0.01 },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "FLR test",
- "!!ARBvp1.0\n"
- "PARAM values = {4.8, 0.3, -0.2, 1.2}; \n"
- "PARAM scale = {0.1, 0.1, 0.1, 0.1}; \n"
- "MOV result.position, vertex.position; \n"
- "TEMP t; \n"
- "FLR t, values; \n"
- "MUL result.color, t, scale; \n"
- "END \n",
- { 0.4,
- 0.0,
- CLAMP01(-0.1),
- 0.1
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "FRC test",
- "!!ARBvp1.0\n"
- "PARAM values = {1.344, -1.5, -10.1, 4.2}; \n"
- "MOV result.position, vertex.position; \n"
- "FRC result.color, values; \n"
- "END \n",
- { 0.344,
- 0.5,
- 0.9,
- 0.2
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "LG2 test",
- "!!ARBvp1.0\n"
- "PARAM values = {64.0, 1, 30, 4}; \n"
- "PARAM scale = {0.1, 0.1, 0.1, 0.1}; \n"
- "MOV result.position, vertex.position; \n"
- "TEMP t; \n"
- "LG2 t.x, values.x; \n"
- "LG2 t.y, values.y; \n"
- "LG2 t.z, values.z; \n"
- "LG2 t.w, values.w; \n"
- "MUL result.color, t, scale; \n"
- "END \n",
- { 0.6,
- 0.0,
- 0.49,
- 0.2
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "LIT test 1",
- "!!ARBvp1.0\n"
- "PARAM values = {0.65, 0.9, 0.0, 8.0}; \n"
- "MOV result.position, vertex.position; \n"
- "LIT result.color, values; \n"
- "END \n",
- { 1.0,
- 0.65, // values.x
- 0.430, // roughly Pow(values.y, values.w)
- 1.0
- },
- DONT_CARE_Z,
- FLAG_LOOSE
- },
- {
- "LIT test 2 (degenerate case: 0 ^ 0 -> 1)",
- "!!ARBvp1.0\n"
- "PARAM values = {0.65, 0.0, 0.0, 0.0}; \n"
- "MOV result.position, vertex.position; \n"
- "LIT result.color, values; \n"
- "END \n",
- { 1.0,
- 0.65, // values.x
- 1.0, // 0^0
- 1.0
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "LIT test 3 (case x < 0)",
- "!!ARBvp1.0\n"
- "PARAM values = {-0.5, 0.0, 0.0, 0.0}; \n"
- "MOV result.position, vertex.position; \n"
- "LIT result.color, values; \n"
- "END \n",
- { 1.0,
- CLAMP01(-0.5), // values.x
- 0.0,
- 1.0
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "LOG test",
- "!!ARBvp1.0\n"
- "PARAM values = {64.0, 50, 30, 4}; \n"
- "PARAM scale = {0.1, 0.1, 0.1, 0.1}; \n"
- "MOV result.position, vertex.position; \n"
- "TEMP t; \n"
- "LOG t.x, values.x; \n"
- "LOG t.y, values.y; \n"
- "LOG t.z, values.z; \n"
- "LOG t.w, values.w; \n"
- "MUL result.color, t, scale; \n"
- "END \n",
- { 0.6, // floor(log2(value.x))
- 0.15, // value.y / 2^(floor(log2(value.y)))
- 0.49, // roughApproxLog2(value.z)
- 0.1
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "MAD test",
- "!!ARBvp1.0\n"
- "PARAM p1 = program.local[1]; \n"
- "PARAM p2 = program.local[2]; \n"
- "MOV result.position, vertex.position; \n"
- "MAD result.color, vertex.color, p1, p2; \n"
- "END \n",
- { CLAMP01(VertColor[0] * Param1[0] + Param2[0]),
- CLAMP01(VertColor[1] * Param1[1] + Param2[1]),
- CLAMP01(VertColor[2] * Param1[2] + Param2[2]),
- CLAMP01(VertColor[3] * Param1[3] + Param2[3])
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "MAX test",
- "!!ARBvp1.0\n"
- "PARAM p1 = program.local[1]; \n"
- "PARAM p2 = program.local[2]; \n"
- "MOV result.position, vertex.position; \n"
- "MAX result.color, p1, p2; \n"
- "END \n",
- { MAX(Param1[0], Param2[0]),
- MAX(Param1[1], Param2[1]),
- MAX(Param1[2], Param2[2]),
- MAX(Param1[3], Param2[3]),
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "MIN test",
- "!!ARBvp1.0\n"
- "PARAM p1 = program.local[1]; \n"
- "MOV result.position, vertex.position; \n"
- "MIN result.color, p1, vertex.color; \n"
- "END \n",
- { MIN(Param1[0], VertColor[0]),
- MIN(Param1[1], VertColor[1]),
- MIN(Param1[2], VertColor[2]),
- MIN(Param1[3], VertColor[3]),
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "MOV test (with swizzle)",
- "!!ARBvp1.0\n"
- "MOV result.position, vertex.position; \n"
- "MOV result.color, vertex.color.wzxy; \n"
- "END \n",
- { VertColor[3],
- VertColor[2],
- VertColor[0],
- VertColor[1]
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "MUL test (with swizzle and masking)",
- "!!ARBvp1.0\n"
- "PARAM p1 = program.local[1]; \n"
- "MOV result.position, vertex.position; \n"
- "MUL result.color.xy, p1.wzww, vertex.color.wzww; \n"
- "MUL result.color.zw, p1.xxyx, vertex.color.xxyx; \n"
- "END \n",
- { CLAMP01(Param1[3] * VertColor[3]),
- CLAMP01(Param1[2] * VertColor[2]),
- CLAMP01(Param1[1] * VertColor[1]),
- CLAMP01(Param1[0] * VertColor[0]),
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "POW test (exponentiation)",
- "!!ARBvp1.0\n"
- "PARAM values = {0.5, 2, 3, 4}; \n"
- "MOV result.position, vertex.position; \n"
- "POW result.color.x, values.x, values.y; \n"
- "POW result.color.y, values.x, values.z; \n"
- "POW result.color.z, values.x, values.w; \n"
- "POW result.color.w, values.w, values.x; \n"
- "END \n",
- { 0.5 * 0.5,
- 0.5 * 0.5 * 0.5,
- 0.5 * 0.5 * 0.5 * 0.5,
- CLAMP01(2.0) },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "RCP test (reciprocal)",
- "!!ARBvp1.0\n"
- "PARAM values = {8, -10, 1, 12 }; \n"
- "MOV result.position, vertex.position; \n"
- "RCP result.color.x, values.x; \n"
- "RCP result.color.y, values.y; \n"
- "RCP result.color.z, values.z; \n"
- "RCP result.color.w, values.w; \n"
- "END \n",
- { 1.0 / 8.0, CLAMP01(1.0 / -10.0), 1, 1.0 / 12.0 },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "RSQ test 1 (reciprocal square root)",
- "!!ARBvp1.0\n"
- "PARAM values = {1, 4, 9, 100 }; \n"
- "MOV result.position, vertex.position; \n"
- "RSQ result.color.x, values.x; \n"
- "RSQ result.color.y, values.y; \n"
- "RSQ result.color.z, values.z; \n"
- "RSQ result.color.w, values.w; \n"
- "END \n",
- { 1.0, 0.5, 0.3333, 0.1 },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "RSQ test 2 (reciprocal square root of negative value)",
- "!!ARBvp1.0\n"
- "PARAM values = {0, -100, -5, -1}; \n"
- "MOV result.position, vertex.position; \n"
- "RSQ result.color.x, values.x; \n"
- "RSQ result.color.y, values.y; \n"
- "RSQ result.color.z, values.z; \n"
- "RSQ result.color.w, values.w; \n"
- "END \n",
- { DONT_CARE_COLOR,
- 0.1,
- 0.447,
- 1.0,
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "SGE test",
- "!!ARBvp1.0\n"
- "PARAM p0 = program.local[0]; \n"
- "PARAM p2 = program.local[2]; \n"
- "MOV result.position, vertex.position; \n"
- "SGE result.color, p2, p0; \n"
- "END \n",
- { Param2[0] >= Param0[0] ? 1.0 : 0.0,
- Param2[1] >= Param0[1] ? 1.0 : 0.0,
- Param2[2] >= Param0[2] ? 1.0 : 0.0,
- Param2[3] >= Param0[3] ? 1.0 : 0.0,
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "SLT test",
- "!!ARBvp1.0\n"
- "PARAM p0 = program.local[0]; \n"
- "PARAM p2 = program.local[2]; \n"
- "MOV result.position, vertex.position; \n"
- "SLT result.color, p2, p0; \n"
- "END \n",
- { Param2[0] < Param0[0] ? 1.0 : 0.0,
- Param2[1] < Param0[1] ? 1.0 : 0.0,
- Param2[2] < Param0[2] ? 1.0 : 0.0,
- Param2[3] < Param0[3] ? 1.0 : 0.0,
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "SUB test (with swizzle)",
- "!!ARBvp1.0\n"
- "PARAM p1 = program.local[1]; \n"
- "MOV result.position, vertex.position; \n"
- "SUB result.color, p1.yxwz, vertex.color.primary.yxwz; \n"
- "END \n",
- { CLAMP01(Param1[1] - VertColor[1]),
- CLAMP01(Param1[0] - VertColor[0]),
- CLAMP01(Param1[3] - VertColor[3]),
- CLAMP01(Param1[2] - VertColor[2])
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "SWZ test 1",
- "!!ARBvp1.0\n"
- "PARAM p = program.local[1]; \n"
- "MOV result.position, vertex.position; \n"
- "SWZ result.color, p, w,x,x,y; \n"
- "END \n",
- { Param1[3],
- Param1[0],
- Param1[0],
- Param1[1]
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "SWZ test 2",
- "!!ARBvp1.0\n"
- "PARAM p = program.local[1]; \n"
- "MOV result.position, vertex.position; \n"
- "SWZ result.color, p, -w,-x,x,y; \n"
- "END \n",
- { CLAMP01(-Param1[3]),
- CLAMP01(-Param1[0]),
- Param1[0],
- Param1[1]
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "SWZ test 3",
- "!!ARBvp1.0\n"
- "PARAM p = program.local[1]; \n"
- "MOV result.position, vertex.position; \n"
- "SWZ result.color, p, 0,1,0,1; \n"
- "END \n",
- { 0.0, 1.0, 0.0, 1.0 },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "SWZ test 4",
- "!!ARBvp1.0\n"
- "PARAM p = program.local[1]; \n"
- "MOV result.position, vertex.position; \n"
- "SWZ result.color, p, 1,x,z,0; \n"
- "END \n",
- { 1.0,
- Param1[0],
- Param1[2],
- 0.0
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "SWZ test 5",
- "!!ARBvp1.0\n"
- "PARAM p = program.local[1]; \n"
- "MOV result.position, vertex.position; \n"
- "SWZ result.color, p, z,-y,-1,0; \n"
- "END \n",
- { CLAMP01(Param1[2]),
- CLAMP01(-Param1[1]),
- CLAMP01(-1),
- 0.0
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "XPD test 1",
- "!!ARBvp1.0\n"
- "PARAM p1 = program.local[1]; \n"
- "PARAM p2 = program.local[2]; \n"
- "MOV result.position, vertex.position; \n"
- "XPD result.color, p1, p2; \n"
- "END \n",
- { CLAMP01(Param1[1] * Param2[2] - Param1[2] * Param2[1]),
- CLAMP01(Param1[2] * Param2[0] - Param1[0] * Param2[2]),
- CLAMP01(Param1[0] * Param2[1] - Param1[1] * Param2[0]),
- DONT_CARE_COLOR
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "XPD test 2 (same src and dst arg)",
- "!!ARBvp1.0\n"
- "PARAM p1 = program.local[1]; \n"
- "PARAM p2 = program.local[2]; \n"
- "TEMP t; \n"
- "MOV result.position, vertex.position; \n"
- "MOV t, p1; \n"
- "XPD t, t, p2; \n"
- "MOV result.color, t; \n"
- "END \n",
- { CLAMP01(Param1[1] * Param2[2] - Param1[2] * Param2[1]),
- CLAMP01(Param1[2] * Param2[0] - Param1[0] * Param2[2]),
- CLAMP01(Param1[0] * Param2[1] - Param1[1] * Param2[0]),
- DONT_CARE_COLOR
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
-
- // ============= Test result.position writes ==========================
- {
- "Position write test (compute position from texcoord)",
- "!!ARBvp1.0\n"
- "ATTRIB texcoord = vertex.texcoord[0]; \n"
- "PARAM scale = {0.5, 0.5, 0.0, 1.0}; \n"
- "PARAM bias = {-0.25, -0.25, 0.0, 0.0}; \n"
- "MAD result.position, texcoord, scale, bias; \n"
- "MOV result.color, vertex.color; \n"
- "END \n",
- VERTCOLOR,
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "Z-write test",
- "!!ARBvp1.0\n"
- "PARAM p1 = program.local[1]; \n"
- "MOV result.position, vertex.position; \n"
- "MOV result.position.z, p1.y; \n"
- "MOV result.color, vertex.color; \n"
- "END \n",
- VERTCOLOR,
- Param1[1] * 0.5 + 0.5, // map clip Z to win Z
- FLAG_NONE
- },
-
- // ============= Global state reference tests =========================
- {
- "State reference test 1 (material ambient)",
- "!!ARBvp1.0\n"
- "PARAM ambient = state.material.front.ambient; \n"
- "MOV result.position, vertex.position; \n"
- "MOV result.color, ambient; \n"
- "END \n",
- AMBIENT,
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- // Note: material.diffuse = VertColor
- // light.diffuse = Diffuse
- "State reference test 2 (light products)",
- "!!ARBvp1.0\n"
- "PARAM dprod = state.lightprod[0].diffuse; \n"
- "MOV result.position, vertex.position; \n"
- "MOV result.color, dprod; \n"
- "END \n",
- { CLAMP01(Diffuse[0] * VertColor[0]),
- CLAMP01(Diffuse[1] * VertColor[1]),
- CLAMP01(Diffuse[2] * VertColor[2]),
- CLAMP01(VertColor[3]) // material's diffuse alpha
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "State reference test 3 (fog params)",
- "!!ARBvp1.0\n"
- "PARAM fog = state.fog.params; \n"
- "PARAM scale = {1.0, 1.0, 1.0, 0.1}; \n"
- "MOV result.position, vertex.position; \n"
- "MUL result.color, fog, scale; \n"
- "END \n",
- { FogDensity,
- FogStart,
- FogEnd,
- (1.0 / (FogEnd - FogStart)) * 0.1
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
-
- // ============= Numeric stress tests =================================
- // Basically just check that we don't crash when we do divides by
- // zero, etc.
- {
- "Divide by zero test",
- "!!ARBvp1.0\n"
- "PARAM zero = program.local[0]; \n"
- "MOV result.position, vertex.position; \n"
- "RCP result.color.x, zero.x; \n"
- "RCP result.color.y, zero.y; \n"
- "RCP result.color.z, zero.z; \n"
- "RCP result.color.w, zero.w; \n"
- "END \n",
- { DONT_CARE_COLOR,
- DONT_CARE_COLOR,
- DONT_CARE_COLOR,
- DONT_CARE_COLOR
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
- {
- "Infinity and nan test",
- "!!ARBvp1.0\n"
- "PARAM zero = program.local[0]; \n"
- "PARAM infNan = program.local[9]; \n"
- "MOV result.position, vertex.position; \n"
- "ADD result.color, infNan, zero; \n"
- "END \n",
- { DONT_CARE_COLOR,
- DONT_CARE_COLOR,
- DONT_CARE_COLOR,
- DONT_CARE_COLOR
- },
- DONT_CARE_Z,
- FLAG_NONE
- },
-
- // ============= Texcoord output tests ================================
- // XXX to do
-
- // XXX add lots more tests here!
- { NULL, NULL, {0,0,0,0}, 0, FLAG_NONE } // end of list sentinal
-};
-
-
-
-void
-VertexProgramTest::setup(void)
-{
- // setup Infinity, Nan values
- int nan;
- float *nanPtr;
-
- nan = (0xff << 23) | (1 << 0);
- nanPtr = (float *) &nan;
- InfNan[0] = HUGE_VAL;
- InfNan[1] = -HUGE_VAL;
- InfNan[2] = (float) (*nanPtr);
- InfNan[3] = 1.0 / HUGE_VAL;
- /*
- printf("InfNan = %f %f %f %f\n",
- InfNan[0], InfNan[1], InfNan[2], InfNan[3]);
- */
-
- glGenProgramsARB(1, &progID);
- glBindProgramARB(GL_VERTEX_PROGRAM_ARB, progID);
- glEnable(GL_VERTEX_PROGRAM_ARB);
-
- // load program inputs
- glColor4fv(VertColor);
- glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 0, Param0);
- glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 1, Param1);
- glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 2, Param2);
- glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 9, InfNan);
-
- // other GL state
- glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, Ambient);
- glLightfv(GL_LIGHT0, GL_DIFFUSE, Diffuse);
- glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, VertColor);
- glFogf(GL_FOG_DENSITY, FogDensity);
- glFogf(GL_FOG_START, FogStart);
- glFogf(GL_FOG_END, FogEnd);
-
- GLenum err = glGetError();
- assert(!err); // should be OK
-
- // setup vertex transform (we'll draw a quad in middle of window)
- glMatrixMode(GL_PROJECTION);
- glLoadIdentity();
- glOrtho(-4.0, 4.0, -4.0, 4.0, 0.0, 1.0);
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
- glDrawBuffer(GL_FRONT);
- glReadBuffer(GL_FRONT);
-
- // compute error tolerances (may need fine-tuning)
- int bufferBits[5];
- glGetIntegerv(GL_RED_BITS, &bufferBits[0]);
- glGetIntegerv(GL_GREEN_BITS, &bufferBits[1]);
- glGetIntegerv(GL_BLUE_BITS, &bufferBits[2]);
- glGetIntegerv(GL_ALPHA_BITS, &bufferBits[3]);
- glGetIntegerv(GL_DEPTH_BITS, &bufferBits[4]);
-
- tolerance[0] = 2.0 / (1 << bufferBits[0]);
- tolerance[1] = 2.0 / (1 << bufferBits[1]);
- tolerance[2] = 2.0 / (1 << bufferBits[2]);
- if (bufferBits[3])
- tolerance[3] = 2.0 / (1 << bufferBits[3]);
- else
- tolerance[3] = 1.0;
- if (bufferBits[4])
- tolerance[4] = 16.0 / (1 << bufferBits[4]);
- else
- tolerance[4] = 1.0;
-
- // Some tests request a looser tolerance:
- // XXX a factor of 4 may be too much...
- for (int i = 0; i < 5; i++)
- looseTolerance[i] = 4.0 * tolerance[i];
-}
-
-
-void
-VertexProgramTest::reportFailure(const char *programName,
- const GLfloat expectedColor[4],
- const GLfloat actualColor[4] ) const
-{
- env->log << "FAILURE:\n";
- env->log << " Program: " << programName << "\n";
- env->log << " Expected color: ";
- env->log << expectedColor[0] << ", ";
- env->log << expectedColor[1] << ", ";
- env->log << expectedColor[2] << ", ";
- env->log << expectedColor[3] << "\n";
- env->log << " Observed color: ";
- env->log << actualColor[0] << ", ";
- env->log << actualColor[1] << ", ";
- env->log << actualColor[2] << ", ";
- env->log << actualColor[3] << "\n";
-}
-
-void
-VertexProgramTest::reportZFailure(const char *programName,
- GLfloat expectedZ, GLfloat actualZ) const
-{
- env->log << "FAILURE:\n";
- env->log << " Program: " << programName << "\n";
- env->log << " Expected Z: " << expectedZ << "\n";
- env->log << " Observed Z: " << actualZ << "\n";
-}
-
-
-
-// Compare actual and expected colors
-bool
-VertexProgramTest::equalColors(const GLfloat act[4], const GLfloat exp[4], int flags) const
-{
- const GLfloat *tol;
- if (flags & FLAG_LOOSE)
- tol = looseTolerance;
- else
- tol = tolerance;
- if ((fabsf(act[0] - exp[0]) > tol[0] && exp[0] != DONT_CARE_COLOR) ||
- (fabsf(act[1] - exp[1]) > tol[1] && exp[1] != DONT_CARE_COLOR) ||
- (fabsf(act[2] - exp[2]) > tol[2] && exp[2] != DONT_CARE_COLOR) ||
- (fabsf(act[3] - exp[3]) > tol[3] && exp[3] != DONT_CARE_COLOR))
- return false;
- else
- return true;
-}
-
-
-bool
-VertexProgramTest::equalDepth(GLfloat z0, GLfloat z1) const
-{
- if (fabsf(z0 - z1) > tolerance[4])
- return false;
- else
- return true;
-}
-
-
-bool
-VertexProgramTest::testProgram(const VertexProgram &p)
-{
- const GLfloat r = 0.25;
-
- glProgramStringARB(GL_VERTEX_PROGRAM_ARB,
- GL_PROGRAM_FORMAT_ASCII_ARB,
- strlen(p.progString),
- (const GLubyte *) p.progString);
-
- GLenum err = glGetError();
- if (err) {
- GLint errorPos;
- glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errorPos);
- env->log << "OpenGL error " << (int) err << "\n";
- env->log << "Invalid Vertex Program:\n";
- env->log << p.progString;
- env->log << "Error position: " << errorPos << "\n";
- env->log << "Error message: " << glGetString(GL_PROGRAM_ERROR_STRING_ARB) << "\n";
- return false;
- }
-
- // to avoid potential issue with undefined result.depth.z
- if (p.expectedZ == DONT_CARE_Z)
- glDisable(GL_DEPTH_TEST);
- else
- glEnable(GL_DEPTH_TEST);
-
- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
- glBegin(GL_POLYGON);
- glTexCoord2f(0, 0); glVertex2f(-r, -r);
- glTexCoord2f(1, 0); glVertex2f( r, -r);
- glTexCoord2f(1, 1); glVertex2f( r, r);
- glTexCoord2f(0, 1); glVertex2f(-r, r);
- glEnd();
-
- GLfloat pixel[4];
- glReadPixels(windowSize / 2, windowSize / 2, 1, 1,
- GL_RGBA, GL_FLOAT, pixel);
-
- if (0) // debug
- printf("%s: Expect: %.3f %.3f %.3f %.3f found: %.3f %.3f %.3f %.3f\n",
- p.name,
- p.expectedColor[0], p.expectedColor[1],
- p.expectedColor[2], p.expectedColor[3],
- pixel[0], pixel[1], pixel[2], pixel[3]);
-
- if (!equalColors(pixel, p.expectedColor, p.flags)) {
- reportFailure(p.name, p.expectedColor, pixel);
- return false;
- }
-
- if (p.expectedZ != DONT_CARE_Z) {
- GLfloat z;
- glReadPixels(windowSize / 2, windowSize / 2, 1, 1,
- GL_DEPTH_COMPONENT, GL_FLOAT, &z);
- if (!equalDepth(z, p.expectedZ)) {
- reportZFailure(p.name, p.expectedZ, z);
- return false;
- }
- }
-
- if (0) // debug
- printf("%s passed\n", p.name);
-
- return true;
-}
-
-void
-VertexProgramTest::testBadProgram(MultiTestResult &result)
-{
- const GLfloat r = 0.25;
- GLenum err;
-
- {
- static const char *badprog =
- "!!ARBvp1.0\n"
- "NOTANOPCODE;\n"
- "MOV result.position, vertex.position;\n";
-
- glProgramStringARB(GL_VERTEX_PROGRAM_ARB,
- GL_PROGRAM_FORMAT_ASCII_ARB,
- strlen(badprog),
- (const GLubyte *) badprog);
-
- /* Test that an invalid program raises an error */
- err = glGetError();
- if (err != GL_INVALID_OPERATION) {
- env->log << "Unexpected OpenGL error state " << (int) err <<
- " with bad vertex program.\n";
- env->log << "Expected: " << GL_INVALID_OPERATION << "\n";
- result.numFailed++;
-
- while (err != 0)
- err = glGetError();
- } else {
- result.numPassed++;
- }
- }
-
-
- /* Check that we correctly produce GL_INVALID_OPERATION when rendering
- * with an invalid (non-existant in this case) program.
- */
- {
- glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 99);
-
- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
- glBegin(GL_POLYGON);
- glTexCoord2f(0, 0); glVertex2f(-r, -r);
- glTexCoord2f(1, 0); glVertex2f( r, -r);
- glTexCoord2f(1, 1); glVertex2f( r, r);
- glTexCoord2f(0, 1); glVertex2f(-r, r);
- glEnd();
- err = glGetError();
-
- if (err != GL_INVALID_OPERATION) {
- env->log << "Unexpected OpenGL error state " << (int) err <<
- " in glBegin() with bad vertex program.\n";
- env->log << "Expected: " << GL_INVALID_OPERATION << "\n";
- result.numFailed++;
-
- while (err != 0)
- err = glGetError();
- } else {
- result.numPassed++;
- }
- }
-
- /* Similarly, test that glDrawArrays raises GL_INVALID_OPERATION
- */
- {
- static const GLfloat vertcoords[4][3] = {
- { -r, -r, 0 }, { r, -r, 0 }, { r, r, 0 }, { -r, r, 0 }
- };
-
- glVertexPointer(3, GL_FLOAT, 0, vertcoords);
- glEnableClientState(GL_VERTEX_ARRAY);
- glDrawArrays(GL_POLYGON, 0, 4);
- err = glGetError();
- glDisableClientState(GL_VERTEX_ARRAY);
-
- if (err != GL_INVALID_OPERATION) {
- env->log << "Unexpected OpenGL error state " << (int) err <<
- " in glDrawArrays() with bad vertex program.\n";
- env->log << "Expected: " << GL_INVALID_OPERATION << "\n";
- result.numFailed++;
-
- while (err != 0)
- err = glGetError();
- } else {
- result.numPassed++;
- }
- }
-}
-
-void
-VertexProgramTest::runOne(MultiTestResult &r, Window &w)
-{
- // to test a single sub-test, set the name here:
- const char *single = getenv("PIGLIT_TEST");
-
- (void) w;
- setup();
-
- for (int i = 0; Programs[i].name; i++) {
-
- if (!single || strcmp(single, Programs[i].name) == 0) {
-
- if (!testProgram(Programs[i])) {
- r.numFailed++;
- }
- else {
- r.numPassed++;
- }
- }
- }
-
- testBadProgram(r);
-
- r.pass = (r.numFailed == 0);
-}
-
-
-// The test object itself:
-VertexProgramTest vertexProgramTest("vertProg1", "window, rgb, z",
- "GL_ARB_vertex_program",
- "Vertex Program test 1: test a specific set of vertex programs.\n"
- );
-
-
-
-} // namespace GLEAN
diff --git a/tests/glean/tvertprog1.h b/tests/glean/tvertprog1.h
deleted file mode 100644
index 1c80406..0000000
--- a/tests/glean/tvertprog1.h
+++ /dev/null
@@ -1,88 +0,0 @@
-// BEGIN_COPYRIGHT -*- glean -*-
-//
-// Copyright (C) 1999 Allen Akin All Rights Reserved.
-//
-// 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 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 ALLEN AKIN 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.
-//
-// END_COPYRIGHT
-
-// tvertprog.h: Test GL_ARB_vertex_program extension.
-// Brian Paul 22 October 2005
-
-#ifndef __tvertprog_h__
-#define __tvertprog_h__
-
-#include "tmultitest.h"
-
-namespace GLEAN {
-
-#define windowSize 100
-
-// to indicate a looser tolerance test is needed
-#define FLAG_NONE 0
-#define FLAG_LOOSE 1
-
-class VertexProgram
-{
-public:
- const char *name;
- const char *progString;
- GLfloat expectedColor[4];
- GLfloat expectedZ;
- int flags;
-};
-
-
-
-class VertexProgramTest: public MultiTest
-{
-public:
- VertexProgramTest(const char* testName, const char* filter,
- const char *extensions, const char* description):
- MultiTest(testName, filter, extensions, description),
- tolerance(),
- looseTolerance()
- {
- }
-
- virtual void runOne(MultiTestResult &r, Window &w);
-
-private:
- GLfloat tolerance[5];
- GLfloat looseTolerance[5];
- void setup(void);
- bool equalColors(const GLfloat a[4], const GLfloat b[4], int flags) const;
- bool equalDepth(GLfloat z0, GLfloat z1) const;
- bool testProgram(const VertexProgram &p);
- void testBadProgram(MultiTestResult &result);
- void reportFailure(const char *programName,
- const GLfloat expectedColor[4],
- const GLfloat actualColor[4] ) const;
- void reportZFailure(const char *programName,
- GLfloat expectedZ, GLfloat actualZ) const;
-
-};
-
-} // namespace GLEAN
-
-#endif // __tvertprog_h__
--
2.7.4
More information about the Piglit
mailing list