void piglit_init(int argc, char **argv) { GLboolean try_to_render; GLuint vs; GLuint fs; piglit_require_gl_version(20); piglit_require_extension("GL_EXT_separate_shader_objects"); glClearColor(0.3, 0.3, 0.3, 0.0); piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_text); fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_text); prog[0] = piglit_link_simple_program(vs, 0); prog[1] = piglit_link_simple_program(0, fs); glDeleteShader(vs); glDeleteShader(fs); /* Don't try to render if either program failed to link, and linking * had better succeed! */ try_to_render = piglit_link_check_status(prog[0]); try_to_render = piglit_link_check_status(prog[1]) && try_to_render; if (!try_to_render) piglit_report_result(PIGLIT_FAIL); }
void piglit_init(int argc, char **argv) { unsigned glsl_version; GLuint vs_prog; GLuint fs_prog_same_declaration_order; GLuint fs_prog_same_location_order; char *source; piglit_require_vertex_shader(); piglit_require_fragment_shader(); piglit_require_extension("GL_ARB_separate_shader_objects"); piglit_require_extension("GL_ARB_explicit_attrib_location"); glsl_version = pick_a_glsl_version(); (void)!asprintf(&source, vs_code_template, glsl_version); vs_prog = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, (const GLchar *const *) &source); piglit_link_check_status(vs_prog); free(source); (void)!asprintf(&source, fs_code_same_declaration_order_template, glsl_version); fs_prog_same_declaration_order = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, (const GLchar *const *) &source); piglit_link_check_status(fs_prog_same_declaration_order); free(source); (void)!asprintf(&source, fs_code_same_location_order_template, glsl_version); fs_prog_same_location_order = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, (const GLchar *const *) &source); piglit_link_check_status(fs_prog_same_location_order); free(source); glGenProgramPipelines(1, &pipeline_same_declaration_order); glUseProgramStages(pipeline_same_declaration_order, GL_VERTEX_SHADER_BIT, vs_prog); glUseProgramStages(pipeline_same_declaration_order, GL_FRAGMENT_SHADER_BIT, fs_prog_same_declaration_order); piglit_program_pipeline_check_status(pipeline_same_declaration_order); glGenProgramPipelines(1, &pipeline_same_location_order); glUseProgramStages(pipeline_same_location_order, GL_VERTEX_SHADER_BIT, vs_prog); glUseProgramStages(pipeline_same_location_order, GL_FRAGMENT_SHADER_BIT, fs_prog_same_location_order); piglit_program_pipeline_check_status(pipeline_same_location_order); if (!piglit_check_gl_error(0)) piglit_report_result(PIGLIT_FAIL); }
void run_test(struct get_tests *test) { GLsizei size; GLenum type; GLuint vs; GLuint prog; char vstest[1024]; snprintf(vstest, 1024, vstext, test->glsltype, test->glsltype); vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstest); prog = glCreateProgram(); glAttachShader(prog, vs); glBindAttribLocation(prog, 0, "vertex"); glTransformFeedbackVaryings(prog, ARRAY_SIZE(varyings), varyings, GL_INTERLEAVED_ATTRIBS_EXT); glLinkProgram(prog); if (!piglit_link_check_status(prog)) { glDeleteProgram(prog); piglit_report_result(PIGLIT_FAIL); } glGetTransformFeedbackVarying(prog, 0, 0, NULL, &size, &type, NULL); if (size != test->size) { printf("For %s, size %d vs %d\n", test->glsltype, size, test->size); size_and_type_ok = false; } if (type != test->type) { printf("For %s, size %d vs %d\n", test->glsltype, type, test->type); size_and_type_ok = false; } glDeleteProgram(prog); }
PIGLIT_GL_TEST_CONFIG_END bool compile_simple_program(const char* vs_text, const char* fs_text) { GLuint vs; GLuint fs; GLuint prog; bool status; prog = glCreateProgram(); vs = piglit_compile_shader_text_nothrow(GL_VERTEX_SHADER, vs_text); fs = piglit_compile_shader_text_nothrow(GL_FRAGMENT_SHADER, fs_text); if (!vs || !fs) return false; glAttachShader(prog, vs); glAttachShader(prog, fs); glLinkProgram(prog); status = piglit_link_check_status(prog); glDeleteProgram(prog); return status; }
void piglit_init(int argc, char *argv[]) { GLuint vs, gs, prog; piglit_require_gl_version(15); piglit_require_GLSL(); do_query_init(queries, ARRAY_SIZE(queries)); prog = glCreateProgram(); vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_src); gs = piglit_compile_shader_text(GL_GEOMETRY_SHADER, gs_src); #ifndef DISPLAY glEnable(GL_RASTERIZER_DISCARD); #else glAttachShader(prog, piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_src)); #endif glAttachShader(prog, vs); glAttachShader(prog, gs); glLinkProgram(prog); if (!piglit_link_check_status(prog)) { glDeleteProgram(prog); piglit_report_result(PIGLIT_FAIL); } glUseProgram(prog); }
void piglit_init(int argc, char **argv) { GLint vert; GLint prog; GLboolean ok; piglit_require_gl_version(20); piglit_require_extension("GL_ARB_explicit_attrib_location"); vert = piglit_compile_shader(GL_VERTEX_SHADER, "shaders/glsl-explicit-location-01.vert"); prog = glCreateProgram(); glAttachShader(prog, vert); glLinkProgram(prog); ok = piglit_link_check_status(prog); if (ok) { GLint loc = glGetAttribLocation(prog, "vertex"); if (loc != 0) { fprintf(stderr, "Expected location of 'vertex' to be 0, got " "%d instead.\n", loc); ok = GL_FALSE; } } piglit_report_result(ok ? PIGLIT_PASS : PIGLIT_FAIL); }
static bool build_and_use_program(GLint gs_invocation_n, const char *gs_template, const char **gs_varyings, int array_size) { GLuint prog; char *gs_text; asprintf(&gs_text, gs_template, gs_invocation_n); prog = piglit_build_simple_program_multiple_shaders( GL_VERTEX_SHADER, vs_pass_thru_text, GL_GEOMETRY_SHADER, gs_text, 0); free(gs_text); glTransformFeedbackVaryings(prog, array_size, gs_varyings, GL_INTERLEAVED_ATTRIBS); glLinkProgram(prog); if (!piglit_link_check_status(prog)) return false; if (!piglit_check_gl_error(GL_NO_ERROR)) return false; glUseProgram(prog); return true; }
void piglit_init(int argc, char **argv) { GLint ok; GLuint prog; GLuint fs[2]; if (piglit_get_gl_version() < 20) { printf("Requires OpenGL 2.0\n"); piglit_report_result(PIGLIT_SKIP); } piglit_require_extension("GL_ARB_fragment_coord_conventions"); fs[0] = piglit_compile_shader_text(GL_FRAGMENT_SHADER, layout_center); fs[1] = piglit_compile_shader_text(GL_FRAGMENT_SHADER, layout_upper); prog = glCreateProgram(); glAttachShader(prog, fs[0]); glAttachShader(prog, fs[1]); glLinkProgram(prog); glDeleteShader(fs[0]); glDeleteShader(fs[1]); ok = piglit_link_check_status(prog); if (!ok) { fprintf(stderr, "Linking with gl_FragCoord layouts " "failed when it should have succeeded.\n"); piglit_report_result(PIGLIT_FAIL); } piglit_report_result(PIGLIT_PASS); }
void piglit_init(int argc, char **argv) { static const char *varyings[] = { "valOut1", "valOut2" }; GLint inAttrib; /* Check the driver. */ piglit_require_extension("GL_ARB_transform_feedback3"); piglit_require_extension("GL_ARB_direct_state_access"); /* Create shaders. */ prog = piglit_build_simple_program_unlinked(vstext, NULL); glTransformFeedbackVaryings(prog, 2, varyings, GL_SEPARATE_ATTRIBS); glLinkProgram(prog); if (!piglit_link_check_status(prog)) { glDeleteProgram(prog); piglit_report_result(PIGLIT_FAIL); } glUseProgram(prog); /* Set up the Vertex Array Buffer */ glEnable(GL_VERTEX_ARRAY); glGenVertexArrays(1, &vao); glBindVertexArray(vao); /* Set up the input data buffer */ glGenBuffers(1, &input_buf); glBindBuffer(GL_ARRAY_BUFFER, input_buf); glBufferData(GL_ARRAY_BUFFER, sizeof(inputs), inputs, GL_STATIC_DRAW); inAttrib = glGetAttribLocation(prog, "valIn"); piglit_check_gl_error(GL_NO_ERROR); glVertexAttribPointer(inAttrib, 1, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(inAttrib); }
void draw(const float *color, float x_offset) { GLuint vs, fs, prog; GLint color_location; GLint offset_location; 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); glBindAttribLocation(prog, 0, "vertex"); glLinkProgram(prog); piglit_link_check_status(prog); glDeleteShader(vs); glDeleteShader(fs); glUseProgram(prog); color_location = glGetUniformLocation(prog, "color"); offset_location = glGetUniformLocation(prog, "offset"); glUniform4fv(color_location, 1, color); glUniform4f(offset_location, x_offset, 0.0f, 0.0f, 0.0f); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glDeleteProgram(prog); }
void piglit_init(int argc, char **argv) { GLuint vs; if (piglit_get_gl_version() < 20) { printf("Requires OpenGL 2.0\n"); piglit_report_result(PIGLIT_SKIP); } glClearColor(0.3, 0.3, 0.3, 0.0); piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_text); prog = piglit_link_simple_program(vs, 0); glDeleteShader(vs); /* Don't try to render if the program failed to link, and linking * had better succeed! */ if (!piglit_link_check_status(prog)) piglit_report_result(PIGLIT_FAIL); glUseProgram(prog); }
void piglit_init(int argc, char *argv[]) { GLuint prog, array, buf; glGenVertexArrays(1, &array); glBindVertexArray(array); glGenBuffers(1, &buf); glBindBuffer(GL_ARRAY_BUFFER, buf); prog = piglit_build_simple_program(vs_src, fs_src); glVertexAttribPointer(0, /* index */ 4, /* size */ GL_FLOAT, /* type */ GL_FALSE, /* normalized */ 0, /* stride */ NULL /* pointer */); glEnableVertexAttribArray(0); #ifndef DISPLAY glEnable(GL_RASTERIZER_DISCARD); #endif do_query_init(queries, ARRAY_SIZE(queries)); if (!piglit_link_check_status(prog)) { glDeleteProgram(prog); piglit_report_result(PIGLIT_FAIL); } glUseProgram(prog); }
void piglit_init(int argc, char **argv) { GLuint vs; GLint maxcomps, maxattrs; unsigned i; piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); /* Check the driver. */ if (piglit_get_gl_version() < 15) { fprintf(stderr, "OpenGL 1.5 required.\n"); piglit_report_result(PIGLIT_SKIP); } piglit_require_GLSL(); piglit_require_transform_feedback(); glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT, &maxattrs); if (maxattrs < 4) { fprintf(stderr, "Not enough separate attribs supported by transform feedback.\n"); piglit_report_result(PIGLIT_SKIP); } glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT, &maxcomps); if (maxcomps < 4) { fprintf(stderr, "Not enough separate components supported by transform feedback.\n"); piglit_report_result(PIGLIT_SKIP); } /* Create shaders. */ vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext); prog = piglit_CreateProgram(); piglit_AttachShader(prog, vs); piglit_TransformFeedbackVaryings(prog, sizeof(varyings)/sizeof(varyings[0]), varyings, GL_SEPARATE_ATTRIBS_EXT); piglit_LinkProgram(prog); if (!piglit_link_check_status(prog)) { piglit_DeleteProgram(prog); piglit_report_result(PIGLIT_FAIL); } /* Set up the transform feedback buffer. */ glGenBuffers(4, buf); for (i = 0; i < 4; i++) { unsigned j; float *ptr; glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER_EXT, buf[i]); glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER_EXT, NUM_OUT_VERTICES*4*sizeof(float), NULL, GL_STREAM_READ); ptr = glMapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER_EXT, GL_WRITE_ONLY); for (j = 0; j < NUM_OUT_VERTICES*4; j++) { ptr[j] = 0.123456; } glUnmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER_EXT); piglit_BindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER_EXT, i, buf[i]); } assert(glGetError() == 0); glClearColor(0.2, 0.2, 0.2, 1.0); glEnableClientState(GL_VERTEX_ARRAY); }
void piglit_init(int argc, char **argv) { GLuint vs, fs; if (piglit_get_gl_version() < 20) { printf("Requires OpenGL 2.0\n"); piglit_report_result(PIGLIT_SKIP); } vs = piglit_compile_shader(GL_VERTEX_SHADER, "shaders/glsl-color-mvp.vert"); fs = piglit_compile_shader(GL_FRAGMENT_SHADER, "shaders/glsl-color.frag"); prog = piglit_link_simple_program(vs, fs); glDeleteShader(vs); glDeleteShader(fs); /* Don't try to render if the program failed to link, and linking * had better succeed! */ if (!piglit_link_check_status(prog)) piglit_report_result(PIGLIT_FAIL); glUseProgram(prog); }
void piglit_init(int argc, char **argv) { GLuint vs; int num_varyings; piglit_require_GLSL(); piglit_require_transform_feedback(); vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext); for (num_varyings = 1; num_varyings <= 2; ++num_varyings) { GLuint prog = piglit_CreateProgram(); piglit_AttachShader(prog, vs); piglit_BindAttribLocation(prog, 0, "vertex_num"); piglit_TransformFeedbackVaryings(prog, num_varyings, varyings, GL_INTERLEAVED_ATTRIBS); piglit_LinkProgram(prog); if (!piglit_link_check_status(prog)) { piglit_DeleteProgram(prog); piglit_report_result(PIGLIT_FAIL); } progs[num_varyings - 1] = prog; } glGenBuffers(1, &xfb_buf); glGenQueries(1, &query_prims_generated); glGenQueries(1, &query_prims_written); }
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); }
PIGLIT_GL_TEST_CONFIG_END void piglit_init(int argc, char **argv) { bool pass = true; GLuint prog; int i, j; piglit_require_extension("GL_ARB_geometry_shader4"); /* NV_geometry_shader4 relaxes some restrictions on valid program * parameters. */ piglit_require_not_extension("GL_NV_geometry_shader4"); /* Create shader. */ prog = create_shader(vs_text, gs_text, fs_text); glProgramParameteri(prog, GL_GEOMETRY_VERTICES_OUT_ARB, 3); for (i = 0; i < ARRAY_SIZE(primitives_in); i++) { const struct primitive_geom_info geom = primitives_in[i]; if (geom.error != GL_NO_ERROR) continue; glProgramParameteri(prog, GL_GEOMETRY_INPUT_TYPE_ARB, geom.type); glLinkProgram(prog); if (!piglit_link_check_status(prog) || !piglit_check_gl_error(GL_NO_ERROR)) { piglit_report_result(PIGLIT_FAIL); } glUseProgram(prog); glUniform1i(glGetUniformLocation(prog, "vertex_count"), 1); for (j = 0; j < ARRAY_SIZE(primitives_draw); j++) { const struct primitive_draw_info draw = primitives_draw[j]; GLenum e; printf("Testing drawing type %s, geometry input " "type %s.\n", piglit_get_prim_name(draw.type), piglit_get_prim_name(geom.type)); if (draw.base_type == geom.type) e = GL_NO_ERROR; else e = GL_INVALID_OPERATION; glDrawArrays(draw.type, 0, 0); pass = piglit_check_gl_error(e) && pass; } } piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); }
void piglit_init(int argc, char **argv) { int i; const struct test_set *test = NULL; GLuint prog, vs, gs, vao, xfb_buf; char *gs_text; bool pass = true; /* Parse params */ if (argc != 2) print_usage_and_exit(argv[0]); for (i = 0; i < ARRAY_SIZE(tests); i++) { if (strcmp(piglit_get_prim_name(tests[i].prim_type), argv[1]) == 0) { test = &tests[i]; break; } } if (test == NULL) print_usage_and_exit(argv[0]); /* Compile shaders */ prog = glCreateProgram(); vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_text); glAttachShader(prog, vs); (void)!asprintf(&gs_text, gs_template, test->input_layout, test->vertices_per_prim); gs = piglit_compile_shader_text(GL_GEOMETRY_SHADER, gs_text); free(gs_text); glAttachShader(prog, gs); glTransformFeedbackVaryings(prog, test->vertices_per_prim, varyings, GL_INTERLEAVED_ATTRIBS); glLinkProgram(prog); if (!piglit_link_check_status(prog)) piglit_report_result(PIGLIT_FAIL); glUseProgram(prog); /* Set up other GL state */ glGenVertexArrays(1, &vao); glBindVertexArray(vao); glGenBuffers(1, &xfb_buf); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, xfb_buf); glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, MAX_OUTPUT_VERTICES * sizeof(GLint), NULL, GL_STREAM_READ); glGenQueries(1, &generated_query); glEnable(GL_RASTERIZER_DISCARD); for (i = 0; i < ARRAY_SIZE(test->test_vectors); i++) { pass = do_test_vector(test, &test->test_vectors[i]) && pass; } piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); }
void piglit_init(int argc, char **argv) { static const char *varyings[] = { "gl_Position", "gl_FrontColor" }; GLuint vs; glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glScalef(0.5, 0.5, 1.0); /* Check the driver. */ piglit_require_gl_version(15); piglit_require_GLSL(); piglit_require_transform_feedback(); /* Create shaders. */ vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext); prog = glCreateProgram(); glAttachShader(prog, vs); glTransformFeedbackVaryings(prog, 2, varyings, GL_INTERLEAVED_ATTRIBS_EXT); glLinkProgram(prog); if (!piglit_link_check_status(prog)) { glDeleteProgram(prog); piglit_report_result(PIGLIT_FAIL); } glUseProgram(prog); /* Set up the vertex data buffer */ glGenBuffers(1, &vert_buf); glBindBuffer(GL_ARRAY_BUFFER, vert_buf); glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW); /* Set up the transform feedback buffer. */ glGenBuffers(1, &xfb_buf); glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER_EXT, xfb_buf); glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER_EXT, xfb_buf_size, NULL, GL_STREAM_READ); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER_EXT, 0, xfb_buf); glClearColor(0.2, 0.2, 0.2, 1.0); if (argc > 1 && strcmp(argv[1], "large") == 0) { GLint range[2]; glGetIntegerv(GL_ALIASED_POINT_SIZE_RANGE, range); if (range[1] == 1.0) { printf("Max point size is %d, can't test large\n", range[1]); piglit_report_result(PIGLIT_WARN); } printf("Testing large points\n"); glPointSize(10.0); } }
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) { GLuint vs_prog, fs_prog; piglit_require_extension("GL_ARB_separate_shader_objects"); vs_prog = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, (const GLchar *const*) &vs_code); piglit_link_check_status(vs_prog); fs_prog = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, (const GLchar *const *) &fs_code); piglit_link_check_status(fs_prog); glGenProgramPipelines(1, &pipeline); glUseProgramStages(pipeline, GL_VERTEX_SHADER_BIT, vs_prog); glUseProgramStages(pipeline, GL_FRAGMENT_SHADER_BIT, fs_prog); piglit_program_pipeline_check_status(pipeline); if (!piglit_check_gl_error(0)) piglit_report_result(PIGLIT_FAIL); }
/** * Generate a full program pipeline using the shader code provided in * the \a sources array. */ static GLuint generate_program_v(const struct grid_info grid, const char **sources) { const unsigned basic_stages = (GL_FRAGMENT_SHADER_BIT | GL_VERTEX_SHADER_BIT); const unsigned tess_stages = (GL_TESS_CONTROL_SHADER_BIT | GL_TESS_EVALUATION_SHADER_BIT); const unsigned graphic_stages = (basic_stages | tess_stages | GL_GEOMETRY_SHADER_BIT); const unsigned stages = (grid.stages | /* Make a full pipeline if a tesselation shader was * requested. */ (grid.stages & tess_stages ? graphic_stages : 0) | /* Make sure there is always a vertex and fragment * shader if we're doing graphics. */ (grid.stages & graphic_stages ? basic_stages : 0)); GLuint prog = glCreateProgram(); const struct image_stage_info *stage; for (stage = known_image_stages(); stage->stage; ++stage) { if (stages & stage->bit) { char *source = generate_stage_source( grid, stage->stage, sources[get_stage_idx(stage)]); GLuint shader = piglit_compile_shader_text_nothrow( stage->stage, source); free(source); if (!shader) { glDeleteProgram(prog); return 0; } glAttachShader(prog, shader); glDeleteShader(shader); } } glBindAttribLocation(prog, PIGLIT_ATTRIB_POS, "piglit_vertex"); glBindAttribLocation(prog, PIGLIT_ATTRIB_TEX, "piglit_texcoord"); glLinkProgram(prog); if (!piglit_link_check_status(prog)) { glDeleteProgram(prog); return 0; } return prog; }
void piglit_init(int argc, char **argv) { bool pass = true; const GLint *readback; GLuint buf; void *initial_data; int i; GLuint prog = piglit_build_simple_program_unlinked(vs_text, NULL); glTransformFeedbackVaryings(prog, ARRAY_SIZE(varyings), varyings, GL_INTERLEAVED_ATTRIBS); glLinkProgram(prog); if (!piglit_link_check_status(prog) || !piglit_check_gl_error(GL_NO_ERROR)) { piglit_report_result(PIGLIT_FAIL); } glUseProgram(prog); /* Create transform feedback buffer and pre-load it with * garbage. */ glGenBuffers(1, &buf); initial_data = malloc(sizeof(expected_xfb_result)); memset(initial_data, 0xcc, sizeof(expected_xfb_result)); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf); glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, sizeof(expected_xfb_result), initial_data, GL_STREAM_READ); free(initial_data); /* Run the test */ glEnable(GL_RASTERIZER_DISCARD); glBeginTransformFeedback(GL_POINTS); glDrawArrays(GL_POINTS, 0, 1); glEndTransformFeedback(); /* Check output */ readback = glMapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, sizeof(expected_xfb_result), GL_MAP_READ_BIT); for (i = 0; i < ARRAY_SIZE(expected_xfb_result); i++) { if (readback[i] != expected_xfb_result[i]) { printf("XFB[%i] == %i, expected %i\n", i, readback[i], expected_xfb_result[i]); pass = false; } } glUnmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); pass = piglit_check_gl_error(GL_NO_ERROR) && pass; piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); }
static GLboolean draw(GLuint vs, GLuint fs, int num_xfb_varyings, int max_varyings, const char **xfb_varyings) { GLboolean pass = GL_TRUE; int offset; for (offset = 0; offset + num_xfb_varyings <= max_varyings; ++offset) { GLuint prog; float initial_buffer[MAX_VARYING * 6][4]; prog = glCreateProgram(); glAttachShader(prog, vs); glAttachShader(prog, fs); glTransformFeedbackVaryings(prog, num_xfb_varyings, xfb_varyings + offset, GL_INTERLEAVED_ATTRIBS); glLinkProgram(prog); if (!piglit_link_check_status(prog)) piglit_report_result(PIGLIT_FAIL); glUseProgram(prog); glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, xfb_buf); memset(initial_buffer, 0, sizeof(initial_buffer)); glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, sizeof(initial_buffer), initial_buffer, GL_STREAM_READ); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, xfb_buf); glBeginTransformFeedback(GL_TRIANGLES); piglit_draw_rect(coord_from_index(offset), coord_from_index(num_xfb_varyings - 1), 10, 10); glEndTransformFeedback(); pass = check_xfb_output(max_varyings, num_xfb_varyings, offset, xfb_varyings); glDeleteProgram(prog); if (!pass) { break; } } return pass; }
PIGLIT_GL_TEST_CONFIG_END enum piglit_result piglit_display(void) { GLint objID = glCreateProgram(); /* check that it doesn't crash when linking empty shader */ glLinkProgram(objID); glValidateProgram(objID); if (!piglit_link_check_status(objID)) piglit_report_result(PIGLIT_FAIL); glUseProgram(objID); glUseProgram(0); glDeleteProgram(objID); piglit_report_result(PIGLIT_PASS); return PIGLIT_PASS; }
void piglit_init(int argc, char **argv) { piglit_require_gl_version(30); piglit_require_extension("GL_ARB_uniform_buffer_object"); prog = piglit_build_simple_program_unlinked(vstext, fstext); glTransformFeedbackVaryings(prog, 1, varyings, GL_INTERLEAVED_ATTRIBS); glLinkProgram(prog); if (!piglit_link_check_status(prog)) { glDeleteProgram(prog); piglit_report_result(PIGLIT_FAIL); } glGenBuffers(2, bufs); }
static GLuint build_and_use_program(const char *vs_text) { GLuint prog = piglit_build_simple_program_multiple_shaders( GL_VERTEX_SHADER, vs_text, 0); glLinkProgram(prog); if (!piglit_link_check_status(prog)) piglit_report_result(PIGLIT_FAIL); if (!piglit_check_gl_error(GL_NO_ERROR)) piglit_report_result(PIGLIT_FAIL); glUseProgram(prog); return prog; }
static GLuint create_prog(GLint sh1, GLint sh2) { GLint p = 0; p = glCreateProgram(); glProgramParameteri(p, GL_PROGRAM_SEPARABLE, GL_TRUE); if (sh1) glAttachShader(p, sh1); if (sh2) glAttachShader(p, sh2); glLinkProgram(p); pass = piglit_link_check_status(p) && pass; return p; }
void piglit_init(int argc, char **argv) { GLuint vs, i; GLint maxcomps; float *ptr; /* Check the driver. */ piglit_require_transform_feedback(); piglit_require_extension("GL_ARB_gpu_shader_fp64"); piglit_require_extension("GL_ARB_transform_feedback3"); glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT, &maxcomps); if (maxcomps < 18) { fprintf(stderr, "Not enough interleaved components supported by transform feedback.\n"); piglit_report_result(PIGLIT_SKIP); } /* Create shaders. */ vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext); prog = glCreateProgram(); glAttachShader(prog, vs); glTransformFeedbackVaryings(prog, sizeof(varyings)/sizeof(varyings[0]), varyings, GL_INTERLEAVED_ATTRIBS_EXT); glLinkProgram(prog); if (!piglit_link_check_status(prog)) { glDeleteProgram(prog); piglit_report_result(PIGLIT_FAIL); } /* Set up the transform feedback buffer. */ glGenBuffers(1, &buf); glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER_EXT, buf); glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER_EXT, TOTAL_BUF_COMPONENTS*sizeof(float), NULL, GL_STREAM_READ); ptr = glMapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER_EXT, GL_WRITE_ONLY); for (i = 0; i < TOTAL_BUF_COMPONENTS; i++) { ptr[i] = 0.123456; } glUnmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER_EXT); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER_EXT, 0, buf); if (!piglit_check_gl_error(GL_NO_ERROR)) piglit_report_result(PIGLIT_FAIL); glClearColor(0.2, 0.2, 0.2, 1.0); }
static GLuint generate_program(const char *code_template, unsigned glsl_version, GLenum program_target, GLint *uniform_loc) { char *code = NULL; GLuint prog; (void)!asprintf(&code, code_template, glsl_version); prog = glCreateShaderProgramv(program_target, 1, (const GLchar * const*) &code); free(code); piglit_link_check_status(prog); *uniform_loc = glGetUniformLocation(prog, "a"); return prog; }