/*-------------------------------------------------------------------------
* 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 Tests for separate shader objects
*//*--------------------------------------------------------------------*/
#include "es31fSeparateShaderTests.hpp"
#include "deInt32.h"
#include "deString.h"
#include "deStringUtil.hpp"
#include "deUniquePtr.hpp"
#include "deRandom.hpp"
#include "deSTLUtil.hpp"
#include "tcuCommandLine.hpp"
#include "tcuImageCompare.hpp"
#include "tcuRenderTarget.hpp"
#include "tcuResultCollector.hpp"
#include "tcuRGBA.hpp"
#include "tcuSurface.hpp"
#include "tcuStringTemplate.hpp"
#include "gluCallLogWrapper.hpp"
#include "gluPixelTransfer.hpp"
#include "gluRenderContext.hpp"
#include "gluShaderProgram.hpp"
#include "gluVarType.hpp"
#include "glsShaderLibrary.hpp"
#include "glwFunctions.hpp"
#include "glwDefs.hpp"
#include "glwEnums.hpp"
#include <cstdarg>
#include <algorithm>
#include <map>
#include <sstream>
#include <string>
#include <set>
#include <vector>
namespace deqp
{
namespace gles31
{
namespace Functional
{
namespace
{
using std::map;
using std::set;
using std::ostringstream;
using std::string;
using std::vector;
using de::MovePtr;
using de::Random;
using de::UniquePtr;
using tcu::MessageBuilder;
using tcu::RenderTarget;
using tcu::StringTemplate;
using tcu::Surface;
using tcu::TestLog;
using tcu::ResultCollector;
using glu::CallLogWrapper;
using glu::DataType;
using glu::VariableDeclaration;
using glu::Precision;
using glu::Program;
using glu::ProgramPipeline;
using glu::ProgramSources;
using glu::RenderContext;
using glu::ShaderProgram;
using glu::ShaderType;
using glu::Storage;
using glu::VarType;
using glu::VertexSource;
using glu::FragmentSource;
using glu::ProgramSeparable;
using namespace glw;
#define LOG_CALL(CALL) do \
{ \
enableLogging(true); \
CALL; \
enableLogging(false); \
} while (deGetFalse())
enum
{
VIEWPORT_SIZE = 128
};
enum VaryingInterpolation
{
VARYINGINTERPOLATION_SMOOTH = 0,
VARYINGINTERPOLATION_FLAT,
VARYINGINTERPOLATION_CENTROID,
VARYINGINTERPOLATION_DEFAULT,
VARYINGINTERPOLATION_RANDOM,
VARYINGINTERPOLATION_LAST
};
DataType randomType (Random& rnd)
{
using namespace glu;
if (rnd.getInt(0, 7) == 0)
{
const int numCols = rnd.getInt(2, 4), numRows = rnd.getInt(2, 4);
return getDataTypeMatrix(numCols, numRows);
}
else
{
static const DataType s_types[] = { TYPE_FLOAT, TYPE_INT, TYPE_UINT };
static const float s_weights[] = { 3.0, 1.0, 1.0 };
const int size = rnd.getInt(1, 4);
const DataType scalarType = rnd.chooseWeighted<DataType>(
DE_ARRAY_BEGIN(s_types), DE_ARRAY_END(s_types), DE_ARRAY_BEGIN(s_weights));
return getDataTypeVector(scalarType, size);
}
DE_FATAL("Impossible");
return TYPE_INVALID;
}
VaryingInterpolation randomInterpolation (Random& rnd)
{
static const VaryingInterpolation s_validInterpolations[] =
{
VARYINGINTERPOLATION_SMOOTH,
VARYINGINTERPOLATION_FLAT,
VARYINGINTERPOLATION_CENTROID,
VARYINGINTERPOLATION_DEFAULT,
};
return s_validInterpolations[rnd.getInt(0, DE_LENGTH_OF_ARRAY(s_validInterpolations)-1)];
}
glu::Interpolation getGluInterpolation (VaryingInterpolation interpolation)
{
switch (interpolation)
{
case VARYINGINTERPOLATION_SMOOTH: return glu::INTERPOLATION_SMOOTH;
case VARYINGINTERPOLATION_FLAT: return glu::INTERPOLATION_FLAT;
case VARYINGINTERPOLATION_CENTROID: return glu::INTERPOLATION_CENTROID;
case VARYINGINTERPOLATION_DEFAULT: return glu::INTERPOLATION_LAST; //!< Last means no qualifier, i.e. default
default:
DE_FATAL("Invalid interpolation");
return glu::INTERPOLATION_LAST;
}
}
// used only for debug sanity checks
#if defined(DE_DEBUG)
VaryingInterpolation getVaryingInterpolation (glu::Interpolation interpolation)
{
switch (interpolation)
{
case glu::INTERPOLATION_SMOOTH: return VARYINGINTERPOLATION_SMOOTH;
case glu::INTERPOLATION_FLAT: return VARYINGINTERPOLATION_FLAT;
case glu::INTERPOLATION_CENTROID: return VARYINGINTERPOLATION_CENTROID;
case glu::INTERPOLATION_LAST: return VARYINGINTERPOLATION_DEFAULT; //!< Last means no qualifier, i.e. default
default:
DE_FATAL("Invalid interpolation");
return VARYINGINTERPOLATION_LAST;
}
}
#endif
enum BindingKind
{
BINDING_NAME,
BINDING_LOCATION,
BINDING_LAST
};
BindingKind randomBinding (Random& rnd)
{
return rnd.getBool() ? BINDING_LOCATION : BINDING_NAME;
}
void printInputColor (ostringstream& oss, const VariableDeclaration& input)
{
using namespace glu;
const DataType basicType = input.varType.getBasicType();
string exp = input.name;
switch (getDataTypeScalarType(basicType))
{
case TYPE_FLOAT:
break;
case TYPE_INT:
case TYPE_UINT:
{
DataType floatType = getDataTypeFloatScalars(basicType);
exp = string() + "(" + getDataTypeName(floatType) + "(" + exp + ") / 255.0" + ")";
break;
}
default:
DE_FATAL("Impossible");
}
if (isDataTypeScalarOrVector(basicType))
{
switch (getDataTypeScalarSize(basicType))
{
case 1:
oss << "hsv(vec3(" << exp << ", 1.0, 1.0))";
break;
case 2:
oss << "hsv(vec3(" << exp << ", 1.0))";
break;
case 3:
oss << "vec4(" << exp << ", 1.0)";
break;
case 4:
oss << exp;
break;
default:
DE_FATAL("Impossible");
}
}
else if (isDataTypeMatrix(basicType))
{
int rows = getDataTypeMatrixNumRows(basicType);
int columns = getDataTypeMatrixNumColumns(basicType);
if (rows == columns)
oss << "hsv(vec3(determinant(" << exp << ")))";
else
{
if (rows != 3 && columns >= 3)
{
exp = "transpose(" + exp + ")";
std::swap(rows, columns);
}
exp = exp + "[0]";
if (rows > 3)
exp = exp + ".xyz";
oss << "hsv(" << exp << ")";
}
}
else
DE_FATAL("Impossible");
}
// Representation for the varyings between vertex and fragment shaders
struct VaryingParams
{
VaryingParams (void)
: count (0)
, type (glu::TYPE_LAST)
, binding (BINDING_LAST)
, vtxInterp (VARYINGINTERPOLATION_LAST)
, frgInterp (VARYINGINTERPOLATION_LAST) {}
int count;
DataType type;
BindingKind binding;
VaryingInterpolation vtxInterp;
VaryingInterpolation frgInterp;
};
struct VaryingInterface
{
vector<VariableDeclaration> vtxOutputs;
vector<VariableDeclaration> frgInputs;
};
// Generate corresponding input and output variable declarations that may vary
// in compatible ways.
VaryingInterpolation chooseInterpolation (VaryingInterpolation param, DataType type, Random& rnd)
{
if (glu::getDataTypeScalarType(type) != glu::TYPE_FLOAT)
return VARYINGINTERPOLATION_FLAT;
if (param == VARYINGINTERPOLATION_RANDOM)
return randomInterpolation(rnd);
return param;
}
bool isSSOCompatibleInterpolation (VaryingInterpolation vertexInterpolation, VaryingInterpolation fragmentInterpolation)
{
// interpolations must be fully specified
DE_ASSERT(vertexInterpolation != VARYINGINTERPOLATION_RANDOM);
DE_ASSERT(vertexInterpolation < VARYINGINTERPOLATION_LAST);
DE_ASSERT(fragmentInterpolation != VARYINGINTERPOLATION_RANDOM);
DE_ASSERT(fragmentInterpolation < VARYINGINTERPOLATION_LAST);
// interpolation can only be either smooth or flat. Auxiliary storage does not matter.
const bool isSmoothVtx = (vertexInterpolation == VARYINGINTERPOLATION_SMOOTH) || //!< trivial
(vertexInterpolation == VARYINGINTERPOLATION_DEFAULT) || //!< default to smooth
(vertexInterpolation == VARYINGINTERPOLATION_CENTROID); //!< default to smooth, ignore storage
const bool isSmoothFrag = (fragmentInterpolation == VARYINGINTERPOLATION_SMOOTH) || //!< trivial
(fragmentInterpolation == VARYINGINTERPOLATION_DEFAULT) || //!< default to smooth
(fragmentInterpolation == VARYINGINTERPOLATION_CENTROID); //!< default to smooth, ignore storage
// Khronos bug #12630: flat / smooth qualifiers must match in SSO
return isSmoothVtx == isSmoothFrag;
}
VaryingInterface genVaryingInterface (const VaryingParams& params,
Random& rnd)
{
using namespace glu;
VaryingInterface ret;
int offset = 0;
for (int varNdx = 0; varNdx < params.count; ++varNdx)
{
const BindingKind binding = ((params.binding == BINDING_LAST)
? randomBinding(rnd) : params.binding);
const DataType type = ((params.type == TYPE_LAST)
? randomType(rnd) : params.type);
const VaryingInterpolation vtxInterp = chooseInterpolation(params.vtxInterp, type, rnd);
const VaryingInterpolation frgInterp = chooseInterpolation(params.frgInterp, type, rnd);
const VaryingInterpolation vtxCompatInterp = (isSSOCompatibleInterpolation(vtxInterp, frgInterp))
? (vtxInterp) : (frgInterp);
const int loc = ((binding == BINDING_LOCATION) ? offset : -1);
const string ndxStr = de::toString(varNdx);
const string vtxName = ((binding == BINDING_NAME)
? "var" + ndxStr : "vtxVar" + ndxStr);
const string frgName = ((binding == BINDING_NAME)
? "var" + ndxStr : "frgVar" + ndxStr);
const VarType varType (type, PRECISION_HIGHP);
offset += getDataTypeNumLocations(type);
// Over 16 locations aren't necessarily supported, so halt here.
if (offset > 16)
break;
ret.vtxOutputs.push_back(
VariableDeclaration(varType, vtxName, STORAGE_OUT, getGluInterpolation(vtxCompatInterp), loc));
ret.frgInputs.push_back(
VariableDeclaration(varType, frgName, STORAGE_IN, getGluInterpolation(frgInterp), loc));
}
return ret;
}
// Create vertex output variable declarations that are maximally compatible
// with the fragment input variables.
vector<VariableDeclaration> varyingCompatVtxOutputs (const VaryingInterface& varyings)
{
vector<VariableDeclaration> outputs = varyings.vtxOutputs;
for (size_t i = 0; i < outputs.size(); ++i)
{
outputs[i].interpolation = varyings.frgInputs[i].interpolation;
outputs[i].name = varyings.frgInputs[i].name;
}
return outputs;
}
// Shader source generation
void printFloat (ostringstream& oss, double d)
{
oss.setf(oss.fixed | oss.internal);
oss.precision(4);
oss.width(7);
oss << d;
}
void printFloatDeclaration (ostringstream& oss,
const string& varName,
bool uniform,
GLfloat value = 0.0)
{
using namespace glu;
const VarType varType (TYPE_FLOAT, PRECISION_HIGHP);
if (uniform)
oss << VariableDeclaration(varType, varName, STORAGE_UNIFORM) << ";\n";
else
oss << VariableDeclaration(varType, varName, STORAGE_CONST)
<< " = " << de::floatToString(value, 6) << ";\n";
}
void printRandomInitializer (ostringstream& oss, DataType type, Random& rnd)
{
using namespace glu;
const int size = getDataTypeScalarSize(type);
if (size > 0)
oss << getDataTypeName(type) << "(";
for (int i = 0; i < size; ++i)
{
oss << (i == 0 ? "" : ", ");
switch (getDataTypeScalarType(type))
{
case TYPE_FLOAT:
printFloat(oss, rnd.getInt(0, 16) / 16.0);
break;
case TYPE_INT:
case TYPE_UINT:
oss << rnd.getInt(0, 255);
break;
case TYPE_BOOL:
oss << (rnd.getBool() ? "true" : "false");
break;
default:
DE_FATAL("Impossible");
}
}
if (size > 0)
oss << ")";
}
string genVtxShaderSrc (deUint32 seed,
const vector<VariableDeclaration>& outputs,
const string& varName,
bool uniform,
float value = 0.0)
{
ostringstream oss;
Random rnd (seed);
enum { NUM_COMPONENTS = 2 };
static const int s_quadrants[][NUM_COMPONENTS] = { {1, 1}, {-1, 1}, {1, -1} };
oss << "#version 310 es\n";
printFloatDeclaration(oss, varName, uniform, value);
for (vector<VariableDeclaration>::const_iterator it = outputs.begin();
it != outputs.end(); ++it)
oss << *it << ";\n";
oss << "const vec2 triangle[3] = vec2[3](\n";
for (int vertexNdx = 0; vertexNdx < DE_LENGTH_OF_ARRAY(s_quadrants); ++vertexNdx)
{
oss << "\tvec2(";
for (int componentNdx = 0; componentNdx < NUM_COMPONENTS; ++componentNdx)
{
printFloat(oss, s_quadrants[vertexNdx][componentNdx] * rnd.getInt(4,16) / 16.0);
oss << (componentNdx < 1 ? ", " : "");
}
oss << ")" << (vertexNdx < 2 ? "," : "") << "\n";
}
oss << ");\n";
for (vector<VariableDeclaration>::const_iterator it = outputs.begin();
it != outputs.end(); ++it)
{
const DataType type = it->varType.getBasicType();
const string typeName = glu::getDataTypeName(type);
oss << "const " << typeName << " " << it->name << "Inits[3] = "
<< typeName << "[3](\n";
for (int i = 0; i < 3; ++i)
{
oss << (i == 0 ? "\t" : ",\n\t");
printRandomInitializer(oss, type, rnd);
}
oss << ");\n";
}
oss << "void main (void)\n"
<< "{\n"
<< "\tgl_Position = vec4(" << varName << " * triangle[gl_VertexID], 0.0, 1.0);\n";
for (vector<VariableDeclaration>::const_iterator it = outputs.begin();
it != outputs.end(); ++it)
oss << "\t" << it->name << " = " << it->name << "Inits[gl_VertexID];\n";
oss << "}\n";
return oss.str();
}
string genFrgShaderSrc (deUint32 seed,
const vector<VariableDeclaration>& inputs,
const string& varName,
bool uniform,
float value = 0.0)
{
Random rnd (seed);
ostringstream oss;
oss.precision(4);
oss.width(7);
oss << "#version 310 es\n";
oss << "precision highp float;\n";
oss << "out vec4 fragColor;\n";
printFloatDeclaration(oss, varName, uniform, value);
for (vector<VariableDeclaration>::const_iterator it = inputs.begin();
it != inputs.end(); ++it)
oss << *it << ";\n";
// glsl % isn't defined for negative numbers
oss << "int imod (int n, int d)" << "\n"
<< "{" << "\n"
<< "\t" << "return (n < 0 ? d - 1 - (-1 - n) % d : n % d);" << "\n"
<< "}" << "\n";
oss << "vec4 hsv (vec3 hsv)"
<< "{" << "\n"
<< "\tfloat h = hsv.x * 3.0;\n"
<< "\tfloat r = max(0.0, 1.0 - h) + max(0.0, h - 2.0);\n"
<< "\tfloat g = max(0.0, 1.0 - abs(h - 1.0));\n"
<< "\tfloat b = max(0.0, 1.0 - abs(h - 2.0));\n"
<< "\tvec3 hs = mix(vec3(1.0), vec3(r, g, b), hsv.y);\n"
<< "\treturn vec4(hsv.z * hs, 1.0);\n"
<< "}\n";
oss << "void main (void)\n"
<< "{\n";
oss << "\t" << "fragColor = vec4(vec3(" << varName << "), 1.0);" << "\n";
if (inputs.size() > 0)
{
oss << "\t"
<< "switch (imod(int(0.5 * (";
printFloat(oss, rnd.getFloat(0.5f, 2.0f));
oss << " * gl_FragCoord.x - ";
printFloat(oss, rnd.getFloat(0.5f, 2.0f));
oss << " * gl_FragCoord.y)), "
<< inputs.size() << "))" << "\n"
<< "\t" << "{" << "\n";
for (size_t i = 0; i < inputs.size(); ++i)
{
oss << "\t\t" << "case " << i << ":" << "\n"
<< "\t\t\t" << "fragColor *= ";
printInputColor(oss, inputs[i]);
oss << ";" << "\n"
<< "\t\t\t" << "break;" << "\n";
}
oss << "\t\t" << "case " << inputs.size() << ":\n"
<< "\t\t\t" << "fragColor = vec4(1.0, 0.0, 1.0, 1.0);" << "\n";
oss << "\t\t\t" << "break;" << "\n";
oss << "\t\t" << "case -1:\n"
<< "\t\t\t" << "fragColor = vec4(1.0, 1.0, 0.0, 1.0);" << "\n";
oss << "\t\t\t" << "break;" << "\n";
oss << "\t\t" << "default:" << "\n"
<< "\t\t\t" << "fragColor = vec4(1.0, 1.0, 0.0, 1.0);" << "\n";
oss << "\t" << "}\n";
}
oss << "}\n";
return oss.str();
}
// ProgramWrapper
class ProgramWrapper
{
public:
virtual ~ProgramWrapper (void) {}
virtual GLuint getProgramName (void) = 0;
virtual void writeToLog (TestLog& log) = 0;
};
class ShaderProgramWrapper : public ProgramWrapper
{
public:
ShaderProgramWrapper (const RenderContext& renderCtx,
const ProgramSources& sources)
: m_shaderProgram (renderCtx, sources) {}
~ShaderProgramWrapper (void) {}
GLuint getProgramName (void) { return m_shaderProgram.getProgram(); }
ShaderProgram& getShaderProgram (void) { return m_shaderProgram; }
void writeToLog (TestLog& log) { log << m_shaderProgram; }
private:
ShaderProgram m_shaderProgram;
};
class RawProgramWrapper : public ProgramWrapper
{
public:
RawProgramWrapper (const RenderContext& renderCtx,
GLuint programName,
ShaderType shaderType,
const string& source)
: m_program (renderCtx, programName)
, m_shaderType (shaderType)
, m_source (source) {}
~RawProgramWrapper (void) {}
GLuint getProgramName (void) { return m_program.getProgram(); }
Program& getProgram (void) { return m_program; }
void writeToLog (TestLog& log);
private:
Program m_program;
ShaderType m_shaderType;
const string m_source;
};
void RawProgramWrapper::writeToLog (TestLog& log)
{
const string info = m_program.getInfoLog();
qpShaderType qpType = glu::getLogShaderType(m_shaderType);
log << TestLog::ShaderProgram(true, info)
<< TestLog::Shader(qpType, m_source,
true, "[Shader created by glCreateShaderProgramv()]")
<< TestLog::EndShaderProgram;
}
// ProgramParams
struct ProgramParams
{
ProgramParams (deUint32 vtxSeed_, GLfloat vtxScale_, deUint32 frgSeed_, GLfloat frgScale_)
: vtxSeed (vtxSeed_)
, vtxScale (vtxScale_)
, frgSeed (frgSeed_)
, frgScale (frgScale_) {}
deUint32 vtxSeed;
GLfloat vtxScale;
deUint32 frgSeed;
GLfloat frgScale;
};
ProgramParams genProgramParams (Random& rnd)
{
const deUint32 vtxSeed = rnd.getUint32();
const GLfloat vtxScale = (float)rnd.getInt(8, 16) / 16.0f;
const deUint32 frgSeed = rnd.getUint32();
const GLfloat frgScale = (float)rnd.getInt(0, 16) / 16.0f;
return ProgramParams(vtxSeed, vtxScale, frgSeed, frgScale);
}
// TestParams
struct TestParams
{
bool initSingle;
bool switchVtx;
bool switchFrg;
bool useUniform;
bool useSameName;
bool useCreateHelper;
bool useProgramUniform;
VaryingParams varyings;
};
deUint32 paramsSeed (const TestParams& params)
{
deUint32 paramCode = (params.initSingle << 0 |
params.switchVtx << 1 |
params.switchFrg << 2 |
params.useUniform << 3 |
params.useSameName << 4 |
params.useCreateHelper << 5 |
params.useProgramUniform << 6);
paramCode = deUint32Hash(paramCode) + params.varyings.count;
paramCode = deUint32Hash(paramCode) + params.varyings.type;
paramCode = deUint32Hash(paramCode) + params.varyings.binding;
paramCode = deUint32Hash(paramCode) + params.varyings.vtxInterp;
paramCode = deUint32Hash(paramCode) + params.varyings.frgInterp;
return deUint32Hash(paramCode);
}
string paramsCode (const TestParams& params)
{
using namespace glu;
ostringstream oss;
oss << (params.initSingle ? "1" : "2")
<< (params.switchVtx ? "v" : "")
<< (params.switchFrg ? "f" : "")
<< (params.useProgramUniform ? "p" : "")
<< (params.useUniform ? "u" : "")
<< (params.useSameName ? "s" : "")
<< (params.useCreateHelper ? "c" : "")
<< de::toString(params.varyings.count)
<< (params.varyings.binding == BINDING_NAME ? "n" :
params.varyings.binding == BINDING_LOCATION ? "l" :
params.varyings.binding == BINDING_LAST ? "r" :
"")
<< (params.varyings.vtxInterp == VARYINGINTERPOLATION_SMOOTH ? "m" :
params.varyings.vtxInterp == VARYINGINTERPOLATION_CENTROID ? "e" :
params.varyings.vtxInterp == VARYINGINTERPOLATION_FLAT ? "a" :
params.varyings.vtxInterp == VARYINGINTERPOLATION_RANDOM ? "r" :
"o")
<< (params.varyings.frgInterp == VARYINGINTERPOLATION_SMOOTH ? "m" :
params.varyings.frgInterp == VARYINGINTERPOLATION_CENTROID ? "e" :
params.varyings.frgInterp == VARYINGINTERPOLATION_FLAT ? "a" :
params.varyings.frgInterp == VARYINGINTERPOLATION_RANDOM ? "r" :
"o");
return oss.str();
}
bool paramsValid (const TestParams& params)
{
using namespace glu;
// Final pipeline has a single program?
if (params.initSingle)
{
// Cannot have conflicting names for uniforms or constants
if (params.useSameName)
return false;
// CreateShaderProgram would never get called
if (!params.switchVtx && !params.switchFrg && params.useCreateHelper)
return false;
// Must switch either all or nothing
if (params.switchVtx != params.switchFrg)
return false;
}
// ProgramUniform would never get called
if (params.useProgramUniform && !params.useUniform)
return false;
// Interpolation is meaningless if we don't use an in/out variable.
if (params.varyings.count == 0 &&
!(params.varyings.vtxInterp == VARYINGINTERPOLATION_LAST &&
params.varyings.frgInterp == VARYINGINTERPOLATION_LAST))
return false;
// Mismatch by flat / smooth is not allowed. See Khronos bug #12630
// \note: iterpolations might be RANDOM, causing generated varyings potentially match / mismatch anyway.
// This is checked later on. Here, we just make sure that we don't force the generator to generate
// only invalid varying configurations, i.e. there exists a valid varying configuration for this
// test param config.
if ((params.varyings.vtxInterp != VARYINGINTERPOLATION_RANDOM) &&
(params.varyings.frgInterp != VARYINGINTERPOLATION_RANDOM) &&
(params.varyings.vtxInterp == VARYINGINTERPOLATION_FLAT) != (params.varyings.frgInterp == VARYINGINTERPOLATION_FLAT))
return false;
return true;
}
// used only for debug sanity checks
#if defined(DE_DEBUG)
bool varyingsValid (const VaryingInterface& varyings)
{
for (int ndx = 0; ndx < (int)varyings.vtxOutputs.size(); ++ndx)
{
const VaryingInterpolation vertexInterpolation = getVaryingInterpolation(varyings.vtxOutputs[ndx].interpolation);
const VaryingInterpolation fragmentInterpolation = getVaryingInterpolation(varyings.frgInputs[ndx].interpolation);
if (!isSSOCompatibleInterpolation(vertexInterpolation, fragmentInterpolation))
return false;
}
return true;
}
#endif
void logParams (TestLog& log, const TestParams& params)
{
// We don't log operational details here since those are shown
// in the log messages during execution.
MessageBuilder msg = log.message();
msg << "Pipeline configuration:\n";
msg << "Vertex and fragment shaders have "
<< (params.useUniform ? "uniform" : "constant") << "s with "
<< (params.useSameName ? "the same name" : "different names") << ".\n";
if (params.varyings.count == 0)
msg << "There are no varyings.\n";
else
{
if (params.varyings.count == 1)
msg << "There is one varying.\n";
else
msg << "There are " << params.varyings.count << " varyings.\n";
if (params.varyings.type == glu::TYPE_LAST)
msg << "Varyings are of random types.\n";
else
msg << "Varyings are of type '"
<< glu::getDataTypeName(params.varyings.type) << "'.\n";
msg << "Varying outputs and inputs correspond ";
switch (params.varyings.binding)
{
case BINDING_NAME:
msg << "by name.\n";
break;
case BINDING_LOCATION:
msg << "by location.\n";
break;
case BINDING_LAST:
msg << "randomly either by name or by location.\n";
break;
default:
DE_FATAL("Impossible");
}
msg << "In the vertex shader the varyings are qualified ";
if (params.varyings.vtxInterp == VARYINGINTERPOLATION_DEFAULT)
msg << "with no interpolation qualifiers.\n";
else if (params.varyings.vtxInterp == VARYINGINTERPOLATION_RANDOM)
msg << "with a random interpolation qualifier.\n";
else
msg << "'" << glu::getInterpolationName(getGluInterpolation(params.varyings.vtxInterp)) << "'.\n";
msg << "In the fragment shader the varyings are qualified ";
if (params.varyings.frgInterp == VARYINGINTERPOLATION_DEFAULT)
msg << "with no interpolation qualifiers.\n";
else if (params.varyings.frgInterp == VARYINGINTERPOLATION_RANDOM)
msg << "with a random interpolation qualifier.\n";
else
msg << "'" << glu::getInterpolationName(getGluInterpolation(params.varyings.frgInterp)) << "'.\n";
}
msg << TestLog::EndMessage;
log.writeMessage("");
}
TestParams genParams (deUint32 seed)
{
Random rnd (seed);
TestParams params;
int tryNdx = 0;
do
{
params.initSingle = rnd.getBool();
params.switchVtx = rnd.getBool();
params.switchFrg = rnd.getBool();
params.useUniform = rnd.getBool();
params.useProgramUniform = params.useUniform && rnd.getBool();
params.useCreateHelper = rnd.getBool();
params.useSameName = rnd.getBool();
{
int i = rnd.getInt(-1, 3);
params.varyings.count = (i == -1 ? 0 : 1 << i);
}
if (params.varyings.count > 0)
{
params.varyings.type = glu::TYPE_LAST;
params.varyings.binding = BINDING_LAST;
params.varyings.vtxInterp = VARYINGINTERPOLATION_RANDOM;
params.varyings.frgInterp = VARYINGINTERPOLATION_RANDOM;
}
else
{
params.varyings.type = glu::TYPE_INVALID;
params.varyings.binding = BINDING_LAST;
params.varyings.vtxInterp = VARYINGINTERPOLATION_LAST;
params.varyings.frgInterp = VARYINGINTERPOLATION_LAST;
}
tryNdx += 1;
} while (!paramsValid(params) && tryNdx < 16);
DE_ASSERT(paramsValid(params));
return params;
}
// Program pipeline wrapper that retains references to component programs.
struct Pipeline
{
Pipeline (MovePtr<ProgramPipeline> pipeline_,
MovePtr<ProgramWrapper> fullProg_,
MovePtr<ProgramWrapper> vtxProg_,
MovePtr<ProgramWrapper> frgProg_)
: pipeline (pipeline_)
, fullProg (fullProg_)
, vtxProg (vtxProg_)
, frgProg (frgProg_) {}
ProgramWrapper& getVertexProgram (void) const
{
return vtxProg ? *vtxProg : *fullProg;
}
ProgramWrapper& getFragmentProgram (void) const
{
return frgProg ? *frgProg : *fullProg;
}
UniquePtr<ProgramPipeline> pipeline;
UniquePtr<ProgramWrapper> fullProg;
UniquePtr<ProgramWrapper> vtxProg;
UniquePtr<ProgramWrapper> frgProg;
};
void logPipeline(TestLog& log, const Pipeline& pipeline)
{
ProgramWrapper& vtxProg = pipeline.getVertexProgram();
ProgramWrapper& frgProg = pipeline.getFragmentProgram();
log.writeMessage("// Failed program pipeline:");
if (&vtxProg == &frgProg)
{
log.writeMessage("// Common program for both vertex and fragment stages:");
vtxProg.writeToLog(log);
}
else
{
log.writeMessage("// Vertex stage program:");
vtxProg.writeToLog(log);
log.writeMessage("// Fragment stage program:");
frgProg.writeToLog(log);
}
}
// Rectangle
struct Rectangle
{
Rectangle (int x_, int y_, int width_, int height_)
: x (x_)
, y (y_)
, width (width_)
, height (height_) {}
int x;
int y;
int width;
int height;
};
void setViewport (const RenderContext& renderCtx, const Rectangle& rect)
{
renderCtx.getFunctions().viewport(rect.x, rect.y, rect.width, rect.height);
}
void readRectangle (const RenderContext& renderCtx, const Rectangle& rect, Surface& dst)
{
dst.setSize(rect.width, rect.height);
glu::readPixels(renderCtx, rect.x, rect.y, dst.getAccess());
}
Rectangle randomViewport (const RenderContext& ctx, Random& rnd,
GLint maxWidth, GLint maxHeight)
{
const RenderTarget& target = ctx.getRenderTarget();
GLint width = de::min(target.getWidth(), maxWidth);
GLint xOff = rnd.getInt(0, target.getWidth() - width);
GLint height = de::min(target.getHeight(), maxHeight);
GLint yOff = rnd.getInt(0, target.getHeight() - height);
return Rectangle(xOff, yOff, width, height);
}
// SeparateShaderTest
class SeparateShaderTest : public TestCase, private CallLogWrapper
{
public:
typedef void (SeparateShaderTest::*TestFunc)
(MovePtr<Pipeline>& pipeOut);
SeparateShaderTest (Context& ctx,
const string& name,
const string& description,
int iterations,
const TestParams& params,
TestFunc testFunc);
IterateResult iterate (void);
void testPipelineRendering (MovePtr<Pipeline>& pipeOut);
void testCurrentProgPriority (MovePtr<Pipeline>& pipeOut);
void testActiveProgramUniform (MovePtr<Pipeline>& pipeOut);
void testPipelineQueryActive (MovePtr<Pipeline>& pipeOut);
void testPipelineQueryPrograms (MovePtr<Pipeline>& pipeOut);
private:
TestLog& log (void);
const RenderContext& getRenderContext (void);
void setUniform (ProgramWrapper& program,
const string& uniformName,
GLfloat value,
bool useProgramUni);
void drawSurface (Surface& dst,
deUint32 seed = 0);
MovePtr<ProgramWrapper> createShaderProgram (const string* vtxSource,
const string* frgSource,
bool separable);
MovePtr<ProgramWrapper> createSingleShaderProgram (ShaderType shaderType,
const string& src);
MovePtr<Pipeline> createPipeline (const ProgramParams& pp);
MovePtr<ProgramWrapper> createReferenceProgram (const ProgramParams& pp);
int m_iterations;
int m_currentIteration;
TestParams m_params;
TestFunc m_testFunc;
Random m_rnd;
ResultCollector m_status;
VaryingInterface m_varyings;
// Per-iteration state required for logging on exception
MovePtr<ProgramWrapper> m_fullProg;
MovePtr<ProgramWrapper> m_vtxProg;
MovePtr<ProgramWrapper> m_frgProg;
};
const RenderContext& SeparateShaderTest::getRenderContext (void)
{
return m_context.getRenderContext();
}
TestLog& SeparateShaderTest::log (void)
{
return m_testCtx.getLog();
}
SeparateShaderTest::SeparateShaderTest (Context& ctx,
const string& name,
const string& description,
int iterations,
const TestParams& params,
TestFunc testFunc)
: TestCase (ctx, name.c_str(), description.c_str())
, CallLogWrapper (ctx.getRenderContext().getFunctions(), log())
, m_iterations (iterations)
, m_currentIteration(0)
, m_params (params)
, m_testFunc (testFunc)
, m_rnd (paramsSeed(params))
, m_status (log(), "// ")
, m_varyings (genVaryingInterface(params.varyings, m_rnd))
{
DE_ASSERT(paramsValid(params));
DE_ASSERT(varyingsValid(m_varyings));
}
MovePtr<ProgramWrapper> SeparateShaderTest::createShaderProgram (const string* vtxSource,
const string* frgSource,
bool separable)
{
ProgramSources sources;
if (vtxSource != DE_NULL)
sources << VertexSource(*vtxSource);
if (frgSource != DE_NULL)
sources << FragmentSource(*frgSource);
sources << ProgramSeparable(separable);
MovePtr<ShaderProgramWrapper> wrapper (new ShaderProgramWrapper(getRenderContext(),
sources));
if (!wrapper->getShaderProgram().isOk())
{
log().writeMessage("Couldn't create shader program");
wrapper->writeToLog(log());
TCU_FAIL("Couldn't create shader program");
}
return MovePtr<ProgramWrapper>(wrapper.release());
}
MovePtr<ProgramWrapper> SeparateShaderTest::createSingleShaderProgram (ShaderType shaderType,
const string& src)
{
const RenderContext& renderCtx = getRenderContext();
if (m_params.useCreateHelper)
{
const char* const srcStr = src.c_str();
const GLenum glType = glu::getGLShaderType(shaderType);
const GLuint programName = glCreateShaderProgramv(glType, 1, &srcStr);
if (glGetError() != GL_NO_ERROR || programName == 0)
{
qpShaderType qpType = glu::getLogShaderType(shaderType);
log() << TestLog::Message << "glCreateShaderProgramv() failed"
<< TestLog::EndMessage
<< TestLog::ShaderProgram(false, "[glCreateShaderProgramv() failed]")
<< TestLog::Shader(qpType, src,
false, "[glCreateShaderProgramv() failed]")
<< TestLog::EndShaderProgram;
TCU_FAIL("glCreateShaderProgramv() failed");
}
RawProgramWrapper* const wrapper = new RawProgramWrapper(renderCtx, programName,
shaderType, src);
MovePtr<ProgramWrapper> wrapperPtr(wrapper);
Program& program = wrapper->getProgram();
if (!program.getLinkStatus())
{
log().writeMessage("glCreateShaderProgramv() failed at linking");
wrapper->writeToLog(log());
TCU_FAIL("glCreateShaderProgram() failed at linking");
}
return wrapperPtr;
}
else
{
switch (shaderType)
{
case glu::SHADERTYPE_VERTEX:
return createShaderProgram(&src, DE_NULL, true);
case glu::SHADERTYPE_FRAGMENT:
return createShaderProgram(DE_NULL, &src, true);
default:
DE_FATAL("Impossible case");
}
}
return MovePtr<ProgramWrapper>(); // Shut up compiler warnings.
}
void SeparateShaderTest::setUniform (ProgramWrapper& program,
const string& uniformName,
GLfloat value,
bool useProgramUniform)
{
const GLuint progName = program.getProgramName();
const GLint location = glGetUniformLocation(progName, uniformName.c_str());
MessageBuilder msg = log().message();
msg << "// Set program " << progName << "'s uniform '" << uniformName << "' to " << value;
if (useProgramUniform)
{
msg << " using glProgramUniform1f";
glProgramUniform1f(progName, location, value);
}
else
{
msg << " using glUseProgram and glUniform1f";
glUseProgram(progName);
glUniform1f(location, value);
glUseProgram(0);
}
msg << TestLog::EndMessage;
}
MovePtr<Pipeline> SeparateShaderTest::createPipeline (const ProgramParams& pp)
{
const bool useUniform = m_params.useUniform;
const string vtxName = m_params.useSameName ? "scale" : "vtxScale";
const deUint32 initVtxSeed = m_params.switchVtx ? m_rnd.getUint32() : pp.vtxSeed;
const string frgName = m_params.useSameName ? "scale" : "frgScale";
const deUint32 initFrgSeed = m_params.switchFrg ? m_rnd.getUint32() : pp.frgSeed;
const string frgSource = genFrgShaderSrc(initFrgSeed, m_varyings.frgInputs,
frgName, useUniform, pp.frgScale);
const RenderContext& renderCtx = getRenderContext();
MovePtr<ProgramPipeline> pipeline (new ProgramPipeline(renderCtx));
MovePtr<ProgramWrapper> fullProg;
MovePtr<ProgramWrapper> vtxProg;
MovePtr<ProgramWrapper> frgProg;
// We cannot allow a situation where we have a single program with a
// single uniform, because then the vertex and fragment shader uniforms
// would not be distinct in the final pipeline, and we are going to test
// that altering one uniform will not affect the other.
DE_ASSERT(!(m_params.initSingle && m_params.useSameName &&
!m_params.switchVtx && !m_params.switchFrg));
if (m_params.initSingle)
{
string vtxSource = genVtxShaderSrc(initVtxSeed,
varyingCompatVtxOutputs(m_varyings),
vtxName, useUniform, pp.vtxScale);
fullProg = createShaderProgram(&vtxSource, &frgSource, true);
pipeline->useProgramStages(GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT,
fullProg->getProgramName());
log() << TestLog::Message
<< "// Created pipeline " << pipeline->getPipeline()
<< " with two-shader program " << fullProg->getProgramName()
<< TestLog::EndMessage;
}
else
{
string vtxSource = genVtxShaderSrc(initVtxSeed, m_varyings.vtxOutputs,
vtxName, useUniform, pp.vtxScale);
vtxProg = createSingleShaderProgram(glu::SHADERTYPE_VERTEX, vtxSource);
pipeline->useProgramStages(GL_VERTEX_SHADER_BIT, vtxProg->getProgramName());
frgProg = createSingleShaderProgram(glu::SHADERTYPE_FRAGMENT, frgSource);
pipeline->useProgramStages(GL_FRAGMENT_SHADER_BIT, frgProg->getProgramName());
log() << TestLog::Message
<< "// Created pipeline " << pipeline->getPipeline()
<< " with vertex program " << vtxProg->getProgramName()
<< " and fragment program " << frgProg->getProgramName()
<< TestLog::EndMessage;
}
m_status.check(pipeline->isValid(),
"Pipeline is invalid after initialization");
if (m_params.switchVtx)
{
string newSource = genVtxShaderSrc(pp.vtxSeed, m_varyings.vtxOutputs,
vtxName, useUniform, pp.vtxScale);
vtxProg = createSingleShaderProgram(glu::SHADERTYPE_VERTEX, newSource);
pipeline->useProgramStages(GL_VERTEX_SHADER_BIT, vtxProg->getProgramName());
log() << TestLog::Message
<< "// Switched pipeline " << pipeline->getPipeline()
<< "'s vertex stage to single-shader program " << vtxProg->getProgramName()
<< TestLog::EndMessage;
}
if (m_params.switchFrg)
{
string newSource = genFrgShaderSrc(pp.frgSeed, m_varyings.frgInputs,
frgName, useUniform, pp.frgScale);
frgProg = createSingleShaderProgram(glu::SHADERTYPE_FRAGMENT, newSource);
pipeline->useProgramStages(GL_FRAGMENT_SHADER_BIT, frgProg->getProgramName());
log() << TestLog::Message
<< "// Switched pipeline " << pipeline->getPipeline()
<< "'s fragment stage to single-shader program " << frgProg->getProgramName()
<< TestLog::EndMessage;
}
if (m_params.switchVtx || m_params.switchFrg)
m_status.check(pipeline->isValid(),
"Pipeline became invalid after changing a stage's program");
if (m_params.useUniform)
{
ProgramWrapper& vtxStage = *(vtxProg ? vtxProg : fullProg);
ProgramWrapper& frgStage = *(frgProg ? frgProg : fullProg);
setUniform(vtxStage, vtxName, pp.vtxScale, m_params.useProgramUniform);
setUniform(frgStage, frgName, pp.frgScale, m_params.useProgramUniform);
}
else
log().writeMessage("// Programs use constants instead of uniforms");
return MovePtr<Pipeline>(new Pipeline(pipeline, fullProg, vtxProg, frgProg));
}
MovePtr<ProgramWrapper> SeparateShaderTest::createReferenceProgram (const ProgramParams& pp)
{
bool useUniform = m_params.useUniform;
const string vtxSrc = genVtxShaderSrc(pp.vtxSeed,
varyingCompatVtxOutputs(m_varyings),
"vtxScale", useUniform, pp.vtxScale);
const string frgSrc = genFrgShaderSrc(pp.frgSeed, m_varyings.frgInputs,
"frgScale", useUniform, pp.frgScale);
MovePtr<ProgramWrapper> program = createShaderProgram(&vtxSrc, &frgSrc, false);
GLuint progName = program->getProgramName();
log() << TestLog::Message
<< "// Created monolithic shader program " << progName
<< TestLog::EndMessage;
if (useUniform)
{
setUniform(*program, "vtxScale", pp.vtxScale, false);
setUniform(*program, "frgScale", pp.frgScale, false);
}
return program;
}
void SeparateShaderTest::drawSurface (Surface& dst, deUint32 seed)
{
const RenderContext& renderCtx = getRenderContext();
Random rnd (seed > 0 ? seed : m_rnd.getUint32());
Rectangle viewport = randomViewport(renderCtx, rnd,
VIEWPORT_SIZE, VIEWPORT_SIZE);
glClearColor(0.125f, 0.25f, 0.5f, 1.f);
setViewport(renderCtx, viewport);
glClear(GL_COLOR_BUFFER_BIT);
GLU_CHECK_CALL(glDrawArrays(GL_TRIANGLES, 0, 3));
readRectangle(renderCtx, viewport, dst);
log().writeMessage("// Drew a triangle");
}
void SeparateShaderTest::testPipelineRendering (MovePtr<Pipeline>& pipeOut)
{
ProgramParams pp = genProgramParams(m_rnd);
Pipeline& pipeline = *(pipeOut = createPipeline(pp));
GLuint pipeName = pipeline.pipeline->getPipeline();
UniquePtr<ProgramWrapper> refProgram (createReferenceProgram(pp));
GLuint refProgName = refProgram->getProgramName();
Surface refSurface;
Surface pipelineSurface;
GLuint drawSeed = m_rnd.getUint32();
glUseProgram(refProgName);
log() << TestLog::Message << "// Use program " << refProgName << TestLog::EndMessage;
drawSurface(refSurface, drawSeed);
glUseProgram(0);
glBindProgramPipeline(pipeName);
log() << TestLog::Message << "// Bind pipeline " << pipeName << TestLog::EndMessage;
drawSurface(pipelineSurface, drawSeed);
glBindProgramPipeline(0);
{
const bool result = tcu::fuzzyCompare(
m_testCtx.getLog(), "Program pipeline result",
"Result of comparing a program pipeline with a monolithic program",
refSurface, pipelineSurface, 0.05f, tcu::COMPARE_LOG_RESULT);
m_status.check(result, "Pipeline rendering differs from equivalent monolithic program");
}
}
void SeparateShaderTest::testCurrentProgPriority (MovePtr<Pipeline>& pipeOut)
{
ProgramParams pipePp = genProgramParams(m_rnd);
ProgramParams programPp = genProgramParams(m_rnd);
Pipeline& pipeline = *(pipeOut = createPipeline(pipePp));
GLuint pipeName = pipeline.pipeline->getPipeline();
UniquePtr<ProgramWrapper> program (createReferenceProgram(programPp));
Surface pipelineSurface;
Surface refSurface;
Surface resultSurface;
deUint32 drawSeed = m_rnd.getUint32();
LOG_CALL(glBindProgramPipeline(pipeName));
drawSurface(pipelineSurface, drawSeed);
LOG_CALL(glBindProgramPipeline(0));
LOG_CALL(glUseProgram(program->getProgramName()));
drawSurface(refSurface, drawSeed);
LOG_CALL(glUseProgram(0));
LOG_CALL(glUseProgram(program->getProgramName()));
LOG_CALL(glBindProgramPipeline(pipeName));
drawSurface(resultSurface, drawSeed);
LOG_CALL(glBindProgramPipeline(0));
LOG_CALL(glUseProgram(0));
bool result = tcu::pixelThresholdCompare(
m_testCtx.getLog(), "Active program rendering result",
"Active program rendering result",
refSurface, resultSurface, tcu::RGBA(0, 0, 0, 0), tcu::COMPARE_LOG_RESULT);
m_status.check(result, "glBindProgramPipeline() affects glUseProgram()");
if (!result)
log() << TestLog::Image("Pipeline image", "Image produced by pipeline",
pipelineSurface);
}
void SeparateShaderTest::testActiveProgramUniform (MovePtr<Pipeline>& pipeOut)
{
ProgramParams refPp = genProgramParams(m_rnd);
Surface refSurface;
Surface resultSurface;
deUint32 drawSeed = m_rnd.getUint32();
DE_UNREF(pipeOut);
{
UniquePtr<ProgramWrapper> refProg (createReferenceProgram(refPp));
GLuint refProgName = refProg->getProgramName();
glUseProgram(refProgName);
log() << TestLog::Message << "// Use reference program " << refProgName
<< TestLog::EndMessage;
drawSurface(refSurface, drawSeed);
glUseProgram(0);
}
{
ProgramParams changePp = genProgramParams(m_rnd);
changePp.vtxSeed = refPp.vtxSeed;
changePp.frgSeed = refPp.frgSeed;
UniquePtr<ProgramWrapper> changeProg (createReferenceProgram(changePp));
GLuint changeName = changeProg->getProgramName();
ProgramPipeline pipeline (getRenderContext());
GLint vtxLoc = glGetUniformLocation(changeName, "vtxScale");
GLint frgLoc = glGetUniformLocation(changeName, "frgScale");
LOG_CALL(glBindProgramPipeline(pipeline.getPipeline()));
pipeline.activeShaderProgram(changeName);
log() << TestLog::Message << "// Set active shader program to " << changeName
<< TestLog::EndMessage;
glUniform1f(vtxLoc, refPp.vtxScale);
log() << TestLog::Message
<< "// Set uniform 'vtxScale' to " << refPp.vtxScale << " using glUniform1f"
<< TestLog::EndMessage;
glUniform1f(frgLoc, refPp.frgScale);
log() << TestLog::Message
<< "// Set uniform 'frgScale' to " << refPp.frgScale << " using glUniform1f"
<< TestLog::EndMessage;
pipeline.activeShaderProgram(0);
LOG_CALL(glBindProgramPipeline(0));
LOG_CALL(glUseProgram(changeName));
drawSurface(resultSurface, drawSeed);
LOG_CALL(glUseProgram(0));
}
bool result = tcu::fuzzyCompare(
m_testCtx.getLog(), "Active program uniform result",
"Active program uniform result",
refSurface, resultSurface, 0.05f, tcu::COMPARE_LOG_RESULT);
m_status.check(result,
"glUniform() did not correctly modify "
"the active program of the bound pipeline");
}
void SeparateShaderTest::testPipelineQueryPrograms (MovePtr<Pipeline>& pipeOut)
{
ProgramParams pipePp = genProgramParams(m_rnd);
Pipeline& pipeline = *(pipeOut = createPipeline(pipePp));
GLuint pipeName = pipeline.pipeline->getPipeline();
GLint queryVtx = 0;
GLint queryFrg = 0;
LOG_CALL(GLU_CHECK_CALL(glGetProgramPipelineiv(pipeName, GL_VERTEX_SHADER, &queryVtx)));
m_status.check(GLuint(queryVtx) == pipeline.getVertexProgram().getProgramName(),
"Program pipeline query reported wrong vertex shader program");
LOG_CALL(GLU_CHECK_CALL(glGetProgramPipelineiv(pipeName, GL_FRAGMENT_SHADER, &queryFrg)));
m_status.check(GLuint(queryFrg) == pipeline.getFragmentProgram().getProgramName(),
"Program pipeline query reported wrong fragment shader program");
}
void SeparateShaderTest::testPipelineQueryActive (MovePtr<Pipeline>& pipeOut)
{
ProgramParams pipePp = genProgramParams(m_rnd);
Pipeline& pipeline = *(pipeOut = createPipeline(pipePp));
GLuint pipeName = pipeline.pipeline->getPipeline();
GLuint newActive = pipeline.getVertexProgram().getProgramName();
GLint queryActive = 0;
LOG_CALL(GLU_CHECK_CALL(glGetProgramPipelineiv(pipeName, GL_ACTIVE_PROGRAM, &queryActive)));
m_status.check(queryActive == 0,
"Program pipeline query reported non-zero initial active program");
pipeline.pipeline->activeShaderProgram(newActive);
log() << TestLog::Message
<< "Set pipeline " << pipeName << "'s active shader program to " << newActive
<< TestLog::EndMessage;
LOG_CALL(GLU_CHECK_CALL(glGetProgramPipelineiv(pipeName, GL_ACTIVE_PROGRAM, &queryActive)));
m_status.check(GLuint(queryActive) == newActive,
"Program pipeline query reported incorrect active program");
pipeline.pipeline->activeShaderProgram(0);
}
TestCase::IterateResult SeparateShaderTest::iterate (void)
{
MovePtr<Pipeline> pipeline;
DE_ASSERT(m_iterations > 0);
if (m_currentIteration == 0)
logParams(log(), m_params);
++m_currentIteration;
try
{
(this->*m_testFunc)(pipeline);
log().writeMessage("");
}
catch (const tcu::Exception&)
{
if (pipeline)
logPipeline(log(), *pipeline);
throw;
}
if (m_status.getResult() != QP_TEST_RESULT_PASS)
{
if (pipeline)
logPipeline(log(), *pipeline);
}
else if (m_currentIteration < m_iterations)
return CONTINUE;
m_status.setTestContextResult(m_testCtx);
return STOP;
}
// Group construction utilities
enum ParamFlags
{
PARAMFLAGS_SWITCH_FRAGMENT = 1 << 0,
PARAMFLAGS_SWITCH_VERTEX = 1 << 1,
PARAMFLAGS_INIT_SINGLE = 1 << 2,
PARAMFLAGS_LAST = 1 << 3,
PARAMFLAGS_MASK = PARAMFLAGS_LAST - 1
};
bool areCaseParamFlagsValid (ParamFlags flags)
{
const ParamFlags switchAll = ParamFlags(PARAMFLAGS_SWITCH_VERTEX|PARAMFLAGS_SWITCH_FRAGMENT);
if ((flags & PARAMFLAGS_INIT_SINGLE) != 0)
return (flags & switchAll) == 0 ||
(flags & switchAll) == switchAll;
else
return true;
}
bool addRenderTest (TestCaseGroup& group, const string& namePrefix, const string& descPrefix,
int numIterations, ParamFlags flags, TestParams params)
{
ostringstream name;
ostringstream desc;
DE_ASSERT(areCaseParamFlagsValid(flags));
name << namePrefix;
desc << descPrefix;
params.initSingle = (flags & PARAMFLAGS_INIT_SINGLE) != 0;
params.switchVtx = (flags & PARAMFLAGS_SWITCH_VERTEX) != 0;
params.switchFrg = (flags & PARAMFLAGS_SWITCH_FRAGMENT) != 0;
name << (flags & PARAMFLAGS_INIT_SINGLE ? "single_program" : "separate_programs");
desc << (flags & PARAMFLAGS_INIT_SINGLE
? "Single program with two shaders"
: "Separate programs for each shader");
switch (flags & (PARAMFLAGS_SWITCH_FRAGMENT | PARAMFLAGS_SWITCH_VERTEX))
{
case 0:
break;
case PARAMFLAGS_SWITCH_FRAGMENT:
name << "_add_fragment";
desc << ", then add a fragment program";
break;
case PARAMFLAGS_SWITCH_VERTEX:
name << "_add_vertex";
desc << ", then add a vertex program";
break;
case PARAMFLAGS_SWITCH_FRAGMENT | PARAMFLAGS_SWITCH_VERTEX:
name << "_add_both";
desc << ", then add both vertex and shader programs";
break;
}
if (!paramsValid(params))
return false;
group.addChild(new SeparateShaderTest(group.getContext(), name.str(), desc.str(),
numIterations, params,
&SeparateShaderTest::testPipelineRendering));
return true;
}
void describeInterpolation (const string& stage, VaryingInterpolation qual,
ostringstream& name, ostringstream& desc)
{
DE_ASSERT(qual < VARYINGINTERPOLATION_RANDOM);
if (qual == VARYINGINTERPOLATION_DEFAULT)
{
desc << ", unqualified in " << stage << " shader";
return;
}
else
{
const string qualName = glu::getInterpolationName(getGluInterpolation(qual));
name << "_" << stage << "_" << qualName;
desc << ", qualified '" << qualName << "' in " << stage << " shader";
}
}
} // anonymous
TestCaseGroup* createSeparateShaderTests (Context& ctx)
{
TestParams defaultParams;
int numIterations = 4;
TestCaseGroup* group =
new TestCaseGroup(ctx, "separate_shader", "Separate shader tests");
defaultParams.useUniform = false;
defaultParams.initSingle = false;
defaultParams.switchVtx = false;
defaultParams.switchFrg = false;
defaultParams.useCreateHelper = false;
defaultParams.useProgramUniform = false;
defaultParams.useSameName = false;
defaultParams.varyings.count = 0;
defaultParams.varyings.type = glu::TYPE_INVALID;
defaultParams.varyings.binding = BINDING_NAME;
defaultParams.varyings.vtxInterp = VARYINGINTERPOLATION_LAST;
defaultParams.varyings.frgInterp = VARYINGINTERPOLATION_LAST;
TestCaseGroup* stagesGroup =
new TestCaseGroup(ctx, "pipeline", "Pipeline configuration tests");
group->addChild(stagesGroup);
for (deUint32 flags = 0; flags < PARAMFLAGS_LAST << 2; ++flags)
{
TestParams params = defaultParams;
ostringstream name;
ostringstream desc;
if (!areCaseParamFlagsValid(ParamFlags(flags & PARAMFLAGS_MASK)))
continue;
if (flags & (PARAMFLAGS_LAST << 1))
{
params.useSameName = true;
name << "same_";
desc << "Identically named ";
}
else
{
name << "different_";
desc << "Differently named ";
}
if (flags & PARAMFLAGS_LAST)
{
params.useUniform = true;
name << "uniform_";
desc << "uniforms, ";
}
else
{
name << "constant_";
desc << "constants, ";
}
addRenderTest(*stagesGroup, name.str(), desc.str(), numIterations,
ParamFlags(flags & PARAMFLAGS_MASK), params);
}
TestCaseGroup* programUniformGroup =
new TestCaseGroup(ctx, "program_uniform", "ProgramUniform tests");
group->addChild(programUniformGroup);
for (deUint32 flags = 0; flags < PARAMFLAGS_LAST; ++flags)
{
TestParams params = defaultParams;
if (!areCaseParamFlagsValid(ParamFlags(flags)))
continue;
params.useUniform = true;
params.useProgramUniform = true;
addRenderTest(*programUniformGroup, "", "", numIterations, ParamFlags(flags), params);
}
TestCaseGroup* createShaderProgramGroup =
new TestCaseGroup(ctx, "create_shader_program", "CreateShaderProgram tests");
group->addChild(createShaderProgramGroup);
for (deUint32 flags = 0; flags < PARAMFLAGS_LAST; ++flags)
{
TestParams params = defaultParams;
if (!areCaseParamFlagsValid(ParamFlags(flags)))
continue;
params.useCreateHelper = true;
addRenderTest(*createShaderProgramGroup, "", "", numIterations,
ParamFlags(flags), params);
}
TestCaseGroup* interfaceGroup =
new TestCaseGroup(ctx, "interface", "Shader interface compatibility tests");
group->addChild(interfaceGroup);
enum
{
NUM_INTERPOLATIONS = VARYINGINTERPOLATION_RANDOM, // VARYINGINTERPOLATION_RANDOM is one after last fully specified interpolation
INTERFACEFLAGS_LAST = BINDING_LAST * NUM_INTERPOLATIONS * NUM_INTERPOLATIONS
};
for (deUint32 flags = 0; flags < INTERFACEFLAGS_LAST; ++flags)
{
deUint32 tmpFlags = flags;
VaryingInterpolation frgInterp = VaryingInterpolation(tmpFlags % NUM_INTERPOLATIONS);
VaryingInterpolation vtxInterp = VaryingInterpolation((tmpFlags /= NUM_INTERPOLATIONS)
% NUM_INTERPOLATIONS);
BindingKind binding = BindingKind((tmpFlags /= NUM_INTERPOLATIONS)
% BINDING_LAST);
TestParams params = defaultParams;
ostringstream name;
ostringstream desc;
params.varyings.count = 1;
params.varyings.type = glu::TYPE_FLOAT;
params.varyings.binding = binding;
params.varyings.vtxInterp = vtxInterp;
params.varyings.frgInterp = frgInterp;
switch (binding)
{
case BINDING_LOCATION:
name << "same_location";
desc << "Varyings have same location, ";
break;
case BINDING_NAME:
name << "same_name";
desc << "Varyings have same name, ";
break;
default:
DE_FATAL("Impossible");
}
describeInterpolation("vertex", vtxInterp, name, desc);
describeInterpolation("fragment", frgInterp, name, desc);
if (!paramsValid(params))
continue;
interfaceGroup->addChild(
new SeparateShaderTest(ctx, name.str(), desc.str(), numIterations, params,
&SeparateShaderTest::testPipelineRendering));
}
deUint32 baseSeed = ctx.getTestContext().getCommandLine().getBaseSeed();
Random rnd (deStringHash("separate_shader.random") + baseSeed);
set<string> seen;
TestCaseGroup* randomGroup = new TestCaseGroup(
ctx, "random", "Random pipeline configuration tests");
group->addChild(randomGroup);
for (deUint32 i = 0; i < 128; ++i)
{
TestParams params;
string code;
deUint32 genIterations = 4096;
do
{
params = genParams(rnd.getUint32());
code = paramsCode(params);
} while (de::contains(seen, code) && --genIterations > 0);
seen.insert(code);
string name = de::toString(i); // Would be code but baseSeed can change
randomGroup->addChild(new SeparateShaderTest(
ctx, name, name, numIterations, params,
&SeparateShaderTest::testPipelineRendering));
}
TestCaseGroup* apiGroup =
new TestCaseGroup(ctx, "api", "Program pipeline API tests");
group->addChild(apiGroup);
{
// More or less random parameters. These shouldn't have much effect, so just
// do a single sample.
TestParams params = defaultParams;
params.useUniform = true;
apiGroup->addChild(new SeparateShaderTest(
ctx,
"current_program_priority",
"Test priority between current program and pipeline binding",
1, params, &SeparateShaderTest::testCurrentProgPriority));
apiGroup->addChild(new SeparateShaderTest(
ctx,
"active_program_uniform",
"Test that glUniform() affects a pipeline's active program",
1, params, &SeparateShaderTest::testActiveProgramUniform));
apiGroup->addChild(new SeparateShaderTest(
ctx,
"pipeline_programs",
"Test queries for programs in program pipeline stages",
1, params, &SeparateShaderTest::testPipelineQueryPrograms));
apiGroup->addChild(new SeparateShaderTest(
ctx,
"pipeline_active",
"Test query for active programs in a program pipeline",
1, params, &SeparateShaderTest::testPipelineQueryActive));
}
TestCaseGroup* interfaceMismatchGroup =
new TestCaseGroup(ctx, "validation", "Negative program pipeline interface matching");
group->addChild(interfaceMismatchGroup);
{
TestCaseGroup* es31Group = new TestCaseGroup(ctx, "es31", "GLSL ES 3.1 pipeline interface matching");
gls::ShaderLibrary shaderLibrary (ctx.getTestContext(), ctx.getRenderContext(), ctx.getContextInfo());
const std::vector<tcu::TestNode*> children = shaderLibrary.loadShaderFile("shaders/es31/separate_shader_validation.test");
for (int i = 0; i < (int)children.size(); i++)
es31Group->addChild(children[i]);
interfaceMismatchGroup->addChild(es31Group);
}
{
TestCaseGroup* es32Group = new TestCaseGroup(ctx, "es32", "GLSL ES 3.2 pipeline interface matching");
gls::ShaderLibrary shaderLibrary (ctx.getTestContext(), ctx.getRenderContext(), ctx.getContextInfo());
const std::vector<tcu::TestNode*> children = shaderLibrary.loadShaderFile("shaders/es32/separate_shader_validation.test");
for (int i = 0; i < (int)children.size(); i++)
es32Group->addChild(children[i]);
interfaceMismatchGroup->addChild(es32Group);
}
return group;
}
} // Functional
} // gles31
} // deqp