tests/spec/arb_viewport_array/viewport_indices.c

   1 /*
   2  * Copyright © 2013 LunarG, Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  * Author: Jon Ashburn <jon@lunarg.com>
  24  */
  25
  26 /**
  27  * Tests GL_ARB_viewport_array regarding the validity for the indices.
  28  * Use both valid and invalid parameters (index, first, count)
  29  * for these new API entry points:
  30  * glViewportArrayv, glViewportIndexedf, glViewportIndexedfv, glGetFloati_v.
  31  *
  32  * Also test that writing to an invalid viewport index for Viewport, DepthRange,
  33  * Scissor Box, Scissor Test does not modify any of the state for the valid
  34  * range of indices.
  35  *
  36  */
  37
  38 #include "piglit-util-gl.h"
  39 #include <stdarg.h>
  40
  41 PIGLIT_GL_TEST_CONFIG_BEGIN
  42
  43         config.supports_gl_compat_version = 32;
  44         config.supports_gl_core_version = 32;
  45         config.supports_gl_es_version = 31;
  46
  47         config.window_visual = PIGLIT_GL_VISUAL_RGBA | PIGLIT_GL_VISUAL_DOUBLE;
  48         config.khr_no_error_support = PIGLIT_NO_ERRORS;
  49
  50 PIGLIT_GL_TEST_CONFIG_END
  51
  52 /**
  53  * Test that ViewportArrayv, ViewportIndexedf(v), GetFloati_v give the
  54  * "expected_error" gl error.  Given the values for "first" and "count"
  55  * or "index" in range [first, first+count).
  56  */
  57 static bool
  58 check_vp_index(GLuint first, GLsizei count, GLenum expected_error)
  59 {
  60         static const GLfloat v[] = {0.2, -2.3, 50.0, 1000.3};
  61         GLfloat *mv, vGet[4];
  62         unsigned int i;
  63         bool pass = true;
  64         const unsigned numIterate = (expected_error == GL_NO_ERROR)
  65                 ? count : 1;
  66         /* only iterate multiple indices for no error case */
  67         for (i = count; i > count - numIterate; i--) {
  68                 glViewportIndexedf(first + i - 1, v[0], v[1], v[2], v[3]);
  69                 pass = piglit_check_gl_error(expected_error) && pass;
  70
  71                 glViewportIndexedfv(first + i - 1, v);
  72                 pass = piglit_check_gl_error(expected_error) && pass;
  73
  74                 glGetFloati_v(GL_VIEWPORT,first + i - 1, vGet);
  75                 pass = piglit_check_gl_error(expected_error) && pass;
  76         }
  77
  78         mv = malloc(sizeof(GLfloat) * 4 * count);
  79         if (mv == NULL)
  80                 return false;
  81         for (i =0; i < count; i++) {
  82                 mv[i*4] = v[0];
  83                 mv[i*4 + 1] = v[1];
  84                 mv[i*4 + 2] = v[2];
  85                 mv[i*4 + 3] = v[3];
  86         }
  87         glViewportArrayv(first, count, mv);
  88         free(mv);
  89         pass = piglit_check_gl_error(expected_error) && pass;
  90
  91         return pass;
  92 }
  93
  94 /**
  95  * Test first + count or index valid invalid values.
  96  * Valid range is 0 thru (MAX_VIEWPORTS-1).
  97  * Also test the Enable, Disable, IsEnabled  with invalid index.
  98  */
  99 static bool
 100 test_vp_indices(GLint maxVP)
 101 {
 102         bool pass = true;
 103
 104         /**
 105          * valid largest range viewport index
 106          * OpenGL Core 4.3 Spec, section 13.6.1 ref:
 107          *    "Multiple viewports are available and are numbered zero
 108          *    through the value of MAX_VIEWPORTS minus one."
 109          */
 110         if (!check_vp_index(0, maxVP, GL_NO_ERROR)) {
 111                 printf("Got error for valid viewport range, max range=%u\n",
 112                        maxVP);
 113                 pass = false;
 114         }
 115
 116         if (!piglit_khr_no_error) {
 117                 /**
 118                  *  invalid count + first index for viewport
 119                  * OpenGL Spec Core 4.3 Spec, section 13.6.1 ref:
 120                  *     "An INVALID_VALUE error is generated if first + count
 121                  *     is greater than the value of MAX_VIEWPORTS."
 122                  */
 123                 if (!check_vp_index(maxVP - 1, 2, GL_INVALID_VALUE)) {
 124                         printf("Wrong error for invalid viewport range\n");
 125                         pass = false;
 126                 }
 127                 /**
 128                  * invalid count for viewport
 129                  * OpenGL Spec Core 4.3 Spec, section 13.6.1 ref:
 130                  *    "An INVALID_VALUE error is generated if count is negative."
 131                  */
 132                 glViewportArrayv(0, -1, NULL);
 133                 pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass;
 134         }
 135
 136         return pass;
 137 }
 138
 139 /**
 140  * Test values for viewports, depth_range and scissor boxes/test are preserved
 141  * with invalid indices.
 142  * OpenGL Core 4.3 Spec, section 13.6.1 ref:
 143  *    "Viewports whose indices lie outside the range [first, first + count)
 144  *    are not modified."
 145  */
 146 static bool
 147 test_preserve_invalid_index(GLint maxVP)
 148 {
 149         bool pass = true;
 150         static const GLfloat vp[4] = {1.5555, 2.433, 3.777, 4.888};
 151         GLfloat vpGet[4];
 152         static const GLint sc[4] = {3, 9, 17, 23};
 153         GLint scGet[4];
 154 #ifdef PIGLIT_USE_OPENGL
 155         static const GLdouble dr[2] = {0.3333, 0.66666};
 156         GLdouble drGet[2];
 157 #else
 158         static const GLfloat dr[2] = {0.3333, 0.66666};
 159         GLfloat drGet[2];
 160 #endif
 161         GLboolean scEnabled;
 162         int i;
 163
 164         /* initialize all indices to know values */
 165         for (i = 0; i < maxVP; i++) {
 166                 glViewportIndexedfv(i, vp);
 167 #ifdef PIGLIT_USE_OPENGL
 168                 glDepthRangeIndexed(i, dr[0], dr[1]);
 169 #else
 170                 glDepthRangeIndexedfOES(i, dr[0], dr[1]);
 171 #endif
 172                 glScissorIndexedv(i, sc);
 173                 glEnablei(GL_SCISSOR_TEST, i);
 174         }
 175         pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
 176
 177         if (!piglit_khr_no_error) {
 178                 /* set an illegal index and then test that no indices changed*/
 179                 glViewportIndexedf(maxVP, 0.0, 0.0, 1.0, 1.0);
 180                 glScissorIndexed(maxVP, 0, 0, 1, 1);
 181 #ifdef PIGLIT_USE_OPENGL
 182                 glDepthRangeIndexed(maxVP, 0.0, 0.0);
 183 #else
 184                 glDepthRangeIndexedfOES(maxVP, 0.0, 0.0);
 185 #endif
 186                 glDisablei(GL_SCISSOR_TEST, maxVP);
 187
 188                 pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass;
 189         }
 190
 191         for (i = 0; i < maxVP; i++) {
 192                 glGetFloati_v(GL_VIEWPORT, i, vpGet);
 193                 if (vpGet[0] != vp[0] || vpGet[1] != vp[1] || vpGet[2] != vp[2]
 194                     || vpGet[3] != vp[3]) {
 195                         printf("Viewport index %d got erroneously changed\n",
 196                                i);
 197                         pass = false;
 198                 }
 199 #ifdef PIGLIT_USE_OPENGL
 200                 glGetDoublei_v(GL_DEPTH_RANGE, i, drGet);
 201 #else
 202                 glGetFloati_vOES(GL_DEPTH_RANGE, i, drGet);
 203 #endif
 204                 /* Allow float precisions instead of double for desktop GL. */
 205                 if ((float)drGet[0] != (float)dr[0] ||
 206                     (float)drGet[1] != (float)dr[1]) {
 207                         printf("DepthRange index %d got erroneously changed\n",
 208                                i);
 209                         pass = false;
 210                 }
 211                 glGetIntegeri_v(GL_SCISSOR_BOX, i, scGet);
 212                 if (scGet[0] != sc[0] || scGet[1] != sc[1] || scGet[2] != sc[2]
 213                     || scGet[3] != sc[3]) {
 214                         printf("Scissor Box for index %d got erroneously changed\n",
 215                                i);
 216                         pass = false;
 217                 }
 218                 scEnabled = glIsEnabledi(GL_SCISSOR_TEST, i);
 219                 if (scEnabled == GL_FALSE) {
 220                         printf("Scissor Test for index %d got erroneously changed\n",
 221                                i);
 222                         pass = false;
 223                 }
 224         }
 225         return pass;
 226 }
 227
 228 enum piglit_result
 229 piglit_display(void)
 230 {
 231         return PIGLIT_FAIL;
 232 }
 233
 234 void
 235 piglit_init(int argc, char **argv)
 236 {
 237         bool pass = true;
 238         GLint maxVP;
 239
 240 #ifdef PIGLIT_USE_OPENGL
 241         piglit_require_extension("GL_ARB_viewport_array");
 242 #else
 243         piglit_require_extension("GL_OES_viewport_array");
 244 #endif
 245
 246         glGetIntegerv(GL_MAX_VIEWPORTS, &maxVP);
 247         if (!piglit_check_gl_error(GL_NO_ERROR))
 248                 piglit_report_result(PIGLIT_FAIL);
 249
 250         pass = test_preserve_invalid_index(maxVP) && pass;
 251         pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
 252         pass = test_vp_indices(maxVP) && pass;
 253         pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
 254         piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
 255 }