| /*------------------------------------------------------------------------- |
| * 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::map; |
| using std::pair; |
| using std::set; |
| using std::string; |
| using std::vector; |
| |
| using namespace deqp::gls::AttributeLocationTestUtil; |
| |
| namespace deqp |
| { |
| namespace gls |
| { |
| namespace |
| { |
| |
| int32_t getBoundLocation(const map<string, uint32_t> &bindings, const string &attrib) |
| { |
| std::map<string, uint32_t>::const_iterator iter = bindings.find(attrib); |
| |
| return (iter == bindings.end() ? (int32_t)Attribute::LOC_UNDEF : iter->second); |
| } |
| |
| bool hasAttributeAliasing(const vector<Attribute> &attributes, const map<string, uint32_t> &bindings) |
| { |
| vector<bool> reservedSpaces; |
| |
| for (int attribNdx = 0; attribNdx < (int)attributes.size(); attribNdx++) |
| { |
| const int32_t location = getBoundLocation(bindings, attributes[attribNdx].getName()); |
| const uint32_t 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; |
| } |
| |
| int32_t getMaxAttributeLocations(glu::RenderContext &renderCtx) |
| { |
| const glw::Functions &gl = renderCtx.getFunctions(); |
| int32_t 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, uint32_t shader) |
| { |
| int32_t 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, uint32_t shader) |
| { |
| int32_t 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, uint32_t program) |
| { |
| int32_t 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, uint32_t program) |
| { |
| int32_t 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, uint32_t 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<uint32_t, uint32_t> createAndAttachShaders(TestLog &log, glu::RenderContext &renderCtx, uint32_t 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 uint32_t vertexShader = gl.createShader(GL_VERTEX_SHADER); |
| const uint32_t 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<uint32_t, uint32_t>(vertexShader, fragmentShader); |
| } |
| catch (...) |
| { |
| if (vertexShader != 0) |
| gl.deleteShader(vertexShader); |
| |
| if (fragmentShader != 0) |
| gl.deleteShader(fragmentShader); |
| |
| throw; |
| } |
| } |
| |
| void bindAttributes(TestLog &log, const glw::Functions &gl, uint32_t 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, uint32_t program, |
| const vector<Attribute> &attributes) |
| { |
| int32_t 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; |
| int32_t length = 0; |
| int32_t size = 0; |
| uint32_t 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, uint32_t program, |
| const vector<Attribute> &attributes, const map<string, uint32_t> &bindings) |
| { |
| bool isOk = true; |
| |
| for (int attribNdx = 0; attribNdx < (int)attributes.size(); attribNdx++) |
| { |
| const Attribute &attrib = attributes[attribNdx]; |
| const int32_t expectedLocation = |
| (attrib.getLayoutLocation() != Attribute::LOC_UNDEF ? attrib.getLayoutLocation() : |
| getBoundLocation(bindings, attrib.getName())); |
| const int32_t 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, uint32_t program, const vector<Attribute> &attributes, |
| const map<string, uint32_t> &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) : ""); |
| } |
| |
| } // namespace |
| |
| namespace AttributeLocationTestUtil |
| { |
| |
| AttribType::AttribType(const string &name, uint32_t localSize, uint32_t 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, int32_t 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, uint32_t 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(); |
| uint32_t program = 0; |
| pair<uint32_t, uint32_t> shaders; |
| |
| try |
| { |
| bool isOk = true; |
| map<string, uint32_t> 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; |
| } |
| } |
| |
| } // namespace 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 int32_t 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 int32_t 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 int32_t 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 int32_t 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 int32_t 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 int32_t 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 int32_t 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 int32_t 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 int32_t 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 int32_t 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; |
| } |
| |
| } // namespace gls |
| } // namespace deqp |
