You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1537 lines
48 KiB
1537 lines
48 KiB
/*------------------------------------------------------------------------- |
|
* drawElements Quality Program OpenGL (ES) 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 Attribute location tests |
|
*//*--------------------------------------------------------------------*/ |
|
|
|
#include "glsAttributeLocationTests.hpp" |
|
|
|
#include "tcuStringTemplate.hpp" |
|
#include "tcuTestLog.hpp" |
|
|
|
#include "gluDefs.hpp" |
|
#include "gluRenderContext.hpp" |
|
#include "gluShaderProgram.hpp" |
|
#include "gluShaderUtil.hpp" |
|
#include "gluStrUtil.hpp" |
|
|
|
#include "glwFunctions.hpp" |
|
|
|
#include "deStringUtil.hpp" |
|
|
|
#include <map> |
|
#include <set> |
|
#include <sstream> |
|
#include <string> |
|
#include <vector> |
|
|
|
#include <cstring> |
|
|
|
#include "glw.h" |
|
|
|
using tcu::TestLog; |
|
|
|
using std::string; |
|
using std::vector; |
|
using std::set; |
|
using std::map; |
|
using std::pair; |
|
|
|
using namespace deqp::gls::AttributeLocationTestUtil; |
|
|
|
namespace deqp |
|
{ |
|
namespace gls |
|
{ |
|
namespace |
|
{ |
|
|
|
deInt32 getBoundLocation (const map<string, deUint32>& bindings, const string& attrib) |
|
{ |
|
std::map<string, deUint32>::const_iterator iter = bindings.find(attrib); |
|
|
|
return (iter == bindings.end() ? (deInt32)Attribute::LOC_UNDEF : iter->second); |
|
} |
|
|
|
bool hasAttributeAliasing (const vector<Attribute>& attributes, const map<string, deUint32>& bindings) |
|
{ |
|
vector<bool> reservedSpaces; |
|
|
|
for (int attribNdx = 0; attribNdx < (int)attributes.size(); attribNdx++) |
|
{ |
|
const deInt32 location = getBoundLocation(bindings, attributes[attribNdx].getName()); |
|
const deUint32 size = attributes[attribNdx].getType().getLocationSize(); |
|
|
|
if (location != Attribute::LOC_UNDEF) |
|
{ |
|
if (reservedSpaces.size() < location + size) |
|
reservedSpaces.resize(location + size, false); |
|
|
|
for (int i = 0; i < (int)size; i++) |
|
{ |
|
if (reservedSpaces[location + i]) |
|
return true; |
|
|
|
reservedSpaces[location + i] = true; |
|
} |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
deInt32 getMaxAttributeLocations (glu::RenderContext& renderCtx) |
|
{ |
|
const glw::Functions& gl = renderCtx.getFunctions(); |
|
deInt32 maxAttribs; |
|
|
|
gl.getIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxAttribs); |
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv()"); |
|
|
|
return maxAttribs; |
|
} |
|
|
|
string generateAttributeDefinitions (const vector<Attribute>& attributes) |
|
{ |
|
std::ostringstream src; |
|
|
|
for (vector<Attribute>::const_iterator iter = attributes.begin(); iter != attributes.end(); ++iter) |
|
{ |
|
if (iter->getLayoutLocation() != Attribute::LOC_UNDEF) |
|
src << "layout(location = " << iter->getLayoutLocation() << ") "; |
|
|
|
src << "${VTX_INPUT} mediump " |
|
<< iter->getType().getName() << " " |
|
<< iter->getName() |
|
<< (iter->getArraySize() != Attribute::NOT_ARRAY ? "[" + de::toString(iter->getArraySize()) + "]" : "") << ";\n"; |
|
} |
|
|
|
return src.str(); |
|
} |
|
|
|
string generateConditionUniformDefinitions (const vector<Attribute>& attributes) |
|
{ |
|
std::ostringstream src; |
|
set<string> conditions; |
|
|
|
for (vector<Attribute>::const_iterator iter = attributes.begin(); iter != attributes.end(); ++iter) |
|
{ |
|
if (iter->getCondition() != Cond::COND_NEVER && iter->getCondition() != Cond::COND_ALWAYS) |
|
conditions.insert(iter->getCondition().getName()); |
|
} |
|
|
|
for (set<string>::const_iterator iter = conditions.begin(); iter != conditions.end(); ++iter) |
|
src << "uniform mediump float u_" << (*iter) << ";\n"; |
|
|
|
return src.str(); |
|
} |
|
|
|
string generateToVec4Expression (const Attribute& attrib, int id=-1) |
|
{ |
|
const string variableName(attrib.getName() + (attrib.getArraySize() != Attribute::NOT_ARRAY ? "[" + de::toString(id) + "]" : "")); |
|
std::ostringstream src; |
|
|
|
switch (attrib.getType().getGLTypeEnum()) |
|
{ |
|
case GL_INT_VEC2: |
|
case GL_UNSIGNED_INT_VEC2: |
|
case GL_FLOAT_VEC2: |
|
src << "vec4(" << variableName << ".xy, " << variableName << ".yx)"; |
|
break; |
|
|
|
case GL_INT_VEC3: |
|
case GL_UNSIGNED_INT_VEC3: |
|
case GL_FLOAT_VEC3: |
|
src << "vec4(" << variableName << ".xyz, " << variableName << ".x)"; |
|
break; |
|
|
|
default: |
|
src << "vec4(" << variableName << ")"; |
|
break; |
|
} |
|
|
|
return src.str(); |
|
} |
|
|
|
string generateOutputCode (const vector<Attribute>& attributes) |
|
{ |
|
std::ostringstream src; |
|
|
|
for (vector<Attribute>::const_iterator iter = attributes.begin(); iter != attributes.end(); ++iter) |
|
{ |
|
if (iter->getCondition() == Cond::COND_NEVER) |
|
{ |
|
src << |
|
"\tif (0 != 0)\n" |
|
"\t{\n"; |
|
|
|
if (iter->getArraySize() == Attribute::NOT_ARRAY) |
|
src << "\t\tcolor += " << generateToVec4Expression(*iter) << ";\n"; |
|
else |
|
{ |
|
for (int i = 0; i < iter->getArraySize(); i++) |
|
src << "\t\tcolor += " << generateToVec4Expression(*iter, i) << ";\n"; |
|
} |
|
|
|
src << "\t}\n"; |
|
} |
|
else if (iter->getCondition() == Cond::COND_ALWAYS) |
|
{ |
|
if (iter->getArraySize() == Attribute::NOT_ARRAY) |
|
src << "\tcolor += " << generateToVec4Expression(*iter) << ";\n"; |
|
else |
|
{ |
|
for (int i = 0; i < iter->getArraySize(); i++) |
|
src << "\tcolor += " << generateToVec4Expression(*iter, i) << ";\n"; |
|
} |
|
} |
|
else |
|
{ |
|
src << |
|
"\tif (u_" << iter->getCondition().getName() << (iter->getCondition().getNegate() ? " != " : " == ") << "0.0)\n" |
|
"\t{\n"; |
|
|
|
if (iter->getArraySize() == Attribute::NOT_ARRAY) |
|
src << "\t\tcolor += " << generateToVec4Expression(*iter) << ";\n"; |
|
else |
|
{ |
|
for (int i = 0; i < iter->getArraySize(); i++) |
|
src << "\t\tcolor += " << generateToVec4Expression(*iter, i) << ";\n"; |
|
} |
|
|
|
src << |
|
"\t}\n"; |
|
} |
|
} |
|
|
|
return src.str(); |
|
} |
|
|
|
string generateVertexShaderTemplate (const vector<Attribute>& attributes) |
|
{ |
|
std::ostringstream src; |
|
|
|
src << "${VERSION}\n" |
|
"${VTX_OUTPUT} mediump vec4 v_color;\n"; |
|
|
|
src << generateAttributeDefinitions(attributes) |
|
<< "\n" |
|
<< generateConditionUniformDefinitions(attributes) |
|
<< "\n"; |
|
|
|
src << "void main (void)\n" |
|
"{\n" |
|
"\tmediump vec4 color = vec4(0.0);\n" |
|
"\n"; |
|
|
|
src << generateOutputCode(attributes); |
|
|
|
src << "\n" |
|
"\tv_color = color;\n" |
|
"\tgl_Position = color;\n" |
|
"}\n"; |
|
|
|
return src.str(); |
|
} |
|
|
|
string createVertexShaderSource (glu::RenderContext& renderCtx, const vector<Attribute>& attributes, bool attributeAliasing) |
|
{ |
|
// \note On GLES only GLSL #version 100 supports aliasing |
|
const glu::GLSLVersion contextGLSLVersion = glu::getContextTypeGLSLVersion(renderCtx.getType()); |
|
const glu::GLSLVersion glslVersion = (attributeAliasing && glu::glslVersionIsES(contextGLSLVersion) ? glu::GLSL_VERSION_100_ES : contextGLSLVersion); |
|
const bool usesInOutQualifiers = glu::glslVersionUsesInOutQualifiers(glslVersion); |
|
const tcu::StringTemplate vertexShaderTemplate(generateVertexShaderTemplate(attributes)); |
|
|
|
map<string, string> parameters; |
|
|
|
parameters["VERSION"] = glu::getGLSLVersionDeclaration(glslVersion); |
|
parameters["VTX_OUTPUT"] = (usesInOutQualifiers ? "out" : "varying"); |
|
parameters["VTX_INPUT"] = (usesInOutQualifiers ? "in" : "attribute"); |
|
parameters["FRAG_INPUT"] = (usesInOutQualifiers ? "in" : "varying"); |
|
parameters["FRAG_OUTPUT_VAR"] = (usesInOutQualifiers ? "dEQP_FragColor" : "gl_FragColor"); |
|
parameters["FRAG_OUTPUT_DECLARATION"] = (usesInOutQualifiers |
|
? "layout(location=0) out mediump vec4 dEQP_FragColor;" |
|
: ""); |
|
|
|
return vertexShaderTemplate.specialize(parameters); |
|
} |
|
|
|
string createFragmentShaderSource (glu::RenderContext& renderCtx, bool attributeAliasing) |
|
{ |
|
const char* const fragmentShaderSource = |
|
"${VERSION}\n" |
|
"${FRAG_OUTPUT_DECLARATION}\n" |
|
"${FRAG_INPUT} mediump vec4 v_color;\n" |
|
"void main (void)\n" |
|
"{\n" |
|
"\t${FRAG_OUTPUT_VAR} = v_color;\n" |
|
"}\n"; |
|
|
|
// \note On GLES only GLSL #version 100 supports aliasing |
|
const glu::GLSLVersion contextGLSLVersion = glu::getContextTypeGLSLVersion(renderCtx.getType()); |
|
const glu::GLSLVersion glslVersion = (attributeAliasing && glu::glslVersionIsES(contextGLSLVersion) ? glu::GLSL_VERSION_100_ES : contextGLSLVersion); |
|
const tcu::StringTemplate fragmentShaderTemplate(fragmentShaderSource); |
|
const bool usesInOutQualifiers = glu::glslVersionUsesInOutQualifiers(glslVersion); |
|
|
|
map<string, string> parameters; |
|
|
|
parameters["VERSION"] = glu::getGLSLVersionDeclaration(glslVersion); |
|
parameters["VTX_OUTPUT"] = (usesInOutQualifiers ? "out" : "varying"); |
|
parameters["VTX_INPUT"] = (usesInOutQualifiers ? "in" : "attribute"); |
|
parameters["FRAG_INPUT"] = (usesInOutQualifiers ? "in" : "varying"); |
|
parameters["FRAG_OUTPUT_VAR"] = (usesInOutQualifiers ? "dEQP_FragColor" : "gl_FragColor"); |
|
parameters["FRAG_OUTPUT_DECLARATION"] = (usesInOutQualifiers |
|
? "layout(location=0) out mediump vec4 dEQP_FragColor;" |
|
: ""); |
|
|
|
return fragmentShaderTemplate.specialize(parameters); |
|
} |
|
|
|
string getShaderInfoLog (const glw::Functions& gl, deUint32 shader) |
|
{ |
|
deInt32 length = 0; |
|
string infoLog; |
|
|
|
gl.getShaderiv(shader, GL_INFO_LOG_LENGTH, &length); |
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv()"); |
|
|
|
infoLog.resize(length, '\0'); |
|
|
|
gl.getShaderInfoLog(shader, (glw::GLsizei)infoLog.length(), DE_NULL, &(infoLog[0])); |
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderInfoLog()"); |
|
|
|
return infoLog; |
|
} |
|
|
|
bool getShaderCompileStatus (const glw::Functions& gl, deUint32 shader) |
|
{ |
|
deInt32 status; |
|
|
|
gl.getShaderiv(shader, GL_COMPILE_STATUS, &status); |
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv()"); |
|
|
|
return status == GL_TRUE; |
|
} |
|
|
|
string getProgramInfoLog (const glw::Functions& gl, deUint32 program) |
|
{ |
|
deInt32 length = 0; |
|
string infoLog; |
|
|
|
gl.getProgramiv(program, GL_INFO_LOG_LENGTH, &length); |
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv()"); |
|
|
|
infoLog.resize(length, '\0'); |
|
|
|
gl.getProgramInfoLog(program, (glw::GLsizei)infoLog.length(), DE_NULL, &(infoLog[0])); |
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramInfoLog()"); |
|
|
|
return infoLog; |
|
} |
|
|
|
bool getProgramLinkStatus (const glw::Functions& gl, deUint32 program) |
|
{ |
|
deInt32 status; |
|
|
|
gl.getProgramiv(program, GL_LINK_STATUS, &status); |
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv()"); |
|
|
|
return status == GL_TRUE; |
|
} |
|
|
|
void logProgram (TestLog& log, const glw::Functions& gl, deUint32 program) |
|
{ |
|
const bool programLinkOk = getProgramLinkStatus(gl, program); |
|
const string programInfoLog = getProgramInfoLog(gl, program); |
|
tcu::ScopedLogSection linkInfo (log, "Program Link Info", "Program Link Info"); |
|
|
|
{ |
|
tcu::ScopedLogSection infoLogSection(log, "Info Log", "Info Log"); |
|
|
|
log << TestLog::Message << programInfoLog << TestLog::EndMessage; |
|
} |
|
|
|
log << TestLog::Message << "Link result: " << (programLinkOk ? "Ok" : "Fail") << TestLog::EndMessage; |
|
} |
|
|
|
void logShaders (TestLog& log, |
|
const string& vertexShaderSource, |
|
const string& vertexShaderInfoLog, |
|
bool vertexCompileOk, |
|
const string& fragmentShaderSource, |
|
const string& fragmentShaderInfoLog, |
|
bool fragmentCompileOk) |
|
{ |
|
// \todo [mika] Log as real shader elements. Currently not supported by TestLog. |
|
{ |
|
tcu::ScopedLogSection shaderSection(log, "Vertex Shader Info", "Vertex Shader Info"); |
|
|
|
log << TestLog::KernelSource(vertexShaderSource); |
|
|
|
{ |
|
tcu::ScopedLogSection infoLogSection(log, "Info Log", "Info Log"); |
|
|
|
log << TestLog::Message << vertexShaderInfoLog << TestLog::EndMessage; |
|
} |
|
|
|
log << TestLog::Message << "Compilation result: " << (vertexCompileOk ? "Ok" : "Failed") << TestLog::EndMessage; |
|
} |
|
|
|
{ |
|
tcu::ScopedLogSection shaderSection(log, "Fragment Shader Info", "Fragment Shader Info"); |
|
|
|
log << TestLog::KernelSource(fragmentShaderSource); |
|
|
|
{ |
|
tcu::ScopedLogSection infoLogSection(log, "Info Log", "Info Log"); |
|
|
|
log << TestLog::Message << fragmentShaderInfoLog << TestLog::EndMessage; |
|
} |
|
|
|
log << TestLog::Message << "Compilation result: " << (fragmentCompileOk ? "Ok" : "Failed") << TestLog::EndMessage; |
|
} |
|
} |
|
|
|
pair<deUint32, deUint32> createAndAttachShaders (TestLog& log, glu::RenderContext& renderCtx, deUint32 program, const vector<Attribute>& attributes, bool attributeAliasing) |
|
{ |
|
const glw::Functions& gl = renderCtx.getFunctions(); |
|
const string vertexShaderSource = createVertexShaderSource(renderCtx, attributes, attributeAliasing); |
|
const string fragmentShaderSource = createFragmentShaderSource(renderCtx, attributeAliasing); |
|
|
|
const deUint32 vertexShader = gl.createShader(GL_VERTEX_SHADER); |
|
const deUint32 fragmentShader = gl.createShader(GL_FRAGMENT_SHADER); |
|
|
|
try |
|
{ |
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader()"); |
|
|
|
{ |
|
const char* const vertexShaderString = vertexShaderSource.c_str(); |
|
const char* const fragmentShaderString = fragmentShaderSource.c_str(); |
|
|
|
gl.shaderSource(vertexShader, 1, &vertexShaderString, DE_NULL); |
|
gl.shaderSource(fragmentShader, 1, &fragmentShaderString, DE_NULL); |
|
|
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource()"); |
|
} |
|
|
|
gl.compileShader(vertexShader); |
|
gl.compileShader(fragmentShader); |
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader()"); |
|
|
|
gl.attachShader(program, vertexShader); |
|
gl.attachShader(program, fragmentShader); |
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader()"); |
|
|
|
{ |
|
const bool vertexCompileOk = getShaderCompileStatus(gl, vertexShader); |
|
const bool fragmentCompileOk = getShaderCompileStatus(gl, fragmentShader); |
|
|
|
const string vertexShaderInfoLog = getShaderInfoLog(gl, vertexShader); |
|
const string fragmentShaderInfoLog = getShaderInfoLog(gl, fragmentShader); |
|
|
|
logShaders(log, vertexShaderSource, vertexShaderInfoLog, vertexCompileOk, fragmentShaderSource, fragmentShaderInfoLog, fragmentCompileOk); |
|
|
|
TCU_CHECK_MSG(vertexCompileOk, "Vertex shader compilation failed"); |
|
TCU_CHECK_MSG(fragmentCompileOk, "Fragment shader compilation failed"); |
|
} |
|
|
|
gl.deleteShader(vertexShader); |
|
gl.deleteShader(fragmentShader); |
|
|
|
return pair<deUint32, deUint32>(vertexShader, fragmentShader); |
|
} |
|
catch (...) |
|
{ |
|
if (vertexShader != 0) |
|
gl.deleteShader(vertexShader); |
|
|
|
if (fragmentShader != 0) |
|
gl.deleteShader(fragmentShader); |
|
|
|
throw; |
|
} |
|
} |
|
|
|
void bindAttributes (TestLog& log, const glw::Functions& gl, deUint32 program, const vector<Bind>& binds) |
|
{ |
|
for (vector<Bind>::const_iterator iter = binds.begin(); iter != binds.end(); ++iter) |
|
{ |
|
log << TestLog::Message << "Bind attribute: '" << iter->getAttributeName() << "' to " << iter->getLocation() << TestLog::EndMessage; |
|
gl.bindAttribLocation(program, iter->getLocation(), iter->getAttributeName().c_str()); |
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindAttribLocation()"); |
|
} |
|
} |
|
|
|
void logAttributes (TestLog& log, const vector<Attribute>& attributes) |
|
{ |
|
for (int attribNdx = 0; attribNdx < (int)attributes.size(); attribNdx++) |
|
{ |
|
const Attribute& attrib = attributes[attribNdx]; |
|
|
|
log << TestLog::Message |
|
<< "Type: " << attrib.getType().getName() |
|
<< ", Name: " << attrib.getName() |
|
<< (attrib.getLayoutLocation() != Attribute::LOC_UNDEF ? ", Layout location " + de::toString(attrib.getLayoutLocation()) : "") |
|
<< TestLog::EndMessage; |
|
} |
|
} |
|
|
|
bool checkActiveAttribQuery (TestLog& log, const glw::Functions& gl, deUint32 program, const vector<Attribute>& attributes) |
|
{ |
|
deInt32 activeAttribCount = 0; |
|
set<string> activeAttributes; |
|
bool isOk = true; |
|
|
|
gl.getProgramiv(program, GL_ACTIVE_ATTRIBUTES, &activeAttribCount); |
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &activeAttribCount)"); |
|
|
|
for (int activeAttribNdx = 0; activeAttribNdx < activeAttribCount; activeAttribNdx++) |
|
{ |
|
char name[128]; |
|
const size_t maxNameSize = DE_LENGTH_OF_ARRAY(name) - 1; |
|
deInt32 length = 0; |
|
deInt32 size = 0; |
|
deUint32 type = 0; |
|
|
|
std::memset(name, 0, sizeof(name)); |
|
|
|
gl.getActiveAttrib(program, activeAttribNdx, maxNameSize, &length, &size, &type, name); |
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetActiveAttrib()"); |
|
|
|
log << TestLog::Message |
|
<< "glGetActiveAttrib(program" |
|
<< ", index=" << activeAttribNdx |
|
<< ", bufSize=" << maxNameSize |
|
<< ", length=" << length |
|
<< ", size=" << size |
|
<< ", type=" << glu::getShaderVarTypeStr(type) |
|
<< ", name='" << name << "')" << TestLog::EndMessage; |
|
|
|
{ |
|
bool found = false; |
|
|
|
for (int attribNdx = 0; attribNdx < (int)attributes.size(); attribNdx++) |
|
{ |
|
const Attribute& attrib = attributes[attribNdx]; |
|
|
|
if (attrib.getName() == name) |
|
{ |
|
if (type != attrib.getType().getGLTypeEnum()) |
|
{ |
|
log << TestLog::Message |
|
<< "Error: Wrong type " << glu::getShaderVarTypeStr(type) |
|
<< " expected " << glu::getShaderVarTypeStr(attrib.getType().getGLTypeEnum()) |
|
<< TestLog::EndMessage; |
|
|
|
isOk = false; |
|
} |
|
|
|
if (attrib.getArraySize() == Attribute::NOT_ARRAY) |
|
{ |
|
if (size != 1) |
|
{ |
|
log << TestLog::Message << "Error: Wrong size " << size << " expected " << 1 << TestLog::EndMessage; |
|
isOk = false; |
|
} |
|
} |
|
else |
|
{ |
|
if (size != attrib.getArraySize()) |
|
{ |
|
log << TestLog::Message << "Error: Wrong size " << size << " expected " << attrib.getArraySize() << TestLog::EndMessage; |
|
isOk = false; |
|
} |
|
} |
|
|
|
found = true; |
|
break; |
|
} |
|
} |
|
|
|
if (!found) |
|
{ |
|
log << TestLog::Message << "Error: Unknown attribute '" << name << "' returned by glGetActiveAttrib()." << TestLog::EndMessage; |
|
isOk = false; |
|
} |
|
} |
|
|
|
activeAttributes.insert(name); |
|
} |
|
|
|
for (int attribNdx = 0; attribNdx < (int)attributes.size(); attribNdx++) |
|
{ |
|
const Attribute& attrib = attributes[attribNdx]; |
|
const bool isActive = attrib.getCondition() != Cond::COND_NEVER; |
|
|
|
if (isActive) |
|
{ |
|
if (activeAttributes.find(attrib.getName()) == activeAttributes.end()) |
|
{ |
|
log << TestLog::Message << "Error: Active attribute " << attrib.getName() << " wasn't returned by glGetActiveAttrib()." << TestLog::EndMessage; |
|
isOk = false; |
|
} |
|
} |
|
else |
|
{ |
|
if (activeAttributes.find(attrib.getName()) != activeAttributes.end()) |
|
log << TestLog::Message << "Note: Inactive attribute " << attrib.getName() << " was returned by glGetActiveAttrib()." << TestLog::EndMessage; |
|
} |
|
} |
|
|
|
return isOk; |
|
} |
|
|
|
bool checkAttribLocationQuery (TestLog& log, const glw::Functions& gl, deUint32 program, const vector<Attribute>& attributes, const map<string, deUint32>& bindings) |
|
{ |
|
bool isOk = true; |
|
|
|
for (int attribNdx = 0; attribNdx < (int)attributes.size(); attribNdx++) |
|
{ |
|
const Attribute& attrib = attributes[attribNdx]; |
|
const deInt32 expectedLocation = (attrib.getLayoutLocation() != Attribute::LOC_UNDEF ? attrib.getLayoutLocation() : getBoundLocation(bindings, attrib.getName())); |
|
const deInt32 location = gl.getAttribLocation(program, attrib.getName().c_str()); |
|
|
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()"); |
|
|
|
log << TestLog::Message |
|
<< location << " = glGetAttribLocation(program, \"" << attrib.getName() << "\")" |
|
<< (attrib.getCondition() != Cond::COND_NEVER && expectedLocation != Attribute::LOC_UNDEF ? ", expected " + de::toString(expectedLocation) : "") |
|
<< "." << TestLog::EndMessage; |
|
|
|
if (attrib.getCondition() == Cond::COND_NEVER && location != -1) |
|
log << TestLog::Message << "\tNote: Inactive attribute with location." << TestLog::EndMessage; |
|
|
|
if (attrib.getCondition() != Cond::COND_NEVER && expectedLocation != Attribute::LOC_UNDEF && expectedLocation != location) |
|
log << TestLog::Message << "\tError: Invalid attribute location." << TestLog::EndMessage; |
|
|
|
isOk &= (attrib.getCondition() == Cond::COND_NEVER || expectedLocation == Attribute::LOC_UNDEF || expectedLocation == location); |
|
} |
|
|
|
return isOk; |
|
} |
|
|
|
bool checkQuery (TestLog& log, const glw::Functions& gl, deUint32 program, const vector<Attribute>& attributes, const map<string, deUint32>& bindings) |
|
{ |
|
bool isOk = checkActiveAttribQuery(log, gl, program, attributes); |
|
|
|
if (!checkAttribLocationQuery(log, gl, program, attributes, bindings)) |
|
isOk = false; |
|
|
|
return isOk; |
|
} |
|
|
|
string generateTestName (const AttribType& type, int arraySize) |
|
{ |
|
return type.getName() + (arraySize != Attribute::NOT_ARRAY ? "_array_" + de::toString(arraySize) : ""); |
|
} |
|
|
|
} // anonymous |
|
|
|
namespace AttributeLocationTestUtil |
|
{ |
|
|
|
AttribType::AttribType (const string& name, deUint32 localSize, deUint32 typeEnum) |
|
: m_name (name) |
|
, m_locationSize (localSize) |
|
, m_glTypeEnum (typeEnum) |
|
{ |
|
} |
|
|
|
Cond::Cond (const string& name, bool negate) |
|
: m_negate (negate) |
|
, m_name (name) |
|
{ |
|
} |
|
|
|
Cond::Cond (ConstCond cond) |
|
: m_negate (cond != COND_NEVER) |
|
, m_name ("__always__") |
|
{ |
|
DE_ASSERT(cond == COND_ALWAYS || cond == COND_NEVER); |
|
} |
|
|
|
Attribute::Attribute (const AttribType& type, const string& name, deInt32 layoutLocation, const Cond& cond, int arraySize) |
|
: m_type (type) |
|
, m_name (name) |
|
, m_layoutLocation (layoutLocation) |
|
, m_cond (cond) |
|
, m_arraySize (arraySize) |
|
{ |
|
} |
|
|
|
Bind::Bind (const std::string& attribute, deUint32 location) |
|
: m_attribute (attribute) |
|
, m_location (location) |
|
{ |
|
} |
|
|
|
void runTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx, |
|
const vector<Attribute>& attributes, |
|
const vector<Bind>& preAttachBind, |
|
const vector<Bind>& preLinkBind, |
|
const vector<Bind>& postLinkBind, |
|
bool relink, |
|
bool reattach = false, |
|
const vector<Attribute>& reattachAttributes = vector<Attribute>()) |
|
{ |
|
TestLog& log = testCtx.getLog(); |
|
const glw::Functions& gl = renderCtx.getFunctions(); |
|
deUint32 program = 0; |
|
pair<deUint32, deUint32> shaders; |
|
|
|
try |
|
{ |
|
bool isOk = true; |
|
map<string, deUint32> activeBindings; |
|
|
|
for (int bindNdx = 0; bindNdx < (int)preAttachBind.size(); bindNdx++) |
|
activeBindings[preAttachBind[bindNdx].getAttributeName()] = preAttachBind[bindNdx].getLocation(); |
|
|
|
for (int bindNdx = 0; bindNdx < (int)preLinkBind.size(); bindNdx++) |
|
activeBindings[preLinkBind[bindNdx].getAttributeName()] = preLinkBind[bindNdx].getLocation(); |
|
|
|
{ |
|
tcu::ScopedLogSection section(log, "Attributes", "Attribute information"); |
|
logAttributes(testCtx.getLog(), attributes); |
|
} |
|
|
|
log << TestLog::Message << "Create program." << TestLog::EndMessage; |
|
program = gl.createProgram(); |
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram()"); |
|
|
|
if (!preAttachBind.empty()) |
|
bindAttributes(log, gl, program, preAttachBind); |
|
|
|
log << TestLog::Message << "Create and attach shaders to program." << TestLog::EndMessage; |
|
shaders = createAndAttachShaders(log, renderCtx, program, attributes, hasAttributeAliasing(attributes, activeBindings)); |
|
|
|
if (!preLinkBind.empty()) |
|
bindAttributes(log, gl, program, preLinkBind); |
|
|
|
log << TestLog::Message << "Link program." << TestLog::EndMessage; |
|
|
|
gl.linkProgram(program); |
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram()"); |
|
|
|
logProgram(log, gl, program); |
|
TCU_CHECK_MSG(getProgramLinkStatus(gl, program), "Program link failed"); |
|
|
|
if (!checkQuery(log, gl, program, attributes, activeBindings)) |
|
isOk = false; |
|
|
|
if (!postLinkBind.empty()) |
|
{ |
|
bindAttributes(log, gl, program, postLinkBind); |
|
|
|
if (!checkQuery(log, gl, program, attributes, activeBindings)) |
|
isOk = false; |
|
} |
|
|
|
if (relink) |
|
{ |
|
log << TestLog::Message << "Relink program." << TestLog::EndMessage; |
|
gl.linkProgram(program); |
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram()"); |
|
|
|
logProgram(log, gl, program); |
|
TCU_CHECK_MSG(getProgramLinkStatus(gl, program), "Program link failed"); |
|
|
|
for (int bindNdx = 0; bindNdx < (int)postLinkBind.size(); bindNdx++) |
|
activeBindings[postLinkBind[bindNdx].getAttributeName()] = postLinkBind[bindNdx].getLocation(); |
|
|
|
if (!checkQuery(log, gl, program, attributes, activeBindings)) |
|
isOk = false; |
|
} |
|
|
|
if (reattach) |
|
{ |
|
gl.detachShader(program, shaders.first); |
|
gl.detachShader(program, shaders.second); |
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glDetachShader()"); |
|
|
|
log << TestLog::Message << "Create and attach shaders to program." << TestLog::EndMessage; |
|
createAndAttachShaders(log, renderCtx, program, reattachAttributes, hasAttributeAliasing(reattachAttributes, activeBindings)); |
|
|
|
log << TestLog::Message << "Relink program." << TestLog::EndMessage; |
|
gl.linkProgram(program); |
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram()"); |
|
|
|
logProgram(log, gl, program); |
|
TCU_CHECK_MSG(getProgramLinkStatus(gl, program), "Program link failed"); |
|
|
|
if (!checkQuery(log, gl, program, reattachAttributes, activeBindings)) |
|
isOk = false; |
|
} |
|
|
|
gl.deleteProgram(program); |
|
GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteProgram()"); |
|
|
|
if (isOk) |
|
testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
else |
|
testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
|
} |
|
catch (...) |
|
{ |
|
if (program) |
|
gl.deleteProgram(program); |
|
|
|
throw; |
|
} |
|
} |
|
|
|
} // AttributeLocationTestUtil |
|
|
|
BindAttributeTest::BindAttributeTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx, |
|
const AttribType& type, |
|
int arraySize) |
|
: TestCase (testCtx, generateTestName(type, arraySize).c_str(), generateTestName(type, arraySize).c_str()) |
|
, m_renderCtx (renderCtx) |
|
, m_type (type) |
|
, m_arraySize (arraySize) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult BindAttributeTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
|
|
vector<Attribute> attributes; |
|
vector<Bind> bindings; |
|
|
|
attributes.push_back(Attribute(m_type, "a_0", Attribute::LOC_UNDEF, Cond::COND_ALWAYS, m_arraySize)); |
|
bindings.push_back(Bind("a_0", 3)); |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false); |
|
return STOP; |
|
} |
|
|
|
BindMaxAttributesTest::BindMaxAttributesTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx, |
|
const AttribType& type, |
|
int arraySize) |
|
: TestCase (testCtx, generateTestName(type, arraySize).c_str(), generateTestName(type, arraySize).c_str()) |
|
, m_renderCtx (renderCtx) |
|
, m_type (type) |
|
, m_arraySize (arraySize) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult BindMaxAttributesTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
const deInt32 maxAttributes = getMaxAttributeLocations(m_renderCtx); |
|
const int arrayElementCount = (m_arraySize != Attribute::NOT_ARRAY ? m_arraySize : 1); |
|
|
|
vector<Attribute> attributes; |
|
vector<Bind> bindings; |
|
int ndx = 0; |
|
|
|
m_testCtx.getLog() << TestLog::Message << "GL_MAX_VERTEX_ATTRIBS: " << maxAttributes << TestLog::EndMessage; |
|
|
|
for (int loc = maxAttributes - (arrayElementCount * m_type.getLocationSize()); loc >= 0; loc -= (arrayElementCount * m_type.getLocationSize())) |
|
{ |
|
attributes.push_back(Attribute(m_type, "a_" + de::toString(ndx), Attribute::LOC_UNDEF, Cond::COND_ALWAYS, m_arraySize)); |
|
bindings.push_back(Bind("a_" + de::toString(ndx), loc)); |
|
ndx++; |
|
} |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false); |
|
return STOP; |
|
} |
|
|
|
BindAliasingAttributeTest::BindAliasingAttributeTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx, |
|
const AttribType& type, |
|
int offset, |
|
int arraySize) |
|
: TestCase (testCtx, ("cond_" + generateTestName(type, arraySize) + (offset != 0 ? "_offset_" + de::toString(offset) : "")).c_str(), |
|
("cond_" + generateTestName(type, arraySize) + (offset != 0 ? "_offset_" + de::toString(offset) : "")).c_str()) |
|
, m_renderCtx (renderCtx) |
|
, m_type (type) |
|
, m_offset (offset) |
|
, m_arraySize (arraySize) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult BindAliasingAttributeTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
|
|
vector<Attribute> attributes; |
|
vector<Bind> bindings; |
|
|
|
attributes.push_back(Attribute(m_type, "a_0", Attribute::LOC_UNDEF, Cond("A", true), m_arraySize)); |
|
attributes.push_back(Attribute(AttribType("vec4", 1, GL_FLOAT_VEC4), "a_1", Attribute::LOC_UNDEF, Cond("A", false))); |
|
bindings.push_back(Bind("a_0", 1)); |
|
bindings.push_back(Bind("a_1", 1 + m_offset)); |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false); |
|
return STOP; |
|
} |
|
|
|
BindMaxAliasingAttributeTest::BindMaxAliasingAttributeTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx, |
|
const AttribType& type, |
|
int arraySize) |
|
: TestCase (testCtx, ("max_cond_" + generateTestName(type, arraySize)).c_str(), ("max_cond_" + generateTestName(type, arraySize)).c_str()) |
|
, m_renderCtx (renderCtx) |
|
, m_type (type) |
|
, m_arraySize (arraySize) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult BindMaxAliasingAttributeTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
const deInt32 maxAttributes = getMaxAttributeLocations(m_renderCtx); |
|
const int arrayElementCount = (m_arraySize != Attribute::NOT_ARRAY ? m_arraySize : 1); |
|
|
|
vector<Attribute> attributes; |
|
vector<Bind> bindings; |
|
int ndx = 0; |
|
|
|
m_testCtx.getLog() << TestLog::Message << "GL_MAX_VERTEX_ATTRIBS: " << maxAttributes << TestLog::EndMessage; |
|
|
|
for (int loc = maxAttributes - arrayElementCount * m_type.getLocationSize(); loc >= 0; loc -= m_type.getLocationSize() * arrayElementCount) |
|
{ |
|
attributes.push_back(Attribute(m_type, "a_" + de::toString(ndx), Attribute::LOC_UNDEF, Cond("A", true))); |
|
bindings.push_back(Bind("a_" + de::toString(ndx), loc)); |
|
|
|
attributes.push_back(Attribute(m_type, "a_" + de::toString(ndx + maxAttributes), Attribute::LOC_UNDEF, Cond("A", false))); |
|
bindings.push_back(Bind("a_" + de::toString(ndx + maxAttributes), loc)); |
|
ndx++; |
|
} |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false); |
|
return STOP; |
|
} |
|
|
|
BindHoleAttributeTest::BindHoleAttributeTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx, |
|
const AttribType& type, |
|
int arraySize) |
|
: TestCase (testCtx, generateTestName(type, arraySize).c_str(), generateTestName(type, arraySize).c_str()) |
|
, m_renderCtx (renderCtx) |
|
, m_type (type) |
|
, m_arraySize (arraySize) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult BindHoleAttributeTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
const deInt32 maxAttributes = getMaxAttributeLocations(m_renderCtx); |
|
const AttribType vec4("vec4", 1, GL_FLOAT_VEC4); |
|
const int arrayElementCount = (m_arraySize != Attribute::NOT_ARRAY ? m_arraySize : 1); |
|
|
|
vector<Attribute> attributes; |
|
vector<Bind> bindings; |
|
int ndx; |
|
|
|
attributes.push_back(Attribute(vec4, "a_0")); |
|
bindings.push_back(Bind("a_0", 0)); |
|
|
|
attributes.push_back(Attribute(m_type, "a_1", Attribute::LOC_UNDEF, Cond::COND_ALWAYS, m_arraySize)); |
|
|
|
ndx = 2; |
|
for (int loc = 1 + m_type.getLocationSize() * arrayElementCount; loc < maxAttributes; loc++) |
|
{ |
|
attributes.push_back(Attribute(vec4, "a_" + de::toString(ndx))); |
|
bindings.push_back(Bind("a_" + de::toString(ndx), loc)); |
|
|
|
ndx++; |
|
} |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false); |
|
return STOP; |
|
} |
|
|
|
BindInactiveAliasingAttributeTest::BindInactiveAliasingAttributeTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx, |
|
const AttribType& type, |
|
int arraySize) |
|
: TestCase (testCtx, ("max_inactive_" + generateTestName(type, arraySize)).c_str(), |
|
("max_inactive_" + generateTestName(type, arraySize)).c_str()) |
|
, m_renderCtx (renderCtx) |
|
, m_type (type) |
|
, m_arraySize (arraySize) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult BindInactiveAliasingAttributeTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
const deInt32 maxAttributes = getMaxAttributeLocations(m_renderCtx); |
|
const int arrayElementCount = (m_arraySize != Attribute::NOT_ARRAY ? m_arraySize : 1); |
|
|
|
vector<Attribute> attributes; |
|
vector<Bind> bindings; |
|
int ndx = 0; |
|
|
|
m_testCtx.getLog() << TestLog::Message << "GL_MAX_VERTEX_ATTRIBS: " << maxAttributes << TestLog::EndMessage; |
|
|
|
for (int loc = maxAttributes - arrayElementCount * m_type.getLocationSize(); loc >= 0; loc -= m_type.getLocationSize() * arrayElementCount) |
|
{ |
|
attributes.push_back(Attribute(m_type, "a_" + de::toString(ndx), Attribute::LOC_UNDEF, Cond("A"))); |
|
bindings.push_back(Bind("a_" + de::toString(ndx), loc)); |
|
|
|
attributes.push_back(Attribute(m_type, "a_" + de::toString(ndx + maxAttributes), Attribute::LOC_UNDEF, Cond::COND_NEVER)); |
|
bindings.push_back(Bind("a_" + de::toString(ndx + maxAttributes), loc)); |
|
ndx++; |
|
} |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false); |
|
return STOP; |
|
} |
|
|
|
PreAttachBindAttributeTest::PreAttachBindAttributeTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx) |
|
: TestCase (testCtx, "pre_attach", "pre_attach") |
|
, m_renderCtx (renderCtx) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult PreAttachBindAttributeTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
|
|
vector<Attribute> attributes; |
|
vector<Bind> bindings; |
|
|
|
attributes.push_back(Attribute(AttribType("vec4", 1, GL_FLOAT_VEC4), "a_0")); |
|
bindings.push_back(Bind("a_0", 3)); |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, bindings, noBindings, noBindings, false); |
|
return STOP; |
|
} |
|
|
|
PreLinkBindAttributeTest::PreLinkBindAttributeTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx) |
|
: TestCase (testCtx, "pre_link", "pre_link") |
|
, m_renderCtx (renderCtx) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult PreLinkBindAttributeTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
|
|
vector<Attribute> attributes; |
|
vector<Bind> bindings; |
|
|
|
attributes.push_back(Attribute(AttribType("vec4", 1, GL_FLOAT_VEC4), "a_0")); |
|
bindings.push_back(Bind("a_0", 3)); |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false); |
|
return STOP; |
|
} |
|
|
|
PostLinkBindAttributeTest::PostLinkBindAttributeTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx) |
|
: TestCase (testCtx, "post_link", "post_link") |
|
, m_renderCtx (renderCtx) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult PostLinkBindAttributeTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
|
|
vector<Attribute> attributes; |
|
vector<Bind> bindings; |
|
|
|
attributes.push_back(Attribute(AttribType("vec4", 1, GL_FLOAT_VEC4), "a_0")); |
|
bindings.push_back(Bind("a_0", 3)); |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, noBindings, noBindings, bindings, false); |
|
return STOP; |
|
} |
|
|
|
LocationAttributeTest::LocationAttributeTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx, |
|
const AttribType& type, |
|
int arraySize) |
|
: TestCase (testCtx, generateTestName(type, arraySize).c_str(), generateTestName(type, arraySize).c_str()) |
|
, m_renderCtx (renderCtx) |
|
, m_type (type) |
|
, m_arraySize (arraySize) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult LocationAttributeTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
|
|
vector<Attribute> attributes; |
|
|
|
attributes.push_back(Attribute(m_type, "a_0", 3, Cond::COND_ALWAYS, m_arraySize)); |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, noBindings, noBindings, noBindings, false); |
|
return STOP; |
|
} |
|
|
|
LocationMaxAttributesTest::LocationMaxAttributesTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx, |
|
const AttribType& type, |
|
int arraySize) |
|
: TestCase (testCtx, generateTestName(type, arraySize).c_str(), generateTestName(type, arraySize).c_str()) |
|
, m_renderCtx (renderCtx) |
|
, m_type (type) |
|
, m_arraySize (arraySize) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult LocationMaxAttributesTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
const deInt32 maxAttributes = getMaxAttributeLocations(m_renderCtx); |
|
const int arrayElementCount = (m_arraySize != Attribute::NOT_ARRAY ? m_arraySize : 1); |
|
|
|
vector<Attribute> attributes; |
|
int ndx = 0; |
|
|
|
m_testCtx.getLog() << TestLog::Message << "GL_MAX_VERTEX_ATTRIBS: " << maxAttributes << TestLog::EndMessage; |
|
|
|
for (int loc = maxAttributes - (arrayElementCount * m_type.getLocationSize()); loc >= 0; loc -= (arrayElementCount * m_type.getLocationSize())) |
|
{ |
|
attributes.push_back(Attribute(m_type, "a_" + de::toString(ndx), loc, Cond::COND_ALWAYS, m_arraySize)); |
|
ndx++; |
|
} |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, noBindings, noBindings, noBindings, false); |
|
return STOP; |
|
} |
|
|
|
LocationHoleAttributeTest::LocationHoleAttributeTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx, |
|
const AttribType& type, |
|
int arraySize) |
|
: TestCase (testCtx, generateTestName(type, arraySize).c_str(), generateTestName(type, arraySize).c_str()) |
|
, m_renderCtx (renderCtx) |
|
, m_type (type) |
|
, m_arraySize (arraySize) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult LocationHoleAttributeTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
const deInt32 maxAttributes = getMaxAttributeLocations(m_renderCtx); |
|
const AttribType vec4("vec4", 1, GL_FLOAT_VEC4); |
|
const int arrayElementCount = (m_arraySize != Attribute::NOT_ARRAY ? m_arraySize : 1); |
|
|
|
vector<Attribute> attributes; |
|
int ndx; |
|
|
|
attributes.push_back(Attribute(vec4, "a_0", 0)); |
|
|
|
attributes.push_back(Attribute(m_type, "a_1", Attribute::LOC_UNDEF, Cond::COND_ALWAYS, m_arraySize)); |
|
|
|
ndx = 2; |
|
for (int loc = 1 + m_type.getLocationSize() * arrayElementCount; loc < maxAttributes; loc++) |
|
{ |
|
attributes.push_back(Attribute(vec4, "a_" + de::toString(ndx), loc)); |
|
ndx++; |
|
} |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, noBindings, noBindings, noBindings, false); |
|
return STOP; |
|
} |
|
|
|
MixedAttributeTest::MixedAttributeTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx, |
|
const AttribType& type, |
|
int arraySize) |
|
: TestCase (testCtx, generateTestName(type, arraySize).c_str(), generateTestName(type, arraySize).c_str()) |
|
, m_renderCtx (renderCtx) |
|
, m_type (type) |
|
, m_arraySize (arraySize) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult MixedAttributeTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
|
|
vector<Bind> bindings; |
|
vector<Attribute> attributes; |
|
|
|
attributes.push_back(Attribute(m_type, "a_0", 3, Cond::COND_ALWAYS, m_arraySize)); |
|
bindings.push_back(Bind("a_0", 4)); |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false); |
|
return STOP; |
|
} |
|
|
|
MixedMaxAttributesTest::MixedMaxAttributesTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx, |
|
const AttribType& type, |
|
int arraySize) |
|
: TestCase (testCtx, generateTestName(type, arraySize).c_str(), generateTestName(type, arraySize).c_str()) |
|
, m_renderCtx (renderCtx) |
|
, m_type (type) |
|
, m_arraySize (arraySize) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult MixedMaxAttributesTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
const deInt32 maxAttributes = getMaxAttributeLocations(m_renderCtx); |
|
const int arrayElementCount = (m_arraySize != Attribute::NOT_ARRAY ? m_arraySize : 1); |
|
|
|
vector<Bind> bindings; |
|
vector<Attribute> attributes; |
|
int ndx = 0; |
|
|
|
m_testCtx.getLog() << TestLog::Message << "GL_MAX_VERTEX_ATTRIBS: " << maxAttributes << TestLog::EndMessage; |
|
|
|
for (int loc = maxAttributes - (arrayElementCount * m_type.getLocationSize()); loc >= 0; loc -= (arrayElementCount * m_type.getLocationSize())) |
|
{ |
|
if ((ndx % 2) != 0) |
|
attributes.push_back(Attribute(m_type, "a_" + de::toString(ndx), loc, Cond::COND_ALWAYS, m_arraySize)); |
|
else |
|
{ |
|
attributes.push_back(Attribute(m_type, "a_" + de::toString(ndx), Attribute::LOC_UNDEF, Cond::COND_ALWAYS, m_arraySize)); |
|
bindings.push_back(Bind("a_" + de::toString(ndx), loc)); |
|
|
|
} |
|
ndx++; |
|
} |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false); |
|
return STOP; |
|
} |
|
|
|
MixedHoleAttributeTest::MixedHoleAttributeTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx, |
|
const AttribType& type, |
|
int arraySize) |
|
: TestCase (testCtx, generateTestName(type, arraySize).c_str(), generateTestName(type, arraySize).c_str()) |
|
, m_renderCtx (renderCtx) |
|
, m_type (type) |
|
, m_arraySize (arraySize) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult MixedHoleAttributeTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
const deInt32 maxAttributes = getMaxAttributeLocations(m_renderCtx); |
|
const AttribType vec4("vec4", 1, GL_FLOAT_VEC4); |
|
const int arrayElementCount = (m_arraySize != Attribute::NOT_ARRAY ? m_arraySize : 1); |
|
|
|
vector<Bind> bindings; |
|
vector<Attribute> attributes; |
|
int ndx; |
|
|
|
attributes.push_back(Attribute(vec4, "a_0")); |
|
bindings.push_back(Bind("a_0", 0)); |
|
|
|
attributes.push_back(Attribute(m_type, "a_1", Attribute::LOC_UNDEF, Cond::COND_ALWAYS, m_arraySize)); |
|
|
|
ndx = 2; |
|
for (int loc = 1 + m_type.getLocationSize() * arrayElementCount; loc < maxAttributes; loc++) |
|
{ |
|
if ((ndx % 2) != 0) |
|
attributes.push_back(Attribute(vec4, "a_" + de::toString(ndx), loc)); |
|
else |
|
{ |
|
attributes.push_back(Attribute(vec4, "a_" + de::toString(ndx), loc)); |
|
bindings.push_back(Bind("a_" + de::toString(ndx), loc)); |
|
|
|
} |
|
ndx++; |
|
} |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false); |
|
return STOP; |
|
} |
|
|
|
BindRelinkAttributeTest::BindRelinkAttributeTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx) |
|
: TestCase (testCtx, "relink", "relink") |
|
, m_renderCtx (renderCtx) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult BindRelinkAttributeTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
const AttribType vec4("vec4", 1, GL_FLOAT_VEC4); |
|
|
|
vector<Attribute> attributes; |
|
vector<Bind> preLinkBindings; |
|
vector<Bind> postLinkBindings; |
|
|
|
attributes.push_back(Attribute(vec4, "a_0")); |
|
attributes.push_back(Attribute(vec4, "a_1")); |
|
|
|
preLinkBindings.push_back(Bind("a_0", 3)); |
|
preLinkBindings.push_back(Bind("a_0", 5)); |
|
|
|
postLinkBindings.push_back(Bind("a_0", 6)); |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, noBindings, preLinkBindings, postLinkBindings, true); |
|
return STOP; |
|
} |
|
|
|
BindRelinkHoleAttributeTest::BindRelinkHoleAttributeTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx, |
|
const AttribType& type, |
|
int arraySize) |
|
: TestCase (testCtx, generateTestName(type, arraySize).c_str(), generateTestName(type, arraySize).c_str()) |
|
, m_renderCtx (renderCtx) |
|
, m_type (type) |
|
, m_arraySize (arraySize) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult BindRelinkHoleAttributeTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
const deInt32 maxAttributes = getMaxAttributeLocations(m_renderCtx); |
|
const AttribType vec4 ("vec4", 1, GL_FLOAT_VEC4); |
|
const int arrayElementCount = (m_arraySize != Attribute::NOT_ARRAY ? m_arraySize : 1); |
|
|
|
vector<Attribute> attributes; |
|
vector<Bind> preLinkBindings; |
|
vector<Bind> postLinkBindings; |
|
int ndx; |
|
|
|
attributes.push_back(Attribute(vec4, "a_0")); |
|
preLinkBindings.push_back(Bind("a_0", 0)); |
|
|
|
attributes.push_back(Attribute(m_type, "a_1", Attribute::LOC_UNDEF, Cond::COND_ALWAYS, m_arraySize)); |
|
|
|
ndx = 2; |
|
for (int loc = 1 + m_type.getLocationSize() * arrayElementCount; loc < maxAttributes; loc++) |
|
{ |
|
attributes.push_back(Attribute(vec4, "a_" + de::toString(ndx))); |
|
preLinkBindings.push_back(Bind("a_" + de::toString(ndx), loc)); |
|
|
|
ndx++; |
|
} |
|
|
|
postLinkBindings.push_back(Bind("a_2", 1)); |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, noBindings, preLinkBindings, postLinkBindings, true); |
|
return STOP; |
|
} |
|
|
|
MixedRelinkHoleAttributeTest::MixedRelinkHoleAttributeTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx, |
|
const AttribType& type, |
|
int arraySize) |
|
: TestCase (testCtx, generateTestName(type, arraySize).c_str(), generateTestName(type, arraySize).c_str()) |
|
, m_renderCtx (renderCtx) |
|
, m_type (type) |
|
, m_arraySize (arraySize) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult MixedRelinkHoleAttributeTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
const deInt32 maxAttributes = getMaxAttributeLocations(m_renderCtx); |
|
const AttribType vec4 ("vec4", 1, GL_FLOAT_VEC4); |
|
const int arrayElementCount = (m_arraySize != Attribute::NOT_ARRAY ? m_arraySize : 1); |
|
|
|
vector<Bind> preLinkBindings; |
|
vector<Bind> postLinkBindings; |
|
vector<Attribute> attributes; |
|
int ndx; |
|
|
|
attributes.push_back(Attribute(vec4, "a_0")); |
|
preLinkBindings.push_back(Bind("a_0", 0)); |
|
|
|
attributes.push_back(Attribute(m_type, "a_1", Attribute::LOC_UNDEF, Cond::COND_ALWAYS, m_arraySize)); |
|
|
|
ndx = 2; |
|
for (int loc = 1 + m_type.getLocationSize() * arrayElementCount; loc < maxAttributes; loc++) |
|
{ |
|
if ((ndx % 2) != 0) |
|
attributes.push_back(Attribute(vec4, "a_" + de::toString(ndx), loc)); |
|
else |
|
{ |
|
attributes.push_back(Attribute(vec4, "a_" + de::toString(ndx))); |
|
preLinkBindings.push_back(Bind("a_" + de::toString(ndx), loc)); |
|
|
|
} |
|
ndx++; |
|
} |
|
|
|
postLinkBindings.push_back(Bind("a_2", 1)); |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, noBindings, preLinkBindings, postLinkBindings, true); |
|
return STOP; |
|
} |
|
|
|
BindReattachAttributeTest::BindReattachAttributeTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx) |
|
: TestCase (testCtx, "reattach", "reattach") |
|
, m_renderCtx (renderCtx) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult BindReattachAttributeTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
const AttribType vec4("vec4", 1, GL_FLOAT_VEC4); |
|
const AttribType vec2("vec2", 1, GL_FLOAT_VEC2); |
|
|
|
vector<Bind> bindings; |
|
vector<Attribute> attributes; |
|
vector<Attribute> reattachAttributes; |
|
|
|
attributes.push_back(Attribute(vec4, "a_0")); |
|
bindings.push_back(Bind("a_0", 1)); |
|
bindings.push_back(Bind("a_1", 1)); |
|
|
|
reattachAttributes.push_back(Attribute(vec2, "a_1")); |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false, true, reattachAttributes); |
|
return STOP; |
|
} |
|
|
|
PreAttachMixedAttributeTest::PreAttachMixedAttributeTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx) |
|
: TestCase (testCtx, "pre_attach", "pre_attach") |
|
, m_renderCtx (renderCtx) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult PreAttachMixedAttributeTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
|
|
vector<Attribute> attributes; |
|
vector<Bind> bindings; |
|
|
|
attributes.push_back(Attribute(AttribType("vec4", 1, GL_FLOAT_VEC4), "a_0", 1)); |
|
bindings.push_back(Bind("a_0", 3)); |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, bindings, noBindings, noBindings, false); |
|
return STOP; |
|
} |
|
|
|
PreLinkMixedAttributeTest::PreLinkMixedAttributeTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx) |
|
: TestCase (testCtx, "pre_link", "pre_link") |
|
, m_renderCtx (renderCtx) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult PreLinkMixedAttributeTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
|
|
vector<Attribute> attributes; |
|
vector<Bind> bindings; |
|
|
|
attributes.push_back(Attribute(AttribType("vec4", 1, GL_FLOAT_VEC4), "a_0", 1)); |
|
bindings.push_back(Bind("a_0", 3)); |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false); |
|
return STOP; |
|
} |
|
|
|
PostLinkMixedAttributeTest::PostLinkMixedAttributeTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx) |
|
: TestCase (testCtx, "post_link", "post_link") |
|
, m_renderCtx (renderCtx) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult PostLinkMixedAttributeTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
|
|
vector<Attribute> attributes; |
|
vector<Bind> bindings; |
|
|
|
attributes.push_back(Attribute(AttribType("vec4", 1, GL_FLOAT_VEC4), "a_0", 1)); |
|
bindings.push_back(Bind("a_0", 3)); |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, noBindings, noBindings, bindings, false); |
|
return STOP; |
|
} |
|
|
|
MixedReattachAttributeTest::MixedReattachAttributeTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx) |
|
: TestCase (testCtx, "reattach", "reattach") |
|
, m_renderCtx (renderCtx) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult MixedReattachAttributeTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
const AttribType vec4("vec4", 1, GL_FLOAT_VEC4); |
|
const AttribType vec2("vec2", 1, GL_FLOAT_VEC2); |
|
|
|
vector<Bind> bindings; |
|
vector<Attribute> attributes; |
|
vector<Attribute> reattachAttributes; |
|
|
|
attributes.push_back(Attribute(vec4, "a_0", 2)); |
|
bindings.push_back(Bind("a_0", 1)); |
|
bindings.push_back(Bind("a_1", 1)); |
|
|
|
reattachAttributes.push_back(Attribute(vec2, "a_1")); |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false, true, reattachAttributes); |
|
return STOP; |
|
} |
|
|
|
MixedRelinkAttributeTest::MixedRelinkAttributeTest (tcu::TestContext& testCtx, |
|
glu::RenderContext& renderCtx) |
|
: TestCase (testCtx, "relink", "relink") |
|
, m_renderCtx (renderCtx) |
|
{ |
|
} |
|
|
|
tcu::TestCase::IterateResult MixedRelinkAttributeTest::iterate (void) |
|
{ |
|
const vector<Bind> noBindings; |
|
const AttribType vec4("vec4", 1, GL_FLOAT_VEC4); |
|
|
|
vector<Attribute> attributes; |
|
vector<Bind> preLinkBindings; |
|
vector<Bind> postLinkBindings; |
|
|
|
attributes.push_back(Attribute(vec4, "a_0", 1)); |
|
attributes.push_back(Attribute(vec4, "a_1")); |
|
|
|
preLinkBindings.push_back(Bind("a_0", 3)); |
|
preLinkBindings.push_back(Bind("a_0", 5)); |
|
|
|
postLinkBindings.push_back(Bind("a_0", 6)); |
|
|
|
runTest(m_testCtx, m_renderCtx, attributes, noBindings, preLinkBindings, postLinkBindings, true); |
|
return STOP; |
|
} |
|
|
|
} // gls |
|
} // deqp
|
|
|