On 10/29/2013 03:55 PM, Jon Ashburn wrote:
Tests for the validity of Viewport bounds, Depth Range bounds and
Scissor Box bounds with viewport arrays (0 to GL_MAX_VIEWPORTS-1).
Viewport bounds are x, y, width, height.
Depth Range bounds are near, far.
Scissor Box bounds are left, bottom, width, height.
I'm not sure those three lines add anything of value.
Tested with Nvidia Quadro 600. All tests pass except Scissor Box with a
negative height fails to return a gl error.
---
tests/all.tests | 1 +
tests/spec/arb_viewport_array/CMakeLists.gl.txt | 1 +
tests/spec/arb_viewport_array/bounds.c | 283 ++++++++++++++++++++++++
3 files changed, 285 insertions(+)
create mode 100644 tests/spec/arb_viewport_array/bounds.c
diff --git a/tests/all.tests b/tests/all.tests
index 57ab720..4b035d3 100644
--- a/tests/all.tests
+++ b/tests/all.tests
@@ -1734,6 +1734,7 @@ spec['ARB_viewport_array'] = arb_viewport_array
arb_viewport_array['viewport-indices'] =
concurrent_test('arb_viewport_array-viewport-indices')
arb_viewport_array['depthrange-indices'] =
concurrent_test('arb_viewport_array-depthrange-indices')
arb_viewport_array['scissor-indices'] =
concurrent_test('arb_viewport_array-scissor-indices')
+arb_viewport_array['bounds'] = concurrent_test('arb_viewport_array-bounds')
nv_vertex_program = Group()
spec['NV_vertex_program'] = nv_vertex_program
diff --git a/tests/spec/arb_viewport_array/CMakeLists.gl.txt
b/tests/spec/arb_viewport_array/CMakeLists.gl.txt
index 35df5ea..e508102 100644
--- a/tests/spec/arb_viewport_array/CMakeLists.gl.txt
+++ b/tests/spec/arb_viewport_array/CMakeLists.gl.txt
@@ -12,5 +12,6 @@ link_libraries(
piglit_add_executable(arb_viewport_array-viewport-indices viewport_indices.c)
piglit_add_executable(arb_viewport_array-depthrange-indices
depth_range_indices.c)
piglit_add_executable(arb_viewport_array-scissor-indices scissor_indices.c)
+piglit_add_executable(arb_viewport_array-bounds bounds.c)
# vim: ft=cmake:
diff --git a/tests/spec/arb_viewport_array/bounds.c
b/tests/spec/arb_viewport_array/bounds.c
new file mode 100644
index 0000000..af4f441
--- /dev/null
+++ b/tests/spec/arb_viewport_array/bounds.c
@@ -0,0 +1,283 @@
+/*
+ * Copyright © 2013 LunarG, Inc.
+ *
+ * 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.
+ *
+ * Author: Jon Ashburn <j...@lunarg.com>
+ */
+
+/**
+ * Tests for the validity of Viewport bounds, Depth Range bounds and
+ * Scissor Box bounds with viewport arrays (0 to GL_MAX_VIEWPORTS-1).
+ * Viewport bounds are x, y, width, height.
+ * Depth Range bounds are near, far.
+ * Scissor Box bounds are left, bottom, width, height.
+ */
+#include "piglit-util-gl-common.h"
+
+PIGLIT_GL_TEST_CONFIG_BEGIN
+
+ config.supports_gl_compat_version = 32;
+ config.supports_gl_core_version = 32;
+
+ config.window_visual = PIGLIT_GL_VISUAL_RGBA | PIGLIT_GL_VISUAL_DOUBLE;
+
+PIGLIT_GL_TEST_CONFIG_END
+
+/**
+ * Test clamping for viewport x,y, width, height. They should be clamped
+ * to VIEWPORT_BOUNDS_RANGE and MAX_VIEWPORT_DIMS. INVALID_VALUE for
+ * negative w,h. Test default values of x,y,w,h.
+ * OpenGL 4.3 Core section 13.6.1 ref:
+ * "The location of the viewport’s bottom-left corner, given by (x, y),
+ * are clamped to be within the implementation-dependent viewport bounds
+ * range. The viewport bounds range [min, max] tuple may be determined by
+ * calling GetFloatv with the symbolic constant VIEWPORT_BOUNDS_RANGE (see
+ * section 22)."
+ *
+ * "Viewport width and height are clamped to implementation-dependent
+ * maximums when specified. The maximum width and height may be found by
+ * calling GetFloatv with the symbolic constant MAX_VIEWPORT_DIMS."
+ *
+ * "An INVALID_VALUE error is generated if either w or h is negative."
+ *
+ * "In the initial state, w and h for each viewport are set to the width
+ * and height, respectively, of the window into which the GL is to do its
+ * rendering. If the default framebuffer is bound but no default framebuffer
+ * is associated with the GL context (see chapter 9), then w and h are
+ * initially set to zero. ox, oy , n, and f are set to w/2 , h/2, 0.0, and
+ * 1.0, respectively."
+ */
+static bool
+viewport_bounds(GLint maxVP)
+{
+ GLfloat maxDims[2];
+ GLfloat range[2];
+ GLfloat vp[4];
+ bool pass = true;
+ int i;
+
+ if (!piglit_check_gl_error(GL_NO_ERROR)) {
+ printf("GL error prior to viewport bounds testing\n");
+ return false;
+ }
+
+ /* intial values for x,y,w,h */
+ glBindFramebuffer(GL_FRAMEBUFFER, 0);
+ for (i = 0; i < maxVP; i++) {
+ glGetFloati_v(GL_VIEWPORT, i, vp);
+ if (vp[0] != 0.0 || vp[1] != 0.0 ||
+ vp[2] != (GLfloat) piglit_width ||
+ vp[3] != (GLfloat) piglit_height) {
+ printf("viewport default value wrong for idx %d\n", i);
+ pass = false;
+ }
+ }
+ pass = pass && piglit_check_gl_error(GL_NO_ERROR);
pass = check && pass;
+
+ /* test clamping of viewport values */
+ glGetFloatv(GL_MAX_VIEWPORT_DIMS, maxDims);
+ glGetFloatv(GL_VIEWPORT_BOUNDS_RANGE, range);
+ vp[0] = range[0] - 2.0;
+ vp[1] = range[1] + 2.0;
+ vp[2] = maxDims[0] + 1.0;
+ vp[3] = maxDims[1] + 1.0;
+ glViewportArrayv(0, 1, vp);
+ glGetFloati_v(GL_VIEWPORT, 0, vp);
+ if (vp[0] != range[0] || vp[1] != range[1] ||
+ vp[2] != maxDims[0] || vp[3] != maxDims[1]) {
+ printf("viewport clamping failed glViewportArrayv\n");
+ pass = false;
+ }
+ glViewportIndexedf(1, vp[0], vp[1], vp[2], vp[3]);
+ glGetFloati_v(GL_VIEWPORT, 1, vp);
+ if (vp[0] != range[0] || vp[1] != range[1] ||
+ vp[2] != maxDims[0] || vp[3] != maxDims[1]) {
+ printf("viewport clamping failed glViewportIndexedf\n");
+ pass = false;
+ }
+ glViewportIndexedfv(2, vp);
+ glGetFloati_v(GL_VIEWPORT, 2, vp);
+ if (vp[0] != range[0] || vp[1] != range[1] ||
+ vp[2] != maxDims[0] || vp[3] != maxDims[1]) {
+ printf("viewport clamping failed glViewportIndexedfv\n");
+ pass = false;
+ }
+
+ pass = pass && piglit_check_gl_error(GL_NO_ERROR);
+
+ /* negative width, height gives gl error */
+ vp[2] = -10.3;
+ vp[3] = 0.0;
+ for (i = 0; i < 2; i++) {
+ glViewportArrayv(0, 1, vp);
+ pass = pass && piglit_check_gl_error(GL_INVALID_VALUE);
+ glViewportIndexedf(1, vp[0], vp[1], vp[2], vp[3]);
+ pass = pass && piglit_check_gl_error(GL_INVALID_VALUE);
+ glViewportIndexedfv(2, vp);
+ pass = pass && piglit_check_gl_error(GL_INVALID_VALUE);
+ vp[2] = 5.0;
+ vp[3] = -12345.7;
+ }
+
+ return pass;
+}
+
+/**
+ * Test clamping for depth range near and far. Make sure clamped
+ * to [0, 1]. Test default values for near and far.
+ * OpenGL 4.3 Core section 13.6.1 ref:
+ * "Values in v are each clamped to the range [0, 1] when specified."
+ *
+ */
+static bool
+depth_range_bounds(GLint maxVP)
+{
+ bool pass = true;
+ GLdouble dr[2];
+ int i;
+
+ if (!piglit_check_gl_error(GL_NO_ERROR)) {
+ printf("GL error prior to depth_range bounds testing\n");
+ return false;
+ }
+
+ /* intial values for near, far are 0.0, 1.0 repsectively */
+ glBindFramebuffer(GL_FRAMEBUFFER, 0);
I think you omit the glBindFramebuffer calls since you never set a
non-default FBO.
+ for (i = 0; i < maxVP; i++) {
+ glGetDoublei_v(GL_DEPTH_RANGE, i, dr);
+ if (dr[0] != 0.0 || dr[1] != 1.0) {
+ printf("depth_range default value wrong for idx %d\n",
+ i);
+ pass = false;
+ }
+ }
+ pass = pass && piglit_check_gl_error(GL_NO_ERROR);
+
+ /* test clamping of depth_range values */
+ dr[0] = -0.001;
+ dr[1] = 2.0;
+ glDepthRangeArrayv(0, 1, dr);
+ glGetDoublei_v(GL_DEPTH_RANGE, 0, dr);
+ if (dr[0] != 0.0 || dr[1] != 1.0) {
+ printf("depth_range clamping failed glDepthRangeArrayv\n");
+ pass = false;
+ }
+ glDepthRangeIndexed(1, dr[0], dr[1]);
+ glGetDoublei_v(GL_DEPTH_RANGE, 1, dr);
+ if (dr[0] != 0.0 || dr[1] != 1.0) {
+ printf("depth_range clamping failed glDepthRangeIndexed\n");
+ pass = false;
+ }
+
+ return pass;
+}
+
+/**
+ * Test invalid values for scissor left, bottom, width, height
+ * INVALID_VALUE for negative w,h. Test default values for left, bottom,
+ * width, height.
+ * OpenGL 4.3 Core section 13.6.1 ref:
+ * "In the initial state, left = bottom = 0, and width and
+ * height are determined by the size of the window into which the GL is
+ * to do its rendering for all viewports. If the default framebuffer is
+ * bound but no default framebuffer is associated with the GL context
+ * (see chapter 4), then width and height are initially set to zero."
+ *
+ * "If either width or height is less than zero for any scissor rectangle,
+ * then an INVALID_VALUE error is generated."
+ */
+static bool
+scissor_bounds(GLint maxVP)
+{
+ GLint sc[4];
+ bool pass = true;
+ int i;
+
+ if (!piglit_check_gl_error(GL_NO_ERROR)) {
+ printf("GL error prior to scissor bounds testing\n");
+ return false;
+ }
+
+ /* intial values for left, bottom, width, height */
+ glBindFramebuffer(GL_FRAMEBUFFER, 0);
+ for (i = 0; i < maxVP; i++) {
+ glGetIntegeri_v(GL_SCISSOR_BOX, i, sc);
+ if (sc[0] != 0.0 || sc[1] != 0.0 ||
+ sc[2] != (GLfloat) piglit_width ||
+ sc[3] != (GLfloat) piglit_height) {
+ printf("scissor box default value wrong for idx %d\n",
+ i);
+ pass = false;
+ }
+ }
+ pass = pass && piglit_check_gl_error(GL_NO_ERROR);
+
+ /* make sure large values don't cause gl errors */
+ glScissorIndexed(0, 0x8000, 0x80000000, 0x7ffff, 0x7fffffff);
+ pass = pass && piglit_check_gl_error(GL_NO_ERROR);
+
+ /* negative width, height gives gl error */
+ sc[2] = -10;
+ sc[3] = 0;
+ for (i = 0; i < 2; i++) {
+ glScissorArrayv(0, 1, sc);
+ pass = pass && piglit_check_gl_error(GL_INVALID_VALUE);
+ glScissorIndexed(1, sc[0], sc[1], sc[2], sc[3]);
+ pass = pass && piglit_check_gl_error(GL_INVALID_VALUE);
+ glScissorIndexedv(2, sc);
+ pass = pass && piglit_check_gl_error(GL_INVALID_VALUE);
+ sc[2] = 5;
+ sc[3] = -12345;
+ }
+
+ return pass;
+}
+
+enum piglit_result
+piglit_display(void)
+{
+ return PIGLIT_FAIL;
+}
+
+#define X(f, desc) \
+ do { \
+ const bool subtest_pass = (f); \
+ piglit_report_subtest_result(subtest_pass \
+ ? PIGLIT_PASS : PIGLIT_FAIL, \
+ (desc)); \
+ pass = pass && subtest_pass; \
+ } while (0)
Insert a couple blank lines here.
+void
+piglit_init(int argc, char **argv)
+{
+ bool pass= true;
+ GLint maxVP;
+
+ piglit_require_extension("GL_ARB_viewport_array");
+
+ glGetIntegerv(GL_MAX_VIEWPORTS, &maxVP);
+ X(viewport_bounds(maxVP), "Viewport x,y,width,height validity");
+ X(depth_range_bounds(maxVP), "DepthRange near, far validity");
+ X(scissor_bounds(maxVP), "Scissor left,bottom,width,height validity");
+#undef X
+ pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
+ piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
+}
Reviewed-by: Brian Paul <bri...@vmware.com>
_______________________________________________
Piglit mailing list
Piglit@lists.freedesktop.org
http://lists.freedesktop.org/mailman/listinfo/piglit
