[Piglit] [PATCH 1/6] Ported blend func test from Glean to Piglit.

Dylan Baker baker.dylan.c at gmail.com
Mon Oct 13 19:58:15 PDT 2014


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.
> + */

Since both licenses are MIT you could just add "Copyright Intel..."
below the original copyright date rather than having two copies of the
license.

> +
> +/** @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, dst_img.name);
> +	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, src_img.name);
> +	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, dst_img.name);
> +		piglit_draw_rect_tex(0, 0, img_width, img_height, 0, 0, 1, 1);
> +
> +		/* Draw src */
> +		glBindTexture(GL_TEXTURE_2D, src_img.name);
> +		piglit_draw_rect_tex(img_width + 2, 0, img_width, img_height, 0, 0, 1, 1);
> +
> +		/* Draw exp */
> +		glBindTexture(GL_TEXTURE_2D, exp_img.name);
> +		/* 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
> 
> _______________________________________________
> Piglit mailing list
> Piglit at lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/piglit
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 473 bytes
Desc: This is a digitally signed message part.
URL: <http://lists.freedesktop.org/archives/piglit/attachments/20141013/65288015/attachment.sig>


More information about the Piglit mailing list