[Intel-gfx] [PATCH 3/3] Add egl_shader_runner to ease OpenGL ES 2.0 test case development
Shuang He
shuang.he at intel.com
Wed Oct 20 10:50:07 CEST 2010
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
>
More information about the Intel-gfx
mailing list