<div dir="ltr">These nits have been incorporated into my local branch (<a href="http://cgit.freedesktop.org/~ldeks/piglit/?h=gl-1.0-glean">http://cgit.freedesktop.org/~ldeks/piglit/?h=gl-1.0-glean</a>). Thanks for the help. Laura </div><div class="gmail_extra"> <div class="gmail_quote">On Mon, Oct 13, 2014 at 7:58 PM, Dylan Baker <<a href="mailto:baker.dylan.c@gmail.com" target="_blank">baker.dylan.c@gmail.com</a>> wrote: <blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div class="HOEnZb"><div class="h5">On Monday, October 13, 2014 02:21:34 PM Laura Ekstrand wrote: > --- > tests/spec/gl-1.0/CMakeLists.gl.txt | 1 + > tests/spec/gl-1.0/blend.c | 786 ++++++++++++++++++++++++++++++++++++ > 2 files changed, 787 insertions(+) > create mode 100644 tests/spec/gl-1.0/blend.c > > diff --git a/tests/spec/gl-1.0/CMakeLists.gl.txt b/tests/spec/gl-1.0/CMakeLists.gl.txt > index e5bb33f..f5f8c48 100644 > --- a/tests/spec/gl-1.0/CMakeLists.gl.txt > +++ b/tests/spec/gl-1.0/CMakeLists.gl.txt > @@ -20,5 +20,6 @@ piglit_add_executable (gl-1.0-long-dlist long-dlist.c) > piglit_add_executable (gl-1.0-rendermode-feedback rendermode-feedback.c) > piglit_add_executable (gl-1.0-swapbuffers-behavior swapbuffers-behavior.c) > piglit_add_executable (gl-1.0-polygon-line-aa polygon-line-aa.c) > +piglit_add_executable (gl-1.0-blend-func blend.c) > > # vim: ft=cmake: > diff --git a/tests/spec/gl-1.0/blend.c b/tests/spec/gl-1.0/blend.c > new file mode 100644 > index 0000000..4812f5d > --- /dev/null > +++ b/tests/spec/gl-1.0/blend.c > @@ -0,0 +1,786 @@ > +/* BEGIN_COPYRIGHT -*- glean -*- > + * > + * Copyright (C) 1999 Allen Akin All Rights Reserved. > + * > + * 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 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 ALLEN AKIN 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. > + > + * END_COPYRIGHT > + */ > + > +/* > + * Copyright 2014 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. > + */ </div></div>Since both licenses are MIT you could just add "Copyright Intel..." below the original copyright date rather than having two copies of the license. <div><div class="h5"> > + > +/** @file blend.c > + * > + * Test blending functions. > + * > + * This test checks all combinations of source and destination > + * blend factors for the GL_FUNC_ADD blend equation. It operates > + * on all RGB or RGBA drawing surface configurations that support > + * the creation of windows. > + * > + * Note that a common cause of failures for this test is small errors > + * introduced when an implementation scales color values incorrectly; > + * for example, converting an 8-bit color value to float by > + * dividing by 256 rather than 255, or computing a blending result > + * by shifting a double-width intermediate value rather than scaling > + * it. Also, please note that the OpenGL spec requires that when > + * converting from floating-point colors to integer form, the result > + * must be rounded to the nearest integer, not truncated. > + * [1.2.1, 2.13.9] > + * > + * The test reports two error measurements. The first (readback) is > + * the error detected when reading back raw values that were written > + * to the framebuffer. The error in this case should be very close > + * to zero, since the values are carefully constructed so that they > + * can be represented accurately in the framebuffer. The second > + * (blending) is the error detected in the result of the blending > + * computation. For the test to pass, these errors must both be > + * no greater than one least-significant bit in the framebuffer > + * representation of a color. > + */ > + > +#include "piglit-util-gl.h" > + > +#include <assert.h> > +#include <math.h> > +#include <stdlib.h> > +#include <stdio.h> > + > +#define ELEMENTS(ARRAY) (sizeof(ARRAY) / sizeof(ARRAY[0])) > + > +#define HUGE_STEP 1000 > + > +/* > + * We will check each pair of blend factors > + * for each pixel in a square image of this > + * dimension, so if you make it too large, > + * the tests may take quite a while to run. > + */ > +#define drawing_size 32 > +#define img_width drawing_size > +#define img_height drawing_size > + > +PIGLIT_GL_TEST_CONFIG_BEGIN > + > + config.supports_gl_compat_version = 10; > + > + config.window_visual = PIGLIT_GL_VISUAL_RGBA | PIGLIT_GL_VISUAL_DOUBLE; > + > +PIGLIT_GL_TEST_CONFIG_END > + > +static GLenum src_factors[] = { > + GL_ZERO, > + GL_ONE, > + GL_DST_COLOR, > + GL_ONE_MINUS_DST_COLOR, > + GL_SRC_ALPHA, > + GL_ONE_MINUS_SRC_ALPHA, > + GL_DST_ALPHA, > + GL_ONE_MINUS_DST_ALPHA, > + GL_SRC_ALPHA_SATURATE, > + GL_CONSTANT_COLOR, > + GL_ONE_MINUS_CONSTANT_COLOR, > + GL_CONSTANT_ALPHA, > + GL_ONE_MINUS_CONSTANT_ALPHA > +}; > +static GLenum dst_factors[] = { > + GL_ZERO, > + GL_ONE, > + GL_SRC_COLOR, > + GL_ONE_MINUS_SRC_COLOR, > + GL_SRC_ALPHA, > + GL_ONE_MINUS_SRC_ALPHA, > + GL_DST_ALPHA, > + GL_ONE_MINUS_DST_ALPHA, > + GL_CONSTANT_COLOR, > + GL_ONE_MINUS_CONSTANT_COLOR, > + GL_CONSTANT_ALPHA, > + GL_ONE_MINUS_CONSTANT_ALPHA > +}; > +static GLenum operators[] = { > + GL_FUNC_ADD, > + GL_FUNC_SUBTRACT, > + GL_FUNC_REVERSE_SUBTRACT, > + GL_MIN, > + GL_MAX > +}; > + > +struct image { > + GLuint name; > + GLfloat *data; > +}; > + > +static struct image dst_img; /* Image #1 */ > +static struct image src_img; /* Image #2 */ > +static struct image exp_img; /* The expected blending result */ > + > +static bool have_sep_func, have_blend_equation; > +static bool have_blend_equation_sep, have_blend_color; > + > +/* A bright, semi-transparent blue */ > +static const GLfloat constant_color[4] = {0.25, 0.0, 1.0, 0.75}; > + > +/* Our random image data factory. */ > +GLfloat* > +random_image_data() { > + /* I guess we don't have to delete this because piglit just quits after a > + * test and dumps its data. */ > + int i; > + GLfloat *img = malloc(4*img_width*img_height*sizeof(GLfloat)); > + for (i = 0; i < 4*img_width*img_height; ++i) { > + img[i] = (float) rand() / RAND_MAX; > + } > + return img; > +} /* random_image_data */ > + > +/* Our solid color fill data factory. */ > +GLfloat* > +color_fill_data(GLfloat r, GLfloat g, GLfloat b, GLfloat a) { > + int i, j; > + GLfloat *img = malloc(4*img_width*img_height*sizeof(GLfloat)); > + for (j = 0; j < img_height; ++j) { /* j = vertical, i = horizontal */ > + for (i = 0; i < img_width; ++i) { > + img[4*(img_width*j + i) + 0] = r; > + img[4*(img_width*j + i) + 1] = g; > + img[4*(img_width*j + i) + 2] = b; > + img[4*(img_width*j + i) + 3] = a; > + } > + } > + return img; > +} /* color_fill_data */ > + > +static void > +image_init(struct image *image) { > + glGenTextures(1, &image->name); > + glBindTexture(GL_TEXTURE_2D, image->name); > + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, > + img_width, img_height, 0, GL_RGBA, GL_FLOAT, image->data); > + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); > + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); > +} /* image_init */ > + > + > +void > +piglit_init(int argc, char **argv) { > + > + srand(0); > + > + /* Fill src and dst with randomness. */ > + dst_img.data = random_image_data(); > + src_img.data = random_image_data(); > + > + /* Fill exp_img with constant_color. */ > + /* > + * You can use this as a check to make sure the test is working > + * properly. > + */ > + exp_img.data = color_fill_data(constant_color[0], > + constant_color[1], > + constant_color[2], > + constant_color[3]); > + > + image_init(&dst_img); > + image_init(&src_img); > + image_init(&exp_img); > +} /* piglit_init */ > + > +bool > +needs_blend_color(const GLenum func) { > + switch (func) { > + case GL_CONSTANT_COLOR: > + case GL_ONE_MINUS_CONSTANT_COLOR: > + case GL_CONSTANT_ALPHA: > + case GL_ONE_MINUS_CONSTANT_ALPHA: > + return true; > + default: > + return false; > + } > +} > + > +/* Function that verifies GL's blending behavior. */ > +static void > +apply_blend(GLenum src_factor_rgb, GLenum src_factor_a, > + GLenum dst_factor_rgb, GLenum dst_factor_a, > + GLenum op_rgb, GLenum op_a, > + float* dst, const float* src, > + const GLfloat constant_color[4]) > +{ > + float sf[4], df[4]; > + > + if (op_rgb != GL_MIN && op_rgb != GL_MAX) { > + /* Src RGB term */ > + switch (src_factor_rgb) { > + case GL_ZERO: > + sf[0] = sf[1] = sf[2] = 0.0; > + break; > + case GL_ONE: > + sf[0] = sf[1] = sf[2] = 1.0; > + break; > + case GL_DST_COLOR: > + sf[0] = dst[0]; > + sf[1] = dst[1]; > + sf[2] = dst[2]; > + break; > + case GL_ONE_MINUS_DST_COLOR: > + sf[0] = 1.0 - dst[0]; > + sf[1] = 1.0 - dst[1]; > + sf[2] = 1.0 - dst[2]; > + break; > + case GL_SRC_ALPHA: > + sf[0] = sf[1] = sf[2] = src[3]; > + break; > + case GL_ONE_MINUS_SRC_ALPHA: > + sf[0] = sf[1] = sf[2] = 1.0 - src[3]; > + break; > + case GL_DST_ALPHA: > + sf[0] = sf[1] = sf[2] = dst[3]; > + break; > + case GL_ONE_MINUS_DST_ALPHA: > + sf[0] = sf[1] = sf[2] = 1.0 - dst[3]; > + break; > + case GL_SRC_ALPHA_SATURATE: { > + float f = 1.0 - dst[3]; > + if (src[3] < f) > + f = src[3]; > + sf[0] = sf[1] = sf[2] = f; > + } > + break; > + case GL_CONSTANT_COLOR: > + sf[0] = constant_color[0]; > + sf[1] = constant_color[1]; > + sf[2] = constant_color[2]; > + break; > + case GL_ONE_MINUS_CONSTANT_COLOR: > + sf[0] = 1.0 - constant_color[0]; > + sf[1] = 1.0 - constant_color[1]; > + sf[2] = 1.0 - constant_color[2]; > + break; > + case GL_CONSTANT_ALPHA: > + sf[0] = > + sf[1] = > + sf[2] = constant_color[3]; > + break; > + case GL_ONE_MINUS_CONSTANT_ALPHA: > + sf[0] = > + sf[1] = > + sf[2] = 1.0 - constant_color[3]; > + break; > + default: > + sf[0] = sf[1] = sf[2] = 0.0; > + abort(); > + break; > + } > + > + /* Dest RGB term */ > + switch (dst_factor_rgb) { > + case GL_ZERO: > + df[0] = df[1] = df[2] = 0.0; > + break; > + case GL_ONE: > + df[0] = df[1] = df[2] = 1.0; > + break; > + case GL_SRC_COLOR: > + df[0] = src[0]; > + df[1] = src[1]; > + df[2] = src[2]; > + break; > + case GL_ONE_MINUS_SRC_COLOR: > + df[0] = 1.0 - src[0]; > + df[1] = 1.0 - src[1]; > + df[2] = 1.0 - src[2]; > + break; > + case GL_SRC_ALPHA: > + df[0] = df[1] = df[2] = src[3]; > + break; > + case GL_ONE_MINUS_SRC_ALPHA: > + df[0] = df[1] = df[2] = 1.0 - src[3]; > + break; > + case GL_DST_ALPHA: > + df[0] = df[1] = df[2] = dst[3]; > + break; > + case GL_ONE_MINUS_DST_ALPHA: > + df[0] = df[1] = df[2] = 1.0 - dst[3]; > + break; > + case GL_CONSTANT_COLOR: > + df[0] = constant_color[0]; > + df[1] = constant_color[1]; > + df[2] = constant_color[2]; > + break; > + case GL_ONE_MINUS_CONSTANT_COLOR: > + df[0] = 1.0 - constant_color[0]; > + df[1] = 1.0 - constant_color[1]; > + df[2] = 1.0 - constant_color[2]; > + break; > + case GL_CONSTANT_ALPHA: > + df[0] = > + df[1] = > + df[2] = constant_color[3]; > + break; > + case GL_ONE_MINUS_CONSTANT_ALPHA: > + df[0] = > + df[1] = > + df[2] = 1.0 - constant_color[3]; > + break; > + default: > + df[0] = df[1] = df[2] = 0.0; > + abort(); > + break; > + } > + } > + > + if (op_a != GL_MIN && op_a != GL_MAX) { > + /* Src Alpha term */ > + switch (src_factor_a) { > + case GL_ZERO: > + sf[3] = 0.0; > + break; > + case GL_ONE: > + sf[3] = 1.0; > + break; > + case GL_DST_COLOR: > + sf[3] = dst[3]; > + break; > + case GL_ONE_MINUS_DST_COLOR: > + sf[3] = 1.0 - dst[3]; > + break; > + case GL_SRC_ALPHA: > + sf[3] = src[3]; > + break; > + case GL_ONE_MINUS_SRC_ALPHA: > + sf[3] = 1.0 - src[3]; > + break; > + case GL_DST_ALPHA: > + sf[3] = dst[3]; > + break; > + case GL_ONE_MINUS_DST_ALPHA: > + sf[3] = 1.0 - dst[3]; > + break; > + case GL_SRC_ALPHA_SATURATE: > + sf[3] = 1.0; > + break; > + case GL_CONSTANT_COLOR: > + sf[3] = constant_color[3]; > + break; > + case GL_ONE_MINUS_CONSTANT_COLOR: > + sf[3] = 1.0 - constant_color[3]; > + break; > + case GL_CONSTANT_ALPHA: > + sf[3] = constant_color[3]; > + break; > + case GL_ONE_MINUS_CONSTANT_ALPHA: > + sf[3] = 1.0 - constant_color[3]; > + break; > + default: > + sf[3] = 0.0; > + abort(); > + break; > + } > + > + /* Dst Alpha term */ > + switch (dst_factor_a) { > + case GL_ZERO: > + df[3] = 0.0; > + break; > + case GL_ONE: > + df[3] = 1.0; > + break; > + case GL_SRC_COLOR: > + df[3] = src[3]; > + break; > + case GL_ONE_MINUS_SRC_COLOR: > + df[3] = 1.0 - src[3]; > + break; > + case GL_SRC_ALPHA: > + df[3] = src[3]; > + break; > + case GL_ONE_MINUS_SRC_ALPHA: > + df[3] = 1.0 - src[3]; > + break; > + case GL_DST_ALPHA: > + df[3] = dst[3]; > + break; > + case GL_ONE_MINUS_DST_ALPHA: > + df[3] = 1.0 - dst[3]; > + break; > + case GL_CONSTANT_COLOR: > + df[3] = constant_color[3]; > + break; > + case GL_ONE_MINUS_CONSTANT_COLOR: > + df[3] = 1.0 - constant_color[3]; > + break; > + case GL_CONSTANT_ALPHA: > + df[3] = constant_color[3]; > + break; > + case GL_ONE_MINUS_CONSTANT_ALPHA: > + df[3] = 1.0 - constant_color[3]; > + break; > + default: > + df[3] = 0.0; > + abort(); > + break; > + } > + } > + > + switch (op_rgb) { > + case GL_FUNC_ADD: > + dst[0] = CLAMP(src[0] * sf[0] + dst[0] * df[0], 0.0f, 1.0f); > + dst[1] = CLAMP(src[1] * sf[1] + dst[1] * df[1], 0.0f, 1.0f); > + dst[2] = CLAMP(src[2] * sf[2] + dst[2] * df[2], 0.0f, 1.0f); > + break; > + case GL_FUNC_SUBTRACT: > + dst[0] = CLAMP(src[0] * sf[0] - dst[0] * df[0], 0.0f, 1.0f); > + dst[1] = CLAMP(src[1] * sf[1] - dst[1] * df[1], 0.0f, 1.0f); > + dst[2] = CLAMP(src[2] * sf[2] - dst[2] * df[2], 0.0f, 1.0f); > + break; > + case GL_FUNC_REVERSE_SUBTRACT: > + dst[0] = CLAMP(dst[0] * df[0] - src[0] * sf[0], 0.0f, 1.0f); > + dst[1] = CLAMP(dst[1] * df[1] - src[1] * sf[1], 0.0f, 1.0f); > + dst[2] = CLAMP(dst[2] * df[2] - src[2] * sf[2], 0.0f, 1.0f); > + break; > + case GL_MIN: > + dst[0] = MIN2(src[0], dst[0]); > + dst[1] = MIN2(src[1], dst[1]); > + dst[2] = MIN2(src[2], dst[2]); > + break; > + case GL_MAX: > + dst[0] = MAX2(src[0], dst[0]); > + dst[1] = MAX2(src[1], dst[1]); > + dst[2] = MAX2(src[2], dst[2]); > + break; > + default: > + abort(); > + } > + > + switch (op_a) { > + case GL_FUNC_ADD: > + dst[3] = CLAMP(src[3] * sf[3] + dst[3] * df[3], 0.0f, 1.0f); > + break; > + case GL_FUNC_SUBTRACT: > + dst[3] = CLAMP(src[3] * sf[3] - dst[3] * df[3], 0.0f, 1.0f); > + break; > + case GL_FUNC_REVERSE_SUBTRACT: > + dst[3] = CLAMP(dst[3] * df[3] - src[3] * sf[3], 0.0f, 1.0f); > + break; > + case GL_MIN: > + dst[3] = MIN2(src[3], dst[3]); > + break; > + case GL_MAX: > + dst[3] = MAX2(src[3], dst[3]); > + break; > + default: > + abort(); > + } > + > +} /* apply_blend */ > + > + > +/* Test for one set of factor levels */ > +bool > +run_factor_set(GLenum src_factor_rgb, GLenum src_factor_a, > + GLenum dst_factor_rgb, GLenum dst_factor_a, > + GLenum op_rgb, GLenum op_a, > + const GLfloat constant_color[4]) > +{ > + int i, j; > + bool pass = true; > + > + glDisable(GL_DITHER); > + glClear(GL_COLOR_BUFFER_BIT); > + > + /* Send dst image to the framebuffer. */ > + glDisable(GL_BLEND); > + piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); > + glEnable(GL_TEXTURE_2D); > + glBindTexture(GL_TEXTURE_2D, <a href="http://dst_img.name" target="_blank">dst_img.name</a>); > + piglit_draw_rect_tex(0, 0, img_width, img_height, 0, 0, 1, 1); > + pass &= piglit_check_gl_error(GL_NO_ERROR); > + > + /* > + * Read back the contents of the framebuffer, and measure any > + * difference from what was actually written. We can't tell > + * whether errors occurred when writing or when reading back, > + * but at least we can report anything unusual. > + */ > + pass &= piglit_probe_image_rgba(0, 0, img_width, img_height, dst_img.data); > + > + /* > + * Now apply the blending > + * operation to both the framebuffer and a copy in the image > + * ``expected''. Note that a fresh source alpha must be > + * generated here, because the range of source alpha values is > + * not limited by the range of alpha values that can be > + * represented in the framebuffer. Save the source pixels in > + * the image ``src'' so we can diagnose any problems we find > + * later. > + */ > + > + /* Configure the appropriate blending settings */ > + if (have_sep_func) > + glBlendFuncSeparate(src_factor_rgb, dst_factor_rgb, > + src_factor_a, dst_factor_a); > + else > + glBlendFunc(src_factor_rgb, dst_factor_rgb); > + > + if (have_blend_equation_sep) > + glBlendEquationSeparate(op_rgb, op_a); > + else if (have_blend_equation) > + glBlendEquation(op_rgb); > + > + > + /* Send src to the framebuffer and let GL blend it with dst */ > + glEnable(GL_BLEND); > + glBindTexture(GL_TEXTURE_2D, <a href="http://src_img.name" target="_blank">src_img.name</a>); > + piglit_draw_rect_tex(0, 0, img_width, img_height, 0, 0, 1, 1); > + glDisable(GL_TEXTURE_2D); > + glDisable(GL_BLEND); > + pass &= piglit_check_gl_error(GL_NO_ERROR); > + > + /* Compute the appropriate expected. */ > + for (j = 0; j < img_height; ++j) { > + for (i = 0; i < img_width; ++i) { > + > + int idx = 4*(img_width*j + i); > + > + /* Initialize expected with dst data. */ > + exp_img.data[idx + 0] = dst_img.data[idx + 0]; > + exp_img.data[idx + 1] = dst_img.data[idx + 1]; > + exp_img.data[idx + 2] = dst_img.data[idx + 2]; > + exp_img.data[idx + 3] = dst_img.data[idx + 3]; > + > + /* Apply the blending. */ > + apply_blend(src_factor_rgb, src_factor_a, > + dst_factor_rgb, dst_factor_a, > + op_rgb, op_a, > + &exp_img.data[idx], &src_img.data[idx], constant_color); > + } > + } > + > + /* > + * Compare the image in the framebuffer to the > + * computed image (``expected'') to see if any pixels are > + * outside the expected tolerance range. > + */ > + pass &= piglit_probe_image_rgba(0, 0, img_width, img_height, exp_img.data); > + > + > + return pass; > +} /* run_factor_set */ > + > +/** > + * Run the whole suite of blend tests > + * Not a full factorial test, that would take too long. > + * Tests all add blending permutations. > + * Tests about 1/3 of subtract blending. > + * Skips most max and min tests. > + */ > +bool > +run_all_factor_sets() { > + bool pass = true; > + int gl_version = piglit_get_gl_version(); > + int counter = 0; /* Number of tests we have done. */ > + int step; > + int op, opa; > + int sf, sfa, df, dfa; > + > + unsigned num_src_factors_sep, num_dst_factors_sep; > + unsigned num_operators_rgb, num_operators_a; > + > + /* Find out what kind of GL blending capability we have. */ > + have_sep_func = false; > + have_blend_equation = false; > + have_blend_equation_sep = false; > + have_blend_color = false; > + if (gl_version >= 14) > + { > + have_blend_equation = true; > + > + if (piglit_is_extension_supported("GL_EXT_blend_func_separate")) { > + have_sep_func = true; > + } > + > + if (piglit_is_extension_supported("GL_EXT_blend_color")) { > + have_blend_color = true; > + } > + } > + else if (piglit_is_extension_supported("GL_EXT_blend_subtract") && > + piglit_is_extension_supported("GL_EXT_blend_min_max")) { > + have_blend_equation = true; > + } > + > + if (gl_version >= 20) { > + have_blend_equation_sep = true; > + } > + else if (piglit_is_extension_supported("GL_EXT_blend_equation_separate")) { > + have_blend_equation_sep = true; > + } > + > + if (have_blend_color) { > + /* Just one blend color setting for all tests */ > + /* A bright, semi-transparent blue */ > + glBlendColor(constant_color[0], constant_color[1], > + constant_color[2], constant_color[3]); > + } > + > + if (have_sep_func) { > + num_src_factors_sep = ELEMENTS(src_factors); > + num_dst_factors_sep = ELEMENTS(dst_factors); > + } > + else { > + num_src_factors_sep = 1; > + num_dst_factors_sep = 1; > + } > + > + if (have_blend_equation) { > + num_operators_rgb = ELEMENTS(operators); > + num_operators_a = ELEMENTS(operators); > + } > + else { > + num_operators_rgb = 1; /* just ADD */ > + num_operators_a = 1; /* just ADD */ > + } > + > + for (op = 0; op < num_operators_rgb; ++op) { > + for (opa = 0; opa < num_operators_a; ++opa) { > + if (operators[op] == GL_FUNC_ADD && operators[opa] == GL_FUNC_ADD) { > + /* test _all_ blend term combinations */ > + step = 1; > + } > + else if (operators[op] == GL_MIN || operators[op] == GL_MAX || > + operators[opa] == GL_MIN || operators[opa] == GL_MAX) { > + /* blend terms are N/A so only do one iteration of loops */ > + step = HUGE_STEP; > + } > + else { > + /* subtract modes: do every 3rd blend term for speed */ > + step = 3; > + } > + > + for (sf = 0; sf < ELEMENTS(src_factors); sf += step) { > + for (sfa = 0; sfa < num_src_factors_sep; sfa += step) { > + for (df = 0; df < ELEMENTS(dst_factors); df += step) { > + for (dfa = 0; dfa < num_dst_factors_sep; dfa += step) { > + > + GLenum src_rgb, src_a, dst_rgb, dst_a; > + > + if (have_sep_func) { > + src_rgb = src_factors[sf]; > + src_a = src_factors[sfa]; > + dst_rgb = dst_factors[df]; > + dst_a = dst_factors[dfa]; > + } > + else { > + src_rgb = src_a = src_factors[sf]; > + dst_rgb = dst_a = dst_factors[df]; > + } > + > + /* skip test if blend color used, but not supported. */ > + if (!have_blend_color > + && (needs_blend_color(src_rgb) || > + needs_blend_color(src_a) || > + needs_blend_color(dst_rgb) || > + needs_blend_color(dst_a))) > + continue; > + > + counter++; /* Increment counter so that tests are numbered starting from 1. */ > + > + /* For verification purposes, this prints every test > + * configuration as it runs.*/ > + /* > + * printf("%i: %s, %s, %s, %s, %s, %s\n", counter, > + * piglit_get_gl_enum_name(src_rgb), > + * piglit_get_gl_enum_name(src_a), > + * piglit_get_gl_enum_name(dst_rgb), > + * piglit_get_gl_enum_name(dst_a), > + * piglit_get_gl_enum_name(operators[op]), > + * piglit_get_gl_enum_name(operators[opa])); > + */ > + > + pass &= run_factor_set(src_rgb, src_a, dst_rgb, dst_a, operators[op], operators[opa], constant_color); > + } > + } > + } > + } > + } > + } > + > + printf("\nRan %i tests.\n", counter); > + return pass; > +} /* run_all_factor_sets */ > + > +enum piglit_result > +piglit_display(void) > +{ > + bool pass = true; > + > + pass &= run_all_factor_sets(); > + > + if (!piglit_automatic) { > + /* > + * Draw our three images, separated by some space. > + * This will show only the results of the last test. > + */ > + > + /* Draw dst */ > + glEnable(GL_TEXTURE_2D); > + glBindTexture(GL_TEXTURE_2D, <a href="http://dst_img.name" target="_blank">dst_img.name</a>); > + piglit_draw_rect_tex(0, 0, img_width, img_height, 0, 0, 1, 1); > + > + /* Draw src */ > + glBindTexture(GL_TEXTURE_2D, <a href="http://src_img.name" target="_blank">src_img.name</a>); > + piglit_draw_rect_tex(img_width + 2, 0, img_width, img_height, 0, 0, 1, 1); > + > + /* Draw exp */ > + glBindTexture(GL_TEXTURE_2D, <a href="http://exp_img.name" target="_blank">exp_img.name</a>); > + /* Have to resend the texture to GL to update GL's copy */ > + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, > + img_width, img_height, 0, GL_RGBA, GL_FLOAT, exp_img.data); > + piglit_draw_rect_tex(2*(img_width + 2), 0, img_width, img_height, 0, 0, 1, 1); > + glDisable(GL_TEXTURE_2D); > + > + piglit_present_results(); > + } > + > + > + return pass ? PIGLIT_PASS : PIGLIT_FAIL; > +} /* piglit_display */ > -- > 2.1.0 > </div></div>> _______________________________________________ > Piglit mailing list > <a href="mailto:Piglit@lists.freedesktop.org">Piglit@lists.freedesktop.org</a> > <a href="http://lists.freedesktop.org/mailman/listinfo/piglit" target="_blank">http://lists.freedesktop.org/mailman/listinfo/piglit</a> </blockquote></div> </div>