[Piglit] [PATCH v2] Porting the two sided stencil extension tests from Glean to Piglit.

Brian Paul brian.e.paul at gmail.com
Fri Sep 25 19:46:03 PDT 2015


Hi Juliet,

This looks pretty good overall.  Assorted comments below.

Also, for Piglit we use 8-column tabs, not spaces, for indentation.  Can
you fix that too?  Thanks!

-Brian


On Fri, Sep 25, 2015 at 4:03 PM, Juliet Fru <julietfru at gmail.com> wrote:

> This test replaces the original glean tstencil2.cpp test.
> ---
>  tests/spec/gl-2.0/ two-sided-stencil.c | 743
> +++++++++++++++++++++++++++++++++
>  tests/spec/gl-2.0/CMakeLists.gl.txt    |   1 +
>  2 files changed, 744 insertions(+)
>  create mode 100644 tests/spec/gl-2.0/ two-sided-stencil.c
>
> diff --git a/tests/spec/gl-2.0/ two-sided-stencil.c b/tests/spec/gl-2.0/
> two-sided-stencil.c
> new file mode 100644
> index 0000000..7f421af
> --- /dev/null
> +++ b/tests/spec/gl-2.0/ two-sided-stencil.c
> @@ -0,0 +1,743 @@
> +/*
> + * BEGIN_COPYRIGHT -*- glean -*-
> + *
> + * Copyright (C) 1999  Allen Akin   All Rights Reserved.
> + * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
> + * Copyright (C) 2015  Intel Corporation  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 (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.
> + *
> + * END_COPYRIGHT
> + */
> +
> +/** @file stencil-extension.c
>

Let's update the filename there.



> + *
> + *  Test two-sided stencil extensions
> + *
> + *     This test could be better:
> + *     1. Generate random state vectors, render and compare to expected
> values
> + *     2. Exercise separate front/back reference values and masks for the
> + *     EXT and GL2 variations.WriteMask
>

remove stray "WriteMask".



> + *
> + *     Note: Must check writeMask of set_stencil_state to make sure it's
> correct
> + *
> + *     Authors:
> + *             Brian Paul <brianp at valinux.com>
> + *             Adapted to Piglit by Juliet Fru <julietfru at gmail.com>,
> September 2015.
> + */
> +
> +#include "piglit-util-gl.h"
> +
> +#include <assert.h>
> +#include <string.h>
> +
> +#define window_size 100
>

We should be able to remove that macro and use piglit_width and
piglit_height instead below.

Also, we should have the usual piglit config section here:

PIGLIT_GL_TEST_CONFIG_BEGIN
config.supports_gl_compat_version = 20;
config.window_visual = PIGLIT_GL_VISUAL_RGBA | PIGLIT_GL_VISUAL_DEPTH |
PIGLIT_GL_VISUAL_STENCIL;
PIGLIT_GL_TEST_CONFIG_END




> +
> +/*  two-sided methods. */
> +#define ATI 1
> +#define EXT 2
> +#define GL2 3
> +
> +GLint stencil_bits, stencil_max;
> +
> +static bool
> +have_stencil_wrap(void)
> +{
> +       if (piglit_get_gl_version() >= 2.0) {
> +               return true;
> +       } else if (piglit_is_extension_supported("GL_EXT_stencil_wrap")) {
> +               return true;
> +       }
> +       return false;
> +}
> +
> +
> +/* Draw four quads:
> + * Bottom row uses GL_CCW
> + * Top row uses GL_CW
> + * Left column is front-facing
> + * Right column is back-facing
> + * Check the values in the stencil buffer to see if they match
> + * the expected values.
> + */
> +static bool
> +render_test(GLuint expectedFront, GLuint expectedBack)
> +{
> +       GLint x0 = 0;
> +       GLint x1 = window_size / 2;
> +       GLint x2 = window_size;
>

GLint x1 = piglit_width / 2;
GLint x2 = piglit_width;


> +       GLint y0 = 0;
> +       GLint y1 = window_size / 2;
> +       GLint y2 = window_size;
>

GLint y1 = piglit_height / 2;
GLint y2 = piglit_height;



> +
> +       glFrontFace(GL_CCW);    /* this the GL default */
> +
> +       /* lower left quad = front-facing */
> +       glBegin(GL_TRIANGLE_FAN);
> +       glVertex2f(x0, y0);
> +       glVertex2f(x1, y0);
> +       glVertex2f(x1, y1);
> +       glVertex2f(x0, y1);
> +       glEnd();
> +
> +       /* lower right quad = back-facing */
> +       glBegin(GL_TRIANGLE_FAN);
> +       glVertex2f(x1, y0);
> +       glVertex2f(x1, y1);
> +       glVertex2f(x2, y1);
> +       glVertex2f(x2, y0);
> +       glEnd();
> +
> +       glFrontFace(GL_CW);
> +
> +       /* upper left quad = front-facing */
> +       glBegin(GL_TRIANGLE_FAN);
> +       glVertex2f(x0, y1);
> +       glVertex2f(x0, y2);
> +       glVertex2f(x1, y2);
> +       glVertex2f(x1, y1);
> +       glEnd();
> +
> +       /* upper right quad = back-facing */
> +       glBegin(GL_TRIANGLE_FAN);
> +       glVertex2f(x1, y1);
> +       glVertex2f(x2, y1);
> +       glVertex2f(x2, y2);
> +       glVertex2f(x1, y2);
> +       glEnd();
> +
> +       GLint midXleft = (x0  x1) / 2;
> +       GLint midXright = (x1  x2) / 2;
> +       GLint midYlower = (y0  y1) / 2;
> +       GLint midYupper = (y1  y2) / 2;
>

It appears that the '+' operator is missing in those statements.



> +       GLuint lowerLeftVal, lowerRightVal;
> +       GLuint upperLeftVal, upperRightVal;
> +
> +       glReadPixels(midXleft, midYlower, 1, 1,
> +                    GL_STENCIL_INDEX, GL_UNSIGNED_INT, &lowerLeftVal);
> +       glReadPixels(midXright, midYlower, 1, 1,
> +                    GL_STENCIL_INDEX, GL_UNSIGNED_INT, &lowerRightVal);
> +
> +       glReadPixels(midXleft, midYupper, 1, 1,
> +                    GL_STENCIL_INDEX, GL_UNSIGNED_INT, &upperLeftVal);
> +       glReadPixels(midXright, midYupper, 1, 1,
> +                    GL_STENCIL_INDEX, GL_UNSIGNED_INT, &upperRightVal);
> +
> +       if (lowerLeftVal != upperLeftVal) {
> +               printf(" FAIL:\n"
> +                      "\tLower-left value (%d) doesn't match upper-left "
> +                      "value (%d).\n \t Looks like a front/back "
> +                      "orientation bug.\n", lowerLeftVal, upperLeftVal);
> +               return false;
> +       }
> +
> +       if (lowerRightVal != upperRightVal) {
> +               printf(" FAIL:\n\tLower-right value (%d) doesn't match"
> +                      " upper-right value (%d).\n\tLooks like "
> +                      "a front/back-face orientation bug.\n",
> lowerRightVal,
> +                      upperRightVal);
> +               return false;
> +       }
> +
> +
> +       if (lowerLeftVal != expectedFront) {
> +               printf("FAIL:\n\tExpected front-face stencil value is "
> +                      "%d but found %d \n", expectedFront, lowerLeftVal);
> +               return false;
> +       } else if (lowerRightVal != expectedBack) {
> +               printf("FAIL:\n\tExpected back-face stencil value is "
> +                      "%d but found %d \n", expectedBack, lowerRightVal);
> +               return false;
> +       } else {
> +               return true;
> +       }
> +}
> +
> +
> +static bool
> +compare_state(int method, GLenum found, GLenum expected, const char *msg)
> +{
> +       if (found != expected) {
> +               printf(" FAIL:\n\tQuery of %s state failed for ", msg);
> +               switch (method) {
> +               case ATI:
> +                       printf("GL_ATI_separate_stencil\n");
> +                       break;
> +               case EXT:
> +                       printf("GL_EXT_stencil_two_side\n");
> +                       break;
> +               case GL2:
> +                       printf("GL 2.x two-sided stencil\n");
> +                       break;
> +               default:
> +                       printf("\n");
> +                       assert(0);
> +               }
> +
> +               printf("\tFound 0x%x, expected 0x%x\n", found, expected);
> +               return false;
> +       }
> +       return true;
> +}
> +
> +
> +/* Set stencil state, plus read it back and check that it's correct.
> + * Note: we only test with one reference value and one mask value
> + * even though EXT and GL2 support separate front/back refs/masks
> + */
> +static bool
> +set_stencil_state(int method,
> +                 GLenum frontStencilFail,
> +                 GLenum backStencilFail,
> +                 GLenum frontZFail,
> +                 GLenum backZFail,
> +                 GLenum frontZPass,
> +                 GLenum backZPass,
> +                 GLenum frontFunc,
> +                 GLenum backFunc,
> +                 GLint frontRef,
> +                 GLint backRef,
> +                 GLuint frontMask,
> +                 GLuint backMask,
> +                 GLuint frontWriteMask, GLuint backWriteMask)
> +{
> +       GLint get_frontStencilFail;
> +       GLint get_backStencilFail;
> +       GLint get_frontZFail;
> +       GLint get_backZFail;
> +       GLint get_frontZPass;
> +       GLint get_backZPass;
> +       GLint get_frontFunc;
> +       GLint get_backFunc;
> +       GLint get_frontRef;
> +       GLint get_backRef;
> +       GLint get_frontMask;
> +       GLint get_backMask;
> +       GLint get_frontWriteMask;
> +       GLint get_backWriteMask;
> +       GLint twoEnabled;
> +
> +       switch (method) {
> +       case ATI:
> +               assert(frontRef == backRef);
> +               assert(frontMask == backMask);
> +               assert(frontWriteMask == backWriteMask);
> +
> +               /* set state */
> +               glStencilOpSeparateATI(GL_FRONT,
> +                                      frontStencilFail,
> +                                      frontZFail, frontZPass);
> +
> +               glStencilOpSeparateATI(GL_BACK,
> +                                      backStencilFail, backZFail,
> backZPass);
> +
> +               glStencilFuncSeparateATI(frontFunc, backFunc, frontRef,
> +                                        frontMask);
> +
> +               glStencilMask(frontWriteMask);
> +
> +               /* get state */
> +               glGetIntegerv(GL_STENCIL_FAIL, &get_frontStencilFail);
> +               glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &get_frontZFail);
> +               glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &get_frontZPass);
> +               glGetIntegerv(GL_STENCIL_FUNC, &get_frontFunc);
> +               glGetIntegerv(GL_STENCIL_REF, &get_frontRef);
> +               glGetIntegerv(GL_STENCIL_VALUE_MASK, &get_frontMask);
> +               glGetIntegerv(GL_STENCIL_WRITEMASK, &get_frontWriteMask);
> +
> +               glGetIntegerv(GL_STENCIL_BACK_FUNC_ATI, &get_backFunc);
> +               glGetIntegerv(GL_STENCIL_BACK_FAIL_ATI,
> &get_backStencilFail);
> +               glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI,
> +                             &get_backZFail);
> +               glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI,
> +                             &get_backZPass);
> +               get_backRef = get_frontRef;
> +               get_backMask = get_frontMask;
> +               get_backWriteMask = get_frontWriteMask;
> +               twoEnabled = GL_TRUE;
> +               break;
> +
> +       case EXT:
> +               /* set state */
> +               glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
> +
> +               glActiveStencilFaceEXT(GL_FRONT);
> +               glStencilOp(frontStencilFail, frontZFail, frontZPass);
> +               glStencilFunc(frontFunc, frontRef, frontMask);
> +               glStencilMask(frontWriteMask);
> +
> +               glActiveStencilFaceEXT(GL_BACK);
> +               glStencilOp(backStencilFail, backZFail, backZPass);
> +               glStencilFunc(backFunc, backRef, backMask);
> +               glStencilMask(backWriteMask);
> +
> +               /* get state */
> +               glActiveStencilFaceEXT(GL_FRONT);
> +               glGetIntegerv(GL_STENCIL_FAIL, &get_frontStencilFail);
> +               glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &get_frontZFail);
> +               glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &get_frontZPass);
> +               glGetIntegerv(GL_STENCIL_FUNC, &get_frontFunc);
> +               glGetIntegerv(GL_STENCIL_REF, &get_frontRef);
> +               glGetIntegerv(GL_STENCIL_VALUE_MASK, &get_frontMask);
> +               glGetIntegerv(GL_STENCIL_WRITEMASK, &get_frontWriteMask);
> +               glActiveStencilFaceEXT(GL_BACK);
> +               glGetIntegerv(GL_STENCIL_FAIL, &get_backStencilFail);
> +               glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &get_backZFail);
> +               glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &get_backZPass);
> +               glGetIntegerv(GL_STENCIL_FUNC, &get_backFunc);
> +               glGetIntegerv(GL_STENCIL_REF, &get_backRef);
> +               glGetIntegerv(GL_STENCIL_VALUE_MASK, &get_backMask);
> +               glGetIntegerv(GL_STENCIL_WRITEMASK, &get_backWriteMask);
> +               glGetIntegerv(GL_STENCIL_TEST_TWO_SIDE_EXT, &twoEnabled);
> +               break;
> +
> +       case GL2:
> +               /* set state */
> +               glStencilOpSeparate(GL_FRONT,
> +                                   frontStencilFail, frontZFail,
> frontZPass);
> +               glStencilOpSeparate(GL_BACK,
> +                                   backStencilFail, backZFail, backZPass);
> +               glStencilFuncSeparate(GL_FRONT, frontFunc, frontRef,
> +                                     frontMask);
> +               glStencilFuncSeparate(GL_BACK, backFunc, backRef,
> backMask);
> +               glStencilMaskSeparate(GL_FRONT, frontWriteMask);
> +               glStencilMaskSeparate(GL_BACK, backWriteMask);
> +
> +               /* get state */
> +               glGetIntegerv(GL_STENCIL_FAIL, &get_frontStencilFail);
> +               glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &get_frontZFail);
> +               glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &get_frontZPass);
> +               glGetIntegerv(GL_STENCIL_FUNC, &get_frontFunc);
> +               glGetIntegerv(GL_STENCIL_REF, &get_frontRef);
> +               glGetIntegerv(GL_STENCIL_VALUE_MASK, &get_frontMask);
> +               glGetIntegerv(GL_STENCIL_WRITEMASK, &get_frontWriteMask);
> +
> +               glGetIntegerv(GL_STENCIL_BACK_FUNC, &get_backFunc);
> +               glGetIntegerv(GL_STENCIL_BACK_FAIL, &get_backStencilFail);
> +               glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_FAIL,
> +                             &get_backZFail);
> +               glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_PASS,
> +                             &get_backZPass);
> +               glGetIntegerv(GL_STENCIL_BACK_REF, &get_backRef);
> +               glGetIntegerv(GL_STENCIL_BACK_VALUE_MASK, &get_backMask);
> +               glGetIntegerv(GL_STENCIL_BACK_WRITEMASK,
> &get_backWriteMask);
> +               twoEnabled = GL_TRUE;
> +               break;
> +
> +       default:
> +               assert(0);
> +       }
> +
> +       /* mask off bits we don't care about */
> +       get_frontMask &= stencil_max;
> +       frontMask &= stencil_max;
> +       get_backMask &= stencil_max;
> +       backMask &= stencil_max;
> +       get_frontWriteMask &= stencil_max;
> +       frontWriteMask &= stencil_max;
> +       get_backWriteMask &= stencil_max;
> +       backWriteMask &= stencil_max;
> +
> +
> +       if (!piglit_check_gl_error(GL_NO_ERROR)) {
> +               printf(" FAIL:\n\tGL error  %d detected.\n", GL_NO_ERROR);
>

You can remove that printf() since the piglit_check_gl_error() function
will print a message if the check fails.



> +               return false;
> +       }
> +
> +       /* see if state-get matches state-set */
> +
> +       if (!compare_state(method, get_frontStencilFail, frontStencilFail,
> +                          "front stencil fail"))
> +               return false;
> +
> +       if (!compare_state(method, get_backStencilFail, backStencilFail,
> +                          "back stencil fail"))
> +               return false;
> +
> +       if (!compare_state(method, get_frontZFail, frontZFail,
> +                          "front Z fail"))
> +               return false;
> +
> +       if (!compare_state(method, get_backZFail, backZFail, "back Z
> fail"))
> +               return false;
> +
> +       if (!compare_state(method, get_frontZPass, frontZPass,
> +                          "front Z pass"))
> +               return false;
> +
> +       if (!compare_state(method, get_backZPass, backZPass, "back Z
> pass"))
> +               return false;
> +
> +       if (!compare_state(method, get_frontFunc, frontFunc,
> +                          "front stencil func"))
> +               return false;
> +
> +       if (!compare_state(method, get_backFunc, backFunc,
> +                          "back stencil func"))
> +               return false;
> +
> +       if (!compare_state(method, get_frontRef, frontRef,
> +                          "front stencil ref"))
> +               return false;
> +
> +       if (!compare_state(method, get_backRef, backRef, "back stencil
> ref"))
> +               return false;
> +
> +       if (!compare_state(method, get_frontMask, frontMask,
> +                          "front stencil mask"))
> +               return false;
> +
> +       if (!compare_state(method, get_backMask, backMask,
> +                          "back stencil mask"))
> +               return false;
> +
> +       if (!compare_state(method, get_frontWriteMask, frontWriteMask,
> +                          "front stencil writemask"))
> +               return false;
> +
> +       if (!compare_state(method, get_backWriteMask, backWriteMask,
> +                          "back stencil writemask"))
> +               return false;
> +
> +       if (!compare_state(method, twoEnabled, GL_TRUE, "two-side enable"))
> +               return false;
> +
> +       return true;
> +}
> +
> +
> +static bool
> +set_stencil_state2(int method,
> +                  GLenum frontStencilFail,
> +                  GLenum backStencilFail,
> +                  GLenum frontZFail,
> +                  GLenum backZFail,
> +                  GLenum frontZPass,
> +                  GLenum backZPass,
> +                  GLenum frontFunc,
> +                  GLenum backFunc, GLint ref, GLuint mask, GLuint
> writeMask)
> +{
> +       return set_stencil_state(method, frontStencilFail,
> backStencilFail, frontZFail, backZFail, frontZPass, backZPass, frontFunc,
> backFunc, ref,     /* frontRef */
> +                                ref,   /* backRef */
> +                                mask,  /* frontMask */
> +                                mask,  /* backMask */
> +                                writeMask,     /* frontWriteMask */
> +                                writeMask);    /* backWriteMask */
> +}
> +
> +
> +void
> +reset_stencil_state(int method)
> +{
> +       switch (method) {
> +       case ATI:
> +               break;
> +       case EXT:
> +               glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
> +               glActiveStencilFaceEXT(GL_FRONT);
> +               break;
> +       case GL2:
> +               break;
> +       default:
> +               assert(0);
> +       }
> +}
> +
> +
> +static bool
> +test_stencil(int method)
> +{
> +       bool pass;
> +
> +       glEnable(GL_STENCIL_TEST);
> +
> +       /**
> +        * No depth testing
> +        */
> +       glDisable(GL_DEPTH_TEST);
> +
> +       glClear(GL_COLOR_BUFFER_BIT |
> +               GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
> +
> +
> +       /* set stencil buffer vals to 5 */
> +       pass = set_stencil_state2(method, GL_KEEP, GL_KEEP,     /* stencil
> fail */
> +                                 GL_KEEP, GL_KEEP,     /* z fail */
> +                                 GL_REPLACE, GL_REPLACE,       /* z pass
> */
> +                                 GL_ALWAYS, GL_ALWAYS, /* stencil func */
> +                                 5, ~0, ~0);   /* ref, mask, set
> white_mask to ~0 */
> +       if (pass)
> +               pass = render_test(5, 5);
> +       reset_stencil_state(method);
> +       if (!pass)
> +               return false;
> +
> +       /* incr front val to 6, decr back val to 4 */
> +       pass = set_stencil_state2(method, GL_KEEP, GL_KEEP,     /* stencil
> fail */
> +                                 GL_KEEP, GL_KEEP,     /* z fail */
> +                                 GL_INCR, GL_DECR,     /* z pass */
> +                                 GL_ALWAYS, GL_ALWAYS, /* stencil func */
> +                                 5, ~0, ~0);   /* ref, mask, set
> white_mask to ~0 */
> +       if (pass)
> +               pass = render_test(6, 4);
> +       reset_stencil_state(method);
> +       if (!pass)
> +               return false;
> +
> +       /* if front==6, keep
> +        * if back<6, replace with zero
> +        * final: front=6, back=0
> +        */
> +       pass = set_stencil_state2(method, GL_KEEP, GL_ZERO,     /* stencil
> fail */
> +                                 GL_KEEP, GL_KEEP,     /* z fail */
> +                                 GL_KEEP, GL_KEEP,     /* z pass */
> +                                 GL_EQUAL, GL_LESS,    /* stencil func */
> +                                 6, ~0, ~0);   /* ref, mask, set
> white_mask to ~0 */
> +       if (pass)
> +               pass = render_test(6, 0);
> +       reset_stencil_state(method);
> +       if (!pass)
> +               return false;
> +
> +       /* if front!=10, keep, else decr
> +        * if back<10, keep, else incr
> +        * final: front=6, back=1
> +        */
> +       pass = set_stencil_state2(method, GL_DECR, GL_INCR,     /* stencil
> fail */
> +                                 GL_KEEP, GL_KEEP,     /* z fail */
> +                                 GL_KEEP, GL_KEEP,     /* z pass */
> +                                 GL_NOTEQUAL, GL_LESS, /* stencil func */
> +                                 10, ~0, ~0);  /* ref, mask, set
> white_mask to ~0 */
> +       if (pass)
> +               pass = render_test(6, 1);
> +       reset_stencil_state(method);
> +       if (!pass)
> +               return false;
> +
> +       if (method != ATI) {
> +               /* if front!=10, keep, else decr
> +                * if back<10, keep, else incr
> +                * final: front=6, back=1
> +                */
> +               pass = set_stencil_state(method, GL_DECR, GL_INCR,      /*
> stencil fail */
> +                                        GL_KEEP, GL_KEEP,      /* z fail
> */
> +                                        GL_REPLACE, GL_REPLACE,        /*
> z pass */
> +                                        GL_ALWAYS, GL_ALWAYS,  /* stencil
> func */
> +                                        0xf6, 0xf1,    /* ref */
> +                                        0xff, 0xff,    /* mask */
> +                                        0x60, 0x10);   /* writeMask */
> +               if (pass)
> +                       pass = render_test(0x66, 0x11);
> +               reset_stencil_state(method);
> +               if (!pass)
> +                       return false;
> +       }
> +
> +       /* reset write mask for clear */
> +       set_stencil_state(method, GL_KEEP, GL_KEEP,     /* stencil fail */
> +                         GL_KEEP, GL_KEEP,     /* z fail */
> +                         GL_REPLACE, GL_REPLACE,       /* z pass */
> +                         GL_ALWAYS, GL_ALWAYS, /* stencil func */
> +                         0, 0, ~0, ~0, ~0, ~0);
> +
> +       /* ============================================================
> +        * Now begin tests with depth test
> +        */
> +       glEnable(GL_DEPTH_TEST);
> +       glDepthFunc(GL_LESS);
> +
> +       glClear(GL_COLOR_BUFFER_BIT |
> +               GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
> +
> +       /* set stencil buffer vals to 7, set Z values */
> +       pass = set_stencil_state2(method, GL_KEEP, GL_KEEP,     /* stencil
> fail */
> +                                 GL_KEEP, GL_KEEP,     /* z fail */
> +                                 GL_REPLACE, GL_REPLACE,       /* z pass
> */
> +                                 GL_ALWAYS, GL_ALWAYS, /* stencil func */
> +                                 7, ~0, ~0);   /* ref, mask, set
> white_mask to ~0 */
> +       if (pass)
> +               pass = render_test(7, 7);
> +       reset_stencil_state(method);
> +       if (!pass)
> +               return false;
> +
> +
> +       /* GL_LESS test should fail everywhere
> +        * decr front to 5, incr back to 2
> +        */
> +       pass = set_stencil_state2(method, GL_KEEP, GL_KEEP,     /* stencil
> fail */
> +                                 GL_DECR, GL_INCR,     /* z fail */
> +                                 GL_KEEP, GL_KEEP,     /* z pass */
> +                                 GL_ALWAYS, GL_ALWAYS, /* stencil func */
> +                                 99, ~0, ~0);  /* ref, mask, set
> white_mask to ~0 */
> +       if (pass)
> +               pass = render_test(6, 8);
> +       reset_stencil_state(method);
> +       if (!pass)
> +               return false;
> +
> +
> +       /* set depth test = GL_EQUAL
> +        * Z test should pass everywhere
> +        * set front to 3
> +        * decr back to 7
> +        */
> +       glDepthFunc(GL_EQUAL);
> +       pass = set_stencil_state2(method, GL_KEEP, GL_KEEP,     /* stencil
> fail */
> +                                 GL_KEEP, GL_KEEP,     /* z fail */
> +                                 GL_REPLACE, GL_DECR,  /* z pass */
> +                                 GL_ALWAYS, GL_ALWAYS, /* stencil func */
> +                                 3, ~0, ~0);   /* ref, mask, set
> white_mask to ~0 */
> +       if (pass)
> +               pass = render_test(3, 7);
> +       reset_stencil_state(method);
> +       if (!pass)
> +               return false;
> +
> +
> +       /* incr front to 4 (by z pass), decr back to 6 (by stencil fail) */
> +       pass = set_stencil_state2(method, GL_DECR, GL_DECR,     /* stencil
> fail */
> +                                 GL_KEEP, GL_KEEP,     /* z fail */
> +                                 GL_INCR, GL_REPLACE,  /* z pass */
> +                                 GL_EQUAL, GL_EQUAL,   /* stencil func */
> +                                 3, ~0, ~0);   /* ref, mask, set
> white_mask to ~0 */
> +       if (pass)
> +               pass = render_test(4, 6);
> +       reset_stencil_state(method);
> +       if (!pass)
> +               return false;
> +
> +
> +       /* ============================================================
> +        * Disable depth test
> +        */
> +       glDisable(GL_DEPTH_TEST);
> +
> +       /* test stencil value mask
> +        * only test bit 1 in stencil values
> +        * if !(front&0x2 == 15&0x2), decr to 3 (should happen)
> +        * if !(back&0x2 == 15&0x2), incr to 7 (should not happen)
> +        */
> +       pass = set_stencil_state2(method, GL_DECR, GL_INCR,     /* stencil
> fail */
> +                                 GL_KEEP, GL_KEEP,     /* z fail */
> +                                 GL_KEEP, GL_KEEP,     /* z pass */
> +                                 GL_EQUAL, GL_EQUAL,   /* stencil func */
> +                                 15, 0x2, ~0); /* ref, mask, set
> white_mask to ~0 */
> +       if (pass)
> +               pass = render_test(3, 6);
> +       reset_stencil_state(method);
> +       if (!pass)
> +               return false;
> +
> +
> +       /* ============================================================
> +        * Test common two-sided stencil modes for shadow volume rendering
> +        * Requires stencil /- wrap feature.
> +        */
> +
> +       if (!have_stencil_wrap())
> +               return true;
> +
> +       glClear(GL_COLOR_BUFFER_BIT |
> +               GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
> +
> +       glEnable(GL_DEPTH_TEST);
> +       glDepthFunc(GL_LESS);
> +
> +       /* "traditional / Z-pass" method:
> +        * front face: incr on zpass
> +        * back face: decr on zpass
> +        * both front and back Z-test should pass here
> +        */
> +       pass = set_stencil_state2(method, GL_KEEP, GL_KEEP,     /* stencil
> fail */
> +                                 GL_KEEP, GL_KEEP,     /* z fail */
> +                                 GL_INCR_WRAP_EXT, GL_DECR_WRAP_EXT,   /*
> z pass */
> +                                 GL_ALWAYS, GL_ALWAYS, /* stencil func */
> +                                 0, ~0, ~0);   /* ref, mask, set
> white_mask to ~0 */
> +       if (pass)
> +               pass = render_test(1, stencil_max);
> +       reset_stencil_state(method);
> +       if (!pass)
> +               return false;
> +
> +
> +       /* "Z-fail" method:
> +        * front face: decr on zfail
> +        * back face: incr on zfail
> +        * both front and back Z-test should fail here
> +        */
> +       pass = set_stencil_state2(method, GL_KEEP, GL_KEEP,     /* stencil
> fail */
> +                                 GL_DECR_WRAP_EXT, GL_INCR_WRAP_EXT,   /*
> z fail */
> +                                 GL_KEEP, GL_KEEP,     /* z pass */
> +                                 GL_ALWAYS, GL_ALWAYS, /* stencil func */
> +                                 0, ~0, ~0);   /* ref, mask, set
> white_mask to ~0 */
> +       if (pass)
> +               pass = render_test(0, 0);
> +       reset_stencil_state(method);
> +       if (!pass)
> +               return false;
> +
> +
>

One empty line there is enough.



> +       return true;
> +}
> +
> +
> +void
> +piglit_init(int argc, char **argv)
> +{
> +
> +       /* Common setup, work done in piglit_display
> +        * piglit_ortho_projection(window_size, window_size, GL_FALSE);
> +        */
>

I think you can replace that comment with:

 /* no initialization */

Or, you could move the glGetIntegerv(GL_STENCIL_BITS) call here from below.



> +}
> +
> +
> +
> +enum piglit_result
> +piglit_display(void)
> +{
> +       bool pass = true;
> +
> +       /* how many stencil bits (we assume at least 8 above) */
> +       glGetIntegerv(GL_STENCIL_BITS, &stencil_bits);
> +       stencil_max = (1 << stencil_bits) - 1;
> +       assert(stencil_bits >= 8);
> +
> +       glViewport(0, 0, window_size, window_size);
> +       glMatrixMode(GL_PROJECTION);
> +       glLoadIdentity();
> +       glOrtho(0, window_size, 0, window_size, -1, 1);
> +       glMatrixMode(GL_MODELVIEW);
> +       glLoadIdentity();
> +
> +       if (piglit_is_extension_supported("GL_ATI_separate_stencil")) {
> +               pass = test_stencil(ATI) && pass;
> +       }
> +
> +       if (piglit_is_extension_supported("GL_EXT_stencil_two_side")) {
> +               pass = test_stencil(EXT) && pass;
> +       }
> +
> +       if (piglit_get_gl_version() >= 2.0) {
> +               pass = test_stencil(GL2) && pass;
> +       }
> +
> +       return pass ? PIGLIT_PASS : PIGLIT_FAIL;
> +}
> diff --git a/tests/spec/gl-2.0/CMakeLists.gl.txt
> b/tests/spec/gl-2.0/CMakeLists.gl.txt
> index 9461a03..bc25688 100644
> --- a/tests/spec/gl-2.0/CMakeLists.gl.txt
> +++ b/tests/spec/gl-2.0/CMakeLists.gl.txt
> @@ -14,6 +14,7 @@ piglit_add_executable (vertex-program-two-side
> vertex-program-two-side.c)
>  piglit_add_executable (gl-2.0-edgeflag edgeflag.c)
>  piglit_add_executable (gl-2.0-edgeflag-immediate edgeflag-immediate.c)
>  piglit_add_executable (gl-2.0-large-point-fs large-point-fs.c)
> +piglit_add_executable (gl-2.0-two-sided-stencil two-sided-stencil.c)
>  piglit_add_executable (gl-2.0-vertexattribpointer vertexattribpointer.c)
>  piglit_add_executable (gl-2.0-vertex-const-attr vertex-const-attr.c)
>  piglit_add_executable (gl-2.0-reuse_fragment_shader
> reuse_fragment_shader.c)
> --
> 2.4.3
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.freedesktop.org/archives/piglit/attachments/20150925/42c49c44/attachment-0001.html>


More information about the Piglit mailing list