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.
493 lines
17 KiB
493 lines
17 KiB
/*-------------------------------------------------------------------------
|
|
* drawElements Quality Program OpenGL ES 3.1 Module
|
|
* -------------------------------------------------
|
|
*
|
|
* Copyright 2014 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
*//*!
|
|
* \file
|
|
* \brief Shader state query tests
|
|
*//*--------------------------------------------------------------------*/
|
|
|
|
#include "es31fShaderStateQueryTests.hpp"
|
|
#include "es31fInfoLogQueryShared.hpp"
|
|
#include "glsStateQueryUtil.hpp"
|
|
#include "tcuTestLog.hpp"
|
|
#include "tcuStringTemplate.hpp"
|
|
#include "gluShaderProgram.hpp"
|
|
#include "gluRenderContext.hpp"
|
|
#include "gluCallLogWrapper.hpp"
|
|
#include "gluContextInfo.hpp"
|
|
#include "gluStrUtil.hpp"
|
|
#include "glwFunctions.hpp"
|
|
#include "glwEnums.hpp"
|
|
|
|
namespace deqp
|
|
{
|
|
namespace gles31
|
|
{
|
|
namespace Functional
|
|
{
|
|
namespace
|
|
{
|
|
|
|
static inline std::string brokenShaderSource (const glu::ContextType &contextType)
|
|
{
|
|
const std::string glslVersionDecl = glu::getGLSLVersionDeclaration(glu::getContextTypeGLSLVersion(contextType));
|
|
|
|
return glslVersionDecl + "\n"
|
|
"broken, this should not compile,\n"
|
|
"{";
|
|
}
|
|
|
|
class BaseTypeCase : public TestCase
|
|
{
|
|
public:
|
|
struct TestTypeInfo
|
|
{
|
|
glw::GLenum glType;
|
|
const char* declarationStr;
|
|
const char* accessStr;
|
|
};
|
|
|
|
BaseTypeCase (Context& ctx, const char* name, const char* desc, const char* extension);
|
|
|
|
private:
|
|
IterateResult iterate (void);
|
|
virtual std::vector<TestTypeInfo> getInfos (void) const = 0;
|
|
virtual void checkRequirements (void) const;
|
|
|
|
const char* const m_extension;
|
|
};
|
|
|
|
BaseTypeCase::BaseTypeCase (Context& ctx, const char* name, const char* desc, const char* extension)
|
|
: TestCase (ctx, name, desc)
|
|
, m_extension (extension)
|
|
{
|
|
}
|
|
|
|
BaseTypeCase::IterateResult BaseTypeCase::iterate (void)
|
|
{
|
|
static const char* const vertexSourceTemplate = "${VERSIONDECL}\n"
|
|
"in highp vec4 a_position;\n"
|
|
"void main(void)\n"
|
|
"{\n"
|
|
" gl_Position = a_position;\n"
|
|
"}\n";
|
|
static const char* const fragmentSourceTemplate = "${VERSIONDECL}\n"
|
|
"${EXTENSIONSTATEMENT}"
|
|
"${DECLARATIONSTR};\n"
|
|
"layout(location = 0) out highp vec4 dEQP_FragColor;\n"
|
|
"void main(void)\n"
|
|
"{\n"
|
|
" dEQP_FragColor = vec4(${ACCESSSTR});\n"
|
|
"}\n";
|
|
|
|
tcu::ResultCollector result (m_testCtx.getLog());
|
|
std::vector<TestTypeInfo> samplerTypes = getInfos();
|
|
auto ctxType = m_context.getRenderContext().getType();
|
|
const bool isES32orGL45 = glu::contextSupports(ctxType, glu::ApiType::es(3, 2)) ||
|
|
glu::contextSupports(ctxType, glu::ApiType::core(4, 5));
|
|
|
|
if (m_extension && !isES32orGL45 && !m_context.getContextInfo().isExtensionSupported(m_extension))
|
|
throw tcu::NotSupportedError("Test requires " + std::string(m_extension));
|
|
checkRequirements();
|
|
|
|
for (int typeNdx = 0; typeNdx < (int)samplerTypes.size(); ++typeNdx)
|
|
{
|
|
const tcu::ScopedLogSection section (m_testCtx.getLog(),
|
|
std::string(glu::getShaderVarTypeStr(samplerTypes[typeNdx].glType).toString()),
|
|
"Uniform type " + glu::getShaderVarTypeStr(samplerTypes[typeNdx].glType).toString());
|
|
|
|
std::map<std::string, std::string> shaderArgs;
|
|
shaderArgs["DECLARATIONSTR"] = samplerTypes[typeNdx].declarationStr;
|
|
shaderArgs["ACCESSSTR"] = samplerTypes[typeNdx].accessStr;
|
|
shaderArgs["EXTENSIONSTATEMENT"] = (m_extension && !isES32orGL45) ? (std::string() + "#extension " + m_extension + " : require\n") : ("");
|
|
shaderArgs["VERSIONDECL"] = glu::getGLSLVersionDeclaration(glu::getContextTypeGLSLVersion(ctxType));
|
|
|
|
const std::string fragmentSource = tcu::StringTemplate(fragmentSourceTemplate).specialize(shaderArgs);
|
|
const std::string vertexSource = tcu::StringTemplate(vertexSourceTemplate).specialize(shaderArgs);
|
|
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
|
|
glu::ShaderProgram program (m_context.getRenderContext(), glu::ProgramSources() << glu::VertexSource(vertexSource) << glu::FragmentSource(fragmentSource));
|
|
|
|
m_testCtx.getLog() << tcu::TestLog::Message << "Building program with uniform sampler of type " << glu::getShaderVarTypeStr(samplerTypes[typeNdx].glType) << tcu::TestLog::EndMessage;
|
|
|
|
if (!program.isOk())
|
|
{
|
|
m_testCtx.getLog() << program;
|
|
result.fail("could not build shader");
|
|
}
|
|
else
|
|
{
|
|
// only one uniform -- uniform at index 0
|
|
int uniforms = 0;
|
|
gl.getProgramiv(program.getProgram(), GL_ACTIVE_UNIFORMS, &uniforms);
|
|
|
|
if (uniforms != 1)
|
|
result.fail("Unexpected GL_ACTIVE_UNIFORMS, expected 1");
|
|
else
|
|
{
|
|
// check type
|
|
const glw::GLuint uniformIndex = 0;
|
|
glw::GLint type = 0;
|
|
|
|
m_testCtx.getLog() << tcu::TestLog::Message << "Verifying uniform type." << tcu::TestLog::EndMessage;
|
|
gl.getActiveUniformsiv(program.getProgram(), 1, &uniformIndex, GL_UNIFORM_TYPE, &type);
|
|
|
|
if (type != (glw::GLint)samplerTypes[typeNdx].glType)
|
|
{
|
|
std::ostringstream buf;
|
|
buf << "Invalid type, expected " << samplerTypes[typeNdx].glType << ", got " << type;
|
|
result.fail(buf.str());
|
|
}
|
|
}
|
|
}
|
|
|
|
GLU_EXPECT_NO_ERROR(gl.getError(), "");
|
|
}
|
|
|
|
result.setTestContextResult(m_testCtx);
|
|
return STOP;
|
|
}
|
|
|
|
void BaseTypeCase::checkRequirements (void) const
|
|
{
|
|
}
|
|
|
|
class CoreSamplerTypeCase : public BaseTypeCase
|
|
{
|
|
public:
|
|
CoreSamplerTypeCase (Context& ctx, const char* name, const char* desc);
|
|
|
|
private:
|
|
std::vector<TestTypeInfo> getInfos (void) const;
|
|
};
|
|
|
|
CoreSamplerTypeCase::CoreSamplerTypeCase (Context& ctx, const char* name, const char* desc)
|
|
: BaseTypeCase(ctx, name, desc, DE_NULL)
|
|
{
|
|
}
|
|
|
|
std::vector<BaseTypeCase::TestTypeInfo> CoreSamplerTypeCase::getInfos (void) const
|
|
{
|
|
static const TestTypeInfo samplerTypes[] =
|
|
{
|
|
{ GL_SAMPLER_2D_MULTISAMPLE, "uniform highp sampler2DMS u_sampler", "texelFetch(u_sampler, ivec2(gl_FragCoord.xy), 0)" },
|
|
{ GL_INT_SAMPLER_2D_MULTISAMPLE, "uniform highp isampler2DMS u_sampler", "texelFetch(u_sampler, ivec2(gl_FragCoord.xy), 0)" },
|
|
{ GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE, "uniform highp usampler2DMS u_sampler", "texelFetch(u_sampler, ivec2(gl_FragCoord.xy), 0)" },
|
|
};
|
|
|
|
std::vector<TestTypeInfo> infos;
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(samplerTypes); ++ndx)
|
|
infos.push_back(samplerTypes[ndx]);
|
|
|
|
return infos;
|
|
}
|
|
|
|
class MSArraySamplerTypeCase : public BaseTypeCase
|
|
{
|
|
public:
|
|
MSArraySamplerTypeCase (Context& ctx, const char* name, const char* desc);
|
|
|
|
private:
|
|
std::vector<TestTypeInfo> getInfos (void) const;
|
|
};
|
|
|
|
MSArraySamplerTypeCase::MSArraySamplerTypeCase (Context& ctx, const char* name, const char* desc)
|
|
: BaseTypeCase(ctx, name, desc, "GL_OES_texture_storage_multisample_2d_array")
|
|
{
|
|
}
|
|
|
|
std::vector<BaseTypeCase::TestTypeInfo> MSArraySamplerTypeCase::getInfos (void) const
|
|
{
|
|
static const TestTypeInfo samplerTypes[] =
|
|
{
|
|
{ GL_SAMPLER_2D_MULTISAMPLE_ARRAY, "uniform highp sampler2DMSArray u_sampler", "texelFetch(u_sampler, ivec3(gl_FragCoord.xyz), 0)" },
|
|
{ GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, "uniform highp isampler2DMSArray u_sampler", "texelFetch(u_sampler, ivec3(gl_FragCoord.xyz), 0)" },
|
|
{ GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, "uniform highp usampler2DMSArray u_sampler", "texelFetch(u_sampler, ivec3(gl_FragCoord.xyz), 0)" },
|
|
};
|
|
|
|
std::vector<TestTypeInfo> infos;
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(samplerTypes); ++ndx)
|
|
infos.push_back(samplerTypes[ndx]);
|
|
|
|
return infos;
|
|
}
|
|
|
|
class TextureBufferSamplerTypeCase : public BaseTypeCase
|
|
{
|
|
public:
|
|
TextureBufferSamplerTypeCase (Context& ctx, const char* name, const char* desc);
|
|
|
|
private:
|
|
std::vector<TestTypeInfo> getInfos (void) const;
|
|
};
|
|
|
|
TextureBufferSamplerTypeCase::TextureBufferSamplerTypeCase (Context& ctx, const char* name, const char* desc)
|
|
: BaseTypeCase(ctx, name, desc, "GL_EXT_texture_buffer")
|
|
{
|
|
}
|
|
|
|
std::vector<BaseTypeCase::TestTypeInfo> TextureBufferSamplerTypeCase::getInfos (void) const
|
|
{
|
|
static const TestTypeInfo samplerTypes[] =
|
|
{
|
|
{ GL_SAMPLER_BUFFER, "uniform highp samplerBuffer u_sampler", "texelFetch(u_sampler, int(gl_FragCoord.x))" },
|
|
{ GL_INT_SAMPLER_BUFFER, "uniform highp isamplerBuffer u_sampler", "texelFetch(u_sampler, int(gl_FragCoord.x))" },
|
|
{ GL_UNSIGNED_INT_SAMPLER_BUFFER, "uniform highp usamplerBuffer u_sampler", "texelFetch(u_sampler, int(gl_FragCoord.x))" },
|
|
};
|
|
|
|
std::vector<TestTypeInfo> infos;
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(samplerTypes); ++ndx)
|
|
infos.push_back(samplerTypes[ndx]);
|
|
|
|
return infos;
|
|
}
|
|
|
|
class TextureBufferImageTypeCase : public BaseTypeCase
|
|
{
|
|
public:
|
|
TextureBufferImageTypeCase (Context& ctx, const char* name, const char* desc);
|
|
|
|
private:
|
|
std::vector<TestTypeInfo> getInfos (void) const;
|
|
void checkRequirements (void) const;
|
|
};
|
|
|
|
TextureBufferImageTypeCase::TextureBufferImageTypeCase (Context& ctx, const char* name, const char* desc)
|
|
: BaseTypeCase(ctx, name, desc, "GL_EXT_texture_buffer")
|
|
{
|
|
}
|
|
|
|
std::vector<BaseTypeCase::TestTypeInfo> TextureBufferImageTypeCase::getInfos (void) const
|
|
{
|
|
static const TestTypeInfo samplerTypes[] =
|
|
{
|
|
{ GL_IMAGE_BUFFER, "layout(binding=0, rgba8) readonly uniform highp imageBuffer u_image", "imageLoad(u_image, int(gl_FragCoord.x))" },
|
|
{ GL_INT_IMAGE_BUFFER, "layout(binding=0, r32i) readonly uniform highp iimageBuffer u_image", "imageLoad(u_image, int(gl_FragCoord.x))" },
|
|
{ GL_UNSIGNED_INT_IMAGE_BUFFER, "layout(binding=0, r32ui) readonly uniform highp uimageBuffer u_image", "imageLoad(u_image, int(gl_FragCoord.x))" },
|
|
};
|
|
|
|
std::vector<TestTypeInfo> infos;
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(samplerTypes); ++ndx)
|
|
infos.push_back(samplerTypes[ndx]);
|
|
|
|
return infos;
|
|
}
|
|
|
|
void TextureBufferImageTypeCase::checkRequirements (void) const
|
|
{
|
|
if (m_context.getContextInfo().getInt(GL_MAX_FRAGMENT_IMAGE_UNIFORMS) < 1)
|
|
throw tcu::NotSupportedError("Test requires fragment images");
|
|
}
|
|
|
|
class CubeArraySamplerTypeCase : public BaseTypeCase
|
|
{
|
|
public:
|
|
CubeArraySamplerTypeCase (Context& ctx, const char* name, const char* desc);
|
|
|
|
private:
|
|
std::vector<TestTypeInfo> getInfos (void) const;
|
|
};
|
|
|
|
CubeArraySamplerTypeCase::CubeArraySamplerTypeCase (Context& ctx, const char* name, const char* desc)
|
|
: BaseTypeCase(ctx, name, desc, "GL_EXT_texture_cube_map_array")
|
|
{
|
|
}
|
|
|
|
std::vector<BaseTypeCase::TestTypeInfo> CubeArraySamplerTypeCase::getInfos (void) const
|
|
{
|
|
static const TestTypeInfo samplerTypes[] =
|
|
{
|
|
{ GL_SAMPLER_CUBE_MAP_ARRAY, "uniform highp samplerCubeArray u_sampler", "texture(u_sampler, gl_FragCoord.xxyz)" },
|
|
{ GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW, "uniform highp samplerCubeArrayShadow u_sampler", "texture(u_sampler, gl_FragCoord.xxyz, 0.5)" },
|
|
{ GL_INT_SAMPLER_CUBE_MAP_ARRAY, "uniform highp isamplerCubeArray u_sampler", "texture(u_sampler, gl_FragCoord.xxyz)" },
|
|
{ GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY, "uniform highp usamplerCubeArray u_sampler", "texture(u_sampler, gl_FragCoord.xxyz)" },
|
|
};
|
|
|
|
std::vector<TestTypeInfo> infos;
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(samplerTypes); ++ndx)
|
|
infos.push_back(samplerTypes[ndx]);
|
|
|
|
return infos;
|
|
}
|
|
|
|
class CubeArrayImageTypeCase : public BaseTypeCase
|
|
{
|
|
public:
|
|
CubeArrayImageTypeCase (Context& ctx, const char* name, const char* desc);
|
|
|
|
private:
|
|
std::vector<TestTypeInfo> getInfos (void) const;
|
|
void checkRequirements (void) const;
|
|
};
|
|
|
|
CubeArrayImageTypeCase::CubeArrayImageTypeCase (Context& ctx, const char* name, const char* desc)
|
|
: BaseTypeCase(ctx, name, desc, "GL_EXT_texture_cube_map_array")
|
|
{
|
|
}
|
|
|
|
std::vector<BaseTypeCase::TestTypeInfo> CubeArrayImageTypeCase::getInfos (void) const
|
|
{
|
|
static const TestTypeInfo samplerTypes[] =
|
|
{
|
|
{ GL_IMAGE_CUBE_MAP_ARRAY, "layout(binding=0, rgba8) readonly uniform highp imageCubeArray u_image", "imageLoad(u_image, ivec3(gl_FragCoord.xyx))" },
|
|
{ GL_INT_IMAGE_CUBE_MAP_ARRAY, "layout(binding=0, r32i) readonly uniform highp iimageCubeArray u_image", "imageLoad(u_image, ivec3(gl_FragCoord.xyx))" },
|
|
{ GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY, "layout(binding=0, r32ui) readonly uniform highp uimageCubeArray u_image", "imageLoad(u_image, ivec3(gl_FragCoord.xyx))" },
|
|
};
|
|
|
|
std::vector<TestTypeInfo> infos;
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(samplerTypes); ++ndx)
|
|
infos.push_back(samplerTypes[ndx]);
|
|
|
|
return infos;
|
|
}
|
|
|
|
void CubeArrayImageTypeCase::checkRequirements (void) const
|
|
{
|
|
if (m_context.getContextInfo().getInt(GL_MAX_FRAGMENT_IMAGE_UNIFORMS) < 1)
|
|
throw tcu::NotSupportedError("Test requires fragment images");
|
|
}
|
|
|
|
class ShaderLogCase : public TestCase
|
|
{
|
|
public:
|
|
ShaderLogCase (Context& ctx, const char* name, const char* desc, glu::ShaderType shaderType);
|
|
|
|
private:
|
|
void init (void);
|
|
IterateResult iterate (void);
|
|
|
|
const glu::ShaderType m_shaderType;
|
|
};
|
|
|
|
ShaderLogCase::ShaderLogCase (Context& ctx, const char* name, const char* desc, glu::ShaderType shaderType)
|
|
: TestCase (ctx, name, desc)
|
|
, m_shaderType (shaderType)
|
|
{
|
|
}
|
|
|
|
void ShaderLogCase::init (void)
|
|
{
|
|
auto ctxType = m_context.getRenderContext().getType();
|
|
const bool isES32orGL45 = glu::contextSupports(ctxType, glu::ApiType::es(3, 2)) ||
|
|
glu::contextSupports(ctxType, glu::ApiType::core(4, 5));
|
|
|
|
switch (m_shaderType)
|
|
{
|
|
case glu::SHADERTYPE_VERTEX:
|
|
case glu::SHADERTYPE_FRAGMENT:
|
|
case glu::SHADERTYPE_COMPUTE:
|
|
break;
|
|
|
|
case glu::SHADERTYPE_GEOMETRY:
|
|
if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader") && !isES32orGL45)
|
|
throw tcu::NotSupportedError("Test requires GL_EXT_geometry_shader extension or an OpenGL ES 3.2 or higher context.");
|
|
break;
|
|
|
|
case glu::SHADERTYPE_TESSELLATION_CONTROL:
|
|
case glu::SHADERTYPE_TESSELLATION_EVALUATION:
|
|
if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader") && !isES32orGL45)
|
|
throw tcu::NotSupportedError("Test requires GL_EXT_tessellation_shader extension or an OpenGL ES 3.2 or higher context.");
|
|
break;
|
|
|
|
default:
|
|
DE_ASSERT(false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
ShaderLogCase::IterateResult ShaderLogCase::iterate (void)
|
|
{
|
|
using gls::StateQueryUtil::StateQueryMemoryWriteGuard;
|
|
|
|
tcu::ResultCollector result (m_testCtx.getLog());
|
|
glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
|
|
deUint32 shader = 0;
|
|
const std::string source = brokenShaderSource(m_context.getRenderContext().getType());
|
|
const char* const brokenSource = source.c_str();
|
|
StateQueryMemoryWriteGuard<glw::GLint> logLen;
|
|
|
|
gl.enableLogging(true);
|
|
|
|
m_testCtx.getLog() << tcu::TestLog::Message << "Trying to compile broken shader source." << tcu::TestLog::EndMessage;
|
|
|
|
shader = gl.glCreateShader(glu::getGLShaderType(m_shaderType));
|
|
GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "create shader");
|
|
|
|
gl.glShaderSource(shader, 1, &brokenSource, DE_NULL);
|
|
gl.glCompileShader(shader);
|
|
GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "compile");
|
|
|
|
gl.glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logLen);
|
|
logLen.verifyValidity(result);
|
|
|
|
if (!logLen.isUndefined())
|
|
verifyInfoLogQuery(result, gl, logLen, shader, &glu::CallLogWrapper::glGetShaderInfoLog, "glGetShaderInfoLog");
|
|
|
|
gl.glDeleteShader(shader);
|
|
GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "delete");
|
|
|
|
result.setTestContextResult(m_testCtx);
|
|
return STOP;
|
|
}
|
|
|
|
} // anonymous
|
|
|
|
ShaderStateQueryTests::ShaderStateQueryTests (Context& context)
|
|
: TestCaseGroup(context, "shader", "Shader state query tests")
|
|
{
|
|
}
|
|
|
|
ShaderStateQueryTests::~ShaderStateQueryTests (void)
|
|
{
|
|
}
|
|
|
|
void ShaderStateQueryTests::init (void)
|
|
{
|
|
addChild(new CoreSamplerTypeCase (m_context, "sampler_type", "Sampler type cases"));
|
|
addChild(new MSArraySamplerTypeCase (m_context, "sampler_type_multisample_array", "MSAA array sampler type cases"));
|
|
addChild(new TextureBufferSamplerTypeCase (m_context, "sampler_type_texture_buffer", "Texture buffer sampler type cases"));
|
|
addChild(new TextureBufferImageTypeCase (m_context, "image_type_texture_buffer", "Texture buffer image type cases"));
|
|
addChild(new CubeArraySamplerTypeCase (m_context, "sampler_type_cube_array", "Cube array sampler type cases"));
|
|
addChild(new CubeArrayImageTypeCase (m_context, "image_type_cube_array", "Cube array image type cases"));
|
|
|
|
// shader info log tests
|
|
// \note, there exists similar tests in gles3 module. However, the gles31 could use a different
|
|
// shader compiler with different INFO_LOG bugs.
|
|
{
|
|
static const struct
|
|
{
|
|
const char* caseName;
|
|
glu::ShaderType caseType;
|
|
} shaderTypes[] =
|
|
{
|
|
{ "info_log_vertex", glu::SHADERTYPE_VERTEX },
|
|
{ "info_log_fragment", glu::SHADERTYPE_FRAGMENT },
|
|
{ "info_log_geometry", glu::SHADERTYPE_GEOMETRY },
|
|
{ "info_log_tess_ctrl", glu::SHADERTYPE_TESSELLATION_CONTROL },
|
|
{ "info_log_tess_eval", glu::SHADERTYPE_TESSELLATION_EVALUATION },
|
|
{ "info_log_compute", glu::SHADERTYPE_COMPUTE },
|
|
};
|
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(shaderTypes); ++ndx)
|
|
addChild(new ShaderLogCase(m_context, shaderTypes[ndx].caseName, "", shaderTypes[ndx].caseType));
|
|
}
|
|
}
|
|
|
|
} // Functional
|
|
} // gles31
|
|
} // deqp
|