void piglit_init(int argc, char **argv)
{
bool pass = true;
unsigned i;
if (argc == 1) {
usage_and_fail(argv[0]);
}
for (i = 1; i < argc; i++) {
if (strcmp("110", argv[i]) == 0) {
pass = do_test(glsl110_tests,
ARRAY_SIZE(glsl110_tests))
&& pass;
} else if (strcmp("120", argv[i]) == 0) {
piglit_require_GLSL_version(120);
pass = do_test(glsl120_tests,
ARRAY_SIZE(glsl120_tests))
&& pass;
} else if (strcmp("130", argv[i]) == 0) {
piglit_require_GLSL_version(130);
pass = do_test(glsl130_tests,
ARRAY_SIZE(glsl130_tests))
&& pass;
} else {
usage_and_fail(argv[0]);
}
}
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
void
piglit_init(int argc, char **argv)
{
int vs, fs, prog;
int tex_location;
piglit_require_GLSL_version(130);
glActiveTexture(GL_TEXTURE0);
piglit_rgbw_texture(GL_RGBA, tex_size, tex_size / 2, true, false,
GL_UNSIGNED_NORMALIZED);
piglit_ortho_projection(piglit_width, piglit_height, false);
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vert);
fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, frag);
prog = piglit_link_simple_program(vs, fs);
tex_location = piglit_GetUniformLocation(prog, "tex");
lod_location = piglit_GetUniformLocation(prog, "lod");
pos_location = piglit_GetUniformLocation(prog, "pos");
piglit_UseProgram(prog);
piglit_Uniform1i(tex_location, 0);
}
void
piglit_init(int argc, char **argv)
{
bool pass = true;
GLint val;
piglit_require_GLSL_version(130);
glGetIntegerv(GL_MIN_PROGRAM_TEXEL_OFFSET, &val);
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
if (val > -8) {
fprintf(stderr,
"query of GL_MIN_PROGRAM_TEXEL_OFFSET "
"returned %d, must be at least -8\n",
val);
pass = false;
}
glGetIntegerv(GL_MAX_PROGRAM_TEXEL_OFFSET, &val);
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
if (val < 7) {
fprintf(stderr,
"query of GL_MAX_PROGRAM_TEXEL_OFFSET "
"returned %d, must be at least 7\n",
val);
pass = false;
}
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
void
piglit_init(int argc, char **argv)
{
piglit_require_GLSL_version(140);
if (argc != 3)
usage(argv[0]);
test_vs = strcmp(argv[1], "vs") == 0;
if (!test_vs && strcmp(argv[1], "fs") != 0)
usage(argv[0]);
test_arb = strcmp(argv[2], "arb") == 0;
if (!test_arb && strcmp(argv[2], "core") != 0)
usage(argv[0]);
piglit_require_extension("GL_EXT_texture_integer");
piglit_require_extension("GL_ARB_texture_rg");
if (test_arb) {
piglit_require_extension("GL_ARB_texture_buffer_object");
} else {
if (piglit_get_gl_version() < 31)
piglit_require_extension("GL_ARB_texture_buffer_object");
}
init_programs();
}
void piglit_init(int argc, char **argv)
{
char *endptr;
GLuint vs, fs;
/* Interpret command line args */
if (argc != 2)
print_usage_and_exit(argv[0]);
endptr = argv[1];
additional_offset = strtoul(argv[1], &endptr, 0);
if (*endptr != '\0')
print_usage_and_exit(argv[0]);
if (additional_offset > 12 || additional_offset % 4 != 0)
print_usage_and_exit(argv[0]);
piglit_require_GLSL_version(130);
piglit_require_gl_version(30);
piglit_require_transform_feedback();
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext);
fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fstext);
prog = piglit_CreateProgram();
piglit_AttachShader(prog, vs);
piglit_AttachShader(prog, fs);
piglit_TransformFeedbackVaryings(prog, 5, varyings,
GL_INTERLEAVED_ATTRIBS);
piglit_LinkProgram(prog);
if (!piglit_link_check_status(prog))
piglit_report_result(PIGLIT_FAIL);
glGenBuffers(1, &xfb_buf);
if (!piglit_check_gl_error(0))
piglit_report_result(PIGLIT_FAIL);
}
void
piglit_init(int argc, char **argv)
{
GLuint prog;
char *vs_text;
if (strcmp(argv[1], "drawid") == 0) {
(void)!asprintf(&vs_text, vs_template,
"ref.x == gl_DrawIDARB");
} else if (strcmp(argv[1], "vertexid") == 0) {
(void)!asprintf(&vs_text, vs_template,
"ref.x == gl_DrawIDARB && ref.y == gl_VertexID");
} else {
printf("Unknown subtest: %s\n", argv[1]);
piglit_report_result(PIGLIT_FAIL);
}
piglit_require_GLSL_version(130);
piglit_require_extension("GL_ARB_shader_draw_parameters");
piglit_require_extension("GL_ARB_base_instance");
prog = piglit_build_simple_program(vs_text, fs_text);
glUseProgram(prog);
}
void
piglit_init(int argc, char **argv)
{
bool pass = true;
GLint prog = 0;
GLint active_attribs = 0;
GLint max_length = 0;
piglit_require_GLSL_version(150);
prog = piglit_build_simple_program(vs_source, fs_source);
glUseProgram(prog);
glGetProgramiv(prog, GL_ACTIVE_ATTRIBUTES, &active_attribs);
glGetProgramiv(prog, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &max_length);
/*
* Check the size of the given attribute with the
* corresponding expected array size.
*/
pass = getAttribLocTest(prog, active_attribs, max_length, "a", 1) && pass;
pass = getAttribLocTest(prog, active_attribs, max_length, "b", 2) && pass;
pass = getAttribLocTest(prog, active_attribs, max_length, "c", 3) && pass;
pass = getAttribLocTest(prog, active_attribs, max_length, "d", 4) && pass;
pass = getAttribLocTest(prog, active_attribs, max_length, "e", 5) && pass;
glDeleteProgram(prog);
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
/**
* Ensures the driver supports the required extensions, GL, and GLSL versions.
* If it doesn't, report PIGLIT_SKIP and exit the test.
*/
void
require_GL_features(enum shader_target test_stage)
{
int tex_units;
piglit_require_GLSL_version(shader_version);
if (swizzling)
piglit_require_extension("GL_EXT_texture_swizzle");
switch (sampler.internal_format) {
case GL_RGBA32I:
case GL_RGBA16I:
piglit_require_extension("GL_EXT_texture_integer");
break;
case GL_RGBA32UI:
case GL_RGBA16UI:
if (piglit_is_extension_supported("GL_EXT_gpu_shader4"))
piglit_require_gl_version(21);
else
piglit_require_gl_version(30);
break;
case GL_RGBA32F:
case GL_RGBA16F:
piglit_require_extension("GL_ARB_texture_float");
break;
}
switch (sampler.target) {
case GL_TEXTURE_CUBE_MAP_ARRAY:
piglit_require_extension("GL_ARB_texture_cube_map_array");
break;
case GL_TEXTURE_1D_ARRAY:
case GL_TEXTURE_2D_ARRAY:
piglit_require_extension("GL_EXT_texture_array");
break;
case GL_TEXTURE_CUBE_MAP:
if (is_shadow_sampler()) {
if (piglit_is_extension_supported("GL_EXT_gpu_shader4"))
piglit_require_gl_version(21);
else
piglit_require_gl_version(30);
}
break;
case GL_TEXTURE_RECTANGLE:
piglit_require_extension("GL_ARB_texture_rectangle");
break;
case GL_TEXTURE_BUFFER:
piglit_require_extension("GL_ARB_texture_buffer_object");
break;
case GL_TEXTURE_2D_MULTISAMPLE:
case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
piglit_require_extension("GL_ARB_texture_multisample");
}
/* If testing in the VS, check for VS texture units */
glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &tex_units);
if (test_stage == VS && tex_units <= 0)
piglit_report_result(PIGLIT_SKIP);
}
enum piglit_result
piglit_display(void)
{
GLboolean pass = GL_TRUE;
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
glClear(GL_COLOR_BUFFER_BIT);
if (Tests & TEST_FIXED_FUNC) {
pass = test_fixed_function() && pass;
}
if (Tests & TEST_ARB_FP) {
piglit_require_extension("GL_ARB_fragment_program");
pass = test_arb_fp() && pass;
}
if (Tests & TEST_GLSL) {
piglit_require_GLSL_version(110);
pass = test_glsl() && pass;
}
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
void
piglit_init(int argc, char **argv)
{
int i;
GLuint vs;
/* Parse params */
if (argc != 2)
print_usage_and_exit(argv[0]);
for (i = 0; i < ARRAY_SIZE(tests); i++) {
if (strcmp(argv[1], tests[i].name) == 0) {
test = &tests[i];
break;
}
}
if (test == NULL)
print_usage_and_exit(argv[0]);
piglit_require_GLSL_version(110);
if (!piglit_is_extension_supported("GL_NV_primitive_restart") &&
piglit_get_gl_version() < 31) {
printf("GL_NV_primitive_restart or GL 3.1 required\n");
piglit_report_result(PIGLIT_SKIP);
}
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_text);
prog = piglit_link_simple_program(vs, 0);
if (!prog)
piglit_report_result(PIGLIT_FAIL);
glDeleteShader(vs);
vertex_attr = glGetAttribLocation(prog, "vertex");
window_size_loc = glGetUniformLocation(prog, "window_size");
offset_loc = glGetUniformLocation(prog, "offset");
color_loc = glGetUniformLocation(prog, "color");
}
void piglit_init(int argc, char **argv)
{
int i;
piglit_require_extension("GL_ARB_framebuffer_object");
piglit_require_extension("GL_ARB_texture_storage");
piglit_require_GLSL_version(120);
format = GL_RGBA8;
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "RGB9_E5") == 0) {
/* Test a non-renderable format. */
piglit_require_extension("GL_EXT_texture_shared_exponent");
format = GL_RGB9_E5;
}
else {
assert(0);
}
}
prog = piglit_build_simple_program(NULL, fs_3d);
glClearColor(0.25, 0.25, 0.25, 0.25);
}
static GLuint
make_program(void)
{
const char *snippet = sample_function->snippet;
int glsl_version = sample_function->glsl_version;
int snippet_length = strlen(snippet);
int snippet_pos = strstr(fragment_source, "SNIPPET") - fragment_source;
GLuint program;
char source[1000], *p = source;
if (glsl_version > 0) {
p += sprintf(p, "#version %i\n", glsl_version);
piglit_require_GLSL_version(glsl_version);
}
if (sample_function->extension) {
p += sprintf(p,
"#extension %s : require\n",
sample_function->extension);
piglit_require_extension(sample_function->extension);
}
memcpy(p, fragment_source, snippet_pos);
p += snippet_pos;
memcpy(p, snippet, snippet_length);
p += snippet_length;
memcpy(p,
fragment_source + snippet_pos + 7,
sizeof fragment_source - snippet_pos - 7);
program = piglit_build_simple_program(vertex_source, source);
return program;
}
void
piglit_init(int argc, char **argv)
{
piglit_require_GLSL_version(140);
if (piglit_get_gl_version() < 31)
piglit_require_extension("GL_ARB_texture_buffer_object");
}
void
piglit_init(int argc, char **argv)
{
GLint maxColorTextureSamples;
/* glClearTexture is either in the GL_ARB_clear_texture
* extension or in core in GL 4.4
*/
if (piglit_get_gl_version() < 44 &&
!piglit_is_extension_supported("GL_ARB_clear_texture")) {
printf("OpenGL 4.4 or GL_ARB_clear_texture is required.\n");
piglit_report_result(PIGLIT_SKIP);
}
piglit_require_extension("GL_ARB_texture_multisample");
piglit_require_GLSL_version(130);
/* We need to support multisample textures with at least 4
* samples */
glGetIntegerv(GL_MAX_COLOR_TEXTURE_SAMPLES, &maxColorTextureSamples);
if (maxColorTextureSamples < TEX_SAMPLES) {
printf("At least %i texture samples are required\n",
TEX_SAMPLES);
piglit_report_result(PIGLIT_SKIP);
}
init_program();
}
void
piglit_init(int argc, char **argv)
{
piglit_require_extension("GL_ARB_framebuffer_object");
piglit_require_extension("GL_EXT_texture_integer");
piglit_require_extension("GL_EXT_gpu_shader4");
piglit_require_GLSL_version(130);
PassthroughFragShader = piglit_compile_shader_text(GL_FRAGMENT_SHADER,
PassthroughFragShaderText);
assert(PassthroughFragShader);
PassthroughProgram = piglit_link_simple_program(0, PassthroughFragShader);
SimpleFragShader = piglit_compile_shader_text(GL_FRAGMENT_SHADER,
SimpleFragShaderText);
assert(SimpleFragShader);
SimpleProgram = piglit_link_simple_program(0, SimpleFragShader);
(void) check_error(__FILE__, __LINE__);
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
}
void
piglit_init(int argc, char **argv)
{
piglit_require_GLSL_version(130);
glGenFramebuffers(1, &fbo);
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glGenTextures(1, &color0);
glBindTexture(GL_TEXTURE_2D, color0);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, color0, 0);
glGenTextures(1, &color1);
glBindTexture(GL_TEXTURE_2D, color1);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, color1, 0);
glGenTextures(1, &color2);
glBindTexture(GL_TEXTURE_2D, color2);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_TEXTURE_2D, color2, 0);
glDrawBuffers(3, buffers);
prog = piglit_build_simple_program(
"#version 130\n"
"in vec4 pos;\n"
"void main() {\n"
" gl_Position = pos;\n"
"}\n",
"#version 130\n"
"void main() {\n"
" float alpha = float(int(gl_FragCoord.x / 16 + gl_FragCoord.y / 16) % 2);\n"
" /*Don't write color to draw buffer zero i.e. gl_FragData[0] */\n"
" gl_FragData[1] = vec4(1.0, 0.0, 0.0, alpha);\n"
" gl_FragData[2] = vec4(0.0, 1.0, 0.0, 1.0);\n"
"}\n"
);
if (!piglit_check_gl_error(GL_NO_ERROR)) {
printf("Setup for test failed.\n");
piglit_report_result(PIGLIT_SKIP);
}
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
printf("Framebuffer not complete.\n");
piglit_report_result(PIGLIT_SKIP);
}
}
void
piglit_init(int argc, char **argv)
{
piglit_require_gl_version(30);
piglit_require_GLSL();
piglit_require_GLSL_version(130);
piglit_require_extension("GL_ARB_cull_distance");
prog = piglit_build_simple_program(vert, frag);
glUseProgram(prog);
}
void
piglit_init(int argc, char **argv)
{
GLuint prog;
piglit_require_GLSL_version(130);
prog = piglit_build_simple_program(vs_text, fs_text);
glUseProgram(prog);
}
void piglit_init(int argc, char **argv)
{
piglit_require_gl_version(20);
piglit_require_GLSL_version(120);
piglit_require_transform_feedback();
glGenBuffers(1, &xfb_buf);
printf("Vertical axis: Increasing numbers of varyings captured by "
"transform feedback.\n");
printf("Horizontal axis: Offset of first varying captured.\n");
}
void piglit_init(int argc, char **argv)
{
int i;
piglit_require_extension("GL_ARB_framebuffer_object");
piglit_require_extension("GL_ARB_texture_storage");
piglit_require_GLSL_version(120);
format = GL_RGBA8;
target = GL_TEXTURE_CUBE_MAP;
num_layers = 6;
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "array") == 0) {
piglit_require_GLSL_version(130);
piglit_require_extension("GL_ARB_texture_cube_map_array");
test_array = GL_TRUE;
target = GL_TEXTURE_CUBE_MAP_ARRAY;
num_layers = 6 * 5;
}
else if (strcmp(argv[i], "RGB9_E5") == 0) {
/* Test a non-renderable format. */
piglit_require_extension("GL_EXT_texture_shared_exponent");
format = GL_RGB9_E5;
}
else if (strcmp(argv[i], "S3TC_DXT1") == 0) {
/* Test a compressed format. */
piglit_require_extension("GL_EXT_texture_compression_s3tc");
format = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
piglit_set_tolerance_for_bits(5, 6, 5, 8);
}
else {
assert(0);
}
}
prog = piglit_build_simple_program(NULL, test_array ? fs_cube_array :
fs_cube);
glClearColor(0.25, 0.25, 0.25, 0.25);
}
void
do_requires(void)
{
int max_components;
piglit_require_GLSL_version(130);
piglit_require_extension("GL_ARB_texture_gather");
/* check whether component count will actually work */
glGetIntegerv(GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB, &max_components);
if (components > max_components) {
printf("Test requires gather from texture with %d components;"
"This implementation only supports %d\n",
components, max_components);
piglit_report_result(PIGLIT_SKIP);
}
/* if we are trying to swizzle, check that we can! */
if (swizzle != -1)
piglit_require_extension("GL_EXT_texture_swizzle");
/* check the sampler type we want actually exists */
if (sampler == SAMPLER_CUBEARRAY)
piglit_require_extension("GL_ARB_texture_cube_map_array");
if (use_offset && (sampler == SAMPLER_CUBE || sampler == SAMPLER_CUBEARRAY)) {
printf("Offset is not supported with cube or cube array samplers.\n");
piglit_report_result(PIGLIT_SKIP);
}
if (comptype == SHADOW_T && components > 1) {
printf("Shadow supported with single-component textures only\n");
piglit_report_result(PIGLIT_SKIP);
}
if (comptype == SHADOW_T && comp_select != -1) {
printf("Shadow not supported with component select parameter\n");
piglit_report_result(PIGLIT_SKIP);
}
/* if we are trying to specify the component from the shader,
* or use non-constant offsets, or use shadow comparitor, or
* use gsampler2DRect, check that we have ARB_gpu_shader5
*/
if (comp_select != -1 || use_nonconst || comptype == SHADOW_T || sampler == SAMPLER_2DRECT)
piglit_require_extension("GL_ARB_gpu_shader5");
/* if rect sampler, repeat is not available */
if (sampler == SAMPLER_2DRECT && address_mode == GL_REPEAT) {
printf("GL_REPEAT not supported with rectangle textures\n");
piglit_report_result(PIGLIT_SKIP);
}
}
void
piglit_init(int argc, char **argv)
{
GLuint vs;
int i;
/* Parse params. */
if (argc != 2)
print_usage_and_exit(argv[0]);
test_to_run = find_matching_test(argv[0], argv[1]);
/* Set up test */
piglit_require_GLSL_version(test_to_run->version);
piglit_require_transform_feedback();
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, test_to_run->vs);
prog = glCreateProgram();
glAttachShader(prog, vs);
glBindAttribLocation(prog, 0, "vertex_pos");
glBindAttribLocation(prog, 1, "vertex_num");
glTransformFeedbackVaryings(prog, test_to_run->num_varyings,
(const char **) test_to_run->varyings,
GL_INTERLEAVED_ATTRIBS_EXT);
glLinkProgram(prog);
if (!piglit_link_check_status(prog)) {
glDeleteProgram(prog);
piglit_report_result(PIGLIT_FAIL);
}
/* Test that GetTransformFeedbackVarying reports the correct
* size and type for all of the varyings.
*/
for (i = 0; i < test_to_run->num_varyings; ++i) {
GLsizei size;
GLenum type;
glGetTransformFeedbackVarying(prog, i, 0, NULL, &size,
&type, NULL);
if (size != test_to_run->expected_size) {
printf("For varying %i, expected size %i, got %i\n",
i, test_to_run->expected_size, size);
size_and_type_ok = GL_FALSE;
}
if (type != test_to_run->expected_type) {
printf("For varying %i, expected type %i, got %i\n",
i, test_to_run->expected_type, type);
size_and_type_ok = GL_FALSE;
}
}
glGenBuffers(1, &xfb_buf);
glGenQueries(1, &query);
glEnable(GL_VERTEX_PROGRAM_TWO_SIDE);
}
void
piglit_init(int argc, char **argv)
{
bool pass = true;
GLuint buffer;
unsigned int i;
double *map;
piglit_require_extension("GL_ARB_shader_storage_buffer_object");
piglit_require_extension("GL_ARB_gpu_shader_fp64");
piglit_require_GLSL_version(150);
prog = piglit_build_simple_program_multiple_shaders(
GL_VERTEX_SHADER, vs_code,
GL_GEOMETRY_SHADER, gs_source,
GL_FRAGMENT_SHADER, fs_source,
NULL);
glUseProgram(prog);
glClearColor(0, 0, 0, 0);
glGenBuffers(1, &buffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, buffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, SSBO_SIZE*sizeof(GLdouble),
&ssbo_values[0], GL_DYNAMIC_DRAW);
glViewport(0, 0, piglit_width, piglit_height);
piglit_draw_rect(-1, -1, 2, 2);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer);
map = (double *) glMapBuffer(GL_SHADER_STORAGE_BUFFER, GL_READ_ONLY);
for (i = 0; i < SSBO_SIZE; i++) {
if (DIFFER(map[i], expected[i])) {
printf("expected[%d] = %.14g. Read value: %.14g\n",
i, expected[i], map[i]);
pass = false;
}
}
glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
if (!piglit_check_gl_error(GL_NO_ERROR))
pass = false;
glDeleteProgram(prog);
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
void
piglit_init(int argc, char **argv)
{
int prog;
piglit_require_GLSL_version(130);
prog = piglit_build_simple_program(vs_source, fs_source);
coord1_location = glGetUniformLocation(prog, "coord1");
coord2_location = glGetUniformLocation(prog, "coord2");
glUseProgram(prog);
}
void
piglit_init(int argc, char **argv)
{
GLuint vs, fs, prog;
piglit_require_GLSL_version(130);
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_text);
fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_text);
prog = piglit_link_simple_program(vs, fs);
if (!vs || !fs || !prog)
piglit_report_result(PIGLIT_FAIL);
glUseProgram(prog);
}
void
piglit_init(int argc, char **argv)
{
piglit_require_extension("GL_ARB_framebuffer_object");
piglit_require_extension("GL_ARB_texture_barrier");
piglit_require_GLSL_version(130);
width = 256;
height = 128;
initialize_program();
initialize_texture();
initialize_fbo();
glViewport(0, 0, width, height);
}
void
piglit_init(int argc, char **argv)
{
int i;
/* Set up test */
piglit_require_GLSL_version(150);
piglit_require_transform_feedback();
piglit_require_extension("GL_ARB_gpu_shader_fp64");
for (i = 0; i < ARRAY_SIZE(tests); i++)
run_test(&tests[i]);
if (size_and_type_ok == false)
piglit_report_result(PIGLIT_FAIL);
piglit_report_result(PIGLIT_PASS);
}
void
piglit_init(int argc, char **argv)
{
bool pass = true;
unsigned int i;
piglit_require_extension("GL_ARB_uniform_buffer_object");
piglit_require_GLSL_version(140);
printf("%-20s %20s %20s\n", "type", "GL_UNIFORM_TYPE", "expected");
printf("--------------------------------------------------------------\n");
for (i = 0; uniform_types[i].type; i++) {
pass = test_format(&uniform_types[i]) && pass;
}
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
void
piglit_init(int argc, char **argv)
{
enum test_array_type array_type;
GLint max_varying_floats;
struct varying_desc *varyings;
unsigned num_varyings;
unsigned glsl_version;
GLuint vs, fs;
if (argc != 3)
print_usage_and_exit(argv[0]);
glsl_version = test_type->glsl_version_required;
if (strcmp(argv[2], "array") == 0)
array_type = ARRAY;
else if (strcmp(argv[2], "separate") == 0)
array_type = SEPARATE;
else if (strcmp(argv[2], "arrays_of_arrays") == 0) {
array_type = ARRAYS_OF_ARRAYS;
piglit_require_extension("GL_ARB_arrays_of_arrays");
if (glsl_version < 120)
glsl_version = 120;
} else
print_usage_and_exit(argv[0]);
piglit_require_gl_version(20);
piglit_require_GLSL_version(glsl_version);
if (test_type->base == BASE_TYPE_DOUBLE)
piglit_require_extension("GL_ARB_gpu_shader_fp64");
glGetIntegerv(GL_MAX_VARYING_FLOATS, &max_varying_floats);
varyings = malloc(sizeof(*varyings) * max_varying_floats);
num_varyings = choose_varyings(varyings, test_type,
array_type, max_varying_floats);
vs = get_shader(true, test_type->glsl_version_required,
num_varyings, varyings, array_type);
fs = get_shader(false, test_type->glsl_version_required,
num_varyings, varyings, array_type);
prog = piglit_link_simple_program(vs, fs);
i_location = glGetUniformLocation(prog, "i");
free(varyings);
}
void
piglit_init(int argc, char **argv)
{
bool pass = true;
GLuint buffer;
unsigned int i;
float ssbo_values[SSBO_SIZE] = {0};
float *map;
piglit_require_extension("GL_ARB_shader_storage_buffer_object");
piglit_require_GLSL_version(130);
prog = piglit_build_simple_program(vs_pass_thru_text, fs_source);
glUseProgram(prog);
glClearColor(0, 0, 0, 0);
glGenBuffers(1, &buffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, buffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, SSBO_SIZE*sizeof(GLfloat),
&ssbo_values[0], GL_DYNAMIC_DRAW);
glViewport(0, 0, piglit_width, piglit_height);
piglit_draw_rect(-1, -1, 2, 2);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer);
map = (float *) glMapBuffer(GL_SHADER_STORAGE_BUFFER, GL_READ_ONLY);
for (i = 0; i < SSBO_SIZE; i++) {
if (map[i] != expected[i]) {
printf("expected[%d] = %.2f. Read value: %.2f\n",
i, expected[i], map[i]);
pass = false;
}
}
glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
if (!piglit_check_gl_error(GL_NO_ERROR))
pass = false;
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
