Google Git
Sign in
fuchsia / third_party / vulkan-cts / refs/heads/upstream/opengl-cts-4.6.1 / . / modules / gles31 / functional / es31fGeometryShaderTests.cpp
blob: 56cb16399f1abdf076bd3f5de21c1942ff5c6dbf [file] [log] [blame]
/*-------------------------------------------------------------------------
* 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 Geometry shader tests.
*//*--------------------------------------------------------------------*/
#include "es31fGeometryShaderTests.hpp"
#include "gluRenderContext.hpp"
#include "gluTextureUtil.hpp"
#include "gluObjectWrapper.hpp"
#include "gluPixelTransfer.hpp"
#include "gluContextInfo.hpp"
#include "gluCallLogWrapper.hpp"
#include "tcuRenderTarget.hpp"
#include "tcuTestLog.hpp"
#include "tcuVectorUtil.hpp"
#include "tcuImageCompare.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuStringTemplate.hpp"
#include "glsStateQueryUtil.hpp"
#include "gluStrUtil.hpp"
#include "deStringUtil.hpp"
#include "deUniquePtr.hpp"
#include "deMemory.h"
#include "sglrContext.hpp"
#include "sglrReferenceContext.hpp"
#include "sglrGLContext.hpp"
#include "sglrReferenceUtils.hpp"
#include "glwDefs.hpp"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include <algorithm>
using namespace glw;
namespace deqp
{
namespace gles31
{
namespace Functional
{
namespace
{
using namespace gls::StateQueryUtil;
const int TEST_CANVAS_SIZE = 256;
static const char *const s_commonShaderSourceVertex = "${GLSL_VERSION_DECL}\n"
"in highp vec4 a_position;\n"
"in highp vec4 a_color;\n"
"out highp vec4 v_geom_FragColor;\n"
"void main (void)\n"
"{\n"
" gl_Position = a_position;\n"
" gl_PointSize = 1.0;\n"
" v_geom_FragColor = a_color;\n"
"}\n";
static const char *const s_commonShaderSourceFragment = "${GLSL_VERSION_DECL}\n"
"layout(location = 0) out mediump vec4 fragColor;\n"
"in mediump vec4 v_frag_FragColor;\n"
"void main (void)\n"
"{\n"
" fragColor = v_frag_FragColor;\n"
"}\n";
static const char *const s_expandShaderSourceGeometryBody =
"in highp vec4 v_geom_FragColor[];\n"
"out highp vec4 v_frag_FragColor;\n"
"\n"
"void main (void)\n"
"{\n"
" const highp vec4 offset0 = vec4(-0.07, -0.01, 0.0, 0.0);\n"
" const highp vec4 offset1 = vec4( 0.03, -0.03, 0.0, 0.0);\n"
" const highp vec4 offset2 = vec4(-0.01, 0.08, 0.0, 0.0);\n"
" highp vec4 yoffset = float(gl_PrimitiveIDIn) * vec4(0.02, 0.1, 0.0, 0.0);\n"
"\n"
" for (highp int ndx = 0; ndx < gl_in.length(); ndx++)\n"
" {\n"
" gl_Position = gl_in[ndx].gl_Position + offset0 + yoffset;\n"
" gl_PrimitiveID = gl_PrimitiveIDIn;\n"
" v_frag_FragColor = v_geom_FragColor[ndx];\n"
" EmitVertex();\n"
"\n"
" gl_Position = gl_in[ndx].gl_Position + offset1 + yoffset;\n"
" gl_PrimitiveID = gl_PrimitiveIDIn;\n"
" v_frag_FragColor = v_geom_FragColor[ndx];\n"
" EmitVertex();\n"
"\n"
" gl_Position = gl_in[ndx].gl_Position + offset2 + yoffset;\n"
" gl_PrimitiveID = gl_PrimitiveIDIn;\n"
" v_frag_FragColor = v_geom_FragColor[ndx];\n"
" EmitVertex();\n"
" EndPrimitive();\n"
" }\n"
"}\n";
static std::string specializeShader(const std::string &shaderSource, const glu::ContextType &contextType)
{
const bool supportsES32orGL45 = glu::contextSupports(contextType, glu::ApiType::es(3, 2)) ||
glu::contextSupports(contextType, glu::ApiType::core(4, 5));
std::map<std::string, std::string> args;
args["GLSL_VERSION_DECL"] = glu::getGLSLVersionDeclaration(glu::getContextTypeGLSLVersion(contextType));
args["GLSL_EXT_GEOMETRY_SHADER"] = supportsES32orGL45 ? "" : "#extension GL_EXT_geometry_shader : require\n";
args["GLSL_OES_TEXTURE_STORAGE_MULTISAMPLE"] =
supportsES32orGL45 ? "" : "#extension GL_OES_texture_storage_multisample_2d_array : require\n";
return tcu::StringTemplate(shaderSource).specialize(args);
}
static bool checkSupport(Context &ctx)
{
auto contextType = ctx.getRenderContext().getType();
return contextSupports(contextType, glu::ApiType::es(3, 2)) ||
contextSupports(contextType, glu::ApiType::core(4, 5)) ||
ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader");
}
std::string inputTypeToGLString(rr::GeometryShaderInputType inputType)
{
switch (inputType)
{
case rr::GEOMETRYSHADERINPUTTYPE_POINTS:
return "points";
case rr::GEOMETRYSHADERINPUTTYPE_LINES:
return "lines";
case rr::GEOMETRYSHADERINPUTTYPE_LINES_ADJACENCY:
return "lines_adjacency";
case rr::GEOMETRYSHADERINPUTTYPE_TRIANGLES:
return "triangles";
case rr::GEOMETRYSHADERINPUTTYPE_TRIANGLES_ADJACENCY:
return "triangles_adjacency";
default:
DE_ASSERT(false);
return "error";
}
}
std::string outputTypeToGLString(rr::GeometryShaderOutputType outputType)
{
switch (outputType)
{
case rr::GEOMETRYSHADEROUTPUTTYPE_POINTS:
return "points";
case rr::GEOMETRYSHADEROUTPUTTYPE_LINE_STRIP:
return "line_strip";
case rr::GEOMETRYSHADEROUTPUTTYPE_TRIANGLE_STRIP:
return "triangle_strip";
default:
DE_ASSERT(false);
return "error";
}
}
std::string primitiveTypeToString(GLenum primitive)
{
switch (primitive)
{
case GL_POINTS:
return "points";
case GL_LINES:
return "lines";
case GL_LINE_LOOP:
return "line_loop";
case GL_LINE_STRIP:
return "line_strip";
case GL_LINES_ADJACENCY:
return "lines_adjacency";
case GL_LINE_STRIP_ADJACENCY:
return "line_strip_adjacency";
case GL_TRIANGLES:
return "triangles";
case GL_TRIANGLE_STRIP:
return "triangle_strip";
case GL_TRIANGLE_FAN:
return "triangle_fan";
case GL_TRIANGLES_ADJACENCY:
return "triangles_adjacency";
case GL_TRIANGLE_STRIP_ADJACENCY:
return "triangle_strip_adjacency";
default:
DE_ASSERT(false);
return "error";
}
}
struct OutputCountPatternSpec
{
OutputCountPatternSpec(int count);
OutputCountPatternSpec(int count0, int count1);
std::vector<int> pattern;
};
OutputCountPatternSpec::OutputCountPatternSpec(int count)
{
pattern.push_back(count);
}
OutputCountPatternSpec::OutputCountPatternSpec(int count0, int count1)
{
pattern.push_back(count0);
pattern.push_back(count1);
}
class VertexExpanderShader : public sglr::ShaderProgram
{
public:
VertexExpanderShader(const glu::ContextType &contextType, rr::GeometryShaderInputType inputType,
rr::GeometryShaderOutputType outputType);
void shadeVertices(const rr::VertexAttrib *inputs, rr::VertexPacket *const *packets, const int numPackets) const;
void shadeFragments(rr::FragmentPacket *packets, const int numPackets,
const rr::FragmentShadingContext &context) const;
void shadePrimitives(rr::GeometryEmitter &output, int verticesIn, const rr::PrimitivePacket *packets,
const int numPackets, int invocationID) const;
private:
size_t calcOutputVertices(rr::GeometryShaderInputType inputType) const;
std::string genGeometrySource(const glu::ContextType &contextType, rr::GeometryShaderInputType inputType,
rr::GeometryShaderOutputType outputType) const;
};
VertexExpanderShader::VertexExpanderShader(const glu::ContextType &contextType, rr::GeometryShaderInputType inputType,
rr::GeometryShaderOutputType outputType)
: sglr::ShaderProgram(sglr::pdec::ShaderProgramDeclaration()
<< sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexAttribute("a_color", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexToGeometryVarying(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::GeometryToFragmentVarying(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::FragmentOutput(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexSource(specializeShader(s_commonShaderSourceVertex, contextType))
<< sglr::pdec::FragmentSource(specializeShader(s_commonShaderSourceFragment, contextType))
<< sglr::pdec::GeometryShaderDeclaration(inputType, outputType, calcOutputVertices(inputType))
<< sglr::pdec::GeometrySource(genGeometrySource(contextType, inputType, outputType)))
{
}
void VertexExpanderShader::shadeVertices(const rr::VertexAttrib *inputs, rr::VertexPacket *const *packets,
const int numPackets) const
{
for (int ndx = 0; ndx < numPackets; ++ndx)
{
packets[ndx]->position =
rr::readVertexAttribFloat(inputs[0], packets[ndx]->instanceNdx, packets[ndx]->vertexNdx);
packets[ndx]->pointSize = 1.0f;
packets[ndx]->outputs[0] =
rr::readVertexAttribFloat(inputs[1], packets[ndx]->instanceNdx, packets[ndx]->vertexNdx);
}
}
void VertexExpanderShader::shadeFragments(rr::FragmentPacket *packets, const int numPackets,
const rr::FragmentShadingContext &context) const
{
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
rr::writeFragmentOutput(context, packetNdx, fragNdx, 0,
rr::readVarying<float>(packets[packetNdx], context, 0, fragNdx));
}
void VertexExpanderShader::shadePrimitives(rr::GeometryEmitter &output, int verticesIn,
const rr::PrimitivePacket *packets, const int numPackets,
int invocationID) const
{
DE_UNREF(invocationID);
for (int ndx = 0; ndx < numPackets; ++ndx)
for (int verticeNdx = 0; verticeNdx < verticesIn; ++verticeNdx)
{
const tcu::Vec4 offsets[] = {tcu::Vec4(-0.07f, -0.01f, 0.0f, 0.0f), tcu::Vec4(0.03f, -0.03f, 0.0f, 0.0f),
tcu::Vec4(-0.01f, 0.08f, 0.0f, 0.0f)};
const tcu::Vec4 yoffset = float(packets[ndx].primitiveIDIn) * tcu::Vec4(0.02f, 0.1f, 0, 0);
// Create new primitive at every input vertice
const rr::VertexPacket *vertex = packets[ndx].vertices[verticeNdx];
output.EmitVertex(vertex->position + offsets[0] + yoffset, vertex->pointSize, vertex->outputs,
packets[ndx].primitiveIDIn);
output.EmitVertex(vertex->position + offsets[1] + yoffset, vertex->pointSize, vertex->outputs,
packets[ndx].primitiveIDIn);
output.EmitVertex(vertex->position + offsets[2] + yoffset, vertex->pointSize, vertex->outputs,
packets[ndx].primitiveIDIn);
output.EndPrimitive();
}
}
size_t VertexExpanderShader::calcOutputVertices(rr::GeometryShaderInputType inputType) const
{
switch (inputType)
{
case rr::GEOMETRYSHADERINPUTTYPE_POINTS:
return 1 * 3;
case rr::GEOMETRYSHADERINPUTTYPE_LINES:
return 2 * 3;
case rr::GEOMETRYSHADERINPUTTYPE_LINES_ADJACENCY:
return 4 * 3;
case rr::GEOMETRYSHADERINPUTTYPE_TRIANGLES:
return 3 * 3;
case rr::GEOMETRYSHADERINPUTTYPE_TRIANGLES_ADJACENCY:
return 6 * 3;
default:
DE_ASSERT(false);
return 0;
}
}
std::string VertexExpanderShader::genGeometrySource(const glu::ContextType &contextType,
rr::GeometryShaderInputType inputType,
rr::GeometryShaderOutputType outputType) const
{
std::ostringstream str;
str << "${GLSL_VERSION_DECL}\n";
str << "${GLSL_EXT_GEOMETRY_SHADER}";
str << "layout(" << inputTypeToGLString(inputType) << ") in;\n";
str << "layout(" << outputTypeToGLString(outputType) << ", max_vertices = " << calcOutputVertices(inputType)
<< ") out;";
str << "\n";
str << s_expandShaderSourceGeometryBody;
return specializeShader(str.str(), contextType);
}
class VertexEmitterShader : public sglr::ShaderProgram
{
public:
VertexEmitterShader(const glu::ContextType &contextType, int emitCountA, int endCountA, int emitCountB,
int endCountB, rr::GeometryShaderOutputType outputType);
void shadeVertices(const rr::VertexAttrib *inputs, rr::VertexPacket *const *packets, const int numPackets) const;
void shadeFragments(rr::FragmentPacket *packets, const int numPackets,
const rr::FragmentShadingContext &context) const;
void shadePrimitives(rr::GeometryEmitter &output, int verticesIn, const rr::PrimitivePacket *packets,
const int numPackets, int invocationID) const;
private:
std::string genGeometrySource(const glu::ContextType &contextType, int emitCountA, int endCountA, int emitCountB,
int endCountB, rr::GeometryShaderOutputType outputType) const;
int m_emitCountA;
int m_endCountA;
int m_emitCountB;
int m_endCountB;
};
VertexEmitterShader::VertexEmitterShader(const glu::ContextType &contextType, int emitCountA, int endCountA,
int emitCountB, int endCountB, rr::GeometryShaderOutputType outputType)
: sglr::ShaderProgram(sglr::pdec::ShaderProgramDeclaration()
<< sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexAttribute("a_color", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexToGeometryVarying(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::GeometryToFragmentVarying(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::FragmentOutput(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexSource(specializeShader(s_commonShaderSourceVertex, contextType))
<< sglr::pdec::FragmentSource(specializeShader(s_commonShaderSourceFragment, contextType))
<< sglr::pdec::GeometryShaderDeclaration(rr::GEOMETRYSHADERINPUTTYPE_POINTS, outputType,
emitCountA + emitCountB)
<< sglr::pdec::GeometrySource(genGeometrySource(contextType, emitCountA, endCountA,
emitCountB, endCountB, outputType)))
, m_emitCountA(emitCountA)
, m_endCountA(endCountA)
, m_emitCountB(emitCountB)
, m_endCountB(endCountB)
{
}
void VertexEmitterShader::shadeVertices(const rr::VertexAttrib *inputs, rr::VertexPacket *const *packets,
const int numPackets) const
{
for (int ndx = 0; ndx < numPackets; ++ndx)
{
packets[ndx]->position =
rr::readVertexAttribFloat(inputs[0], packets[ndx]->instanceNdx, packets[ndx]->vertexNdx);
packets[ndx]->pointSize = 1.0f;
packets[ndx]->outputs[0] =
rr::readVertexAttribFloat(inputs[1], packets[ndx]->instanceNdx, packets[ndx]->vertexNdx);
}
}
void VertexEmitterShader::shadeFragments(rr::FragmentPacket *packets, const int numPackets,
const rr::FragmentShadingContext &context) const
{
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
rr::writeFragmentOutput(context, packetNdx, fragNdx, 0,
rr::readVarying<float>(packets[packetNdx], context, 0, fragNdx));
}
void VertexEmitterShader::shadePrimitives(rr::GeometryEmitter &output, int verticesIn,
const rr::PrimitivePacket *packets, const int numPackets,
int invocationID) const
{
DE_UNREF(verticesIn);
DE_UNREF(invocationID);
for (int ndx = 0; ndx < numPackets; ++ndx)
{
const tcu::Vec4 positions[] = {
tcu::Vec4(-0.5f, 0.5f, 0.0f, 0.0f), tcu::Vec4(0.0f, 0.1f, 0.0f, 0.0f), tcu::Vec4(0.5f, 0.5f, 0.0f, 0.0f),
tcu::Vec4(0.7f, -0.2f, 0.0f, 0.0f), tcu::Vec4(0.2f, 0.2f, 0.0f, 0.0f), tcu::Vec4(0.4f, -0.3f, 0.0f, 0.0f),
};
// Create new primitive at this point
const rr::VertexPacket *vertex = packets[ndx].vertices[0];
for (int i = 0; i < m_emitCountA; ++i)
output.EmitVertex(vertex->position + positions[i], vertex->pointSize, vertex->outputs,
packets[ndx].primitiveIDIn);
for (int i = 0; i < m_endCountA; ++i)
output.EndPrimitive();
for (int i = 0; i < m_emitCountB; ++i)
output.EmitVertex(vertex->position + positions[m_emitCountA + i], vertex->pointSize, vertex->outputs,
packets[ndx].primitiveIDIn);
for (int i = 0; i < m_endCountB; ++i)
output.EndPrimitive();
}
}
std::string VertexEmitterShader::genGeometrySource(const glu::ContextType &contextType, int emitCountA, int endCountA,
int emitCountB, int endCountB,
rr::GeometryShaderOutputType outputType) const
{
std::ostringstream str;
str << "${GLSL_VERSION_DECL}\n";
str << "${GLSL_EXT_GEOMETRY_SHADER}";
str << "layout(points) in;\n";
str << "layout(" << outputTypeToGLString(outputType) << ", max_vertices = " << (emitCountA + emitCountB)
<< ") out;";
str << "\n";
str << "in highp vec4 v_geom_FragColor[];\n"
"out highp vec4 v_frag_FragColor;\n"
"\n"
"void main (void)\n"
"{\n"
" const highp vec4 position0 = vec4(-0.5, 0.5, 0.0, 0.0);\n"
" const highp vec4 position1 = vec4( 0.0, 0.1, 0.0, 0.0);\n"
" const highp vec4 position2 = vec4( 0.5, 0.5, 0.0, 0.0);\n"
" const highp vec4 position3 = vec4( 0.7, -0.2, 0.0, 0.0);\n"
" const highp vec4 position4 = vec4( 0.2, 0.2, 0.0, 0.0);\n"
" const highp vec4 position5 = vec4( 0.4, -0.3, 0.0, 0.0);\n"
"\n";
for (int i = 0; i < emitCountA; ++i)
str << " gl_Position = gl_in[0].gl_Position + position" << i
<< ";\n"
" gl_PrimitiveID = gl_PrimitiveIDIn;\n"
" v_frag_FragColor = v_geom_FragColor[0];\n"
" EmitVertex();\n"
"\n";
for (int i = 0; i < endCountA; ++i)
str << " EndPrimitive();\n";
for (int i = 0; i < emitCountB; ++i)
str << " gl_Position = gl_in[0].gl_Position + position" << (emitCountA + i)
<< ";\n"
" gl_PrimitiveID = gl_PrimitiveIDIn;\n"
" v_frag_FragColor = v_geom_FragColor[0];\n"
" EmitVertex();\n"
"\n";
for (int i = 0; i < endCountB; ++i)
str << " EndPrimitive();\n";
str << "}\n";
return specializeShader(str.str(), contextType);
}
class VertexVaryingShader : public sglr::ShaderProgram
{
public:
VertexVaryingShader(const glu::ContextType &contextType, int vertexOut, int geometryOut);
void shadeVertices(const rr::VertexAttrib *inputs, rr::VertexPacket *const *packets, const int numPackets) const;
void shadeFragments(rr::FragmentPacket *packets, const int numPackets,
const rr::FragmentShadingContext &context) const;
void shadePrimitives(rr::GeometryEmitter &output, int verticesIn, const rr::PrimitivePacket *packets,
const int numPackets, int invocationID) const;
private:
static sglr::pdec::ShaderProgramDeclaration genProgramDeclaration(const glu::ContextType &contextType,
int vertexOut, int geometryOut);
const int m_vertexOut;
const int m_geometryOut;
};
VertexVaryingShader::VertexVaryingShader(const glu::ContextType &contextType, int vertexOut, int geometryOut)
: sglr::ShaderProgram(genProgramDeclaration(contextType, vertexOut, geometryOut))
, m_vertexOut(vertexOut)
, m_geometryOut(geometryOut)
{
}
void VertexVaryingShader::shadeVertices(const rr::VertexAttrib *inputs, rr::VertexPacket *const *packets,
const int numPackets) const
{
// vertex shader is no-op
if (m_vertexOut == -1)
return;
for (int ndx = 0; ndx < numPackets; ++ndx)
{
const tcu::Vec4 color =
rr::readVertexAttribFloat(inputs[1], packets[ndx]->instanceNdx, packets[ndx]->vertexNdx);
packets[ndx]->position =
rr::readVertexAttribFloat(inputs[0], packets[ndx]->instanceNdx, packets[ndx]->vertexNdx);
packets[ndx]->pointSize = 1.0f;
switch (m_vertexOut)
{
case 0:
break;
case 1:
packets[ndx]->outputs[0] = color;
break;
case 2:
packets[ndx]->outputs[0] = color * 0.5f;
packets[ndx]->outputs[1] = color.swizzle(2, 1, 0, 3) * 0.5f;
break;
default:
DE_ASSERT(false);
}
}
}
void VertexVaryingShader::shadeFragments(rr::FragmentPacket *packets, const int numPackets,
const rr::FragmentShadingContext &context) const
{
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
{
switch (m_geometryOut)
{
case 0:
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f));
break;
case 1:
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
rr::writeFragmentOutput(context, packetNdx, fragNdx, 0,
rr::readTriangleVarying<float>(packets[packetNdx], context, 0, fragNdx));
break;
case 2:
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
rr::writeFragmentOutput(
context, packetNdx, fragNdx, 0,
rr::readTriangleVarying<float>(packets[packetNdx], context, 0, fragNdx) +
rr::readTriangleVarying<float>(packets[packetNdx], context, 1, fragNdx).swizzle(1, 0, 2, 3));
break;
default:
DE_ASSERT(false);
}
}
}
void VertexVaryingShader::shadePrimitives(rr::GeometryEmitter &output, int verticesIn,
const rr::PrimitivePacket *packets, const int numPackets,
int invocationID) const
{
DE_UNREF(invocationID);
const tcu::Vec4 vertexOffset(-0.2f, -0.2f, 0, 0);
if (m_vertexOut == -1)
{
// vertex is a no-op
const tcu::Vec4 inputColor = tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f);
rr::GenericVec4 outputs[2];
// output color
switch (m_geometryOut)
{
case 0:
break;
case 1:
outputs[0] = inputColor;
break;
case 2:
outputs[0] = inputColor * 0.5f;
outputs[1] = inputColor.swizzle(1, 0, 2, 3) * 0.5f;
break;
default:
DE_ASSERT(false);
}
for (int ndx = 0; ndx < numPackets; ++ndx)
{
output.EmitVertex(tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f) + vertexOffset, 1.0f, outputs,
packets[ndx].primitiveIDIn);
output.EmitVertex(tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f) + vertexOffset, 1.0f, outputs,
packets[ndx].primitiveIDIn);
output.EmitVertex(tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f) + vertexOffset, 1.0f, outputs,
packets[ndx].primitiveIDIn);
output.EndPrimitive();
}
}
else
{
// vertex is not a no-op
for (int ndx = 0; ndx < numPackets; ++ndx)
{
for (int verticeNdx = 0; verticeNdx < verticesIn; ++verticeNdx)
{
tcu::Vec4 inputColor;
rr::GenericVec4 outputs[2];
// input color
switch (m_vertexOut)
{
case 0:
inputColor = tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f);
break;
case 1:
inputColor = packets[ndx].vertices[verticeNdx]->outputs[0].get<float>();
break;
case 2:
inputColor =
(packets[ndx].vertices[verticeNdx]->outputs[0].get<float>() * 0.5f) +
(packets[ndx].vertices[verticeNdx]->outputs[1].get<float>().swizzle(2, 1, 0, 3) * 0.5f);
break;
default:
DE_ASSERT(false);
}
// output color
switch (m_geometryOut)
{
case 0:
break;
case 1:
outputs[0] = inputColor;
break;
case 2:
outputs[0] = inputColor * 0.5f;
outputs[1] = inputColor.swizzle(1, 0, 2, 3) * 0.5f;
break;
default:
DE_ASSERT(false);
}
output.EmitVertex(packets[ndx].vertices[verticeNdx]->position + vertexOffset,
packets[ndx].vertices[verticeNdx]->pointSize, outputs, packets[ndx].primitiveIDIn);
}
output.EndPrimitive();
}
}
}
sglr::pdec::ShaderProgramDeclaration VertexVaryingShader::genProgramDeclaration(const glu::ContextType &contextType,
int vertexOut, int geometryOut)
{
sglr::pdec::ShaderProgramDeclaration decl;
std::ostringstream vertexSource;
std::ostringstream fragmentSource;
std::ostringstream geometrySource;
decl << sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexAttribute("a_color", rr::GENERICVECTYPE_FLOAT);
for (int i = 0; i < vertexOut; ++i)
decl << sglr::pdec::VertexToGeometryVarying(rr::GENERICVECTYPE_FLOAT);
for (int i = 0; i < geometryOut; ++i)
decl << sglr::pdec::GeometryToFragmentVarying(rr::GENERICVECTYPE_FLOAT);
decl << sglr::pdec::FragmentOutput(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::GeometryShaderDeclaration(rr::GEOMETRYSHADERINPUTTYPE_TRIANGLES,
rr::GEOMETRYSHADEROUTPUTTYPE_TRIANGLE_STRIP, 3);
// vertexSource
vertexSource << "${GLSL_VERSION_DECL}\n"
"in highp vec4 a_position;\n"
"in highp vec4 a_color;\n";
// no-op case?
if (vertexOut == -1)
{
vertexSource << "void main (void)\n"
"{\n"
"}\n";
}
else
{
for (int i = 0; i < vertexOut; ++i)
vertexSource << "out highp vec4 v_geom_" << i << ";\n";
vertexSource << "void main (void)\n"
"{\n"
"\tgl_Position = a_position;\n"
"\tgl_PointSize = 1.0;\n";
switch (vertexOut)
{
case 0:
break;
case 1:
vertexSource << "\tv_geom_0 = a_color;\n";
break;
case 2:
vertexSource << "\tv_geom_0 = a_color * 0.5;\n";
vertexSource << "\tv_geom_1 = a_color.zyxw * 0.5;\n";
break;
default:
DE_ASSERT(false);
}
vertexSource << "}\n";
}
// fragmentSource
fragmentSource << "${GLSL_VERSION_DECL}\n"
"layout(location = 0) out mediump vec4 fragColor;\n";
for (int i = 0; i < geometryOut; ++i)
fragmentSource << "in mediump vec4 v_frag_" << i << ";\n";
fragmentSource << "void main (void)\n"
"{\n";
switch (geometryOut)
{
case 0:
fragmentSource << "\tfragColor = vec4(1.0, 0.0, 0.0, 1.0);\n";
break;
case 1:
fragmentSource << "\tfragColor = v_frag_0;\n";
break;
case 2:
fragmentSource << "\tfragColor = v_frag_0 + v_frag_1.yxzw;\n";
break;
default:
DE_ASSERT(false);
}
fragmentSource << "}\n";
// geometrySource
geometrySource << "${GLSL_VERSION_DECL}\n"
"${GLSL_EXT_GEOMETRY_SHADER}"
"layout(triangles) in;\n"
"layout(triangle_strip, max_vertices = 3) out;\n";
for (int i = 0; i < vertexOut; ++i)
geometrySource << "in highp vec4 v_geom_" << i << "[];\n";
for (int i = 0; i < geometryOut; ++i)
geometrySource << "out highp vec4 v_frag_" << i << ";\n";
geometrySource << "void main (void)\n"
"{\n"
"\thighp vec4 offset = vec4(-0.2, -0.2, 0.0, 0.0);\n"
"\thighp vec4 inputColor;\n\n";
for (int vertexNdx = 0; vertexNdx < 3; ++vertexNdx)
{
if (vertexOut == -1)
{
// vertex is a no-op
geometrySource << "\tinputColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
"\tgl_Position = vec4("
<< ((vertexNdx == 0) ? ("0.0, 0.0") : ((vertexNdx == 1) ? ("1.0, 0.0") : ("1.0, 1.0")))
<< ", 0.0, 1.0) + offset;\n"
"\tgl_PrimitiveID = gl_PrimitiveIDIn;\n";
}
else
{
switch (vertexOut)
{
case 0:
geometrySource << "\tinputColor = vec4(1.0, 0.0, 0.0, 1.0);\n";
break;
case 1:
geometrySource << "\tinputColor = v_geom_0[" << vertexNdx << "];\n";
break;
case 2:
geometrySource << "\tinputColor = v_geom_0[" << vertexNdx << "] * 0.5 + v_geom_1[" << vertexNdx
<< "].zyxw * 0.5;\n";
break;
default:
DE_ASSERT(false);
}
geometrySource << "\tgl_Position = gl_in[" << vertexNdx
<< "].gl_Position + offset;\n"
"\tgl_PrimitiveID = gl_PrimitiveIDIn;\n";
}
switch (geometryOut)
{
case 0:
break;
case 1:
geometrySource << "\tv_frag_0 = inputColor;\n";
break;
case 2:
geometrySource << "\tv_frag_0 = inputColor * 0.5;\n";
geometrySource << "\tv_frag_1 = inputColor.yxzw * 0.5;\n";
break;
default:
DE_ASSERT(false);
}
geometrySource << "\tEmitVertex();\n\n";
}
geometrySource << "\tEndPrimitive();\n"
"}\n";
decl << sglr::pdec::VertexSource(specializeShader(vertexSource.str(), contextType))
<< sglr::pdec::FragmentSource(specializeShader(fragmentSource.str(), contextType))
<< sglr::pdec::GeometrySource(specializeShader(geometrySource.str(), contextType));
return decl;
}
class OutputCountShader : public sglr::ShaderProgram
{
public:
OutputCountShader(const glu::ContextType &contextType, const OutputCountPatternSpec &spec);
void shadeVertices(const rr::VertexAttrib *inputs, rr::VertexPacket *const *packets, const int numPackets) const;
void shadeFragments(rr::FragmentPacket *packets, const int numPackets,
const rr::FragmentShadingContext &context) const;
void shadePrimitives(rr::GeometryEmitter &output, int verticesIn, const rr::PrimitivePacket *packets,
const int numPackets, int invocationID) const;
private:
std::string genGeometrySource(const glu::ContextType &contextType, const OutputCountPatternSpec &spec) const;
size_t getPatternEmitCount(const OutputCountPatternSpec &spec) const;
const int m_patternLength;
const int m_patternMaxEmitCount;
const OutputCountPatternSpec m_spec;
};
OutputCountShader::OutputCountShader(const glu::ContextType &contextType, const OutputCountPatternSpec &spec)
: sglr::ShaderProgram(sglr::pdec::ShaderProgramDeclaration()
<< sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexAttribute("a_color", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexToGeometryVarying(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::GeometryToFragmentVarying(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::FragmentOutput(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexSource(specializeShader(s_commonShaderSourceVertex, contextType))
<< sglr::pdec::FragmentSource(specializeShader(s_commonShaderSourceFragment, contextType))
<< sglr::pdec::GeometryShaderDeclaration(rr::GEOMETRYSHADERINPUTTYPE_POINTS,
rr::GEOMETRYSHADEROUTPUTTYPE_TRIANGLE_STRIP,
getPatternEmitCount(spec))
<< sglr::pdec::GeometrySource(genGeometrySource(contextType, spec)))
, m_patternLength((int)spec.pattern.size())
, m_patternMaxEmitCount((int)getPatternEmitCount(spec))
, m_spec(spec)
{
}
void OutputCountShader::shadeVertices(const rr::VertexAttrib *inputs, rr::VertexPacket *const *packets,
const int numPackets) const
{
for (int ndx = 0; ndx < numPackets; ++ndx)
{
packets[ndx]->position =
rr::readVertexAttribFloat(inputs[0], packets[ndx]->instanceNdx, packets[ndx]->vertexNdx);
packets[ndx]->pointSize = 1.0f;
packets[ndx]->outputs[0] =
rr::readVertexAttribFloat(inputs[1], packets[ndx]->instanceNdx, packets[ndx]->vertexNdx);
}
}
void OutputCountShader::shadeFragments(rr::FragmentPacket *packets, const int numPackets,
const rr::FragmentShadingContext &context) const
{
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
rr::writeFragmentOutput(context, packetNdx, fragNdx, 0,
rr::readVarying<float>(packets[packetNdx], context, 0, fragNdx));
}
void OutputCountShader::shadePrimitives(rr::GeometryEmitter &output, int verticesIn, const rr::PrimitivePacket *packets,
const int numPackets, int invocationID) const
{
DE_UNREF(verticesIn);
DE_UNREF(invocationID);
const float rowHeight = 2.0f / (float)m_patternLength;
const float colWidth = 2.0f / (float)m_patternMaxEmitCount;
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
{
// Create triangle strip at this point
const rr::VertexPacket *vertex = packets[packetNdx].vertices[0];
const int emitCount = m_spec.pattern[packets[packetNdx].primitiveIDIn];
for (int ndx = 0; ndx < emitCount / 2; ++ndx)
{
output.EmitVertex(vertex->position + tcu::Vec4(2 * (float)ndx * colWidth, 0.0, 0.0, 0.0), vertex->pointSize,
vertex->outputs, packets[packetNdx].primitiveIDIn);
output.EmitVertex(vertex->position + tcu::Vec4(2 * (float)ndx * colWidth, rowHeight, 0.0, 0.0),
vertex->pointSize, vertex->outputs, packets[packetNdx].primitiveIDIn);
}
output.EndPrimitive();
}
}
std::string OutputCountShader::genGeometrySource(const glu::ContextType &contextType,
const OutputCountPatternSpec &spec) const
{
std::ostringstream str;
// draw row with a triangle strip, always make rectangles
for (int ndx = 0; ndx < (int)spec.pattern.size(); ++ndx)
DE_ASSERT(spec.pattern[ndx] % 2 == 0);
str << "${GLSL_VERSION_DECL}\n";
str << "${GLSL_EXT_GEOMETRY_SHADER}";
str << "layout(points) in;\n";
str << "layout(triangle_strip, max_vertices = " << getPatternEmitCount(spec) << ") out;";
str << "\n";
str << "in highp vec4 v_geom_FragColor[];\n"
"out highp vec4 v_frag_FragColor;\n"
"\n"
"void main (void)\n"
"{\n"
" const highp float rowHeight = 2.0 / float("
<< spec.pattern.size()
<< ");\n"
" const highp float colWidth = 2.0 / float("
<< getPatternEmitCount(spec)
<< ");\n"
"\n";
str << " highp int emitCount = ";
for (int ndx = 0; ndx < (int)spec.pattern.size() - 1; ++ndx)
str << "(gl_PrimitiveIDIn == " << ndx << ") ? (" << spec.pattern[ndx] << ") : (";
str << spec.pattern[(int)spec.pattern.size() - 1] << ((spec.pattern.size() == 1) ? ("") : (")")) << ";\n";
str << " for (highp int ndx = 0; ndx < emitCount / 2; ndx++)\n"
" {\n"
" gl_Position = gl_in[0].gl_Position + vec4(float(ndx) * 2.0 * colWidth, 0.0, 0.0, 0.0);\n"
" v_frag_FragColor = v_geom_FragColor[0];\n"
" EmitVertex();\n"
"\n"
" gl_Position = gl_in[0].gl_Position + vec4(float(ndx) * 2.0 * colWidth, rowHeight, 0.0, 0.0);\n"
" v_frag_FragColor = v_geom_FragColor[0];\n"
" EmitVertex();\n"
" }\n"
"}\n";
return specializeShader(str.str(), contextType);
}
size_t OutputCountShader::getPatternEmitCount(const OutputCountPatternSpec &spec) const
{
return *std::max_element(spec.pattern.begin(), spec.pattern.end());
}
class BuiltinVariableShader : public sglr::ShaderProgram
{
public:
enum VariableTest
{
TEST_POINT_SIZE = 0,
TEST_PRIMITIVE_ID_IN,
TEST_PRIMITIVE_ID,
TEST_LAST
};
BuiltinVariableShader(const glu::ContextType &contextType, VariableTest test);
void shadeVertices(const rr::VertexAttrib *inputs, rr::VertexPacket *const *packets, const int numPackets) const;
void shadeFragments(rr::FragmentPacket *packets, const int numPackets,
const rr::FragmentShadingContext &context) const;
void shadePrimitives(rr::GeometryEmitter &output, int verticesIn, const rr::PrimitivePacket *packets,
const int numPackets, int invocationID) const;
static const char *getTestAttributeName(VariableTest test);
private:
std::string genGeometrySource(const glu::ContextType &contextType, VariableTest test) const;
std::string genVertexSource(const glu::ContextType &contextType, VariableTest test) const;
std::string genFragmentSource(const glu::ContextType &contextType, VariableTest test) const;
const VariableTest m_test;
};
BuiltinVariableShader::BuiltinVariableShader(const glu::ContextType &contextType, VariableTest test)
: sglr::ShaderProgram(sglr::pdec::ShaderProgramDeclaration()
<< sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexAttribute(getTestAttributeName(test), rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexToGeometryVarying(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::GeometryToFragmentVarying(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::FragmentOutput(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexSource(genVertexSource(contextType, test))
<< sglr::pdec::FragmentSource(genFragmentSource(contextType, test))
<< sglr::pdec::GeometryShaderDeclaration(rr::GEOMETRYSHADERINPUTTYPE_POINTS,
((test == TEST_POINT_SIZE) ?
(rr::GEOMETRYSHADEROUTPUTTYPE_POINTS) :
(rr::GEOMETRYSHADEROUTPUTTYPE_TRIANGLE_STRIP)),
((test == TEST_POINT_SIZE) ? (1) : (3)))
<< sglr::pdec::GeometrySource(genGeometrySource(contextType, test)))
, m_test(test)
{
}
void BuiltinVariableShader::shadeVertices(const rr::VertexAttrib *inputs, rr::VertexPacket *const *packets,
const int numPackets) const
{
for (int ndx = 0; ndx < numPackets; ++ndx)
{
packets[ndx]->position =
rr::readVertexAttribFloat(inputs[0], packets[ndx]->instanceNdx, packets[ndx]->vertexNdx);
packets[ndx]->pointSize = 1.0f;
packets[ndx]->outputs[0] =
rr::readVertexAttribFloat(inputs[1], packets[ndx]->instanceNdx, packets[ndx]->vertexNdx);
}
}
void BuiltinVariableShader::shadeFragments(rr::FragmentPacket *packets, const int numPackets,
const rr::FragmentShadingContext &context) const
{
const tcu::Vec4 red = tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f);
const tcu::Vec4 green = tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f);
const tcu::Vec4 blue = tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f);
const tcu::Vec4 yellow = tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f);
const tcu::Vec4 colors[4] = {yellow, red, green, blue};
if (m_test == TEST_POINT_SIZE || m_test == TEST_PRIMITIVE_ID_IN)
{
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
rr::writeFragmentOutput(context, packetNdx, fragNdx, 0,
rr::readVarying<float>(packets[packetNdx], context, 0, fragNdx));
}
else if (m_test == TEST_PRIMITIVE_ID)
{
const tcu::Vec4 color = colors[context.primitiveID % 4];
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, color);
}
else
DE_ASSERT(false);
}
void BuiltinVariableShader::shadePrimitives(rr::GeometryEmitter &output, int verticesIn,
const rr::PrimitivePacket *packets, const int numPackets,
int invocationID) const
{
DE_UNREF(verticesIn);
DE_UNREF(invocationID);
const tcu::Vec4 red = tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f);
const tcu::Vec4 green = tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f);
const tcu::Vec4 blue = tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f);
const tcu::Vec4 yellow = tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f);
const tcu::Vec4 colors[4] = {red, green, blue, yellow};
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
{
const rr::VertexPacket *vertex = packets[packetNdx].vertices[0];
if (m_test == TEST_POINT_SIZE)
{
rr::GenericVec4 fragColor;
const float pointSize = vertex->outputs[0].get<float>().x() + 1.0f;
fragColor = tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f);
output.EmitVertex(vertex->position, pointSize, &fragColor, packets[packetNdx].primitiveIDIn);
}
else if (m_test == TEST_PRIMITIVE_ID_IN)
{
rr::GenericVec4 fragColor;
fragColor = colors[packets[packetNdx].primitiveIDIn % 4];
output.EmitVertex(vertex->position + tcu::Vec4(0.05f, 0.0f, 0.0f, 0.0f), 1.0f, &fragColor,
packets[packetNdx].primitiveIDIn);
output.EmitVertex(vertex->position - tcu::Vec4(0.05f, 0.0f, 0.0f, 0.0f), 1.0f, &fragColor,
packets[packetNdx].primitiveIDIn);
output.EmitVertex(vertex->position + tcu::Vec4(0.0f, 0.05f, 0.0f, 0.0f), 1.0f, &fragColor,
packets[packetNdx].primitiveIDIn);
}
else if (m_test == TEST_PRIMITIVE_ID)
{
const int primitiveID = (int)deFloatFloor(vertex->outputs[0].get<float>().x()) + 3;
output.EmitVertex(vertex->position + tcu::Vec4(0.05f, 0.0f, 0.0f, 0.0f), 1.0f, vertex->outputs,
primitiveID);
output.EmitVertex(vertex->position - tcu::Vec4(0.05f, 0.0f, 0.0f, 0.0f), 1.0f, vertex->outputs,
primitiveID);
output.EmitVertex(vertex->position + tcu::Vec4(0.0f, 0.05f, 0.0f, 0.0f), 1.0f, vertex->outputs,
primitiveID);
}
else
DE_ASSERT(false);
output.EndPrimitive();
}
}
const char *BuiltinVariableShader::getTestAttributeName(VariableTest test)
{
switch (test)
{
case TEST_POINT_SIZE:
return "a_pointSize";
case TEST_PRIMITIVE_ID_IN:
return "";
case TEST_PRIMITIVE_ID:
return "a_primitiveID";
default:
DE_ASSERT(false);
return "";
}
}
std::string BuiltinVariableShader::genGeometrySource(const glu::ContextType &contextType, VariableTest test) const
{
std::ostringstream buf;
buf << "${GLSL_VERSION_DECL}\n"
"${GLSL_EXT_GEOMETRY_SHADER}";
const bool supportsGL45 = glu::contextSupports(contextType, glu::ApiType::core(4, 5));
/* GL_EXT_geometry_point_size not available on desktop GLSL. */
if (!supportsGL45 && test == TEST_POINT_SIZE)
buf << "#extension GL_EXT_geometry_point_size : require\n";
buf << "layout(points) in;\n";
if (test == TEST_POINT_SIZE)
buf << "layout(points, max_vertices = 1) out;\n";
else
buf << "layout(triangle_strip, max_vertices = 3) out;\n";
if (test == TEST_POINT_SIZE)
buf << "in highp vec4 v_geom_pointSize[];\n";
else if (test == TEST_PRIMITIVE_ID)
buf << "in highp vec4 v_geom_primitiveID[];\n";
if (test != TEST_PRIMITIVE_ID)
buf << "out highp vec4 v_frag_FragColor;\n";
buf << "\n"
"void main (void)\n"
"{\n";
if (test == TEST_POINT_SIZE)
{
buf << " gl_Position = gl_in[0].gl_Position;\n"
" gl_PointSize = v_geom_pointSize[0].x + 1.0;\n"
" v_frag_FragColor = vec4(1.0, 1.0, 1.0, 1.0);\n"
" EmitVertex();\n";
}
else if (test == TEST_PRIMITIVE_ID_IN)
{
buf << " const highp vec4 red = vec4(1.0, 0.0, 0.0, 1.0);\n"
" const highp vec4 green = vec4(0.0, 1.0, 0.0, 1.0);\n"
" const highp vec4 blue = vec4(0.0, 0.0, 1.0, 1.0);\n"
" const highp vec4 yellow = vec4(1.0, 1.0, 0.0, 1.0);\n"
" const highp vec4 colors[4] = vec4[4](red, green, blue, yellow);\n"
"\n"
" gl_Position = gl_in[0].gl_Position + vec4(0.05, 0.0, 0.0, 0.0);\n"
" v_frag_FragColor = colors[gl_PrimitiveIDIn % 4];\n"
" EmitVertex();\n"
"\n"
" gl_Position = gl_in[0].gl_Position - vec4(0.05, 0.0, 0.0, 0.0);\n"
" v_frag_FragColor = colors[gl_PrimitiveIDIn % 4];\n"
" EmitVertex();\n"
"\n"
" gl_Position = gl_in[0].gl_Position + vec4(0.0, 0.05, 0.0, 0.0);\n"
" v_frag_FragColor = colors[gl_PrimitiveIDIn % 4];\n"
" EmitVertex();\n";
}
else if (test == TEST_PRIMITIVE_ID)
{
buf << " gl_Position = gl_in[0].gl_Position + vec4(0.05, 0.0, 0.0, 0.0);\n"
" gl_PrimitiveID = int(floor(v_geom_primitiveID[0].x)) + 3;\n"
" EmitVertex();\n"
"\n"
" gl_Position = gl_in[0].gl_Position - vec4(0.05, 0.0, 0.0, 0.0);\n"
" gl_PrimitiveID = int(floor(v_geom_primitiveID[0].x)) + 3;\n"
" EmitVertex();\n"
"\n"
" gl_Position = gl_in[0].gl_Position + vec4(0.0, 0.05, 0.0, 0.0);\n"
" gl_PrimitiveID = int(floor(v_geom_primitiveID[0].x)) + 3;\n"
" EmitVertex();\n"
"\n";
}
else
DE_ASSERT(false);
buf << "}\n";
return specializeShader(buf.str(), contextType);
}
std::string BuiltinVariableShader::genVertexSource(const glu::ContextType &contextType, VariableTest test) const
{
std::ostringstream buf;
buf << "${GLSL_VERSION_DECL}\n"
"in highp vec4 a_position;\n";
if (test == TEST_POINT_SIZE)
buf << "in highp vec4 a_pointSize;\n";
else if (test == TEST_PRIMITIVE_ID)
buf << "in highp vec4 a_primitiveID;\n";
if (test == TEST_POINT_SIZE)
buf << "out highp vec4 v_geom_pointSize;\n";
else if (test == TEST_PRIMITIVE_ID)
buf << "out highp vec4 v_geom_primitiveID;\n";
buf << "void main (void)\n"
"{\n"
" gl_Position = a_position;\n"
" gl_PointSize = 1.0;\n";
if (test == TEST_POINT_SIZE)
buf << " v_geom_pointSize = a_pointSize;\n";
else if (test == TEST_PRIMITIVE_ID)
buf << " v_geom_primitiveID = a_primitiveID;\n";
buf << "}\n";
return specializeShader(buf.str(), contextType);
}
std::string BuiltinVariableShader::genFragmentSource(const glu::ContextType &contextType, VariableTest test) const
{
std::ostringstream buf;
if (test == TEST_POINT_SIZE || test == TEST_PRIMITIVE_ID_IN)
return specializeShader(s_commonShaderSourceFragment, contextType);
else if (test == TEST_PRIMITIVE_ID)
{
buf << "${GLSL_VERSION_DECL}\n"
"${GLSL_EXT_GEOMETRY_SHADER}"
"layout(location = 0) out mediump vec4 fragColor;\n"
"void main (void)\n"
"{\n"
" const mediump vec4 red = vec4(1.0, 0.0, 0.0, 1.0);\n"
" const mediump vec4 green = vec4(0.0, 1.0, 0.0, 1.0);\n"
" const mediump vec4 blue = vec4(0.0, 0.0, 1.0, 1.0);\n"
" const mediump vec4 yellow = vec4(1.0, 1.0, 0.0, 1.0);\n"
" const mediump vec4 colors[4] = vec4[4](yellow, red, green, blue);\n"
" fragColor = colors[gl_PrimitiveID % 4];\n"
"}\n";
return specializeShader(buf.str(), contextType);
}
else
{
DE_ASSERT(false);
return DE_NULL;
}
}
class VaryingOutputCountShader : public sglr::ShaderProgram
{
public:
enum VaryingSource
{
READ_ATTRIBUTE = 0,
READ_UNIFORM,
READ_TEXTURE,
READ_LAST
};
enum
{
EMIT_COUNT_VERTEX_0 = 6,
EMIT_COUNT_VERTEX_1 = 0,
EMIT_COUNT_VERTEX_2 = -1,
EMIT_COUNT_VERTEX_3 = 10,
};
VaryingOutputCountShader(const glu::ContextType &contextType, VaryingSource source, int maxEmitCount,
bool instanced);
void shadeVertices(const rr::VertexAttrib *inputs, rr::VertexPacket *const *packets, const int numPackets) const;
void shadeFragments(rr::FragmentPacket *packets, const int numPackets,
const rr::FragmentShadingContext &context) const;
void shadePrimitives(rr::GeometryEmitter &output, int verticesIn, const rr::PrimitivePacket *packets,
const int numPackets, int invocationID) const;
static const char *getAttributeName(VaryingSource test);
private:
static std::string genGeometrySource(const glu::ContextType &contextType, VaryingSource test, int maxEmitCount,
bool instanced);
static std::string genVertexSource(const glu::ContextType &contextType, VaryingSource test);
const VaryingSource m_test;
const sglr::UniformSlot &m_sampler;
const sglr::UniformSlot &m_emitCount;
const int m_maxEmitCount;
const bool m_instanced;
};
VaryingOutputCountShader::VaryingOutputCountShader(const glu::ContextType &contextType, VaryingSource source,
int maxEmitCount, bool instanced)
: sglr::ShaderProgram(
sglr::pdec::ShaderProgramDeclaration()
<< sglr::pdec::Uniform("u_sampler", glu::TYPE_SAMPLER_2D)
<< sglr::pdec::Uniform("u_emitCount", glu::TYPE_INT_VEC4)
<< sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexAttribute(getAttributeName(source), rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexToGeometryVarying(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::GeometryToFragmentVarying(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::FragmentOutput(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexSource(genVertexSource(contextType, source))
<< sglr::pdec::FragmentSource(specializeShader(s_commonShaderSourceFragment, contextType))
<< sglr::pdec::GeometryShaderDeclaration(rr::GEOMETRYSHADERINPUTTYPE_POINTS,
rr::GEOMETRYSHADEROUTPUTTYPE_TRIANGLE_STRIP, maxEmitCount,
(instanced) ? (4) : (1))
<< sglr::pdec::GeometrySource(genGeometrySource(contextType, source, maxEmitCount, instanced)))
, m_test(source)
, m_sampler(getUniformByName("u_sampler"))
, m_emitCount(getUniformByName("u_emitCount"))
, m_maxEmitCount(maxEmitCount)
, m_instanced(instanced)
{
}
void VaryingOutputCountShader::shadeVertices(const rr::VertexAttrib *inputs, rr::VertexPacket *const *packets,
const int numPackets) const
{
for (int ndx = 0; ndx < numPackets; ++ndx)
{
packets[ndx]->position =
rr::readVertexAttribFloat(inputs[0], packets[ndx]->instanceNdx, packets[ndx]->vertexNdx);
packets[ndx]->outputs[0] =
rr::readVertexAttribFloat(inputs[1], packets[ndx]->instanceNdx, packets[ndx]->vertexNdx);
}
}
void VaryingOutputCountShader::shadeFragments(rr::FragmentPacket *packets, const int numPackets,
const rr::FragmentShadingContext &context) const
{
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
rr::writeFragmentOutput(context, packetNdx, fragNdx, 0,
rr::readVarying<float>(packets[packetNdx], context, 0, fragNdx));
}
void VaryingOutputCountShader::shadePrimitives(rr::GeometryEmitter &output, int verticesIn,
const rr::PrimitivePacket *packets, const int numPackets,
int invocationID) const
{
DE_UNREF(verticesIn);
const tcu::Vec4 red = tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f);
const tcu::Vec4 green = tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f);
const tcu::Vec4 blue = tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f);
const tcu::Vec4 yellow = tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f);
const tcu::Vec4 colors[4] = {red, green, blue, yellow};
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
{
const rr::VertexPacket *vertex = packets[packetNdx].vertices[0];
int emitCount = 0;
tcu::Vec4 color = tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f);
if (m_test == READ_ATTRIBUTE)
{
emitCount = (int)vertex->outputs[0].get<float>()[(m_instanced) ? (invocationID) : (0)];
color = tcu::Vec4((emitCount < 10) ? (0.0f) : (1.0f), (emitCount > 10) ? (0.0f) : (1.0f), 1.0f, 1.0f);
}
else if (m_test == READ_UNIFORM)
{
const int primitiveNdx = (m_instanced) ? (invocationID) : ((int)vertex->outputs[0].get<float>().x());
DE_ASSERT(primitiveNdx >= 0);
DE_ASSERT(primitiveNdx < 4);
emitCount = m_emitCount.value.i4[primitiveNdx];
color = colors[primitiveNdx];
}
else if (m_test == READ_TEXTURE)
{
const int primitiveNdx = (m_instanced) ? (invocationID) : ((int)vertex->outputs[0].get<float>().x());
const tcu::Vec2 texCoord = tcu::Vec2(1.0f / 8.0f + (float)primitiveNdx / 4.0f, 0.5f);
const tcu::Vec4 texColor = m_sampler.sampler.tex2D->sample(texCoord.x(), texCoord.y(), 0.0f);
DE_ASSERT(primitiveNdx >= 0);
DE_ASSERT(primitiveNdx < 4);
color = colors[primitiveNdx];
emitCount = 0;
if (texColor.x() > 0.0f)
emitCount += (EMIT_COUNT_VERTEX_0 == -1) ? (m_maxEmitCount) : (EMIT_COUNT_VERTEX_0);
if (texColor.y() > 0.0f)
emitCount += (EMIT_COUNT_VERTEX_1 == -1) ? (m_maxEmitCount) : (EMIT_COUNT_VERTEX_1);
if (texColor.z() > 0.0f)
emitCount += (EMIT_COUNT_VERTEX_2 == -1) ? (m_maxEmitCount) : (EMIT_COUNT_VERTEX_2);
if (texColor.w() > 0.0f)
emitCount += (EMIT_COUNT_VERTEX_3 == -1) ? (m_maxEmitCount) : (EMIT_COUNT_VERTEX_3);
}
else
DE_ASSERT(false);
for (int ndx = 0; ndx < (int)emitCount / 2; ++ndx)
{
const float angle = (float(ndx) + 0.5f) / float(emitCount / 2) * 3.142f;
const tcu::Vec4 basePosition =
(m_instanced) ?
(vertex->position +
tcu::Vec4(deFloatCos(float(invocationID)), deFloatSin(float(invocationID)), 0.0f, 0.0f) * 0.5f) :
(vertex->position);
const tcu::Vec4 position0 =
basePosition + tcu::Vec4(deFloatCos(angle), deFloatSin(angle), 0.0f, 0.0f) * 0.15f;
const tcu::Vec4 position1 =
basePosition + tcu::Vec4(deFloatCos(angle), -deFloatSin(angle), 0.0f, 0.0f) * 0.15f;
rr::GenericVec4 fragColor;
fragColor = color;
output.EmitVertex(position0, 0.0f, &fragColor, packets[packetNdx].primitiveIDIn);
output.EmitVertex(position1, 0.0f, &fragColor, packets[packetNdx].primitiveIDIn);
}
output.EndPrimitive();
}
}
const char *VaryingOutputCountShader::getAttributeName(VaryingSource test)
{
switch (test)
{
case READ_ATTRIBUTE:
return "a_emitCount";
case READ_UNIFORM:
return "a_vertexNdx";
case READ_TEXTURE:
return "a_vertexNdx";
default:
DE_ASSERT(false);
return "";
}
}
std::string VaryingOutputCountShader::genGeometrySource(const glu::ContextType &contextType, VaryingSource test,
int maxEmitCount, bool instanced)
{
std::ostringstream buf;
buf << "${GLSL_VERSION_DECL}\n"
"${GLSL_EXT_GEOMETRY_SHADER}"
"layout(points"
<< ((instanced) ? (",invocations=4") : (""))
<< ") in;\n"
"layout(triangle_strip, max_vertices = "
<< maxEmitCount << ") out;\n";
if (test == READ_ATTRIBUTE)
buf << "in highp vec4 v_geom_emitCount[];\n";
else if (test == READ_UNIFORM)
buf << "in highp vec4 v_geom_vertexNdx[];\n"
"uniform highp ivec4 u_emitCount;\n";
else
buf << "in highp vec4 v_geom_vertexNdx[];\n"
"uniform highp sampler2D u_sampler;\n";
buf << "out highp vec4 v_frag_FragColor;\n"
"\n"
"void main (void)\n"
"{\n";
// emit count
if (test == READ_ATTRIBUTE)
{
buf << " highp vec4 attrEmitCounts = v_geom_emitCount[0];\n"
" mediump int emitCount = int(attrEmitCounts["
<< ((instanced) ? ("gl_InvocationID") : ("0")) << "]);\n";
}
else if (test == READ_UNIFORM)
{
buf << " mediump int primitiveNdx = " << ((instanced) ? ("gl_InvocationID") : ("int(v_geom_vertexNdx[0].x)"))
<< ";\n"
" mediump int emitCount = u_emitCount[primitiveNdx];\n";
}
else if (test == READ_TEXTURE)
{
buf << " highp float primitiveNdx = "
<< ((instanced) ? ("float(gl_InvocationID)") : ("v_geom_vertexNdx[0].x"))
<< ";\n"
" highp vec2 texCoord = vec2(1.0 / 8.0 + primitiveNdx / 4.0, 0.5);\n"
" highp vec4 texColor = texture(u_sampler, texCoord);\n"
" mediump int emitCount = 0;\n"
" if (texColor.x > 0.0)\n"
" emitCount += "
<< ((EMIT_COUNT_VERTEX_0 == -1) ? (maxEmitCount) : (EMIT_COUNT_VERTEX_0))
<< ";\n"
" if (texColor.y > 0.0)\n"
" emitCount += "
<< ((EMIT_COUNT_VERTEX_1 == -1) ? (maxEmitCount) : (EMIT_COUNT_VERTEX_1))
<< ";\n"
" if (texColor.z > 0.0)\n"
" emitCount += "
<< ((EMIT_COUNT_VERTEX_2 == -1) ? (maxEmitCount) : (EMIT_COUNT_VERTEX_2))
<< ";\n"
" if (texColor.w > 0.0)\n"
" emitCount += "
<< ((EMIT_COUNT_VERTEX_3 == -1) ? (maxEmitCount) : (EMIT_COUNT_VERTEX_3)) << ";\n";
}
else
DE_ASSERT(false);
// color
if (test == READ_ATTRIBUTE)
{
// We don't want color to be compile time constant
buf << " highp vec4 color = vec4((emitCount < 10) ? (0.0) : (1.0), (emitCount > 10) ? (0.0) : (1.0), 1.0, "
"1.0);\n";
}
else if (test == READ_UNIFORM || test == READ_TEXTURE)
{
buf << "\n"
" const highp vec4 red = vec4(1.0, 0.0, 0.0, 1.0);\n"
" const highp vec4 green = vec4(0.0, 1.0, 0.0, 1.0);\n"
" const highp vec4 blue = vec4(0.0, 0.0, 1.0, 1.0);\n"
" const highp vec4 yellow = vec4(1.0, 1.0, 0.0, 1.0);\n"
" const highp vec4 colors[4] = vec4[4](red, green, blue, yellow);\n"
" highp vec4 color = colors[int(primitiveNdx)];\n";
}
else
DE_ASSERT(false);
buf << "\n"
" highp vec4 basePos = "
<< ((instanced) ? ("gl_in[0].gl_Position + 0.5 * vec4(cos(float(gl_InvocationID)), "
"sin(float(gl_InvocationID)), 0.0, 0.0)") :
("gl_in[0].gl_Position"))
<< ";\n"
" for (mediump int i = 0; i < emitCount / 2; i++)\n"
" {\n"
" highp float angle = (float(i) + 0.5) / float(emitCount / 2) * 3.142;\n"
" gl_Position = basePos + vec4(cos(angle), sin(angle), 0.0, 0.0) * 0.15;\n"
" v_frag_FragColor = color;\n"
" EmitVertex();\n"
" gl_Position = basePos + vec4(cos(angle), -sin(angle), 0.0, 0.0) * 0.15;\n"
" v_frag_FragColor = color;\n"
" EmitVertex();\n"
" }"
"}\n";
return specializeShader(buf.str(), contextType);
}
std::string VaryingOutputCountShader::genVertexSource(const glu::ContextType &contextType, VaryingSource test)
{
std::ostringstream buf;
buf << "${GLSL_VERSION_DECL}\n"
"in highp vec4 a_position;\n";
if (test == READ_ATTRIBUTE)
{
buf << "in highp vec4 a_emitCount;\n";
buf << "out highp vec4 v_geom_emitCount;\n";
}
else if (test == READ_UNIFORM || test == READ_TEXTURE)
{
buf << "in highp vec4 a_vertexNdx;\n";
buf << "out highp vec4 v_geom_vertexNdx;\n";
}
buf << "void main (void)\n"
"{\n"
" gl_Position = a_position;\n";
if (test == READ_ATTRIBUTE)
buf << " v_geom_emitCount = a_emitCount;\n";
else if (test == READ_UNIFORM || test == READ_TEXTURE)
buf << " v_geom_vertexNdx = a_vertexNdx;\n";
buf << "}\n";
return specializeShader(buf.str(), contextType);
}
class InvocationCountShader : public sglr::ShaderProgram
{
public:
enum OutputCase
{
CASE_FIXED_OUTPUT_COUNTS = 0,
CASE_DIFFERENT_OUTPUT_COUNTS,
CASE_LAST
};
InvocationCountShader(const glu::ContextType &contextType, int numInvocations, OutputCase testCase);
private:
void shadeVertices(const rr::VertexAttrib *inputs, rr::VertexPacket *const *packets, const int numPackets) const;
void shadeFragments(rr::FragmentPacket *packets, const int numPackets,
const rr::FragmentShadingContext &context) const;
void shadePrimitives(rr::GeometryEmitter &output, int verticesIn, const rr::PrimitivePacket *packets,
const int numPackets, int invocationID) const;
static std::string genGeometrySource(const glu::ContextType &contextType, int numInvocations, OutputCase testCase);
static size_t getNumVertices(int numInvocations, OutputCase testCase);
const int m_numInvocations;
const OutputCase m_testCase;
};
InvocationCountShader::InvocationCountShader(const glu::ContextType &contextType, int numInvocations,
OutputCase testCase)
: sglr::ShaderProgram(sglr::pdec::ShaderProgramDeclaration()
<< sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexAttribute("a_color", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexToGeometryVarying(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::GeometryToFragmentVarying(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::FragmentOutput(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexSource(specializeShader(s_commonShaderSourceVertex, contextType))
<< sglr::pdec::FragmentSource(specializeShader(s_commonShaderSourceFragment, contextType))
<< sglr::pdec::GeometryShaderDeclaration(
rr::GEOMETRYSHADERINPUTTYPE_POINTS, rr::GEOMETRYSHADEROUTPUTTYPE_TRIANGLE_STRIP,
getNumVertices(numInvocations, testCase), numInvocations)
<< sglr::pdec::GeometrySource(genGeometrySource(contextType, numInvocations, testCase)))
, m_numInvocations(numInvocations)
, m_testCase(testCase)
{
}
void InvocationCountShader::shadeVertices(const rr::VertexAttrib *inputs, rr::VertexPacket *const *packets,
const int numPackets) const
{
for (int ndx = 0; ndx < numPackets; ++ndx)
{
packets[ndx]->position =
rr::readVertexAttribFloat(inputs[0], packets[ndx]->instanceNdx, packets[ndx]->vertexNdx);
packets[ndx]->outputs[0] =
rr::readVertexAttribFloat(inputs[1], packets[ndx]->instanceNdx, packets[ndx]->vertexNdx);
}
}
void InvocationCountShader::shadeFragments(rr::FragmentPacket *packets, const int numPackets,
const rr::FragmentShadingContext &context) const
{
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
rr::writeFragmentOutput(context, packetNdx, fragNdx, 0,
rr::readVarying<float>(packets[packetNdx], context, 0, fragNdx));
}
void InvocationCountShader::shadePrimitives(rr::GeometryEmitter &output, int verticesIn,
const rr::PrimitivePacket *packets, const int numPackets,
int invocationID) const
{
DE_UNREF(verticesIn);
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
{
const float l_angle = float(invocationID) / float(m_numInvocations) * 5.5f;
const float l_radius = 0.6f;
const rr::VertexPacket *vertex = packets[packetNdx].vertices[0];
if (m_testCase == CASE_FIXED_OUTPUT_COUNTS)
{
const tcu::Vec4 position0 =
vertex->position +
tcu::Vec4(deFloatCos(l_angle) * (l_radius - 0.1f), deFloatSin(l_angle) * (l_radius - 0.1f), 0.0f, 0.0f);
const tcu::Vec4 position1 = vertex->position + tcu::Vec4(deFloatCos(l_angle + 0.1f) * l_radius,
deFloatSin(l_angle + 0.1f) * l_radius, 0.0f, 0.0f);
const tcu::Vec4 position2 = vertex->position + tcu::Vec4(deFloatCos(l_angle - 0.1f) * l_radius,
deFloatSin(l_angle - 0.1f) * l_radius, 0.0f, 0.0f);
rr::GenericVec4 tipColor;
rr::GenericVec4 baseColor;
tipColor = tcu::Vec4(1.0, 1.0, 0.0, 1.0) * packets[packetNdx].vertices[0]->outputs[0].get<float>();
baseColor = tcu::Vec4(1.0, 0.0, 0.0, 1.0) * packets[packetNdx].vertices[0]->outputs[0].get<float>();
output.EmitVertex(position0, 0.0f, &tipColor, packets[packetNdx].primitiveIDIn);
output.EmitVertex(position1, 0.0f, &baseColor, packets[packetNdx].primitiveIDIn);
output.EmitVertex(position2, 0.0f, &baseColor, packets[packetNdx].primitiveIDIn);
output.EndPrimitive();
}
else if (m_testCase == CASE_DIFFERENT_OUTPUT_COUNTS)
{
const tcu::Vec4 color =
tcu::Vec4(float(invocationID % 2), (((invocationID / 2) % 2) == 0) ? (1.0f) : (0.0f), 1.0f, 1.0f);
const tcu::Vec4 basePosition = vertex->position + tcu::Vec4(deFloatCos(l_angle) * l_radius,
deFloatSin(l_angle) * l_radius, 0.0f, 0.0f);
const int numNgonVtx = invocationID + 3;
rr::GenericVec4 outColor;
outColor = color;
for (int ndx = 0; ndx + 1 < numNgonVtx; ndx += 2)
{
const float subAngle = (float(ndx) + 1.0f) / float(numNgonVtx) * 3.141f;
output.EmitVertex(basePosition +
tcu::Vec4(deFloatCos(subAngle) * 0.1f, deFloatSin(subAngle) * 0.1f, 0.0f, 0.0f),
0.0f, &outColor, packets[packetNdx].primitiveIDIn);
output.EmitVertex(basePosition +
tcu::Vec4(deFloatCos(subAngle) * 0.1f, deFloatSin(subAngle) * -0.1f, 0.0f, 0.0f),
0.0f, &outColor, packets[packetNdx].primitiveIDIn);
}
if ((numNgonVtx % 2) == 1)
output.EmitVertex(basePosition + tcu::Vec4(-0.1f, 0.0f, 0.0f, 0.0f), 0.0f, &outColor,
packets[packetNdx].primitiveIDIn);
output.EndPrimitive();
}
}
}
std::string InvocationCountShader::genGeometrySource(const glu::ContextType &contextType, int numInvocations,
OutputCase testCase)
{
const int maxVertices = (int)getNumVertices(numInvocations, testCase);
std::ostringstream buf;
buf << "${GLSL_VERSION_DECL}\n"
"${GLSL_EXT_GEOMETRY_SHADER}"
"layout(points, invocations = "
<< numInvocations
<< ") in;\n"
"layout(triangle_strip, max_vertices = "
<< maxVertices
<< ") out;\n"
"\n"
"in highp vec4 v_geom_FragColor[];\n"
"out highp vec4 v_frag_FragColor;\n"
"\n"
"void main ()\n"
"{\n"
" highp float l_angle = float(gl_InvocationID) / float("
<< numInvocations
<< ") * 5.5;\n"
" highp float l_radius = 0.6;\n"
"\n";
if (testCase == CASE_FIXED_OUTPUT_COUNTS)
{
buf << " v_frag_FragColor = vec4(1.0, 1.0, 0.0, 1.0) * v_geom_FragColor[0];\n"
" gl_Position = gl_in[0].gl_Position + vec4(cos(l_angle) * (l_radius - 0.1), sin(l_angle) * "
"(l_radius - 0.1), 0.0, 0.0);\n"
" EmitVertex();\n"
"\n"
" v_frag_FragColor = vec4(1.0, 0.0, 0.0, 1.0) * v_geom_FragColor[0];\n"
" gl_Position = gl_in[0].gl_Position + vec4(cos(l_angle+0.1) * l_radius, sin(l_angle+0.1) * "
"l_radius, 0.0, 0.0);\n"
" EmitVertex();\n"
"\n"
" v_frag_FragColor = vec4(1.0, 0.0, 0.0, 1.0) * v_geom_FragColor[0];\n"
" gl_Position = gl_in[0].gl_Position + vec4(cos(l_angle-0.1) * l_radius, sin(l_angle-0.1) * "
"l_radius, 0.0, 0.0);\n"
" EmitVertex();\n";
}
else if (testCase == CASE_DIFFERENT_OUTPUT_COUNTS)
{
buf << " highp vec4 l_color = vec4(float(gl_InvocationID % 2), (((gl_InvocationID / 2) % 2) == 0) ? (1.0) : "
"(0.0), 1.0, 1.0);\n"
" highp vec4 basePosition = gl_in[0].gl_Position + vec4(cos(l_angle) * l_radius, sin(l_angle) * "
"l_radius, 0.0, 0.0);\n"
" mediump int numNgonVtx = gl_InvocationID + 3;\n"
"\n"
" for (int ndx = 0; ndx + 1 < numNgonVtx; ndx += 2)\n"
" {\n"
" highp float sub_angle = (float(ndx) + 1.0) / float(numNgonVtx) * 3.141;\n"
"\n"
" v_frag_FragColor = l_color;\n"
" gl_Position = basePosition + vec4(cos(sub_angle) * 0.1, sin(sub_angle) * 0.1, 0.0, 0.0);\n"
" EmitVertex();\n"
"\n"
" v_frag_FragColor = l_color;\n"
" gl_Position = basePosition + vec4(cos(sub_angle) * 0.1, sin(sub_angle) * -0.1, 0.0, 0.0);\n"
" EmitVertex();\n"
" }\n"
" if ((numNgonVtx % 2) == 1)\n"
" {\n"
" v_frag_FragColor = l_color;\n"
" gl_Position = basePosition + vec4(-0.1, 0.0, 0.0, 0.0);\n"
" EmitVertex();\n"
" }\n";
}
else
DE_ASSERT(false);
buf << "}\n";
return specializeShader(buf.str(), contextType);
}
size_t InvocationCountShader::getNumVertices(int numInvocations, OutputCase testCase)
{
switch (testCase)
{
case CASE_FIXED_OUTPUT_COUNTS:
return 3;
case CASE_DIFFERENT_OUTPUT_COUNTS:
return (size_t)(2 + numInvocations);
default:
DE_ASSERT(false);
return 0;
}
}
class InstancedExpansionShader : public sglr::ShaderProgram
{
public:
InstancedExpansionShader(const glu::ContextType &contextType, int numInvocations);
private:
void shadeVertices(const rr::VertexAttrib *inputs, rr::VertexPacket *const *packets, const int numPackets) const;
void shadeFragments(rr::FragmentPacket *packets, const int numPackets,
const rr::FragmentShadingContext &context) const;
void shadePrimitives(rr::GeometryEmitter &output, int verticesIn, const rr::PrimitivePacket *packets,
const int numPackets, int invocationID) const;
static std::string genVertexSource(const glu::ContextType &contextType);
static std::string genFragmentSource(const glu::ContextType &contextType);
static std::string genGeometrySource(const glu::ContextType &contextType, int numInvocations);
const int m_numInvocations;
};
InstancedExpansionShader::InstancedExpansionShader(const glu::ContextType &contextType, int numInvocations)
: sglr::ShaderProgram(sglr::pdec::ShaderProgramDeclaration()
<< sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexAttribute("a_offset", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::FragmentOutput(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexSource(genVertexSource(contextType))
<< sglr::pdec::FragmentSource(genFragmentSource(contextType))
<< sglr::pdec::GeometryShaderDeclaration(rr::GEOMETRYSHADERINPUTTYPE_POINTS,
rr::GEOMETRYSHADEROUTPUTTYPE_TRIANGLE_STRIP, 4,
numInvocations)
<< sglr::pdec::GeometrySource(genGeometrySource(contextType, numInvocations)))
, m_numInvocations(numInvocations)
{
}
void InstancedExpansionShader::shadeVertices(const rr::VertexAttrib *inputs, rr::VertexPacket *const *packets,
const int numPackets) const
{
for (int ndx = 0; ndx < numPackets; ++ndx)
{
packets[ndx]->position =
rr::readVertexAttribFloat(inputs[0], packets[ndx]->instanceNdx, packets[ndx]->vertexNdx) +
rr::readVertexAttribFloat(inputs[1], packets[ndx]->instanceNdx, packets[ndx]->vertexNdx);
}
}
void InstancedExpansionShader::shadeFragments(rr::FragmentPacket *packets, const int numPackets,
const rr::FragmentShadingContext &context) const
{
DE_UNREF(packets);
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f));
}
void InstancedExpansionShader::shadePrimitives(rr::GeometryEmitter &output, int verticesIn,
const rr::PrimitivePacket *packets, const int numPackets,
int invocationID) const
{
DE_UNREF(verticesIn);
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
{
const rr::VertexPacket *vertex = packets[packetNdx].vertices[0];
const tcu::Vec4 basePosition = vertex->position;
const float phase = float(invocationID) / float(m_numInvocations) * 6.3f;
const tcu::Vec4 centerPosition =
basePosition + tcu::Vec4(deFloatCos(phase), deFloatSin(phase), 0.0f, 0.0f) * 0.1f;
output.EmitVertex(centerPosition + tcu::Vec4(0.0f, -0.1f, 0.0f, 0.0f), 0.0f, DE_NULL,
packets[packetNdx].primitiveIDIn);
output.EmitVertex(centerPosition + tcu::Vec4(-0.05f, 0.0f, 0.0f, 0.0f), 0.0f, DE_NULL,
packets[packetNdx].primitiveIDIn);
output.EmitVertex(centerPosition + tcu::Vec4(0.05f, 0.0f, 0.0f, 0.0f), 0.0f, DE_NULL,
packets[packetNdx].primitiveIDIn);
output.EndPrimitive();
}
}
std::string InstancedExpansionShader::genVertexSource(const glu::ContextType &contextType)
{
std::ostringstream buf;
buf << "${GLSL_VERSION_DECL}\n"
"in highp vec4 a_position;\n"
"in highp vec4 a_offset;\n"
"void main (void)\n"
"{\n"
" gl_Position = a_position + a_offset;\n"
"}\n";
return specializeShader(buf.str(), contextType);
}
std::string InstancedExpansionShader::genFragmentSource(const glu::ContextType &contextType)
{
std::ostringstream buf;
buf << "${GLSL_VERSION_DECL}\n"
"layout(location = 0) out mediump vec4 fragColor;\n"
"void main (void)\n"
"{\n"
" fragColor = vec4(1.0, 1.0, 1.0, 1.0);\n"
"}\n";
return specializeShader(buf.str(), contextType);
}
std::string InstancedExpansionShader::genGeometrySource(const glu::ContextType &contextType, int numInvocations)
{
std::ostringstream buf;
buf << "${GLSL_VERSION_DECL}\n"
"${GLSL_EXT_GEOMETRY_SHADER}"
"layout(points,invocations="
<< numInvocations
<< ") in;\n"
"layout(triangle_strip, max_vertices = 3) out;\n"
"\n"
"void main (void)\n"
"{\n"
" highp vec4 basePosition = gl_in[0].gl_Position;\n"
" highp float phase = float(gl_InvocationID) / float("
<< numInvocations
<< ") * 6.3;\n"
" highp vec4 centerPosition = basePosition + 0.1 * vec4(cos(phase), sin(phase), 0.0, 0.0);\n"
"\n"
" gl_Position = centerPosition + vec4( 0.00, -0.1, 0.0, 0.0);\n"
" EmitVertex();\n"
" gl_Position = centerPosition + vec4(-0.05, 0.0, 0.0, 0.0);\n"
" EmitVertex();\n"
" gl_Position = centerPosition + vec4( 0.05, 0.0, 0.0, 0.0);\n"
" EmitVertex();\n"
"}\n";
return specializeShader(buf.str(), contextType);
}
class GeometryShaderRenderTest : public TestCase
{
public:
enum Flag
{
FLAG_DRAW_INSTANCED = 1,
FLAG_USE_INDICES = 2,
FLAG_USE_RESTART_INDEX = 4,
};
GeometryShaderRenderTest(Context &context, const char *name, const char *desc, GLenum inputPrimitives,
GLenum outputPrimitives, const char *dataAttributeName, int flags = 0);
virtual ~GeometryShaderRenderTest(void);
void init(void);
void deinit(void);
IterateResult iterate(void);
bool compare(void);
virtual sglr::ShaderProgram &getProgram(void) = 0;
protected:
virtual void genVertexAttribData(void);
void renderWithContext(sglr::Context &ctx, sglr::ShaderProgram &program, tcu::Surface &dstSurface);
virtual void preRender(sglr::Context &ctx, GLuint programID);
virtual void postRender(sglr::Context &ctx, GLuint programID);
int m_numDrawVertices;
int m_numDrawInstances;
int m_vertexAttrDivisor;
const GLenum m_inputPrimitives;
const GLenum m_outputPrimitives;
const char *const m_dataAttributeName;
const int m_flags;
tcu::IVec2 m_viewportSize;
int m_interationCount;
tcu::Surface *m_glResult;
tcu::Surface *m_refResult;
sglr::ReferenceContextBuffers *m_refBuffers;
sglr::ReferenceContext *m_refContext;
sglr::Context *m_glContext;
std::vector<tcu::Vec4> m_vertexPosData;
std::vector<tcu::Vec4> m_vertexAttrData;
std::vector<uint16_t> m_indices;
};
GeometryShaderRenderTest::GeometryShaderRenderTest(Context &context, const char *name, const char *desc,
GLenum inputPrimitives, GLenum outputPrimitives,
const char *dataAttributeName, int flags)
: TestCase(context, name, desc)
, m_numDrawVertices(0)
, m_numDrawInstances(0)
, m_vertexAttrDivisor(0)
, m_inputPrimitives(inputPrimitives)
, m_outputPrimitives(outputPrimitives)
, m_dataAttributeName(dataAttributeName)
, m_flags(flags)
, m_viewportSize(TEST_CANVAS_SIZE, TEST_CANVAS_SIZE)
, m_interationCount(0)
, m_glResult(DE_NULL)
, m_refResult(DE_NULL)
, m_refBuffers(DE_NULL)
, m_refContext(DE_NULL)
, m_glContext(DE_NULL)
{
// Disallow instanced drawElements
DE_ASSERT(((m_flags & FLAG_DRAW_INSTANCED) == 0) || ((m_flags & FLAG_USE_INDICES) == 0));
// Disallow restart without indices
DE_ASSERT(!(((m_flags & FLAG_USE_RESTART_INDEX) != 0) && ((m_flags & FLAG_USE_INDICES) == 0)));
}
GeometryShaderRenderTest::~GeometryShaderRenderTest(void)
{
deinit();
}
void GeometryShaderRenderTest::init(void)
{
// requirements
if (!checkSupport(m_context))
TCU_THROW(NotSupportedError, "Tests require GL_EXT_geometry_shader extension or higher context version.");
// gen resources
{
sglr::ReferenceContextLimits limits;
m_glResult = new tcu::Surface(m_viewportSize.x(), m_viewportSize.y());
m_refResult = new tcu::Surface(m_viewportSize.x(), m_viewportSize.y());
m_refBuffers = new sglr::ReferenceContextBuffers(m_context.getRenderTarget().getPixelFormat(),
m_context.getRenderTarget().getDepthBits(), 0,
m_viewportSize.x(), m_viewportSize.y());
m_refContext = new sglr::ReferenceContext(limits, m_refBuffers->getColorbuffer(),
m_refBuffers->getDepthbuffer(), m_refBuffers->getStencilbuffer());
m_glContext = new sglr::GLContext(m_context.getRenderContext(), m_testCtx.getLog(),
sglr::GLCONTEXT_LOG_CALLS | sglr::GLCONTEXT_LOG_PROGRAMS,
tcu::IVec4(0, 0, m_viewportSize.x(), m_viewportSize.y()));
}
}
void GeometryShaderRenderTest::deinit(void)
{
delete m_glResult;
delete m_refResult;
m_glResult = DE_NULL;
m_refResult = DE_NULL;
delete m_refContext;
delete m_glContext;
delete m_refBuffers;
m_refBuffers = DE_NULL;
m_refContext = DE_NULL;
m_glContext = DE_NULL;
}
tcu::TestCase::IterateResult GeometryShaderRenderTest::iterate(void)
{
// init() must be called
DE_ASSERT(m_glContext);
DE_ASSERT(m_refContext);
const int iteration = m_interationCount++;
if (iteration == 0)
{
// Check requirements
const int width = m_context.getRenderTarget().getWidth();
const int height = m_context.getRenderTarget().getHeight();
if (width < m_viewportSize.x() || height < m_viewportSize.y())
throw tcu::NotSupportedError(std::string("Render target size must be at least ") +
de::toString(m_viewportSize.x()) + "x" + de::toString(m_viewportSize.y()));
// Gen data
genVertexAttribData();
return CONTINUE;
}
else if (iteration == 1)
{
// Render
sglr::ShaderProgram &program = getProgram();
renderWithContext(*m_glContext, program, *m_glResult);
renderWithContext(*m_refContext, program, *m_refResult);
return CONTINUE;
}
else
{
if (compare())
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
else
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
return STOP;
}
}
bool GeometryShaderRenderTest::compare(void)
{
using tcu::TestLog;
if (m_context.getRenderTarget().getNumSamples() > 1)
{
return tcu::fuzzyCompare(m_testCtx.getLog(), "Compare Results", "Compare Results", m_refResult->getAccess(),
m_glResult->getAccess(), 0.02f, tcu::COMPARE_LOG_RESULT);
}
else
{
tcu::Surface errorMask(m_viewportSize.x(), m_viewportSize.y());
const tcu::RGBA green(0, 255, 0, 255);
const tcu::RGBA red(255, 0, 0, 255);
const int colorComponentThreshold = 20;
bool testResult = true;
for (int x = 0; x < m_viewportSize.x(); ++x)
for (int y = 0; y < m_viewportSize.y(); ++y)
{
if (x == 0 || y == 0 || x + 1 == m_viewportSize.x() || y + 1 == m_viewportSize.y())
{
// Mark edge pixels as correct since their neighbourhood is undefined
errorMask.setPixel(x, y, green);
}
else
{
const tcu::RGBA refcolor = m_refResult->getPixel(x, y);
bool found = false;
// Got to find similar pixel near this pixel (3x3 kernel)
for (int dx = -1; dx <= 1; ++dx)
for (int dy = -1; dy <= 1; ++dy)
{
const tcu::RGBA testColor = m_glResult->getPixel(x + dx, y + dy);
const tcu::IVec4 colDiff = tcu::abs(testColor.toIVec() - refcolor.toIVec());
const int maxColDiff =
de::max(de::max(colDiff.x(), colDiff.y()), colDiff.z()); // check RGB channels
if (maxColDiff <= colorComponentThreshold)
found = true;
}
if (!found)
testResult = false;
errorMask.setPixel(x, y, (found) ? (green) : (red));
}
}
if (testResult)
{
m_testCtx.getLog() << TestLog::ImageSet("Compare result", "Result of rendering")
<< TestLog::Image("Result", "Result", *m_glResult) << TestLog::EndImageSet;
m_testCtx.getLog() << TestLog::Message << "Image compare ok." << TestLog::EndMessage;
}
else
{
m_testCtx.getLog() << TestLog::ImageSet("Compare result", "Result of rendering")
<< TestLog::Image("Result", "Result", *m_glResult)
<< TestLog::Image("Reference", "Reference", *m_refResult)
<< TestLog::Image("ErrorMask", "Error mask", errorMask) << TestLog::EndImageSet;
m_testCtx.getLog() << TestLog::Message << "Image compare failed." << TestLog::EndMessage;
}
return testResult;
}
}
void GeometryShaderRenderTest::genVertexAttribData(void)
{
// Create 1 X 2 grid in triangle strip adjacent - order
const float scale = 0.3f;
const tcu::Vec4 offset(-0.5f, -0.2f, 0.0f, 1.0f);
m_vertexPosData.resize(12);
m_vertexPosData[0] = tcu::Vec4(0, 0, 0.0f, 0.0f) * scale + offset;
m_vertexPosData[1] = tcu::Vec4(-1, -1, 0.0f, 0.0f) * scale + offset;
m_vertexPosData[2] = tcu::Vec4(0, -1, 0.0f, 0.0f) * scale + offset;
m_vertexPosData[3] = tcu::Vec4(1, 1, 0.0f, 0.0f) * scale + offset;
m_vertexPosData[4] = tcu::Vec4(1, 0, 0.0f, 0.0f) * scale + offset;
m_vertexPosData[5] = tcu::Vec4(0, -2, 0.0f, 0.0f) * scale + offset;
m_vertexPosData[6] = tcu::Vec4(1, -1, 0.0f, 0.0f) * scale + offset;
m_vertexPosData[7] = tcu::Vec4(2, 1, 0.0f, 0.0f) * scale + offset;
m_vertexPosData[8] = tcu::Vec4(2, 0, 0.0f, 0.0f) * scale + offset;
m_vertexPosData[9] = tcu::Vec4(1, -2, 0.0f, 0.0f) * scale + offset;
m_vertexPosData[10] = tcu::Vec4(2, -1, 0.0f, 0.0f) * scale + offset;
m_vertexPosData[11] = tcu::Vec4(3, 0, 0.0f, 0.0f) * scale + offset;
// Red and white
m_vertexAttrData.resize(12);
for (int i = 0; i < 12; ++i)
m_vertexAttrData[i] = (i % 2 == 0) ? tcu::Vec4(1, 1, 1, 1) : tcu::Vec4(1, 0, 0, 1);
m_numDrawVertices = 12;
}
void GeometryShaderRenderTest::renderWithContext(sglr::Context &ctx, sglr::ShaderProgram &program,
tcu::Surface &dstSurface)
{
#define CHECK_GL_CTX_ERRORS() glu::checkError(ctx.getError(), DE_NULL, __FILE__, __LINE__)
const GLuint programId = ctx.createProgram(&program);
const GLint attrPosLoc = ctx.getAttribLocation(programId, "a_position");
const GLint attrColLoc = ctx.getAttribLocation(programId, m_dataAttributeName);
GLuint vaoId = 0;
GLuint vertexPosBuf = 0;
GLuint vertexAttrBuf = 0;
GLuint elementArrayBuf = 0;
ctx.genVertexArrays(1, &vaoId);
ctx.bindVertexArray(vaoId);
if (attrPosLoc != -1)
{
ctx.genBuffers(1, &vertexPosBuf);
ctx.bindBuffer(GL_ARRAY_BUFFER, vertexPosBuf);
ctx.bufferData(GL_ARRAY_BUFFER, m_vertexPosData.size() * sizeof(tcu::Vec4), &m_vertexPosData[0],
GL_STATIC_DRAW);
ctx.vertexAttribPointer(attrPosLoc, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL);
ctx.enableVertexAttribArray(attrPosLoc);
}
if (attrColLoc != -1)
{
ctx.genBuffers(1, &vertexAttrBuf);
ctx.bindBuffer(GL_ARRAY_BUFFER, vertexAttrBuf);
ctx.bufferData(GL_ARRAY_BUFFER, m_vertexAttrData.size() * sizeof(tcu::Vec4), &m_vertexAttrData[0],
GL_STATIC_DRAW);
ctx.vertexAttribPointer(attrColLoc, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL);
ctx.enableVertexAttribArray(attrColLoc);
if (m_vertexAttrDivisor)
ctx.vertexAttribDivisor(attrColLoc, m_vertexAttrDivisor);
}
if (m_flags & FLAG_USE_INDICES)
{
ctx.genBuffers(1, &elementArrayBuf);
ctx.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementArrayBuf);
ctx.bufferData(GL_ELEMENT_ARRAY_BUFFER, m_indices.size() * sizeof(uint16_t), &m_indices[0], GL_STATIC_DRAW);
}
ctx.clearColor(0, 0, 0, 1);
ctx.clear(GL_COLOR_BUFFER_BIT);
ctx.viewport(0, 0, m_viewportSize.x(), m_viewportSize.y());
CHECK_GL_CTX_ERRORS();
ctx.useProgram(programId);
CHECK_GL_CTX_ERRORS();
preRender(ctx, programId);
CHECK_GL_CTX_ERRORS();
if (m_flags & FLAG_USE_RESTART_INDEX)
{
ctx.enable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
CHECK_GL_CTX_ERRORS();
}
if (m_flags & FLAG_USE_INDICES)
ctx.drawElements(m_inputPrimitives, m_numDrawVertices, GL_UNSIGNED_SHORT, DE_NULL);
else if (m_flags & FLAG_DRAW_INSTANCED)
ctx.drawArraysInstanced(m_inputPrimitives, 0, m_numDrawVertices, m_numDrawInstances);
else
ctx.drawArrays(m_inputPrimitives, 0, m_numDrawVertices);
CHECK_GL_CTX_ERRORS();
if (m_flags & FLAG_USE_RESTART_INDEX)
{
ctx.disable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
CHECK_GL_CTX_ERRORS();
}
postRender(ctx, programId);
CHECK_GL_CTX_ERRORS();
ctx.useProgram(0);
if (attrPosLoc != -1)
ctx.disableVertexAttribArray(attrPosLoc);
if (attrColLoc != -1)
ctx.disableVertexAttribArray(attrColLoc);
if (vertexPosBuf)
ctx.deleteBuffers(1, &vertexPosBuf);
if (vertexAttrBuf)
ctx.deleteBuffers(1, &vertexAttrBuf);
if (elementArrayBuf)
ctx.deleteBuffers(1, &elementArrayBuf);
ctx.deleteVertexArrays(1, &vaoId);
CHECK_GL_CTX_ERRORS();
ctx.finish();
ctx.readPixels(dstSurface, 0, 0, m_viewportSize.x(), m_viewportSize.y());
#undef CHECK_GL_CTX_ERRORS
}
void GeometryShaderRenderTest::preRender(sglr::Context &ctx, GLuint programID)
{
DE_UNREF(ctx);
DE_UNREF(programID);
}
void GeometryShaderRenderTest::postRender(sglr::Context &ctx, GLuint programID)
{
DE_UNREF(ctx);
DE_UNREF(programID);
}
class GeometryExpanderRenderTest : public GeometryShaderRenderTest
{
public:
GeometryExpanderRenderTest(Context &context, const char *name, const char *desc, GLenum inputPrimitives,
GLenum outputPrimitives);
virtual ~GeometryExpanderRenderTest(void);
sglr::ShaderProgram &getProgram(void);
private:
void init(void);
void deinit(void);
VertexExpanderShader *m_program;
};
GeometryExpanderRenderTest::GeometryExpanderRenderTest(Context &context, const char *name, const char *desc,
GLenum inputPrimitives, GLenum outputPrimitives)
: GeometryShaderRenderTest(context, name, desc, inputPrimitives, outputPrimitives, "a_color")
, m_program(DE_NULL)
{
}
GeometryExpanderRenderTest::~GeometryExpanderRenderTest(void)
{
}
void GeometryExpanderRenderTest::init(void)
{
m_program = new VertexExpanderShader(m_context.getRenderContext().getType(),
sglr::rr_util::mapGLGeometryShaderInputType(m_inputPrimitives),
sglr::rr_util::mapGLGeometryShaderOutputType(m_outputPrimitives));
GeometryShaderRenderTest::init();
}
void GeometryExpanderRenderTest::deinit(void)
{
if (m_program)
{
delete m_program;
m_program = DE_NULL;
}
GeometryShaderRenderTest::deinit();
}
sglr::ShaderProgram &GeometryExpanderRenderTest::getProgram(void)
{
return *m_program;
}
class EmitTest : public GeometryShaderRenderTest
{
public:
EmitTest(Context &context, const char *name, const char *desc, int emitCountA, int endCountA, int emitCountB,
int endCountB, GLenum outputType);
sglr::ShaderProgram &getProgram(void);
private:
void init(void);
void deinit(void);
void genVertexAttribData(void);
VertexEmitterShader *m_program;
int m_emitCountA;
int m_endCountA;
int m_emitCountB;
int m_endCountB;
GLenum m_outputType;
};
EmitTest::EmitTest(Context &context, const char *name, const char *desc, int emitCountA, int endCountA, int emitCountB,
int endCountB, GLenum outputType)
: GeometryShaderRenderTest(context, name, desc, GL_POINTS, outputType, "a_color")
, m_program(DE_NULL)
, m_emitCountA(emitCountA)
, m_endCountA(endCountA)
, m_emitCountB(emitCountB)
, m_endCountB(endCountB)
, m_outputType(outputType)
{
}
void EmitTest::init(void)
{
m_program = new VertexEmitterShader(m_context.getRenderContext().getType(), m_emitCountA, m_endCountA, m_emitCountB,
m_endCountB, sglr::rr_util::mapGLGeometryShaderOutputType(m_outputType));
GeometryShaderRenderTest::init();
}
void EmitTest::deinit(void)
{
if (m_program)
{
delete m_program;
m_program = DE_NULL;
}
GeometryShaderRenderTest::deinit();
}
sglr::ShaderProgram &EmitTest::getProgram(void)
{
return *m_program;
}
void EmitTest::genVertexAttribData(void)
{
m_vertexPosData.resize(1);
m_vertexPosData[0] = tcu::Vec4(0, 0, 0, 1);
m_vertexAttrData.resize(1);
m_vertexAttrData[0] = tcu::Vec4(1, 1, 1, 1);
m_numDrawVertices = 1;
}
class VaryingTest : public GeometryShaderRenderTest
{
public:
VaryingTest(Context &context, const char *name, const char *desc, int vertexOut, int geometryOut);
sglr::ShaderProgram &getProgram(void);
private:
void init(void);
void deinit(void);
void genVertexAttribData(void);
VertexVaryingShader *m_program;
int m_vertexOut;
int m_geometryOut;
};
VaryingTest::VaryingTest(Context &context, const char *name, const char *desc, int vertexOut, int geometryOut)
: GeometryShaderRenderTest(context, name, desc, GL_TRIANGLES, GL_TRIANGLE_STRIP, "a_color")
, m_program(DE_NULL)
, m_vertexOut(vertexOut)
, m_geometryOut(geometryOut)
{
}
void VaryingTest::init(void)
{
m_program = new VertexVaryingShader(m_context.getRenderContext().getType(), m_vertexOut, m_geometryOut);
GeometryShaderRenderTest::init();
}
void VaryingTest::deinit(void)
{
if (m_program)
{
delete m_program;
m_program = DE_NULL;
}
GeometryShaderRenderTest::deinit();
}
sglr::ShaderProgram &VaryingTest::getProgram(void)
{
return *m_program;
}
void VaryingTest::genVertexAttribData(void)
{
m_vertexPosData.resize(3);
m_vertexPosData[0] = tcu::Vec4(0.5f, 0.0f, 0.0f, 1.0f);
m_vertexPosData[1] = tcu::Vec4(0.0f, 0.5f, 0.0f, 1.0f);
m_vertexPosData[2] = tcu::Vec4(0.1f, 0.0f, 0.0f, 1.0f);
m_vertexAttrData.resize(3);
m_vertexAttrData[0] = tcu::Vec4(0.7f, 0.4f, 0.6f, 1.0f);
m_vertexAttrData[1] = tcu::Vec4(0.9f, 0.2f, 0.5f, 1.0f);
m_vertexAttrData[2] = tcu::Vec4(0.1f, 0.8f, 0.3f, 1.0f);
m_numDrawVertices = 3;
}
class TriangleStripAdjacencyVertexCountTest : public GeometryExpanderRenderTest
{
public:
TriangleStripAdjacencyVertexCountTest(Context &context, const char *name, const char *desc, int numInputVertices);
private:
void genVertexAttribData(void);
int m_numInputVertices;
};
TriangleStripAdjacencyVertexCountTest::TriangleStripAdjacencyVertexCountTest(Context &context, const char *name,
const char *desc, int numInputVertices)
: GeometryExpanderRenderTest(context, name, desc, GL_TRIANGLE_STRIP_ADJACENCY, GL_TRIANGLE_STRIP)
, m_numInputVertices(numInputVertices)
{
}
void TriangleStripAdjacencyVertexCountTest::genVertexAttribData(void)
{
this->GeometryShaderRenderTest::genVertexAttribData();
m_numDrawVertices = m_numInputVertices;
}
class NegativeDrawCase : public TestCase
{
public:
NegativeDrawCase(Context &context, const char *name, const char *desc, GLenum inputType, GLenum inputPrimitives);
~NegativeDrawCase(void);
void init(void);
void deinit(void);
IterateResult iterate(void);
private:
sglr::Context *m_ctx;
VertexExpanderShader *m_program;
GLenum m_inputType;
GLenum m_inputPrimitives;
};
NegativeDrawCase::NegativeDrawCase(Context &context, const char *name, const char *desc, GLenum inputType,
GLenum inputPrimitives)
: TestCase(context, name, desc)
, m_ctx(DE_NULL)
, m_program(DE_NULL)
, m_inputType(inputType)
, m_inputPrimitives(inputPrimitives)
{
}
NegativeDrawCase::~NegativeDrawCase(void)
{
deinit();
}
void NegativeDrawCase::init(void)
{
if (!checkSupport(m_context))
TCU_THROW(NotSupportedError, "Tests require GL_EXT_geometry_shader extension or higher context version.");
m_ctx = new sglr::GLContext(m_context.getRenderContext(), m_testCtx.getLog(),
sglr::GLCONTEXT_LOG_CALLS | sglr::GLCONTEXT_LOG_PROGRAMS, tcu::IVec4(0, 0, 1, 1));
m_program = new VertexExpanderShader(m_context.getRenderContext().getType(),
sglr::rr_util::mapGLGeometryShaderInputType(m_inputType),
rr::GEOMETRYSHADEROUTPUTTYPE_POINTS);
}
void NegativeDrawCase::deinit(void)
{
delete m_ctx;
delete m_program;
m_ctx = NULL;
m_program = DE_NULL;
}
NegativeDrawCase::IterateResult NegativeDrawCase::iterate(void)
{
const GLuint programId = m_ctx->createProgram(m_program);
const GLint attrPosLoc = m_ctx->getAttribLocation(programId, "a_position");
const tcu::Vec4 vertexPosData(0, 0, 0, 1);
GLuint vaoId = 0;
GLuint vertexPosBuf = 0;
GLenum errorCode = 0;
m_ctx->genVertexArrays(1, &vaoId);
m_ctx->bindVertexArray(vaoId);
m_ctx->genBuffers(1, &vertexPosBuf);
m_ctx->bindBuffer(GL_ARRAY_BUFFER, vertexPosBuf);
m_ctx->bufferData(GL_ARRAY_BUFFER, sizeof(tcu::Vec4), vertexPosData.m_data, GL_STATIC_DRAW);
m_ctx->vertexAttribPointer(attrPosLoc, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL);
m_ctx->enableVertexAttribArray(attrPosLoc);
m_ctx->clearColor(0, 0, 0, 1);
m_ctx->clear(GL_COLOR_BUFFER_BIT);
m_ctx->viewport(0, 0, 1, 1);
m_ctx->useProgram(programId);
// no errors before
glu::checkError(m_ctx->getError(), "", __FILE__, __LINE__);
m_ctx->drawArrays(m_inputPrimitives, 0, 1);
errorCode = m_ctx->getError();
if (errorCode != GL_INVALID_OPERATION)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Expected GL_INVALID_OPERATION, got "
<< glu::getErrorStr(errorCode) << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got wrong error code");
}
else
{
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
}
m_ctx->useProgram(0);
m_ctx->disableVertexAttribArray(attrPosLoc);
m_ctx->deleteBuffers(1, &vertexPosBuf);
m_ctx->deleteVertexArrays(1, &vaoId);
return STOP;
}
class OutputCountCase : public GeometryShaderRenderTest
{
public:
OutputCountCase(Context &context, const char *name, const char *desc, const OutputCountPatternSpec &);
private:
void init(void);
void deinit(void);
sglr::ShaderProgram &getProgram(void);
void genVertexAttribData(void);
const int m_primitiveCount;
OutputCountShader *m_program;
OutputCountPatternSpec m_spec;
};
OutputCountCase::OutputCountCase(Context &context, const char *name, const char *desc,
const OutputCountPatternSpec &spec)
: GeometryShaderRenderTest(context, name, desc, GL_POINTS, GL_TRIANGLE_STRIP, "a_color")
, m_primitiveCount((int)spec.pattern.size())
, m_program(DE_NULL)
, m_spec(spec)
{
}
void OutputCountCase::init(void)
{
// Check requirements and adapt to them
{
const int componentsPerVertex = 4 + 4; // vec4 pos, vec4 color
const int testVertices = *std::max_element(m_spec.pattern.begin(), m_spec.pattern.end());
glw::GLint maxVertices = 0;
glw::GLint maxComponents = 0;
// check the extension before querying anything
if (!checkSupport(m_context))
TCU_THROW(NotSupportedError, "Tests require GL_EXT_geometry_shader extension or higher context version.");
m_context.getRenderContext().getFunctions().getIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES, &maxVertices);
m_context.getRenderContext().getFunctions().getIntegerv(GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS,
&maxComponents);
m_testCtx.getLog() << tcu::TestLog::Message << "GL_MAX_GEOMETRY_OUTPUT_VERTICES = " << maxVertices
<< tcu::TestLog::EndMessage;
m_testCtx.getLog() << tcu::TestLog::Message << "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = " << maxComponents
<< tcu::TestLog::EndMessage;
m_testCtx.getLog() << tcu::TestLog::Message << "Components per vertex = " << componentsPerVertex
<< tcu::TestLog::EndMessage;
if (testVertices == -1)
{
// "max vertices"-case
DE_ASSERT((int)m_spec.pattern.size() == 1);
m_spec.pattern[0] = de::min(maxVertices, maxComponents / componentsPerVertex);
// make sure size is dividable by 2, as OutputShader requires
m_spec.pattern[0] = m_spec.pattern[0] & ~0x00000001;
if (m_spec.pattern[0] == 0)
throw tcu::InternalError("Pattern size is invalid.");
}
else
{
// normal case
if (testVertices > maxVertices)
throw tcu::NotSupportedError(de::toString(testVertices) + " output vertices required.");
if (testVertices * componentsPerVertex > maxComponents)
throw tcu::NotSupportedError(de::toString(testVertices * componentsPerVertex) +
" output components required.");
}
}
// Log what the test tries to do
m_testCtx.getLog() << tcu::TestLog::Message << "Rendering " << (int)m_spec.pattern.size()
<< " row(s).\nOne geometry shader invocation generates one row.\nRow sizes:"
<< tcu::TestLog::EndMessage;
for (int ndx = 0; ndx < (int)m_spec.pattern.size(); ++ndx)
m_testCtx.getLog() << tcu::TestLog::Message << "Row " << ndx << ": " << m_spec.pattern[ndx] << " vertices."
<< tcu::TestLog::EndMessage;
// Gen shader
DE_ASSERT(!m_program);
m_program = new OutputCountShader(m_context.getRenderContext().getType(), m_spec);
// Case init
GeometryShaderRenderTest::init();
}
void OutputCountCase::deinit(void)
{
if (m_program)
{
delete m_program;
m_program = DE_NULL;
}
GeometryShaderRenderTest::deinit();
}
sglr::ShaderProgram &OutputCountCase::getProgram(void)
{
return *m_program;
}
void OutputCountCase::genVertexAttribData(void)
{
m_vertexPosData.resize(m_primitiveCount);
m_vertexAttrData.resize(m_primitiveCount);
for (int ndx = 0; ndx < m_primitiveCount; ++ndx)
{
m_vertexPosData[ndx] = tcu::Vec4(-1.0f, ((float)ndx) / (float)m_primitiveCount * 2.0f - 1.0f, 0.0f, 1.0f);
m_vertexAttrData[ndx] = (ndx % 2 == 0) ? tcu::Vec4(1, 1, 1, 1) : tcu::Vec4(1, 0, 0, 1);
}
m_numDrawVertices = m_primitiveCount;
}
class BuiltinVariableRenderTest : public GeometryShaderRenderTest
{
public:
BuiltinVariableRenderTest(Context &context, const char *name, const char *desc,
BuiltinVariableShader::VariableTest test, int flags = 0);
private:
void init(void);
void deinit(void);
sglr::ShaderProgram &getProgram(void);
void genVertexAttribData(void);
BuiltinVariableShader *m_program;
const BuiltinVariableShader::VariableTest m_test;
};
BuiltinVariableRenderTest::BuiltinVariableRenderTest(Context &context, const char *name, const char *desc,
BuiltinVariableShader::VariableTest test, int flags)
: GeometryShaderRenderTest(context, name, desc, GL_POINTS, GL_POINTS,
BuiltinVariableShader::getTestAttributeName(test), flags)
, m_program(DE_NULL)
, m_test(test)
{
}
void BuiltinVariableRenderTest::init(void)
{
// Requirements
if (m_test == BuiltinVariableShader::TEST_POINT_SIZE)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
const float requiredPointSize = 5.0f;
tcu::Vec2 range = tcu::Vec2(1.0f, 1.0f);
if (!glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 4)) &&
!m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_point_size"))
TCU_THROW(NotSupportedError, "Tests require GL_EXT_geometry_point_size extension.");
gl.getFloatv(GL_ALIASED_POINT_SIZE_RANGE, range.getPtr());
if (range.y() < requiredPointSize)
throw tcu::NotSupportedError("Test case requires point size " + de::toString(requiredPointSize));
if (glu::isContextTypeGLCore(m_context.getRenderContext().getType()))
gl.enable(GL_PROGRAM_POINT_SIZE);
}
m_program = new BuiltinVariableShader(m_context.getRenderContext().getType(), m_test);
// Shader init
GeometryShaderRenderTest::init();
}
void BuiltinVariableRenderTest::deinit(void)
{
if (BuiltinVariableShader::TEST_POINT_SIZE == m_test &&
glu::isContextTypeGLCore(m_context.getRenderContext().getType()))
{
m_context.getRenderContext().getFunctions().disable(GL_PROGRAM_POINT_SIZE);
}
if (m_program)
{
delete m_program;
m_program = DE_NULL;
}
GeometryShaderRenderTest::deinit();
}
sglr::ShaderProgram &BuiltinVariableRenderTest::getProgram(void)
{
return *m_program;
}
void BuiltinVariableRenderTest::genVertexAttribData(void)
{
m_vertexPosData.resize(4);
m_vertexPosData[0] = tcu::Vec4(0.5f, 0.0f, 0.0f, 1.0f);
m_vertexPosData[1] = tcu::Vec4(0.0f, 0.5f, 0.0f, 1.0f);
m_vertexPosData[2] = tcu::Vec4(-0.7f, -0.1f, 0.0f, 1.0f);
m_vertexPosData[3] = tcu::Vec4(-0.1f, -0.7f, 0.0f, 1.0f);
m_vertexAttrData.resize(4);
m_vertexAttrData[0] = tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f);
m_vertexAttrData[1] = tcu::Vec4(1.0f, 0.0f, 0.0f, 0.0f);
m_vertexAttrData[2] = tcu::Vec4(2.0f, 0.0f, 0.0f, 0.0f);
m_vertexAttrData[3] = tcu::Vec4(3.0f, 0.0f, 0.0f, 0.0f);
// Only used by primitive ID restart test
m_indices.resize(4);
m_indices[0] = 3;
m_indices[1] = 2;
m_indices[2] = 0xFFFF; // restart
m_indices[3] = 1;
m_numDrawVertices = 4;
}
class LayeredRenderCase : public TestCase
{
public:
enum LayeredRenderTargetType
{
TARGET_CUBE = 0,
TARGET_3D,
TARGET_1D_ARRAY,
TARGET_2D_ARRAY,
TARGET_2D_MS_ARRAY,
TARGET_LAST
};
enum TestType
{
TEST_DEFAULT_LAYER, // !< draw to default layer
TEST_SINGLE_LAYER, // !< draw to single layer
TEST_ALL_LAYERS, // !< draw all layers
TEST_DIFFERENT_LAYERS, // !< draw different content to different layers
TEST_INVOCATION_PER_LAYER, // !< draw to all layers, one invocation per layer
TEST_MULTIPLE_LAYERS_PER_INVOCATION, // !< draw to all layers, multiple invocations write to multiple layers
TEST_LAYER_ID, // !< draw to all layers, verify gl_Layer fragment input
TEST_LAYER_PROVOKING_VERTEX, // !< draw primitive with vertices in different layers, check which layer it was drawn to
TEST_LAST
};
LayeredRenderCase(Context &context, const char *name, const char *desc, LayeredRenderTargetType target,
TestType test);
~LayeredRenderCase(void);
void init(void);
void deinit(void);
IterateResult iterate(void);
private:
void initTexture(void);
void initFbo(void);
void initRenderShader(void);
void initSamplerShader(void);
std::string genFragmentSource(const glu::ContextType &contextType) const;
std::string genGeometrySource(const glu::ContextType &contextType) const;
std::string genSamplerFragmentSource(const glu::ContextType &contextType) const;
void renderToTexture(void);
void sampleTextureLayer(tcu::Surface &dst, int layer);
bool verifyLayerContent(const tcu::Surface &layer, int layerNdx);
bool verifyImageSingleColoredRow(const tcu::Surface &layer, float rowWidthRatio, const tcu::Vec4 &color,
bool logging = true);
bool verifyEmptyImage(const tcu::Surface &layer, bool logging = true);
bool verifyProvokingVertexLayers(const tcu::Surface &layer0, const tcu::Surface &layer1);
static int getTargetLayers(LayeredRenderTargetType target);
static glw::GLenum getTargetTextureTarget(LayeredRenderTargetType target);
static tcu::IVec3 getTargetDimensions(LayeredRenderTargetType target);
static tcu::IVec2 getResolveDimensions(LayeredRenderTargetType target);
const LayeredRenderTargetType m_target;
const TestType m_test;
const int m_numLayers;
const int m_targetLayer;
const tcu::IVec2 m_resolveDimensions;
int m_iteration;
bool m_allLayersOk;
glw::GLuint m_texture;
glw::GLuint m_fbo;
glu::ShaderProgram *m_renderShader;
glu::ShaderProgram *m_samplerShader;
glw::GLint m_samplerSamplerLoc;
glw::GLint m_samplerLayerLoc;
glw::GLenum m_provokingVertex;
};
LayeredRenderCase::LayeredRenderCase(Context &context, const char *name, const char *desc,
LayeredRenderTargetType target, TestType test)
: TestCase(context, name, desc)
, m_target(target)
, m_test(test)
, m_numLayers(getTargetLayers(target))
, m_targetLayer(m_numLayers / 2)
, m_resolveDimensions(getResolveDimensions(target))
, m_iteration(0)
, m_allLayersOk(true)
, m_texture(0)
, m_fbo(0)
, m_renderShader(DE_NULL)
, m_samplerShader(DE_NULL)
, m_samplerSamplerLoc(-1)
, m_samplerLayerLoc(-1)
, m_provokingVertex(0)
{
}
LayeredRenderCase::~LayeredRenderCase(void)
{
deinit();
}
void LayeredRenderCase::init(void)
{
// Requirements
const bool supportES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
const bool supportGL45 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5));
if (!checkSupport(m_context))
TCU_THROW(NotSupportedError, "Tests require GL_EXT_geometry_shader extension or higher context version.");
if (m_target == TARGET_2D_MS_ARRAY &&
!(supportGL45 || (supportES32 && m_context.getContextInfo().isExtensionSupported(
"GL_OES_texture_storage_multisample_2d_array"))))
TCU_THROW(NotSupportedError,
"Test requires OES_texture_storage_multisample_2d_array extension or higher context version.");
if (m_context.getRenderTarget().getWidth() < m_resolveDimensions.x() ||
m_context.getRenderTarget().getHeight() < m_resolveDimensions.y())
throw tcu::NotSupportedError("Render target size must be at least " + de::toString(m_resolveDimensions.x()) +
"x" + de::toString(m_resolveDimensions.y()));
// log what the test tries to do
if (m_test == TEST_DEFAULT_LAYER)
m_testCtx.getLog() << tcu::TestLog::Message << "Rendering to the default layer." << tcu::TestLog::EndMessage;
else if (m_test == TEST_SINGLE_LAYER)
m_testCtx.getLog() << tcu::TestLog::Message << "Rendering to a single layer." << tcu::TestLog::EndMessage;
else if (m_test == TEST_ALL_LAYERS)
m_testCtx.getLog() << tcu::TestLog::Message << "Rendering to all layers." << tcu::TestLog::EndMessage;
else if (m_test == TEST_DIFFERENT_LAYERS)
m_testCtx.getLog() << tcu::TestLog::Message << "Outputting different number of vertices to each layer."
<< tcu::TestLog::EndMessage;
else if (m_test == TEST_INVOCATION_PER_LAYER)
m_testCtx.getLog() << tcu::TestLog::Message << "Using a different invocation to output to each layer."
<< tcu::TestLog::EndMessage;
else if (m_test == TEST_MULTIPLE_LAYERS_PER_INVOCATION)
m_testCtx.getLog() << tcu::TestLog::Message << "Outputting to each layer from multiple invocations."
<< tcu::TestLog::EndMessage;
else if (m_test == TEST_LAYER_ID)
m_testCtx.getLog() << tcu::TestLog::Message << "Using gl_Layer in fragment shader." << tcu::TestLog::EndMessage;
else if (m_test == TEST_LAYER_PROVOKING_VERTEX)
m_testCtx.getLog() << tcu::TestLog::Message << "Verifying LAYER_PROVOKING_VERTEX." << tcu::TestLog::EndMessage;
else
DE_ASSERT(false);
// init resources
initTexture();
initFbo();
initRenderShader();
initSamplerShader();
}
void LayeredRenderCase::deinit(void)
{
if (m_texture)
{
m_context.getRenderContext().getFunctions().deleteTextures(1, &m_texture);
m_texture = 0;
}
if (m_fbo)
{
m_context.getRenderContext().getFunctions().deleteFramebuffers(1, &m_fbo);
m_fbo = 0;
}
delete m_renderShader;
delete m_samplerShader;
m_renderShader = DE_NULL;
m_samplerShader = DE_NULL;
}
LayeredRenderCase::IterateResult LayeredRenderCase::iterate(void)
{
++m_iteration;
if (m_iteration == 1)
{
if (m_test == TEST_LAYER_PROVOKING_VERTEX)
{
// which layer the implementation claims to render to
gls::StateQueryUtil::StateQueryMemoryWriteGuard<glw::GLint> state;
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
gl.getIntegerv(GL_LAYER_PROVOKING_VERTEX, &state);
GLU_EXPECT_NO_ERROR(gl.getError(), "getInteger(GL_LAYER_PROVOKING_VERTEX)");
if (!state.verifyValidity(m_testCtx))
return STOP;
m_testCtx.getLog() << tcu::TestLog::Message
<< "GL_LAYER_PROVOKING_VERTEX = " << glu::getProvokingVertexStr(state)
<< tcu::TestLog::EndMessage;
bool ok = false;
if (contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(3, 2)))
{
ok = state == GL_FIRST_VERTEX_CONVENTION || state == GL_LAST_VERTEX_CONVENTION ||
state == GL_PROVOKING_VERTEX || state == GL_UNDEFINED_VERTEX;
m_provokingVertex = (glw::GLenum)state;
if (state == GL_PROVOKING_VERTEX)
{
gl.getIntegerv(GL_PROVOKING_VERTEX, reinterpret_cast<glw::GLint *>(&m_provokingVertex));
GLU_EXPECT_NO_ERROR(gl.getError(), "getInteger(GL_PROVOKING_VERTEX)");
}
}
else
{
ok = state == GL_FIRST_VERTEX_CONVENTION || state == GL_LAST_VERTEX_CONVENTION ||
state == GL_UNDEFINED_VERTEX;
m_provokingVertex = (glw::GLenum)state;
}
if (!ok)
{
m_testCtx.getLog() << tcu::TestLog::Message
<< "getInteger(GL_LAYER_PROVOKING_VERTEX) returned illegal value. Got " << state
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got unexpected provoking vertex value");
return STOP;
}
}
// render to texture
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "RenderToTexture", "Render to layered texture");
// render to layered texture with the geometry shader
renderToTexture();
}
return CONTINUE;
}
else if (m_test == TEST_LAYER_PROVOKING_VERTEX && m_provokingVertex == GL_UNDEFINED_VERTEX)
{
// Verification requires information from another layers, layers not independent
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "VerifyLayers", "Verify layers 0 and 1");
tcu::Surface layer0(m_resolveDimensions.x(), m_resolveDimensions.y());
tcu::Surface layer1(m_resolveDimensions.x(), m_resolveDimensions.y());
// sample layer to frame buffer
sampleTextureLayer(layer0, 0);
sampleTextureLayer(layer1, 1);
m_allLayersOk &= verifyProvokingVertexLayers(layer0, layer1);
}
// Other layers empty
for (int layerNdx = 2; layerNdx < m_numLayers; ++layerNdx)
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "VerifyLayer",
"Verify layer " + de::toString(layerNdx));
tcu::Surface layer(m_resolveDimensions.x(), m_resolveDimensions.y());
// sample layer to frame buffer
sampleTextureLayer(layer, layerNdx);
// verify
m_allLayersOk &= verifyEmptyImage(layer);
}
}
else
{
// Layers independent
const int layerNdx = m_iteration - 2;
const tcu::ScopedLogSection section(m_testCtx.getLog(), "VerifyLayer",
"Verify layer " + de::toString(layerNdx));
tcu::Surface layer(m_resolveDimensions.x(), m_resolveDimensions.y());
// sample layer to frame buffer
sampleTextureLayer(layer, layerNdx);
// verify
m_allLayersOk &= verifyLayerContent(layer, layerNdx);
if (layerNdx < m_numLayers - 1)
return CONTINUE;
}
// last iteration
if (m_allLayersOk)
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
else
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Detected invalid layer content");
return STOP;
}
void LayeredRenderCase::initTexture(void)
{
DE_ASSERT(!m_texture);
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
const tcu::IVec3 texSize = getTargetDimensions(m_target);
const tcu::TextureFormat texFormat = glu::mapGLInternalFormat(GL_RGBA8);
const glu::TransferFormat transferFormat = glu::getTransferFormat(texFormat);
gl.genTextures(1, &m_texture);
GLU_EXPECT_NO_ERROR(gl.getError(), "gen texture");
switch (m_target)
{
case TARGET_CUBE:
m_testCtx.getLog() << tcu::TestLog::Message << "Creating cubemap texture, size = " << texSize.x() << "x"
<< texSize.y() << tcu::TestLog::EndMessage;
gl.bindTexture(GL_TEXTURE_CUBE_MAP, m_texture);
gl.texImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGBA8, texSize.x(), texSize.y(), 0, transferFormat.format,
transferFormat.dataType, DE_NULL);
gl.texImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGBA8, texSize.x(), texSize.y(), 0, transferFormat.format,
transferFormat.dataType, DE_NULL);
gl.texImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGBA8, texSize.x(), texSize.y(), 0, transferFormat.format,
transferFormat.dataType, DE_NULL);
gl.texImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGBA8, texSize.x(), texSize.y(), 0, transferFormat.format,
transferFormat.dataType, DE_NULL);
gl.texImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGBA8, texSize.x(), texSize.y(), 0, transferFormat.format,
transferFormat.dataType, DE_NULL);
gl.texImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGBA8, texSize.x(), texSize.y(), 0, transferFormat.format,
transferFormat.dataType, DE_NULL);
break;
case TARGET_3D:
m_testCtx.getLog() << tcu::TestLog::Message << "Creating 3d texture, size = " << texSize.x() << "x"
<< texSize.y() << "x" << texSize.z() << tcu::TestLog::EndMessage;
gl.bindTexture(GL_TEXTURE_3D, m_texture);
gl.texImage3D(GL_TEXTURE_3D, 0, GL_RGBA8, texSize.x(), texSize.y(), texSize.z(), 0, transferFormat.format,
transferFormat.dataType, DE_NULL);
break;
case TARGET_1D_ARRAY:
m_testCtx.getLog() << tcu::TestLog::Message << "Creating 1d texture array, size = " << texSize.x()
<< ", layers = " << texSize.y() << tcu::TestLog::EndMessage;
gl.bindTexture(GL_TEXTURE_1D_ARRAY, m_texture);
gl.texImage2D(GL_TEXTURE_1D_ARRAY, 0, GL_RGBA8, texSize.x(), texSize.y(), 0, transferFormat.format,
transferFormat.dataType, DE_NULL);
break;
case TARGET_2D_ARRAY:
m_testCtx.getLog() << tcu::TestLog::Message << "Creating 2d texture array, size = " << texSize.x() << "x"
<< texSize.y() << ", layers = " << texSize.z() << tcu::TestLog::EndMessage;
gl.bindTexture(GL_TEXTURE_2D_ARRAY, m_texture);
gl.texImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA8, texSize.x(), texSize.y(), texSize.z(), 0, transferFormat.format,
transferFormat.dataType, DE_NULL);
break;
case TARGET_2D_MS_ARRAY:
{
const int numSamples = 2;
int maxSamples = 0;
gl.getIntegerv(GL_MAX_COLOR_TEXTURE_SAMPLES, &maxSamples);
m_testCtx.getLog() << tcu::TestLog::Message << "Creating 2d multisample texture array, size = " << texSize.x()
<< "x" << texSize.y() << ", layers = " << texSize.z() << ", samples = " << numSamples
<< tcu::TestLog::EndMessage;
if (numSamples > maxSamples)
throw tcu::NotSupportedError("Test requires " + de::toString(numSamples) + " color texture samples.");
gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, m_texture);
gl.texStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, numSamples, GL_RGBA8, texSize.x(), texSize.y(),
texSize.z(), GL_TRUE);
break;
}
default:
DE_ASSERT(false);
}
GLU_EXPECT_NO_ERROR(gl.getError(), "tex image");
// Multisample textures don't use filters
if (getTargetTextureTarget(m_target) != GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
{
gl.texParameteri(getTargetTextureTarget(m_target), GL_TEXTURE_MAG_FILTER, GL_NEAREST);
gl.texParameteri(getTargetTextureTarget(m_target), GL_TEXTURE_MIN_FILTER, GL_NEAREST);
gl.texParameteri(getTargetTextureTarget(m_target), GL_TEXTURE_WRAP_S, GL_REPEAT);
gl.texParameteri(getTargetTextureTarget(m_target), GL_TEXTURE_WRAP_T, GL_REPEAT);
gl.texParameteri(getTargetTextureTarget(m_target), GL_TEXTURE_WRAP_R, GL_REPEAT);
GLU_EXPECT_NO_ERROR(gl.getError(), "tex filter");
}
}
void LayeredRenderCase::initFbo(void)
{
DE_ASSERT(!m_fbo);
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
m_testCtx.getLog() << tcu::TestLog::Message << "Creating FBO" << tcu::TestLog::EndMessage;
gl.genFramebuffers(1, &m_fbo);
gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo);
gl.framebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_texture, 0);
gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "setup fbo");
}
void LayeredRenderCase::initRenderShader(void)
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "RenderToTextureShader",
"Create layered rendering shader program");
static const char *const positionVertex = "${GLSL_VERSION_DECL}\n"
"void main (void)\n"
"{\n"
" gl_Position = vec4(0.0, 0.0, 0.0, 1.0);\n"
"}\n";
m_renderShader = new glu::ShaderProgram(
m_context.getRenderContext(),
glu::ProgramSources() << glu::VertexSource(
specializeShader(positionVertex, m_context.getRenderContext().getType()))
<< glu::FragmentSource(genFragmentSource(m_context.getRenderContext().getType()))
<< glu::GeometrySource(genGeometrySource(m_context.getRenderContext().getType())));
m_testCtx.getLog() << *m_renderShader;
if (!m_renderShader->isOk())
throw tcu::TestError("failed to build render shader");
}
void LayeredRenderCase::initSamplerShader(void)
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "TextureSamplerShader", "Create shader sampler program");
static const char *const positionVertex = "${GLSL_VERSION_DECL}\n"
"in highp vec4 a_position;\n"
"void main (void)\n"
"{\n"
" gl_Position = a_position;\n"
"}\n";
m_samplerShader = new glu::ShaderProgram(
m_context.getRenderContext(),
glu::ProgramSources() << glu::VertexSource(
specializeShader(positionVertex, m_context.getRenderContext().getType()))
<< glu::FragmentSource(genSamplerFragmentSource(m_context.getRenderContext().getType())));
m_testCtx.getLog() << *m_samplerShader;
if (!m_samplerShader->isOk())
throw tcu::TestError("failed to build sampler shader");
m_samplerSamplerLoc =
m_context.getRenderContext().getFunctions().getUniformLocation(m_samplerShader->getProgram(), "u_sampler");
if (m_samplerSamplerLoc == -1)
throw tcu::TestError("u_sampler uniform location = -1");
m_samplerLayerLoc =
m_context.getRenderContext().getFunctions().getUniformLocation(m_samplerShader->getProgram(), "u_layer");
if (m_samplerLayerLoc == -1)
throw tcu::TestError("u_layer uniform location = -1");
}
std::string LayeredRenderCase::genFragmentSource(const glu::ContextType &contextType) const
{
static const char *const fragmentLayerIdShader = "${GLSL_VERSION_DECL}\n"
"${GLSL_EXT_GEOMETRY_SHADER}"
"layout(location = 0) out mediump vec4 fragColor;\n"
"void main (void)\n"
"{\n"
" fragColor = vec4(((gl_Layer % 2) == 1) ? 1.0 : 0.5,\n"
" (((gl_Layer / 2) % 2) == 1) ? 1.0 : 0.5,\n"
" (gl_Layer == 0) ? 1.0 : 0.0,\n"
" 1.0);\n"
"}\n";
if (m_test != TEST_LAYER_ID)
return specializeShader(s_commonShaderSourceFragment, contextType);
else
return specializeShader(fragmentLayerIdShader, contextType);
}
std::string LayeredRenderCase::genGeometrySource(const glu::ContextType &contextType) const
{
// TEST_DIFFERENT_LAYERS: draw 0 quad to first layer, 1 to second, etc.
// TEST_ALL_LAYERS: draw 1 quad to all layers
// TEST_MULTIPLE_LAYERS_PER_INVOCATION: draw 1 triangle to "current layer" and 1 triangle to another layer
// else: draw 1 quad to some single layer
const int maxVertices = (m_test == TEST_DIFFERENT_LAYERS) ? ((2 + m_numLayers - 1) * m_numLayers) :
(m_test == TEST_ALL_LAYERS || m_test == TEST_LAYER_ID) ? (m_numLayers * 4) :
(m_test == TEST_MULTIPLE_LAYERS_PER_INVOCATION) ? (6) :
(m_test == TEST_LAYER_PROVOKING_VERTEX) ? (6) :
(4);
std::ostringstream buf;
buf << "${GLSL_VERSION_DECL}\n"
"${GLSL_EXT_GEOMETRY_SHADER}";
if (m_test == TEST_INVOCATION_PER_LAYER || m_test == TEST_MULTIPLE_LAYERS_PER_INVOCATION)
buf << "layout(points, invocations=" << m_numLayers << ") in;\n";
else
buf << "layout(points) in;\n";
buf << "layout(triangle_strip, max_vertices = " << maxVertices
<< ") out;\n"
"out highp vec4 v_frag_FragColor;\n"
"\n"
"void main (void)\n"
"{\n";
if (m_test == TEST_DEFAULT_LAYER)
{
buf << " const highp vec4 white = vec4(1.0, 1.0, 1.0, 1.0);\n\n"
" gl_Position = vec4(-1.0, -1.0, 0.0, 1.0);\n"
" v_frag_FragColor = white;\n"
" EmitVertex();\n\n"
" gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n"
" v_frag_FragColor = white;\n"
" EmitVertex();\n\n"
" gl_Position = vec4( 0.0, -1.0, 0.0, 1.0);\n"
" v_frag_FragColor = white;\n"
" EmitVertex();\n\n"
" gl_Position = vec4( 0.0, 1.0, 0.0, 1.0);\n"
" v_frag_FragColor = white;\n"
" EmitVertex();\n";
}
else if (m_test == TEST_SINGLE_LAYER)
{
buf << " const highp vec4 white = vec4(1.0, 1.0, 1.0, 1.0);\n\n"
" gl_Position = vec4(-1.0, -1.0, 0.0, 1.0);\n"
" gl_Layer = "
<< m_targetLayer
<< ";\n"
" v_frag_FragColor = white;\n"
" EmitVertex();\n\n"
" gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n"
" gl_Layer = "
<< m_targetLayer
<< ";\n"
" v_frag_FragColor = white;\n"
" EmitVertex();\n\n"
" gl_Position = vec4( 0.0, -1.0, 0.0, 1.0);\n"
" gl_Layer = "
<< m_targetLayer
<< ";\n"
" v_frag_FragColor = white;\n"
" EmitVertex();\n\n"
" gl_Position = vec4( 0.0, 1.0, 0.0, 1.0);\n"
" gl_Layer = "
<< m_targetLayer
<< ";\n"
" v_frag_FragColor = white;\n"
" EmitVertex();\n";
}
else if (m_test == TEST_ALL_LAYERS || m_test == TEST_LAYER_ID)
{
DE_ASSERT(m_numLayers <= 6);
buf << " const highp vec4 white = vec4(1.0, 1.0, 1.0, 1.0);\n"
" const highp vec4 red = vec4(1.0, 0.0, 0.0, 1.0);\n"
" const highp vec4 green = vec4(0.0, 1.0, 0.0, 1.0);\n"
" const highp vec4 blue = vec4(0.0, 0.0, 1.0, 1.0);\n"
" const highp vec4 yellow = vec4(1.0, 1.0, 0.0, 1.0);\n"
" const highp vec4 magenta = vec4(1.0, 0.0, 1.0, 1.0);\n"
" const highp vec4 colors[6] = vec4[6](white, red, green, blue, yellow, magenta);\n\n"
" for (mediump int layerNdx = 0; layerNdx < "
<< m_numLayers
<< "; ++layerNdx)\n"
" {\n"
" gl_Position = vec4(-1.0, -1.0, 0.0, 1.0);\n"
" gl_Layer = layerNdx;\n"
" v_frag_FragColor = colors[layerNdx];\n"
" EmitVertex();\n\n"
" gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n"
" gl_Layer = layerNdx;\n"
" v_frag_FragColor = colors[layerNdx];\n"
" EmitVertex();\n\n"
" gl_Position = vec4( 0.0, -1.0, 0.0, 1.0);\n"
" gl_Layer = layerNdx;\n"
" v_frag_FragColor = colors[layerNdx];\n"
" EmitVertex();\n\n"
" gl_Position = vec4( 0.0, 1.0, 0.0, 1.0);\n"
" gl_Layer = layerNdx;\n"
" v_frag_FragColor = colors[layerNdx];\n"
" EmitVertex();\n"
" EndPrimitive();\n"
" }\n";
}
else if (m_test == TEST_DIFFERENT_LAYERS)
{
DE_ASSERT(m_numLayers <= 6);
buf << " const highp vec4 white = vec4(1.0, 1.0, 1.0, 1.0);\n\n"
" for (mediump int layerNdx = 0; layerNdx < "
<< m_numLayers
<< "; ++layerNdx)\n"
" {\n"
" for (mediump int colNdx = 0; colNdx <= layerNdx; ++colNdx)\n"
" {\n"
" highp float posX = float(colNdx) / float("
<< m_numLayers
<< ") * 2.0 - 1.0;\n\n"
" gl_Position = vec4(posX, 1.0, 0.0, 1.0);\n"
" gl_Layer = layerNdx;\n"
" v_frag_FragColor = white;\n"
" EmitVertex();\n\n"
" gl_Position = vec4(posX, -1.0, 0.0, 1.0);\n"
" gl_Layer = layerNdx;\n"
" v_frag_FragColor = white;\n"
" EmitVertex();\n"
" }\n"
" EndPrimitive();\n"
" }\n";
}
else if (m_test == TEST_INVOCATION_PER_LAYER)
{
buf << " const highp vec4 white = vec4(1.0, 1.0, 1.0, 1.0);\n"
" const highp vec4 red = vec4(1.0, 0.0, 0.0, 1.0);\n"
" const highp vec4 green = vec4(0.0, 1.0, 0.0, 1.0);\n"
" const highp vec4 blue = vec4(0.0, 0.0, 1.0, 1.0);\n"
" const highp vec4 yellow = vec4(1.0, 1.0, 0.0, 1.0);\n"
" const highp vec4 magenta = vec4(1.0, 0.0, 1.0, 1.0);\n"
" const highp vec4 colors[6] = vec4[6](white, red, green, blue, yellow, magenta);\n"
"\n"
" gl_Position = vec4(-1.0, -1.0, 0.0, 1.0);\n"
" gl_Layer = gl_InvocationID;\n"
" v_frag_FragColor = colors[gl_InvocationID];\n"
" EmitVertex();\n\n"
" gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n"
" gl_Layer = gl_InvocationID;\n"
" v_frag_FragColor = colors[gl_InvocationID];\n"
" EmitVertex();\n\n"
" gl_Position = vec4( 0.0, -1.0, 0.0, 1.0);\n"
" gl_Layer = gl_InvocationID;\n"
" v_frag_FragColor = colors[gl_InvocationID];\n"
" EmitVertex();\n\n"
" gl_Position = vec4( 0.0, 1.0, 0.0, 1.0);\n"
" gl_Layer = gl_InvocationID;\n"
" v_frag_FragColor = colors[gl_InvocationID];\n"
" EmitVertex();\n"
" EndPrimitive();\n";
}
else if (m_test == TEST_MULTIPLE_LAYERS_PER_INVOCATION)
{
buf << " const highp vec4 white = vec4(1.0, 1.0, 1.0, 1.0);\n"
"\n"
" mediump int layerA = gl_InvocationID;\n"
" mediump int layerB = (gl_InvocationID + 1) % "
<< m_numLayers
<< ";\n"
" highp float aEnd = float(layerA) / float("
<< m_numLayers
<< ") * 2.0 - 1.0;\n"
" highp float bEnd = float(layerB) / float("
<< m_numLayers
<< ") * 2.0 - 1.0;\n"
"\n"
" gl_Position = vec4(-1.0, -1.0, 0.0, 1.0);\n"
" gl_Layer = layerA;\n"
" v_frag_FragColor = white;\n"
" EmitVertex();\n\n"
" gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n"
" gl_Layer = layerA;\n"
" v_frag_FragColor = white;\n"
" EmitVertex();\n\n"
" gl_Position = vec4(aEnd, -1.0, 0.0, 1.0);\n"
" gl_Layer = layerA;\n"
" v_frag_FragColor = white;\n"
" EmitVertex();\n\n"
" EndPrimitive();\n"
"\n"
" gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n"
" gl_Layer = layerB;\n"
" v_frag_FragColor = white;\n"
" EmitVertex();\n\n"
" gl_Position = vec4(bEnd, 1.0, 0.0, 1.0);\n"
" gl_Layer = layerB;\n"
" v_frag_FragColor = white;\n"
" EmitVertex();\n\n"
" gl_Position = vec4(bEnd, -1.0, 0.0, 1.0);\n"
" gl_Layer = layerB;\n"
" v_frag_FragColor = white;\n"
" EmitVertex();\n\n"
" EndPrimitive();\n";
}
else if (m_test == TEST_LAYER_PROVOKING_VERTEX)
{
buf << " const highp vec4 white = vec4(1.0, 1.0, 1.0, 1.0);\n\n"
" gl_Position = vec4(-1.0, -1.0, 0.0, 1.0);\n"
" gl_Layer = 0;\n"
" v_frag_FragColor = white;\n"
" EmitVertex();\n\n"
" gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n"
" gl_Layer = 1;\n"
" v_frag_FragColor = white;\n"
" EmitVertex();\n\n"
" gl_Position = vec4( 0.0, -1.0, 0.0, 1.0);\n"
" gl_Layer = 1;\n"
" v_frag_FragColor = white;\n"
" EmitVertex();\n\n"
" EndPrimitive();\n\n"
" gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n"
" gl_Layer = 0;\n"
" v_frag_FragColor = white;\n"
" EmitVertex();\n\n"
" gl_Position = vec4( 0.0, -1.0, 0.0, 1.0);\n"
" gl_Layer = 1;\n"
" v_frag_FragColor = white;\n"
" EmitVertex();\n\n"
" gl_Position = vec4( 0.0, 1.0, 0.0, 1.0);\n"
" gl_Layer = 1;\n"
" v_frag_FragColor = white;\n"
" EmitVertex();\n";
}
else
DE_ASSERT(false);
buf << "}\n";
return specializeShader(buf.str(), contextType);
}
std::string LayeredRenderCase::genSamplerFragmentSource(const glu::ContextType &contextType) const
{
std::ostringstream buf;
buf << "${GLSL_VERSION_DECL}\n";
if (m_target == TARGET_2D_MS_ARRAY)
buf << "${GLSL_OES_TEXTURE_STORAGE_MULTISAMPLE}";
buf << "layout(location = 0) out mediump vec4 fragColor;\n";
switch (m_target)
{
case TARGET_CUBE:
buf << "uniform highp samplerCube u_sampler;\n";
break;
case TARGET_3D:
buf << "uniform highp sampler3D u_sampler;\n";
break;
case TARGET_2D_ARRAY:
buf << "uniform highp sampler2DArray u_sampler;\n";
break;
case TARGET_1D_ARRAY:
buf << "uniform highp sampler1DArray u_sampler;\n";
break;
case TARGET_2D_MS_ARRAY:
buf << "uniform highp sampler2DMSArray u_sampler;\n";
break;
default:
DE_ASSERT(false);
}
buf << "uniform highp int u_layer;\n"
"void main (void)\n"
"{\n";
switch (m_target)
{
case TARGET_CUBE:
buf << " highp vec2 facepos = 2.0 * gl_FragCoord.xy / vec2(ivec2(" << m_resolveDimensions.x() << ", "
<< m_resolveDimensions.y()
<< ")) - vec2(1.0, 1.0);\n"
" if (u_layer == 0)\n"
" fragColor = textureLod(u_sampler, vec3(1.0, -facepos.y, -facepos.x), 0.0);\n"
" else if (u_layer == 1)\n"
" fragColor = textureLod(u_sampler, vec3(-1.0, -facepos.y, facepos.x), 0.0);\n"
" else if (u_layer == 2)\n"
" fragColor = textureLod(u_sampler, vec3(facepos.x, 1.0, facepos.y), 0.0);\n"
" else if (u_layer == 3)\n"
" fragColor = textureLod(u_sampler, vec3(facepos.x, -1.0, -facepos.y), 0.0);\n"
" else if (u_layer == 4)\n"
" fragColor = textureLod(u_sampler, vec3(facepos.x, -facepos.y, 1.0), 0.0);\n"
" else if (u_layer == 5)\n"
" fragColor = textureLod(u_sampler, vec3(-facepos.x, -facepos.y, -1.0), 0.0);\n"
" else\n"
" fragColor = vec4(1.0, 0.0, 1.0, 1.0);\n";
break;
case TARGET_3D:
case TARGET_2D_ARRAY:
case TARGET_2D_MS_ARRAY:
buf << " highp ivec2 screenpos = ivec2(floor(gl_FragCoord.xy));\n"
" fragColor = texelFetch(u_sampler, ivec3(screenpos, u_layer), 0);\n";
break;
case TARGET_1D_ARRAY:
buf << " highp ivec2 screenpos = ivec2(floor(gl_FragCoord.xy));\n"
" fragColor = texelFetch(u_sampler, ivec2(screenpos.x, u_layer), 0);\n";
break;
default:
DE_ASSERT(false);
}
buf << "}\n";
return specializeShader(buf.str(), contextType);
}
void LayeredRenderCase::renderToTexture(void)
{
const tcu::IVec3 texSize = getTargetDimensions(m_target);
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
glu::VertexArray vao(m_context.getRenderContext());
m_testCtx.getLog() << tcu::TestLog::Message << "Rendering to texture" << tcu::TestLog::EndMessage;
gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo);
gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
gl.clear(GL_COLOR_BUFFER_BIT);
gl.viewport(0, 0, texSize.x(), texSize.y());
gl.clear(GL_COLOR_BUFFER_BIT);
gl.bindVertexArray(*vao);
gl.useProgram(m_renderShader->getProgram());
gl.drawArrays(GL_POINTS, 0, 1);
gl.useProgram(0);
gl.bindVertexArray(0);
gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "render");
}
void LayeredRenderCase::sampleTextureLayer(tcu::Surface &dst, int layer)
{
DE_ASSERT(dst.getWidth() == m_resolveDimensions.x());
DE_ASSERT(dst.getHeight() == m_resolveDimensions.y());
static const tcu::Vec4 fullscreenQuad[4] = {
tcu::Vec4(-1.0f, -1.0f, 0.0f, 1.0f),
tcu::Vec4(-1.0f, 1.0f, 0.0f, 1.0f),
tcu::Vec4(1.0f, -1.0f, 0.0f, 1.0f),
tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f),
};
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
const int positionLoc = gl.getAttribLocation(m_samplerShader->getProgram(), "a_position");
glu::VertexArray vao(m_context.getRenderContext());
glu::Buffer buf(m_context.getRenderContext());
m_testCtx.getLog() << tcu::TestLog::Message << "Sampling from texture layer " << layer << tcu::TestLog::EndMessage;
gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
gl.clear(GL_COLOR_BUFFER_BIT);
gl.viewport(0, 0, m_resolveDimensions.x(), m_resolveDimensions.y());
GLU_EXPECT_NO_ERROR(gl.getError(), "clear");
gl.bindBuffer(GL_ARRAY_BUFFER, *buf);
gl.bufferData(GL_ARRAY_BUFFER, sizeof(fullscreenQuad), fullscreenQuad, GL_STATIC_DRAW);
GLU_EXPECT_NO_ERROR(gl.getError(), "buf");
gl.bindVertexArray(*vao);
gl.vertexAttribPointer(positionLoc, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL);
gl.enableVertexAttribArray(positionLoc);
GLU_EXPECT_NO_ERROR(gl.getError(), "setup attribs");
gl.activeTexture(GL_TEXTURE0);
gl.bindTexture(getTargetTextureTarget(m_target), m_texture);
GLU_EXPECT_NO_ERROR(gl.getError(), "bind texture");
gl.useProgram(m_samplerShader->getProgram());
gl.uniform1i(m_samplerLayerLoc, layer);
gl.uniform1i(m_samplerSamplerLoc, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "setup program");
gl.drawArrays(GL_TRIANGLE_STRIP, 0, 4);
GLU_EXPECT_NO_ERROR(gl.getError(), "draw");
gl.useProgram(0);
gl.bindVertexArray(0);
GLU_EXPECT_NO_ERROR(gl.getError(), "clean");
glu::readPixels(m_context.getRenderContext(), 0, 0, dst.getAccess());
}
bool LayeredRenderCase::verifyLayerContent(const tcu::Surface &layer, int layerNdx)
{
const tcu::Vec4 white = tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f);
const tcu::Vec4 red = tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f);
const tcu::Vec4 green = tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f);
const tcu::Vec4 blue = tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f);
const tcu::Vec4 yellow = tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f);
const tcu::Vec4 magenta = tcu::Vec4(1.0f, 0.0f, 1.0f, 1.0f);
const tcu::Vec4 colors[6] = {white, red, green, blue, yellow, magenta};
m_testCtx.getLog() << tcu::TestLog::Message << "Verifying layer contents" << tcu::TestLog::EndMessage;
switch (m_test)
{
case TEST_DEFAULT_LAYER:
if (layerNdx == 0)
return verifyImageSingleColoredRow(layer, 0.5f, white);
else
return verifyEmptyImage(layer);
case TEST_SINGLE_LAYER:
if (layerNdx == m_targetLayer)
return verifyImageSingleColoredRow(layer, 0.5f, white);
else
return verifyEmptyImage(layer);
case TEST_ALL_LAYERS:
case TEST_INVOCATION_PER_LAYER:
return verifyImageSingleColoredRow(layer, 0.5f, colors[layerNdx]);
case TEST_DIFFERENT_LAYERS:
case TEST_MULTIPLE_LAYERS_PER_INVOCATION:
if (layerNdx == 0)
return verifyEmptyImage(layer);
else
return verifyImageSingleColoredRow(layer, (float)layerNdx / (float)m_numLayers, white);
case TEST_LAYER_ID:
{
const tcu::Vec4 layerColor((layerNdx % 2 == 1) ? (1.0f) : (0.5f), ((layerNdx / 2) % 2 == 1) ? (1.0f) : (0.5f),
(layerNdx == 0) ? (1.0f) : (0.0f), 1.0f);
return verifyImageSingleColoredRow(layer, 0.5f, layerColor);
}
case TEST_LAYER_PROVOKING_VERTEX:
if (m_provokingVertex == GL_FIRST_VERTEX_CONVENTION)
{
if (layerNdx == 0)
return verifyImageSingleColoredRow(layer, 0.5f, white);
else
return verifyEmptyImage(layer);
}
else if (m_provokingVertex == GL_LAST_VERTEX_CONVENTION)
{
if (layerNdx == 1)
return verifyImageSingleColoredRow(layer, 0.5f, white);
else
return verifyEmptyImage(layer);
}
else
{
DE_ASSERT(false);
return false;
}
default:
DE_ASSERT(false);
return false;
};
}
bool LayeredRenderCase::verifyImageSingleColoredRow(const tcu::Surface &layer, float rowWidthRatio,
const tcu::Vec4 &barColor, bool logging)
{
DE_ASSERT(rowWidthRatio > 0.0f);
const int barLength = (int)(rowWidthRatio * (float)layer.getWidth());
const int barLengthThreshold = 1;
tcu::Surface errorMask(layer.getWidth(), layer.getHeight());
bool allPixelsOk = true;
if (logging)
m_testCtx.getLog() << tcu::TestLog::Message << "Expecting all pixels with distance less or equal to (about) "
<< barLength << " pixels from left border to be of color " << barColor.swizzle(0, 1, 2)
<< "." << tcu::TestLog::EndMessage;
tcu::clear(errorMask.getAccess(), tcu::RGBA::green().toIVec());
for (int y = 0; y < layer.getHeight(); ++y)
for (int x = 0; x < layer.getWidth(); ++x)
{
const tcu::RGBA color = layer.getPixel(x, y);
const tcu::RGBA refColor = tcu::RGBA(barColor);
const int threshold = 8;
const bool isBlack =
color.getRed() <= threshold || color.getGreen() <= threshold || color.getBlue() <= threshold;
const bool isColor = tcu::allEqual(
tcu::lessThan(tcu::abs(color.toIVec().swizzle(0, 1, 2) - refColor.toIVec().swizzle(0, 1, 2)),
tcu::IVec3(threshold, threshold, threshold)),
tcu::BVec3(true, true, true));
bool isOk;
if (x <= barLength - barLengthThreshold)
isOk = isColor;
else if (x >= barLength + barLengthThreshold)
isOk = isBlack;
else
isOk = isColor || isBlack;
allPixelsOk &= isOk;
if (!isOk)
errorMask.setPixel(x, y, tcu::RGBA::red());
}
if (allPixelsOk)
{
if (logging)
m_testCtx.getLog() << tcu::TestLog::Message << "Image is valid." << tcu::TestLog::EndMessage
<< tcu::TestLog::ImageSet("LayerContent", "Layer content")
<< tcu::TestLog::Image("Layer", "Layer", layer) << tcu::TestLog::EndImageSet;
return true;
}
else
{
if (logging)
m_testCtx.getLog() << tcu::TestLog::Message << "Image verification failed. Got unexpected pixels."
<< tcu::TestLog::EndMessage << tcu::TestLog::ImageSet("LayerContent", "Layer content")
<< tcu::TestLog::Image("Layer", "Layer", layer)
<< tcu::TestLog::Image("ErrorMask", "Errors", errorMask) << tcu::TestLog::EndImageSet;
return false;
}
// Note: never reached
if (logging)
m_testCtx.getLog() << tcu::TestLog::Image("LayerContent", "Layer content", layer);
return allPixelsOk;
}
bool LayeredRenderCase::verifyEmptyImage(const tcu::Surface &layer, bool logging)
{
// Expect black
if (logging)
m_testCtx.getLog() << tcu::TestLog::Message << "Expecting empty image" << tcu::TestLog::EndMessage;
for (int y = 0; y < layer.getHeight(); ++y)
for (int x = 0; x < layer.getWidth(); ++x)
{
const tcu::RGBA color = layer.getPixel(x, y);
const int threshold = 8;
const bool isBlack =
color.getRed() <= threshold || color.getGreen() <= threshold || color.getBlue() <= threshold;
if (!isBlack)
{
if (logging)
m_testCtx.getLog() << tcu::TestLog::Message << "Found (at least) one bad pixel at " << x << "," << y
<< ". Pixel color is not background color." << tcu::TestLog::EndMessage
<< tcu::TestLog::ImageSet("LayerContent", "Layer content")
<< tcu::TestLog::Image("Layer", "Layer", layer) << tcu::TestLog::EndImageSet;
return false;
}
}
if (logging)
m_testCtx.getLog() << tcu::TestLog::Message << "Image is valid" << tcu::TestLog::EndMessage;
return true;
}
bool LayeredRenderCase::verifyProvokingVertexLayers(const tcu::Surface &layer0, const tcu::Surface &layer1)
{
const bool layer0Empty = verifyEmptyImage(layer0, false);
const bool layer1Empty = verifyEmptyImage(layer1, false);
bool error = false;
// Both images could contain something if the quad triangles get assigned to different layers
m_testCtx.getLog() << tcu::TestLog::Message << "Expecting non-empty layers, or non-empty layer."
<< tcu::TestLog::EndMessage;
if (layer0Empty == true && layer1Empty == true)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Got empty images." << tcu::TestLog::EndMessage;
error = true;
}
// log images always
m_testCtx.getLog() << tcu::TestLog::ImageSet("LayerContent", "Layer content")
<< tcu::TestLog::Image("Layer", "Layer0", layer0)
<< tcu::TestLog::Image("Layer", "Layer1", layer1) << tcu::TestLog::EndImageSet;
if (error)
m_testCtx.getLog() << tcu::TestLog::Message << "Image verification failed." << tcu::TestLog::EndMessage;
else
m_testCtx.getLog() << tcu::TestLog::Message << "Image is valid." << tcu::TestLog::EndMessage;
return !error;
}
int LayeredRenderCase::getTargetLayers(LayeredRenderTargetType target)
{
switch (target)
{
case TARGET_CUBE:
return 6;
case TARGET_3D:
return 4;
case TARGET_1D_ARRAY:
return 4;
case TARGET_2D_ARRAY:
return 4;
case TARGET_2D_MS_ARRAY:
return 2;
default:
DE_ASSERT(false);
return 0;
}
}
glw::GLenum LayeredRenderCase::getTargetTextureTarget(LayeredRenderTargetType target)
{
switch (target)
{
case TARGET_CUBE:
return GL_TEXTURE_CUBE_MAP;
case TARGET_3D:
return GL_TEXTURE_3D;
case TARGET_1D_ARRAY:
return GL_TEXTURE_1D_ARRAY;
case TARGET_2D_ARRAY:
return GL_TEXTURE_2D_ARRAY;
case TARGET_2D_MS_ARRAY:
return GL_TEXTURE_2D_MULTISAMPLE_ARRAY;
default:
DE_ASSERT(false);
return 0;
}
}
tcu::IVec3 LayeredRenderCase::getTargetDimensions(LayeredRenderTargetType target)
{
switch (target)
{
case TARGET_CUBE:
return tcu::IVec3(64, 64, 0);
case TARGET_3D:
return tcu::IVec3(64, 64, 4);
case TARGET_1D_ARRAY:
return tcu::IVec3(64, 4, 0);
case TARGET_2D_ARRAY:
return tcu::IVec3(64, 64, 4);
case TARGET_2D_MS_ARRAY:
return tcu::IVec3(64, 64, 2);
default:
DE_ASSERT(false);
return tcu::IVec3(0, 0, 0);
}
}
tcu::IVec2 LayeredRenderCase::getResolveDimensions(LayeredRenderTargetType target)
{
switch (target)
{
case TARGET_CUBE:
return tcu::IVec2(64, 64);
case TARGET_3D:
return tcu::IVec2(64, 64);
case TARGET_1D_ARRAY:
return tcu::IVec2(64, 1);
case TARGET_2D_ARRAY:
return tcu::IVec2(64, 64);
case TARGET_2D_MS_ARRAY:
return tcu::IVec2(64, 64);
default:
DE_ASSERT(false);
return tcu::IVec2(0, 0);
}
}
class VaryingOutputCountCase : public GeometryShaderRenderTest
{
public:
enum ShaderInstancingMode
{
MODE_WITHOUT_INSTANCING = 0,
MODE_WITH_INSTANCING,
MODE_LAST
};
VaryingOutputCountCase(Context &context, const char *name, const char *desc,
VaryingOutputCountShader::VaryingSource test, ShaderInstancingMode mode);
private:
void init(void);
void deinit(void);
void preRender(sglr::Context &ctx, GLuint programID);
sglr::ShaderProgram &getProgram(void);
void genVertexAttribData(void);
void genVertexDataWithoutInstancing(void);
void genVertexDataWithInstancing(void);
VaryingOutputCountShader *m_program;
const VaryingOutputCountShader::VaryingSource m_test;
const ShaderInstancingMode m_mode;
int m_maxEmitCount;
};
VaryingOutputCountCase::VaryingOutputCountCase(Context &context, const char *name, const char *desc,
VaryingOutputCountShader::VaryingSource test, ShaderInstancingMode mode)
: GeometryShaderRenderTest(context, name, desc, GL_POINTS, GL_TRIANGLE_STRIP,
VaryingOutputCountShader::getAttributeName(test))
, m_program(DE_NULL)
, m_test(test)
, m_mode(mode)
, m_maxEmitCount(0)
{
DE_ASSERT(mode < MODE_LAST);
}
void VaryingOutputCountCase::init(void)
{
// Check requirements
if (!checkSupport(m_context))
TCU_THROW(NotSupportedError, "Tests require GL_EXT_geometry_shader extension or higher context version.");
if (m_test == VaryingOutputCountShader::READ_TEXTURE)
{
glw::GLint maxTextures = 0;
m_context.getRenderContext().getFunctions().getIntegerv(GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS, &maxTextures);
m_testCtx.getLog() << tcu::TestLog::Message << "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = " << maxTextures
<< tcu::TestLog::EndMessage;
if (maxTextures < 1)
throw tcu::NotSupportedError("Geometry shader texture units required");
}
// Get max emit count
{
const int componentsPerVertex = 4 + 4; // vec4 pos, vec4 color
glw::GLint maxVertices = 0;
glw::GLint maxComponents = 0;
m_context.getRenderContext().getFunctions().getIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES, &maxVertices);
m_context.getRenderContext().getFunctions().getIntegerv(GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS,
&maxComponents);
m_testCtx.getLog() << tcu::TestLog::Message << "GL_MAX_GEOMETRY_OUTPUT_VERTICES = " << maxVertices
<< tcu::TestLog::EndMessage;
m_testCtx.getLog() << tcu::TestLog::Message << "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = " << maxComponents
<< tcu::TestLog::EndMessage;
m_testCtx.getLog() << tcu::TestLog::Message << "Components per vertex = " << componentsPerVertex
<< tcu::TestLog::EndMessage;
if (maxVertices < 256)
throw tcu::TestError("MAX_GEOMETRY_OUTPUT_VERTICES was less than minimum required (256)");
if (maxComponents < 1024)
throw tcu::TestError("MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS was less than minimum required (1024)");
m_maxEmitCount = de::min(maxVertices, maxComponents / componentsPerVertex);
}
// Log what the test tries to do
m_testCtx.getLog() << tcu::TestLog::Message << "Rendering 4 n-gons with n = "
<< ((VaryingOutputCountShader::EMIT_COUNT_VERTEX_0 == -1) ?
(m_maxEmitCount) :
(VaryingOutputCountShader::EMIT_COUNT_VERTEX_0))
<< ", "
<< ((VaryingOutputCountShader::EMIT_COUNT_VERTEX_1 == -1) ?
(m_maxEmitCount) :
(VaryingOutputCountShader::EMIT_COUNT_VERTEX_1))
<< ", "
<< ((VaryingOutputCountShader::EMIT_COUNT_VERTEX_2 == -1) ?
(m_maxEmitCount) :
(VaryingOutputCountShader::EMIT_COUNT_VERTEX_2))
<< ", and "
<< ((VaryingOutputCountShader::EMIT_COUNT_VERTEX_3 == -1) ?
(m_maxEmitCount) :
(VaryingOutputCountShader::EMIT_COUNT_VERTEX_3))
<< ".\n"
<< "N is supplied to the geomery shader with "
<< ((m_test == VaryingOutputCountShader::READ_ATTRIBUTE) ? ("attribute") :
(m_test == VaryingOutputCountShader::READ_UNIFORM) ? ("uniform") :
("texture"))
<< tcu::TestLog::EndMessage;
// Gen shader
{
const bool instanced = (m_mode == MODE_WITH_INSTANCING);
DE_ASSERT(!m_program);
m_program =
new VaryingOutputCountShader(m_context.getRenderContext().getType(), m_test, m_maxEmitCount, instanced);
}
// Case init
GeometryShaderRenderTest::init();
}
void VaryingOutputCountCase::deinit(void)
{
if (m_program)
{
delete m_program;
m_program = DE_NULL;
}
GeometryShaderRenderTest::deinit();
}
void VaryingOutputCountCase::preRender(sglr::Context &ctx, GLuint programID)
{
if (m_test == VaryingOutputCountShader::READ_UNIFORM)
{
const int location = ctx.getUniformLocation(programID, "u_emitCount");
const int32_t emitCount[4] = {6, 0, m_maxEmitCount, 10};
if (location == -1)
throw tcu::TestError("uniform location of u_emitCount was -1.");
ctx.uniform4iv(location, 1, emitCount);
}
else if (m_test == VaryingOutputCountShader::READ_TEXTURE)
{
const uint8_t data[4 * 4] = {
255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255,
};
const int location = ctx.getUniformLocation(programID, "u_sampler");
GLuint texID = 0;
if (location == -1)
throw tcu::TestError("uniform location of u_sampler was -1.");
ctx.uniform1i(location, 0);
// \note we don't need to explicitly delete the texture, the sglr context will delete it
ctx.genTextures(1, &texID);
ctx.bindTexture(GL_TEXTURE_2D, texID);
ctx.texImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
ctx.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
ctx.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}
}
sglr::ShaderProgram &VaryingOutputCountCase::getProgram(void)
{
return *m_program;
}
void VaryingOutputCountCase::genVertexAttribData(void)
{
if (m_mode == MODE_WITHOUT_INSTANCING)
genVertexDataWithoutInstancing();
else if (m_mode == MODE_WITH_INSTANCING)
genVertexDataWithInstancing();
else
DE_ASSERT(false);
}
void VaryingOutputCountCase::genVertexDataWithoutInstancing(void)
{
m_numDrawVertices = 4;
m_vertexPosData.resize(4);
m_vertexAttrData.resize(4);
m_vertexPosData[0] = tcu::Vec4(0.5f, 0.0f, 0.0f, 1.0f);
m_vertexPosData[1] = tcu::Vec4(0.0f, 0.5f, 0.0f, 1.0f);
m_vertexPosData[2] = tcu::Vec4(-0.7f, -0.1f, 0.0f, 1.0f);
m_vertexPosData[3] = tcu::Vec4(-0.1f, -0.7f, 0.0f, 1.0f);
if (m_test == VaryingOutputCountShader::READ_ATTRIBUTE)
{
m_vertexAttrData[0] = tcu::Vec4(((VaryingOutputCountShader::EMIT_COUNT_VERTEX_0 == -1) ?
((float)m_maxEmitCount) :
((float)VaryingOutputCountShader::EMIT_COUNT_VERTEX_0)),
0.0f, 0.0f, 0.0f);
m_vertexAttrData[1] = tcu::Vec4(((VaryingOutputCountShader::EMIT_COUNT_VERTEX_1 == -1) ?
((float)m_maxEmitCount) :
((float)VaryingOutputCountShader::EMIT_COUNT_VERTEX_1)),
0.0f, 0.0f, 0.0f);
m_vertexAttrData[2] = tcu::Vec4(((VaryingOutputCountShader::EMIT_COUNT_VERTEX_2 == -1) ?
((float)m_maxEmitCount) :
((float)VaryingOutputCountShader::EMIT_COUNT_VERTEX_2)),
0.0f, 0.0f, 0.0f);
m_vertexAttrData[3] = tcu::Vec4(((VaryingOutputCountShader::EMIT_COUNT_VERTEX_3 == -1) ?
((float)m_maxEmitCount) :
((float)VaryingOutputCountShader::EMIT_COUNT_VERTEX_3)),
0.0f, 0.0f, 0.0f);
}
else
{
m_vertexAttrData[0] = tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f);
m_vertexAttrData[1] = tcu::Vec4(1.0f, 0.0f, 0.0f, 0.0f);
m_vertexAttrData[2] = tcu::Vec4(2.0f, 0.0f, 0.0f, 0.0f);
m_vertexAttrData[3] = tcu::Vec4(3.0f, 0.0f, 0.0f, 0.0f);
}
}
void VaryingOutputCountCase::genVertexDataWithInstancing(void)
{
m_numDrawVertices = 1;
m_vertexPosData.resize(1);
m_vertexAttrData.resize(1);
m_vertexPosData[0] = tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f);
if (m_test == VaryingOutputCountShader::READ_ATTRIBUTE)
{
const int emitCounts[] = {
(VaryingOutputCountShader::EMIT_COUNT_VERTEX_0 == -1) ? (m_maxEmitCount) :
(VaryingOutputCountShader::EMIT_COUNT_VERTEX_0),
(VaryingOutputCountShader::EMIT_COUNT_VERTEX_1 == -1) ? (m_maxEmitCount) :
(VaryingOutputCountShader::EMIT_COUNT_VERTEX_1),
(VaryingOutputCountShader::EMIT_COUNT_VERTEX_2 == -1) ? (m_maxEmitCount) :
(VaryingOutputCountShader::EMIT_COUNT_VERTEX_2),
(VaryingOutputCountShader::EMIT_COUNT_VERTEX_3 == -1) ? (m_maxEmitCount) :
(VaryingOutputCountShader::EMIT_COUNT_VERTEX_3),
};
m_vertexAttrData[0] =
tcu::Vec4((float)emitCounts[0], (float)emitCounts[1], (float)emitCounts[2], (float)emitCounts[3]);
}
else
{
// not used
m_vertexAttrData[0] = tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f);
}
}
class GeometryProgramQueryCase : public TestCase
{
public:
struct ProgramCase
{
const char *description;
const char *header;
int value;
};
GeometryProgramQueryCase(Context &context, const char *name, const char *description, glw::GLenum target);
void init(void);
IterateResult iterate(void);
private:
void expectProgramValue(uint32_t program, int value);
void expectQueryError(uint32_t program);
const glw::GLenum m_target;
protected:
std::vector<ProgramCase> m_cases;
};
GeometryProgramQueryCase::GeometryProgramQueryCase(Context &context, const char *name, const char *description,
glw::GLenum target)
: TestCase(context, name, description)
, m_target(target)
{
}
void GeometryProgramQueryCase::init(void)
{
if (!checkSupport(m_context))
TCU_THROW(NotSupportedError, "Tests require GL_EXT_geometry_shader extension or higher context version.");
}
GeometryProgramQueryCase::IterateResult GeometryProgramQueryCase::iterate(void)
{
const bool supportsES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
const std::string vertexSource = std::string(glu::getGLSLVersionDeclaration(
glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType()))) +
"\n"
"void main ()\n"
"{\n"
" gl_Position = vec4(0.0, 0.0, 0.0, 0.0);\n"
"}\n";
const std::string fragmentSource = std::string(glu::getGLSLVersionDeclaration(
glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType()))) +
"\n"
"layout(location = 0) out mediump vec4 fragColor;\n"
"void main ()\n"
"{\n"
" fragColor = vec4(0.0, 0.0, 0.0, 0.0);\n"
"}\n";
static const char *s_geometryBody = "void main ()\n"
"{\n"
" gl_Position = vec4(0.0, 0.0, 0.0, 0.0);\n"
" EmitVertex();\n"
"}\n";
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
// default cases
for (int ndx = 0; ndx < (int)m_cases.size(); ++ndx)
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Case", m_cases[ndx].description);
const std::string geometrySource = m_cases[ndx].header + std::string(s_geometryBody);
const glu::ShaderProgram program(m_context.getRenderContext(),
glu::ProgramSources()
<< glu::VertexSource(vertexSource) << glu::FragmentSource(fragmentSource)
<< glu::GeometrySource(specializeShader(
geometrySource, m_context.getRenderContext().getType())));
m_testCtx.getLog() << program;
expectProgramValue(program.getProgram(), m_cases[ndx].value);
}
// no geometry shader -case (INVALID OP)
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "NoGeometryShader", "No geometry shader");
const glu::ShaderProgram program(m_context.getRenderContext(), glu::ProgramSources()
<< glu::VertexSource(vertexSource)
<< glu::FragmentSource(fragmentSource));
m_testCtx.getLog() << program;
expectQueryError(program.getProgram());
}
// not linked -case (INVALID OP)
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "NotLinkedProgram", "Shader program not linked");
const std::string geometrySource =
std::string(glu::getGLSLVersionDeclaration(
glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType()))) +
"\n" + std::string(supportsES32 ? "" : "#extension GL_EXT_geometry_shader : require\n") +
"layout (triangles) in;\n"
"layout (points, max_vertices = 3) out;\n" +
std::string(s_geometryBody);
const char *const vtxSourcePtr = vertexSource.c_str();
const char *const fragSourcePtr = fragmentSource.c_str();
const char *const geomSourcePtr = geometrySource.c_str();
glu::Shader vertexShader(m_context.getRenderContext(), glu::SHADERTYPE_VERTEX);
glu::Shader fragmentShader(m_context.getRenderContext(), glu::SHADERTYPE_FRAGMENT);
glu::Shader geometryShader(m_context.getRenderContext(), glu::SHADERTYPE_GEOMETRY);
glu::Program program(m_context.getRenderContext());
vertexShader.setSources(1, &vtxSourcePtr, DE_NULL);
fragmentShader.setSources(1, &fragSourcePtr, DE_NULL);
geometryShader.setSources(1, &geomSourcePtr, DE_NULL);
vertexShader.compile();
fragmentShader.compile();
geometryShader.compile();
if (!vertexShader.getCompileStatus() || !fragmentShader.getCompileStatus() ||
!geometryShader.getCompileStatus())
throw tcu::TestError("Failed to compile shader");
program.attachShader(vertexShader.getShader());
program.attachShader(fragmentShader.getShader());
program.attachShader(geometryShader.getShader());
m_testCtx.getLog() << tcu::TestLog::Message << "Creating a program with geometry shader, but not linking it"
<< tcu::TestLog::EndMessage;
expectQueryError(program.getProgram());
}
return STOP;
}
void GeometryProgramQueryCase::expectProgramValue(uint32_t program, int value)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
gls::StateQueryUtil::StateQueryMemoryWriteGuard<glw::GLint> state;
gl.getProgramiv(program, m_target, &state);
GLU_EXPECT_NO_ERROR(gl.getError(), "getProgramiv");
m_testCtx.getLog() << tcu::TestLog::Message << glu::getProgramParamStr(m_target) << " = " << state
<< tcu::TestLog::EndMessage;
if (state != value)
{
m_testCtx.getLog() << tcu::TestLog::Message << "// ERROR: Expected " << value << ", got " << state
<< tcu::TestLog::EndMessage;
// don't overwrite error
if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS)
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid value");
}
}
void GeometryProgramQueryCase::expectQueryError(uint32_t program)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
glw::GLint dummy;
glw::GLenum errorCode;
m_testCtx.getLog() << tcu::TestLog::Message << "Querying " << glu::getProgramParamStr(m_target)
<< ", expecting INVALID_OPERATION" << tcu::TestLog::EndMessage;
gl.getProgramiv(program, m_target, &dummy);
errorCode = gl.getError();
if (errorCode != GL_INVALID_OPERATION)
{
m_testCtx.getLog() << tcu::TestLog::Message << "// ERROR: Expected INVALID_OPERATION, got "
<< glu::getErrorStr(errorCode) << tcu::TestLog::EndMessage;
// don't overwrite error
if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS)
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got unexpected error code");
}
}
class GeometryShaderInvocationsQueryCase : public GeometryProgramQueryCase
{
public:
GeometryShaderInvocationsQueryCase(Context &context, const char *name, const char *description);
};
GeometryShaderInvocationsQueryCase::GeometryShaderInvocationsQueryCase(Context &context, const char *name,
const char *description)
: GeometryProgramQueryCase(context, name, description, GL_GEOMETRY_SHADER_INVOCATIONS)
{
// 2 normal cases
m_cases.resize(2);
m_cases[0].description = "Default value";
m_cases[0].header = "${GLSL_VERSION_DECL}\n${GLSL_EXT_GEOMETRY_SHADER}layout (triangles) in;\nlayout (points, "
"max_vertices = 3) out;\n";
m_cases[0].value = 1;
m_cases[1].description = "Value declared";
m_cases[1].header = "${GLSL_VERSION_DECL}\n${GLSL_EXT_GEOMETRY_SHADER}layout (triangles, invocations=2) "
"in;\nlayout (points, max_vertices = 3) out;\n";
m_cases[1].value = 2;
}
class GeometryShaderVerticesQueryCase : public GeometryProgramQueryCase
{
public:
GeometryShaderVerticesQueryCase(Context &context, const char *name, const char *description);
};
GeometryShaderVerticesQueryCase::GeometryShaderVerticesQueryCase(Context &context, const char *name,
const char *description)
: GeometryProgramQueryCase(context, name, description, GL_GEOMETRY_LINKED_VERTICES_OUT_EXT)
{
m_cases.resize(1);
m_cases[0].description = "max_vertices = 1";
m_cases[0].header = "${GLSL_VERSION_DECL}\n${GLSL_EXT_GEOMETRY_SHADER}layout (triangles) in;\nlayout (points, "
"max_vertices = 1) out;\n";
m_cases[0].value = 1;
}
class GeometryShaderInputQueryCase : public GeometryProgramQueryCase
{
public:
GeometryShaderInputQueryCase(Context &context, const char *name, const char *description);
};
GeometryShaderInputQueryCase::GeometryShaderInputQueryCase(Context &context, const char *name, const char *description)
: GeometryProgramQueryCase(context, name, description, GL_GEOMETRY_LINKED_INPUT_TYPE_EXT)
{
m_cases.resize(3);
m_cases[0].description = "Triangles";
m_cases[0].header = "${GLSL_VERSION_DECL}\n${GLSL_EXT_GEOMETRY_SHADER}layout (triangles) in;\nlayout (points, "
"max_vertices = 3) out;\n";
m_cases[0].value = GL_TRIANGLES;
m_cases[1].description = "Lines";
m_cases[1].header =
"${GLSL_VERSION_DECL}\n${GLSL_EXT_GEOMETRY_SHADER}layout (lines) in;\nlayout (points, max_vertices = 3) out;\n";
m_cases[1].value = GL_LINES;
m_cases[2].description = "Points";
m_cases[2].header = "${GLSL_VERSION_DECL}\n${GLSL_EXT_GEOMETRY_SHADER}layout (points) in;\nlayout (points, "
"max_vertices = 3) out;\n";
m_cases[2].value = GL_POINTS;
}
class GeometryShaderOutputQueryCase : public GeometryProgramQueryCase
{
public:
GeometryShaderOutputQueryCase(Context &context, const char *name, const char *description);
};
GeometryShaderOutputQueryCase::GeometryShaderOutputQueryCase(Context &context, const char *name,
const char *description)
: GeometryProgramQueryCase(context, name, description, GL_GEOMETRY_LINKED_OUTPUT_TYPE_EXT)
{
m_cases.resize(3);
m_cases[0].description = "Triangle strip";
m_cases[0].header = "${GLSL_VERSION_DECL}\n${GLSL_EXT_GEOMETRY_SHADER}layout (triangles) in;\nlayout "
"(triangle_strip, max_vertices = 3) out;\n";
m_cases[0].value = GL_TRIANGLE_STRIP;
m_cases[1].description = "Lines";
m_cases[1].header = "${GLSL_VERSION_DECL}\n${GLSL_EXT_GEOMETRY_SHADER}layout (triangles) in;\nlayout (line_strip, "
"max_vertices = 3) out;\n";
m_cases[1].value = GL_LINE_STRIP;
m_cases[2].description = "Points";
m_cases[2].header = "${GLSL_VERSION_DECL}\n${GLSL_EXT_GEOMETRY_SHADER}layout (triangles) in;\nlayout (points, "
"max_vertices = 3) out;\n";
m_cases[2].value = GL_POINTS;
}
class ImplementationLimitCase : public TestCase
{
public:
ImplementationLimitCase(Context &context, const char *name, const char *description, glw::GLenum target,
int minValue);
void init(void);
IterateResult iterate(void);
const glw::GLenum m_target;
const int m_minValue;
};
ImplementationLimitCase::ImplementationLimitCase(Context &context, const char *name, const char *description,
glw::GLenum target, int minValue)
: TestCase(context, name, description)
, m_target(target)
, m_minValue(minValue)
{
}
void ImplementationLimitCase::init(void)
{
if (!checkSupport(m_context))
TCU_THROW(NotSupportedError, "Tests require GL_EXT_geometry_shader extension or higher context version.");
}
ImplementationLimitCase::IterateResult ImplementationLimitCase::iterate(void)
{
glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: ");
gl.enableLogging(true);
verifyStateIntegerMin(result, gl, m_target, m_minValue, QUERY_INTEGER);
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Types", "Alternative queries");
verifyStateIntegerMin(result, gl, m_target, m_minValue, QUERY_BOOLEAN);
verifyStateIntegerMin(result, gl, m_target, m_minValue, QUERY_INTEGER64);
verifyStateIntegerMin(result, gl, m_target, m_minValue, QUERY_FLOAT);
}
result.setTestContextResult(m_testCtx);
return STOP;
}
class LayerProvokingVertexQueryCase : public TestCase
{
public:
LayerProvokingVertexQueryCase(Context &context, const char *name, const char *description);
void init(void);
IterateResult iterate(void);
};
LayerProvokingVertexQueryCase::LayerProvokingVertexQueryCase(Context &context, const char *name,
const char *description)
: TestCase(context, name, description)
{
}
void LayerProvokingVertexQueryCase::init(void)
{
if (!checkSupport(m_context))
TCU_THROW(NotSupportedError, "Tests require GL_EXT_geometry_shader extension or higher context version.");
}
LayerProvokingVertexQueryCase::IterateResult LayerProvokingVertexQueryCase::iterate(void)
{
glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: ");
QueriedState state;
gl.enableLogging(true);
queryState(result, gl, QUERY_INTEGER, GL_LAYER_PROVOKING_VERTEX, state);
if (!state.isUndefined())
{
m_testCtx.getLog() << tcu::TestLog::Message
<< "LAYER_PROVOKING_VERTEX = " << glu::getProvokingVertexStr(state.getIntAccess())
<< tcu::TestLog::EndMessage;
bool ok = true;
std::string expectedValue;
if (contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(3, 2)))
{
if (state.getIntAccess() != GL_FIRST_VERTEX_CONVENTION &&
state.getIntAccess() != GL_LAST_VERTEX_CONVENTION && state.getIntAccess() != GL_PROVOKING_VERTEX &&
state.getIntAccess() != GL_UNDEFINED_VERTEX)
{
ok = false;
expectedValue =
"any of {FIRST_VERTEX_CONVENTION, LAST_VERTEX_CONVENTION, GL_PROVOKING_VERTEX, UNDEFINED_VERTEX}";
}
}
else if (state.getIntAccess() != GL_FIRST_VERTEX_CONVENTION &&
state.getIntAccess() != GL_LAST_VERTEX_CONVENTION && state.getIntAccess() != GL_UNDEFINED_VERTEX)
{
ok = false;
expectedValue = "any of {FIRST_VERTEX_CONVENTION, LAST_VERTEX_CONVENTION, UNDEFINED_VERTEX}";
}
if (!ok)
{
m_testCtx.getLog() << tcu::TestLog::Message
<< "getInteger(GL_LAYER_PROVOKING_VERTEX) returned illegal value. Got "
<< state.getIntAccess() << "\n"
<< "Expected " << expectedValue << "." << tcu::TestLog::EndMessage;
result.fail("got unexpected provoking vertex value");
}
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Types", "Alternative queries");
verifyStateInteger(result, gl, GL_LAYER_PROVOKING_VERTEX, state.getIntAccess(), QUERY_BOOLEAN);
verifyStateInteger(result, gl, GL_LAYER_PROVOKING_VERTEX, state.getIntAccess(), QUERY_INTEGER64);
verifyStateInteger(result, gl, GL_LAYER_PROVOKING_VERTEX, state.getIntAccess(), QUERY_FLOAT);
}
}
result.setTestContextResult(m_testCtx);
return STOP;
}
class GeometryInvocationCase : public GeometryShaderRenderTest
{
public:
enum OutputCase
{
CASE_FIXED_OUTPUT_COUNTS = 0,
CASE_DIFFERENT_OUTPUT_COUNTS,
CASE_LAST
};
GeometryInvocationCase(Context &context, const char *name, const char *description, int numInvocations,
OutputCase testCase);
~GeometryInvocationCase(void);
void init(void);
void deinit(void);
private:
sglr::ShaderProgram &getProgram(void);
void genVertexAttribData(void);
static InvocationCountShader::OutputCase mapToShaderCaseType(OutputCase testCase);
const OutputCase m_testCase;
int m_numInvocations;
InvocationCountShader *m_program;
};
GeometryInvocationCase::GeometryInvocationCase(Context &context, const char *name, const char *description,
int numInvocations, OutputCase testCase)
: GeometryShaderRenderTest(context, name, description, GL_POINTS, GL_TRIANGLE_STRIP, "a_color")
, m_testCase(testCase)
, m_numInvocations(numInvocations)
, m_program(DE_NULL)
{
DE_ASSERT(m_testCase < CASE_LAST);
}
GeometryInvocationCase::~GeometryInvocationCase(void)
{
deinit();
}
void GeometryInvocationCase::init(void)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
int maxGeometryShaderInvocations = 0;
int maxComponents = 0;
// requirements
if (!checkSupport(m_context))
TCU_THROW(NotSupportedError, "Tests require GL_EXT_geometry_shader extension or higher context version.");
gl.getIntegerv(GL_MAX_GEOMETRY_SHADER_INVOCATIONS, &maxGeometryShaderInvocations);
GLU_EXPECT_NO_ERROR(gl.getError(), "getIntegerv(GL_MAX_GEOMETRY_SHADER_INVOCATIONS)");
gl.getIntegerv(GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS, &maxComponents);
GLU_EXPECT_NO_ERROR(gl.getError(), "getIntegerv(GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS)");
m_testCtx.getLog() << tcu::TestLog::Message
<< "GL_MAX_GEOMETRY_SHADER_INVOCATIONS = " << maxGeometryShaderInvocations
<< tcu::TestLog::EndMessage;
// set target num invocations
if (m_numInvocations == -1)
m_numInvocations = maxGeometryShaderInvocations;
else if (maxGeometryShaderInvocations < m_numInvocations)
throw tcu::NotSupportedError("Test requires larger GL_MAX_GEOMETRY_SHADER_INVOCATIONS");
if (m_testCase == CASE_DIFFERENT_OUTPUT_COUNTS)
{
const int maxEmitCount = m_numInvocations + 2;
const int numComponents = 8; // pos + color
if (maxEmitCount * numComponents > maxComponents)
throw tcu::NotSupportedError("Test requires larger GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS");
}
// Log what the test tries to do
if (m_testCase == CASE_FIXED_OUTPUT_COUNTS)
{
m_testCtx.getLog() << tcu::TestLog::Message
<< "Rendering triangles in a partial circle formation with a geometry shader. Each triangle "
"is generated by a separate invocation.\n"
<< "Drawing 2 points, each generating " << m_numInvocations << " triangles."
<< tcu::TestLog::EndMessage;
}
else if (m_testCase == CASE_DIFFERENT_OUTPUT_COUNTS)
{
m_testCtx.getLog() << tcu::TestLog::Message
<< "Rendering n-gons in a partial circle formation with a geometry shader. Each n-gon is "
"generated by a separate invocation.\n"
<< "Drawing 2 points, each generating " << m_numInvocations << " n-gons."
<< tcu::TestLog::EndMessage;
}
else
DE_ASSERT(false);
// resources
m_program = new InvocationCountShader(m_context.getRenderContext().getType(), m_numInvocations,
mapToShaderCaseType(m_testCase));
GeometryShaderRenderTest::init();
}
void GeometryInvocationCase::deinit(void)
{
if (m_program)
{
delete m_program;
m_program = DE_NULL;
}
GeometryShaderRenderTest::deinit();
}
sglr::ShaderProgram &GeometryInvocationCase::getProgram(void)
{
return *m_program;
}
void GeometryInvocationCase::genVertexAttribData(void)
{
m_vertexPosData.resize(2);
m_vertexPosData[0] = tcu::Vec4(0.0f, -0.3f, 0.0f, 1.0f);
m_vertexPosData[1] = tcu::Vec4(0.2f, 0.3f, 0.0f, 1.0f);
m_vertexAttrData.resize(2);
m_vertexAttrData[0] = tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f);
m_vertexAttrData[1] = tcu::Vec4(0.8f, 0.8f, 0.8f, 1.0f);
m_numDrawVertices = 2;
}
InvocationCountShader::OutputCase GeometryInvocationCase::mapToShaderCaseType(OutputCase testCase)
{
switch (testCase)
{
case CASE_FIXED_OUTPUT_COUNTS:
return InvocationCountShader::CASE_FIXED_OUTPUT_COUNTS;
case CASE_DIFFERENT_OUTPUT_COUNTS:
return InvocationCountShader::CASE_DIFFERENT_OUTPUT_COUNTS;
default:
DE_ASSERT(false);
return InvocationCountShader::CASE_LAST;
}
}
class DrawInstancedGeometryInstancedCase : public GeometryShaderRenderTest
{
public:
DrawInstancedGeometryInstancedCase(Context &context, const char *name, const char *description, int numInstances,
int numInvocations);
~DrawInstancedGeometryInstancedCase(void);
private:
void init(void);
void deinit(void);
sglr::ShaderProgram &getProgram(void);
void genVertexAttribData(void);
const int m_numInstances;
const int m_numInvocations;
InstancedExpansionShader *m_program;
};
DrawInstancedGeometryInstancedCase::DrawInstancedGeometryInstancedCase(Context &context, const char *name,
const char *description, int numInstances,
int numInvocations)
: GeometryShaderRenderTest(context, name, description, GL_POINTS, GL_TRIANGLE_STRIP, "a_offset",
FLAG_DRAW_INSTANCED)
, m_numInstances(numInstances)
, m_numInvocations(numInvocations)
, m_program(DE_NULL)
{
}
DrawInstancedGeometryInstancedCase::~DrawInstancedGeometryInstancedCase(void)
{
}
void DrawInstancedGeometryInstancedCase::init(void)
{
m_program = new InstancedExpansionShader(m_context.getRenderContext().getType(), m_numInvocations);
m_testCtx.getLog() << tcu::TestLog::Message << "Rendering a single point with " << m_numInstances << " instances. "
<< "Each geometry shader is invoked " << m_numInvocations << " times for each primitive. "
<< tcu::TestLog::EndMessage;
GeometryShaderRenderTest::init();
}
void DrawInstancedGeometryInstancedCase::deinit(void)
{
if (m_program)
{
delete m_program;
m_program = DE_NULL;
}
GeometryShaderRenderTest::deinit();
}
sglr::ShaderProgram &DrawInstancedGeometryInstancedCase::getProgram(void)
{
return *m_program;
}
void DrawInstancedGeometryInstancedCase::genVertexAttribData(void)
{
m_numDrawVertices = 1;
m_numDrawInstances = m_numInstances;
m_vertexAttrDivisor = 1;
m_vertexPosData.resize(1);
m_vertexAttrData.resize(8);
m_vertexPosData[0] = tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f);
m_vertexAttrData[0] = tcu::Vec4(0.5f, 0.0f, 0.0f, 0.0f);
m_vertexAttrData[1] = tcu::Vec4(0.0f, 0.5f, 0.0f, 0.0f);
m_vertexAttrData[2] = tcu::Vec4(-0.7f, -0.1f, 0.0f, 0.0f);
m_vertexAttrData[3] = tcu::Vec4(-0.1f, -0.7f, 0.0f, 0.0f);
m_vertexAttrData[4] = tcu::Vec4(-0.8f, -0.7f, 0.0f, 0.0f);
m_vertexAttrData[5] = tcu::Vec4(-0.9f, 0.6f, 0.0f, 0.0f);
m_vertexAttrData[6] = tcu::Vec4(-0.8f, 0.3f, 0.0f, 0.0f);
m_vertexAttrData[7] = tcu::Vec4(-0.1f, 0.1f, 0.0f, 0.0f);
DE_ASSERT(m_numInstances <= (int)m_vertexAttrData.size());
}
class GeometryProgramLimitCase : public TestCase
{
public:
GeometryProgramLimitCase(Context &context, const char *name, const char *description, glw::GLenum apiName,
const std::string &glslName, int limit);
private:
void init(void);
IterateResult iterate(void);
const glw::GLenum m_apiName;
const std::string m_glslName;
const int m_limit;
};
GeometryProgramLimitCase::GeometryProgramLimitCase(Context &context, const char *name, const char *description,
glw::GLenum apiName, const std::string &glslName, int limit)
: TestCase(context, name, description)
, m_apiName(apiName)
, m_glslName(glslName)
, m_limit(limit)
{
}
void GeometryProgramLimitCase::init(void)
{
if (!checkSupport(m_context))
TCU_THROW(NotSupportedError, "Tests require GL_EXT_geometry_shader extension or higher context version.");
}
GeometryProgramLimitCase::IterateResult GeometryProgramLimitCase::iterate(void)
{
tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: ");
int limit;
// query limit
{
gls::StateQueryUtil::StateQueryMemoryWriteGuard<glw::GLint> state;
glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
gl.enableLogging(true);
gl.glGetIntegerv(m_apiName, &state);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "getIntegerv()");
m_testCtx.getLog() << tcu::TestLog::Message << glu::getGettableStateStr(m_apiName) << " = " << state
<< tcu::TestLog::EndMessage;
if (!state.verifyValidity(result))
{
result.setTestContextResult(m_testCtx);
return STOP;
}
if (state < m_limit)
{
result.fail("Minimum value = " + de::toString(m_limit) + ", got " + de::toString(state.get()));
result.setTestContextResult(m_testCtx);
return STOP;
}
limit = state;
// verify other getters
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Types", "Alternative queries");
verifyStateInteger(result, gl, m_apiName, limit, QUERY_BOOLEAN);
verifyStateInteger(result, gl, m_apiName, limit, QUERY_INTEGER64);
verifyStateInteger(result, gl, m_apiName, limit, QUERY_FLOAT);
}
}
// verify limit is the same in GLSL
{
static const char *const vertexSource = "${GLSL_VERSION_DECL}\n"
"void main ()\n"
"{\n"
" gl_Position = vec4(0.0, 0.0, 0.0, 0.0);\n"
"}\n";
static const char *const fragmentSource = "${GLSL_VERSION_DECL}\n"
"layout(location = 0) out mediump vec4 fragColor;\n"
"void main ()\n"
"{\n"
" fragColor = vec4(0.0, 0.0, 0.0, 0.0);\n"
"}\n";
const std::string geometrySource =
"${GLSL_VERSION_DECL}\n"
"${GLSL_EXT_GEOMETRY_SHADER}"
"layout(points) in;\n"
"layout(points, max_vertices = 1) out;\n"
"void main ()\n"
"{\n"
" // Building the shader will fail if the constant value is not the expected\n"
" const mediump int cArraySize = (gl_" +
m_glslName + " == " + de::toString(limit) +
") ? (1) : (-1);\n"
" float[cArraySize] fArray;\n"
" fArray[0] = 0.0f;\n"
" gl_Position = vec4(0.0, 0.0, 0.0, fArray[0]);\n"
" EmitVertex();\n"
"}\n";
const de::UniquePtr<glu::ShaderProgram> program(new glu::ShaderProgram(
m_context.getRenderContext(),
glu::ProgramSources() << glu::VertexSource(
specializeShader(vertexSource, m_context.getRenderContext().getType()))
<< glu::FragmentSource(
specializeShader(fragmentSource, m_context.getRenderContext().getType()))
<< glu::GeometrySource(
specializeShader(geometrySource, m_context.getRenderContext().getType()))));
m_testCtx.getLog() << tcu::TestLog::Message << "Building a test shader to verify GLSL constant " << m_glslName
<< " value." << tcu::TestLog::EndMessage;
m_testCtx.getLog() << *program;
if (!program->isOk())
{
// compile failed, assume static assert failed
result.fail("Shader build failed");
result.setTestContextResult(m_testCtx);
return STOP;
}
m_testCtx.getLog() << tcu::TestLog::Message << "Build ok" << tcu::TestLog::EndMessage;
}
result.setTestContextResult(m_testCtx);
return STOP;
}
class PrimitivesGeneratedQueryCase : public TestCase
{
public:
enum QueryTest
{
TEST_NO_GEOMETRY = 0,
TEST_NO_AMPLIFICATION,
TEST_AMPLIFICATION,
TEST_PARTIAL_PRIMITIVES,
TEST_INSTANCED,
TEST_LAST
};
PrimitivesGeneratedQueryCase(Context &context, const char *name, const char *description, QueryTest test);
~PrimitivesGeneratedQueryCase(void);
private:
void init(void);
void deinit(void);
IterateResult iterate(void);
glu::ShaderProgram *genProgram(void);
const QueryTest m_test;
glu::ShaderProgram *m_program;
};
PrimitivesGeneratedQueryCase::PrimitivesGeneratedQueryCase(Context &context, const char *name, const char *description,
QueryTest test)
: TestCase(context, name, description)
, m_test(test)
, m_program(DE_NULL)
{
DE_ASSERT(m_test < TEST_LAST);
}
PrimitivesGeneratedQueryCase::~PrimitivesGeneratedQueryCase(void)
{
deinit();
}
void PrimitivesGeneratedQueryCase::init(void)
{
// requirements
if (!checkSupport(m_context))
TCU_THROW(NotSupportedError, "Tests require GL_EXT_geometry_shader extension or higher context version.");
// log what test tries to do
if (m_test == TEST_NO_GEOMETRY)
m_testCtx.getLog() << tcu::TestLog::Message
<< "Querying PRIMITIVES_GENERATED while rendering without a geometry shader."
<< tcu::TestLog::EndMessage;
else if (m_test == TEST_NO_AMPLIFICATION)
m_testCtx.getLog() << tcu::TestLog::Message
<< "Querying PRIMITIVES_GENERATED while rendering with a non-amplifying geometry shader."
<< tcu::TestLog::EndMessage;
else if (m_test == TEST_AMPLIFICATION)
m_testCtx.getLog() << tcu::TestLog::Message
<< "Querying PRIMITIVES_GENERATED while rendering with a (3x) amplifying geometry shader."
<< tcu::TestLog::EndMessage;
else if (m_test == TEST_PARTIAL_PRIMITIVES)
m_testCtx.getLog() << tcu::TestLog::Message
<< "Querying PRIMITIVES_GENERATED while rendering with a geometry shader that emits also "
"partial primitives."
<< tcu::TestLog::EndMessage;
else if (m_test == TEST_INSTANCED)
m_testCtx.getLog() << tcu::TestLog::Message
<< "Querying PRIMITIVES_GENERATED while rendering with a instanced geometry shader."
<< tcu::TestLog::EndMessage;
else
DE_ASSERT(false);
// resources
m_program = genProgram();
m_testCtx.getLog() << *m_program;
if (!m_program->isOk())
throw tcu::TestError("could not build program");
}
void PrimitivesGeneratedQueryCase::deinit(void)
{
delete m_program;
m_program = DE_NULL;
}
PrimitivesGeneratedQueryCase::IterateResult PrimitivesGeneratedQueryCase::iterate(void)
{
glw::GLuint primitivesGenerated = 0xDEBADBAD;
m_testCtx.getLog() << tcu::TestLog::Message
<< "Drawing 8 points, setting a_one for each to value (1.0, 1.0, 1.0, 1.0)"
<< tcu::TestLog::EndMessage;
{
static const tcu::Vec4 vertexData[8 * 2] = {
tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), tcu::Vec4(0.1f, 0.0f, 0.0f, 1.0f),
tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), tcu::Vec4(0.2f, 0.0f, 0.0f, 1.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f),
tcu::Vec4(0.3f, 0.0f, 0.0f, 1.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), tcu::Vec4(0.4f, 0.0f, 0.0f, 1.0f),
tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), tcu::Vec4(0.5f, 0.0f, 0.0f, 1.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f),
tcu::Vec4(0.6f, 0.0f, 0.0f, 1.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), tcu::Vec4(0.7f, 0.0f, 0.0f, 1.0f),
tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f),
};
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
const glu::VertexArray vao(m_context.getRenderContext());
const glu::Buffer buffer(m_context.getRenderContext());
const glu::Query query(m_context.getRenderContext());
const int positionLocation = gl.getAttribLocation(m_program->getProgram(), "a_position");
const int oneLocation = gl.getAttribLocation(m_program->getProgram(), "a_one");
gl.bindVertexArray(*vao);
gl.bindBuffer(GL_ARRAY_BUFFER, *buffer);
gl.bufferData(GL_ARRAY_BUFFER, (int)sizeof(vertexData), vertexData, GL_STATIC_DRAW);
gl.vertexAttribPointer(positionLocation, 4, GL_FLOAT, GL_FALSE, 2 * (int)sizeof(tcu::Vec4), DE_NULL);
gl.enableVertexAttribArray(positionLocation);
if (oneLocation != -1)
{
gl.vertexAttribPointer(oneLocation, 4, GL_FLOAT, GL_FALSE, 2 * (int)sizeof(tcu::Vec4),
glu::BufferOffsetAsPointer(1 * sizeof(tcu::Vec4)));
gl.enableVertexAttribArray(oneLocation);
}
gl.useProgram(m_program->getProgram());
GLU_EXPECT_NO_ERROR(gl.getError(), "setup render");
gl.beginQuery(GL_PRIMITIVES_GENERATED, *query);
gl.drawArrays(GL_POINTS, 0, 8);
gl.endQuery(GL_PRIMITIVES_GENERATED);
GLU_EXPECT_NO_ERROR(gl.getError(), "render and query");
gl.getQueryObjectuiv(*query, GL_QUERY_RESULT, &primitivesGenerated);
GLU_EXPECT_NO_ERROR(gl.getError(), "get query result");
}
m_testCtx.getLog() << tcu::TestLog::Message << "GL_PRIMITIVES_GENERATED = " << primitivesGenerated
<< tcu::TestLog::EndMessage;
{
const uint32_t expectedGenerated = (m_test == TEST_AMPLIFICATION) ? (3 * 8) :
(m_test == TEST_INSTANCED) ? (8 * (3 + 1)) :
(8);
if (expectedGenerated == primitivesGenerated)
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
else
{
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got wrong result for GL_PRIMITIVES_GENERATED");
m_testCtx.getLog() << tcu::TestLog::Message
<< "Got unexpected result for GL_PRIMITIVES_GENERATED. Expected " << expectedGenerated
<< ", got " << primitivesGenerated << tcu::TestLog::EndMessage;
}
}
return STOP;
}
glu::ShaderProgram *PrimitivesGeneratedQueryCase::genProgram(void)
{
static const char *const vertexSource = "${GLSL_VERSION_DECL}\n"
"in highp vec4 a_position;\n"
"in highp vec4 a_one;\n"
"out highp vec4 v_one;\n"
"void main (void)\n"
"{\n"
" gl_Position = a_position;\n"
" v_one = a_one;\n"
"}\n";
static const char *const fragmentSource = "${GLSL_VERSION_DECL}\n"
"layout(location = 0) out mediump vec4 fragColor;\n"
"void main (void)\n"
"{\n"
" fragColor = vec4(1.0, 1.0, 1.0, 1.0);\n"
"}\n";
std::ostringstream geometrySource;
glu::ProgramSources sources;
if (m_test != TEST_NO_GEOMETRY)
{
geometrySource << "${GLSL_VERSION_DECL}\n"
"${GLSL_EXT_GEOMETRY_SHADER}"
"layout(points"
<< ((m_test == TEST_INSTANCED) ? (", invocations = 3") : (""))
<< ") in;\n"
"layout(triangle_strip, max_vertices = 7) out;\n"
"in highp vec4 v_one[];\n"
"void main (void)\n"
"{\n"
" // always taken\n"
" if (v_one[0].x != 0.0)\n"
" {\n"
" gl_Position = gl_in[0].gl_Position + vec4(0.0, 0.1, 0.0, 0.0);\n"
" EmitVertex();\n"
" gl_Position = gl_in[0].gl_Position + vec4(0.1, 0.0, 0.0, 0.0);\n"
" EmitVertex();\n"
" gl_Position = gl_in[0].gl_Position - vec4(0.1, 0.0, 0.0, 0.0);\n"
" EmitVertex();\n"
" EndPrimitive();\n"
" }\n";
if (m_test == TEST_AMPLIFICATION)
{
geometrySource << "\n"
" // always taken\n"
" if (v_one[0].y != 0.0)\n"
" {\n"
" gl_Position = gl_in[0].gl_Position + vec4(0.0, 0.1, 0.0, 0.0);\n"
" EmitVertex();\n"
" gl_Position = gl_in[0].gl_Position + vec4(0.1, 0.0, 0.0, 0.0);\n"
" EmitVertex();\n"
" gl_Position = gl_in[0].gl_Position - vec4(0.0, 0.1, 0.0, 0.0);\n"
" EmitVertex();\n"
" gl_Position = gl_in[0].gl_Position - vec4(0.1, 0.0, 0.0, 0.0);\n"
" EmitVertex();\n"
" }\n";
}
else if (m_test == TEST_PARTIAL_PRIMITIVES)
{
geometrySource << "\n"
" // always taken\n"
" if (v_one[0].y != 0.0)\n"
" {\n"
" gl_Position = gl_in[0].gl_Position + vec4(0.0, 0.1, 0.0, 0.0);\n"
" EmitVertex();\n"
" gl_Position = gl_in[0].gl_Position + vec4(0.1, 0.0, 0.0, 0.0);\n"
" EmitVertex();\n"
"\n"
" // never taken\n"
" if (v_one[0].z < 0.0)\n"
" {\n"
" gl_Position = gl_in[0].gl_Position - vec4(0.1, 0.0, 0.0, 0.0);\n"
" EmitVertex();\n"
" }\n"
" }\n";
}
else if (m_test == TEST_INSTANCED)
{
geometrySource << "\n"
" // taken once\n"
" if (v_one[0].y > float(gl_InvocationID) + 0.5)\n"
" {\n"
" gl_Position = gl_in[0].gl_Position + vec4(0.0, 0.1, 0.0, 0.0);\n"
" EmitVertex();\n"
" gl_Position = gl_in[0].gl_Position + vec4(0.1, 0.0, 0.0, 0.0);\n"
" EmitVertex();\n"
" gl_Position = gl_in[0].gl_Position - vec4(0.1, 0.0, 0.0, 0.0);\n"
" EmitVertex();\n"
" }\n";
}
geometrySource << "}\n";
}
sources << glu::VertexSource(specializeShader(vertexSource, m_context.getRenderContext().getType()));
sources << glu::FragmentSource(specializeShader(fragmentSource, m_context.getRenderContext().getType()));
if (!geometrySource.str().empty())
sources << glu::GeometrySource(specializeShader(geometrySource.str(), m_context.getRenderContext().getType()));
return new glu::ShaderProgram(m_context.getRenderContext(), sources);
}
class PrimitivesGeneratedQueryObjectQueryCase : public TestCase
{
public:
PrimitivesGeneratedQueryObjectQueryCase(Context &context, const char *name, const char *description);
void init(void);
IterateResult iterate(void);
};
PrimitivesGeneratedQueryObjectQueryCase::PrimitivesGeneratedQueryObjectQueryCase(Context &context, const char *name,
const char *description)
: TestCase(context, name, description)
{
}
void PrimitivesGeneratedQueryObjectQueryCase::init(void)
{
if (!checkSupport(m_context))
TCU_THROW(NotSupportedError, "Tests require GL_EXT_geometry_shader extension or higher context version.");
}
PrimitivesGeneratedQueryObjectQueryCase::IterateResult PrimitivesGeneratedQueryObjectQueryCase::iterate(void)
{
glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: ");
gl.enableLogging(true);
{
glw::GLuint query = 0;
verifyStateQueryInteger(result, gl, GL_PRIMITIVES_GENERATED, GL_CURRENT_QUERY, 0, QUERY_QUERY);
gl.glGenQueries(1, &query);
GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenQueries");
gl.glBeginQuery(GL_PRIMITIVES_GENERATED, query);
GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "beginQuery");
verifyStateQueryInteger(result, gl, GL_PRIMITIVES_GENERATED, GL_CURRENT_QUERY, (int)query, QUERY_QUERY);
gl.glEndQuery(GL_PRIMITIVES_GENERATED);
GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "endQuery");
}
result.setTestContextResult(m_testCtx);
return STOP;
}
class GeometryShaderFeartureTestCase : public TestCase
{
public:
GeometryShaderFeartureTestCase(Context &context, const char *name, const char *description);
void init(void);
};
GeometryShaderFeartureTestCase::GeometryShaderFeartureTestCase(Context &context, const char *name,
const char *description)
: TestCase(context, name, description)
{
}
void GeometryShaderFeartureTestCase::init(void)
{
if (!checkSupport(m_context))
TCU_THROW(NotSupportedError, "Tests require GL_EXT_geometry_shader extension or higher context version.");
}
class FramebufferDefaultLayersCase : public GeometryShaderFeartureTestCase
{
public:
FramebufferDefaultLayersCase(Context &context, const char *name, const char *description);
IterateResult iterate(void);
};
FramebufferDefaultLayersCase::FramebufferDefaultLayersCase(Context &context, const char *name, const char *description)
: GeometryShaderFeartureTestCase(context, name, description)
{
}
FramebufferDefaultLayersCase::IterateResult FramebufferDefaultLayersCase::iterate(void)
{
glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
gl.enableLogging(true);
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Default", "Default value");
const glu::Framebuffer fbo(m_context.getRenderContext());
glw::GLint defaultLayers = -1;
gl.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, *fbo);
gl.glGetFramebufferParameteriv(GL_DRAW_FRAMEBUFFER, GL_FRAMEBUFFER_DEFAULT_LAYERS, &defaultLayers);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "getFramebufferParameteriv");
m_testCtx.getLog() << tcu::TestLog::Message << "GL_FRAMEBUFFER_DEFAULT_LAYERS = " << defaultLayers
<< tcu::TestLog::EndMessage;
if (defaultLayers != 0)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, expected 0, got " << defaultLayers
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "invalid layer count");
}
}
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "SetTo12", "Set default layers to 12");
const glu::Framebuffer fbo(m_context.getRenderContext());
glw::GLint defaultLayers = -1;
gl.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, *fbo);
gl.glFramebufferParameteri(GL_DRAW_FRAMEBUFFER, GL_FRAMEBUFFER_DEFAULT_LAYERS, 12);
gl.glGetFramebufferParameteriv(GL_DRAW_FRAMEBUFFER, GL_FRAMEBUFFER_DEFAULT_LAYERS, &defaultLayers);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "getFramebufferParameteriv");
m_testCtx.getLog() << tcu::TestLog::Message << "GL_FRAMEBUFFER_DEFAULT_LAYERS = " << defaultLayers
<< tcu::TestLog::EndMessage;
if (defaultLayers != 12)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, expected 12, got " << defaultLayers
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "invalid layer count");
}
}
return STOP;
}
class FramebufferAttachmentLayeredCase : public GeometryShaderFeartureTestCase
{
public:
FramebufferAttachmentLayeredCase(Context &context, const char *name, const char *description);
IterateResult iterate(void);
};
FramebufferAttachmentLayeredCase::FramebufferAttachmentLayeredCase(Context &context, const char *name,
const char *description)
: GeometryShaderFeartureTestCase(context, name, description)
{
}
FramebufferAttachmentLayeredCase::IterateResult FramebufferAttachmentLayeredCase::iterate(void)
{
enum CaseType
{
TEXTURE_3D,
TEXTURE_2D_ARRAY,
TEXTURE_CUBE,
TEXTURE_2D_MS_ARRAY,
TEXTURE_3D_LAYER,
TEXTURE_2D_ARRAY_LAYER,
};
static const struct TextureType
{
const char *name;
const char *description;
bool layered;
CaseType type;
} textureTypes[] = {
{"3D", "3D texture", true, TEXTURE_3D},
{"2DArray", "2D array", true, TEXTURE_2D_ARRAY},
{"Cube", "Cube map", true, TEXTURE_CUBE},
{"2DMSArray", "2D multisample array", true, TEXTURE_2D_MS_ARRAY},
{"3DLayer", "3D texture layer ", false, TEXTURE_3D_LAYER},
{"2DArrayLayer", "2D array layer ", false, TEXTURE_2D_ARRAY_LAYER},
};
glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
gl.enableLogging(true);
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(textureTypes); ++ndx)
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), textureTypes[ndx].name, textureTypes[ndx].description);
const glu::Framebuffer fbo(m_context.getRenderContext());
const glu::Texture texture(m_context.getRenderContext());
glw::GLint layered = -1;
gl.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, *fbo);
if (textureTypes[ndx].type == TEXTURE_3D || textureTypes[ndx].type == TEXTURE_3D_LAYER)
{
gl.glBindTexture(GL_TEXTURE_3D, *texture);
gl.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA8, 32, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
gl.glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
gl.glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
if (textureTypes[ndx].type == TEXTURE_3D)
gl.glFramebufferTexture(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, *texture, 0);
else
gl.glFramebufferTextureLayer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, *texture, 0, 2);
}
else if (textureTypes[ndx].type == TEXTURE_2D_ARRAY || textureTypes[ndx].type == TEXTURE_2D_ARRAY_LAYER)
{
gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *texture);
gl.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA8, 32, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
gl.glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
gl.glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
if (textureTypes[ndx].type == TEXTURE_2D_ARRAY)
gl.glFramebufferTexture(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, *texture, 0);
else
gl.glFramebufferTextureLayer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, *texture, 0, 3);
}
else if (textureTypes[ndx].type == TEXTURE_CUBE)
{
gl.glBindTexture(GL_TEXTURE_CUBE_MAP, *texture);
for (int face = 0; face < 6; ++face)
gl.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, 0, GL_RGBA8, 32, 32, 0, GL_RGBA,
GL_UNSIGNED_BYTE, DE_NULL);
gl.glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
gl.glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
gl.glFramebufferTexture(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, *texture, 0);
}
else if (textureTypes[ndx].type == TEXTURE_2D_MS_ARRAY)
{
const bool supportES32 =
glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
const bool supportGL45 =
glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5));
// check extension
if (!(supportGL45 || (supportES32 && m_context.getContextInfo().isExtensionSupported(
"GL_OES_texture_storage_multisample_2d_array"))))
{
m_testCtx.getLog() << tcu::TestLog::Message
<< "Context is not equal or greather than 3.2 and "
"GL_OES_texture_storage_multisample_2d_array not supported, skipping."
<< tcu::TestLog::EndMessage;
continue;
}
gl.glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, *texture);
gl.glTexStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, 1, GL_RGBA8, 32, 32, 32, GL_FALSE);
gl.glFramebufferTexture(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, *texture, 0);
}
GLU_EXPECT_NO_ERROR(gl.glGetError(), "setup attachment");
gl.glGetFramebufferAttachmentParameteriv(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_FRAMEBUFFER_ATTACHMENT_LAYERED, &layered);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "getFramebufferParameteriv");
m_testCtx.getLog() << tcu::TestLog::Message
<< "GL_FRAMEBUFFER_ATTACHMENT_LAYERED = " << glu::getBooleanStr(layered)
<< tcu::TestLog::EndMessage;
if (layered != GL_TRUE && layered != GL_FALSE)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, expected boolean, got " << layered
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "invalid boolean");
}
else if ((layered == GL_TRUE) != textureTypes[ndx].layered)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, expected "
<< ((textureTypes[ndx].layered) ? ("GL_TRUE") : ("GL_FALSE")) << ", got "
<< glu::getBooleanStr(layered) << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "invalid layer count");
}
}
return STOP;
}
class FramebufferIncompleteLayereTargetsCase : public GeometryShaderFeartureTestCase
{
public:
FramebufferIncompleteLayereTargetsCase(Context &context, const char *name, const char *description);
IterateResult iterate(void);
};
FramebufferIncompleteLayereTargetsCase::FramebufferIncompleteLayereTargetsCase(Context &context, const char *name,
const char *description)
: GeometryShaderFeartureTestCase(context, name, description)
{
}
FramebufferIncompleteLayereTargetsCase::IterateResult FramebufferIncompleteLayereTargetsCase::iterate(void)
{
glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
gl.enableLogging(true);
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "LayerAndNonLayer", "Layered and non-layered");
const glu::Framebuffer fbo(m_context.getRenderContext());
const glu::Texture texture0(m_context.getRenderContext());
const glu::Texture texture1(m_context.getRenderContext());
glw::GLint fboStatus;
gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *texture0);
gl.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA8, 32, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
gl.glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
gl.glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *texture1);
gl.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA8, 32, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
gl.glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
gl.glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
gl.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, *fbo);
gl.glFramebufferTexture(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, *texture0, 0);
gl.glFramebufferTextureLayer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, *texture1, 0, 0);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "setup fbo");
fboStatus = gl.glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER);
m_testCtx.getLog() << tcu::TestLog::Message << "Framebuffer status: " << glu::getFramebufferStatusStr(fboStatus)
<< tcu::TestLog::EndMessage;
if (fboStatus != GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS)
{
m_testCtx.getLog() << tcu::TestLog::Message
<< "Error, expected GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS, got "
<< glu::getFramebufferStatusStr(fboStatus) << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "invalid layer count");
}
}
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "DifferentTarget", "Different target");
const glu::Framebuffer fbo(m_context.getRenderContext());
const glu::Texture texture0(m_context.getRenderContext());
const glu::Texture texture1(m_context.getRenderContext());
glw::GLint fboStatus;
gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *texture0);
gl.glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA8, 32, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
gl.glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
gl.glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
gl.glBindTexture(GL_TEXTURE_3D, *texture1);
gl.glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA8, 32, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
gl.glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
gl.glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
gl.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, *fbo);
gl.glFramebufferTexture(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, *texture0, 0);
gl.glFramebufferTexture(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, *texture1, 0);
GLU_EXPECT_NO_ERROR(gl.glGetError(), "setup fbo");
fboStatus = gl.glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER);
m_testCtx.getLog() << tcu::TestLog::Message << "Framebuffer status: " << glu::getFramebufferStatusStr(fboStatus)
<< tcu::TestLog::EndMessage;
if (fboStatus != GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS)
{
m_testCtx.getLog() << tcu::TestLog::Message
<< "Error, expected GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS, got "
<< glu::getFramebufferStatusStr(fboStatus) << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "invalid layer count");
}
}
return STOP;
}
class ReferencedByGeometryShaderCase : public GeometryShaderFeartureTestCase
{
public:
ReferencedByGeometryShaderCase(Context &context, const char *name, const char *description);
IterateResult iterate(void);
};
ReferencedByGeometryShaderCase::ReferencedByGeometryShaderCase(Context &context, const char *name,
const char *description)
: GeometryShaderFeartureTestCase(context, name, description)
{
}
ReferencedByGeometryShaderCase::IterateResult ReferencedByGeometryShaderCase::iterate(void)
{
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
{
static const char *const vertexSource = "${GLSL_VERSION_DECL}\n"
"uniform highp vec4 u_position;\n"
"void main (void)\n"
"{\n"
" gl_Position = u_position;\n"
"}\n";
static const char *const fragmentSource = "${GLSL_VERSION_DECL}\n"
"layout(location = 0) out mediump vec4 fragColor;\n"
"void main (void)\n"
"{\n"
" fragColor = vec4(1.0, 1.0, 1.0, 1.0);\n"
"}\n";
static const char *const geometrySource = "${GLSL_VERSION_DECL}\n"
"${GLSL_EXT_GEOMETRY_SHADER}"
"layout(points) in;\n"
"layout(points, max_vertices=1) out;\n"
"uniform highp vec4 u_offset;\n"
"void main (void)\n"
"{\n"
" gl_Position = gl_in[0].gl_Position + u_offset;\n"
" EmitVertex();\n"
"}\n";
const glu::ShaderProgram program(
m_context.getRenderContext(),
glu::ProgramSources() << glu::VertexSource(
specializeShader(vertexSource, m_context.getRenderContext().getType()))
<< glu::FragmentSource(
specializeShader(fragmentSource, m_context.getRenderContext().getType()))
<< glu::GeometrySource(
specializeShader(geometrySource, m_context.getRenderContext().getType())));
m_testCtx.getLog() << program;
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "UnreferencedUniform",
"Unreferenced uniform u_position");
glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
const uint32_t props[1] = {GL_REFERENCED_BY_GEOMETRY_SHADER};
uint32_t resourcePos;
glw::GLsizei length = 0;
glw::GLint referenced = 0;
gl.enableLogging(true);
resourcePos = gl.glGetProgramResourceIndex(program.getProgram(), GL_UNIFORM, "u_position");
m_testCtx.getLog() << tcu::TestLog::Message << "u_position resource index: " << resourcePos
<< tcu::TestLog::EndMessage;
gl.glGetProgramResourceiv(program.getProgram(), GL_UNIFORM, resourcePos, 1, props, 1, &length, &referenced);
m_testCtx.getLog() << tcu::TestLog::Message << "Query GL_REFERENCED_BY_GEOMETRY_SHADER, got " << length
<< " value(s), value[0] = " << glu::getBooleanStr(referenced)
<< tcu::TestLog::EndMessage;
GLU_EXPECT_NO_ERROR(gl.glGetError(), "query resource");
if (length == 0 || referenced != GL_FALSE)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, expected GL_FALSE." << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got unexpected value");
}
}
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "ReferencedUniform", "Referenced uniform u_offset");
glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
const uint32_t props[1] = {GL_REFERENCED_BY_GEOMETRY_SHADER};
uint32_t resourcePos;
glw::GLsizei length = 0;
glw::GLint referenced = 0;
gl.enableLogging(true);
resourcePos = gl.glGetProgramResourceIndex(program.getProgram(), GL_UNIFORM, "u_offset");
m_testCtx.getLog() << tcu::TestLog::Message << "u_offset resource index: " << resourcePos
<< tcu::TestLog::EndMessage;
gl.glGetProgramResourceiv(program.getProgram(), GL_UNIFORM, resourcePos, 1, props, 1, &length, &referenced);
m_testCtx.getLog() << tcu::TestLog::Message << "Query GL_REFERENCED_BY_GEOMETRY_SHADER, got " << length
<< " value(s), value[0] = " << glu::getBooleanStr(referenced)
<< tcu::TestLog::EndMessage;
GLU_EXPECT_NO_ERROR(gl.glGetError(), "query resource");
if (length == 0 || referenced != GL_TRUE)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, expected GL_TRUE." << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got unexpected value");
}
}
}
return STOP;
}
class CombinedGeometryUniformLimitCase : public GeometryShaderFeartureTestCase
{
public:
CombinedGeometryUniformLimitCase(Context &context, const char *name, const char *desc);
private:
IterateResult iterate(void);
};
CombinedGeometryUniformLimitCase::CombinedGeometryUniformLimitCase(Context &context, const char *name, const char *desc)
: GeometryShaderFeartureTestCase(context, name, desc)
{
}
CombinedGeometryUniformLimitCase::IterateResult CombinedGeometryUniformLimitCase::iterate(void)
{
glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: ");
gl.enableLogging(true);
m_testCtx.getLog() << tcu::TestLog::Message
<< "The minimum value of MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS is "
"MAX_GEOMETRY_UNIFORM_BLOCKS x MAX_UNIFORM_BLOCK_SIZE / 4 + MAX_GEOMETRY_UNIFORM_COMPONENTS"
<< tcu::TestLog::EndMessage;
StateQueryMemoryWriteGuard<glw::GLint> maxUniformBlocks;
gl.glGetIntegerv(GL_MAX_GEOMETRY_UNIFORM_BLOCKS, &maxUniformBlocks);
GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGetIntegerv");
StateQueryMemoryWriteGuard<glw::GLint> maxUniformBlockSize;
gl.glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &maxUniformBlockSize);
GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGetIntegerv");
StateQueryMemoryWriteGuard<glw::GLint> maxUniformComponents;
gl.glGetIntegerv(GL_MAX_GEOMETRY_UNIFORM_COMPONENTS, &maxUniformComponents);
GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGetIntegerv");
if (maxUniformBlocks.verifyValidity(result) && maxUniformBlockSize.verifyValidity(result) &&
maxUniformComponents.verifyValidity(result))
{
const int limit = ((int)maxUniformBlocks) * ((int)maxUniformBlockSize) / 4 + (int)maxUniformComponents;
verifyStateIntegerMin(result, gl, GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS, limit, QUERY_INTEGER);
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Types", "Alternative queries");
verifyStateIntegerMin(result, gl, GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS, limit, QUERY_BOOLEAN);
verifyStateIntegerMin(result, gl, GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS, limit, QUERY_INTEGER64);
verifyStateIntegerMin(result, gl, GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS, limit, QUERY_FLOAT);
}
}
result.setTestContextResult(m_testCtx);
return STOP;
}
class VertexFeedbackCase : public TestCase
{
public:
enum DrawMethod
{
METHOD_DRAW_ARRAYS = 0,
METHOD_DRAW_ARRAYS_INSTANCED,
METHOD_DRAW_ARRAYS_INDIRECT,
METHOD_DRAW_ELEMENTS,
METHOD_DRAW_ELEMENTS_INSTANCED,
METHOD_DRAW_ELEMENTS_INDIRECT,
METHOD_LAST
};
enum PrimitiveType
{
PRIMITIVE_LINE_LOOP = 0,
PRIMITIVE_LINE_STRIP,
PRIMITIVE_TRIANGLE_STRIP,
PRIMITIVE_TRIANGLE_FAN,
PRIMITIVE_POINTS,
PRIMITIVE_LAST
};
VertexFeedbackCase(Context &context, const char *name, const char *description, DrawMethod method,
PrimitiveType output);
~VertexFeedbackCase(void);
private:
void init(void);
void deinit(void);
IterateResult iterate(void);
glu::ShaderProgram *genProgram(void);
uint32_t getOutputPrimitive(void);
uint32_t getBasePrimitive(void);
const DrawMethod m_method;
const PrimitiveType m_output;
uint32_t m_elementBuf;
uint32_t m_arrayBuf;
uint32_t m_offsetBuf;
uint32_t m_feedbackBuf;
uint32_t m_indirectBuffer;
glu::ShaderProgram *m_program;
glu::VertexArray *m_vao;
};
VertexFeedbackCase::VertexFeedbackCase(Context &context, const char *name, const char *description, DrawMethod method,
PrimitiveType output)
: TestCase(context, name, description)
, m_method(method)
, m_output(output)
, m_elementBuf(0)
, m_arrayBuf(0)
, m_offsetBuf(0)
, m_feedbackBuf(0)
, m_indirectBuffer(0)
, m_program(DE_NULL)
, m_vao(DE_NULL)
{
DE_ASSERT(method < METHOD_LAST);
DE_ASSERT(output < PRIMITIVE_LAST);
}
VertexFeedbackCase::~VertexFeedbackCase(void)
{
deinit();
}
void VertexFeedbackCase::init(void)
{
// requirements
if (!checkSupport(m_context))
TCU_THROW(NotSupportedError, "Tests require GL_EXT_geometry_shader extension or higher context version.");
// log what test tries to do
m_testCtx.getLog() << tcu::TestLog::Message << "Testing GL_EXT_geometry_shader transform feedback relaxations.\n"
<< "Capturing vertex shader varying, no geometry shader. Invoke with:"
<< tcu::TestLog::EndMessage;
switch (m_method)
{
case METHOD_DRAW_ARRAYS:
m_testCtx.getLog() << tcu::TestLog::Message << "Draw method: drawArrays" << tcu::TestLog::EndMessage;
break;
case METHOD_DRAW_ARRAYS_INSTANCED:
m_testCtx.getLog() << tcu::TestLog::Message << "Draw method: drawArraysInstanced" << tcu::TestLog::EndMessage;
break;
case METHOD_DRAW_ARRAYS_INDIRECT:
m_testCtx.getLog() << tcu::TestLog::Message << "Draw method: drawArraysIndirect" << tcu::TestLog::EndMessage;
break;
case METHOD_DRAW_ELEMENTS:
m_testCtx.getLog() << tcu::TestLog::Message << "Draw method: drawElements" << tcu::TestLog::EndMessage;
break;
case METHOD_DRAW_ELEMENTS_INSTANCED:
m_testCtx.getLog() << tcu::TestLog::Message << "Draw method: drawElementsInstanced" << tcu::TestLog::EndMessage;
break;
case METHOD_DRAW_ELEMENTS_INDIRECT:
m_testCtx.getLog() << tcu::TestLog::Message << "Draw method: drawElementsIndirect" << tcu::TestLog::EndMessage;
break;
default:
DE_ASSERT(false);
}
switch (m_output)
{
case PRIMITIVE_LINE_LOOP:
m_testCtx.getLog() << tcu::TestLog::Message << "Draw primitive: line loop" << tcu::TestLog::EndMessage;
break;
case PRIMITIVE_LINE_STRIP:
m_testCtx.getLog() << tcu::TestLog::Message << "Draw primitive: line strip" << tcu::TestLog::EndMessage;
break;
case PRIMITIVE_TRIANGLE_STRIP:
m_testCtx.getLog() << tcu::TestLog::Message << "Draw primitive: triangle strip" << tcu::TestLog::EndMessage;
break;
case PRIMITIVE_TRIANGLE_FAN:
m_testCtx.getLog() << tcu::TestLog::Message << "Draw primitive: triangle fan" << tcu::TestLog::EndMessage;
break;
case PRIMITIVE_POINTS:
m_testCtx.getLog() << tcu::TestLog::Message << "Draw primitive: points" << tcu::TestLog::EndMessage;
break;
default:
DE_ASSERT(false);
}
// resources
{
static const uint16_t elementData[] = {
0,
1,
2,
3,
};
static const tcu::Vec4 arrayData[] = {
tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f),
tcu::Vec4(1.0f, 0.0f, 0.0f, 0.0f),
tcu::Vec4(2.0f, 0.0f, 0.0f, 0.0f),
tcu::Vec4(3.0f, 0.0f, 0.0f, 0.0f),
};
static const tcu::Vec4 offsetData[] = {
tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f),
tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f),
tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f),
tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f),
};
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
const int feedbackSize = 8 * (int)sizeof(float[4]);
m_vao = new glu::VertexArray(m_context.getRenderContext());
gl.bindVertexArray(**m_vao);
GLU_EXPECT_NO_ERROR(gl.getError(), "set up vao");
gl.genBuffers(1, &m_elementBuf);
gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_elementBuf);
gl.bufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(elementData), &elementData[0], GL_STATIC_DRAW);
GLU_EXPECT_NO_ERROR(gl.getError(), "gen buf");
gl.genBuffers(1, &m_arrayBuf);
gl.bindBuffer(GL_ARRAY_BUFFER, m_arrayBuf);
gl.bufferData(GL_ARRAY_BUFFER, sizeof(arrayData), &arrayData[0], GL_STATIC_DRAW);
GLU_EXPECT_NO_ERROR(gl.getError(), "gen buf");
gl.genBuffers(1, &m_offsetBuf);
gl.bindBuffer(GL_ARRAY_BUFFER, m_offsetBuf);
gl.bufferData(GL_ARRAY_BUFFER, sizeof(offsetData), &offsetData[0], GL_STATIC_DRAW);
GLU_EXPECT_NO_ERROR(gl.getError(), "gen buf");
gl.genBuffers(1, &m_feedbackBuf);
gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_feedbackBuf);
gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, feedbackSize, DE_NULL, GL_DYNAMIC_COPY);
GLU_EXPECT_NO_ERROR(gl.getError(), "gen buf");
m_program = genProgram();
if (!m_program->isOk())
{
m_testCtx.getLog() << *m_program;
throw tcu::TestError("could not build program");
}
}
}
void VertexFeedbackCase::deinit(void)
{
if (m_elementBuf)
{
m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_elementBuf);
m_elementBuf = 0;
}
if (m_arrayBuf)
{
m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_arrayBuf);
m_arrayBuf = 0;
}
if (m_offsetBuf)
{
m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_offsetBuf);
m_offsetBuf = 0;
}
if (m_feedbackBuf)
{
m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_feedbackBuf);
m_feedbackBuf = 0;
}
if (m_indirectBuffer)
{
m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_indirectBuffer);
m_indirectBuffer = 0;
}
delete m_program;
m_program = DE_NULL;
delete m_vao;
m_vao = DE_NULL;
}
VertexFeedbackCase::IterateResult VertexFeedbackCase::iterate(void)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
const uint32_t outputPrimitive = getOutputPrimitive();
const uint32_t basePrimitive = getBasePrimitive();
const int posLocation = gl.getAttribLocation(m_program->getProgram(), "a_position");
const int offsetLocation = gl.getAttribLocation(m_program->getProgram(), "a_offset");
if (posLocation == -1)
throw tcu::TestError("a_position location was -1");
if (offsetLocation == -1)
throw tcu::TestError("a_offset location was -1");
gl.useProgram(m_program->getProgram());
gl.bindBuffer(GL_ARRAY_BUFFER, m_arrayBuf);
gl.vertexAttribPointer(posLocation, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL);
gl.enableVertexAttribArray(posLocation);
gl.bindBuffer(GL_ARRAY_BUFFER, m_offsetBuf);
gl.vertexAttribPointer(offsetLocation, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL);
gl.enableVertexAttribArray(offsetLocation);
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_feedbackBuf);
GLU_EXPECT_NO_ERROR(gl.getError(), "bind buffer base");
m_testCtx.getLog() << tcu::TestLog::Message << "Calling BeginTransformFeedback("
<< glu::getPrimitiveTypeStr(basePrimitive) << ")" << tcu::TestLog::EndMessage;
gl.beginTransformFeedback(basePrimitive);
GLU_EXPECT_NO_ERROR(gl.getError(), "beginTransformFeedback");
switch (m_method)
{
case METHOD_DRAW_ARRAYS:
{
m_testCtx.getLog() << tcu::TestLog::Message << "Calling DrawArrays("
<< glu::getPrimitiveTypeStr(outputPrimitive) << ", ...)" << tcu::TestLog::EndMessage;
gl.drawArrays(outputPrimitive, 0, 4);
break;
}
case METHOD_DRAW_ARRAYS_INSTANCED:
{
m_testCtx.getLog() << tcu::TestLog::Message << "Calling DrawArraysInstanced("
<< glu::getPrimitiveTypeStr(outputPrimitive) << ", ...)" << tcu::TestLog::EndMessage;
gl.vertexAttribDivisor(offsetLocation, 2);
gl.drawArraysInstanced(outputPrimitive, 0, 3, 2);
break;
}
case METHOD_DRAW_ELEMENTS:
{
m_testCtx.getLog() << tcu::TestLog::Message << "Calling DrawElements("
<< glu::getPrimitiveTypeStr(outputPrimitive) << ", ...)" << tcu::TestLog::EndMessage;
gl.drawElements(outputPrimitive, 4, GL_UNSIGNED_SHORT, DE_NULL);
break;
}
case METHOD_DRAW_ELEMENTS_INSTANCED:
{
m_testCtx.getLog() << tcu::TestLog::Message << "Calling DrawElementsInstanced("
<< glu::getPrimitiveTypeStr(outputPrimitive) << ", ...)" << tcu::TestLog::EndMessage;
gl.drawElementsInstanced(outputPrimitive, 3, GL_UNSIGNED_SHORT, DE_NULL, 2);
break;
}
case METHOD_DRAW_ARRAYS_INDIRECT:
{
struct DrawArraysIndirectCommand
{
uint32_t count;
uint32_t instanceCount;
uint32_t first;
uint32_t reservedMustBeZero;
} params;
DE_STATIC_ASSERT(sizeof(DrawArraysIndirectCommand) == sizeof(uint32_t[4]));
params.count = 4;
params.instanceCount = 1;
params.first = 0;
params.reservedMustBeZero = 0;
gl.genBuffers(1, &m_indirectBuffer);
gl.bindBuffer(GL_DRAW_INDIRECT_BUFFER, m_indirectBuffer);
gl.bufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(params), &params, GL_STATIC_DRAW);
m_testCtx.getLog() << tcu::TestLog::Message << "Calling DrawElementsIndirect("
<< glu::getPrimitiveTypeStr(outputPrimitive) << ", ...)" << tcu::TestLog::EndMessage;
gl.drawArraysIndirect(outputPrimitive, DE_NULL);
break;
}
case METHOD_DRAW_ELEMENTS_INDIRECT:
{
struct DrawElementsIndirectCommand
{
uint32_t count;
uint32_t instanceCount;
uint32_t firstIndex;
int32_t baseVertex;
uint32_t reservedMustBeZero;
} params;
DE_STATIC_ASSERT(sizeof(DrawElementsIndirectCommand) == sizeof(uint32_t[5]));
params.count = 4;
params.instanceCount = 1;
params.firstIndex = 0;
params.baseVertex = 0;
params.reservedMustBeZero = 0;
gl.genBuffers(1, &m_indirectBuffer);
gl.bindBuffer(GL_DRAW_INDIRECT_BUFFER, m_indirectBuffer);
gl.bufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(params), &params, GL_STATIC_DRAW);
m_testCtx.getLog() << tcu::TestLog::Message << "Calling DrawElementsIndirect("
<< glu::getPrimitiveTypeStr(outputPrimitive) << ", ...)" << tcu::TestLog::EndMessage;
gl.drawElementsIndirect(outputPrimitive, GL_UNSIGNED_SHORT, DE_NULL);
break;
}
default:
DE_ASSERT(false);
}
GLU_EXPECT_NO_ERROR(gl.getError(), "draw");
gl.endTransformFeedback();
GLU_EXPECT_NO_ERROR(gl.getError(), "endTransformFeedback");
m_testCtx.getLog() << tcu::TestLog::Message << "No errors." << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return STOP;
}
glu::ShaderProgram *VertexFeedbackCase::genProgram(void)
{
static const char *const vertexSource = "${GLSL_VERSION_DECL}\n"
"in highp vec4 a_position;\n"
"in highp vec4 a_offset;\n"
"out highp vec4 tf_value;\n"
"void main (void)\n"
"{\n"
" gl_Position = a_position;\n"
" tf_value = a_position + a_offset;\n"
"}\n";
static const char *const fragmentSource = "${GLSL_VERSION_DECL}\n"
"layout(location = 0) out mediump vec4 fragColor;\n"
"void main (void)\n"
"{\n"
" fragColor = vec4(1.0);\n"
"}\n";
return new glu::ShaderProgram(m_context.getRenderContext(),
glu::ProgramSources() << glu::VertexSource(specializeShader(
vertexSource, m_context.getRenderContext().getType()))
<< glu::FragmentSource(specializeShader(
fragmentSource, m_context.getRenderContext().getType()))
<< glu::TransformFeedbackVarying("tf_value")
<< glu::TransformFeedbackMode(GL_INTERLEAVED_ATTRIBS));
}
uint32_t VertexFeedbackCase::getOutputPrimitive(void)
{
switch (m_output)
{
case PRIMITIVE_LINE_LOOP:
return GL_LINE_LOOP;
case PRIMITIVE_LINE_STRIP:
return GL_LINE_STRIP;
case PRIMITIVE_TRIANGLE_STRIP:
return GL_TRIANGLE_STRIP;
case PRIMITIVE_TRIANGLE_FAN:
return GL_TRIANGLE_FAN;
case PRIMITIVE_POINTS:
return GL_POINTS;
default:
DE_ASSERT(false);
return 0;
}
}
uint32_t VertexFeedbackCase::getBasePrimitive(void)
{
switch (m_output)
{
case PRIMITIVE_LINE_LOOP:
return GL_LINES;
case PRIMITIVE_LINE_STRIP:
return GL_LINES;
case PRIMITIVE_TRIANGLE_STRIP:
return GL_TRIANGLES;
case PRIMITIVE_TRIANGLE_FAN:
return GL_TRIANGLES;
case PRIMITIVE_POINTS:
return GL_POINTS;
default:
DE_ASSERT(false);
return 0;
}
}
class VertexFeedbackOverflowCase : public TestCase
{
public:
enum Method
{
METHOD_DRAW_ARRAYS = 0,
METHOD_DRAW_ELEMENTS,
};
VertexFeedbackOverflowCase(Context &context, const char *name, const char *description, Method method);
~VertexFeedbackOverflowCase(void);
private:
void init(void);
void deinit(void);
IterateResult iterate(void);
glu::ShaderProgram *genProgram(void);
const Method m_method;
uint32_t m_elementBuf;
uint32_t m_arrayBuf;
uint32_t m_feedbackBuf;
glu::ShaderProgram *m_program;
glu::VertexArray *m_vao;
};
VertexFeedbackOverflowCase::VertexFeedbackOverflowCase(Context &context, const char *name, const char *description,
Method method)
: TestCase(context, name, description)
, m_method(method)
, m_elementBuf(0)
, m_arrayBuf(0)
, m_feedbackBuf(0)
, m_program(DE_NULL)
, m_vao(DE_NULL)
{
}
VertexFeedbackOverflowCase::~VertexFeedbackOverflowCase(void)
{
deinit();
}
void VertexFeedbackOverflowCase::init(void)
{
// requirements
if (!checkSupport(m_context))
TCU_THROW(NotSupportedError, "Tests require GL_EXT_geometry_shader extension or higher context version.");
// log what test tries to do
m_testCtx.getLog()
<< tcu::TestLog::Message << "Testing GL_EXT_geometry_shader transform feedback overflow behavior.\n"
<< "Capturing vertex shader varying, rendering 2 triangles. Allocating feedback buffer for 5 vertices."
<< tcu::TestLog::EndMessage;
// resources
{
static const uint16_t elementData[] = {
0, 1, 2, 0, 1, 2,
};
static const tcu::Vec4 arrayData[] = {
tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f),
tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f),
tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f),
tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f),
};
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
m_vao = new glu::VertexArray(m_context.getRenderContext());
gl.bindVertexArray(**m_vao);
GLU_EXPECT_NO_ERROR(gl.getError(), "set up vao");
if (m_method == METHOD_DRAW_ELEMENTS)
{
gl.genBuffers(1, &m_elementBuf);
gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_elementBuf);
gl.bufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(elementData), &elementData[0], GL_STATIC_DRAW);
GLU_EXPECT_NO_ERROR(gl.getError(), "gen buf");
}
gl.genBuffers(1, &m_arrayBuf);
gl.bindBuffer(GL_ARRAY_BUFFER, m_arrayBuf);
gl.bufferData(GL_ARRAY_BUFFER, sizeof(arrayData), &arrayData[0], GL_STATIC_DRAW);
GLU_EXPECT_NO_ERROR(gl.getError(), "gen buf");
{
const int feedbackCount = 5 * 4; // 5x vec4
const std::vector<float> initialBufferContents(feedbackCount, -1.0f);
m_testCtx.getLog() << tcu::TestLog::Message << "Filling feeback buffer with dummy value (-1.0)."
<< tcu::TestLog::EndMessage;
gl.genBuffers(1, &m_feedbackBuf);
gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_feedbackBuf);
gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, (int)(sizeof(float) * initialBufferContents.size()),
&initialBufferContents[0], GL_DYNAMIC_COPY);
GLU_EXPECT_NO_ERROR(gl.getError(), "gen buf");
}
m_program = genProgram();
if (!m_program->isOk())
{
m_testCtx.getLog() << *m_program;
throw tcu::TestError("could not build program");
}
}
}
void VertexFeedbackOverflowCase::deinit(void)
{
if (m_elementBuf)
{
m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_elementBuf);
m_elementBuf = 0;
}
if (m_arrayBuf)
{
m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_arrayBuf);
m_arrayBuf = 0;
}
if (m_feedbackBuf)
{
m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_feedbackBuf);
m_feedbackBuf = 0;
}
delete m_program;
m_program = DE_NULL;
delete m_vao;
m_vao = DE_NULL;
}
VertexFeedbackOverflowCase::IterateResult VertexFeedbackOverflowCase::iterate(void)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
const int posLocation = gl.getAttribLocation(m_program->getProgram(), "a_position");
if (posLocation == -1)
throw tcu::TestError("a_position location was -1");
gl.useProgram(m_program->getProgram());
gl.bindBuffer(GL_ARRAY_BUFFER, m_arrayBuf);
gl.vertexAttribPointer(posLocation, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL);
gl.enableVertexAttribArray(posLocation);
if (m_method == METHOD_DRAW_ELEMENTS)
{
gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_elementBuf);
GLU_EXPECT_NO_ERROR(gl.getError(), "bind buffers");
}
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_feedbackBuf);
GLU_EXPECT_NO_ERROR(gl.getError(), "bind buffer base");
m_testCtx.getLog() << tcu::TestLog::Message << "Capturing 2 triangles." << tcu::TestLog::EndMessage;
gl.beginTransformFeedback(GL_TRIANGLES);
if (m_method == METHOD_DRAW_ELEMENTS)
gl.drawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, DE_NULL);
else if (m_method == METHOD_DRAW_ARRAYS)
gl.drawArrays(GL_TRIANGLE_STRIP, 0, 4);
else
DE_ASSERT(false);
gl.endTransformFeedback();
GLU_EXPECT_NO_ERROR(gl.getError(), "capture");
m_testCtx.getLog() << tcu::TestLog::Message
<< "Verifying final triangle was not partially written to the feedback buffer."
<< tcu::TestLog::EndMessage;
{
const void *ptr = gl.mapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, sizeof(float[4]) * 5, GL_MAP_READ_BIT);
std::vector<float> feedback;
bool error = false;
GLU_EXPECT_NO_ERROR(gl.getError(), "mapBufferRange");
if (!ptr)
throw tcu::TestError("mapBufferRange returned null");
feedback.resize(5 * 4);
deMemcpy(&feedback[0], ptr, sizeof(float[4]) * 5);
if (gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER) != GL_TRUE)
throw tcu::TestError("unmapBuffer returned false");
// Verify vertices 0 - 2
for (int vertex = 0; vertex < 3; ++vertex)
{
for (int component = 0; component < 4; ++component)
{
if (feedback[vertex * 4 + component] != 1.0f)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Feedback buffer vertex " << vertex << ", component "
<< component << ": unexpected value, expected 1.0, got "
<< feedback[vertex * 4 + component] << tcu::TestLog::EndMessage;
error = true;
}
}
}
// Verify vertices 3 - 4
for (int vertex = 3; vertex < 5; ++vertex)
{
for (int component = 0; component < 4; ++component)
{
if (feedback[vertex * 4 + component] != -1.0f)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Feedback buffer vertex " << vertex << ", component "
<< component << ": unexpected value, expected -1.0, got "
<< feedback[vertex * 4 + component] << tcu::TestLog::EndMessage;
error = true;
}
}
}
if (error)
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Feedback result validation failed");
else
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
}
return STOP;
}
glu::ShaderProgram *VertexFeedbackOverflowCase::genProgram(void)
{
static const char *const vertexSource = "${GLSL_VERSION_DECL}\n"
"in highp vec4 a_position;\n"
"void main (void)\n"
"{\n"
" gl_Position = a_position;\n"
"}\n";
static const char *const fragmentSource = "${GLSL_VERSION_DECL}\n"
"layout(location = 0) out mediump vec4 fragColor;\n"
"void main (void)\n"
"{\n"
" fragColor = vec4(1.0);\n"
"}\n";
return new glu::ShaderProgram(m_context.getRenderContext(),
glu::ProgramSources() << glu::VertexSource(specializeShader(
vertexSource, m_context.getRenderContext().getType()))
<< glu::FragmentSource(specializeShader(
fragmentSource, m_context.getRenderContext().getType()))
<< glu::TransformFeedbackVarying("gl_Position")
<< glu::TransformFeedbackMode(GL_INTERLEAVED_ATTRIBS));
}
} // namespace
GeometryShaderTests::GeometryShaderTests(Context &context, bool isGL45)
: TestCaseGroup(context, "geometry_shading", "Geometry shader tests")
, m_isGL45(isGL45)
{
}
GeometryShaderTests::~GeometryShaderTests(void)
{
}
void GeometryShaderTests::init(void)
{
struct PrimitiveTestSpec
{
uint32_t primitiveType;
const char *name;
uint32_t outputType;
};
struct EmitTestSpec
{
uint32_t outputType;
int emitCountA; //!< primitive A emit count
int endCountA; //!< primitive A end count
int emitCountB; //!<
int endCountB; //!<
const char *name;
};
static const struct LayeredTarget
{
LayeredRenderCase::LayeredRenderTargetType target;
const char *name;
const char *desc;
} layerTargets[] = {
{LayeredRenderCase::TARGET_CUBE, "cubemap", "cubemap"},
{LayeredRenderCase::TARGET_3D, "3d", "3D texture"},
{LayeredRenderCase::TARGET_2D_ARRAY, "2d_array", "2D array texture"},
{LayeredRenderCase::TARGET_2D_MS_ARRAY, "2d_multisample_array", "2D multisample array texture"},
};
tcu::TestCaseGroup *const queryGroup = new tcu::TestCaseGroup(m_testCtx, "query", "Query tests.");
tcu::TestCaseGroup *const basicGroup = new tcu::TestCaseGroup(m_testCtx, "basic", "Basic tests.");
tcu::TestCaseGroup *const inputPrimitiveGroup =
new tcu::TestCaseGroup(m_testCtx, "input", "Different input primitives.");
tcu::TestCaseGroup *const conversionPrimitiveGroup =
new tcu::TestCaseGroup(m_testCtx, "conversion", "Different input and output primitives.");
tcu::TestCaseGroup *const emitGroup = new tcu::TestCaseGroup(m_testCtx, "emit", "Different emit counts.");
tcu::TestCaseGroup *const varyingGroup = new tcu::TestCaseGroup(m_testCtx, "varying", "Test varyings.");
tcu::TestCaseGroup *const layeredGroup = new tcu::TestCaseGroup(m_testCtx, "layered", "Layered rendering.");
tcu::TestCaseGroup *const instancedGroup = new tcu::TestCaseGroup(m_testCtx, "instanced", "Instanced rendering.");
tcu::TestCaseGroup *const negativeGroup = new tcu::TestCaseGroup(m_testCtx, "negative", "Negative tests.");
tcu::TestCaseGroup *const feedbackGroup =
new tcu::TestCaseGroup(m_testCtx, "vertex_transform_feedback", "Transform feedback.");
this->addChild(queryGroup);
this->addChild(basicGroup);
this->addChild(inputPrimitiveGroup);
this->addChild(conversionPrimitiveGroup);
this->addChild(emitGroup);
this->addChild(varyingGroup);
this->addChild(layeredGroup);
this->addChild(instancedGroup);
this->addChild(negativeGroup);
this->addChild(feedbackGroup);
// query test
{
// limits with a corresponding glsl constant
queryGroup->addChild(new GeometryProgramLimitCase(m_context, "max_geometry_input_components", "",
GL_MAX_GEOMETRY_INPUT_COMPONENTS,
"MaxGeometryInputComponents", 64));
queryGroup->addChild(new GeometryProgramLimitCase(m_context, "max_geometry_output_components", "",
GL_MAX_GEOMETRY_OUTPUT_COMPONENTS,
"MaxGeometryOutputComponents", 64));
queryGroup->addChild(new GeometryProgramLimitCase(m_context, "max_geometry_image_uniforms", "",
GL_MAX_GEOMETRY_IMAGE_UNIFORMS, "MaxGeometryImageUniforms",
0));
queryGroup->addChild(new GeometryProgramLimitCase(m_context, "max_geometry_texture_image_units", "",
GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS,
"MaxGeometryTextureImageUnits", 16));
queryGroup->addChild(new GeometryProgramLimitCase(m_context, "max_geometry_output_vertices", "",
GL_MAX_GEOMETRY_OUTPUT_VERTICES, "MaxGeometryOutputVertices",
256));
queryGroup->addChild(new GeometryProgramLimitCase(m_context, "max_geometry_total_output_components", "",
GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS,
"MaxGeometryTotalOutputComponents", 1024));
queryGroup->addChild(new GeometryProgramLimitCase(m_context, "max_geometry_uniform_components", "",
GL_MAX_GEOMETRY_UNIFORM_COMPONENTS,
"MaxGeometryUniformComponents", 1024));
queryGroup->addChild(new GeometryProgramLimitCase(m_context, "max_geometry_atomic_counters", "",
GL_MAX_GEOMETRY_ATOMIC_COUNTERS, "MaxGeometryAtomicCounters",
0));
queryGroup->addChild(new GeometryProgramLimitCase(m_context, "max_geometry_atomic_counter_buffers", "",
GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS,
"MaxGeometryAtomicCounterBuffers", 0));
// program queries
// ES only
if (!m_isGL45)
{
queryGroup->addChild(new GeometryShaderVerticesQueryCase(m_context, "geometry_linked_vertices_out",
"GL_GEOMETRY_LINKED_VERTICES_OUT"));
queryGroup->addChild(new GeometryShaderInputQueryCase(m_context, "geometry_linked_input_type",
"GL_GEOMETRY_LINKED_INPUT_TYPE"));
queryGroup->addChild(new GeometryShaderOutputQueryCase(m_context, "geometry_linked_output_type",
"GL_GEOMETRY_LINKED_OUTPUT_TYPE"));
queryGroup->addChild(new GeometryShaderInvocationsQueryCase(m_context, "geometry_shader_invocations",
"GL_GEOMETRY_SHADER_INVOCATIONS"));
}
// limits
queryGroup->addChild(new ImplementationLimitCase(m_context, "max_geometry_shader_invocations", "",
GL_MAX_GEOMETRY_SHADER_INVOCATIONS, 32));
queryGroup->addChild(new ImplementationLimitCase(m_context, "max_geometry_uniform_blocks", "",
GL_MAX_GEOMETRY_UNIFORM_BLOCKS, 12));
queryGroup->addChild(new ImplementationLimitCase(m_context, "max_geometry_shader_storage_blocks", "",
GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS, 0));
// layer_provoking_vertex_ext
queryGroup->addChild(
new LayerProvokingVertexQueryCase(m_context, "layer_provoking_vertex", "GL_LAYER_PROVOKING_VERTEX"));
// primitives_generated
queryGroup->addChild(new PrimitivesGeneratedQueryCase(m_context, "primitives_generated_no_geometry",
"PRIMITIVES_GENERATED query with no geometry shader",
PrimitivesGeneratedQueryCase::TEST_NO_GEOMETRY));
queryGroup->addChild(
new PrimitivesGeneratedQueryCase(m_context, "primitives_generated_no_amplification",
"PRIMITIVES_GENERATED query with non amplifying geometry shader",
PrimitivesGeneratedQueryCase::TEST_NO_AMPLIFICATION));
queryGroup->addChild(
new PrimitivesGeneratedQueryCase(m_context, "primitives_generated_amplification",
"PRIMITIVES_GENERATED query with amplifying geometry shader",
PrimitivesGeneratedQueryCase::TEST_AMPLIFICATION));
queryGroup->addChild(new PrimitivesGeneratedQueryCase(
m_context, "primitives_generated_partial_primitives",
"PRIMITIVES_GENERATED query with geometry shader emitting partial primitives",
PrimitivesGeneratedQueryCase::TEST_PARTIAL_PRIMITIVES));
queryGroup->addChild(new PrimitivesGeneratedQueryCase(
m_context, "primitives_generated_instanced", "PRIMITIVES_GENERATED query with instanced geometry shader",
PrimitivesGeneratedQueryCase::TEST_INSTANCED));
queryGroup->addChild(new PrimitivesGeneratedQueryObjectQueryCase(m_context, "primitives_generated",
"Query bound PRIMITIVES_GENERATED query"));
// fbo
queryGroup->addChild(
new ImplementationLimitCase(m_context, "max_framebuffer_layers", "", GL_MAX_FRAMEBUFFER_LAYERS, 256));
queryGroup->addChild(new FramebufferDefaultLayersCase(m_context, "framebuffer_default_layers", ""));
queryGroup->addChild(new FramebufferAttachmentLayeredCase(m_context, "framebuffer_attachment_layered", ""));
queryGroup->addChild(
new FramebufferIncompleteLayereTargetsCase(m_context, "framebuffer_incomplete_layer_targets", ""));
// resource query
queryGroup->addChild(new ReferencedByGeometryShaderCase(m_context, "referenced_by_geometry_shader", ""));
// combined limits
queryGroup->addChild(new CombinedGeometryUniformLimitCase(m_context, "max_combined_geometry_uniform_components",
"MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS"));
}
// basic tests
{
basicGroup->addChild(
new OutputCountCase(m_context, "output_10", "Output 10 vertices", OutputCountPatternSpec(10)));
basicGroup->addChild(
new OutputCountCase(m_context, "output_128", "Output 128 vertices", OutputCountPatternSpec(128)));
basicGroup->addChild(
new OutputCountCase(m_context, "output_256", "Output 256 vertices", OutputCountPatternSpec(256)));
basicGroup->addChild(
new OutputCountCase(m_context, "output_max", "Output max vertices", OutputCountPatternSpec(-1)));
basicGroup->addChild(new OutputCountCase(m_context, "output_10_and_100",
"Output 10 and 100 vertices in two invocations",
OutputCountPatternSpec(10, 100)));
basicGroup->addChild(new OutputCountCase(m_context, "output_100_and_10",
"Output 100 and 10 vertices in two invocations",
OutputCountPatternSpec(100, 10)));
basicGroup->addChild(new OutputCountCase(m_context, "output_0_and_128",
"Output 0 and 128 vertices in two invocations",
OutputCountPatternSpec(0, 128)));
basicGroup->addChild(new OutputCountCase(m_context, "output_128_and_0",
"Output 128 and 0 vertices in two invocations",
OutputCountPatternSpec(128, 0)));
basicGroup->addChild(new VaryingOutputCountCase(
m_context, "output_vary_by_attribute", "Output varying number of vertices",
VaryingOutputCountShader::READ_ATTRIBUTE, VaryingOutputCountCase::MODE_WITHOUT_INSTANCING));
basicGroup->addChild(new VaryingOutputCountCase(
m_context, "output_vary_by_uniform", "Output varying number of vertices",
VaryingOutputCountShader::READ_UNIFORM, VaryingOutputCountCase::MODE_WITHOUT_INSTANCING));
basicGroup->addChild(new VaryingOutputCountCase(
m_context, "output_vary_by_texture", "Output varying number of vertices",
VaryingOutputCountShader::READ_TEXTURE, VaryingOutputCountCase::MODE_WITHOUT_INSTANCING));
basicGroup->addChild(new BuiltinVariableRenderTest(m_context, "point_size", "test gl_PointSize",
BuiltinVariableShader::TEST_POINT_SIZE));
basicGroup->addChild(new BuiltinVariableRenderTest(m_context, "primitive_id_in", "test gl_PrimitiveIDIn",
BuiltinVariableShader::TEST_PRIMITIVE_ID_IN));
basicGroup->addChild(new BuiltinVariableRenderTest(
m_context, "primitive_id_in_restarted", "test gl_PrimitiveIDIn with primitive restart",
BuiltinVariableShader::TEST_PRIMITIVE_ID_IN,
GeometryShaderRenderTest::FLAG_USE_RESTART_INDEX | GeometryShaderRenderTest::FLAG_USE_INDICES));
basicGroup->addChild(new BuiltinVariableRenderTest(m_context, "primitive_id", "test gl_PrimitiveID",
BuiltinVariableShader::TEST_PRIMITIVE_ID));
}
// input primitives
{
static const PrimitiveTestSpec inputPrimitives[] = {
{GL_POINTS, "points", GL_POINTS},
{GL_LINES, "lines", GL_LINE_STRIP},
{GL_LINE_LOOP, "line_loop", GL_LINE_STRIP},
{GL_LINE_STRIP, "line_strip", GL_LINE_STRIP},
{GL_TRIANGLES, "triangles", GL_TRIANGLE_STRIP},
{GL_TRIANGLE_STRIP, "triangle_strip", GL_TRIANGLE_STRIP},
{GL_TRIANGLE_FAN, "triangle_fan", GL_TRIANGLE_STRIP},
{GL_LINES_ADJACENCY, "lines_adjacency", GL_LINE_STRIP},
{GL_LINE_STRIP_ADJACENCY, "line_strip_adjacency", GL_LINE_STRIP},
{GL_TRIANGLES_ADJACENCY, "triangles_adjacency", GL_TRIANGLE_STRIP}};
tcu::TestCaseGroup *const basicPrimitiveGroup =
new tcu::TestCaseGroup(m_testCtx, "basic_primitive", "Different input and output primitives.");
tcu::TestCaseGroup *const triStripAdjacencyGroup = new tcu::TestCaseGroup(
m_testCtx, "triangle_strip_adjacency", "Different triangle_strip_adjacency vertex counts.");
// more basic types
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(inputPrimitives); ++ndx)
basicPrimitiveGroup->addChild(
new GeometryExpanderRenderTest(m_context, inputPrimitives[ndx].name, inputPrimitives[ndx].name,
inputPrimitives[ndx].primitiveType, inputPrimitives[ndx].outputType));
// triangle strip adjacency with different vtx counts
for (int vtxCount = 0; vtxCount <= 12; ++vtxCount)
{
const std::string name = "vertex_count_" + de::toString(vtxCount);
const std::string desc = "Vertex count is " + de::toString(vtxCount);
triStripAdjacencyGroup->addChild(
new TriangleStripAdjacencyVertexCountTest(m_context, name.c_str(), desc.c_str(), vtxCount));
}
inputPrimitiveGroup->addChild(basicPrimitiveGroup);
inputPrimitiveGroup->addChild(triStripAdjacencyGroup);
}
// different type conversions
{
static const PrimitiveTestSpec conversionPrimitives[] = {
{GL_TRIANGLES, "triangles_to_points", GL_POINTS}, {GL_LINES, "lines_to_points", GL_POINTS},
{GL_POINTS, "points_to_lines", GL_LINE_STRIP}, {GL_TRIANGLES, "triangles_to_lines", GL_LINE_STRIP},
{GL_POINTS, "points_to_triangles", GL_TRIANGLE_STRIP}, {GL_LINES, "lines_to_triangles", GL_TRIANGLE_STRIP}};
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(conversionPrimitives); ++ndx)
conversionPrimitiveGroup->addChild(new GeometryExpanderRenderTest(
m_context, conversionPrimitives[ndx].name, conversionPrimitives[ndx].name,
conversionPrimitives[ndx].primitiveType, conversionPrimitives[ndx].outputType));
}
// emit different amounts
{
static const EmitTestSpec emitTests[] = {
{GL_POINTS, 0, 0, 0, 0, "points"},
{GL_POINTS, 0, 1, 0, 0, "points"},
{GL_POINTS, 1, 1, 0, 0, "points"},
{GL_POINTS, 0, 2, 0, 0, "points"},
{GL_POINTS, 1, 2, 0, 0, "points"},
{GL_LINE_STRIP, 0, 0, 0, 0, "line_strip"},
{GL_LINE_STRIP, 0, 1, 0, 0, "line_strip"},
{GL_LINE_STRIP, 1, 1, 0, 0, "line_strip"},
{GL_LINE_STRIP, 2, 1, 0, 0, "line_strip"},
{GL_LINE_STRIP, 0, 2, 0, 0, "line_strip"},
{GL_LINE_STRIP, 1, 2, 0, 0, "line_strip"},
{GL_LINE_STRIP, 2, 2, 0, 0, "line_strip"},
{GL_LINE_STRIP, 2, 2, 2, 0, "line_strip"},
{GL_TRIANGLE_STRIP, 0, 0, 0, 0, "triangle_strip"},
{GL_TRIANGLE_STRIP, 0, 1, 0, 0, "triangle_strip"},
{GL_TRIANGLE_STRIP, 1, 1, 0, 0, "triangle_strip"},
{GL_TRIANGLE_STRIP, 2, 1, 0, 0, "triangle_strip"},
{GL_TRIANGLE_STRIP, 3, 1, 0, 0, "triangle_strip"},
{GL_TRIANGLE_STRIP, 0, 2, 0, 0, "triangle_strip"},
{GL_TRIANGLE_STRIP, 1, 2, 0, 0, "triangle_strip"},
{GL_TRIANGLE_STRIP, 2, 2, 0, 0, "triangle_strip"},
{GL_TRIANGLE_STRIP, 3, 2, 0, 0, "triangle_strip"},
{GL_TRIANGLE_STRIP, 3, 2, 3, 0, "triangle_strip"},
};
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(emitTests); ++ndx)
{
std::string name = std::string(emitTests[ndx].name) + "_emit_" + de::toString(emitTests[ndx].emitCountA) +
"_end_" + de::toString(emitTests[ndx].endCountA);
std::string desc = std::string(emitTests[ndx].name) + " output, emit " +
de::toString(emitTests[ndx].emitCountA) + " vertices, call EndPrimitive " +
de::toString(emitTests[ndx].endCountA) + " times";
if (emitTests[ndx].emitCountB)
{
name += "_emit_" + de::toString(emitTests[ndx].emitCountB) + "_end_" +
de::toString(emitTests[ndx].endCountB);
desc += ", emit " + de::toString(emitTests[ndx].emitCountB) + " vertices, call EndPrimitive " +
de::toString(emitTests[ndx].endCountB) + " times";
}
emitGroup->addChild(new EmitTest(m_context, name.c_str(), desc.c_str(), emitTests[ndx].emitCountA,
emitTests[ndx].endCountA, emitTests[ndx].emitCountB,
emitTests[ndx].endCountB, emitTests[ndx].outputType));
}
}
// varying
{
struct VaryingTestSpec
{
int vertexOutputs;
int geometryOutputs;
const char *name;
const char *desc;
};
static const VaryingTestSpec varyingTests[] = {
{-1, 1, "vertex_no_op_geometry_out_1", "vertex_no_op_geometry_out_1"},
{0, 1, "vertex_out_0_geometry_out_1", "vertex_out_0_geometry_out_1"},
{0, 2, "vertex_out_0_geometry_out_2", "vertex_out_0_geometry_out_2"},
{1, 0, "vertex_out_1_geometry_out_0", "vertex_out_1_geometry_out_0"},
{1, 2, "vertex_out_1_geometry_out_2", "vertex_out_1_geometry_out_2"},
};
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(varyingTests); ++ndx)
varyingGroup->addChild(new VaryingTest(m_context, varyingTests[ndx].name, varyingTests[ndx].desc,
varyingTests[ndx].vertexOutputs, varyingTests[ndx].geometryOutputs));
}
// layered
{
static const struct TestType
{
LayeredRenderCase::TestType test;
const char *testPrefix;
const char *descPrefix;
} tests[] = {
{LayeredRenderCase::TEST_DEFAULT_LAYER, "render_with_default_layer_", "Render to all layers of "},
{LayeredRenderCase::TEST_SINGLE_LAYER, "render_to_one_", "Render to one layer of "},
{LayeredRenderCase::TEST_ALL_LAYERS, "render_to_all_", "Render to all layers of "},
{LayeredRenderCase::TEST_DIFFERENT_LAYERS, "render_different_to_",
"Render different data to different layers"},
{LayeredRenderCase::TEST_LAYER_ID, "fragment_layer_", "Read gl_Layer in fragment shader"},
{LayeredRenderCase::TEST_LAYER_PROVOKING_VERTEX, "layer_provoking_vertex_",
"Verify LAYER_PROVOKING_VERTEX"},
};
for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(tests); ++testNdx)
for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(layerTargets); ++targetNdx)
{
const std::string name = std::string(tests[testNdx].testPrefix) + layerTargets[targetNdx].name;
const std::string desc = std::string(tests[testNdx].descPrefix) + layerTargets[targetNdx].desc;
layeredGroup->addChild(new LayeredRenderCase(m_context, name.c_str(), desc.c_str(),
layerTargets[targetNdx].target, tests[testNdx].test));
}
}
// instanced
{
static const struct InvocationCase
{
const char *name;
int numInvocations;
} invocationCases[] = {
{"1", 1}, {"2", 2}, {"8", 8}, {"32", 32}, {"max", -1},
};
static const int numDrawInstances[] = {2, 4, 8};
static const int numDrawInvocations[] = {2, 8};
// same amount of content to all invocations
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(invocationCases); ++ndx)
instancedGroup->addChild(new GeometryInvocationCase(
m_context, (std::string("geometry_") + invocationCases[ndx].name + "_invocations").c_str(),
(std::string("Geometry shader with ") + invocationCases[ndx].name + " invocation(s)").c_str(),
invocationCases[ndx].numInvocations, GeometryInvocationCase::CASE_FIXED_OUTPUT_COUNTS));
// different amount of content to each invocation
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(invocationCases); ++ndx)
if (invocationCases[ndx].numInvocations != 1)
instancedGroup->addChild(new GeometryInvocationCase(
m_context,
(std::string("geometry_output_different_") + invocationCases[ndx].name + "_invocations").c_str(),
"Geometry shader invocation(s) with different emit counts", invocationCases[ndx].numInvocations,
GeometryInvocationCase::CASE_DIFFERENT_OUTPUT_COUNTS));
// invocation per layer
for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(layerTargets); ++targetNdx)
{
const std::string name = std::string("invocation_per_layer_") + layerTargets[targetNdx].name;
const std::string desc =
std::string("Render to multiple layers with multiple invocations, one invocation per layer, target ") +
layerTargets[targetNdx].desc;
instancedGroup->addChild(new LayeredRenderCase(m_context, name.c_str(), desc.c_str(),
layerTargets[targetNdx].target,
LayeredRenderCase::TEST_INVOCATION_PER_LAYER));
}
// multiple layers per invocation
for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(layerTargets); ++targetNdx)
{
const std::string name = std::string("multiple_layers_per_invocation_") + layerTargets[targetNdx].name;
const std::string desc =
std::string(
"Render to multiple layers with multiple invocations, multiple layers per invocation, target ") +
layerTargets[targetNdx].desc;
instancedGroup->addChild(new LayeredRenderCase(m_context, name.c_str(), desc.c_str(),
layerTargets[targetNdx].target,
LayeredRenderCase::TEST_MULTIPLE_LAYERS_PER_INVOCATION));
}
// different invocation output counts depending on {uniform, attrib, texture}
instancedGroup->addChild(new VaryingOutputCountCase(
m_context, "invocation_output_vary_by_attribute", "Output varying number of vertices",
VaryingOutputCountShader::READ_ATTRIBUTE, VaryingOutputCountCase::MODE_WITH_INSTANCING));
instancedGroup->addChild(new VaryingOutputCountCase(
m_context, "invocation_output_vary_by_uniform", "Output varying number of vertices",
VaryingOutputCountShader::READ_UNIFORM, VaryingOutputCountCase::MODE_WITH_INSTANCING));
instancedGroup->addChild(new VaryingOutputCountCase(
m_context, "invocation_output_vary_by_texture", "Output varying number of vertices",
VaryingOutputCountShader::READ_TEXTURE, VaryingOutputCountCase::MODE_WITH_INSTANCING));
// with drawInstanced
for (int instanceNdx = 0; instanceNdx < DE_LENGTH_OF_ARRAY(numDrawInstances); ++instanceNdx)
for (int invocationNdx = 0; invocationNdx < DE_LENGTH_OF_ARRAY(numDrawInvocations); ++invocationNdx)
{
const std::string name = std::string("draw_") + de::toString(numDrawInstances[instanceNdx]) +
"_instances_geometry_" + de::toString(numDrawInvocations[invocationNdx]) +
"_invocations";
const std::string desc = std::string("Draw ") + de::toString(numDrawInstances[instanceNdx]) +
" instances, with " + de::toString(numDrawInvocations[invocationNdx]) +
" geometry shader invocations.";
instancedGroup->addChild(new DrawInstancedGeometryInstancedCase(m_context, name.c_str(), desc.c_str(),
numDrawInstances[instanceNdx],
numDrawInvocations[invocationNdx]));
}
}
// negative (wrong types)
{
struct PrimitiveToInputTypeConversion
{
GLenum inputType;
GLenum primitiveType;
};
static const PrimitiveToInputTypeConversion legalConversions[] = {
{GL_POINTS, GL_POINTS},
{GL_LINES, GL_LINES},
{GL_LINES, GL_LINE_LOOP},
{GL_LINES, GL_LINE_STRIP},
{GL_LINES_ADJACENCY, GL_LINES_ADJACENCY},
{GL_LINES_ADJACENCY, GL_LINE_STRIP_ADJACENCY},
{GL_TRIANGLES, GL_TRIANGLES},
{GL_TRIANGLES, GL_TRIANGLE_STRIP},
{GL_TRIANGLES, GL_TRIANGLE_FAN},
{GL_TRIANGLES_ADJACENCY, GL_TRIANGLES_ADJACENCY},
{GL_TRIANGLES_ADJACENCY, GL_TRIANGLE_STRIP_ADJACENCY},
};
static const GLenum inputTypes[] = {GL_POINTS, GL_LINES, GL_LINES_ADJACENCY, GL_TRIANGLES,
GL_TRIANGLES_ADJACENCY};
static const GLenum primitiveTypes[] = {GL_POINTS,
GL_LINES,
GL_LINE_LOOP,
GL_LINE_STRIP,
GL_LINES_ADJACENCY,
GL_LINE_STRIP_ADJACENCY,
GL_TRIANGLES,
GL_TRIANGLE_STRIP,
GL_TRIANGLE_FAN,
GL_TRIANGLES_ADJACENCY,
GL_TRIANGLE_STRIP_ADJACENCY};
for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); ++inputTypeNdx)
for (int primitiveTypeNdx = 0; primitiveTypeNdx < DE_LENGTH_OF_ARRAY(primitiveTypes); ++primitiveTypeNdx)
{
const GLenum inputType = inputTypes[inputTypeNdx];
const GLenum primitiveType = primitiveTypes[primitiveTypeNdx];
const std::string name = std::string("type_") +
inputTypeToGLString(sglr::rr_util::mapGLGeometryShaderInputType(inputType)) +
"_primitive_" + primitiveTypeToString(primitiveType);
const std::string desc = std::string("Shader input type ") +
inputTypeToGLString(sglr::rr_util::mapGLGeometryShaderInputType(inputType)) +
", draw primitive type " + primitiveTypeToString(primitiveType);
bool isLegal = false;
for (int legalNdx = 0; legalNdx < DE_LENGTH_OF_ARRAY(legalConversions); ++legalNdx)
if (legalConversions[legalNdx].inputType == inputType &&
legalConversions[legalNdx].primitiveType == primitiveType)
isLegal = true;
// only illegal
if (!isLegal)
negativeGroup->addChild(
new NegativeDrawCase(m_context, name.c_str(), desc.c_str(), inputType, primitiveType));
}
}
// vertex transform feedback
{
feedbackGroup->addChild(new VertexFeedbackCase(m_context, "capture_vertex_line_loop", "Capture line loop lines",
VertexFeedbackCase::METHOD_DRAW_ARRAYS,
VertexFeedbackCase::PRIMITIVE_LINE_LOOP));
feedbackGroup->addChild(
new VertexFeedbackCase(m_context, "capture_vertex_line_strip", "Capture line strip lines",
VertexFeedbackCase::METHOD_DRAW_ARRAYS, VertexFeedbackCase::PRIMITIVE_LINE_STRIP));
feedbackGroup->addChild(new VertexFeedbackCase(
m_context, "capture_vertex_triangle_strip", "Capture triangle strip triangles",
VertexFeedbackCase::METHOD_DRAW_ARRAYS, VertexFeedbackCase::PRIMITIVE_TRIANGLE_STRIP));
feedbackGroup->addChild(
new VertexFeedbackCase(m_context, "capture_vertex_triangle_fan", "Capture triangle fan triangles",
VertexFeedbackCase::METHOD_DRAW_ARRAYS, VertexFeedbackCase::PRIMITIVE_TRIANGLE_FAN));
feedbackGroup->addChild(new VertexFeedbackCase(
m_context, "capture_vertex_draw_arrays", "Capture primitives generated with drawArrays",
VertexFeedbackCase::METHOD_DRAW_ARRAYS, VertexFeedbackCase::PRIMITIVE_POINTS));
feedbackGroup->addChild(new VertexFeedbackCase(
m_context, "capture_vertex_draw_arrays_instanced", "Capture primitives generated with drawArraysInstanced",
VertexFeedbackCase::METHOD_DRAW_ARRAYS_INSTANCED, VertexFeedbackCase::PRIMITIVE_POINTS));
feedbackGroup->addChild(new VertexFeedbackCase(
m_context, "capture_vertex_draw_arrays_indirect", "Capture primitives generated with drawArraysIndirect",
VertexFeedbackCase::METHOD_DRAW_ARRAYS_INDIRECT, VertexFeedbackCase::PRIMITIVE_POINTS));
feedbackGroup->addChild(new VertexFeedbackCase(
m_context, "capture_vertex_draw_elements", "Capture primitives generated with drawElements",
VertexFeedbackCase::METHOD_DRAW_ELEMENTS, VertexFeedbackCase::PRIMITIVE_POINTS));
feedbackGroup->addChild(new VertexFeedbackCase(m_context, "capture_vertex_draw_elements_instanced",
"Capture primitives generated with drawElementsInstanced",
VertexFeedbackCase::METHOD_DRAW_ELEMENTS_INSTANCED,
VertexFeedbackCase::PRIMITIVE_POINTS));
feedbackGroup->addChild(new VertexFeedbackCase(m_context, "capture_vertex_draw_elements_indirect",
"Capture primitives generated with drawElementsIndirect",
VertexFeedbackCase::METHOD_DRAW_ELEMENTS_INDIRECT,
VertexFeedbackCase::PRIMITIVE_POINTS));
feedbackGroup->addChild(new VertexFeedbackOverflowCase(
m_context, "capture_vertex_draw_arrays_overflow_single_buffer", "Capture triangles to too small a buffer",
VertexFeedbackOverflowCase::METHOD_DRAW_ARRAYS));
feedbackGroup->addChild(new VertexFeedbackOverflowCase(
m_context, "capture_vertex_draw_elements_overflow_single_buffer", "Capture triangles to too small a buffer",
VertexFeedbackOverflowCase::METHOD_DRAW_ELEMENTS));
}
}
} // namespace Functional
} // namespace gles31
} // namespace deqp