/*-------------------------------------------------------------------------
* drawElements Quality Program OpenGL ES 3.1 Module
* -------------------------------------------------
*
* Copyright 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*//*!
* \file
* \brief Indexed state query tests
*//*--------------------------------------------------------------------*/
#include "es31fIndexedStateQueryTests.hpp"
#include "tcuTestLog.hpp"
#include "tcuFormatUtil.hpp"
#include "gluRenderContext.hpp"
#include "gluCallLogWrapper.hpp"
#include "gluStrUtil.hpp"
#include "gluContextInfo.hpp"
#include "gluObjectWrapper.hpp"
#include "glwFunctions.hpp"
#include "glwEnums.hpp"
#include "glsStateQueryUtil.hpp"
#include "deRandom.hpp"
#include "deStringUtil.hpp"
namespace deqp
{
namespace gles31
{
namespace Functional
{
namespace
{
using namespace gls::StateQueryUtil;
static const char* getVerifierSuffix (QueryType type)
{
switch (type)
{
case QUERY_INDEXED_BOOLEAN: return "getbooleani_v";
case QUERY_INDEXED_INTEGER: return "getintegeri_v";
case QUERY_INDEXED_INTEGER64: return "getinteger64i_v";
case QUERY_INDEXED_BOOLEAN_VEC4: return "getbooleani_v";
case QUERY_INDEXED_INTEGER_VEC4: return "getintegeri_v";
case QUERY_INDEXED_INTEGER64_VEC4: return "getinteger64i_v";
case QUERY_INDEXED_ISENABLED: return "isenabledi";
default:
DE_ASSERT(DE_FALSE);
return DE_NULL;
}
}
void isExtensionSupported (Context& context, std::string extensionName)
{
if (extensionName == "GL_EXT_draw_buffers_indexed" || extensionName == "GL_KHR_blend_equation_advanced")
{
if (!contextSupports(context.getRenderContext().getType(), glu::ApiType::es(3, 2)) && !context.getContextInfo().isExtensionSupported(extensionName.c_str()))
TCU_THROW(NotSupportedError, (std::string("Extension ") + extensionName + std::string(" not supported.")).c_str());
}
else if (!context.getContextInfo().isExtensionSupported(extensionName.c_str()))
TCU_THROW(NotSupportedError, (std::string("Extension ") + extensionName + std::string(" not supported.")).c_str());
}
class SampleMaskCase : public TestCase
{
public:
SampleMaskCase (Context& context, const char* name, const char* desc, QueryType verifierType);
private:
void init (void);
IterateResult iterate (void);
const QueryType m_verifierType;
int m_maxSampleMaskWords;
};
SampleMaskCase::SampleMaskCase (Context& context, const char* name, const char* desc, QueryType verifierType)
: TestCase (context, name, desc)
, m_verifierType (verifierType)
, m_maxSampleMaskWords (-1)
{
}
void SampleMaskCase::init (void)
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.getIntegerv(GL_MAX_SAMPLE_MASK_WORDS, &m_maxSampleMaskWords);
GLU_EXPECT_NO_ERROR(gl.getError(), "query sample mask words");
// mask word count ok?
if (m_maxSampleMaskWords <= 0)
throw tcu::TestError("Minimum value of GL_MAX_SAMPLE_MASK_WORDS is 1. Got " + de::toString(m_maxSampleMaskWords));
m_testCtx.getLog() << tcu::TestLog::Message << "GL_MAX_SAMPLE_MASK_WORDS = " << m_maxSampleMaskWords << tcu::TestLog::EndMessage;
}
SampleMaskCase::IterateResult SampleMaskCase::iterate (void)
{
glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
gl.enableLogging(true);
// initial values
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "initial", "Initial values");
for (int ndx = 0; ndx < m_maxSampleMaskWords; ++ndx)
verifyStateIndexedInteger(result, gl, GL_SAMPLE_MASK_VALUE, ndx, -1, m_verifierType);
}
// fixed values
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "fixed", "Fixed values");
for (int ndx = 0; ndx < m_maxSampleMaskWords; ++ndx)
{
gl.glSampleMaski(ndx, 0);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "glSampleMaski");
verifyStateIndexedInteger(result, gl, GL_SAMPLE_MASK_VALUE, ndx, 0, m_verifierType);
}
}
// random masks
{
const int numRandomTest = 20;
const tcu::ScopedLogSection section (m_testCtx.getLog(), "random", "Random values");
de::Random rnd (0x4312);
for (int testNdx = 0; testNdx < numRandomTest; ++testNdx)
{
const glw::GLint maskIndex = (glw::GLint)(rnd.getUint32() % m_maxSampleMaskWords);
glw::GLint mask = (glw::GLint)(rnd.getUint32());
gl.glSampleMaski(maskIndex, mask);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "glSampleMaski");
verifyStateIndexedInteger(result, gl, GL_SAMPLE_MASK_VALUE, maskIndex, mask, m_verifierType);
}
}
result.setTestContextResult(m_testCtx);
return STOP;
}
class MinValueIndexed3Case : public TestCase
{
public:
MinValueIndexed3Case (Context& context, const char* name, const char* desc, glw::GLenum target, const tcu::IVec3& ref, QueryType verifierType);
private:
IterateResult iterate (void);
const glw::GLenum m_target;
const tcu::IVec3 m_ref;
const QueryType m_verifierType;
};
MinValueIndexed3Case::MinValueIndexed3Case (Context& context, const char* name, const char* desc, glw::GLenum target, const tcu::IVec3& ref, QueryType verifierType)
: TestCase (context, name, desc)
, m_target (target)
, m_ref (ref)
, m_verifierType (verifierType)
{
}
MinValueIndexed3Case::IterateResult MinValueIndexed3Case::iterate (void)
{
glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
gl.enableLogging(true);
for (int ndx = 0; ndx < 3; ++ndx)
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Element", "Element " + de::toString(ndx));
verifyStateIndexedIntegerMin(result, gl, m_target, ndx, m_ref[ndx], m_verifierType);
}
result.setTestContextResult(m_testCtx);
return STOP;
}
class BufferBindingCase : public TestCase
{
public:
BufferBindingCase (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType);
private:
IterateResult iterate (void);
const glw::GLenum m_queryTarget;
const glw::GLenum m_bufferTarget;
const glw::GLenum m_numBindingsTarget;
const QueryType m_verifierType;
};
BufferBindingCase::BufferBindingCase (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType)
: TestCase (context, name, desc)
, m_queryTarget (queryTarget)
, m_bufferTarget (bufferTarget)
, m_numBindingsTarget (numBindingsTarget)
, m_verifierType (verifierType)
{
}
BufferBindingCase::IterateResult BufferBindingCase::iterate (void)
{
glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
int maxBindings = -1;
gl.enableLogging(true);
gl.glGetIntegerv(m_numBindingsTarget, &maxBindings);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
for (int ndx = 0; ndx < maxBindings; ++ndx)
verifyStateIndexedInteger(result, gl, m_queryTarget, ndx, 0, m_verifierType);
}
{
const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting");
glu::Buffer bufferA (m_context.getRenderContext());
glu::Buffer bufferB (m_context.getRenderContext());
const int ndxA = 0;
const int ndxB = maxBindings / 2;
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Generic", "After setting generic binding point");
gl.glBindBuffer(m_bufferTarget, *bufferA);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "glBindBuffer");
verifyStateIndexedInteger(result, gl, m_queryTarget, 0, 0, m_verifierType);
}
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferBase");
gl.glBindBufferBase(m_bufferTarget, ndxA, *bufferA);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "glBindBufferBase");
verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, *bufferA, m_verifierType);
}
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferRange");
gl.glBindBufferRange(m_bufferTarget, ndxB, *bufferB, 0, 8);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "glBindBufferRange");
verifyStateIndexedInteger(result, gl, m_queryTarget, ndxB, *bufferB, m_verifierType);
}
if (ndxA != ndxB)
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "DifferentStates", "Original state did not change");
verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, *bufferA, m_verifierType);
}
}
result.setTestContextResult(m_testCtx);
return STOP;
}
class BufferStartCase : public TestCase
{
public:
BufferStartCase (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType);
private:
IterateResult iterate (void);
const glw::GLenum m_queryTarget;
const glw::GLenum m_bufferTarget;
const glw::GLenum m_numBindingsTarget;
const QueryType m_verifierType;
};
BufferStartCase::BufferStartCase (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType)
: TestCase (context, name, desc)
, m_queryTarget (queryTarget)
, m_bufferTarget (bufferTarget)
, m_numBindingsTarget (numBindingsTarget)
, m_verifierType (verifierType)
{
}
BufferStartCase::IterateResult BufferStartCase::iterate (void)
{
glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
int maxBindings = -1;
gl.enableLogging(true);
gl.glGetIntegerv(m_numBindingsTarget, &maxBindings);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
for (int ndx = 0; ndx < maxBindings; ++ndx)
verifyStateIndexedInteger(result, gl, m_queryTarget, ndx, 0, m_verifierType);
}
{
const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting");
glu::Buffer bufferA (m_context.getRenderContext());
glu::Buffer bufferB (m_context.getRenderContext());
const int ndxA = 0;
const int ndxB = maxBindings / 2;
int offset = -1;
if (m_bufferTarget == GL_ATOMIC_COUNTER_BUFFER)
offset = 4;
else if (m_bufferTarget == GL_SHADER_STORAGE_BUFFER)
{
gl.glGetIntegerv(GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT, &offset);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "get align");
}
else
DE_ASSERT(false);
TCU_CHECK(offset >= 0);
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Generic", "After setting generic binding point");
gl.glBindBuffer(m_bufferTarget, *bufferA);
gl.glBufferData(m_bufferTarget, 16, DE_NULL, GL_DYNAMIC_READ);
gl.glBindBuffer(m_bufferTarget, *bufferB);
gl.glBufferData(m_bufferTarget, 32, DE_NULL, GL_DYNAMIC_READ);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen bufs");
verifyStateIndexedInteger(result, gl, m_queryTarget, 0, 0, m_verifierType);
}
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferBase");
gl.glBindBufferBase(m_bufferTarget, ndxA, *bufferA);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind buf");
verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, 0, m_verifierType);
}
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferRange");
gl.glBindBufferRange(m_bufferTarget, ndxB, *bufferB, offset, 8);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind buf");
verifyStateIndexedInteger(result, gl, m_queryTarget, ndxB, offset, m_verifierType);
}
if (ndxA != ndxB)
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "DifferentStates", "Original state did not change");
verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, 0, m_verifierType);
}
}
result.setTestContextResult(m_testCtx);
return STOP;
}
class BufferSizeCase : public TestCase
{
public:
BufferSizeCase (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType);
private:
IterateResult iterate (void);
const glw::GLenum m_queryTarget;
const glw::GLenum m_bufferTarget;
const glw::GLenum m_numBindingsTarget;
const QueryType m_verifierType;
};
BufferSizeCase::BufferSizeCase (Context& context, const char* name, const char* desc, glw::GLenum queryTarget, glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType)
: TestCase (context, name, desc)
, m_queryTarget (queryTarget)
, m_bufferTarget (bufferTarget)
, m_numBindingsTarget (numBindingsTarget)
, m_verifierType (verifierType)
{
}
BufferSizeCase::IterateResult BufferSizeCase::iterate (void)
{
glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
int maxBindings = -1;
gl.enableLogging(true);
gl.glGetIntegerv(m_numBindingsTarget, &maxBindings);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
for (int ndx = 0; ndx < maxBindings; ++ndx)
verifyStateIndexedInteger(result, gl, m_queryTarget, ndx, 0, m_verifierType);
}
{
const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting");
glu::Buffer bufferA (m_context.getRenderContext());
glu::Buffer bufferB (m_context.getRenderContext());
const int ndxA = 0;
const int ndxB = maxBindings / 2;
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Generic", "After setting generic binding point");
gl.glBindBuffer(m_bufferTarget, *bufferA);
gl.glBufferData(m_bufferTarget, 16, DE_NULL, GL_DYNAMIC_READ);
gl.glBindBuffer(m_bufferTarget, *bufferB);
gl.glBufferData(m_bufferTarget, 32, DE_NULL, GL_DYNAMIC_READ);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen bufs");
verifyStateIndexedInteger(result, gl, m_queryTarget, 0, 0, m_verifierType);
}
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferBase");
gl.glBindBufferBase(m_bufferTarget, ndxA, *bufferA);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind buf");
verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, 0, m_verifierType);
}
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferRange");
gl.glBindBufferRange(m_bufferTarget, ndxB, *bufferB, 0, 8);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind buf");
verifyStateIndexedInteger(result, gl, m_queryTarget, ndxB, 8, m_verifierType);
}
if (ndxA != ndxB)
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "DifferentStates", "Original state did not change");
verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, 0, m_verifierType);
}
}
result.setTestContextResult(m_testCtx);
return STOP;
}
class ImageBindingNameCase : public TestCase
{
public:
ImageBindingNameCase (Context& context, const char* name, const char* desc, QueryType verifierType);
private:
IterateResult iterate (void);
const QueryType m_verifierType;
};
ImageBindingNameCase::ImageBindingNameCase (Context& context, const char* name, const char* desc, QueryType verifierType)
: TestCase (context, name, desc)
, m_verifierType (verifierType)
{
}
ImageBindingNameCase::IterateResult ImageBindingNameCase::iterate (void)
{
glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
int maxImages = -1;
gl.enableLogging(true);
gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
for (int ndx = 0; ndx < maxImages; ++ndx)
verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_NAME, ndx, 0, m_verifierType);
}
{
const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting");
glu::Texture textureA (m_context.getRenderContext());
glu::Texture textureB (m_context.getRenderContext());
const int ndxA = 0;
const int ndxB = maxImages / 2;
gl.glBindTexture(GL_TEXTURE_2D, *textureA);
gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB);
gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, 32, 32, 4);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
gl.glBindImageTexture(ndxB, *textureB, 0, GL_FALSE, 2, GL_READ_ONLY, GL_RGBA8UI);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_NAME, ndxA, *textureA, m_verifierType);
verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_NAME, ndxB, *textureB, m_verifierType);
}
result.setTestContextResult(m_testCtx);
return STOP;
}
class ImageBindingLevelCase : public TestCase
{
public:
ImageBindingLevelCase (Context& context, const char* name, const char* desc, QueryType verifierType);
private:
IterateResult iterate (void);
const QueryType m_verifierType;
};
ImageBindingLevelCase::ImageBindingLevelCase (Context& context, const char* name, const char* desc, QueryType verifierType)
: TestCase (context, name, desc)
, m_verifierType (verifierType)
{
}
ImageBindingLevelCase::IterateResult ImageBindingLevelCase::iterate (void)
{
glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
int maxImages = -1;
gl.enableLogging(true);
gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
for (int ndx = 0; ndx < maxImages; ++ndx)
verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LEVEL, ndx, 0, m_verifierType);
}
{
const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting");
glu::Texture textureA (m_context.getRenderContext());
glu::Texture textureB (m_context.getRenderContext());
const int ndxA = 0;
const int ndxB = maxImages / 2;
gl.glBindTexture(GL_TEXTURE_2D, *textureA);
gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
gl.glBindTexture(GL_TEXTURE_2D, *textureB);
gl.glTexStorage2D(GL_TEXTURE_2D, 3, GL_RGBA8, 32, 32);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
gl.glBindImageTexture(ndxB, *textureB, 2, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LEVEL, ndxA, 0, m_verifierType);
verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LEVEL, ndxB, 2, m_verifierType);
}
result.setTestContextResult(m_testCtx);
return STOP;
}
class ImageBindingLayeredCase : public TestCase
{
public:
ImageBindingLayeredCase (Context& context, const char* name, const char* desc, QueryType verifierType);
private:
IterateResult iterate (void);
const QueryType m_verifierType;
};
ImageBindingLayeredCase::ImageBindingLayeredCase (Context& context, const char* name, const char* desc, QueryType verifierType)
: TestCase (context, name, desc)
, m_verifierType (verifierType)
{
}
ImageBindingLayeredCase::IterateResult ImageBindingLayeredCase::iterate (void)
{
glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
int maxImages = -1;
gl.enableLogging(true);
gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
for (int ndx = 0; ndx < maxImages; ++ndx)
verifyStateIndexedBoolean(result, gl, GL_IMAGE_BINDING_LAYERED, ndx, false, m_verifierType);
}
{
const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting");
glu::Texture textureA (m_context.getRenderContext());
glu::Texture textureB (m_context.getRenderContext());
const int ndxA = 0;
const int ndxB = maxImages / 2;
gl.glBindTexture(GL_TEXTURE_2D, *textureA);
gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB);
gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, 32, 32, 4);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
gl.glBindImageTexture(ndxB, *textureB, 0, GL_TRUE, 2, GL_READ_ONLY, GL_RGBA8UI);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
verifyStateIndexedBoolean(result, gl, GL_IMAGE_BINDING_LAYERED, ndxA, false, m_verifierType);
verifyStateIndexedBoolean(result, gl, GL_IMAGE_BINDING_LAYERED, ndxB, true, m_verifierType);
}
result.setTestContextResult(m_testCtx);
return STOP;
}
class ImageBindingLayerCase : public TestCase
{
public:
ImageBindingLayerCase (Context& context, const char* name, const char* desc, QueryType verifierType);
private:
IterateResult iterate (void);
const QueryType m_verifierType;
};
ImageBindingLayerCase::ImageBindingLayerCase (Context& context, const char* name, const char* desc, QueryType verifierType)
: TestCase (context, name, desc)
, m_verifierType (verifierType)
{
}
ImageBindingLayerCase::IterateResult ImageBindingLayerCase::iterate (void)
{
glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
int maxImages = -1;
gl.enableLogging(true);
gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
for (int ndx = 0; ndx < maxImages; ++ndx)
verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LAYER, ndx, 0, m_verifierType);
}
{
const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting");
glu::Texture textureA (m_context.getRenderContext());
glu::Texture textureB (m_context.getRenderContext());
const int ndxA = 0;
const int ndxB = maxImages / 2;
gl.glBindTexture(GL_TEXTURE_2D, *textureA);
gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB);
gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, 32, 32, 4);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
gl.glBindImageTexture(ndxB, *textureB, 0, GL_TRUE, 2, GL_READ_ONLY, GL_RGBA8UI);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LAYER, ndxA, 0, m_verifierType);
verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LAYER, ndxB, 2, m_verifierType);
}
result.setTestContextResult(m_testCtx);
return STOP;
}
class ImageBindingAccessCase : public TestCase
{
public:
ImageBindingAccessCase (Context& context, const char* name, const char* desc, QueryType verifierType);
private:
IterateResult iterate (void);
const QueryType m_verifierType;
};
ImageBindingAccessCase::ImageBindingAccessCase (Context& context, const char* name, const char* desc, QueryType verifierType)
: TestCase (context, name, desc)
, m_verifierType (verifierType)
{
}
ImageBindingAccessCase::IterateResult ImageBindingAccessCase::iterate (void)
{
glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
int maxImages = -1;
gl.enableLogging(true);
gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
for (int ndx = 0; ndx < maxImages; ++ndx)
verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_ACCESS, ndx, GL_READ_ONLY, m_verifierType);
}
{
const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting");
glu::Texture textureA (m_context.getRenderContext());
glu::Texture textureB (m_context.getRenderContext());
const int ndxA = 0;
const int ndxB = maxImages / 2;
gl.glBindTexture(GL_TEXTURE_2D, *textureA);
gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB);
gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, 32, 32, 4);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
gl.glBindImageTexture(ndxB, *textureB, 0, GL_TRUE, 2, GL_READ_WRITE, GL_RGBA8UI);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_ACCESS, ndxA, GL_READ_ONLY, m_verifierType);
verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_ACCESS, ndxB, GL_READ_WRITE, m_verifierType);
}
result.setTestContextResult(m_testCtx);
return STOP;
}
class ImageBindingFormatCase : public TestCase
{
public:
ImageBindingFormatCase (Context& context, const char* name, const char* desc, QueryType verifierType);
private:
IterateResult iterate (void);
const QueryType m_verifierType;
};
ImageBindingFormatCase::ImageBindingFormatCase (Context& context, const char* name, const char* desc, QueryType verifierType)
: TestCase (context, name, desc)
, m_verifierType (verifierType)
{
}
ImageBindingFormatCase::IterateResult ImageBindingFormatCase::iterate (void)
{
glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
int maxImages = -1;
gl.enableLogging(true);
gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
for (int ndx = 0; ndx < maxImages; ++ndx)
verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_FORMAT, ndx, GL_R32UI, m_verifierType);
}
{
const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSetting", "After setting");
glu::Texture textureA (m_context.getRenderContext());
glu::Texture textureB (m_context.getRenderContext());
const int ndxA = 0;
const int ndxB = maxImages / 2;
gl.glBindTexture(GL_TEXTURE_2D, *textureA);
gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB);
gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_R32F, 32, 32, 4);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");
gl.glBindImageTexture(ndxB, *textureB, 0, GL_TRUE, 2, GL_READ_WRITE, GL_R32F);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");
verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_FORMAT, ndxA, GL_RGBA8UI, m_verifierType);
verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_FORMAT, ndxB, GL_R32F, m_verifierType);
}
result.setTestContextResult(m_testCtx);
return STOP;
}
class EnableBlendCase : public TestCase
{
public:
EnableBlendCase (Context& context, const char* name, const char* desc, QueryType verifierType);
void init (void);
private:
IterateResult iterate (void);
const QueryType m_verifierType;
};
EnableBlendCase::EnableBlendCase (Context& context, const char* name, const char* desc, QueryType verifierType)
: TestCase (context, name, desc)
, m_verifierType (verifierType)
{
}
void EnableBlendCase::init (void)
{
isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
}
EnableBlendCase::IterateResult EnableBlendCase::iterate (void)
{
glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
deInt32 maxDrawBuffers = 0;
gl.enableLogging(true);
gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedBoolean(result, gl, GL_BLEND, ndx, false, m_verifierType);
}
{
const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSettingCommon", "After setting common");
gl.glEnable(GL_BLEND);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedBoolean(result, gl, GL_BLEND, ndx, true, m_verifierType);
}
{
const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed");
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
{
if (ndx % 2 == 0)
gl.glEnablei(GL_BLEND, ndx);
else
gl.glDisablei(GL_BLEND, ndx);
}
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedBoolean(result, gl, GL_BLEND, ndx, (ndx % 2 == 0), m_verifierType);
}
{
const tcu::ScopedLogSection superSection (m_testCtx.getLog(), "AfterResettingIndexedWithCommon", "After resetting indexed with common");
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
{
if (ndx % 2 == 0)
gl.glEnablei(GL_BLEND, ndx);
else
gl.glDisablei(GL_BLEND, ndx);
}
gl.glEnable(GL_BLEND);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedBoolean(result, gl, GL_BLEND, ndx, true, m_verifierType);
}
result.setTestContextResult(m_testCtx);
return STOP;
}
class ColorMaskCase : public TestCase
{
public:
ColorMaskCase (Context& context, const char* name, const char* desc, QueryType verifierType);
void init (void);
private:
IterateResult iterate (void);
const QueryType m_verifierType;
};
ColorMaskCase::ColorMaskCase (Context& context, const char* name, const char* desc, QueryType verifierType)
: TestCase (context, name, desc)
, m_verifierType (verifierType)
{
}
void ColorMaskCase::init (void)
{
isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
}
ColorMaskCase::IterateResult ColorMaskCase::iterate (void)
{
glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
deInt32 maxDrawBuffers = 0;
gl.enableLogging(true);
gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedBooleanVec4(result, gl, GL_COLOR_WRITEMASK, ndx, tcu::BVec4(true), m_verifierType);
}
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommon", "After setting common");
gl.glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_FALSE);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedBooleanVec4(result, gl, GL_COLOR_WRITEMASK, ndx, tcu::BVec4(false, true, true, false), m_verifierType);
}
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed");
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
gl.glColorMaski(ndx, (ndx % 2 == 0 ? GL_TRUE : GL_FALSE), (ndx % 2 == 1 ? GL_TRUE : GL_FALSE), (ndx % 2 == 0 ? GL_TRUE : GL_FALSE), (ndx % 2 == 1 ? GL_TRUE : GL_FALSE));
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedBooleanVec4(result, gl, GL_COLOR_WRITEMASK, ndx, (ndx % 2 == 0 ? tcu::BVec4(true, false, true, false) : tcu::BVec4(false, true, false, true)), m_verifierType);
}
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommon", "After resetting indexed with common");
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
gl.glColorMaski(ndx, (ndx % 2 == 0 ? GL_TRUE : GL_FALSE), (ndx % 2 == 1 ? GL_TRUE : GL_FALSE), (ndx % 2 == 0 ? GL_TRUE : GL_FALSE), (ndx % 2 == 1 ? GL_TRUE : GL_FALSE));
gl.glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_FALSE);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedBooleanVec4(result, gl, GL_COLOR_WRITEMASK, ndx, tcu::BVec4(false, true, true, false), m_verifierType);
}
result.setTestContextResult(m_testCtx);
return STOP;
}
class BlendFuncCase : public TestCase
{
public:
BlendFuncCase (Context& context, const char* name, const char* desc, QueryType verifierType);
void init (void);
private:
IterateResult iterate (void);
const QueryType m_verifierType;
};
BlendFuncCase::BlendFuncCase (Context& context, const char* name, const char* desc, QueryType verifierType)
: TestCase (context, name, desc)
, m_verifierType (verifierType)
{
}
void BlendFuncCase::init (void)
{
isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
}
BlendFuncCase::IterateResult BlendFuncCase::iterate (void)
{
const deUint32 blendFuncs[] =
{
GL_ZERO,
GL_ONE,
GL_SRC_COLOR,
GL_ONE_MINUS_SRC_COLOR,
GL_DST_COLOR,
GL_ONE_MINUS_DST_COLOR,
GL_SRC_ALPHA,
GL_ONE_MINUS_SRC_ALPHA,
GL_DST_ALPHA,
GL_ONE_MINUS_DST_ALPHA,
GL_CONSTANT_COLOR,
GL_ONE_MINUS_CONSTANT_COLOR,
GL_CONSTANT_ALPHA,
GL_ONE_MINUS_CONSTANT_ALPHA,
GL_SRC_ALPHA_SATURATE
};
glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
deInt32 maxDrawBuffers = 0;
gl.enableLogging(true);
gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_ONE, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_ZERO, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_ONE, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_ZERO, m_verifierType);
}
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommon", "After setting common");
gl.glBlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_SRC_ALPHA, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_DST_ALPHA, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_SRC_ALPHA, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_DST_ALPHA, m_verifierType);
}
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommonSeparate", "After setting common separate");
gl.glBlendFuncSeparate(GL_SRC_COLOR, GL_ONE_MINUS_SRC_ALPHA, GL_DST_COLOR, GL_ONE_MINUS_DST_ALPHA);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_SRC_COLOR, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_ONE_MINUS_SRC_ALPHA, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_DST_COLOR, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_ONE_MINUS_DST_ALPHA, m_verifierType);
}
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed");
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
gl.glBlendFunci(ndx, blendFuncs[ndx % DE_LENGTH_OF_ARRAY(blendFuncs)], blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)]);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, blendFuncs[ndx % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, blendFuncs[ndx % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
}
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexedSeparate", "After setting indexed separate");
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
gl.glBlendFuncSeparatei(ndx, blendFuncs[(ndx + 3) % DE_LENGTH_OF_ARRAY(blendFuncs)],
blendFuncs[(ndx + 2) % DE_LENGTH_OF_ARRAY(blendFuncs)],
blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)],
blendFuncs[(ndx + 0) % DE_LENGTH_OF_ARRAY(blendFuncs)]);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, blendFuncs[(ndx + 3) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, blendFuncs[(ndx + 2) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, blendFuncs[(ndx + 0) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
}
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommon", "After resetting indexed with common");
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
gl.glBlendFunci(ndx, blendFuncs[ndx % DE_LENGTH_OF_ARRAY(blendFuncs)], blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)]);
gl.glBlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_SRC_ALPHA, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_DST_ALPHA, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_SRC_ALPHA, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_DST_ALPHA, m_verifierType);
}
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommonSeparate", "After resetting indexed with common separate");
gl.glBlendFuncSeparate(GL_SRC_COLOR, GL_ONE_MINUS_SRC_ALPHA, GL_DST_COLOR, GL_ONE_MINUS_DST_ALPHA);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
gl.glBlendFuncSeparatei(ndx, blendFuncs[(ndx + 3) % DE_LENGTH_OF_ARRAY(blendFuncs)],
blendFuncs[(ndx + 2) % DE_LENGTH_OF_ARRAY(blendFuncs)],
blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)],
blendFuncs[(ndx + 0) % DE_LENGTH_OF_ARRAY(blendFuncs)]);
gl.glBlendFuncSeparate(GL_SRC_COLOR, GL_ONE_MINUS_SRC_ALPHA, GL_DST_COLOR, GL_ONE_MINUS_DST_ALPHA);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_SRC_COLOR, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_ONE_MINUS_SRC_ALPHA, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_DST_COLOR, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_ONE_MINUS_DST_ALPHA, m_verifierType);
}
result.setTestContextResult(m_testCtx);
return STOP;
}
class BlendEquationCase : public TestCase
{
public:
BlendEquationCase (Context& context, const char* name, const char* desc, QueryType verifierType);
void init (void);
private:
IterateResult iterate (void);
const QueryType m_verifierType;
};
BlendEquationCase::BlendEquationCase (Context& context, const char* name, const char* desc, QueryType verifierType)
: TestCase (context, name, desc)
, m_verifierType (verifierType)
{
}
void BlendEquationCase::init (void)
{
isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
}
BlendEquationCase::IterateResult BlendEquationCase::iterate (void)
{
const deUint32 blendEquations[] =
{
GL_FUNC_ADD,
GL_FUNC_SUBTRACT,
GL_FUNC_REVERSE_SUBTRACT,
GL_MIN,
GL_MAX
};
glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
deInt32 maxDrawBuffers = 0;
gl.enableLogging(true);
gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_ADD, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_ADD, m_verifierType);
}
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommon", "After setting common");
gl.glBlendEquation(GL_FUNC_SUBTRACT);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_SUBTRACT, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_SUBTRACT, m_verifierType);
}
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommonSeparate", "After setting common separate");
gl.glBlendEquationSeparate(GL_FUNC_REVERSE_SUBTRACT, GL_FUNC_SUBTRACT);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_REVERSE_SUBTRACT, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_SUBTRACT, m_verifierType);
}
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed");
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
gl.glBlendEquationi(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)]);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], m_verifierType);
}
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexedSeparate", "After setting indexed separate");
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
gl.glBlendEquationSeparatei(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], blendEquations[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendEquations)]);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, blendEquations[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendEquations)], m_verifierType);
}
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommon", "After resetting indexed with common");
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
gl.glBlendEquationi(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)]);
gl.glBlendEquation(GL_FUNC_SUBTRACT);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_SUBTRACT, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_SUBTRACT, m_verifierType);
}
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommonSeparate", "After resetting indexed with common separate");
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
gl.glBlendEquationSeparatei(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], blendEquations[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendEquations)]);
gl.glBlendEquationSeparate(GL_FUNC_REVERSE_SUBTRACT, GL_FUNC_SUBTRACT);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_REVERSE_SUBTRACT, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_SUBTRACT, m_verifierType);
}
result.setTestContextResult(m_testCtx);
return STOP;
}
class BlendEquationAdvancedCase : public TestCase
{
public:
BlendEquationAdvancedCase (Context& context, const char* name, const char* desc, QueryType verifierType);
void init (void);
private:
IterateResult iterate (void);
const QueryType m_verifierType;
};
BlendEquationAdvancedCase::BlendEquationAdvancedCase (Context& context, const char* name, const char* desc, QueryType verifierType)
: TestCase (context, name, desc)
, m_verifierType (verifierType)
{
}
void BlendEquationAdvancedCase::init (void)
{
isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
isExtensionSupported(m_context, "GL_KHR_blend_equation_advanced");
}
BlendEquationAdvancedCase::IterateResult BlendEquationAdvancedCase::iterate (void)
{
const deUint32 blendEquations[] =
{
GL_FUNC_ADD,
GL_FUNC_SUBTRACT,
GL_FUNC_REVERSE_SUBTRACT,
GL_MIN,
GL_MAX
};
const deUint32 blendEquationAdvanced[] =
{
GL_MULTIPLY,
GL_SCREEN,
GL_OVERLAY,
GL_DARKEN,
GL_LIGHTEN,
GL_COLORDODGE,
GL_COLORBURN,
GL_HARDLIGHT,
GL_SOFTLIGHT,
GL_DIFFERENCE,
GL_EXCLUSION,
GL_HSL_HUE,
GL_HSL_SATURATION,
GL_HSL_COLOR,
GL_HSL_LUMINOSITY
};
glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
deInt32 maxDrawBuffers = 0;
gl.enableLogging(true);
gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommon", "After setting common");
gl.glBlendEquation(GL_SCREEN);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_SCREEN, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_SCREEN, m_verifierType);
}
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed");
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
gl.glBlendEquationi(ndx, blendEquationAdvanced[ndx % DE_LENGTH_OF_ARRAY(blendEquationAdvanced)]);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, blendEquationAdvanced[ndx % DE_LENGTH_OF_ARRAY(blendEquationAdvanced)], m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, blendEquationAdvanced[ndx % DE_LENGTH_OF_ARRAY(blendEquationAdvanced)], m_verifierType);
}
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedWithCommon", "After resetting indexed with common");
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
gl.glBlendEquationi(ndx, blendEquationAdvanced[ndx % DE_LENGTH_OF_ARRAY(blendEquationAdvanced)]);
gl.glBlendEquation(GL_MULTIPLY);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_MULTIPLY, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_MULTIPLY, m_verifierType);
}
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedSeparateWithCommon", "After resetting indexed separate with common");
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
gl.glBlendEquationSeparatei(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], blendEquations[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendEquations)]);
gl.glBlendEquation(GL_LIGHTEN);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_LIGHTEN, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_LIGHTEN, m_verifierType);
}
result.setTestContextResult(m_testCtx);
return STOP;
}
} // anonymous
IndexedStateQueryTests::IndexedStateQueryTests (Context& context)
: TestCaseGroup(context, "indexed", "Indexed state queries")
{
}
IndexedStateQueryTests::~IndexedStateQueryTests (void)
{
}
void IndexedStateQueryTests::init (void)
{
static const QueryType verifiers[] = { QUERY_INDEXED_BOOLEAN, QUERY_INDEXED_INTEGER, QUERY_INDEXED_INTEGER64 };
static const QueryType vec4Verifiers[] = { QUERY_INDEXED_BOOLEAN_VEC4, QUERY_INDEXED_INTEGER_VEC4, QUERY_INDEXED_INTEGER64_VEC4 };
#define FOR_EACH_VERIFIER(X) \
for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx) \
{ \
const QueryType verifier = verifiers[verifierNdx]; \
const char* verifierSuffix = getVerifierSuffix(verifier); \
this->addChild(X); \
}
#define FOR_EACH_VEC4_VERIFIER(X) \
for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(vec4Verifiers); ++verifierNdx) \
{ \
const QueryType verifier = vec4Verifiers[verifierNdx]; \
const char* verifierSuffix = getVerifierSuffix(verifier); \
this->addChild(X); \
}
FOR_EACH_VERIFIER(new SampleMaskCase (m_context, (std::string() + "sample_mask_value_" + verifierSuffix).c_str(), "Test SAMPLE_MASK_VALUE", verifier))
FOR_EACH_VERIFIER(new MinValueIndexed3Case (m_context, (std::string() + "max_compute_work_group_count_" + verifierSuffix).c_str(), "Test MAX_COMPUTE_WORK_GROUP_COUNT", GL_MAX_COMPUTE_WORK_GROUP_COUNT, tcu::IVec3(65535,65535,65535), verifier))
FOR_EACH_VERIFIER(new MinValueIndexed3Case (m_context, (std::string() + "max_compute_work_group_size_" + verifierSuffix).c_str(), "Test MAX_COMPUTE_WORK_GROUP_SIZE", GL_MAX_COMPUTE_WORK_GROUP_SIZE, tcu::IVec3(128, 128, 64), verifier))
FOR_EACH_VERIFIER(new BufferBindingCase (m_context, (std::string() + "atomic_counter_buffer_binding_" + verifierSuffix).c_str(), "Test ATOMIC_COUNTER_BUFFER_BINDING", GL_ATOMIC_COUNTER_BUFFER_BINDING, GL_ATOMIC_COUNTER_BUFFER, GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, verifier))
FOR_EACH_VERIFIER(new BufferStartCase (m_context, (std::string() + "atomic_counter_buffer_start_" + verifierSuffix).c_str(), "Test ATOMIC_COUNTER_BUFFER_START", GL_ATOMIC_COUNTER_BUFFER_START, GL_ATOMIC_COUNTER_BUFFER, GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, verifier))
FOR_EACH_VERIFIER(new BufferSizeCase (m_context, (std::string() + "atomic_counter_buffer_size_" + verifierSuffix).c_str(), "Test ATOMIC_COUNTER_BUFFER_SIZE", GL_ATOMIC_COUNTER_BUFFER_SIZE, GL_ATOMIC_COUNTER_BUFFER, GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, verifier))
FOR_EACH_VERIFIER(new BufferBindingCase (m_context, (std::string() + "shader_storage_buffer_binding_" + verifierSuffix).c_str(), "Test SHADER_STORAGE_BUFFER_BINDING", GL_SHADER_STORAGE_BUFFER_BINDING, GL_SHADER_STORAGE_BUFFER, GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, verifier))
FOR_EACH_VERIFIER(new BufferStartCase (m_context, (std::string() + "shader_storage_buffer_start_" + verifierSuffix).c_str(), "Test SHADER_STORAGE_BUFFER_START", GL_SHADER_STORAGE_BUFFER_START, GL_SHADER_STORAGE_BUFFER, GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, verifier))
FOR_EACH_VERIFIER(new BufferSizeCase (m_context, (std::string() + "shader_storage_buffer_size_" + verifierSuffix).c_str(), "Test SHADER_STORAGE_BUFFER_SIZE", GL_SHADER_STORAGE_BUFFER_SIZE, GL_SHADER_STORAGE_BUFFER, GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, verifier))
FOR_EACH_VERIFIER(new ImageBindingNameCase (m_context, (std::string() + "image_binding_name_" + verifierSuffix).c_str(), "Test IMAGE_BINDING_NAME", verifier))
FOR_EACH_VERIFIER(new ImageBindingLevelCase (m_context, (std::string() + "image_binding_level_" + verifierSuffix).c_str(), "Test IMAGE_BINDING_LEVEL", verifier))
FOR_EACH_VERIFIER(new ImageBindingLayeredCase (m_context, (std::string() + "image_binding_layered_" + verifierSuffix).c_str(), "Test IMAGE_BINDING_LAYERED", verifier))
FOR_EACH_VERIFIER(new ImageBindingLayerCase (m_context, (std::string() + "image_binding_layer_" + verifierSuffix).c_str(), "Test IMAGE_BINDING_LAYER", verifier))
FOR_EACH_VERIFIER(new ImageBindingAccessCase (m_context, (std::string() + "image_binding_access_" + verifierSuffix).c_str(), "Test IMAGE_BINDING_ACCESS", verifier))
FOR_EACH_VERIFIER(new ImageBindingFormatCase (m_context, (std::string() + "image_binding_format_" + verifierSuffix).c_str(), "Test IMAGE_BINDING_FORMAT", verifier))
{
const QueryType verifier = QUERY_INDEXED_ISENABLED;
const char* verifierSuffix = getVerifierSuffix(verifier);
this->addChild(new EnableBlendCase (m_context, (std::string() + "blend_" + verifierSuffix).c_str(), "BLEND", verifier));
}
FOR_EACH_VEC4_VERIFIER(new ColorMaskCase (m_context, (std::string() + "color_mask_" + verifierSuffix).c_str(), "COLOR_WRITEMASK", verifier))
FOR_EACH_VERIFIER(new BlendFuncCase (m_context, (std::string() + "blend_func_" + verifierSuffix).c_str(), "BLEND_SRC and BLEND_DST", verifier))
FOR_EACH_VERIFIER(new BlendEquationCase (m_context, (std::string() + "blend_equation_" + verifierSuffix).c_str(), "BLEND_EQUATION_RGB and BLEND_DST", verifier))
FOR_EACH_VERIFIER(new BlendEquationAdvancedCase (m_context, (std::string() + "blend_equation_advanced_" + verifierSuffix).c_str(), "BLEND_EQUATION_RGB and BLEND_DST", verifier))
#undef FOR_EACH_VEC4_VERIFIER
#undef FOR_EACH_VERIFIER
}
} // Functional
} // gles31
} // deqp