static bool
draw(int num_varyings)
{
int data_varying;
float vertex[4][4] = { {0.0, 0.0, 0.0, 1.0},
{0.0, 0.0, 0.0, 1.0},
{0.0, 0.0, 0.0, 1.0},
{0.0, 0.0, 0.0, 1.0} };
float green[4][4] = { {0.0, 1.0, 0.0, 0.0},
{0.0, 1.0, 0.0, 0.0},
{0.0, 1.0, 0.0, 0.0},
{0.0, 1.0, 0.0, 0.0} };
float red[4][4] = { {1.0, 0.0, 0.0, 0.0},
{1.0, 0.0, 0.0, 0.0},
{1.0, 0.0, 0.0, 0.0},
{1.0, 0.0, 0.0, 0.0} };
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(float),
vertex);
glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(float),
green);
glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(float),
red);
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);
for (data_varying = 0; data_varying < num_varyings; data_varying++) {
GLuint prog, vs, fs;
GLint loc;
float x, y;
vs = get_vs(num_varyings, data_varying);
fs = get_fs(num_varyings, data_varying);
prog = glCreateProgram();
glAttachShader(prog, vs);
glAttachShader(prog, fs);
glBindAttribLocation(prog, 0, "vertex");
glBindAttribLocation(prog, 1, "green");
glBindAttribLocation(prog, 2, "red");
glLinkProgram(prog);
if (!piglit_link_check_status_quiet(prog)) {
if (num_varyings > max_varyings) {
printf("Failed to link with %d out of %d "
"varyings used\n",
num_varyings, max_varyings);
return false;
} else {
piglit_report_result(PIGLIT_FAIL);
}
}
glUseProgram(prog);
loc = glGetUniformLocation(prog, "zero");
if (loc != -1) /* not used for num_varyings == 1 */
glUniform1f(loc, 0.0);
loc = glGetUniformLocation(prog, "one");
assert(loc != -1); /* should always be used */
glUniform1f(loc, 1.0);
x = coord_from_index(data_varying);
y = coord_from_index(num_varyings - 1);
vertex[0][0] = x;
vertex[0][1] = y;
vertex[1][0] = x + 2;
vertex[1][1] = y;
vertex[2][0] = x;
vertex[2][1] = y + 2;
vertex[3][0] = x + 2;
vertex[3][1] = y + 2;
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glDeleteShader(vs);
glDeleteShader(fs);
glDeleteProgram(prog);
}
return true;
}
enum piglit_result
piglit_display(void)
{
GLint max_components;
int max_varyings, row, col;
int max_xfb_varyings = 0;
GLint max_xfb_components;
GLboolean pass = GL_TRUE, warned = GL_FALSE;
GLuint vs, fs;
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
glGetIntegerv(GL_MAX_VARYING_FLOATS, &max_components);
max_varyings = max_components / 4;
printf("GL_MAX_VARYING_FLOATS = %i\n", max_components);
if (max_varyings > MAX_VARYING) {
printf("test not designed to handle >%d varying vec4s.\n"
"(implementation reports %d components)\n",
max_components, MAX_VARYING);
max_varyings = MAX_VARYING;
warned = GL_TRUE;
}
glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS,
&max_xfb_components);
max_xfb_varyings = MIN2(max_xfb_components / 4, max_varyings);
printf("GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = %i\n",
max_xfb_components);
vs = get_vs(max_varyings);
fs = get_fs(max_varyings);
glClearColor(0.5, 0.5, 0.5, 0.5);
glClear(GL_COLOR_BUFFER_BIT);
for (row = 0; row < max_xfb_varyings; row++) {
pass = draw(vs, fs, row + 1, max_xfb_varyings) && pass;
}
for (row = 0; row < max_varyings; row++) {
for (col = 0; col < max_varyings - row; col++) {
GLboolean ok;
float green[3] = {0.0, 1.0, 0.0};
ok = piglit_probe_rect_rgb(coord_from_index(col),
coord_from_index(row),
10, 10,
green);
if (!ok) {
printf(" Failure with %d vec4 varyings"
" captured and offset %d\n",
row + 1, col);
pass = GL_FALSE;
break;
}
}
}
piglit_present_results();
if (!pass)
return PIGLIT_FAIL;
if (warned)
return PIGLIT_WARN;
else
return PIGLIT_PASS;
}
enum piglit_result
piglit_display(void)
{
GLint max_components;
int max_varyings;
int max_xfb_varyings = 0;
GLint max_xfb_components;
GLboolean pass;
enum piglit_result status = PIGLIT_PASS;
GLuint vs, fs;
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
glGetIntegerv(GL_MAX_VARYING_FLOATS, &max_components);
max_varyings = max_components / 4;
init_xfb_varyings(max_varyings);
printf("GL_MAX_VARYING_FLOATS = %i\n", max_components);
if (max_varyings > MAX_VARYING) {
printf("test not designed to handle >%d varying vec4s.\n"
"(implementation reports %d components)\n",
max_components, MAX_VARYING);
max_varyings = MAX_VARYING;
status = PIGLIT_WARN;
}
glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS,
&max_xfb_components);
max_xfb_varyings = MIN2(max_xfb_components / 4, max_varyings);
printf("GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = %i\n",
max_xfb_components);
/* Test single dimension array */
vs = get_vs(max_varyings);
fs = get_fs(max_varyings);
pass = run_subtest(vs, fs, max_xfb_varyings,
max_varyings, xfb_varying_array);
if (!pass) {
status = PIGLIT_FAIL;
}
piglit_report_subtest_result(status,
"max-varying-single-dimension-array");
/* Test arrays of arrays */
if (piglit_is_extension_supported("GL_ARB_arrays_of_arrays")) {
bool subtest_result;
vs = get_vs_aoa(max_varyings);
fs = get_fs_aoa(max_varyings);
subtest_result = run_subtest(vs, fs, max_xfb_varyings,
max_varyings, xfb_varying_aoa);
if (!subtest_result) {
status = PIGLIT_FAIL;
pass = false;
}
piglit_report_subtest_result(status,
"max-varying-arrays-of-arrays");
}
piglit_present_results();
return status;
}
