From: Shuang He <shuang.he@intel.com>
To: "piglit@lists.freedesktop.org" <piglit@lists.freedesktop.org>
Cc: intel-gfx@lists.freedesktop.org, "Romanick,
Ian D" <ian.d.romanick@intel.com>,
"Graunke, Kenneth W" <kenneth.w.graunke@intel.com>
Subject: Re: [PATCH 3/3] Add egl_shader_runner to ease OpenGL ES 2.0 test case development
Date: Wed, 20 Oct 2010 16:50:07 +0800 [thread overview]
Message-ID: <4CBEAD3F.3020500@intel.com> (raw)
In-Reply-To: <1287477758-13800-1-git-send-email-shuang.he@intel.com>
Do you have any comment? :-) , or I'd try to commit them tomorrow
Thanks
--Shuang
On 2010-10-19 16:42, He, Shuang wrote:
> ---
> tests/CMakeLists.txt | 3 +
> tests/gles2/CMakeLists.txt | 22 ++
> tests/gles2/egl_shader_runner.c | 762 +++++++++++++++++++++++++++++++++++++++
> 3 files changed, 787 insertions(+), 0 deletions(-)
> create mode 100644 tests/gles2/CMakeLists.txt
> create mode 100644 tests/gles2/egl_shader_runner.c
>
> diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
> index 3d3a892..58f8070 100644
> --- a/tests/CMakeLists.txt
> +++ b/tests/CMakeLists.txt
> @@ -13,6 +13,9 @@ add_subdirectory (spec)
>
> IF(OPENGL_egl_LIBRARY)
> add_subdirectory (egl)
> + IF(OPENGL_gles2_LIBRARY)
> + add_subdirectory (gles2)
> + ENDIF(OPENGL_gles2_LIBRARY)
> ENDIF(OPENGL_egl_LIBRARY)
>
> IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
> diff --git a/tests/gles2/CMakeLists.txt b/tests/gles2/CMakeLists.txt
> new file mode 100644
> index 0000000..28c5bc7
> --- /dev/null
> +++ b/tests/gles2/CMakeLists.txt
> @@ -0,0 +1,22 @@
> +add_definitions ( -DSOURCE_DIR="${piglit_SOURCE_DIR}/" )
> +
> +include_directories(
> + ${OPENGL_INCLUDE_PATH}
> + ${piglit_SOURCE_DIR}/tests/util/egl
> +)
> +
> +link_directories (
> + ${piglit_SOURCE_DIR}/tests/util/egl
> + ${piglit_SOURCE_DIR}/tests/util/eglut
> +)
> +
> +link_libraries (
> + ${OPENGLES_gles2_LIBRARY}
> + ${OPENGL_egl_LIBRARY}
> + pigliteglut
> + pigliteglutil
> +)
> +
> +
> +add_executable (egl_shader_runner egl_shader_runner.c ../util/shader-load.c)
> +target_link_libraries(egl_shader_runner X11)
> diff --git a/tests/gles2/egl_shader_runner.c b/tests/gles2/egl_shader_runner.c
> new file mode 100644
> index 0000000..9a42d56
> --- /dev/null
> +++ b/tests/gles2/egl_shader_runner.c
> @@ -0,0 +1,762 @@
> +/*
> + * Copyright © 2010 Intel Corporation
> + *
> + * Permission is hereby granted, free of charge, to any person obtaining a
> + * copy of this software and associated documentation files (the "Software"),
> + * to deal in the Software without restriction, including without limitation
> + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
> + * and/or sell copies of the Software, and to permit persons to whom the
> + * Software is furnished to do so, subject to the following conditions:
> + *
> + * The above copyright notice and this permission notice (including the next
> + * paragraph) shall be included in all copies or substantial portions of the
> + * Software.
> + *
> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
> + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
> + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
> + * DEALINGS IN THE SOFTWARE.
> + */
> +
> +#define _GNU_SOURCE
> +#if defined(_MSC_VER)
> +#define bool BOOL
> +#define true 1
> +#define false 0
> +#else
> +#include<stdbool.h>
> +#endif
> +#include<string.h>
> +#include<ctype.h>
> +#include "piglit-egl-util.h"
> +#include<GLES2/gl2.h>
> +
> +int piglit_width = 250, piglit_height = 250;
> +
> +static float gles_version = 0.0;
> +static float essl_version = 0.0;
> +
> +const char *path = NULL;
> +const char *test_start = NULL;
> +
> +GLuint vertex_shaders[256];
> +unsigned num_vertex_shaders = 0;
> +GLuint fragment_shaders[256];
> +unsigned num_fragment_shaders = 0;
> +
> +/**
> + * List of strings loaded from files
> + *
> + * Some test script sections, such as "[vertex shader file]", can supply shader
> + * source code from multiple disk files. This array stores those strings.
> + */
> +
> +char *shader_strings[256];
> +GLsizei shader_string_sizes[256];
> +unsigned num_shader_strings = 0;
> +GLuint prog;
> +
> +enum states {
> + none = 0,
> + requirements,
> + vertex_shader,
> + vertex_shader_file,
> + vertex_program,
> + fragment_shader,
> + fragment_shader_file,
> + fragment_program,
> + test,
> +};
> +
> +
> +enum comparison {
> + equal = 0,
> + not_equal,
> + less,
> + greater_equal,
> + greater,
> + less_equal
> +};
> +
> +
> +void
> +compile_glsl(GLenum target, bool release_text)
> +{
> + GLuint shader = glCreateShader(target);
> + GLint ok;
> + unsigned i;
> +
> + glShaderSource(shader, num_shader_strings,
> + (const GLchar **) shader_strings, shader_string_sizes);
> +
> + glCompileShader(shader);
> +
> + glGetShaderiv(shader, GL_COMPILE_STATUS,&ok);
> +
> + if (!ok) {
> + GLchar *info;
> + GLint size;
> +
> + glGetShaderiv(shader, GL_INFO_LOG_LENGTH,&size);
> + info = malloc(size);
> +
> + glGetShaderInfoLog(shader, size, NULL, info);
> +
> + fprintf(stderr, "Failed to compile %s: %s\n",
> + target == GL_FRAGMENT_SHADER ? "FS" : "VS",
> + info);
> +
> + free(info);
> + piglit_report_result(PIGLIT_FAILURE);
> + }
> +
> + if (release_text) {
> + for (i = 0; i< num_shader_strings; i++)
> + free(shader_strings[i]);
> + }
> +
> + switch (target) {
> + case GL_VERTEX_SHADER:
> + vertex_shaders[num_vertex_shaders] = shader;
> + num_vertex_shaders++;
> + break;
> + case GL_FRAGMENT_SHADER:
> + fragment_shaders[num_fragment_shaders] = shader;
> + num_fragment_shaders++;
> + break;
> + }
> +}
> +
> +
> +/**
> + * Copy a string until either whitespace or the end of the string
> + */
> +const char *
> +strcpy_to_space(char *dst, const char *src)
> +{
> + while (!isspace(*src)&& (*src != '\0'))
> + *(dst++) = *(src++);
> +
> + *dst = '\0';
> + return src;
> +}
> +
> +
> +/**
> + * Skip over whitespace upto the end of line
> + */
> +const char *
> +eat_whitespace(const char *src)
> +{
> + while (isspace(*src)&& (*src != '\n'))
> + src++;
> +
> + return src;
> +}
> +
> +
> +/**
> + * Skip over non-whitespace upto the end of line
> + */
> +const char *
> +eat_text(const char *src)
> +{
> + while (!isspace(*src)&& (*src != '\0'))
> + src++;
> +
> + return src;
> +}
> +
> +
> +/**
> + * Compare two values given a specified comparison operator
> + */
> +bool
> +compare(float ref, float value, enum comparison cmp)
> +{
> + switch (cmp) {
> + case equal: return value == ref;
> + case not_equal: return value != ref;
> + case less: return value< ref;
> + case greater_equal: return value>= ref;
> + case greater: return value> ref;
> + case less_equal: return value<= ref;
> + }
> +
> + assert(!"Should not get here.");
> +}
> +
> +
> +/**
> + * Get the string representation of a comparison operator
> + */
> +const char *
> +comparison_string(enum comparison cmp)
> +{
> + switch (cmp) {
> + case equal: return "==";
> + case not_equal: return "!=";
> + case less: return "<";
> + case greater_equal: return ">=";
> + case greater: return ">";
> + case less_equal: return "<=";
> + }
> +
> + assert(!"Should not get here.");
> +}
> +
> +
> +void
> +load_shader_file(const char *line)
> +{
> + GLsizei *const size =&shader_string_sizes[num_shader_strings];
> + char buf[256];
> + char *text;
> +
> + strcpy_to_space(buf, line);
> +
> + text = piglit_load_text_file(buf, (unsigned *) size);
> + if ((text == NULL)&& (path != NULL)) {
> + const size_t len = strlen(path);
> +
> + memcpy(buf, path, len);
> + buf[len] = '/';
> + strcpy_to_space(&buf[len + 1], line);
> +
> + text = piglit_load_text_file(buf, (unsigned *) size);
> + }
> +
> + if (text == NULL) {
> + strcpy_to_space(buf, line);
> +
> + printf("could not load file \"%s\"\n", buf);
> + piglit_report_result(PIGLIT_FAILURE);
> + }
> +
> + shader_strings[num_shader_strings] = text;
> + num_shader_strings++;
> +}
> +
> +
> +/**
> + * Parse a binary comparison operator and return the matching token
> + */
> +const char *
> +process_comparison(const char *src, enum comparison *cmp)
> +{
> + char buf[32];
> +
> + switch (src[0]) {
> + case '=':
> + if (src[1] == '=') {
> + *cmp = equal;
> + return src + 2;
> + }
> + break;
> + case '<':
> + if (src[1] == '=') {
> + *cmp = less_equal;
> + return src + 2;
> + } else {
> + *cmp = less;
> + return src + 1;
> + }
> + case '>':
> + if (src[1] == '=') {
> + *cmp = greater_equal;
> + return src + 2;
> + } else {
> + *cmp = greater;
> + return src + 1;
> + }
> + case '!':
> + if (src[1] == '=') {
> + *cmp = not_equal;
> + return src + 2;
> + }
> + break;
> + }
> +
> + strncpy(buf, src, sizeof(buf));
> + buf[sizeof(buf) - 1] = '\0';
> + printf("invalid comparison in test script:\n%s\n", buf);
> + piglit_report_result(PIGLIT_FAILURE);
> +
> + /* Won't get here. */
> + return NULL;
> +}
> +
> +
> +/**
> + * Parse and check a line from the requirement section of the test
> + */
> +void
> +process_requirement(const char *line)
> +{
> + char buffer[4096];
> +
> + /* There are three types of requirements that a test can currently
> + * have:
> + *
> + * * Require that some GL extension be supported
> + * * Require some particular versions of GL
> + * * Require some particular versions of GLSL
> + *
> + * The tests for GL and GLSL versions can be equal, not equal,
> + * less, less-or-equal, greater, or greater-or-equal. Extension tests
> + * can also require that a particular extension not be supported by
> + * prepending ! to the extension name.
> + */
> + if (strncmp("GL_OES_", line, 7) == 0) {
> + strcpy_to_space(buffer, line + 7);
> + piglit_require_extension(buffer);
> + } else if (strncmp("!GL_OES_", line, 8) == 0) {
> + strcpy_to_space(buffer, line + 8);
> + piglit_require_not_extension(buffer);
> + } else if (strncmp("ESSL", line, 4) == 0) {
> + enum comparison cmp;
> + float version;
> +
> + line = eat_whitespace(line + 4);
> +
> + line = process_comparison(line,&cmp);
> +
> + version = strtod(line, NULL);
> + if (!compare(version, essl_version, cmp)) {
> + printf("Test requires GLSL ES version %s %.1f. "
> + "Actual version is %.1f.\n",
> + comparison_string(cmp),
> + version,
> + essl_version);
> + piglit_report_result(PIGLIT_SKIP);
> + }
> + } else if (strncmp("GLES", line, 4) == 0) {
> + enum comparison cmp;
> + float version;
> +
> + line = eat_whitespace(line + 4);
> +
> + line = process_comparison(line,&cmp);
> +
> + version = strtod(line, NULL);
> + if (!compare(version, gles_version, cmp)) {
> + printf("Test requires GL version %s %.1f. "
> + "Actual version is %.1f.\n",
> + comparison_string(cmp),
> + version,
> + gles_version);
> + piglit_report_result(PIGLIT_SKIP);
> + }
> + }
> +}
> +
> +
> +void
> +leave_state(enum states state, const char *line)
> +{
> + switch (state) {
> + case none:
> + break;
> +
> + case requirements:
> + break;
> +
> + case vertex_shader:
> + shader_string_sizes[0] = line - shader_strings[0];
> + num_shader_strings = 1;
> + compile_glsl(GL_VERTEX_SHADER, false);
> + break;
> +
> + case vertex_shader_file:
> + compile_glsl(GL_VERTEX_SHADER, true);
> + break;
> +
> + case vertex_program:
> + break;
> +
> + case fragment_shader:
> + shader_string_sizes[0] = line - shader_strings[0];
> + num_shader_strings = 1;
> + compile_glsl(GL_FRAGMENT_SHADER, false);
> + break;
> +
> + case fragment_shader_file:
> + compile_glsl(GL_FRAGMENT_SHADER, true);
> + break;
> +
> + case fragment_program:
> + break;
> +
> + case test:
> + break;
> +
> + default:
> + assert(!"Not yet supported.");
> + }
> +}
> +
> +
> +void
> +link_and_use_shaders(void)
> +{
> + unsigned i;
> + GLenum err;
> + GLint ok;
> +
> + if ((num_vertex_shaders == 0)
> +&& (num_fragment_shaders == 0))
> + return;
> +
> + prog = glCreateProgram();
> +
> + for (i = 0; i< num_vertex_shaders; i++) {
> + glAttachShader(prog, vertex_shaders[i]);
> + }
> +
> + for (i = 0; i< num_fragment_shaders; i++) {
> + glAttachShader(prog, fragment_shaders[i]);
> + }
> +
> + glLinkProgram(prog);
> +
> + for (i = 0; i< num_vertex_shaders; i++) {
> + glDeleteShader(vertex_shaders[i]);
> + }
> +
> + for (i = 0; i< num_fragment_shaders; i++) {
> + glDeleteShader(fragment_shaders[i]);
> + }
> +
> + glGetProgramiv(prog, GL_LINK_STATUS,&ok);
> + if (!ok) {
> + GLchar *info;
> + GLint size;
> +
> + glGetProgramiv(prog, GL_INFO_LOG_LENGTH,&size);
> + info = malloc(size);
> +
> + glGetProgramInfoLog(prog, size, NULL, info);
> +
> + fprintf(stderr, "Failed to link:\n%s\n",
> + info);
> +
> + free(info);
> + piglit_report_result(PIGLIT_FAILURE);
> + }
> +
> + glUseProgram(prog);
> +
> + err = glGetError();
> + if (err) {
> + GLchar *info;
> + GLint size;
> +
> + printf("GL error after linking program: 0x%04x\n", err);
> +
> + glGetProgramiv(prog, GL_INFO_LOG_LENGTH,&size);
> + info = malloc(size);
> +
> + glGetProgramInfoLog(prog, size, NULL, info);
> + fprintf(stderr, "Info log: %s\n", info);
> +
> + piglit_report_result(PIGLIT_FAILURE);
> + }
> +}
> +
> +
> +void
> +process_test_script(const char *script_name)
> +{
> + unsigned text_size;
> + char *text = piglit_load_text_file(script_name,&text_size);
> + enum states state = none;
> + const char *line = text;
> +
> + if (line == NULL) {
> + printf("could not read file \"%s\"\n", script_name);
> + piglit_report_result(PIGLIT_FAILURE);
> + }
> +
> + while (line[0] != '\0') {
> + if (line[0] == '[') {
> + leave_state(state, line);
> +
> + if (strncmp(line, "[require]", 9) == 0) {
> + state = requirements;
> + } else if (strncmp(line, "[vertex shader]", 15) == 0) {
> + state = vertex_shader;
> + shader_strings[0] = NULL;
> + } else if (strncmp(line, "[vertex shader file]", 20) == 0) {
> + state = vertex_shader_file;
> + shader_strings[0] = NULL;
> + num_shader_strings = 0;
> + } else if (strncmp(line, "[fragment shader]", 17) == 0) {
> + state = fragment_shader;
> + shader_strings[0] = NULL;
> + } else if (strncmp(line, "[fragment shader file]", 22) == 0) {
> + state = fragment_shader_file;
> + shader_strings[0] = NULL;
> + num_shader_strings = 0;
> + } else if (strncmp(line, "[test]", 6) == 0) {
> + test_start = strchrnul(line, '\n');
> + if (test_start[0] != '\0')
> + test_start++;
> + return;
> + }
> + } else {
> + switch (state) {
> + case none:
> + break;
> +
> + case requirements:
> + process_requirement(line);
> + break;
> +
> + case vertex_shader:
> + case vertex_program:
> + case fragment_shader:
> + case fragment_program:
> + if (shader_strings[0] == NULL)
> + shader_strings[0] = (char *) line;
> + break;
> +
> + case vertex_shader_file:
> + case fragment_shader_file:
> + line = eat_whitespace(line);
> + if ((line[0] != '\n')&& (line[0] != '#'))
> + load_shader_file(line);
> + break;
> +
> + case test:
> + break;
> + }
> + }
> +
> + line = strchrnul(line, '\n');
> + if (line[0] != '\0')
> + line++;
> + }
> +
> + leave_state(state, line);
> +}
> +
> +
> +void
> +get_floats(const char *line, float *f, unsigned count)
> +{
> + unsigned i;
> +
> + for (i = 0; i< count; i++)
> + f[i] = strtod(line, (char **)&line);
> +}
> +
> +void
> +set_uniform(const char *line)
> +{
> + char name[512];
> + float f[16];
> + GLuint prog;
> + GLint loc;
> + const char *type;
> +
> + glGetIntegerv(GL_CURRENT_PROGRAM, (GLint *)&prog);
> +
> + type = eat_whitespace(line);
> + line = eat_text(type);
> +
> + line = strcpy_to_space(name, eat_whitespace(line));
> + loc = glGetUniformLocation(prog, name);
> + if (loc< 0) {
> + printf("cannot get location of uniform \"%s\"\n",
> + name);
> + piglit_report_result(PIGLIT_FAILURE);
> + }
> +
> + if (strncmp("float", type, 5) == 0) {
> + get_floats(line, f, 1);
> + glUniform1fv(loc, 1, f);
> + return;
> + } else if (strncmp("int", type, 3) == 0) {
> + int val = atoi(line);
> + glUniform1i(loc, val);
> + return;
> + } else if (strncmp("vec", type, 3) == 0) {
> + switch (type[3]) {
> + case '2':
> + get_floats(line, f, 2);
> + glUniform2fv(loc, 1, f);
> + return;
> + case '3':
> + get_floats(line, f, 3);
> + glUniform3fv(loc, 1, f);
> + return;
> + case '4':
> + get_floats(line, f, 4);
> + glUniform4fv(loc, 1, f);
> + return;
> + }
> + }
> +
> + strcpy_to_space(name, type);
> + printf("unknown uniform type \"%s\"", name);
> + piglit_report_result(PIGLIT_FAILURE);
> +
> + return;
> +}
> +
> +static GLboolean
> +string_match(const char *string, const char *line)
> +{
> + return (strncmp(string, line, strlen(string)) == 0);
> +}
> +
> +enum piglit_result
> +piglit_egl_display(void)
> +{
> + const char *line;
> + bool pass = true;
> + GLbitfield clear_bits = 0;
> +
> + if (test_start == NULL)
> + return PIGLIT_SUCCESS;
> +
> + line = test_start;
> + while (line[0] != '\0') {
> + float c[32];
> + int x, y, w, h, tex, level;
> +
> + line = eat_whitespace(line);
> +
> + if (string_match("clear color", line)) {
> + get_floats(line + 11, c, 4);
> + glClearColor(c[0], c[1], c[2], c[3]);
> + clear_bits |= GL_COLOR_BUFFER_BIT;
> + } else if (string_match("clear", line)) {
> + glClear(clear_bits);
> + } else if (string_match("draw rect", line)) {
> + get_floats(line + 9, c, 4);
> + piglit_draw_rect(c[0], c[1], c[2], c[3]);
> + } else if (string_match("probe rgba", line)) {
> + get_floats(line + 10, c, 6);
> + if (!piglit_probe_pixel_rgba((int) c[0], (int) c[1],
> +& c[2])) {
> + pass = false;
> + }
> + } else if (sscanf(line,
> + "relative probe rgba ( %f , %f ) "
> + "( %f , %f , %f , %f )",
> + c + 0, c + 1,
> + c + 2, c + 3, c + 4, c + 5) == 6) {
> + x = c[0] * piglit_width;
> + y = c[1] * piglit_width;
> + if (x>= piglit_width)
> + x = piglit_width - 1;
> + if (y>= piglit_height)
> + y = piglit_height - 1;
> +
> + if (!piglit_probe_pixel_rgba(x, y,&c[2])) {
> + pass = false;
> + }
> + } else if (string_match("probe rgb", line)) {
> + get_floats(line + 9, c, 5);
> + if (!piglit_probe_pixel_rgb((int) c[0], (int) c[1],
> +& c[2])) {
> + pass = false;
> + }
> + } else if (sscanf(line,
> + "relative probe rgb ( %f , %f ) "
> + "( %f , %f , %f )",
> + c + 0, c + 1,
> + c + 2, c + 3, c + 4) == 5) {
> + x = c[0] * piglit_width;
> + y = c[1] * piglit_width;
> + if (x>= piglit_width)
> + x = piglit_width - 1;
> + if (y>= piglit_height)
> + y = piglit_height - 1;
> +
> + if (!piglit_probe_pixel_rgb(x, y,&c[2])) {
> + pass = false;
> + }
> + } else if (string_match("probe all rgba", line)) {
> + get_floats(line + 14, c, 4);
> + pass = pass&&
> + piglit_probe_rect_rgba(0, 0, piglit_width,
> + piglit_height, c);
> + } else if (string_match("probe all rgb", line)) {
> + get_floats(line + 13, c, 3);
> + pass = pass&&
> + piglit_probe_rect_rgb(0, 0, piglit_width,
> + piglit_height, c);
> + } else if (sscanf(line,
> + "texture rgbw %d ( %d , %d )",
> +&tex,&w,&h) == 3) {
> + glActiveTexture(GL_TEXTURE0 + tex);
> + piglit_rgbw_texture(GL_RGBA, w, h, GL_FALSE, GL_FALSE);
> + glEnable(GL_TEXTURE_2D);
> + } else if (sscanf(line,
> + "texture checkerboard %d %d ( %d , %d ) "
> + "( %f , %f , %f , %f ) "
> + "( %f , %f , %f , %f )",
> +&tex,&level,&w,&h,
> + c + 0, c + 1, c + 2, c + 3,
> + c + 4, c + 5, c + 6, c + 7) == 12) {
> + glActiveTexture(GL_TEXTURE0 + tex);
> + piglit_checkerboard_texture(0, level,
> + w, h,
> + w / 2, h / 2,
> + c + 0, c + 4);
> + glEnable(GL_TEXTURE_2D);
> + } else if (string_match("uniform", line)) {
> + set_uniform(line + 7);
> + } else if ((line[0] != '\n')&& (line[0] != '\0')
> +&& (line[0] != '#')) {
> + printf("unknown command \"%s\"", line);
> + piglit_report_result(PIGLIT_FAILURE);
> + }
> +
> + line = strchrnul(line, '\n');
> + if (line[0] != '\0')
> + line++;
> + }
> +
> + /* XXX eglutSwapBuffers() */
> +
> + if (piglit_automatic) {
> + /* Free our resources, useful for valgrinding. */
> + glDeleteProgram(prog);
> + glUseProgram(0);
> + }
> + return pass ? PIGLIT_SUCCESS : PIGLIT_FAILURE;
> +}
> +
> +
> +void
> +piglit_egl_init(int argc, char **argv)
> +{
> + const char *essl_version_string;
> +
> + /* OpenGL ES version string is in the form of :
> + * OpenGL<space>ES<space><version number><space><vendor-specific information>
> + */
> + gles_version = strtod((char *) glGetString(GL_VERSION)+10, NULL);
> +
> + essl_version_string = (char *)
> + glGetString(GL_SHADING_LANGUAGE_VERSION);
> +
> + /* OpenGL ES SHADING_LANGUAGE_VERSION string is in the form of :
> + * OpenGL<space>ES<space><GLSL><space>ES<space><version number><space>
> + *<vendor-specific information>
> + */
> + essl_version = (essl_version_string == NULL)
> + ? 0.0 : strtod(essl_version_string+18, NULL);
> +
> + if (argc> 2)
> + path = argv[2];
> +
> + process_test_script(argv[1]);
> + link_and_use_shaders();
> +}
> --
> 1.7.2.3
>
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
parent reply other threads:[~2010-10-20 8:50 UTC|newest]
Thread overview: expand[flat|nested] mbox.gz Atom feed
[parent not found: <1287477758-13800-1-git-send-email-shuang.he@intel.com>]
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=4CBEAD3F.3020500@intel.com \
--to=shuang.he@intel.com \
--cc=ian.d.romanick@intel.com \
--cc=intel-gfx@lists.freedesktop.org \
--cc=kenneth.w.graunke@intel.com \
--cc=piglit@lists.freedesktop.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.