static bool draw_multi_viewport(void) { bool pass = true; int i, j; const int divX=4, divY=4; GLfloat w = (GLfloat) piglit_width / (GLfloat) divX; GLfloat h = (GLfloat) piglit_height / (GLfloat) divY; GLfloat data[16 * 4 /* 4x4 * (x + y + w + h) */]; int idx; int p; idx = 0; for (i = 0; i < divX; i++) { for (j = 0; j < divY; j++) { data[idx * 4 + 0] = (GLfloat)(i * w); data[idx * 4 + 1] = (GLfloat)(j * h); data[idx * 4 + 2] = w; data[idx * 4 + 3] = h; idx++; } } glViewport(0, 0, piglit_width, piglit_height); /* for glClear() */ glClear(GL_COLOR_BUFFER_BIT); glViewportArrayv(0, 16, data); glDrawArrays(GL_POINTS, 0, 1); pass = piglit_check_gl_error(GL_NO_ERROR) && pass; for (i = 0; i < divX; i++) { for (j = 0; j < divY; j++) { GLfloat expected[4]; expected[0] = 1.0 / (1 + i*4 + j); expected[1] = 0.0; expected[2] = 0.0; expected[3] = 1.0; p = piglit_probe_pixel_rgba(i * w + w/2, j * h + h /2, expected); if (!p) { printf("Wrong color for viewport i,j %d %d\n", i, j); pass = false; } } } piglit_present_results(); return pass; }
void WrappedOpenGL::glViewportIndexedfv(GLuint index, const GLfloat *v) { glViewportArrayv(index, 1, v); }
void WrappedOpenGL::glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h) { const float v[4] = {x, y, w, h}; glViewportArrayv(index, 1, v); }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL41_nglViewportArrayv(JNIEnv *env, jclass clazz, jint first, jint count, jlong v, jlong function_pointer) { const GLfloat *v_address = (const GLfloat *)(intptr_t)v; glViewportArrayvPROC glViewportArrayv = (glViewportArrayvPROC)((intptr_t)function_pointer); glViewportArrayv(first, count, v_address); }
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], vpGet[4]; bool pass = true; int i; /* intial values for x,y,w,h */ 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 = piglit_check_gl_error(GL_NO_ERROR) && 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, vpGet); if (vpGet[0] != range[0] || vpGet[1] != range[1] || vpGet[2] != maxDims[0] || vpGet[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, vpGet); if (vpGet[0] != range[0] || vpGet[1] != range[1] || vpGet[2] != maxDims[0] || vpGet[3] != maxDims[1]) { printf("viewport clamping failed glViewportIndexedf\n"); pass = false; } glViewportIndexedfv(2, vp); glGetFloati_v(GL_VIEWPORT, 2, vpGet); if (vpGet[0] != range[0] || vpGet[1] != range[1] || vpGet[2] != maxDims[0] || vpGet[3] != maxDims[1]) { printf("viewport clamping failed glViewportIndexedfv\n"); pass = false; } pass = piglit_check_gl_error(GL_NO_ERROR) && pass; /* 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 = piglit_check_gl_error(GL_INVALID_VALUE) && pass; glViewportIndexedf(1, vp[0], vp[1], vp[2], vp[3]); pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass; glViewportIndexedfv(2, vp); pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass; vp[2] = 5.0; vp[3] = -12345.7; } return pass; }
void HandRenderer::PerformDraw( bool bTransformTransfer, unsigned int iBaseViewport, unsigned int iViewPortCount, float *pViewPortData) { size_t iSpheresPerViewport = 22*2; size_t iCylindersPerViewport = 16*2; size_t iSpheresPerViewportUniform = iSpheresPerViewport; size_t iCylindersPerViewportUniform = iCylindersPerViewport; if(pViewPortData != NULL) { glViewportArrayv(0, iViewPortCount, &pViewPortData[4*iBaseViewport]); } if(bTransformTransfer) { // bind and fill sphere transform SSBO size_t sizeSphereTransforms = sizeof(VistaTransformMatrix) * iSpheresPerViewport * iViewPortCount; size_t sizeCylinderTransforms = sizeof(VistaTransformMatrix) * iCylindersPerViewport * iViewPortCount; size_t sizeSpheresArray = 22*2*16; float *data = new float[sizeSpheresArray]; for(size_t i = 0; i < sizeSpheresArray; ++i) { data[i] = 0; } glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_idSSBOTransforms); glBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeSphereTransforms, &m_vSphereTransforms[0]); glBufferSubData(GL_SHADER_STORAGE_BUFFER, sizeof(VistaTransformMatrix) * iSpheresPerViewport * 64, sizeCylinderTransforms, &m_vCylinderTransforms[0]); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, m_idSSBOTransforms); m_vSphereTransforms.clear(); m_vCylinderTransforms.clear(); } // set uniform for transform buffer offset glUniform1ui(m_locTransformOffset, iSpheresPerViewport*iBaseViewport); // set uniform for viewport indexing glUniform1i(m_locInstancesPerViewportUniform, iSpheresPerViewportUniform); // draw all shperes glDrawArraysInstanced(GL_TRIANGLES, 0, m_szSphereData, iSpheresPerViewport * iViewPortCount); // set uniform for transform buffer offset glUniform1ui(m_locTransformOffset, iSpheresPerViewport * 64 + iCylindersPerViewport*iBaseViewport); // set uniform for viewport indexing glUniform1i(m_locInstancesPerViewportUniform, iCylindersPerViewportUniform); // draw all cylinders glDrawArraysInstanced(GL_TRIANGLES, m_szSphereData, m_szCylinderData, iCylindersPerViewport * iViewPortCount); if(bTransformTransfer) { glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, 0); } }