These mainly check the state machine. Compiler checks will come later.
Signed-off-by: Miklós Máté <mtm...@gmail.com>
---
tests/spec/ati_fragment_shader/render-constants.c | 98 +++++++++++++++
tests/spec/ati_fragment_shader/render-default.c | 81 +++++++++++++
tests/spec/ati_fragment_shader/render-fog.c | 95 +++++++++++++++
tests/spec/ati_fragment_shader/render-notexture.c | 71 +++++++++++
tests/spec/ati_fragment_shader/render-precedence.c | 118 ++++++++++++++++++
tests/spec/ati_fragment_shader/render-sources.c | 132 +++++++++++++++++++++
tests/spec/ati_fragment_shader/render-textargets.c | 89 ++++++++++++++
7 files changed, 684 insertions(+)
create mode 100644 tests/spec/ati_fragment_shader/render-constants.c
create mode 100644 tests/spec/ati_fragment_shader/render-default.c
create mode 100644 tests/spec/ati_fragment_shader/render-fog.c
create mode 100644 tests/spec/ati_fragment_shader/render-notexture.c
create mode 100644 tests/spec/ati_fragment_shader/render-precedence.c
create mode 100644 tests/spec/ati_fragment_shader/render-sources.c
create mode 100644 tests/spec/ati_fragment_shader/render-textargets.c
diff --git a/tests/spec/ati_fragment_shader/render-constants.c
b/tests/spec/ati_fragment_shader/render-constants.c
new file mode 100644
index 000000000..6e1e4fd8c
--- /dev/null
+++ b/tests/spec/ati_fragment_shader/render-constants.c
@@ -0,0 +1,98 @@
+/* TODO license header */
+
+/**
+ * Tests rendering with GL_ATI_fragment_shader:
+ * - using local and global constants
+ * - updating global constants
+ */
+
+#include "piglit-util-gl.h"
+
+PIGLIT_GL_TEST_CONFIG_BEGIN
+
+ config.supports_gl_compat_version = 10;
+ config.window_visual = PIGLIT_GL_VISUAL_DOUBLE | PIGLIT_GL_VISUAL_RGBA;
+
+PIGLIT_GL_TEST_CONFIG_END
+
+static const float color1[] = {0.4, 0.2, 0.6};
+static const float color2[] = {0.7, 0.2, 0.3};
+static const float color3[] = {0.1, 0.7, 0.2};
+static const float color4[] = {0.8, 0.1, 0.7};
+
+static float result1p3[] = {0.0, 0.0, 0.0};
+static float result2p3[] = {0.0, 0.0, 0.0};
+static float result4p3[] = {0.0, 0.0, 0.0};
+
+#define check_gl_error(err) if (!piglit_check_gl_error(err))
piglit_report_result(PIGLIT_FAIL)
+
+enum piglit_result
+piglit_display(void)
+{
+ bool pass = true;
+
+ piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
+
+ glClearColor(1.0, 0.0, 0.0, 1.0);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ glEnable(GL_FRAGMENT_SHADER_ATI);
+ glSetFragmentShaderConstantATI(GL_CON_7_ATI, color2);
+ glSetFragmentShaderConstantATI(GL_CON_4_ATI, color3);
+ glBindFragmentShaderATI(13);
+ piglit_draw_rect(0, 0, piglit_width/4, piglit_height); /* 2+3 */
+ glBindFragmentShaderATI(42);
+ piglit_draw_rect(piglit_width/4, 0, piglit_width/4, piglit_height); /*
1+3 */
+ glBindFragmentShaderATI(13);
+ glSetFragmentShaderConstantATI(GL_CON_7_ATI, color4);
+ piglit_draw_rect(2*piglit_width/4, 0, piglit_width/4, piglit_height);
/* 4+3 */
+ glBindFragmentShaderATI(42);
+ piglit_draw_rect(3*piglit_width/4, 0, piglit_width/4, piglit_height);
/*1+3 */
+ glDisable(GL_FRAGMENT_SHADER_ATI);
+
+ pass = pass && piglit_probe_rect_rgb(0, 0, piglit_width/4,
piglit_height, result2p3);
+ pass = pass && piglit_probe_rect_rgb(piglit_width/4, 0, piglit_width/4,
piglit_height, result1p3);
+ pass = pass && piglit_probe_rect_rgb(2*piglit_width/4, 0,
piglit_width/4, piglit_height, result4p3);
+ pass = pass && piglit_probe_rect_rgb(3*piglit_width/4, 0,
piglit_width/4, piglit_height, result1p3);
+
+ piglit_present_results();
+
+ check_gl_error(GL_NO_ERROR);
+
+ return pass ? PIGLIT_PASS : PIGLIT_FAIL;
+}
+
+void
+piglit_init(int argc, char **argv)
+{
+ unsigned u;
+
+ piglit_require_extension("GL_ATI_fragment_shader");
+
+ /* create identical shaders, but one of them has a local constant */
+
+ glBindFragmentShaderATI(13);
+ glBeginFragmentShaderATI();
+ glColorFragmentOp2ATI(GL_ADD_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE,
+ GL_CON_7_ATI, GL_NONE, GL_NONE,
+ GL_CON_4_ATI, GL_NONE, GL_NONE);
+ glEndFragmentShaderATI();
+
+ glBindFragmentShaderATI(42);
+ glBeginFragmentShaderATI();
+ glColorFragmentOp2ATI(GL_ADD_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE,
+ GL_CON_7_ATI, GL_NONE, GL_NONE,
+ GL_CON_4_ATI, GL_NONE, GL_NONE);
+ glSetFragmentShaderConstantATI(GL_CON_7_ATI, color1);
+ glEndFragmentShaderATI();
+
+ /* compute the expected results */
+
+ for (u=0; u<3; u++) {
+ result1p3[u] = color1[u]+color3[u];
+ result2p3[u] = color2[u]+color3[u];
+ result4p3[u] = color4[u]+color3[u];
+ }
+
+ check_gl_error(GL_NO_ERROR);
+}
diff --git a/tests/spec/ati_fragment_shader/render-default.c
b/tests/spec/ati_fragment_shader/render-default.c
new file mode 100644
index 000000000..314a21810
--- /dev/null
+++ b/tests/spec/ati_fragment_shader/render-default.c
@@ -0,0 +1,81 @@
+/* TODO license header */
+
+/**
+ * Tests rendering with GL_ATI_fragment_shader: enable, disable, default
fragment shader.
+ */
+
+#include "piglit-util-gl.h"
+
+PIGLIT_GL_TEST_CONFIG_BEGIN
+
+ config.supports_gl_compat_version = 10;
+ config.window_visual = PIGLIT_GL_VISUAL_DOUBLE | PIGLIT_GL_VISUAL_RGBA;
+
+PIGLIT_GL_TEST_CONFIG_END
+
+static const float color[] = {0.2, 0.3, 0.8};
+static const float texcoord[] = {0.2, 0.7, 0.4};
+
+#define check_gl_error(err) if (!piglit_check_gl_error(err))
piglit_report_result(PIGLIT_FAIL)
+
+enum piglit_result
+piglit_display(void)
+{
+ bool pass = true;
+ GLuint tex;
+
+ piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
+
+ glClearColor(1.0, 0.0, 0.0, 1.0);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ glColor3fv(color);
+ glTexCoord3fv(texcoord);
+
+ //TODO swrast: passtexcoord only works when there is a bound texture
AND texturing is enabled
+ /*glEnable(GL_TEXTURE_2D);
+ glGenTextures(1, &tex);
+ glBindTexture(GL_TEXTURE_2D, tex);
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 0, GL_RGB, GL_FLOAT,
(void*)color);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+ check_gl_error(GL_NO_ERROR);*/
+
+
+ glDisable(GL_FRAGMENT_SHADER_ATI);
+ piglit_draw_rect(0, 0, piglit_width/4, piglit_height);
+ glEnable(GL_FRAGMENT_SHADER_ATI);
+ piglit_draw_rect(piglit_width/4, 0, piglit_width/4, piglit_height);
+ glDisable(GL_FRAGMENT_SHADER_ATI);
+ piglit_draw_rect(2*piglit_width/4, 0, piglit_width/4, piglit_height);
+ glEnable(GL_FRAGMENT_SHADER_ATI);
+ piglit_draw_rect(3*piglit_width/4, 0, piglit_width/4, piglit_height);
+
+ pass = pass && piglit_probe_rect_rgb(0, 0, piglit_width/4,
piglit_height, color);
+ pass = pass && piglit_probe_rect_rgb(piglit_width/4, 0, piglit_width/4,
piglit_height, texcoord);
+ pass = pass && piglit_probe_rect_rgb(2*piglit_width/4, 0,
piglit_width/4, piglit_height, color);
+ pass = pass && piglit_probe_rect_rgb(3*piglit_width/4, 0,
piglit_width/4, piglit_height, texcoord);
+
+ piglit_present_results();
+
+ check_gl_error(GL_NO_ERROR);
+
+ return pass ? PIGLIT_PASS : PIGLIT_FAIL;
+}
+
+void
+piglit_init(int argc, char **argv)
+{
+ piglit_require_extension("GL_ATI_fragment_shader");
+
+ /* create a default shader that does something different than
fixed-function */
+ glBeginFragmentShaderATI();
+ glPassTexCoordATI(GL_REG_1_ATI, GL_TEXTURE0_ARB, GL_SWIZZLE_STR_ATI);
+ glColorFragmentOp1ATI(GL_MOV_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE,
+ GL_REG_1_ATI, GL_NONE, GL_NONE);
+ glEndFragmentShaderATI();
+
+ check_gl_error(GL_NO_ERROR);
+}
diff --git a/tests/spec/ati_fragment_shader/render-fog.c
b/tests/spec/ati_fragment_shader/render-fog.c
new file mode 100644
index 000000000..a7b72c502
--- /dev/null
+++ b/tests/spec/ati_fragment_shader/render-fog.c
@@ -0,0 +1,95 @@
+/* TODO license header */
+
+/**
+ * Tests rendering with GL_ATI_fragment_shader: using fog.
+ */
+
+#include "piglit-util-gl.h"
+
+PIGLIT_GL_TEST_CONFIG_BEGIN
+
+ config.supports_gl_compat_version = 10;
+ config.window_visual = PIGLIT_GL_VISUAL_DOUBLE | PIGLIT_GL_VISUAL_RGBA;
+
+PIGLIT_GL_TEST_CONFIG_END
+
+static const float color1[] = {0.2, 0.3, 0.8};
+static const float color2[] = {0.9, 0.8, 0.3};
+
+static float resultLin[] = {0.0, 0.0, 0.0};
+static float resultExp[] = {0.0, 0.0, 0.0};
+static float resultEx2[] = {0.0, 0.0, 0.0};
+
+static const float z = 0.8;
+static const float dens = 0.4;
+
+#define check_gl_error(err) if (!piglit_check_gl_error(err))
piglit_report_result(PIGLIT_FAIL)
+
+enum piglit_result
+piglit_display(void)
+{
+ bool pass = true;
+
+ piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
+
+ glClearColor(1.0, 0.0, 0.0, 1.0);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ glColor3fv(color2);
+
+ glFogfv(GL_FOG_COLOR, color1);
+ glFogf(GL_FOG_DENSITY, dens);
+ glFogf(GL_FOG_START, 0.0);
+ glFogf(GL_FOG_END, 1.0);
+ glHint(GL_FOG_HINT, GL_NICEST);
+
+ glEnable(GL_FRAGMENT_SHADER_ATI);
+ glEnable(GL_FOG);
+ glFogi(GL_FOG_MODE, GL_LINEAR);
+ piglit_draw_rect_z(z, 0, 0, piglit_width/4, piglit_height);
+ glFogi(GL_FOG_MODE, GL_EXP);
+ piglit_draw_rect_z(z, piglit_width/4, 0, piglit_width/4, piglit_height);
+ glFogi(GL_FOG_MODE, GL_EXP2);
+ piglit_draw_rect_z(z, 2*piglit_width/4, 0, piglit_width/4,
piglit_height);
+ glDisable(GL_FOG);
+ piglit_draw_rect_z(z, 3*piglit_width/4, 0, piglit_width/4,
piglit_height);
+ glDisable(GL_FRAGMENT_SHADER_ATI);
+
+ pass = pass && piglit_probe_rect_rgb(0, 0, piglit_width/4,
piglit_height, resultLin);
+ pass = pass && piglit_probe_rect_rgb(piglit_width/4, 0, piglit_width/4,
piglit_height, resultExp);
+ pass = pass && piglit_probe_rect_rgb(2*piglit_width/4, 0,
piglit_width/4, piglit_height, resultEx2);
+ pass = pass && piglit_probe_rect_rgb(3*piglit_width/4, 0,
piglit_width/4, piglit_height, color2);
+
+ piglit_present_results();
+
+ check_gl_error(GL_NO_ERROR);
+
+ return pass ? PIGLIT_PASS : PIGLIT_FAIL;
+}
+
+void
+piglit_init(int argc, char **argv)
+{
+ unsigned u;
+ float f;
+
+ piglit_require_extension("GL_ATI_fragment_shader");
+
+ glBeginFragmentShaderATI();
+ glColorFragmentOp1ATI(GL_MOV_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE,
+ GL_PRIMARY_COLOR_ARB, GL_NONE, GL_NONE);
+ glEndFragmentShaderATI();
+
+ /* compute the expected results */
+
+ for (u=0; u<3; u++) {
+ f = (1.0-z)/(1.0-0.0);
+ resultLin[u] = f*color2[u] + (1.0-f)*color1[u];
+ f = exp(-dens*z);
+ resultExp[u] = f*color2[u] + (1.0-f)*color1[u];
+ f = exp(-pow(dens*z,2.0));
+ resultEx2[u] = f*color2[u] + (1.0-f)*color1[u];
+ }
+
+ check_gl_error(GL_NO_ERROR);
+}
diff --git a/tests/spec/ati_fragment_shader/render-notexture.c
b/tests/spec/ati_fragment_shader/render-notexture.c
new file mode 100644
index 000000000..2d9aefe09
--- /dev/null
+++ b/tests/spec/ati_fragment_shader/render-notexture.c
@@ -0,0 +1,71 @@
+/* TODO license header */
+
+/**
+ * Tests rendering with GL_ATI_fragment_shader: when no texture is bound
+ * - glPassTexCoordATI() should work as normal
+ * - glSampleMapATI() should return all zeros (technically this is undefined)
+ */
+
+#include "piglit-util-gl.h"
+
+PIGLIT_GL_TEST_CONFIG_BEGIN
+
+ config.supports_gl_compat_version = 10;
+ config.window_visual = PIGLIT_GL_VISUAL_DOUBLE | PIGLIT_GL_VISUAL_RGBA;
+
+PIGLIT_GL_TEST_CONFIG_END
+
+static const float texcoord[] = {0.2, 0.7, 0.4};
+
+#define check_gl_error(err) if (!piglit_check_gl_error(err))
piglit_report_result(PIGLIT_FAIL)
+
+enum piglit_result
+piglit_display(void)
+{
+ bool pass = true;
+
+ piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
+
+ glClearColor(1.0, 0.0, 0.0, 1.0);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ glTexCoord3fv(texcoord);
+
+ glEnable(GL_FRAGMENT_SHADER_ATI);
+ glBindFragmentShaderATI(6);
+ piglit_draw_rect(0, 0, piglit_width/2, piglit_height);
+ glBindFragmentShaderATI(42);
+ piglit_draw_rect(piglit_width/2, 0, piglit_width/2, piglit_height);
+ glDisable(GL_FRAGMENT_SHADER_ATI);
+
+ pass = pass && piglit_probe_rect_rgb(0, 0, piglit_width/2,
piglit_height, texcoord);
+ /* the right hand side is undefined */
+
+ piglit_present_results();
+
+ check_gl_error(GL_NO_ERROR);
+
+ return pass ? PIGLIT_PASS : PIGLIT_FAIL;
+}
+
+void
+piglit_init(int argc, char **argv)
+{
+ piglit_require_extension("GL_ATI_fragment_shader");
+
+ glBindFragmentShaderATI(6);
+ glBeginFragmentShaderATI();
+ glPassTexCoordATI(GL_REG_1_ATI, GL_TEXTURE0_ARB, GL_SWIZZLE_STR_ATI);
+ glColorFragmentOp1ATI(GL_MOV_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE,
+ GL_REG_1_ATI, GL_NONE, GL_NONE);
+ glEndFragmentShaderATI();
+
+ glBindFragmentShaderATI(42);
+ glBeginFragmentShaderATI();
+ glSampleMapATI(GL_REG_0_ATI, GL_TEXTURE0_ARB, GL_SWIZZLE_STR_ATI);
+ glColorFragmentOp1ATI(GL_MOV_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE,
+ GL_REG_0_ATI, GL_NONE, GL_NONE);
+ glEndFragmentShaderATI();
+
+ check_gl_error(GL_NO_ERROR);
+}
diff --git a/tests/spec/ati_fragment_shader/render-precedence.c
b/tests/spec/ati_fragment_shader/render-precedence.c
new file mode 100644
index 000000000..9d1b9d0af
--- /dev/null
+++ b/tests/spec/ati_fragment_shader/render-precedence.c
@@ -0,0 +1,118 @@
+/* TODO license header */
+
+/**
+ * Tests rendering with GL_ATI_fragment_shader:
+ * - precedence between ATI_fragment_shader, ARB_fragment_program, GLSL
+ * - ARB_fragment_program overrides ATI_fragment_shader
+ * - GLSL overrides both
+ */
+
+#include "piglit-util-gl.h"
+
+PIGLIT_GL_TEST_CONFIG_BEGIN
+
+ config.supports_gl_compat_version = 10;
+ config.window_visual = PIGLIT_GL_VISUAL_DOUBLE | PIGLIT_GL_VISUAL_RGBA;
+
+PIGLIT_GL_TEST_CONFIG_END
+
+static const float color1[] = {0.2, 0.3, 0.8};
+static const float color2[] = {0.9, 0.8, 0.3};
+static const float texcoord[] = {0.2, 0.7, 0.4};
+
+static bool have_fp = false;
+static bool have_fs = false;
+
+static GLuint glslprog;
+
+#define check_gl_error(err) if (!piglit_check_gl_error(err))
piglit_report_result(PIGLIT_FAIL)
+
+enum piglit_result
+piglit_display(void)
+{
+ bool pass = true;
+
+ piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
+
+ glClearColor(1.0, 0.0, 0.0, 1.0);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ glColor3fv(color1);
+ glSecondaryColor3fvEXT(color2);
+ glTexCoord3fv(texcoord);
+ //glEnable(GL_COLOR_SUM);
+
+ glEnable(GL_FRAGMENT_SHADER_ATI);
+ piglit_draw_rect(0, 0, piglit_width/4, piglit_height);
+ if (have_fp) {
+ glEnable(GL_FRAGMENT_PROGRAM_ARB);
+ piglit_draw_rect(piglit_width/4, 0, piglit_width/4,
piglit_height);
+ glDisable(GL_FRAGMENT_PROGRAM_ARB);
+ }
+ if (have_fs) {
+ glUseProgram(glslprog);
+ piglit_draw_rect(2*piglit_width/4, 0, piglit_width/4,
piglit_height);
+ glUseProgram(0);
+ }
+ if (have_fp && have_fs) {
+ glUseProgram(glslprog);
+ glEnable(GL_FRAGMENT_PROGRAM_ARB);
+ piglit_draw_rect(3*piglit_width/4, 0, piglit_width/4,
piglit_height);
+ glUseProgram(0);
+ glDisable(GL_FRAGMENT_PROGRAM_ARB);
+ }
+ glDisable(GL_FRAGMENT_SHADER_ATI);
+
+ pass = pass && piglit_probe_rect_rgb(0, 0, piglit_width/4,
piglit_height, color2);
+ if (have_fp)
+ pass = pass && piglit_probe_rect_rgb(piglit_width/4, 0,
piglit_width/4, piglit_height, texcoord);
+ if (have_fs)
+ pass = pass && piglit_probe_rect_rgb(2*piglit_width/4, 0,
piglit_width/4, piglit_height, color1);
+ if (have_fp && have_fs)
+ pass = pass && piglit_probe_rect_rgb(3*piglit_width/4, 0,
piglit_width/4, piglit_height, color1);
+
+ piglit_present_results();
+
+ check_gl_error(GL_NO_ERROR);
+
+ return pass ? PIGLIT_PASS : PIGLIT_FAIL;
+}
+
+const char *arbfp_str =
+"!!ARBfp1.0\n"
+"MOV result.color, fragment.texcoord[0];\n"
+//"MOV result.color, fragment.color.secondary;\n"
+"END";
+
+const char *glslfs_str =
+"void main() { gl_FragColor = gl_Color; }";
+//"void main() { gl_FragColor = gl_SecondaryColor; }";
+
+void
+piglit_init(int argc, char **argv)
+{
+ piglit_require_extension("GL_ATI_fragment_shader");
+
+ /* create shaders */
+
+ //TODO swrast only has secondary color in ATI_fs if at least one of
these is true:
+ // GL_COLOR_SUM is enabled
+ // an ARB_fp was compiled that uses secondary color
+ // a GLSL fragment shader was compiled that uses secondary color
+ glBeginFragmentShaderATI();
+ glColorFragmentOp1ATI(GL_MOV_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE,
+ GL_SECONDARY_INTERPOLATOR_ATI, GL_NONE, GL_NONE);
+ glEndFragmentShaderATI();
+
+ if (piglit_is_extension_supported("GL_ARB_fragment_program")) {
+ have_fp = true;
+ piglit_compile_program(GL_FRAGMENT_PROGRAM_ARB, arbfp_str);
+ }
+
+ if (piglit_is_extension_supported("GL_ARB_fragment_shader")) {
+ have_fs = true;
+ glslprog = piglit_build_simple_program(NULL, glslfs_str);
+ }
+
+ check_gl_error(GL_NO_ERROR);
+}
diff --git a/tests/spec/ati_fragment_shader/render-sources.c
b/tests/spec/ati_fragment_shader/render-sources.c
new file mode 100644
index 000000000..d9e80eef9
--- /dev/null
+++ b/tests/spec/ati_fragment_shader/render-sources.c
@@ -0,0 +1,132 @@
+/* TODO license header */
+
+/**
+ * Tests rendering with GL_ATI_fragment_shader:
+ * - various data sources for calculations in fragment shader
+ * - texture coordinates
+ * - texture sample
+ * - constant
+ * - primary color
+ * - secondary interpolator
+ * - one, zero
+ * - switch between named fragment shaders
+ * - use undefined default shader (rendering is undefined but shouldn't crash)
+ */
+
+#include "piglit-util-gl.h"
+
+PIGLIT_GL_TEST_CONFIG_BEGIN
+
+ config.supports_gl_compat_version = 10;
+ config.window_visual = PIGLIT_GL_VISUAL_DOUBLE | PIGLIT_GL_VISUAL_RGBA;
+
+PIGLIT_GL_TEST_CONFIG_END
+
+static const float color1[] = {0.2, 0.3, 0.8};
+static const float color2[] = {0.9, 0.8, 0.3};
+static const float texcoord[] = {0.2, 0.7, 0.4};
+static const float texcolor[] = {0.8, 0.1, 0.7};
+
+static float result6[] = {0.0, 0.0, 0.0};
+static float result13[] = {0.0, 0.0, 0.0};
+static float result42[] = {0.0, 0.0, 0.0};
+
+static GLuint tex;
+
+#define check_gl_error(err) if (!piglit_check_gl_error(err))
piglit_report_result(PIGLIT_FAIL)
+
+enum piglit_result
+piglit_display(void)
+{
+ bool pass = true;
+
+ piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
+
+ glClearColor(1.0, 0.0, 0.0, 1.0);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ glColor3fv(color1);
+ glSecondaryColor3fvEXT(color2);
+ glTexCoord3fv(texcoord);
+
+ glEnable(GL_TEXTURE_2D);
+ //glEnable(GL_COLOR_SUM); //TODO swrast only has secondary color if
this is enabled
+
+ glEnable(GL_FRAGMENT_SHADER_ATI);
+ glBindFragmentShaderATI(0);
+ piglit_draw_rect(0, 0, piglit_width/4, piglit_height);
+ glBindFragmentShaderATI(6);
+ piglit_draw_rect(piglit_width/4, 0, piglit_width/4, piglit_height);
+ glBindFragmentShaderATI(42);
+ piglit_draw_rect(2*piglit_width/4, 0, piglit_width/4, piglit_height);
+ glBindFragmentShaderATI(13);
+ piglit_draw_rect(3*piglit_width/4, 0, piglit_width/4, piglit_height);
+ glDisable(GL_FRAGMENT_SHADER_ATI);
+
+ /* Mesa uses fixed-function when the shader is invalid, but it's
undefined */
+ /*pass = pass && piglit_probe_rect_rgb(0, 0, piglit_width/4,
piglit_height, color1*texcolor);*/
+ pass = pass && piglit_probe_rect_rgb(piglit_width/4, 0, piglit_width/4,
piglit_height, result6);
+ pass = pass && piglit_probe_rect_rgb(2*piglit_width/4, 0,
piglit_width/4, piglit_height, result42);
+ pass = pass && piglit_probe_rect_rgb(3*piglit_width/4, 0,
piglit_width/4, piglit_height, result13);
+
+ piglit_present_results();
+
+ check_gl_error(GL_NO_ERROR);
+
+ return pass ? PIGLIT_PASS : PIGLIT_FAIL;
+}
+
+void
+piglit_init(int argc, char **argv)
+{
+ unsigned u;
+
+ piglit_require_extension("GL_ATI_fragment_shader");
+
+ /* create shaders that use all possible input sources: texcoord,
sample, const, zero, one, pri&sec color */
+
+ glBindFragmentShaderATI(13);
+ glBeginFragmentShaderATI();
+ glPassTexCoordATI(GL_REG_1_ATI, GL_TEXTURE0_ARB, GL_SWIZZLE_STR_ATI);
+ glSampleMapATI(GL_REG_0_ATI, GL_TEXTURE0_ARB, GL_SWIZZLE_STR_ATI);
+ glColorFragmentOp2ATI(GL_MUL_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE,
+ GL_REG_0_ATI, GL_NONE, GL_NONE,
+ GL_REG_1_ATI, GL_NONE, GL_NONE);
+ glEndFragmentShaderATI();
+
+ glBindFragmentShaderATI(6);
+ glBeginFragmentShaderATI();
+ glColorFragmentOp3ATI(GL_LERP_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE,
+ GL_CON_1_ATI, GL_NONE, GL_NONE,
+ GL_ONE, GL_NONE, GL_NONE,
+ GL_ZERO, GL_NONE, GL_NONE);
+ glSetFragmentShaderConstantATI(GL_CON_1_ATI, color2);
+ glEndFragmentShaderATI();
+
+ glBindFragmentShaderATI(42);
+ glBeginFragmentShaderATI();
+ glColorFragmentOp2ATI(GL_MUL_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE,
+ GL_SECONDARY_INTERPOLATOR_ATI, GL_NONE, GL_NONE,
+ GL_PRIMARY_COLOR_ARB, GL_NONE, GL_NONE);
+ glEndFragmentShaderATI();
+
+ /* create a texture */
+
+ glGenTextures(1, &tex);
+ glBindTexture(GL_TEXTURE_2D, tex);
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 0, GL_RGB, GL_FLOAT,
(void*)texcolor);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+
+ /* compute the expected results */
+
+ for (u=0; u<3; u++) {
+ result6[u] = color2[u];
+ result13[u] = texcoord[u]*texcolor[u];
+ result42[u] = color1[u]*color2[u];
+ }
+
+ check_gl_error(GL_NO_ERROR);
+}
diff --git a/tests/spec/ati_fragment_shader/render-textargets.c
b/tests/spec/ati_fragment_shader/render-textargets.c
new file mode 100644
index 000000000..b45b2e422
--- /dev/null
+++ b/tests/spec/ati_fragment_shader/render-textargets.c
@@ -0,0 +1,89 @@
+/* TODO license header */
+
+/**
+ * Tests rendering with GL_ATI_fragment_shader: using different texture
targets with the same shader.
+ */
+
+#include "piglit-util-gl.h"
+
+PIGLIT_GL_TEST_CONFIG_BEGIN
+
+ config.supports_gl_compat_version = 10;
+ config.window_visual = PIGLIT_GL_VISUAL_DOUBLE | PIGLIT_GL_VISUAL_RGBA;
+
+PIGLIT_GL_TEST_CONFIG_END
+
+static const float color1[] = {0.2, 0.3, 0.8};
+static const float color2[] = {0.9, 0.8, 0.3};
+static const float texcoord[] = {0.2, 0.7, 0.4};
+
+static GLuint tex2D;
+static GLuint texCUBE;
+
+#define check_gl_error(err) if (!piglit_check_gl_error(err))
piglit_report_result(PIGLIT_FAIL)
+
+enum piglit_result
+piglit_display(void)
+{
+ bool pass = true;
+
+ piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
+
+ glClearColor(1.0, 0.0, 0.0, 1.0);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ glTexCoord3fv(texcoord);
+
+ glEnable(GL_FRAGMENT_SHADER_ATI);
+ glEnable(GL_TEXTURE_2D);
+ glBindTexture(GL_TEXTURE_2D, tex2D);
+ piglit_draw_rect(0, 0, piglit_width/2, piglit_height);
+ glDisable(GL_TEXTURE_2D);
+ glEnable(GL_TEXTURE_CUBE_MAP);
+ glBindTexture(GL_TEXTURE_CUBE_MAP, texCUBE);
+ piglit_draw_rect(piglit_width/2, 0, piglit_width/2, piglit_height);
+ glDisable(GL_TEXTURE_CUBE_MAP);
+ glDisable(GL_FRAGMENT_SHADER_ATI);
+
+ pass = pass && piglit_probe_rect_rgb(0, 0, piglit_width/2,
piglit_height, color1);
+ pass = pass && piglit_probe_rect_rgb(piglit_width/2, 0, piglit_width/2,
piglit_height, color2);
+
+ piglit_present_results();
+
+ check_gl_error(GL_NO_ERROR);
+
+ return pass ? PIGLIT_PASS : PIGLIT_FAIL;
+}
+
+void
+piglit_init(int argc, char **argv)
+{
+ piglit_require_extension("GL_ATI_fragment_shader");
+
+ glBeginFragmentShaderATI();
+ glSampleMapATI(GL_REG_0_ATI, GL_TEXTURE0_ARB, GL_SWIZZLE_STR_ATI);
+ glColorFragmentOp1ATI(GL_MOV_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE,
+ GL_REG_0_ATI, GL_NONE, GL_NONE);
+ glEndFragmentShaderATI();
+
+ glGenTextures(1, &tex2D);
+ glBindTexture(GL_TEXTURE_2D, tex2D);
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 0, GL_RGB, GL_FLOAT,
(void*)color1);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+
+ glGenTextures(1, &texCUBE);
+ glBindTexture(GL_TEXTURE_CUBE_MAP, texCUBE);
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, 1, 1, 0,
GL_RGB, GL_FLOAT, (void*)color2);
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, 1, 1, 0,
GL_RGB, GL_FLOAT, (void*)color2);
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, 1, 1, 0,
GL_RGB, GL_FLOAT, (void*)color2);
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, 1, 1, 0,
GL_RGB, GL_FLOAT, (void*)color2);
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, 1, 1, 0,
GL_RGB, GL_FLOAT, (void*)color2);
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, 1, 1, 0,
GL_RGB, GL_FLOAT, (void*)color2);
+ glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+ check_gl_error(GL_NO_ERROR);
+}
--
2.15.0.rc0
_______________________________________________
Piglit mailing list
Piglit@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/piglit
