blob: c04cb2d84134ba85c7a0702a68d289c5c0470e9d [file] [log] [blame]
/*-------------------------------------------------------------------------
* OpenGL Conformance Test Suite
* -----------------------------
*
* Copyright (c) 2017 The Khronos Group Inc.
*
* 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 glcShaderConstExprTests.cpp
* \brief Declares shader constant expressions tests.
*/ /*-------------------------------------------------------------------*/
#include "glcShaderConstExprTests.hpp"
#include "deMath.h"
#include "deSharedPtr.hpp"
#include "glsShaderExecUtil.hpp"
#include "gluContextInfo.hpp"
#include "gluShaderUtil.hpp"
#include "tcuFloat.hpp"
#include "tcuStringTemplate.hpp"
#include "tcuTestLog.hpp"
#include <map>
using namespace deqp::gls::ShaderExecUtil;
namespace glcts
{
namespace ShaderConstExpr
{
struct TestParams
{
const char* name;
const char* expression;
glu::DataType inType;
int minComponents;
int maxComponents;
glu::DataType outType;
union {
float outputFloat;
int outputInt;
};
};
struct ShaderExecutorParams
{
deqp::Context* context;
std::string caseName;
std::string source;
glu::DataType outType;
union {
float outputFloat;
int outputInt;
};
};
template <typename OutputType>
class ExecutorTestCase : public deqp::TestCase
{
public:
ExecutorTestCase(deqp::Context& context, const char* name, glu::ShaderType shaderType, const ShaderSpec& shaderSpec,
OutputType expectedOutput);
virtual ~ExecutorTestCase(void);
virtual tcu::TestNode::IterateResult iterate(void);
protected:
void validateOutput(de::SharedPtr<ShaderExecutor> executor);
glu::ShaderType m_shaderType;
ShaderSpec m_shaderSpec;
OutputType m_expectedOutput;
};
template <typename OutputType>
ExecutorTestCase<OutputType>::ExecutorTestCase(deqp::Context& context, const char* name, glu::ShaderType shaderType,
const ShaderSpec& shaderSpec, OutputType expectedOutput)
: deqp::TestCase(context, name, "")
, m_shaderType(shaderType)
, m_shaderSpec(shaderSpec)
, m_expectedOutput(expectedOutput)
{
}
template <typename OutputType>
ExecutorTestCase<OutputType>::~ExecutorTestCase(void)
{
}
template <>
void ExecutorTestCase<float>::validateOutput(de::SharedPtr<ShaderExecutor> executor)
{
float result = 0.0f;
void* const outputs = &result;
executor->execute(1, DE_NULL, &outputs);
const float epsilon = 0.01f;
if (de::abs(m_expectedOutput - result) > epsilon)
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "Expected: " << m_expectedOutput << " ("
<< tcu::toHex(tcu::Float32(m_expectedOutput).bits()) << ") but constant expresion returned: " << result
<< " (" << tcu::toHex(tcu::Float32(result).bits()) << "), used " << epsilon << " epsilon for comparison"
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
return;
}
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return;
}
template <>
void ExecutorTestCase<int>::validateOutput(de::SharedPtr<ShaderExecutor> executor)
{
int result = 0;
void* const outputs = &result;
executor->execute(1, DE_NULL, &outputs);
if (result == m_expectedOutput)
{
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return;
}
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Expected: " << m_expectedOutput
<< " but constant expresion returned: " << result << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
template <typename OutputType>
tcu::TestNode::IterateResult ExecutorTestCase<OutputType>::iterate(void)
{
de::SharedPtr<ShaderExecutor> executor(createExecutor(m_context.getRenderContext(), m_shaderType, m_shaderSpec));
DE_ASSERT(executor.get());
executor->log(m_context.getTestContext().getLog());
try
{
if (!executor->isOk())
TCU_FAIL("Compilation failed");
executor->useProgram();
validateOutput(executor);
}
catch (const tcu::NotSupportedError& e)
{
m_testCtx.getLog() << tcu::TestLog::Message << e.what() << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, e.getMessage());
}
catch (const tcu::TestError& e)
{
m_testCtx.getLog() << tcu::TestLog::Message << e.what() << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, e.getMessage());
}
return tcu::TestNode::STOP;
}
template <typename OutputType>
void createTestCasesForAllShaderTypes(const ShaderExecutorParams& params, std::vector<tcu::TestNode*>& outputTests)
{
DE_ASSERT(params.context);
deqp::Context& context = *(params.context);
glu::ContextType contextType = context.getRenderContext().getType();
ShaderSpec shaderSpec;
shaderSpec.version = glu::getContextTypeGLSLVersion(contextType);
shaderSpec.source = params.source;
shaderSpec.outputs.push_back(Symbol("out0", glu::VarType(params.outType, glu::PRECISION_HIGHP)));
// Construct list of shaders for which tests can be created
std::vector<glu::ShaderType> shaderTypes;
if (glu::contextSupports(contextType, glu::ApiType::core(4, 3)))
{
shaderTypes.push_back(glu::SHADERTYPE_VERTEX);
shaderTypes.push_back(glu::SHADERTYPE_FRAGMENT);
shaderTypes.push_back(glu::SHADERTYPE_COMPUTE);
shaderTypes.push_back(glu::SHADERTYPE_GEOMETRY);
shaderTypes.push_back(glu::SHADERTYPE_TESSELLATION_CONTROL);
shaderTypes.push_back(glu::SHADERTYPE_TESSELLATION_EVALUATION);
}
else if (glu::contextSupports(contextType, glu::ApiType::es(3, 2)))
{
shaderSpec.version = glu::GLSL_VERSION_320_ES;
shaderTypes.push_back(glu::SHADERTYPE_GEOMETRY);
shaderTypes.push_back(glu::SHADERTYPE_TESSELLATION_CONTROL);
shaderTypes.push_back(glu::SHADERTYPE_TESSELLATION_EVALUATION);
}
else if (glu::contextSupports(contextType, glu::ApiType::es(3, 1)))
{
shaderSpec.version = glu::GLSL_VERSION_310_ES;
shaderTypes.push_back(glu::SHADERTYPE_COMPUTE);
shaderTypes.push_back(glu::SHADERTYPE_GEOMETRY);
shaderTypes.push_back(glu::SHADERTYPE_TESSELLATION_CONTROL);
shaderTypes.push_back(glu::SHADERTYPE_TESSELLATION_EVALUATION);
}
else
{
shaderTypes.push_back(glu::SHADERTYPE_VERTEX);
shaderTypes.push_back(glu::SHADERTYPE_FRAGMENT);
}
shaderSpec.globalDeclarations += "precision highp float;\n";
for (std::size_t typeIndex = 0; typeIndex < shaderTypes.size(); ++typeIndex)
{
glu::ShaderType shaderType = shaderTypes[typeIndex];
std::string caseName(params.caseName + '_' + getShaderTypeName(shaderType));
outputTests.push_back(
new ExecutorTestCase<OutputType>(context, caseName.c_str(), shaderType, shaderSpec, static_cast<OutputType>(params.outputFloat)));
}
}
void createTests(deqp::Context& context, const TestParams* cases, int numCases, const char* shaderTemplateSrc,
const char* casePrefix, std::vector<tcu::TestNode*>& outputTests)
{
const tcu::StringTemplate shaderTemplate(shaderTemplateSrc);
const char* componentAccess[] = { "", ".y", ".z", ".w" };
ShaderExecutorParams shaderExecutorParams;
shaderExecutorParams.context = &context;
for (int caseIndex = 0; caseIndex < numCases; caseIndex++)
{
const TestParams& testCase = cases[caseIndex];
const std::string baseName = testCase.name;
const int minComponents = testCase.minComponents;
const int maxComponents = testCase.maxComponents;
const glu::DataType inType = testCase.inType;
const std::string expression = testCase.expression;
// Check for presence of func(vec, scalar) style specialization,
// use as gatekeeper for applying said specialization
const bool alwaysScalar = expression.find("${MT}") != std::string::npos;
std::map<std::string, std::string> shaderTemplateParams;
shaderTemplateParams["CASE_BASE_TYPE"] = glu::getDataTypeName(testCase.outType);
shaderExecutorParams.outType = testCase.outType;
shaderExecutorParams.outputFloat = testCase.outputFloat;
for (int component = minComponents - 1; component < maxComponents; component++)
{
// Get type name eg. float, vec2, vec3, vec4 (same for other primitive types)
glu::DataType dataType = static_cast<glu::DataType>(inType + component);
std::string typeName = glu::getDataTypeName(dataType);
// ${T} => final type, ${MT} => final type but with scalar version usable even when T is a vector
std::map<std::string, std::string> expressionTemplateParams;
expressionTemplateParams["T"] = typeName;
expressionTemplateParams["MT"] = typeName;
const tcu::StringTemplate expressionTemplate(expression);
// Add vector access to expression as needed
shaderTemplateParams["CASE_EXPRESSION"] =
expressionTemplate.specialize(expressionTemplateParams) + componentAccess[component];
{
// Add type to case name if we are generating multiple versions
shaderExecutorParams.caseName = (casePrefix + baseName);
if (minComponents != maxComponents)
shaderExecutorParams.caseName += ("_" + typeName);
shaderExecutorParams.source = shaderTemplate.specialize(shaderTemplateParams);
if (shaderExecutorParams.outType == glu::TYPE_FLOAT)
createTestCasesForAllShaderTypes<float>(shaderExecutorParams, outputTests);
else
createTestCasesForAllShaderTypes<int>(shaderExecutorParams, outputTests);
}
// Deal with functions that allways accept one ore more scalar parameters even when others are vectors
if (alwaysScalar && component > 0)
{
shaderExecutorParams.caseName =
casePrefix + baseName + "_" + typeName + "_" + glu::getDataTypeName(inType);
expressionTemplateParams["MT"] = glu::getDataTypeName(inType);
shaderTemplateParams["CASE_EXPRESSION"] =
expressionTemplate.specialize(expressionTemplateParams) + componentAccess[component];
shaderExecutorParams.source = shaderTemplate.specialize(shaderTemplateParams);
if (shaderExecutorParams.outType == glu::TYPE_FLOAT)
createTestCasesForAllShaderTypes<float>(shaderExecutorParams, outputTests);
else
createTestCasesForAllShaderTypes<int>(shaderExecutorParams, outputTests);
}
} // component loop
}
}
} // namespace ShaderConstExpr
ShaderConstExprTests::ShaderConstExprTests(deqp::Context& context)
: deqp::TestCaseGroup(context, "constant_expressions", "Constant expressions")
{
}
ShaderConstExprTests::~ShaderConstExprTests(void)
{
}
void ShaderConstExprTests::init(void)
{
// Needed for autogenerating shader code for increased component counts
DE_STATIC_ASSERT(glu::TYPE_FLOAT + 1 == glu::TYPE_FLOAT_VEC2);
DE_STATIC_ASSERT(glu::TYPE_FLOAT + 2 == glu::TYPE_FLOAT_VEC3);
DE_STATIC_ASSERT(glu::TYPE_FLOAT + 3 == glu::TYPE_FLOAT_VEC4);
DE_STATIC_ASSERT(glu::TYPE_INT + 1 == glu::TYPE_INT_VEC2);
DE_STATIC_ASSERT(glu::TYPE_INT + 2 == glu::TYPE_INT_VEC3);
DE_STATIC_ASSERT(glu::TYPE_INT + 3 == glu::TYPE_INT_VEC4);
DE_STATIC_ASSERT(glu::TYPE_UINT + 1 == glu::TYPE_UINT_VEC2);
DE_STATIC_ASSERT(glu::TYPE_UINT + 2 == glu::TYPE_UINT_VEC3);
DE_STATIC_ASSERT(glu::TYPE_UINT + 3 == glu::TYPE_UINT_VEC4);
DE_STATIC_ASSERT(glu::TYPE_BOOL + 1 == glu::TYPE_BOOL_VEC2);
DE_STATIC_ASSERT(glu::TYPE_BOOL + 2 == glu::TYPE_BOOL_VEC3);
DE_STATIC_ASSERT(glu::TYPE_BOOL + 3 == glu::TYPE_BOOL_VEC4);
// ${T} => final type, ${MT} => final type but with scalar version usable even when T is a vector
const ShaderConstExpr::TestParams baseCases[] = {
{ "radians", "radians(${T} (90.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, { deFloatRadians(90.0f) } },
{ "degrees", "degrees(${T} (2.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, { deFloatDegrees(2.0f) } },
{ "sin", "sin(${T} (3.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, { deFloatSin(3.0f) } },
{ "cos", "cos(${T} (3.2))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, { deFloatCos(3.2f) } },
{ "asin", "asin(${T} (0.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, { deFloatAsin(0.0f) } },
{ "acos", "acos(${T} (1.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, { deFloatAcos(1.0f) } },
{ "pow", "pow(${T} (1.7), ${T} (3.5))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, { deFloatPow(1.7f, 3.5f) } },
{ "exp", "exp(${T} (4.2))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, { deFloatExp(4.2f) } },
{ "log", "log(${T} (42.12))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, { deFloatLog(42.12f) } },
{ "exp2", "exp2(${T} (6.7))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, { deFloatExp2(6.7f) } },
{ "log2", "log2(${T} (100.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, { deFloatLog2(100.0f) } },
{ "sqrt", "sqrt(${T} (10.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, { deFloatSqrt(10.0f) } },
{ "inversesqrt", "inversesqrt(${T} (10.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, { deFloatRsq(10.0f) } },
{ "abs", "abs(${T} (-42))", glu::TYPE_INT, 1, 4, glu::TYPE_INT, { 42 } },
{ "sign", "sign(${T} (-18.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, { -1.0f } },
{ "floor", "floor(${T} (37.3))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, { deFloatFloor(37.3f) } },
{ "trunc", "trunc(${T} (-1.8))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, { -1.0f } },
{ "round", "round(${T} (42.1))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, { 42.0f } },
{ "ceil", "ceil(${T} (82.2))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, { deFloatCeil(82.2f) } },
{ "mod", "mod(${T} (87.65), ${MT} (3.7))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, { deFloatMod(87.65f, 3.7f) } },
{ "min", "min(${T} (12.3), ${MT} (32.1))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, { 12.3f } },
{ "max", "max(${T} (12.3), ${MT} (32.1))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, { 32.1f } },
{ "clamp", "clamp(${T} (42.1), ${MT} (10.0), ${MT} (15.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, { 15.0f } },
{ "length_float", "length(1.0)", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, { 1.0f } },
{ "length_vec2", "length(vec2(1.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, { deFloatSqrt(2.0f) } },
{ "length_vec3", "length(vec3(1.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, { deFloatSqrt(3.0f) } },
{ "length_vec4", "length(vec4(1.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, { deFloatSqrt(4.0f) } },
{ "dot_float", "dot(1.0, 1.0)", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, { 1.0f } },
{ "dot_vec2", "dot(vec2(1.0), vec2(1.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, { 2.0f } },
{ "dot_vec3", "dot(vec3(1.0), vec3(1.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, { 3.0f } },
{ "dot_vec4", "dot(vec4(1.0), vec4(1.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, { 4.0f } },
{ "normalize_float", "normalize(1.0)", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, { 1.0f } },
{ "normalize_vec2", "normalize(vec2(1.0)).x", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, { deFloatRsq(2.0f) } },
{ "normalize_vec3", "normalize(vec3(1.0)).x", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, { deFloatRsq(3.0f) } },
{ "normalize_vec4", "normalize(vec4(1.0)).x", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, { deFloatRsq(4.0f) } },
};
const ShaderConstExpr::TestParams arrayCases[] = {
{ "radians", "radians(${T} (60.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, { deFloatRadians(60.0f) } },
{ "degrees", "degrees(${T} (0.11))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, { deFloatDegrees(0.11f) } },
{ "sin", "${T} (1.0) + sin(${T} (0.7))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, { 1.0f + deFloatSin(0.7f) } },
{ "cos", "${T} (1.0) + cos(${T} (0.7))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, { 1.0f + deFloatCos(0.7f) } },
{ "asin", "asin(${T} (0.9))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, { deFloatAsin(0.9f) } },
{ "acos", "acos(${T} (-0.5))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, { deFloatAcos(-0.5f) } },
{ "pow", "pow(${T} (2.0), ${T} (2.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, { deFloatPow(2.0f, 2.0f) } },
{ "exp", "exp(${T} (1.2))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, { deFloatExp(1.2f) } },
{ "log", "log(${T} (8.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, { deFloatLog(8.0f) } },
{ "exp2", "exp2(${T} (2.1))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, { deFloatExp2(2.1f) } },
{ "log2", "log2(${T} (9.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, { deFloatLog2(9.0) } },
{ "sqrt", "sqrt(${T} (4.5))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, { deFloatSqrt(4.5f) } },
{ "inversesqrt", "inversesqrt(${T} (0.26))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, { deFloatRsq(0.26f) } },
{ "abs", "abs(${T} (-2))", glu::TYPE_INT, 1, 4, glu::TYPE_INT, { 2 } },
{ "sign", "sign(${T} (18.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, { deFloatSign(18.0f) } },
{ "floor", "floor(${T} (3.3))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, { deFloatFloor(3.3f) } },
{ "trunc", "trunc(${T} (2.8))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, { 2 } },
{ "round", "round(${T} (2.2))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, { deFloatRound(2.2f) } },
{ "ceil", "ceil(${T} (2.2))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, { deFloatCeil(2.2f) } },
{ "mod", "mod(${T} (7.1), ${MT} (4.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, { deFloatMod(7.1f, 4.0f) } },
{ "min", "min(${T} (2.3), ${MT} (3.1))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, { deFloatMin(2.3f, 3.1f) } },
{ "max", "max(${T} (2.3), ${MT} (3.1))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, { deFloatMax(2.3f, 3.1f) } },
{ "clamp", "clamp(${T} (4.1), ${MT} (2.1), ${MT} (3.1))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, { 3 } },
{ "length_float", "length(2.1)", glu::TYPE_FLOAT, 1, 1, glu::TYPE_INT, { 2 } },
{ "length_vec2", "length(vec2(1.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_INT, { deFloatSqrt(2.0f) } },
{ "length_vec3", "length(vec3(1.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_INT, { deFloatSqrt(3.0f) } },
{ "length_vec4", "length(vec4(1.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_INT, { deFloatSqrt(4.0f) } },
{ "dot_float", "dot(1.0, 1.0)", glu::TYPE_FLOAT, 1, 1, glu::TYPE_INT, { 1 } },
{ "dot_vec2", "dot(vec2(1.0), vec2(1.01))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_INT, { 2 } },
{ "dot_vec3", "dot(vec3(1.0), vec3(1.1))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_INT, { 3 } },
{ "dot_vec4", "dot(vec4(1.0), vec4(1.1))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_INT, { 4 } },
{ "normalize_float", "${T} (1.0) + normalize(2.0)", glu::TYPE_FLOAT, 1, 1, glu::TYPE_INT, { 2 } },
{ "normalize_vec2", "${T} (1.0) + normalize(vec2(1.0)).x", glu::TYPE_FLOAT, 1, 1, glu::TYPE_INT, { 1.0f + deFloatRsq(2.0f) } },
{ "normalize_vec3", "${T} (1.0) + normalize(vec3(1.0)).x", glu::TYPE_FLOAT, 1, 1, glu::TYPE_INT, { 1.0f + deFloatRsq(3.0f) } },
{ "normalize_vec4", "${T} (1.0) + normalize(vec4(1.0)).x", glu::TYPE_FLOAT, 1, 1, glu::TYPE_INT, { 1.0f + deFloatRsq(4.0f) } },
};
const char* basicShaderTemplate = "const ${CASE_BASE_TYPE} cval = ${CASE_EXPRESSION};\n"
"out0 = cval;\n";
std::vector<tcu::TestNode*> children;
ShaderConstExpr::createTests(m_context, baseCases, DE_LENGTH_OF_ARRAY(baseCases), basicShaderTemplate, "basic_",
children);
const char* arrayShaderTemplate = "float array[int(${CASE_EXPRESSION})];\n"
"out0 = array.length();\n";
ShaderConstExpr::createTests(m_context, arrayCases, DE_LENGTH_OF_ARRAY(arrayCases), arrayShaderTemplate, "array_",
children);
for (std::size_t i = 0; i < children.size(); i++)
addChild(children[i]);
}
} // glcts