king
/
v811_spc009
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
v811_spc009/external/deqp/modules/gles31/functional/es31fProgramInterfaceQueryT...

7110 lines
301 KiB
Raw Blame History

/*-------------------------------------------------------------------------
* drawElements Quality Program OpenGL ES 3.1 Module
* -------------------------------------------------
*
* Copyright 2014 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 Program interface query tests.
*//*--------------------------------------------------------------------*/
#include "es31fProgramInterfaceQueryTests.hpp"
#include "es31fProgramInterfaceQueryTestCase.hpp"
#include "es31fProgramInterfaceDefinition.hpp"
#include "es31fProgramInterfaceDefinitionUtil.hpp"
#include "tcuTestLog.hpp"
#include "tcuStringTemplate.hpp"
#include "gluShaderProgram.hpp"
#include "gluVarTypeUtil.hpp"
#include "gluStrUtil.hpp"
#include "gluContextInfo.hpp"
#include "glwFunctions.hpp"
#include "glwEnums.hpp"
#include "deRandom.hpp"
#include "deString.h"
#include "deStringUtil.hpp"
#include "deSharedPtr.hpp"
#include "deUniquePtr.hpp"
#include "deSTLUtil.hpp"
#include "deArrayUtil.hpp"
#include <set>
#include <map>
namespace deqp
{
namespace gles31
{
namespace Functional
{
namespace
{
static int getTypeSize (glu::DataType type)
{
if (type == glu::TYPE_FLOAT)
return 4;
else if (type == glu::TYPE_INT || type == glu::TYPE_UINT)
return 4;
else if (type == glu::TYPE_BOOL)
return 4; // uint
DE_ASSERT(false);
return 0;
}
static int getVarTypeSize (const glu::VarType& type)
{
if (type.isBasicType())
return glu::getDataTypeScalarSize(type.getBasicType()) * getTypeSize(glu::getDataTypeScalarType(type.getBasicType()));
else if (type.isStructType())
{
int size = 0;
for (int ndx = 0; ndx < type.getStructPtr()->getNumMembers(); ++ndx)
size += getVarTypeSize(type.getStructPtr()->getMember(ndx).getType());
return size;
}
else if (type.isArrayType())
{
if (type.getArraySize() == glu::VarType::UNSIZED_ARRAY)
return getVarTypeSize(type.getElementType());
else
return type.getArraySize() * getVarTypeSize(type.getElementType());
}
else
{
DE_ASSERT(false);
return 0;
}
}
static std::string convertGLTypeNameToTestName (const char* glName)
{
// vectors and matrices are fine as is
{
if (deStringBeginsWith(glName, "vec") == DE_TRUE ||
deStringBeginsWith(glName, "ivec") == DE_TRUE ||
deStringBeginsWith(glName, "uvec") == DE_TRUE ||
deStringBeginsWith(glName, "bvec") == DE_TRUE ||
deStringBeginsWith(glName, "mat") == DE_TRUE)
return std::string(glName);
}
// convert camel case to use underscore
{
std::ostringstream buf;
std::istringstream name (glName);
bool mergeNextToken = false;
bool previousTokenWasDigit = false;
while (!name.eof())
{
std::ostringstream token;
while (name.peek() != EOF)
{
if ((de::isDigit((char)name.peek()) || de::isUpper((char)name.peek())) && token.tellp())
break;
token << de::toLower((char)name.get());
}
if (buf.str().empty() || mergeNextToken)
buf << token.str();
else
buf << '_' << token.str();
// Single char causes next char to be merged (don't split initialisms or acronyms) unless it is 'D' after a number (split to ..._2d_acronym_aa
mergeNextToken = false;
if (token.tellp() == (std::streamoff)1)
{
if (!previousTokenWasDigit || token.str()[0] != 'd')
mergeNextToken = true;
previousTokenWasDigit = de::isDigit(token.str()[0]);
}
else
previousTokenWasDigit = false;
}
return buf.str();
}
}
static glw::GLenum getProgramInterfaceGLEnum (ProgramInterface interface)
{
static const glw::GLenum s_enums[] =
{
GL_UNIFORM, // PROGRAMINTERFACE_UNIFORM
GL_UNIFORM_BLOCK, // PROGRAMINTERFACE_UNIFORM_BLOCK
GL_ATOMIC_COUNTER_BUFFER, // PROGRAMINTERFACE_ATOMIC_COUNTER_BUFFER
GL_PROGRAM_INPUT, // PROGRAMINTERFACE_PROGRAM_INPUT
GL_PROGRAM_OUTPUT, // PROGRAMINTERFACE_PROGRAM_OUTPUT
GL_TRANSFORM_FEEDBACK_VARYING, // PROGRAMINTERFACE_TRANSFORM_FEEDBACK_VARYING
GL_BUFFER_VARIABLE, // PROGRAMINTERFACE_BUFFER_VARIABLE
GL_SHADER_STORAGE_BLOCK, // PROGRAMINTERFACE_SHADER_STORAGE_BLOCK
};
return de::getSizedArrayElement<PROGRAMINTERFACE_LAST>(s_enums, interface);
}
static glu::ShaderType getShaderMaskFirstStage (deUint32 mask)
{
if (mask & (1u << glu::SHADERTYPE_COMPUTE))
return glu::SHADERTYPE_COMPUTE;
if (mask & (1u << glu::SHADERTYPE_VERTEX))
return glu::SHADERTYPE_VERTEX;
if (mask & (1u << glu::SHADERTYPE_TESSELLATION_CONTROL))
return glu::SHADERTYPE_TESSELLATION_CONTROL;
if (mask & (1u << glu::SHADERTYPE_TESSELLATION_EVALUATION))
return glu::SHADERTYPE_TESSELLATION_EVALUATION;
if (mask & (1u << glu::SHADERTYPE_GEOMETRY))
return glu::SHADERTYPE_GEOMETRY;
if (mask & (1u << glu::SHADERTYPE_FRAGMENT))
return glu::SHADERTYPE_FRAGMENT;
DE_ASSERT(false);
return glu::SHADERTYPE_LAST;
}
static glu::ShaderType getShaderMaskLastStage (deUint32 mask)
{
if (mask & (1u << glu::SHADERTYPE_FRAGMENT))
return glu::SHADERTYPE_FRAGMENT;
if (mask & (1u << glu::SHADERTYPE_GEOMETRY))
return glu::SHADERTYPE_GEOMETRY;
if (mask & (1u << glu::SHADERTYPE_TESSELLATION_EVALUATION))
return glu::SHADERTYPE_TESSELLATION_EVALUATION;
if (mask & (1u << glu::SHADERTYPE_TESSELLATION_CONTROL))
return glu::SHADERTYPE_TESSELLATION_CONTROL;
if (mask & (1u << glu::SHADERTYPE_VERTEX))
return glu::SHADERTYPE_VERTEX;
if (mask & (1u << glu::SHADERTYPE_COMPUTE))
return glu::SHADERTYPE_COMPUTE;
DE_ASSERT(false);
return glu::SHADERTYPE_LAST;
}
static bool checkSupport(Context& ctx)
{
auto ctxType = ctx.getRenderContext().getType();
return contextSupports(ctxType, glu::ApiType::es(3, 2)) ||
contextSupports(ctxType, glu::ApiType::core(4, 5));
}
static std::string specializeShader(Context& context, const char* code)
{
const glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(context.getRenderContext().getType());
std::map<std::string, std::string> specializationMap;
specializationMap["GLSL_VERSION_DECL"] = glu::getGLSLVersionDeclaration(glslVersion);
return tcu::StringTemplate(code).specialize(specializationMap);
}
namespace ResourceDefinition
{
class Node
{
public:
enum NodeType
{
TYPE_PROGRAM = 0,
TYPE_SHADER,
TYPE_DEFAULT_BLOCK,
TYPE_VARIABLE,
TYPE_INTERFACE_BLOCK,
TYPE_ARRAY_ELEMENT,
TYPE_STRUCT_MEMBER,
TYPE_STORAGE_QUALIFIER,
TYPE_LAYOUT_QUALIFIER,
TYPE_SHADER_SET,
TYPE_INTERPOLATION_QUALIFIER,
TYPE_TRANSFORM_FEEDBACK_TARGET,
TYPE_LAST
};
typedef de::SharedPtr<const Node> SharedPtr;
Node (NodeType type, const SharedPtr& enclosingNode) : m_type(type), m_enclosingNode(enclosingNode) { DE_ASSERT(type < TYPE_LAST); }
virtual ~Node (void) { }
inline const Node* getEnclosingNode (void) const { return m_enclosingNode.get(); }
inline NodeType getType (void) const { return m_type; }
private:
const NodeType m_type;
const SharedPtr m_enclosingNode;
};
class Program : public Node
{
public:
Program (bool separable = false)
: Node (TYPE_PROGRAM, SharedPtr())
, m_separable (separable)
{
}
const bool m_separable;
};
class Shader : public Node
{
public:
Shader (const SharedPtr& enclosingNode, glu::ShaderType type, glu::GLSLVersion version)
: Node (TYPE_SHADER, enclosingNode)
, m_type (type)
, m_version (version)
{
DE_ASSERT(enclosingNode->getType() == TYPE_PROGRAM);
DE_ASSERT(type < glu::SHADERTYPE_LAST);
}
const glu::ShaderType m_type;
const glu::GLSLVersion m_version;
};
class DefaultBlock : public Node
{
public:
DefaultBlock (const SharedPtr& enclosing)
: Node(TYPE_DEFAULT_BLOCK, enclosing)
{
// enclosed by the shader
DE_ASSERT(enclosing->getType() == TYPE_SHADER ||
enclosing->getType() == TYPE_SHADER_SET);
}
};
class StorageQualifier : public Node
{
public:
StorageQualifier (const SharedPtr& enclosing, glu::Storage storage)
: Node (TYPE_STORAGE_QUALIFIER, enclosing)
, m_storage (storage)
{
// not a part of any block
DE_ASSERT(enclosing->getType() == TYPE_DEFAULT_BLOCK);
}
const glu::Storage m_storage;
};
class Variable : public Node
{
public:
Variable (const SharedPtr& enclosing, glu::DataType dataType)
: Node (TYPE_VARIABLE, enclosing)
, m_dataType (dataType)
{
DE_ASSERT(enclosing->getType() == TYPE_STORAGE_QUALIFIER ||
enclosing->getType() == TYPE_LAYOUT_QUALIFIER ||
enclosing->getType() == TYPE_INTERPOLATION_QUALIFIER ||
enclosing->getType() == TYPE_INTERFACE_BLOCK ||
enclosing->getType() == TYPE_ARRAY_ELEMENT ||
enclosing->getType() == TYPE_STRUCT_MEMBER ||
enclosing->getType() == TYPE_TRANSFORM_FEEDBACK_TARGET);
}
const glu::DataType m_dataType;
};
class InterfaceBlock : public Node
{
public:
InterfaceBlock (const SharedPtr& enclosing, bool named)
: Node (TYPE_INTERFACE_BLOCK, enclosing)
, m_named (named)
{
// Must be storage qualified
const Node* storageNode = enclosing.get();
while (storageNode->getType() == TYPE_ARRAY_ELEMENT ||
storageNode->getType() == TYPE_LAYOUT_QUALIFIER)
{
storageNode = storageNode->getEnclosingNode();
}
DE_ASSERT(storageNode->getType() == TYPE_STORAGE_QUALIFIER);
DE_UNREF(storageNode);
}
const bool m_named;
};
class ArrayElement : public Node
{
public:
ArrayElement (const SharedPtr& enclosing, int arraySize = DEFAULT_SIZE)
: Node (TYPE_ARRAY_ELEMENT, enclosing)
, m_arraySize (arraySize)
{
DE_ASSERT(enclosing->getType() == TYPE_STORAGE_QUALIFIER ||
enclosing->getType() == TYPE_LAYOUT_QUALIFIER ||
enclosing->getType() == TYPE_INTERPOLATION_QUALIFIER ||
enclosing->getType() == TYPE_INTERFACE_BLOCK ||
enclosing->getType() == TYPE_ARRAY_ELEMENT ||
enclosing->getType() == TYPE_STRUCT_MEMBER ||
enclosing->getType() == TYPE_TRANSFORM_FEEDBACK_TARGET);
}
const int m_arraySize;
enum
{
DEFAULT_SIZE = -1,
UNSIZED_ARRAY = -2,
};
};
class StructMember : public Node
{
public:
StructMember (const SharedPtr& enclosing)
: Node(TYPE_STRUCT_MEMBER, enclosing)
{
DE_ASSERT(enclosing->getType() == TYPE_STORAGE_QUALIFIER ||
enclosing->getType() == TYPE_LAYOUT_QUALIFIER ||
enclosing->getType() == TYPE_INTERPOLATION_QUALIFIER ||
enclosing->getType() == TYPE_INTERFACE_BLOCK ||
enclosing->getType() == TYPE_ARRAY_ELEMENT ||
enclosing->getType() == TYPE_STRUCT_MEMBER ||
enclosing->getType() == TYPE_TRANSFORM_FEEDBACK_TARGET);
}
};
class LayoutQualifier : public Node
{
public:
LayoutQualifier (const SharedPtr& enclosing, const glu::Layout& layout)
: Node (TYPE_LAYOUT_QUALIFIER, enclosing)
, m_layout (layout)
{
DE_ASSERT(enclosing->getType() == TYPE_STORAGE_QUALIFIER ||
enclosing->getType() == TYPE_LAYOUT_QUALIFIER ||
enclosing->getType() == TYPE_INTERPOLATION_QUALIFIER ||
enclosing->getType() == TYPE_DEFAULT_BLOCK ||
enclosing->getType() == TYPE_INTERFACE_BLOCK);
}
const glu::Layout m_layout;
};
class InterpolationQualifier : public Node
{
public:
InterpolationQualifier (const SharedPtr& enclosing, const glu::Interpolation& interpolation)
: Node (TYPE_INTERPOLATION_QUALIFIER, enclosing)
, m_interpolation (interpolation)
{
DE_ASSERT(enclosing->getType() == TYPE_STORAGE_QUALIFIER ||
enclosing->getType() == TYPE_LAYOUT_QUALIFIER ||
enclosing->getType() == TYPE_INTERPOLATION_QUALIFIER ||
enclosing->getType() == TYPE_DEFAULT_BLOCK ||
enclosing->getType() == TYPE_INTERFACE_BLOCK);
}
const glu::Interpolation m_interpolation;
};
class ShaderSet : public Node
{
public:
ShaderSet (const SharedPtr& enclosing, glu::GLSLVersion version);
ShaderSet (const SharedPtr& enclosing, glu::GLSLVersion version, deUint32 stagesPresentBits, deUint32 stagesReferencingBits);
void setStage (glu::ShaderType type, bool referencing);
bool isStagePresent (glu::ShaderType stage) const;
bool isStageReferencing (glu::ShaderType stage) const;
deUint32 getReferencingMask (void) const;
const glu::GLSLVersion m_version;
private:
bool m_stagePresent[glu::SHADERTYPE_LAST];
bool m_stageReferencing[glu::SHADERTYPE_LAST];
};
ShaderSet::ShaderSet (const SharedPtr& enclosing, glu::GLSLVersion version)
: Node (TYPE_SHADER_SET, enclosing)
, m_version (version)
{
DE_ASSERT(enclosing->getType() == TYPE_PROGRAM);
deMemset(m_stagePresent, 0, sizeof(m_stagePresent));
deMemset(m_stageReferencing, 0, sizeof(m_stageReferencing));
}
ShaderSet::ShaderSet (const SharedPtr& enclosing,
glu::GLSLVersion version,
deUint32 stagesPresentBits,
deUint32 stagesReferencingBits)
: Node (TYPE_SHADER_SET, enclosing)
, m_version (version)
{
for (deUint32 stageNdx = 0; stageNdx < glu::SHADERTYPE_LAST; ++stageNdx)
{
const deUint32 stageMask = (1u << stageNdx);
const bool stagePresent = (stagesPresentBits & stageMask) != 0;
const bool stageReferencing = (stagesReferencingBits & stageMask) != 0;
DE_ASSERT(stagePresent || !stageReferencing);
m_stagePresent[stageNdx] = stagePresent;
m_stageReferencing[stageNdx] = stageReferencing;
}
}
void ShaderSet::setStage (glu::ShaderType type, bool referencing)
{
DE_ASSERT(type < glu::SHADERTYPE_LAST);
m_stagePresent[type] = true;
m_stageReferencing[type] = referencing;
}
bool ShaderSet::isStagePresent (glu::ShaderType stage) const
{
DE_ASSERT(stage < glu::SHADERTYPE_LAST);
return m_stagePresent[stage];
}
bool ShaderSet::isStageReferencing (glu::ShaderType stage) const
{
DE_ASSERT(stage < glu::SHADERTYPE_LAST);
return m_stageReferencing[stage];
}
deUint32 ShaderSet::getReferencingMask (void) const
{
deUint32 mask = 0;
for (deUint32 stage = 0; stage < glu::SHADERTYPE_LAST; ++stage)
{
if (m_stageReferencing[stage])
mask |= (1u << stage);
}
return mask;
}
class TransformFeedbackTarget : public Node
{
public:
TransformFeedbackTarget (const SharedPtr& enclosing, const char* builtinVarName = DE_NULL)
: Node (TYPE_TRANSFORM_FEEDBACK_TARGET, enclosing)
, m_builtinVarName (builtinVarName)
{
}
const char* const m_builtinVarName;
};
} // ResourceDefinition
static glu::Precision getDataTypeDefaultPrecision (const glu::DataType& type)
{
if (glu::isDataTypeBoolOrBVec(type))
return glu::PRECISION_LAST;
else if (glu::isDataTypeScalarOrVector(type) || glu::isDataTypeMatrix(type))
return glu::PRECISION_HIGHP;
else if (glu::isDataTypeSampler(type))
return glu::PRECISION_HIGHP;
else if (glu::isDataTypeImage(type))
return glu::PRECISION_HIGHP;
else if (type == glu::TYPE_UINT_ATOMIC_COUNTER)
return glu::PRECISION_HIGHP;
DE_ASSERT(false);
return glu::PRECISION_LAST;
}
static de::MovePtr<ProgramInterfaceDefinition::Program> generateProgramDefinitionFromResource (const ResourceDefinition::Node* resource)
{
de::MovePtr<ProgramInterfaceDefinition::Program> program (new ProgramInterfaceDefinition::Program());
const ResourceDefinition::Node* head = resource;
if (head->getType() == ResourceDefinition::Node::TYPE_VARIABLE)
{
DE_ASSERT(dynamic_cast<const ResourceDefinition::Variable*>(resource));
enum BindingType
{
BINDING_VARIABLE,
BINDING_INTERFACE_BLOCK,
BINDING_DEFAULT_BLOCK
};
int structNdx = 0;
int autoAssignArraySize = 0;
const glu::DataType basicType = static_cast<const ResourceDefinition::Variable*>(resource)->m_dataType;
BindingType boundObject = BINDING_VARIABLE;
glu::VariableDeclaration variable (glu::VarType(basicType, getDataTypeDefaultPrecision(basicType)), "target");
glu::InterfaceBlock interfaceBlock;
ProgramInterfaceDefinition::DefaultBlock defaultBlock;
std::vector<std::string> feedbackTargetVaryingPath;
bool feedbackTargetSet = false;
// image specific
if (glu::isDataTypeImage(basicType))
{
variable.memoryAccessQualifierBits |= glu::MEMORYACCESSQUALIFIER_READONLY_BIT;
variable.layout.binding = 1;
if (basicType >= glu::TYPE_IMAGE_2D && basicType <= glu::TYPE_IMAGE_3D)
variable.layout.format = glu::FORMATLAYOUT_RGBA8;
else if (basicType >= glu::TYPE_INT_IMAGE_2D && basicType <= glu::TYPE_INT_IMAGE_3D)
variable.layout.format = glu::FORMATLAYOUT_RGBA8I;
else if (basicType >= glu::TYPE_UINT_IMAGE_2D && basicType <= glu::TYPE_UINT_IMAGE_3D)
variable.layout.format = glu::FORMATLAYOUT_RGBA8UI;
else
DE_ASSERT(false);
}
// atomic counter specific
if (basicType == glu::TYPE_UINT_ATOMIC_COUNTER)
variable.layout.binding = 1;
for (head = head->getEnclosingNode(); head; head = head->getEnclosingNode())
{
if (head->getType() == ResourceDefinition::Node::TYPE_STORAGE_QUALIFIER)
{
const ResourceDefinition::StorageQualifier* qualifier = static_cast<const ResourceDefinition::StorageQualifier*>(head);
DE_ASSERT(dynamic_cast<const ResourceDefinition::StorageQualifier*>(head));
if (boundObject == BINDING_VARIABLE)
{
DE_ASSERT(variable.storage == glu::STORAGE_LAST);
variable.storage = qualifier->m_storage;
}
else if (boundObject == BINDING_INTERFACE_BLOCK)
{
DE_ASSERT(interfaceBlock.storage == glu::STORAGE_LAST);
interfaceBlock.storage = qualifier->m_storage;
}
else
DE_ASSERT(false);
}
else if (head->getType() == ResourceDefinition::Node::TYPE_LAYOUT_QUALIFIER)
{
const ResourceDefinition::LayoutQualifier* qualifier = static_cast<const ResourceDefinition::LayoutQualifier*>(head);
glu::Layout* targetLayout = DE_NULL;
DE_ASSERT(dynamic_cast<const ResourceDefinition::LayoutQualifier*>(head));
if (boundObject == BINDING_VARIABLE)
targetLayout = &variable.layout;
else if (boundObject == BINDING_INTERFACE_BLOCK)
targetLayout = &interfaceBlock.layout;
else
DE_ASSERT(false);
if (qualifier->m_layout.location != -1)
targetLayout->location = qualifier->m_layout.location;
if (qualifier->m_layout.binding != -1)
targetLayout->binding = qualifier->m_layout.binding;
if (qualifier->m_layout.offset != -1)
targetLayout->offset = qualifier->m_layout.offset;
if (qualifier->m_layout.format != glu::FORMATLAYOUT_LAST)
targetLayout->format = qualifier->m_layout.format;
if (qualifier->m_layout.matrixOrder != glu::MATRIXORDER_LAST)
targetLayout->matrixOrder = qualifier->m_layout.matrixOrder;
}
else if (head->getType() == ResourceDefinition::Node::TYPE_INTERPOLATION_QUALIFIER)
{
const ResourceDefinition::InterpolationQualifier* qualifier = static_cast<const ResourceDefinition::InterpolationQualifier*>(head);
DE_ASSERT(dynamic_cast<const ResourceDefinition::InterpolationQualifier*>(head));
if (boundObject == BINDING_VARIABLE)
variable.interpolation = qualifier->m_interpolation;
else
DE_ASSERT(false);
}
else if (head->getType() == ResourceDefinition::Node::TYPE_ARRAY_ELEMENT)
{
DE_ASSERT(dynamic_cast<const ResourceDefinition::ArrayElement*>(head));
const ResourceDefinition::ArrayElement* arrayElement = static_cast<const ResourceDefinition::ArrayElement*>(head);
int arraySize;
// Vary array size per level
if (arrayElement->m_arraySize == ResourceDefinition::ArrayElement::DEFAULT_SIZE)
{
if (--autoAssignArraySize <= 1)
autoAssignArraySize = 3;
arraySize = autoAssignArraySize;
}
else if (arrayElement->m_arraySize == ResourceDefinition::ArrayElement::UNSIZED_ARRAY)
arraySize = glu::VarType::UNSIZED_ARRAY;
else
arraySize = arrayElement->m_arraySize;
if (boundObject == BINDING_VARIABLE)
variable.varType = glu::VarType(variable.varType, arraySize);
else if (boundObject == BINDING_INTERFACE_BLOCK)
interfaceBlock.dimensions.push_back(arraySize);
else
DE_ASSERT(false);
if (feedbackTargetSet)
feedbackTargetVaryingPath.back().append("[0]");
}
else if (head->getType() == ResourceDefinition::Node::TYPE_STRUCT_MEMBER)
{
DE_ASSERT(dynamic_cast<const ResourceDefinition::StructMember*>(head));
DE_ASSERT(boundObject == BINDING_VARIABLE);
// Struct members cannot contain any qualifiers except precision
DE_ASSERT(variable.interpolation == glu::INTERPOLATION_LAST);
DE_ASSERT(variable.layout == glu::Layout());
DE_ASSERT(variable.memoryAccessQualifierBits == 0);
DE_ASSERT(variable.storage == glu::STORAGE_LAST);
{
glu::StructType* structPtr = new glu::StructType(("StructType" + de::toString(structNdx++)).c_str());
structPtr->addMember(variable.name.c_str(), variable.varType);
variable = glu::VariableDeclaration(glu::VarType(structPtr), "target");
}
if (feedbackTargetSet)
feedbackTargetVaryingPath.push_back("target");
}
else if (head->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK)
{
DE_ASSERT(dynamic_cast<const ResourceDefinition::InterfaceBlock*>(head));
DE_ASSERT(boundObject == BINDING_VARIABLE);
const bool named = static_cast<const ResourceDefinition::InterfaceBlock*>(head)->m_named;
boundObject = BINDING_INTERFACE_BLOCK;
interfaceBlock.interfaceName = "TargetInterface";
interfaceBlock.instanceName = (named) ? ("targetInstance") : ("");
interfaceBlock.variables.push_back(variable);
if (feedbackTargetSet && !interfaceBlock.instanceName.empty())
feedbackTargetVaryingPath.push_back(interfaceBlock.interfaceName);
}
else if (head->getType() == ResourceDefinition::Node::TYPE_DEFAULT_BLOCK)
{
DE_ASSERT(dynamic_cast<const ResourceDefinition::DefaultBlock*>(head));
DE_ASSERT(boundObject == BINDING_VARIABLE || boundObject == BINDING_INTERFACE_BLOCK);
if (boundObject == BINDING_VARIABLE)
defaultBlock.variables.push_back(variable);
else if (boundObject == BINDING_INTERFACE_BLOCK)
defaultBlock.interfaceBlocks.push_back(interfaceBlock);
else
DE_ASSERT(false);
boundObject = BINDING_DEFAULT_BLOCK;
}
else if (head->getType() == ResourceDefinition::Node::TYPE_SHADER)
{
DE_ASSERT(dynamic_cast<const ResourceDefinition::Shader*>(head));
const ResourceDefinition::Shader* shaderDef = static_cast<const ResourceDefinition::Shader*>(head);
ProgramInterfaceDefinition::Shader* shader = program->addShader(shaderDef->m_type, shaderDef->m_version);
shader->getDefaultBlock() = defaultBlock;
}
else if (head->getType() == ResourceDefinition::Node::TYPE_SHADER_SET)
{
DE_ASSERT(dynamic_cast<const ResourceDefinition::ShaderSet*>(head));
const ResourceDefinition::ShaderSet* shaderDef = static_cast<const ResourceDefinition::ShaderSet*>(head);
for (int shaderType = 0; shaderType < glu::SHADERTYPE_LAST; ++shaderType)
{
if (shaderDef->isStagePresent((glu::ShaderType)shaderType))
{
ProgramInterfaceDefinition::Shader* shader = program->addShader((glu::ShaderType)shaderType, shaderDef->m_version);
if (shaderDef->isStageReferencing((glu::ShaderType)shaderType))
shader->getDefaultBlock() = defaultBlock;
}
}
}
else if (head->getType() == ResourceDefinition::Node::TYPE_PROGRAM)
{
DE_ASSERT(dynamic_cast<const ResourceDefinition::Program*>(head));
const ResourceDefinition::Program* programDef = static_cast<const ResourceDefinition::Program*>(head);
program->setSeparable(programDef->m_separable);
DE_ASSERT(feedbackTargetSet == !feedbackTargetVaryingPath.empty());
if (!feedbackTargetVaryingPath.empty())
{
std::ostringstream buf;
for (std::vector<std::string>::reverse_iterator it = feedbackTargetVaryingPath.rbegin(); it != feedbackTargetVaryingPath.rend(); ++it)
{
if (it != feedbackTargetVaryingPath.rbegin())
buf << ".";
buf << *it;
}
program->addTransformFeedbackVarying(buf.str());
program->setTransformFeedbackMode(GL_INTERLEAVED_ATTRIBS);
}
break;
}
else if (head->getType() == ResourceDefinition::Node::TYPE_TRANSFORM_FEEDBACK_TARGET)
{
DE_ASSERT(dynamic_cast<const ResourceDefinition::TransformFeedbackTarget*>(head));
const ResourceDefinition::TransformFeedbackTarget* feedbackTarget = static_cast<const ResourceDefinition::TransformFeedbackTarget*>(head);
DE_ASSERT(feedbackTarget->m_builtinVarName == DE_NULL);
DE_UNREF(feedbackTarget);
feedbackTargetSet = true;
feedbackTargetVaryingPath.push_back(variable.name);
}
else
{
DE_ASSERT(DE_FALSE);
break;
}
}
}
else if (head->getType() == ResourceDefinition::Node::TYPE_DEFAULT_BLOCK ||
head->getType() == ResourceDefinition::Node::TYPE_TRANSFORM_FEEDBACK_TARGET)
{
const char* feedbackTargetVaryingName = DE_NULL;
// empty default block
for (; head; head = head->getEnclosingNode())
{
if (head->getType() == ResourceDefinition::Node::TYPE_SHADER)
{
DE_ASSERT(dynamic_cast<const ResourceDefinition::Shader*>(head));
const ResourceDefinition::Shader* shaderDef = static_cast<const ResourceDefinition::Shader*>(head);
program->addShader(shaderDef->m_type, shaderDef->m_version);
}
else if (head->getType() == ResourceDefinition::Node::TYPE_SHADER_SET)
{
DE_ASSERT(dynamic_cast<const ResourceDefinition::ShaderSet*>(head));
const ResourceDefinition::ShaderSet* shaderDef = static_cast<const ResourceDefinition::ShaderSet*>(head);
for (int shaderType = 0; shaderType < glu::SHADERTYPE_LAST; ++shaderType)
if (shaderDef->isStagePresent((glu::ShaderType)shaderType))
program->addShader((glu::ShaderType)shaderType, shaderDef->m_version);
}
else if (head->getType() == ResourceDefinition::Node::TYPE_PROGRAM)
{
DE_ASSERT(dynamic_cast<const ResourceDefinition::Program*>(head));
const ResourceDefinition::Program* programDef = static_cast<const ResourceDefinition::Program*>(head);
program->setSeparable(programDef->m_separable);
if (feedbackTargetVaryingName)
{
program->addTransformFeedbackVarying(std::string(feedbackTargetVaryingName));
program->setTransformFeedbackMode(GL_INTERLEAVED_ATTRIBS);
}
break;
}
else if (head->getType() == ResourceDefinition::Node::TYPE_TRANSFORM_FEEDBACK_TARGET)
{
DE_ASSERT(dynamic_cast<const ResourceDefinition::TransformFeedbackTarget*>(head));
const ResourceDefinition::TransformFeedbackTarget* feedbackTarget = static_cast<const ResourceDefinition::TransformFeedbackTarget*>(head);
DE_ASSERT(feedbackTarget->m_builtinVarName != DE_NULL);
feedbackTargetVaryingName = feedbackTarget->m_builtinVarName;
}
else if (head->getType() == ResourceDefinition::Node::TYPE_DEFAULT_BLOCK)
{
}
else
{
DE_ASSERT(DE_FALSE);
break;
}
}
}
if (program->hasStage(glu::SHADERTYPE_GEOMETRY))
program->setGeometryNumOutputVertices(1);
if (program->hasStage(glu::SHADERTYPE_TESSELLATION_CONTROL) || program->hasStage(glu::SHADERTYPE_TESSELLATION_EVALUATION))
program->setTessellationNumOutputPatchVertices(1);
return program;
}
static void checkAndLogProgram (const glu::ShaderProgram& program, const ProgramInterfaceDefinition::Program* programDefinition, const glw::Functions& gl, tcu::TestLog& log)
{
const tcu::ScopedLogSection section(log, "Program", "Program");
log << program;
if (!program.isOk())
{
log << tcu::TestLog::Message << "Program build failed, checking if program exceeded implementation limits" << tcu::TestLog::EndMessage;
checkProgramResourceUsage(programDefinition, gl, log);
// within limits
throw tcu::TestError("could not build program");
}
}
// Resource list query case
class ResourceListTestCase : public TestCase
{
public:
ResourceListTestCase (Context& context, const ResourceDefinition::Node::SharedPtr& targetResource, ProgramInterface interface, const char* name = DE_NULL);
~ResourceListTestCase (void);
protected:
void init (void);
void deinit (void);
IterateResult iterate (void);
void queryResourceList (std::vector<std::string>& dst, glw::GLuint program);
bool verifyResourceList (const std::vector<std::string>& resourceList, const std::vector<std::string>& expectedResources);
bool verifyResourceIndexQuery (const std::vector<std::string>& resourceList, const std::vector<std::string>& referenceResources, glw::GLuint program);
bool verifyMaxNameLength (const std::vector<std::string>& referenceResourceList, glw::GLuint program);
static std::string genTestCaseName (ProgramInterface interface, const ResourceDefinition::Node*);
static bool isArrayedInterface (ProgramInterface interface, deUint32 stageBits);
const ProgramInterface m_programInterface;
ResourceDefinition::Node::SharedPtr m_targetResource;
ProgramInterfaceDefinition::Program* m_programDefinition;
};
ResourceListTestCase::ResourceListTestCase (Context& context, const ResourceDefinition::Node::SharedPtr& targetResource, ProgramInterface interface, const char* name)
: TestCase (context, (name == DE_NULL) ? (genTestCaseName(interface, targetResource.get()).c_str()) : (name), "")
, m_programInterface (interface)
, m_targetResource (targetResource)
, m_programDefinition (DE_NULL)
{
// GL_ATOMIC_COUNTER_BUFFER: no resource names
DE_ASSERT(m_programInterface != PROGRAMINTERFACE_ATOMIC_COUNTER_BUFFER);
}
ResourceListTestCase::~ResourceListTestCase (void)
{
deinit();
}
void ResourceListTestCase::init (void)
{
m_programDefinition = generateProgramDefinitionFromResource(m_targetResource.get()).release();
const bool supportsES32orGL45 = checkSupport(m_context);
if ((m_programDefinition->hasStage(glu::SHADERTYPE_TESSELLATION_CONTROL) || m_programDefinition->hasStage(glu::SHADERTYPE_TESSELLATION_EVALUATION)) &&
!supportsES32orGL45 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader"))
{
throw tcu::NotSupportedError("Test requires GL_EXT_tessellation_shader extension");
}
if (m_programDefinition->hasStage(glu::SHADERTYPE_GEOMETRY) &&
!supportsES32orGL45 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"))
{
throw tcu::NotSupportedError("Test requires GL_EXT_geometry_shader extension");
}
if (programContainsIOBlocks(m_programDefinition) &&
!supportsES32orGL45 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_shader_io_blocks"))
{
throw tcu::NotSupportedError("Test requires GL_EXT_shader_io_blocks extension");
}
}
void ResourceListTestCase::deinit (void)
{
m_targetResource.clear();
delete m_programDefinition;
m_programDefinition = DE_NULL;
}
ResourceListTestCase::IterateResult ResourceListTestCase::iterate (void)
{
const glu::ShaderProgram program(m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_programDefinition));
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
checkAndLogProgram(program, m_programDefinition, m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
// Check resource list
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "ResourceList", "Resource list");
std::vector<std::string> resourceList;
std::vector<std::string> expectedResources;
queryResourceList(resourceList, program.getProgram());
expectedResources = getProgramInterfaceResourceList(m_programDefinition, m_programInterface);
// verify the list and the expected list match
if (!verifyResourceList(resourceList, expectedResources))
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "invalid resource list");
// verify GetProgramResourceIndex() matches the indices of the list
if (!verifyResourceIndexQuery(resourceList, expectedResources, program.getProgram()))
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "GetProgramResourceIndex returned unexpected values");
// Verify MAX_NAME_LENGTH
if (!verifyMaxNameLength(resourceList, program.getProgram()))
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "MAX_NAME_LENGTH invalid");
}
return STOP;
}
void ResourceListTestCase::queryResourceList (std::vector<std::string>& dst, glw::GLuint program)
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const glw::GLenum programInterface = getProgramInterfaceGLEnum(m_programInterface);
glw::GLint numActiveResources = 0;
glw::GLint maxNameLength = 0;
std::vector<char> buffer;
m_testCtx.getLog() << tcu::TestLog::Message << "Querying " << glu::getProgramInterfaceName(programInterface) << " interface:" << tcu::TestLog::EndMessage;
gl.getProgramInterfaceiv(program, programInterface, GL_ACTIVE_RESOURCES, &numActiveResources);
gl.getProgramInterfaceiv(program, programInterface, GL_MAX_NAME_LENGTH, &maxNameLength);
GLU_EXPECT_NO_ERROR(gl.getError(), "query interface");
m_testCtx.getLog() << tcu::TestLog::Message
<< "\tGL_ACTIVE_RESOURCES = " << numActiveResources << "\n"
<< "\tGL_MAX_NAME_LENGTH = " << maxNameLength
<< tcu::TestLog::EndMessage;
m_testCtx.getLog() << tcu::TestLog::Message << "Querying all active resources" << tcu::TestLog::EndMessage;
buffer.resize(maxNameLength+1, '\0');
for (int resourceNdx = 0; resourceNdx < numActiveResources; ++resourceNdx)
{
glw::GLint written = 0;
gl.getProgramResourceName(program, programInterface, resourceNdx, maxNameLength, &written, &buffer[0]);
GLU_EXPECT_NO_ERROR(gl.getError(), "query resource name");
dst.push_back(std::string(&buffer[0], written));
}
}
bool ResourceListTestCase::verifyResourceList (const std::vector<std::string>& resourceList, const std::vector<std::string>& expectedResources)
{
bool error = false;
// Log and compare resource lists
m_testCtx.getLog() << tcu::TestLog::Message << "GL returned resources:" << tcu::TestLog::EndMessage;
for (int ndx = 0; ndx < (int)resourceList.size(); ++ndx)
{
// dummyZero is a uniform that may be added by
// generateProgramInterfaceProgramSources. Omit it here to avoid
// confusion about the output.
if (resourceList[ndx] != getDummyZeroUniformName())
m_testCtx.getLog() << tcu::TestLog::Message << "\t" << ndx << ": " << resourceList[ndx] << tcu::TestLog::EndMessage;
}
m_testCtx.getLog() << tcu::TestLog::Message << "Expected list of resources:" << tcu::TestLog::EndMessage;
for (int ndx = 0; ndx < (int)expectedResources.size(); ++ndx)
m_testCtx.getLog() << tcu::TestLog::Message << "\t" << ndx << ": " << expectedResources[ndx] << tcu::TestLog::EndMessage;
m_testCtx.getLog() << tcu::TestLog::Message << "Verifying resource list contents." << tcu::TestLog::EndMessage;
for (int ndx = 0; ndx < (int)expectedResources.size(); ++ndx)
{
if (!de::contains(resourceList.begin(), resourceList.end(), expectedResources[ndx]))
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, resource list did not contain active resource " << expectedResources[ndx] << tcu::TestLog::EndMessage;
error = true;
}
}
for (int ndx = 0; ndx < (int)resourceList.size(); ++ndx)
{
if (!de::contains(expectedResources.begin(), expectedResources.end(), resourceList[ndx]))
{
// Ignore all builtin variables or the variable dummyZero,
// mismatch causes errors otherwise. dummyZero is a uniform that
// may be added by generateProgramInterfaceProgramSources.
if (deStringBeginsWith(resourceList[ndx].c_str(), "gl_") == DE_FALSE &&
resourceList[ndx] != getDummyZeroUniformName())
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, resource list contains unexpected resource name " << resourceList[ndx] << tcu::TestLog::EndMessage;
error = true;
}
else
m_testCtx.getLog() << tcu::TestLog::Message << "Note, resource list contains unknown built-in " << resourceList[ndx] << ". This variable is ignored." << tcu::TestLog::EndMessage;
}
}
return !error;
}
bool ResourceListTestCase::verifyResourceIndexQuery (const std::vector<std::string>& resourceList, const std::vector<std::string>& referenceResources, glw::GLuint program)
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const glw::GLenum programInterface = getProgramInterfaceGLEnum(m_programInterface);
bool error = false;
m_testCtx.getLog() << tcu::TestLog::Message << "Verifying GetProgramResourceIndex returns correct indices for resource names." << tcu::TestLog::EndMessage;
for (int ndx = 0; ndx < (int)referenceResources.size(); ++ndx)
{
const glw::GLuint index = gl.getProgramResourceIndex(program, programInterface, referenceResources[ndx].c_str());
GLU_EXPECT_NO_ERROR(gl.getError(), "query resource index");
if (index == GL_INVALID_INDEX)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, for active resource \"" << referenceResources[ndx] << "\" got index GL_INVALID_INDEX." << tcu::TestLog::EndMessage;
error = true;
}
else if ((int)index >= (int)resourceList.size())
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, for active resource \"" << referenceResources[ndx] << "\" got index " << index << " (larger or equal to GL_ACTIVE_RESOURCES)." << tcu::TestLog::EndMessage;
error = true;
}
else if (resourceList[index] != referenceResources[ndx])
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, for active resource \"" << referenceResources[ndx] << "\" got index (index = " << index << ") of another resource (" << resourceList[index] << ")." << tcu::TestLog::EndMessage;
error = true;
}
}
// Query for "name" should match "name[0]" except for XFB
if (m_programInterface != PROGRAMINTERFACE_TRANSFORM_FEEDBACK_VARYING)
{
for (int ndx = 0; ndx < (int)referenceResources.size(); ++ndx)
{
if (de::endsWith(referenceResources[ndx], "[0]"))
{
const std::string queryString = referenceResources[ndx].substr(0, referenceResources[ndx].length()-3);
const glw::GLuint index = gl.getProgramResourceIndex(program, programInterface, queryString.c_str());
GLU_EXPECT_NO_ERROR(gl.getError(), "query resource index");
if (index == GL_INVALID_INDEX)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for \"" << queryString << "\" resulted in index GL_INVALID_INDEX." << tcu::TestLog::EndMessage;
error = true;
}
else if ((int)index >= (int)resourceList.size())
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for \"" << queryString << "\" resulted in index " << index << " (larger or equal to GL_ACTIVE_RESOURCES)." << tcu::TestLog::EndMessage;
error = true;
}
else if (resourceList[index] != queryString + "[0]")
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for \"" << queryString << "\" got index (index = " << index << ") of another resource (\"" << resourceList[index] << "\")." << tcu::TestLog::EndMessage;
error = true;
}
}
}
}
return !error;
}
bool ResourceListTestCase::verifyMaxNameLength (const std::vector<std::string>& resourceList, glw::GLuint program)
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const glw::GLenum programInterface = getProgramInterfaceGLEnum(m_programInterface);
glw::GLint maxNameLength = 0;
glw::GLint expectedMaxNameLength = 0;
gl.getProgramInterfaceiv(program, programInterface, GL_MAX_NAME_LENGTH, &maxNameLength);
GLU_EXPECT_NO_ERROR(gl.getError(), "query interface");
for (int ndx = 0; ndx < (int)resourceList.size(); ++ndx)
expectedMaxNameLength = de::max(expectedMaxNameLength, (int)resourceList[ndx].size() + 1);
m_testCtx.getLog() << tcu::TestLog::Message << "Verifying MAX_NAME_LENGTH, expecting " << expectedMaxNameLength << " (i.e. consistent with the queried resource list)" << tcu::TestLog::EndMessage;
if (expectedMaxNameLength != maxNameLength)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, got " << maxNameLength << tcu::TestLog::EndMessage;
return false;
}
return true;
}
std::string ResourceListTestCase::genTestCaseName (ProgramInterface interface, const ResourceDefinition::Node* root)
{
bool isImplicitlySizedArray = false;
bool hasVariable = false;
bool accumulateName = true;
std::string buf = "var";
std::string prefix;
for (const ResourceDefinition::Node* node = root; node; node = node->getEnclosingNode())
{
switch (node->getType())
{
case ResourceDefinition::Node::TYPE_VARIABLE:
{
hasVariable = true;
break;
}
case ResourceDefinition::Node::TYPE_STRUCT_MEMBER:
{
if (accumulateName)
buf += "_struct";
break;
}
case ResourceDefinition::Node::TYPE_ARRAY_ELEMENT:
{
DE_ASSERT(dynamic_cast<const ResourceDefinition::ArrayElement*>(node));
const ResourceDefinition::ArrayElement* arrayElement = static_cast<const ResourceDefinition::ArrayElement*>(node);
isImplicitlySizedArray = (arrayElement->m_arraySize == ResourceDefinition::ArrayElement::UNSIZED_ARRAY);
if (accumulateName)
buf += "_array";
break;
}
case ResourceDefinition::Node::TYPE_STORAGE_QUALIFIER:
{
DE_ASSERT(dynamic_cast<const ResourceDefinition::StorageQualifier*>(node));
const ResourceDefinition::StorageQualifier* storageDef = static_cast<const ResourceDefinition::StorageQualifier*>(node);
if (storageDef->m_storage == glu::STORAGE_PATCH_IN ||
storageDef->m_storage == glu::STORAGE_PATCH_OUT)
{
if (accumulateName)
prefix += "patch_";
}
break;
}
case ResourceDefinition::Node::TYPE_SHADER:
case ResourceDefinition::Node::TYPE_SHADER_SET:
{
bool arrayedInterface;
if (node->getType() == ResourceDefinition::Node::TYPE_SHADER)
{
DE_ASSERT(dynamic_cast<const ResourceDefinition::Shader*>(node));
const ResourceDefinition::Shader* shaderDef = static_cast<const ResourceDefinition::Shader*>(node);
arrayedInterface = isArrayedInterface(interface, (1u << shaderDef->m_type));
}
else
{
DE_ASSERT(node->getType() == ResourceDefinition::Node::TYPE_SHADER_SET);
DE_ASSERT(dynamic_cast<const ResourceDefinition::ShaderSet*>(node));
const ResourceDefinition::ShaderSet* shaderDef = static_cast<const ResourceDefinition::ShaderSet*>(node);
arrayedInterface = isArrayedInterface(interface, shaderDef->getReferencingMask());
}
if (arrayedInterface && isImplicitlySizedArray)
{
// omit implicit arrayness from name, i.e. remove trailing "_array"
DE_ASSERT(de::endsWith(buf, "_array"));
buf = buf.substr(0, buf.length() - 6);
}
break;
}
case ResourceDefinition::Node::TYPE_INTERFACE_BLOCK:
{
accumulateName = false;
break;
}
default:
break;
}
}
if (!hasVariable)
return prefix + "empty";
else
return prefix + buf;
}
bool ResourceListTestCase::isArrayedInterface (ProgramInterface interface, deUint32 stageBits)
{
if (interface == PROGRAMINTERFACE_PROGRAM_INPUT)
{
const glu::ShaderType firstStage = getShaderMaskFirstStage(stageBits);
return firstStage == glu::SHADERTYPE_TESSELLATION_CONTROL ||
firstStage == glu::SHADERTYPE_TESSELLATION_EVALUATION ||
firstStage == glu::SHADERTYPE_GEOMETRY;
}
else if (interface == PROGRAMINTERFACE_PROGRAM_OUTPUT)
{
const glu::ShaderType lastStage = getShaderMaskLastStage(stageBits);
return lastStage == glu::SHADERTYPE_TESSELLATION_CONTROL;
}
return false;
}
// Resouce property query case
class ResourceTestCase : public ProgramInterfaceQueryTestCase
{
public:
ResourceTestCase (Context& context, const ResourceDefinition::Node::SharedPtr& targetResource, const ProgramResourceQueryTestTarget& queryTarget, const char* name = DE_NULL);
~ResourceTestCase (void);
private:
void init (void);
void deinit (void);
const ProgramInterfaceDefinition::Program* getProgramDefinition (void) const;
std::vector<std::string> getQueryTargetResources (void) const;
static std::string genTestCaseName (const ResourceDefinition::Node*);
static std::string genMultilineDescription (const ResourceDefinition::Node*);
ResourceDefinition::Node::SharedPtr m_targetResource;
ProgramInterfaceDefinition::Program* m_program;
std::vector<std::string> m_targetResources;
};
ResourceTestCase::ResourceTestCase (Context& context, const ResourceDefinition::Node::SharedPtr& targetResource, const ProgramResourceQueryTestTarget& queryTarget, const char* name)
: ProgramInterfaceQueryTestCase (context, (name == DE_NULL) ? (genTestCaseName(targetResource.get()).c_str()) : (name), "", queryTarget)
, m_targetResource (targetResource)
, m_program (DE_NULL)
{
}
ResourceTestCase::~ResourceTestCase (void)
{
deinit();
}
void ResourceTestCase::init (void)
{
m_testCtx.getLog()
<< tcu::TestLog::Message
<< genMultilineDescription(m_targetResource.get())
<< tcu::TestLog::EndMessage;
// Program
{
// Generate interface with target resource
m_program = generateProgramDefinitionFromResource(m_targetResource.get()).release();
m_targetResources = getProgramInterfaceResourceList(m_program, getTargetInterface());
}
}
void ResourceTestCase::deinit (void)
{
m_targetResource.clear();
delete m_program;
m_program = DE_NULL;
m_targetResources = std::vector<std::string>();
}
const ProgramInterfaceDefinition::Program* ResourceTestCase::getProgramDefinition (void) const
{
return m_program;
}
std::vector<std::string> ResourceTestCase::getQueryTargetResources (void) const
{
return m_targetResources;
}
std::string ResourceTestCase::genTestCaseName (const ResourceDefinition::Node* resource)
{
if (resource->getType() == ResourceDefinition::Node::TYPE_VARIABLE)
{
DE_ASSERT(dynamic_cast<const ResourceDefinition::Variable*>(resource));
const ResourceDefinition::Variable* variable = static_cast<const ResourceDefinition::Variable*>(resource);
return convertGLTypeNameToTestName(glu::getDataTypeName(variable->m_dataType));
}
DE_ASSERT(false);
return "";
}
std::string ResourceTestCase::genMultilineDescription (const ResourceDefinition::Node* resource)
{
if (resource->getType() == ResourceDefinition::Node::TYPE_VARIABLE)
{
DE_ASSERT(dynamic_cast<const ResourceDefinition::Variable*>(resource));
const ResourceDefinition::Variable* varDef = static_cast<const ResourceDefinition::Variable*>(resource);
std::ostringstream buf;
std::ostringstream structureDescriptor;
std::string uniformType;
for (const ResourceDefinition::Node* node = resource; node; node = node->getEnclosingNode())
{
if (node->getType() == ResourceDefinition::Node::TYPE_STORAGE_QUALIFIER)
{
DE_ASSERT(dynamic_cast<const ResourceDefinition::StorageQualifier*>(node));
const ResourceDefinition::StorageQualifier* storageDef = static_cast<const ResourceDefinition::StorageQualifier*>(node);
uniformType = std::string(" ") + glu::getStorageName(storageDef->m_storage);
structureDescriptor << "\n\tdeclared as \"" << glu::getStorageName(storageDef->m_storage) << "\"";
}
if (node->getType() == ResourceDefinition::Node::TYPE_ARRAY_ELEMENT)
structureDescriptor << "\n\tarray";
if (node->getType() == ResourceDefinition::Node::TYPE_STRUCT_MEMBER)
structureDescriptor << "\n\tin a struct";
if (node->getType() == ResourceDefinition::Node::TYPE_DEFAULT_BLOCK)
structureDescriptor << "\n\tin the default block";
if (node->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK)
structureDescriptor << "\n\tin an interface block";
}
buf << "Querying properties of " << glu::getDataTypeName(varDef->m_dataType) << uniformType << " variable.\n"
<< "Variable is:\n"
<< "\t" << glu::getDataTypeName(varDef->m_dataType)
<< structureDescriptor.str();
return buf.str();
}
else if (resource->getType() == ResourceDefinition::Node::TYPE_TRANSFORM_FEEDBACK_TARGET)
{
DE_ASSERT(dynamic_cast<const ResourceDefinition::TransformFeedbackTarget*>(resource));
const ResourceDefinition::TransformFeedbackTarget* xfbDef = static_cast<const ResourceDefinition::TransformFeedbackTarget*>(resource);
DE_ASSERT(xfbDef->m_builtinVarName);
return std::string("Querying properties of a builtin variable ") + xfbDef->m_builtinVarName;
}
DE_ASSERT(false);
return DE_NULL;
}
class ResourceNameBufferLimitCase : public TestCase
{
public:
ResourceNameBufferLimitCase (Context& context, const char* name, const char* description);
~ResourceNameBufferLimitCase (void);
private:
IterateResult iterate (void);
};
ResourceNameBufferLimitCase::ResourceNameBufferLimitCase (Context& context, const char* name, const char* description)
: TestCase(context, name, description)
{
}
ResourceNameBufferLimitCase::~ResourceNameBufferLimitCase (void)
{
}
ResourceNameBufferLimitCase::IterateResult ResourceNameBufferLimitCase::iterate (void)
{
static const char* const computeSource = "${GLSL_VERSION_DECL}\n"
"layout(local_size_x = 1) in;\n"
"uniform highp int u_uniformWithALongName;\n"
"writeonly buffer OutputBufferBlock { highp int b_output_int; };\n"
"void main ()\n"
"{\n"
" b_output_int = u_uniformWithALongName;\n"
"}\n";
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const glu::ShaderProgram program (m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(specializeShader(m_context, computeSource)));
glw::GLuint uniformIndex;
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
// Log program
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Program", "Program");
m_testCtx.getLog() << program;
if (!program.isOk())
throw tcu::TestError("could not build program");
}
uniformIndex = gl.getProgramResourceIndex(program.getProgram(), GL_UNIFORM, "u_uniformWithALongName");
GLU_EXPECT_NO_ERROR(gl.getError(), "query resource index");
if (uniformIndex == GL_INVALID_INDEX)
throw tcu::TestError("Uniform u_uniformWithALongName resource index was GL_INVALID_INDEX");
// Query with different sized buffers, len("u_uniformWithALongName") == 22
{
static const struct
{
const char* description;
int querySize;
bool returnLength;
} querySizes[] =
{
{ "Query to larger buffer", 24, true },
{ "Query to buffer the same size", 23, true },
{ "Query to one byte too small buffer", 22, true },
{ "Query to one byte buffer", 1, true },
{ "Query to zero sized buffer", 0, true },
{ "Query to one byte too small buffer, null length argument", 22, false },
{ "Query to one byte buffer, null length argument", 1, false },
{ "Query to zero sized buffer, null length argument", 0, false },
};
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(querySizes); ++ndx)
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "Query", querySizes[ndx].description);
const int uniformNameLen = 22;
const int expectedWriteLen = (querySizes[ndx].querySize != 0) ? (de::min(uniformNameLen, (querySizes[ndx].querySize - 1))) : (0);
char buffer [26];
glw::GLsizei written = -1;
// One byte for guard
DE_ASSERT((int)sizeof(buffer) > querySizes[ndx].querySize);
deMemset(buffer, 'x', sizeof(buffer));
if (querySizes[ndx].querySize)
m_testCtx.getLog()
<< tcu::TestLog::Message
<< "Querying uniform name to a buffer of size " << querySizes[ndx].querySize
<< ", expecting query to write " << expectedWriteLen << " bytes followed by a null terminator"
<< tcu::TestLog::EndMessage;
else
m_testCtx.getLog()
<< tcu::TestLog::Message
<< "Querying uniform name to a buffer of size " << querySizes[ndx].querySize
<< ", expecting query to write 0 bytes"
<< tcu::TestLog::EndMessage;
gl.getProgramResourceName(program.getProgram(), GL_UNIFORM, uniformIndex, querySizes[ndx].querySize, (querySizes[ndx].returnLength) ? (&written) : (DE_NULL), buffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "query resource name");
if (querySizes[ndx].returnLength && written != expectedWriteLen)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, expected write length of " << expectedWriteLen << ", got " << written << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Unexpected write lenght");
}
else if (querySizes[ndx].querySize != 0 && buffer[expectedWriteLen] != 0)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, expected null terminator at " << expectedWriteLen << ", got dec=" << (int)buffer[expectedWriteLen] << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Missing null terminator");
}
else if (querySizes[ndx].querySize != 0 && buffer[expectedWriteLen+1] != 'x')
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, guard at index " << (expectedWriteLen+1) << " was modified, got dec=" << (int)buffer[expectedWriteLen+1] << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Wrote over buffer size");
}
else if (querySizes[ndx].querySize == 0 && buffer[0] != 'x')
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, buffer size was 0 but buffer contents were modified. At index 0 got dec=" << (int)buffer[0] << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Buffer contents were modified");
}
}
}
return STOP;
}
class ResourceQueryBufferLimitCase : public TestCase
{
public:
ResourceQueryBufferLimitCase (Context& context, const char* name, const char* description);
~ResourceQueryBufferLimitCase (void);
private:
IterateResult iterate (void);
};
ResourceQueryBufferLimitCase::ResourceQueryBufferLimitCase (Context& context, const char* name, const char* description)
: TestCase(context, name, description)
{
}
ResourceQueryBufferLimitCase::~ResourceQueryBufferLimitCase (void)
{
}
ResourceQueryBufferLimitCase::IterateResult ResourceQueryBufferLimitCase::iterate (void)
{
static const char* const computeSource = "${GLSL_VERSION_DECL}\n"
"layout(local_size_x = 1) in;\n"
"uniform highp int u_uniform;\n"
"writeonly buffer OutputBufferBlock { highp int b_output_int; };\n"
"void main ()\n"
"{\n"
" b_output_int = u_uniform;\n"
"}\n";
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const glu::ShaderProgram program (m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(specializeShader(m_context, computeSource)));
glw::GLuint uniformIndex;
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
// Log program
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Program", "Program");
m_testCtx.getLog() << program;
if (!program.isOk())
throw tcu::TestError("could not build program");
}
uniformIndex = gl.getProgramResourceIndex(program.getProgram(), GL_UNIFORM, "u_uniform");
GLU_EXPECT_NO_ERROR(gl.getError(), "query resource index");
if (uniformIndex == GL_INVALID_INDEX)
throw tcu::TestError("Uniform u_uniform resource index was GL_INVALID_INDEX");
// Query uniform properties
{
static const struct
{
const char* description;
int numProps;
int bufferSize;
bool returnLength;
} querySizes[] =
{
{ "Query to a larger buffer", 2, 3, true },
{ "Query to too small a buffer", 3, 2, true },
{ "Query to zero sized buffer", 3, 0, true },
{ "Query to a larger buffer, null length argument", 2, 3, false },
{ "Query to too small a buffer, null length argument", 3, 2, false },
{ "Query to zero sized buffer, null length argument", 3, 0, false },
};
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(querySizes); ++ndx)
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "QueryToLarger", querySizes[ndx].description);
const glw::GLenum props[] = { GL_LOCATION, GL_LOCATION, GL_LOCATION };
const int expectedWriteLen = de::min(querySizes[ndx].bufferSize, querySizes[ndx].numProps);
int params[] = { 255, 255, 255, 255 };
glw::GLsizei written = -1;
DE_ASSERT(querySizes[ndx].numProps <= DE_LENGTH_OF_ARRAY(props));
DE_ASSERT(querySizes[ndx].bufferSize < DE_LENGTH_OF_ARRAY(params)); // leave at least one element for overflow detection
m_testCtx.getLog()
<< tcu::TestLog::Message
<< "Querying " << querySizes[ndx].numProps << " uniform prop(s) to a buffer with size " << querySizes[ndx].bufferSize << ". Expecting query to return " << expectedWriteLen << " prop(s)"
<< tcu::TestLog::EndMessage;
gl.getProgramResourceiv(program.getProgram(), GL_UNIFORM, uniformIndex, querySizes[ndx].numProps, props, querySizes[ndx].bufferSize, (querySizes[ndx].returnLength) ? (&written) : (DE_NULL), params);
GLU_EXPECT_NO_ERROR(gl.getError(), "query program resources");
if (querySizes[ndx].returnLength && written != expectedWriteLen)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, expected write length of " << expectedWriteLen << ", got " << written << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Unexpected write lenght");
}
else if (params[expectedWriteLen] != 255)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, guard at index " << (expectedWriteLen) << " was modified. Was 255 before call, got dec=" << params[expectedWriteLen] << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Wrote over buffer size");
}
}
}
return STOP;
}
class InterfaceBlockBaseCase : public TestCase
{
public:
enum CaseType
{
CASE_NAMED_BLOCK = 0,
CASE_UNNAMED_BLOCK,
CASE_BLOCK_ARRAY,
CASE_LAST
};
InterfaceBlockBaseCase (Context& context, const char* name, const char* description, glu::Storage storage, CaseType caseType);
~InterfaceBlockBaseCase (void);
private:
void init (void);
void deinit (void);
protected:
const glu::Storage m_storage;
const CaseType m_caseType;
ProgramInterfaceDefinition::Program* m_program;
};
InterfaceBlockBaseCase::InterfaceBlockBaseCase (Context& context, const char* name, const char* description, glu::Storage storage, CaseType caseType)
: TestCase (context, name, description)
, m_storage (storage)
, m_caseType (caseType)
, m_program (DE_NULL)
{
DE_ASSERT(storage == glu::STORAGE_UNIFORM || storage == glu::STORAGE_BUFFER);
}
InterfaceBlockBaseCase::~InterfaceBlockBaseCase (void)
{
deinit();
}
void InterfaceBlockBaseCase::init (void)
{
const glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
ProgramInterfaceDefinition::Shader* shader;
m_program = new ProgramInterfaceDefinition::Program();
shader = m_program->addShader(glu::SHADERTYPE_COMPUTE, glslVersion);
// PrecedingInterface
{
glu::InterfaceBlock precedingInterfaceBlock;
precedingInterfaceBlock.interfaceName = "PrecedingInterface";
precedingInterfaceBlock.layout.binding = 0;
precedingInterfaceBlock.storage = m_storage;
precedingInterfaceBlock.instanceName = "precedingInstance";
precedingInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), "precedingMember"));
// Unsized array type
if (m_storage == glu::STORAGE_BUFFER)
precedingInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT, glu::PRECISION_HIGHP), glu::VarType::UNSIZED_ARRAY), "precedingMemberUnsizedArray"));
else
precedingInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT, glu::PRECISION_HIGHP), 2), "precedingMemberArray"));
shader->getDefaultBlock().interfaceBlocks.push_back(precedingInterfaceBlock);
}
// TargetInterface
{
glu::InterfaceBlock targetInterfaceBlock;
targetInterfaceBlock.interfaceName = "TargetInterface";
targetInterfaceBlock.layout.binding = 1;
targetInterfaceBlock.storage = m_storage;
if (m_caseType == CASE_UNNAMED_BLOCK)
targetInterfaceBlock.instanceName = "";
else
targetInterfaceBlock.instanceName = "targetInstance";
if (m_caseType == CASE_BLOCK_ARRAY)
targetInterfaceBlock.dimensions.push_back(2);
// Basic type
{
targetInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), "blockMemberBasic"));
}
// Array type
{
targetInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT, glu::PRECISION_HIGHP), 3), "blockMemberArray"));
}
// Struct type
{
glu::StructType* structPtr = new glu::StructType("StructType");
structPtr->addMember("structMemberBasic", glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP));
structPtr->addMember("structMemberArray", glu::VarType(glu::VarType(glu::TYPE_FLOAT, glu::PRECISION_HIGHP), 2));
targetInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(structPtr), 2), "blockMemberStruct"));
}
// Unsized array type
if (m_storage == glu::STORAGE_BUFFER)
targetInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT, glu::PRECISION_HIGHP), glu::VarType::UNSIZED_ARRAY), "blockMemberUnsizedArray"));
shader->getDefaultBlock().interfaceBlocks.push_back(targetInterfaceBlock);
}
// TrailingInterface
{
glu::InterfaceBlock trailingInterfaceBlock;
trailingInterfaceBlock.interfaceName = "TrailingInterface";
trailingInterfaceBlock.layout.binding = 3;
trailingInterfaceBlock.storage = m_storage;
trailingInterfaceBlock.instanceName = "trailingInstance";
trailingInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), "trailingMember"));
shader->getDefaultBlock().interfaceBlocks.push_back(trailingInterfaceBlock);
}
DE_ASSERT(m_program->isValid());
}
void InterfaceBlockBaseCase::deinit (void)
{
delete m_program;
m_program = DE_NULL;
}
class InterfaceBlockActiveVariablesTestCase : public InterfaceBlockBaseCase
{
public:
InterfaceBlockActiveVariablesTestCase (Context& context, const char* name, const char* description, glu::Storage storage, CaseType caseType);
private:
IterateResult iterate (void);
};
InterfaceBlockActiveVariablesTestCase::InterfaceBlockActiveVariablesTestCase (Context& context, const char* name, const char* description, glu::Storage storage, CaseType caseType)
: InterfaceBlockBaseCase(context, name, description, storage, caseType)
{
}
InterfaceBlockActiveVariablesTestCase::IterateResult InterfaceBlockActiveVariablesTestCase::iterate (void)
{
const ProgramInterface programInterface = (m_storage == glu::STORAGE_UNIFORM) ? (PROGRAMINTERFACE_UNIFORM_BLOCK) :
(m_storage == glu::STORAGE_BUFFER) ? (PROGRAMINTERFACE_SHADER_STORAGE_BLOCK) :
(PROGRAMINTERFACE_LAST);
const glw::GLenum programGLInterfaceValue = getProgramInterfaceGLEnum(programInterface);
const glw::GLenum programMemberInterfaceValue = (m_storage == glu::STORAGE_UNIFORM) ? (GL_UNIFORM) :
(m_storage == glu::STORAGE_BUFFER) ? (GL_BUFFER_VARIABLE) :
(0);
const std::vector<std::string> blockNames = getProgramInterfaceResourceList(m_program, programInterface);
glu::ShaderProgram program (m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_program));
int expectedMaxNumActiveVariables = 0;
DE_ASSERT(programInterface != PROGRAMINTERFACE_LAST);
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
checkAndLogProgram(program, m_program, m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
// Verify all blocks
for (int blockNdx = 0; blockNdx < (int)blockNames.size(); ++blockNdx)
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "Block", "Block \"" + blockNames[blockNdx] + "\"");
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const glw::GLuint resourceNdx = gl.getProgramResourceIndex(program.getProgram(), programGLInterfaceValue, blockNames[blockNdx].c_str());
glw::GLint numActiveResources;
std::vector<std::string> activeResourceNames;
GLU_EXPECT_NO_ERROR(gl.getError(), "query resource index");
if (resourceNdx == GL_INVALID_INDEX)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, getProgramResourceIndex returned GL_INVALID_INDEX for \"" << blockNames[blockNdx] << "\"" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Resource not found");
continue;
}
// query block information
{
const glw::GLenum props[] = { GL_NUM_ACTIVE_VARIABLES };
glw::GLint retBuffer[2] = { -1, -1 };
glw::GLint written = -1;
gl.getProgramResourceiv(program.getProgram(), programGLInterfaceValue, resourceNdx, DE_LENGTH_OF_ARRAY(props), props, 1, &written, retBuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "query GL_NUM_ACTIVE_VARIABLES");
numActiveResources = retBuffer[0];
expectedMaxNumActiveVariables = de::max(expectedMaxNumActiveVariables, numActiveResources);
m_testCtx.getLog() << tcu::TestLog::Message << "NUM_ACTIVE_VARIABLES = " << numActiveResources << tcu::TestLog::EndMessage;
if (written == -1 || retBuffer[0] == -1)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, Query for NUM_ACTIVE_VARIABLES did not return a value" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Query for NUM_ACTIVE_VARIABLES failed");
continue;
}
else if (retBuffer[1] != -1)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, Query for NUM_ACTIVE_VARIABLES returned too many values" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Query for NUM_ACTIVE_VARIABLES returned too many values");
continue;
}
else if (retBuffer[0] < 0)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, NUM_ACTIVE_VARIABLES < 0" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "NUM_ACTIVE_VARIABLES < 0");
continue;
}
}
// query block variable information
{
const glw::GLenum props[] = { GL_ACTIVE_VARIABLES };
std::vector<glw::GLint> activeVariableIndices (numActiveResources + 1, -1); // Allocate one extra trailing to detect wrong write lengths
glw::GLint written = -1;
gl.getProgramResourceiv(program.getProgram(), programGLInterfaceValue, resourceNdx, DE_LENGTH_OF_ARRAY(props), props, (glw::GLsizei)activeVariableIndices.size(), &written, &activeVariableIndices[0]);
GLU_EXPECT_NO_ERROR(gl.getError(), "query GL_ACTIVE_VARIABLES");
if (written == -1)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, Query for GL_ACTIVE_VARIABLES did not return any values" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Query for GL_ACTIVE_VARIABLES failed");
continue;
}
else if (written != numActiveResources)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, Query for GL_ACTIVE_VARIABLES did not return NUM_ACTIVE_VARIABLES values" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Query for GL_ACTIVE_VARIABLES returned invalid number of values");
continue;
}
else if (activeVariableIndices.back() != -1)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, GL_ACTIVE_VARIABLES query return buffer trailing guard value was modified, getProgramResourceiv returned more than NUM_ACTIVE_VARIABLES values" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Query for GL_ACTIVE_VARIABLES returned too many values");
continue;
}
// log indices
{
tcu::MessageBuilder builder(&m_testCtx.getLog());
builder << "Active variable indices: {";
for (int varNdx = 0; varNdx < numActiveResources; ++varNdx)
{
if (varNdx)
builder << ", ";
builder << activeVariableIndices[varNdx];
}
builder << "}" << tcu::TestLog::EndMessage;
}
// collect names
activeResourceNames.resize(numActiveResources);
for (int varNdx = 0; varNdx < numActiveResources; ++varNdx)
{
const glw::GLenum nameProp = GL_NAME_LENGTH;
glw::GLint nameLength = -1;
std::vector<char> nameBuffer;
written = -1;
gl.getProgramResourceiv(program.getProgram(), programMemberInterfaceValue, activeVariableIndices[varNdx], 1, &nameProp, 1, &written, &nameLength);
GLU_EXPECT_NO_ERROR(gl.getError(), "query GL_NAME_LENGTH");
if (nameLength <= 0 || written <= 0)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, GL_NAME_LENGTH query failed" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "GL_NAME_LENGTH query failed");
continue;
}
nameBuffer.resize(nameLength + 2, 'X'); // allocate more than required
written = -1;
gl.getProgramResourceName(program.getProgram(), programMemberInterfaceValue, activeVariableIndices[varNdx], nameLength+1, &written, &nameBuffer[0]);
GLU_EXPECT_NO_ERROR(gl.getError(), "getProgramResourceName");
if (written <= 0)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, name query failed, no data written" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "name query failed");
continue;
}
else if (written > nameLength)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, name query failed, query returned too much data" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "name query failed");
continue;
}
activeResourceNames[varNdx] = std::string(&nameBuffer[0], written);
}
// log collected names
{
tcu::MessageBuilder builder(&m_testCtx.getLog());
builder << "Active variables:\n";
for (int varNdx = 0; varNdx < numActiveResources; ++varNdx)
builder << "\t" << activeResourceNames[varNdx] << "\n";
builder << tcu::TestLog::EndMessage;
}
}
// verify names
{
glu::InterfaceBlock* block = DE_NULL;
const std::string blockName = glu::parseVariableName(blockNames[blockNdx].c_str());
std::vector<std::string> referenceList;
for (int interfaceNdx = 0; interfaceNdx < (int)m_program->getShaders()[0]->getDefaultBlock().interfaceBlocks.size(); ++interfaceNdx)
{
if (m_program->getShaders()[0]->getDefaultBlock().interfaceBlocks[interfaceNdx].interfaceName == blockName)
{
block = &m_program->getShaders()[0]->getDefaultBlock().interfaceBlocks[interfaceNdx];
break;
}
}
if (!block)
throw tcu::InternalError("could not find block referenced in the reference resource list");
// generate reference list
referenceList = getProgramInterfaceBlockMemberResourceList(*block);
{
tcu::MessageBuilder builder(&m_testCtx.getLog());
builder << "Expected variable names:\n";
for (int varNdx = 0; varNdx < (int)referenceList.size(); ++varNdx)
builder << "\t" << referenceList[varNdx] << "\n";
builder << tcu::TestLog::EndMessage;
}
// compare lists
{
bool listsIdentical = true;
for (int ndx = 0; ndx < (int)referenceList.size(); ++ndx)
{
if (!de::contains(activeResourceNames.begin(), activeResourceNames.end(), referenceList[ndx]))
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, variable name list did not contain active variable " << referenceList[ndx] << tcu::TestLog::EndMessage;
listsIdentical = false;
}
}
for (int ndx = 0; ndx < (int)activeResourceNames.size(); ++ndx)
{
if (!de::contains(referenceList.begin(), referenceList.end(), activeResourceNames[ndx]))
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, variable name list contains unexpected resource \"" << activeResourceNames[ndx] << "\"" << tcu::TestLog::EndMessage;
listsIdentical = false;
}
}
if (listsIdentical)
m_testCtx.getLog() << tcu::TestLog::Message << "Lists identical" << tcu::TestLog::EndMessage;
else
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, invalid active variable list" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "invalid active variable list");
continue;
}
}
}
}
// Max num active variables
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "MaxNumActiveVariables", "MAX_NUM_ACTIVE_VARIABLES");
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
glw::GLint maxNumActiveVariables = -1;
gl.getProgramInterfaceiv(program.getProgram(), programGLInterfaceValue, GL_MAX_NUM_ACTIVE_VARIABLES, &maxNumActiveVariables);
GLU_EXPECT_NO_ERROR(gl.getError(), "query MAX_NUM_ACTIVE_VARIABLES");
m_testCtx.getLog() << tcu::TestLog::Message << "MAX_NUM_ACTIVE_VARIABLES = " << maxNumActiveVariables << tcu::TestLog::EndMessage;
if (expectedMaxNumActiveVariables != maxNumActiveVariables)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, got unexpected MAX_NUM_ACTIVE_VARIABLES" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "unexpected MAX_NUM_ACTIVE_VARIABLES");
}
else
m_testCtx.getLog() << tcu::TestLog::Message << "MAX_NUM_ACTIVE_VARIABLES valid" << tcu::TestLog::EndMessage;
}
return STOP;
}
class InterfaceBlockDataSizeTestCase : public InterfaceBlockBaseCase
{
public:
InterfaceBlockDataSizeTestCase (Context& context, const char* name, const char* description, glu::Storage storage, CaseType caseType);
private:
IterateResult iterate (void);
int getBlockMinDataSize (const std::string& blockName) const;
int getBlockMinDataSize (const glu::InterfaceBlock& block) const;
};
InterfaceBlockDataSizeTestCase::InterfaceBlockDataSizeTestCase (Context& context, const char* name, const char* description, glu::Storage storage, CaseType caseType)
: InterfaceBlockBaseCase(context, name, description, storage, caseType)
{
}
InterfaceBlockDataSizeTestCase::IterateResult InterfaceBlockDataSizeTestCase::iterate (void)
{
const ProgramInterface programInterface = (m_storage == glu::STORAGE_UNIFORM) ? (PROGRAMINTERFACE_UNIFORM_BLOCK) :
(m_storage == glu::STORAGE_BUFFER) ? (PROGRAMINTERFACE_SHADER_STORAGE_BLOCK) :
(PROGRAMINTERFACE_LAST);
const glw::GLenum programGLInterfaceValue = getProgramInterfaceGLEnum(programInterface);
const std::vector<std::string> blockNames = getProgramInterfaceResourceList(m_program, programInterface);
glu::ShaderProgram program (m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_program));
DE_ASSERT(programInterface != PROGRAMINTERFACE_LAST);
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
checkAndLogProgram(program, m_program, m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
// Verify all blocks
for (int blockNdx = 0; blockNdx < (int)blockNames.size(); ++blockNdx)
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "Block", "Block \"" + blockNames[blockNdx] + "\"");
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const glw::GLuint resourceNdx = gl.getProgramResourceIndex(program.getProgram(), programGLInterfaceValue, blockNames[blockNdx].c_str());
const int expectedMinDataSize = getBlockMinDataSize(blockNames[blockNdx]);
glw::GLint queryDataSize = -1;
GLU_EXPECT_NO_ERROR(gl.getError(), "query resource index");
if (resourceNdx == GL_INVALID_INDEX)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, getProgramResourceIndex returned GL_INVALID_INDEX for \"" << blockNames[blockNdx] << "\"" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Resource not found");
continue;
}
// query
{
const glw::GLenum prop = GL_BUFFER_DATA_SIZE;
gl.getProgramResourceiv(program.getProgram(), programGLInterfaceValue, resourceNdx, 1, &prop, 1, DE_NULL, &queryDataSize);
GLU_EXPECT_NO_ERROR(gl.getError(), "query resource BUFFER_DATA_SIZE");
}
m_testCtx.getLog()
<< tcu::TestLog::Message
<< "BUFFER_DATA_SIZE = " << queryDataSize << "\n"
<< "Buffer data size with tight packing: " << expectedMinDataSize
<< tcu::TestLog::EndMessage;
if (queryDataSize < expectedMinDataSize)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, buffer size was less than minimum buffer data size" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Buffer data size invalid");
continue;
}
else
m_testCtx.getLog() << tcu::TestLog::Message << "Buffer size valid" << tcu::TestLog::EndMessage;
}
return STOP;
}
int InterfaceBlockDataSizeTestCase::getBlockMinDataSize (const std::string& blockFullName) const
{
const std::string blockName = glu::parseVariableName(blockFullName.c_str());
for (int interfaceNdx = 0; interfaceNdx < (int)m_program->getShaders()[0]->getDefaultBlock().interfaceBlocks.size(); ++interfaceNdx)
{
if (m_program->getShaders()[0]->getDefaultBlock().interfaceBlocks[interfaceNdx].interfaceName == blockName &&
m_program->getShaders()[0]->getDefaultBlock().interfaceBlocks[interfaceNdx].storage == m_storage)
return getBlockMinDataSize(m_program->getShaders()[0]->getDefaultBlock().interfaceBlocks[interfaceNdx]);
}
DE_ASSERT(false);
return -1;
}
class AtomicCounterCase : public TestCase
{
public:
AtomicCounterCase (Context& context, const char* name, const char* description);
~AtomicCounterCase (void);
private:
void init (void);
void deinit (void);
protected:
int getNumAtomicCounterBuffers (void) const;
int getMaxNumActiveVariables (void) const;
int getBufferVariableCount (int binding) const;
int getBufferMinimumDataSize (int binding) const;
ProgramInterfaceDefinition::Program* m_program;
};
AtomicCounterCase::AtomicCounterCase (Context& context, const char* name, const char* description)
: TestCase (context, name, description)
, m_program (DE_NULL)
{
}
AtomicCounterCase::~AtomicCounterCase (void)
{
deinit();
}
void AtomicCounterCase::init (void)
{
ProgramInterfaceDefinition::Shader* shader;
glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
m_program = new ProgramInterfaceDefinition::Program();
shader = m_program->addShader(glu::SHADERTYPE_COMPUTE, glslVersion);
{
glu::VariableDeclaration decl(glu::VarType(glu::TYPE_UINT_ATOMIC_COUNTER, glu::PRECISION_LAST), "binding1_counter1", glu::STORAGE_UNIFORM);
decl.layout.binding = 1;
shader->getDefaultBlock().variables.push_back(decl);
}
{
glu::VariableDeclaration decl(glu::VarType(glu::TYPE_UINT_ATOMIC_COUNTER, glu::PRECISION_LAST), "binding1_counter2", glu::STORAGE_UNIFORM);
decl.layout.binding = 1;
decl.layout.offset = 8;
shader->getDefaultBlock().variables.push_back(decl);
}
{
glu::VariableDeclaration decl(glu::VarType(glu::TYPE_UINT_ATOMIC_COUNTER, glu::PRECISION_LAST), "binding2_counter1", glu::STORAGE_UNIFORM);
decl.layout.binding = 2;
shader->getDefaultBlock().variables.push_back(decl);
}
DE_ASSERT(m_program->isValid());
}
void AtomicCounterCase::deinit (void)
{
delete m_program;
m_program = DE_NULL;
}
int AtomicCounterCase::getNumAtomicCounterBuffers (void) const
{
std::set<int> buffers;
for (int ndx = 0; ndx < (int)m_program->getShaders()[0]->getDefaultBlock().variables.size(); ++ndx)
{
if (m_program->getShaders()[0]->getDefaultBlock().variables[ndx].varType.isBasicType() &&
glu::isDataTypeAtomicCounter(m_program->getShaders()[0]->getDefaultBlock().variables[ndx].varType.getBasicType()))
{
buffers.insert(m_program->getShaders()[0]->getDefaultBlock().variables[ndx].layout.binding);
}
}
return (int)buffers.size();
}
int AtomicCounterCase::getMaxNumActiveVariables (void) const
{
int maxVars = 0;
std::map<int,int> numBufferVars;
for (int ndx = 0; ndx < (int)m_program->getShaders()[0]->getDefaultBlock().variables.size(); ++ndx)
{
if (m_program->getShaders()[0]->getDefaultBlock().variables[ndx].varType.isBasicType() &&
glu::isDataTypeAtomicCounter(m_program->getShaders()[0]->getDefaultBlock().variables[ndx].varType.getBasicType()))
{
const int binding = m_program->getShaders()[0]->getDefaultBlock().variables[ndx].layout.binding;
if (numBufferVars.find(binding) == numBufferVars.end())
numBufferVars[binding] = 1;
else
++numBufferVars[binding];
}
}
for (std::map<int,int>::const_iterator it = numBufferVars.begin(); it != numBufferVars.end(); ++it)
maxVars = de::max(maxVars, it->second);
return maxVars;
}
int AtomicCounterCase::getBufferVariableCount (int binding) const
{
int numVars = 0;
for (int ndx = 0; ndx < (int)m_program->getShaders()[0]->getDefaultBlock().variables.size(); ++ndx)
{
if (m_program->getShaders()[0]->getDefaultBlock().variables[ndx].varType.isBasicType() &&
glu::isDataTypeAtomicCounter(m_program->getShaders()[0]->getDefaultBlock().variables[ndx].varType.getBasicType()) &&
m_program->getShaders()[0]->getDefaultBlock().variables[ndx].layout.binding == binding)
++numVars;
}
return numVars;
}
int AtomicCounterCase::getBufferMinimumDataSize (int binding) const
{
int minSize = -1;
int currentOffset = 0;
for (int ndx = 0; ndx < (int)m_program->getShaders()[0]->getDefaultBlock().variables.size(); ++ndx)
{
if (m_program->getShaders()[0]->getDefaultBlock().variables[ndx].varType.isBasicType() &&
glu::isDataTypeAtomicCounter(m_program->getShaders()[0]->getDefaultBlock().variables[ndx].varType.getBasicType()) &&
m_program->getShaders()[0]->getDefaultBlock().variables[ndx].layout.binding == binding)
{
const int thisOffset = (m_program->getShaders()[0]->getDefaultBlock().variables[ndx].layout.offset != -1) ? (m_program->getShaders()[0]->getDefaultBlock().variables[ndx].layout.offset) : (currentOffset);
currentOffset = thisOffset + 4;
minSize = de::max(minSize, thisOffset + 4);
}
}
return minSize;
}
class AtomicCounterResourceListCase : public AtomicCounterCase
{
public:
AtomicCounterResourceListCase (Context& context, const char* name, const char* description);
private:
IterateResult iterate (void);
};
AtomicCounterResourceListCase::AtomicCounterResourceListCase (Context& context, const char* name, const char* description)
: AtomicCounterCase(context, name, description)
{
}
AtomicCounterResourceListCase::IterateResult AtomicCounterResourceListCase::iterate (void)
{
const glu::ShaderProgram program(m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_program));
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
checkAndLogProgram(program, m_program, m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "ActiveResources", "ACTIVE_RESOURCES");
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
glw::GLint numActiveResources = -1;
const int numExpectedActiveResources = 2; // 2 buffer bindings
m_testCtx.getLog() << tcu::TestLog::Message << "Verifying ACTIVE_RESOURCES, expecting " << numExpectedActiveResources << tcu::TestLog::EndMessage;
gl.getProgramInterfaceiv(program.getProgram(), GL_ATOMIC_COUNTER_BUFFER, GL_ACTIVE_RESOURCES, &numActiveResources);
GLU_EXPECT_NO_ERROR(gl.getError(), "query GL_ACTIVE_RESOURCES");
m_testCtx.getLog() << tcu::TestLog::Message << "ACTIVE_RESOURCES = " << numActiveResources << tcu::TestLog::EndMessage;
if (numActiveResources != numExpectedActiveResources)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, got unexpected ACTIVE_RESOURCES" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got unexpected ACTIVE_RESOURCES");
}
else
m_testCtx.getLog() << tcu::TestLog::Message << "ACTIVE_RESOURCES valid" << tcu::TestLog::EndMessage;
}
return STOP;
}
class AtomicCounterActiveVariablesCase : public AtomicCounterCase
{
public:
AtomicCounterActiveVariablesCase (Context& context, const char* name, const char* description);
private:
IterateResult iterate (void);
};
AtomicCounterActiveVariablesCase::AtomicCounterActiveVariablesCase (Context& context, const char* name, const char* description)
: AtomicCounterCase(context, name, description)
{
}
AtomicCounterActiveVariablesCase::IterateResult AtomicCounterActiveVariablesCase::iterate (void)
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const glu::ShaderProgram program (m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_program));
const int numAtomicBuffers = getNumAtomicCounterBuffers();
const int expectedMaxNumActiveVariables = getMaxNumActiveVariables();
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
checkAndLogProgram(program, m_program, m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
// check active variables
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "Interface", "ATOMIC_COUNTER_BUFFER interface");
glw::GLint queryActiveResources = -1;
glw::GLint queryMaxNumActiveVariables = -1;
gl.getProgramInterfaceiv(program.getProgram(), GL_ATOMIC_COUNTER_BUFFER, GL_ACTIVE_RESOURCES, &queryActiveResources);
gl.getProgramInterfaceiv(program.getProgram(), GL_ATOMIC_COUNTER_BUFFER, GL_MAX_NUM_ACTIVE_VARIABLES, &queryMaxNumActiveVariables);
GLU_EXPECT_NO_ERROR(gl.getError(), "query interface");
m_testCtx.getLog()
<< tcu::TestLog::Message
<< "GL_ACTIVE_RESOURCES = " << queryActiveResources << "\n"
<< "GL_MAX_NUM_ACTIVE_VARIABLES = " << queryMaxNumActiveVariables << "\n"
<< tcu::TestLog::EndMessage;
if (queryActiveResources != numAtomicBuffers)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, got unexpected GL_ACTIVE_RESOURCES, expected " << numAtomicBuffers << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got unexpected GL_ACTIVE_RESOURCES");
}
if (queryMaxNumActiveVariables != expectedMaxNumActiveVariables)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, got unexpected GL_MAX_NUM_ACTIVE_VARIABLES, expected " << expectedMaxNumActiveVariables << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got unexpected GL_MAX_NUM_ACTIVE_VARIABLES");
}
}
// Check each buffer
for (int bufferNdx = 0; bufferNdx < numAtomicBuffers; ++bufferNdx)
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "Resource", "Resource index " + de::toString(bufferNdx));
std::vector<glw::GLint> activeVariables;
std::vector<std::string> memberNames;
// Find active variables
{
const glw::GLenum numActiveVariablesProp = GL_NUM_ACTIVE_VARIABLES;
const glw::GLenum activeVariablesProp = GL_ACTIVE_VARIABLES;
glw::GLint numActiveVariables = -2;
glw::GLint written = -1;
gl.getProgramResourceiv(program.getProgram(), GL_ATOMIC_COUNTER_BUFFER, bufferNdx, 1, &numActiveVariablesProp, 1, &written, &numActiveVariables);
GLU_EXPECT_NO_ERROR(gl.getError(), "query num active variables");
if (numActiveVariables <= 0)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, got unexpected NUM_ACTIVE_VARIABLES: " << numActiveVariables << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got unexpected NUM_ACTIVE_VARIABLES");
continue;
}
if (written <= 0)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for NUM_ACTIVE_VARIABLES returned no values" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "NUM_ACTIVE_VARIABLES query failed");
continue;
}
m_testCtx.getLog() << tcu::TestLog::Message << "GL_NUM_ACTIVE_VARIABLES = " << numActiveVariables << tcu::TestLog::EndMessage;
written = -1;
activeVariables.resize(numActiveVariables + 1, -2);
gl.getProgramResourceiv(program.getProgram(), GL_ATOMIC_COUNTER_BUFFER, bufferNdx, 1, &activeVariablesProp, numActiveVariables, &written, &activeVariables[0]);
GLU_EXPECT_NO_ERROR(gl.getError(), "query active variables");
if (written != numActiveVariables)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, unexpected number of ACTIVE_VARIABLES, NUM_ACTIVE_VARIABLES = " << numActiveVariables << ", query returned " << written << " values" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got unexpected ACTIVE_VARIABLES");
continue;
}
if (activeVariables.back() != -2)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for ACTIVE_VARIABLES wrote over target buffer bounds" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "ACTIVE_VARIABLES query failed");
continue;
}
activeVariables.pop_back();
}
// log indices
{
tcu::MessageBuilder builder(&m_testCtx.getLog());
builder << "Active variable indices: {";
for (int varNdx = 0; varNdx < (int)activeVariables.size(); ++varNdx)
{
if (varNdx)
builder << ", ";
builder << activeVariables[varNdx];
}
builder << "}" << tcu::TestLog::EndMessage;
}
// collect member names
for (int ndx = 0; ndx < (int)activeVariables.size(); ++ndx)
{
const glw::GLenum nameLengthProp = GL_NAME_LENGTH;
glw::GLint nameLength = -1;
glw::GLint written = -1;
std::vector<char> nameBuf;
gl.getProgramResourceiv(program.getProgram(), GL_UNIFORM, activeVariables[ndx], 1, &nameLengthProp, 1, &written, &nameLength);
GLU_EXPECT_NO_ERROR(gl.getError(), "query buffer variable name length");
if (written <= 0 || nameLength == -1)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for GL_NAME_LENGTH returned no values" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "GL_NAME_LENGTH query failed");
continue;
}
nameBuf.resize(nameLength + 2, 'X'); // +2 to tolerate potential off-by-ones in some implementations, name queries will check these cases better
written = -1;
gl.getProgramResourceName(program.getProgram(), GL_UNIFORM, activeVariables[ndx], (int)nameBuf.size(), &written, &nameBuf[0]);
GLU_EXPECT_NO_ERROR(gl.getError(), "query buffer variable name");
if (written <= 0)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for resource name returned no name" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Name query failed");
continue;
}
memberNames.push_back(std::string(&nameBuf[0], written));
}
// log names
{
tcu::MessageBuilder builder(&m_testCtx.getLog());
builder << "Active variables:\n";
for (int varNdx = 0; varNdx < (int)memberNames.size(); ++varNdx)
{
builder << "\t" << memberNames[varNdx] << "\n";
}
builder << tcu::TestLog::EndMessage;
}
// check names are all in the same buffer
{
bool bindingsValid = true;
m_testCtx.getLog() << tcu::TestLog::Message << "Verifying names" << tcu::TestLog::EndMessage;
for (int nameNdx = 0; nameNdx < (int)memberNames.size(); ++nameNdx)
{
int prevBinding = -1;
for (int varNdx = 0; varNdx < (int)m_program->getShaders()[0]->getDefaultBlock().variables.size(); ++varNdx)
{
if (m_program->getShaders()[0]->getDefaultBlock().variables[varNdx].name == memberNames[nameNdx])
{
const int varBinding = m_program->getShaders()[0]->getDefaultBlock().variables[varNdx].layout.binding;
if (prevBinding == -1 || prevBinding == varBinding)
prevBinding = varBinding;
else
bindingsValid = false;
}
}
if (prevBinding == -1)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, could not find variable with name \"" << memberNames[nameNdx] << "\"" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Variable name invalid");
}
else if (getBufferVariableCount(prevBinding) != (int)memberNames.size())
{
m_testCtx.getLog()
<< tcu::TestLog::Message
<< "Error, unexpected variable count for binding " << prevBinding
<< ". Expected " << getBufferVariableCount(prevBinding) << ", got " << (int)memberNames.size()
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Variable names invalid");
}
}
if (!bindingsValid)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, all resource do not share the same buffer" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Active variables invalid");
continue;
}
}
}
return STOP;
}
class AtomicCounterBufferBindingCase : public AtomicCounterCase
{
public:
AtomicCounterBufferBindingCase (Context& context, const char* name, const char* description);
private:
IterateResult iterate (void);
};
AtomicCounterBufferBindingCase::AtomicCounterBufferBindingCase (Context& context, const char* name, const char* description)
: AtomicCounterCase(context, name, description)
{
}
AtomicCounterBufferBindingCase::IterateResult AtomicCounterBufferBindingCase::iterate (void)
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const glu::ShaderProgram program (m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_program));
const int numAtomicBuffers = getNumAtomicCounterBuffers();
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
checkAndLogProgram(program, m_program, m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
// check every buffer
for (int bufferNdx = 0; bufferNdx < numAtomicBuffers; ++bufferNdx)
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "Resource", "Resource index " + de::toString(bufferNdx));
const glw::GLenum bufferBindingProp = GL_BUFFER_BINDING;
glw::GLint bufferBinding = -1;
glw::GLint written = -1;
gl.getProgramResourceiv(program.getProgram(), GL_ATOMIC_COUNTER_BUFFER, bufferNdx, 1, &bufferBindingProp, 1, &written, &bufferBinding);
GLU_EXPECT_NO_ERROR(gl.getError(), "query buffer binding");
if (written <= 0)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for BUFFER_BINDING returned no values." << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "BUFFER_BINDING query failed");
}
m_testCtx.getLog() << tcu::TestLog::Message << "GL_BUFFER_BINDING = " << bufferBinding << tcu::TestLog::EndMessage;
// no such buffer binding?
if (getBufferVariableCount(bufferBinding) == 0)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, got buffer with BUFFER_BINDING = " << bufferBinding << ", but such buffer does not exist." << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got unexpected BUFFER_BINDING");
}
}
return STOP;
}
class AtomicCounterBufferDataSizeCase : public AtomicCounterCase
{
public:
AtomicCounterBufferDataSizeCase (Context& context, const char* name, const char* description);
private:
IterateResult iterate (void);
};
AtomicCounterBufferDataSizeCase::AtomicCounterBufferDataSizeCase (Context& context, const char* name, const char* description)
: AtomicCounterCase(context, name, description)
{
}
AtomicCounterBufferDataSizeCase::IterateResult AtomicCounterBufferDataSizeCase::iterate (void)
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const glu::ShaderProgram program (m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_program));
const int numAtomicBuffers = getNumAtomicCounterBuffers();
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
checkAndLogProgram(program, m_program, m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
// check every buffer
for (int bufferNdx = 0; bufferNdx < numAtomicBuffers; ++bufferNdx)
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "Resource", "Resource index " + de::toString(bufferNdx));
const glw::GLenum props[] = { GL_BUFFER_BINDING, GL_BUFFER_DATA_SIZE };
glw::GLint values[] = { -1, -1 };
glw::GLint written = -1;
int bufferMinDataSize;
gl.getProgramResourceiv(program.getProgram(), GL_ATOMIC_COUNTER_BUFFER, bufferNdx, DE_LENGTH_OF_ARRAY(props), props, DE_LENGTH_OF_ARRAY(values), &written, values);
GLU_EXPECT_NO_ERROR(gl.getError(), "query buffer binding");
if (written != 2)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for (BUFFER_BINDING, BUFFER_DATA_SIZE) returned " << written << " value(s)." << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "property query failed");
continue;
}
m_testCtx.getLog()
<< tcu::TestLog::Message
<< "GL_BUFFER_BINDING = " << values[0] << "\n"
<< "GL_BUFFER_DATA_SIZE = " << values[1]
<< tcu::TestLog::EndMessage;
bufferMinDataSize = getBufferMinimumDataSize(values[0]);
m_testCtx.getLog() << tcu::TestLog::Message << "Verifying data size, expected greater than or equal to " << bufferMinDataSize << tcu::TestLog::EndMessage;
// no such buffer binding?
if (bufferMinDataSize == -1)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, got buffer with BUFFER_BINDING = " << values[0] << ", but such buffer does not exist." << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got unexpected BUFFER_BINDING");
}
else if (values[1] < bufferMinDataSize)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, got buffer with BUFFER_DATA_SIZE = " << values[1] << ", expected greater than or equal to " << bufferMinDataSize << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got unexpected BUFFER_BINDING");
}
else
m_testCtx.getLog() << tcu::TestLog::Message << "Data size valid" << tcu::TestLog::EndMessage;
}
return STOP;
}
class AtomicCounterReferencedByCase : public TestCase
{
public:
AtomicCounterReferencedByCase (Context& context,
const char* name,
const char* description,
bool separable,
deUint32 presentStagesMask,
deUint32 activeStagesMask);
~AtomicCounterReferencedByCase (void);
private:
void init (void);
void deinit (void);
IterateResult iterate (void);
const bool m_separable;
const deUint32 m_presentStagesMask;
const deUint32 m_activeStagesMask;
ProgramInterfaceDefinition::Program* m_program;
};
AtomicCounterReferencedByCase::AtomicCounterReferencedByCase (Context& context,
const char* name,
const char* description,
bool separable,
deUint32 presentStagesMask,
deUint32 activeStagesMask)
: TestCase (context, name, description)
, m_separable (separable)
, m_presentStagesMask (presentStagesMask)
, m_activeStagesMask (activeStagesMask)
, m_program (DE_NULL)
{
DE_ASSERT((activeStagesMask & presentStagesMask) == activeStagesMask);
}
AtomicCounterReferencedByCase::~AtomicCounterReferencedByCase (void)
{
deinit();
}
void AtomicCounterReferencedByCase::init (void)
{
const deUint32 geometryMask = (1 << glu::SHADERTYPE_GEOMETRY);
const deUint32 tessellationMask = (1 << glu::SHADERTYPE_TESSELLATION_CONTROL) | (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION);
glu::VariableDeclaration atomicVar (glu::VarType(glu::TYPE_UINT_ATOMIC_COUNTER, glu::PRECISION_LAST), "targetCounter", glu::STORAGE_UNIFORM);
const glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
const bool supportsES32orGL45 = checkSupport(m_context);
if ((m_presentStagesMask & tessellationMask) != 0 && !supportsES32orGL45 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader"))
throw tcu::NotSupportedError("Test requires GL_EXT_tessellation_shader extension");
if ((m_presentStagesMask & geometryMask) != 0 && !supportsES32orGL45 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"))
throw tcu::NotSupportedError("Test requires GL_EXT_geometry_shader extension");
atomicVar.layout.binding = 1;
m_program = new ProgramInterfaceDefinition::Program();
m_program->setSeparable(m_separable);
for (int shaderType = 0; shaderType < glu::SHADERTYPE_LAST; ++shaderType)
{
if (m_activeStagesMask & (1 << shaderType))
m_program->addShader((glu::ShaderType)shaderType, glslVersion)->getDefaultBlock().variables.push_back(atomicVar);
else if (m_presentStagesMask & (1 << shaderType))
m_program->addShader((glu::ShaderType)shaderType, glslVersion);
}
if (m_program->hasStage(glu::SHADERTYPE_GEOMETRY))
m_program->setGeometryNumOutputVertices(1);
if (m_program->hasStage(glu::SHADERTYPE_TESSELLATION_CONTROL) || m_program->hasStage(glu::SHADERTYPE_TESSELLATION_EVALUATION))
m_program->setTessellationNumOutputPatchVertices(1);
DE_ASSERT(m_program->isValid());
}
void AtomicCounterReferencedByCase::deinit (void)
{
delete m_program;
m_program = DE_NULL;
}
AtomicCounterReferencedByCase::IterateResult AtomicCounterReferencedByCase::iterate (void)
{
const glu::RenderContext& rc = m_context.getRenderContext();
const bool isES32orGL45 = glu::contextSupports(rc.getType(), glu::ApiType::es(3, 2)) ||
glu::contextSupports(rc.getType(), glu::ApiType::core(4, 5));
const struct
{
glw::GLenum propName;
glu::ShaderType shaderType;
const char* extension;
} targetProps[] =
{
{ GL_REFERENCED_BY_VERTEX_SHADER, glu::SHADERTYPE_VERTEX, DE_NULL },
{ GL_REFERENCED_BY_FRAGMENT_SHADER, glu::SHADERTYPE_FRAGMENT, DE_NULL },
{ GL_REFERENCED_BY_COMPUTE_SHADER, glu::SHADERTYPE_COMPUTE, DE_NULL },
{ GL_REFERENCED_BY_TESS_CONTROL_SHADER, glu::SHADERTYPE_TESSELLATION_CONTROL, (isES32orGL45 ? DE_NULL : "GL_EXT_tessellation_shader") },
{ GL_REFERENCED_BY_TESS_EVALUATION_SHADER, glu::SHADERTYPE_TESSELLATION_EVALUATION, (isES32orGL45 ? DE_NULL : "GL_EXT_tessellation_shader") },
{ GL_REFERENCED_BY_GEOMETRY_SHADER, glu::SHADERTYPE_GEOMETRY, (isES32orGL45 ? DE_NULL : "GL_EXT_geometry_shader") },
};
const glw::Functions& gl = rc.getFunctions();
const glu::ShaderProgram program (rc, generateProgramInterfaceProgramSources(m_program));
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
checkAndLogProgram(program, m_program, rc.getFunctions(), m_testCtx.getLog());
// check props
for (int propNdx = 0; propNdx < DE_LENGTH_OF_ARRAY(targetProps); ++propNdx)
{
if (targetProps[propNdx].extension == DE_NULL || m_context.getContextInfo().isExtensionSupported(targetProps[propNdx].extension))
{
const glw::GLenum prop = targetProps[propNdx].propName;
const glw::GLint expected = ((m_activeStagesMask & (1 << targetProps[propNdx].shaderType)) != 0) ? (GL_TRUE) : (GL_FALSE);
glw::GLint value = -1;
glw::GLint written = -1;
m_testCtx.getLog() << tcu::TestLog::Message << "Verifying " << glu::getProgramResourcePropertyName(prop) << ", expecting " << glu::getBooleanName(expected) << tcu::TestLog::EndMessage;
gl.getProgramResourceiv(program.getProgram(), GL_ATOMIC_COUNTER_BUFFER, 0, 1, &prop, 1, &written, &value);
GLU_EXPECT_NO_ERROR(gl.getError(), "query buffer binding");
if (written != 1)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for referenced_by_* returned invalid number of values." << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "property query failed");
continue;
}
m_testCtx.getLog() << tcu::TestLog::Message << glu::getProgramResourcePropertyName(prop) << " = " << glu::getBooleanStr(value) << tcu::TestLog::EndMessage;
if (value != expected)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, got unexpected value" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "unexpected property value");
continue;
}
}
}
return STOP;
}
class ProgramInputOutputReferencedByCase : public TestCase
{
public:
enum CaseType
{
CASE_VERTEX_FRAGMENT = 0,
CASE_VERTEX_GEO_FRAGMENT,
CASE_VERTEX_TESS_FRAGMENT,
CASE_VERTEX_TESS_GEO_FRAGMENT,
CASE_SEPARABLE_VERTEX,
CASE_SEPARABLE_FRAGMENT,
CASE_SEPARABLE_GEOMETRY,
CASE_SEPARABLE_TESS_CTRL,
CASE_SEPARABLE_TESS_EVAL,
CASE_LAST
};
ProgramInputOutputReferencedByCase (Context& context, const char* name, const char* description, glu::Storage targetStorage, CaseType caseType);
~ProgramInputOutputReferencedByCase (void);
private:
void init (void);
void deinit (void);
IterateResult iterate (void);
const CaseType m_caseType;
const glu::Storage m_targetStorage;
ProgramInterfaceDefinition::Program* m_program;
};
ProgramInputOutputReferencedByCase::ProgramInputOutputReferencedByCase (Context& context, const char* name, const char* description, glu::Storage targetStorage, CaseType caseType)
: TestCase (context, name, description)
, m_caseType (caseType)
, m_targetStorage (targetStorage)
, m_program (DE_NULL)
{
DE_ASSERT(caseType < CASE_LAST);
}
ProgramInputOutputReferencedByCase::~ProgramInputOutputReferencedByCase (void)
{
deinit();
}
void ProgramInputOutputReferencedByCase::init (void)
{
const bool hasTessellationShader = (m_caseType == CASE_VERTEX_TESS_FRAGMENT) ||
(m_caseType == CASE_VERTEX_TESS_GEO_FRAGMENT) ||
(m_caseType == CASE_SEPARABLE_TESS_CTRL) ||
(m_caseType == CASE_SEPARABLE_TESS_EVAL);
const bool hasGeometryShader = (m_caseType == CASE_VERTEX_GEO_FRAGMENT) ||
(m_caseType == CASE_VERTEX_TESS_GEO_FRAGMENT) ||
(m_caseType == CASE_SEPARABLE_GEOMETRY);
const bool supportsES32orGL45 = checkSupport(m_context);
if (hasTessellationShader && !supportsES32orGL45 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader"))
throw tcu::NotSupportedError("Test requires GL_EXT_tessellation_shader extension");
if (hasGeometryShader && !supportsES32orGL45 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"))
throw tcu::NotSupportedError("Test requires GL_EXT_geometry_shader extension");
glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
m_program = new ProgramInterfaceDefinition::Program();
if (m_caseType == CASE_SEPARABLE_VERTEX ||
m_caseType == CASE_SEPARABLE_FRAGMENT ||
m_caseType == CASE_SEPARABLE_GEOMETRY ||
m_caseType == CASE_SEPARABLE_TESS_CTRL ||
m_caseType == CASE_SEPARABLE_TESS_EVAL)
{
const bool isInputCase = (m_targetStorage == glu::STORAGE_IN || m_targetStorage == glu::STORAGE_PATCH_IN);
const bool perPatchStorage = (m_targetStorage == glu::STORAGE_PATCH_IN || m_targetStorage == glu::STORAGE_PATCH_OUT);
const char* varName = (isInputCase) ? ("shaderInput") : ("shaderOutput");
const glu::VariableDeclaration targetDecl (glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), varName, m_targetStorage);
const glu::ShaderType shaderType = (m_caseType == CASE_SEPARABLE_VERTEX) ? (glu::SHADERTYPE_VERTEX)
: (m_caseType == CASE_SEPARABLE_FRAGMENT) ? (glu::SHADERTYPE_FRAGMENT)
: (m_caseType == CASE_SEPARABLE_GEOMETRY) ? (glu::SHADERTYPE_GEOMETRY)
: (m_caseType == CASE_SEPARABLE_TESS_CTRL) ? (glu::SHADERTYPE_TESSELLATION_CONTROL)
: (m_caseType == CASE_SEPARABLE_TESS_EVAL) ? (glu::SHADERTYPE_TESSELLATION_EVALUATION)
: (glu::SHADERTYPE_LAST);
const bool arrayedInterface = (isInputCase) ? ((shaderType == glu::SHADERTYPE_GEOMETRY) ||
(shaderType == glu::SHADERTYPE_TESSELLATION_CONTROL) ||
(shaderType == glu::SHADERTYPE_TESSELLATION_EVALUATION))
: (shaderType == glu::SHADERTYPE_TESSELLATION_CONTROL);
m_program->setSeparable(true);
if (arrayedInterface && !perPatchStorage)
{
const glu::VariableDeclaration targetDeclArr(glu::VarType(targetDecl.varType, glu::VarType::UNSIZED_ARRAY), varName, m_targetStorage);
m_program->addShader(shaderType, glslVersion)->getDefaultBlock().variables.push_back(targetDeclArr);
}
else
{
m_program->addShader(shaderType, glslVersion)->getDefaultBlock().variables.push_back(targetDecl);
}
}
else if (m_caseType == CASE_VERTEX_FRAGMENT ||
m_caseType == CASE_VERTEX_GEO_FRAGMENT ||
m_caseType == CASE_VERTEX_TESS_FRAGMENT ||
m_caseType == CASE_VERTEX_TESS_GEO_FRAGMENT)
{
ProgramInterfaceDefinition::Shader* vertex = m_program->addShader(glu::SHADERTYPE_VERTEX, glslVersion);
ProgramInterfaceDefinition::Shader* fragment = m_program->addShader(glu::SHADERTYPE_FRAGMENT, glslVersion);
m_program->setSeparable(false);
vertex->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP),
"shaderInput",
glu::STORAGE_IN));
vertex->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP),
"shaderOutput",
glu::STORAGE_OUT,
glu::INTERPOLATION_LAST,
glu::Layout(1)));
fragment->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP),
"shaderOutput",
glu::STORAGE_OUT,
glu::INTERPOLATION_LAST,
glu::Layout(0)));
fragment->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP),
"shaderInput",
glu::STORAGE_IN,
glu::INTERPOLATION_LAST,
glu::Layout(1)));
if (m_caseType == CASE_VERTEX_TESS_FRAGMENT || m_caseType == CASE_VERTEX_TESS_GEO_FRAGMENT)
{
ProgramInterfaceDefinition::Shader* tessCtrl = m_program->addShader(glu::SHADERTYPE_TESSELLATION_CONTROL, glslVersion);
ProgramInterfaceDefinition::Shader* tessEval = m_program->addShader(glu::SHADERTYPE_TESSELLATION_EVALUATION, glslVersion);
tessCtrl->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), glu::VarType::UNSIZED_ARRAY),
"shaderInput",
glu::STORAGE_IN,
glu::INTERPOLATION_LAST,
glu::Layout(1)));
tessCtrl->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), glu::VarType::UNSIZED_ARRAY),
"shaderOutput",
glu::STORAGE_OUT,
glu::INTERPOLATION_LAST,
glu::Layout(1)));
tessEval->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), glu::VarType::UNSIZED_ARRAY),
"shaderInput",
glu::STORAGE_IN,
glu::INTERPOLATION_LAST,
glu::Layout(1)));
tessEval->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP),
"shaderOutput",
glu::STORAGE_OUT,
glu::INTERPOLATION_LAST,
glu::Layout(1)));
}
if (m_caseType == CASE_VERTEX_GEO_FRAGMENT || m_caseType == CASE_VERTEX_TESS_GEO_FRAGMENT)
{
ProgramInterfaceDefinition::Shader* geometry = m_program->addShader(glu::SHADERTYPE_GEOMETRY, glslVersion);
geometry->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), glu::VarType::UNSIZED_ARRAY),
"shaderInput",
glu::STORAGE_IN,
glu::INTERPOLATION_LAST,
glu::Layout(1)));
geometry->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP),
"shaderOutput",
glu::STORAGE_OUT,
glu::INTERPOLATION_LAST,
glu::Layout(1)));
}
}
else
DE_ASSERT(false);
if (m_program->hasStage(glu::SHADERTYPE_GEOMETRY))
m_program->setGeometryNumOutputVertices(1);
if (m_program->hasStage(glu::SHADERTYPE_TESSELLATION_CONTROL) || m_program->hasStage(glu::SHADERTYPE_TESSELLATION_EVALUATION))
m_program->setTessellationNumOutputPatchVertices(1);
DE_ASSERT(m_program->isValid());
}
void ProgramInputOutputReferencedByCase::deinit (void)
{
delete m_program;
m_program = DE_NULL;
}
ProgramInputOutputReferencedByCase::IterateResult ProgramInputOutputReferencedByCase::iterate (void)
{
static const struct
{
glw::GLenum propName;
glu::ShaderType shaderType;
const char* extension;
} targetProps[] =
{
{ GL_REFERENCED_BY_VERTEX_SHADER, glu::SHADERTYPE_VERTEX, DE_NULL },
{ GL_REFERENCED_BY_FRAGMENT_SHADER, glu::SHADERTYPE_FRAGMENT, DE_NULL },
{ GL_REFERENCED_BY_COMPUTE_SHADER, glu::SHADERTYPE_COMPUTE, DE_NULL },
{ GL_REFERENCED_BY_TESS_CONTROL_SHADER, glu::SHADERTYPE_TESSELLATION_CONTROL, "GL_EXT_tessellation_shader" },
{ GL_REFERENCED_BY_TESS_EVALUATION_SHADER, glu::SHADERTYPE_TESSELLATION_EVALUATION, "GL_EXT_tessellation_shader" },
{ GL_REFERENCED_BY_GEOMETRY_SHADER, glu::SHADERTYPE_GEOMETRY, "GL_EXT_geometry_shader" },
};
const bool isInputCase = (m_targetStorage == glu::STORAGE_IN || m_targetStorage == glu::STORAGE_PATCH_IN);
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const glu::ShaderProgram program (m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_program));
const std::string targetResourceName = (isInputCase) ? ("shaderInput") : ("shaderOutput");
const glw::GLenum programGLInterface = (isInputCase) ? (GL_PROGRAM_INPUT) : (GL_PROGRAM_OUTPUT);
glw::GLuint resourceIndex;
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
checkAndLogProgram(program, m_program, m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
// find target resource index
resourceIndex = gl.getProgramResourceIndex(program.getProgram(), programGLInterface, targetResourceName.c_str());
GLU_EXPECT_NO_ERROR(gl.getError(), "query resource index");
if (resourceIndex == GL_INVALID_INDEX)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for resource \"" << targetResourceName << "\" index returned invalid index." << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "could not find target resource");
return STOP;
}
// check props
for (int propNdx = 0; propNdx < DE_LENGTH_OF_ARRAY(targetProps); ++propNdx)
{
if (targetProps[propNdx].extension == DE_NULL || m_context.getContextInfo().isExtensionSupported(targetProps[propNdx].extension))
{
const glw::GLenum prop = targetProps[propNdx].propName;
const bool expected = (isInputCase) ? (targetProps[propNdx].shaderType == m_program->getFirstStage()) : (targetProps[propNdx].shaderType == m_program->getLastStage());
glw::GLint value = -1;
glw::GLint written = -1;
m_testCtx.getLog() << tcu::TestLog::Message << "Verifying " << glu::getProgramResourcePropertyName(prop) << ", expecting " << ((expected) ? ("TRUE") : ("FALSE")) << tcu::TestLog::EndMessage;
gl.getProgramResourceiv(program.getProgram(), programGLInterface, resourceIndex, 1, &prop, 1, &written, &value);
GLU_EXPECT_NO_ERROR(gl.getError(), "query buffer binding");
if (written != 1)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, query for referenced_by_* returned invalid number of values." << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "property query failed");
continue;
}
m_testCtx.getLog() << tcu::TestLog::Message << glu::getProgramResourcePropertyName(prop) << " = " << glu::getBooleanStr(value) << tcu::TestLog::EndMessage;
if (value != ((expected) ? (GL_TRUE) : (GL_FALSE)))
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, got unexpected value" << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "unexpected property value");
continue;
}
}
}
return STOP;
}
class FeedbackResourceListTestCase : public ResourceListTestCase
{
public:
FeedbackResourceListTestCase (Context& context, const ResourceDefinition::Node::SharedPtr& resource, const char* name);
~FeedbackResourceListTestCase (void);
private:
IterateResult iterate (void);
};
FeedbackResourceListTestCase::FeedbackResourceListTestCase (Context& context, const ResourceDefinition::Node::SharedPtr& resource, const char* name)
: ResourceListTestCase(context, resource, PROGRAMINTERFACE_TRANSFORM_FEEDBACK_VARYING, name)
{
}
FeedbackResourceListTestCase::~FeedbackResourceListTestCase (void)
{
deinit();
}
FeedbackResourceListTestCase::IterateResult FeedbackResourceListTestCase::iterate (void)
{
const glu::ShaderProgram program(m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_programDefinition));
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
// Feedback varyings
{
tcu::MessageBuilder builder(&m_testCtx.getLog());
builder << "Transform feedback varyings: {";
for (int ndx = 0; ndx < (int)m_programDefinition->getTransformFeedbackVaryings().size(); ++ndx)
{
if (ndx)
builder << ", ";
builder << "\"" << m_programDefinition->getTransformFeedbackVaryings()[ndx] << "\"";
}
builder << "}" << tcu::TestLog::EndMessage;
}
checkAndLogProgram(program, m_programDefinition, m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
// Check resource list
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "ResourceList", "Resource list");
std::vector<std::string> resourceList;
std::vector<std::string> expectedResources;
queryResourceList(resourceList, program.getProgram());
expectedResources = getProgramInterfaceResourceList(m_programDefinition, m_programInterface);
// verify the list and the expected list match
if (!verifyResourceList(resourceList, expectedResources))
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "invalid resource list");
// verify GetProgramResourceIndex() matches the indices of the list
if (!verifyResourceIndexQuery(resourceList, expectedResources, program.getProgram()))
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "GetProgramResourceIndex returned unexpected values");
// Verify MAX_NAME_LENGTH
if (!verifyMaxNameLength(resourceList, program.getProgram()))
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "MAX_NAME_LENGTH invalid");
}
return STOP;
}
int InterfaceBlockDataSizeTestCase::getBlockMinDataSize (const glu::InterfaceBlock& block) const
{
int dataSize = 0;
for (int ndx = 0; ndx < (int)block.variables.size(); ++ndx)
dataSize += getVarTypeSize(block.variables[ndx].varType);
return dataSize;
}
static bool isDataTypeLayoutQualified (glu::DataType type)
{
return glu::isDataTypeImage(type) || glu::isDataTypeAtomicCounter(type);
}
static void generateVariableCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, const ProgramResourceQueryTestTarget& queryTarget, int expandLevel = 3, bool createTestGroup = true)
{
static const struct
{
int level;
glu::DataType dataType;
} variableTypes[] =
{
{ 0, glu::TYPE_FLOAT },
{ 1, glu::TYPE_INT },
{ 1, glu::TYPE_UINT },
{ 1, glu::TYPE_BOOL },
{ 3, glu::TYPE_FLOAT_VEC2 },
{ 1, glu::TYPE_FLOAT_VEC3 },
{ 1, glu::TYPE_FLOAT_VEC4 },
{ 3, glu::TYPE_INT_VEC2 },
{ 2, glu::TYPE_INT_VEC3 },
{ 3, glu::TYPE_INT_VEC4 },
{ 3, glu::TYPE_UINT_VEC2 },
{ 2, glu::TYPE_UINT_VEC3 },
{ 3, glu::TYPE_UINT_VEC4 },
{ 3, glu::TYPE_BOOL_VEC2 },
{ 2, glu::TYPE_BOOL_VEC3 },
{ 3, glu::TYPE_BOOL_VEC4 },
{ 2, glu::TYPE_FLOAT_MAT2 },
{ 3, glu::TYPE_FLOAT_MAT2X3 },
{ 3, glu::TYPE_FLOAT_MAT2X4 },
{ 2, glu::TYPE_FLOAT_MAT3X2 },
{ 2, glu::TYPE_FLOAT_MAT3 },
{ 3, glu::TYPE_FLOAT_MAT3X4 },
{ 2, glu::TYPE_FLOAT_MAT4X2 },
{ 3, glu::TYPE_FLOAT_MAT4X3 },
{ 2, glu::TYPE_FLOAT_MAT4 },
};
tcu::TestCaseGroup* group;
if (createTestGroup)
{
group = new tcu::TestCaseGroup(context.getTestContext(), "basic_type", "Basic variable");
targetGroup->addChild(group);
}
else
group = targetGroup;
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(variableTypes); ++ndx)
{
if (variableTypes[ndx].level <= expandLevel)
{
const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(parentStructure, variableTypes[ndx].dataType));
group->addChild(new ResourceTestCase(context, variable, queryTarget));
}
}
}
static void generateOpaqueTypeCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, const ProgramResourceQueryTestTarget& queryTarget, int expandLevel = 3, bool createTestGroup = true)
{
static const struct
{
int level;
glu::DataType dataType;
} variableTypes[] =
{
{ 0, glu::TYPE_SAMPLER_2D },
{ 2, glu::TYPE_SAMPLER_CUBE },
{ 1, glu::TYPE_SAMPLER_2D_ARRAY },
{ 1, glu::TYPE_SAMPLER_3D },
{ 2, glu::TYPE_SAMPLER_2D_SHADOW },
{ 3, glu::TYPE_SAMPLER_CUBE_SHADOW },
{ 3, glu::TYPE_SAMPLER_2D_ARRAY_SHADOW },
{ 1, glu::TYPE_INT_SAMPLER_2D },
{ 3, glu::TYPE_INT_SAMPLER_CUBE },
{ 3, glu::TYPE_INT_SAMPLER_2D_ARRAY },
{ 3, glu::TYPE_INT_SAMPLER_3D },
{ 2, glu::TYPE_UINT_SAMPLER_2D },
{ 3, glu::TYPE_UINT_SAMPLER_CUBE },
{ 3, glu::TYPE_UINT_SAMPLER_2D_ARRAY },
{ 3, glu::TYPE_UINT_SAMPLER_3D },
{ 2, glu::TYPE_SAMPLER_2D_MULTISAMPLE },
{ 2, glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE },
{ 3, glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE },
{ 1, glu::TYPE_IMAGE_2D },
{ 3, glu::TYPE_IMAGE_CUBE },
{ 3, glu::TYPE_IMAGE_2D_ARRAY },
{ 3, glu::TYPE_IMAGE_3D },
{ 3, glu::TYPE_INT_IMAGE_2D },
{ 3, glu::TYPE_INT_IMAGE_CUBE },
{ 1, glu::TYPE_INT_IMAGE_2D_ARRAY },
{ 3, glu::TYPE_INT_IMAGE_3D },
{ 2, glu::TYPE_UINT_IMAGE_2D },
{ 3, glu::TYPE_UINT_IMAGE_CUBE },
{ 3, glu::TYPE_UINT_IMAGE_2D_ARRAY },
{ 3, glu::TYPE_UINT_IMAGE_3D },
{ 1, glu::TYPE_UINT_ATOMIC_COUNTER },
};
bool isStructMember = false;
// Requirements
for (const ResourceDefinition::Node* node = parentStructure.get(); node; node = node->getEnclosingNode())
{
// Don't insert inside a interface block
if (node->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK)
return;
isStructMember |= (node->getType() == ResourceDefinition::Node::TYPE_STRUCT_MEMBER);
}
// Add cases
{
tcu::TestCaseGroup* group;
if (createTestGroup)
{
group = new tcu::TestCaseGroup(context.getTestContext(), "opaque_type", "Opaque types");
targetGroup->addChild(group);
}
else
group = targetGroup;
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(variableTypes); ++ndx)
{
if (variableTypes[ndx].level > expandLevel)
continue;
// Layout qualifiers are not allowed on struct members
if (isDataTypeLayoutQualified(variableTypes[ndx].dataType) && isStructMember)
continue;
{
const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(parentStructure, variableTypes[ndx].dataType));
group->addChild(new ResourceTestCase(context, variable, queryTarget));
}
}
}
}
static void generateCompoundVariableCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, const ProgramResourceQueryTestTarget& queryTarget, int expandLevel = 3);
static void generateVariableArrayCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, const ProgramResourceQueryTestTarget& queryTarget, int expandLevel = 3)
{
if (expandLevel > 0)
{
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(parentStructure));
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "array", "Arrays");
targetGroup->addChild(blockGroup);
// Arrays of basic variables
generateVariableCases(context, arrayElement, blockGroup, queryTarget, expandLevel, expandLevel != 1);
// Arrays of opaque types
generateOpaqueTypeCases(context, arrayElement, blockGroup, queryTarget, expandLevel, expandLevel != 1);
// Arrays of arrays
generateVariableArrayCases(context, arrayElement, blockGroup, queryTarget, expandLevel-1);
// Arrays of structs
generateCompoundVariableCases(context, arrayElement, blockGroup, queryTarget, expandLevel-1);
}
}
static void generateCompoundVariableCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, const ProgramResourceQueryTestTarget& queryTarget, int expandLevel)
{
if (expandLevel > 0)
{
const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(parentStructure));
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "struct", "Structs");
targetGroup->addChild(blockGroup);
// Struct containing basic variable
generateVariableCases(context, structMember, blockGroup, queryTarget, expandLevel, expandLevel != 1);
// Struct containing opaque types
generateOpaqueTypeCases(context, structMember, blockGroup, queryTarget, expandLevel, expandLevel != 1);
// Struct containing arrays
generateVariableArrayCases(context, structMember, blockGroup, queryTarget, expandLevel-1);
// Struct containing struct
generateCompoundVariableCases(context, structMember, blockGroup, queryTarget, expandLevel-1);
}
}
// Resource list cases
enum BlockFlags
{
BLOCKFLAG_DEFAULT = 0x01,
BLOCKFLAG_NAMED = 0x02,
BLOCKFLAG_UNNAMED = 0x04,
BLOCKFLAG_ARRAY = 0x08,
BLOCKFLAG_ALL = 0x0F
};
static void generateUniformCaseBlocks (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, deUint32 blockFlags, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup* const))
{
const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(parentStructure));
const ResourceDefinition::Node::SharedPtr uniform (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_UNIFORM));
// .default_block
if (blockFlags & BLOCKFLAG_DEFAULT)
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "default_block", "Default block");
targetGroup->addChild(blockGroup);
blockContentGenerator(context, uniform, blockGroup);
}
// .named_block
if (blockFlags & BLOCKFLAG_NAMED)
{
const ResourceDefinition::Node::SharedPtr block(new ResourceDefinition::InterfaceBlock(uniform, true));
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "named_block", "Named uniform block");
targetGroup->addChild(blockGroup);
blockContentGenerator(context, block, blockGroup);
}
// .unnamed_block
if (blockFlags & BLOCKFLAG_UNNAMED)
{
const ResourceDefinition::Node::SharedPtr block(new ResourceDefinition::InterfaceBlock(uniform, false));
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "unnamed_block", "Unnamed uniform block");
targetGroup->addChild(blockGroup);
blockContentGenerator(context, block, blockGroup);
}
// .block_array
if (blockFlags & BLOCKFLAG_ARRAY)
{
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(uniform));
const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(arrayElement, true));
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "block_array", "Uniform block array");
targetGroup->addChild(blockGroup);
blockContentGenerator(context, block, blockGroup);
}
}
static void generateBufferBackedResourceListBlockContentCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, ProgramInterface interface, int depth)
{
// variable
{
const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(parentStructure, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceListTestCase(context, variable, interface));
}
// struct
if (depth > 0)
{
const ResourceDefinition::Node::SharedPtr structMember(new ResourceDefinition::StructMember(parentStructure));
generateBufferBackedResourceListBlockContentCases(context, structMember, targetGroup, interface, depth - 1);
}
// array
if (depth > 0)
{
const ResourceDefinition::Node::SharedPtr arrayElement(new ResourceDefinition::ArrayElement(parentStructure));
generateBufferBackedResourceListBlockContentCases(context, arrayElement, targetGroup, interface, depth - 1);
}
}
static void generateBufferBackedVariableAggregateTypeCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, ProgramInterface interface, ProgramResourcePropFlags targetProp, glu::DataType dataType, const std::string& nameSuffix, int depth)
{
// variable
{
const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(parentStructure, dataType));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(interface, targetProp), ("var" + nameSuffix).c_str()));
}
// struct
if (depth > 0)
{
const ResourceDefinition::Node::SharedPtr structMember(new ResourceDefinition::StructMember(parentStructure));
generateBufferBackedVariableAggregateTypeCases(context, structMember, targetGroup, interface, targetProp, dataType, "_struct" + nameSuffix, depth - 1);
}
// array
if (depth > 0)
{
const ResourceDefinition::Node::SharedPtr arrayElement(new ResourceDefinition::ArrayElement(parentStructure));
generateBufferBackedVariableAggregateTypeCases(context, arrayElement, targetGroup, interface, targetProp, dataType, "_array" + nameSuffix, depth - 1);
}
}
static void generateUniformResourceListBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup)
{
generateBufferBackedResourceListBlockContentCases(context, parentStructure, targetGroup, PROGRAMINTERFACE_UNIFORM, 4);
}
static void generateUniformBlockArraySizeContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup)
{
const ProgramResourceQueryTestTarget queryTarget (PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_ARRAY_SIZE);
const bool isInterfaceBlock = (parentStructure->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK);
const bool namedNonArrayBlock = isInterfaceBlock &&
static_cast<const ResourceDefinition::InterfaceBlock*>(parentStructure.get())->m_named &&
parentStructure->getEnclosingNode()->getType() != ResourceDefinition::Node::TYPE_ARRAY_ELEMENT;
if (!isInterfaceBlock || namedNonArrayBlock)
{
// .types
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "types", "Types");
targetGroup->addChild(blockGroup);
generateVariableCases(context, parentStructure, blockGroup, queryTarget, 2, false);
generateOpaqueTypeCases(context, parentStructure, blockGroup, queryTarget, 2, false);
}
// aggregates
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "aggregates", "Aggregate types");
targetGroup->addChild(blockGroup);
generateBufferBackedVariableAggregateTypeCases(context, parentStructure, blockGroup, queryTarget.interface, PROGRAMRESOURCEPROP_ARRAY_SIZE, glu::TYPE_FLOAT, "", 3);
}
}
else
{
// aggregates
generateBufferBackedVariableAggregateTypeCases(context, parentStructure, targetGroup, queryTarget.interface, PROGRAMRESOURCEPROP_ARRAY_SIZE, glu::TYPE_FLOAT, "", 2);
}
}
static void generateBufferBackedArrayStrideTypeAggregateSubCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, const std::string& namePrefix, ProgramInterface interface, glu::DataType type, int expandLevel)
{
// case
{
const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(parentStructure, type));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(interface, PROGRAMRESOURCEPROP_ARRAY_STRIDE), namePrefix.c_str()));
}
if (expandLevel > 0)
{
const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(parentStructure));
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(parentStructure));
// _struct
generateBufferBackedArrayStrideTypeAggregateSubCases(context, structMember, targetGroup, namePrefix + "_struct", interface, type, expandLevel - 1);
// _array
generateBufferBackedArrayStrideTypeAggregateSubCases(context, arrayElement, targetGroup, namePrefix + "_array", interface, type, expandLevel - 1);
}
}
static void generateBufferBackedArrayStrideTypeAggregateCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, ProgramInterface interface, glu::DataType type, int expandLevel, bool includeBaseCase)
{
const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(parentStructure));
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(parentStructure));
const std::string namePrefix = glu::getDataTypeName(type);
if (expandLevel == 0 || includeBaseCase)
{
const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(parentStructure, type));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(interface, PROGRAMRESOURCEPROP_ARRAY_STRIDE), namePrefix.c_str()));
}
if (expandLevel >= 1)
{
// _struct
if (!glu::isDataTypeAtomicCounter(type))
generateBufferBackedArrayStrideTypeAggregateSubCases(context, structMember, targetGroup, namePrefix + "_struct", interface, type, expandLevel - 1);
// _array
generateBufferBackedArrayStrideTypeAggregateSubCases(context, arrayElement, targetGroup, namePrefix + "_array", interface, type, expandLevel - 1);
}
}
static void generateUniformBlockArrayStrideContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup)
{
const ProgramResourceQueryTestTarget queryTarget (PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_ARRAY_STRIDE);
const bool isInterfaceBlock = (parentStructure->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK);
const bool namedNonArrayBlock = isInterfaceBlock &&
static_cast<const ResourceDefinition::InterfaceBlock*>(parentStructure.get())->m_named &&
parentStructure->getEnclosingNode()->getType() != ResourceDefinition::Node::TYPE_ARRAY_ELEMENT;
if (!isInterfaceBlock || namedNonArrayBlock)
{
// .types
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "types", "Types");
targetGroup->addChild(blockGroup);
generateVariableCases(context, parentStructure, blockGroup, queryTarget, 2, false);
generateOpaqueTypeCases(context, parentStructure, blockGroup, queryTarget, 2, false);
}
// .aggregates
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "aggregates", "Aggregate types");
targetGroup->addChild(blockGroup);
// .sampler_2d_*
if (!isInterfaceBlock)
generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, blockGroup, queryTarget.interface, glu::TYPE_SAMPLER_2D, 1, false);
// .atomic_counter_*
if (!isInterfaceBlock)
{
const ResourceDefinition::Node::SharedPtr layout(new ResourceDefinition::LayoutQualifier(parentStructure, glu::Layout(-1, 0)));
generateBufferBackedArrayStrideTypeAggregateCases(context, layout, blockGroup, queryTarget.interface, glu::TYPE_UINT_ATOMIC_COUNTER, 1, false);
}
// .float_*
generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, blockGroup, queryTarget.interface, glu::TYPE_FLOAT, 2, false);
// .bool_*
generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, blockGroup, queryTarget.interface, glu::TYPE_BOOL, 1, false);
// .bvec3_*
generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, blockGroup, queryTarget.interface, glu::TYPE_BOOL_VEC3, 2, false);
// .vec3_*
generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, blockGroup, queryTarget.interface, glu::TYPE_FLOAT_VEC3, 2, false);
// .ivec2_*
generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, blockGroup, queryTarget.interface, glu::TYPE_INT_VEC3, 2, false);
}
}
else
{
generateVariableCases(context, parentStructure, targetGroup, queryTarget, 1);
generateVariableArrayCases(context, parentStructure, targetGroup, queryTarget, 1);
generateCompoundVariableCases(context, parentStructure, targetGroup, queryTarget, 1);
}
}
static void generateUniformBlockLocationContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup)
{
const ProgramResourceQueryTestTarget queryTarget (PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_LOCATION);
const bool isInterfaceBlock = (parentStructure->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK);
if (!isInterfaceBlock)
{
generateVariableCases(context, parentStructure, targetGroup, queryTarget, 3);
generateOpaqueTypeCases(context, parentStructure, targetGroup, queryTarget, 3);
generateVariableArrayCases(context, parentStructure, targetGroup, queryTarget, 2);
generateCompoundVariableCases(context, parentStructure, targetGroup, queryTarget, 2);
}
else
generateVariableCases(context, parentStructure, targetGroup, queryTarget, 1, false);
}
static void generateUniformBlockBlockIndexContents (Context& context, tcu::TestCaseGroup* const targetGroup, glu::GLSLVersion glslVersion)
{
const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program());
const ResourceDefinition::Node::SharedPtr shader (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader));
const ResourceDefinition::Node::SharedPtr uniform (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_UNIFORM));
const ResourceDefinition::Node::SharedPtr binding (new ResourceDefinition::LayoutQualifier(uniform, glu::Layout(-1, 0)));
// .default_block
{
const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(uniform, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_BLOCK_INDEX), "default_block"));
}
// .named_block
{
const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(binding, true));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(buffer, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_BLOCK_INDEX), "named_block"));
}
// .unnamed_block
{
const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(binding, false));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(buffer, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_BLOCK_INDEX), "unnamed_block"));
}
// .block_array
{
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(binding));
const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(arrayElement, true));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(buffer, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_BLOCK_INDEX), "block_array"));
}
}
static void generateUniformBlockAtomicCounterBufferIndexContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup)
{
const ProgramResourceQueryTestTarget queryTarget (PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_ATOMIC_COUNTER_BUFFER_INDEX);
const bool isInterfaceBlock = (parentStructure->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK);
if (!isInterfaceBlock)
{
generateVariableCases(context, parentStructure, targetGroup, queryTarget, 3);
generateOpaqueTypeCases(context, parentStructure, targetGroup, queryTarget, 3);
// .array
{
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(parentStructure));
const ResourceDefinition::Node::SharedPtr arrayArrayElement (new ResourceDefinition::ArrayElement(arrayElement));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElement, glu::TYPE_UINT_ATOMIC_COUNTER));
const ResourceDefinition::Node::SharedPtr elementvariable (new ResourceDefinition::Variable(arrayArrayElement, glu::TYPE_UINT_ATOMIC_COUNTER));
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "array", "Arrays");
targetGroup->addChild(blockGroup);
blockGroup->addChild(new ResourceTestCase(context, variable, queryTarget, "var_array"));
blockGroup->addChild(new ResourceTestCase(context, elementvariable, queryTarget, "var_array_array"));
}
}
else
generateVariableCases(context, parentStructure, targetGroup, queryTarget, 1, false);
}
static void generateUniformBlockNameLengthContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup)
{
const bool isInterfaceBlock = (parentStructure->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK);
const bool namedNonArrayBlock = isInterfaceBlock &&
static_cast<const ResourceDefinition::InterfaceBlock*>(parentStructure.get())->m_named &&
parentStructure->getEnclosingNode()->getType() != ResourceDefinition::Node::TYPE_ARRAY_ELEMENT;
if (!isInterfaceBlock || namedNonArrayBlock)
generateBufferBackedVariableAggregateTypeCases(context, parentStructure, targetGroup, PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_NAME_LENGTH, glu::TYPE_FLOAT, "", 2);
else
generateBufferBackedVariableAggregateTypeCases(context, parentStructure, targetGroup, PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_NAME_LENGTH, glu::TYPE_FLOAT, "", 1);
}
static void generateUniformBlockTypeContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup)
{
const ProgramResourceQueryTestTarget queryTarget (PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_TYPE);
const bool isInterfaceBlock = (parentStructure->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK);
const bool namedNonArrayBlock = isInterfaceBlock &&
static_cast<const ResourceDefinition::InterfaceBlock*>(parentStructure.get())->m_named &&
parentStructure->getEnclosingNode()->getType() != ResourceDefinition::Node::TYPE_ARRAY_ELEMENT;
if (!isInterfaceBlock || namedNonArrayBlock)
{
// .types
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "types", "Types");
targetGroup->addChild(blockGroup);
generateVariableCases(context, parentStructure, blockGroup, queryTarget, 3, false);
generateOpaqueTypeCases(context, parentStructure, blockGroup, queryTarget, 3, false);
}
generateVariableArrayCases(context, parentStructure, targetGroup, queryTarget, 1);
generateCompoundVariableCases(context, parentStructure, targetGroup, queryTarget, 1);
}
else
{
generateVariableCases(context, parentStructure, targetGroup, queryTarget, 1);
generateVariableArrayCases(context, parentStructure, targetGroup, queryTarget, 1);
generateCompoundVariableCases(context, parentStructure, targetGroup, queryTarget, 1);
}
}
static void generateUniformBlockOffsetContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup)
{
const ProgramResourceQueryTestTarget queryTarget (PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_OFFSET);
const bool isInterfaceBlock = (parentStructure->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK);
const bool namedNonArrayBlock = isInterfaceBlock &&
static_cast<const ResourceDefinition::InterfaceBlock*>(parentStructure.get())->m_named &&
parentStructure->getEnclosingNode()->getType() != ResourceDefinition::Node::TYPE_ARRAY_ELEMENT;
if (!isInterfaceBlock)
{
// .types
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "types", "Types");
targetGroup->addChild(blockGroup);
generateVariableCases(context, parentStructure, blockGroup, queryTarget, 3, false);
generateOpaqueTypeCases(context, parentStructure, blockGroup, queryTarget, 3, false);
}
// .aggregates
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "aggregates", "Aggregate types");
targetGroup->addChild(blockGroup);
// .atomic_uint_struct
// .atomic_uint_array
{
const ResourceDefinition::Node::SharedPtr offset (new ResourceDefinition::LayoutQualifier(parentStructure, glu::Layout(-1, -1, 4)));
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(offset));
const ResourceDefinition::Node::SharedPtr elementVariable (new ResourceDefinition::Variable(arrayElement, glu::TYPE_UINT_ATOMIC_COUNTER));
blockGroup->addChild(new ResourceTestCase(context, elementVariable, queryTarget, "atomic_uint_array"));
}
// .float_array
// .float_struct
{
const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(parentStructure));
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(parentStructure));
const ResourceDefinition::Node::SharedPtr memberVariable (new ResourceDefinition::Variable(structMember, glu::TYPE_FLOAT));
const ResourceDefinition::Node::SharedPtr elementVariable (new ResourceDefinition::Variable(arrayElement, glu::TYPE_FLOAT));
blockGroup->addChild(new ResourceTestCase(context, memberVariable, queryTarget, "float_struct"));
blockGroup->addChild(new ResourceTestCase(context, elementVariable, queryTarget, "float_array"));
}
}
}
else if (namedNonArrayBlock)
{
// .types
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "types", "Types");
targetGroup->addChild(blockGroup);
generateVariableCases(context, parentStructure, blockGroup, queryTarget, 3, false);
generateOpaqueTypeCases(context, parentStructure, blockGroup, queryTarget, 3, false);
}
// .aggregates
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "aggregates", "Aggregate types");
targetGroup->addChild(blockGroup);
// .float_array
// .float_struct
{
const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(parentStructure));
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::StructMember(parentStructure));
const ResourceDefinition::Node::SharedPtr memberVariable (new ResourceDefinition::Variable(structMember, glu::TYPE_FLOAT));
const ResourceDefinition::Node::SharedPtr elementVariable (new ResourceDefinition::Variable(arrayElement, glu::TYPE_FLOAT));
blockGroup->addChild(new ResourceTestCase(context, memberVariable, queryTarget, "float_struct"));
blockGroup->addChild(new ResourceTestCase(context, elementVariable, queryTarget, "float_array"));
}
}
}
else
{
generateVariableCases(context, parentStructure, targetGroup, queryTarget, 1);
generateVariableArrayCases(context, parentStructure, targetGroup, queryTarget, 1);
generateCompoundVariableCases(context, parentStructure, targetGroup, queryTarget, 1);
}
}
static void generateMatrixVariableCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, const ProgramResourceQueryTestTarget& queryTarget, bool createTestGroup = true, int expandLevel = 2)
{
static const struct
{
int priority;
glu::DataType type;
} variableTypes[] =
{
{ 0, glu::TYPE_FLOAT_MAT2 },
{ 1, glu::TYPE_FLOAT_MAT2X3 },
{ 2, glu::TYPE_FLOAT_MAT2X4 },
{ 2, glu::TYPE_FLOAT_MAT3X2 },
{ 1, glu::TYPE_FLOAT_MAT3 },
{ 0, glu::TYPE_FLOAT_MAT3X4 },
{ 2, glu::TYPE_FLOAT_MAT4X2 },
{ 1, glu::TYPE_FLOAT_MAT4X3 },
{ 0, glu::TYPE_FLOAT_MAT4 },
};
tcu::TestCaseGroup* group;
if (createTestGroup)
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "matrix", "Basic matrix type");
targetGroup->addChild(blockGroup);
group = blockGroup;
}
else
group = targetGroup;
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(variableTypes); ++ndx)
{
if (variableTypes[ndx].priority < expandLevel)
{
const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(parentStructure, variableTypes[ndx].type));
group->addChild(new ResourceTestCase(context, variable, queryTarget));
}
}
}
static void generateMatrixStructCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, const ProgramResourceQueryTestTarget& queryTarget, int expandLevel);
static void generateMatrixArrayCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, const ProgramResourceQueryTestTarget& queryTarget, int expandLevel)
{
if (expandLevel > 0)
{
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(parentStructure));
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "array", "Arrays");
targetGroup->addChild(blockGroup);
// Arrays of basic variables
generateMatrixVariableCases(context, arrayElement, blockGroup, queryTarget, expandLevel != 1, expandLevel);
// Arrays of arrays
generateMatrixArrayCases(context, arrayElement, blockGroup, queryTarget, expandLevel-1);
// Arrays of structs
generateMatrixStructCases(context, arrayElement, blockGroup, queryTarget, expandLevel-1);
}
}
static void generateMatrixStructCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, const ProgramResourceQueryTestTarget& queryTarget, int expandLevel)
{
if (expandLevel > 0)
{
const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(parentStructure));
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "struct", "Structs");
targetGroup->addChild(blockGroup);
// Struct containing basic variable
generateMatrixVariableCases(context, structMember, blockGroup, queryTarget, expandLevel != 1, expandLevel);
// Struct containing arrays
generateMatrixArrayCases(context, structMember, blockGroup, queryTarget, expandLevel-1);
// Struct containing struct
generateMatrixStructCases(context, structMember, blockGroup, queryTarget, expandLevel-1);
}
}
static void generateUniformMatrixOrderCaseBlockContentCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, bool extendedBasicTypeCases, bool opaqueCases)
{
static const struct
{
const char* name;
glu::MatrixOrder order;
} qualifiers[] =
{
{ "no_qualifier", glu::MATRIXORDER_LAST },
{ "row_major", glu::MATRIXORDER_ROW_MAJOR },
{ "column_major", glu::MATRIXORDER_COLUMN_MAJOR },
};
const ProgramResourceQueryTestTarget queryTarget(PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_MATRIX_ROW_MAJOR);
for (int qualifierNdx = 0; qualifierNdx < DE_LENGTH_OF_ARRAY(qualifiers); ++qualifierNdx)
{
// Add layout qualifiers only for block members
if (qualifiers[qualifierNdx].order == glu::MATRIXORDER_LAST || parentStructure->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK)
{
ResourceDefinition::Node::SharedPtr subStructure = parentStructure;
tcu::TestCaseGroup* const qualifierGroup = new tcu::TestCaseGroup(context.getTestContext(), qualifiers[qualifierNdx].name, "");
targetGroup->addChild(qualifierGroup);
if (qualifiers[qualifierNdx].order != glu::MATRIXORDER_LAST)
{
glu::Layout layout;
layout.matrixOrder = qualifiers[qualifierNdx].order;
subStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::LayoutQualifier(subStructure, layout));
}
if (extendedBasicTypeCases && qualifiers[qualifierNdx].order == glu::MATRIXORDER_LAST)
{
// .types
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "types", "");
qualifierGroup->addChild(blockGroup);
generateVariableCases(context, subStructure, blockGroup, queryTarget, 1, false);
generateMatrixVariableCases(context, subStructure, blockGroup, queryTarget, false);
if (opaqueCases)
generateOpaqueTypeCases(context, subStructure, blockGroup, queryTarget, 2, false);
}
// .aggregates
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "aggregates", "");
qualifierGroup->addChild(blockGroup);
generateBufferBackedVariableAggregateTypeCases(context, subStructure, blockGroup, queryTarget.interface, PROGRAMRESOURCEPROP_MATRIX_ROW_MAJOR, glu::TYPE_FLOAT_MAT3X2, "", 1);
}
}
else
{
generateBufferBackedVariableAggregateTypeCases(context, subStructure, qualifierGroup, queryTarget.interface, PROGRAMRESOURCEPROP_MATRIX_ROW_MAJOR, glu::TYPE_FLOAT_MAT3X2, "", 1);
}
}
}
}
static void generateUniformMatrixStrideCaseBlockContentCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, bool extendedBasicTypeCases, bool opaqueCases)
{
static const struct
{
const char* name;
glu::MatrixOrder order;
} qualifiers[] =
{
{ "no_qualifier", glu::MATRIXORDER_LAST },
{ "row_major", glu::MATRIXORDER_ROW_MAJOR },
{ "column_major", glu::MATRIXORDER_COLUMN_MAJOR },
};
const ProgramResourceQueryTestTarget queryTarget(PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_MATRIX_STRIDE);
for (int qualifierNdx = 0; qualifierNdx < DE_LENGTH_OF_ARRAY(qualifiers); ++qualifierNdx)
{
// Add layout qualifiers only for block members
if (qualifiers[qualifierNdx].order == glu::MATRIXORDER_LAST || parentStructure->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK)
{
ResourceDefinition::Node::SharedPtr subStructure = parentStructure;
tcu::TestCaseGroup* const qualifierGroup = new tcu::TestCaseGroup(context.getTestContext(), qualifiers[qualifierNdx].name, "");
targetGroup->addChild(qualifierGroup);
if (qualifiers[qualifierNdx].order != glu::MATRIXORDER_LAST)
{
glu::Layout layout;
layout.matrixOrder = qualifiers[qualifierNdx].order;
subStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::LayoutQualifier(subStructure, layout));
}
if (extendedBasicTypeCases)
{
// .types
// .matrix
if (qualifiers[qualifierNdx].order == glu::MATRIXORDER_LAST)
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "types", "");
qualifierGroup->addChild(blockGroup);
generateVariableCases(context, subStructure, blockGroup, queryTarget, 1, false);
generateMatrixVariableCases(context, subStructure, blockGroup, queryTarget, false);
if (opaqueCases)
generateOpaqueTypeCases(context, subStructure, blockGroup, queryTarget, 2, false);
}
else
generateMatrixVariableCases(context, subStructure, qualifierGroup, queryTarget);
// .aggregates
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "aggregates", "");
qualifierGroup->addChild(blockGroup);
generateBufferBackedVariableAggregateTypeCases(context, subStructure, blockGroup, queryTarget.interface, PROGRAMRESOURCEPROP_MATRIX_ROW_MAJOR, glu::TYPE_FLOAT_MAT3X2, "", 1);
}
}
else
generateBufferBackedVariableAggregateTypeCases(context, subStructure, qualifierGroup, queryTarget.interface, PROGRAMRESOURCEPROP_MATRIX_ROW_MAJOR, glu::TYPE_FLOAT_MAT3X2, "", 1);
}
}
}
static void generateUniformMatrixCaseBlocks (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup* const, bool, bool))
{
static const struct
{
const char* name;
const char* description;
bool block;
bool namedBlock;
bool extendedBasicTypeCases;
glu::MatrixOrder order;
} children[] =
{
{ "default_block", "Default block", false, true, true, glu::MATRIXORDER_LAST },
{ "named_block", "Named uniform block", true, true, true, glu::MATRIXORDER_LAST },
{ "named_block_row_major", "Named uniform block", true, true, false, glu::MATRIXORDER_ROW_MAJOR },
{ "named_block_col_major", "Named uniform block", true, true, false, glu::MATRIXORDER_COLUMN_MAJOR },
{ "unnamed_block", "Unnamed uniform block", true, false, false, glu::MATRIXORDER_LAST },
{ "unnamed_block_row_major", "Unnamed uniform block", true, false, false, glu::MATRIXORDER_ROW_MAJOR },
{ "unnamed_block_col_major", "Unnamed uniform block", true, false, false, glu::MATRIXORDER_COLUMN_MAJOR },
};
const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(parentStructure));
const ResourceDefinition::Node::SharedPtr uniform (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_UNIFORM));
for (int childNdx = 0; childNdx < (int)DE_LENGTH_OF_ARRAY(children); ++childNdx)
{
ResourceDefinition::Node::SharedPtr subStructure = uniform;
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), children[childNdx].name, children[childNdx].description);
const bool addOpaqueCases = children[childNdx].extendedBasicTypeCases && !children[childNdx].block;
targetGroup->addChild(blockGroup);
if (children[childNdx].order != glu::MATRIXORDER_LAST)
{
glu::Layout layout;
layout.matrixOrder = children[childNdx].order;
subStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::LayoutQualifier(subStructure, layout));
}
if (children[childNdx].block)
subStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::InterfaceBlock(subStructure, children[childNdx].namedBlock));
blockContentGenerator(context, subStructure, blockGroup, children[childNdx].extendedBasicTypeCases, addOpaqueCases);
}
}
static void generateBufferReferencedByShaderInterfaceBlockCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, const ProgramResourceQueryTestTarget& queryTarget, bool extendedCases)
{
const bool isDefaultBlock = (parentStructure->getType() != ResourceDefinition::Node::TYPE_INTERFACE_BLOCK);
// .float
// .float_array
// .float_struct
{
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(parentStructure, glu::TYPE_FLOAT));
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(parentStructure));
const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(parentStructure));
const ResourceDefinition::Node::SharedPtr variableArray (new ResourceDefinition::Variable(arrayElement, glu::TYPE_FLOAT));
const ResourceDefinition::Node::SharedPtr variableStruct (new ResourceDefinition::Variable(structMember, glu::TYPE_FLOAT));
targetGroup->addChild(new ResourceTestCase(context, variable, queryTarget, "float"));
targetGroup->addChild(new ResourceTestCase(context, variableArray, queryTarget, "float_array"));
targetGroup->addChild(new ResourceTestCase(context, variableStruct, queryTarget, "float_struct"));
}
// .sampler
// .sampler_array
// .sampler_struct
if (isDefaultBlock)
{
const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(parentStructure, glu::Layout(-1, 0)));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(layout, glu::TYPE_SAMPLER_2D));
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(layout));
const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(parentStructure));
const ResourceDefinition::Node::SharedPtr variableArray (new ResourceDefinition::Variable(arrayElement, glu::TYPE_SAMPLER_2D));
const ResourceDefinition::Node::SharedPtr variableStruct (new ResourceDefinition::Variable(structMember, glu::TYPE_SAMPLER_2D));
targetGroup->addChild(new ResourceTestCase(context, variable, queryTarget, "sampler"));
targetGroup->addChild(new ResourceTestCase(context, variableArray, queryTarget, "sampler_array"));
targetGroup->addChild(new ResourceTestCase(context, variableStruct, queryTarget, "sampler_struct"));
}
// .atomic_uint
// .atomic_uint_array
if (isDefaultBlock)
{
const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(parentStructure, glu::Layout(-1, 0)));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(layout, glu::TYPE_UINT_ATOMIC_COUNTER));
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(layout));
const ResourceDefinition::Node::SharedPtr variableArray (new ResourceDefinition::Variable(arrayElement, glu::TYPE_UINT_ATOMIC_COUNTER));
targetGroup->addChild(new ResourceTestCase(context, variable, queryTarget, "atomic_uint"));
targetGroup->addChild(new ResourceTestCase(context, variableArray, queryTarget, "atomic_uint_array"));
}
if (extendedCases)
{
// .float_array_struct
{
const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(parentStructure));
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(structMember));
const ResourceDefinition::Node::SharedPtr variableArrayStruct (new ResourceDefinition::Variable(arrayElement, glu::TYPE_FLOAT));
targetGroup->addChild(new ResourceTestCase(context, variableArrayStruct, queryTarget, "float_array_struct"));
}
// .float_struct_array
{
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(parentStructure));
const ResourceDefinition::Node::SharedPtr arrayStructMember (new ResourceDefinition::StructMember(arrayElement));
const ResourceDefinition::Node::SharedPtr variableArrayStruct (new ResourceDefinition::Variable(arrayStructMember, glu::TYPE_FLOAT));
targetGroup->addChild(new ResourceTestCase(context, variableArrayStruct, queryTarget, "float_struct_array"));
}
// .float_array_array
{
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(parentStructure));
const ResourceDefinition::Node::SharedPtr subArrayElement (new ResourceDefinition::ArrayElement(arrayElement));
const ResourceDefinition::Node::SharedPtr variableArrayStruct (new ResourceDefinition::Variable(subArrayElement, glu::TYPE_FLOAT));
targetGroup->addChild(new ResourceTestCase(context, variableArrayStruct, queryTarget, "float_array_array"));
}
// .float_struct_struct
{
const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(parentStructure));
const ResourceDefinition::Node::SharedPtr subStructMember (new ResourceDefinition::StructMember(structMember));
const ResourceDefinition::Node::SharedPtr variableArrayStruct (new ResourceDefinition::Variable(subStructMember, glu::TYPE_FLOAT));
targetGroup->addChild(new ResourceTestCase(context, variableArrayStruct, queryTarget, "float_struct_struct"));
}
if (queryTarget.interface == PROGRAMINTERFACE_BUFFER_VARIABLE)
{
const ResourceDefinition::Node::SharedPtr arrayElement(new ResourceDefinition::ArrayElement(parentStructure, ResourceDefinition::ArrayElement::UNSIZED_ARRAY));
// .float_unsized_array
{
const ResourceDefinition::Node::SharedPtr variableArray (new ResourceDefinition::Variable(arrayElement, glu::TYPE_FLOAT));
targetGroup->addChild(new ResourceTestCase(context, variableArray, queryTarget, "float_unsized_array"));
}
// .float_unsized_struct_array
{
const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(arrayElement));
const ResourceDefinition::Node::SharedPtr variableArray (new ResourceDefinition::Variable(structMember, glu::TYPE_FLOAT));
targetGroup->addChild(new ResourceTestCase(context, variableArray, queryTarget, "float_unsized_struct_array"));
}
}
}
}
static void generateUniformReferencedByShaderSingleBlockContentCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, int expandLevel)
{
DE_UNREF(expandLevel);
const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(parentStructure));
const ResourceDefinition::Node::SharedPtr uniform (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_UNIFORM));
const ProgramResourceQueryTestTarget queryTarget (PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_REFERENCED_BY_SHADER);
const bool singleShaderCase = parentStructure->getType() == ResourceDefinition::Node::TYPE_SHADER;
// .default_block
{
TestCaseGroup* const blockGroup = new TestCaseGroup(context, "default_block", "");
targetGroup->addChild(blockGroup);
generateBufferReferencedByShaderInterfaceBlockCases(context, uniform, blockGroup, queryTarget, singleShaderCase);
}
// .named_block
{
const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(uniform, true));
TestCaseGroup* const blockGroup = new TestCaseGroup(context, "uniform_block", "");
targetGroup->addChild(blockGroup);
generateBufferReferencedByShaderInterfaceBlockCases(context, block, blockGroup, queryTarget, singleShaderCase);
}
// .unnamed_block
{
const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(uniform, false));
TestCaseGroup* const blockGroup = new TestCaseGroup(context, "unnamed_block", "");
targetGroup->addChild(blockGroup);
generateBufferReferencedByShaderInterfaceBlockCases(context, block, blockGroup, queryTarget, false);
}
// .block_array
{
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(uniform));
const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(arrayElement, true));
TestCaseGroup* const blockGroup = new TestCaseGroup(context, "block_array", "");
targetGroup->addChild(blockGroup);
generateBufferReferencedByShaderInterfaceBlockCases(context, block, blockGroup, queryTarget, false);
}
}
static void generateReferencedByShaderCaseBlocks (Context& context, tcu::TestCaseGroup* const targetGroup, glu::GLSLVersion glslVersion, void (*generateBlockContent)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*, int expandLevel))
{
static const struct
{
const char* name;
glu::ShaderType stage;
int expandLevel;
} singleStageCases[] =
{
{ "compute", glu::SHADERTYPE_COMPUTE, 3 },
{ "separable_vertex", glu::SHADERTYPE_VERTEX, 2 },
{ "separable_fragment", glu::SHADERTYPE_FRAGMENT, 2 },
{ "separable_tess_ctrl", glu::SHADERTYPE_TESSELLATION_CONTROL, 2 },
{ "separable_tess_eval", glu::SHADERTYPE_TESSELLATION_EVALUATION, 2 },
{ "separable_geometry", glu::SHADERTYPE_GEOMETRY, 2 },
};
static const struct
{
const char* name;
deUint32 flags;
int expandLevel;
int subExpandLevel;
} pipelines[] =
{
{
"vertex_fragment",
(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT),
3,
2,
},
{
"vertex_tess_fragment",
(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_TESSELLATION_CONTROL) | (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION),
2,
2,
},
{
"vertex_geo_fragment",
(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_GEOMETRY),
2,
2,
},
{
"vertex_tess_geo_fragment",
(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_TESSELLATION_CONTROL) | (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION) | (1 << glu::SHADERTYPE_GEOMETRY),
2,
1,
},
};
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(singleStageCases); ++ndx)
{
TestCaseGroup* const blockGroup = new TestCaseGroup(context, singleStageCases[ndx].name, "");
const bool programSeparable = (singleStageCases[ndx].stage != glu::SHADERTYPE_COMPUTE);
const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program(programSeparable));
const ResourceDefinition::Node::SharedPtr stage (new ResourceDefinition::Shader(program, singleStageCases[ndx].stage, glslVersion));
targetGroup->addChild(blockGroup);
generateBlockContent(context, stage, blockGroup, singleStageCases[ndx].expandLevel);
}
for (int pipelineNdx = 0; pipelineNdx < DE_LENGTH_OF_ARRAY(pipelines); ++pipelineNdx)
{
// whole pipeline
{
TestCaseGroup* const blockGroup = new TestCaseGroup(context, pipelines[pipelineNdx].name, "");
const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program());
ResourceDefinition::ShaderSet* shaderSet = new ResourceDefinition::ShaderSet(program,
glslVersion,
pipelines[pipelineNdx].flags,
pipelines[pipelineNdx].flags);
targetGroup->addChild(blockGroup);
{
const ResourceDefinition::Node::SharedPtr shaders(shaderSet);
generateBlockContent(context, shaders, blockGroup, pipelines[pipelineNdx].expandLevel);
}
}
// only one stage
for (int selectedStageBit = 0; selectedStageBit < glu::SHADERTYPE_LAST; ++selectedStageBit)
{
if (pipelines[pipelineNdx].flags & (1 << selectedStageBit))
{
const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program());
ResourceDefinition::ShaderSet* shaderSet = new ResourceDefinition::ShaderSet(program,
glslVersion,
pipelines[pipelineNdx].flags,
(1u << selectedStageBit));
const char* stageName = (selectedStageBit == glu::SHADERTYPE_VERTEX) ? ("vertex")
: (selectedStageBit == glu::SHADERTYPE_FRAGMENT) ? ("fragment")
: (selectedStageBit == glu::SHADERTYPE_GEOMETRY) ? ("geo")
: (selectedStageBit == glu::SHADERTYPE_TESSELLATION_CONTROL) ? ("tess_ctrl")
: (selectedStageBit == glu::SHADERTYPE_TESSELLATION_EVALUATION) ? ("tess_eval")
: (DE_NULL);
const std::string setName = std::string() + pipelines[pipelineNdx].name + "_only_" + stageName;
TestCaseGroup* const blockGroup = new TestCaseGroup(context, setName.c_str(), "");
const ResourceDefinition::Node::SharedPtr shaders (shaderSet);
generateBlockContent(context, shaders, blockGroup, pipelines[pipelineNdx].subExpandLevel);
targetGroup->addChild(blockGroup);
}
}
}
}
static glu::DataType generateRandomDataType (de::Random& rnd, bool excludeOpaqueTypes)
{
static const glu::DataType s_types[] =
{
glu::TYPE_FLOAT,
glu::TYPE_INT,
glu::TYPE_UINT,
glu::TYPE_BOOL,
glu::TYPE_FLOAT_VEC2,
glu::TYPE_FLOAT_VEC3,
glu::TYPE_FLOAT_VEC4,
glu::TYPE_INT_VEC2,
glu::TYPE_INT_VEC3,
glu::TYPE_INT_VEC4,
glu::TYPE_UINT_VEC2,
glu::TYPE_UINT_VEC3,
glu::TYPE_UINT_VEC4,
glu::TYPE_BOOL_VEC2,
glu::TYPE_BOOL_VEC3,
glu::TYPE_BOOL_VEC4,
glu::TYPE_FLOAT_MAT2,
glu::TYPE_FLOAT_MAT2X3,
glu::TYPE_FLOAT_MAT2X4,
glu::TYPE_FLOAT_MAT3X2,
glu::TYPE_FLOAT_MAT3,
glu::TYPE_FLOAT_MAT3X4,
glu::TYPE_FLOAT_MAT4X2,
glu::TYPE_FLOAT_MAT4X3,
glu::TYPE_FLOAT_MAT4,
glu::TYPE_SAMPLER_2D,
glu::TYPE_SAMPLER_CUBE,
glu::TYPE_SAMPLER_2D_ARRAY,
glu::TYPE_SAMPLER_3D,
glu::TYPE_SAMPLER_2D_SHADOW,
glu::TYPE_SAMPLER_CUBE_SHADOW,
glu::TYPE_SAMPLER_2D_ARRAY_SHADOW,
glu::TYPE_INT_SAMPLER_2D,
glu::TYPE_INT_SAMPLER_CUBE,
glu::TYPE_INT_SAMPLER_2D_ARRAY,
glu::TYPE_INT_SAMPLER_3D,
glu::TYPE_UINT_SAMPLER_2D,
glu::TYPE_UINT_SAMPLER_CUBE,
glu::TYPE_UINT_SAMPLER_2D_ARRAY,
glu::TYPE_UINT_SAMPLER_3D,
glu::TYPE_SAMPLER_2D_MULTISAMPLE,
glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE,
glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE,
glu::TYPE_IMAGE_2D,
glu::TYPE_IMAGE_CUBE,
glu::TYPE_IMAGE_2D_ARRAY,
glu::TYPE_IMAGE_3D,
glu::TYPE_INT_IMAGE_2D,
glu::TYPE_INT_IMAGE_CUBE,
glu::TYPE_INT_IMAGE_2D_ARRAY,
glu::TYPE_INT_IMAGE_3D,
glu::TYPE_UINT_IMAGE_2D,
glu::TYPE_UINT_IMAGE_CUBE,
glu::TYPE_UINT_IMAGE_2D_ARRAY,
glu::TYPE_UINT_IMAGE_3D,
glu::TYPE_UINT_ATOMIC_COUNTER
};
for (;;)
{
const glu::DataType type = s_types[rnd.getInt(0, DE_LENGTH_OF_ARRAY(s_types)-1)];
if (!excludeOpaqueTypes ||
glu::isDataTypeScalarOrVector(type) ||
glu::isDataTypeMatrix(type))
return type;
}
}
static ResourceDefinition::Node::SharedPtr generateRandomVariableDefinition (de::Random& rnd,
const ResourceDefinition::Node::SharedPtr& parentStructure,
glu::DataType baseType,
const glu::Layout& layout,
bool allowUnsized)
{
const int maxNesting = 4;
ResourceDefinition::Node::SharedPtr currentStructure = parentStructure;
const bool canBeInsideAStruct = layout.binding == -1 && !isDataTypeLayoutQualified(baseType);
for (int nestNdx = 0; nestNdx < maxNesting; ++nestNdx)
{
if (allowUnsized && nestNdx == 0 && rnd.getFloat() < 0.2)
currentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::ArrayElement(currentStructure, ResourceDefinition::ArrayElement::UNSIZED_ARRAY));
else if (rnd.getFloat() < 0.3 && canBeInsideAStruct)
currentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::StructMember(currentStructure));
else if (rnd.getFloat() < 0.3)
currentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::ArrayElement(currentStructure));
else
break;
}
return ResourceDefinition::Node::SharedPtr(new ResourceDefinition::Variable(currentStructure, baseType));
}
static ResourceDefinition::Node::SharedPtr generateRandomCoreShaderSet (de::Random& rnd, glu::GLSLVersion glslVersion)
{
if (rnd.getFloat() < 0.5f)
{
// compute only
const ResourceDefinition::Node::SharedPtr program(new ResourceDefinition::Program());
return ResourceDefinition::Node::SharedPtr(new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
}
else if (rnd.getFloat() < 0.5f)
{
// vertex and fragment
const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program());
ResourceDefinition::ShaderSet* shaderSet = new ResourceDefinition::ShaderSet(program, glslVersion);
if (rnd.getBool())
{
shaderSet->setStage(glu::SHADERTYPE_VERTEX, true);
shaderSet->setStage(glu::SHADERTYPE_FRAGMENT, rnd.getBool());
}
else
{
shaderSet->setStage(glu::SHADERTYPE_VERTEX, rnd.getBool());
shaderSet->setStage(glu::SHADERTYPE_FRAGMENT, true);
}
return ResourceDefinition::Node::SharedPtr(shaderSet);
}
else
{
// separate vertex or fragment
const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program(true));
const glu::ShaderType shaderType = (rnd.getBool()) ? (glu::SHADERTYPE_VERTEX) : (glu::SHADERTYPE_FRAGMENT);
return ResourceDefinition::Node::SharedPtr(new ResourceDefinition::Shader(program, shaderType, glslVersion));
}
}
static ResourceDefinition::Node::SharedPtr generateRandomExtShaderSet (de::Random& rnd, glu::GLSLVersion glslVersion)
{
if (rnd.getFloat() < 0.5f)
{
// whole pipeline
const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program());
ResourceDefinition::ShaderSet* shaderSet = new ResourceDefinition::ShaderSet(program, glslVersion);
shaderSet->setStage(glu::SHADERTYPE_VERTEX, rnd.getBool());
shaderSet->setStage(glu::SHADERTYPE_FRAGMENT, rnd.getBool());
// tess shader are either both or neither present. Make cases interesting
// by forcing one extended shader to always have reference
if (rnd.getBool())
{
shaderSet->setStage(glu::SHADERTYPE_GEOMETRY, true);
if (rnd.getBool())
{
shaderSet->setStage(glu::SHADERTYPE_TESSELLATION_CONTROL, rnd.getBool());
shaderSet->setStage(glu::SHADERTYPE_TESSELLATION_EVALUATION, rnd.getBool());
}
}
else
{
shaderSet->setStage(glu::SHADERTYPE_GEOMETRY, rnd.getBool());
if (rnd.getBool())
{
shaderSet->setStage(glu::SHADERTYPE_TESSELLATION_CONTROL, true);
shaderSet->setStage(glu::SHADERTYPE_TESSELLATION_EVALUATION, rnd.getBool());
}
else
{
shaderSet->setStage(glu::SHADERTYPE_TESSELLATION_CONTROL, rnd.getBool());
shaderSet->setStage(glu::SHADERTYPE_TESSELLATION_EVALUATION, true);
}
}
return ResourceDefinition::Node::SharedPtr(shaderSet);
}
else
{
// separate
const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program(true));
const int selector = rnd.getInt(0, 2);
const glu::ShaderType shaderType = (selector == 0) ? (glu::SHADERTYPE_GEOMETRY)
: (selector == 1) ? (glu::SHADERTYPE_TESSELLATION_CONTROL)
: (selector == 2) ? (glu::SHADERTYPE_TESSELLATION_EVALUATION)
: (glu::SHADERTYPE_LAST);
return ResourceDefinition::Node::SharedPtr(new ResourceDefinition::Shader(program, shaderType, glslVersion));
}
}
static ResourceDefinition::Node::SharedPtr generateRandomShaderSet (de::Random& rnd, glu::GLSLVersion glslVersion, bool onlyExtensionStages)
{
if (!onlyExtensionStages)
return generateRandomCoreShaderSet(rnd, glslVersion);
else
return generateRandomExtShaderSet(rnd, glslVersion);
}
static glu::Layout generateRandomUniformBlockLayout (de::Random& rnd)
{
glu::Layout layout;
if (rnd.getBool())
layout.binding = rnd.getInt(0, 5);
if (rnd.getBool())
layout.matrixOrder = (rnd.getBool()) ? (glu::MATRIXORDER_COLUMN_MAJOR) : (glu::MATRIXORDER_ROW_MAJOR);
return layout;
}
static glu::Layout generateRandomBufferBlockLayout (de::Random& rnd)
{
return generateRandomUniformBlockLayout(rnd);
}
static glu::Layout generateRandomVariableLayout (de::Random& rnd, glu::DataType type, bool interfaceBlockMember)
{
glu::Layout layout;
if ((glu::isDataTypeAtomicCounter(type) || glu::isDataTypeImage(type) || glu::isDataTypeSampler(type)) && rnd.getBool())
layout.binding = rnd.getInt(0, 5);
if (glu::isDataTypeAtomicCounter(type) && rnd.getBool())
layout.offset = rnd.getInt(0, 3) * 4;
if (glu::isDataTypeMatrix(type) && interfaceBlockMember && rnd.getBool())
layout.matrixOrder = (rnd.getBool()) ? (glu::MATRIXORDER_COLUMN_MAJOR) : (glu::MATRIXORDER_ROW_MAJOR);
return layout;
}
static void generateUniformRandomCase (Context& context, tcu::TestCaseGroup* const targetGroup, glu::GLSLVersion glslVersion, int index, bool onlyExtensionStages)
{
de::Random rnd (index * 0x12345);
const ResourceDefinition::Node::SharedPtr shader = generateRandomShaderSet(rnd, glslVersion, onlyExtensionStages);
const bool interfaceBlock = rnd.getBool();
const glu::DataType type = generateRandomDataType(rnd, interfaceBlock);
const glu::Layout layout = generateRandomVariableLayout(rnd, type, interfaceBlock);
const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader));
const ResourceDefinition::Node::SharedPtr uniform (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_UNIFORM));
ResourceDefinition::Node::SharedPtr currentStructure = uniform;
if (interfaceBlock)
{
const bool namedBlock = rnd.getBool();
currentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::LayoutQualifier(currentStructure, generateRandomUniformBlockLayout(rnd)));
if (namedBlock && rnd.getBool())
currentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::ArrayElement(currentStructure));
currentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::InterfaceBlock(currentStructure, namedBlock));
}
currentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::LayoutQualifier(currentStructure, layout));
currentStructure = generateRandomVariableDefinition(rnd, currentStructure, type, layout, false);
targetGroup->addChild(new ResourceTestCase(context, currentStructure, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_UNIFORM_INTERFACE_MASK), de::toString(index).c_str()));
}
static void generateUniformCaseRandomCases (Context& context, tcu::TestCaseGroup* const targetGroup, glu::GLSLVersion glslVersion)
{
const int numBasicCases = 40;
const int numTessGeoCases = 40;
for (int ndx = 0; ndx < numBasicCases; ++ndx)
generateUniformRandomCase(context, targetGroup, glslVersion, ndx, false);
for (int ndx = 0; ndx < numTessGeoCases; ++ndx)
generateUniformRandomCase(context, targetGroup, glslVersion, numBasicCases + ndx, true);
}
class UniformInterfaceTestGroup : public TestCaseGroup
{
public:
UniformInterfaceTestGroup (Context& context);
void init (void);
};
UniformInterfaceTestGroup::UniformInterfaceTestGroup (Context& context)
: TestCaseGroup(context, "uniform", "Uniform interace")
{
}
void UniformInterfaceTestGroup::init (void)
{
glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program());
const ResourceDefinition::Node::SharedPtr computeShader (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
// .resource_list
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "resource_list", "Resource list");
addChild(blockGroup);
generateUniformCaseBlocks(m_context, computeShader, blockGroup, BLOCKFLAG_ALL, generateUniformResourceListBlockContents);
}
// .array_size
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "array_size", "Query array size");
addChild(blockGroup);
generateUniformCaseBlocks(m_context, computeShader, blockGroup, BLOCKFLAG_ALL, generateUniformBlockArraySizeContents);
}
// .array_stride
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "array_stride", "Query array stride");
addChild(blockGroup);
generateUniformCaseBlocks(m_context, computeShader, blockGroup, BLOCKFLAG_ALL, generateUniformBlockArrayStrideContents);
}
// .atomic_counter_buffer_index
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "atomic_counter_buffer_index", "Query atomic counter buffer index");
addChild(blockGroup);
generateUniformCaseBlocks(m_context, computeShader, blockGroup, BLOCKFLAG_DEFAULT | BLOCKFLAG_NAMED, generateUniformBlockAtomicCounterBufferIndexContents);
}
// .block_index
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "block_index", "Query block index");
addChild(blockGroup);
generateUniformBlockBlockIndexContents(m_context, blockGroup, glslVersion);
}
// .location
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "location", "Query location");
addChild(blockGroup);
generateUniformCaseBlocks(m_context, computeShader, blockGroup, BLOCKFLAG_DEFAULT | BLOCKFLAG_NAMED | BLOCKFLAG_UNNAMED, generateUniformBlockLocationContents);
}
// .matrix_row_major
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "matrix_row_major", "Query matrix row_major");
addChild(blockGroup);
generateUniformMatrixCaseBlocks(m_context, computeShader, blockGroup, generateUniformMatrixOrderCaseBlockContentCases);
}
// .matrix_stride
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "matrix_stride", "Query matrix stride");
addChild(blockGroup);
generateUniformMatrixCaseBlocks(m_context, computeShader, blockGroup, generateUniformMatrixStrideCaseBlockContentCases);
}
// .name_length
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "name_length", "Query name length");
addChild(blockGroup);
generateUniformCaseBlocks(m_context, computeShader, blockGroup, BLOCKFLAG_ALL, generateUniformBlockNameLengthContents);
}
// .offset
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "offset", "Query offset");
addChild(blockGroup);
generateUniformCaseBlocks(m_context, computeShader, blockGroup, BLOCKFLAG_ALL, generateUniformBlockOffsetContents);
}
// .referenced_by_shader
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "referenced_by_shader", "Query referenced by shader");
addChild(blockGroup);
generateReferencedByShaderCaseBlocks(m_context, blockGroup, glslVersion, generateUniformReferencedByShaderSingleBlockContentCases);
}
// .type
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "type", "Query type");
addChild(blockGroup);
generateUniformCaseBlocks(m_context, computeShader, blockGroup, BLOCKFLAG_ALL, generateUniformBlockTypeContents);
}
// .random
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "random", "Random");
addChild(blockGroup);
generateUniformCaseRandomCases(m_context, blockGroup, glslVersion);
}
}
static void generateBufferBackedInterfaceResourceListCase (Context& context, const ResourceDefinition::Node::SharedPtr& targetResource, tcu::TestCaseGroup* const targetGroup, ProgramInterface interface, const char* blockName)
{
targetGroup->addChild(new ResourceListTestCase(context, targetResource, interface, blockName));
}
static void generateBufferBackedInterfaceNameLengthCase (Context& context, const ResourceDefinition::Node::SharedPtr& targetResource, tcu::TestCaseGroup* const targetGroup, ProgramInterface interface, const char* blockName)
{
targetGroup->addChild(new ResourceTestCase(context, targetResource, ProgramResourceQueryTestTarget(interface, PROGRAMRESOURCEPROP_NAME_LENGTH), blockName));
}
static void generateBufferBackedInterfaceResourceBasicBlockTypes (Context& context, tcu::TestCaseGroup* targetGroup, glu::GLSLVersion glslVersion, glu::Storage storage, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup* const, ProgramInterface interface, const char* blockName))
{
const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program());
const ResourceDefinition::Node::SharedPtr shader (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader));
const ResourceDefinition::Node::SharedPtr storageQualifier (new ResourceDefinition::StorageQualifier(defaultBlock, storage));
const ResourceDefinition::Node::SharedPtr binding (new ResourceDefinition::LayoutQualifier(storageQualifier, glu::Layout(-1, 1)));
const ProgramInterface programInterface = (storage == glu::STORAGE_UNIFORM) ? (PROGRAMINTERFACE_UNIFORM_BLOCK) : (PROGRAMINTERFACE_SHADER_STORAGE_BLOCK);
// .named_block
{
const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(binding, true));
const ResourceDefinition::Node::SharedPtr dummyVariable (new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3));
blockContentGenerator(context, dummyVariable, targetGroup, programInterface, "named_block");
}
// .unnamed_block
{
const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(binding, false));
const ResourceDefinition::Node::SharedPtr dummyVariable (new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3));
blockContentGenerator(context, dummyVariable, targetGroup, programInterface, "unnamed_block");
}
// .block_array
{
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(binding, 3));
const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(arrayElement, true));
const ResourceDefinition::Node::SharedPtr dummyVariable (new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3));
blockContentGenerator(context, dummyVariable, targetGroup, programInterface, "block_array");
}
// .block_array_single_element
{
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(binding, 1));
const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(arrayElement, true));
const ResourceDefinition::Node::SharedPtr dummyVariable (new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3));
blockContentGenerator(context, dummyVariable, targetGroup, programInterface, "block_array_single_element");
}
}
static void generateBufferBackedInterfaceResourceBufferBindingCases (Context& context, tcu::TestCaseGroup* targetGroup, glu::GLSLVersion glslVersion, glu::Storage storage)
{
const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program());
const ResourceDefinition::Node::SharedPtr shader (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader));
const ResourceDefinition::Node::SharedPtr storageQualifier (new ResourceDefinition::StorageQualifier(defaultBlock, storage));
for (int ndx = 0; ndx < 2; ++ndx)
{
const bool explicitBinding = (ndx == 1);
const int bindingNdx = (explicitBinding) ? (1) : (-1);
const std::string nameSuffix = (explicitBinding) ? ("_explicit_binding") : ("");
const ResourceDefinition::Node::SharedPtr binding (new ResourceDefinition::LayoutQualifier(storageQualifier, glu::Layout(-1, bindingNdx)));
const ProgramInterface programInterface = (storage == glu::STORAGE_UNIFORM) ? (PROGRAMINTERFACE_UNIFORM_BLOCK) : (PROGRAMINTERFACE_SHADER_STORAGE_BLOCK);
// .named_block*
{
const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(binding, true));
const ResourceDefinition::Node::SharedPtr dummyVariable (new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3));
targetGroup->addChild(new ResourceTestCase(context, dummyVariable, ProgramResourceQueryTestTarget(programInterface, PROGRAMRESOURCEPROP_BUFFER_BINDING), ("named_block" + nameSuffix).c_str()));
}
// .unnamed_block*
{
const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(binding, false));
const ResourceDefinition::Node::SharedPtr dummyVariable (new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3));
targetGroup->addChild(new ResourceTestCase(context, dummyVariable, ProgramResourceQueryTestTarget(programInterface, PROGRAMRESOURCEPROP_BUFFER_BINDING), ("unnamed_block" + nameSuffix).c_str()));
}
// .block_array*
{
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(binding, 3));
const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(arrayElement, true));
const ResourceDefinition::Node::SharedPtr dummyVariable (new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3));
targetGroup->addChild(new ResourceTestCase(context, dummyVariable, ProgramResourceQueryTestTarget(programInterface, PROGRAMRESOURCEPROP_BUFFER_BINDING), ("block_array" + nameSuffix).c_str()));
}
}
}
template <glu::Storage Storage>
static void generateBufferBlockReferencedByShaderSingleBlockContentCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, int expandLevel)
{
const ProgramInterface programInterface = (Storage == glu::STORAGE_UNIFORM) ? (PROGRAMINTERFACE_UNIFORM_BLOCK) :
(Storage == glu::STORAGE_BUFFER) ? (PROGRAMINTERFACE_SHADER_STORAGE_BLOCK) :
(PROGRAMINTERFACE_LAST);
const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(parentStructure));
const ResourceDefinition::Node::SharedPtr storage (new ResourceDefinition::StorageQualifier(defaultBlock, Storage));
DE_UNREF(expandLevel);
DE_ASSERT(programInterface != PROGRAMINTERFACE_LAST);
// .named_block
{
const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(storage, true));
const ResourceDefinition::Node::SharedPtr dummyVariable (new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3));
targetGroup->addChild(new ResourceTestCase(context, dummyVariable, ProgramResourceQueryTestTarget(programInterface, PROGRAMRESOURCEPROP_REFERENCED_BY_SHADER), "named_block"));
}
// .unnamed_block
{
const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(storage, false));
const ResourceDefinition::Node::SharedPtr dummyVariable (new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3));
targetGroup->addChild(new ResourceTestCase(context, dummyVariable, ProgramResourceQueryTestTarget(programInterface, PROGRAMRESOURCEPROP_REFERENCED_BY_SHADER), "unnamed_block"));
}
// .block_array
{
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(storage, 3));
const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(arrayElement, true));
const ResourceDefinition::Node::SharedPtr dummyVariable (new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3));
targetGroup->addChild(new ResourceTestCase(context, dummyVariable, ProgramResourceQueryTestTarget(programInterface, PROGRAMRESOURCEPROP_REFERENCED_BY_SHADER), "block_array"));
}
}
static void generateBufferBackedInterfaceResourceActiveVariablesCase (Context& context, tcu::TestCaseGroup* targetGroup, glu::Storage storage)
{
targetGroup->addChild(new InterfaceBlockActiveVariablesTestCase(context, "named_block", "Named block", storage, InterfaceBlockActiveVariablesTestCase::CASE_NAMED_BLOCK));
targetGroup->addChild(new InterfaceBlockActiveVariablesTestCase(context, "unnamed_block", "Unnamed block", storage, InterfaceBlockActiveVariablesTestCase::CASE_UNNAMED_BLOCK));
targetGroup->addChild(new InterfaceBlockActiveVariablesTestCase(context, "block_array", "Block array", storage, InterfaceBlockActiveVariablesTestCase::CASE_BLOCK_ARRAY));
}
static void generateBufferBackedInterfaceResourceBufferDataSizeCases (Context& context, tcu::TestCaseGroup* targetGroup, glu::Storage storage)
{
targetGroup->addChild(new InterfaceBlockDataSizeTestCase(context, "named_block", "Named block", storage, InterfaceBlockDataSizeTestCase::CASE_NAMED_BLOCK));
targetGroup->addChild(new InterfaceBlockDataSizeTestCase(context, "unnamed_block", "Unnamed block", storage, InterfaceBlockDataSizeTestCase::CASE_UNNAMED_BLOCK));
targetGroup->addChild(new InterfaceBlockDataSizeTestCase(context, "block_array", "Block array", storage, InterfaceBlockDataSizeTestCase::CASE_BLOCK_ARRAY));
}
class BufferBackedBlockInterfaceTestGroup : public TestCaseGroup
{
public:
BufferBackedBlockInterfaceTestGroup (Context& context, glu::Storage interfaceBlockStorage);
void init (void);
private:
static const char* getGroupName (glu::Storage storage);
static const char* getGroupDescription (glu::Storage storage);
const glu::Storage m_storage;
};
BufferBackedBlockInterfaceTestGroup::BufferBackedBlockInterfaceTestGroup(Context& context, glu::Storage storage)
: TestCaseGroup (context, getGroupName(storage), getGroupDescription(storage))
, m_storage (storage)
{
DE_ASSERT(storage == glu::STORAGE_BUFFER || storage == glu::STORAGE_UNIFORM);
}
void BufferBackedBlockInterfaceTestGroup::init (void)
{
const glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
// .resource_list
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "resource_list", "Resource list");
addChild(blockGroup);
generateBufferBackedInterfaceResourceBasicBlockTypes(m_context, blockGroup, glslVersion, m_storage, generateBufferBackedInterfaceResourceListCase);
}
// .active_variables
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "active_variables", "Active variables");
addChild(blockGroup);
generateBufferBackedInterfaceResourceActiveVariablesCase(m_context, blockGroup, m_storage);
}
// .buffer_binding
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "buffer_binding", "Buffer binding");
addChild(blockGroup);
generateBufferBackedInterfaceResourceBufferBindingCases(m_context, blockGroup, glslVersion, m_storage);
}
// .buffer_data_size
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "buffer_data_size", "Buffer data size");
addChild(blockGroup);
generateBufferBackedInterfaceResourceBufferDataSizeCases(m_context, blockGroup, m_storage);
}
// .name_length
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "name_length", "Name length");
addChild(blockGroup);
generateBufferBackedInterfaceResourceBasicBlockTypes(m_context, blockGroup, glslVersion, m_storage, generateBufferBackedInterfaceNameLengthCase);
}
// .referenced_by
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "referenced_by", "Referenced by shader");
addChild(blockGroup);
if (m_storage == glu::STORAGE_UNIFORM)
generateReferencedByShaderCaseBlocks(m_context, blockGroup, glslVersion, generateBufferBlockReferencedByShaderSingleBlockContentCases<glu::STORAGE_UNIFORM>);
else if (m_storage == glu::STORAGE_BUFFER)
generateReferencedByShaderCaseBlocks(m_context, blockGroup, glslVersion, generateBufferBlockReferencedByShaderSingleBlockContentCases<glu::STORAGE_BUFFER>);
else
DE_ASSERT(false);
}
}
const char* BufferBackedBlockInterfaceTestGroup::getGroupName (glu::Storage storage)
{
switch (storage)
{
case glu::STORAGE_UNIFORM: return "uniform_block";
case glu::STORAGE_BUFFER: return "shader_storage_block";
default:
DE_FATAL("invalid storage enum value");
return DE_NULL;
}
}
const char* BufferBackedBlockInterfaceTestGroup::getGroupDescription (glu::Storage storage)
{
switch (storage)
{
case glu::STORAGE_UNIFORM: return "Uniform block interface";
case glu::STORAGE_BUFFER: return "Shader storage block interface";
default:
DE_FATAL("invalid storage enum value");
return DE_NULL;
}
}
class AtomicCounterTestGroup : public TestCaseGroup
{
public:
AtomicCounterTestGroup (Context& context);
void init (void);
};
AtomicCounterTestGroup::AtomicCounterTestGroup (Context& context)
: TestCaseGroup(context, "atomic_counter_buffer", "Atomic counter buffer")
{
}
void AtomicCounterTestGroup::init (void)
{
static const struct
{
const char* name;
deUint32 flags;
} pipelines[] =
{
{
"vertex_fragment",
(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT)
},
{
"vertex_tess_fragment",
(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_TESSELLATION_CONTROL) | (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION)
},
{
"vertex_geo_fragment",
(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_GEOMETRY)
},
{
"vertex_tess_geo_fragment",
(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_TESSELLATION_CONTROL) | (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION) | (1 << glu::SHADERTYPE_GEOMETRY),
},
};
// .resource_list
addChild(new AtomicCounterResourceListCase(m_context, "resource_list", "Resource list"));
// .active_variables
addChild(new AtomicCounterActiveVariablesCase(m_context, "active_variables", "Active variables"));
// .buffer_binding
addChild(new AtomicCounterBufferBindingCase(m_context, "buffer_binding", "Buffer binding"));
// .buffer_data_size
addChild(new AtomicCounterBufferDataSizeCase(m_context, "buffer_data_size", "Buffer binding"));
// .referenced_by
addChild(new AtomicCounterReferencedByCase(m_context, "referenced_by_compute", "", false, (1 << glu::SHADERTYPE_COMPUTE), (1 << glu::SHADERTYPE_COMPUTE)));
addChild(new AtomicCounterReferencedByCase(m_context, "referenced_by_separable_vertex", "", true, (1 << glu::SHADERTYPE_VERTEX), (1 << glu::SHADERTYPE_VERTEX)));
addChild(new AtomicCounterReferencedByCase(m_context, "referenced_by_separable_fragment", "", true, (1 << glu::SHADERTYPE_FRAGMENT), (1 << glu::SHADERTYPE_FRAGMENT)));
addChild(new AtomicCounterReferencedByCase(m_context, "referenced_by_separable_geometry", "", true, (1 << glu::SHADERTYPE_GEOMETRY), (1 << glu::SHADERTYPE_GEOMETRY)));
addChild(new AtomicCounterReferencedByCase(m_context, "referenced_by_separable_tess_ctrl", "", true, (1 << glu::SHADERTYPE_TESSELLATION_CONTROL), (1 << glu::SHADERTYPE_TESSELLATION_CONTROL)));
addChild(new AtomicCounterReferencedByCase(m_context, "referenced_by_separable_tess_eval", "", true, (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION), (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION)));
for (int pipelineNdx = 0; pipelineNdx < DE_LENGTH_OF_ARRAY(pipelines); ++pipelineNdx)
{
addChild(new AtomicCounterReferencedByCase(m_context, (std::string() + "referenced_by_" + pipelines[pipelineNdx].name).c_str(), "", false, pipelines[pipelineNdx].flags, pipelines[pipelineNdx].flags));
for (deUint32 stageNdx = 0; stageNdx < glu::SHADERTYPE_LAST; ++stageNdx)
{
const deUint32 currentBit = (1u << stageNdx);
if (currentBit > pipelines[pipelineNdx].flags)
break;
if (currentBit & pipelines[pipelineNdx].flags)
{
const char* stageName = (stageNdx == glu::SHADERTYPE_VERTEX) ? ("vertex")
: (stageNdx == glu::SHADERTYPE_FRAGMENT) ? ("fragment")
: (stageNdx == glu::SHADERTYPE_GEOMETRY) ? ("geo")
: (stageNdx == glu::SHADERTYPE_TESSELLATION_CONTROL) ? ("tess_ctrl")
: (stageNdx == glu::SHADERTYPE_TESSELLATION_EVALUATION) ? ("tess_eval")
: (DE_NULL);
const std::string name = std::string() + "referenced_by_" + pipelines[pipelineNdx].name + "_only_" + stageName;
addChild(new AtomicCounterReferencedByCase(m_context, name.c_str(), "", false, pipelines[pipelineNdx].flags, currentBit));
}
}
}
}
static void generateProgramInputOutputShaderCaseBlocks (Context& context, tcu::TestCaseGroup* targetGroup, glu::GLSLVersion glslVersion, bool withCompute, bool inputCase, bool isGL45, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*, deUint32, bool))
{
static const struct
{
const char* name;
glu::ShaderType stage;
} singleStageCases[] =
{
{ "separable_vertex", glu::SHADERTYPE_VERTEX },
{ "separable_fragment", glu::SHADERTYPE_FRAGMENT },
{ "separable_tess_ctrl", glu::SHADERTYPE_TESSELLATION_CONTROL },
{ "separable_tess_eval", glu::SHADERTYPE_TESSELLATION_EVALUATION },
{ "separable_geometry", glu::SHADERTYPE_GEOMETRY },
};
// .vertex_fragment
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "vertex_fragment", "Vertex and fragment");
const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program(false));
ResourceDefinition::ShaderSet* shaderSetPtr = new ResourceDefinition::ShaderSet(program, glslVersion);
const ResourceDefinition::Node::SharedPtr shaderSet (shaderSetPtr);
const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shaderSet));
shaderSetPtr->setStage(glu::SHADERTYPE_VERTEX, inputCase);
shaderSetPtr->setStage(glu::SHADERTYPE_FRAGMENT, !inputCase);
targetGroup->addChild(blockGroup);
blockContentGenerator(context, defaultBlock, blockGroup, (1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT), isGL45);
}
// .separable_*
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(singleStageCases); ++ndx)
{
TestCaseGroup* const blockGroup = new TestCaseGroup(context, singleStageCases[ndx].name, "");
const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program(true));
const ResourceDefinition::Node::SharedPtr shader (new ResourceDefinition::Shader(program, singleStageCases[ndx].stage, glslVersion));
const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader));
targetGroup->addChild(blockGroup);
blockContentGenerator(context, defaultBlock, blockGroup, (1 << singleStageCases[ndx].stage), isGL45);
}
// .compute
if (withCompute)
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "compute", "Compute");
const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program(true));
const ResourceDefinition::Node::SharedPtr shader (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader));
targetGroup->addChild(blockGroup);
blockContentGenerator(context, defaultBlock, blockGroup, (1 << glu::SHADERTYPE_COMPUTE), isGL45);
}
// .interface_blocks
{
static const struct
{
const char* inputName;
glu::ShaderType inputStage;
glu::Storage inputStorage;
const char* outputName;
glu::ShaderType outputStage;
glu::Storage outputStorage;
} ioBlockTypes[] =
{
{
"in",
glu::SHADERTYPE_FRAGMENT,
glu::STORAGE_IN,
"out",
glu::SHADERTYPE_VERTEX,
glu::STORAGE_OUT,
},
{
"patch_in",
glu::SHADERTYPE_TESSELLATION_EVALUATION,
glu::STORAGE_PATCH_IN,
"patch_out",
glu::SHADERTYPE_TESSELLATION_CONTROL,
glu::STORAGE_PATCH_OUT,
},
};
tcu::TestCaseGroup* const ioBlocksGroup = new TestCaseGroup(context, "interface_blocks", "Interface blocks");
targetGroup->addChild(ioBlocksGroup);
// .in/out
// .sample in/out
// .patch in/out
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(ioBlockTypes); ++ndx)
{
const char* const name = (inputCase) ? (ioBlockTypes[ndx].inputName) : (ioBlockTypes[ndx].outputName);
const glu::ShaderType shaderType = (inputCase) ? (ioBlockTypes[ndx].inputStage) : (ioBlockTypes[ndx].outputStage);
const glu::Storage storageType = (inputCase) ? (ioBlockTypes[ndx].inputStorage) : (ioBlockTypes[ndx].outputStorage);
tcu::TestCaseGroup* const ioBlockGroup = new TestCaseGroup(context, name, "");
const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program(true));
const ResourceDefinition::Node::SharedPtr shader (new ResourceDefinition::Shader(program, shaderType, glslVersion));
const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader));
const ResourceDefinition::Node::SharedPtr storage (new ResourceDefinition::StorageQualifier(defaultBlock, storageType));
ioBlocksGroup->addChild(ioBlockGroup);
// .named_block
{
const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(storage, true));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "named_block", "Named block");
ioBlockGroup->addChild(blockGroup);
blockContentGenerator(context, block, blockGroup, (1 << shaderType), isGL45);
}
// .named_block_explicit_location
{
const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(storage, glu::Layout(3)));
const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(layout, true));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "named_block_explicit_location", "Named block with explicit location");
ioBlockGroup->addChild(blockGroup);
blockContentGenerator(context, block, blockGroup, (1 << shaderType), isGL45);
}
// .unnamed_block
if (!isGL45)
{
const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(storage, false));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "unnamed_block", "Unnamed block");
ioBlockGroup->addChild(blockGroup);
blockContentGenerator(context, block, blockGroup, (1 << shaderType), isGL45);
}
// .block_array
{
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(storage));
const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(arrayElement, true));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "block_array", "Block array");
ioBlockGroup->addChild(blockGroup);
blockContentGenerator(context, block, blockGroup, (1 << shaderType), isGL45);
}
}
}
}
static void generateProgramInputBlockContents (Context& context,
const ResourceDefinition::Node::SharedPtr& parentStructure,
tcu::TestCaseGroup* targetGroup,
deUint32 presentShadersMask,
bool includeEmpty,
void (*genCase)(Context& context,
const ResourceDefinition::Node::SharedPtr& parentStructure,
tcu::TestCaseGroup* targetGroup,
ProgramInterface interface,
const char* name))
{
const bool inDefaultBlock = parentStructure->getType() == ResourceDefinition::Node::TYPE_DEFAULT_BLOCK;
const ResourceDefinition::Node::SharedPtr input = (inDefaultBlock)
? (ResourceDefinition::Node::SharedPtr(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_IN)))
: (parentStructure);
const glu::ShaderType firstStage = getShaderMaskFirstStage(presentShadersMask);
// .empty
if (includeEmpty && inDefaultBlock)
genCase(context, parentStructure, targetGroup, PROGRAMINTERFACE_PROGRAM_INPUT, "empty");
if (firstStage == glu::SHADERTYPE_VERTEX)
{
// .var
const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(input, glu::TYPE_FLOAT_VEC4));
genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_INPUT, "var");
}
else if (firstStage == glu::SHADERTYPE_FRAGMENT || !inDefaultBlock)
{
// .var
{
const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(input, glu::TYPE_FLOAT_VEC4));
genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_INPUT, "var");
}
// .var_struct
{
const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(input));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_INPUT, "var_struct");
}
// .var_array
{
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(input));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_INPUT, "var_array");
}
}
else if (firstStage == glu::SHADERTYPE_TESSELLATION_CONTROL ||
firstStage == glu::SHADERTYPE_GEOMETRY)
{
// arrayed interface
// .var
{
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(input, ResourceDefinition::ArrayElement::UNSIZED_ARRAY));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_INPUT, "var");
}
// extension forbids use arrays of structs
// extension forbids use arrays of arrays
}
else if (firstStage == glu::SHADERTYPE_TESSELLATION_EVALUATION)
{
// arrayed interface
const ResourceDefinition::Node::SharedPtr patchInput(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_PATCH_IN));
// .var
{
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(input, ResourceDefinition::ArrayElement::UNSIZED_ARRAY));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_INPUT, "var");
}
// extension forbids use arrays of structs
// extension forbids use arrays of arrays
// .patch_var
{
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(patchInput, glu::TYPE_FLOAT_VEC4));
genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_INPUT, "patch_var");
}
// .patch_var_struct
{
const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(patchInput));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_INPUT, "patch_var_struct");
}
// .patch_var_array
{
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(patchInput));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_INPUT, "patch_var_array");
}
}
else if (firstStage == glu::SHADERTYPE_COMPUTE)
{
// nada
}
else
DE_ASSERT(false);
}
static void generateProgramOutputBlockContents (Context& context,
const ResourceDefinition::Node::SharedPtr& parentStructure,
tcu::TestCaseGroup* targetGroup,
deUint32 presentShadersMask,
bool includeEmpty,
void (*genCase)(Context& context,
const ResourceDefinition::Node::SharedPtr& parentStructure,
tcu::TestCaseGroup* targetGroup,
ProgramInterface interface,
const char* name))
{
const bool inDefaultBlock = parentStructure->getType() == ResourceDefinition::Node::TYPE_DEFAULT_BLOCK;
const ResourceDefinition::Node::SharedPtr output = (inDefaultBlock)
? (ResourceDefinition::Node::SharedPtr(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_OUT)))
: (parentStructure);
const glu::ShaderType lastStage = getShaderMaskLastStage(presentShadersMask);
// .empty
if (includeEmpty && inDefaultBlock)
genCase(context, parentStructure, targetGroup, PROGRAMINTERFACE_PROGRAM_OUTPUT, "empty");
if (lastStage == glu::SHADERTYPE_VERTEX ||
lastStage == glu::SHADERTYPE_GEOMETRY ||
lastStage == glu::SHADERTYPE_TESSELLATION_EVALUATION ||
!inDefaultBlock)
{
// .var
{
const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(output, glu::TYPE_FLOAT_VEC4));
genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_OUTPUT, "var");
}
// .var_struct
{
const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(output));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_OUTPUT, "var_struct");
}
// .var_array
{
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(output));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_OUTPUT, "var_array");
}
}
else if (lastStage == glu::SHADERTYPE_FRAGMENT)
{
// .var
{
const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(output, glu::TYPE_FLOAT_VEC4));
genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_OUTPUT, "var");
}
// .var_array
{
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(output));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_OUTPUT, "var_array");
}
}
else if (lastStage == glu::SHADERTYPE_TESSELLATION_CONTROL)
{
// arrayed interface
const ResourceDefinition::Node::SharedPtr patchOutput(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_PATCH_OUT));
// .var
{
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(output, ResourceDefinition::ArrayElement::UNSIZED_ARRAY));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_OUTPUT, "var");
}
// extension forbids use arrays of structs
// extension forbids use array of arrays
// .patch_var
{
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(patchOutput, glu::TYPE_FLOAT_VEC4));
genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_OUTPUT, "patch_var");
}
// .patch_var_struct
{
const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(patchOutput));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_OUTPUT, "patch_var_struct");
}
// .patch_var_array
{
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(patchOutput));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
genCase(context, variable, targetGroup, PROGRAMINTERFACE_PROGRAM_OUTPUT, "patch_var_array");
}
}
else if (lastStage == glu::SHADERTYPE_COMPUTE)
{
// nada
}
else
DE_ASSERT(false);
}
static void addProgramInputOutputResourceListCase (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, ProgramInterface programInterface, const char* name)
{
ResourceListTestCase* const resourceListCase = new ResourceListTestCase(context, parentStructure, programInterface);
DE_ASSERT(deStringEqual(name, resourceListCase->getName()));
DE_UNREF(name);
targetGroup->addChild(resourceListCase);
}
static void generateProgramInputResourceListBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, deUint32 presentShadersMask, bool isGL45)
{
DE_UNREF(isGL45);
generateProgramInputBlockContents(context, parentStructure, targetGroup, presentShadersMask, true, addProgramInputOutputResourceListCase);
}
static void generateProgramOutputResourceListBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, deUint32 presentShadersMask, bool isGL45)
{
DE_UNREF(isGL45);
generateProgramOutputBlockContents(context, parentStructure, targetGroup, presentShadersMask, true, addProgramInputOutputResourceListCase);
}
template <ProgramResourcePropFlags TargetProp>
static void addProgramInputOutputResourceTestCase (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, ProgramInterface programInterface, const char* name)
{
ResourceTestCase* const resourceTestCase = new ResourceTestCase(context, parentStructure, ProgramResourceQueryTestTarget(programInterface, TargetProp), name);
targetGroup->addChild(resourceTestCase);
}
template <ProgramResourcePropFlags TargetProp>
static void generateProgramInputBasicBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, deUint32 presentShadersMask, bool isGL45)
{
DE_UNREF(isGL45);
generateProgramInputBlockContents(context, parentStructure, targetGroup, presentShadersMask, false, addProgramInputOutputResourceTestCase<TargetProp>);
}
template <ProgramResourcePropFlags TargetProp>
static void generateProgramOutputBasicBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, deUint32 presentShadersMask, bool isGL45)
{
DE_UNREF(isGL45);
generateProgramOutputBlockContents(context, parentStructure, targetGroup, presentShadersMask, false, addProgramInputOutputResourceTestCase<TargetProp>);
}
static void generateProgramInputLocationBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, deUint32 presentShadersMask, bool isGL45)
{
DE_UNREF(isGL45);
const bool inDefaultBlock = parentStructure->getType() == ResourceDefinition::Node::TYPE_DEFAULT_BLOCK;
const ResourceDefinition::Node::SharedPtr input = (inDefaultBlock)
? (ResourceDefinition::Node::SharedPtr(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_IN)))
: (parentStructure);
const glu::ShaderType firstStage = getShaderMaskFirstStage(presentShadersMask);
if (firstStage == glu::SHADERTYPE_VERTEX)
{
// .var
{
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(input, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var"));
}
// .var_explicit_location
{
const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(input, glu::Layout(2)));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(layout, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var_explicit_location"));
}
}
else if (firstStage == glu::SHADERTYPE_FRAGMENT || !inDefaultBlock)
{
// .var
{
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(input, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var"));
}
// .var_explicit_location
{
const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(input, glu::Layout(2)));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(layout, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var_explicit_location"));
}
// .var_struct
{
const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(input));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var_struct"));
}
// .var_struct_explicit_location
{
const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(input, glu::Layout(2)));
const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(layout));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var_struct_explicit_location"));
}
// .var_array
{
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(input));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var_array"));
}
// .var_array_explicit_location
{
const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(input, glu::Layout(2)));
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(layout));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var_array_explicit_location"));
}
}
else if (firstStage == glu::SHADERTYPE_TESSELLATION_CONTROL ||
firstStage == glu::SHADERTYPE_GEOMETRY)
{
// arrayed interface
// .var
{
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(input, ResourceDefinition::ArrayElement::UNSIZED_ARRAY));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var"));
}
// .var_explicit_location
{
const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(input, glu::Layout(2)));
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(layout, ResourceDefinition::ArrayElement::UNSIZED_ARRAY));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var_explicit_location"));
}
// extension forbids use arrays of structs
// extension forbids use arrays of arrays
}
else if (firstStage == glu::SHADERTYPE_TESSELLATION_EVALUATION)
{
// arrayed interface
const ResourceDefinition::Node::SharedPtr patchInput(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_PATCH_IN));
// .var
{
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(input, ResourceDefinition::ArrayElement::UNSIZED_ARRAY));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var"));
}
// .var_explicit_location
{
const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(input, glu::Layout(2)));
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(layout, ResourceDefinition::ArrayElement::UNSIZED_ARRAY));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "var_explicit_location"));
}
// extension forbids use arrays of structs
// extension forbids use arrays of arrays
// .patch_var
{
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(patchInput, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var"));
}
// .patch_var_explicit_location
{
const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(patchInput, glu::Layout(2)));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(layout, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var_explicit_location"));
}
// .patch_var_struct
{
const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(patchInput));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var_struct"));
}
// .patch_var_struct_explicit_location
{
const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(patchInput, glu::Layout(2)));
const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(layout));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var_struct_explicit_location"));
}
// .patch_var_array
{
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(patchInput));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var_array"));
}
// .patch_var_array_explicit_location
{
const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(patchInput, glu::Layout(2)));
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(layout));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_INPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var_array_explicit_location"));
}
}
else if (firstStage == glu::SHADERTYPE_COMPUTE)
{
// nada
}
else
DE_ASSERT(false);
}
static void generateProgramOutputLocationBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, deUint32 presentShadersMask, bool isGL45)
{
const bool inDefaultBlock = parentStructure->getType() == ResourceDefinition::Node::TYPE_DEFAULT_BLOCK;
const ResourceDefinition::Node::SharedPtr output = (inDefaultBlock)
? (ResourceDefinition::Node::SharedPtr(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_OUT)))
: (parentStructure);
const glu::ShaderType lastStage = getShaderMaskLastStage(presentShadersMask);
const bool inBlockArray = 0 == deStringEqual("block_array", targetGroup->getName());
if (lastStage == glu::SHADERTYPE_VERTEX ||
lastStage == glu::SHADERTYPE_GEOMETRY ||
lastStage == glu::SHADERTYPE_TESSELLATION_EVALUATION ||
!inDefaultBlock)
{
// .var
{
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(output, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var"));
}
// .var_explicit_location
if (!(isGL45 && inBlockArray))
{
const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(output, glu::Layout(2)));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(layout, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var_explicit_location"));
}
// .var_struct
{
const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(output));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var_struct"));
}
// .var_struct_explicit_location
if (!(isGL45 && inBlockArray))
{
const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(output, glu::Layout(2)));
const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(layout));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var_struct_explicit_location"));
}
// .var_array
{
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(output));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var_array"));
}
// .var_array_explicit_location
if (!(isGL45 && inBlockArray))
{
const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(output, glu::Layout(2)));
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(layout));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var_array_explicit_location"));
}
}
else if (lastStage == glu::SHADERTYPE_FRAGMENT)
{
// .var
{
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(output, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var"));
}
// .var_explicit_location
if (!(isGL45 && inBlockArray))
{
const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(output, glu::Layout(2)));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(layout, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var_explicit_location"));
}
// .var_array
{
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(output));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var_array"));
}
// .var_array_explicit_location
if (!(isGL45 && inBlockArray))
{
const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(output, glu::Layout(1)));
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(layout));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var_array_explicit_location"));
}
}
else if (lastStage == glu::SHADERTYPE_TESSELLATION_CONTROL)
{
// arrayed interface
const ResourceDefinition::Node::SharedPtr patchOutput(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_PATCH_OUT));
// .var
{
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(output, ResourceDefinition::ArrayElement::UNSIZED_ARRAY));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var"));
}
// .var_explicit_location
{
const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(output, glu::Layout(2)));
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(layout, ResourceDefinition::ArrayElement::UNSIZED_ARRAY));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "var_explicit_location"));
}
// extension forbids use arrays of structs
// extension forbids use array of arrays
// .patch_var
{
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(patchOutput, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var"));
}
// .patch_var_explicit_location
{
const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(patchOutput, glu::Layout(2)));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(layout, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var_explicit_location"));
}
// .patch_var_struct
{
const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(patchOutput));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var_struct"));
}
// .patch_var_struct_explicit_location
{
const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(patchOutput, glu::Layout(2)));
const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(layout));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var_struct_explicit_location"));
}
// .patch_var_array
{
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(patchOutput));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var_array"));
}
// .patch_var_array_explicit_location
{
const ResourceDefinition::Node::SharedPtr layout (new ResourceDefinition::LayoutQualifier(patchOutput, glu::Layout(2)));
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(layout));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_PROGRAM_OUTPUT, PROGRAMRESOURCEPROP_LOCATION), "patch_var_array_explicit_location"));
}
}
else if (lastStage == glu::SHADERTYPE_COMPUTE)
{
// nada
}
else
DE_ASSERT(false);
}
static void generateProgramInputOutputReferencedByCases (Context& context, tcu::TestCaseGroup* targetGroup, glu::Storage storage)
{
// all whole pipelines
targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_vertex_fragment", "", storage, ProgramInputOutputReferencedByCase::CASE_VERTEX_FRAGMENT));
targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_vertex_tess_fragment", "", storage, ProgramInputOutputReferencedByCase::CASE_VERTEX_TESS_FRAGMENT));
targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_vertex_geo_fragment", "", storage, ProgramInputOutputReferencedByCase::CASE_VERTEX_GEO_FRAGMENT));
targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_vertex_tess_geo_fragment", "", storage, ProgramInputOutputReferencedByCase::CASE_VERTEX_TESS_GEO_FRAGMENT));
// all partial pipelines
targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_separable_vertex", "", storage, ProgramInputOutputReferencedByCase::CASE_SEPARABLE_VERTEX));
targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_separable_fragment", "", storage, ProgramInputOutputReferencedByCase::CASE_SEPARABLE_FRAGMENT));
targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_separable_geometry", "", storage, ProgramInputOutputReferencedByCase::CASE_SEPARABLE_GEOMETRY));
targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_separable_tess_eval", "", storage, ProgramInputOutputReferencedByCase::CASE_SEPARABLE_TESS_EVAL));
targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_separable_tess_ctrl", "", storage, ProgramInputOutputReferencedByCase::CASE_SEPARABLE_TESS_CTRL));
// patch
if (storage == glu::STORAGE_IN)
targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_separable_tess_eval_patch_in", "", glu::STORAGE_PATCH_IN, ProgramInputOutputReferencedByCase::CASE_SEPARABLE_TESS_EVAL));
else if (storage == glu::STORAGE_OUT)
targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_separable_tess_ctrl_patch_out", "", glu::STORAGE_PATCH_OUT, ProgramInputOutputReferencedByCase::CASE_SEPARABLE_TESS_CTRL));
else
DE_ASSERT(false);
}
template <ProgramInterface interface>
static void generateProgramInputOutputTypeBasicTypeCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, bool allowMatrixCases, int expandLevel)
{
static const struct
{
glu::DataType type;
bool isMatrix;
int level;
} variableTypes[] =
{
{ glu::TYPE_FLOAT, false, 0 },
{ glu::TYPE_INT, false, 1 },
{ glu::TYPE_UINT, false, 1 },
{ glu::TYPE_FLOAT_VEC2, false, 2 },
{ glu::TYPE_FLOAT_VEC3, false, 1 },
{ glu::TYPE_FLOAT_VEC4, false, 2 },
{ glu::TYPE_INT_VEC2, false, 0 },
{ glu::TYPE_INT_VEC3, false, 2 },
{ glu::TYPE_INT_VEC4, false, 2 },
{ glu::TYPE_UINT_VEC2, false, 2 },
{ glu::TYPE_UINT_VEC3, false, 2 },
{ glu::TYPE_UINT_VEC4, false, 0 },
{ glu::TYPE_FLOAT_MAT2, true, 2 },
{ glu::TYPE_FLOAT_MAT2X3, true, 2 },
{ glu::TYPE_FLOAT_MAT2X4, true, 2 },
{ glu::TYPE_FLOAT_MAT3X2, true, 0 },
{ glu::TYPE_FLOAT_MAT3, true, 2 },
{ glu::TYPE_FLOAT_MAT3X4, true, 2 },
{ glu::TYPE_FLOAT_MAT4X2, true, 2 },
{ glu::TYPE_FLOAT_MAT4X3, true, 2 },
{ glu::TYPE_FLOAT_MAT4, true, 2 },
};
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(variableTypes); ++ndx)
{
if (!allowMatrixCases && variableTypes[ndx].isMatrix)
continue;
if (variableTypes[ndx].level <= expandLevel)
{
const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(parentStructure, variableTypes[ndx].type));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(interface, PROGRAMRESOURCEPROP_TYPE)));
}
}
}
static void generateProgramInputTypeBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, deUint32 presentShadersMask, bool isGL45)
{
DE_UNREF(isGL45);
const bool inDefaultBlock = parentStructure->getType() == ResourceDefinition::Node::TYPE_DEFAULT_BLOCK;
const ResourceDefinition::Node::SharedPtr input = (inDefaultBlock)
? (ResourceDefinition::Node::SharedPtr(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_IN)))
: (parentStructure);
const glu::ShaderType firstStage = getShaderMaskFirstStage(presentShadersMask);
const int interfaceBlockExpansionReducement = (!inDefaultBlock) ? (1) : (0); // lesser expansions on block members to keep test counts reasonable
if (firstStage == glu::SHADERTYPE_VERTEX)
{
// Only basic types (and no booleans)
generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_INPUT>(context, input, targetGroup, true, 2 - interfaceBlockExpansionReducement);
}
else if (firstStage == glu::SHADERTYPE_FRAGMENT || !inDefaultBlock)
{
const ResourceDefinition::Node::SharedPtr flatShading(new ResourceDefinition::InterpolationQualifier(input, glu::INTERPOLATION_FLAT));
// Only basic types, arrays of basic types, struct of basic types (and no booleans)
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "basic_type", "Basic types");
targetGroup->addChild(blockGroup);
generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_INPUT>(context, flatShading, blockGroup, true, 2 - interfaceBlockExpansionReducement);
}
{
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(flatShading));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "array", "Array types");
targetGroup->addChild(blockGroup);
generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_INPUT>(context, arrayElement, blockGroup, true, 2 - interfaceBlockExpansionReducement);
}
{
const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(flatShading));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "struct", "Struct types");
targetGroup->addChild(blockGroup);
generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_INPUT>(context, structMember, blockGroup, true, 2 - interfaceBlockExpansionReducement);
}
}
else if (firstStage == glu::SHADERTYPE_TESSELLATION_CONTROL ||
firstStage == glu::SHADERTYPE_GEOMETRY)
{
// arrayed interface
// Only basic types (and no booleans)
const ResourceDefinition::Node::SharedPtr arrayElement(new ResourceDefinition::ArrayElement(input, ResourceDefinition::ArrayElement::UNSIZED_ARRAY));
generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_INPUT>(context, arrayElement, targetGroup, true, 2);
}
else if (firstStage == glu::SHADERTYPE_TESSELLATION_EVALUATION)
{
// arrayed interface
const ResourceDefinition::Node::SharedPtr patchInput(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_PATCH_IN));
// .var
{
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(input, ResourceDefinition::ArrayElement::UNSIZED_ARRAY));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "basic_type", "Basic types");
targetGroup->addChild(blockGroup);
generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_INPUT>(context, arrayElem, blockGroup, true, 2);
}
// extension forbids use arrays of structs
// extension forbids use arrays of arrays
// .patch_var
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "patch_var", "Basic types, per-patch");
targetGroup->addChild(blockGroup);
generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_INPUT>(context, patchInput, blockGroup, true, 1);
}
// .patch_var_struct
{
const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(patchInput));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "patch_var_struct", "Struct types, per-patch");
targetGroup->addChild(blockGroup);
generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_INPUT>(context, structMbr, blockGroup, true, 1);
}
// .patch_var_array
{
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(patchInput));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "patch_var_array", "Array types, per-patch");
targetGroup->addChild(blockGroup);
generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_INPUT>(context, arrayElem, blockGroup, true, 1);
}
}
else if (firstStage == glu::SHADERTYPE_COMPUTE)
{
// nada
}
else
DE_ASSERT(false);
}
static void generateProgramOutputTypeBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, deUint32 presentShadersMask, bool isGL45)
{
DE_UNREF(isGL45);
const bool inDefaultBlock = parentStructure->getType() == ResourceDefinition::Node::TYPE_DEFAULT_BLOCK;
const ResourceDefinition::Node::SharedPtr output = (inDefaultBlock)
? (ResourceDefinition::Node::SharedPtr(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_OUT)))
: (parentStructure);
const glu::ShaderType lastStage = getShaderMaskLastStage(presentShadersMask);
const int interfaceBlockExpansionReducement = (!inDefaultBlock) ? (1) : (0); // lesser expansions on block members to keep test counts reasonable
if (lastStage == glu::SHADERTYPE_VERTEX ||
lastStage == glu::SHADERTYPE_GEOMETRY ||
lastStage == glu::SHADERTYPE_TESSELLATION_EVALUATION ||
!inDefaultBlock)
{
const ResourceDefinition::Node::SharedPtr flatShading(new ResourceDefinition::InterpolationQualifier(output, glu::INTERPOLATION_FLAT));
// Only basic types, arrays of basic types, struct of basic types (and no booleans)
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "basic_type", "Basic types");
targetGroup->addChild(blockGroup);
generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_OUTPUT>(context, flatShading, blockGroup, true, 2 - interfaceBlockExpansionReducement);
}
{
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(flatShading));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "array", "Array types");
const int typeExpansionReducement = (lastStage != glu::SHADERTYPE_VERTEX) ? (1) : (0); // lesser expansions on other stages
const int expansionLevel = 2 - interfaceBlockExpansionReducement - typeExpansionReducement;
targetGroup->addChild(blockGroup);
generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_OUTPUT>(context, arrayElement, blockGroup, true, expansionLevel);
}
{
const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(flatShading));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "struct", "Struct types");
const int typeExpansionReducement = (lastStage != glu::SHADERTYPE_VERTEX) ? (1) : (0); // lesser expansions on other stages
const int expansionLevel = 2 - interfaceBlockExpansionReducement - typeExpansionReducement;
targetGroup->addChild(blockGroup);
generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_OUTPUT>(context, structMember, blockGroup, true, expansionLevel);
}
}
else if (lastStage == glu::SHADERTYPE_FRAGMENT)
{
// only basic type and basic type array (and no booleans or matrices)
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "basic_type", "Basic types");
targetGroup->addChild(blockGroup);
generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_OUTPUT>(context, output, blockGroup, false, 2);
}
{
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(output));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "array", "Array types");
targetGroup->addChild(blockGroup);
generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_OUTPUT>(context, arrayElement, blockGroup, false, 2);
}
}
else if (lastStage == glu::SHADERTYPE_TESSELLATION_CONTROL)
{
// arrayed interface
const ResourceDefinition::Node::SharedPtr patchOutput(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_PATCH_OUT));
// .var
{
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(output, ResourceDefinition::ArrayElement::UNSIZED_ARRAY));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "basic_type", "Basic types");
targetGroup->addChild(blockGroup);
generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_OUTPUT>(context, arrayElem, blockGroup, true, 2);
}
// extension forbids use arrays of structs
// extension forbids use arrays of arrays
// .patch_var
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "patch_var", "Basic types, per-patch");
targetGroup->addChild(blockGroup);
generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_OUTPUT>(context, patchOutput, blockGroup, true, 1);
}
// .patch_var_struct
{
const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(patchOutput));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "patch_var_struct", "Struct types, per-patch");
targetGroup->addChild(blockGroup);
generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_OUTPUT>(context, structMbr, blockGroup, true, 1);
}
// .patch_var_array
{
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(patchOutput));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "patch_var_array", "Array types, per-patch");
targetGroup->addChild(blockGroup);
generateProgramInputOutputTypeBasicTypeCases<PROGRAMINTERFACE_PROGRAM_OUTPUT>(context, arrayElem, blockGroup, true, 1);
}
}
else if (lastStage == glu::SHADERTYPE_COMPUTE)
{
// nada
}
else
DE_ASSERT(false);
}
class ProgramInputTestGroup : public TestCaseGroup
{
public:
ProgramInputTestGroup (Context& context, bool is_GL45);
void init (void);
private:
bool m_isGL45;
};
ProgramInputTestGroup::ProgramInputTestGroup (Context& context, bool is_GL45)
: TestCaseGroup(context, "program_input", "Program input")
, m_isGL45(is_GL45)
{
}
void ProgramInputTestGroup::init (void)
{
const glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
// .resource_list
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "resource_list", "Resource list");
addChild(blockGroup);
generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, true, true, m_isGL45, generateProgramInputResourceListBlockContents);
}
// .array_size
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "array_size", "Array size");
addChild(blockGroup);
generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, false, true, m_isGL45, generateProgramInputBasicBlockContents<PROGRAMRESOURCEPROP_ARRAY_SIZE>);
}
// .location
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "location", "Location");
addChild(blockGroup);
generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, false, true, m_isGL45, generateProgramInputLocationBlockContents);
}
// .name_length
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "name_length", "Name length");
addChild(blockGroup);
generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, false, true, m_isGL45, generateProgramInputBasicBlockContents<PROGRAMRESOURCEPROP_NAME_LENGTH>);
}
// .referenced_by
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "referenced_by", "Reference by shader");
addChild(blockGroup);
generateProgramInputOutputReferencedByCases(m_context, blockGroup, glu::STORAGE_IN);
}
// .type
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "type", "Type");
addChild(blockGroup);
generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, false, true, m_isGL45, generateProgramInputTypeBlockContents);
}
// .is_per_patch
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "is_per_patch", "Is per patch");
addChild(blockGroup);
generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, false, true, m_isGL45, generateProgramInputBasicBlockContents<PROGRAMRESOURCEPROP_IS_PER_PATCH>);
}
}
class ProgramOutputTestGroup : public TestCaseGroup
{
public:
ProgramOutputTestGroup (Context& context, bool is_GL45);
void init (void);
private:
bool m_isGL45;
};
ProgramOutputTestGroup::ProgramOutputTestGroup (Context& context, bool is_GL45)
: TestCaseGroup(context, "program_output", "Program output")
, m_isGL45(is_GL45)
{
}
void ProgramOutputTestGroup::init (void)
{
const glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
// .resource_list
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "resource_list", "Resource list");
addChild(blockGroup);
generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, true, false, m_isGL45, generateProgramOutputResourceListBlockContents);
}
// .array_size
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "array_size", "Array size");
addChild(blockGroup);
generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, false, false, m_isGL45, generateProgramOutputBasicBlockContents<PROGRAMRESOURCEPROP_ARRAY_SIZE>);
}
// .location
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "location", "Location");
addChild(blockGroup);
generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, false, false, m_isGL45, generateProgramOutputLocationBlockContents);
}
// .name_length
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "name_length", "Name length");
addChild(blockGroup);
generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, false, false, m_isGL45, generateProgramOutputBasicBlockContents<PROGRAMRESOURCEPROP_NAME_LENGTH>);
}
// .referenced_by
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "referenced_by", "Reference by shader");
addChild(blockGroup);
generateProgramInputOutputReferencedByCases(m_context, blockGroup, glu::STORAGE_OUT);
}
// .type
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "type", "Type");
addChild(blockGroup);
generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, false, false, m_isGL45, generateProgramOutputTypeBlockContents);
}
// .is_per_patch
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "is_per_patch", "Is per patch");
addChild(blockGroup);
generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, false, false, m_isGL45, generateProgramOutputBasicBlockContents<PROGRAMRESOURCEPROP_IS_PER_PATCH>);
}
}
static void generateTransformFeedbackShaderCaseBlocks (Context& context, tcu::TestCaseGroup* targetGroup, glu::GLSLVersion glslVersion, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*, bool))
{
static const struct
{
const char* name;
deUint32 stageBits;
deUint32 lastStageBit;
bool reducedSet;
} pipelines[] =
{
{
"vertex_fragment",
(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT),
(1 << glu::SHADERTYPE_VERTEX),
false
},
{
"vertex_tess_fragment",
(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_TESSELLATION_CONTROL) | (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION),
(1 << glu::SHADERTYPE_TESSELLATION_EVALUATION),
true
},
{
"vertex_geo_fragment",
(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_GEOMETRY),
(1 << glu::SHADERTYPE_GEOMETRY),
true
},
{
"vertex_tess_geo_fragment",
(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_TESSELLATION_CONTROL) | (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION) | (1 << glu::SHADERTYPE_GEOMETRY),
(1 << glu::SHADERTYPE_GEOMETRY),
true
},
};
static const struct
{
const char* name;
glu::ShaderType stage;
bool reducedSet;
} singleStageCases[] =
{
{ "separable_vertex", glu::SHADERTYPE_VERTEX, false },
{ "separable_tess_eval", glu::SHADERTYPE_TESSELLATION_EVALUATION, true },
{ "separable_geometry", glu::SHADERTYPE_GEOMETRY, true },
};
// monolithic pipeline
for (int pipelineNdx = 0; pipelineNdx < DE_LENGTH_OF_ARRAY(pipelines); ++pipelineNdx)
{
TestCaseGroup* const blockGroup = new TestCaseGroup(context, pipelines[pipelineNdx].name, "");
const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program());
const ResourceDefinition::Node::SharedPtr shaderSet (new ResourceDefinition::ShaderSet(program,
glslVersion,
pipelines[pipelineNdx].stageBits,
pipelines[pipelineNdx].lastStageBit));
targetGroup->addChild(blockGroup);
blockContentGenerator(context, shaderSet, blockGroup, pipelines[pipelineNdx].reducedSet);
}
// separable pipeline
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(singleStageCases); ++ndx)
{
TestCaseGroup* const blockGroup = new TestCaseGroup(context, singleStageCases[ndx].name, "");
const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program(true));
const ResourceDefinition::Node::SharedPtr shader (new ResourceDefinition::Shader(program, singleStageCases[ndx].stage, glslVersion));
targetGroup->addChild(blockGroup);
blockContentGenerator(context, shader, blockGroup, singleStageCases[ndx].reducedSet);
}
}
static void generateTransformFeedbackResourceListBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, bool reducedSet)
{
const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(parentStructure));
const ResourceDefinition::Node::SharedPtr output (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_OUT));
DE_UNREF(reducedSet);
// .builtin_gl_position
{
const ResourceDefinition::Node::SharedPtr xfbTarget(new ResourceDefinition::TransformFeedbackTarget(defaultBlock, "gl_Position"));
targetGroup->addChild(new FeedbackResourceListTestCase(context, xfbTarget, "builtin_gl_position"));
}
// .default_block_basic_type
{
const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(output));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(xfbTarget, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new FeedbackResourceListTestCase(context, variable, "default_block_basic_type"));
}
// .default_block_struct_member
{
const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(output));
const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(structMbr));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(xfbTarget, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new FeedbackResourceListTestCase(context, variable, "default_block_struct_member"));
}
// .default_block_array
{
const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(output));
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(xfbTarget));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new FeedbackResourceListTestCase(context, variable, "default_block_array"));
}
// .default_block_array_element
{
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(output));
const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(arrayElem));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(xfbTarget, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new FeedbackResourceListTestCase(context, variable, "default_block_array_element"));
}
}
template <ProgramResourcePropFlags TargetProp>
static void generateTransformFeedbackVariableBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, bool reducedSet)
{
const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(parentStructure));
const ResourceDefinition::Node::SharedPtr output (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_OUT));
DE_UNREF(reducedSet);
// .builtin_gl_position
{
const ResourceDefinition::Node::SharedPtr xfbTarget(new ResourceDefinition::TransformFeedbackTarget(defaultBlock, "gl_Position"));
targetGroup->addChild(new ResourceTestCase(context, xfbTarget, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_TRANSFORM_FEEDBACK_VARYING, TargetProp), "builtin_gl_position"));
}
// .default_block_basic_type
{
const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(output));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(xfbTarget, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_TRANSFORM_FEEDBACK_VARYING, TargetProp), "default_block_basic_type"));
}
// .default_block_struct_member
{
const ResourceDefinition::Node::SharedPtr structMbr (new ResourceDefinition::StructMember(output));
const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(structMbr));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(xfbTarget, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_TRANSFORM_FEEDBACK_VARYING, TargetProp), "default_block_struct_member"));
}
// .default_block_array
{
const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(output));
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(xfbTarget));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_TRANSFORM_FEEDBACK_VARYING, TargetProp), "default_block_array"));
}
// .default_block_array_element
{
const ResourceDefinition::Node::SharedPtr arrayElem (new ResourceDefinition::ArrayElement(output));
const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(arrayElem));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(xfbTarget, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_TRANSFORM_FEEDBACK_VARYING, TargetProp), "default_block_array_element"));
}
}
static void generateTransformFeedbackVariableBasicTypeCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, bool reducedSet)
{
static const struct
{
glu::DataType type;
bool important;
} variableTypes[] =
{
{ glu::TYPE_FLOAT, true },
{ glu::TYPE_INT, true },
{ glu::TYPE_UINT, true },
{ glu::TYPE_FLOAT_VEC2, false },
{ glu::TYPE_FLOAT_VEC3, true },
{ glu::TYPE_FLOAT_VEC4, false },
{ glu::TYPE_INT_VEC2, false },
{ glu::TYPE_INT_VEC3, true },
{ glu::TYPE_INT_VEC4, false },
{ glu::TYPE_UINT_VEC2, true },
{ glu::TYPE_UINT_VEC3, false },
{ glu::TYPE_UINT_VEC4, false },
{ glu::TYPE_FLOAT_MAT2, false },
{ glu::TYPE_FLOAT_MAT2X3, false },
{ glu::TYPE_FLOAT_MAT2X4, false },
{ glu::TYPE_FLOAT_MAT3X2, false },
{ glu::TYPE_FLOAT_MAT3, false },
{ glu::TYPE_FLOAT_MAT3X4, true },
{ glu::TYPE_FLOAT_MAT4X2, false },
{ glu::TYPE_FLOAT_MAT4X3, false },
{ glu::TYPE_FLOAT_MAT4, false },
};
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(variableTypes); ++ndx)
{
if (variableTypes[ndx].important || !reducedSet)
{
const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(parentStructure, variableTypes[ndx].type));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_TRANSFORM_FEEDBACK_VARYING, PROGRAMRESOURCEPROP_TYPE)));
}
}
}
static void generateTransformFeedbackVariableTypeBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, bool reducedSet)
{
const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(parentStructure));
const ResourceDefinition::Node::SharedPtr output (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_OUT));
const ResourceDefinition::Node::SharedPtr flatShading (new ResourceDefinition::InterpolationQualifier(output, glu::INTERPOLATION_FLAT));
// Only builtins, basic types, arrays of basic types, struct of basic types (and no booleans)
{
const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(defaultBlock, "gl_Position"));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "builtin", "Built-in outputs");
targetGroup->addChild(blockGroup);
blockGroup->addChild(new ResourceTestCase(context, xfbTarget, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_TRANSFORM_FEEDBACK_VARYING, PROGRAMRESOURCEPROP_TYPE), "gl_position"));
}
{
const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(flatShading));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "basic_type", "Basic types");
targetGroup->addChild(blockGroup);
generateTransformFeedbackVariableBasicTypeCases(context, xfbTarget, blockGroup, reducedSet);
}
{
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(flatShading));
const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(arrayElement));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "array", "Array types");
targetGroup->addChild(blockGroup);
generateTransformFeedbackVariableBasicTypeCases(context, xfbTarget, blockGroup, reducedSet);
}
{
const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(flatShading));
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(xfbTarget));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "whole_array", "Whole array");
targetGroup->addChild(blockGroup);
generateTransformFeedbackVariableBasicTypeCases(context, arrayElement, blockGroup, reducedSet);
}
{
const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(flatShading));
const ResourceDefinition::Node::SharedPtr xfbTarget (new ResourceDefinition::TransformFeedbackTarget(structMember));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "struct", "Struct types");
targetGroup->addChild(blockGroup);
generateTransformFeedbackVariableBasicTypeCases(context, xfbTarget, blockGroup, reducedSet);
}
}
class TransformFeedbackVaryingTestGroup : public TestCaseGroup
{
public:
TransformFeedbackVaryingTestGroup (Context& context);
void init (void);
};
TransformFeedbackVaryingTestGroup::TransformFeedbackVaryingTestGroup (Context& context)
: TestCaseGroup(context, "transform_feedback_varying", "Transform feedback varyings")
{
}
void TransformFeedbackVaryingTestGroup::init (void)
{
const glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
// .resource_list
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "resource_list", "Resource list");
addChild(blockGroup);
generateTransformFeedbackShaderCaseBlocks(m_context, blockGroup, glslVersion, generateTransformFeedbackResourceListBlockContents);
}
// .array_size
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "array_size", "Array size");
addChild(blockGroup);
generateTransformFeedbackShaderCaseBlocks(m_context, blockGroup, glslVersion, generateTransformFeedbackVariableBlockContents<PROGRAMRESOURCEPROP_ARRAY_SIZE>);
}
// .name_length
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "name_length", "Name length");
addChild(blockGroup);
generateTransformFeedbackShaderCaseBlocks(m_context, blockGroup, glslVersion, generateTransformFeedbackVariableBlockContents<PROGRAMRESOURCEPROP_NAME_LENGTH>);
}
// .type
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "type", "Type");
addChild(blockGroup);
generateTransformFeedbackShaderCaseBlocks(m_context, blockGroup, glslVersion, generateTransformFeedbackVariableTypeBlockContents);
}
}
static void generateBufferVariableBufferCaseBlocks (Context& context, tcu::TestCaseGroup* targetGroup, glu::GLSLVersion glslVersion, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*))
{
const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program());
const ResourceDefinition::Node::SharedPtr shader (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader));
const ResourceDefinition::Node::SharedPtr bufferStorage (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_BUFFER));
const ResourceDefinition::Node::SharedPtr binding (new ResourceDefinition::LayoutQualifier(bufferStorage, glu::Layout(-1, 0)));
// .named_block
{
const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(binding, true));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "named_block", "Named block");
targetGroup->addChild(blockGroup);
blockContentGenerator(context, buffer, blockGroup);
}
// .unnamed_block
{
const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(binding, false));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "unnamed_block", "Unnamed block");
targetGroup->addChild(blockGroup);
blockContentGenerator(context, buffer, blockGroup);
}
// .block_array
{
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(binding));
const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(arrayElement, true));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "block_array", "Block array");
targetGroup->addChild(blockGroup);
blockContentGenerator(context, buffer, blockGroup);
}
}
static void generateBufferVariableResourceListBlockContentsProxy (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup)
{
generateBufferBackedResourceListBlockContentCases(context, parentStructure, targetGroup, PROGRAMINTERFACE_BUFFER_VARIABLE, 4);
}
static void generateBufferVariableArraySizeSubCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, ProgramResourcePropFlags targetProp, bool sizedArray, bool extendedCases)
{
const ProgramResourceQueryTestTarget queryTarget (PROGRAMINTERFACE_BUFFER_VARIABLE, targetProp);
tcu::TestCaseGroup* aggregateGroup;
// .types
if (extendedCases)
{
tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(context.getTestContext(), "types", "Types");
targetGroup->addChild(blockGroup);
generateVariableCases(context, parentStructure, blockGroup, queryTarget, (sizedArray) ? (2) : (1), false);
}
// .aggregates
if (extendedCases)
{
aggregateGroup = new tcu::TestCaseGroup(context.getTestContext(), "aggregates", "Aggregate types");
targetGroup->addChild(aggregateGroup);
}
else
aggregateGroup = targetGroup;
// .float_*
generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, aggregateGroup, queryTarget.interface, glu::TYPE_FLOAT, (extendedCases && sizedArray) ? (2) : (1), !extendedCases);
// .bool_*
generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, aggregateGroup, queryTarget.interface, glu::TYPE_BOOL, (extendedCases && sizedArray) ? (1) : (0), !extendedCases);
// .bvec3_*
generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, aggregateGroup, queryTarget.interface, glu::TYPE_BOOL_VEC3, (extendedCases && sizedArray) ? (2) : (1), !extendedCases);
// .vec4_*
generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, aggregateGroup, queryTarget.interface, glu::TYPE_FLOAT_VEC4, (extendedCases && sizedArray) ? (2) : (1), !extendedCases);
// .ivec2_*
generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, aggregateGroup, queryTarget.interface, glu::TYPE_INT_VEC2, (extendedCases && sizedArray) ? (2) : (1), !extendedCases);
}
template <ProgramResourcePropFlags TargetProp>
static void generateBufferVariableArrayCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup)
{
const ProgramResourceQueryTestTarget queryTarget (PROGRAMINTERFACE_BUFFER_VARIABLE, TargetProp);
const bool namedNonArrayBlock = static_cast<const ResourceDefinition::InterfaceBlock*>(parentStructure.get())->m_named && parentStructure->getEnclosingNode()->getType() != ResourceDefinition::Node::TYPE_ARRAY_ELEMENT;
// .non_array
if (namedNonArrayBlock)
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "non_array", "Non-array target");
targetGroup->addChild(blockGroup);
generateVariableCases(context, parentStructure, blockGroup, queryTarget, 1, false);
}
// .sized
{
const ResourceDefinition::Node::SharedPtr sized (new ResourceDefinition::ArrayElement(parentStructure));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "sized", "Sized target");
targetGroup->addChild(blockGroup);
generateBufferVariableArraySizeSubCases(context, sized, blockGroup, TargetProp, true, namedNonArrayBlock);
}
// .unsized
{
const ResourceDefinition::Node::SharedPtr unsized (new ResourceDefinition::ArrayElement(parentStructure, ResourceDefinition::ArrayElement::UNSIZED_ARRAY));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "unsized", "Unsized target");
targetGroup->addChild(blockGroup);
generateBufferVariableArraySizeSubCases(context, unsized, blockGroup, TargetProp, false, namedNonArrayBlock);
}
}
static void generateBufferVariableBlockIndexCases (Context& context, glu::GLSLVersion glslVersion, tcu::TestCaseGroup* const targetGroup)
{
const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program());
const ResourceDefinition::Node::SharedPtr shader (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader));
const ResourceDefinition::Node::SharedPtr bufferStorage (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_BUFFER));
const ResourceDefinition::Node::SharedPtr binding (new ResourceDefinition::LayoutQualifier(bufferStorage, glu::Layout(-1, 0)));
// .named_block
{
const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(binding, true));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(buffer, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_BLOCK_INDEX), "named_block"));
}
// .unnamed_block
{
const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(binding, false));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(buffer, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_BLOCK_INDEX), "unnamed_block"));
}
// .block_array
{
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(binding));
const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(arrayElement, true));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(buffer, glu::TYPE_FLOAT_VEC4));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_BLOCK_INDEX), "block_array"));
}
}
static void generateBufferVariableMatrixCaseBlocks (Context& context, tcu::TestCaseGroup* const targetGroup, glu::GLSLVersion glslVersion, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*, bool))
{
static const struct
{
const char* name;
const char* description;
bool namedBlock;
bool extendedBasicTypeCases;
glu::MatrixOrder order;
} children[] =
{
{ "named_block", "Named uniform block", true, true, glu::MATRIXORDER_LAST },
{ "named_block_row_major", "Named uniform block", true, false, glu::MATRIXORDER_ROW_MAJOR },
{ "named_block_col_major", "Named uniform block", true, false, glu::MATRIXORDER_COLUMN_MAJOR },
{ "unnamed_block", "Unnamed uniform block", false, false, glu::MATRIXORDER_LAST },
{ "unnamed_block_row_major", "Unnamed uniform block", false, false, glu::MATRIXORDER_ROW_MAJOR },
{ "unnamed_block_col_major", "Unnamed uniform block", false, false, glu::MATRIXORDER_COLUMN_MAJOR },
};
const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program());
const ResourceDefinition::Node::SharedPtr shader (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader));
const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_BUFFER));
for (int childNdx = 0; childNdx < (int)DE_LENGTH_OF_ARRAY(children); ++childNdx)
{
ResourceDefinition::Node::SharedPtr parentStructure = buffer;
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, children[childNdx].name, children[childNdx].description);
targetGroup->addChild(blockGroup);
if (children[childNdx].order != glu::MATRIXORDER_LAST)
{
glu::Layout layout;
layout.matrixOrder = children[childNdx].order;
parentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::LayoutQualifier(parentStructure, layout));
}
parentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::InterfaceBlock(parentStructure, children[childNdx].namedBlock));
blockContentGenerator(context, parentStructure, blockGroup, children[childNdx].extendedBasicTypeCases);
}
}
static void generateBufferVariableMatrixVariableBasicTypeCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, ProgramResourcePropFlags targetProp)
{
// all matrix types and some non-matrix
static const glu::DataType variableTypes[] =
{
glu::TYPE_FLOAT,
glu::TYPE_INT_VEC3,
glu::TYPE_FLOAT_MAT2,
glu::TYPE_FLOAT_MAT2X3,
glu::TYPE_FLOAT_MAT2X4,
glu::TYPE_FLOAT_MAT3X2,
glu::TYPE_FLOAT_MAT3,
glu::TYPE_FLOAT_MAT3X4,
glu::TYPE_FLOAT_MAT4X2,
glu::TYPE_FLOAT_MAT4X3,
glu::TYPE_FLOAT_MAT4,
};
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(variableTypes); ++ndx)
{
const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(parentStructure, variableTypes[ndx]));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_BUFFER_VARIABLE, targetProp)));
}
}
static void generateBufferVariableMatrixVariableCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, ProgramResourcePropFlags targetProp)
{
// Basic aggregates
generateBufferBackedVariableAggregateTypeCases(context, parentStructure, targetGroup, PROGRAMINTERFACE_BUFFER_VARIABLE, targetProp, glu::TYPE_FLOAT_MAT3X2, "", 2);
// Unsized array
{
const ResourceDefinition::Node::SharedPtr unsized (new ResourceDefinition::ArrayElement(parentStructure, ResourceDefinition::ArrayElement::UNSIZED_ARRAY));
const ResourceDefinition::Node::SharedPtr variable (new ResourceDefinition::Variable(unsized, glu::TYPE_FLOAT_MAT3X2));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_BUFFER_VARIABLE, targetProp), "var_unsized_array"));
}
}
template <ProgramResourcePropFlags TargetProp>
static void generateBufferVariableMatrixCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, bool extendedTypeCases)
{
// .types
if (extendedTypeCases)
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "types", "Types");
targetGroup->addChild(blockGroup);
generateBufferVariableMatrixVariableBasicTypeCases(context, parentStructure, blockGroup, TargetProp);
}
// .no_qualifier
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "no_qualifier", "No qualifier");
targetGroup->addChild(blockGroup);
generateBufferVariableMatrixVariableCases(context, parentStructure, blockGroup, TargetProp);
}
// .column_major
{
const ResourceDefinition::Node::SharedPtr matrixOrder(new ResourceDefinition::LayoutQualifier(parentStructure, glu::Layout(-1, -1, -1, glu::FORMATLAYOUT_LAST, glu::MATRIXORDER_COLUMN_MAJOR)));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "column_major", "Column major qualifier");
targetGroup->addChild(blockGroup);
generateBufferVariableMatrixVariableCases(context, matrixOrder, blockGroup, TargetProp);
}
// .row_major
{
const ResourceDefinition::Node::SharedPtr matrixOrder(new ResourceDefinition::LayoutQualifier(parentStructure, glu::Layout(-1, -1, -1, glu::FORMATLAYOUT_LAST, glu::MATRIXORDER_ROW_MAJOR)));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "row_major", "Row major qualifier");
targetGroup->addChild(blockGroup);
generateBufferVariableMatrixVariableCases(context, matrixOrder, blockGroup, TargetProp);
}
}
static void generateBufferVariableNameLengthCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup)
{
// .sized
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "sized", "Sized target");
targetGroup->addChild(blockGroup);
generateBufferBackedVariableAggregateTypeCases(context, parentStructure, blockGroup, PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_NAME_LENGTH, glu::TYPE_FLOAT, "", 3);
}
// .unsized
{
const ResourceDefinition::Node::SharedPtr unsized (new ResourceDefinition::ArrayElement(parentStructure, ResourceDefinition::ArrayElement::UNSIZED_ARRAY));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "unsized", "Unsized target");
targetGroup->addChild(blockGroup);
generateBufferBackedVariableAggregateTypeCases(context, unsized, blockGroup, PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_NAME_LENGTH, glu::TYPE_FLOAT, "", 2);
}
}
static void generateBufferVariableOffsetCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup)
{
// .sized
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "sized", "Sized target");
targetGroup->addChild(blockGroup);
generateBufferBackedVariableAggregateTypeCases(context, parentStructure, blockGroup, PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_OFFSET, glu::TYPE_FLOAT, "", 3);
}
// .unsized
{
const ResourceDefinition::Node::SharedPtr unsized (new ResourceDefinition::ArrayElement(parentStructure, ResourceDefinition::ArrayElement::UNSIZED_ARRAY));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "unsized", "Unsized target");
targetGroup->addChild(blockGroup);
generateBufferBackedVariableAggregateTypeCases(context, unsized, blockGroup, PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_OFFSET, glu::TYPE_FLOAT, "", 2);
}
}
static void generateBufferVariableReferencedByBlockContents (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, int expandLevel)
{
DE_UNREF(expandLevel);
const ProgramResourceQueryTestTarget queryTarget (PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_REFERENCED_BY_SHADER);
const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(parentStructure));
const ResourceDefinition::Node::SharedPtr storage (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_BUFFER));
const bool singleShaderCase = parentStructure->getType() == ResourceDefinition::Node::TYPE_SHADER;
// .named_block
{
const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(storage, true));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "named_block", "Named block");
targetGroup->addChild(blockGroup);
generateBufferReferencedByShaderInterfaceBlockCases(context, buffer, blockGroup, queryTarget, singleShaderCase);
}
// .unnamed_block
{
const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(storage, false));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "unnamed_block", "Unnamed block");
targetGroup->addChild(blockGroup);
generateBufferReferencedByShaderInterfaceBlockCases(context, buffer, blockGroup, queryTarget, false);
}
// .block_array
{
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(storage));
const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::InterfaceBlock(arrayElement, true));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "block_array", "Block array");
targetGroup->addChild(blockGroup);
generateBufferReferencedByShaderInterfaceBlockCases(context, buffer, blockGroup, queryTarget, false);
}
}
template <ProgramResourcePropFlags TargetProp>
static void generateBufferVariableTopLevelCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup)
{
// basic and aggregate types
generateBufferBackedVariableAggregateTypeCases(context, parentStructure, targetGroup, PROGRAMINTERFACE_BUFFER_VARIABLE, TargetProp, glu::TYPE_FLOAT_VEC4, "", 3);
// basic and aggregate types in an unsized array
{
const ResourceDefinition::Node::SharedPtr unsized(new ResourceDefinition::ArrayElement(parentStructure, ResourceDefinition::ArrayElement::UNSIZED_ARRAY));
generateBufferBackedVariableAggregateTypeCases(context, unsized, targetGroup, PROGRAMINTERFACE_BUFFER_VARIABLE, TargetProp, glu::TYPE_FLOAT_VEC4, "_unsized_array", 2);
}
}
static void generateBufferVariableTypeBasicTypeCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, int expandLevel)
{
static const struct
{
int level;
glu::DataType dataType;
} variableTypes[] =
{
{ 0, glu::TYPE_FLOAT },
{ 1, glu::TYPE_INT },
{ 1, glu::TYPE_UINT },
{ 1, glu::TYPE_BOOL },
{ 3, glu::TYPE_FLOAT_VEC2 },
{ 1, glu::TYPE_FLOAT_VEC3 },
{ 1, glu::TYPE_FLOAT_VEC4 },
{ 3, glu::TYPE_INT_VEC2 },
{ 2, glu::TYPE_INT_VEC3 },
{ 3, glu::TYPE_INT_VEC4 },
{ 3, glu::TYPE_UINT_VEC2 },
{ 2, glu::TYPE_UINT_VEC3 },
{ 3, glu::TYPE_UINT_VEC4 },
{ 3, glu::TYPE_BOOL_VEC2 },
{ 2, glu::TYPE_BOOL_VEC3 },
{ 3, glu::TYPE_BOOL_VEC4 },
{ 2, glu::TYPE_FLOAT_MAT2 },
{ 3, glu::TYPE_FLOAT_MAT2X3 },
{ 3, glu::TYPE_FLOAT_MAT2X4 },
{ 2, glu::TYPE_FLOAT_MAT3X2 },
{ 2, glu::TYPE_FLOAT_MAT3 },
{ 3, glu::TYPE_FLOAT_MAT3X4 },
{ 2, glu::TYPE_FLOAT_MAT4X2 },
{ 3, glu::TYPE_FLOAT_MAT4X3 },
{ 2, glu::TYPE_FLOAT_MAT4 },
};
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(variableTypes); ++ndx)
{
if (variableTypes[ndx].level <= expandLevel)
{
const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(parentStructure, variableTypes[ndx].dataType));
targetGroup->addChild(new ResourceTestCase(context, variable, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_TYPE)));
}
}
}
static void generateBufferVariableTypeCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* targetGroup, int depth = 3)
{
// .basic_type
if (depth > 0)
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "basic_type", "Basic type");
targetGroup->addChild(blockGroup);
generateBufferVariableTypeBasicTypeCases(context, parentStructure, blockGroup, depth);
}
else
{
// flatten bottom-level
generateBufferVariableTypeBasicTypeCases(context, parentStructure, targetGroup, depth);
}
// .array
if (depth > 0)
{
const ResourceDefinition::Node::SharedPtr arrayElement (new ResourceDefinition::ArrayElement(parentStructure));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "array", "Arrays");
targetGroup->addChild(blockGroup);
generateBufferVariableTypeCases(context, arrayElement, blockGroup, depth-1);
}
// .struct
if (depth > 0)
{
const ResourceDefinition::Node::SharedPtr structMember (new ResourceDefinition::StructMember(parentStructure));
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(context, "struct", "Structs");
targetGroup->addChild(blockGroup);
generateBufferVariableTypeCases(context, structMember, blockGroup, depth-1);
}
}
static void generateBufferVariableTypeBlock (Context& context, tcu::TestCaseGroup* targetGroup, glu::GLSLVersion glslVersion)
{
const ResourceDefinition::Node::SharedPtr program (new ResourceDefinition::Program());
const ResourceDefinition::Node::SharedPtr shader (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader));
const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_BUFFER));
const ResourceDefinition::Node::SharedPtr block (new ResourceDefinition::InterfaceBlock(buffer, true));
generateBufferVariableTypeCases(context, block, targetGroup);
}
static void generateBufferVariableRandomCase (Context& context, tcu::TestCaseGroup* const targetGroup, glu::GLSLVersion glslVersion, int index, bool onlyExtensionStages)
{
de::Random rnd (index * 0x12345);
const ResourceDefinition::Node::SharedPtr shader = generateRandomShaderSet(rnd, glslVersion, onlyExtensionStages);
const glu::DataType type = generateRandomDataType(rnd, true);
const glu::Layout layout = generateRandomVariableLayout(rnd, type, true);
const bool namedBlock = rnd.getBool();
const ResourceDefinition::Node::SharedPtr defaultBlock (new ResourceDefinition::DefaultBlock(shader));
const ResourceDefinition::Node::SharedPtr buffer (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_BUFFER));
ResourceDefinition::Node::SharedPtr currentStructure (new ResourceDefinition::LayoutQualifier(buffer, generateRandomBufferBlockLayout(rnd)));
if (namedBlock && rnd.getBool())
currentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::ArrayElement(currentStructure));
currentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::InterfaceBlock(currentStructure, namedBlock));
currentStructure = ResourceDefinition::Node::SharedPtr(new ResourceDefinition::LayoutQualifier(currentStructure, layout));
currentStructure = generateRandomVariableDefinition(rnd, currentStructure, type, layout, true);
targetGroup->addChild(new ResourceTestCase(context, currentStructure, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_BUFFER_VARIABLE_MASK), de::toString(index).c_str()));
}
static void generateBufferVariableRandomCases (Context& context, tcu::TestCaseGroup* const targetGroup, glu::GLSLVersion glslVersion)
{
const int numBasicCases = 40;
const int numTessGeoCases = 40;
for (int ndx = 0; ndx < numBasicCases; ++ndx)
generateBufferVariableRandomCase(context, targetGroup, glslVersion, ndx, false);
for (int ndx = 0; ndx < numTessGeoCases; ++ndx)
generateBufferVariableRandomCase(context, targetGroup, glslVersion, numBasicCases + ndx, true);
}
class BufferVariableTestGroup : public TestCaseGroup
{
public:
BufferVariableTestGroup (Context& context);
void init (void);
};
BufferVariableTestGroup::BufferVariableTestGroup (Context& context)
: TestCaseGroup(context, "buffer_variable", "Buffer variable")
{
}
void BufferVariableTestGroup::init (void)
{
const glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
// .resource_list
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "resource_list", "Resource list");
addChild(blockGroup);
generateBufferVariableBufferCaseBlocks(m_context, blockGroup, glslVersion, generateBufferVariableResourceListBlockContentsProxy);
}
// .array_size
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "array_size", "Array size");
addChild(blockGroup);
generateBufferVariableBufferCaseBlocks(m_context, blockGroup, glslVersion, generateBufferVariableArrayCases<PROGRAMRESOURCEPROP_ARRAY_SIZE>);
}
// .array_stride
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "array_stride", "Array stride");
addChild(blockGroup);
generateBufferVariableBufferCaseBlocks(m_context, blockGroup, glslVersion, generateBufferVariableArrayCases<PROGRAMRESOURCEPROP_ARRAY_STRIDE>);
}
// .block_index
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "block_index", "Block index");
addChild(blockGroup);
generateBufferVariableBlockIndexCases(m_context, glslVersion, blockGroup);
}
// .is_row_major
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "is_row_major", "Is row major");
addChild(blockGroup);
generateBufferVariableMatrixCaseBlocks(m_context, blockGroup, glslVersion, generateBufferVariableMatrixCases<PROGRAMRESOURCEPROP_MATRIX_ROW_MAJOR>);
}
// .matrix_stride
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "matrix_stride", "Matrix stride");
addChild(blockGroup);
generateBufferVariableMatrixCaseBlocks(m_context, blockGroup, glslVersion, generateBufferVariableMatrixCases<PROGRAMRESOURCEPROP_MATRIX_STRIDE>);
}
// .name_length
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "name_length", "Name length");
addChild(blockGroup);
generateBufferVariableBufferCaseBlocks(m_context, blockGroup, glslVersion, generateBufferVariableNameLengthCases);
}
// .offset
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "offset", "Offset");
addChild(blockGroup);
generateBufferVariableBufferCaseBlocks(m_context, blockGroup, glslVersion, generateBufferVariableOffsetCases);
}
// .referenced_by
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "referenced_by", "Referenced by");
addChild(blockGroup);
generateReferencedByShaderCaseBlocks(m_context, blockGroup, glslVersion, generateBufferVariableReferencedByBlockContents);
}
// .top_level_array_size
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "top_level_array_size", "Top-level array size");
addChild(blockGroup);
generateBufferVariableBufferCaseBlocks(m_context, blockGroup, glslVersion, generateBufferVariableTopLevelCases<PROGRAMRESOURCEPROP_TOP_LEVEL_ARRAY_SIZE>);
}
// .top_level_array_stride
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "top_level_array_stride", "Top-level array stride");
addChild(blockGroup);
generateBufferVariableBufferCaseBlocks(m_context, blockGroup, glslVersion, generateBufferVariableTopLevelCases<PROGRAMRESOURCEPROP_TOP_LEVEL_ARRAY_STRIDE>);
}
// .type
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "type", "Type");
addChild(blockGroup);
generateBufferVariableTypeBlock(m_context, blockGroup, glslVersion);
}
// .random
{
tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "random", "Random");
addChild(blockGroup);
generateBufferVariableRandomCases(m_context, blockGroup, glslVersion);
}
}
} // anonymous
ProgramInterfaceQueryTests::ProgramInterfaceQueryTests (Context& context, bool is_GL45)
: TestCaseGroup(context, "program_interface_query", "Program interface query tests")
, m_isGL45 (is_GL45)
{
}
ProgramInterfaceQueryTests::~ProgramInterfaceQueryTests (void)
{
}
void ProgramInterfaceQueryTests::init (void)
{
// Misc queries
// .buffer_limited_query
{
tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "buffer_limited_query", "Queries limited by the buffer size");
addChild(group);
group->addChild(new ResourceNameBufferLimitCase(m_context, "resource_name_query", "Test GetProgramResourceName with too small a buffer"));
group->addChild(new ResourceQueryBufferLimitCase(m_context, "resource_query", "Test GetProgramResourceiv with too small a buffer"));
}
// Interfaces
// .uniform
addChild(new UniformInterfaceTestGroup(m_context));
// .uniform_block
addChild(new BufferBackedBlockInterfaceTestGroup(m_context, glu::STORAGE_UNIFORM));
// .atomic_counter_buffer
addChild(new AtomicCounterTestGroup(m_context));
// .program_input
addChild(new ProgramInputTestGroup(m_context, m_isGL45));
// .program_output
addChild(new ProgramOutputTestGroup(m_context, m_isGL45));
// .transform_feedback_varying
addChild(new TransformFeedbackVaryingTestGroup(m_context));
// .buffer_variable
addChild(new BufferVariableTestGroup(m_context));
// .shader_storage_block
addChild(new BufferBackedBlockInterfaceTestGroup(m_context, glu::STORAGE_BUFFER));
}
} // Functional
} // gles31
} // deqp
Reference in new issue View Git Blame Copy Permalink