| /*------------------------------------------------------------------------- |
| * OpenGL Conformance Test Suite |
| * ----------------------------- |
| * |
| * Copyright (c) 2016 The Khronos Group Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ /*! |
| * \file |
| * \brief |
| */ /*-------------------------------------------------------------------*/ |
| |
| /** |
| */ /*! |
| * \file gl4cSparseTextureTests.cpp |
| * \brief Conformance tests for the GL_ARB_sparse_texture functionality. |
| */ /*-------------------------------------------------------------------*/ |
| |
| #include "gl4cSparseTextureTests.hpp" |
| #include "gluContextInfo.hpp" |
| #include "gluDefs.hpp" |
| #include "glwEnums.hpp" |
| #include "glwFunctions.hpp" |
| #include "tcuTestLog.hpp" |
| |
| #include <algorithm> |
| #include <cmath> |
| #include <cstdlib> |
| #include <string.h> |
| #include <vector> |
| |
| using namespace glw; |
| using namespace glu; |
| |
| namespace gl4cts |
| { |
| |
| typedef std::pair<GLint, GLint> IntPair; |
| |
| /** Verifies last query error and generate proper log message |
| * |
| * @param funcName Verified function name |
| * @param target Target for which texture is binded |
| * @param pname Parameter name |
| * @param error Generated error code |
| * @param expectedError Expected error code |
| * |
| * @return Returns true if queried value is as expected, returns false otherwise |
| */ |
| bool SparseTextureUtils::verifyQueryError(std::stringstream& log, const char* funcName, GLint target, GLint pname, |
| GLint error, GLint expectedError) |
| { |
| if (error != expectedError) |
| { |
| log << "QueryError [" << funcName << " return wrong error code" |
| << ", target: " << target << ", pname: " << pname << ", expected: " << expectedError |
| << ", returned: " << error << "] - "; |
| |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /** Verifies last operation error and generate proper log message |
| * |
| * @param funcName Verified function name |
| * @param mesage Error message |
| * @param error Generated error code |
| * @param expectedError Expected error code |
| * |
| * @return Returns true if queried value is as expected, returns false otherwise |
| */ |
| bool SparseTextureUtils::verifyError(std::stringstream& log, const char* funcName, GLint error, GLint expectedError) |
| { |
| if (error != expectedError) |
| { |
| log << "Error [" << funcName << " return wrong error code " |
| << ", expectedError: " << expectedError << ", returnedError: " << error << "] - "; |
| |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /** Get minimal depth value for target |
| * |
| * @param target Texture target |
| * |
| * @return Returns depth value |
| */ |
| GLint SparseTextureUtils::getTargetDepth(GLint target) |
| { |
| GLint depth; |
| |
| if (target == GL_TEXTURE_3D || target == GL_TEXTURE_1D_ARRAY || target == GL_TEXTURE_2D_ARRAY || |
| target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY || target == GL_TEXTURE_2D || target == GL_TEXTURE_RECTANGLE || target == GL_TEXTURE_CUBE_MAP) |
| { |
| depth = 1; |
| } |
| else if (target == GL_TEXTURE_CUBE_MAP_ARRAY) |
| depth = 6; |
| else |
| depth = 0; |
| |
| return depth; |
| } |
| |
| /** Queries for virtual page sizes |
| * |
| * @param gl GL functions |
| * @param target Texture target |
| * @param format Texture internal format |
| * @param pageSizeX Texture page size reference for X dimension |
| * @param pageSizeY Texture page size reference for X dimension |
| * @param pageSizeZ Texture page size reference for X dimension |
| **/ |
| void SparseTextureUtils::getTexturePageSizes(const glw::Functions& gl, glw::GLint target, glw::GLint format, |
| glw::GLint& pageSizeX, glw::GLint& pageSizeY, glw::GLint& pageSizeZ) |
| { |
| gl.getInternalformativ(target, format, GL_VIRTUAL_PAGE_SIZE_X_ARB, 1, &pageSizeX); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "getInternalformativ error occurred for GL_VIRTUAL_PAGE_SIZE_X_ARB"); |
| |
| gl.getInternalformativ(target, format, GL_VIRTUAL_PAGE_SIZE_Y_ARB, 1, &pageSizeY); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "getInternalformativ error occurred for GL_VIRTUAL_PAGE_SIZE_Y_ARB"); |
| |
| gl.getInternalformativ(target, format, GL_VIRTUAL_PAGE_SIZE_Z_ARB, 1, &pageSizeZ); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "getInternalformativ error occurred for GL_VIRTUAL_PAGE_SIZE_Z_ARB"); |
| } |
| |
| /** Calculate texture size for specific mipmap |
| * |
| * @param target GL functions |
| * @param state Texture current state |
| * @param level Texture mipmap level |
| * @param width Texture output width |
| * @param height Texture output height |
| * @param depth Texture output depth |
| **/ |
| void SparseTextureUtils::getTextureLevelSize(GLint target, TextureState& state, GLint level, GLint& width, |
| GLint& height, GLint& depth) |
| { |
| width = state.width / (int)pow(2, level); |
| if (target == GL_TEXTURE_1D || target == GL_TEXTURE_1D_ARRAY) |
| height = 1; |
| else |
| height = state.height / (int)pow(2, level); |
| |
| if (target == GL_TEXTURE_3D) |
| depth = state.depth / (int)pow(2, level); |
| else if (target == GL_TEXTURE_1D_ARRAY || target == GL_TEXTURE_2D_ARRAY || target == GL_TEXTURE_CUBE_MAP_ARRAY) |
| depth = state.depth; |
| else |
| depth = 1; |
| } |
| |
| /* Texture static fields */ |
| const GLuint Texture::m_invalid_id = -1; |
| |
| /** Bind texture to target |
| * |
| * @param gl GL API functions |
| * @param id Id of texture |
| * @param tex_type Type of texture |
| **/ |
| void Texture::Bind(const Functions& gl, GLuint id, GLenum target) |
| { |
| gl.bindTexture(target, id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture"); |
| } |
| |
| /** Generate texture instance |
| * |
| * @param gl GL functions |
| * @param out_id Id of texture |
| **/ |
| void Texture::Generate(const Functions& gl, GLuint& out_id) |
| { |
| GLuint id = m_invalid_id; |
| |
| gl.genTextures(1, &id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GenTextures"); |
| |
| if (m_invalid_id == id) |
| { |
| TCU_FAIL("Invalid id"); |
| } |
| |
| out_id = id; |
| } |
| |
| /** Delete texture instance |
| * |
| * @param gl GL functions |
| * @param id Id of texture |
| **/ |
| void Texture::Delete(const Functions& gl, GLuint& id) |
| { |
| gl.deleteTextures(1, &id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GenTextures"); |
| } |
| |
| /** Allocate storage for texture |
| * |
| * @param gl GL functions |
| * @param target Texture target |
| * @param levels Number of levels |
| * @param internal_format Internal format of texture |
| * @param width Width of texture |
| * @param height Height of texture |
| * @param depth Depth of texture |
| **/ |
| void Texture::Storage(const Functions& gl, GLenum target, GLsizei levels, GLenum internal_format, GLuint width, |
| GLuint height, GLuint depth) |
| { |
| switch (target) |
| { |
| case GL_TEXTURE_1D: |
| gl.texStorage1D(target, levels, internal_format, width); |
| break; |
| case GL_TEXTURE_1D_ARRAY: |
| gl.texStorage2D(target, levels, internal_format, width, depth); |
| break; |
| case GL_TEXTURE_2D: |
| case GL_TEXTURE_RECTANGLE: |
| case GL_TEXTURE_CUBE_MAP: |
| gl.texStorage2D(target, levels, internal_format, width, height); |
| break; |
| case GL_TEXTURE_3D: |
| case GL_TEXTURE_2D_ARRAY: |
| case GL_TEXTURE_CUBE_MAP_ARRAY: |
| gl.texStorage3D(target, levels, internal_format, width, height, depth); |
| break; |
| case GL_TEXTURE_2D_MULTISAMPLE: |
| gl.texStorage2DMultisample(target, levels /* samples */, internal_format, width, height, GL_TRUE); |
| break; |
| case GL_TEXTURE_2D_MULTISAMPLE_ARRAY: |
| gl.texStorage3DMultisample(target, levels /* samples */, internal_format, width, height, depth, GL_TRUE); |
| break; |
| default: |
| TCU_FAIL("Invliad enum"); |
| break; |
| } |
| } |
| |
| /** Get texture data |
| * |
| * @param gl GL functions |
| * @param target Texture target |
| * @param format Format of data |
| * @param type Type of data |
| * @param out_data Buffer for data |
| **/ |
| void Texture::GetData(const glw::Functions& gl, glw::GLint level, glw::GLenum target, glw::GLenum format, |
| glw::GLenum type, glw::GLvoid* out_data) |
| { |
| gl.getTexImage(target, level, format, type, out_data); |
| } |
| |
| /** Set contents of texture |
| * |
| * @param gl GL functions |
| * @param target Texture target |
| * @param level Mipmap level |
| * @param x X offset |
| * @param y Y offset |
| * @param z Z offset |
| * @param width Width of texture |
| * @param height Height of texture |
| * @param depth Depth of texture |
| * @param format Format of data |
| * @param type Type of data |
| * @param pixels Buffer with image data |
| **/ |
| void Texture::SubImage(const glw::Functions& gl, glw::GLenum target, glw::GLint level, glw::GLint x, glw::GLint y, |
| glw::GLint z, glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth, glw::GLenum format, |
| glw::GLenum type, const glw::GLvoid* pixels) |
| { |
| switch (target) |
| { |
| case GL_TEXTURE_1D: |
| gl.texSubImage1D(target, level, x, width, format, type, pixels); |
| break; |
| case GL_TEXTURE_1D_ARRAY: |
| gl.texSubImage2D(target, level, x, y, width, depth, format, type, pixels); |
| break; |
| case GL_TEXTURE_2D: |
| case GL_TEXTURE_RECTANGLE: |
| gl.texSubImage2D(target, level, x, y, width, height, format, type, pixels); |
| break; |
| case GL_TEXTURE_CUBE_MAP: |
| gl.texSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, level, x, y, width, height, format, type, pixels); |
| gl.texSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, level, x, y, width, height, format, type, pixels); |
| gl.texSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, level, x, y, width, height, format, type, pixels); |
| gl.texSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, level, x, y, width, height, format, type, pixels); |
| gl.texSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, level, x, y, width, height, format, type, pixels); |
| gl.texSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, level, x, y, width, height, format, type, pixels); |
| break; |
| case GL_TEXTURE_3D: |
| case GL_TEXTURE_2D_ARRAY: |
| case GL_TEXTURE_CUBE_MAP_ARRAY: |
| gl.texSubImage3D(target, level, x, y, z, width, height, depth, format, type, pixels); |
| break; |
| default: |
| TCU_FAIL("Invliad enum"); |
| break; |
| } |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context |
| */ |
| TextureParameterQueriesTestCase::TextureParameterQueriesTestCase(deqp::Context& context) |
| : TestCase( |
| context, "TextureParameterQueries", |
| "Implements all glTexParameter* and glGetTexParameter* queries tests described in CTS_ARB_sparse_texture") |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Stub init method */ |
| void TextureParameterQueriesTestCase::init() |
| { |
| mSupportedTargets.push_back(GL_TEXTURE_2D); |
| mSupportedTargets.push_back(GL_TEXTURE_2D_ARRAY); |
| mSupportedTargets.push_back(GL_TEXTURE_CUBE_MAP); |
| mSupportedTargets.push_back(GL_TEXTURE_CUBE_MAP_ARRAY); |
| mSupportedTargets.push_back(GL_TEXTURE_3D); |
| mSupportedTargets.push_back(GL_TEXTURE_RECTANGLE); |
| |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_sparse_texture2")) |
| { |
| mNotSupportedTargets.push_back(GL_TEXTURE_2D_MULTISAMPLE); |
| mNotSupportedTargets.push_back(GL_TEXTURE_2D_MULTISAMPLE_ARRAY); |
| } |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult TextureParameterQueriesTestCase::iterate() |
| { |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_sparse_texture")) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported"); |
| return STOP; |
| } |
| |
| const Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| bool result = true; |
| |
| GLuint texture; |
| |
| //Iterate through supported targets |
| |
| for (std::vector<glw::GLint>::const_iterator iter = mSupportedTargets.begin(); iter != mSupportedTargets.end(); |
| ++iter) |
| { |
| const GLint& target = *iter; |
| |
| mLog.str(""); |
| |
| Texture::Generate(gl, texture); |
| Texture::Bind(gl, texture, target); |
| |
| result = testTextureSparseARB(gl, target) && testVirtualPageSizeIndexARB(gl, target) && |
| testNumSparseLevelsARB(gl, target); |
| |
| Texture::Delete(gl, texture); |
| |
| if (!result) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << mLog.str() << "Fail [positive tests]" |
| << tcu::TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| return STOP; |
| } |
| } |
| |
| //Iterate through not supported targets |
| for (std::vector<glw::GLint>::const_iterator iter = mNotSupportedTargets.begin(); |
| iter != mNotSupportedTargets.end(); ++iter) |
| { |
| const GLint& target = *iter; |
| |
| mLog.str(""); |
| |
| Texture::Generate(gl, texture); |
| Texture::Bind(gl, texture, target); |
| |
| result = testTextureSparseARB(gl, target, GL_INVALID_VALUE); |
| |
| Texture::Delete(gl, texture); |
| |
| if (!result) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << mLog.str() << "Fail [positive tests]" |
| << tcu::TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail on negative tests"); |
| return STOP; |
| } |
| } |
| |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| return STOP; |
| } |
| |
| /** Testing texParameter* functions for binded texture and GL_TEXTURE_SPARSE_ARB parameter name |
| * |
| * @param gl GL API functions |
| * @param target Target for which texture is binded |
| * @param expectedError Expected error code (default value GL_NO_ERROR) |
| * |
| * @return Returns true if queried value is as expected, returns false otherwise |
| */ |
| bool TextureParameterQueriesTestCase::testTextureSparseARB(const Functions& gl, GLint target, GLint expectedError) |
| { |
| const GLint pname = GL_TEXTURE_SPARSE_ARB; |
| |
| bool result = true; |
| |
| GLint testValueInt; |
| GLuint testValueUInt; |
| GLfloat testValueFloat; |
| |
| mLog << "Testing TEXTURE_SPARSE_ARB for target: " << target << " - "; |
| |
| //Check getTexParameter* default value |
| if (expectedError == GL_NO_ERROR) |
| result = checkGetTexParameter(gl, target, pname, GL_FALSE); |
| |
| //Check getTexParameter* for manually set values |
| if (result) |
| { |
| //Query to set parameter |
| gl.texParameteri(target, pname, GL_TRUE); |
| if (expectedError == GL_NO_ERROR) |
| { |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred."); |
| result = checkGetTexParameter(gl, target, pname, GL_TRUE); |
| |
| //If no error verification reset TEXTURE_SPARSE_ARB value |
| gl.texParameteri(target, pname, GL_FALSE); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred."); |
| } |
| else |
| result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameteri", target, pname, gl.getError(), |
| expectedError); |
| } |
| |
| if (result) |
| { |
| gl.texParameterf(target, pname, GL_TRUE); |
| if (expectedError == GL_NO_ERROR) |
| { |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameterf error occurred."); |
| result = checkGetTexParameter(gl, target, pname, GL_TRUE); |
| |
| gl.texParameteri(target, pname, GL_FALSE); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred."); |
| } |
| else |
| result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterf", target, pname, gl.getError(), |
| expectedError); |
| } |
| |
| if (result) |
| { |
| testValueInt = GL_TRUE; |
| gl.texParameteriv(target, pname, &testValueInt); |
| if (expectedError == GL_NO_ERROR) |
| { |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteriv error occurred."); |
| result = checkGetTexParameter(gl, target, pname, GL_TRUE); |
| |
| gl.texParameteri(target, pname, GL_FALSE); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred."); |
| } |
| else |
| result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameteriv", target, pname, gl.getError(), |
| expectedError); |
| } |
| |
| if (result) |
| { |
| testValueFloat = (GLfloat)GL_TRUE; |
| gl.texParameterfv(target, pname, &testValueFloat); |
| if (expectedError == GL_NO_ERROR) |
| { |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameterfv error occurred."); |
| result = checkGetTexParameter(gl, target, pname, GL_TRUE); |
| |
| gl.texParameteri(target, pname, GL_FALSE); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred."); |
| } |
| else |
| result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterfv", target, pname, gl.getError(), |
| expectedError); |
| } |
| |
| if (result) |
| { |
| testValueInt = GL_TRUE; |
| gl.texParameterIiv(target, pname, &testValueInt); |
| if (expectedError == GL_NO_ERROR) |
| { |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameterIiv error occurred."); |
| result = checkGetTexParameter(gl, target, pname, GL_TRUE); |
| |
| gl.texParameteri(target, pname, GL_FALSE); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred."); |
| } |
| else |
| result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterIiv", target, pname, gl.getError(), |
| expectedError); |
| } |
| |
| if (result) |
| { |
| testValueUInt = GL_TRUE; |
| gl.texParameterIuiv(target, pname, &testValueUInt); |
| if (expectedError == GL_NO_ERROR) |
| { |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameterIuiv error occurred."); |
| result = checkGetTexParameter(gl, target, pname, GL_TRUE); |
| |
| gl.texParameteri(target, pname, GL_FALSE); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred."); |
| } |
| else |
| result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterIuiv", target, pname, gl.getError(), |
| expectedError); |
| } |
| |
| return result; |
| } |
| |
| /** Testing texParameter* functions for binded texture and GL_VIRTUAL_PAGE_SIZE_INDEX_ARB parameter name |
| * |
| * @param gl GL API functions |
| * @param target Target for which texture is binded |
| * @param expectedError Expected error code (default value GL_NO_ERROR) |
| * |
| * @return Returns true if queried value is as expected, returns false otherwise |
| */ |
| bool TextureParameterQueriesTestCase::testVirtualPageSizeIndexARB(const Functions& gl, GLint target, |
| GLint expectedError) |
| { |
| const GLint pname = GL_VIRTUAL_PAGE_SIZE_INDEX_ARB; |
| |
| bool result = true; |
| |
| GLint testValueInt; |
| GLuint testValueUInt; |
| GLfloat testValueFloat; |
| |
| mLog << "Testing VIRTUAL_PAGE_SIZE_INDEX_ARB for target: " << target << " - "; |
| |
| //Check getTexParameter* default value |
| if (expectedError == GL_NO_ERROR) |
| result = checkGetTexParameter(gl, target, pname, 0); |
| |
| //Check getTexParameter* for manually set values |
| if (result) |
| { |
| gl.texParameteri(target, pname, 1); |
| if (expectedError == GL_NO_ERROR) |
| { |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred"); |
| result = checkGetTexParameter(gl, target, pname, 1); |
| |
| //If no error verification reset TEXTURE_SPARSE_ARB value |
| gl.texParameteri(target, pname, 0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred"); |
| } |
| else |
| result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameteri", target, pname, gl.getError(), |
| expectedError); |
| } |
| |
| if (result) |
| { |
| gl.texParameterf(target, pname, 2.0f); |
| if (expectedError == GL_NO_ERROR) |
| { |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameterf error occurred"); |
| result = checkGetTexParameter(gl, target, pname, 2); |
| |
| gl.texParameteri(target, pname, 0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred"); |
| } |
| else |
| result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterf", target, pname, gl.getError(), |
| expectedError); |
| } |
| |
| if (result) |
| { |
| testValueInt = 8; |
| gl.texParameteriv(target, pname, &testValueInt); |
| if (expectedError == GL_NO_ERROR) |
| { |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteriv error occurred"); |
| result = checkGetTexParameter(gl, target, pname, 8); |
| |
| gl.texParameteri(target, pname, 0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred"); |
| } |
| else |
| result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameteriv", target, pname, gl.getError(), |
| expectedError); |
| } |
| |
| if (result) |
| { |
| testValueFloat = 10.0f; |
| gl.texParameterfv(target, pname, &testValueFloat); |
| if (expectedError == GL_NO_ERROR) |
| { |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameterfv error occurred"); |
| result = checkGetTexParameter(gl, target, pname, 10); |
| |
| gl.texParameteri(target, pname, 0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred"); |
| } |
| else |
| result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterfv", target, pname, gl.getError(), |
| expectedError); |
| } |
| |
| if (result) |
| { |
| testValueInt = 6; |
| gl.texParameterIiv(target, pname, &testValueInt); |
| if (expectedError == GL_NO_ERROR) |
| { |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameterIiv error occurred"); |
| result = checkGetTexParameter(gl, target, pname, 6); |
| |
| gl.texParameteri(target, pname, 0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred"); |
| } |
| else |
| result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterIiv", target, pname, gl.getError(), |
| expectedError); |
| } |
| |
| if (result) |
| { |
| testValueUInt = 16; |
| gl.texParameterIuiv(target, pname, &testValueUInt); |
| if (expectedError == GL_NO_ERROR) |
| { |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameterIuiv error occurred"); |
| result = checkGetTexParameter(gl, target, pname, 16); |
| |
| gl.texParameteri(target, pname, 0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred"); |
| } |
| else |
| result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterIuiv", target, pname, gl.getError(), |
| expectedError); |
| } |
| |
| return result; |
| } |
| |
| /** Testing getTexParameter* functions for binded texture and GL_NUM_SPARSE_LEVELS_ARB parameter name |
| * |
| * @param gl GL API functions |
| * @param target Target for which texture is binded |
| * @param expectedError Expected error code (default value GL_NO_ERROR) |
| * |
| * @return Returns true if no error code was generated, throws exception otherwise |
| */ |
| bool TextureParameterQueriesTestCase::testNumSparseLevelsARB(const Functions& gl, GLint target) |
| { |
| const GLint pname = GL_NUM_SPARSE_LEVELS_ARB; |
| |
| bool result = true; |
| |
| GLint value_int; |
| GLuint value_uint; |
| GLfloat value_float; |
| |
| mLog << "Testing NUM_SPARSE_LEVELS_ARB for target: " << target << " - "; |
| |
| gl.getTexParameteriv(target, pname, &value_int); |
| result = SparseTextureUtils::verifyError(mLog, "glGetTexParameteriv", gl.getError(), GL_NO_ERROR); |
| |
| if (result) |
| { |
| gl.getTexParameterfv(target, pname, &value_float); |
| result = SparseTextureUtils::verifyError(mLog, "glGetTexParameterfv", gl.getError(), GL_NO_ERROR); |
| |
| if (result) |
| { |
| gl.getTexParameterIiv(target, pname, &value_int); |
| result = SparseTextureUtils::verifyError(mLog, "glGetGexParameterIiv", gl.getError(), GL_NO_ERROR); |
| |
| if (result) |
| { |
| gl.getTexParameterIuiv(target, pname, &value_uint); |
| result = SparseTextureUtils::verifyError(mLog, "getTexParameterIuiv", gl.getError(), GL_NO_ERROR); |
| } |
| } |
| } |
| |
| return result; |
| } |
| |
| /** Checking if getTexParameter* for binded texture returns value as expected |
| * |
| * @param gl GL API functions |
| * @param target Target for which texture is binded |
| * @param pname Parameter name |
| * @param expected Expected value (int because function is designed to query only int and boolean parameters) |
| * |
| * @return Returns true if queried value is as expected, returns false otherwise |
| */ |
| bool TextureParameterQueriesTestCase::checkGetTexParameter(const Functions& gl, GLint target, GLint pname, |
| GLint expected) |
| { |
| bool result = true; |
| |
| GLint value_int; |
| GLuint value_uint; |
| GLfloat value_float; |
| |
| mLog << "Testing GetTexParameter for target: " << target << " - "; |
| |
| gl.getTexParameteriv(target, pname, &value_int); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexParameteriv error occurred"); |
| if (value_int != expected) |
| { |
| mLog << "glGetTexParameteriv return wrong value" |
| << ", target: " << target << ", pname: " << pname << ", expected: " << expected |
| << ", returned: " << value_int << " - "; |
| |
| result = false; |
| } |
| |
| gl.getTexParameterfv(target, pname, &value_float); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexParameterfv error occurred"); |
| if ((GLint)value_float != expected) |
| { |
| mLog << "glGetTexParameterfv return wrong value" |
| << ", target: " << target << ", pname: " << pname << ", expected: " << expected |
| << ", returned: " << (GLint)value_float << " - "; |
| |
| result = false; |
| } |
| |
| gl.getTexParameterIiv(target, pname, &value_int); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetGexParameterIiv error occurred"); |
| if (value_int != expected) |
| { |
| mLog << "glGetGexParameterIiv return wrong value" |
| << ", target: " << target << ", pname: " << pname << ", expected: " << expected |
| << ", returned: " << value_int << " - "; |
| |
| result = false; |
| } |
| |
| gl.getTexParameterIuiv(target, pname, &value_uint); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetGexParameterIui error occurred"); |
| if ((GLint)value_uint != expected) |
| { |
| mLog << "glGetGexParameterIui return wrong value" |
| << ", target: " << target << ", pname: " << pname << ", expected: " << expected |
| << ", returned: " << (GLint)value_uint << " - "; |
| |
| result = false; |
| } |
| |
| return result; |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context |
| */ |
| InternalFormatQueriesTestCase::InternalFormatQueriesTestCase(deqp::Context& context) |
| : TestCase(context, "InternalFormatQueries", |
| "Implements GetInternalformat query tests described in CTS_ARB_sparse_texture") |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Stub init method */ |
| void InternalFormatQueriesTestCase::init() |
| { |
| mSupportedTargets.push_back(GL_TEXTURE_2D); |
| mSupportedTargets.push_back(GL_TEXTURE_2D_ARRAY); |
| mSupportedTargets.push_back(GL_TEXTURE_3D); |
| mSupportedTargets.push_back(GL_TEXTURE_CUBE_MAP); |
| mSupportedTargets.push_back(GL_TEXTURE_CUBE_MAP_ARRAY); |
| mSupportedTargets.push_back(GL_TEXTURE_RECTANGLE); |
| |
| mSupportedInternalFormats.push_back(GL_R8); |
| mSupportedInternalFormats.push_back(GL_R8_SNORM); |
| mSupportedInternalFormats.push_back(GL_R16); |
| mSupportedInternalFormats.push_back(GL_R16_SNORM); |
| mSupportedInternalFormats.push_back(GL_RG8); |
| mSupportedInternalFormats.push_back(GL_RG8_SNORM); |
| mSupportedInternalFormats.push_back(GL_RG16); |
| mSupportedInternalFormats.push_back(GL_RG16_SNORM); |
| mSupportedInternalFormats.push_back(GL_RGB565); |
| mSupportedInternalFormats.push_back(GL_RGBA8); |
| mSupportedInternalFormats.push_back(GL_RGBA8_SNORM); |
| mSupportedInternalFormats.push_back(GL_RGB10_A2); |
| mSupportedInternalFormats.push_back(GL_RGB10_A2UI); |
| mSupportedInternalFormats.push_back(GL_RGBA16); |
| mSupportedInternalFormats.push_back(GL_RGBA16_SNORM); |
| mSupportedInternalFormats.push_back(GL_R16F); |
| mSupportedInternalFormats.push_back(GL_RG16F); |
| mSupportedInternalFormats.push_back(GL_RGBA16F); |
| mSupportedInternalFormats.push_back(GL_R32F); |
| mSupportedInternalFormats.push_back(GL_RG32F); |
| mSupportedInternalFormats.push_back(GL_RGBA32F); |
| mSupportedInternalFormats.push_back(GL_R11F_G11F_B10F); |
| mSupportedInternalFormats.push_back(GL_RGB9_E5); |
| mSupportedInternalFormats.push_back(GL_R8I); |
| mSupportedInternalFormats.push_back(GL_R8UI); |
| mSupportedInternalFormats.push_back(GL_R16I); |
| mSupportedInternalFormats.push_back(GL_R16UI); |
| mSupportedInternalFormats.push_back(GL_R32I); |
| mSupportedInternalFormats.push_back(GL_R32UI); |
| mSupportedInternalFormats.push_back(GL_RG8I); |
| mSupportedInternalFormats.push_back(GL_RG8UI); |
| mSupportedInternalFormats.push_back(GL_RG16I); |
| mSupportedInternalFormats.push_back(GL_RG16UI); |
| mSupportedInternalFormats.push_back(GL_RG32I); |
| mSupportedInternalFormats.push_back(GL_RG32UI); |
| mSupportedInternalFormats.push_back(GL_RGBA8I); |
| mSupportedInternalFormats.push_back(GL_RGBA8UI); |
| mSupportedInternalFormats.push_back(GL_RGBA16I); |
| mSupportedInternalFormats.push_back(GL_RGBA16UI); |
| mSupportedInternalFormats.push_back(GL_RGBA32I); |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult InternalFormatQueriesTestCase::iterate() |
| { |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_sparse_texture")) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported"); |
| return STOP; |
| } |
| |
| const Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| bool result = true; |
| |
| mLog << "Testing getInternalformativ - "; |
| |
| for (std::vector<glw::GLint>::const_iterator iter = mSupportedTargets.begin(); iter != mSupportedTargets.end(); |
| ++iter) |
| { |
| const GLint& target = *iter; |
| |
| for (std::vector<glw::GLint>::const_iterator formIter = mSupportedInternalFormats.begin(); |
| formIter != mSupportedInternalFormats.end(); ++formIter) |
| { |
| const GLint& format = *formIter; |
| GLint value; |
| |
| gl.getInternalformativ(target, format, GL_NUM_VIRTUAL_PAGE_SIZES_ARB, 1, &value); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "getInternalformativ error occurred for GL_NUM_VIRTUAL_PAGE_SIZES_ARB"); |
| if (value == 0) |
| { |
| mLog << "getInternalformativ for GL_NUM_VIRTUAL_PAGE_SIZES_ARB, target: " << target |
| << ", format: " << format << " returns wrong value: " << value << " - "; |
| |
| result = false; |
| } |
| |
| if (result) |
| { |
| GLint pageSizeX; |
| GLint pageSizeY; |
| GLint pageSizeZ; |
| SparseTextureUtils::getTexturePageSizes(gl, target, format, pageSizeX, pageSizeY, pageSizeZ); |
| } |
| else |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << mLog.str() << "Fail" << tcu::TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| return STOP; |
| } |
| } |
| } |
| |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| |
| return STOP; |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context |
| */ |
| SimpleQueriesTestCase::SimpleQueriesTestCase(deqp::Context& context) |
| : TestCase(context, "SimpleQueries", "Implements Get* queries tests described in CTS_ARB_sparse_texture") |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult SimpleQueriesTestCase::iterate() |
| { |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_sparse_texture")) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported"); |
| return STOP; |
| } |
| |
| const Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| testSipmleQueries(gl, GL_MAX_SPARSE_TEXTURE_SIZE_ARB); |
| testSipmleQueries(gl, GL_MAX_SPARSE_3D_TEXTURE_SIZE_ARB); |
| testSipmleQueries(gl, GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB); |
| testSipmleQueries(gl, GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB); |
| |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| return STOP; |
| } |
| |
| void SimpleQueriesTestCase::testSipmleQueries(const Functions& gl, GLint pname) |
| { |
| std::stringstream log; |
| log << "Testing simple query for pname: " << pname << " - "; |
| |
| bool result = true; |
| |
| GLint value_int; |
| GLint64 value_int64; |
| GLfloat value_float; |
| GLdouble value_double; |
| GLboolean value_bool; |
| |
| gl.getIntegerv(pname, &value_int); |
| result = SparseTextureUtils::verifyError(log, "getIntegerv", gl.getError(), GL_NO_ERROR); |
| |
| if (result) |
| { |
| gl.getInteger64v(pname, &value_int64); |
| result = SparseTextureUtils::verifyError(log, "getInteger64v", gl.getError(), GL_NO_ERROR); |
| |
| if (result) |
| { |
| gl.getFloatv(pname, &value_float); |
| result = SparseTextureUtils::verifyError(log, "getFloatv", gl.getError(), GL_NO_ERROR); |
| |
| if (result) |
| { |
| gl.getDoublev(pname, &value_double); |
| result = SparseTextureUtils::verifyError(log, "getDoublev", gl.getError(), GL_NO_ERROR); |
| |
| if (result) |
| { |
| gl.getBooleanv(pname, &value_bool); |
| result = SparseTextureUtils::verifyError(log, "getBooleanv", gl.getError(), GL_NO_ERROR); |
| } |
| } |
| } |
| } |
| |
| if (!result) |
| { |
| TCU_FAIL(log.str().c_str()); |
| } |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context |
| */ |
| SparseTextureAllocationTestCase::SparseTextureAllocationTestCase(deqp::Context& context) |
| : TestCase(context, "SparseTextureAllocation", "Verifies TexStorage* functionality added in CTS_ARB_sparse_texture") |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context |
| */ |
| SparseTextureAllocationTestCase::SparseTextureAllocationTestCase(deqp::Context& context, const char* name, |
| const char* description) |
| : TestCase(context, name, description) |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Initializes the test group contents. */ |
| void SparseTextureAllocationTestCase::init() |
| { |
| mSupportedTargets.push_back(GL_TEXTURE_2D); |
| mSupportedTargets.push_back(GL_TEXTURE_2D_ARRAY); |
| mSupportedTargets.push_back(GL_TEXTURE_CUBE_MAP); |
| mSupportedTargets.push_back(GL_TEXTURE_CUBE_MAP_ARRAY); |
| mSupportedTargets.push_back(GL_TEXTURE_3D); |
| mSupportedTargets.push_back(GL_TEXTURE_RECTANGLE); |
| |
| mFullArrayTargets.push_back(GL_TEXTURE_2D_ARRAY); |
| mFullArrayTargets.push_back(GL_TEXTURE_CUBE_MAP); |
| mFullArrayTargets.push_back(GL_TEXTURE_CUBE_MAP_ARRAY); |
| |
| mSupportedInternalFormats.push_back(GL_R8); |
| mSupportedInternalFormats.push_back(GL_R8_SNORM); |
| mSupportedInternalFormats.push_back(GL_R16); |
| mSupportedInternalFormats.push_back(GL_R16_SNORM); |
| mSupportedInternalFormats.push_back(GL_RG8); |
| mSupportedInternalFormats.push_back(GL_RG8_SNORM); |
| mSupportedInternalFormats.push_back(GL_RG16); |
| mSupportedInternalFormats.push_back(GL_RG16_SNORM); |
| mSupportedInternalFormats.push_back(GL_RGB565); |
| mSupportedInternalFormats.push_back(GL_RGBA8); |
| mSupportedInternalFormats.push_back(GL_RGBA8_SNORM); |
| mSupportedInternalFormats.push_back(GL_RGB10_A2); |
| mSupportedInternalFormats.push_back(GL_RGB10_A2UI); |
| mSupportedInternalFormats.push_back(GL_RGBA16); |
| mSupportedInternalFormats.push_back(GL_RGBA16_SNORM); |
| mSupportedInternalFormats.push_back(GL_R16F); |
| mSupportedInternalFormats.push_back(GL_RG16F); |
| mSupportedInternalFormats.push_back(GL_RGBA16F); |
| mSupportedInternalFormats.push_back(GL_R32F); |
| mSupportedInternalFormats.push_back(GL_RG32F); |
| mSupportedInternalFormats.push_back(GL_RGBA32F); |
| mSupportedInternalFormats.push_back(GL_R11F_G11F_B10F); |
| mSupportedInternalFormats.push_back(GL_RGB9_E5); |
| mSupportedInternalFormats.push_back(GL_R8I); |
| mSupportedInternalFormats.push_back(GL_R8UI); |
| mSupportedInternalFormats.push_back(GL_R16I); |
| mSupportedInternalFormats.push_back(GL_R16UI); |
| mSupportedInternalFormats.push_back(GL_R32I); |
| mSupportedInternalFormats.push_back(GL_R32UI); |
| mSupportedInternalFormats.push_back(GL_RG8I); |
| mSupportedInternalFormats.push_back(GL_RG8UI); |
| mSupportedInternalFormats.push_back(GL_RG16I); |
| mSupportedInternalFormats.push_back(GL_RG16UI); |
| mSupportedInternalFormats.push_back(GL_RG32I); |
| mSupportedInternalFormats.push_back(GL_RG32UI); |
| mSupportedInternalFormats.push_back(GL_RGBA8I); |
| mSupportedInternalFormats.push_back(GL_RGBA8UI); |
| mSupportedInternalFormats.push_back(GL_RGBA16I); |
| mSupportedInternalFormats.push_back(GL_RGBA16UI); |
| mSupportedInternalFormats.push_back(GL_RGBA32I); |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult SparseTextureAllocationTestCase::iterate() |
| { |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_sparse_texture")) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported"); |
| return STOP; |
| } |
| |
| const Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| bool result = true; |
| |
| for (std::vector<glw::GLint>::const_iterator iter = mSupportedTargets.begin(); iter != mSupportedTargets.end(); |
| ++iter) |
| { |
| const GLint& target = *iter; |
| |
| for (std::vector<glw::GLint>::const_iterator formIter = mSupportedInternalFormats.begin(); |
| formIter != mSupportedInternalFormats.end(); ++formIter) |
| { |
| const GLint& format = *formIter; |
| |
| mLog.str(""); |
| mLog << "Testing sparse texture allocation for target: " << target << ", format: " << format << " - "; |
| |
| result = positiveTesting(gl, target, format) && verifyTexParameterErrors(gl, target, format) && |
| verifyTexStorageVirtualPageSizeIndexError(gl, target, format) && |
| verifyTexStorageFullArrayCubeMipmapsError(gl, target, format) && |
| verifyTexStorageInvalidValueErrors(gl, target, format); |
| |
| if (!result) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << mLog.str() << "Fail" << tcu::TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| return STOP; |
| } |
| } |
| } |
| |
| for (std::vector<glw::GLint>::const_iterator iter = mFullArrayTargets.begin(); iter != mFullArrayTargets.end(); |
| ++iter) |
| { |
| const GLint& target = *iter; |
| |
| for (std::vector<glw::GLint>::const_iterator formIter = mSupportedInternalFormats.begin(); |
| formIter != mSupportedInternalFormats.end(); ++formIter) |
| { |
| const GLint& format = *formIter; |
| |
| mLog.str(""); |
| mLog << "Testing sparse texture allocation for target [full array]: " << target << ", format: " << format |
| << " - "; |
| |
| result = verifyTexStorageFullArrayCubeMipmapsError(gl, target, format); |
| |
| if (!result) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << mLog.str() << "Fail" << tcu::TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| return STOP; |
| } |
| } |
| } |
| |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| return STOP; |
| } |
| |
| /** Testing if texStorage* functionality added in ARB_sparse_texture extension works properly for given target and internal format |
| * |
| * @param gl GL API functions |
| * @param target Target for which texture is binded |
| * @param format Texture internal format |
| * |
| * @return Returns true if no errors occurred, false otherwise. |
| **/ |
| bool SparseTextureAllocationTestCase::positiveTesting(const Functions& gl, GLint target, GLint format) |
| { |
| mLog << "Positive Testing - "; |
| |
| GLuint texture; |
| |
| Texture::Generate(gl, texture); |
| Texture::Bind(gl, texture, target); |
| |
| GLint pageSizeX; |
| GLint pageSizeY; |
| GLint pageSizeZ; |
| GLint depth = SparseTextureUtils::getTargetDepth(target); |
| SparseTextureUtils::getTexturePageSizes(gl, target, format, pageSizeX, pageSizeY, pageSizeZ); |
| |
| gl.texParameteri(target, GL_TEXTURE_SPARSE_ARB, GL_TRUE); |
| if (!SparseTextureUtils::verifyError(mLog, "texParameteri", gl.getError(), GL_NO_ERROR)) |
| { |
| Texture::Delete(gl, texture); |
| return false; |
| } |
| |
| //The <width> and <height> has to be equal for cube map textures |
| if (target == GL_TEXTURE_CUBE_MAP || target == GL_TEXTURE_CUBE_MAP_ARRAY) |
| { |
| if (pageSizeX > pageSizeY) |
| pageSizeY = pageSizeX; |
| else if (pageSizeX < pageSizeY) |
| pageSizeX = pageSizeY; |
| } |
| |
| Texture::Storage(gl, target, 1, format, pageSizeX, pageSizeY, depth * pageSizeZ); |
| if (!SparseTextureUtils::verifyError(mLog, "Texture::Storage", gl.getError(), GL_NO_ERROR)) |
| { |
| Texture::Delete(gl, texture); |
| return false; |
| } |
| |
| Texture::Delete(gl, texture); |
| return true; |
| } |
| |
| /** Verifies if texParameter* generate proper errors for given target and internal format. |
| * |
| * @param gl GL API functions |
| * @param target Target for which texture is binded |
| * @param format Texture internal format |
| * |
| * @return Returns true if errors are as expected, false otherwise. |
| */ |
| bool SparseTextureAllocationTestCase::verifyTexParameterErrors(const Functions& gl, GLint target, GLint format) |
| { |
| mLog << "Verify TexParameter errors - "; |
| |
| bool result = true; |
| |
| GLuint texture; |
| GLint depth; |
| |
| Texture::Generate(gl, texture); |
| Texture::Bind(gl, texture, target); |
| |
| depth = SparseTextureUtils::getTargetDepth(target); |
| |
| Texture::Storage(gl, target, 1, format, 8, 8, depth); |
| if (!SparseTextureUtils::verifyError(mLog, "TexStorage", gl.getError(), GL_NO_ERROR)) |
| { |
| Texture::Delete(gl, texture); |
| return false; |
| } |
| |
| GLint immutableFormat; |
| |
| gl.getTexParameteriv(target, GL_TEXTURE_IMMUTABLE_FORMAT, &immutableFormat); |
| if (!SparseTextureUtils::verifyQueryError(mLog, "getTexParameteriv", target, GL_TEXTURE_IMMUTABLE_FORMAT, |
| gl.getError(), GL_NO_ERROR)) |
| { |
| Texture::Delete(gl, texture); |
| return false; |
| } |
| |
| // Test error only if texture is immutable format, otherwise skip |
| if (immutableFormat == GL_TRUE) |
| { |
| std::vector<IntPair> params; |
| params.push_back(IntPair(GL_TEXTURE_SPARSE_ARB, GL_TRUE)); |
| params.push_back(IntPair(GL_VIRTUAL_PAGE_SIZE_INDEX_ARB, 1)); |
| |
| for (std::vector<IntPair>::const_iterator iter = params.begin(); iter != params.end(); ++iter) |
| { |
| const IntPair& param = *iter; |
| |
| if (result) |
| { |
| gl.texParameteri(target, param.first, param.second); |
| result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameteri", target, param.first, |
| gl.getError(), GL_INVALID_OPERATION); |
| } |
| |
| if (result) |
| { |
| gl.texParameterf(target, param.first, (GLfloat)param.second); |
| result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterf", target, param.first, |
| gl.getError(), GL_INVALID_OPERATION); |
| } |
| |
| if (result) |
| { |
| GLint value = param.second; |
| gl.texParameteriv(target, param.first, &value); |
| result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameteriv", target, param.first, |
| gl.getError(), GL_INVALID_OPERATION); |
| } |
| |
| if (result) |
| { |
| GLfloat value = (GLfloat)param.second; |
| gl.texParameterfv(target, param.first, &value); |
| result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterfv", target, param.first, |
| gl.getError(), GL_INVALID_OPERATION); |
| } |
| |
| if (result) |
| { |
| GLint value = param.second; |
| gl.texParameterIiv(target, param.first, &value); |
| result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterIiv", target, param.first, |
| gl.getError(), GL_INVALID_OPERATION); |
| } |
| |
| if (result) |
| { |
| GLuint value = param.second; |
| gl.texParameterIuiv(target, param.first, &value); |
| result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterIuiv", target, param.first, |
| gl.getError(), GL_INVALID_OPERATION); |
| } |
| } |
| } |
| |
| Texture::Delete(gl, texture); |
| return result; |
| } |
| |
| /** Verifies if texStorage* generate proper error for given target and internal format when |
| * VIRTUAL_PAGE_SIZE_INDEX_ARB value is greater than NUM_VIRTUAL_PAGE_SIZES_ARB. |
| * |
| * @param gl GL API functions |
| * @param target Target for which texture is binded |
| * @param format Texture internal format |
| * |
| * @return Returns true if errors are as expected, false otherwise. |
| */ |
| bool SparseTextureAllocationTestCase::verifyTexStorageVirtualPageSizeIndexError(const Functions& gl, GLint target, |
| GLint format) |
| { |
| mLog << "Verify VirtualPageSizeIndex errors - "; |
| |
| GLuint texture; |
| GLint depth; |
| GLint numPageSizes; |
| |
| Texture::Generate(gl, texture); |
| Texture::Bind(gl, texture, target); |
| |
| gl.texParameteri(target, GL_TEXTURE_SPARSE_ARB, GL_TRUE); |
| if (!SparseTextureUtils::verifyQueryError(mLog, "texParameteri", target, GL_TEXTURE_SPARSE_ARB, gl.getError(), |
| GL_NO_ERROR)) |
| { |
| Texture::Delete(gl, texture); |
| return false; |
| } |
| |
| gl.getInternalformativ(target, format, GL_NUM_VIRTUAL_PAGE_SIZES_ARB, 1, &numPageSizes); |
| if (!SparseTextureUtils::verifyQueryError(mLog, "getInternalformativ", target, GL_NUM_VIRTUAL_PAGE_SIZES_ARB, |
| gl.getError(), GL_NO_ERROR)) |
| { |
| Texture::Delete(gl, texture); |
| return false; |
| } |
| |
| numPageSizes += 1; |
| gl.texParameteri(target, GL_VIRTUAL_PAGE_SIZE_INDEX_ARB, numPageSizes); |
| if (!SparseTextureUtils::verifyQueryError(mLog, "texParameteri", target, GL_VIRTUAL_PAGE_SIZE_INDEX_ARB, |
| gl.getError(), GL_NO_ERROR)) |
| { |
| Texture::Delete(gl, texture); |
| return false; |
| } |
| |
| depth = SparseTextureUtils::getTargetDepth(target); |
| |
| Texture::Storage(gl, target, 1, format, 8, 8, depth); |
| if (!SparseTextureUtils::verifyError(mLog, "TexStorage", gl.getError(), GL_INVALID_OPERATION)) |
| { |
| Texture::Delete(gl, texture); |
| return false; |
| } |
| |
| Texture::Delete(gl, texture); |
| return true; |
| } |
| |
| /** Verifies if texStorage* generate proper errors for given target and internal format and |
| * SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB value set to FALSE. |
| * |
| * @param gl GL API functions |
| * @param target Target for which texture is binded |
| * @param format Texture internal format |
| * |
| * @return Returns true if errors are as expected, false otherwise. |
| */ |
| bool SparseTextureAllocationTestCase::verifyTexStorageFullArrayCubeMipmapsError(const Functions& gl, GLint target, |
| GLint format) |
| { |
| mLog << "Verify FullArrayCubeMipmaps errors - "; |
| |
| bool result = true; |
| |
| GLuint texture; |
| GLint depth; |
| |
| depth = SparseTextureUtils::getTargetDepth(target); |
| |
| GLboolean fullArrayCubeMipmaps; |
| |
| gl.getBooleanv(GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB, &fullArrayCubeMipmaps); |
| if (!SparseTextureUtils::verifyQueryError( |
| mLog, "getBooleanv", target, GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB, gl.getError(), GL_NO_ERROR)) |
| return false; |
| |
| if (fullArrayCubeMipmaps == GL_FALSE && |
| (target == GL_TEXTURE_2D_ARRAY || target == GL_TEXTURE_CUBE_MAP || target == GL_TEXTURE_CUBE_MAP_ARRAY)) |
| { |
| Texture::Generate(gl, texture); |
| Texture::Bind(gl, texture, target); |
| |
| GLint pageSizeX; |
| GLint pageSizeY; |
| GLint pageSizeZ; |
| SparseTextureUtils::getTexturePageSizes(gl, target, format, pageSizeX, pageSizeY, pageSizeZ); |
| |
| gl.texParameteri(target, GL_TEXTURE_SPARSE_ARB, GL_TRUE); |
| |
| GLint levels = 4; |
| GLint width = pageSizeX * (int)pow(2, levels - 1); |
| GLint height = pageSizeY * (int)pow(2, levels - 1); |
| |
| // Check 2 different cases: |
| // 1) wrong width |
| // 2) wrong height |
| if (target == GL_TEXTURE_CUBE_MAP || target == GL_TEXTURE_CUBE_MAP_ARRAY) |
| { |
| GLint widthHeight = de::max(width, height); |
| GLint pageSize = de::max(pageSizeX, pageSizeY); |
| Texture::Storage(gl, target, levels, format, widthHeight + pageSize, widthHeight + pageSize, depth); |
| result = |
| SparseTextureUtils::verifyError(mLog, "TexStorage [wrong width]", gl.getError(), GL_INVALID_OPERATION); |
| } |
| else |
| { |
| Texture::Storage(gl, target, levels, format, width + pageSizeX, height, depth); |
| result = |
| SparseTextureUtils::verifyError(mLog, "TexStorage [wrong width]", gl.getError(), GL_INVALID_OPERATION); |
| |
| if (result) |
| { |
| Texture::Storage(gl, target, levels, format, width, height + pageSizeY, depth); |
| result = SparseTextureUtils::verifyError(mLog, "TexStorage [wrong height]", gl.getError(), |
| GL_INVALID_OPERATION); |
| } |
| } |
| |
| Texture::Delete(gl, texture); |
| } |
| |
| return result; |
| } |
| |
| /** Verifies if texStorage* generate proper errors for given target and internal format when |
| * texture size are set greater than allowed. |
| * |
| * @param gl GL API functions |
| * @param target Target for which texture is binded |
| * @param format Texture internal format |
| * |
| * @return Returns true if errors are as expected, false otherwise. |
| */ |
| bool SparseTextureAllocationTestCase::verifyTexStorageInvalidValueErrors(const Functions& gl, GLint target, |
| GLint format) |
| { |
| mLog << "Verify Invalid Value errors - "; |
| |
| GLuint texture; |
| |
| Texture::Generate(gl, texture); |
| Texture::Bind(gl, texture, target); |
| |
| GLint pageSizeX; |
| GLint pageSizeY; |
| GLint pageSizeZ; |
| SparseTextureUtils::getTexturePageSizes(gl, target, format, pageSizeX, pageSizeY, pageSizeZ); |
| |
| gl.texParameteri(target, GL_TEXTURE_SPARSE_ARB, GL_TRUE); |
| |
| GLint width = pageSizeX; |
| GLint height = pageSizeY; |
| GLint depth = SparseTextureUtils::getTargetDepth(target) * pageSizeZ; |
| |
| if (target == GL_TEXTURE_3D) |
| { |
| GLint max3DTextureSize; |
| |
| gl.getIntegerv(GL_MAX_SPARSE_3D_TEXTURE_SIZE_ARB, &max3DTextureSize); |
| if (!SparseTextureUtils::verifyQueryError(mLog, "getIntegerv", target, GL_MAX_SPARSE_3D_TEXTURE_SIZE_ARB, |
| gl.getError(), GL_NO_ERROR)) |
| { |
| Texture::Delete(gl, texture); |
| return false; |
| } |
| |
| // Check 3 different cases: |
| // 1) wrong width |
| // 2) wrong height |
| // 3) wrong depth |
| Texture::Storage(gl, target, 1, format, width + max3DTextureSize, height, depth); |
| if (!SparseTextureUtils::verifyError(mLog, "TexStorage [GL_TEXTURE_3D wrong width]", gl.getError(), |
| GL_INVALID_VALUE)) |
| { |
| Texture::Delete(gl, texture); |
| return false; |
| } |
| |
| Texture::Storage(gl, target, 1, format, width, height + max3DTextureSize, depth); |
| if (!SparseTextureUtils::verifyError(mLog, "TexStorage [GL_TEXTURE_3D wrong height]", gl.getError(), |
| GL_INVALID_VALUE)) |
| { |
| Texture::Delete(gl, texture); |
| return false; |
| } |
| |
| // Check for GL_NV_deep_texture3D support, if so we'll need to check |
| // against the depth limit instead of the generic 3D texture size limit |
| if (m_context.getContextInfo().isExtensionSupported("GL_NV_deep_texture3D")) |
| { |
| |
| // Ensure that width and height are within the valid bounds for a |
| // deep texture |
| GLint maxTextureWidthHeight; |
| gl.getIntegerv(GL_MAX_DEEP_3D_TEXTURE_DEPTH_NV, &maxTextureWidthHeight); |
| |
| if (width < maxTextureWidthHeight && height < maxTextureWidthHeight) |
| { |
| gl.getIntegerv(GL_MAX_DEEP_3D_TEXTURE_DEPTH_NV, &max3DTextureSize); |
| } |
| } |
| |
| Texture::Storage(gl, target, 1, format, width, height, depth + max3DTextureSize); |
| if (!SparseTextureUtils::verifyError(mLog, "TexStorage [GL_TEXTURE_3D wrong depth]", gl.getError(), |
| GL_INVALID_VALUE)) |
| { |
| Texture::Delete(gl, texture); |
| return false; |
| } |
| } |
| else |
| { |
| GLint maxTextureSize; |
| |
| gl.getIntegerv(GL_MAX_SPARSE_TEXTURE_SIZE_ARB, &maxTextureSize); |
| if (!SparseTextureUtils::verifyQueryError(mLog, "getIntegerv", target, GL_MAX_SPARSE_TEXTURE_SIZE_ARB, |
| gl.getError(), GL_NO_ERROR)) |
| { |
| Texture::Delete(gl, texture); |
| return false; |
| } |
| |
| // Check 3 different cases: |
| // 1) wrong width |
| // 2) wrong height |
| Texture::Storage(gl, target, 1, format, width + maxTextureSize, height, depth); |
| if (!SparseTextureUtils::verifyError(mLog, "TexStorage [!GL_TEXTURE_3D wrong width]", gl.getError(), |
| GL_INVALID_VALUE)) |
| { |
| Texture::Delete(gl, texture); |
| return false; |
| } |
| |
| if (target != GL_TEXTURE_1D_ARRAY) |
| { |
| Texture::Storage(gl, target, 1, format, width, height + maxTextureSize, depth); |
| if (!SparseTextureUtils::verifyError(mLog, "TexStorage [!GL_TEXTURE_3D wrong height]", gl.getError(), |
| GL_INVALID_VALUE)) |
| { |
| Texture::Delete(gl, texture); |
| return false; |
| } |
| } |
| |
| GLint maxArrayTextureLayers; |
| |
| gl.getIntegerv(GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB, &maxArrayTextureLayers); |
| if (!SparseTextureUtils::verifyQueryError(mLog, "getIntegerv", target, GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB, |
| gl.getError(), GL_NO_ERROR)) |
| { |
| Texture::Delete(gl, texture); |
| return false; |
| } |
| |
| if (target == GL_TEXTURE_1D_ARRAY || target == GL_TEXTURE_2D_ARRAY || target == GL_TEXTURE_CUBE_MAP_ARRAY) |
| { |
| Texture::Storage(gl, target, 1, format, width, height, depth + maxArrayTextureLayers); |
| if (!SparseTextureUtils::verifyError(mLog, "TexStorage [ARRAY wrong depth]", gl.getError(), |
| GL_INVALID_VALUE)) |
| { |
| Texture::Delete(gl, texture); |
| return false; |
| } |
| } |
| } |
| |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_sparse_texture2")) |
| { |
| if (pageSizeX > 1) |
| { |
| Texture::Storage(gl, target, 1, format, pageSizeX + 1, height, depth); |
| if (!SparseTextureUtils::verifyError(mLog, "TexStorage [wrong width]", gl.getError(), GL_INVALID_VALUE)) |
| { |
| Texture::Delete(gl, texture); |
| return false; |
| } |
| } |
| |
| if (pageSizeY > 1) |
| { |
| Texture::Storage(gl, target, 1, format, width, pageSizeY + 1, depth); |
| if (!SparseTextureUtils::verifyError(mLog, "TexStorage [wrong height]", gl.getError(), GL_INVALID_VALUE)) |
| { |
| Texture::Delete(gl, texture); |
| return false; |
| } |
| } |
| |
| if (pageSizeZ > 1) |
| { |
| Texture::Storage(gl, target, 1, format, width, height, pageSizeZ + 1); |
| if (!SparseTextureUtils::verifyError(mLog, "TexStorage [wrong depth]", gl.getError(), GL_INVALID_VALUE)) |
| { |
| Texture::Delete(gl, texture); |
| return false; |
| } |
| } |
| } |
| |
| Texture::Delete(gl, texture); |
| return true; |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context |
| */ |
| SparseTextureCommitmentTestCase::SparseTextureCommitmentTestCase(deqp::Context& context) |
| : TestCase(context, "SparseTextureCommitment", |
| "Verifies TexPageCommitmentARB functionality added in CTS_ARB_sparse_texture") |
| , mState() |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context |
| * @param name Test name |
| * @param description Test description |
| */ |
| SparseTextureCommitmentTestCase::SparseTextureCommitmentTestCase(deqp::Context& context, const char* name, |
| const char* description) |
| : TestCase(context, name, description), mState() |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Initializes the test case. */ |
| void SparseTextureCommitmentTestCase::init() |
| { |
| mSupportedTargets.push_back(GL_TEXTURE_2D); |
| mSupportedTargets.push_back(GL_TEXTURE_2D_ARRAY); |
| mSupportedTargets.push_back(GL_TEXTURE_CUBE_MAP); |
| mSupportedTargets.push_back(GL_TEXTURE_CUBE_MAP_ARRAY); |
| mSupportedTargets.push_back(GL_TEXTURE_3D); |
| mSupportedTargets.push_back(GL_TEXTURE_RECTANGLE); |
| |
| mSupportedInternalFormats.push_back(GL_R8); |
| mSupportedInternalFormats.push_back(GL_R8_SNORM); |
| mSupportedInternalFormats.push_back(GL_R16); |
| mSupportedInternalFormats.push_back(GL_R16_SNORM); |
| mSupportedInternalFormats.push_back(GL_RG8); |
| mSupportedInternalFormats.push_back(GL_RG8_SNORM); |
| mSupportedInternalFormats.push_back(GL_RG16); |
| mSupportedInternalFormats.push_back(GL_RG16_SNORM); |
| mSupportedInternalFormats.push_back(GL_RGB565); |
| mSupportedInternalFormats.push_back(GL_RGBA8); |
| mSupportedInternalFormats.push_back(GL_RGBA8_SNORM); |
| mSupportedInternalFormats.push_back(GL_RGB10_A2); |
| mSupportedInternalFormats.push_back(GL_RGB10_A2UI); |
| mSupportedInternalFormats.push_back(GL_RGBA16); |
| mSupportedInternalFormats.push_back(GL_RGBA16_SNORM); |
| mSupportedInternalFormats.push_back(GL_R16F); |
| mSupportedInternalFormats.push_back(GL_RG16F); |
| mSupportedInternalFormats.push_back(GL_RGBA16F); |
| mSupportedInternalFormats.push_back(GL_R32F); |
| mSupportedInternalFormats.push_back(GL_RG32F); |
| mSupportedInternalFormats.push_back(GL_RGBA32F); |
| mSupportedInternalFormats.push_back(GL_R11F_G11F_B10F); |
| mSupportedInternalFormats.push_back(GL_RGB9_E5); |
| mSupportedInternalFormats.push_back(GL_R8I); |
| mSupportedInternalFormats.push_back(GL_R8UI); |
| mSupportedInternalFormats.push_back(GL_R16I); |
| mSupportedInternalFormats.push_back(GL_R16UI); |
| mSupportedInternalFormats.push_back(GL_R32I); |
| mSupportedInternalFormats.push_back(GL_R32UI); |
| mSupportedInternalFormats.push_back(GL_RG8I); |
| mSupportedInternalFormats.push_back(GL_RG8UI); |
| mSupportedInternalFormats.push_back(GL_RG16I); |
| mSupportedInternalFormats.push_back(GL_RG16UI); |
| mSupportedInternalFormats.push_back(GL_RG32I); |
| mSupportedInternalFormats.push_back(GL_RG32UI); |
| mSupportedInternalFormats.push_back(GL_RGBA8I); |
| mSupportedInternalFormats.push_back(GL_RGBA8UI); |
| mSupportedInternalFormats.push_back(GL_RGBA16I); |
| mSupportedInternalFormats.push_back(GL_RGBA16UI); |
| mSupportedInternalFormats.push_back(GL_RGBA32I); |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult SparseTextureCommitmentTestCase::iterate() |
| { |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_sparse_texture")) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported"); |
| return STOP; |
| } |
| |
| const Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| bool result = true; |
| |
| GLuint texture; |
| |
| for (std::vector<glw::GLint>::const_iterator iter = mSupportedTargets.begin(); iter != mSupportedTargets.end(); |
| ++iter) |
| { |
| const GLint& target = *iter; |
| |
| for (std::vector<glw::GLint>::const_iterator formIter = mSupportedInternalFormats.begin(); |
| formIter != mSupportedInternalFormats.end(); ++formIter) |
| { |
| const GLint& format = *formIter; |
| |
| if (!caseAllowed(target, format)) |
| continue; |
| |
| mLog.str(""); |
| mLog << "Testing sparse texture commitment for target: " << target << ", format: " << format << " - "; |
| |
| //Checking if written data into not committed region generates no error |
| sparseAllocateTexture(gl, target, format, texture, 3); |
| for (int l = 0; l < mState.levels; ++l) |
| writeDataToTexture(gl, target, format, texture, l); |
| |
| //Checking if written data into committed region is as expected |
| for (int l = 0; l < mState.levels; ++l) |
| { |
| if (commitTexturePage(gl, target, format, texture, l)) |
| { |
| writeDataToTexture(gl, target, format, texture, l); |
| result = verifyTextureData(gl, target, format, texture, l); |
| } |
| |
| if (!result) |
| break; |
| } |
| |
| Texture::Delete(gl, texture); |
| |
| //verify errors |
| result = result && verifyInvalidOperationErrors(gl, target, format, texture); |
| result = result && verifyInvalidValueErrors(gl, target, format, texture); |
| |
| if (!result) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << mLog.str() << "Fail" << tcu::TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| return STOP; |
| } |
| } |
| } |
| |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| return STOP; |
| } |
| |
| /** Bind texPageCommitmentARB function |
| * |
| * @param gl GL API functions |
| * @param target Target for which texture is binded |
| * @param format Texture internal format |
| * @param texture Texture object |
| * @param xOffset Texture commitment x offset |
| * @param yOffset Texture commitment y offset |
| * @param zOffset Texture commitment z offset |
| * @param width Texture commitment width |
| * @param height Texture commitment height |
| * @param depth Texture commitment depth |
| * @param commit Commit or de-commit indicator |
| **/ |
| void SparseTextureCommitmentTestCase::texPageCommitment(const glw::Functions& gl, glw::GLint target, glw::GLint format, |
| glw::GLuint& texture, GLint level, GLint xOffset, GLint yOffset, |
| GLint zOffset, GLint width, GLint height, GLint depth, |
| GLboolean commit) |
| { |
| DE_UNREF(format); |
| Texture::Bind(gl, texture, target); |
| |
| gl.texPageCommitmentARB(target, level, xOffset, yOffset, zOffset, width, height, depth, commit); |
| } |
| |
| /** Check if specific combination of target and format is allowed |
| * |
| * @param target Target for which texture is binded |
| * @param format Texture internal format |
| * |
| * @return Returns true if target/format combination is allowed, false otherwise. |
| */ |
| bool SparseTextureCommitmentTestCase::caseAllowed(GLint target, GLint format) |
| { |
| DE_UNREF(target); |
| DE_UNREF(format); |
| return true; |
| } |
| |
| /** Preparing texture |
| * |
| * @param gl GL API functions |
| * @param target Target for which texture is binded |
| * @param format Texture internal format |
| * @param texture Texture object |
| * |
| * @return Returns true if no error occurred, otherwise throws an exception. |
| */ |
| bool SparseTextureCommitmentTestCase::prepareTexture(const Functions& gl, GLint target, GLint format, GLuint& texture) |
| { |
| Texture::Generate(gl, texture); |
| Texture::Bind(gl, texture, target); |
| |
| mState.minDepth = SparseTextureUtils::getTargetDepth(target); |
| SparseTextureUtils::getTexturePageSizes(gl, target, format, mState.pageSizeX, mState.pageSizeY, mState.pageSizeZ); |
| |
| //The <width> and <height> has to be equal for cube map textures |
| if (target == GL_TEXTURE_CUBE_MAP || target == GL_TEXTURE_CUBE_MAP_ARRAY) |
| { |
| if (mState.pageSizeX > mState.pageSizeY) |
| mState.pageSizeY = mState.pageSizeX; |
| else if (mState.pageSizeX < mState.pageSizeY) |
| mState.pageSizeX = mState.pageSizeY; |
| } |
| |
| mState.width = 2 * mState.pageSizeX; |
| mState.height = 2 * mState.pageSizeY; |
| mState.depth = 2 * mState.pageSizeZ * mState.minDepth; |
| |
| mState.format = glu::mapGLInternalFormat(format); |
| |
| return true; |
| } |
| |
| /** Allocating sparse texture memory using texStorage* function |
| * |
| * @param gl GL API functions |
| * @param target Target for which texture is binded |
| * @param format Texture internal format |
| * @param texture Texture object |
| * @param levels Texture mipmaps level |
| * |
| * @return Returns true if no error occurred, otherwise throws an exception. |
| */ |
| bool SparseTextureCommitmentTestCase::sparseAllocateTexture(const Functions& gl, GLint target, GLint format, |
| GLuint& texture, GLint levels) |
| { |
| mLog << "Sparse Allocate [levels: " << levels << "] - "; |
| |
| prepareTexture(gl, target, format, texture); |
| |
| gl.texParameteri(target, GL_TEXTURE_SPARSE_ARB, GL_TRUE); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "texParameteri error occurred for GL_TEXTURE_SPARSE_ARB"); |
| |
| // GL_TEXTURE_RECTANGLE can have only one level |
| if (target != GL_TEXTURE_RECTANGLE) |
| { |
| gl.getTexParameteriv(target, GL_NUM_SPARSE_LEVELS_ARB, &mState.levels); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexParameteriv"); |
| |
| mState.levels = deMin32(mState.levels, levels); |
| } |
| else |
| mState.levels = 1; |
| |
| Texture::Storage(gl, target, mState.levels, format, mState.width, mState.height, mState.depth); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "TexStorage"); |
| |
| return true; |
| } |
| |
| /** Allocating texture memory using texStorage* function |
| * |
| * @param gl GL API functions |
| * @param target Target for which texture is binded |
| * @param format Texture internal format |
| * @param texture Texture object |
| * @param levels Texture mipmaps level |
| * |
| * @return Returns true if no error occurred, otherwise throws an exception. |
| */ |
| bool SparseTextureCommitmentTestCase::allocateTexture(const Functions& gl, GLint target, GLint format, GLuint& texture, |
| GLint levels) |
| { |
| mLog << "Allocate [levels: " << levels << "] - "; |
| |
| prepareTexture(gl, target, format, texture); |
| |
| //GL_TEXTURE_RECTANGLE can have only one level |
| if (target != GL_TEXTURE_RECTANGLE) |
| mState.levels = levels; |
| else |
| mState.levels = 1; |
| |
| Texture::Storage(gl, target, mState.levels, format, mState.width, mState.height, mState.depth); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "TexStorage"); |
| |
| return true; |
| } |
| |
| /** Writing data to generated texture |
| * |
| * @param gl GL API functions |
| * @param target Target for which texture is binded |
| * @param format Texture internal format |
| * @param texture Texture object |
| * |
| * @return Returns true if no error occurred, otherwise throws an exception. |
| */ |
| bool SparseTextureCommitmentTestCase::writeDataToTexture(const Functions& gl, GLint target, GLint format, |
| GLuint& texture, GLint level) |
| { |
| DE_UNREF(format); |
| DE_UNREF(texture); |
| |
| mLog << "Fill texture [level: " << level << "] - "; |
| |
| if (level > mState.levels - 1) |
| TCU_FAIL("Invalid level"); |
| |
| TransferFormat transferFormat = glu::getTransferFormat(mState.format); |
| |
| GLint width; |
| GLint height; |
| GLint depth; |
| SparseTextureUtils::getTextureLevelSize(target, mState, level, width, height, depth); |
| |
| if (width > 0 && height > 0 && depth >= mState.minDepth) |
| { |
| GLint texSize = width * height * depth * mState.format.getPixelSize(); |
| |
| std::vector<GLubyte> vecData; |
| vecData.resize(texSize); |
| GLubyte* data = vecData.data(); |
| |
| deMemset(data, 16 + 16 * level, texSize); |
| |
| Texture::SubImage(gl, target, level, 0, 0, 0, width, height, depth, transferFormat.format, |
| transferFormat.dataType, (GLvoid*)data); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "SubImage"); |
| } |
| |
| return true; |
| } |
| |
| /** Verify if data stored in texture is as expected |
| * |
| * @param gl GL API functions |
| * @param target Target for which texture is binded |
| * @param format Texture internal format |
| * @param texture Texture object |
| * @param level Texture mipmap level |
| * |
| * @return Returns true if data is as expected, false if not, throws an exception if error occurred. |
| */ |
| bool SparseTextureCommitmentTestCase::verifyTextureData(const Functions& gl, GLint target, GLint format, |
| GLuint& texture, GLint level) |
| { |
| DE_UNREF(format); |
| DE_UNREF(texture); |
| |
| mLog << "Verify Texture [level: " << level << "] - "; |
| |
| if (level > mState.levels - 1) |
| TCU_FAIL("Invalid level"); |
| |
| TransferFormat transferFormat = glu::getTransferFormat(mState.format); |
| |
| GLint width; |
| GLint height; |
| GLint depth; |
| SparseTextureUtils::getTextureLevelSize(target, mState, level, width, height, depth); |
| |
| //Committed region is limited to 1/2 of width |
| GLint widthCommitted = width / 2; |
| |
| if (widthCommitted == 0 || height == 0 || depth < mState.minDepth) |
| return true; |
| |
| bool result = true; |
| |
| if (target != GL_TEXTURE_CUBE_MAP) |
| { |
| GLint texSize = width * height * depth * mState.format.getPixelSize(); |
| |
| std::vector<GLubyte> vecExpData; |
| std::vector<GLubyte> vecOutData; |
| vecExpData.resize(texSize); |
| vecOutData.resize(texSize); |
| GLubyte* exp_data = vecExpData.data(); |
| GLubyte* out_data = vecOutData.data(); |
| |
| deMemset(exp_data, 16 + 16 * level, texSize); |
| deMemset(out_data, 255, texSize); |
| |
| Texture::GetData(gl, level, target, transferFormat.format, transferFormat.dataType, (GLvoid*)out_data); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Texture::GetData"); |
| |
| //Verify only committed region |
| for (GLint x = 0; x < widthCommitted; ++x) |
| for (GLint y = 0; y < height; ++y) |
| for (GLint z = 0; z < depth; ++z) |
| { |
| int pixelSize = mState.format.getPixelSize(); |
| GLubyte* dataRegion = exp_data + ((x + y * width) * pixelSize); |
| GLubyte* outDataRegion = out_data + ((x + y * width) * pixelSize); |
| if (deMemCmp(dataRegion, outDataRegion, pixelSize) != 0) |
| result = false; |
| } |
| } |
| else |
| { |
| std::vector<GLint> subTargets; |
| |
| subTargets.push_back(GL_TEXTURE_CUBE_MAP_POSITIVE_X); |
| subTargets.push_back(GL_TEXTURE_CUBE_MAP_NEGATIVE_X); |
| subTargets.push_back(GL_TEXTURE_CUBE_MAP_POSITIVE_Y); |
| subTargets.push_back(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y); |
| subTargets.push_back(GL_TEXTURE_CUBE_MAP_POSITIVE_Z); |
| subTargets.push_back(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z); |
| |
| GLint texSize = width * height * mState.format.getPixelSize(); |
| |
| std::vector<GLubyte> vecExpData; |
| std::vector<GLubyte> vecOutData; |
| vecExpData.resize(texSize); |
| vecOutData.resize(texSize); |
| GLubyte* exp_data = vecExpData.data(); |
| GLubyte* out_data = vecOutData.data(); |
| |
| deMemset(exp_data, 16 + 16 * level, texSize); |
| deMemset(out_data, 255, texSize); |
| |
| for (size_t i = 0; i < subTargets.size(); ++i) |
| { |
| GLint subTarget = subTargets[i]; |
| |
| mLog << "Verify Subtarget [subtarget: " << subTarget << "] - "; |
| |
| deMemset(out_data, 255, texSize); |
| |
| Texture::GetData(gl, level, subTarget, transferFormat.format, transferFormat.dataType, (GLvoid*)out_data); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Texture::GetData"); |
| |
| //Verify only committed region |
| for (GLint x = 0; x < widthCommitted; ++x) |
| for (GLint y = 0; y < height; ++y) |
| for (GLint z = 0; z < depth; ++z) |
| { |
| int pixelSize = mState.format.getPixelSize(); |
| GLubyte* dataRegion = exp_data + ((x + y * width) * pixelSize); |
| GLubyte* outDataRegion = out_data + ((x + y * width) * pixelSize); |
| if (deMemCmp(dataRegion, outDataRegion, pixelSize) != 0) |
| result = false; |
| } |
| |
| if (!result) |
| break; |
| } |
| } |
| |
| return result; |
| } |
| |
| /** Commit texture page using texPageCommitment function |
| * |
| * @param gl GL API functions |
| * @param target Target for which texture is binded |
| * @param format Texture internal format |
| * @param texture Texture object |
| * @param level Texture mipmap level |
| * |
| * @return Returns true if commitment is done properly, false if commitment is not allowed or throws exception if error occurred. |
| */ |
| bool SparseTextureCommitmentTestCase::commitTexturePage(const Functions& gl, GLint target, GLint format, |
| GLuint& texture, GLint level) |
| { |
| mLog << "Commit Region [level: " << level << "] - "; |
| |
| if (level > mState.levels - 1) |
| TCU_FAIL("Invalid level"); |
| |
| // Avoid not allowed commitments |
| if (!isInPageSizesRange(target, level) || !isPageSizesMultiplication(target, level)) |
| { |
| mLog << "Skip commitment [level: " << level << "] - "; |
| return false; |
| } |
| |
| GLint width; |
| GLint height; |
| GLint depth; |
| SparseTextureUtils::getTextureLevelSize(target, mState, level, width, height, depth); |
| |
| if (target == GL_TEXTURE_CUBE_MAP) |
| depth = 6 * depth; |
| |
| GLint widthCommitted = width / 2; |
| |
| Texture::Bind(gl, texture, target); |
| texPageCommitment(gl, target, format, texture, level, 0, 0, 0, widthCommitted, height, depth, GL_TRUE); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "texPageCommitment"); |
| |
| return true; |
| } |
| |
| /** Check if current texture size for level is greater or equal page size in a corresponding direction |
| * |
| * @param target Target for which texture is binded |
| * @param level Texture mipmap level |
| * |
| * @return Returns true if the texture size condition is fulfilled, false otherwise. |
| */ |
| bool SparseTextureCommitmentTestCase::isInPageSizesRange(GLint target, GLint level) |
| { |
| GLint width; |
| GLint height; |
| GLint depth; |
| SparseTextureUtils::getTextureLevelSize(target, mState, level, width, height, depth); |
| |
| if (target == GL_TEXTURE_CUBE_MAP) |
| depth = 6 * depth; |
| |
| GLint widthCommitted = width / 2; |
| if (widthCommitted >= mState.pageSizeX && height >= mState.pageSizeY && |
| (mState.minDepth == 0 || depth >= mState.pageSizeZ)) |
| { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /** Check if current texture size for level is page size multiplication in a corresponding direction |
| * |
| * @param target Target for which texture is binded |
| * @param level Texture mipmap level |
| * |
| * @return Returns true if the texture size condition is fulfilled, false otherwise. |
| */ |
| bool SparseTextureCommitmentTestCase::isPageSizesMultiplication(GLint target, GLint level) |
| { |
| GLint width; |
| GLint height; |
| GLint depth; |
| SparseTextureUtils::getTextureLevelSize(target, mState, level, width, height, depth); |
| |
| if (target == GL_TEXTURE_CUBE_MAP) |
| depth = 6 * depth; |
| |
| GLint widthCommitted = width / 2; |
| if ((widthCommitted % mState.pageSizeX) == 0 && (height % mState.pageSizeY) == 0 && (depth % mState.pageSizeZ) == 0) |
| { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /** Verifies if gltexPageCommitment generates INVALID_OPERATION error in expected use cases |
| * |
| * @param gl GL API functions |
| * @param target Target for which texture is binded |
| * @param format Texture internal format |
| * @param texture Texture object |
| * |
| * @return Returns true if no error occurred, otherwise throws an exception. |
| */ |
| bool SparseTextureCommitmentTestCase::verifyInvalidOperationErrors(const Functions& gl, GLint target, GLint format, |
| GLuint& texture) |
| { |
| mLog << "Verify INVALID_OPERATION Errors - "; |
| |
| bool result = true; |
| |
| // Case 1 - texture is not GL_TEXTURE_IMMUTABLE_FORMAT |
| Texture::Generate(gl, texture); |
| Texture::Bind(gl, texture, target); |
| |
| gl.texParameteri(target, GL_TEXTURE_SPARSE_ARB, GL_TRUE); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "texParameteri error occurred for GL_TEXTURE_SPARSE_ARB"); |
| |
| GLint immutableFormat; |
| |
| gl.getTexParameteriv(target, GL_TEXTURE_IMMUTABLE_FORMAT, &immutableFormat); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "getTexParameteriv error occurred for GL_TEXTURE_IMMUTABLE_FORMAT"); |
| |
| if (immutableFormat == GL_FALSE) |
| { |
| texPageCommitment(gl, target, format, texture, 0, 0, 0, 0, mState.pageSizeX, mState.pageSizeY, mState.pageSizeZ, |
| GL_TRUE); |
| result = SparseTextureUtils::verifyError(mLog, "texPageCommitment [GL_TEXTURE_IMMUTABLE_FORMAT texture]", |
| gl.getError(), GL_INVALID_OPERATION); |
| if (!result) |
| goto verifing_invalid_operation_end; |
| } |
| |
| Texture::Delete(gl, texture); |
| |
| // Case 2 - texture is not TEXTURE_SPARSE_ARB |
| allocateTexture(gl, target, format, texture, 1); |
| |
| texPageCommitment(gl, target, format, texture, 0, 0, 0, 0, mState.pageSizeX, mState.pageSizeY, mState.pageSizeZ, |
| GL_TRUE); |
| result = SparseTextureUtils::verifyError(mLog, "texPageCommitment [not TEXTURE_SPARSE_ARB texture]", gl.getError(), |
| GL_INVALID_OPERATION); |
| if (!result) |
| goto verifing_invalid_operation_end; |
| |
| // Sparse allocate texture |
| Texture::Delete(gl, texture); |
| sparseAllocateTexture(gl, target, format, texture, 1); |
| |
| // Case 3 - commitment sizes greater than expected |
| texPageCommitment(gl, target, format, texture, 0, 0, 0, 0, mState.width + mState.pageSizeX, mState.height, |
| mState.depth, GL_TRUE); |
| result = SparseTextureUtils::verifyError(mLog, "texPageCommitment [commitment width greater than expected]", |
| gl.getError(), GL_INVALID_OPERATION); |
| if (!result) |
| goto verifing_invalid_operation_end; |
| |
| texPageCommitment(gl, target, format, texture, 0, 0, 0, 0, mState.width, mState.height + mState.pageSizeY, |
| mState.depth, GL_TRUE); |
| result = SparseTextureUtils::verifyError(mLog, "texPageCommitment [commitment height greater than expected]", |
| gl.getError(), GL_INVALID_OPERATION); |
| if (!result) |
| goto verifing_invalid_operation_end; |
| |
| if (target == GL_TEXTURE_3D || target == GL_TEXTURE_2D_ARRAY || target == GL_TEXTURE_CUBE_MAP_ARRAY) |
| { |
| texPageCommitment(gl, target, format, texture, 0, 0, 0, 0, mState.width, mState.height, |
| mState.depth + mState.pageSizeZ, GL_TRUE); |
| result = SparseTextureUtils::verifyError(mLog, "texPageCommitment [commitment depth greater than expected]", |
| gl.getError(), GL_INVALID_OPERATION); |
| if (!result) |
| goto verifing_invalid_operation_end; |
| } |
| |
| // Case 4 - commitment sizes not multiple of corresponding page sizes |
| if (mState.pageSizeX > 1) |
| { |
| texPageCommitment(gl, target, format, texture, 0, 0, 0, 0, 1, mState.pageSizeY, mState.pageSizeZ, GL_TRUE); |
| result = |
| SparseTextureUtils::verifyError(mLog, "texPageCommitment [commitment width not multiple of page sizes X]", |
| gl.getError(), GL_INVALID_OPERATION); |
| if (!result) |
| goto verifing_invalid_operation_end; |
| } |
| |
| if (mState.pageSizeY > 1) |
| { |
| texPageCommitment(gl, target, format, texture, 0, 0, 0, 0, mState.pageSizeX, 1, mState.pageSizeZ, GL_TRUE); |
| result = |
| SparseTextureUtils::verifyError(mLog, "texPageCommitment [commitment height not multiple of page sizes Y]", |
| gl.getError(), GL_INVALID_OPERATION); |
| if (!result) |
| goto verifing_invalid_operation_end; |
| } |
| |
| if (mState.pageSizeZ > 1) |
| { |
| if (target == GL_TEXTURE_3D || target == GL_TEXTURE_2D_ARRAY || target == GL_TEXTURE_CUBE_MAP_ARRAY) |
| { |
| texPageCommitment(gl, target, format, texture, 0, 0, 0, 0, mState.pageSizeX, mState.pageSizeY, |
| mState.minDepth, GL_TRUE); |
| result = SparseTextureUtils::verifyError( |
| mLog, "texPageCommitment [commitment depth not multiple of page sizes Z]", gl.getError(), |
| GL_INVALID_OPERATION); |
| if (!result) |
| goto verifing_invalid_operation_end; |
| } |
| } |
| |
| verifing_invalid_operation_end: |
| |
| Texture::Delete(gl, texture); |
| |
| return result; |
| } |
| |
| /** Verifies if texPageCommitment generates INVALID_VALUE error in expected use cases |
| * |
| * @param gl GL API functions |
| * @param target Target for which texture is binded |
| * @param format Texture internal format |
| * @param texture Texture object |
| * |
| * @return Returns true if no error occurred, otherwise throws an exception. |
| */ |
| bool SparseTextureCommitmentTestCase::verifyInvalidValueErrors(const Functions& gl, GLint target, GLint format, |
| GLuint& texture) |
| { |
| mLog << "Verify INVALID_VALUE Errors - "; |
| |
| bool result = true; |
| |
| sparseAllocateTexture(gl, target, format, texture, 1); |
| |
| // Case 1 - commitment offset not multiple of page size in corresponding dimension |
| if (mState.pageSizeX > 1) |
| { |
| texPageCommitment(gl, target, format, texture, 0, 1, 0, 0, mState.pageSizeX, mState.pageSizeY, mState.pageSizeZ, |
| GL_TRUE); |
| result = |
| SparseTextureUtils::verifyError(mLog, "texPageCommitment [commitment offsetX not multiple of page size X]", |
| gl.getError(), GL_INVALID_VALUE); |
| if (!result) |
| goto verifing_invalid_value_end; |
| } |
| if (mState.pageSizeY > 1) |
| { |
| texPageCommitment(gl, target, format, texture, 0, 0, 1, 0, mState.pageSizeX, mState.pageSizeY, mState.pageSizeZ, |
| GL_TRUE); |
| result = |
| SparseTextureUtils::verifyError(mLog, "texPageCommitment [commitment offsetY not multiple of page size Y]", |
| gl.getError(), GL_INVALID_VALUE); |
| if (!result) |
| goto verifing_invalid_value_end; |
| } |
| if ((target == GL_TEXTURE_3D || target == GL_TEXTURE_2D_ARRAY || target == GL_TEXTURE_CUBE_MAP_ARRAY) && |
| (mState.minDepth % mState.pageSizeZ)) |
| { |
| texPageCommitment(gl, target, format, texture, 0, 0, 0, mState.minDepth, mState.pageSizeX, mState.pageSizeY, |
| mState.pageSizeZ, GL_TRUE); |
| result = |
| SparseTextureUtils::verifyError(mLog, "texPageCommitment [commitment offsetZ not multiple of page size Z]", |
| gl.getError(), GL_INVALID_VALUE); |
| if (!result) |
| goto verifing_invalid_value_end; |
| } |
| |
| verifing_invalid_value_end: |
| |
| Texture::Delete(gl, texture); |
| |
| return result; |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context |
| */ |
| SparseDSATextureCommitmentTestCase::SparseDSATextureCommitmentTestCase(deqp::Context& context) |
| : SparseTextureCommitmentTestCase(context, "SparseDSATextureCommitment", |
| "Verifies texturePageCommitmentEXT functionality added in CTS_ARB_sparse_texture") |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult SparseDSATextureCommitmentTestCase::iterate() |
| { |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_sparse_texture")) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported"); |
| return STOP; |
| } |
| |
| if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_direct_state_access")) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "GL_EXT_direct_state_access extension is not supported."); |
| return STOP; |
| } |
| |
| const Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| bool result = true; |
| |
| GLuint texture; |
| |
| for (std::vector<glw::GLint>::const_iterator iter = mSupportedTargets.begin(); iter != mSupportedTargets.end(); |
| ++iter) |
| { |
| const GLint& target = *iter; |
| |
| for (std::vector<glw::GLint>::const_iterator formIter = mSupportedInternalFormats.begin(); |
| formIter != mSupportedInternalFormats.end(); ++formIter) |
| { |
| const GLint& format = *formIter; |
| |
| mLog.str(""); |
| mLog << "Testing DSA sparse texture commitment for target: " << target << ", format: " << format << " - "; |
| |
| //Checking if written data into committed region is as expected |
| sparseAllocateTexture(gl, target, format, texture, 3); |
| for (int l = 0; l < mState.levels; ++l) |
| { |
| if (commitTexturePage(gl, target, format, texture, l)) |
| { |
| writeDataToTexture(gl, target, format, texture, l); |
| result = verifyTextureData(gl, target, format, texture, l); |
| } |
| |
| if (!result) |
| break; |
| } |
| |
| Texture::Delete(gl, texture); |
| |
| //verify errors |
| result = result && verifyInvalidOperationErrors(gl, target, format, texture); |
| result = result && verifyInvalidValueErrors(gl, target, format, texture); |
| |
| if (!result) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << mLog.str() << "Fail" << tcu::TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| return STOP; |
| } |
| } |
| } |
| |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| return STOP; |
| } |
| |
| /** Bind DSA texturePageCommitmentEXT function |
| * |
| * @param gl GL API functions |
| * @param target Target for which texture is binded |
| * @param format Texture internal format |
| * @param texture Texture object |
| * @param xOffset Texture commitment x offset |
| * @param yOffset Texture commitment y offset |
| * @param zOffset Texture commitment z offset |
| * @param width Texture commitment width |
| * @param height Texture commitment height |
| * @param depth Texture commitment depth |
| * @param commit Commit or de-commit indicator |
| **/ |
| void SparseDSATextureCommitmentTestCase::texPageCommitment(const glw::Functions& gl, glw::GLint target, |
| glw::GLint format, glw::GLuint& texture, GLint level, |
| GLint xOffset, GLint yOffset, GLint zOffset, GLint width, |
| GLint height, GLint depth, GLboolean commit) |
| { |
| DE_UNREF(target); |
| DE_UNREF(format); |
| gl.texturePageCommitmentEXT(texture, level, xOffset, yOffset, zOffset, width, height, depth, commit); |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context. |
| */ |
| SparseTextureTests::SparseTextureTests(deqp::Context& context) |
| : TestCaseGroup(context, "sparse_texture_tests", "Verify conformance of CTS_ARB_sparse_texture implementation") |
| { |
| } |
| |
| /** Initializes the test group contents. */ |
| void SparseTextureTests::init() |
| { |
| addChild(new TextureParameterQueriesTestCase(m_context)); |
| addChild(new InternalFormatQueriesTestCase(m_context)); |
| addChild(new SimpleQueriesTestCase(m_context)); |
| addChild(new SparseTextureAllocationTestCase(m_context)); |
| addChild(new SparseTextureCommitmentTestCase(m_context)); |
| addChild(new SparseDSATextureCommitmentTestCase(m_context)); |
| } |
| |
| } /* gl4cts namespace */ |