Google Git
Sign in
fuchsia / third_party / vulkan-cts / refs/heads/upstream/opengl-cts-4.6.3 / . / modules / gles31 / functional / es31fTessellationGeometryInteractionTests.cpp
blob: e318fe5a90b6df852947c0fd404c2d25f9bc28f5 [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 Tessellation and geometry shader interaction tests.
*//*--------------------------------------------------------------------*/
#include "es31fTessellationGeometryInteractionTests.hpp"
#include "tcuTestLog.hpp"
#include "tcuRenderTarget.hpp"
#include "tcuSurface.hpp"
#include "tcuImageCompare.hpp"
#include "tcuVectorUtil.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuStringTemplate.hpp"
#include "gluRenderContext.hpp"
#include "gluShaderProgram.hpp"
#include "gluStrUtil.hpp"
#include "gluContextInfo.hpp"
#include "gluObjectWrapper.hpp"
#include "gluPixelTransfer.hpp"
#include "glwFunctions.hpp"
#include "glwEnums.hpp"
#include "deStringUtil.hpp"
#include "deUniquePtr.hpp"
#include <sstream>
#include <algorithm>
#include <iterator>
namespace deqp
{
namespace gles31
{
namespace Functional
{
namespace
{
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));
const bool supportsGL45 = glu::contextSupports(contextType, glu::ApiType::core(4, 5));
std::map<std::string, std::string> shaderArgs;
shaderArgs["VERSION_DECL"] = glu::getGLSLVersionDeclaration(glu::getContextTypeGLSLVersion(contextType));
shaderArgs["EXTENSION_GEOMETRY_SHADER"] =
(supportsES32orGL45) ? ("") : ("#extension GL_EXT_geometry_shader : require\n");
shaderArgs["EXTENSION_TESSELATION_SHADER"] =
(supportsES32orGL45) ? ("") : ("#extension GL_EXT_tessellation_shader : require\n");
shaderArgs["EXTENSION_TESSELATION_POINT_SIZE"] =
(supportsGL45) ? ("") : ("#extension GL_EXT_tessellation_point_size : require\n");
shaderArgs["EXTENSION_GEOMETRY_POINT_SIZE"] =
(supportsGL45) ? ("") : ("#extension GL_EXT_geometry_point_size : require\n");
return tcu::StringTemplate(shaderSource).specialize(shaderArgs);
}
static const char *const s_positionVertexShader = "${VERSION_DECL}\n"
"in highp vec4 a_position;\n"
"void main (void)\n"
"{\n"
" gl_Position = a_position;\n"
"}\n";
static const char *const s_whiteOutputFragmentShader = "${VERSION_DECL}\n"
"layout(location = 0) out mediump vec4 fragColor;\n"
"void main (void)\n"
"{\n"
" fragColor = vec4(1.0);\n"
"}\n";
static bool isBlack(const tcu::RGBA &c)
{
return c.getRed() == 0 && c.getGreen() == 0 && c.getBlue() == 0;
}
class IdentityShaderCase : public TestCase
{
public:
IdentityShaderCase(Context &context, const char *name, const char *description);
protected:
std::string getVertexSource(void) const;
std::string getFragmentSource(void) const;
};
IdentityShaderCase::IdentityShaderCase(Context &context, const char *name, const char *description)
: TestCase(context, name, description)
{
}
std::string IdentityShaderCase::getVertexSource(void) const
{
std::string source = "${VERSION_DECL}\n"
"in highp vec4 a_position;\n"
"out highp vec4 v_vertex_color;\n"
"void main (void)\n"
"{\n"
" gl_Position = a_position;\n"
" v_vertex_color = vec4(a_position.x * 0.5 + 0.5, a_position.y * 0.5 + 0.5, 1.0, 0.4);\n"
"}\n";
return specializeShader(source, m_context.getRenderContext().getType());
}
std::string IdentityShaderCase::getFragmentSource(void) const
{
std::string source = "${VERSION_DECL}\n"
"in mediump vec4 v_fragment_color;\n"
"layout(location = 0) out mediump vec4 fragColor;\n"
"void main (void)\n"
"{\n"
" fragColor = v_fragment_color;\n"
"}\n";
return specializeShader(source, m_context.getRenderContext().getType());
}
class IdentityGeometryShaderCase : public IdentityShaderCase
{
public:
enum CaseType
{
CASE_TRIANGLES = 0,
CASE_QUADS,
CASE_ISOLINES,
};
IdentityGeometryShaderCase(Context &context, const char *name, const char *description, CaseType caseType);
~IdentityGeometryShaderCase(void);
private:
void init(void);
void deinit(void);
IterateResult iterate(void);
std::string getTessellationControlSource(void) const;
std::string getTessellationEvaluationSource(bool geometryActive) const;
std::string getGeometrySource(void) const;
enum
{
RENDER_SIZE = 128,
};
const CaseType m_case;
uint32_t m_patchBuffer;
};
IdentityGeometryShaderCase::IdentityGeometryShaderCase(Context &context, const char *name, const char *description,
CaseType caseType)
: IdentityShaderCase(context, name, description)
, m_case(caseType)
, m_patchBuffer(0)
{
}
IdentityGeometryShaderCase::~IdentityGeometryShaderCase(void)
{
deinit();
}
void IdentityGeometryShaderCase::init(void)
{
// Requirements
const bool supportsES32orGL45 =
glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)) ||
glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5));
if (!supportsES32orGL45 && (!m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader") ||
!m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")))
throw tcu::NotSupportedError("Test requires GL_EXT_tessellation_shader and GL_EXT_geometry_shader extensions");
if (m_context.getRenderTarget().getWidth() < RENDER_SIZE || m_context.getRenderTarget().getHeight() < RENDER_SIZE)
throw tcu::NotSupportedError("Test requires " + de::toString<int>(RENDER_SIZE) + "x" +
de::toString<int>(RENDER_SIZE) + " or larger render target.");
// Log
m_testCtx.getLog()
<< tcu::TestLog::Message
<< "Testing tessellating shader program output does not change when a passthrough geometry shader is "
"attached.\n"
<< "Rendering two images, first with and second without a geometry shader. Expecting similar results.\n"
<< "Using additive blending to detect overlap.\n"
<< tcu::TestLog::EndMessage;
// Resources
{
static const tcu::Vec4 patchBufferData[4] = {
tcu::Vec4(-0.9f, -0.9f, 0.0f, 1.0f),
tcu::Vec4(-0.9f, 0.9f, 0.0f, 1.0f),
tcu::Vec4(0.9f, -0.9f, 0.0f, 1.0f),
tcu::Vec4(0.9f, 0.9f, 0.0f, 1.0f),
};
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
gl.genBuffers(1, &m_patchBuffer);
gl.bindBuffer(GL_ARRAY_BUFFER, m_patchBuffer);
gl.bufferData(GL_ARRAY_BUFFER, sizeof(patchBufferData), patchBufferData, GL_STATIC_DRAW);
GLU_EXPECT_NO_ERROR(gl.getError(), "gen buffer");
}
}
void IdentityGeometryShaderCase::deinit(void)
{
if (m_patchBuffer)
{
m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_patchBuffer);
m_patchBuffer = 0;
}
}
IdentityGeometryShaderCase::IterateResult IdentityGeometryShaderCase::iterate(void)
{
const float innerTessellationLevel = 14.0f;
const float outerTessellationLevel = 14.0f;
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
tcu::Surface resultWithGeometry(RENDER_SIZE, RENDER_SIZE);
tcu::Surface resultWithoutGeometry(RENDER_SIZE, RENDER_SIZE);
const struct
{
const char *name;
const char *description;
bool containsGeometryShader;
tcu::PixelBufferAccess surfaceAccess;
} renderTargets[] = {
{"RenderWithGeometryShader", "Render with geometry shader", true, resultWithGeometry.getAccess()},
{"RenderWithoutGeometryShader", "Render without geometry shader", false, resultWithoutGeometry.getAccess()},
};
gl.viewport(0, 0, RENDER_SIZE, RENDER_SIZE);
gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
GLU_EXPECT_NO_ERROR(gl.getError(), "set viewport");
gl.enable(GL_BLEND);
gl.blendFunc(GL_SRC_ALPHA, GL_ONE);
gl.blendEquation(GL_FUNC_ADD);
GLU_EXPECT_NO_ERROR(gl.getError(), "set blend");
m_testCtx.getLog() << tcu::TestLog::Message << "Tessellation level: inner " << innerTessellationLevel << ", outer "
<< outerTessellationLevel << tcu::TestLog::EndMessage;
// render with and without geometry shader
for (int renderNdx = 0; renderNdx < DE_LENGTH_OF_ARRAY(renderTargets); ++renderNdx)
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), renderTargets[renderNdx].name,
renderTargets[renderNdx].description);
glu::ProgramSources sources;
sources << glu::VertexSource(getVertexSource()) << glu::FragmentSource(getFragmentSource())
<< glu::TessellationControlSource(getTessellationControlSource())
<< glu::TessellationEvaluationSource(
getTessellationEvaluationSource(renderTargets[renderNdx].containsGeometryShader));
if (renderTargets[renderNdx].containsGeometryShader)
sources << glu::GeometrySource(getGeometrySource());
{
const glu::ShaderProgram program(m_context.getRenderContext(), sources);
const glu::VertexArray vao(m_context.getRenderContext());
const int posLocation = gl.getAttribLocation(program.getProgram(), "a_position");
const int innerTessellationLoc = gl.getUniformLocation(program.getProgram(), "u_innerTessellationLevel");
const int outerTessellationLoc = gl.getUniformLocation(program.getProgram(), "u_outerTessellationLevel");
m_testCtx.getLog() << program;
if (!program.isOk())
throw tcu::TestError("could not build program");
if (posLocation == -1)
throw tcu::TestError("a_position location was -1");
if (outerTessellationLoc == -1)
throw tcu::TestError("u_outerTessellationLevel location was -1");
gl.bindVertexArray(*vao);
gl.bindBuffer(GL_ARRAY_BUFFER, m_patchBuffer);
gl.vertexAttribPointer(posLocation, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL);
gl.enableVertexAttribArray(posLocation);
GLU_EXPECT_NO_ERROR(gl.getError(), "setup attribs");
gl.useProgram(program.getProgram());
gl.uniform1f(outerTessellationLoc, outerTessellationLevel);
if (innerTessellationLoc == -1)
gl.uniform1f(innerTessellationLoc, innerTessellationLevel);
GLU_EXPECT_NO_ERROR(gl.getError(), "use program");
gl.patchParameteri(GL_PATCH_VERTICES, (m_case == CASE_TRIANGLES) ? (3) : (4));
GLU_EXPECT_NO_ERROR(gl.getError(), "set patch param");
gl.clear(GL_COLOR_BUFFER_BIT);
GLU_EXPECT_NO_ERROR(gl.getError(), "clear");
gl.drawArrays(GL_PATCHES, 0, 4);
GLU_EXPECT_NO_ERROR(gl.getError(), "draw patches");
glu::readPixels(m_context.getRenderContext(), 0, 0, renderTargets[renderNdx].surfaceAccess);
}
}
if (tcu::intThresholdPositionDeviationCompare(m_testCtx.getLog(), "ImageCompare", "Image comparison",
resultWithoutGeometry.getAccess(), resultWithGeometry.getAccess(),
tcu::UVec4(8, 8, 8, 255), tcu::IVec3(1, 1, 0), true,
tcu::COMPARE_LOG_RESULT))
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
else
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
return STOP;
}
std::string IdentityGeometryShaderCase::getTessellationControlSource(void) const
{
std::ostringstream buf;
buf << "${VERSION_DECL}\n"
"${EXTENSION_TESSELATION_SHADER}"
"layout(vertices = 4) out;\n"
"\n"
"uniform highp float u_innerTessellationLevel;\n"
"uniform highp float u_outerTessellationLevel;\n"
"in highp vec4 v_vertex_color[];\n"
"out highp vec4 v_patch_color[];\n"
"\n"
"void main (void)\n"
"{\n"
" gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
" v_patch_color[gl_InvocationID] = v_vertex_color[gl_InvocationID];\n"
"\n";
if (m_case == CASE_TRIANGLES)
buf << " gl_TessLevelOuter[0] = u_outerTessellationLevel;\n"
" gl_TessLevelOuter[1] = u_outerTessellationLevel;\n"
" gl_TessLevelOuter[2] = u_outerTessellationLevel;\n"
" gl_TessLevelInner[0] = u_innerTessellationLevel;\n";
else if (m_case == CASE_QUADS)
buf << " gl_TessLevelOuter[0] = u_outerTessellationLevel;\n"
" gl_TessLevelOuter[1] = u_outerTessellationLevel;\n"
" gl_TessLevelOuter[2] = u_outerTessellationLevel;\n"
" gl_TessLevelOuter[3] = u_outerTessellationLevel;\n"
" gl_TessLevelInner[0] = u_innerTessellationLevel;\n"
" gl_TessLevelInner[1] = u_innerTessellationLevel;\n";
else if (m_case == CASE_ISOLINES)
buf << " gl_TessLevelOuter[0] = u_outerTessellationLevel;\n"
" gl_TessLevelOuter[1] = u_outerTessellationLevel;\n";
else
DE_ASSERT(false);
buf << "}\n";
return specializeShader(buf.str(), m_context.getRenderContext().getType());
}
std::string IdentityGeometryShaderCase::getTessellationEvaluationSource(bool geometryActive) const
{
const char *const colorOutputName = ((geometryActive) ? ("v_evaluated_color") : ("v_fragment_color"));
std::ostringstream buf;
buf << "${VERSION_DECL}\n"
"${EXTENSION_TESSELATION_SHADER}"
"layout("
<< ((m_case == CASE_TRIANGLES) ? ("triangles") :
(m_case == CASE_QUADS) ? ("quads") :
("isolines"))
<< ") in;\n"
"\n"
"in highp vec4 v_patch_color[];\n"
"out highp vec4 "
<< colorOutputName
<< ";\n"
"\n"
"// note: No need to use precise gl_Position since we do not require gapless geometry\n"
"void main (void)\n"
"{\n";
if (m_case == CASE_TRIANGLES)
buf << " vec3 weights = vec3(pow(gl_TessCoord.x, 1.3), pow(gl_TessCoord.y, 1.3), pow(gl_TessCoord.z, "
"1.3));\n"
" vec3 cweights = gl_TessCoord;\n"
" gl_Position = vec4(weights.x * gl_in[0].gl_Position.xyz + weights.y * gl_in[1].gl_Position.xyz + "
"weights.z * gl_in[2].gl_Position.xyz, 1.0);\n"
" "
<< colorOutputName
<< " = cweights.x * v_patch_color[0] + cweights.y * v_patch_color[1] + cweights.z * v_patch_color[2];\n";
else if (m_case == CASE_QUADS || m_case == CASE_ISOLINES)
buf << " vec2 normalizedCoord = (gl_TessCoord.xy * 2.0 - vec2(1.0));\n"
" vec2 normalizedWeights = normalizedCoord * (vec2(1.0) - 0.3 * cos(normalizedCoord.yx * 1.57));\n"
" vec2 weights = normalizedWeights * 0.5 + vec2(0.5);\n"
" vec2 cweights = gl_TessCoord.xy;\n"
" gl_Position = mix(mix(gl_in[0].gl_Position, gl_in[1].gl_Position, weights.y), "
"mix(gl_in[2].gl_Position, gl_in[3].gl_Position, weights.y), weights.x);\n"
" "
<< colorOutputName
<< " = mix(mix(v_patch_color[0], v_patch_color[1], cweights.y), mix(v_patch_color[2], v_patch_color[3], "
"cweights.y), cweights.x);\n";
else
DE_ASSERT(false);
buf << "}\n";
return specializeShader(buf.str(), m_context.getRenderContext().getType());
}
std::string IdentityGeometryShaderCase::getGeometrySource(void) const
{
const char *const geometryInputPrimitive = (m_case == CASE_ISOLINES) ? ("lines") : ("triangles");
const char *const geometryOutputPrimitive = (m_case == CASE_ISOLINES) ? ("line_strip") : ("triangle_strip");
const int numEmitVertices = (m_case == CASE_ISOLINES) ? (2) : (3);
std::ostringstream buf;
buf << "${VERSION_DECL}\n"
"${EXTENSION_GEOMETRY_SHADER}"
"layout("
<< geometryInputPrimitive
<< ") in;\n"
"layout("
<< geometryOutputPrimitive << ", max_vertices=" << numEmitVertices
<< ") out;\n"
"\n"
"in highp vec4 v_evaluated_color[];\n"
"out highp vec4 v_fragment_color;\n"
"\n"
"void main (void)\n"
"{\n"
" for (int ndx = 0; ndx < gl_in.length(); ++ndx)\n"
" {\n"
" gl_Position = gl_in[ndx].gl_Position;\n"
" v_fragment_color = v_evaluated_color[ndx];\n"
" EmitVertex();\n"
" }\n"
"}\n";
return specializeShader(buf.str(), m_context.getRenderContext().getType());
}
class IdentityTessellationShaderCase : public IdentityShaderCase
{
public:
enum CaseType
{
CASE_TRIANGLES = 0,
CASE_ISOLINES,
};
IdentityTessellationShaderCase(Context &context, const char *name, const char *description, CaseType caseType);
~IdentityTessellationShaderCase(void);
private:
void init(void);
void deinit(void);
IterateResult iterate(void);
std::string getTessellationControlSource(void) const;
std::string getTessellationEvaluationSource(void) const;
std::string getGeometrySource(bool tessellationActive) const;
enum
{
RENDER_SIZE = 256,
};
const CaseType m_case;
uint32_t m_dataBuffer;
};
IdentityTessellationShaderCase::IdentityTessellationShaderCase(Context &context, const char *name,
const char *description, CaseType caseType)
: IdentityShaderCase(context, name, description)
, m_case(caseType)
, m_dataBuffer(0)
{
}
IdentityTessellationShaderCase::~IdentityTessellationShaderCase(void)
{
deinit();
}
void IdentityTessellationShaderCase::init(void)
{
// Requirements
const bool supportsES32orGL45 =
glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)) ||
glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5));
if (!supportsES32orGL45 && (!m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader") ||
!m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")))
throw tcu::NotSupportedError("Test requires GL_EXT_tessellation_shader and GL_EXT_geometry_shader extensions");
if (m_context.getRenderTarget().getWidth() < RENDER_SIZE || m_context.getRenderTarget().getHeight() < RENDER_SIZE)
throw tcu::NotSupportedError("Test requires " + de::toString<int>(RENDER_SIZE) + "x" +
de::toString<int>(RENDER_SIZE) + " or larger render target.");
// Log
m_testCtx.getLog()
<< tcu::TestLog::Message
<< "Testing geometry shading shader program output does not change when a passthrough tessellation shader is "
"attached.\n"
<< "Rendering two images, first with and second without a tessellation shader. Expecting similar results.\n"
<< "Using additive blending to detect overlap.\n"
<< tcu::TestLog::EndMessage;
// Resources
{
static const tcu::Vec4 pointData[] = {
tcu::Vec4(-0.4f, 0.4f, 0.0f, 1.0f),
tcu::Vec4(0.0f, -0.5f, 0.0f, 1.0f),
tcu::Vec4(0.4f, 0.4f, 0.0f, 1.0f),
};
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
gl.genBuffers(1, &m_dataBuffer);
gl.bindBuffer(GL_ARRAY_BUFFER, m_dataBuffer);
gl.bufferData(GL_ARRAY_BUFFER, sizeof(pointData), pointData, GL_STATIC_DRAW);
GLU_EXPECT_NO_ERROR(gl.getError(), "gen buffer");
}
}
void IdentityTessellationShaderCase::deinit(void)
{
if (m_dataBuffer)
{
m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_dataBuffer);
m_dataBuffer = 0;
}
}
IdentityTessellationShaderCase::IterateResult IdentityTessellationShaderCase::iterate(void)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
tcu::Surface resultWithTessellation(RENDER_SIZE, RENDER_SIZE);
tcu::Surface resultWithoutTessellation(RENDER_SIZE, RENDER_SIZE);
const int numPrimitiveVertices = (m_case == CASE_TRIANGLES) ? (3) : (2);
const struct
{
const char *name;
const char *description;
bool containsTessellationShaders;
tcu::PixelBufferAccess surfaceAccess;
} renderTargets[] = {
{"RenderWithTessellationShader", "Render with tessellation shader", true, resultWithTessellation.getAccess()},
{"RenderWithoutTessellationShader", "Render without tessellation shader", false,
resultWithoutTessellation.getAccess()},
};
gl.viewport(0, 0, RENDER_SIZE, RENDER_SIZE);
gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
GLU_EXPECT_NO_ERROR(gl.getError(), "set viewport");
gl.enable(GL_BLEND);
gl.blendFunc(GL_SRC_ALPHA, GL_ONE);
gl.blendEquation(GL_FUNC_ADD);
GLU_EXPECT_NO_ERROR(gl.getError(), "set blend");
// render with and without tessellation shader
for (int renderNdx = 0; renderNdx < DE_LENGTH_OF_ARRAY(renderTargets); ++renderNdx)
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), renderTargets[renderNdx].name,
renderTargets[renderNdx].description);
glu::ProgramSources sources;
sources << glu::VertexSource(getVertexSource()) << glu::FragmentSource(getFragmentSource())
<< glu::GeometrySource(getGeometrySource(renderTargets[renderNdx].containsTessellationShaders));
if (renderTargets[renderNdx].containsTessellationShaders)
sources << glu::TessellationControlSource(getTessellationControlSource())
<< glu::TessellationEvaluationSource(getTessellationEvaluationSource());
{
const glu::ShaderProgram program(m_context.getRenderContext(), sources);
const glu::VertexArray vao(m_context.getRenderContext());
const int posLocation = gl.getAttribLocation(program.getProgram(), "a_position");
m_testCtx.getLog() << program;
if (!program.isOk())
throw tcu::TestError("could not build program");
if (posLocation == -1)
throw tcu::TestError("a_position location was -1");
gl.bindVertexArray(*vao);
gl.bindBuffer(GL_ARRAY_BUFFER, m_dataBuffer);
gl.vertexAttribPointer(posLocation, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL);
gl.enableVertexAttribArray(posLocation);
GLU_EXPECT_NO_ERROR(gl.getError(), "setup attribs");
gl.useProgram(program.getProgram());
GLU_EXPECT_NO_ERROR(gl.getError(), "use program");
gl.clear(GL_COLOR_BUFFER_BIT);
GLU_EXPECT_NO_ERROR(gl.getError(), "clear");
if (renderTargets[renderNdx].containsTessellationShaders)
{
gl.patchParameteri(GL_PATCH_VERTICES, numPrimitiveVertices);
GLU_EXPECT_NO_ERROR(gl.getError(), "set patch param");
gl.drawArrays(GL_PATCHES, 0, numPrimitiveVertices);
GLU_EXPECT_NO_ERROR(gl.getError(), "draw patches");
}
else
{
gl.drawArrays((m_case == CASE_TRIANGLES) ? (GL_TRIANGLES) : (GL_LINES), 0, numPrimitiveVertices);
GLU_EXPECT_NO_ERROR(gl.getError(), "draw primitives");
}
glu::readPixels(m_context.getRenderContext(), 0, 0, renderTargets[renderNdx].surfaceAccess);
}
}
// compare
{
bool imageOk;
if (m_context.getRenderTarget().getNumSamples() > 1)
imageOk = tcu::fuzzyCompare(m_testCtx.getLog(), "ImageCompare", "Image comparison",
resultWithoutTessellation.getAccess(), resultWithTessellation.getAccess(),
0.03f, tcu::COMPARE_LOG_RESULT);
else
imageOk = tcu::intThresholdPositionDeviationCompare(
m_testCtx.getLog(), "ImageCompare", "Image comparison", resultWithoutTessellation.getAccess(),
resultWithTessellation.getAccess(), tcu::UVec4(8, 8, 8, 255), //!< threshold
tcu::IVec3(1, 1, 0), //!< 3x3 search kernel
true, //!< fragments may end up over the viewport, just ignore them
tcu::COMPARE_LOG_RESULT);
if (imageOk)
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
else
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
}
return STOP;
}
std::string IdentityTessellationShaderCase::getTessellationControlSource(void) const
{
std::ostringstream buf;
buf << "${VERSION_DECL}\n"
"${EXTENSION_TESSELATION_SHADER}"
"layout(vertices = "
<< ((m_case == CASE_TRIANGLES) ? (3) : (2))
<< ") out;\n"
"\n"
"in highp vec4 v_vertex_color[];\n"
"out highp vec4 v_control_color[];\n"
"\n"
"void main (void)\n"
"{\n"
" gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
" v_control_color[gl_InvocationID] = v_vertex_color[gl_InvocationID];\n"
"\n";
if (m_case == CASE_TRIANGLES)
buf << " gl_TessLevelOuter[0] = 1.0;\n"
" gl_TessLevelOuter[1] = 1.0;\n"
" gl_TessLevelOuter[2] = 1.0;\n"
" gl_TessLevelInner[0] = 1.0;\n";
else if (m_case == CASE_ISOLINES)
buf << " gl_TessLevelOuter[0] = 1.0;\n"
" gl_TessLevelOuter[1] = 1.0;\n";
else
DE_ASSERT(false);
buf << "}\n";
return specializeShader(buf.str(), m_context.getRenderContext().getType());
}
std::string IdentityTessellationShaderCase::getTessellationEvaluationSource(void) const
{
std::ostringstream buf;
buf << "${VERSION_DECL}\n"
"${EXTENSION_TESSELATION_SHADER}"
"layout("
<< ((m_case == CASE_TRIANGLES) ? ("triangles") : ("isolines"))
<< ") in;\n"
"\n"
"in highp vec4 v_control_color[];\n"
"out highp vec4 v_evaluated_color;\n"
"\n"
"// note: No need to use precise gl_Position since we do not require gapless geometry\n"
"void main (void)\n"
"{\n";
if (m_case == CASE_TRIANGLES)
buf << " gl_Position = gl_TessCoord.x * gl_in[0].gl_Position + gl_TessCoord.y * gl_in[1].gl_Position + "
"gl_TessCoord.z * gl_in[2].gl_Position;\n"
" v_evaluated_color = gl_TessCoord.x * v_control_color[0] + gl_TessCoord.y * v_control_color[1] + "
"gl_TessCoord.z * v_control_color[2];\n";
else if (m_case == CASE_ISOLINES)
buf << " gl_Position = mix(gl_in[0].gl_Position, gl_in[1].gl_Position, gl_TessCoord.x);\n"
" v_evaluated_color = mix(v_control_color[0], v_control_color[1], gl_TessCoord.x);\n";
else
DE_ASSERT(false);
buf << "}\n";
return specializeShader(buf.str(), m_context.getRenderContext().getType());
}
std::string IdentityTessellationShaderCase::getGeometrySource(bool tessellationActive) const
{
const char *const colorSourceName = (tessellationActive) ? ("v_evaluated_color") : ("v_vertex_color");
const char *const geometryInputPrimitive = (m_case == CASE_ISOLINES) ? ("lines") : ("triangles");
const char *const geometryOutputPrimitive = (m_case == CASE_ISOLINES) ? ("line_strip") : ("triangle_strip");
const int numEmitVertices = (m_case == CASE_ISOLINES) ? (11) : (8);
std::ostringstream buf;
buf << "${VERSION_DECL}\n"
"${EXTENSION_GEOMETRY_SHADER}"
"layout("
<< geometryInputPrimitive
<< ") in;\n"
"layout("
<< geometryOutputPrimitive << ", max_vertices=" << numEmitVertices
<< ") out;\n"
"\n"
"in highp vec4 "
<< colorSourceName
<< "[];\n"
"out highp vec4 v_fragment_color;\n"
"\n"
"void main (void)\n"
"{\n";
if (m_case == CASE_TRIANGLES)
{
buf << " vec4 centerPos = (gl_in[0].gl_Position + gl_in[1].gl_Position + gl_in[2].gl_Position) / 3.0f;\n"
"\n"
" for (int ndx = 0; ndx < 4; ++ndx)\n"
" {\n"
" gl_Position = centerPos + (centerPos - gl_in[ndx % 3].gl_Position);\n"
" v_fragment_color = "
<< colorSourceName
<< "[ndx % 3];\n"
" EmitVertex();\n"
"\n"
" gl_Position = centerPos + 0.7 * (centerPos - gl_in[ndx % 3].gl_Position);\n"
" v_fragment_color = "
<< colorSourceName
<< "[ndx % 3];\n"
" EmitVertex();\n"
" }\n";
}
else if (m_case == CASE_ISOLINES)
{
buf << " vec4 mdir = vec4(gl_in[0].gl_Position.y - gl_in[1].gl_Position.y, gl_in[1].gl_Position.x - "
"gl_in[0].gl_Position.x, 0.0, 0.0);\n"
" for (int i = 0; i <= 10; ++i)\n"
" {\n"
" float xweight = cos(float(i) / 10.0 * 6.28) * 0.5 + 0.5;\n"
" float mweight = sin(float(i) / 10.0 * 6.28) * 0.1 + 0.1;\n"
" gl_Position = mix(gl_in[0].gl_Position, gl_in[1].gl_Position, xweight) + mweight * mdir;\n"
" v_fragment_color = mix("
<< colorSourceName << "[0], " << colorSourceName
<< "[1], xweight);\n"
" EmitVertex();\n"
" }\n";
}
else
DE_ASSERT(false);
buf << "}\n";
return specializeShader(buf.str(), m_context.getRenderContext().getType());
}
class FeedbackPrimitiveTypeCase : public TestCase
{
public:
enum TessellationOutputType
{
TESSELLATION_OUT_TRIANGLES = 0,
TESSELLATION_OUT_QUADS,
TESSELLATION_OUT_ISOLINES,
TESSELLATION_OUT_LAST
};
enum TessellationPointMode
{
TESSELLATION_POINTMODE_OFF = 0,
TESSELLATION_POINTMODE_ON,
TESSELLATION_POINTMODE_LAST
};
enum GeometryOutputType
{
GEOMETRY_OUTPUT_POINTS = 0,
GEOMETRY_OUTPUT_LINES,
GEOMETRY_OUTPUT_TRIANGLES,
GEOMETRY_OUTPUT_LAST
};
FeedbackPrimitiveTypeCase(Context &context, const char *name, const char *description,
TessellationOutputType tessellationOutput, TessellationPointMode tessellationPointMode,
GeometryOutputType geometryOutputType);
~FeedbackPrimitiveTypeCase(void);
private:
void init(void);
void deinit(void);
IterateResult iterate(void);
void renderWithFeedback(tcu::Surface &dst);
void renderWithoutFeedback(tcu::Surface &dst);
void verifyFeedbackResults(const std::vector<tcu::Vec4> &feedbackResult);
void verifyRenderedImage(const tcu::Surface &image, const std::vector<tcu::Vec4> &vertices);
void genTransformFeedback(void);
int getNumGeneratedElementsPerPrimitive(void) const;
int getNumGeneratedPrimitives(void) const;
int getNumTessellatedPrimitives(void) const;
int getGeometryAmplification(void) const;
std::string getVertexSource(void) const;
std::string getFragmentSource(void) const;
std::string getTessellationControlSource(void) const;
std::string getTessellationEvaluationSource(void) const;
std::string getGeometrySource(void) const;
static const char *getTessellationOutputDescription(TessellationOutputType tessellationOutput,
TessellationPointMode tessellationPointMode);
static const char *getGeometryInputDescription(TessellationOutputType tessellationOutput,
TessellationPointMode tessellationPointMode);
static const char *getGeometryOutputDescription(GeometryOutputType geometryOutput);
glw::GLenum getOutputPrimitiveGLType(void) const;
enum
{
RENDER_SIZE = 128,
};
const TessellationOutputType m_tessellationOutput;
const TessellationPointMode m_tessellationPointMode;
const GeometryOutputType m_geometryOutputType;
glu::ShaderProgram *m_feedbackProgram;
glu::ShaderProgram *m_nonFeedbackProgram;
uint32_t m_patchBuffer;
uint32_t m_feedbackID;
uint32_t m_feedbackBuffer;
};
FeedbackPrimitiveTypeCase::FeedbackPrimitiveTypeCase(Context &context, const char *name, const char *description,
TessellationOutputType tessellationOutput,
TessellationPointMode tessellationPointMode,
GeometryOutputType geometryOutputType)
: TestCase(context, name, description)
, m_tessellationOutput(tessellationOutput)
, m_tessellationPointMode(tessellationPointMode)
, m_geometryOutputType(geometryOutputType)
, m_feedbackProgram(DE_NULL)
, m_nonFeedbackProgram(DE_NULL)
, m_patchBuffer(0)
, m_feedbackID(0)
, m_feedbackBuffer(0)
{
DE_ASSERT(tessellationOutput < TESSELLATION_OUT_LAST);
DE_ASSERT(tessellationPointMode < TESSELLATION_POINTMODE_LAST);
DE_ASSERT(geometryOutputType < GEOMETRY_OUTPUT_LAST);
}
FeedbackPrimitiveTypeCase::~FeedbackPrimitiveTypeCase(void)
{
deinit();
}
void FeedbackPrimitiveTypeCase::init(void)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
// Requirements
const bool supportsES32orGL45 =
glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)) ||
glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5));
if (!supportsES32orGL45 && (!m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader") ||
!m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")))
throw tcu::NotSupportedError("Test requires GL_EXT_tessellation_shader and GL_EXT_geometry_shader extensions");
if (m_context.getRenderTarget().getWidth() < RENDER_SIZE || m_context.getRenderTarget().getHeight() < RENDER_SIZE)
throw tcu::NotSupportedError("Test requires " + de::toString<int>(RENDER_SIZE) + "x" +
de::toString<int>(RENDER_SIZE) + " or larger render target.");
// Log
m_testCtx.getLog() << tcu::TestLog::Message << "Testing "
<< getTessellationOutputDescription(m_tessellationOutput, m_tessellationPointMode) << "->"
<< getGeometryInputDescription(m_tessellationOutput, m_tessellationPointMode)
<< " primitive conversion with and without transform feedback.\n"
<< "Sending a patch of 4 vertices (2x2 uniform grid) to tessellation control shader.\n"
<< "Control shader emits a patch of 9 vertices (3x3 uniform grid).\n"
<< "Setting outer tessellation level = 3, inner = 3.\n"
<< "Primitive generator emits "
<< getTessellationOutputDescription(m_tessellationOutput, m_tessellationPointMode) << "\n"
<< "Geometry shader transforms emitted primitives to "
<< getGeometryOutputDescription(m_geometryOutputType) << "\n"
<< "Reading back vertex positions of generated primitives using transform feedback.\n"
<< "Verifying rendered image and feedback vertices are consistent.\n"
<< "Rendering scene again with identical shader program, but without setting feedback varying. "
"Expecting similar output image."
<< tcu::TestLog::EndMessage;
// Resources
{
static const tcu::Vec4 patchBufferData[4] = {
tcu::Vec4(-0.9f, -0.9f, 0.0f, 1.0f),
tcu::Vec4(-0.9f, 0.9f, 0.0f, 1.0f),
tcu::Vec4(0.9f, -0.9f, 0.0f, 1.0f),
tcu::Vec4(0.9f, 0.9f, 0.0f, 1.0f),
};
gl.genBuffers(1, &m_patchBuffer);
gl.bindBuffer(GL_ARRAY_BUFFER, m_patchBuffer);
gl.bufferData(GL_ARRAY_BUFFER, sizeof(patchBufferData), patchBufferData, GL_STATIC_DRAW);
GLU_EXPECT_NO_ERROR(gl.getError(), "gen buffer");
}
m_feedbackProgram = new glu::ShaderProgram(
m_context.getRenderContext(),
glu::ProgramSources() << glu::VertexSource(getVertexSource()) << glu::FragmentSource(getFragmentSource())
<< glu::TessellationControlSource(getTessellationControlSource())
<< glu::TessellationEvaluationSource(getTessellationEvaluationSource())
<< glu::GeometrySource(getGeometrySource())
<< glu::TransformFeedbackVarying("tf_someVertexPosition")
<< glu::TransformFeedbackMode(GL_INTERLEAVED_ATTRIBS));
m_testCtx.getLog() << *m_feedbackProgram;
if (!m_feedbackProgram->isOk())
throw tcu::TestError("failed to build program");
m_nonFeedbackProgram = new glu::ShaderProgram(
m_context.getRenderContext(),
glu::ProgramSources() << glu::VertexSource(getVertexSource()) << glu::FragmentSource(getFragmentSource())
<< glu::TessellationControlSource(getTessellationControlSource())
<< glu::TessellationEvaluationSource(getTessellationEvaluationSource())
<< glu::GeometrySource(getGeometrySource()));
if (!m_nonFeedbackProgram->isOk())
{
m_testCtx.getLog() << *m_nonFeedbackProgram;
throw tcu::TestError("failed to build program");
}
genTransformFeedback();
}
void FeedbackPrimitiveTypeCase::deinit(void)
{
if (m_patchBuffer)
{
m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_patchBuffer);
m_patchBuffer = 0;
}
if (m_feedbackBuffer)
{
m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_feedbackBuffer);
m_feedbackBuffer = 0;
}
if (m_feedbackID)
{
m_context.getRenderContext().getFunctions().deleteTransformFeedbacks(1, &m_feedbackID);
m_feedbackID = 0;
}
if (m_feedbackProgram)
{
delete m_feedbackProgram;
m_feedbackProgram = DE_NULL;
}
if (m_nonFeedbackProgram)
{
delete m_nonFeedbackProgram;
m_nonFeedbackProgram = DE_NULL;
}
}
FeedbackPrimitiveTypeCase::IterateResult FeedbackPrimitiveTypeCase::iterate(void)
{
tcu::Surface feedbackResult(RENDER_SIZE, RENDER_SIZE);
tcu::Surface nonFeedbackResult(RENDER_SIZE, RENDER_SIZE);
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
// render with and without XFB
renderWithFeedback(feedbackResult);
renderWithoutFeedback(nonFeedbackResult);
// compare
{
bool imageOk;
m_testCtx.getLog() << tcu::TestLog::Message
<< "Comparing the image rendered with no transform feedback against the image rendered with "
"enabled transform feedback."
<< tcu::TestLog::EndMessage;
if (m_context.getRenderTarget().getNumSamples() > 1)
imageOk =
tcu::fuzzyCompare(m_testCtx.getLog(), "ImageCompare", "Image comparison", feedbackResult.getAccess(),
nonFeedbackResult.getAccess(), 0.03f, tcu::COMPARE_LOG_RESULT);
else
imageOk = tcu::intThresholdPositionDeviationCompare(
m_testCtx.getLog(), "ImageCompare", "Image comparison", feedbackResult.getAccess(),
nonFeedbackResult.getAccess(), tcu::UVec4(8, 8, 8, 255), //!< threshold
tcu::IVec3(1, 1, 0), //!< 3x3 search kernel
true, //!< fragments may end up over the viewport, just ignore them
tcu::COMPARE_LOG_RESULT);
if (!imageOk)
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
}
return STOP;
}
void FeedbackPrimitiveTypeCase::renderWithFeedback(tcu::Surface &dst)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
const glu::VertexArray vao(m_context.getRenderContext());
const glu::Query primitivesGeneratedQuery(m_context.getRenderContext());
const int posLocation = gl.getAttribLocation(m_feedbackProgram->getProgram(), "a_position");
const glw::GLenum feedbackPrimitiveMode = getOutputPrimitiveGLType();
if (posLocation == -1)
throw tcu::TestError("a_position was -1");
m_testCtx.getLog() << tcu::TestLog::Message << "Rendering with transform feedback" << tcu::TestLog::EndMessage;
gl.viewport(0, 0, dst.getWidth(), dst.getHeight());
gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
gl.clear(GL_COLOR_BUFFER_BIT);
GLU_EXPECT_NO_ERROR(gl.getError(), "clear");
gl.bindVertexArray(*vao);
gl.bindBuffer(GL_ARRAY_BUFFER, m_patchBuffer);
gl.vertexAttribPointer(posLocation, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL);
gl.enableVertexAttribArray(posLocation);
GLU_EXPECT_NO_ERROR(gl.getError(), "setup attribs");
gl.useProgram(m_feedbackProgram->getProgram());
GLU_EXPECT_NO_ERROR(gl.getError(), "use program");
gl.patchParameteri(GL_PATCH_VERTICES, 4);
GLU_EXPECT_NO_ERROR(gl.getError(), "set patch param");
gl.beginQuery(GL_PRIMITIVES_GENERATED, *primitivesGeneratedQuery);
GLU_EXPECT_NO_ERROR(gl.getError(), "begin GL_PRIMITIVES_GENERATED query");
m_testCtx.getLog() << tcu::TestLog::Message << "Begin transform feedback with mode "
<< glu::getPrimitiveTypeStr(feedbackPrimitiveMode) << tcu::TestLog::EndMessage;
gl.beginTransformFeedback(feedbackPrimitiveMode);
GLU_EXPECT_NO_ERROR(gl.getError(), "begin xfb");
m_testCtx.getLog() << tcu::TestLog::Message << "Calling drawArrays with mode GL_PATCHES"
<< tcu::TestLog::EndMessage;
gl.drawArrays(GL_PATCHES, 0, 4);
GLU_EXPECT_NO_ERROR(gl.getError(), "draw patches");
gl.endTransformFeedback();
GLU_EXPECT_NO_ERROR(gl.getError(), "end xfb");
gl.endQuery(GL_PRIMITIVES_GENERATED);
GLU_EXPECT_NO_ERROR(gl.getError(), "end GL_PRIMITIVES_GENERATED query");
glu::readPixels(m_context.getRenderContext(), 0, 0, dst.getAccess());
GLU_EXPECT_NO_ERROR(gl.getError(), "readPixels");
// verify GL_PRIMITIVES_GENERATED
{
glw::GLuint primitivesGeneratedResult = 0;
gl.getQueryObjectuiv(*primitivesGeneratedQuery, GL_QUERY_RESULT, &primitivesGeneratedResult);
GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_PRIMITIVES_GENERATED value");
m_testCtx.getLog() << tcu::TestLog::Message << "Verifying GL_PRIMITIVES_GENERATED, expecting "
<< getNumGeneratedPrimitives() << tcu::TestLog::EndMessage;
if ((int)primitivesGeneratedResult != getNumGeneratedPrimitives())
{
m_testCtx.getLog() << tcu::TestLog::Message << "Error, GL_PRIMITIVES_GENERATED was "
<< primitivesGeneratedResult << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got unexpected GL_PRIMITIVES_GENERATED");
}
else
m_testCtx.getLog() << tcu::TestLog::Message << "GL_PRIMITIVES_GENERATED valid." << tcu::TestLog::EndMessage;
}
// feedback
{
std::vector<tcu::Vec4> feedbackResults(getNumGeneratedElementsPerPrimitive() * getNumGeneratedPrimitives());
const void *mappedPtr =
gl.mapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0,
(glw::GLsizeiptr)(feedbackResults.size() * sizeof(tcu::Vec4)), GL_MAP_READ_BIT);
glw::GLboolean unmapResult;
GLU_EXPECT_NO_ERROR(gl.getError(), "mapBufferRange");
m_testCtx.getLog() << tcu::TestLog::Message << "Reading transform feedback buffer." << tcu::TestLog::EndMessage;
if (!mappedPtr)
throw tcu::TestError("mapBufferRange returned null");
deMemcpy(feedbackResults[0].getPtr(), mappedPtr, (int)(feedbackResults.size() * sizeof(tcu::Vec4)));
unmapResult = gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
GLU_EXPECT_NO_ERROR(gl.getError(), "unmapBuffer");
if (unmapResult != GL_TRUE)
throw tcu::TestError("unmapBuffer failed, did not return true");
// verify transform results
verifyFeedbackResults(feedbackResults);
// verify feedback results are consistent with rendered image
verifyRenderedImage(dst, feedbackResults);
}
}
void FeedbackPrimitiveTypeCase::renderWithoutFeedback(tcu::Surface &dst)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
const glu::VertexArray vao(m_context.getRenderContext());
const int posLocation = gl.getAttribLocation(m_nonFeedbackProgram->getProgram(), "a_position");
if (posLocation == -1)
throw tcu::TestError("a_position was -1");
m_testCtx.getLog() << tcu::TestLog::Message << "Rendering without transform feedback" << tcu::TestLog::EndMessage;
gl.viewport(0, 0, dst.getWidth(), dst.getHeight());
gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
gl.clear(GL_COLOR_BUFFER_BIT);
GLU_EXPECT_NO_ERROR(gl.getError(), "clear");
gl.bindVertexArray(*vao);
gl.bindBuffer(GL_ARRAY_BUFFER, m_patchBuffer);
gl.vertexAttribPointer(posLocation, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL);
gl.enableVertexAttribArray(posLocation);
GLU_EXPECT_NO_ERROR(gl.getError(), "setup attribs");
gl.useProgram(m_nonFeedbackProgram->getProgram());
GLU_EXPECT_NO_ERROR(gl.getError(), "use program");
gl.patchParameteri(GL_PATCH_VERTICES, 4);
GLU_EXPECT_NO_ERROR(gl.getError(), "set patch param");
m_testCtx.getLog() << tcu::TestLog::Message << "Calling drawArrays with mode GL_PATCHES"
<< tcu::TestLog::EndMessage;
gl.drawArrays(GL_PATCHES, 0, 4);
GLU_EXPECT_NO_ERROR(gl.getError(), "draw patches");
glu::readPixels(m_context.getRenderContext(), 0, 0, dst.getAccess());
GLU_EXPECT_NO_ERROR(gl.getError(), "readPixels");
}
void FeedbackPrimitiveTypeCase::verifyFeedbackResults(const std::vector<tcu::Vec4> &feedbackResult)
{
const int geometryAmplification = getGeometryAmplification();
const int elementsPerPrimitive = getNumGeneratedElementsPerPrimitive();
const int errorFloodThreshold = 8;
int readNdx = 0;
int numErrors = 0;
m_testCtx.getLog() << tcu::TestLog::Message << "Verifying feedback results." << tcu::TestLog::EndMessage;
for (int tessellatedPrimitiveNdx = 0; tessellatedPrimitiveNdx < getNumTessellatedPrimitives();
++tessellatedPrimitiveNdx)
{
const tcu::Vec4 primitiveVertex = feedbackResult[readNdx];
// check the generated vertices are in the proper range (range: -0.4 <-> 0.4)
{
const float equalThreshold = 1.0e-6f;
const bool centroidOk =
(primitiveVertex.x() >= -0.4f - equalThreshold) && (primitiveVertex.x() <= 0.4f + equalThreshold) &&
(primitiveVertex.y() >= -0.4f - equalThreshold) && (primitiveVertex.y() <= 0.4f + equalThreshold) &&
(de::abs(primitiveVertex.z()) < equalThreshold) &&
(de::abs(primitiveVertex.w() - 1.0f) < equalThreshold);
if (!centroidOk && numErrors++ < errorFloodThreshold)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Element at index " << (readNdx)
<< " (tessellation invocation " << tessellatedPrimitiveNdx << ")\n"
<< "\texpected vertex in range: ( [-0.4, 0.4], [-0.4, 0.4], 0.0, 1.0 )\n"
<< "\tgot: " << primitiveVertex << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "invalid feedback output");
++readNdx;
continue;
}
}
// check all other primitives generated from this tessellated primitive have the same feedback value
for (int generatedPrimitiveNdx = 0; generatedPrimitiveNdx < geometryAmplification; ++generatedPrimitiveNdx)
for (int primitiveVertexNdx = 0; primitiveVertexNdx < elementsPerPrimitive; ++primitiveVertexNdx)
{
const tcu::Vec4 generatedElementVertex = feedbackResult[readNdx];
const tcu::Vec4 equalThreshold(1.0e-6f);
if (tcu::boolAny(tcu::greaterThan(tcu::abs(primitiveVertex - generatedElementVertex), equalThreshold)))
{
if (numErrors++ < errorFloodThreshold)
{
m_testCtx.getLog()
<< tcu::TestLog::Message << "Element at index " << (readNdx) << " (tessellation invocation "
<< tessellatedPrimitiveNdx << ", geometry primitive " << generatedPrimitiveNdx
<< ", emitted vertex " << primitiveVertexNdx << "):\n"
<< "\tfeedback result was not contant over whole primitive.\n"
<< "\tfirst emitted value: " << primitiveVertex << "\n"
<< "\tcurrent emitted value:" << generatedElementVertex << "\n"
<< tcu::TestLog::EndMessage;
}
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL,
"got multiple different feedback values for a single primitive");
}
readNdx++;
}
}
if (numErrors > errorFloodThreshold)
m_testCtx.getLog() << tcu::TestLog::Message << "Omitted " << (numErrors - errorFloodThreshold) << " error(s)."
<< tcu::TestLog::EndMessage;
}
static bool feedbackResultCompare(const tcu::Vec4 &a, const tcu::Vec4 &b)
{
if (a.x() < b.x())
return true;
if (a.x() > b.x())
return false;
return a.y() < b.y();
}
void FeedbackPrimitiveTypeCase::verifyRenderedImage(const tcu::Surface &image, const std::vector<tcu::Vec4> &tfVertices)
{
std::vector<tcu::Vec4> vertices;
m_testCtx.getLog() << tcu::TestLog::Message << "Comparing result image against feedback results."
<< tcu::TestLog::EndMessage;
// Check only unique vertices
std::unique_copy(tfVertices.begin(), tfVertices.end(), std::back_insert_iterator<std::vector<tcu::Vec4>>(vertices));
std::sort(vertices.begin(), vertices.end(), feedbackResultCompare);
vertices.erase(std::unique(vertices.begin(), vertices.end()), vertices.end());
// Verifying vertices recorded with feedback actually ended up on the result image
for (int ndx = 0; ndx < (int)vertices.size(); ++ndx)
{
// Rasterization (of lines) may deviate by one pixel. In addition to that, allow minimal errors in rasterized position vs. feedback result.
// This minimal error could result in a difference in rounding => allow one additional pixel in deviation
const int rasterDeviation = 2;
const tcu::IVec2 rasterPos((int)deFloatRound((vertices[ndx].x() * 0.5f + 0.5f) * (float)image.getWidth()),
(int)deFloatRound((vertices[ndx].y() * 0.5f + 0.5f) * (float)image.getHeight()));
// Find produced rasterization results
bool found = false;
for (int dy = -rasterDeviation; dy <= rasterDeviation && !found; ++dy)
for (int dx = -rasterDeviation; dx <= rasterDeviation && !found; ++dx)
{
// Raster result could end up outside the viewport
if (rasterPos.x() + dx < 0 || rasterPos.x() + dx >= image.getWidth() || rasterPos.y() + dy < 0 ||
rasterPos.y() + dy >= image.getHeight())
found = true;
else
{
const tcu::RGBA result = image.getPixel(rasterPos.x() + dx, rasterPos.y() + dy);
if (!isBlack(result))
found = true;
}
}
if (!found)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Vertex " << vertices[ndx] << "\n"
<< "\tCould not find rasterization output for vertex.\n"
<< "\tExpected non-black pixels near " << rasterPos << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "invalid result image");
}
}
}
void FeedbackPrimitiveTypeCase::genTransformFeedback(void)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
const int elementsPerPrimitive = getNumGeneratedElementsPerPrimitive();
const int feedbackPrimitives = getNumGeneratedPrimitives();
const int feedbackElements = elementsPerPrimitive * feedbackPrimitives;
const std::vector<tcu::Vec4> initialBuffer(feedbackElements, tcu::Vec4(-1.0f, -1.0f, -1.0f, -1.0f));
gl.genTransformFeedbacks(1, &m_feedbackID);
gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_feedbackID);
GLU_EXPECT_NO_ERROR(gl.getError(), "gen transform feedback");
gl.genBuffers(1, &m_feedbackBuffer);
gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_feedbackBuffer);
gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, sizeof(tcu::Vec4) * initialBuffer.size(), initialBuffer[0].getPtr(),
GL_STATIC_COPY);
GLU_EXPECT_NO_ERROR(gl.getError(), "gen feedback buffer");
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_feedbackBuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "bind feedback buffer");
}
static int getTriangleNumOutputPrimitives(int tessellationLevel)
{
if (tessellationLevel == 1)
return 1;
else if (tessellationLevel == 2)
return 6;
else
return 3 * (2 + 2 * (tessellationLevel - 2)) + getTriangleNumOutputPrimitives(tessellationLevel - 2);
}
static int getTriangleNumOutputPrimitivesPoints(int tessellationLevel)
{
if (tessellationLevel == 0)
return 1;
else if (tessellationLevel == 1)
return 3;
else
return 3 + 3 * (tessellationLevel - 1) + getTriangleNumOutputPrimitivesPoints(tessellationLevel - 2);
}
int FeedbackPrimitiveTypeCase::getNumGeneratedElementsPerPrimitive(void) const
{
if (m_geometryOutputType == GEOMETRY_OUTPUT_TRIANGLES)
return 3;
else if (m_geometryOutputType == GEOMETRY_OUTPUT_LINES)
return 2;
else if (m_geometryOutputType == GEOMETRY_OUTPUT_POINTS)
return 1;
else
{
DE_ASSERT(false);
return -1;
}
}
int FeedbackPrimitiveTypeCase::getNumGeneratedPrimitives(void) const
{
return getNumTessellatedPrimitives() * getGeometryAmplification();
}
int FeedbackPrimitiveTypeCase::getNumTessellatedPrimitives(void) const
{
const int tessellationLevel = 3;
if (m_tessellationPointMode == TESSELLATION_POINTMODE_OFF)
{
if (m_tessellationOutput == TESSELLATION_OUT_TRIANGLES)
return getTriangleNumOutputPrimitives(tessellationLevel);
else if (m_tessellationOutput == TESSELLATION_OUT_QUADS)
return tessellationLevel * tessellationLevel * 2; // tessellated as triangles
else if (m_tessellationOutput == TESSELLATION_OUT_ISOLINES)
return tessellationLevel * tessellationLevel;
}
else if (m_tessellationPointMode == TESSELLATION_POINTMODE_ON)
{
if (m_tessellationOutput == TESSELLATION_OUT_TRIANGLES)
return getTriangleNumOutputPrimitivesPoints(tessellationLevel);
else if (m_tessellationOutput == TESSELLATION_OUT_QUADS)
return (tessellationLevel + 1) * (tessellationLevel + 1);
else if (m_tessellationOutput == TESSELLATION_OUT_ISOLINES)
return tessellationLevel * (tessellationLevel + 1);
}
DE_ASSERT(false);
return -1;
}
int FeedbackPrimitiveTypeCase::getGeometryAmplification(void) const
{
const int outputAmplification = (m_geometryOutputType == GEOMETRY_OUTPUT_LINES) ? (2) : (1);
const int numInputVertices = (m_tessellationPointMode) ? (1) :
(m_tessellationOutput == TESSELLATION_OUT_ISOLINES) ? (2) :
(3);
return outputAmplification * numInputVertices;
}
glw::GLenum FeedbackPrimitiveTypeCase::getOutputPrimitiveGLType(void) const
{
if (m_geometryOutputType == GEOMETRY_OUTPUT_TRIANGLES)
return GL_TRIANGLES;
else if (m_geometryOutputType == GEOMETRY_OUTPUT_LINES)
return GL_LINES;
else if (m_geometryOutputType == GEOMETRY_OUTPUT_POINTS)
return GL_POINTS;
else
{
DE_ASSERT(false);
return -1;
}
}
std::string FeedbackPrimitiveTypeCase::getVertexSource(void) const
{
return specializeShader(s_positionVertexShader, m_context.getRenderContext().getType());
}
std::string FeedbackPrimitiveTypeCase::getFragmentSource(void) const
{
return specializeShader(s_whiteOutputFragmentShader, m_context.getRenderContext().getType());
}
std::string FeedbackPrimitiveTypeCase::getTessellationControlSource(void) const
{
std::ostringstream buf;
buf << "${VERSION_DECL}\n"
"${EXTENSION_TESSELATION_SHADER}"
"layout(vertices = 9) out;\n"
"\n"
"uniform highp float u_innerTessellationLevel;\n"
"uniform highp float u_outerTessellationLevel;\n"
"\n"
"void main (void)\n"
"{\n"
" if (gl_PatchVerticesIn != 4)\n"
" return;\n"
"\n"
" // Convert input 2x2 grid to 3x3 grid\n"
" float xweight = float(gl_InvocationID % 3) / 2.0f;\n"
" float yweight = float(gl_InvocationID / 3) / 2.0f;\n"
"\n"
" vec4 y0 = mix(gl_in[0].gl_Position, gl_in[1].gl_Position, yweight);\n"
" vec4 y1 = mix(gl_in[2].gl_Position, gl_in[3].gl_Position, yweight);\n"
"\n"
" gl_out[gl_InvocationID].gl_Position = mix(y0, y1, xweight);\n"
"\n";
if (m_tessellationOutput == TESSELLATION_OUT_TRIANGLES)
buf << " gl_TessLevelOuter[0] = 3.0;\n"
" gl_TessLevelOuter[1] = 3.0;\n"
" gl_TessLevelOuter[2] = 3.0;\n"
" gl_TessLevelInner[0] = 3.0;\n";
else if (m_tessellationOutput == TESSELLATION_OUT_QUADS)
buf << " gl_TessLevelOuter[0] = 3.0;\n"
" gl_TessLevelOuter[1] = 3.0;\n"
" gl_TessLevelOuter[2] = 3.0;\n"
" gl_TessLevelOuter[3] = 3.0;\n"
" gl_TessLevelInner[0] = 3.0;\n"
" gl_TessLevelInner[1] = 3.0;\n";
else if (m_tessellationOutput == TESSELLATION_OUT_ISOLINES)
buf << " gl_TessLevelOuter[0] = 3.0;\n"
" gl_TessLevelOuter[1] = 3.0;\n";
else
DE_ASSERT(false);
buf << "}\n";
return specializeShader(buf.str(), m_context.getRenderContext().getType());
}
std::string FeedbackPrimitiveTypeCase::getTessellationEvaluationSource(void) const
{
std::ostringstream buf;
buf << "${VERSION_DECL}\n"
"${EXTENSION_TESSELATION_SHADER}"
"layout("
<< ((m_tessellationOutput == TESSELLATION_OUT_TRIANGLES) ? ("triangles") :
(m_tessellationOutput == TESSELLATION_OUT_QUADS) ? ("quads") :
("isolines"))
<< ((m_tessellationPointMode) ? (", point_mode") : (""))
<< ") in;\n"
"\n"
"out highp vec4 v_tessellationCoords;\n"
"\n"
"// note: No need to use precise gl_Position since we do not require gapless geometry\n"
"void main (void)\n"
"{\n"
" if (gl_PatchVerticesIn != 9)\n"
" return;\n"
"\n"
" vec4 patchCentroid = vec4(0.0);\n"
" for (int ndx = 0; ndx < gl_PatchVerticesIn; ++ndx)\n"
" patchCentroid += gl_in[ndx].gl_Position;\n"
" patchCentroid /= patchCentroid.w;\n"
"\n";
if (m_tessellationOutput == TESSELLATION_OUT_TRIANGLES)
buf << " // map barycentric coords to 2d coords\n"
" const vec3 tessDirX = vec3( 0.4, 0.4, 0.0);\n"
" const vec3 tessDirY = vec3( 0.0, -0.4, 0.0);\n"
" const vec3 tessDirZ = vec3(-0.4, 0.4, 0.0);\n"
" gl_Position = patchCentroid + vec4(gl_TessCoord.x * tessDirX + gl_TessCoord.y * tessDirY + "
"gl_TessCoord.z * tessDirZ, 0.0);\n";
else if (m_tessellationOutput == TESSELLATION_OUT_QUADS || m_tessellationOutput == TESSELLATION_OUT_ISOLINES)
buf << " gl_Position = patchCentroid + vec4(gl_TessCoord.x * 0.8 - 0.4, gl_TessCoord.y * 0.8 - 0.4, 0.0, "
"0.0);\n";
else
DE_ASSERT(false);
buf << " v_tessellationCoords = vec4(gl_TessCoord, 0.0);\n"
"}\n";
return specializeShader(buf.str(), m_context.getRenderContext().getType());
}
std::string FeedbackPrimitiveTypeCase::getGeometrySource(void) const
{
const char *const geometryInputPrimitive = (m_tessellationPointMode) ? ("points") :
(m_tessellationOutput == TESSELLATION_OUT_ISOLINES) ? ("lines") :
("triangles");
const char *const geometryOutputPrimitive = (m_geometryOutputType == GEOMETRY_OUTPUT_POINTS) ? ("points") :
(m_geometryOutputType == GEOMETRY_OUTPUT_LINES) ? ("line_strip") :
("triangle_strip");
const int numInputVertices = (m_tessellationPointMode) ? (1) :
(m_tessellationOutput == TESSELLATION_OUT_ISOLINES) ? (2) :
(3);
const int numSingleVertexOutputVertices = (m_geometryOutputType == GEOMETRY_OUTPUT_POINTS) ? (1) :
(m_geometryOutputType == GEOMETRY_OUTPUT_LINES) ? (4) :
(3);
const int numEmitVertices = numInputVertices * numSingleVertexOutputVertices;
std::ostringstream buf;
buf << "${VERSION_DECL}\n"
"${EXTENSION_GEOMETRY_SHADER}"
"layout("
<< geometryInputPrimitive
<< ") in;\n"
"layout("
<< geometryOutputPrimitive << ", max_vertices=" << numEmitVertices
<< ") out;\n"
"\n"
"in highp vec4 v_tessellationCoords[];\n"
"out highp vec4 tf_someVertexPosition;\n"
"\n"
"void main (void)\n"
"{\n"
" // Emit primitive\n"
" for (int ndx = 0; ndx < gl_in.length(); ++ndx)\n"
" {\n";
switch (m_geometryOutputType)
{
case GEOMETRY_OUTPUT_POINTS:
buf << " // Draw point on vertex\n"
" gl_Position = gl_in[ndx].gl_Position;\n"
" tf_someVertexPosition = gl_in[gl_in.length() - 1].gl_Position;\n"
" EmitVertex();\n";
break;
case GEOMETRY_OUTPUT_LINES:
buf << " // Draw cross on vertex\n"
" gl_Position = gl_in[ndx].gl_Position + vec4(-0.02, -0.02, 0.0, 0.0);\n"
" tf_someVertexPosition = gl_in[gl_in.length() - 1].gl_Position;\n"
" EmitVertex();\n"
" gl_Position = gl_in[ndx].gl_Position + vec4( 0.02, 0.02, 0.0, 0.0);\n"
" tf_someVertexPosition = gl_in[gl_in.length() - 1].gl_Position;\n"
" EmitVertex();\n"
" EndPrimitive();\n"
" gl_Position = gl_in[ndx].gl_Position + vec4( 0.02, -0.02, 0.0, 0.0);\n"
" tf_someVertexPosition = gl_in[gl_in.length() - 1].gl_Position;\n"
" EmitVertex();\n"
" gl_Position = gl_in[ndx].gl_Position + vec4(-0.02, 0.02, 0.0, 0.0);\n"
" tf_someVertexPosition = gl_in[gl_in.length() - 1].gl_Position;\n"
" EmitVertex();\n"
" EndPrimitive();\n";
break;
case GEOMETRY_OUTPUT_TRIANGLES:
buf << " // Draw triangle on vertex\n"
" gl_Position = gl_in[ndx].gl_Position + vec4( 0.00, -0.02, 0.0, 0.0);\n"
" tf_someVertexPosition = gl_in[gl_in.length() - 1].gl_Position;\n"
" EmitVertex();\n"
" gl_Position = gl_in[ndx].gl_Position + vec4( 0.02, 0.00, 0.0, 0.0);\n"
" tf_someVertexPosition = gl_in[gl_in.length() - 1].gl_Position;\n"
" EmitVertex();\n"
" gl_Position = gl_in[ndx].gl_Position + vec4( -0.02, 0.00, 0.0, 0.0);\n"
" tf_someVertexPosition = gl_in[gl_in.length() - 1].gl_Position;\n"
" EmitVertex();\n"
" EndPrimitive();\n";
break;
default:
DE_ASSERT(false);
return "";
}
buf << " }\n"
"}\n";
return specializeShader(buf.str(), m_context.getRenderContext().getType());
}
const char *FeedbackPrimitiveTypeCase::getTessellationOutputDescription(TessellationOutputType tessellationOutput,
TessellationPointMode pointMode)
{
switch (tessellationOutput)
{
case TESSELLATION_OUT_TRIANGLES:
return (pointMode) ? ("points (triangles in point mode)") : ("triangles");
case TESSELLATION_OUT_QUADS:
return (pointMode) ? ("points (quads in point mode)") : ("quads");
case TESSELLATION_OUT_ISOLINES:
return (pointMode) ? ("points (isolines in point mode)") : ("isolines");
default:
DE_ASSERT(false);
return DE_NULL;
}
}
const char *FeedbackPrimitiveTypeCase::getGeometryInputDescription(TessellationOutputType tessellationOutput,
TessellationPointMode pointMode)
{
switch (tessellationOutput)
{
case TESSELLATION_OUT_TRIANGLES:
return (pointMode) ? ("points") : ("triangles");
case TESSELLATION_OUT_QUADS:
return (pointMode) ? ("points") : ("triangles");
case TESSELLATION_OUT_ISOLINES:
return (pointMode) ? ("points") : ("lines");
default:
DE_ASSERT(false);
return DE_NULL;
}
}
const char *FeedbackPrimitiveTypeCase::getGeometryOutputDescription(GeometryOutputType geometryOutput)
{
switch (geometryOutput)
{
case GEOMETRY_OUTPUT_POINTS:
return "points";
case GEOMETRY_OUTPUT_LINES:
return "lines";
case GEOMETRY_OUTPUT_TRIANGLES:
return "triangles";
default:
DE_ASSERT(false);
return DE_NULL;
}
}
class PointSizeCase : public TestCase
{
public:
enum Flags
{
FLAG_VERTEX_SET = 0x01, // !< set gl_PointSize in vertex shader
FLAG_TESSELLATION_CONTROL_SET = 0x02, // !< set gl_PointSize in tessellation evaluation shader
FLAG_TESSELLATION_EVALUATION_SET = 0x04, // !< set gl_PointSize in tessellation control shader
FLAG_TESSELLATION_ADD = 0x08, // !< read and add to gl_PointSize in tessellation shader pair
FLAG_TESSELLATION_DONT_SET = 0x10, // !< don't set gl_PointSize in tessellation shader
FLAG_GEOMETRY_SET = 0x20, // !< set gl_PointSize in geometry shader
FLAG_GEOMETRY_ADD = 0x40, // !< read and add to gl_PointSize in geometry shader
FLAG_GEOMETRY_DONT_SET = 0x80, // !< don't set gl_PointSize in geometry shader
};
PointSizeCase(Context &context, const char *name, const char *description, int flags);
~PointSizeCase(void);
static std::string genTestCaseName(int flags);
static std::string genTestCaseDescription(int flags);
private:
void init(void);
void deinit(void);
IterateResult iterate(void);
void checkExtensions(void) const;
void checkPointSizeRequirements(void) const;
void renderTo(tcu::Surface &dst);
bool verifyImage(const tcu::Surface &src);
int getExpectedPointSize(void) const;
std::string genVertexSource(void) const;
std::string genFragmentSource(void) const;
std::string genTessellationControlSource(void) const;
std::string genTessellationEvaluationSource(void) const;
std::string genGeometrySource(void) const;
enum
{
RENDER_SIZE = 32,
};
const int m_flags;
glu::ShaderProgram *m_program;
};
PointSizeCase::PointSizeCase(Context &context, const char *name, const char *description, int flags)
: TestCase(context, name, description)
, m_flags(flags)
, m_program(DE_NULL)
{
}
PointSizeCase::~PointSizeCase(void)
{
deinit();
}
std::string PointSizeCase::genTestCaseName(int flags)
{
std::ostringstream buf;
// join per-bit descriptions into a single string with '_' separator
if (flags & FLAG_VERTEX_SET)
buf << "vertex_set";
if (flags & FLAG_TESSELLATION_CONTROL_SET)
buf << ((flags & (FLAG_TESSELLATION_CONTROL_SET - 1)) ? ("_") : ("")) << "control_set";
if (flags & FLAG_TESSELLATION_EVALUATION_SET)
buf << ((flags & (FLAG_TESSELLATION_EVALUATION_SET - 1)) ? ("_") : ("")) << "evaluation_set";
if (flags & FLAG_TESSELLATION_ADD)
buf << ((flags & (FLAG_TESSELLATION_ADD - 1)) ? ("_") : ("")) << "control_pass_eval_add";
if (flags & FLAG_TESSELLATION_DONT_SET)
buf << ((flags & (FLAG_TESSELLATION_DONT_SET - 1)) ? ("_") : ("")) << "eval_default";
if (flags & FLAG_GEOMETRY_SET)
buf << ((flags & (FLAG_GEOMETRY_SET - 1)) ? ("_") : ("")) << "geometry_set";
if (flags & FLAG_GEOMETRY_ADD)
buf << ((flags & (FLAG_GEOMETRY_ADD - 1)) ? ("_") : ("")) << "geometry_add";
if (flags & FLAG_GEOMETRY_DONT_SET)
buf << ((flags & (FLAG_GEOMETRY_DONT_SET - 1)) ? ("_") : ("")) << "geometry_default";
return buf.str();
}
std::string PointSizeCase::genTestCaseDescription(int flags)
{
std::ostringstream buf;
// join per-bit descriptions into a single string with ", " separator
if (flags & FLAG_VERTEX_SET)
buf << "set point size in vertex shader";
if (flags & FLAG_TESSELLATION_CONTROL_SET)
buf << ((flags & (FLAG_TESSELLATION_CONTROL_SET - 1)) ? (", ") : (""))
<< "set point size in tessellation control shader";
if (flags & FLAG_TESSELLATION_EVALUATION_SET)
buf << ((flags & (FLAG_TESSELLATION_EVALUATION_SET - 1)) ? (", ") : (""))
<< "set point size in tessellation evaluation shader";
if (flags & FLAG_TESSELLATION_ADD)
buf << ((flags & (FLAG_TESSELLATION_ADD - 1)) ? (", ") : ("")) << "add to point size in tessellation shader";
if (flags & FLAG_TESSELLATION_DONT_SET)
buf << ((flags & (FLAG_TESSELLATION_DONT_SET - 1)) ? (", ") : (""))
<< "don't set point size in tessellation evaluation shader";
if (flags & FLAG_GEOMETRY_SET)
buf << ((flags & (FLAG_GEOMETRY_SET - 1)) ? (", ") : ("")) << "set point size in geometry shader";
if (flags & FLAG_GEOMETRY_ADD)
buf << ((flags & (FLAG_GEOMETRY_ADD - 1)) ? (", ") : ("")) << "add to point size in geometry shader";
if (flags & FLAG_GEOMETRY_DONT_SET)
buf << ((flags & (FLAG_GEOMETRY_DONT_SET - 1)) ? (", ") : ("")) << "don't set point size in geometry shader";
return buf.str();
}
void PointSizeCase::init(void)
{
checkExtensions();
checkPointSizeRequirements();
if (glu::isContextTypeGLCore(m_context.getRenderContext().getType()))
{
m_context.getRenderContext().getFunctions().enable(GL_PROGRAM_POINT_SIZE);
}
// log
if (m_flags & FLAG_VERTEX_SET)
m_testCtx.getLog() << tcu::TestLog::Message << "Setting point size in vertex shader to 2.0."
<< tcu::TestLog::EndMessage;
if (m_flags & FLAG_TESSELLATION_CONTROL_SET)
m_testCtx.getLog()
<< tcu::TestLog::Message
<< "Setting point size in tessellation control shader to 4.0. (And ignoring it in evaluation)."
<< tcu::TestLog::EndMessage;
if (m_flags & FLAG_TESSELLATION_EVALUATION_SET)
m_testCtx.getLog() << tcu::TestLog::Message << "Setting point size in tessellation evaluation shader to 4.0."
<< tcu::TestLog::EndMessage;
if (m_flags & FLAG_TESSELLATION_ADD)
m_testCtx.getLog() << tcu::TestLog::Message
<< "Reading point size in tessellation control shader and adding 2.0 to it in evaluation."
<< tcu::TestLog::EndMessage;
if (m_flags & FLAG_TESSELLATION_DONT_SET)
m_testCtx.getLog()
<< tcu::TestLog::Message
<< "Not setting point size in tessellation evaluation shader (resulting in the default point size)."
<< tcu::TestLog::EndMessage;
if (m_flags & FLAG_GEOMETRY_SET)
m_testCtx.getLog() << tcu::TestLog::Message << "Setting point size in geometry shader to 6.0."
<< tcu::TestLog::EndMessage;
if (m_flags & FLAG_GEOMETRY_ADD)
m_testCtx.getLog() << tcu::TestLog::Message << "Reading point size in geometry shader and adding 2.0."
<< tcu::TestLog::EndMessage;
if (m_flags & FLAG_GEOMETRY_DONT_SET)
m_testCtx.getLog() << tcu::TestLog::Message
<< "Not setting point size in geometry shader (resulting in the default point size)."
<< tcu::TestLog::EndMessage;
// program
{
glu::ProgramSources sources;
sources << glu::VertexSource(genVertexSource()) << glu::FragmentSource(genFragmentSource());
if (m_flags & (FLAG_TESSELLATION_CONTROL_SET | FLAG_TESSELLATION_EVALUATION_SET | FLAG_TESSELLATION_ADD |
FLAG_TESSELLATION_DONT_SET))
sources << glu::TessellationControlSource(genTessellationControlSource())
<< glu::TessellationEvaluationSource(genTessellationEvaluationSource());
if (m_flags & (FLAG_GEOMETRY_SET | FLAG_GEOMETRY_ADD | FLAG_GEOMETRY_DONT_SET))
sources << glu::GeometrySource(genGeometrySource());
m_program = new glu::ShaderProgram(m_context.getRenderContext(), sources);
m_testCtx.getLog() << *m_program;
if (!m_program->isOk())
throw tcu::TestError("failed to build program");
}
}
void PointSizeCase::deinit(void)
{
if (glu::isContextTypeGLCore(m_context.getRenderContext().getType()) &&
m_context.getRenderContext().getFunctions().disable)
{
m_context.getRenderContext().getFunctions().disable(GL_PROGRAM_POINT_SIZE);
}
delete m_program;
m_program = DE_NULL;
}
PointSizeCase::IterateResult PointSizeCase::iterate(void)
{
tcu::Surface resultImage(RENDER_SIZE, RENDER_SIZE);
renderTo(resultImage);
if (verifyImage(resultImage))
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
else
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed");
return STOP;
}
void PointSizeCase::checkExtensions(void) const
{
glu::ContextType contextType = m_context.getRenderContext().getType();
if (glu::contextSupports(contextType, glu::ApiType::core(4, 5)))
return;
std::vector<std::string> requiredExtensions;
const bool supportsES32 = glu::contextSupports(contextType, glu::ApiType::es(3, 2));
bool allOk = true;
if ((m_flags & (FLAG_TESSELLATION_CONTROL_SET | FLAG_TESSELLATION_EVALUATION_SET | FLAG_TESSELLATION_ADD |
FLAG_TESSELLATION_DONT_SET)) &&
!supportsES32)
requiredExtensions.push_back("GL_EXT_tessellation_shader");
if (m_flags & (FLAG_TESSELLATION_CONTROL_SET | FLAG_TESSELLATION_EVALUATION_SET | FLAG_TESSELLATION_ADD))
requiredExtensions.push_back("GL_EXT_tessellation_point_size");
if ((m_flags & (m_flags & (FLAG_GEOMETRY_SET | FLAG_GEOMETRY_ADD | FLAG_GEOMETRY_DONT_SET))) && !supportsES32)
requiredExtensions.push_back("GL_EXT_geometry_shader");
if (m_flags & (m_flags & (FLAG_GEOMETRY_SET | FLAG_GEOMETRY_ADD)))
requiredExtensions.push_back("GL_EXT_geometry_point_size");
for (int ndx = 0; ndx < (int)requiredExtensions.size(); ++ndx)
if (!m_context.getContextInfo().isExtensionSupported(requiredExtensions[ndx].c_str()))
allOk = false;
if (!allOk)
{
std::ostringstream extensionList;
for (int ndx = 0; ndx < (int)requiredExtensions.size(); ++ndx)
{
if (ndx != 0)
extensionList << ", ";
extensionList << requiredExtensions[ndx];
}
throw tcu::NotSupportedError("Test requires {" + extensionList.str() + "} extension(s)");
}
}
void PointSizeCase::checkPointSizeRequirements(void) const
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
float aliasedSizeRange[2] = {0.0f, 0.0f};
const int requiredSize = getExpectedPointSize();
gl.getFloatv(GL_ALIASED_POINT_SIZE_RANGE, aliasedSizeRange);
if (float(requiredSize) > aliasedSizeRange[1])
throw tcu::NotSupportedError("Test requires point size " + de::toString(requiredSize));
}
void PointSizeCase::renderTo(tcu::Surface &dst)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
const bool tessellationActive = (m_flags & (FLAG_TESSELLATION_CONTROL_SET | FLAG_TESSELLATION_EVALUATION_SET |
FLAG_TESSELLATION_ADD | FLAG_TESSELLATION_DONT_SET)) != 0;
const int positionLocation = gl.getAttribLocation(m_program->getProgram(), "a_position");
const glu::VertexArray vao(m_context.getRenderContext());
m_testCtx.getLog() << tcu::TestLog::Message << "Rendering single point." << tcu::TestLog::EndMessage;
if (positionLocation == -1)
throw tcu::TestError("Attribute a_position location was -1");
gl.viewport(0, 0, RENDER_SIZE, RENDER_SIZE);
gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
gl.clear(GL_COLOR_BUFFER_BIT);
GLU_EXPECT_NO_ERROR(gl.getError(), "clear");
gl.bindVertexArray(*vao);
GLU_EXPECT_NO_ERROR(gl.getError(), "bind vao");
gl.useProgram(m_program->getProgram());
GLU_EXPECT_NO_ERROR(gl.getError(), "use program");
gl.vertexAttrib4f(positionLocation, 0.0f, 0.0f, 0.0f, 1.0f);
if (tessellationActive)
{
gl.patchParameteri(GL_PATCH_VERTICES, 1);
GLU_EXPECT_NO_ERROR(gl.getError(), "set patch param");
gl.drawArrays(GL_PATCHES, 0, 1);
GLU_EXPECT_NO_ERROR(gl.getError(), "draw patches");
}
else
{
gl.drawArrays(GL_POINTS, 0, 1);
GLU_EXPECT_NO_ERROR(gl.getError(), "draw points");
}
glu::readPixels(m_context.getRenderContext(), 0, 0, dst.getAccess());
}
bool PointSizeCase::verifyImage(const tcu::Surface &src)
{
const bool MSAATarget = (m_context.getRenderTarget().getNumSamples() > 1);
const int expectedSize = getExpectedPointSize();
m_testCtx.getLog() << tcu::TestLog::Message << "Verifying rendered point size. Expecting " << expectedSize
<< " pixels." << tcu::TestLog::EndMessage;
m_testCtx.getLog() << tcu::TestLog::Image("RenderImage", "Rendered image", src.getAccess());
{
bool resultAreaFound = false;
tcu::IVec4 resultArea;
// Find rasterization output area
for (int y = 0; y < src.getHeight(); ++y)
for (int x = 0; x < src.getWidth(); ++x)
{
if (!isBlack(src.getPixel(x, y)))
{
if (!resultAreaFound)
{
// first fragment
resultArea = tcu::IVec4(x, y, x + 1, y + 1);
resultAreaFound = true;
}
else
{
// union area
resultArea.x() = de::min(resultArea.x(), x);
resultArea.y() = de::min(resultArea.y(), y);
resultArea.z() = de::max(resultArea.z(), x + 1);
resultArea.w() = de::max(resultArea.w(), y + 1);
}
}
}
if (!resultAreaFound)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Verification failed, could not find any point fragments."
<< tcu::TestLog::EndMessage;
return false;
}
// verify area size
if (MSAATarget)
{
const tcu::IVec2 pointSize = resultArea.swizzle(2, 3) - resultArea.swizzle(0, 1);
// MSAA: edges may be a little fuzzy
if (de::abs(pointSize.x() - pointSize.y()) > 1)
{
m_testCtx.getLog() << tcu::TestLog::Message
<< "ERROR! Rasterized point is not a square. Detected point size was " << pointSize
<< tcu::TestLog::EndMessage;
return false;
}
// MSAA may produce larger areas, allow one pixel larger
if (expectedSize != de::max(pointSize.x(), pointSize.y()) &&
(expectedSize + 1) != de::max(pointSize.x(), pointSize.y()))
{
m_testCtx.getLog() << tcu::TestLog::Message << "ERROR! Point size invalid, expected " << expectedSize
<< ", got " << de::max(pointSize.x(), pointSize.y()) << tcu::TestLog::EndMessage;
return false;
}
}
else
{
const tcu::IVec2 pointSize = resultArea.swizzle(2, 3) - resultArea.swizzle(0, 1);
if (pointSize.x() != pointSize.y())
{
m_testCtx.getLog() << tcu::TestLog::Message
<< "ERROR! Rasterized point is not a square. Point size was " << pointSize
<< tcu::TestLog::EndMessage;
return false;
}
if (pointSize.x() != expectedSize)
{
m_testCtx.getLog() << tcu::TestLog::Message << "ERROR! Point size invalid, expected " << expectedSize
<< ", got " << pointSize.x() << tcu::TestLog::EndMessage;
return false;
}
}
}
return true;
}
int PointSizeCase::getExpectedPointSize(void) const
{
int addition = 0;
// geometry
if (m_flags & FLAG_GEOMETRY_DONT_SET)
return 1;
else if (m_flags & FLAG_GEOMETRY_SET)
return 6;
else if (m_flags & FLAG_GEOMETRY_ADD)
addition += 2;
// tessellation
if (m_flags & FLAG_TESSELLATION_EVALUATION_SET)
return 4 + addition;
else if (m_flags & FLAG_TESSELLATION_ADD)
addition += 2;
else if (m_flags & (FLAG_TESSELLATION_CONTROL_SET | FLAG_TESSELLATION_DONT_SET))
{
DE_ASSERT((m_flags & FLAG_GEOMETRY_ADD) == 0); // reading pointSize undefined
return 1;
}
// vertex
if (m_flags & FLAG_VERTEX_SET)
return 2 + addition;
// undefined
DE_ASSERT(false);
return -1;
}
std::string PointSizeCase::genVertexSource(void) const
{
std::ostringstream buf;
buf << "${VERSION_DECL}\n"
<< "in highp vec4 a_position;\n"
<< "void main ()\n"
<< "{\n"
<< " gl_Position = a_position;\n";
if (m_flags & FLAG_VERTEX_SET)
buf << " gl_PointSize = 2.0;\n";
buf << "}\n";
return specializeShader(buf.str(), m_context.getRenderContext().getType());
}
std::string PointSizeCase::genFragmentSource(void) const
{
return specializeShader(s_whiteOutputFragmentShader, m_context.getRenderContext().getType());
}
std::string PointSizeCase::genTessellationControlSource(void) const
{
std::ostringstream buf;
buf << "${VERSION_DECL}\n"
<< "${EXTENSION_TESSELATION_SHADER}"
<< ((m_flags & FLAG_TESSELLATION_DONT_SET) ? ("") : ("${EXTENSION_TESSELATION_POINT_SIZE}"))
<< "layout(vertices = 1) out;\n"
<< "void main ()\n"
<< "{\n"
<< " gl_TessLevelOuter[0] = 3.0;\n"
<< " gl_TessLevelOuter[1] = 3.0;\n"
<< " gl_TessLevelOuter[2] = 3.0;\n"
<< " gl_TessLevelInner[0] = 3.0;\n"
<< " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n";
if (m_flags & FLAG_TESSELLATION_ADD)
buf << " // pass as is to eval\n"
<< " gl_out[gl_InvocationID].gl_PointSize = gl_in[gl_InvocationID].gl_PointSize;\n";
else if (m_flags & FLAG_TESSELLATION_CONTROL_SET)
buf << " // thrown away\n"
<< " gl_out[gl_InvocationID].gl_PointSize = 4.0;\n";
buf << "}\n";
return specializeShader(buf.str(), m_context.getRenderContext().getType());
}
std::string PointSizeCase::genTessellationEvaluationSource(void) const
{
std::ostringstream buf;
buf << "${VERSION_DECL}\n"
<< "${EXTENSION_TESSELATION_SHADER}"
<< ((m_flags & FLAG_TESSELLATION_DONT_SET) ? ("") : ("${EXTENSION_TESSELATION_POINT_SIZE}"))
<< "layout(triangles, point_mode) in;\n"
<< "void main ()\n"
<< "{\n"
<< " // hide all but one vertex\n"
<< " if (gl_TessCoord.x < 0.99)\n"
<< " gl_Position = vec4(-2.0, 0.0, 0.0, 1.0);\n"
<< " else\n"
<< " gl_Position = gl_in[0].gl_Position;\n";
if (m_flags & FLAG_TESSELLATION_ADD)
buf << "\n"
<< " // add to point size\n"
<< " gl_PointSize = gl_in[0].gl_PointSize + 2.0;\n";
else if (m_flags & FLAG_TESSELLATION_EVALUATION_SET)
buf << "\n"
<< " // set point size\n"
<< " gl_PointSize = 4.0;\n";
buf << "}\n";
return specializeShader(buf.str(), m_context.getRenderContext().getType());
}
std::string PointSizeCase::genGeometrySource(void) const
{
std::ostringstream buf;
buf << "${VERSION_DECL}\n"
<< "${EXTENSION_GEOMETRY_SHADER}"
<< ((m_flags & FLAG_GEOMETRY_DONT_SET) ? ("") : ("${EXTENSION_GEOMETRY_POINT_SIZE}")) << "layout (points) in;\n"
<< "layout (points, max_vertices=1) out;\n"
<< "\n"
<< "void main ()\n"
<< "{\n";
if (m_flags & FLAG_GEOMETRY_SET)
buf << " gl_Position = gl_in[0].gl_Position;\n"
<< " gl_PointSize = 6.0;\n";
else if (m_flags & FLAG_GEOMETRY_ADD)
buf << " gl_Position = gl_in[0].gl_Position;\n"
<< " gl_PointSize = gl_in[0].gl_PointSize + 2.0;\n";
else if (m_flags & FLAG_GEOMETRY_DONT_SET)
buf << " gl_Position = gl_in[0].gl_Position;\n";
buf << " EmitVertex();\n"
<< "}\n";
return specializeShader(buf.str(), m_context.getRenderContext().getType());
}
class AllowedRenderFailureException : public std::runtime_error
{
public:
AllowedRenderFailureException(const char *message) : std::runtime_error(message)
{
}
};
class GridRenderCase : public TestCase
{
public:
enum Flags
{
FLAG_TESSELLATION_MAX_SPEC = 0x0001,
FLAG_TESSELLATION_MAX_IMPLEMENTATION = 0x0002,
FLAG_GEOMETRY_MAX_SPEC = 0x0004,
FLAG_GEOMETRY_MAX_IMPLEMENTATION = 0x0008,
FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC = 0x0010,
FLAG_GEOMETRY_INVOCATIONS_MAX_IMPLEMENTATION = 0x0020,
FLAG_GEOMETRY_SCATTER_INSTANCES = 0x0040,
FLAG_GEOMETRY_SCATTER_PRIMITIVES = 0x0080,
FLAG_GEOMETRY_SEPARATE_PRIMITIVES =
0x0100, //!< if set, geometry shader outputs separate grid cells and not continuous slices
FLAG_GEOMETRY_SCATTER_LAYERS = 0x0200,
FLAG_ALLOW_OUT_OF_MEMORY = 0x0400, //!< allow draw command to set GL_OUT_OF_MEMORY
};
GridRenderCase(Context &context, const char *name, const char *description, int flags);
~GridRenderCase(void);
private:
void init(void);
void deinit(void);
IterateResult iterate(void);
void renderTo(std::vector<tcu::Surface> &dst);
bool verifyResultLayer(int layerNdx, const tcu::Surface &dst);
std::string getVertexSource(void);
std::string getFragmentSource(void);
std::string getTessellationControlSource(int tessLevel);
std::string getTessellationEvaluationSource(int tessLevel);
std::string getGeometryShaderSource(int numPrimitives, int numInstances, int tessLevel);
enum
{
RENDER_SIZE = 256
};
const int m_flags;
glu::ShaderProgram *m_program;
uint32_t m_texture;
int m_numLayers;
};
GridRenderCase::GridRenderCase(Context &context, const char *name, const char *description, int flags)
: TestCase(context, name, description)
, m_flags(flags)
, m_program(DE_NULL)
, m_texture(0)
, m_numLayers(1)
{
DE_ASSERT(((m_flags & FLAG_TESSELLATION_MAX_SPEC) == 0) || ((m_flags & FLAG_TESSELLATION_MAX_IMPLEMENTATION) == 0));
DE_ASSERT(((m_flags & FLAG_GEOMETRY_MAX_SPEC) == 0) || ((m_flags & FLAG_GEOMETRY_MAX_IMPLEMENTATION) == 0));
DE_ASSERT(((m_flags & FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC) == 0) ||
((m_flags & FLAG_GEOMETRY_INVOCATIONS_MAX_IMPLEMENTATION) == 0));
DE_ASSERT(((m_flags & (FLAG_GEOMETRY_SCATTER_PRIMITIVES | FLAG_GEOMETRY_SCATTER_LAYERS)) != 0) ==
((m_flags & FLAG_GEOMETRY_SEPARATE_PRIMITIVES) != 0));
}
GridRenderCase::~GridRenderCase(void)
{
deinit();
}
void GridRenderCase::init(void)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
glu::ContextType contextType = m_context.getRenderContext().getType();
const bool supportsES32orGL45 = glu::contextSupports(contextType, glu::ApiType::es(3, 2)) ||
glu::contextSupports(contextType, glu::ApiType::core(4, 5));
// Requirements
if (!supportsES32orGL45 && (!m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader") ||
!m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")))
throw tcu::NotSupportedError("Test requires GL_EXT_tessellation_shader and GL_EXT_geometry_shader extensions");
if ((m_flags & FLAG_GEOMETRY_SCATTER_LAYERS) == 0)
{
if (m_context.getRenderTarget().getWidth() < RENDER_SIZE ||
m_context.getRenderTarget().getHeight() < RENDER_SIZE)
throw tcu::NotSupportedError("Test requires " + de::toString<int>(RENDER_SIZE) + "x" +
de::toString<int>(RENDER_SIZE) + " or larger render target.");
}
// Log
m_testCtx.getLog() << tcu::TestLog::Message
<< "Testing tessellation and geometry shaders that output a large number of primitives.\n"
<< getDescription() << tcu::TestLog::EndMessage;
// Render target
if (m_flags & FLAG_GEOMETRY_SCATTER_LAYERS)
{
// set limits
m_numLayers = 8;
m_testCtx.getLog() << tcu::TestLog::Message << "Rendering to 2d texture array, numLayers = " << m_numLayers
<< tcu::TestLog::EndMessage;
gl.genTextures(1, &m_texture);
gl.bindTexture(GL_TEXTURE_2D_ARRAY, m_texture);
gl.texStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, RENDER_SIZE, RENDER_SIZE, m_numLayers);
gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
GLU_EXPECT_NO_ERROR(gl.getError(), "gen texture");
}
// Gen program
{
glu::ProgramSources sources;
int tessGenLevel = -1;
sources << glu::VertexSource(getVertexSource()) << glu::FragmentSource(getFragmentSource());
// Tessellation limits
{
if (m_flags & FLAG_TESSELLATION_MAX_IMPLEMENTATION)
{
gl.getIntegerv(GL_MAX_TESS_GEN_LEVEL, &tessGenLevel);
GLU_EXPECT_NO_ERROR(gl.getError(), "query tessellation limits");
}
else if (m_flags & FLAG_TESSELLATION_MAX_SPEC)
{
tessGenLevel = 64;
}
else
{
tessGenLevel = 5;
}
m_testCtx.getLog() << tcu::TestLog::Message << "Tessellation level: " << tessGenLevel << ", mode = quad.\n"
<< "\tEach input patch produces " << (tessGenLevel * tessGenLevel) << " ("
<< (tessGenLevel * tessGenLevel * 2) << " triangles)\n"
<< tcu::TestLog::EndMessage;
sources << glu::TessellationControlSource(getTessellationControlSource(tessGenLevel))
<< glu::TessellationEvaluationSource(getTessellationEvaluationSource(tessGenLevel));
}
// Geometry limits
{
int geometryOutputComponents = -1;
int geometryOutputVertices = -1;
int geometryTotalOutputComponents = -1;
int geometryShaderInvocations = -1;
bool logGeometryLimits = false;
bool logInvocationLimits = false;
if (m_flags & FLAG_GEOMETRY_MAX_IMPLEMENTATION)
{
m_testCtx.getLog() << tcu::TestLog::Message
<< "Using implementation maximum geometry shader output limits."
<< tcu::TestLog::EndMessage;
gl.getIntegerv(GL_MAX_GEOMETRY_OUTPUT_COMPONENTS, &geometryOutputComponents);
gl.getIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES, &geometryOutputVertices);
gl.getIntegerv(GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS, &geometryTotalOutputComponents);
GLU_EXPECT_NO_ERROR(gl.getError(), "query geometry limits");
logGeometryLimits = true;
}
else if (m_flags & FLAG_GEOMETRY_MAX_SPEC)
{
m_testCtx.getLog() << tcu::TestLog::Message
<< "Using geometry shader extension minimum maximum output limits."
<< tcu::TestLog::EndMessage;
geometryOutputComponents = 128;
geometryOutputVertices = 256;
geometryTotalOutputComponents = 1024;
logGeometryLimits = true;
}
else
{
geometryOutputComponents = 128;
geometryOutputVertices = 16;
geometryTotalOutputComponents = 1024;
}
if (m_flags & FLAG_GEOMETRY_INVOCATIONS_MAX_IMPLEMENTATION)
{
gl.getIntegerv(GL_MAX_GEOMETRY_SHADER_INVOCATIONS, &geometryShaderInvocations);
GLU_EXPECT_NO_ERROR(gl.getError(), "query geometry invocation limits");
logInvocationLimits = true;
}
else if (m_flags & FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC)
{
geometryShaderInvocations = 32;
logInvocationLimits = true;
}
else
{
geometryShaderInvocations = 4;
}
if (logGeometryLimits || logInvocationLimits)
{
tcu::MessageBuilder msg(&m_testCtx.getLog());
msg << "Geometry shader, targeting following limits:\n";
if (logGeometryLimits)
msg << "\tGL_MAX_GEOMETRY_OUTPUT_COMPONENTS = " << geometryOutputComponents << "\n"
<< "\tGL_MAX_GEOMETRY_OUTPUT_VERTICES = " << geometryOutputVertices << "\n"
<< "\tGL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = " << geometryTotalOutputComponents << "\n";
if (logInvocationLimits)
msg << "\tGL_MAX_GEOMETRY_SHADER_INVOCATIONS = " << geometryShaderInvocations;
msg << tcu::TestLog::EndMessage;
}
{
const bool separatePrimitives = (m_flags & FLAG_GEOMETRY_SEPARATE_PRIMITIVES) != 0;
const int numComponentsPerVertex = 8; // vec4 pos, vec4 color
int numVerticesPerInvocation;
int numPrimitivesPerInvocation;
int geometryVerticesPerPrimitive;
int geometryPrimitivesOutPerPrimitive;
if (separatePrimitives)
{
const int numComponentLimit = geometryTotalOutputComponents / (4 * numComponentsPerVertex);
const int numOutputLimit = geometryOutputVertices / 4;
numPrimitivesPerInvocation = de::min(numComponentLimit, numOutputLimit);
numVerticesPerInvocation = numPrimitivesPerInvocation * 4;
}
else
{
// If FLAG_GEOMETRY_SEPARATE_PRIMITIVES is not set, geometry shader fills a rectangle area in slices.
// Each slice is a triangle strip and is generated by a single shader invocation.
// One slice with 4 segment ends (nodes) and 3 segments:
// .__.__.__.
// |\ |\ |\ |
// |_\|_\|_\|
const int numSliceNodesComponentLimit =
geometryTotalOutputComponents / (2 * numComponentsPerVertex); // each node 2 vertices
const int numSliceNodesOutputLimit = geometryOutputVertices / 2; // each node 2 vertices
const int numSliceNodes = de::min(numSliceNodesComponentLimit, numSliceNodesOutputLimit);
numVerticesPerInvocation = numSliceNodes * 2;
numPrimitivesPerInvocation = (numSliceNodes - 1) * 2;
}
geometryVerticesPerPrimitive = numVerticesPerInvocation * geometryShaderInvocations;
geometryPrimitivesOutPerPrimitive = numPrimitivesPerInvocation * geometryShaderInvocations;
m_testCtx.getLog() << tcu::TestLog::Message << "Geometry shader:\n"
<< "\tTotal output vertex count per invocation: " << (numVerticesPerInvocation)
<< "\n"
<< "\tTotal output primitive count per invocation: " << (numPrimitivesPerInvocation)
<< "\n"
<< "\tNumber of invocations per primitive: " << geometryShaderInvocations << "\n"
<< "\tTotal output vertex count per input primitive: "
<< (geometryVerticesPerPrimitive) << "\n"
<< "\tTotal output primitive count per input primitive: "
<< (geometryPrimitivesOutPerPrimitive) << "\n"
<< tcu::TestLog::EndMessage;
sources << glu::GeometrySource(
getGeometryShaderSource(numPrimitivesPerInvocation, geometryShaderInvocations, tessGenLevel));
m_testCtx.getLog() << tcu::TestLog::Message << "Program:\n"
<< "\tTotal program output vertices count per input patch: "
<< (tessGenLevel * tessGenLevel * 2 * geometryVerticesPerPrimitive) << "\n"
<< "\tTotal program output primitive count per input patch: "
<< (tessGenLevel * tessGenLevel * 2 * geometryPrimitivesOutPerPrimitive) << "\n"
<< tcu::TestLog::EndMessage;
}
}
m_program = new glu::ShaderProgram(m_context.getRenderContext(), sources);
m_testCtx.getLog() << *m_program;
if (!m_program->isOk())
throw tcu::TestError("failed to build program");
}
}
void GridRenderCase::deinit(void)
{
delete m_program;
m_program = DE_NULL;
if (m_texture)
{
m_context.getRenderContext().getFunctions().deleteTextures(1, &m_texture);
m_texture = 0;
}
}
GridRenderCase::IterateResult GridRenderCase::iterate(void)
{
std::vector<tcu::Surface> renderedLayers(m_numLayers);
bool allLayersOk = true;
for (int ndx = 0; ndx < m_numLayers; ++ndx)
renderedLayers[ndx].setSize(RENDER_SIZE, RENDER_SIZE);
m_testCtx.getLog() << tcu::TestLog::Message
<< "Rendering single point at the origin. Expecting yellow and green colored grid-like image. "
"(High-frequency grid may appear unicolored)."
<< tcu::TestLog::EndMessage;
try
{
renderTo(renderedLayers);
}
catch (const AllowedRenderFailureException &ex)
{
// Got accepted failure
m_testCtx.getLog() << tcu::TestLog::Message << "Could not render, reason: " << ex.what() << "\n"
<< "Failure is allowed." << tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return STOP;
}
for (int ndx = 0; ndx < m_numLayers; ++ndx)
allLayersOk &= verifyResultLayer(ndx, renderedLayers[ndx]);
if (allLayersOk)
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
else
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed");
return STOP;
}
void GridRenderCase::renderTo(std::vector<tcu::Surface> &dst)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
const int positionLocation = gl.getAttribLocation(m_program->getProgram(), "a_position");
const glu::VertexArray vao(m_context.getRenderContext());
de::MovePtr<glu::Framebuffer> fbo;
if (positionLocation == -1)
throw tcu::TestError("Attribute a_position location was -1");
gl.viewport(0, 0, dst.front().getWidth(), dst.front().getHeight());
gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
GLU_EXPECT_NO_ERROR(gl.getError(), "viewport");
gl.bindVertexArray(*vao);
GLU_EXPECT_NO_ERROR(gl.getError(), "bind vao");
gl.useProgram(m_program->getProgram());
GLU_EXPECT_NO_ERROR(gl.getError(), "use program");
gl.patchParameteri(GL_PATCH_VERTICES, 1);
GLU_EXPECT_NO_ERROR(gl.getError(), "set patch param");
gl.vertexAttrib4f(positionLocation, 0.0f, 0.0f, 0.0f, 1.0f);
if (m_flags & FLAG_GEOMETRY_SCATTER_LAYERS)
{
// clear texture contents
{
glu::Framebuffer clearFbo(m_context.getRenderContext());
gl.bindFramebuffer(GL_FRAMEBUFFER, *clearFbo);
for (int layerNdx = 0; layerNdx < m_numLayers; ++layerNdx)
{
gl.framebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_texture, 0, layerNdx);
gl.clear(GL_COLOR_BUFFER_BIT);
}
GLU_EXPECT_NO_ERROR(gl.getError(), "clear tex contents");
}
// create and bind layered fbo
fbo = de::MovePtr<glu::Framebuffer>(new glu::Framebuffer(m_context.getRenderContext()));
gl.bindFramebuffer(GL_FRAMEBUFFER, **fbo);
gl.framebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_texture, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "gen fbo");
}
else
{
// clear viewport
gl.clear(GL_COLOR_BUFFER_BIT);
}
// draw
{
glw::GLenum glerror;
gl.drawArrays(GL_PATCHES, 0, 1);
glerror = gl.getError();
if (glerror == GL_OUT_OF_MEMORY && (m_flags & FLAG_ALLOW_OUT_OF_MEMORY))
throw AllowedRenderFailureException("got GL_OUT_OF_MEMORY while drawing");
GLU_EXPECT_NO_ERROR(glerror, "draw patches");
}
// Read layers
if (m_flags & FLAG_GEOMETRY_SCATTER_LAYERS)
{
glu::Framebuffer readFbo(m_context.getRenderContext());
gl.bindFramebuffer(GL_FRAMEBUFFER, *readFbo);
for (int layerNdx = 0; layerNdx < m_numLayers; ++layerNdx)
{
gl.framebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_texture, 0, layerNdx);
glu::readPixels(m_context.getRenderContext(), 0, 0, dst[layerNdx].getAccess());
GLU_EXPECT_NO_ERROR(gl.getError(), "read pixels");
}
}
else
{
glu::readPixels(m_context.getRenderContext(), 0, 0, dst.front().getAccess());
GLU_EXPECT_NO_ERROR(gl.getError(), "read pixels");
}
}
bool GridRenderCase::verifyResultLayer(int layerNdx, const tcu::Surface &image)
{
tcu::Surface errorMask(image.getWidth(), image.getHeight());
bool foundError = false;
tcu::clear(errorMask.getAccess(), tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f));
m_testCtx.getLog() << tcu::TestLog::Message << "Verifying output layer " << layerNdx << tcu::TestLog::EndMessage;
for (int y = 0; y < image.getHeight(); ++y)
for (int x = 0; x < image.getWidth(); ++x)
{
const int threshold = 8;
const tcu::RGBA color = image.getPixel(x, y);
// Color must be a linear combination of green and yellow
if (color.getGreen() < 255 - threshold || color.getBlue() > threshold)
{
errorMask.setPixel(x, y, tcu::RGBA::red());
foundError = true;
}
}
if (!foundError)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Image valid." << tcu::TestLog::EndMessage
<< tcu::TestLog::ImageSet("ImageVerification", "Image verification")
<< tcu::TestLog::Image("Result", "Rendered result", image.getAccess())
<< tcu::TestLog::EndImageSet;
return true;
}
else
{
m_testCtx.getLog() << tcu::TestLog::Message << "Image verification failed, found invalid pixels."
<< tcu::TestLog::EndMessage
<< tcu::TestLog::ImageSet("ImageVerification", "Image verification")
<< tcu::TestLog::Image("Result", "Rendered result", image.getAccess())
<< tcu::TestLog::Image("ErrorMask", "Error mask", errorMask.getAccess())
<< tcu::TestLog::EndImageSet;
return false;
}
}
std::string GridRenderCase::getVertexSource(void)
{
return specializeShader(s_positionVertexShader, m_context.getRenderContext().getType());
}
std::string GridRenderCase::getFragmentSource(void)
{
const char *source = "${VERSION_DECL}\n"
"flat in mediump vec4 v_color;\n"
"layout(location = 0) out mediump vec4 fragColor;\n"
"void main (void)\n"
"{\n"
" fragColor = v_color;\n"
"}\n";
return specializeShader(source, m_context.getRenderContext().getType());
}
std::string GridRenderCase::getTessellationControlSource(int tessLevel)
{
std::ostringstream buf;
buf << "${VERSION_DECL}\n"
"${EXTENSION_TESSELATION_SHADER}"
"layout(vertices=1) out;\n"
"\n"
"void main()\n"
"{\n"
" gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
" gl_TessLevelOuter[0] = "
<< tessLevel
<< ".0;\n"
" gl_TessLevelOuter[1] = "
<< tessLevel
<< ".0;\n"
" gl_TessLevelOuter[2] = "
<< tessLevel
<< ".0;\n"
" gl_TessLevelOuter[3] = "
<< tessLevel
<< ".0;\n"
" gl_TessLevelInner[0] = "
<< tessLevel
<< ".0;\n"
" gl_TessLevelInner[1] = "
<< tessLevel
<< ".0;\n"
"}\n";
return specializeShader(buf.str(), m_context.getRenderContext().getType());
}
std::string GridRenderCase::getTessellationEvaluationSource(int tessLevel)
{
std::ostringstream buf;
buf << "${VERSION_DECL}\n"
"${EXTENSION_TESSELATION_SHADER}"
"layout(quads) in;\n"
"\n"
"out mediump ivec2 v_tessellationGridPosition;\n"
"\n"
"// note: No need to use precise gl_Position since position does not depend on order\n"
"void main (void)\n"
"{\n";
if (m_flags & (FLAG_GEOMETRY_SCATTER_INSTANCES | FLAG_GEOMETRY_SCATTER_PRIMITIVES | FLAG_GEOMETRY_SCATTER_LAYERS))
buf << " // Cover only a small area in a corner. The area will be expanded in geometry shader to cover "
"whole viewport\n"
" gl_Position = vec4(gl_TessCoord.x * 0.3 - 1.0, gl_TessCoord.y * 0.3 - 1.0, 0.0, 1.0);\n";
else
buf << " // Fill the whole viewport\n"
" gl_Position = vec4(gl_TessCoord.x * 2.0 - 1.0, gl_TessCoord.y * 2.0 - 1.0, 0.0, 1.0);\n";
buf << " // Calculate position in tessellation grid\n"
" v_tessellationGridPosition = ivec2(round(gl_TessCoord.xy * float("
<< tessLevel
<< ")));\n"
"}\n";
return specializeShader(buf.str(), m_context.getRenderContext().getType());
}
std::string GridRenderCase::getGeometryShaderSource(int numPrimitives, int numInstances, int tessLevel)
{
std::ostringstream buf;
buf << "${VERSION_DECL}\n"
"${EXTENSION_GEOMETRY_SHADER}"
"layout(triangles, invocations="
<< numInstances
<< ") in;\n"
"layout(triangle_strip, max_vertices="
<< ((m_flags & FLAG_GEOMETRY_SEPARATE_PRIMITIVES) ? (4 * numPrimitives) : (numPrimitives + 2))
<< ") out;\n"
"\n"
"in mediump ivec2 v_tessellationGridPosition[];\n"
"flat out highp vec4 v_color;\n"
"\n"
"void main ()\n"
"{\n"
" const float equalThreshold = 0.001;\n"
" const float gapOffset = 0.0001; // subdivision performed by the geometry shader might produce gaps. "
"Fill potential gaps by enlarging the output slice a little.\n"
"\n"
" // Input triangle is generated from an axis-aligned rectangle by splitting it in half\n"
" // Original rectangle can be found by finding the bounding AABB of the triangle\n"
" vec4 aabb = vec4(min(gl_in[0].gl_Position.x, min(gl_in[1].gl_Position.x, gl_in[2].gl_Position.x)),\n"
" min(gl_in[0].gl_Position.y, min(gl_in[1].gl_Position.y, gl_in[2].gl_Position.y)),\n"
" max(gl_in[0].gl_Position.x, max(gl_in[1].gl_Position.x, gl_in[2].gl_Position.x)),\n"
" max(gl_in[0].gl_Position.y, max(gl_in[1].gl_Position.y, gl_in[2].gl_Position.y)));\n"
"\n"
" // Location in tessellation grid\n"
" ivec2 gridPosition = ivec2(min(v_tessellationGridPosition[0], min(v_tessellationGridPosition[1], "
"v_tessellationGridPosition[2])));\n"
"\n"
" // Which triangle of the two that split the grid cell\n"
" int numVerticesOnBottomEdge = 0;\n"
" for (int ndx = 0; ndx < 3; ++ndx)\n"
" if (abs(gl_in[ndx].gl_Position.y - aabb.w) < equalThreshold)\n"
" ++numVerticesOnBottomEdge;\n"
" bool isBottomTriangle = numVerticesOnBottomEdge == 2;\n"
"\n";
if (m_flags & FLAG_GEOMETRY_SCATTER_PRIMITIVES)
{
// scatter primitives
buf << " // Draw grid cells\n"
" int inputTriangleNdx = gl_InvocationID * 2 + ((isBottomTriangle) ? (1) : (0));\n"
" for (int ndx = 0; ndx < "
<< numPrimitives
<< "; ++ndx)\n"
" {\n"
" ivec2 dstGridSize = ivec2("
<< tessLevel << " * " << numPrimitives << ", 2 * " << tessLevel << " * " << numInstances
<< ");\n"
" ivec2 dstGridNdx = ivec2("
<< tessLevel << " * ndx + gridPosition.x, " << tessLevel
<< " * inputTriangleNdx + 2 * gridPosition.y + ndx * 127) % dstGridSize;\n"
" vec4 dstArea;\n"
" dstArea.x = float(dstGridNdx.x) / float(dstGridSize.x) * 2.0 - 1.0 - gapOffset;\n"
" dstArea.y = float(dstGridNdx.y) / float(dstGridSize.y) * 2.0 - 1.0 - gapOffset;\n"
" dstArea.z = float(dstGridNdx.x+1) / float(dstGridSize.x) * 2.0 - 1.0 + gapOffset;\n"
" dstArea.w = float(dstGridNdx.y+1) / float(dstGridSize.y) * 2.0 - 1.0 + gapOffset;\n"
"\n"
" vec4 green = vec4(0.0, 1.0, 0.0, 1.0);\n"
" vec4 yellow = vec4(1.0, 1.0, 0.0, 1.0);\n"
" vec4 outputColor = (((dstGridNdx.y + dstGridNdx.x) % 2) == 0) ? (green) : (yellow);\n"
"\n"
" gl_Position = vec4(dstArea.x, dstArea.y, 0.0, 1.0);\n"
" v_color = outputColor;\n"
" EmitVertex();\n"
"\n"
" gl_Position = vec4(dstArea.x, dstArea.w, 0.0, 1.0);\n"
" v_color = outputColor;\n"
" EmitVertex();\n"
"\n"
" gl_Position = vec4(dstArea.z, dstArea.y, 0.0, 1.0);\n"
" v_color = outputColor;\n"
" EmitVertex();\n"
"\n"
" gl_Position = vec4(dstArea.z, dstArea.w, 0.0, 1.0);\n"
" v_color = outputColor;\n"
" EmitVertex();\n"
" EndPrimitive();\n"
" }\n";
}
else if (m_flags & FLAG_GEOMETRY_SCATTER_LAYERS)
{
// Number of subrectangle instances = num layers
DE_ASSERT(m_numLayers == numInstances * 2);
buf << " // Draw grid cells, send each primitive to a separate layer\n"
" int baseLayer = gl_InvocationID * 2 + ((isBottomTriangle) ? (1) : (0));\n"
" for (int ndx = 0; ndx < "
<< numPrimitives
<< "; ++ndx)\n"
" {\n"
" ivec2 dstGridSize = ivec2("
<< tessLevel << " * " << numPrimitives << ", " << tessLevel
<< ");\n"
" ivec2 dstGridNdx = ivec2((gridPosition.x * "
<< numPrimitives
<< " * 7 + ndx)*13, (gridPosition.y * 127 + ndx) * 19) % dstGridSize;\n"
" vec4 dstArea;\n"
" dstArea.x = float(dstGridNdx.x) / float(dstGridSize.x) * 2.0 - 1.0 - gapOffset;\n"
" dstArea.y = float(dstGridNdx.y) / float(dstGridSize.y) * 2.0 - 1.0 - gapOffset;\n"
" dstArea.z = float(dstGridNdx.x+1) / float(dstGridSize.x) * 2.0 - 1.0 + gapOffset;\n"
" dstArea.w = float(dstGridNdx.y+1) / float(dstGridSize.y) * 2.0 - 1.0 + gapOffset;\n"
"\n"
" vec4 green = vec4(0.0, 1.0, 0.0, 1.0);\n"
" vec4 yellow = vec4(1.0, 1.0, 0.0, 1.0);\n"
" vec4 outputColor = (((dstGridNdx.y + dstGridNdx.x) % 2) == 0) ? (green) : (yellow);\n"
"\n"
" gl_Position = vec4(dstArea.x, dstArea.y, 0.0, 1.0);\n"
" v_color = outputColor;\n"
" gl_Layer = ((baseLayer + ndx) * 11) % "
<< m_numLayers
<< ";\n"
" EmitVertex();\n"
"\n"
" gl_Position = vec4(dstArea.x, dstArea.w, 0.0, 1.0);\n"
" v_color = outputColor;\n"
" gl_Layer = ((baseLayer + ndx) * 11) % "
<< m_numLayers
<< ";\n"
" EmitVertex();\n"
"\n"
" gl_Position = vec4(dstArea.z, dstArea.y, 0.0, 1.0);\n"
" v_color = outputColor;\n"
" gl_Layer = ((baseLayer + ndx) * 11) % "
<< m_numLayers
<< ";\n"
" EmitVertex();\n"
"\n"
" gl_Position = vec4(dstArea.z, dstArea.w, 0.0, 1.0);\n"
" v_color = outputColor;\n"
" gl_Layer = ((baseLayer + ndx) * 11) % "
<< m_numLayers
<< ";\n"
" EmitVertex();\n"
" EndPrimitive();\n"
" }\n";
}
else
{
if (m_flags & FLAG_GEOMETRY_SCATTER_INSTANCES)
{
buf << " // Scatter slices\n"
" int inputTriangleNdx = gl_InvocationID * 2 + ((isBottomTriangle) ? (1) : (0));\n"
" ivec2 srcSliceNdx = ivec2(gridPosition.x, gridPosition.y * "
<< (numInstances * 2)
<< " + inputTriangleNdx);\n"
" ivec2 dstSliceNdx = ivec2(7 * srcSliceNdx.x, 127 * srcSliceNdx.y) % ivec2("
<< tessLevel << ", " << tessLevel << " * " << (numInstances * 2)
<< ");\n"
"\n"
" // Draw slice to the dstSlice slot\n"
" vec4 outputSliceArea;\n"
" outputSliceArea.x = float(dstSliceNdx.x) / float("
<< tessLevel
<< ") * 2.0 - 1.0 - gapOffset;\n"
" outputSliceArea.y = float(dstSliceNdx.y) / float("
<< (tessLevel * numInstances * 2)
<< ") * 2.0 - 1.0 - gapOffset;\n"
" outputSliceArea.z = float(dstSliceNdx.x+1) / float("
<< tessLevel
<< ") * 2.0 - 1.0 + gapOffset;\n"
" outputSliceArea.w = float(dstSliceNdx.y+1) / float("
<< (tessLevel * numInstances * 2) << ") * 2.0 - 1.0 + gapOffset;\n";
}
else
{
buf << " // Fill the input area with slices\n"
" // Upper triangle produces slices only to the upper half of the quad and vice-versa\n"
" float triangleOffset = (isBottomTriangle) ? ((aabb.w + aabb.y) / 2.0) : (aabb.y);\n"
" // Each slice is a invocation\n"
" float sliceHeight = (aabb.w - aabb.y) / float(2 * "
<< numInstances
<< ");\n"
" float invocationOffset = float(gl_InvocationID) * sliceHeight;\n"
"\n"
" vec4 outputSliceArea;\n"
" outputSliceArea.x = aabb.x - gapOffset;\n"
" outputSliceArea.y = triangleOffset + invocationOffset - gapOffset;\n"
" outputSliceArea.z = aabb.z + gapOffset;\n"
" outputSliceArea.w = triangleOffset + invocationOffset + sliceHeight + gapOffset;\n";
}
buf << "\n"
" // Draw slice\n"
" for (int ndx = 0; ndx < "
<< ((numPrimitives + 2) / 2)
<< "; ++ndx)\n"
" {\n"
" vec4 green = vec4(0.0, 1.0, 0.0, 1.0);\n"
" vec4 yellow = vec4(1.0, 1.0, 0.0, 1.0);\n"
" vec4 outputColor = (((gl_InvocationID + ndx) % 2) == 0) ? (green) : (yellow);\n"
" float xpos = mix(outputSliceArea.x, outputSliceArea.z, float(ndx) / float("
<< (numPrimitives / 2)
<< "));\n"
"\n"
" gl_Position = vec4(xpos, outputSliceArea.y, 0.0, 1.0);\n"
" v_color = outputColor;\n"
" EmitVertex();\n"
"\n"
" gl_Position = vec4(xpos, outputSliceArea.w, 0.0, 1.0);\n"
" v_color = outputColor;\n"
" EmitVertex();\n"
" }\n";
}
buf << "}\n";
return specializeShader(buf.str(), m_context.getRenderContext().getType());
}
class FeedbackRecordVariableSelectionCase : public TestCase
{
public:
FeedbackRecordVariableSelectionCase(Context &context, const char *name, const char *description);
~FeedbackRecordVariableSelectionCase(void);
private:
void init(void);
void deinit(void);
IterateResult iterate(void);
std::string getVertexSource(void);
std::string getFragmentSource(void);
std::string getTessellationControlSource(void);
std::string getTessellationEvaluationSource(void);
std::string getGeometrySource(void);
glu::ShaderProgram *m_program;
uint32_t m_xfbBuf;
};
FeedbackRecordVariableSelectionCase::FeedbackRecordVariableSelectionCase(Context &context, const char *name,
const char *description)
: TestCase(context, name, description)
, m_program(DE_NULL)
, m_xfbBuf(0)
{
}
FeedbackRecordVariableSelectionCase::~FeedbackRecordVariableSelectionCase(void)
{
deinit();
}
void FeedbackRecordVariableSelectionCase::init(void)
{
const bool supportsES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
const bool supportsCore40 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 0));
if ((!supportsES32 && !supportsCore40) &&
(!m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader") ||
!m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")))
throw tcu::NotSupportedError("Test requires GL_EXT_tessellation_shader and GL_EXT_geometry_shader extensions");
m_testCtx.getLog() << tcu::TestLog::Message
<< "Declaring multiple output variables with the same name in multiple shader stages. Capturing "
"the value of the varying using transform feedback."
<< tcu::TestLog::EndMessage;
// gen feedback buffer fit for 1 triangle (4 components)
{
static const tcu::Vec4 initialData[3] = {
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_testCtx.getLog()
<< tcu::TestLog::Message
<< "Creating buffer for transform feedback. Allocating storage for one triangle. Filling with -1.0"
<< tcu::TestLog::EndMessage;
gl.genBuffers(1, &m_xfbBuf);
gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_xfbBuf);
gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, (int)(sizeof(tcu::Vec4[3])), initialData, GL_DYNAMIC_READ);
GLU_EXPECT_NO_ERROR(gl.getError(), "gen xfb buf");
}
// gen shader
m_program = new glu::ShaderProgram(
m_context.getRenderContext(),
glu::ProgramSources() << glu::VertexSource(getVertexSource()) << glu::FragmentSource(getFragmentSource())
<< glu::TessellationControlSource(getTessellationControlSource())
<< glu::TessellationEvaluationSource(getTessellationEvaluationSource())
<< glu::GeometrySource(getGeometrySource())
<< glu::TransformFeedbackMode(GL_INTERLEAVED_ATTRIBS)
<< glu::TransformFeedbackVarying("tf_feedback"));
m_testCtx.getLog() << *m_program;
if (!m_program->isOk())
throw tcu::TestError("could not build program");
}
void FeedbackRecordVariableSelectionCase::deinit(void)
{
delete m_program;
m_program = DE_NULL;
if (m_xfbBuf)
{
m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_xfbBuf);
m_xfbBuf = 0;
}
}
FeedbackRecordVariableSelectionCase::IterateResult FeedbackRecordVariableSelectionCase::iterate(void)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
const int posLoc = gl.getAttribLocation(m_program->getProgram(), "a_position");
const glu::VertexArray vao(m_context.getRenderContext());
if (posLoc == -1)
throw tcu::TestError("a_position attribute location was -1");
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
m_testCtx.getLog() << tcu::TestLog::Message << "Rendering a patch of size 3." << tcu::TestLog::EndMessage;
// Render and feed back
gl.viewport(0, 0, 1, 1);
gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
gl.clear(GL_COLOR_BUFFER_BIT);
GLU_EXPECT_NO_ERROR(gl.getError(), "clear");
gl.bindVertexArray(*vao);
GLU_EXPECT_NO_ERROR(gl.getError(), "bindVertexArray");
gl.vertexAttrib4f(posLoc, 0.0f, 0.0f, 0.0f, 1.0f);
GLU_EXPECT_NO_ERROR(gl.getError(), "vertexAttrib4f");
gl.useProgram(m_program->getProgram());
GLU_EXPECT_NO_ERROR(gl.getError(), "use program");
gl.patchParameteri(GL_PATCH_VERTICES, 3);
GLU_EXPECT_NO_ERROR(gl.getError(), "set patch param");
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_xfbBuf);
GLU_EXPECT_NO_ERROR(gl.getError(), "bind xfb buf");
gl.beginTransformFeedback(GL_TRIANGLES);
GLU_EXPECT_NO_ERROR(gl.getError(), "beginTransformFeedback");
gl.drawArrays(GL_PATCHES, 0, 3);
GLU_EXPECT_NO_ERROR(gl.getError(), "drawArrays");
gl.endTransformFeedback();
GLU_EXPECT_NO_ERROR(gl.getError(), "beginTransformFeedback");
m_testCtx.getLog() << tcu::TestLog::Message
<< "Verifying the value of tf_feedback using transform feedback, expecting (3.0, 3.0, 3.0, 3.0)."
<< tcu::TestLog::EndMessage;
// Read back result (one triangle)
{
tcu::Vec4 feedbackValues[3];
const void *mapPtr =
gl.mapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, (int)sizeof(feedbackValues), GL_MAP_READ_BIT);
GLU_EXPECT_NO_ERROR(gl.getError(), "mapBufferRange");
if (mapPtr == DE_NULL)
throw tcu::TestError("mapBufferRange returned null");
deMemcpy(feedbackValues, mapPtr, sizeof(feedbackValues));
if (gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER) != GL_TRUE)
throw tcu::TestError("unmapBuffer did not return TRUE");
for (int ndx = 0; ndx < 3; ++ndx)
{
if (!tcu::boolAll(tcu::lessThan(tcu::abs(feedbackValues[ndx] - tcu::Vec4(3.0f)), tcu::Vec4(0.001f))))
{
m_testCtx.getLog() << tcu::TestLog::Message << "Feedback vertex " << ndx
<< ": expected (3.0, 3.0, 3.0, 3.0), got " << feedbackValues[ndx]
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got unexpected feedback results");
}
}
}
return STOP;
}
std::string FeedbackRecordVariableSelectionCase::getVertexSource(void)
{
std::string source = "${VERSION_DECL}\n"
"in highp vec4 a_position;\n"
"out highp vec4 tf_feedback;\n"
"void main()\n"
"{\n"
" gl_Position = a_position;\n"
" tf_feedback = vec4(1.0, 1.0, 1.0, 1.0);\n"
"}\n";
return specializeShader(source, m_context.getRenderContext().getType());
}
std::string FeedbackRecordVariableSelectionCase::getFragmentSource(void)
{
return specializeShader(s_whiteOutputFragmentShader, m_context.getRenderContext().getType());
}
std::string FeedbackRecordVariableSelectionCase::getTessellationControlSource(void)
{
std::string source = "${VERSION_DECL}\n"
"${EXTENSION_TESSELATION_SHADER}"
"layout(vertices=3) out;\n"
"void main()\n"
"{\n"
" gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
" gl_TessLevelOuter[0] = 1.0;\n"
" gl_TessLevelOuter[1] = 1.0;\n"
" gl_TessLevelOuter[2] = 1.0;\n"
" gl_TessLevelInner[0] = 1.0;\n"
"}\n";
return specializeShader(source, m_context.getRenderContext().getType());
}
std::string FeedbackRecordVariableSelectionCase::getTessellationEvaluationSource(void)
{
std::string source = "${VERSION_DECL}\n"
"${EXTENSION_TESSELATION_SHADER}"
"layout(triangles) in;\n"
"out highp vec4 tf_feedback;\n"
"void main()\n"
"{\n"
" gl_Position = gl_in[0].gl_Position * gl_TessCoord.x + gl_in[1].gl_Position * "
"gl_TessCoord.y + gl_in[2].gl_Position * gl_TessCoord.z;\n"
" tf_feedback = vec4(2.0, 2.0, 2.0, 2.0);\n"
"}\n";
return specializeShader(source, m_context.getRenderContext().getType());
}
std::string FeedbackRecordVariableSelectionCase::getGeometrySource(void)
{
std::string source =
"${VERSION_DECL}\n"
"${EXTENSION_GEOMETRY_SHADER}"
"layout (triangles) in;\n"
"layout (triangle_strip, max_vertices=3) out;\n"
"out highp vec4 tf_feedback;\n"
"void main()\n"
"{\n"
" for (int ndx = 0; ndx < 3; ++ndx)\n"
" {\n"
" gl_Position = gl_in[ndx].gl_Position + vec4(float(ndx), float(ndx)*float(ndx), 0.0, 0.0);\n"
" tf_feedback = vec4(3.0, 3.0, 3.0, 3.0);\n"
" EmitVertex();\n"
" }\n"
" EndPrimitive();\n"
"}\n";
return specializeShader(source, m_context.getRenderContext().getType());
}
} // namespace
TessellationGeometryInteractionTests::TessellationGeometryInteractionTests(Context &context, bool isGL45)
: TestCaseGroup(context, "tessellation_geometry_interaction", "Tessellation and geometry shader interaction tests")
, m_isGL45(isGL45)
{
}
TessellationGeometryInteractionTests::~TessellationGeometryInteractionTests(void)
{
}
void TessellationGeometryInteractionTests::init(void)
{
tcu::TestCaseGroup *const renderGroup = new tcu::TestCaseGroup(m_testCtx, "render", "Various render tests");
tcu::TestCaseGroup *const feedbackGroup = new tcu::TestCaseGroup(m_testCtx, "feedback", "Test transform feedback");
tcu::TestCaseGroup *const pointSizeGroup = new tcu::TestCaseGroup(m_testCtx, "point_size", "Test point size");
addChild(renderGroup);
addChild(feedbackGroup);
addChild(pointSizeGroup);
// .render
{
tcu::TestCaseGroup *const passthroughGroup = new tcu::TestCaseGroup(
m_testCtx, "passthrough", "Render various types with either passthrough geometry or tessellation shader");
tcu::TestCaseGroup *const limitGroup =
new tcu::TestCaseGroup(m_testCtx, "limits", "Render with properties near their limits");
tcu::TestCaseGroup *const scatterGroup =
new tcu::TestCaseGroup(m_testCtx, "scatter", "Scatter output primitives");
renderGroup->addChild(passthroughGroup);
renderGroup->addChild(limitGroup);
renderGroup->addChild(scatterGroup);
// .passthrough
{
// tessellate_tris_passthrough_geometry_no_change
// tessellate_quads_passthrough_geometry_no_change
// tessellate_isolines_passthrough_geometry_no_change
passthroughGroup->addChild(new IdentityGeometryShaderCase(
m_context, "tessellate_tris_passthrough_geometry_no_change",
"Passthrough geometry shader has no effect", IdentityGeometryShaderCase::CASE_TRIANGLES));
passthroughGroup->addChild(new IdentityGeometryShaderCase(
m_context, "tessellate_quads_passthrough_geometry_no_change",
"Passthrough geometry shader has no effect", IdentityGeometryShaderCase::CASE_QUADS));
passthroughGroup->addChild(new IdentityGeometryShaderCase(
m_context, "tessellate_isolines_passthrough_geometry_no_change",
"Passthrough geometry shader has no effect", IdentityGeometryShaderCase::CASE_ISOLINES));
// passthrough_tessellation_geometry_shade_triangles_no_change
// passthrough_tessellation_geometry_shade_lines_no_change
passthroughGroup->addChild(new IdentityTessellationShaderCase(
m_context, "passthrough_tessellation_geometry_shade_triangles_no_change",
"Passthrough tessellation shader has no effect", IdentityTessellationShaderCase::CASE_TRIANGLES));
passthroughGroup->addChild(new IdentityTessellationShaderCase(
m_context, "passthrough_tessellation_geometry_shade_lines_no_change",
"Passthrough tessellation shader has no effect", IdentityTessellationShaderCase::CASE_ISOLINES));
}
// .limits
{
static const struct LimitCaseDef
{
const char *name;
const char *desc;
int flags;
} cases[] = {
// Test single limit
{"output_required_max_tessellation", "Minimum maximum tessellation level",
GridRenderCase::FLAG_TESSELLATION_MAX_SPEC},
{"output_implementation_max_tessellation", "Maximum tessellation level supported by the implementation",
GridRenderCase::FLAG_TESSELLATION_MAX_IMPLEMENTATION},
{"output_required_max_geometry", "Output minimum maximum number of vertices the geometry shader",
GridRenderCase::FLAG_GEOMETRY_MAX_SPEC},
{"output_implementation_max_geometry",
"Output maximum number of vertices in the geometry shader supported by the implementation",
GridRenderCase::FLAG_GEOMETRY_MAX_IMPLEMENTATION},
{"output_required_max_invocations", "Minimum maximum number of geometry shader invocations",
GridRenderCase::FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC},
{"output_implementation_max_invocations",
"Maximum number of geometry shader invocations supported by the implementation",
GridRenderCase::FLAG_GEOMETRY_INVOCATIONS_MAX_IMPLEMENTATION},
};
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ++ndx)
limitGroup->addChild(new GridRenderCase(m_context, cases[ndx].name, cases[ndx].desc, cases[ndx].flags));
}
// .scatter
{
scatterGroup->addChild(new GridRenderCase(
m_context, "geometry_scatter_instances",
"Each geometry shader instance outputs its primitives far from other instances of the same execution",
GridRenderCase::FLAG_GEOMETRY_SCATTER_INSTANCES));
scatterGroup->addChild(new GridRenderCase(
m_context, "geometry_scatter_primitives",
"Each geometry shader instance outputs its primitives far from other primitives of the same instance",
GridRenderCase::FLAG_GEOMETRY_SCATTER_PRIMITIVES | GridRenderCase::FLAG_GEOMETRY_SEPARATE_PRIMITIVES));
scatterGroup->addChild(new GridRenderCase(
m_context, "geometry_scatter_layers",
"Each geometry shader instance outputs its primitives to multiple layers and far from other primitives "
"of the same instance",
GridRenderCase::FLAG_GEOMETRY_SCATTER_LAYERS | GridRenderCase::FLAG_GEOMETRY_SEPARATE_PRIMITIVES));
}
}
// .feedback
{
static const struct PrimitiveCaseConfig
{
const char *name;
const char *description;
FeedbackPrimitiveTypeCase::TessellationOutputType tessellationOutput;
FeedbackPrimitiveTypeCase::TessellationPointMode tessellationPointMode;
FeedbackPrimitiveTypeCase::GeometryOutputType geometryOutputType;
} caseConfigs[] = {
// tess output triangles -> geo input triangles, output points
{"tessellation_output_triangles_geometry_output_points",
"Tessellation outputs triangles, geometry outputs points",
FeedbackPrimitiveTypeCase::TESSELLATION_OUT_TRIANGLES,
FeedbackPrimitiveTypeCase::TESSELLATION_POINTMODE_OFF, FeedbackPrimitiveTypeCase::GEOMETRY_OUTPUT_POINTS},
// tess output quads <-> geo input triangles, output points
{"tessellation_output_quads_geometry_output_points", "Tessellation outputs quads, geometry outputs points",
FeedbackPrimitiveTypeCase::TESSELLATION_OUT_QUADS, FeedbackPrimitiveTypeCase::TESSELLATION_POINTMODE_OFF,
FeedbackPrimitiveTypeCase::GEOMETRY_OUTPUT_POINTS},
// tess output isolines <-> geo input lines, output points
{"tessellation_output_isolines_geometry_output_points",
"Tessellation outputs isolines, geometry outputs points",
FeedbackPrimitiveTypeCase::TESSELLATION_OUT_ISOLINES,
FeedbackPrimitiveTypeCase::TESSELLATION_POINTMODE_OFF, FeedbackPrimitiveTypeCase::GEOMETRY_OUTPUT_POINTS},
// tess output triangles, point_mode <-> geo input points, output lines
{"tessellation_output_triangles_point_mode_geometry_output_lines",
"Tessellation outputs triangles in point mode, geometry outputs lines",
FeedbackPrimitiveTypeCase::TESSELLATION_OUT_TRIANGLES,
FeedbackPrimitiveTypeCase::TESSELLATION_POINTMODE_ON, FeedbackPrimitiveTypeCase::GEOMETRY_OUTPUT_LINES},
// tess output quads, point_mode <-> geo input points, output lines
{"tessellation_output_quads_point_mode_geometry_output_lines",
"Tessellation outputs quads in point mode, geometry outputs lines",
FeedbackPrimitiveTypeCase::TESSELLATION_OUT_QUADS, FeedbackPrimitiveTypeCase::TESSELLATION_POINTMODE_ON,
FeedbackPrimitiveTypeCase::GEOMETRY_OUTPUT_LINES},
// tess output isolines, point_mode <-> geo input points, output triangles
{"tessellation_output_isolines_point_mode_geometry_output_triangles",
"Tessellation outputs isolines in point mode, geometry outputs triangles",
FeedbackPrimitiveTypeCase::TESSELLATION_OUT_ISOLINES, FeedbackPrimitiveTypeCase::TESSELLATION_POINTMODE_ON,
FeedbackPrimitiveTypeCase::GEOMETRY_OUTPUT_TRIANGLES},
};
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(caseConfigs); ++ndx)
{
feedbackGroup->addChild(new FeedbackPrimitiveTypeCase(
m_context, caseConfigs[ndx].name, caseConfigs[ndx].description, caseConfigs[ndx].tessellationOutput,
caseConfigs[ndx].tessellationPointMode, caseConfigs[ndx].geometryOutputType));
}
feedbackGroup->addChild(new FeedbackRecordVariableSelectionCase(
m_context, "record_variable_selection",
"Record a variable that has been declared as an output variable in multiple shader stages"));
}
// .point_size
{
static const struct PointSizeCaseConfig
{
const int caseMask;
const bool isSupportedInGL; // is this case supported in OpenGL
} caseConfigs[] = {
{PointSizeCase::FLAG_VERTEX_SET, true},
{PointSizeCase::FLAG_TESSELLATION_EVALUATION_SET, true},
{PointSizeCase::FLAG_GEOMETRY_SET, true},
{PointSizeCase::FLAG_VERTEX_SET | PointSizeCase::FLAG_TESSELLATION_CONTROL_SET, false},
{PointSizeCase::FLAG_VERTEX_SET | PointSizeCase::FLAG_TESSELLATION_EVALUATION_SET, true},
{PointSizeCase::FLAG_VERTEX_SET | PointSizeCase::FLAG_TESSELLATION_DONT_SET, false},
{PointSizeCase::FLAG_VERTEX_SET | PointSizeCase::FLAG_GEOMETRY_SET, true},
{PointSizeCase::FLAG_VERTEX_SET | PointSizeCase::FLAG_TESSELLATION_EVALUATION_SET |
PointSizeCase::FLAG_GEOMETRY_SET,
true},
{PointSizeCase::FLAG_VERTEX_SET | PointSizeCase::FLAG_TESSELLATION_ADD | PointSizeCase::FLAG_GEOMETRY_ADD,
true},
{PointSizeCase::FLAG_VERTEX_SET | PointSizeCase::FLAG_TESSELLATION_EVALUATION_SET |
PointSizeCase::FLAG_GEOMETRY_DONT_SET,
false},
};
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(caseConfigs); ++ndx)
{
if (m_isGL45 && !caseConfigs[ndx].isSupportedInGL)
continue;
const std::string name = PointSizeCase::genTestCaseName(caseConfigs[ndx].caseMask);
const std::string desc = PointSizeCase::genTestCaseDescription(caseConfigs[ndx].caseMask);
pointSizeGroup->addChild(
new PointSizeCase(m_context, name.c_str(), desc.c_str(), caseConfigs[ndx].caseMask));
}
}
}
} // namespace Functional
} // namespace gles31
} // namespace deqp