namespace gl4cts
{
+const char* compute_textureFill = "#version 430 core\n"
+ "\n"
+ "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
+ "\n"
+ "layout (location = 1) writeonly uniform highp <INIMAGE_TYPE> uni_image;\n"
+ "\n"
+ "void main()\n"
+ "{\n"
+ " <POINT_TYPE> point = <POINT_TYPE>(<POINT_DEF>);\n"
+ " memoryBarrier();\n"
+ " <INCOLOR_TYPE> color = <INCOLOR_TYPE><INIMAGE_COLOR>;\n"
+ " imageStore(uni_image, point<SAMPLE_DEF>, color);\n"
+ "}\n";
+
+const char* compute_textureVerify = "#version 430 core\n"
+ "\n"
+ "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
+ "\n"
+ "layout (location = 1, r8ui) writeonly uniform <OUTIMAGE_TYPE> uni_out_image;\n"
+ "layout (location = 2, <FORMAT>) readonly uniform <INIMAGE_TYPE> uni_in_image;\n"
+ "\n"
+ "void main()\n"
+ "{\n"
+ " <POINT_TYPE> point = <POINT_TYPE>(<POINT_DEF>);\n"
+ " memoryBarrier();\n"
+ " highp <INCOLOR_TYPE> color,\n"
+ " expected,\n"
+ " epsilon;\n"
+ " color = imageLoad(uni_in_image, point<SAMPLE_DEF>);\n"
+ " expected = <INCOLOR_TYPE><INCOLOR_EXPECTED>;\n"
+ " epsilon = <INCOLOR_TYPE>(<EPSILON>);\n"
+ "\n"
+ " if (all(lessThanEqual(color, expected + epsilon)) &&\n"
+ " all(greaterThanEqual(color, expected - epsilon)))\n"
+ " {\n"
+ " imageStore(uni_out_image, point, uvec4(255));\n"
+ " }\n"
+ " else {\n"
+ " imageStore(uni_out_image, point, uvec4(0));\n"
+ " }\n"
+ "}\n";
+
+const char* compute_atomicVerify =
+ "#version 430 core\n"
+ "\n"
+ "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
+ "\n"
+ "layout (location = 1, r8ui) writeonly uniform <OUTIMAGE_TYPE> uni_out_image;\n"
+ "layout (location = 2, <FORMAT>) uniform <INIMAGE_TYPE> uni_in_image;\n"
+ "\n"
+ "layout (location = 3) uniform int widthCommitted;\n"
+ "\n"
+ "void main()\n"
+ "{\n"
+ " <POINT_TYPE> point,\n"
+ " offset;\n"
+ " point = <POINT_TYPE>(<POINT_DEF>);\n"
+ " offset = <POINT_TYPE>(0);\n"
+ " offset.x = widthCommitted;\n"
+ " memoryBarrier();\n"
+ " if (point.x >= widthCommitted) {\n"
+ " uint index = ((point.x - widthCommitted) + point.y * 8) % 8;\n"
+ " <DATA_TYPE> value = 127;\n"
+ " if (index == 0)\n"
+ " value = imageAtomicExchange(uni_in_image, point<SAMPLE_DEF>, <DATA_TYPE>(0x0F));\n"
+ " else if (index == 1)\n"
+ " value = imageAtomicCompSwap(uni_in_image, point<SAMPLE_DEF>, <DATA_TYPE>(0), <DATA_TYPE>(0x0F));\n"
+ " else if (index == 2)\n"
+ " value = imageAtomicAdd(uni_in_image, point<SAMPLE_DEF>, <DATA_TYPE>(0x0F));\n"
+ " else if (index == 3)\n"
+ " value = imageAtomicAnd(uni_in_image, point<SAMPLE_DEF>, <DATA_TYPE>(0x0F));\n"
+ " else if (index == 4)\n"
+ " value = imageAtomicOr(uni_in_image, point<SAMPLE_DEF>, <DATA_TYPE>(0x0F));\n"
+ " else if (index == 5)\n"
+ " value = imageAtomicXor(uni_in_image, point<SAMPLE_DEF>, <DATA_TYPE>(0x0F));\n"
+ " else if (index == 6)\n"
+ " value = imageAtomicMin(uni_in_image, point<SAMPLE_DEF>, <DATA_TYPE>(0x0F));\n"
+ " else if (index == 7)\n"
+ " value = imageAtomicMax(uni_in_image, point<SAMPLE_DEF>, <DATA_TYPE>(0x0F));\n"
+ "\n"
+ " <INCOLOR_TYPE> color = imageLoad(uni_in_image, point<SAMPLE_DEF>);\n"
+ "\n"
+ " if (value == 0)\n"
+ " imageStore(uni_out_image, point - offset, uvec4(0));\n"
+ " else\n"
+ " imageStore(uni_out_image, point - offset, uvec4(value));\n"
+ "\n"
+ " if (color.r == 0)\n"
+ " imageStore(uni_out_image, point, uvec4(0));\n"
+ " else\n"
+ " imageStore(uni_out_image, point, uvec4(1));\n"
+ " }\n"
+ "}\n";
+
+const char* vertex_drawBuffer = "#version 430 core\n"
+ "\n"
+ "in vec3 vertex;\n"
+ "in vec2 inTexCoord;\n"
+ "out vec2 texCoord;\n"
+ "\n"
+ "void main()\n"
+ "{\n"
+ " texCoord = inTexCoord;\n"
+ " gl_Position = vec4(vertex, 1);\n"
+ "}\n";
+
+const char* fragment_drawBuffer = "#version 430 core\n"
+ "\n"
+ "layout (location = 1) uniform sampler2D uni_sampler;\n"
+ "\n"
+ "in vec2 texCoord;\n"
+ "out vec4 fragColor;\n"
+ "\n"
+ "void main()\n"
+ "{\n"
+ " fragColor = texture(uni_sampler, texCoord);\n"
+ "}\n";
+
+/** Replace first occurance of <token> with <text> in <string> starting at <search_posistion>
+ *
+ * @param token Token string
+ * @param search_position Position at which find will start, it is updated to position at which replaced text ends
+ * @param text String that will be used as replacement for <token>
+ * @param string String to work on
+ **/
+void replaceToken(const GLchar* token, size_t& search_position, const GLchar* text, std::string& string)
+{
+ const size_t text_length = strlen(text);
+ const size_t token_length = strlen(token);
+ const size_t token_position = string.find(token, search_position);
+
+ string.replace(token_position, token_length, text, text_length);
+
+ search_position = token_position + text_length;
+}
+
/** Constructor.
*
* @param context Rendering context
*/
tcu::TestNode::IterateResult StandardPageSizesTestCase::iterate()
{
+ if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_sparse_texture2"))
+ {
+ m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");
+ return STOP;
+ }
+
const Functions& gl = m_context.getRenderContext().getFunctions();
m_testCtx.getLog() << tcu::TestLog::Message << "Testing getInternalformativ" << tcu::TestLog::EndMessage;
/* Left blank intentionally */
}
+/** Constructor.
+ *
+ * @param context Rendering context
+ * @param name Test name
+ * @param description Test description
+ */
+SparseTexture2CommitmentTestCase::SparseTexture2CommitmentTestCase(deqp::Context& context, const char* name,
+ const char* description)
+ : SparseTextureCommitmentTestCase(context, name, description)
+{
+ /* Left blank intentionally */
+}
+
/** Initializes the test group contents. */
void SparseTexture2AllocationTestCase::init()
{
+ SparseTextureAllocationTestCase::init();
+
+ mSupportedTargets.clear();
mSupportedTargets.push_back(GL_TEXTURE_2D_MULTISAMPLE);
mSupportedTargets.push_back(GL_TEXTURE_2D_MULTISAMPLE_ARRAY);
+ mFullArrayTargets.clear();
mFullArrayTargets.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 SparseTexture2AllocationTestCase::iterate()
+{
+ if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_sparse_texture2"))
+ {
+ m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");
+ return STOP;
+ }
- 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);
+ return SparseTextureAllocationTestCase::iterate();
}
/** Constructor.
*
- * @param context Rendering context.
+ * @param context Rendering context
*/
-SparseTexture2Tests::SparseTexture2Tests(deqp::Context& context)
- : TestCaseGroup(context, "sparse_texture2_tests", "Verify conformance of CTS_ARB_sparse_texture2 implementation")
+SparseTexture2CommitmentTestCase::SparseTexture2CommitmentTestCase(deqp::Context& context)
+ : SparseTextureCommitmentTestCase(
+ context, "SparseTexture2Commitment",
+ "Verifies glTexPageCommitmentARB functionality added by ARB_sparse_texture2 extension")
{
+ /* Left blank intentionally */
}
/** Initializes the test group contents. */
-void SparseTexture2Tests::init()
+void SparseTexture2CommitmentTestCase::init()
{
- addChild(new StandardPageSizesTestCase(m_context));
- addChild(new SparseTextureAllocationTestCase(m_context));
+ SparseTextureCommitmentTestCase::init();
+
+ //Verify all targets once again and multisample targets as it was added in ARB_sparse_texture2 extension
+ mSupportedTargets.clear();
+ mSupportedTargets.push_back(GL_TEXTURE_2D_MULTISAMPLE);
+ mSupportedTargets.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 SparseTexture2CommitmentTestCase::iterate()
+{
+ if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_sparse_texture2"))
+ {
+ m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");
+ return STOP;
+ }
+
+ return SparseTextureCommitmentTestCase::iterate();
+}
+
+/** Sets proper strings that will be used to tekenize shaders depending on target and format.
+ *
+ * @param target Target for which texture is binded
+ * @param format Texture internal format
+ * @param sample Multisample texture sample number
+
+ * @return target Structure of token strings
+ */
+TokenStrings SparseTexture2CommitmentTestCase::setupShaderTokens(GLint target, GLint format, GLint sample)
+{
+ std::stringstream stemp;
+
+ TokenStrings s;
+ std::string prefix;
+
+ if (format == GL_R8)
+ {
+ s.format = "r8";
+ s.inColorExpected = "(0.1, 0, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ }
+ else if (format == GL_R8_SNORM)
+ {
+ s.format = "r8_snorm";
+ s.inColorExpected = "(0.1, 0, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ }
+ else if (format == GL_R16)
+ {
+ s.format = "r16";
+ s.inColorExpected = "(0.1, 0, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ }
+ else if (format == GL_R16_SNORM)
+ {
+ s.format = "r16_snorm";
+ s.inColorExpected = "(0.1, 0, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ }
+ else if (format == GL_RG8)
+ {
+ s.format = "rg8";
+ s.inColorExpected = "(0.1, 0.1, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ }
+ else if (format == GL_RG8_SNORM)
+ {
+ s.format = "rg8_snorm";
+ s.inColorExpected = "(0.1, 0.1, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ }
+ else if (format == GL_RG16)
+ {
+ s.format = "rg16";
+ s.inColorExpected = "(0.1, 0.1, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ }
+ else if (format == GL_RG16_SNORM)
+ {
+ s.format = "rg16_snorm";
+ s.inColorExpected = "(0.1, 0.1, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ }
+ else if (format == GL_RGBA8)
+ {
+ s.format = "rgba8";
+ s.inColorExpected = "(0.1, 0.1, 0.1, 1)";
+ s.inEmptyColor = "(0, 0, 0, 0)";
+ }
+ else if (format == GL_RGBA8_SNORM)
+ {
+ s.format = "rgba8_snorm";
+ s.inColorExpected = "(0.1, 0.1, 0.1, 1)";
+ s.inEmptyColor = "(0, 0, 0, 0)";
+ }
+ else if (format == GL_RGB10_A2)
+ {
+ s.format = "rgb10_a2";
+ s.inColorExpected = "(0.1, 0.1, 0.1, 1)";
+ s.inEmptyColor = "(0, 0, 0, 0)";
+ }
+ else if (format == GL_RGB10_A2UI)
+ {
+ s.format = "rgb10_a2ui";
+ s.inColorExpected = "(1, 1, 1, 1)";
+ s.inEmptyColor = "(0, 0, 0, 0)";
+ prefix = "u";
+ }
+ else if (format == GL_RGBA16)
+ {
+ s.format = "rgba16";
+ s.inColorExpected = "(0.1, 0.1, 0.1, 1)";
+ s.inEmptyColor = "(0, 0, 0, 0)";
+ }
+ else if (format == GL_RGBA16_SNORM)
+ {
+ s.format = "rgba16_snorm";
+ s.inColorExpected = "(0.1, 0.1, 0.1, 1)";
+ s.inEmptyColor = "(0, 0, 0, 0)";
+ }
+ else if (format == GL_R16F)
+ {
+ s.format = "r16f";
+ s.inColorExpected = "(1, 0, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ }
+ else if (format == GL_RG16F)
+ {
+ s.format = "rg16f";
+ s.inColorExpected = "(0.1, 0.1, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ }
+ else if (format == GL_RGBA16F)
+ {
+ s.format = "rgba16f";
+ s.inColorExpected = "(0.1, 0.1, 0.1, 1)";
+ s.inEmptyColor = "(0, 0, 0, 0)";
+ }
+ else if (format == GL_R32F)
+ {
+ s.format = "r32f";
+ s.inColorExpected = "(0.1, 0, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ }
+ else if (format == GL_RG32F)
+ {
+ s.format = "rg32f";
+ s.inColorExpected = "(0.1, 0.1, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ }
+ else if (format == GL_RGBA32F)
+ {
+ s.format = "rgba32f";
+ s.inColorExpected = "(0.1, 0.1, 0.1, 1)";
+ s.inEmptyColor = "(0, 0, 0, 0)";
+ }
+ else if (format == GL_R11F_G11F_B10F)
+ {
+ s.format = "r11f_g11f_b10f";
+ s.inColorExpected = "(0.1, 0.1, 0.1, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ }
+ else if (format == GL_R8I)
+ {
+ s.format = "r8i";
+ s.inColorExpected = "(1, 0, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ prefix = "i";
+ }
+ else if (format == GL_R8UI)
+ {
+ s.format = "r8ui";
+ s.inColorExpected = "(1, 0, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ prefix = "u";
+ }
+ else if (format == GL_R16I)
+ {
+ s.format = "r16i";
+ s.inColorExpected = "(1, 0, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ prefix = "i";
+ }
+ else if (format == GL_R16UI)
+ {
+ s.format = "r16ui";
+ s.inColorExpected = "(1, 0, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ prefix = "u";
+ }
+ else if (format == GL_R32I)
+ {
+ s.format = "r32i";
+ s.inColorExpected = "(1, 0, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ prefix = "i";
+ }
+ else if (format == GL_R32UI)
+ {
+ s.format = "r32ui";
+ s.inColorExpected = "(1, 0, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ prefix = "u";
+ }
+ else if (format == GL_RG8I)
+ {
+ s.format = "rg8i";
+ s.inColorExpected = "(1, 1, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ prefix = "i";
+ }
+ else if (format == GL_RG8UI)
+ {
+ s.format = "rg8ui";
+ s.inColorExpected = "(1, 1, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ prefix = "u";
+ }
+ else if (format == GL_RG16I)
+ {
+ s.format = "rg16i";
+ s.inColorExpected = "(1, 1, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ prefix = "i";
+ }
+ else if (format == GL_RG16UI)
+ {
+ s.format = "rg16ui";
+ s.inColorExpected = "(1, 1, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ prefix = "u";
+ }
+ else if (format == GL_RG32I)
+ {
+ s.format = "rg32i";
+ s.inColorExpected = "(1, 1, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ prefix = "i";
+ }
+ else if (format == GL_RG32UI)
+ {
+ s.format = "rg32ui";
+ s.inColorExpected = "(1, 1, 0, 1)";
+ s.inEmptyColor = "(0, 0, 0, 1)";
+ prefix = "u";
+ }
+ else if (format == GL_RGBA8I)
+ {
+ s.format = "rgba8i";
+ s.inColorExpected = "(1, 1, 1, 1)";
+ s.inEmptyColor = "(0, 0, 0, 0)";
+ prefix = "i";
+ }
+ else if (format == GL_RGBA8UI)
+ {
+ s.format = "rgba8ui";
+ s.inColorExpected = "(1, 1, 1, 1)";
+ s.inEmptyColor = "(0, 0, 0, 0)";
+ prefix = "u";
+ }
+ else if (format == GL_RGBA16I)
+ {
+ s.format = "rgba16i";
+ s.inColorExpected = "(1, 1, 1, 1)";
+ s.inEmptyColor = "(0, 0, 0, 0)";
+ prefix = "i";
+ }
+ else if (format == GL_RGBA16UI)
+ {
+ s.format = "rgba16ui";
+ s.inColorExpected = "(1, 1, 1, 1)";
+ s.inEmptyColor = "(0, 0, 0, 0)";
+ prefix = "u";
+ }
+ else if (format == GL_RGBA32I)
+ {
+ s.format = "rgba32i";
+ s.inColorExpected = "(1, 1, 1, 1)";
+ s.inEmptyColor = "(0, 0, 0, 0)";
+ prefix = "i";
+ }
+
+ s.inColorType = prefix + "vec4";
+ s.outImageType = "uimage2D";
+ s.inImageType = prefix + "image2D";
+ s.pointType = "ivec2";
+ s.pointDef = "gl_WorkGroupID.x, gl_WorkGroupID.y";
+
+ if (s.inColorType == "vec4")
+ s.epsilon = "0.008";
+ else
+ s.epsilon = "0";
+
+ if (target == GL_TEXTURE_2D_ARRAY)
+ {
+ s.outImageType = "uimage2DArray";
+ s.inImageType = prefix + "image2DArray";
+ s.pointType = "ivec3";
+ s.pointDef = "gl_WorkGroupID.x, gl_WorkGroupID.y, gl_WorkGroupID.z";
+ }
+ else if (target == GL_TEXTURE_3D)
+ {
+ s.outImageType = "uimage2DArray";
+ s.inImageType = prefix + "image3D";
+ s.pointType = "ivec3";
+ s.pointDef = "gl_WorkGroupID.x, gl_WorkGroupID.y, gl_WorkGroupID.z";
+ }
+ else if (target == GL_TEXTURE_CUBE_MAP)
+ {
+ s.outImageType = "uimage2DArray";
+ s.inImageType = prefix + "imageCube";
+ s.pointType = "ivec3";
+ s.pointDef = "gl_WorkGroupID.x, gl_WorkGroupID.y, gl_WorkGroupID.z";
+ }
+ else if (target == GL_TEXTURE_CUBE_MAP_ARRAY)
+ {
+ s.outImageType = "uimage2DArray";
+ s.inImageType = prefix + "imageCubeArray";
+ s.pointType = "ivec3";
+ s.pointDef = "gl_WorkGroupID.x, gl_WorkGroupID.y, gl_WorkGroupID.z";
+ }
+ else if (target == GL_TEXTURE_RECTANGLE)
+ {
+ s.inImageType = prefix + "image2DRect";
+ }
+ else if (target == GL_TEXTURE_2D_MULTISAMPLE)
+ {
+ s.inImageType = prefix + "image2DMS";
+ stemp.str("");
+ stemp << ", " << sample;
+ s.sampleDef = stemp.str();
+ }
+ else if (target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
+ {
+ s.outImageType = "uimage2DArray";
+ s.inImageType = prefix + "image2DMSArray";
+ s.pointType = "ivec3";
+ s.pointDef = "gl_WorkGroupID.x, gl_WorkGroupID.y, gl_WorkGroupID.z";
+ stemp.str("");
+ stemp << ", " << sample;
+ s.sampleDef = stemp.str();
+ }
+
+ return s;
+}
+
+/** 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 SparseTexture2CommitmentTestCase::caseAllowed(GLint target, GLint format)
+{
+ // Multisample textures are filling with data and verifying using compute shader.
+ // As shaders do not support some texture formats it is necessary to exclude them.
+ if ((target == GL_TEXTURE_2D_MULTISAMPLE || target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY) &&
+ (format == GL_RGB565 || format == GL_RGB10_A2UI || format == GL_RGB9_E5))
+ {
+ return false;
+ }
+
+ 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 SparseTexture2CommitmentTestCase::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, GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_2D_MULTISAMPLE_ARRAY can have only one level
+ if (target != GL_TEXTURE_RECTANGLE && target != GL_TEXTURE_2D_MULTISAMPLE &&
+ target != GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
+ {
+ 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;
+
+ if (target != GL_TEXTURE_2D_MULTISAMPLE && target != GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
+ {
+ mState.samples = 1;
+ }
+ else
+ mState.samples = 2;
+
+ Texture::Storage(gl, target, deMax32(mState.levels, mState.samples), 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 SparseTexture2CommitmentTestCase::allocateTexture(const Functions& gl, GLint target, GLint format, GLuint& texture,
+ GLint levels)
+{
+ mLog << "Allocate [levels: " << levels << "] - ";
+
+ prepareTexture(gl, target, format, texture);
+
+ // GL_TEXTURE_RECTANGLE, GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_2D_MULTISAMPLE_ARRAY can have only one level
+ if (target != GL_TEXTURE_RECTANGLE && target != GL_TEXTURE_2D_MULTISAMPLE &&
+ target != GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
+ {
+ mState.levels = levels;
+ }
+ else
+ mState.levels = 1;
+
+ // GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_2D_MULTISAMPLE_ARRAY can use multiple samples
+ if (target != GL_TEXTURE_2D_MULTISAMPLE && target != GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
+ {
+ mState.samples = 1;
+ }
+ else
+ mState.samples = 2;
+
+ Texture::Storage(gl, target, deMax32(mState.levels, mState.samples), 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 SparseTexture2CommitmentTestCase::writeDataToTexture(const Functions& gl, GLint target, GLint format,
+ GLuint& texture, GLint level)
+{
+ 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, 255, texSize);
+
+ if (target != GL_TEXTURE_2D_MULTISAMPLE && target != GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
+ {
+ Texture::SubImage(gl, target, level, 0, 0, 0, width, height, depth, transferFormat.format,
+ transferFormat.dataType, (GLvoid*)data);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "SubImage");
+ }
+ // For multisample texture use compute shader to store image data
+ else
+ {
+ for (GLint sample = 0; sample < mState.samples; ++sample)
+ {
+ std::string shader = compute_textureFill;
+
+ // Adjust shader source to texture format
+ TokenStrings s = setupShaderTokens(target, format, sample);
+
+ size_t pos = 0;
+ replaceToken("<INIMAGE_TYPE>", pos, s.inImageType.c_str(), shader);
+ replaceToken("<POINT_TYPE>", pos, s.pointType.c_str(), shader);
+ replaceToken("<POINT_TYPE>", pos, s.pointType.c_str(), shader);
+ replaceToken("<POINT_DEF>", pos, s.pointDef.c_str(), shader);
+ replaceToken("<INCOLOR_TYPE>", pos, s.inColorType.c_str(), shader);
+ replaceToken("<INCOLOR_TYPE>", pos, s.inColorType.c_str(), shader);
+ replaceToken("<INIMAGE_COLOR>", pos, s.inColorExpected.c_str(), shader);
+ replaceToken("<SAMPLE_DEF>", pos, s.sampleDef.c_str(), shader);
+
+ ProgramSources sources;
+ sources << ComputeSource(shader);
+
+ // Build and run shader
+ ShaderProgram program(m_context.getRenderContext(), sources);
+ if (program.isOk())
+ {
+ gl.useProgram(program.getProgram());
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram");
+ gl.bindImageTexture(0 /* unit */, texture, level /* level */, GL_FALSE /* layered */, 0 /* layer */,
+ GL_WRITE_ONLY, format);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glBindImageTexture");
+ gl.uniform1i(1, 0 /* image_unit */);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i");
+ gl.dispatchCompute(width, height, depth);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glDispatchCompute");
+ gl.memoryBarrier(GL_ALL_BARRIER_BITS);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glMemoryBarrier");
+ }
+ else
+ {
+ mLog << "Compute shader compilation failed (writing) for target: " << target
+ << ", format: " << format << ", sample: " << sample
+ << ", infoLog: " << program.getShaderInfo(SHADERTYPE_COMPUTE).infoLog
+ << ", shaderSource: " << shader.c_str() << " - ";
+ }
+ }
+ }
+ }
+
+ 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 SparseTexture2CommitmentTestCase::verifyTextureData(const Functions& gl, GLint target, GLint format,
+ GLuint& texture, GLint level)
+{
+ 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 && target != GL_TEXTURE_2D_MULTISAMPLE &&
+ target != GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
+ {
+ 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, 255, texSize);
+ deMemset(out_data, 127, 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 if (target == GL_TEXTURE_CUBE_MAP)
+ {
+ 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, 255, texSize);
+
+ for (size_t i = 0; i < subTargets.size(); ++i)
+ {
+ GLint subTarget = subTargets[i];
+
+ mLog << "Verify Subtarget [subtarget: " << subTarget << "] - ";
+
+ deMemset(out_data, 127, 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;
+ }
+ }
+ // For multisample texture use compute shader to verify image data
+ else if (target == GL_TEXTURE_2D_MULTISAMPLE || target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
+ {
+ GLint texSize = width * height * depth;
+
+ 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, 255, texSize);
+
+ // Create verifying texture
+ GLint verifyTarget;
+ if (target == GL_TEXTURE_2D_MULTISAMPLE)
+ verifyTarget = GL_TEXTURE_2D;
+ else
+ verifyTarget = GL_TEXTURE_2D_ARRAY;
+
+ GLuint verifyTexture;
+ Texture::Generate(gl, verifyTexture);
+ Texture::Bind(gl, verifyTexture, verifyTarget);
+ Texture::Storage(gl, verifyTarget, 1, GL_R8, width, height, depth);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "Texture::Storage");
+
+ for (int sample = 0; sample < mState.samples; ++sample)
+ {
+ deMemset(out_data, 0, texSize);
+
+ Texture::Bind(gl, verifyTexture, verifyTarget);
+ Texture::SubImage(gl, verifyTarget, 0, 0, 0, 0, width, height, depth, GL_RED, GL_UNSIGNED_BYTE,
+ (GLvoid*)out_data);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "Texture::SubImage");
+
+ std::string shader = compute_textureVerify;
+
+ // Adjust shader source to texture format
+ TokenStrings s = setupShaderTokens(target, format, sample);
+
+ size_t pos = 0;
+ std::string imageType;
+
+ replaceToken("<OUTIMAGE_TYPE>", pos, s.outImageType.c_str(), shader);
+ replaceToken("<FORMAT>", pos, s.format.c_str(), shader);
+ replaceToken("<INIMAGE_TYPE>", pos, s.inImageType.c_str(), shader);
+ replaceToken("<POINT_TYPE>", pos, s.pointType.c_str(), shader);
+ replaceToken("<POINT_TYPE>", pos, s.pointType.c_str(), shader);
+ replaceToken("<POINT_DEF>", pos, s.pointDef.c_str(), shader);
+ replaceToken("<INCOLOR_TYPE>", pos, s.inColorType.c_str(), shader);
+ replaceToken("<SAMPLE_DEF>", pos, s.sampleDef.c_str(), shader);
+ replaceToken("<INCOLOR_TYPE>", pos, s.inColorType.c_str(), shader);
+ replaceToken("<INCOLOR_EXPECTED>", pos, s.inColorExpected.c_str(), shader);
+ replaceToken("<INCOLOR_TYPE>", pos, s.inColorType.c_str(), shader);
+ replaceToken("<EPSILON>", pos, s.epsilon.c_str(), shader);
+
+ ProgramSources sources;
+ sources << ComputeSource(shader);
+
+ // Build and run shader
+ ShaderProgram program(m_context.getRenderContext(), sources);
+ if (program.isOk())
+ {
+ gl.useProgram(program.getProgram());
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram");
+ gl.bindImageTexture(0, //unit
+ verifyTexture,
+ level, //level
+ GL_FALSE, //layered
+ 0, //layer
+ GL_WRITE_ONLY, GL_R8UI);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glBindImageTexture");
+ gl.bindImageTexture(1, //unit
+ texture,
+ level, //level
+ GL_FALSE, //layered
+ 0, //layer
+ GL_READ_ONLY, format);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glBindImageTexture");
+ gl.uniform1i(1, 0 /* image_unit */);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i");
+ gl.uniform1i(2, 1 /* image_unit */);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i");
+ gl.dispatchCompute(width, height, depth);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glDispatchCompute");
+ gl.memoryBarrier(GL_ALL_BARRIER_BITS);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glMemoryBarrier");
+
+ Texture::GetData(gl, 0, verifyTarget, GL_RED, GL_UNSIGNED_BYTE, (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)
+ {
+ GLubyte* dataRegion = exp_data + ((x + y * width) + z * width * height);
+ GLubyte* outDataRegion = out_data + ((x + y * width) + z * width * height);
+ if (dataRegion[0] != outDataRegion[0])
+ result = false;
+ }
+ }
+ else
+ {
+ mLog << "Compute shader compilation failed (reading) for target: " << target << ", format: " << format
+ << ", infoLog: " << program.getShaderInfo(SHADERTYPE_COMPUTE).infoLog
+ << ", shaderSource: " << shader.c_str() << " - ";
+
+ result = false;
+ }
+ }
+
+ Texture::Delete(gl, verifyTexture);
+ }
+
+ return result;
+}
+
+const GLfloat texCoord[] = {
+ 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
+};
+
+const GLfloat vertices[] = {
+ -1.0f, -1.0f, 0.0f, 1.0f, -1.0f, 0.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f,
+};
+
+const GLuint indices[] = { 0, 1, 2, 1, 2, 3 };
+
+/** Constructor.
+ *
+ * @param context Rendering context
+ */
+UncommittedRegionsAccessTestCase::UncommittedRegionsAccessTestCase(deqp::Context& context)
+ : SparseTexture2CommitmentTestCase(context, "UncommittedRegionsAccessTest",
+ "Verifies if access to uncommitted regions of sparse texture works as expected")
+{
+ /* Left blank intentionally */
+}
+
+/** Stub init method */
+void UncommittedRegionsAccessTestCase::init()
+{
+ SparseTextureCommitmentTestCase::init();
+
+ mSupportedTargets.push_back(GL_TEXTURE_2D_MULTISAMPLE);
+ mSupportedTargets.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 UncommittedRegionsAccessTestCase::iterate()
+{
+ if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_sparse_texture2"))
+ {
+ 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 uncommitted regions access for target: " << target << ", format: " << format << " - ";
+
+ 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 = result && UncommittedReads(gl, target, format, texture, l);
+ result = result && UncommittedAtomicOperations(gl, target, format, texture, l);
+ result = result && UncommittedDepthStencil(gl, target, format, texture, l);
+ }
+
+ if (!result)
+ break;
+ }
+
+ Texture::Delete(gl, 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;
+}
+
+/** Check if reads from uncommitted regions are allowed
+ *
+ * @param target Target for which texture is binded
+ * @param format Texture internal format
+ *
+ * @return Returns true if allowed, false otherwise.
+ */
+bool UncommittedRegionsAccessTestCase::readsAllowed(GLint target, GLint format, bool shaderOnly)
+{
+ DE_UNREF(target);
+
+ if (shaderOnly && (format == GL_RGB565 || format == GL_RGB10_A2UI || format == GL_RGB9_E5))
+ {
+ return false;
+ }
+
+ return true;
+}
+
+/** Check if atomic operations on uncommitted regions are allowed
+ *
+ * @param target Target for which texture is binded
+ * @param format Texture internal format
+ *
+ * @return Returns true if allowed, false otherwise.
+ */
+bool UncommittedRegionsAccessTestCase::atomicAllowed(GLint target, GLint format)
+{
+ DE_UNREF(target);
+
+ if (format == GL_R32I || format == GL_R32UI)
+ {
+ return true;
+ }
+
+ return false;
+}
+
+/** Check if depth and stencil test on uncommitted regions are allowed
+ *
+ * @param target Target for which texture is binded
+ * @param format Texture internal format
+ *
+ * @return Returns true if allowed, false otherwise.
+ */
+bool UncommittedRegionsAccessTestCase::depthStencilAllowed(GLint target, GLint format)
+{
+ if (target == GL_TEXTURE_2D && format == GL_RGBA8)
+ {
+ return true;
+ }
+
+ return false;
+}
+
+/** Verify reads from uncommitted texture regions works 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 otherwise.
+ */
+bool UncommittedRegionsAccessTestCase::UncommittedReads(const Functions& gl, GLint target, GLint format,
+ GLuint& texture, GLint level)
+{
+ bool result = true;
+
+ // Verify using API glGetTexImage*
+ if (readsAllowed(target, format, false))
+ {
+ mLog << "API Reads - ";
+ result = result && verifyTextureDataExtended(gl, target, format, texture, level, false);
+ }
+
+ // Verify using shader imageLoad function
+ if (result && readsAllowed(target, format, true))
+ {
+ mLog << "Shader Reads - ";
+ result = result && verifyTextureDataExtended(gl, target, format, texture, level, true);
+ }
+
+ // Verify mipmap generating
+ if (result && level == 0 && target != GL_TEXTURE_RECTANGLE && target != GL_TEXTURE_2D_MULTISAMPLE &&
+ target != GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
+ {
+ mLog << "Mipmap Generate - ";
+ Texture::Bind(gl, texture, target);
+ gl.generateMipmap(target);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glGenerateMipmap");
+
+ for (int l = 1; l < mState.levels; ++l)
+ result = result && verifyTextureDataExtended(gl, target, format, texture, level, false);
+ }
+
+ return result;
+}
+
+/** Verify atomic operations on uncommitted texture pixels works 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 otherwise.
+ */
+bool UncommittedRegionsAccessTestCase::UncommittedAtomicOperations(const Functions& gl, GLint target, GLint format,
+ GLuint& texture, GLint level)
+{
+ bool result = true;
+
+ if (atomicAllowed(target, format))
+ {
+ mLog << "Atomic Operations - ";
+ result = result && verifyAtomicOperations(gl, target, format, texture, level);
+ }
+
+ return result;
+}
+
+/** Verify depth and stencil tests on uncommitted texture pixels works 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 otherwise.
+ */
+bool UncommittedRegionsAccessTestCase::UncommittedDepthStencil(const Functions& gl, GLint target, GLint format,
+ GLuint& texture, GLint level)
+{
+ if (!depthStencilAllowed(target, format))
+ return true;
+
+ mLog << "Depth Stencil - ";
+
+ bool result = true;
+
+ GLint width;
+ GLint height;
+ GLint depth;
+ SparseTextureUtils::getTextureLevelSize(target, mState, level, width, height, depth);
+
+ //Committed region is limited to 1/2 of width
+ GLuint widthCommitted = width / 2;
+
+ if (widthCommitted == 0 || height == 0 || depth < mState.minDepth)
+ return true;
+
+ //Prepare shaders
+ std::string vertexSource = vertex_drawBuffer;
+ std::string fragmentSource = fragment_drawBuffer;
+
+ ShaderProgram program(gl, glu::makeVtxFragSources(vertexSource, fragmentSource));
+ if (!program.isOk())
+ {
+ mLog << "Shader compilation failed (depth_stencil) for target: " << target << ", format: " << format
+ << ", vertex_infoLog: " << program.getShaderInfo(SHADERTYPE_VERTEX).infoLog
+ << ", fragment_infoLog: " << program.getShaderInfo(SHADERTYPE_FRAGMENT).infoLog
+ << ", vertexSource: " << vertexSource.c_str() << "\n"
+ << ", fragmentSource: " << fragmentSource.c_str() << " - ";
+
+ return false;
+ }
+
+ prepareDepthStencilFramebuffer(gl, width, height);
+
+ gl.useProgram(program.getProgram());
+
+ gl.activeTexture(GL_TEXTURE0);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveTexture");
+ Texture::Bind(gl, texture, target);
+ gl.uniform1i(1, 0);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i");
+
+ // Stencil test
+ result = result && verifyStencilTest(gl, program, width, height, widthCommitted);
+
+ // Depth test
+ result = result && verifyDepthTest(gl, program, width, height, widthCommitted);
+
+ // Depth bounds test
+ if (m_context.getContextInfo().isExtensionSupported("GL_EXT_depth_bounds_test"))
+ result = result && verifyDepthBoundsTest(gl, program, width, height, widthCommitted);
+
+ // Resources cleaning
+ cleanupDepthStencilFramebuffer(gl);
+
+ return result;
+}
+
+/** Prepare gl depth and stencil test resources
+ *
+ * @param gl GL API functions
+ * @param width Framebuffer width
+ * @param height Framebuffer height
+ */
+void UncommittedRegionsAccessTestCase::prepareDepthStencilFramebuffer(const Functions& gl, GLint width, GLint height)
+{
+ gl.genRenderbuffers(1, &mRenderbuffer);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glGenRenderbuffers");
+ gl.bindRenderbuffer(GL_RENDERBUFFER, mRenderbuffer);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer");
+ if (mState.samples == 1)
+ {
+ gl.renderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_STENCIL, width, height);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glRenderbufferStorage");
+ }
+ else
+ {
+ gl.renderbufferStorageMultisample(GL_RENDERBUFFER, mState.samples, GL_DEPTH_STENCIL, width, height);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glRenderbufferStorageMultisample");
+ }
+
+ gl.genFramebuffers(1, &mFramebuffer);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers");
+ gl.bindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer");
+ gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, mRenderbuffer);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferRenderbuffer");
+ gl.viewport(0, 0, width, height);
+}
+
+/** Cleanup gl depth and stencil test resources
+ *
+ * @param gl GL API functions
+ */
+void UncommittedRegionsAccessTestCase::cleanupDepthStencilFramebuffer(const Functions& gl)
+{
+ gl.deleteFramebuffers(1, &mFramebuffer);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteFramebuffers");
+ gl.deleteRenderbuffers(1, &mRenderbuffer);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteRenderbuffers");
+
+ gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer");
+}
+
+/** Verify if data stored in texture in uncommitted regions 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
+ * @param shaderOnly Shader texture filling flag, default false
+ *
+ * @return Returns true if data is as expected, false if not, throws an exception if error occurred.
+ */
+bool UncommittedRegionsAccessTestCase::verifyTextureDataExtended(const Functions& gl, GLint target, GLint format,
+ GLuint& texture, GLint level, bool shaderOnly)
+{
+ 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;
+
+ // Verify texture using API glGetTexImage* (Skip multisample textures as it can not be verified using API)
+ if (!shaderOnly && target != GL_TEXTURE_CUBE_MAP && target != GL_TEXTURE_2D_MULTISAMPLE &&
+ target != GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
+ {
+ 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, 0, texSize);
+ deMemset(out_data, 127, 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 = widthCommitted; x < width; ++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;
+ }
+ }
+ // Verify texture using API glGetTexImage* (Only cube map as it has to be verified for subtargets)
+ else if (!shaderOnly && target == GL_TEXTURE_CUBE_MAP)
+ {
+ 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, 0, texSize);
+
+ for (size_t i = 0; i < subTargets.size(); ++i)
+ {
+ GLint subTarget = subTargets[i];
+
+ mLog << "Verify Subtarget [subtarget: " << subTarget << "] - ";
+
+ deMemset(out_data, 127, 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 = widthCommitted; x < width; ++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;
+ }
+ }
+ // Verify texture using shader imageLoad function
+ else if (shaderOnly)
+ {
+ // Create verifying texture
+ GLint verifyTarget;
+ if (target == GL_TEXTURE_2D_MULTISAMPLE)
+ verifyTarget = GL_TEXTURE_2D;
+ else
+ verifyTarget = GL_TEXTURE_2D_ARRAY;
+
+ if (target == GL_TEXTURE_CUBE_MAP)
+ depth = depth * 6;
+
+ GLint texSize = width * height * depth;
+
+ std::vector<GLubyte> vecExpData;
+ std::vector<GLubyte> vecOutData;
+ vecExpData.resize(texSize);
+ vecOutData.resize(texSize);
+ GLubyte* exp_data = vecExpData.data();
+ GLubyte* out_data = vecOutData.data();
+
+ // Expected value in this case is 255 because shader fills output texture with 255 if in texture is filled with zeros
+ deMemset(exp_data, 255, texSize);
+
+ GLuint verifyTexture;
+ Texture::Generate(gl, verifyTexture);
+ Texture::Bind(gl, verifyTexture, verifyTarget);
+ Texture::Storage(gl, verifyTarget, 1, GL_R8, width, height, depth);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "Texture::Storage");
+
+ for (GLint sample = 0; sample < mState.samples; ++sample)
+ {
+ deMemset(out_data, 0, texSize);
+
+ Texture::Bind(gl, verifyTexture, verifyTarget);
+ Texture::SubImage(gl, verifyTarget, 0, 0, 0, 0, width, height, depth, GL_RED, GL_UNSIGNED_BYTE,
+ (GLvoid*)out_data);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "Texture::SubImage");
+
+ std::string shader = compute_textureVerify;
+
+ // Adjust shader source to texture format
+ TokenStrings s = setupShaderTokens(target, format, sample);
+
+ size_t pos = 0;
+ replaceToken("<OUTIMAGE_TYPE>", pos, s.outImageType.c_str(), shader);
+ replaceToken("<FORMAT>", pos, s.format.c_str(), shader);
+ replaceToken("<INIMAGE_TYPE>", pos, s.inImageType.c_str(), shader);
+ replaceToken("<POINT_TYPE>", pos, s.pointType.c_str(), shader);
+ replaceToken("<POINT_TYPE>", pos, s.pointType.c_str(), shader);
+ replaceToken("<POINT_DEF>", pos, s.pointDef.c_str(), shader);
+ replaceToken("<INCOLOR_TYPE>", pos, s.inColorType.c_str(), shader);
+ replaceToken("<SAMPLE_DEF>", pos, s.sampleDef.c_str(), shader);
+ replaceToken("<INCOLOR_TYPE>", pos, s.inColorType.c_str(), shader);
+ replaceToken("<INCOLOR_EXPECTED>", pos, s.inEmptyColor.c_str(), shader);
+ replaceToken("<INCOLOR_TYPE>", pos, s.inColorType.c_str(), shader);
+ replaceToken("<EPSILON>", pos, s.epsilon.c_str(), shader);
+
+ ProgramSources sources;
+ sources << ComputeSource(shader);
+
+ // Build and run shader
+ ShaderProgram program(m_context.getRenderContext(), sources);
+ if (program.isOk())
+ {
+ gl.useProgram(program.getProgram());
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram");
+ gl.bindImageTexture(0, //unit
+ verifyTexture,
+ level, //level
+ GL_FALSE, //layered
+ 0, //layer
+ GL_WRITE_ONLY, GL_R8UI);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glBindImageTexture");
+ gl.bindImageTexture(1, //unit
+ texture,
+ level, //level
+ GL_FALSE, //layered
+ 0, //layer
+ GL_READ_ONLY, format);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glBindImageTexture");
+ gl.uniform1i(1, 0 /* image_unit */);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i");
+ gl.uniform1i(2, 1 /* image_unit */);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i");
+ gl.dispatchCompute(width, height, depth);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glDispatchCompute");
+ gl.memoryBarrier(GL_ALL_BARRIER_BITS);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glMemoryBarrier");
+
+ Texture::GetData(gl, 0, verifyTarget, GL_RED, GL_UNSIGNED_BYTE, (GLvoid*)out_data);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "Texture::GetData");
+
+ //Verify only committed region
+ for (GLint x = widthCommitted; x < width; ++x)
+ for (GLint y = 0; y < height; ++y)
+ for (GLint z = 0; z < depth; ++z)
+ {
+ GLubyte* dataRegion = exp_data + ((x + y * width) + z * width * height);
+ GLubyte* outDataRegion = out_data + ((x + y * width) + z * width * height);
+ if (dataRegion[0] != outDataRegion[0])
+ result = false;
+ }
+ }
+ else
+ {
+ mLog << "Compute shader compilation failed (reading) for target: " << target << ", format: " << format
+ << ", sample: " << sample << ", infoLog: " << program.getShaderInfo(SHADERTYPE_COMPUTE).infoLog
+ << ", shaderSource: " << shader.c_str() << " - ";
+
+ result = false;
+ }
+ }
+
+ Texture::Delete(gl, verifyTexture);
+ }
+
+ return result;
+}
+
+/** Verify if atomic operations on uncommitted regions returns zeros and has no effect on texture
+ *
+ * @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 UncommittedRegionsAccessTestCase::verifyAtomicOperations(const Functions& gl, GLint target, GLint format,
+ GLuint& texture, GLint level)
+{
+ mLog << "Verify Atomic Operations [level: " << level << "] - ";
+
+ if (level > mState.levels - 1)
+ TCU_FAIL("Invalid level");
+
+ 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;
+
+ // Create verifying texture
+ GLint verifyTarget;
+ if (target == GL_TEXTURE_2D_MULTISAMPLE)
+ verifyTarget = GL_TEXTURE_2D;
+ else
+ verifyTarget = GL_TEXTURE_2D_ARRAY;
+
+ GLint texSize = width * height * depth;
+
+ std::vector<GLubyte> vecExpData;
+ std::vector<GLubyte> vecOutData;
+ vecExpData.resize(texSize);
+ vecOutData.resize(texSize);
+ GLubyte* exp_data = vecExpData.data();
+ GLubyte* out_data = vecOutData.data();
+
+ // Expected value in this case is 255 because shader fills output texture with 255 if in texture is filled with zeros
+ deMemset(exp_data, 0, texSize);
+
+ GLuint verifyTexture;
+ Texture::Generate(gl, verifyTexture);
+ Texture::Bind(gl, verifyTexture, verifyTarget);
+ Texture::Storage(gl, verifyTarget, 1, GL_R8, width, height, depth);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "Texture::Storage");
+
+ for (GLint sample = 0; sample < mState.samples; ++sample)
+ {
+ deMemset(out_data, 255, texSize);
+
+ Texture::Bind(gl, verifyTexture, verifyTarget);
+ Texture::SubImage(gl, verifyTarget, 0, 0, 0, 0, width, height, depth, GL_RED, GL_UNSIGNED_BYTE,
+ (GLvoid*)out_data);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "Texture::SubImage");
+
+ std::string shader = compute_atomicVerify;
+
+ // Adjust shader source to texture format
+ TokenStrings s = setupShaderTokens(target, format, sample);
+ std::string dataType = (s.inColorType == "ivec4" ? "int" : "uint");
+
+ size_t pos = 0;
+ replaceToken("<OUTIMAGE_TYPE>", pos, s.outImageType.c_str(), shader);
+ replaceToken("<FORMAT>", pos, s.format.c_str(), shader);
+ replaceToken("<INIMAGE_TYPE>", pos, s.inImageType.c_str(), shader);
+ replaceToken("<POINT_TYPE>", pos, s.pointType.c_str(), shader);
+ replaceToken("<POINT_TYPE>", pos, s.pointType.c_str(), shader);
+ replaceToken("<POINT_DEF>", pos, s.pointDef.c_str(), shader);
+ replaceToken("<POINT_TYPE>", pos, s.pointType.c_str(), shader);
+ replaceToken("<DATA_TYPE>", pos, dataType.c_str(), shader);
+ replaceToken("<SAMPLE_DEF>", pos, s.sampleDef.c_str(), shader);
+ replaceToken("<DATA_TYPE>", pos, dataType.c_str(), shader);
+ replaceToken("<SAMPLE_DEF>", pos, s.sampleDef.c_str(), shader);
+ replaceToken("<DATA_TYPE>", pos, dataType.c_str(), shader);
+ replaceToken("<DATA_TYPE>", pos, dataType.c_str(), shader);
+ replaceToken("<SAMPLE_DEF>", pos, s.sampleDef.c_str(), shader);
+ replaceToken("<DATA_TYPE>", pos, dataType.c_str(), shader);
+ replaceToken("<SAMPLE_DEF>", pos, s.sampleDef.c_str(), shader);
+ replaceToken("<DATA_TYPE>", pos, dataType.c_str(), shader);
+ replaceToken("<SAMPLE_DEF>", pos, s.sampleDef.c_str(), shader);
+ replaceToken("<DATA_TYPE>", pos, dataType.c_str(), shader);
+ replaceToken("<SAMPLE_DEF>", pos, s.sampleDef.c_str(), shader);
+ replaceToken("<DATA_TYPE>", pos, dataType.c_str(), shader);
+ replaceToken("<SAMPLE_DEF>", pos, s.sampleDef.c_str(), shader);
+ replaceToken("<DATA_TYPE>", pos, dataType.c_str(), shader);
+ replaceToken("<SAMPLE_DEF>", pos, s.sampleDef.c_str(), shader);
+ replaceToken("<DATA_TYPE>", pos, dataType.c_str(), shader);
+ replaceToken("<INCOLOR_TYPE>", pos, s.inColorType.c_str(), shader);
+ replaceToken("<SAMPLE_DEF>", pos, s.sampleDef.c_str(), shader);
+
+ ProgramSources sources;
+ sources << ComputeSource(shader);
+
+ // Build and run shader
+ ShaderProgram program(m_context.getRenderContext(), sources);
+ if (program.isOk())
+ {
+ gl.useProgram(program.getProgram());
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram");
+ gl.bindImageTexture(0, //unit
+ verifyTexture,
+ level, //level
+ GL_FALSE, //layered
+ 0, //layer
+ GL_WRITE_ONLY, GL_R8UI);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glBindImageTexture");
+ gl.bindImageTexture(1, //unit
+ texture,
+ level, //level
+ GL_FALSE, //layered
+ 0, //layer
+ GL_READ_ONLY, format);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glBindImageTexture");
+ gl.uniform1i(1, 0 /* image_unit */);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i");
+ gl.uniform1i(2, 1 /* image_unit */);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i");
+ gl.uniform1i(3, widthCommitted /* committed width */);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i");
+ gl.dispatchCompute(width, height, depth);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glDispatchCompute");
+ gl.memoryBarrier(GL_ALL_BARRIER_BITS);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glMemoryBarrier");
+
+ Texture::GetData(gl, 0, verifyTarget, GL_RED, GL_UNSIGNED_BYTE, (GLvoid*)out_data);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "Texture::GetData");
+
+ //Verify only committed region
+ for (GLint x = 0; x < width; ++x)
+ for (GLint y = 0; y < height; ++y)
+ for (GLint z = 0; z < depth; ++z)
+ {
+ GLubyte* dataRegion = exp_data + ((x + y * width) + z * width * height);
+ GLubyte* outDataRegion = out_data + ((x + y * width) + z * width * height);
+ if (dataRegion[0] != outDataRegion[0])
+ {
+ result = false;
+ }
+ }
+ }
+ else
+ {
+ mLog << "Compute shader compilation failed (atomic) for target: " << target << ", format: " << format
+ << ", sample: " << sample << ", infoLog: " << program.getShaderInfo(SHADERTYPE_COMPUTE).infoLog
+ << ", shaderSource: " << shader.c_str() << " - ";
+
+ result = false;
+ }
+ }
+
+ Texture::Delete(gl, verifyTexture);
+
+ return result;
+}
+
+/** Verify if stencil test on uncommitted texture region works as expected texture
+ *
+ * @param gl GL API functions
+ * @param program Shader program
+ * @param width Texture width
+ * @param height Texture height
+ * @param widthCommitted Committed region width
+ *
+ * @return Returns true if stencil data is as expected, false otherwise.
+ */
+bool UncommittedRegionsAccessTestCase::verifyStencilTest(const Functions& gl, ShaderProgram& program, GLint width,
+ GLint height, GLint widthCommitted)
+{
+ glu::VertexArrayBinding vertexArrays[] = { glu::va::Float("vertex", 3, 4, 0, vertices),
+ glu::va::Float("inTexCoord", 2, 4, 0, texCoord) };
+
+ mLog << "Perform Stencil Test - ";
+
+ gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+ gl.enable(GL_STENCIL_TEST);
+ gl.stencilFunc(GL_GREATER, 1, 0xFF);
+ gl.stencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
+
+ glu::draw(m_context.getRenderContext(), program.getProgram(), DE_LENGTH_OF_ARRAY(vertexArrays), vertexArrays,
+ glu::pr::TriangleStrip(DE_LENGTH_OF_ARRAY(indices), indices));
+
+ std::vector<GLubyte> dataStencil;
+ dataStencil.resize(width * height);
+ GLubyte* dataStencilPtr = dataStencil.data();
+
+ gl.readPixels(0, 0, width, height, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, (GLvoid*)dataStencilPtr);
+ for (int x = widthCommitted; x < width; ++x)
+ for (int y = 0; y < height; ++y)
+ {
+ if (dataStencilPtr[x + y * width] != 0x00)
+ {
+ gl.disable(GL_STENCIL_TEST);
+ return false;
+ }
+ }
+
+ gl.disable(GL_STENCIL_TEST);
+ return true;
+}
+
+/** Verify if depth test on uncommitted texture region works as expected texture
+ *
+ * @param gl GL API functions
+ * @param program Shader program
+ * @param width Texture width
+ * @param height Texture height
+ * @param widthCommitted Committed region width
+ *
+ * @return Returns true if depth data is as expected, false otherwise.
+ */
+bool UncommittedRegionsAccessTestCase::verifyDepthTest(const Functions& gl, ShaderProgram& program, GLint width,
+ GLint height, GLint widthCommitted)
+{
+ glu::VertexArrayBinding vertexArrays[] = { glu::va::Float("vertex", 3, 4, 0, vertices),
+ glu::va::Float("inTexCoord", 2, 4, 0, texCoord) };
+
+ mLog << "Perform Depth Test - ";
+
+ gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+ gl.enable(GL_DEPTH_TEST);
+ gl.depthFunc(GL_LESS);
+
+ glu::draw(m_context.getRenderContext(), program.getProgram(), DE_LENGTH_OF_ARRAY(vertexArrays), vertexArrays,
+ glu::pr::TriangleStrip(DE_LENGTH_OF_ARRAY(indices), indices));
+
+ std::vector<GLuint> dataDepth;
+ dataDepth.resize(width * height);
+ GLuint* dataDepthPtr = dataDepth.data();
+
+ gl.readPixels(0, 0, width, height, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, (GLvoid*)dataDepthPtr);
+ for (int x = widthCommitted; x < width; ++x)
+ for (int y = 0; y < height; ++y)
+ {
+ if (dataDepthPtr[x + y * width] != 0xFFFFFFFF)
+ {
+ gl.disable(GL_DEPTH_TEST);
+ return false;
+ }
+ }
+
+ gl.disable(GL_DEPTH_TEST);
+ return true;
+}
+
+/** Verify if depth bounds test on uncommitted texture region works as expected texture
+ *
+ * @param gl GL API functions
+ * @param program Shader program
+ * @param width Texture width
+ * @param height Texture height
+ * @param widthCommitted Committed region width
+ *
+ * @return Returns true if depth data is as expected, false otherwise.
+ */
+bool UncommittedRegionsAccessTestCase::verifyDepthBoundsTest(const Functions& gl, ShaderProgram& program, GLint width,
+ GLint height, GLint widthCommitted)
+{
+ glu::VertexArrayBinding vertexArrays[] = { glu::va::Float("vertex", 3, 4, 0, vertices),
+ glu::va::Float("inTexCoord", 2, 4, 0, texCoord) };
+
+ mLog << "Perform Depth Bounds Test - ";
+
+ gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+ gl.enable(GL_DEPTH_BOUNDS_TEST_EXT);
+ gl.depthFunc(GL_LESS);
+
+ glu::draw(m_context.getRenderContext(), program.getProgram(), DE_LENGTH_OF_ARRAY(vertexArrays), vertexArrays,
+ glu::pr::TriangleStrip(DE_LENGTH_OF_ARRAY(indices), indices));
+
+ std::vector<GLuint> dataDepth;
+ dataDepth.resize(width * height);
+ GLuint* dataDepthPtr = dataDepth.data();
+
+ gl.readPixels(0, 0, width, height, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, (GLvoid*)dataDepthPtr);
+ for (int x = widthCommitted; x < width; ++x)
+ for (int y = 0; y < height; ++y)
+ {
+ if (dataDepthPtr[x + y * width] != 0xFFFFFFFF)
+ {
+ gl.disable(GL_DEPTH_BOUNDS_TEST_EXT);
+ return false;
+ }
+ }
+
+ gl.disable(GL_DEPTH_BOUNDS_TEST_EXT);
+ return true;
+}
+
+/** Constructor.
+ *
+ * @param context Rendering context.
+ */
+SparseTexture2Tests::SparseTexture2Tests(deqp::Context& context)
+ : TestCaseGroup(context, "sparse_texture2_tests", "Verify conformance of CTS_ARB_sparse_texture2 implementation")
+{
+}
+
+/** Initializes the test group contents. */
+void SparseTexture2Tests::init()
+{
+ addChild(new StandardPageSizesTestCase(m_context));
+ addChild(new SparseTexture2AllocationTestCase(m_context));
+ addChild(new SparseTexture2CommitmentTestCase(m_context));
+ addChild(new UncommittedRegionsAccessTestCase(m_context));
+}
+
} /* gl4cts namespace */
* \file gl4cSparseTexture2Tests.hpp
* \brief Conformance tests for the GL_ARB_sparse_texture2 functionality.
*/ /*-------------------------------------------------------------------*/
+
#include "glcTestCase.hpp"
#include "glwDefs.hpp"
#include "tcuDefs.hpp"
#include <map>
#include <vector>
+#include "gl4cSparseTextureTests.hpp"
+#include "gluDrawUtil.hpp"
+#include "gluShaderProgram.hpp"
#include "gluTextureUtil.hpp"
#include "tcuTextureUtil.hpp"
-#include "gl4cSparseTextureTests.hpp"
+using namespace glw;
+using namespace glu;
namespace gl4cts
{
struct PageSizeStruct
{
- glw::GLint xSize;
- glw::GLint ySize;
- glw::GLint zSize;
+ GLint xSize;
+ GLint ySize;
+ GLint zSize;
PageSizeStruct() : xSize(0), ySize(0), zSize(0)
{
}
- PageSizeStruct(glw::GLint x, glw::GLint y, glw::GLint z) : xSize(x), ySize(y), zSize(z)
+ PageSizeStruct(GLint x, GLint y, GLint z) : xSize(x), ySize(y), zSize(z)
{
}
};
-typedef std::pair<glw::GLint, PageSizeStruct> PageSizePair;
+typedef std::pair<GLint, PageSizeStruct> PageSizePair;
+
+struct TokenStrings
+{
+ std::string format;
+ std::string pointType;
+ std::string pointDef;
+ std::string outImageType;
+ std::string inImageType;
+ std::string inColorType;
+ std::string inColorExpected;
+ std::string inEmptyColor;
+ std::string epsilon;
+ std::string sampleDef;
+};
/** Test verifies if values returned by GetInternalFormat* query matches Standard Virtual Page Sizes for <pname>:
* - VIRTUAL_PAGE_SIZE_X_ARB,
private:
/* Private methods */
- std::vector<glw::GLint> mSupportedTargets;
- std::map<glw::GLint, PageSizeStruct> mStandardVirtualPageSizesTable;
+ std::vector<GLint> mSupportedTargets;
+ std::map<GLint, PageSizeStruct> mStandardVirtualPageSizesTable;
/* Private members */
};
/* Public methods */
SparseTexture2AllocationTestCase(deqp::Context& context);
- virtual void init();
- //virtual tcu::TestNode::IterateResult iterate();
+ virtual void init();
+ virtual tcu::TestNode::IterateResult iterate();
+
+private:
+ /* Private methods */
+};
+
+/** Test verifies glTexPageCommitmentARB functionality added by ARB_sparse_texture2 extension
+ **/
+class SparseTexture2CommitmentTestCase : public SparseTextureCommitmentTestCase
+{
+public:
+ /* Public methods */
+ SparseTexture2CommitmentTestCase(deqp::Context& context);
+
+ SparseTexture2CommitmentTestCase(deqp::Context& context, const char* name, const char* description);
+
+ virtual void init();
+ virtual tcu::TestNode::IterateResult iterate();
+
+protected:
+ /* Protected members */
+
+ /* Protected methods */
+ TokenStrings setupShaderTokens(GLint target, GLint format, GLint sample);
+
+ virtual bool caseAllowed(GLint target, GLint format);
+
+ virtual bool sparseAllocateTexture(const Functions& gl, GLint target, GLint format, GLuint& texture, GLint levels);
+ virtual bool allocateTexture(const Functions& gl, GLint target, GLint format, GLuint& texture, GLint levels);
+ virtual bool writeDataToTexture(const Functions& gl, GLint target, GLint format, GLuint& texture, GLint level);
+ virtual bool verifyTextureData(const Functions& gl, GLint target, GLint format, GLuint& texture, GLint level);
+};
+
+/** Test verifies if access to uncommitted regions of sparse texture works as expected
+ **/
+class UncommittedRegionsAccessTestCase : public SparseTexture2CommitmentTestCase
+{
+public:
+ /* Public methods */
+ UncommittedRegionsAccessTestCase(deqp::Context& context);
+
+ virtual void init();
+ virtual tcu::TestNode::IterateResult iterate();
private:
+ /* Private members */
+ GLuint mFramebuffer;
+ GLuint mRenderbuffer;
+
/* Private methods */
+ bool readsAllowed(GLint target, GLint format, bool shaderOnly = false);
+ bool atomicAllowed(GLint target, GLint format);
+ bool depthStencilAllowed(GLint target, GLint format);
+
+ bool UncommittedReads(const Functions& gl, GLint target, GLint format, GLuint& texture, GLint level);
+ bool UncommittedAtomicOperations(const Functions& gl, GLint target, GLint format, GLuint& texture, GLint level);
+ bool UncommittedDepthStencil(const Functions& gl, GLint target, GLint format, GLuint& texture, GLint level);
+
+ void prepareDepthStencilFramebuffer(const Functions& gl, GLint width, GLint height);
+ void cleanupDepthStencilFramebuffer(const Functions& gl);
+ bool verifyTextureDataExtended(const Functions& gl, GLint target, GLint format, GLuint& texture, GLint level,
+ bool shaderOnly = false);
+ bool verifyAtomicOperations(const Functions& gl, GLint target, GLint format, GLuint& texture, GLint level);
+ bool verifyStencilTest(const Functions& gl, ShaderProgram& program, GLint width, GLint height,
+ GLint widthCommitted);
+ bool verifyDepthTest(const Functions& gl, ShaderProgram& program, GLint width, GLint height, GLint widthCommitted);
+ bool verifyDepthBoundsTest(const Functions& gl, ShaderProgram& program, GLint width, GLint height,
+ GLint widthCommitted);
};
/** Test group which encapsulates all sparse texture conformance tests */
#include "glwFunctions.hpp"
#include "tcuTestLog.hpp"
+#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <string.h>
*
* @return Returns true if queried value is as expected, returns false otherwise
*/
-bool SparseTextureUtils::verifyQueryError(tcu::TestContext& testCtx, const char* funcName, GLint target, GLint pname,
+bool SparseTextureUtils::verifyQueryError(std::stringstream& log, const char* funcName, GLint target, GLint pname,
GLint error, GLint expectedError)
{
if (error != expectedError)
{
- testCtx.getLog() << tcu::TestLog::Message << funcName << " return wrong error code"
- << ", target: " << target << ", pname: " << pname << ", expected: " << expectedError
- << ", returned: " << error << tcu::TestLog::EndMessage;
+ log << "QueryError [" << funcName << " return wrong error code"
+ << ", target: " << target << ", pname: " << pname << ", expected: " << expectedError
+ << ", returned: " << error << "] - ";
return false;
}
*
* @return Returns true if queried value is as expected, returns false otherwise
*/
-bool SparseTextureUtils::verifyError(tcu::TestContext& testCtx, const char* funcName, GLint error, GLint expectedError)
+bool SparseTextureUtils::verifyError(std::stringstream& log, const char* funcName, GLint error, GLint expectedError)
{
if (error != expectedError)
{
- testCtx.getLog() << tcu::TestLog::Message << funcName << " return wrong error code "
- << ", expectedError: " << expectedError << ", returnedError: " << error
- << tcu::TestLog::EndMessage;
+ log << "Error [" << funcName << " return wrong error code "
+ << ", expectedError: " << expectedError << ", returnedError: " << error << "] - ";
return false;
}
{
GLint depth;
- if (target == GL_TEXTURE_3D || target == GL_TEXTURE_2D_ARRAY || target == GL_TEXTURE_CUBE_MAP_ARRAY)
+ if (target == GL_TEXTURE_3D || target == GL_TEXTURE_2D_ARRAY || target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY ||
+ target == GL_TEXTURE_CUBE_MAP)
{
- depth = 6;
+ depth = 1;
}
+ else if (target == GL_TEXTURE_CUBE_MAP_ARRAY)
+ depth = 6;
else
- depth = 1;
+ depth = 0;
return depth;
}
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);
+ height = state.height / (int)pow(2, level);
+
+ if (target == GL_TEXTURE_3D || target == GL_TEXTURE_2D_ARRAY || target == GL_TEXTURE_CUBE_MAP_ARRAY)
+ {
+ depth = state.depth / (int)pow(2, level);
+ }
+ else
+ depth = 1;
+}
+
/* Texture static fields */
const GLuint Texture::m_invalid_id = -1;
case GL_TEXTURE_CUBE_MAP:
gl.texStorage2D(target, levels, internal_format, width, height);
break;
- case GL_TEXTURE_2D_MULTISAMPLE:
- gl.texStorage2DMultisample(target, levels, internal_format, width, height, GL_FALSE);
- 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
*/
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;
{
const GLint& target = *iter;
+ mLog.str("");
+
Texture::Generate(gl, texture);
Texture::Bind(gl, texture, target);
if (!result)
{
- m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail on positive tests");
+ m_testCtx.getLog() << tcu::TestLog::Message << mLog.str() << "Fail [positive tests]"
+ << tcu::TestLog::EndMessage;
+ m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
return STOP;
}
}
{
const GLint& target = *iter;
+ mLog.str("");
+
Texture::Generate(gl, texture);
Texture::Bind(gl, texture, target);
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;
}
GLuint testValueUInt;
GLfloat testValueFloat;
- m_testCtx.getLog() << tcu::TestLog::Message << "Testing TEXTURE_SPARSE_ARB for target: " << target
- << ", expected error: " << expectedError << tcu::TestLog::EndMessage;
+ mLog << "Testing TEXTURE_SPARSE_ARB for target: " << target << " - ";
//Check getTexParameter* default value
if (expectedError == GL_NO_ERROR)
GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred.");
}
else
- result = SparseTextureUtils::verifyQueryError(m_testCtx, "glTexParameteri", target, pname, gl.getError(),
+ result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameteri", target, pname, gl.getError(),
expectedError);
}
GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred.");
}
else
- result = SparseTextureUtils::verifyQueryError(m_testCtx, "glTexParameterf", target, pname, gl.getError(),
+ result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterf", target, pname, gl.getError(),
expectedError);
}
GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred.");
}
else
- result = SparseTextureUtils::verifyQueryError(m_testCtx, "glTexParameteriv", target, pname, gl.getError(),
+ result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameteriv", target, pname, gl.getError(),
expectedError);
}
GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred.");
}
else
- result = SparseTextureUtils::verifyQueryError(m_testCtx, "glTexParameterfv", target, pname, gl.getError(),
+ result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterfv", target, pname, gl.getError(),
expectedError);
}
GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred.");
}
else
- result = SparseTextureUtils::verifyQueryError(m_testCtx, "glTexParameterIiv", target, pname, gl.getError(),
+ result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterIiv", target, pname, gl.getError(),
expectedError);
}
GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred.");
}
else
- result = SparseTextureUtils::verifyQueryError(m_testCtx, "glTexParameterIuiv", target, pname, gl.getError(),
+ result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterIuiv", target, pname, gl.getError(),
expectedError);
}
GLuint testValueUInt;
GLfloat testValueFloat;
- m_testCtx.getLog() << tcu::TestLog::Message << "Testing VIRTUAL_PAGE_SIZE_INDEX_ARB for target: " << target
- << ", expected error: " << expectedError << tcu::TestLog::EndMessage;
+ mLog << "Testing VIRTUAL_PAGE_SIZE_INDEX_ARB for target: " << target << " - ";
//Check getTexParameter* default value
if (expectedError == GL_NO_ERROR)
GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred");
}
else
- result = SparseTextureUtils::verifyQueryError(m_testCtx, "glTexParameteri", target, pname, gl.getError(),
+ result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameteri", target, pname, gl.getError(),
expectedError);
}
GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred");
}
else
- result = SparseTextureUtils::verifyQueryError(m_testCtx, "glTexParameterf", target, pname, gl.getError(),
+ result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterf", target, pname, gl.getError(),
expectedError);
}
GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred");
}
else
- result = SparseTextureUtils::verifyQueryError(m_testCtx, "glTexParameteriv", target, pname, gl.getError(),
+ result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameteriv", target, pname, gl.getError(),
expectedError);
}
GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred");
}
else
- result = SparseTextureUtils::verifyQueryError(m_testCtx, "glTexParameterfv", target, pname, gl.getError(),
+ result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterfv", target, pname, gl.getError(),
expectedError);
}
GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred");
}
else
- result = SparseTextureUtils::verifyQueryError(m_testCtx, "glTexParameterIiv", target, pname, gl.getError(),
+ result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterIiv", target, pname, gl.getError(),
expectedError);
}
GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri error occurred");
}
else
- result = SparseTextureUtils::verifyQueryError(m_testCtx, "glTexParameterIuiv", target, pname, gl.getError(),
+ result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterIuiv", target, pname, gl.getError(),
expectedError);
}
{
const GLint pname = GL_NUM_SPARSE_LEVELS_ARB;
+ bool result = true;
+
GLint value_int;
GLuint value_uint;
GLfloat value_float;
- m_testCtx.getLog() << tcu::TestLog::Message << "Testing NUM_SPARSE_LEVELS_ARB for target: " << target
- << tcu::TestLog::EndMessage;
+ mLog << "Testing NUM_SPARSE_LEVELS_ARB for target: " << target << " - ";
gl.getTexParameteriv(target, pname, &value_int);
- GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexParameteriv error occurred");
+ result = SparseTextureUtils::verifyError(mLog, "glGetTexParameteriv", gl.getError(), GL_NO_ERROR);
- gl.getTexParameterfv(target, pname, &value_float);
- GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexParameterfv error occurred");
+ if (result)
+ {
+ gl.getTexParameterfv(target, pname, &value_float);
+ result = SparseTextureUtils::verifyError(mLog, "glGetTexParameterfv", gl.getError(), GL_NO_ERROR);
- gl.getTexParameterIiv(target, pname, &value_int);
- GLU_EXPECT_NO_ERROR(gl.getError(), "glGetGexParameterIiv error occurred");
+ if (result)
+ {
+ gl.getTexParameterIiv(target, pname, &value_int);
+ result = SparseTextureUtils::verifyError(mLog, "glGetGexParameterIiv", gl.getError(), GL_NO_ERROR);
- gl.getTexParameterIuiv(target, pname, &value_uint);
- GLU_EXPECT_NO_ERROR(gl.getError(), "glGetGexParameterIui error occurred");
+ if (result)
+ {
+ gl.getTexParameterIuiv(target, pname, &value_uint);
+ result = SparseTextureUtils::verifyError(mLog, "getTexParameterIuiv", gl.getError(), GL_NO_ERROR);
+ }
+ }
+ }
- return true;
+ return result;
}
/** Checking if getTexParameter* for binded texture returns value as expected
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)
{
- m_testCtx.getLog() << tcu::TestLog::Message << "glGetTexParameteriv return wrong value"
- << ", target: " << target << ", pname: " << pname << ", expected: " << expected
- << ", returned: " << value_int << tcu::TestLog::EndMessage;
+ mLog << "glGetTexParameteriv return wrong value"
+ << ", target: " << target << ", pname: " << pname << ", expected: " << expected
+ << ", returned: " << value_int << " - ";
result = false;
}
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexParameterfv error occurred");
if ((GLint)value_float != expected)
{
- m_testCtx.getLog() << tcu::TestLog::Message << "glGetTexParameterfv return wrong value"
- << ", target: " << target << ", pname: " << pname << ", expected: " << expected
- << ", returned: " << (GLint)value_float << tcu::TestLog::EndMessage;
+ mLog << "glGetTexParameterfv return wrong value"
+ << ", target: " << target << ", pname: " << pname << ", expected: " << expected
+ << ", returned: " << (GLint)value_float << " - ";
result = false;
}
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetGexParameterIiv error occurred");
if (value_int != expected)
{
- m_testCtx.getLog() << tcu::TestLog::Message << "glGetGexParameterIiv return wrong value"
- << ", target: " << target << ", pname: " << pname << ", expected: " << expected
- << ", returned: " << value_int << tcu::TestLog::EndMessage;
+ mLog << "glGetGexParameterIiv return wrong value"
+ << ", target: " << target << ", pname: " << pname << ", expected: " << expected
+ << ", returned: " << value_int << " - ";
result = false;
}
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetGexParameterIui error occurred");
if ((GLint)value_uint != expected)
{
- m_testCtx.getLog() << tcu::TestLog::Message << "glGetGexParameterIui return wrong value"
- << ", target: " << target << ", pname: " << pname << ", expected: " << expected
- << ", returned: " << (GLint)value_uint << tcu::TestLog::EndMessage;
+ mLog << "glGetGexParameterIui return wrong value"
+ << ", target: " << target << ", pname: " << pname << ", expected: " << expected
+ << ", returned: " << (GLint)value_uint << " - ";
result = false;
}
*/
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;
- m_testCtx.getLog() << tcu::TestLog::Message << "Testing getInternalformativ" << tcu::TestLog::EndMessage;
+ mLog << "Testing getInternalformativ - ";
for (std::vector<glw::GLint>::const_iterator iter = mSupportedTargets.begin(); iter != mSupportedTargets.end();
++iter)
GLU_EXPECT_NO_ERROR(gl.getError(), "getInternalformativ error occurred for GL_NUM_VIRTUAL_PAGE_SIZES_ARB");
if (value == 0)
{
- m_testCtx.getLog() << tcu::TestLog::Message
- << "getInternalformativ for GL_NUM_VIRTUAL_PAGE_SIZES_ARB, target: " << target
- << ", format: " << format << " returns wrong value: " << value
- << tcu::TestLog::EndMessage;
+ mLog << "getInternalformativ for GL_NUM_VIRTUAL_PAGE_SIZES_ARB, target: " << target
+ << ", format: " << format << " returns wrong value: " << value << " - ";
result = false;
}
}
else
{
+ m_testCtx.getLog() << tcu::TestLog::Message << mLog.str() << "Fail" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
return STOP;
}
*/
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);
void SimpleQueriesTestCase::testSipmleQueries(const Functions& gl, GLint pname)
{
- m_testCtx.getLog() << tcu::TestLog::Message << "Testing simple queries for pname: " << pname
- << tcu::TestLog::EndMessage;
+ std::stringstream log;
+ log << "Testing simple query for pname: " << pname << " - ";
+
+ bool result = true;
GLint value_int;
GLint64 value_int64;
GLboolean value_bool;
gl.getIntegerv(pname, &value_int);
- GLU_EXPECT_NO_ERROR(gl.getError(), "getIntegerv error occurred");
+ result = SparseTextureUtils::verifyError(log, "getIntegerv", gl.getError(), GL_NO_ERROR);
- gl.getInteger64v(pname, &value_int64);
- GLU_EXPECT_NO_ERROR(gl.getError(), "getInteger64v error occurred");
+ if (result)
+ {
+ gl.getInteger64v(pname, &value_int64);
+ result = SparseTextureUtils::verifyError(log, "getInteger64v", gl.getError(), GL_NO_ERROR);
- gl.getFloatv(pname, &value_float);
- GLU_EXPECT_NO_ERROR(gl.getError(), "getFloatv error occurred");
+ if (result)
+ {
+ gl.getFloatv(pname, &value_float);
+ result = SparseTextureUtils::verifyError(log, "getFloatv", gl.getError(), GL_NO_ERROR);
- gl.getDoublev(pname, &value_double);
- GLU_EXPECT_NO_ERROR(gl.getError(), "getDoublev error occurred");
+ 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);
+ }
+ }
+ }
+ }
- gl.getBooleanv(pname, &value_bool);
- GLU_EXPECT_NO_ERROR(gl.getError(), "getBooleanv error occurred");
+ if (!result)
+ {
+ TCU_FAIL(log.str().c_str());
+ }
}
/** Constructor.
*/
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;
{
const GLint& format = *formIter;
- m_testCtx.getLog() << tcu::TestLog::Message << "Testing sparse texture allocation for target: " << target
- << ", format: " << format << tcu::TestLog::EndMessage;
-
- positiveTesting(gl, target, format);
+ mLog.str("");
+ mLog << "Testing sparse texture allocation for target: " << target << ", format: " << format << " - ";
- result = verifyTexParameterErrors(gl, target, 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;
}
{
const GLint& format = *formIter;
- m_testCtx.getLog() << tcu::TestLog::Message << "Testing sparse texture allocation for target: " << target
- << ", format: " << format << tcu::TestLog::EndMessage;
+ mLog.str("");
+ mLog << "Testing sparse texture allocation for target [full array]: " << target << ", format: " << format
+ << " - ";
result = 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;
}
* @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.
**/
-void SparseTextureAllocationTestCase::positiveTesting(const Functions& gl, GLint target, GLint format)
+bool SparseTextureAllocationTestCase::positiveTesting(const Functions& gl, GLint target, GLint format)
{
+ mLog << "Positive Testing - ";
+
GLuint texture;
Texture::Generate(gl, texture);
SparseTextureUtils::getTexturePageSizes(gl, target, format, pageSizeX, pageSizeY, pageSizeZ);
gl.texParameteri(target, GL_TEXTURE_SPARSE_ARB, GL_TRUE);
- GLU_EXPECT_NO_ERROR(gl.getError(), "texParameteri error occurred for GL_TEXTURE_SPARSE_ARB");
+ 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)
}
Texture::Storage(gl, target, 1, format, pageSizeX, pageSizeY, depth * pageSizeZ);
- GLU_EXPECT_NO_ERROR(gl.getError(), "TexStorage");
+ 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.
*/
bool SparseTextureAllocationTestCase::verifyTexParameterErrors(const Functions& gl, GLint target, GLint format)
{
+ mLog << "Verify TexParameter errors - ";
+
bool result = true;
GLuint texture;
depth = SparseTextureUtils::getTargetDepth(target);
Texture::Storage(gl, target, 1, format, 8, 8, depth);
- GLU_EXPECT_NO_ERROR(gl.getError(), "TexStorage");
+ 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);
- GLU_EXPECT_NO_ERROR(gl.getError(), "getTexParameteriv error occurred for GL_TEXTURE_IMMUTABLE_FORMAT");
+ 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)
if (result)
{
gl.texParameteri(target, param.first, param.second);
- result = SparseTextureUtils::verifyQueryError(m_testCtx, "glTexParameteri", target, param.first,
+ 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(m_testCtx, "glTexParameterf", target, param.first,
+ result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterf", target, param.first,
gl.getError(), GL_INVALID_OPERATION);
}
{
GLint value = param.second;
gl.texParameteriv(target, param.first, &value);
- result = SparseTextureUtils::verifyQueryError(m_testCtx, "glTexParameteriv", target, param.first,
+ result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameteriv", target, param.first,
gl.getError(), GL_INVALID_OPERATION);
}
{
GLfloat value = (GLfloat)param.second;
gl.texParameterfv(target, param.first, &value);
- result = SparseTextureUtils::verifyQueryError(m_testCtx, "glTexParameterfv", target, param.first,
+ result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterfv", target, param.first,
gl.getError(), GL_INVALID_OPERATION);
}
{
GLint value = param.second;
gl.texParameterIiv(target, param.first, &value);
- result = SparseTextureUtils::verifyQueryError(m_testCtx, "glTexParameterIiv", target, param.first,
+ result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterIiv", target, param.first,
gl.getError(), GL_INVALID_OPERATION);
}
{
GLuint value = param.second;
gl.texParameterIuiv(target, param.first, &value);
- result = SparseTextureUtils::verifyQueryError(m_testCtx, "glTexParameterIuiv", target, param.first,
+ result = SparseTextureUtils::verifyQueryError(mLog, "glTexParameterIuiv", target, param.first,
gl.getError(), GL_INVALID_OPERATION);
}
}
}
Texture::Delete(gl, texture);
-
return result;
}
bool SparseTextureAllocationTestCase::verifyTexStorageVirtualPageSizeIndexError(const Functions& gl, GLint target,
GLint format)
{
- bool result = true;
+ mLog << "Verify VirtualPageSizeIndex errors - ";
GLuint texture;
GLint depth;
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");
+ 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, sizeof(numPageSizes), &numPageSizes);
- GLU_EXPECT_NO_ERROR(gl.getError(), "getTexParameteriv error occurred for GL_NUM_VIRTUAL_PAGE_SIZES_ARB");
+ 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);
- GLU_EXPECT_NO_ERROR(gl.getError(), "texParameteri error occurred for GL_VIRTUAL_PAGE_SIZE_INDEX_ARB");
+ 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);
- result = SparseTextureUtils::verifyError(m_testCtx, "TexStorage", gl.getError(), GL_INVALID_OPERATION);
+ if (!SparseTextureUtils::verifyError(mLog, "TexStorage", gl.getError(), GL_NO_ERROR))
+ {
+ Texture::Delete(gl, texture);
+ return false;
+ }
Texture::Delete(gl, texture);
-
- return result;
+ return true;
}
/** Verifies if texStorage* generate proper errors for given target and internal format and
bool SparseTextureAllocationTestCase::verifyTexStorageFullArrayCubeMipmapsError(const Functions& gl, GLint target,
GLint format)
{
+ mLog << "Verify FullArrayCubeMipmaps errors - ";
+
bool result = true;
GLuint texture;
GLboolean fullArrayCubeMipmaps;
gl.getBooleanv(GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB, &fullArrayCubeMipmaps);
- GLU_EXPECT_NO_ERROR(gl.getError(), "getBooleanv error occurred for GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB");
+ 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)
{
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");
+ if (!SparseTextureUtils::verifyQueryError(mLog, "texParameteri", target, GL_TEXTURE_SPARSE_ARB,
+ gl.getError(), GL_NO_ERROR))
+ return false;
Texture::Storage(gl, target, 1, format, 8, 8, depth);
- result =
- SparseTextureUtils::verifyError(m_testCtx, "TexStorage [case 1]", gl.getError(), GL_INVALID_OPERATION);
-
- Texture::Delete(gl, texture);
-
- // Case 2: test wrong texture size
- if (result)
+ if (!SparseTextureUtils::verifyError(mLog, "TexStorage [sparse texture]", gl.getError(),
+ GL_INVALID_OPERATION))
{
- Texture::Generate(gl, texture);
- Texture::Bind(gl, texture, target);
+ Texture::Delete(gl, texture);
+ return false;
+ }
- GLint pageSizeX;
- GLint pageSizeY;
- GLint pageSizeZ;
- SparseTextureUtils::getTexturePageSizes(gl, target, format, pageSizeX, pageSizeY, pageSizeZ);
+ // Case 2: test wrong texture size
+ Texture::Generate(gl, texture);
+ Texture::Bind(gl, texture, target);
- GLint levels = 4;
- GLint width = pageSizeX * (int)pow(2, levels - 1);
- GLint height = pageSizeY * (int)pow(2, levels - 1);
+ GLint pageSizeX;
+ GLint pageSizeY;
+ GLint pageSizeZ;
+ SparseTextureUtils::getTexturePageSizes(gl, target, format, pageSizeX, pageSizeY, pageSizeZ);
- // Check 2 different cases:
- // 1) wrong width
- // 2) wrong height
- Texture::Storage(gl, target, levels, format, width + pageSizeX, height, depth);
- result = SparseTextureUtils::verifyError(m_testCtx, "TexStorage [case 2 wrong width]", gl.getError(),
- GL_INVALID_OPERATION);
+ GLint levels = 4;
+ GLint width = pageSizeX * (int)pow(2, levels - 1);
+ GLint height = pageSizeY * (int)pow(2, levels - 1);
- if (result)
- {
- Texture::Storage(gl, target, levels, format, width, height + pageSizeY, depth);
- result = SparseTextureUtils::verifyError(m_testCtx, "TexStorage [case 2 wrong height]",
- gl.getError(), GL_INVALID_OPERATION);
- }
+ // Check 2 different cases:
+ // 1) wrong width
+ // 2) wrong height
+ Texture::Storage(gl, target, levels, format, width + pageSizeX, height, depth);
+ result =
+ SparseTextureUtils::verifyError(mLog, "TexStorage [wrong width]", gl.getError(), GL_INVALID_OPERATION);
- Texture::Delete(gl, texture);
+ 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);
}
else
{
else
Texture::Storage(gl, target, 1, format, 8, 8, depth);
- result =
- SparseTextureUtils::verifyError(m_testCtx, "TexStorage [case 3]", gl.getError(), GL_INVALID_OPERATION);
+ result = SparseTextureUtils::verifyError(mLog, "TexStorage [case 3]", gl.getError(), GL_INVALID_OPERATION);
Texture::Delete(gl, texture);
}
bool SparseTextureAllocationTestCase::verifyTexStorageInvalidValueErrors(const Functions& gl, GLint target,
GLint format)
{
+ mLog << "Verify Invalid Value errors - ";
+
GLuint texture;
GLint pageSizeX;
GLint pageSizeY;
GLint max3DTextureSize;
gl.getIntegerv(GL_MAX_SPARSE_3D_TEXTURE_SIZE_ARB, &max3DTextureSize);
- GLU_EXPECT_NO_ERROR(gl.getError(), "getIntegeriv error occurred for GL_MAX_SPARSE_3D_TEXTURE_SIZE_ARB");
+ 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(m_testCtx, "TexStorage [GL_TEXTURE_3D wrong width]", gl.getError(),
+ if (!SparseTextureUtils::verifyError(mLog, "TexStorage [GL_TEXTURE_3D wrong width]", gl.getError(),
GL_INVALID_VALUE))
{
Texture::Delete(gl, texture);
}
Texture::Storage(gl, target, 1, format, width, height + max3DTextureSize, depth);
- if (!SparseTextureUtils::verifyError(m_testCtx, "TexStorage [GL_TEXTURE_3D wrong height]", gl.getError(),
+ if (!SparseTextureUtils::verifyError(mLog, "TexStorage [GL_TEXTURE_3D wrong height]", gl.getError(),
GL_INVALID_VALUE))
{
Texture::Delete(gl, texture);
}
Texture::Storage(gl, target, 1, format, width, height, depth + max3DTextureSize);
- if (!SparseTextureUtils::verifyError(m_testCtx, "TexStorage [GL_TEXTURE_3D wrong depth]", gl.getError(),
+ if (!SparseTextureUtils::verifyError(mLog, "TexStorage [GL_TEXTURE_3D wrong depth]", gl.getError(),
GL_INVALID_VALUE))
{
Texture::Delete(gl, texture);
GLint maxTextureSize;
gl.getIntegerv(GL_MAX_SPARSE_TEXTURE_SIZE_ARB, &maxTextureSize);
- GLU_EXPECT_NO_ERROR(gl.getError(), "getIntegeriv error occurred for GL_MAX_SPARSE_TEXTURE_SIZE_ARB");
+ 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(m_testCtx, "TexStorage [!GL_TEXTURE_3D wrong width]", gl.getError(),
+ if (!SparseTextureUtils::verifyError(mLog, "TexStorage [!GL_TEXTURE_3D wrong width]", gl.getError(),
GL_INVALID_VALUE))
{
Texture::Delete(gl, texture);
}
Texture::Storage(gl, target, 1, format, width, height + maxTextureSize, depth);
- if (!SparseTextureUtils::verifyError(m_testCtx, "TexStorage [!GL_TEXTURE_3D wrong height]", gl.getError(),
+ if (!SparseTextureUtils::verifyError(mLog, "TexStorage [!GL_TEXTURE_3D wrong height]", gl.getError(),
GL_INVALID_VALUE))
{
Texture::Delete(gl, texture);
GLint maxArrayTextureLayers;
gl.getIntegerv(GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB, &maxArrayTextureLayers);
- GLU_EXPECT_NO_ERROR(gl.getError(), "getIntegeriv error occurred for GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB");
+ 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)
{
Texture::Storage(gl, target, 1, format, width, height + maxArrayTextureLayers, 0);
- if (!SparseTextureUtils::verifyError(m_testCtx, "TexStorage [ARRAY wrong height]", gl.getError(),
+ if (!SparseTextureUtils::verifyError(mLog, "TexStorage [ARRAY wrong height]", gl.getError(),
GL_INVALID_VALUE))
{
Texture::Delete(gl, texture);
else if ((target == GL_TEXTURE_2D_ARRAY || target == GL_TEXTURE_CUBE_MAP_ARRAY))
{
Texture::Storage(gl, target, 1, format, width, height, depth + maxArrayTextureLayers);
- if (!SparseTextureUtils::verifyError(m_testCtx, "TexStorage [ARRAY wrong depth]", gl.getError(),
+ if (!SparseTextureUtils::verifyError(mLog, "TexStorage [ARRAY wrong depth]", gl.getError(),
GL_INVALID_VALUE))
{
Texture::Delete(gl, texture);
if (pageSizeX > 1)
{
Texture::Storage(gl, target, 1, format, 1, height, depth);
- if (!SparseTextureUtils::verifyError(m_testCtx, "TexStorage [wrong width]", gl.getError(),
- GL_INVALID_VALUE))
+ 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, 1, depth);
- if (!SparseTextureUtils::verifyError(m_testCtx, "TexStorage [wrong height]", gl.getError(),
- GL_INVALID_VALUE))
+ 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, SparseTextureUtils::getTargetDepth(target));
- if (!SparseTextureUtils::verifyError(m_testCtx, "TexStorage [wrong depth]", gl.getError(),
- GL_INVALID_VALUE))
+ if (!SparseTextureUtils::verifyError(mLog, "TexStorage [wrong depth]", gl.getError(), GL_INVALID_VALUE))
{
Texture::Delete(gl, texture);
return false;
SparseTextureCommitmentTestCase::SparseTextureCommitmentTestCase(deqp::Context& context)
: TestCase(context, "SparseTextureCommitment",
"Verifies TexPageCommitmentARB functionality added in CTS_ARB_sparse_texture")
- , mWidthStored(0)
- , mHeightStored(0)
- , mDepthStored(0)
+ , mState()
{
/* Left blank intentionally */
}
*/
SparseTextureCommitmentTestCase::SparseTextureCommitmentTestCase(deqp::Context& context, const char* name,
const char* description)
- : TestCase(context, name, description), mWidthStored(0), mHeightStored(0), mDepthStored(0)
+ : TestCase(context, name, description), mState()
{
/* Left blank intentionally */
}
-/** Initializes the test group contents. */
+/** Initializes the test case. */
void SparseTextureCommitmentTestCase::init()
{
mSupportedTargets.push_back(GL_TEXTURE_2D);
*/
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;
{
const GLint& format = *formIter;
- m_testCtx.getLog() << tcu::TestLog::Message << "Testing sparse texture commitment for target: " << target
- << ", format: " << format << tcu::TestLog::EndMessage;
+ 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);
- writeDataToTexture(gl, target, format, texture);
+ 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
- commitTexturePage(gl, target, format, texture);
- writeDataToTexture(gl, target, format, texture);
- result = verifyTextureData(gl, target, format, texture);
+ 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 = verifyInvalidOperationErrors(gl, target, format, texture) &&
- verifyInvalidValueErrors(gl, target, format, texture);
+ 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;
}
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
Texture::Generate(gl, texture);
Texture::Bind(gl, texture, target);
- GLint pageSizeX;
- GLint pageSizeY;
- GLint pageSizeZ;
- GLint minDepth = SparseTextureUtils::getTargetDepth(target);
- SparseTextureUtils::getTexturePageSizes(gl, target, format, pageSizeX, pageSizeY, pageSizeZ);
+ 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 (pageSizeX > pageSizeY)
- pageSizeY = pageSizeX;
- else if (pageSizeX < pageSizeY)
- pageSizeX = pageSizeY;
+ if (mState.pageSizeX > mState.pageSizeY)
+ mState.pageSizeY = mState.pageSizeX;
+ else if (mState.pageSizeX < mState.pageSizeY)
+ mState.pageSizeX = mState.pageSizeY;
}
- mWidthStored = 2 * pageSizeX;
- mHeightStored = 2 * pageSizeY;
- mDepthStored = minDepth * pageSizeZ;
+ mState.width = 2 * mState.pageSizeX;
+ mState.height = 2 * mState.pageSizeY;
+ mState.depth = mState.minDepth * mState.pageSizeZ;
- mTextureFormatStored = glu::mapGLInternalFormat(format);
+ mState.format = glu::mapGLInternalFormat(format);
return true;
}
* @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)
+ 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");
- Texture::Storage(gl, target, 1, format, mWidthStored, mHeightStored, mDepthStored);
+ // 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;
* @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)
+bool SparseTextureCommitmentTestCase::allocateTexture(const Functions& gl, GLint target, GLint format, GLuint& texture,
+ GLint levels)
{
+ mLog << "Allocate [levels: " << levels << "] - ";
+
prepareTexture(gl, target, format, texture);
- Texture::Storage(gl, target, 1, format, mWidthStored, mHeightStored, mDepthStored);
+ //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;
* @return Returns true if no error occurred, otherwise throws an exception.
*/
bool SparseTextureCommitmentTestCase::writeDataToTexture(const Functions& gl, GLint target, GLint format,
- GLuint& texture)
+ GLuint& texture, GLint level)
{
DE_UNREF(format);
DE_UNREF(texture);
- TransferFormat transferFormat = glu::getTransferFormat(mTextureFormatStored);
+ mLog << "Fill texture [level: " << level << "] - ";
- GLuint texSize = mWidthStored * mHeightStored * mDepthStored;
+ if (level > mState.levels - 1)
+ TCU_FAIL("Invalid level");
- GLubyte* data = (GLubyte*)malloc(texSize * mTextureFormatStored.getPixelSize());
+ TransferFormat transferFormat = glu::getTransferFormat(mState.format);
- deMemset(data, 128, texSize * mTextureFormatStored.getPixelSize());
+ GLint width;
+ GLint height;
+ GLint depth;
+ SparseTextureUtils::getTextureLevelSize(target, mState, level, width, height, depth);
- Texture::SubImage(gl, target, 0, 0, 0, 0, mWidthStored, mHeightStored, mDepthStored, transferFormat.format,
- transferFormat.dataType, (GLvoid*)data);
+ if (width > 0 && height > 0 && depth >= mState.minDepth)
+ {
+ GLint texSize = width * height * depth * mState.format.getPixelSize();
- GLU_EXPECT_NO_ERROR(gl.getError(), "SubImage");
+ std::vector<GLubyte> vecData;
+ vecData.resize(texSize);
+ GLubyte* data = vecData.data();
- free(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");
+
+ delete[] data;
+ }
return true;
}
* @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)
+ GLuint& texture, GLint level)
{
DE_UNREF(format);
DE_UNREF(texture);
- TransferFormat transferFormat = glu::getTransferFormat(mTextureFormatStored);
+ mLog << "Verify Texture [level: " << level << "] - ";
- GLuint texSize = mWidthStored * mHeightStored * mDepthStored;
+ if (level > mState.levels - 1)
+ TCU_FAIL("Invalid level");
- GLubyte* data = (GLubyte*)malloc(texSize * mTextureFormatStored.getPixelSize());
- GLubyte* out_data = (GLubyte*)malloc(texSize * mTextureFormatStored.getPixelSize());
+ TransferFormat transferFormat = glu::getTransferFormat(mState.format);
- deMemset(data, 128, texSize * mTextureFormatStored.getPixelSize());
+ GLint width;
+ GLint height;
+ GLint depth;
+ SparseTextureUtils::getTextureLevelSize(target, mState, level, width, height, depth);
- bool result = true;
+ //Committed region is limited to 1/2 of width
+ GLint widthCommitted = width / 2;
- GLint error = GL_NO_ERROR;
+ if (widthCommitted == 0 || height == 0 || depth < mState.minDepth)
+ return true;
+
+ bool result = true;
if (target != GL_TEXTURE_CUBE_MAP)
{
- deMemset(out_data, 255, texSize * mTextureFormatStored.getPixelSize());
+ GLint texSize = width * height * depth * mState.format.getPixelSize();
- gl.getTexImage(target, 0, transferFormat.format, transferFormat.dataType, (GLvoid*)out_data);
- error = gl.getError();
+ std::vector<GLubyte> vecExpData;
+ std::vector<GLubyte> vecOutData;
+ vecExpData.resize(texSize);
+ vecOutData.resize(texSize);
+ GLubyte* exp_data = vecExpData.data();
+ GLubyte* out_data = vecOutData.data();
- if (deMemCmp(out_data, data, texSize * mTextureFormatStored.getPixelSize()) != 0)
- result = false;
+ 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
{
subTargets.push_back(GL_TEXTURE_CUBE_MAP_POSITIVE_Z);
subTargets.push_back(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z);
- for (std::vector<glw::GLint>::const_iterator iter = subTargets.begin(); iter != subTargets.end(); ++iter)
+ 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)
{
- const GLint& subTarget = *iter;
+ GLint subTarget = subTargets[i];
- m_testCtx.getLog() << tcu::TestLog::Message << "Testing subTarget: " << subTarget
- << tcu::TestLog::EndMessage;
+ mLog << "Verify Subtarget [subtarget: " << subTarget << "] - ";
- deMemset(out_data, 255, texSize * mTextureFormatStored.getPixelSize());
+ deMemset(out_data, 255, texSize);
- gl.getTexImage(subTarget, 0, transferFormat.format, transferFormat.dataType, (GLvoid*)out_data);
- error = gl.getError();
+ Texture::GetData(gl, level, subTarget, transferFormat.format, transferFormat.dataType, (GLvoid*)out_data);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "Texture::GetData");
- if (deMemCmp(out_data, data, texSize * mTextureFormatStored.getPixelSize()) != 0)
- result = false;
+ //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 || error != GL_NO_ERROR)
+ if (!result)
break;
}
}
- GLU_EXPECT_NO_ERROR(error, "glGetTexImage");
-
- free(data);
- free(out_data);
-
return result;
}
* @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 no error occurred, otherwise throws an exception.
+ * @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)
+ GLuint& texture, GLint level)
{
- Texture::Bind(gl, texture, target);
+ 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 * mState.minDepth;
+
+ GLint widthCommitted = width / 2;
- texPageCommitment(gl, target, format, texture, 0, 0, 0, 0, mWidthStored, mHeightStored, mDepthStored, GL_TRUE);
+ 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 * mState.minDepth;
+
+ GLint widthCommitted = width / 2;
+ if (widthCommitted >= mState.pageSizeX && height >= mState.pageSizeY && 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 * mState.minDepth;
+
+ 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
bool SparseTextureCommitmentTestCase::verifyInvalidOperationErrors(const Functions& gl, GLint target, GLint format,
GLuint& texture)
{
- bool result = true;
+ mLog << "Verify INVALID_OPERATION Errors - ";
- GLint pageSizeX;
- GLint pageSizeY;
- GLint pageSizeZ;
- GLint minDepth = SparseTextureUtils::getTargetDepth(target);
- SparseTextureUtils::getTexturePageSizes(gl, target, format, pageSizeX, pageSizeY, pageSizeZ);
+ 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);
if (immutableFormat == GL_FALSE)
{
- texPageCommitment(gl, target, format, texture, 0, 0, 0, 0, mWidthStored, mHeightStored, mDepthStored, GL_TRUE);
- result =
- SparseTextureUtils::verifyError(m_testCtx, "texPageCommitment [A1]", gl.getError(), GL_INVALID_OPERATION);
+ 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);
+ allocateTexture(gl, target, format, texture, 1);
- texPageCommitment(gl, target, format, texture, 0, 0, 0, 0, mWidthStored, mHeightStored, mDepthStored, GL_TRUE);
- result = SparseTextureUtils::verifyError(m_testCtx, "texPageCommitment [A2]", gl.getError(), GL_INVALID_OPERATION);
+ 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);
+ sparseAllocateTexture(gl, target, format, texture, 1);
// Case 3 - commitment sizes greater than expected
- texPageCommitment(gl, target, format, texture, 0, 0, 0, 0, mWidthStored + pageSizeX, mHeightStored, mDepthStored,
- GL_TRUE);
- result = SparseTextureUtils::verifyError(m_testCtx, "texPageCommitment [A3]", gl.getError(), GL_INVALID_OPERATION);
+ 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, mWidthStored, mHeightStored + pageSizeY, mDepthStored,
- GL_TRUE);
- result = SparseTextureUtils::verifyError(m_testCtx, "texPageCommitment [A4]", gl.getError(), GL_INVALID_OPERATION);
+ 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, mWidthStored, mHeightStored,
- mDepthStored + pageSizeZ, GL_TRUE);
- result =
- SparseTextureUtils::verifyError(m_testCtx, "texPageCommitment [A5]", gl.getError(), GL_INVALID_OPERATION);
+ 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 (pageSizeX > 1)
+ if (mState.pageSizeX > 1)
{
- texPageCommitment(gl, target, format, texture, 0, 0, 0, 0, 1, mHeightStored, mDepthStored, GL_TRUE);
+ texPageCommitment(gl, target, format, texture, 0, 0, 0, 0, 1, mState.pageSizeY, mState.pageSizeZ, GL_TRUE);
result =
- SparseTextureUtils::verifyError(m_testCtx, "texPageCommitment [A6]", gl.getError(), GL_INVALID_OPERATION);
+ 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 (pageSizeY > 1)
+ if (mState.pageSizeY > 1)
{
- texPageCommitment(gl, target, format, texture, 0, 0, 0, 0, mWidthStored, 1, mDepthStored, GL_TRUE);
+ texPageCommitment(gl, target, format, texture, 0, 0, 0, 0, mState.pageSizeX, 1, mState.pageSizeZ, GL_TRUE);
result =
- SparseTextureUtils::verifyError(m_testCtx, "texPageCommitment [A7]", gl.getError(), GL_INVALID_OPERATION);
+ 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 (pageSizeZ > 1)
+ 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, mWidthStored, mHeightStored, minDepth, GL_TRUE);
- result = SparseTextureUtils::verifyError(m_testCtx, "texPageCommitment [A8]", gl.getError(),
- GL_INVALID_OPERATION);
+ 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;
}
bool SparseTextureCommitmentTestCase::verifyInvalidValueErrors(const Functions& gl, GLint target, GLint format,
GLuint& texture)
{
- bool result = true;
+ mLog << "Verify INVALID_VALUE Errors - ";
- GLint pageSizeX;
- GLint pageSizeY;
- GLint pageSizeZ;
- GLint minDepth = SparseTextureUtils::getTargetDepth(target);
- SparseTextureUtils::getTexturePageSizes(gl, target, format, pageSizeX, pageSizeY, pageSizeZ);
+ bool result = true;
- sparseAllocateTexture(gl, target, format, texture);
+ sparseAllocateTexture(gl, target, format, texture, 1);
- // Case 1 - commitment sizes greater than expected
- texPageCommitment(gl, target, format, texture, 0, 1, 0, 0, mWidthStored + pageSizeX, mHeightStored, minDepth,
+ // Case 1 - commitment offset not multiple of page size in corresponding dimension
+ texPageCommitment(gl, target, format, texture, 0, 1, 0, 0, mState.pageSizeX, mState.pageSizeY, mState.pageSizeZ,
GL_TRUE);
- result = SparseTextureUtils::verifyError(m_testCtx, "texPageCommitment [B1]", gl.getError(), GL_INVALID_VALUE);
+ 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;
- texPageCommitment(gl, target, format, texture, 0, 0, 1, 0, mWidthStored, mHeightStored + pageSizeY, minDepth,
+ texPageCommitment(gl, target, format, texture, 0, 0, 1, 0, mState.pageSizeX, mState.pageSizeY, mState.pageSizeZ,
GL_TRUE);
- result = SparseTextureUtils::verifyError(m_testCtx, "texPageCommitment [B2]", gl.getError(), GL_INVALID_VALUE);
+ 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)
{
- texPageCommitment(gl, target, format, texture, 0, 0, 0, minDepth, mWidthStored, mHeightStored,
- mDepthStored + pageSizeZ, GL_TRUE);
- result = SparseTextureUtils::verifyError(m_testCtx, "texPageCommitment [B3]", gl.getError(), GL_INVALID_VALUE);
+ 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;
}
*/
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.");
{
const GLint& format = *formIter;
- m_testCtx.getLog() << tcu::TestLog::Message
- << "Testing DSA sparse texture commitment for target: " << target
- << ", format: " << format << tcu::TestLog::EndMessage;
+ 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);
- commitTexturePage(gl, target, format, texture);
- writeDataToTexture(gl, target, format, texture);
- result = verifyTextureData(gl, target, format, texture);
+ 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 = verifyInvalidOperationErrors(gl, target, format, texture) &&
- verifyInvalidValueErrors(gl, target, format, texture);
+ 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;
}
* \file gl4cSparseTextureTests.hpp
* \brief Conformance tests for the GL_ARB_sparse_texture functionality.
*/ /*-------------------------------------------------------------------*/
+
#include "glcTestCase.hpp"
#include "glwDefs.hpp"
#include "glwEnums.hpp"
#include "tcuDefs.hpp"
+#include <sstream>
#include <vector>
#include "gluTextureUtil.hpp"
#include "tcuTextureUtil.hpp"
+using namespace glw;
+using namespace glu;
+
namespace gl4cts
{
+
+struct TextureState
+{
+ GLint width;
+ GLint height;
+ GLint depth;
+ GLint levels;
+ GLint samples;
+ tcu::TextureFormat format;
+
+ GLint minDepth;
+
+ GLint pageSizeX;
+ GLint pageSizeY;
+ GLint pageSizeZ;
+};
+
class SparseTextureUtils
{
public:
- static bool verifyQueryError(tcu::TestContext& testCtx, const char* funcName, glw::GLint target, glw::GLint pname,
- glw::GLint error, glw::GLint expectedError);
+ static bool verifyQueryError(std::stringstream& log, const char* funcName, GLint target, GLint pname, GLint error,
+ GLint expectedError);
- static bool verifyError(tcu::TestContext& testCtx, const char* funcName, glw::GLint error,
- glw::GLint expectedError);
+ static bool verifyError(std::stringstream& log, const char* funcName, GLint error, GLint expectedError);
- static glw::GLint getTargetDepth(glw::GLint target);
+ static GLint getTargetDepth(GLint target);
- static void getTexturePageSizes(const glw::Functions& gl, glw::GLint target, glw::GLint format,
- glw::GLint& pageSizeX, glw::GLint& pageSizeY, glw::GLint& pageSizeZ);
+ static void getTexturePageSizes(const Functions& gl, GLint target, GLint format, GLint& pageSizeX, GLint& pageSizeY,
+ GLint& pageSizeZ);
+
+ static void getTextureLevelSize(GLint target, TextureState& state, GLint level, GLint& width, GLint& height,
+ GLint& depth);
};
/** Represents texture static helper
public:
/* Public static routines */
/* Functionality */
- static void Bind(const glw::Functions& gl, glw::GLuint id, glw::GLenum target);
+ static void Bind(const Functions& gl, GLuint id, GLenum target);
+
+ static void Generate(const Functions& gl, GLuint& out_id);
- static void Generate(const glw::Functions& gl, glw::GLuint& out_id);
+ static void Delete(const Functions& gl, GLuint& id);
- static void Delete(const glw::Functions& gl, glw::GLuint& id);
+ static void Storage(const Functions& gl, GLenum target, GLsizei levels, GLenum internal_format, GLuint width,
+ GLuint height, GLuint depth);
- static void Storage(const glw::Functions& gl, glw::GLenum target, glw::GLsizei levels, glw::GLenum internal_format,
- glw::GLuint width, glw::GLuint height, glw::GLuint depth);
+ static void GetData(const Functions& gl, GLint level, GLenum target, GLenum format, GLenum type, GLvoid* out_data);
- static void 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);
+ static void SubImage(const Functions& gl, GLenum target, GLint level, GLint x, GLint y, GLint z, GLsizei width,
+ GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels);
/* Public fields */
- glw::GLuint m_id;
+ GLuint m_id;
/* Public constants */
- static const glw::GLuint m_invalid_id;
+ static const GLuint m_invalid_id;
};
/** Test verifies TexParameter{if}{v}, TexParameterI{u}v, GetTexParameter{if}v
private:
/* Private members */
- std::vector<glw::GLint> mSupportedTargets;
- std::vector<glw::GLint> mNotSupportedTargets;
+ std::stringstream mLog;
+
+ std::vector<GLint> mSupportedTargets;
+ std::vector<GLint> mNotSupportedTargets;
/* Private methods */
- bool testTextureSparseARB(const glw::Functions& gl, glw::GLint target, glw::GLint expectedError = GL_NO_ERROR);
- bool testVirtualPageSizeIndexARB(const glw::Functions& gl, glw::GLint target,
- glw::GLint expectedError = GL_NO_ERROR);
- bool testNumSparseLevelsARB(const glw::Functions& gl, glw::GLint target);
+ bool testTextureSparseARB(const Functions& gl, GLint target, GLint expectedError = GL_NO_ERROR);
+ bool testVirtualPageSizeIndexARB(const Functions& gl, GLint target, GLint expectedError = GL_NO_ERROR);
+ bool testNumSparseLevelsARB(const Functions& gl, GLint target);
- bool checkGetTexParameter(const glw::Functions& gl, glw::GLint target, glw::GLint pname, glw::GLint expected);
+ bool checkGetTexParameter(const Functions& gl, GLint target, GLint pname, GLint expected);
};
/** Test verifies GetInternalformativ query for formats from Table 8.12 and <pname>:
private:
/* Private methods */
- std::vector<glw::GLint> mSupportedTargets;
- std::vector<glw::GLint> mSupportedInternalFormats;
+ std::stringstream mLog;
+
+ std::vector<GLint> mSupportedTargets;
+ std::vector<GLint> mSupportedInternalFormats;
/* Private members */
};
private:
/* Private methods */
/* Private members */
- void testSipmleQueries(const glw::Functions& gl, glw::GLint pname);
+ void testSipmleQueries(const Functions& gl, GLint pname);
};
/** Test verifies glTexStorage* functionality added by ARB_sparse_texture extension
protected:
/* Protected methods */
- std::vector<glw::GLint> mSupportedTargets;
- std::vector<glw::GLint> mFullArrayTargets;
- std::vector<glw::GLint> mSupportedInternalFormats;
+ std::stringstream mLog;
+
+ std::vector<GLint> mSupportedTargets;
+ std::vector<GLint> mFullArrayTargets;
+ std::vector<GLint> mSupportedInternalFormats;
/* Protected members */
- void positiveTesting(const glw::Functions& gl, glw::GLint target, glw::GLint format);
- bool verifyTexParameterErrors(const glw::Functions& gl, glw::GLint target, glw::GLint format);
- bool verifyTexStorageVirtualPageSizeIndexError(const glw::Functions& gl, glw::GLint target, glw::GLint format);
- bool verifyTexStorageFullArrayCubeMipmapsError(const glw::Functions& gl, glw::GLint target, glw::GLint format);
- bool verifyTexStorageInvalidValueErrors(const glw::Functions& gl, glw::GLint target, glw::GLint format);
+ bool positiveTesting(const Functions& gl, GLint target, GLint format);
+ bool verifyTexParameterErrors(const Functions& gl, GLint target, GLint format);
+ bool verifyTexStorageVirtualPageSizeIndexError(const Functions& gl, GLint target, GLint format);
+ bool verifyTexStorageFullArrayCubeMipmapsError(const Functions& gl, GLint target, GLint format);
+ bool verifyTexStorageInvalidValueErrors(const Functions& gl, GLint target, GLint format);
};
/** Test verifies glTexPageCommitmentARB functionality added by ARB_sparse_texture extension
protected:
/* Protected members */
- std::vector<glw::GLint> mSupportedTargets;
- std::vector<glw::GLint> mSupportedInternalFormats;
+ std::stringstream mLog;
+
+ std::vector<GLint> mSupportedTargets;
+ std::vector<GLint> mSupportedInternalFormats;
- glw::GLint mWidthStored;
- glw::GLint mHeightStored;
- glw::GLint mDepthStored;
- tcu::TextureFormat mTextureFormatStored;
+ TextureState mState;
/* Protected methods */
- void texPageCommitment(const glw::Functions& gl, glw::GLint target, glw::GLint format, glw::GLuint& texture,
- glw::GLint level, glw::GLint xOffset, glw::GLint yOffset, glw::GLint zOffset,
- glw::GLint width, glw::GLint height, glw::GLint depth, glw::GLboolean committ);
-
- bool prepareTexture(const glw::Functions& gl, glw::GLint target, glw::GLint format, glw::GLuint& texture);
- bool sparseAllocateTexture(const glw::Functions& gl, glw::GLint target, glw::GLint format, glw::GLuint& texture);
- bool allocateTexture(const glw::Functions& gl, glw::GLint target, glw::GLint format, glw::GLuint& texture);
- bool writeDataToTexture(const glw::Functions& gl, glw::GLint target, glw::GLint format, glw::GLuint& texture);
- bool verifyTextureData(const glw::Functions& gl, glw::GLint target, glw::GLint format, glw::GLuint& texture);
- bool commitTexturePage(const glw::Functions& gl, glw::GLint target, glw::GLint format, glw::GLuint& texture);
-
- bool verifyInvalidOperationErrors(const glw::Functions& gl, glw::GLint target, glw::GLint format,
- glw::GLuint& texture);
- bool verifyInvalidValueErrors(const glw::Functions& gl, glw::GLint target, glw::GLint format, glw::GLuint& texture);
+ virtual void texPageCommitment(const Functions& gl, GLint target, GLint format, GLuint& texture, GLint level,
+ GLint xOffset, GLint yOffset, GLint zOffset, GLint width, GLint height, GLint depth,
+ GLboolean committ);
+
+ virtual bool caseAllowed(GLint target, GLint format);
+
+ virtual bool prepareTexture(const Functions& gl, GLint target, GLint format, GLuint& texture);
+ virtual bool sparseAllocateTexture(const Functions& gl, GLint target, GLint format, GLuint& texture, GLint levels);
+ virtual bool allocateTexture(const Functions& gl, GLint target, GLint format, GLuint& texture, GLint levels);
+ virtual bool writeDataToTexture(const Functions& gl, GLint target, GLint format, GLuint& texture, GLint level);
+ virtual bool verifyTextureData(const Functions& gl, GLint target, GLint format, GLuint& texture, GLint level);
+ virtual bool commitTexturePage(const Functions& gl, GLint target, GLint format, GLuint& texture, GLint level);
+
+ virtual bool isInPageSizesRange(GLint target, GLint level);
+ virtual bool isPageSizesMultiplication(GLint target, GLint level);
+
+ virtual bool verifyInvalidOperationErrors(const Functions& gl, GLint target, GLint format, GLuint& texture);
+ virtual bool verifyInvalidValueErrors(const Functions& gl, GLint target, GLint format, GLuint& texture);
};
/** Test verifies glTexturePageCommitmentEXT functionality added by ARB_sparse_texture extension
private:
/* Private methods */
- virtual void texPageCommitment(const glw::Functions& gl, glw::GLint target, glw::GLint format, glw::GLuint& texture,
- glw::GLint level, glw::GLint xOffset, glw::GLint yOffset, glw::GLint zOffset,
- glw::GLint width, glw::GLint height, glw::GLint depth, glw::GLboolean committ);
+ virtual void texPageCommitment(const Functions& gl, GLint target, GLint format, GLuint& texture, GLint level,
+ GLint xOffset, GLint yOffset, GLint zOffset, GLint width, GLint height, GLint depth,
+ GLboolean committ);
};
/** Test group which encapsulates all sparse texture conformance tests */
m_gl.deleteVertexArrays(n, arrays);
}
+void CallLogWrapper::glDepthBoundsEXT (glw::GLclampd zmin, glw::GLclampd zmax)
+{
+ if (m_enableLog)
+ m_log << TestLog::Message << "glDepthBoundsEXT(" << zmin << ", " << zmax << ");" << TestLog::EndMessage;
+ m_gl.depthBoundsEXT(zmin, zmax);
+}
+
void CallLogWrapper::glDepthFunc (glw::GLenum func)
{
if (m_enableLog)
void glDeleteTextures (glw::GLsizei n, const glw::GLuint *textures);
void glDeleteTransformFeedbacks (glw::GLsizei n, const glw::GLuint *ids);
void glDeleteVertexArrays (glw::GLsizei n, const glw::GLuint *arrays);
+void glDepthBoundsEXT (glw::GLclampd zmin, glw::GLclampd zmax);
void glDepthFunc (glw::GLenum func);
void glDepthMask (glw::GLboolean flag);
void glDepthRange (glw::GLdouble near, glw::GLdouble far);
#define glDeleteTextures glwDeleteTextures
#define glDeleteTransformFeedbacks glwDeleteTransformFeedbacks
#define glDeleteVertexArrays glwDeleteVertexArrays
+#define glDepthBoundsEXT glwDepthBoundsEXT
#define glDepthFunc glwDepthFunc
#define glDepthMask glwDepthMask
#define glDepthRange glwDepthRange
void glwDeleteTextures (GLsizei n, const GLuint *textures);
void glwDeleteTransformFeedbacks (GLsizei n, const GLuint *ids);
void glwDeleteVertexArrays (GLsizei n, const GLuint *arrays);
+void glwDepthBoundsEXT (GLclampd zmin, GLclampd zmax);
void glwDepthFunc (GLenum func);
void glwDepthMask (GLboolean flag);
void glwDepthRange (GLdouble near, GLdouble far);
#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872
#define GL_GEOMETRY_SHADER_INVOCATIONS 0x887F
#define GL_GEOMETRY_SHADER_INVOCATIONS_EXT 0x887F
+#define GL_DEPTH_BOUNDS_TEST_EXT 0x8890
+#define GL_DEPTH_BOUNDS_EXT 0x8891
#define GL_ARRAY_BUFFER 0x8892
#define GL_ELEMENT_ARRAY_BUFFER 0x8893
#define GL_ARRAY_BUFFER_BINDING 0x8894
typedef GLW_APICALL void (GLW_APIENTRY* glDeleteTexturesFunc) (GLsizei n, const GLuint *textures);
typedef GLW_APICALL void (GLW_APIENTRY* glDeleteTransformFeedbacksFunc) (GLsizei n, const GLuint *ids);
typedef GLW_APICALL void (GLW_APIENTRY* glDeleteVertexArraysFunc) (GLsizei n, const GLuint *arrays);
+typedef GLW_APICALL void (GLW_APIENTRY* glDepthBoundsEXTFunc) (GLclampd zmin, GLclampd zmax);
typedef GLW_APICALL void (GLW_APIENTRY* glDepthFuncFunc) (GLenum func);
typedef GLW_APICALL void (GLW_APIENTRY* glDepthMaskFunc) (GLboolean flag);
typedef GLW_APICALL void (GLW_APIENTRY* glDepthRangeFunc) (GLdouble near, GLdouble far);
glDeleteTexturesFunc deleteTextures;
glDeleteTransformFeedbacksFunc deleteTransformFeedbacks;
glDeleteVertexArraysFunc deleteVertexArrays;
+glDepthBoundsEXTFunc depthBoundsEXT;
glDepthFuncFunc depthFunc;
glDepthMaskFunc depthMask;
glDepthRangeFunc depthRange;
gl->deleteVertexArrays(n, arrays);
}
+void glwDepthBoundsEXT (GLclampd zmin, GLclampd zmax)
+{
+ const glw::Functions* gl = glw::getCurrentThreadFunctions();
+ if (!gl)
+ return;
+ gl->depthBoundsEXT(zmin, zmax);
+}
+
void glwDepthFunc (GLenum func)
{
const glw::Functions* gl = glw::getCurrentThreadFunctions();
}
+GLW_APICALL void GLW_APIENTRY glDepthBoundsEXT (GLclampd zmin, GLclampd zmax)
+{
+ DE_UNREF(zmin);
+ DE_UNREF(zmax);
+
+}
+
GLW_APICALL void GLW_APIENTRY glDepthFunc (GLenum func)
{
DE_UNREF(func);
gl->deleteTextures = glDeleteTextures;
gl->deleteTransformFeedbacks = glDeleteTransformFeedbacks;
gl->deleteVertexArrays = glDeleteVertexArrays;
+gl->depthBoundsEXT = glDepthBoundsEXT;
gl->depthFunc = glDepthFunc;
gl->depthMask = glDepthMask;
gl->depthRange = glDepthRange;
'GL_EXT_texture_compression_s3tc',
'GL_EXT_texture_type_2_10_10_10_REV',
'GL_EXT_copy_image',
+ 'GL_EXT_depth_bounds_test',
'GL_EXT_draw_buffers_indexed',
'GL_EXT_draw_elements_base_vertex',
'GL_EXT_direct_state_access',
projects / platform / upstream / VK-GL-CTS.git / commitdiff