void piglit_init(int argc, char **argv) { glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-1.25, 1.25, -1.25, 1.25, -1, 1); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glShadeModel(GL_FLAT); glPixelStorei(GL_PACK_ALIGNMENT, 1); glFrontFace(GL_CW); glCullFace(GL_FRONT); glEnable(GL_CULL_FACE); if (piglit_is_extension_supported("GL_ARB_provoking_vertex")) { provoking_vertex_first = true; } else if (piglit_is_extension_supported("GL_EXT_provoking_vertex")) { provoking_vertex_first = true; } if (provoking_vertex_first) { GLboolean k; glGetBooleanv(GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT, &k); quads_follows_pv_convention = k; } }
void piglit_init(int argc, char **argv) { GLint max_samples; GLuint rb; piglit_require_extension("GL_EXT_framebuffer_multisample"); if (piglit_is_extension_supported("GL_ARB_internalformat_query")) { printf("ARB_internalformat_query is supported and " "redefines this behavior; skipping\n"); piglit_report_result(PIGLIT_SKIP); } if (piglit_is_extension_supported("GL_ARB_texture_multisample")) { printf("ARB_texture_multisample is supposed and " "redefines this behavior; skipping\n"); piglit_report_result(PIGLIT_SKIP); } glGetIntegerv(GL_MAX_SAMPLES, &max_samples); glGenRenderbuffersEXT(1, &rb); glBindRenderbufferEXT(GL_RENDERBUFFER, rb); glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER, max_samples + 1, GL_RGBA, 1, 1); if (!piglit_check_gl_error(GL_INVALID_VALUE)) piglit_report_result(PIGLIT_FAIL); glDeleteRenderbuffersEXT(1, &rb); piglit_report_result(PIGLIT_PASS); }
bool atomic_counters_supported(GLenum shader_stage) { int n = 0; switch (shader_stage) { case GL_NONE: case GL_FRAGMENT_SHADER: return true; case GL_VERTEX_SHADER: glGetIntegerv(GL_MAX_VERTEX_ATOMIC_COUNTERS, &n); return n; case GL_GEOMETRY_SHADER: if (piglit_get_gl_version() >= 32) glGetIntegerv(GL_MAX_GEOMETRY_ATOMIC_COUNTERS, &n); return n; case GL_TESS_CONTROL_SHADER: if (piglit_is_extension_supported("GL_ARB_tessellation_shader")) glGetIntegerv(GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS, &n); return n; case GL_TESS_EVALUATION_SHADER: if (piglit_is_extension_supported("GL_ARB_tessellation_shader")) glGetIntegerv(GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS, &n); return n; default: assert(!"Unreachable"); abort(); } }
/** * 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); }
/* Test subroutine uniform location query with compute. */ static bool test_subroutine_stages_compute() { GLuint prog, i; if (!piglit_is_extension_supported("GL_ARB_shader_subroutine")) { piglit_report_subtest_result(PIGLIT_SKIP, __func__); return true; } if (!piglit_is_extension_supported("GL_ARB_compute_shader")) { piglit_report_subtest_result(PIGLIT_SKIP, __func__); return true; } prog = piglit_build_simple_program_multiple_shaders( GL_COMPUTE_SHADER, compute_subroutine_text, 0); glUseProgram(prog); /* Iterate through all valid subroutine enums passing invalid name. */ for (i = 0; i < (sizeof(valid_enums_sub_com)/sizeof(GLenum)); i++) { glGetProgramResourceLocation(prog, valid_enums_sub_com[i], "name"); if (!piglit_check_gl_error(GL_NO_ERROR)) piglit_report_result(PIGLIT_FAIL); } CHECK_SUB(COMPUTE); piglit_report_subtest_result(PIGLIT_PASS, __func__); return true; }
PIGLIT_GL_TEST_CONFIG_END void piglit_init(int argc, char **argv) { bool pass; /* We can create depth/stencil textures if either: * 1. We have GL 3.0 or later * 2. We have GL_EXT_packed_depth_stencil and GL_ARB_depth_texture */ if (piglit_get_gl_version() < 30 && !(piglit_is_extension_supported("GL_EXT_packed_depth_stencil") && piglit_is_extension_supported("GL_ARB_depth_texture"))) { printf("OpenGL 3.0 or GL_EXT_packed_depth_stencil + " "GL_ARB_depth_texture is required.\n"); piglit_report_result(PIGLIT_SKIP); } pass = test_format(GL_DEPTH24_STENCIL8_EXT, GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT, 4); piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); }
void piglit_init(int argc, char **argv) { if (!piglit_is_extension_supported("GL_ARB_shader_objects") || !piglit_is_extension_supported("GL_ARB_vertex_shader") || !piglit_is_extension_supported("GL_ARB_fragment_shader")) { printf("Requires ARB_shader_objects and ARB_{vertex,fragment}_shader\n"); piglit_report_result(PIGLIT_SKIP); } }
void piglit_init(int argc, char**argv) { piglit_require_extension("GL_EXT_framebuffer_object"); have_extension[0] = GL_TRUE; have_extension[EXT_packed_depth_stencil] = piglit_is_extension_supported("GL_EXT_packed_depth_stencil"); have_extension[ARB_framebuffer_object] = piglit_is_extension_supported("GL_ARB_framebuffer_object"); have_extension[ARB_texture_rg] = piglit_is_extension_supported("GL_ARB_texture_rg"); piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); }
void piglit_require_fragment_shader(void) { if (piglit_get_gl_version() >= 20) { init_functions_from_core(); } else if (piglit_is_extension_supported("GL_ARB_shader_objects") && piglit_is_extension_supported("GL_ARB_fragment_shader")) { init_functions_from_extension(); } else { printf("GLSL vertex shaders are not supported.\n"); piglit_report_result(PIGLIT_SKIP); exit(1); } }
void piglit_require_GLSL(void) { if (piglit_get_gl_version() >= 20) { init_functions_from_core(); } else if (piglit_is_extension_supported("GL_ARB_shader_objects") && piglit_is_extension_supported("GL_ARB_shading_language_100")) { init_functions_from_extension(); } else { printf("GLSL not supported.\n"); piglit_report_result(PIGLIT_SKIP); exit(1); } }
void piglit_init(int argc, char **argv) { if (!piglit_is_extension_supported("GL_ARB_imaging") && !piglit_is_extension_supported("GL_EXT_blend_minmax")) { printf("Sorry, this program requires either GL_ARB_imaging or " "GL_EXT_blend_minmax.\n"); piglit_report_result(PIGLIT_SKIP); } piglit_require_gl_version(14); printf("\nAll 4 quads should be the same color.\n"); glEnable(GL_BLEND); }
static bool supported_target(unsigned i) { /* Array targets are only supported if GLSL is available. */ if ((target[i].target == GL_TEXTURE_1D_ARRAY || target[i].target == GL_TEXTURE_2D_ARRAY) && (piglit_get_gl_version() < 20 && !piglit_is_extension_supported("GL_ARB_fragment_shader"))) return false; return piglit_get_gl_version() >= target[i].gl_version || (target[i].extension && piglit_is_extension_supported(target[i].extension)); }
static bool check_extensions(GLuint prog, GLenum programInterface) { /* First check the availability of the extensions */ if ((programInterface == GL_BUFFER_VARIABLE || programInterface == GL_SHADER_STORAGE_BLOCK || prog == prog_stor) && !piglit_is_extension_supported("GL_ARB_shader_storage_buffer_object")) { return false; } if ((programInterface == GL_VERTEX_SUBROUTINE || programInterface == GL_GEOMETRY_SUBROUTINE || programInterface == GL_FRAGMENT_SUBROUTINE || programInterface == GL_COMPUTE_SUBROUTINE || programInterface == GL_VERTEX_SUBROUTINE_UNIFORM || programInterface == GL_GEOMETRY_SUBROUTINE_UNIFORM || programInterface == GL_FRAGMENT_SUBROUTINE_UNIFORM || programInterface == GL_COMPUTE_SUBROUTINE_UNIFORM || programInterface == GL_TESS_CONTROL_SUBROUTINE || programInterface == GL_TESS_EVALUATION_SUBROUTINE || programInterface == GL_TESS_CONTROL_SUBROUTINE_UNIFORM || programInterface == GL_TESS_EVALUATION_SUBROUTINE_UNIFORM || programInterface == GL_COMPUTE_SUBROUTINE_UNIFORM || prog == prog_sub || prog == prog_sub_tess) && !piglit_is_extension_supported("GL_ARB_shader_subroutine")) { return false; } if ((programInterface == GL_TESS_CONTROL_SUBROUTINE || programInterface == GL_TESS_EVALUATION_SUBROUTINE || programInterface == GL_TESS_CONTROL_SUBROUTINE_UNIFORM || programInterface == GL_TESS_EVALUATION_SUBROUTINE_UNIFORM || prog == prog_sub_tess) && !piglit_is_extension_supported("GL_ARB_tessellation_shader")) { return false; } if ((programInterface == GL_COMPUTE_SUBROUTINE || programInterface == GL_COMPUTE_SUBROUTINE_UNIFORM || prog == prog_cs) && !piglit_is_extension_supported("GL_ARB_compute_shader") && !piglit_is_extension_supported("GL_ARB_shader_image_load_store")) { return false; } return true; }
GLboolean test(void) { GLboolean all_pass = GL_TRUE; int npass = 0, total = 0; unsigned semantic, blend, logicop, vpmode, fpmode; unsigned vpmodes = 1 + !!piglit_is_extension_supported("GL_ARB_vertex_program"); unsigned fpmodes = 1 + !!piglit_is_extension_supported("GL_ARB_fragment_program"); unsigned vert_clamp, frag_clamp; glFogi(GL_FOG_MODE, GL_LINEAR); for (vert_clamp = 0; vert_clamp < (sanity ? 1 : 3); ++vert_clamp) for (frag_clamp = sanity ? 1 : 0; frag_clamp < (sanity ? 2 : 3); ++frag_clamp) for (semantic = 0; semantic < 2; ++semantic) for (blend = 0; blend < 4; ++blend) for (logicop = 0; logicop < 2; ++logicop) for (vpmode = 0; vpmode < vpmodes; ++vpmode) for (fpmode = 0; fpmode < fpmodes; ++fpmode) { GLboolean pass; if (!fpmode && semantic) continue; pass = test_one(vert_clamp, frag_clamp, semantic, blend, logicop, vpmode, fpmode); if (pass) { npass++; } else { #if 0 /* Enable this code to re-run the failed test. * It's easy to set a breakpoint here to start debugging. */ pass = test_one(vert_clamp, frag_clamp, semantic, blend, logicop, vpmode, fpmode); #endif } total++; all_pass = all_pass && pass; } printf("Summary: %i/%i passed.\n", npass, total); return all_pass; }
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) { Have_NV = piglit_is_extension_supported("GL_NV_primitive_restart"); Have_31 = piglit_get_gl_version() >= 31; if (argc >= 2) { VBO_CFG vbo_cfg; for (vbo_cfg = 0; vbo_cfg < ARRAY_SIZE(vbo_cfg_names); vbo_cfg++) { if (strcmp(argv[1], vbo_cfg_names[vbo_cfg]) == 0) { vbo_init_cfg = vbo_cfg; break; } } } /* Debug */ if (0) { printf("Have NV: %d\n", Have_NV); printf("Have 31: %d\n", Have_31); } if (!Have_NV && !Have_31) { piglit_report_result(PIGLIT_SKIP); exit(1); } glClearColor(0, 0, 0, 0); }
void piglit_init(int argc, char **argv) { Have_NV = piglit_is_extension_supported("GL_NV_primitive_restart"); Have_31 = piglit_get_gl_version() >= 31; if (argc >= 2) { VBO_CFG vbo_cfg; for (vbo_cfg = 0; vbo_cfg < ARRAY_SIZE(vbo_cfg_names); vbo_cfg++) { if (strcmp(argv[1], vbo_cfg_names[vbo_cfg]) == 0) { vbo_init_cfg = vbo_cfg; break; } } } /* Debug */ /* NOTE! glew 1.5.2's OpenGL 3.1 detection is broken. You'll need * to upgrade to a newer version if you want to test the GL 3.1 * primitive restart feature! */ if (0) { printf("Have NV: %d\n", Have_NV); printf("Have 31: %d\n", Have_31); } if (!Have_NV && !Have_31) { piglit_report_result(PIGLIT_SKIP); exit(1); } glClearColor(0, 0, 0, 0); }
void piglit_init(int argc, char **argv) { bool pass = true; ObjectPtrLabel = GET_FUNC(glObjectPtrLabel); GetObjectPtrLabel = GET_FUNC(glGetObjectPtrLabel); ObjectLabel = GET_FUNC(glObjectLabel); GetObjectLabel = GET_FUNC(glGetObjectLabel); #ifdef PIGLIT_USE_OPENGL piglit_require_gl_version(15); #endif piglit_require_extension("GL_KHR_debug"); pass = test_object_label_types() && pass; pass = test_object_label() && pass; pass = test_get_object_label() && pass; /* Test only if is GLES 3.0 or GL 3.2 or has ARB_sync */ if ((piglit_is_gles() && piglit_get_gl_version() >= 30) || piglit_get_gl_version() >= 32 || piglit_is_extension_supported("GL_ARB_sync")) pass = test_object_ptr_label() && pass; piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); }
void piglit_init(int argc, char **argv) { GLuint Texture; piglit_require_extension("GL_ARB_texture_float"); piglit_require_extension("GL_ARB_fragment_shader"); HaveRG = piglit_is_extension_supported("GL_ARB_texture_rg"); FragShader = piglit_compile_shader_text(GL_FRAGMENT_SHADER, FragShaderText); assert(FragShader); Program = piglit_link_simple_program(0, FragShader); glUseProgram(Program); BiasUniform = glGetUniformLocation(Program, "bias"); ScaleUniform = glGetUniformLocation(Program, "scale"); TexUniform = glGetUniformLocation(Program, "tex"); glUniform1f(BiasUniform, Bias); glUniform1f(ScaleUniform, Scale); glUniform1i(TexUniform, 0); /* tex unit zero */ (void) check_error(__FILE__, __LINE__); glGenTextures(1, &Texture); glBindTexture(GL_TEXTURE_2D, Texture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); }
/* Test subroutine uniform location query with vs, fs and gs. */ static bool test_subroutine_stages_vs_fs_gs() { GLuint prog, i; if (!piglit_is_extension_supported("GL_ARB_shader_subroutine")) { piglit_report_subtest_result(PIGLIT_SKIP, __func__); return true; } prog = piglit_build_simple_program_multiple_shaders( GL_VERTEX_SHADER, vs_subroutine_text, GL_GEOMETRY_SHADER, gs_subroutine_text, GL_FRAGMENT_SHADER, fs_subroutine_text, 0); glUseProgram(prog); /* Iterate through all valid subroutine enums passing invalid name. */ for (i = 0; i < (sizeof(valid_enums_sub)/sizeof(GLenum)); i++) { glGetProgramResourceLocation(prog, valid_enums_sub[i], "name"); if (!piglit_check_gl_error(GL_NO_ERROR)) piglit_report_result(PIGLIT_FAIL); } CHECK_SUB(VERTEX); CHECK_SUB(FRAGMENT); CHECK_SUB(GEOMETRY); piglit_report_subtest_result(PIGLIT_PASS, __func__); return true; }
void piglit_init(int argc, char **argv) { #ifdef GL_ARB_ES2_compatibility static const float verts[] = { -1.0, 1.0, 0.0, 1.0, -1.0, -1.0, 0.0, 1.0, +0.0, 1.0, 0.0, 1.0, +0.0, -1.0, 0.0, 1.0, }; if (piglit_get_gl_version() < 20) { printf("Requires OpenGL 2.0\n"); piglit_report_result(PIGLIT_SKIP); } if (!piglit_is_extension_supported("GL_ARB_ES2_compatibility")) { printf("Requires ARB_ES2_compatibility\n"); piglit_report_result(PIGLIT_SKIP); } glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(float) * 4, verts); glEnableVertexAttribArray(0); #endif }
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) { bool pass = true; #ifdef PIGLIT_USE_OPENGL piglit_require_extension("GL_ARB_texture_storage"); piglit_require_extension("GL_ARB_texture_view"); piglit_require_extension("GL_ARB_texture_cube_map_array"); piglit_require_extension("GL_EXT_texture_array"); piglit_require_extension("GL_ARB_texture_rectangle"); if (piglit_get_gl_version() < 31) piglit_require_extension("GL_ARB_texture_cube_map"); #else piglit_require_extension("GL_OES_texture_view"); piglit_require_extension("GL_OES_texture_cube_map_array"); #endif #ifdef PIGLIT_USE_OPENGL X(test_target_errors(GL_TEXTURE_1D), "1D tex target validity"); #endif X(test_target_errors(GL_TEXTURE_2D), "2D tex target validity"); X(test_target_errors(GL_TEXTURE_3D), "3D tex target validity"); X(test_target_errors(GL_TEXTURE_CUBE_MAP), "Cubemap tex target validity"); #ifdef PIGLIT_USE_OPENGL X(test_target_errors(GL_TEXTURE_RECTANGLE), "Rectangle tex target validity"); X(test_target_errors(GL_TEXTURE_1D_ARRAY), "1D Array tex target validity"); #endif X(test_target_errors(GL_TEXTURE_2D_ARRAY), "2D Array tex target validity"); X(test_target_errors(GL_TEXTURE_CUBE_MAP_ARRAY), "Cubemap Array tex target validity"); if (piglit_is_extension_supported("GL_ARB_texture_storage_multisample") || piglit_is_extension_supported("GL_OES_texture_storage_multisample_2d_array")) { X(test_target_errors(GL_TEXTURE_2D_MULTISAMPLE), "Multisample 2D tex target validity"); X(test_target_errors(GL_TEXTURE_2D_MULTISAMPLE_ARRAY), "Multisample 2D array tex target validity"); } #undef X pass = piglit_check_gl_error(GL_NO_ERROR) && pass; piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); }
static bool test_non_power_of_two(void) { bool pass = true; if (piglit_is_extension_supported("GL_ARB_texture_non_power_of_two")) { GLuint tex; GLubyte buf[800]; int width = 11, height = 14; int format = GL_COMPRESSED_RGB_S3TC_DXT1_EXT; memset(buf, 0, sizeof(buf)); /* Setup initial texture */ glGenTextures(1, &tex); glBindTexture(GL_TEXTURE_2D, tex); glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, buf); pass = piglit_check_gl_error(GL_NO_ERROR) && pass; /* Try TexSubImage of partial block on right edge */ glTexSubImage2D(GL_TEXTURE_2D, 0, width-3, 0, /* position */ 3, 4, /* size */ GL_RGBA, GL_UNSIGNED_BYTE, buf); pass = piglit_check_gl_error(GL_NO_ERROR) && pass; /* Try TexSubImage of partial block on top edge */ glTexSubImage2D(GL_TEXTURE_2D, 0, 0, height-2, /* position */ 4, 2, /* size */ GL_RGBA, GL_UNSIGNED_BYTE, buf); pass = piglit_check_gl_error(GL_NO_ERROR) && pass; /* Try TexSubImage of larger partial block on right edge */ glTexSubImage2D(GL_TEXTURE_2D, 0, width-3-4, 0, /* position */ 3+4, 4, /* size */ GL_RGBA, GL_UNSIGNED_BYTE, buf); pass = piglit_check_gl_error(GL_NO_ERROR) && pass; /* Try TexSubImage of larger partial block on top edge */ glTexSubImage2D(GL_TEXTURE_2D, 0, 0, height-2-4, /* position */ 4, 2+4, /* size */ GL_RGBA, GL_UNSIGNED_BYTE, buf); pass = piglit_check_gl_error(GL_NO_ERROR) && pass; glDeleteTextures(1, &tex); } return pass; }
/** is the given texture internal format supported? */ static bool supported_format(GLenum format) { switch (format) { case GL_RGBA16F: case GL_RGBA32F: case GL_RGB16F: case GL_RGB32F: return piglit_is_extension_supported("GL_ARB_texture_float"); case GL_RG: return piglit_is_extension_supported("GL_ARB_texture_rg"); case GL_DEPTH_COMPONENT32F: return piglit_is_extension_supported("GL_ARB_depth_buffer_float"); default: return true; } }
/** * Handle the special case when a test requests GL 3.1. */ static bool special_case_gl_31(const struct piglit_gl_test_config *test_config, enum context_flavor flavor, const char *context_description) { int gl_version; if (flavor == CONTEXT_GL_CORE && test_config->supports_gl_core_version == 31) { gl_version = piglit_get_gl_version(); assert(gl_version >= 31); if (gl_version == 31 && piglit_is_extension_supported("GL_ARB_compatibility")) { printf("piglit: info: Requested a %s, but the actual " "context is a 3.1 context that exposes the " "GL_ARB_compatibility extension\n", context_description); return false; } else { return true; } } else if (flavor == CONTEXT_GL_COMPAT && test_config->supports_gl_compat_version == 31) { gl_version = piglit_get_gl_version(); assert(gl_version >= 31); if (gl_version == 31 && !piglit_is_extension_supported("GL_ARB_compatibility")) { printf("piglit: info: Requested a %s, but the actual " "context is a 3.1 context that lacks the " "GL_ARB_compatibility extension\n", context_description); return false; } else { return true; } } else { /* No need to check the special case. */ return true; } }
void piglit_init(int argc, char **argv) { bool pass = true; piglit_require_extension("GL_ARB_get_texture_sub_image"); piglit_require_extension("GL_ARB_compressed_texture_pixel_storage"); piglit_require_extension("GL_EXT_texture_compression_s3tc"); piglit_require_extension("GL_ARB_texture_non_power_of_two"); pass = test_getsubimage(GL_TEXTURE_2D, 256, 128, 1, GL_COMPRESSED_RGB_S3TC_DXT1_EXT) && pass; pass = test_getsubimage(GL_TEXTURE_2D, 80, 40, 1, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT) && pass; pass = test_getsubimage(GL_TEXTURE_2D, 32, 32, 1, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT) && pass; pass = test_getsubimage(GL_TEXTURE_2D, 32, 32, 1, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT) && pass; /* NOTE: texture rectangle not supported with S3TC */ pass = test_getsubimage(GL_TEXTURE_CUBE_MAP, 16, 16, 6, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT) && pass; if (piglit_is_extension_supported("GL_EXT_texture_array")) { pass = test_getsubimage(GL_TEXTURE_2D_ARRAY, 16, 32, 10, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT) && pass; pass = test_getsubimage(GL_TEXTURE_2D_ARRAY, 32, 16, 1, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT) && pass; } if (piglit_is_extension_supported("GL_ARB_texture_cube_map_array")) { pass = test_getsubimage(GL_TEXTURE_CUBE_MAP_ARRAY, 16, 16, 18, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT) && pass; } piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); }
void piglit_init(int argc, char **argv) { int vuniforms = 0, vblocks = 0; int guniforms = 0, gblocks = 0; int funiforms = 0, fblocks = 0; int blocksize = 0; bool gs = piglit_is_extension_supported("GL_ARB_geometry_shader4"); piglit_require_extension("GL_ARB_uniform_buffer_object"); piglit_print_minmax_header(); piglit_test_min_int(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, 1024); piglit_test_min_int(GL_MAX_VERTEX_UNIFORM_BLOCKS, 12); piglit_test_min_int(GL_MAX_FRAGMENT_UNIFORM_BLOCKS, 12); if (gs) piglit_test_min_int(GL_MAX_GEOMETRY_UNIFORM_BLOCKS, 12); piglit_test_min_int(GL_MAX_COMBINED_UNIFORM_BLOCKS, gs ? 36 : 24); piglit_test_min_int(GL_MAX_UNIFORM_BUFFER_BINDINGS, gs ? 36 : 24); piglit_test_min_int(GL_MAX_UNIFORM_BLOCK_SIZE, 16384); /* Minimum value for OpenGL 3.1 is * (MAX_<stage>_UNIFORM_BLOCKS * MAX_UNIFORM_BLOCK_SIZE) + * MAX_<stage>_UNIFORM_COMPONENTS. Minimum value prior to * OpenGL 3.1 is MAX_<stage>_UNIFORM_COMPONENTS. */ if (piglit_get_gl_version() >= 31) { glGetIntegerv(GL_MAX_VERTEX_UNIFORM_BLOCKS, &vblocks); glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_BLOCKS, &fblocks); } glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, &vuniforms); glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &funiforms); glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &blocksize); piglit_test_min_int(GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS, vblocks * blocksize + vuniforms); piglit_test_min_int(GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS, fblocks * blocksize + funiforms); if (gs) { if (piglit_get_gl_version() >= 31) { glGetIntegerv(GL_MAX_GEOMETRY_UNIFORM_BLOCKS, &gblocks); } glGetIntegerv(GL_MAX_GEOMETRY_UNIFORM_COMPONENTS, &guniforms); piglit_test_min_int(GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS, gblocks * blocksize + guniforms); } piglit_test_min_int(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, 1); if (!piglit_check_gl_error(GL_NO_ERROR)) piglit_report_result(PIGLIT_FAIL); piglit_report_result(piglit_minmax_pass ? PIGLIT_PASS : PIGLIT_FAIL); }
void piglit_init(int argc, char **argv) { if ((piglit_get_gl_version() < 14) && !piglit_is_extension_supported("GL_ARB_window_pos")) { printf("Requires GL 1.4 or GL_ARB_window_pos"); piglit_report_result(PIGLIT_SKIP); } piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); }
unsigned init(void) { if (piglit_is_extension_supported("GL_ARB_vertex_program")) { unsigned i; for (i = 0; i < 2; ++i) vps[i] = piglit_compile_program(GL_VERTEX_PROGRAM_ARB, vp_strings[i]); } if (piglit_is_extension_supported("GL_ARB_fragment_program")) { unsigned i; for (i = 0; i < 4; ++i) fps[i] = piglit_compile_program(GL_FRAGMENT_PROGRAM_ARB, fp_strings[i]); } return TEST_SRT; }