Google Git
Sign in
fuchsia / third_party / vulkan-cts / refs/heads/main / . / external / openglcts / modules / gl / gl3cTransformFeedbackTests.cpp
blob: ab1c3ae085ee2e2acb49be91f7e3c9bdd83e4519 [file] [log] [blame]
/*-------------------------------------------------------------------------
* OpenGL Conformance Test Suite
* -----------------------------
*
* Copyright (c) 2015-2016 The Khronos Group Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/ /*!
* \file
* \brief
*/ /*-------------------------------------------------------------------*/
/**
*/ /*!
* \file gl3cTransformFeedback.cpp
* \brief Transform Feedback Test Suite Implementation
*/ /*-------------------------------------------------------------------*/
/* Includes. */
#include "gl3cTransformFeedbackTests.hpp"
#include "gluContextInfo.hpp"
#include "gluDefs.hpp"
#include "gluRenderContext.hpp"
#include "gluStrUtil.hpp"
#include "tcuTestLog.hpp"
#include <algorithm>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <sstream>
/* Stringify macro. */
#define _STR(s) STR(s)
#define STR(s) #s
/* Unused attribute / variable MACRO.
Some methods of clesses' heirs do not need all function parameters.
This triggers warnings on GCC platform. This macro will silence them.
*/
#ifdef __GNUC__
#define UNUSED __attribute__((__unused__))
#else
#define UNUSED
#endif
gl3cts::TransformFeedback::Tests::Tests(deqp::Context& context)
: TestCaseGroup(context, "transform_feedback", "Transform Feedback Test Suite")
{
addChild(new TransformFeedback::APIErrors(m_context));
addChild(new TransformFeedback::LinkingErrors(m_context));
addChild(new TransformFeedback::Limits(m_context));
addChild(new TransformFeedback::CaptureVertexInterleaved(m_context, "capture_vertex_interleaved_test",
"Transform Feedback Capture Vertex Interleaved Test"));
addChild(new TransformFeedback::CaptureGeometryInterleaved(m_context, "capture_geometry_interleaved_test",
"Transform Feedback Capture Geometry Interleaved Test"));
addChild(new TransformFeedback::CaptureVertexSeparate(m_context, "capture_vertex_separate_test",
"Transform Feedback Capture Vertex Separate Test"));
addChild(new TransformFeedback::CaptureGeometrySeparate(m_context, "capture_geometry_separate_test",
"Transform Feedback Capture Geometry Separate Test"));
addChild(new TransformFeedback::CheckGetXFBVarying(m_context, "get_xfb_varying",
"Transform Feedback Varying Getters Test"));
addChild(new TransformFeedback::QueryVertexInterleaved(m_context, "query_vertex_interleaved_test",
"Transform Feedback Query Vertex Interleaved Test"));
addChild(new TransformFeedback::QueryGeometryInterleaved(m_context, "query_geometry_interleaved_test",
"Transform Feedback Query Geometry Interleaved Test"));
addChild(new TransformFeedback::QueryVertexSeparate(m_context, "query_vertex_separate_test",
"Transform Feedback Query Vertex Separate Test"));
addChild(new TransformFeedback::QueryGeometrySeparate(m_context, "query_geometry_separate_test",
"Transform Feedback Query Geometry Separate Test"));
addChild(new TransformFeedback::DiscardVertex(m_context, "discard_vertex_test",
"Transform Feedback Discard Vertex Test"));
addChild(new TransformFeedback::DiscardGeometry(m_context, "discard_geometry_test",
"Transform Feedback Discard Geometry Test"));
addChild(new TransformFeedback::DrawXFB(m_context, "draw_xfb_test", "Transform Feedback Draw Test"));
addChild(new TransformFeedback::DrawXFBFeedback(m_context, "draw_xfb_feedbackk_test",
"Transform Feedback Draw Feedback Test"));
addChild(
new TransformFeedback::DrawXFBStream(m_context, "draw_xfb_stream_test", "Transform Feedback Draw Stream Test"));
addChild(new TransformFeedback::CaptureSpecialInterleaved(m_context, "capture_special_interleaved_test",
"Transform Feedback Capture Special Test"));
addChild(new TransformFeedback::DrawXFBInstanced(m_context, "draw_xfb_instanced_test",
"Transform Feedback Draw Instanced Test"));
addChild(new TransformFeedback::DrawXFBStreamInstanced(m_context, "draw_xfb_stream_instanced_test",
"Transform Feedback Draw Stream Instanced Test"));
}
gl3cts::TransformFeedback::Tests::~Tests(void)
{
}
void gl3cts::TransformFeedback::Tests::init(void)
{
}
gl3cts::TransformFeedback::APIErrors::APIErrors(deqp::Context& context)
: deqp::TestCase(context, "api_errors_test", "Transform Feedback API Errors Test")
, m_context(context)
, m_buffer_0(0)
, m_buffer_1(0)
, m_vertex_array_object(0)
, m_transform_feedback_object_0(0)
, m_transform_feedback_object_1(0)
, m_query_object(0)
, m_program_id_with_input_output(0)
, m_program_id_with_output(0)
, m_program_id_without_output(0)
, m_program_id_with_geometry_shader(0)
, m_program_id_with_tessellation_shaders(0)
, m_glBindBufferOffsetEXT(DE_NULL)
, m_glGetIntegerIndexedvEXT(DE_NULL)
, m_glGetBooleanIndexedvEXT(DE_NULL)
{
}
gl3cts::TransformFeedback::APIErrors::~APIErrors(void)
{
}
tcu::TestNode::IterateResult gl3cts::TransformFeedback::APIErrors::iterate(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Initializations. */
bool is_at_least_gl_30 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(3, 0)));
bool is_at_least_gl_33 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(3, 3)));
bool is_at_least_gl_40 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 0)));
bool is_at_least_gl_42 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 2)));
bool is_ext_tf_1 = m_context.getContextInfo().isExtensionSupported("GL_EXT_transform_feedback");
bool is_arb_tf_2 = m_context.getContextInfo().isExtensionSupported("GL_ARB_transform_feedback2");
bool is_arb_tf_3 = m_context.getContextInfo().isExtensionSupported("GL_ARB_transform_feedback3");
bool is_arb_tf_instanced = m_context.getContextInfo().isExtensionSupported("GL_ARB_transform_feedback_instanced");
if (is_ext_tf_1)
{
/* Extension query. */
m_glBindBufferOffsetEXT =
(BindBufferOffsetEXT_ProcAddress)m_context.getRenderContext().getProcAddress("glBindBufferOffsetEXT");
m_glGetIntegerIndexedvEXT =
(GetIntegerIndexedvEXT_ProcAddress)m_context.getRenderContext().getProcAddress("glGetIntegerIndexedvEXT");
m_glGetBooleanIndexedvEXT =
(GetBooleanIndexedvEXT_ProcAddress)m_context.getRenderContext().getProcAddress("glGetBooleanIndexedvEXT");
}
if (is_at_least_gl_40 || is_arb_tf_2)
{
/* Create transform feedback objects. */
gl.genTransformFeedbacks(1, &m_transform_feedback_object_0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTransformFeedbacks call failed.");
}
if (is_at_least_gl_40 || is_arb_tf_3)
{
/* Create query object. */
gl.genQueries(1, &m_query_object);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenQueries call failed.");
}
if (is_at_least_gl_42 || is_arb_tf_instanced)
{
/* Create transform feedback objects. */
gl.genTransformFeedbacks(1, &m_transform_feedback_object_1);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTransformFeedbacks call failed.");
}
/* Default result. */
bool is_ok = true;
bool test_error = false;
/* Entities setup. */
try
{
/* VAO setup. */
gl.genVertexArrays(1, &m_vertex_array_object);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays call failed.");
gl.bindVertexArray(m_vertex_array_object);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray call failed.");
/* Buffer setup. */
gl.genBuffers(1, &m_buffer_0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers call failed.");
gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_buffer_0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 16, NULL, GL_STATIC_DRAW);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData call failed.");
gl.genBuffers(1, &m_buffer_1);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers call failed.");
gl.bindBuffer(GL_ARRAY_BUFFER, m_buffer_1);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
gl.bufferData(GL_ARRAY_BUFFER, m_buffer_1_size, m_buffer_1_data, GL_STATIC_DRAW);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData call failed.");
/* Programs setup. */
m_program_id_with_input_output = gl3cts::TransformFeedback::Utilities::buildProgram(
gl, m_context.getTestContext().getLog(), NULL, NULL, NULL, s_vertex_shader_with_input_output,
s_fragment_shader, &m_varying_name, 1, GL_INTERLEAVED_ATTRIBS);
m_program_id_with_output = gl3cts::TransformFeedback::Utilities::buildProgram(
gl, m_context.getTestContext().getLog(), NULL, NULL, NULL, s_vertex_shader_with_output, s_fragment_shader,
&m_varying_name, 1, GL_INTERLEAVED_ATTRIBS, true);
m_program_id_without_output = gl3cts::TransformFeedback::Utilities::buildProgram(
gl, m_context.getTestContext().getLog(), NULL, NULL, NULL, s_vertex_shader_without_output,
s_fragment_shader, NULL, 0, GL_SEPARATE_ATTRIBS);
is_ok = is_ok && m_program_id_with_input_output && m_program_id_with_output && m_program_id_without_output;
if (is_at_least_gl_33) {
m_program_id_with_geometry_shader = gl3cts::TransformFeedback::Utilities::buildProgram(
gl, m_context.getTestContext().getLog(), m_geometry_shader, NULL, NULL, s_vertex_shader_without_output,
s_fragment_shader, &m_varying_name, 1, GL_INTERLEAVED_ATTRIBS);
is_ok = is_ok && m_program_id_with_geometry_shader;
}
if (is_at_least_gl_40) {
m_program_id_with_tessellation_shaders = gl3cts::TransformFeedback::Utilities::buildProgram(
gl, m_context.getTestContext().getLog(), NULL, m_tessellation_control_shader,
m_tessellation_evaluation_shader, s_vertex_shader_without_output, s_fragment_shader, &m_varying_name, 1,
GL_INTERLEAVED_ATTRIBS);
is_ok = is_ok && m_program_id_with_tessellation_shaders;
}
}
catch (...)
{
is_ok = false;
test_error = true;
}
/* Iterating tests. */
try
{
if (is_at_least_gl_30 || is_ext_tf_1)
{
is_ok = is_ok && testExtension1();
}
if (is_at_least_gl_40 || is_arb_tf_2)
{
is_ok = is_ok && testExtension2();
}
if (is_at_least_gl_40 || is_arb_tf_3)
{
is_ok = is_ok && testExtension3();
}
if (is_at_least_gl_42 || is_arb_tf_instanced)
{
is_ok = is_ok && testInstanced();
}
}
catch (...)
{
is_ok = false;
test_error = true;
}
/* Deinitialization. */
if (m_vertex_array_object)
{
gl.deleteVertexArrays(1, &m_vertex_array_object);
m_vertex_array_object = 0;
}
if (m_buffer_0)
{
gl.deleteBuffers(1, &m_buffer_0); // silently unbinds
m_buffer_0 = 0;
}
if (m_buffer_1)
{
gl.deleteBuffers(1, &m_buffer_1); // silently unbinds
m_buffer_1 = 0;
}
if (m_transform_feedback_object_0)
{
gl.deleteTransformFeedbacks(1, &m_transform_feedback_object_0);
m_transform_feedback_object_0 = 0;
}
if (m_transform_feedback_object_1)
{
gl.deleteTransformFeedbacks(1, &m_transform_feedback_object_1);
m_transform_feedback_object_1 = 0;
}
if (m_query_object)
{
gl.deleteQueries(1, &m_query_object);
m_query_object = 0;
}
if (m_program_id_with_input_output)
{
gl.deleteProgram(m_program_id_with_input_output);
m_program_id_with_input_output = 0;
}
if (m_program_id_with_output)
{
gl.deleteProgram(m_program_id_with_output);
m_program_id_with_output = 0;
}
if (m_program_id_without_output)
{
gl.deleteProgram(m_program_id_without_output);
m_program_id_without_output = 0;
}
if (m_program_id_with_geometry_shader)
{
gl.deleteProgram(m_program_id_with_geometry_shader);
m_program_id_with_geometry_shader = 0;
}
if (m_program_id_with_tessellation_shaders)
{
gl.deleteProgram(m_program_id_with_tessellation_shaders);
m_program_id_with_tessellation_shaders = 0;
}
/* Result's setup. */
if (is_ok)
{
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
}
else
{
if (test_error)
{
m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
}
else
{
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
}
return STOP;
}
bool gl3cts::TransformFeedback::APIErrors::testExtension1(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* INVALID_VALUE is generated by BindBufferRange, BindBufferOffset and
BindBufferBase when <index> is greater or equal to
MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS; */
glw::GLint index_count = 0;
gl.getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &index_count);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv call failed.");
if (index_count == 0)
{
m_context.getTestContext().getLog() << tcu::TestLog::Message << "glGetIntegerv did not returned any value."
<< tcu::TestLog::EndMessage;
throw 0;
}
gl.bindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, index_count, m_buffer_0, 0, 16);
if (GL_INVALID_VALUE != gl.getError())
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "INVALID_VALUE was not generated by BindBufferRange "
"when <index> was greater or equal to "
"MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS."
<< tcu::TestLog::EndMessage;
return false;
}
if (DE_NULL != m_glBindBufferOffsetEXT)
{
m_glBindBufferOffsetEXT(GL_TRANSFORM_FEEDBACK_BUFFER, index_count, m_buffer_0, 0);
if (GL_INVALID_VALUE != gl.getError())
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "INVALID_VALUE was not generated by BindBufferOffset "
"when <index> was greater or equal to "
"MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS."
<< tcu::TestLog::EndMessage;
return false;
}
}
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, index_count, m_buffer_0);
if (GL_INVALID_VALUE != gl.getError())
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "INVALID_VALUE was not generated by "
"BindBufferBase when <index> was greater or equal to "
"MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS."
<< tcu::TestLog::EndMessage;
return false;
}
/* INVALID_VALUE is generated by BindBufferRange when <size> is less or equal to zero; */
gl.bindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, index_count, m_buffer_0, 0, 0);
if (GL_INVALID_VALUE != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "INVALID_VALUE was not generated by BindBufferRange when <size> was less or equal to zero."
<< tcu::TestLog::EndMessage;
return false;
}
/* INVALID_VALUE is generated by BindBufferRange and BindBufferOffset
when <offset> is not word-aligned; */
gl.bindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, index_count, m_buffer_0, 3, 4);
if (GL_INVALID_VALUE != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "INVALID_VALUE was not generated by BindBufferRange when <offset> was not word-aligned."
<< tcu::TestLog::EndMessage;
return false;
}
if (DE_NULL != m_glBindBufferOffsetEXT)
{
m_glBindBufferOffsetEXT(GL_TRANSFORM_FEEDBACK_BUFFER, index_count, m_buffer_0, 3);
if (GL_INVALID_VALUE != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "INVALID_VALUE was not generated by BindBufferOffset when <offset> was not word-aligned."
<< tcu::TestLog::EndMessage;
return false;
}
}
/* INVALID_VALUE is generated by BindBufferRange when <size> is not word-aligned; */
gl.bindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, index_count, m_buffer_0, 0, 3);
if (GL_INVALID_VALUE != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "INVALID_VALUE was not generated by BindBufferRange when <size> was not word-aligned."
<< tcu::TestLog::EndMessage;
return false;
}
/* INVALID_OPERATION is generated by BindBufferRange, BindBufferOffset and
BindBufferBase when <target> is TRANSFORM_FEEDBACK_BUFFER and transform
feedback is active; */
gl.useProgram(m_program_id_with_output);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed.");
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_buffer_0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase call failed.");
gl.beginTransformFeedback(GL_POINTS);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback call failed.");
gl.bindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_buffer_0, 0, 16);
if (GL_INVALID_OPERATION != gl.getError())
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "INVALID_OPERATION was not generated by BindBufferRange "
"when <target> was TRANSFORM_FEEDBACK_BUFFER and transform "
"feedback was active."
<< tcu::TestLog::EndMessage;
gl.endTransformFeedback();
return false;
}
if (DE_NULL != m_glBindBufferOffsetEXT)
{
m_glBindBufferOffsetEXT(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_buffer_0, 0);
if (GL_INVALID_OPERATION != gl.getError())
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "INVALID_OPERATION was not generated by BindBufferOffset "
"when <target> was TRANSFORM_FEEDBACK_BUFFER and transform "
"feedback was active."
<< tcu::TestLog::EndMessage;
gl.endTransformFeedback();
return false;
}
}
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_buffer_0);
if (GL_INVALID_OPERATION != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "INVALID_OPERATION was not generated by "
"BindBufferBase when <target> was TRANSFORM_FEEDBACK_BUFFER and transform "
"feedback was active."
<< tcu::TestLog::EndMessage;
gl.endTransformFeedback();
return false;
}
gl.endTransformFeedback();
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback call failed.");
/* INVALID_OPERATION is generated by UseProgram when transform feedback is
active; */
gl.beginTransformFeedback(GL_POINTS);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback call failed.");
gl.useProgram(0);
if (GL_INVALID_OPERATION != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "INVALID_OPERATION was not generated by UseProgram when transform feedback was active."
<< tcu::TestLog::EndMessage;
gl.endTransformFeedback();
return false;
}
gl.endTransformFeedback();
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback call failed.");
/* INVALID_OPERATION is generated by LinkProgram when <program> is currently
active and transform feedback is active; */
gl.useProgram(m_program_id_with_output);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed.");
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_buffer_0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase call failed.");
gl.beginTransformFeedback(GL_POINTS);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback call failed.");
gl.linkProgram(m_program_id_with_output);
if (GL_INVALID_OPERATION != gl.getError())
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "INVALID_OPERATION was not generated by LinkProgram when <program> was "
"currently active and transform feedback was active."
<< tcu::TestLog::EndMessage;
gl.endTransformFeedback();
return false;
}
gl.endTransformFeedback();
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback call failed.");
/* INVALID_OPERATION is generated by BeginTransformFeedback when transform
feedback is active; */
gl.useProgram(m_program_id_with_output);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed.");
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_buffer_0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase call failed.");
gl.beginTransformFeedback(GL_POINTS);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback call failed.");
gl.beginTransformFeedback(GL_POINTS);
if (GL_INVALID_OPERATION != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "INVALID_OPERATION was not generated by BeginTransformFeedback when transform feedback was active."
<< tcu::TestLog::EndMessage;
gl.endTransformFeedback();
return false;
}
gl.endTransformFeedback();
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback call failed.");
/* INVALID_OPERATION is generated by EndTransformFeedback when transform
feedback is inactive; */
gl.endTransformFeedback();
if (GL_INVALID_OPERATION != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "INVALID_OPERATION was not generated by EndTransformFeedback when transform feedback was inactive."
<< tcu::TestLog::EndMessage;
return false;
}
/* INVALID_OPERATION is generated by draw command when generated primitives
type does not match <primitiveMode>; */
gl.useProgram(m_program_id_with_output);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed.");
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_buffer_0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase call failed.");
gl.beginTransformFeedback(GL_POINTS);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback call failed.");
gl.drawArrays(GL_LINES, 0, 2);
if (GL_INVALID_OPERATION != gl.getError())
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "INVALID_OPERATION was not generated by draw command when generated "
"primitives type does not match <primitiveMode>."
<< tcu::TestLog::EndMessage;
gl.endTransformFeedback();
return false;
}
gl.endTransformFeedback();
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback call failed.");
/* INVALID_OPERATION is generated by BeginTransformFeedback when any binding
point used by XFB does not have buffer bound; */
gl.useProgram(m_program_id_with_output);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed.");
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase call failed.");
gl.beginTransformFeedback(GL_POINTS);
if (GL_INVALID_OPERATION != gl.getError())
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "INVALID_OPERATION was not generated by BeginTransformFeedback when any "
"binding point used by XFB does not have buffer bound."
<< tcu::TestLog::EndMessage;
return false;
}
/* INVALID_OPERATION is generated by BeginTransformFeedback when no program
is active; */
gl.useProgram(0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed.");
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_buffer_0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase call failed.");
gl.beginTransformFeedback(GL_POINTS);
if (GL_INVALID_OPERATION != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "INVALID_OPERATION was not generated by BeginTransformFeedback when no program was active."
<< tcu::TestLog::EndMessage;
gl.endTransformFeedback();
return false;
}
/* INVALID_OPERATION is generated by BeginTransformFeedback when no variable
are specified to be captured in the active program; */
gl.useProgram(m_program_id_without_output);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed.");
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_buffer_0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase call failed.");
gl.beginTransformFeedback(GL_POINTS);
if (GL_INVALID_OPERATION != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "INVALID_OPERATION was not generated by BeginTransformFeedback when no variable "
"are specified to be captured in the active program."
<< tcu::TestLog::EndMessage;
gl.endTransformFeedback();
return false;
}
/* INVALID_VALUE is generated by TransformFeedbackVaryings when <program> is
not id of the program object; */
unsigned short int invalid_name = 1;
while (gl.isProgram(invalid_name) || gl.isShader(invalid_name))
{
++invalid_name;
/* Make sure that this loop ends someday, bad day. */
if (invalid_name == USHRT_MAX)
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "Cannot find unused trnasform feedback object." << tcu::TestLog::EndMessage;
throw 0;
}
}
gl.transformFeedbackVaryings((glw::GLuint)invalid_name, 1, &m_varying_name, GL_INTERLEAVED_ATTRIBS);
if (GL_INVALID_VALUE != gl.getError())
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "INVALID_VALUE was not generated by TransformFeedbackVaryings when "
"<program> was not id of the program object."
<< tcu::TestLog::EndMessage;
return false;
}
/* INVALID_VALUE is generated by TransformFeedbackVaryings when <bufferMode>
is SEPARATE_ATTRIBS and <count> is exceeds limits; */
glw::GLint max_separate_attribs = 0;
gl.getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &max_separate_attribs);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv call failed.");
if (max_separate_attribs == 0)
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "INVALID_VALUE was not generated by TransformFeedbackVaryings when <bufferMode>"
" was SEPARATE_ATTRIBS and <count> was exceeds limits."
<< tcu::TestLog::EndMessage;
throw 0;
}
glw::GLint more_than_max_separate_attribs = max_separate_attribs + 1;
glw::GLchar** attrib = new glw::GLchar*[more_than_max_separate_attribs];
for (glw::GLint i = 0; i < more_than_max_separate_attribs; ++i)
{
std::string new_attrib = "a" + gl3cts::TransformFeedback::Utilities::itoa(i);
size_t new_attrib_size = new_attrib.size();
attrib[i] = new glw::GLchar[new_attrib_size + 1];
memset(attrib[i], 0, new_attrib_size + 1);
memcpy(attrib[i], new_attrib.c_str(), new_attrib_size);
}
gl.transformFeedbackVaryings(m_program_id_with_output, more_than_max_separate_attribs, attrib, GL_SEPARATE_ATTRIBS);
for (glw::GLint i = 0; i < more_than_max_separate_attribs; ++i)
{
delete[] attrib[i];
}
delete[] attrib;
if (GL_INVALID_VALUE != gl.getError())
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "INVALID_VALUE was not generated by TransformFeedbackVaryings when "
"<bufferMode> was SEPARATE_ATTRIBS and <count> exceeded limits."
<< tcu::TestLog::EndMessage;
return false;
}
/* INVALID_VALUE is generated by GetTransformFeedbackVarying when <index> is
greater than or equal to TRANSFORM_FEEDBACK_VARYINGS; */
glw::GLint transform_feedback_varyings = 0;
gl.getProgramiv(m_program_id_with_output, GL_TRANSFORM_FEEDBACK_VARYINGS, &transform_feedback_varyings);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv call failed.");
if (transform_feedback_varyings == 0)
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "glGetProgramiv failed to return GL_TRANSFORM_FEEDBACK_VARYINGS."
<< tcu::TestLog::EndMessage;
throw 0;
}
glw::GLchar tmp_buffer[256];
glw::GLsizei tmp_size = 0;
glw::GLenum tmp_type = GL_NONE;
gl.getTransformFeedbackVarying(m_program_id_with_output, transform_feedback_varyings, sizeof(tmp_buffer), NULL,
&tmp_size, &tmp_type, tmp_buffer);
if (GL_INVALID_VALUE != gl.getError())
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "INVALID_VALUE was not generated by GetTransformFeedbackVarying when "
"<index> was greater than or equal to TRANSFORM_FEEDBACK_VARYINGS."
<< tcu::TestLog::EndMessage;
return false;
}
/* INVALID_VALUE is generated by GetIntegerIndexdv when <index> exceeds the
limits of MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS and <param> is one of the
following:
* TRANSFORM_FEEDBACK_BUFFER_BINDING,
* TRANSFORM_FEEDBACK_BUFFER_START,
* TRANSFORM_FEEDBACK_BUFFER_SIZE; */
if (DE_NULL != m_glGetIntegerIndexedvEXT)
{
glw::GLint tmp_int_value;
m_glGetIntegerIndexedvEXT(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, more_than_max_separate_attribs, &tmp_int_value);
if (GL_INVALID_VALUE != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "INVALID_VALUE was not generated by GetIntegerIndexdv when <index> exceeds the "
"limits of MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS and <param> was "
"TRANSFORM_FEEDBACK_BUFFER_BINDING."
<< tcu::TestLog::EndMessage;
return false;
}
m_glGetIntegerIndexedvEXT(GL_TRANSFORM_FEEDBACK_BUFFER_START, more_than_max_separate_attribs, &tmp_int_value);
if (GL_INVALID_VALUE != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "INVALID_VALUE was not generated by GetIntegerIndexdv when <index> exceeds the "
"limits of MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS and <param> was "
"GL_TRANSFORM_FEEDBACK_BUFFER_START."
<< tcu::TestLog::EndMessage;
return false;
}
m_glGetIntegerIndexedvEXT(GL_TRANSFORM_FEEDBACK_BUFFER_SIZE, more_than_max_separate_attribs, &tmp_int_value);
if (GL_INVALID_VALUE != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "INVALID_VALUE was not generated by GetIntegerIndexdv when <index> exceeds the "
"limits of MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS and <param> was "
"GL_TRANSFORM_FEEDBACK_BUFFER_SIZE."
<< tcu::TestLog::EndMessage;
return false;
}
}
/* INVALID_VALUE is generated by GetBooleanIndexedv when <index> exceeds the
limits of MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS and <param> is
TRANSFORM_FEEDBACK_BUFFER_BINDING. */
if (DE_NULL != m_glGetBooleanIndexedvEXT)
{
glw::GLboolean tmp_bool_value;
m_glGetBooleanIndexedvEXT(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, more_than_max_separate_attribs,
&tmp_bool_value);
if (GL_INVALID_VALUE != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "INVALID_VALUE was not generated by GetBooleanIndexedv when <index> exceeds the "
"limits of MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS and <param> was "
"TRANSFORM_FEEDBACK_BUFFER_BINDING."
<< tcu::TestLog::EndMessage;
return false;
}
}
return true;
}
bool gl3cts::TransformFeedback::APIErrors::testExtension2(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Bind Transform Feedback Object */
gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_transform_feedback_object_0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTransformFeedback call failed.");
/* INVALID_OPERATION is generated by PauseTransformFeedback if current
transform feedback is not active or paused; */
gl.pauseTransformFeedback();
if (GL_INVALID_OPERATION != gl.getError())
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "INVALID_OPERATION is not generated by PauseTransformFeedback if "
"current transform feedback is not active or paused."
<< tcu::TestLog::EndMessage;
return false;
}
/* INVALID_OPERATION is generated by ResumeTransformFeedback if current
transform feedback is not active; */
gl.resumeTransformFeedback();
if (GL_INVALID_OPERATION != gl.getError())
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "INVALID_OPERATION is not generated by ResumeTransformFeedback if "
"current transform feedback is not active."
<< tcu::TestLog::EndMessage;
return false;
}
/* Prepare program and buffer. */
gl.useProgram(m_program_id_with_output);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed.");
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_buffer_0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase call failed.");
/* INVALID_OPERATION is generated by DrawTransformFeedback when
EndTransformFeedback was never called for the object named <id>. */
gl.drawTransformFeedback(GL_POINTS, m_transform_feedback_object_0);
if (GL_INVALID_OPERATION != gl.getError())
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "INVALID_OPERATION is not generated by DrawTransformFeedback when "
"EndTransformFeedback was never called for the object named <id>."
<< tcu::TestLog::EndMessage;
return false;
}
/* Make Transform Feedback Active */
gl.beginTransformFeedback(GL_POINTS);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback call failed.");
/* INVALID_OPERATION is generated by BindTransformFeedback if current
transform feedback is active and not paused; */
gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_transform_feedback_object_0);
if (GL_INVALID_OPERATION != gl.getError())
{
gl.endTransformFeedback();
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "INVALID_OPERATION is not generated by BindTransformFeedback if current "
"transform feedback is active and not paused."
<< tcu::TestLog::EndMessage;
return false;
}
/* INVALID_OPERATION is generated by DeleteTransformFeedbacks if any of <ids>
is active; */
gl.deleteTransformFeedbacks(1, &m_transform_feedback_object_0);
if (GL_INVALID_OPERATION != gl.getError())
{
gl.endTransformFeedback();
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "INVALID_OPERATION is not generated by DeleteTransformFeedbacks if any of <ids> is active."
<< tcu::TestLog::EndMessage;
return false;
}
/* INVALID_OPERATION is generated by ResumeTransformFeedback if current
transform feedback is not not paused; */
gl.resumeTransformFeedback();
if (GL_INVALID_OPERATION != gl.getError())
{
gl.endTransformFeedback();
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "INVALID_OPERATION is not generated by ResumeTransformFeedback if "
"current transform feedback is not not paused."
<< tcu::TestLog::EndMessage;
return false;
}
/* pause transform feedback */
gl.pauseTransformFeedback();
GLU_EXPECT_NO_ERROR(gl.getError(), "glPauseTransformFeedback call failed.");
/* No error is generated by draw command when transform feedback is paused
and primitive modes do not match; */
gl.drawArrays(GL_LINES, 0, 2);
if (GL_NO_ERROR != gl.getError())
{
gl.endTransformFeedback();
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "No error is not generated by draw command when transform feedback is "
"paused and primitive modes do not match."
<< tcu::TestLog::EndMessage;
return false;
}
/* INVALID_OPERATION is generated by LinkProgram when <program> is used by
some transform feedback object that is currently not active; */
gl.linkProgram(m_program_id_with_output);
if (GL_INVALID_OPERATION != gl.getError())
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "INVALID_OPERATION was not generated by LinkProgram when <program> was "
"used by some transform feedback object that is currently not active."
<< tcu::TestLog::EndMessage;
gl.endTransformFeedback();
return false;
}
/* No error is generated by UseProgram when transform feedback is paused; */
gl.useProgram(0);
if (GL_NO_ERROR != gl.getError())
{
gl.endTransformFeedback();
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "glUseProgram unexpectedly failed when transform feedback is paused."
<< tcu::TestLog::EndMessage;
return false;
}
gl.useProgram(m_program_id_with_output);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed.");
/* End Transform Feedback and make draw. */
gl.endTransformFeedback();
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback call failed.");
/* INVALID_VALUE is generated by DrawTransformFeedback if <id> is not name of
transform feedback object; */
unsigned short int invalid_name = 1;
while (gl.isTransformFeedback(invalid_name))
{
++invalid_name;
/* Make sure that this loop ends someday, bad day. */
if (invalid_name == USHRT_MAX)
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "Cannot find unused trnasform feedback object." << tcu::TestLog::EndMessage;
throw 0;
}
}
gl.drawTransformFeedback(GL_POINTS, (glw::GLuint)invalid_name);
if (GL_INVALID_VALUE != gl.getError())
{
gl.endTransformFeedback();
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "glUseProgram unexpectedly failed when transform feedback is paused."
<< tcu::TestLog::EndMessage;
return false;
}
return true;
}
bool gl3cts::TransformFeedback::APIErrors::testExtension3(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* INVALID_VALUE is generated by BeginQueryIndexed, EndQueryIndexed and
GetQueryIndexediv when <target> is TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN and
<index> exceeds limits of MAX_VERTEX_STREAMS
INVALID_VALUE is generated by BeginQueryIndexed, EndQueryIndexed and
GetQueryIndexediv when <target> is PRIMITIVES_GENERATED and <index> exceeds
limits of MAX_VERTEX_STREAMS */
glw::GLint max_vertex_streams = 0;
gl.getIntegerv(GL_MAX_VERTEX_STREAMS, &max_vertex_streams);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv call failed.");
if (max_vertex_streams == 0)
{
/* Nothing returned. */
throw 0;
}
++max_vertex_streams;
static const glw::GLenum target[] = { GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, GL_PRIMITIVES_GENERATED };
static const glw::GLchar* target_str[] = { STR(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN),
STR(GL_PRIMITIVES_GENERATED) };
static const glw::GLuint target_count = sizeof(target) / sizeof(target[0]);
for (glw::GLuint i = 0; i < target_count; ++i)
{
gl.beginQueryIndexed(target[i], max_vertex_streams, m_query_object);
if (GL_INVALID_VALUE != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "INVALID_VALUE was not generated by BeginQueryIndexed, EndQueryIndexed and"
"GetQueryIndexediv when <target> was "
<< target_str[i] << " and "
"<index> exceeded limits of MAX_VERTEX_STREAMS."
<< tcu::TestLog::EndMessage;
return false;
}
gl.endQueryIndexed(target[i], max_vertex_streams);
if (GL_INVALID_VALUE != gl.getError())
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "INVALID_VALUE was not generated by EndQueryIndexed "
"when <target> was "
<< target_str[i] << " and "
"<index> exceeded limits of MAX_VERTEX_STREAMS."
<< tcu::TestLog::EndMessage;
return false;
}
glw::GLint param = 0;
gl.getQueryIndexediv(target[i], max_vertex_streams, GL_QUERY_COUNTER_BITS, &param);
if (GL_INVALID_VALUE != gl.getError())
{
m_context.getTestContext().getLog() << tcu::TestLog::Message << "INVALID_VALUE was not generated by "
"GetQueryIndexediv when <target> was "
<< target_str[i] << " and "
"<index> exceeded limits of MAX_VERTEX_STREAMS."
<< tcu::TestLog::EndMessage;
return false;
}
}
/* INVALID_OPERATION is generated by EndQueryIndexed when name of active
query at <index> of <target> is zero */
gl.endQueryIndexed(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, 0);
if (GL_INVALID_OPERATION != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "INVALID_OPERATION was not generated by EndQueryIndexed when name of active "
"query at <index> of <target> is zero"
<< tcu::TestLog::EndMessage;
return false;
}
/* INVALID_VALUE is generated by DrawTransformFeedbackStream when <stream>
exceeds limits of MAX_VERTEX_STREAMS */
gl.drawTransformFeedbackStream(GL_POINTS, m_transform_feedback_object_0, max_vertex_streams);
if (GL_INVALID_VALUE != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "INVALID_VALUE was not generated by DrawTransformFeedbackStream when <stream> "
"exceeded limits of MAX_VERTEX_STREAMS"
<< tcu::TestLog::EndMessage;
return false;
}
/* INVALID_OPERATION is generated by TransformFeedbackVaryings when
<varyings> contains any of the special names while <bufferMode> is not
INTERLEAVED_ATTRIBS */
static const glw::GLchar* tf_varying_names[] = { "gl_NextBuffer", "gl_SkipComponents1", "gl_SkipComponents2",
"gl_SkipComponents3", "gl_SkipComponents4" };
static const glw::GLuint tf_varying_names_count = sizeof(tf_varying_names) / sizeof(tf_varying_names[0]);
for (glw::GLuint i = 0; i < tf_varying_names_count; ++i)
{
gl.transformFeedbackVaryings(m_program_id_with_output, 1, &tf_varying_names[i], GL_SEPARATE_ATTRIBS);
if (GL_INVALID_OPERATION != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "INVALID_OPERATION was not generated by TransformFeedbackVaryings when "
"<varyings> contained any of the special names while <bufferMode> was "
"GL_SEPARATE_ATTRIBS."
<< tcu::TestLog::EndMessage;
return false;
}
}
/* INVALID_OPERATION is generated by TransformFeedbackVaryings when
<varyings> contains more "gl_NextBuffer" entries than allowed limit of
MAX_TRANSFORM_FEEDBACK_BUFFERS */
glw::GLint max_transform_feedback_buffers = 0;
gl.getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_BUFFERS, &max_transform_feedback_buffers);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv call failed.");
if (max_transform_feedback_buffers == 0)
{
/* Nothing returned. */
throw 0;
}
glw::GLint more_than_max_transform_feedback_buffers = max_transform_feedback_buffers + 1;
const glw::GLchar** tf_next_buffer_varying_names = new const glw::GLchar*[more_than_max_transform_feedback_buffers];
if (DE_NULL == tf_next_buffer_varying_names)
{
/* Allocation error. */
throw 0;
}
for (glw::GLint i = 0; i < more_than_max_transform_feedback_buffers; ++i)
{
tf_next_buffer_varying_names[i] = tf_varying_names[0];
}
gl.transformFeedbackVaryings(m_program_id_with_output, more_than_max_transform_feedback_buffers,
tf_next_buffer_varying_names, GL_INTERLEAVED_ATTRIBS);
delete[] tf_next_buffer_varying_names;
if (GL_INVALID_OPERATION != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "INVALID_OPERATION was not generated by TransformFeedbackVaryings when "
"<varyings> contained more \"gl_NextBuffer\" entries than allowed limit of "
"MAX_TRANSFORM_FEEDBACK_BUFFER."
<< tcu::TestLog::EndMessage;
return false;
}
return true;
}
bool gl3cts::TransformFeedback::APIErrors::testInstanced(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
bool is_at_least_gl_40 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 0)));
bool is_tessellation = m_context.getContextInfo().isExtensionSupported("GL_ARB_tessellation_shader");
bool has_patches = is_at_least_gl_40 || is_tessellation;
/* INVALID_ENUM is generated by DrawTransformFeedbackInstanced and
DrawTransformFeedbackStreamInstanced if <mode> is invalid */
glw::GLenum _supported_mode[] = { GL_POINTS,
GL_LINE_STRIP,
GL_LINE_LOOP,
GL_LINES,
GL_LINE_STRIP_ADJACENCY,
GL_LINES_ADJACENCY,
GL_TRIANGLE_STRIP,
GL_TRIANGLE_FAN,
GL_TRIANGLES,
GL_TRIANGLE_STRIP_ADJACENCY,
GL_TRIANGLES_ADJACENCY,
GL_QUADS,
GL_PATCHES };
std::set<glw::GLenum> supported_mode(_supported_mode,
_supported_mode + sizeof(_supported_mode) / sizeof(_supported_mode[0]) - (has_patches ? 0 : 1));
int mode = 0;
while (supported_mode.find(mode) != supported_mode.end())
{
mode++;
}
gl.drawTransformFeedbackInstanced(mode, m_transform_feedback_object_0, 1);
if (GL_INVALID_ENUM != gl.getError())
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "INVALID_ENUM was not generated by DrawTransformFeedbackInstanced and "
"DrawTransformFeedbackStreamInstanced when <mode> was invalid."
<< tcu::TestLog::EndMessage;
return false;
}
gl.drawTransformFeedbackStreamInstanced(mode, m_transform_feedback_object_0, 0, 1);
if (GL_INVALID_ENUM != gl.getError())
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "INVALID_ENUM was not generated by DrawTransformFeedbackInstanced and "
"DrawTransformFeedbackStreamInstanced when <mode> was invalid."
<< tcu::TestLog::EndMessage;
return false;
}
if (m_program_id_with_geometry_shader != 0) {
/* INVALID_OPERATION is generated by DrawTransformFeedbackInstanced and
DrawTransformFeedbackStreamInstanced if <mode> does not match geometry
shader */
gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_transform_feedback_object_0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTransformFeedback call failed.");
gl.useProgram(m_program_id_with_geometry_shader);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed.");
gl.bindVertexArray(m_vertex_array_object);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray call failed.");
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_buffer_0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
gl.beginTransformFeedback(GL_POINTS);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback call failed.");
gl.drawArrays(GL_POINTS, 0, 1);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays call failed.");
gl.endTransformFeedback();
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback call failed.");
gl.drawTransformFeedbackInstanced(GL_LINES, m_transform_feedback_object_0, 1);
if (GL_INVALID_OPERATION != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "INVALID_OPERATION was not generated by DrawTransformFeedbackInstanced and "
"DrawTransformFeedbackStreamInstanced if <mode> did not match geometry shader."
<< tcu::TestLog::EndMessage;
return false;
}
gl.drawTransformFeedbackStreamInstanced(GL_LINES, m_transform_feedback_object_0, 0, 1);
if (GL_INVALID_OPERATION != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "INVALID_OPERATION was not generated by DrawTransformFeedbackInstanced and "
"DrawTransformFeedbackStreamInstanced if <mode> did not match geometry shader."
<< tcu::TestLog::EndMessage;
return false;
}
}
/* All of the below tests concern themselves with GL_PATCHES and
* tessellation shaders */
if (m_program_id_with_tessellation_shaders == 0)
{
return true;
}
/* INVALID_OPERATION is generated by DrawTransformFeedbackInstanced and
DrawTransformFeedbackStreamInstanced if <mode> does not match tessellation */
gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_transform_feedback_object_0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTransformFeedback call failed.");
gl.useProgram(m_program_id_with_tessellation_shaders);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed.");
gl.bindVertexArray(m_vertex_array_object);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray call failed.");
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_buffer_0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
gl.beginTransformFeedback(GL_LINES);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback call failed.");
gl.drawArrays(GL_PATCHES, 0, 2);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays call failed.");
gl.endTransformFeedback();
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback call failed.");
gl.drawTransformFeedbackInstanced(GL_POINTS, m_transform_feedback_object_0, 1);
if (GL_INVALID_OPERATION != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "INVALID_OPERATION was not generated by DrawTransformFeedbackInstanced and "
"DrawTransformFeedbackStreamInstanced if <mode> did not match geometry shader."
<< tcu::TestLog::EndMessage;
return false;
}
gl.drawTransformFeedbackStreamInstanced(GL_POINTS, m_transform_feedback_object_0, 0, 1);
if (GL_INVALID_OPERATION != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "INVALID_OPERATION was not generated by DrawTransformFeedbackInstanced and "
"DrawTransformFeedbackStreamInstanced if <mode> did not match geometry shader."
<< tcu::TestLog::EndMessage;
return false;
}
/* INVALID_VALUE is generated by DrawTransformFeedbackStreamInstanced if
<stream> is greater than or equal to MAX_VERTEX_STREAMS */
glw::GLint max_vertex_streams = 0;
gl.getIntegerv(GL_MAX_VERTEX_STREAMS, &max_vertex_streams);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv call failed.");
if (max_vertex_streams == 0)
{
/* Failed to query GL_MAX_VERTEX_STREAMS. */
throw 0;
}
glw::GLint more_than_max_vertex_streams = max_vertex_streams + 1;
gl.drawTransformFeedbackStreamInstanced(GL_PATCHES, m_transform_feedback_object_0, more_than_max_vertex_streams, 1);
if (GL_INVALID_VALUE != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "INVALID_OPERATION was not generated by DrawTransformFeedbackInstanced and "
"DrawTransformFeedbackStreamInstanced if <mode> did not match geometry shader."
<< tcu::TestLog::EndMessage;
return false;
}
/* INVALID_VALUE is generated by DrawTransformFeedbackInstanced and
DrawTransformFeedbackStreamInstanced if <id> is not name of transform
feedback object */
unsigned short int invalid_name = 1;
while (gl.isTransformFeedback(invalid_name))
{
++invalid_name;
/* Make sure that this loop ends someday, bad day. */
if (invalid_name == USHRT_MAX)
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "Cannot find unused trnasform feedback object." << tcu::TestLog::EndMessage;
throw 0;
}
}
gl.drawTransformFeedbackInstanced(GL_PATCHES, (glw::GLuint)invalid_name, 1);
if (GL_INVALID_VALUE != gl.getError())
{
gl.endTransformFeedback();
return false;
}
gl.drawTransformFeedbackStreamInstanced(GL_PATCHES, (glw::GLuint)invalid_name, 0, 1);
if (GL_INVALID_VALUE != gl.getError())
{
gl.endTransformFeedback();
return false;
}
/* INVALID_OPERATION is generated if by DrawTransformFeedbackStreamInstanced
if EndTransformFeedback was never called for the object named <id>.
return true */
gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_transform_feedback_object_1);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTransformFeedback call failed.");
gl.drawTransformFeedbackStreamInstanced(GL_PATCHES, m_transform_feedback_object_1, 0, 1);
if (GL_INVALID_OPERATION != gl.getError())
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "INVALID_OPERATION was not generated by DrawTransformFeedbackInstanced and "
"DrawTransformFeedbackStreamInstanced if <mode> did not match geometry shader."
<< tcu::TestLog::EndMessage;
return false;
}
return true;
}
const glw::GLchar* gl3cts::TransformFeedback::APIErrors::m_tessellation_control_shader =
"#version 400\n"
"\n"
"layout (vertices = 2 ) out;\n"
"\n"
"void main()\n"
"{\n"
" gl_TessLevelOuter[1] = 3.0;\n"
" gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::APIErrors::m_tessellation_evaluation_shader =
"#version 400\n"
"\n"
"layout(isolines, equal_spacing, ccw) in;\n"
"\n"
"out float result;\n"
"\n"
"void main()\n"
"{\n"
" result = 0.5;\n"
" gl_Position = gl_in[0].gl_Position + gl_in[1].gl_Position + gl_in[2].gl_Position;\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::APIErrors::m_geometry_shader =
"#version 150\n"
"\n"
"layout(points) in;\n"
"layout(points, max_vertices = 2) out;\n"
"\n"
"out float result;\n"
"\n"
"void main()\n"
"{\n"
" gl_Position = gl_in[0].gl_Position + vec4(0.0, 0.0, 0.0, 0.0);\n"
" result = 0.0;\n"
" EmitVertex();\n"
"\n"
" gl_Position = gl_in[0].gl_Position + vec4(1.0, 0.0, 0.0, 0.0);\n"
" result = 1.0;\n"
" EmitVertex();\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::APIErrors::s_vertex_shader_with_output =
"#version 130\n"
"\n"
"out float result;\n"
"\n"
"void main()\n"
"{\n"
" result = float(gl_VertexID);\n"
" gl_Position = vec4(1.0);\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::APIErrors::s_vertex_shader_with_input_output =
"#version 130\n"
"\n"
"in float v_input;\n"
"\n"
"out float result;\n"
"\n"
"void main()\n"
"{\n"
" result = float(gl_VertexID);\n"
" gl_Position = vec4(v_input);\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::APIErrors::s_vertex_shader_without_output =
"#version 130\n"
"\n"
"void main()\n"
"{\n"
" gl_Position = vec4(1.0);\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::APIErrors::s_fragment_shader = "#version 130\n"
"\n"
"out vec4 color;\n"
"\n"
"void main()\n"
"{\n"
" color = vec4(1.0);\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::APIErrors::m_varying_name = "result";
const glw::GLfloat gl3cts::TransformFeedback::APIErrors::m_buffer_1_data[] = { 3.14159265359f, 2.7182818f };
const glw::GLsizei gl3cts::TransformFeedback::APIErrors::m_buffer_1_size =
sizeof(gl3cts::TransformFeedback::APIErrors::m_buffer_1_data);
/*-----------------------------------------------------------------------------------------------*/
gl3cts::TransformFeedback::LinkingErrors::LinkingErrors(deqp::Context& context)
: deqp::TestCase(context, "linking_errors_test", "Transform Feedback Linking Errors Test"), m_context(context)
{
/* Left intentionally blank. */
}
gl3cts::TransformFeedback::LinkingErrors::~LinkingErrors(void)
{
}
tcu::TestNode::IterateResult gl3cts::TransformFeedback::LinkingErrors::iterate(void)
{
bool is_ok = true;
bool test_error = false;
try
{
is_ok = is_ok && testNoVertexNoGeometry();
is_ok = is_ok && testInvalidVarying();
is_ok = is_ok && testRepeatedVarying();
is_ok = is_ok && testTooManyVaryings();
}
catch (...)
{
is_ok = false;
test_error = true;
}
/* Result's setup. */
if (is_ok)
{
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
}
else
{
if (test_error)
{
m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
}
else
{
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
}
return STOP;
}
bool gl3cts::TransformFeedback::LinkingErrors::testNoVertexNoGeometry(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Check if link process fails under the following conditions:
<count> specified by TransformFeedbackVaryings is non-zero and program has
neither vertex nor geometry shader; */
glw::GLint linking_status = 1;
glw::GLuint program = gl3cts::TransformFeedback::Utilities::buildProgram(
gl, m_context.getTestContext().getLog(), NULL, NULL, NULL, NULL, s_fragment_shader,
&s_valid_transform_feedback_varying, 1, GL_INTERLEAVED_ATTRIBS, false, &linking_status);
if ((GL_FALSE != linking_status) || program)
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "Linking unexpectedly succeded when Transform Feedback varying was "
"specified but program had neither vertex nor geometry shader stages."
<< tcu::TestLog::EndMessage;
if (program)
{
gl.deleteProgram(program);
}
return false;
}
/* Log success. */
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "Linking failed as expected when Transform Feedback varying was specified "
"but program had neither vertex nor geometry shader stages."
<< tcu::TestLog::EndMessage;
return true;
}
bool gl3cts::TransformFeedback::LinkingErrors::testInvalidVarying(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Check if link process fails under the following conditions:
<varyings> specified by TransformFeedbackVaryings contains name of
variable that is not available for capture; */
std::string vertex_shader(s_vertex_shader_template);
vertex_shader = gl3cts::TransformFeedback::Utilities::preprocessCode(
vertex_shader, "TEMPLATE_INPUT_OUTPUT_DECLARATIONS", "in float data;\n");
vertex_shader = gl3cts::TransformFeedback::Utilities::preprocessCode(vertex_shader, "TEMPLATE_OUTPUT_SETTERS", "");
glw::GLint linking_status = 1;
glw::GLuint program = gl3cts::TransformFeedback::Utilities::buildProgram(
gl, m_context.getTestContext().getLog(), NULL, NULL, NULL, vertex_shader.c_str(), s_fragment_shader,
&s_invalid_transform_feedback_varying, 1, GL_INTERLEAVED_ATTRIBS, false, &linking_status);
if ((GL_FALSE != linking_status) || program)
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "Linking unexpectedly succeded when Transform Feedback varying was specified with name of variable ("
<< s_invalid_transform_feedback_varying << ") that is not available for capture."
<< tcu::TestLog::EndMessage;
if (program)
{
gl.deleteProgram(program);
}
return false;
}
/* Log success. */
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "Linking failed as expected when Transform Feedback varying was specified with name of variable ("
<< s_invalid_transform_feedback_varying << ") that is not available for capture." << tcu::TestLog::EndMessage;
return true;
}
bool gl3cts::TransformFeedback::LinkingErrors::testRepeatedVarying(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Check if link process fails under the following conditions:
<varyings> specified by TransformFeedbackVaryings contains name of
variable more than once; */
std::string vertex_shader(s_vertex_shader_template);
vertex_shader = gl3cts::TransformFeedback::Utilities::preprocessCode(
vertex_shader, "TEMPLATE_INPUT_OUTPUT_DECLARATIONS", "out float result;\n");
vertex_shader = gl3cts::TransformFeedback::Utilities::preprocessCode(vertex_shader, "TEMPLATE_OUTPUT_SETTERS",
" result = 0.577215664901532;\n");
glw::GLint linking_status = 1;
glw::GLuint program = gl3cts::TransformFeedback::Utilities::buildProgram(
gl, m_context.getTestContext().getLog(), NULL, NULL, NULL, vertex_shader.c_str(), s_fragment_shader,
s_repeated_transform_feedback_varying, s_repeated_transform_feedback_varying_count, GL_INTERLEAVED_ATTRIBS,
false, &linking_status);
if ((GL_FALSE != linking_status) || program)
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "Linking unexpectedly succeded when Transform Feedback varying was specified twice."
<< tcu::TestLog::EndMessage;
if (program)
{
gl.deleteProgram(program);
}
return false;
}
/* Log success. */
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "Linking failed as expected when Transform Feedback varying was specified twice."
<< tcu::TestLog::EndMessage;
return true;
}
bool gl3cts::TransformFeedback::LinkingErrors::testTooManyVaryings(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Check if link process fails under the following conditions:
number of components specified to capture exceeds limits
MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS or
MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS. */
/* Fetching limits. */
glw::GLint max_transform_feedback_separate_components = 0;
glw::GLint max_transform_feedback_interleaved_components = 0;
gl.getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS, &max_transform_feedback_separate_components);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv call failed.");
if (max_transform_feedback_separate_components == 0)
{
throw 0;
}
gl.getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS, &max_transform_feedback_interleaved_components);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv call failed.");
if (max_transform_feedback_interleaved_components == 0)
{
throw 0;
}
glw::GLint more_than_max_transform_feedback_components =
deMax32(max_transform_feedback_separate_components, max_transform_feedback_interleaved_components) + 1;
/* Preparing source code. */
std::string vertex_shader(s_vertex_shader_template);
std::string transform_feedback_variable_declarations("");
std::string transform_feedback_variable_setters("");
std::vector<std::string> transform_feedback_varyings(more_than_max_transform_feedback_components);
std::vector<const glw::GLchar*> transform_feedback_varyings_c(more_than_max_transform_feedback_components);
for (glw::GLint i = 0; i < more_than_max_transform_feedback_components; ++i)
{
std::string varying = "result_";
varying.append(gl3cts::TransformFeedback::Utilities::itoa(i));
transform_feedback_varyings[i] = varying;
transform_feedback_varyings_c[i] = transform_feedback_varyings[i].c_str();
transform_feedback_variable_declarations.append("out float ");
transform_feedback_variable_declarations.append(varying);
transform_feedback_variable_declarations.append(";\n");
transform_feedback_variable_setters.append(" ");
transform_feedback_variable_setters.append(varying);
transform_feedback_variable_setters.append(" = ");
transform_feedback_variable_setters.append(gl3cts::TransformFeedback::Utilities::itoa(i * i));
transform_feedback_variable_setters.append(".0;\n");
}
vertex_shader = gl3cts::TransformFeedback::Utilities::preprocessCode(
vertex_shader, "TEMPLATE_INPUT_OUTPUT_DECLARATIONS", transform_feedback_variable_declarations);
vertex_shader = gl3cts::TransformFeedback::Utilities::preprocessCode(vertex_shader, "TEMPLATE_OUTPUT_SETTERS",
transform_feedback_variable_setters);
glw::GLuint program = gl3cts::TransformFeedback::Utilities::buildProgram(
gl, m_context.getTestContext().getLog(), NULL, NULL, NULL, vertex_shader.c_str(), s_fragment_shader,
&transform_feedback_varyings_c[0], more_than_max_transform_feedback_components, GL_INTERLEAVED_ATTRIBS);
/* Note: we check for program as not only linking shall fail, but also glTransformFeedbackVaryings shall return an error. */
if (program)
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "Linking unexpectedly succeded when too many Transform Feedback varying "
"were specified in INTERLEAVED mode."
<< tcu::TestLog::EndMessage;
if (program)
{
gl.deleteProgram(program);
}
return false;
}
program = gl3cts::TransformFeedback::Utilities::buildProgram(
gl, m_context.getTestContext().getLog(), NULL, NULL, NULL, vertex_shader.c_str(), s_fragment_shader,
&transform_feedback_varyings_c[0], more_than_max_transform_feedback_components, GL_SEPARATE_ATTRIBS);
if (program)
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "Linking unexpectedly succeded when too many Transform Feedback "
"varyings were specified in SEPARATE mode."
<< tcu::TestLog::EndMessage;
if (program)
{
gl.deleteProgram(program);
}
return false;
}
/* Log success. */
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "Linking failed as expected when too many Transform Feedback varyings were specified."
<< tcu::TestLog::EndMessage;
return true;
}
const glw::GLchar* gl3cts::TransformFeedback::LinkingErrors::s_fragment_shader = "#version 130\n"
"\n"
"out vec4 color;\n"
"\n"
"void main()\n"
"{\n"
" color = vec4(1.0);\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::LinkingErrors::s_vertex_shader_template =
"#version 130\n"
"\n"
"TEMPLATE_INPUT_OUTPUT_DECLARATIONS"
"\n"
"void main()\n"
"{\n"
"TEMPLATE_OUTPUT_SETTERS"
"\n"
" gl_Position = vec4(1.618033988749);\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::LinkingErrors::s_valid_transform_feedback_varying = "result";
const glw::GLchar* gl3cts::TransformFeedback::LinkingErrors::s_invalid_transform_feedback_varying = "data";
const glw::GLchar* gl3cts::TransformFeedback::LinkingErrors::s_repeated_transform_feedback_varying[] = { "result",
"result" };
const glw::GLsizei gl3cts::TransformFeedback::LinkingErrors::s_repeated_transform_feedback_varying_count =
sizeof(s_repeated_transform_feedback_varying) / sizeof(s_repeated_transform_feedback_varying[0]);
/*-----------------------------------------------------------------------------------------------*/
const glw::GLint gl3cts::TransformFeedback::Limits::s_min_value_of_max_transform_feedback_interleaved_components = 64;
const glw::GLint gl3cts::TransformFeedback::Limits::s_min_value_of_max_transform_feedback_separate_attribs = 4;
const glw::GLint gl3cts::TransformFeedback::Limits::s_min_value_of_max_transform_feedback_separate_components = 4;
const glw::GLint gl3cts::TransformFeedback::Limits::s_min_value_of_max_transform_feedback_buffers = 4;
const glw::GLint gl3cts::TransformFeedback::Limits::s_min_value_of_max_vertex_streams = 1;
gl3cts::TransformFeedback::Limits::Limits(deqp::Context& context)
: deqp::TestCase(context, "limits_test", "Transform Feedback Limits Test"), m_context(context)
{
}
gl3cts::TransformFeedback::Limits::~Limits(void)
{
}
tcu::TestNode::IterateResult gl3cts::TransformFeedback::Limits::iterate(void)
{
/* Initializations. */
bool is_at_least_gl_30 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(3, 0)));
bool is_at_least_gl_40 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 0)));
bool is_ext_tf_1 = m_context.getContextInfo().isExtensionSupported("GL_EXT_transform_feedback");
bool is_arb_tf_3 = m_context.getContextInfo().isExtensionSupported("GL_ARB_transform_feedback3");
bool is_ok = true;
bool test_error = false;
/* Tests. */
try
{
if (is_at_least_gl_30 || is_ext_tf_1)
{
is_ok = is_ok && test_max_transform_feedback_interleaved_components();
is_ok = is_ok && test_max_transform_feedback_separate_attribs();
is_ok = is_ok && test_max_transform_feedback_separate_components();
}
if (is_at_least_gl_40 || is_arb_tf_3)
{
is_ok = is_ok && test_max_transform_feedback_buffers();
is_ok = is_ok && test_max_vertex_streams();
}
}
catch (...)
{
is_ok = false;
test_error = true;
}
/* Result's setup. */
if (is_ok)
{
/* Log success. */
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Limits are in range of specification."
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
}
else
{
if (test_error)
{
m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
}
else
{
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
}
return STOP;
}
bool gl3cts::TransformFeedback::Limits::test_max_transform_feedback_interleaved_components(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Check that MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS is at least 64. */
glw::GLint max_transform_feedback_interleaved_components = 0;
gl.getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS, &max_transform_feedback_interleaved_components);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv call failed.");
if (max_transform_feedback_interleaved_components < s_min_value_of_max_transform_feedback_interleaved_components)
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS is equal to "
<< max_transform_feedback_interleaved_components << " which is less than expected "
<< s_min_value_of_max_transform_feedback_interleaved_components << "." << tcu::TestLog::EndMessage;
return false;
}
return true;
}
bool gl3cts::TransformFeedback::Limits::test_max_transform_feedback_separate_attribs(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Check that MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS is at least 4. */
glw::GLint max_transform_feedback_separate_attribs = 0;
gl.getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &max_transform_feedback_separate_attribs);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv call failed.");
if (max_transform_feedback_separate_attribs < s_min_value_of_max_transform_feedback_separate_attribs)
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS is equal to "
<< max_transform_feedback_separate_attribs << " which is less than expected "
<< s_min_value_of_max_transform_feedback_separate_attribs << "." << tcu::TestLog::EndMessage;
return false;
}
return true;
}
bool gl3cts::TransformFeedback::Limits::test_max_transform_feedback_separate_components(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Check that MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS is at least 4. */
glw::GLint max_transform_feedback_separate_components = 0;
gl.getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS, &max_transform_feedback_separate_components);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv call failed.");
if (max_transform_feedback_separate_components < s_min_value_of_max_transform_feedback_separate_components)
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS is equal to "
<< max_transform_feedback_separate_components << " which is less than expected "
<< s_min_value_of_max_transform_feedback_separate_components << "." << tcu::TestLog::EndMessage;
return false;
}
return true;
}
bool gl3cts::TransformFeedback::Limits::test_max_transform_feedback_buffers(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Check that MAX_TRANSFORM_FEEDBACK_BUFFERS is at least 4. */
glw::GLint max_transform_feedback_buffers = 0;
gl.getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_BUFFERS, &max_transform_feedback_buffers);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv call failed.");
if (max_transform_feedback_buffers < s_min_value_of_max_transform_feedback_buffers)
{
m_context.getTestContext().getLog() << tcu::TestLog::Message << "MAX_TRANSFORM_FEEDBACK_BUFFERS is equal to "
<< max_transform_feedback_buffers << " which is less than expected "
<< s_min_value_of_max_transform_feedback_buffers << "."
<< tcu::TestLog::EndMessage;
return false;
}
return true;
}
bool gl3cts::TransformFeedback::Limits::test_max_vertex_streams(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Check that MAX_VERTEX_STREAMS is at least 1. */
glw::GLint max_vertex_streams = 0;
gl.getIntegerv(GL_MAX_VERTEX_STREAMS, &max_vertex_streams);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv call failed.");
if (max_vertex_streams < s_min_value_of_max_vertex_streams)
{
m_context.getTestContext().getLog() << tcu::TestLog::Message << "MAX_VERTEX_STREAMS is equal to "
<< max_vertex_streams << " which is less than expected "
<< s_min_value_of_max_vertex_streams << "." << tcu::TestLog::EndMessage;
return false;
}
return true;
}
/*-----------------------------------------------------------------------------------------------*/
gl3cts::TransformFeedback::CaptureVertexInterleaved::CaptureVertexInterleaved(deqp::Context& context,
const char* test_name,
const char* test_description)
: deqp::TestCase(context, test_name, test_description)
, m_context(context)
, m_program(0)
, m_framebuffer(0)
, m_renderbuffer(0)
, m_buffer(0)
, m_buffer_size(0)
, m_vertex_array_object(0)
, m_max_transform_feedback_components(0)
, m_attrib_type(GL_INTERLEAVED_ATTRIBS)
, m_max_vertices_drawn(8)
, m_glBindBufferOffsetEXT(DE_NULL)
{
}
gl3cts::TransformFeedback::CaptureVertexInterleaved::~CaptureVertexInterleaved(void)
{
}
tcu::TestNode::IterateResult gl3cts::TransformFeedback::CaptureVertexInterleaved::iterate(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Initializations. */
bool is_at_least_gl_30 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(3, 0)));
bool is_ext_tf_1 = m_context.getContextInfo().isExtensionSupported("GL_EXT_transform_feedback");
bool is_ok = true;
bool test_error = false;
try
{
if (is_ext_tf_1)
{
/* Extension query. */
m_glBindBufferOffsetEXT =
(BindBufferOffsetEXT_ProcAddress)m_context.getRenderContext().getProcAddress("glBindBufferOffsetEXT");
if (DE_NULL == m_glBindBufferOffsetEXT)
{
throw 0;
}
}
if (is_at_least_gl_30 || is_ext_tf_1)
{
fetchLimits();
buildProgram();
createFramebuffer();
createTransformFeedbackBuffer();
createVertexArrayObject();
gl.useProgram(m_program);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed.");
for (glw::GLint i_bind_case = 0; (i_bind_case < BIND_BUFFER_CASES_COUNT) && is_ok; ++i_bind_case)
{
if ((i_bind_case == BIND_BUFFER_OFFSET_CASE) && (DE_NULL == m_glBindBufferOffsetEXT))
{
continue;
}
bindBuffer((BindBufferCase)i_bind_case);
for (glw::GLuint i_primitive_case = 0; (i_primitive_case < s_primitive_cases_count) && is_ok;
++i_primitive_case)
{
draw(i_primitive_case);
is_ok = is_ok && checkFramebuffer(s_primitive_cases[i_primitive_case]);
is_ok = is_ok && checkTransformFeedbackBuffer((BindBufferCase)i_bind_case,
s_primitive_cases[i_primitive_case]);
}
}
}
}
catch (...)
{
is_ok = false;
test_error = true;
}
/* Clean objects. */
clean();
/* Result's setup. */
if (is_ok)
{
/* Log success. */
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Capture Vertex have passed."
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
}
else
{
if (test_error)
{
m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
}
else
{
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
}
return STOP;
}
void gl3cts::TransformFeedback::CaptureVertexInterleaved::fetchLimits(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Fetching limits. */
gl.getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS, &m_max_transform_feedback_components);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv call failed.");
if (m_max_transform_feedback_components == 0)
{
throw 0;
}
glw::GLint max_varyings_components = 0;
gl.getIntegerv(GL_MAX_VARYING_COMPONENTS, &max_varyings_components);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv call failed.");
if (max_varyings_components == 0)
{
throw 0;
}
if (m_max_transform_feedback_components > max_varyings_components)
{
m_max_transform_feedback_components = max_varyings_components;
}
}
void gl3cts::TransformFeedback::CaptureVertexInterleaved::buildProgram(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Preparing source code. */
std::string vertex_shader(s_vertex_shader_source_code_template); /* Storage for vertex shader source code. */
std::string transform_feedback_variable_declarations(
""); /* String to contain all custom outputs from vertex shader. */
std::string transform_feedback_variable_setters(
""); /* String containing all initializations of custom outputs from vertex shader. */
std::vector<std::string> transform_feedback_varyings(m_max_transform_feedback_components); /* Varyings array. */
std::vector<const glw::GLchar*> transform_feedback_varyings_c(
m_max_transform_feedback_components); /* Varyings array in C form to pass to the GL. */
glw::GLint user_defined_transform_feedback_interleaved_varyings_count =
m_max_transform_feedback_components /* total max to be written by the shader */
/ 4 /* components per vec4 */
- 1 /* gl_Position */;
glw::GLint all_transform_feedback_interleaved_varyings_count =
user_defined_transform_feedback_interleaved_varyings_count + 1 /* gl_Position */;
/* Most of varyings is declarated output variables. */
for (glw::GLint i = 0; i < user_defined_transform_feedback_interleaved_varyings_count; ++i)
{
std::string varying = "result_";
varying.append(gl3cts::TransformFeedback::Utilities::itoa(i));
transform_feedback_varyings[i] = varying;
transform_feedback_varyings_c[i] = transform_feedback_varyings[i].c_str();
transform_feedback_variable_declarations.append("out vec4 ");
transform_feedback_variable_declarations.append(varying);
transform_feedback_variable_declarations.append(";\n");
transform_feedback_variable_setters.append(" ");
transform_feedback_variable_setters.append(varying);
transform_feedback_variable_setters.append(" = vec4(");
transform_feedback_variable_setters.append(gl3cts::TransformFeedback::Utilities::itoa(i * 4));
transform_feedback_variable_setters.append(".0, ");
transform_feedback_variable_setters.append(gl3cts::TransformFeedback::Utilities::itoa(i * 4 + 1));
transform_feedback_variable_setters.append(".0, ");
transform_feedback_variable_setters.append(gl3cts::TransformFeedback::Utilities::itoa(i * 4 + 2));
transform_feedback_variable_setters.append(".0, ");
transform_feedback_variable_setters.append(gl3cts::TransformFeedback::Utilities::itoa(i * 4 + 3));
transform_feedback_variable_setters.append(".0);\n");
}
/* Last four varying components are gl_Position components. */
transform_feedback_varyings[user_defined_transform_feedback_interleaved_varyings_count] = "gl_Position";
transform_feedback_varyings_c[user_defined_transform_feedback_interleaved_varyings_count] =
transform_feedback_varyings[user_defined_transform_feedback_interleaved_varyings_count].c_str();
/* Preprocess vertex shader source code template. */
vertex_shader = gl3cts::TransformFeedback::Utilities::preprocessCode(
vertex_shader, "TEMPLATE_INPUT_OUTPUT_DECLARATIONS", transform_feedback_variable_declarations);
vertex_shader = gl3cts::TransformFeedback::Utilities::preprocessCode(vertex_shader, "TEMPLATE_OUTPUT_SETTERS",
transform_feedback_variable_setters);
vertex_shader = gl3cts::TransformFeedback::Utilities::preprocessCode(
vertex_shader, "TEMPLATE_RASTERIZATION_EPSILON",
gl3cts::TransformFeedback::Utilities::ftoa(s_rasterization_epsilon));
/* Compile, link and check. */
m_program = gl3cts::TransformFeedback::Utilities::buildProgram(
gl, m_context.getTestContext().getLog(), NULL, NULL, NULL, vertex_shader.c_str(), s_fragment_shader_source_code,
&transform_feedback_varyings_c[0], all_transform_feedback_interleaved_varyings_count, m_attrib_type);
if (0 == m_program)
{
throw 0;
}
}
void gl3cts::TransformFeedback::CaptureVertexInterleaved::createFramebuffer(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Setting clear color */
gl.clearColor(0.f, 0.f, 0.f, 1.f);
GLU_EXPECT_NO_ERROR(gl.getError(), "glClearColor call failed.");
/* Creating framebuffer */
gl.genFramebuffers(1, &m_framebuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers call failed.");
gl.genRenderbuffers(1, &m_renderbuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenRenderbuffers call failed.");
gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");
gl.bindRenderbuffer(GL_RENDERBUFFER, m_renderbuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer call failed.");
gl.renderbufferStorage(GL_RENDERBUFFER, GL_R32F, s_framebuffer_size, s_framebuffer_size);
GLU_EXPECT_NO_ERROR(gl.getError(), "glRenderbufferStorage call failed.");
gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_renderbuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferRenderbuffer call failed.");
if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
throw 0;
}
gl.viewport(0, 0, s_framebuffer_size, s_framebuffer_size);
GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport call failed.");
}
void gl3cts::TransformFeedback::CaptureVertexInterleaved::createTransformFeedbackBuffer(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Creating xfb buffer */
gl.genBuffers(1, &m_buffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers call failed.");
gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_buffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
m_buffer_size =
static_cast<glw::GLuint>(m_max_transform_feedback_components * m_max_vertices_drawn * sizeof(glw::GLfloat));
gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, m_buffer_size, NULL, GL_DYNAMIC_READ);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData call failed.");
}
void gl3cts::TransformFeedback::CaptureVertexInterleaved::createVertexArrayObject(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* VAO Creations */
gl.genVertexArrays(1, &m_vertex_array_object);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays call failed.");
gl.bindVertexArray(m_vertex_array_object);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray call failed.");
}
void gl3cts::TransformFeedback::CaptureVertexInterleaved::draw(glw::GLuint primitive_case)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Draw */
gl.clear(GL_COLOR_BUFFER_BIT);
GLU_EXPECT_NO_ERROR(gl.getError(), "glClear call failed.");
gl.beginTransformFeedback(s_primitive_cases_xfb[primitive_case]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedbac call failed.");
gl.drawElements(s_primitive_cases[primitive_case], s_element_indices_counts[primitive_case], GL_UNSIGNED_INT,
s_element_indices[primitive_case]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawElements call failed.");
gl.endTransformFeedback();
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedbac call failed.");
}
bool gl3cts::TransformFeedback::CaptureVertexInterleaved::checkFramebuffer(glw::GLenum primitive_type UNUSED)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Fetch framebuffer. */
std::vector<glw::GLfloat> pixels(s_framebuffer_size * s_framebuffer_size);
if (s_framebuffer_size > 0)
{
gl.readPixels(0, 0, s_framebuffer_size, s_framebuffer_size, GL_RED, GL_FLOAT, pixels.data());
GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels call failed.");
}
/* Check results.
Note: assuming that s_buffer_size == 2 -> then all points shall be drawn. */
for (std::vector<glw::GLfloat>::iterator i = pixels.begin(); i != pixels.end(); ++i)
{
if (fabs(*i - 0.5f) > 0.0625f /* precision */)
{
return false;
}
}
return true;
}
bool gl3cts::TransformFeedback::CaptureVertexInterleaved::checkTransformFeedbackBuffer(BindBufferCase bind_case UNUSED,
glw::GLenum primitive_type)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Check */
glw::GLuint number_of_vertices = 0;
switch (primitive_type)
{
case GL_POINTS:
number_of_vertices = 4;
break;
case GL_LINES:
number_of_vertices = 4;
break;
case GL_LINE_LOOP:
number_of_vertices = 8;
break;
case GL_LINE_STRIP:
number_of_vertices = 6;
break;
case GL_TRIANGLES:
number_of_vertices = 6;
break;
case GL_TRIANGLE_STRIP:
number_of_vertices = 6;
break;
case GL_TRIANGLE_FAN:
number_of_vertices = 6;
break;
default:
throw 0;
}
glw::GLfloat* results = (glw::GLfloat*)gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY);
GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBuffer call failed.");
bool is_ok = true;
for (glw::GLuint j = 0; (j < number_of_vertices) && is_ok; ++j)
{
for (glw::GLint i = 0; i < m_max_transform_feedback_components - 4; ++i)
{
glw::GLfloat result = results[i + j * m_max_transform_feedback_components];
glw::GLfloat reference = (glw::GLfloat)(i);
if (fabs(result - reference) > 0.125 /* precision */)
{
is_ok = false;
break;
}
}
/* gl_Position */
glw::GLfloat result[4] = { results[(j + 1) * m_max_transform_feedback_components - 4],
results[(j + 1) * m_max_transform_feedback_components - 3],
results[(j + 1) * m_max_transform_feedback_components - 2],
results[(j + 1) * m_max_transform_feedback_components - 1] };
if ((fabs(fabs(result[0]) - 1.0 + s_rasterization_epsilon) > 0.125 /* precision */) ||
(fabs(fabs(result[1]) - 1.0 + s_rasterization_epsilon) > 0.125 /* precision */) ||
(fabs(result[2]) > 0.125 /* precision */) || (fabs(result[3] - 1.0) > 0.125 /* precision */))
{
is_ok = false;
break;
}
}
gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer call failed.");
return is_ok;
}
void gl3cts::TransformFeedback::CaptureVertexInterleaved::bindBuffer(BindBufferCase bind_case)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
switch (bind_case)
{
case BIND_BUFFER_BASE_CASE:
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_buffer);
break;
case BIND_BUFFER_RANGE_CASE:
gl.bindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_buffer, 0, m_buffer_size);
break;
case BIND_BUFFER_OFFSET_CASE:
if (DE_NULL == m_glBindBufferOffsetEXT)
{
throw 0;
}
m_glBindBufferOffsetEXT(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_buffer, 0);
break;
default:
throw 0;
}
}
void gl3cts::TransformFeedback::CaptureVertexInterleaved::clean(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
if (m_program)
{
gl.deleteProgram(m_program);
m_program = 0;
}
if (m_framebuffer)
{
gl.deleteFramebuffers(1, &m_framebuffer);
m_framebuffer = 0;
}
if (m_renderbuffer)
{
gl.deleteRenderbuffers(1, &m_renderbuffer);
m_renderbuffer = 0;
}
cleanBuffer();
if (m_vertex_array_object)
{
gl.deleteVertexArrays(1, &m_vertex_array_object);
m_vertex_array_object = 0;
}
}
void gl3cts::TransformFeedback::CaptureVertexInterleaved::cleanBuffer(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
if (m_buffer)
{
gl.deleteBuffers(1, &m_buffer);
m_buffer = 0;
}
}
const glw::GLchar* gl3cts::TransformFeedback::CaptureVertexInterleaved::s_vertex_shader_source_code_template =
"#version 130\n"
"\n"
"TEMPLATE_INPUT_OUTPUT_DECLARATIONS"
"\n"
"void main()\n"
"{\n"
"TEMPLATE_OUTPUT_SETTERS"
"\n"
" vec4 position = vec4(0.0);\n"
"\n"
" /* Note: The points are moved 0.0625 from the borders to\n"
" reduce non-XFB related rasterization problems. */\n"
" switch(gl_VertexID)\n"
" {\n"
" case 0:\n"
" position = vec4(-1.0 + TEMPLATE_RASTERIZATION_EPSILON, 1.0 - TEMPLATE_RASTERIZATION_EPSILON, 0.0, "
"1.0);\n"
" break;\n"
" case 1:\n"
" position = vec4( 1.0 - TEMPLATE_RASTERIZATION_EPSILON, 1.0 - TEMPLATE_RASTERIZATION_EPSILON, 0.0, "
"1.0);\n"
" break;\n"
" case 2:\n"
" position = vec4(-1.0 + TEMPLATE_RASTERIZATION_EPSILON, -1.0 + TEMPLATE_RASTERIZATION_EPSILON, 0.0, "
"1.0);\n"
" break;\n"
" case 3:\n"
" position = vec4( 1.0 - TEMPLATE_RASTERIZATION_EPSILON, -1.0 + TEMPLATE_RASTERIZATION_EPSILON, 0.0, "
"1.0);\n"
" break;\n"
" }\n"
"\n"
" gl_Position = position;\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::CaptureVertexInterleaved::s_fragment_shader_source_code =
"#version 130\n"
"\n"
"out vec4 color;\n"
"\n"
"void main()\n"
"{\n"
" color = vec4(0.5);\n"
"}\n";
const glw::GLuint
gl3cts::TransformFeedback::CaptureVertexInterleaved::s_element_indices[][s_max_element_indices_count] = {
{ 0, 1, 2, 3 }, { 0, 1, 2, 3 }, { 0, 1, 3, 2 }, { 0, 1, 3, 2 },
{ 2, 0, 1, 2, 1, 3 }, { 0, 1, 2, 3 }, { 2, 0, 1, 3 }
};
const glw::GLuint gl3cts::TransformFeedback::CaptureVertexInterleaved::s_primitive_cases_count =
sizeof(s_element_indices) / sizeof(s_element_indices[0]);
const glw::GLenum gl3cts::TransformFeedback::CaptureVertexInterleaved::s_primitive_cases[] = {
GL_POINTS, GL_LINES, GL_LINE_LOOP, GL_LINE_STRIP, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN
};
const glw::GLenum gl3cts::TransformFeedback::CaptureVertexInterleaved::s_primitive_cases_xfb[] = {
GL_POINTS, GL_LINES, GL_LINES, GL_LINES, GL_TRIANGLES, GL_TRIANGLES, GL_TRIANGLES
};
const glw::GLuint gl3cts::TransformFeedback::CaptureVertexInterleaved::s_element_indices_counts[] = { 4, 4, 4, 4,
6, 4, 4 };
const glw::GLuint gl3cts::TransformFeedback::CaptureVertexInterleaved::s_framebuffer_size =
2; /* If you change this, update checkFramebuffer function according. */
const glw::GLfloat gl3cts::TransformFeedback::CaptureVertexInterleaved::s_rasterization_epsilon = 0.0625;
/*-----------------------------------------------------------------------------------------------*/
gl3cts::TransformFeedback::CaptureGeometryInterleaved::CaptureGeometryInterleaved(deqp::Context& context,
const char* test_name,
const char* test_description)
: CaptureVertexInterleaved(context, test_name, test_description)
{
}
gl3cts::TransformFeedback::CaptureGeometryInterleaved::~CaptureGeometryInterleaved(void)
{
}
tcu::TestNode::IterateResult gl3cts::TransformFeedback::CaptureGeometryInterleaved::iterate(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Initializations. */
bool is_at_least_gl_30 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(3, 0)));
bool is_at_least_gl_32 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(3, 2)));
bool is_ext_tf_1 = m_context.getContextInfo().isExtensionSupported("GL_EXT_transform_feedback");
bool is_arb_gs_4 = m_context.getContextInfo().isExtensionSupported("GL_ARB_geometry_shader4");
bool is_ok = true;
bool test_error = false;
/* Tests. */
try
{
if ((is_at_least_gl_30 || is_ext_tf_1) && (is_at_least_gl_32 || is_arb_gs_4))
{
fetchLimits();
createFramebuffer();
createTransformFeedbackBuffer();
createVertexArrayObject();
for (glw::GLuint i_primitive_case = 0;
(i_primitive_case < s_geometry_interleaved_primitive_cases_count) && is_ok; ++i_primitive_case)
{
buildProgram(i_primitive_case);
gl.useProgram(m_program);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed.");
for (glw::GLint i_bind_case = 0; (i_bind_case < BIND_BUFFER_CASES_COUNT) && is_ok; ++i_bind_case)
{
if ((i_bind_case == BIND_BUFFER_OFFSET_CASE) && (DE_NULL == m_glBindBufferOffsetEXT))
{
continue;
}
bindBuffer((BindBufferCase)i_bind_case);
draw(i_primitive_case);
is_ok = is_ok && checkFramebuffer(s_primitive_cases[i_primitive_case]);
is_ok = is_ok &&
checkTransformFeedbackBuffer((BindBufferCase)i_bind_case,
s_geometry_interleaved_primitive_cases_xfb[i_primitive_case]);
}
gl.deleteProgram(m_program);
m_program = 0;
GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteProgram call failed.");
}
}
}
catch (...)
{
is_ok = false;
test_error = true;
}
/* Clean objects. */
clean();
/* Result's setup. */
if (is_ok)
{
/* Log success. */
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Capture Geometry have passed."
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
}
else
{
if (test_error)
{
m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
}
else
{
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
}
return STOP;
}
void gl3cts::TransformFeedback::CaptureGeometryInterleaved::fetchLimits(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Fetching limits. */
gl.getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS, &m_max_transform_feedback_components);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv call failed.");
if (m_max_transform_feedback_components == 0)
{
throw 0;
}
glw::GLint max_geometry_total_components = 0;
gl.getIntegerv(GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS, &max_geometry_total_components);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv call failed.");
if (max_geometry_total_components == 0)
{
throw 0;
}
if (m_max_transform_feedback_components * 4 > max_geometry_total_components)
{
m_max_transform_feedback_components = max_geometry_total_components / 4;
}
}
void gl3cts::TransformFeedback::CaptureGeometryInterleaved::buildProgram(glw::GLuint primitive_case)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Preparing source code. */
std::string geometry_shader(s_geometry_shader_source_code_template); /* Storage for vertex shader source code. */
std::string transform_feedback_variable_declarations(
""); /* String to contain all custom outputs from vertex shader. */
std::string transform_feedback_variable_setters(
""); /* String containing all initializations of custom outputs from vertex shader. */
std::vector<std::string> transform_feedback_varyings(m_max_transform_feedback_components); /* Varyings array. */
std::vector<const glw::GLchar*> transform_feedback_varyings_c(
m_max_transform_feedback_components); /* Varyings array in C form to pass to the GL. */
glw::GLint user_defined_transform_feedback_interleaved_varyings_count =
m_max_transform_feedback_components /* total max to be written by the shader */
/ 4 /* components per vec4 */
// / 4 /* number of vertices */
- 1 /* gl_Position */;
glw::GLint all_transform_feedback_interleaved_varyings_count =
user_defined_transform_feedback_interleaved_varyings_count + 1 /* gl_Position */;
/* Most of varyings is declarated output variables. */
for (glw::GLint i = 0; i < user_defined_transform_feedback_interleaved_varyings_count; ++i)
{
/* Preparing variable name. */
std::string varying = "result_";
varying.append(gl3cts::TransformFeedback::Utilities::itoa(i));
transform_feedback_varyings[i] = varying;
transform_feedback_varyings_c[i] = transform_feedback_varyings[i].c_str();
/* Preparing variable declaration. */
transform_feedback_variable_declarations.append("out vec4 ");
transform_feedback_variable_declarations.append(varying);
transform_feedback_variable_declarations.append(";\n");
/* Preparing variable setters. */
transform_feedback_variable_setters.append(" ");
transform_feedback_variable_setters.append(varying);
transform_feedback_variable_setters.append(" = vec4(");
transform_feedback_variable_setters.append(gl3cts::TransformFeedback::Utilities::itoa(i * 4));
transform_feedback_variable_setters.append(".0, ");
transform_feedback_variable_setters.append(gl3cts::TransformFeedback::Utilities::itoa(i * 4 + 1));
transform_feedback_variable_setters.append(".0, ");
transform_feedback_variable_setters.append(gl3cts::TransformFeedback::Utilities::itoa(i * 4 + 2));
transform_feedback_variable_setters.append(".0, ");
transform_feedback_variable_setters.append(gl3cts::TransformFeedback::Utilities::itoa(i * 4 + 3));
transform_feedback_variable_setters.append(".0);\n");
}
/* Last four varying components are gl_Position components. */
transform_feedback_varyings[user_defined_transform_feedback_interleaved_varyings_count /* gl_Position */] =
"gl_Position";
transform_feedback_varyings_c[user_defined_transform_feedback_interleaved_varyings_count /* gl_Position */] =
transform_feedback_varyings[user_defined_transform_feedback_interleaved_varyings_count /* gl_Position */]
.c_str();
/* Preprocess vertex shader source code template. */
geometry_shader = gl3cts::TransformFeedback::Utilities::preprocessCode(
geometry_shader, "TEMPLATE_PRIMITIVE_TYPE", s_geometry_interleaved_primitive_cases[primitive_case]);
geometry_shader = gl3cts::TransformFeedback::Utilities::preprocessCode(
geometry_shader, "TEMPLATE_INPUT_OUTPUT_DECLARATIONS", transform_feedback_variable_declarations);
geometry_shader = gl3cts::TransformFeedback::Utilities::preprocessCode(geometry_shader, "TEMPLATE_OUTPUT_SETTERS",
transform_feedback_variable_setters);
geometry_shader = gl3cts::TransformFeedback::Utilities::preprocessCode(
geometry_shader, "TEMPLATE_RASTERIZATION_EPSILON",
gl3cts::TransformFeedback::Utilities::ftoa(s_rasterization_epsilon));
/* Compile, link and check. */
m_program = gl3cts::TransformFeedback::Utilities::buildProgram(
gl, m_context.getTestContext().getLog(), geometry_shader.c_str(), NULL, NULL, s_blank_vertex_shader_source_code,
s_fragment_shader_source_code, &transform_feedback_varyings_c[0],
all_transform_feedback_interleaved_varyings_count, m_attrib_type);
if (0 == m_program)
{
throw 0;
}
}
void gl3cts::TransformFeedback::CaptureGeometryInterleaved::draw(glw::GLuint primitive_case)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.clear(GL_COLOR_BUFFER_BIT);
GLU_EXPECT_NO_ERROR(gl.getError(), "glClear call failed.");
gl.beginTransformFeedback(s_geometry_interleaved_primitive_cases_xfb[primitive_case]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback call failed.");
gl.drawArrays(GL_POINTS, 0, 1);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays call failed.");
gl.endTransformFeedback();
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedbac call failed.");
}
const glw::GLchar* gl3cts::TransformFeedback::CaptureGeometryInterleaved::s_geometry_shader_source_code_template =
"#version 150\n"
"\n"
"layout(points) in;\n"
"layout(TEMPLATE_PRIMITIVE_TYPE, max_vertices = 4) out;\n"
"\n"
"TEMPLATE_INPUT_OUTPUT_DECLARATIONS"
"\n"
"void main()\n"
"{\n"
" /* Note: The points are moved 0.0625 from the borders to\n"
" reduce non-XFB related rasterization problems. */\n"
"\n"
" gl_Position = vec4(-1.0 + TEMPLATE_RASTERIZATION_EPSILON, 1.0 - TEMPLATE_RASTERIZATION_EPSILON, 0.0, "
"1.0);\n"
"TEMPLATE_OUTPUT_SETTERS"
" EmitVertex();\n"
"\n"
" gl_Position = vec4( 1.0 - TEMPLATE_RASTERIZATION_EPSILON, 1.0 - TEMPLATE_RASTERIZATION_EPSILON, 0.0, "
"1.0);\n"
"TEMPLATE_OUTPUT_SETTERS"
" EmitVertex();\n"
"\n"
" gl_Position = vec4(-1.0 + TEMPLATE_RASTERIZATION_EPSILON, -1.0 + TEMPLATE_RASTERIZATION_EPSILON, 0.0, "
"1.0);\n"
"TEMPLATE_OUTPUT_SETTERS"
" EmitVertex();\n"
"\n"
" gl_Position = vec4( 1.0 - TEMPLATE_RASTERIZATION_EPSILON, -1.0 + TEMPLATE_RASTERIZATION_EPSILON, 0.0, "
"1.0);\n"
"TEMPLATE_OUTPUT_SETTERS"
" EmitVertex();\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::CaptureGeometryInterleaved::s_blank_vertex_shader_source_code =
"#version 130\n"
"\n"
"void main()\n"
"{\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::CaptureGeometryInterleaved::s_geometry_interleaved_primitive_cases[] = {
"points", "line_strip", "triangle_strip"
};
const glw::GLenum gl3cts::TransformFeedback::CaptureGeometryInterleaved::s_geometry_interleaved_primitive_cases_xfb[] =
{ GL_POINTS, GL_LINES, GL_TRIANGLES };
const glw::GLuint gl3cts::TransformFeedback::CaptureGeometryInterleaved::s_geometry_interleaved_primitive_cases_count =
sizeof(s_geometry_interleaved_primitive_cases) / sizeof(s_geometry_interleaved_primitive_cases[0]);
/*-----------------------------------------------------------------------------------------------*/
gl3cts::TransformFeedback::CaptureVertexSeparate::CaptureVertexSeparate(deqp::Context& context, const char* test_name,
const char* test_description)
: CaptureVertexInterleaved(context, test_name, test_description)
, m_buffers(DE_NULL)
, m_max_transform_feedback_separate_attribs(0)
{
m_attrib_type = GL_SEPARATE_ATTRIBS;
}
void gl3cts::TransformFeedback::CaptureVertexSeparate::fetchLimits(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Fetching limits. */
glw::GLint max_transform_feedback_separate_components;
gl.getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS, &max_transform_feedback_separate_components);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv call failed.");
if (max_transform_feedback_separate_components < 4)
{
throw 0;
}
gl.getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &m_max_transform_feedback_separate_attribs);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv call failed.");
if (m_max_transform_feedback_separate_attribs == 0)
{
throw 0;
}
m_max_transform_feedback_components = m_max_transform_feedback_separate_attribs * 4 /* vec4 is used */;
glw::GLint max_varyings_components = 0;
gl.getIntegerv(GL_MAX_VARYING_COMPONENTS, &max_varyings_components);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv call failed.");
if (max_varyings_components == 0)
{
throw 0;
}
if (m_max_transform_feedback_components > max_varyings_components)
{
m_max_transform_feedback_components = max_varyings_components;
}
}
void gl3cts::TransformFeedback::CaptureVertexSeparate::createTransformFeedbackBuffer(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
m_buffers = new glw::GLuint[m_max_transform_feedback_components];
if (DE_NULL == m_buffers)
{
throw 0;
}
gl.genBuffers(m_max_transform_feedback_separate_attribs, m_buffers);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers call failed.");
m_buffer_size = static_cast<glw::GLuint>(m_max_vertices_drawn * 4 /* vec4 */ * sizeof(glw::GLfloat));
for (glw::GLint i = 0; i < m_max_transform_feedback_separate_attribs; ++i)
{
gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_buffers[i]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, m_buffer_size, NULL, GL_DYNAMIC_READ);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData call failed.");
}
}
void gl3cts::TransformFeedback::CaptureVertexSeparate::bindBuffer(BindBufferCase bind_case)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
switch (bind_case)
{
case BIND_BUFFER_BASE_CASE:
for (glw::GLint i = 0; i < m_max_transform_feedback_separate_attribs; ++i)
{
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, i, m_buffers[i]);
}
break;
case BIND_BUFFER_RANGE_CASE:
for (glw::GLint i = 0; i < m_max_transform_feedback_separate_attribs; ++i)
{
gl.bindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, i, m_buffers[i], 0, m_buffer_size);
}
break;
case BIND_BUFFER_OFFSET_CASE:
for (glw::GLint i = 0; i < m_max_transform_feedback_separate_attribs; ++i)
{
m_glBindBufferOffsetEXT(GL_TRANSFORM_FEEDBACK_BUFFER, i, m_buffers[i], 0);
}
break;
default:
throw 0;
}
}
void gl3cts::TransformFeedback::CaptureVertexSeparate::cleanBuffer(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
if (DE_NULL != m_buffers)
{
gl.deleteBuffers(m_max_transform_feedback_separate_attribs, m_buffers);
delete[] m_buffers;
m_buffers = DE_NULL;
}
}
bool gl3cts::TransformFeedback::CaptureVertexSeparate::checkTransformFeedbackBuffer(BindBufferCase bind_case UNUSED,
glw::GLenum primitive_type)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
glw::GLuint number_of_vertices = 0;
switch (primitive_type)
{
case GL_POINTS:
number_of_vertices = 4;
break;
case GL_LINES:
number_of_vertices = 4;
break;
case GL_LINE_LOOP:
number_of_vertices = 8;
break;
case GL_LINE_STRIP:
number_of_vertices = 6;
break;
case GL_TRIANGLES:
number_of_vertices = 6;
break;
case GL_TRIANGLE_STRIP:
number_of_vertices = 6;
break;
case GL_TRIANGLE_FAN:
number_of_vertices = 6;
break;
default:
throw 0;
}
bool is_ok = true;
for (glw::GLint i = 0; i < m_max_transform_feedback_separate_attribs - 1; ++i)
{
gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_buffers[i]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
glw::GLfloat* results = (glw::GLfloat*)gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY);
GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBuffer call failed.");
for (glw::GLuint j = 0; (j < number_of_vertices) && is_ok; ++j)
{
for (glw::GLuint k = 0; k < 4 /* vec4 */; ++k)
{
glw::GLfloat result = results[j * 4 + k];
glw::GLfloat reference = (glw::GLfloat)(i * 4 + k);
if (fabs(result - reference) > 0.125 /* precision */)
{
is_ok = false;
break;
}
}
}
gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer call failed.");
}
/* gl_Position */
if (is_ok)
{
gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_buffers[m_max_transform_feedback_separate_attribs - 1]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
glw::GLfloat* results = (glw::GLfloat*)gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY);
GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBuffer call failed.");
for (glw::GLuint j = 0; (j < number_of_vertices) && is_ok; ++j)
{
glw::GLfloat result[4] = { results[j * 4], results[j * 4 + 1], results[j * 4 + 2], results[j * 4 + 3] };
if ((fabs(fabs(result[0]) - 1.0 + s_rasterization_epsilon) > 0.125 /* precision */) ||
(fabs(fabs(result[1]) - 1.0 + s_rasterization_epsilon) > 0.125 /* precision */) ||
(fabs(result[2]) > 0.125 /* precision */) || (fabs(result[3] - 1.0) > 0.125 /* precision */))
{
is_ok = false;
break;
}
}
gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer call failed.");
}
return is_ok;
}
/*-----------------------------------------------------------------------------------------------*/
gl3cts::TransformFeedback::CaptureGeometrySeparate::CaptureGeometrySeparate(deqp::Context& context,
const char* test_name,
const char* test_description)
: CaptureVertexInterleaved(context, test_name, test_description)
, CaptureVertexSeparate(context, test_name, test_description)
, CaptureGeometryInterleaved(context, test_name, test_description)
, m_buffers(DE_NULL)
, m_max_transform_feedback_separate_attribs(0)
{
}
/*-----------------------------------------------------------------------------------------------*/
gl3cts::TransformFeedback::CheckGetXFBVarying::CheckGetXFBVarying(deqp::Context& context, const char* test_name,
const char* test_description)
: deqp::TestCase(context, test_name, test_description)
, m_context(context)
, m_max_xfb_interleaved_components(0)
, m_max_xfb_separate_attributes(0)
, m_max_xfb_separate_components(0)
, m_max_varying_components(0)
, m_max_varying_vectors(0)
, m_max_geometry_total_output_components(0)
{
}
gl3cts::TransformFeedback::CheckGetXFBVarying::~CheckGetXFBVarying(void)
{
}
void gl3cts::TransformFeedback::CheckGetXFBVarying::fetchLimits(void)
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Fetching limits. */
gl.getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS, &m_max_xfb_interleaved_components);
gl.getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &m_max_xfb_separate_attributes);
gl.getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS, &m_max_xfb_separate_components);
gl.getIntegerv(GL_MAX_VARYING_COMPONENTS, &m_max_varying_components);
gl.getIntegerv(GL_MAX_VARYING_VECTORS, &m_max_varying_vectors);
gl.getIntegerv(GL_MAX_GEOMETRY_OUTPUT_COMPONENTS, &m_max_geometry_total_output_components);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv call failed.");
}
glw::GLuint gl3cts::TransformFeedback::CheckGetXFBVarying::numberOfAttributes(glw::GLuint capture_way,
glw::GLuint shader_case,
glw::GLuint varying_type)
{
/* Setup limits of the case. */
const glw::GLuint max_total_components =
((s_shader_cases[shader_case].geometry_shader == DE_NULL) ? m_max_varying_components :
m_max_geometry_total_output_components) -
4 /* gl_Position is not captured */;
const glw::GLuint attribute_components = s_varying_types[varying_type].components_count;
const glw::GLuint max_xfb_components = (s_capture_ways[capture_way] == GL_INTERLEAVED_ATTRIBS) ?
m_max_xfb_interleaved_components :
(attribute_components * m_max_xfb_separate_components);
if (s_capture_ways[capture_way] == GL_SEPARATE_ATTRIBS)
{
if (attribute_components > glw::GLuint(m_max_xfb_separate_components))
{
return 0;
}
}
/* Setup number of attributes. */
glw::GLuint number_of_attributes = max_xfb_components / attribute_components;
if (s_capture_ways[capture_way] == GL_SEPARATE_ATTRIBS &&
number_of_attributes > glw::GLuint(m_max_xfb_separate_attributes))
{
number_of_attributes = m_max_xfb_separate_attributes;
}
/* Clamp to limits. */
if (number_of_attributes * attribute_components > max_total_components)
{
number_of_attributes = max_total_components / attribute_components;
}
/* Vectors limit. */
if (attribute_components <= 4)
{
if (number_of_attributes > glw::GLuint(m_max_varying_vectors))
{
number_of_attributes = m_max_varying_vectors;
}
}
else
{
if (number_of_attributes > glw::GLuint(m_max_varying_vectors) / 4)
{
number_of_attributes = glw::GLuint(m_max_varying_vectors) / 4;
}
}
/* Return. */
return number_of_attributes;
}
tcu::TestNode::IterateResult gl3cts::TransformFeedback::CheckGetXFBVarying::iterate(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Initializations. */
bool is_at_least_gl_30 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(3, 0)));
bool is_ext_tf_1 = m_context.getContextInfo().isExtensionSupported("GL_EXT_transform_feedback");
bool is_ok = true;
bool test_error = false;
glw::GLuint program = 0;
/* Tests. */
try
{
if (is_at_least_gl_30 || is_ext_tf_1)
{
fetchLimits();
for (glw::GLuint i = 0; (i < s_capture_ways_count) && is_ok; ++i)
{
for (glw::GLuint j = 0; (j < s_shader_cases_count) && is_ok; ++j)
{
for (glw::GLuint k = 0; (k < s_varying_types_count) && is_ok; ++k)
{
glw::GLuint n = numberOfAttributes(i, j, k);
if (n)
{
program = buildProgram(i, j, k, n);
is_ok = is_ok && (program != 0);
is_ok = is_ok && check(program, i, j, k, n);
gl.deleteProgram(program);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteProgram call failed.");
program = 0;
}
}
}
}
}
}
catch (...)
{
is_ok = false;
test_error = true;
if (program)
{
gl.deleteProgram(program);
program = 0;
}
}
/* Result's setup. */
if (is_ok)
{
/* Log success. */
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "Test checking Get Transform Feedback Varying have passed."
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
}
else
{
if (test_error)
{
m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
}
else
{
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
}
return STOP;
}
glw::GLuint gl3cts::TransformFeedback::CheckGetXFBVarying::buildProgram(glw::GLuint capture_way,
glw::GLuint shader_case,
glw::GLuint varying_type,
glw::GLuint number_of_attributes)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Preparing source code. */
std::string xfb_variable_declarations("");
std::string xfb_variable_setters("");
std::vector<std::string> xfb_varyings(number_of_attributes);
std::vector<const glw::GLchar*> xfb_varyings_c(number_of_attributes);
/* Most of varyings is declarated output variables. */
for (glw::GLuint i = 0; i < number_of_attributes; ++i)
{
/* Varying name: result_# */
std::string varying = "result_";
varying.append(gl3cts::TransformFeedback::Utilities::itoa(i));
xfb_varyings[i] = varying;
xfb_varyings_c[i] = xfb_varyings[i].c_str();
/* Varying declaration: out TYPE result_#;*/
xfb_variable_declarations.append("out ");
xfb_variable_declarations.append(s_varying_types[varying_type].name);
xfb_variable_declarations.append(" ");
xfb_variable_declarations.append(varying);
xfb_variable_declarations.append(";\n");
/* Varying setter: result_# = TYPE(#); */
xfb_variable_setters.append(" ");
xfb_variable_setters.append(varying);
xfb_variable_setters.append(" = ");
xfb_variable_setters.append(s_varying_types[varying_type].name);
xfb_variable_setters.append("(");
xfb_variable_setters.append("2"); //gl3cts::TransformFeedback::Utilities::itoa(i));
if (s_varying_types[varying_type].float_component)
{
/* if varying is float varying setter is: result_# = TYPE(#.0); */
xfb_variable_setters.append(".0");
}
xfb_variable_setters.append(");\n");
}
/* Preprocess vertex shader source code template. */
const glw::GLchar* vertex_shader = s_shader_cases[shader_case].vertex_shader;
const glw::GLchar* geometry_shader = s_shader_cases[shader_case].geometry_shader;
std::string xfb_shader;
if (DE_NULL == s_shader_cases[shader_case].geometry_shader)
{
/* XFB tested in vertex shader. */
xfb_shader = vertex_shader;
}
else
{
/* XFB tested in geometry shader. */
xfb_shader = geometry_shader;
}
/* Preprocess shader. */
xfb_shader = gl3cts::TransformFeedback::Utilities::preprocessCode(xfb_shader, "TEMPLATE_OUTPUT_DECLARATIONS",
xfb_variable_declarations);
xfb_shader = gl3cts::TransformFeedback::Utilities::preprocessCode(xfb_shader, "TEMPLATE_OUTPUT_SETTERS",
xfb_variable_setters);
if (DE_NULL == s_shader_cases[shader_case].geometry_shader)
{
/* XFB tested in vertex shader. */
vertex_shader = xfb_shader.c_str();
}
else
{
/* XFB tested in geometry shader. */
geometry_shader = xfb_shader.c_str();
}
/* Compile, link and check. */
glw::GLuint program = gl3cts::TransformFeedback::Utilities::buildProgram(
gl, m_context.getTestContext().getLog(), geometry_shader, NULL, NULL, vertex_shader, s_generic_fragment_shader,
&xfb_varyings_c[0], number_of_attributes, s_capture_ways[capture_way]);
/* Check compilation status. */
if (0 == program)
{
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Building program has failed.\nVertex shader:\n"
<< vertex_shader << "Geometry shader:\n"
<< ((DE_NULL == geometry_shader) ? "" : geometry_shader)
<< "Fragment shader:\n"
<< s_generic_fragment_shader << tcu::TestLog::EndMessage;
throw 0;
}
return program;
}
bool gl3cts::TransformFeedback::CheckGetXFBVarying::check(glw::GLuint program, glw::GLuint capture_way,
glw::GLuint shader_case UNUSED, glw::GLuint varying_type,
glw::GLuint number_of_attributes)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
glw::GLuint max_length = 0;
/* Inspect glGetTransformFeedbackVarying. */
for (glw::GLuint i = 0; i < number_of_attributes; ++i)
{
const glw::GLsizei bufSize = 18;
glw::GLsizei length = 0;
glw::GLsizei size = 0;
glw::GLenum type = GL_NONE;
glw::GLchar name[18] = { 0 }; /* Size of bufSize. */
gl.getTransformFeedbackVarying(program, i, bufSize, &length, &size, &type, name);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTransformFeedbackVarying call failed.");
max_length = deMaxu32(max_length, glw::GLuint(length));
/* Check name. */
if (length)
{
std::string varying = name;
std::string varying_ref = "result_";
varying_ref.append(gl3cts::TransformFeedback::Utilities::itoa(i));
if (0 != varying.compare(varying_ref))
{
return false;
}
}
else
{
return false;
}
/* Check size. */
const glw::GLuint size_ref = 1;
if (size != size_ref)
{
return false;
}
/* Check type. */
if (type != s_varying_types[varying_type].type)
{
return false;
}
}
/* Inspect glGetProgramiv. */
glw::GLint xfb_varyings = 0;
glw::GLint xfb_mode = 0;
glw::GLint xfb_varying_max_length = 0;
gl.getProgramiv(program, GL_TRANSFORM_FEEDBACK_VARYINGS, &xfb_varyings);
gl.getProgramiv(program, GL_TRANSFORM_FEEDBACK_BUFFER_MODE, &xfb_mode);
gl.getProgramiv(program, GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH, &xfb_varying_max_length);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv call failed.");
if (glw::GLuint(xfb_varyings) != number_of_attributes)
{
return false;
}
if (glw::GLenum(xfb_mode) != s_capture_ways[capture_way])
{
return false;
}
if (glw::GLuint(xfb_varying_max_length) < max_length)
{
return false;
}
return true;
}
const glw::GLchar* gl3cts::TransformFeedback::CheckGetXFBVarying::s_generic_fragment_shader = "#version 130\n"
"\n"
"out vec4 color;\n"
"\n"
"void main()\n"
"{\n"
" color = vec4(1.0);\n"
"}\n";
const struct gl3cts::TransformFeedback::CheckGetXFBVarying::ShaderCase
gl3cts::TransformFeedback::CheckGetXFBVarying::s_shader_cases[] = { { /* Vertex Shader. */
"#version 130\n"
"\n"
"TEMPLATE_OUTPUT_DECLARATIONS"
"\n"
"void main()\n"
"{\n"
" gl_Position = vec4(1.0);\n"
"TEMPLATE_OUTPUT_SETTERS"
"}\n",
/* Geometry Shader. */
NULL },
{ /* Vertex Shader. */
"#version 130\n"
"\n"
"void main()\n"
"{\n"
"}\n",
/* Geometry Shader. */
"#version 150\n"
"\n"
"layout(points) in;\n"
"layout(points, max_vertices = 1) out;\n"
"\n"
"TEMPLATE_OUTPUT_DECLARATIONS"
"\n"
"void main()\n"
"{\n"
" gl_Position = vec4(1.0);\n"
"TEMPLATE_OUTPUT_SETTERS"
" EmitVertex();\n"
"}\n" } };
const glw::GLuint gl3cts::TransformFeedback::CheckGetXFBVarying::s_shader_cases_count =
sizeof(s_shader_cases) / sizeof(s_shader_cases[0]);
const struct gl3cts::TransformFeedback::CheckGetXFBVarying::VaryingType
gl3cts::TransformFeedback::CheckGetXFBVarying::s_varying_types[] = {
/* type, name, #components, is component float */
{ GL_FLOAT, "float", 1, true },
{ GL_FLOAT_VEC2, "vec2", 2, true },
{ GL_FLOAT_VEC3, "vec3", 3, true },
{ GL_FLOAT_VEC4, "vec4", 4, true },
{ GL_INT, "int", 1, false },
{ GL_INT_VEC2, "ivec2", 2, false },
{ GL_INT_VEC3, "ivec3", 3, false },
{ GL_INT_VEC4, "ivec4", 4, false },
{ GL_UNSIGNED_INT, "uint", 1, false },
{ GL_UNSIGNED_INT_VEC2, "uvec2", 2, false },
{ GL_UNSIGNED_INT_VEC3, "uvec3", 3, false },
{ GL_UNSIGNED_INT_VEC4, "uvec4", 4, false },
{ GL_FLOAT_MAT2, "mat2", 4, true },
{ GL_FLOAT_MAT3, "mat3", 9, true },
{ GL_FLOAT_MAT4, "mat4", 16, true }
};
const glw::GLuint gl3cts::TransformFeedback::CheckGetXFBVarying::s_varying_types_count =
sizeof(s_varying_types) / sizeof(s_varying_types[0]);
const glw::GLenum gl3cts::TransformFeedback::CheckGetXFBVarying::s_capture_ways[] = { GL_INTERLEAVED_ATTRIBS,
GL_SEPARATE_ATTRIBS };
const glw::GLuint gl3cts::TransformFeedback::CheckGetXFBVarying::s_capture_ways_count =
sizeof(s_capture_ways) / sizeof(s_capture_ways[0]);
/*-----------------------------------------------------------------------------------------------*/
gl3cts::TransformFeedback::QueryVertexInterleaved::QueryVertexInterleaved(deqp::Context& context, const char* test_name,
const char* test_description)
: CaptureVertexInterleaved(context, test_name, test_description), m_query_object(0)
{
m_max_vertices_drawn = 3; /* Make buffer smaller up to 3 vertices. */
}
void gl3cts::TransformFeedback::QueryVertexInterleaved::createTransformFeedbackBuffer(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Create buffer object. */
gl3cts::TransformFeedback::CaptureVertexInterleaved::createTransformFeedbackBuffer();
/* Create query object. */
gl.genQueries(1, &m_query_object);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenQueries call failed.");
}
void gl3cts::TransformFeedback::QueryVertexInterleaved::draw(glw::GLuint primitive_case)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.beginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, m_query_object);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginQuery call failed.");
gl3cts::TransformFeedback::CaptureVertexInterleaved::draw(primitive_case);
gl.endQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndQuery call failed.");
}
bool gl3cts::TransformFeedback::QueryVertexInterleaved::checkTransformFeedbackBuffer(BindBufferCase bind_case UNUSED,
glw::GLenum primitive_type)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
glw::GLuint number_of_primitives;
gl.getQueryObjectuiv(m_query_object, GL_QUERY_RESULT, &number_of_primitives);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetQueryObjectuiv call failed.");
/* expected result */
glw::GLuint number_of_primitives_reference = (primitive_type == GL_POINTS) ? 3 : 1; /* m_max_vertices_drawn == 3 */
if (number_of_primitives_reference != number_of_primitives)
{
return false;
}
return true;
}
void gl3cts::TransformFeedback::QueryVertexInterleaved::clean(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Delete query object. */
gl.deleteQueries(1, &m_query_object);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteQueries call failed.");
/* Other */
gl3cts::TransformFeedback::CaptureVertexInterleaved::clean();
}
/*-----------------------------------------------------------------------------------------------*/
gl3cts::TransformFeedback::QueryGeometryInterleaved::QueryGeometryInterleaved(deqp::Context& context,
const char* test_name,
const char* test_description)
: CaptureVertexInterleaved(context, test_name, test_description)
, CaptureGeometryInterleaved(context, test_name, test_description)
{
m_query_object = 0;
m_max_vertices_drawn = 3; /* Make buffer smaller up to 3 vertices. */
}
void gl3cts::TransformFeedback::QueryGeometryInterleaved::createTransformFeedbackBuffer(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Create buffer object. */
gl3cts::TransformFeedback::CaptureGeometryInterleaved::createTransformFeedbackBuffer();
/* Create query object. */
gl.genQueries(1, &m_query_object);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenQueries call failed.");
}
void gl3cts::TransformFeedback::QueryGeometryInterleaved::draw(glw::GLuint primitive_case)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.beginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, m_query_object);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginQuery call failed.");
gl3cts::TransformFeedback::CaptureGeometryInterleaved::draw(primitive_case);
gl.endQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndQuery call failed.");
}
bool gl3cts::TransformFeedback::QueryGeometryInterleaved::checkTransformFeedbackBuffer(BindBufferCase bind_case UNUSED,
glw::GLenum primitive_type)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
glw::GLuint number_of_primitives;
gl.getQueryObjectuiv(m_query_object, GL_QUERY_RESULT, &number_of_primitives);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetQueryObjectuiv call failed.");
/* expected result */
glw::GLuint number_of_primitives_reference = (primitive_type == GL_POINTS) ? 3 : 1; /* m_max_vertices_drawn == 3 */
if (number_of_primitives_reference != number_of_primitives)
{
return false;
}
return true;
}
void gl3cts::TransformFeedback::QueryGeometryInterleaved::clean(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Delete query object. */
gl.deleteQueries(1, &m_query_object);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteQueries call failed.");
/* Other. */
gl3cts::TransformFeedback::CaptureGeometryInterleaved::clean();
}
/*-----------------------------------------------------------------------------------------------*/
gl3cts::TransformFeedback::QueryVertexSeparate::QueryVertexSeparate(deqp::Context& context, const char* test_name,
const char* test_description)
: CaptureVertexInterleaved(context, test_name, test_description)
, CaptureVertexSeparate(context, test_name, test_description)
{
m_query_object = 0;
m_max_vertices_drawn = 3; /* Make buffer smaller up to 3 vertices. */
}
void gl3cts::TransformFeedback::QueryVertexSeparate::createTransformFeedbackBuffer(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Create buffer object. */
gl3cts::TransformFeedback::CaptureVertexSeparate::createTransformFeedbackBuffer();
/* Create query object. */
gl.genQueries(1, &m_query_object);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenQueries call failed.");
}
void gl3cts::TransformFeedback::QueryVertexSeparate::draw(glw::GLuint primitive_case)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.beginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, m_query_object);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginQuery call failed.");
gl3cts::TransformFeedback::CaptureVertexSeparate::draw(primitive_case);
gl.endQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndQuery call failed.");
}
bool gl3cts::TransformFeedback::QueryVertexSeparate::checkTransformFeedbackBuffer(BindBufferCase bind_case UNUSED,
glw::GLenum primitive_type)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
glw::GLuint number_of_primitives;
gl.getQueryObjectuiv(m_query_object, GL_QUERY_RESULT, &number_of_primitives);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetQueryObjectuiv call failed.");
/* expected result */
glw::GLuint number_of_primitives_reference = (primitive_type == GL_POINTS) ? 3 : 1; /* m_max_vertices_drawn == 3 */
if (number_of_primitives_reference != number_of_primitives)
{
return false;
}
return true;
}
void gl3cts::TransformFeedback::QueryVertexSeparate::clean(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Delete query object. */
gl.deleteQueries(1, &m_query_object);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteQueries call failed.");
/* Other */
gl3cts::TransformFeedback::CaptureVertexSeparate::clean();
}
/*-----------------------------------------------------------------------------------------------*/
gl3cts::TransformFeedback::QueryGeometrySeparate::QueryGeometrySeparate(deqp::Context& context, const char* test_name,
const char* test_description)
: CaptureVertexInterleaved(context, test_name, test_description)
, CaptureVertexSeparate(context, test_name, test_description)
, CaptureGeometrySeparate(context, test_name, test_description)
{
m_query_object = 0;
m_max_vertices_drawn = 3; /* Make buffer smaller up to 3 vertices. */
}
void gl3cts::TransformFeedback::QueryGeometrySeparate::createTransformFeedbackBuffer(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Create buffer object. */
gl3cts::TransformFeedback::CaptureGeometrySeparate::createTransformFeedbackBuffer();
/* Create query object. */
gl.genQueries(1, &m_query_object);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenQueries call failed.");
}
void gl3cts::TransformFeedback::QueryGeometrySeparate::draw(glw::GLuint primitive_case)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.beginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, m_query_object);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginQuery call failed.");
gl3cts::TransformFeedback::CaptureGeometrySeparate::draw(primitive_case);
gl.endQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndQuery call failed.");
}
bool gl3cts::TransformFeedback::QueryGeometrySeparate::checkTransformFeedbackBuffer(BindBufferCase bind_case UNUSED,
glw::GLenum primitive_type)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
glw::GLuint number_of_primitives;
gl.getQueryObjectuiv(m_query_object, GL_QUERY_RESULT, &number_of_primitives);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetQueryObjectuiv call failed.");
/* expected result */
glw::GLuint number_of_primitives_reference = (primitive_type == GL_POINTS) ? 3 : 1; /* m_max_vertices_drawn == 3 */
if (number_of_primitives_reference != number_of_primitives)
{
return false;
}
return true;
}
void gl3cts::TransformFeedback::QueryGeometrySeparate::clean(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Delete query object. */
gl.deleteQueries(1, &m_query_object);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteQueries call failed.");
/* Other */
gl3cts::TransformFeedback::CaptureGeometrySeparate::clean();
}
/*-----------------------------------------------------------------------------------------------*/
gl3cts::TransformFeedback::DiscardVertex::DiscardVertex(deqp::Context& context, const char* test_name,
const char* test_description)
: CaptureVertexInterleaved(context, test_name, test_description)
{
}
void gl3cts::TransformFeedback::DiscardVertex::draw(glw::GLuint primitive_case)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Must clear before rasterizer discard */
gl.clear(GL_COLOR_BUFFER_BIT);
GLU_EXPECT_NO_ERROR(gl.getError(), "glClear call failed.");
gl.enable(GL_RASTERIZER_DISCARD);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable call failed.");
gl3cts::TransformFeedback::CaptureVertexInterleaved::draw(primitive_case);
gl.disable(GL_RASTERIZER_DISCARD);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDisable call failed.");
}
bool gl3cts::TransformFeedback::DiscardVertex::checkFramebuffer(glw::GLuint primitive_case UNUSED)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Fetch framebuffer. */
std::vector<glw::GLfloat> pixels(s_framebuffer_size * s_framebuffer_size);
if (s_framebuffer_size > 0)
{
gl.readPixels(0, 0, s_framebuffer_size, s_framebuffer_size, GL_RED, GL_FLOAT, pixels.data());
GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels call failed.");
}
/* Check results.
Note: assuming that s_buffer_size == 2 -> then all points shall be drawn. */
for (std::vector<glw::GLfloat>::iterator i = pixels.begin(); i != pixels.end(); ++i)
{
if (fabs(*i) > 0.0625f /* precision */)
{
return false;
}
}
return true;
}
/*-----------------------------------------------------------------------------------------------*/
gl3cts::TransformFeedback::DiscardGeometry::DiscardGeometry(deqp::Context& context, const char* test_name,
const char* test_description)
: CaptureVertexInterleaved(context, test_name, test_description)
, CaptureGeometryInterleaved(context, test_name, test_description)
{
}
void gl3cts::TransformFeedback::DiscardGeometry::draw(glw::GLuint primitive_case)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Must clear before rasterizer discard */
gl.clear(GL_COLOR_BUFFER_BIT);
GLU_EXPECT_NO_ERROR(gl.getError(), "glClear call failed.");
gl.enable(GL_RASTERIZER_DISCARD);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable call failed.");
gl3cts::TransformFeedback::CaptureGeometryInterleaved::draw(primitive_case);
gl.disable(GL_RASTERIZER_DISCARD);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDisable call failed.");
}
bool gl3cts::TransformFeedback::DiscardGeometry::checkFramebuffer(glw::GLuint primitive_case UNUSED)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Fetch framebuffer. */
std::vector<glw::GLfloat> pixels(s_framebuffer_size * s_framebuffer_size);
if (s_framebuffer_size > 0)
{
gl.readPixels(0, 0, s_framebuffer_size, s_framebuffer_size, GL_RED, GL_FLOAT, pixels.data());
GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels call failed.");
}
/* Check results.
Note: assuming that s_buffer_size == 2 -> then all points shall be drawn. */
for (std::vector<glw::GLfloat>::iterator i = pixels.begin(); i != pixels.end(); ++i)
{
if (fabs(*i) > 0.0625f /* precision */)
{
return false;
}
}
return true;
}
/*-----------------------------------------------------------------------------------------------*/
gl3cts::TransformFeedback::DrawXFB::DrawXFB(deqp::Context& context, const char* test_name, const char* test_description)
: deqp::TestCase(context, test_name, test_description)
, m_context(context)
, m_program_id_xfb(0)
, m_program_id_draw(0)
, m_fbo_id(0)
, m_rbo_id(0)
, m_vao_id(0)
{
memset(m_xfb_id, 0, sizeof(m_xfb_id));
memset(m_bo_id, 0, sizeof(m_bo_id));
}
gl3cts::TransformFeedback::DrawXFB::~DrawXFB(void)
{
}
tcu::TestNode::IterateResult gl3cts::TransformFeedback::DrawXFB::iterate(void)
{
/* Initializations. */
bool is_at_least_gl_40 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 0)));
bool is_arb_tf_2 = m_context.getContextInfo().isExtensionSupported("GL_ARB_transform_feedback2");
bool is_ok = true;
bool test_error = false;
/* Tests. */
try
{
if (is_at_least_gl_40 || is_arb_tf_2)
{
for (glw::GLuint i = 0; (i < s_capture_modes_count) && is_ok; ++i)
{
prepare(s_capture_modes[i]);
bindVAO(m_vao_id);
useProgram(m_program_id_xfb);
for (glw::GLuint j = 0; (j < s_xfb_count) && is_ok; ++j)
{
bindXFB(m_xfb_id[j]);
bindBOForXFB(s_capture_modes[i], m_bo_id[j]);
useColour(m_program_id_xfb, s_colours[j][0], s_colours[j][1], s_colours[j][2], s_colours[j][3]);
useGeometrySet(m_program_id_xfb, false);
drawForCapture(true, true, false, false);
is_ok = is_ok && inspectXFBState(true, true);
}
for (glw::GLuint j = 0; (j < s_xfb_count) && is_ok; ++j)
{
bindXFB(m_xfb_id[j]);
useColour(m_program_id_xfb, s_colours[j][0], s_colours[j][1], s_colours[j][2], s_colours[j][3]);
useGeometrySet(m_program_id_xfb, true);
drawForCapture(false, false, true, true);
is_ok = is_ok && inspectXFBState(false, false);
}
useProgram(m_program_id_draw);
for (glw::GLuint j = 0; (j < s_xfb_count) && is_ok; ++j)
{
bindXFB(m_xfb_id[j]);
bindBOForDraw(m_program_id_draw, s_capture_modes[i], m_bo_id[j]);
drawToFramebuffer(m_xfb_id[j]);
is_ok =
is_ok && checkFramebuffer(s_colours[j][0], s_colours[j][1], s_colours[j][2], s_colours[j][3]);
}
clean();
}
}
}
catch (...)
{
is_ok = false;
test_error = true;
clean();
}
/* Result's setup. */
if (is_ok)
{
/* Log success. */
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Draw XFB have passed."
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
}
else
{
if (test_error)
{
/* Log error. */
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Draw XFB have approached error."
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
}
else
{
/* Log fail. */
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Draw XFB have failed."
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
}
return STOP;
}
void gl3cts::TransformFeedback::DrawXFB::prepare(glw::GLenum capture_mode)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Prepare programs. */
m_program_id_xfb = gl3cts::TransformFeedback::Utilities::buildProgram(
gl, m_context.getTestContext().getLog(), NULL, NULL, NULL, s_vertex_shader_xfb, s_fragment_shader,
s_xfb_varyings, s_xfb_varyings_count, capture_mode);
if (0 == m_program_id_xfb)
{
throw 0;
}
m_program_id_draw = gl3cts::TransformFeedback::Utilities::buildProgram(gl, m_context.getTestContext().getLog(),
NULL, NULL, NULL, s_vertex_shader_draw,
s_fragment_shader, NULL, 0, capture_mode);
if (0 == m_program_id_draw)
{
throw 0;
}
/* Prepare transform feedbacks. */
gl.genTransformFeedbacks(s_xfb_count, m_xfb_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTransformFeedbacks call failed.");
/* Prepare buffer objects. */
gl.genBuffers(s_xfb_count, m_bo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers call failed.");
for (glw::GLuint i = 0; i < s_xfb_count; ++i)
{
gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_bo_id[i]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, s_capture_size, NULL, GL_DYNAMIC_COPY);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData call failed.");
}
/* Prepare framebuffer. */
gl.clearColor(0.f, 0.f, 0.f, 1.f);
GLU_EXPECT_NO_ERROR(gl.getError(), "glClearColor call failed.");
gl.genFramebuffers(1, &m_fbo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers call failed.");
gl.genRenderbuffers(1, &m_rbo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenRenderbuffers call failed.");
gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");
gl.bindRenderbuffer(GL_RENDERBUFFER, m_rbo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer call failed.");
gl.renderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, s_view_size, s_view_size);
GLU_EXPECT_NO_ERROR(gl.getError(), "glRenderbufferStorage call failed.");
gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_rbo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferRenderbuffer call failed.");
if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
throw 0;
}
gl.viewport(0, 0, s_view_size, s_view_size);
GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport call failed.");
/* Create empty Vertex Array Object */
gl.genVertexArrays(1, &m_vao_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays call failed.");
}
void gl3cts::TransformFeedback::DrawXFB::bindXFB(glw::GLuint xfb_id)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, xfb_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTransformFeedback call failed.");
}
void gl3cts::TransformFeedback::DrawXFB::bindVAO(glw::GLuint vao_id)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.bindVertexArray(vao_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray call failed.");
}
void gl3cts::TransformFeedback::DrawXFB::bindBOForXFB(glw::GLenum capture_mode, glw::GLuint bo_id)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
switch (capture_mode)
{
case GL_INTERLEAVED_ATTRIBS:
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, bo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase call failed.");
break;
case GL_SEPARATE_ATTRIBS:
for (glw::GLuint i = 0; i < s_xfb_varyings_count; ++i)
{
gl.bindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, i, bo_id, i * s_capture_size / s_xfb_varyings_count,
(i + 1) * s_capture_size / s_xfb_varyings_count);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase call failed.");
}
break;
default:
throw 0;
}
}
void gl3cts::TransformFeedback::DrawXFB::bindBOForDraw(glw::GLuint program_id, glw::GLenum capture_mode,
glw::GLuint bo_id)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.bindBuffer(GL_ARRAY_BUFFER, bo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
glw::GLuint position_location = gl.getAttribLocation(program_id, "position");
glw::GLuint color_location = gl.getAttribLocation(program_id, "color");
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation call failed.");
glw::GLvoid* color_offset = (capture_mode == GL_INTERLEAVED_ATTRIBS) ?
(glw::GLvoid*)(4 /* components */ * sizeof(glw::GLfloat)) :
(glw::GLvoid*)(4 /* components */ * 6 /* vertices */ * sizeof(glw::GLfloat));
glw::GLuint stride =
static_cast<glw::GLuint>((capture_mode == GL_INTERLEAVED_ATTRIBS) ?
(4 /* components */ * 2 /* position and color */ * sizeof(glw::GLfloat)) :
(4 /* components */ * sizeof(glw::GLfloat)));
gl.vertexAttribPointer(position_location, 4, GL_FLOAT, GL_FALSE, stride, NULL);
gl.vertexAttribPointer(color_location, 4, GL_FLOAT, GL_FALSE, stride, color_offset);
GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer call failed.");
gl.enableVertexAttribArray(position_location);
gl.enableVertexAttribArray(color_location);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray call failed.");
}
void gl3cts::TransformFeedback::DrawXFB::useProgram(glw::GLuint program_id)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.useProgram(program_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed.");
}
void gl3cts::TransformFeedback::DrawXFB::useColour(glw::GLuint program_id, glw::GLfloat r, glw::GLfloat g,
glw::GLfloat b, glw::GLfloat a)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
glw::GLint location = gl.getUniformLocation(program_id, "color");
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation call failed.");
gl.uniform4f(location, r, g, b, a);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform4f call failed.");
}
void gl3cts::TransformFeedback::DrawXFB::useGeometrySet(glw::GLuint program_id, bool invert_sign)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
glw::GLint location = gl.getUniformLocation(program_id, "invert_sign");
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation call failed.");
gl.uniform1f(location, invert_sign ? -1.f : 1.f);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform4f call failed.");
}
void gl3cts::TransformFeedback::DrawXFB::clean()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.useProgram(0);
if (m_program_id_xfb)
{
gl.deleteProgram(m_program_id_xfb);
m_program_id_xfb = 0;
}
if (m_program_id_draw)
{
gl.deleteProgram(m_program_id_draw);
m_program_id_draw = 1;
}
for (glw::GLuint i = 0; i < s_xfb_count; ++i)
{
if (m_xfb_id[i])
{
gl.deleteTransformFeedbacks(1, &m_xfb_id[i]);
m_xfb_id[i] = 0;
}
}
for (glw::GLuint i = 0; i < s_xfb_count; ++i)
{
if (m_bo_id[i])
{
gl.deleteBuffers(1, &m_bo_id[i]);
m_bo_id[i] = 0;
}
}
if (m_vao_id)
{
gl.deleteVertexArrays(1, &m_vao_id);
m_vao_id = 0;
}
if (m_fbo_id)
{
gl.deleteFramebuffers(1, &m_fbo_id);
m_fbo_id = 0;
}
if (m_rbo_id)
{
gl.deleteRenderbuffers(1, &m_rbo_id);
m_rbo_id = 0;
}
}
void gl3cts::TransformFeedback::DrawXFB::drawForCapture(bool begin_xfb, bool pause_xfb, bool resume_xfb, bool end_xfb)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.enable(GL_RASTERIZER_DISCARD);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable call failed.");
if (begin_xfb)
{
gl.beginTransformFeedback(GL_POINTS);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback call failed.");
}
if (resume_xfb)
{
gl.resumeTransformFeedback();
GLU_EXPECT_NO_ERROR(gl.getError(), "glResumeTransformFeedback call failed.");
}
gl.drawArrays(GL_POINTS, 0, 3);
if (pause_xfb)
{
gl.pauseTransformFeedback();
GLU_EXPECT_NO_ERROR(gl.getError(), "glPauseTransformFeedback call failed.");
}
if (end_xfb)
{
gl.endTransformFeedback();
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback call failed.");
}
gl.disable(GL_RASTERIZER_DISCARD);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDisable call failed.");
}
void gl3cts::TransformFeedback::DrawXFB::drawToFramebuffer(glw::GLuint xfb_id)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.clearColor(0.f, 0.f, 0.f, 0.f);
GLU_EXPECT_NO_ERROR(gl.getError(), "glClearColor call failed.");
gl.clear(GL_COLOR_BUFFER_BIT);
GLU_EXPECT_NO_ERROR(gl.getError(), "glClear call failed.");
gl.drawTransformFeedback(GL_TRIANGLES, xfb_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawTransformFeedback call failed.");
}
bool gl3cts::TransformFeedback::DrawXFB::checkFramebuffer(glw::GLfloat r, glw::GLfloat g, glw::GLfloat b,
glw::GLfloat a)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Number of pixels. */
const glw::GLuint number_of_pixels = s_view_size * s_view_size;
/* Fetch framebuffer. */
std::vector<glw::GLubyte> pixels(number_of_pixels * 4 /* components */);
if (s_view_size > 0)
{
gl.readPixels(0, 0, s_view_size, s_view_size, GL_RGBA, GL_UNSIGNED_BYTE, pixels.data());
GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels call failed.");
}
/* Convert color to integer. */
glw::GLubyte ir = (glw::GLubyte)(255.f * r);
glw::GLubyte ig = (glw::GLubyte)(255.f * g);
glw::GLubyte ib = (glw::GLubyte)(255.f * b);
glw::GLubyte ia = (glw::GLubyte)(255.f * a);
/* Check results. */
for (glw::GLuint i = 0; i < number_of_pixels; ++i)
{
if ((pixels[i * 4 /* components */] != ir) || (pixels[i * 4 /* components */ + 1] != ig) ||
(pixels[i * 4 /* components */ + 2] != ib) || (pixels[i * 4 /* components */ + 3] != ia))
{
return false;
}
}
return true;
}
bool gl3cts::TransformFeedback::DrawXFB::inspectXFBState(bool shall_be_paused, bool shall_be_active)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
glw::GLint is_paused = 0;
glw::GLint is_active = 0;
gl.getIntegerv(GL_TRANSFORM_FEEDBACK_PAUSED, &is_paused);
gl.getIntegerv(GL_TRANSFORM_FEEDBACK_ACTIVE, &is_active);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv call failed.");
if ((is_paused == -1) || (is_active == -1))
{
throw 0;
}
if (shall_be_paused ^ (is_paused == GL_TRUE))
{
return false;
}
if (shall_be_active ^ (is_active == GL_TRUE))
{
return false;
}
return true;
}
const glw::GLchar* gl3cts::TransformFeedback::DrawXFB::s_vertex_shader_xfb =
"#version 130\n"
"\n"
"uniform vec4 color;\n"
"uniform float invert_sign;\n"
"out vec4 colour;\n"
"\n"
"void main()\n"
"{\n"
" switch(gl_VertexID)\n"
" {\n"
" case 0:\n"
" gl_Position = vec4(-1.0, -1.0, 0.0, 1.0);\n"
" break;\n"
" case 1:\n"
" gl_Position = vec4(-1.0 * invert_sign, 1.0, 0.0, 1.0);\n"
" break;\n"
" case 2:\n"
" gl_Position = vec4( 1.0, 1.0 * invert_sign, 0.0, 1.0);\n"
" break;\n"
" }\n"
"\n"
" colour = color;\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::DrawXFB::s_vertex_shader_draw = "#version 130\n"
"\n"
"in vec4 color;\n"
"in vec4 position;\n"
"out vec4 colour;\n"
"\n"
"void main()\n"
"{\n"
" gl_Position = position;\n"
" colour = color;\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::DrawXFB::s_fragment_shader = "#version 130\n"
"\n"
"in vec4 colour;\n"
"out vec4 pixel;\n"
"\n"
"void main()\n"
"{\n"
" pixel = colour;\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::DrawXFB::s_xfb_varyings[s_xfb_varyings_count] = { "gl_Position",
"colour" };
const glw::GLenum gl3cts::TransformFeedback::DrawXFB::s_capture_modes[] = { GL_INTERLEAVED_ATTRIBS,
GL_SEPARATE_ATTRIBS };
const glw::GLuint gl3cts::TransformFeedback::DrawXFB::s_capture_modes_count =
sizeof(s_capture_modes) / sizeof(s_capture_modes[0]);
const glw::GLfloat gl3cts::TransformFeedback::DrawXFB::s_colours[s_xfb_count][4] = { { 1.f, 0.f, 0.f, 1.f },
{ 0.f, 1.f, 0.f, 1.f },
{ 0.f, 0.f, 1.f, 1.f } };
/*-----------------------------------------------------------------------------------------------*/
gl3cts::TransformFeedback::DrawXFBFeedback::DrawXFBFeedback(deqp::Context& context, const char* test_name,
const char* test_description)
: deqp::TestCase(context, test_name, test_description)
, m_context(context)
, m_program_id(0)
, m_xfb_id(0)
, m_source_bo_index(0)
{
memset(m_bo_id, 1, sizeof(m_bo_id));
memset(m_bo_id, 1, sizeof(m_vao_id));
}
gl3cts::TransformFeedback::DrawXFBFeedback::~DrawXFBFeedback(void)
{
}
tcu::TestNode::IterateResult gl3cts::TransformFeedback::DrawXFBFeedback::iterate(void)
{
/* Initializations. */
bool is_at_least_gl_40 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 0)));
bool is_arb_tf_2 = m_context.getContextInfo().isExtensionSupported("GL_ARB_transform_feedback2");
bool is_ok = true;
bool test_error = false;
/* Tests. */
try
{
if (is_at_least_gl_40 || is_arb_tf_2)
{
prepareAndBind();
draw(true);
swapBuffers();
draw(false);
swapBuffers();
draw(false);
is_ok = is_ok && check();
}
}
catch (...)
{
is_ok = false;
test_error = true;
}
/* Clean GL objects. */
clean();
/* Result's setup. */
if (is_ok)
{
/* Log success. */
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Draw XFB Feedback have passed."
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
}
else
{
if (test_error)
{
/* Log error. */
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Draw XFB Feedback have approached error."
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
}
else
{
/* Log fail. */
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Draw XFB Feedback have failed."
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
}
return STOP;
}
void gl3cts::TransformFeedback::DrawXFBFeedback::prepareAndBind()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Prepare programs. */
m_program_id = gl3cts::TransformFeedback::Utilities::buildProgram(gl, m_context.getTestContext().getLog(), NULL,
NULL, NULL, s_vertex_shader, s_fragment_shader,
&s_xfb_varying, 1, GL_INTERLEAVED_ATTRIBS);
if (0 == m_program_id)
{
throw 0;
}
gl.useProgram(m_program_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed.");
/* Prepare transform feedbacks. */
gl.genTransformFeedbacks(1, &m_xfb_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTransformFeedbacks call failed.");
gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_xfb_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTransformFeedbacks call failed.");
/* Prepare buffer objects. */
gl.genBuffers(s_bo_count, m_bo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers call failed.");
gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_id[0]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
gl.bufferData(GL_ARRAY_BUFFER, s_bo_size, s_initial_data, GL_DYNAMIC_COPY);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData call failed.");
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_bo_id[1]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, s_bo_size, NULL, GL_DYNAMIC_COPY);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData call failed.");
/* Setup vertex arrays. */
gl.genVertexArrays(s_bo_count, m_vao_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays call failed.");
glw::GLuint position_location = gl.getAttribLocation(m_program_id, "position");
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation call failed.");
for (glw::GLuint i = 0; i < 2; ++i)
{
gl.bindVertexArray(m_vao_id[i]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray call failed.");
gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_id[i]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
gl.vertexAttribPointer(position_location, 4, GL_FLOAT, GL_FALSE, 0, NULL);
GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer call failed.");
gl.enableVertexAttribArray(position_location);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray call failed.");
}
gl.bindBuffer(GL_ARRAY_BUFFER, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
gl.bindVertexArray(m_vao_id[0]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray call failed.");
}
void gl3cts::TransformFeedback::DrawXFBFeedback::swapBuffers()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_bo_id[m_source_bo_index]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
m_source_bo_index = (m_source_bo_index + 1) % 2;
gl.bindVertexArray(m_vao_id[(m_source_bo_index)]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray call failed.");
}
void gl3cts::TransformFeedback::DrawXFBFeedback::draw(bool is_first_draw)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.enable(GL_RASTERIZER_DISCARD);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable call failed.");
gl.beginTransformFeedback(GL_POINTS);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback call failed.");
if (is_first_draw)
{
gl.drawArrays(GL_POINTS, 0, 1);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays call failed.");
}
else
{
gl.drawTransformFeedback(GL_POINTS, m_xfb_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawTransformFeedback call failed.");
}
gl.endTransformFeedback();
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback call failed.");
gl.disable(GL_RASTERIZER_DISCARD);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDisable call failed.");
}
bool gl3cts::TransformFeedback::DrawXFBFeedback::check()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
glw::GLfloat* results =
(glw::GLfloat*)gl.mapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, s_bo_size, GL_MAP_READ_BIT);
GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange call failed.");
bool is_ok = false;
if (results)
{
if ((results[0] == 8.f) && (results[1] == 16.f) && (results[2] == 24.f) && (results[3] == 32.f))
{
is_ok = true;
}
gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer call failed.");
}
return is_ok;
}
void gl3cts::TransformFeedback::DrawXFBFeedback::clean()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.useProgram(0);
if (m_program_id)
{
gl.deleteProgram(m_program_id);
m_program_id = 0;
}
if (m_xfb_id)
{
gl.deleteTransformFeedbacks(1, &m_xfb_id);
m_xfb_id = 0;
}
for (glw::GLuint i = 0; i < s_bo_count; ++i)
{
if (m_bo_id[i])
{
gl.deleteBuffers(1, &m_bo_id[i]);
m_bo_id[i] = 0;
}
}
for (glw::GLuint i = 0; i < s_bo_count; ++i)
{
if (m_vao_id[i])
{
gl.deleteVertexArrays(1, &m_vao_id[i]);
m_vao_id[i] = 0;
}
}
}
const glw::GLchar* gl3cts::TransformFeedback::DrawXFBFeedback::s_vertex_shader = "#version 130\n"
"\n"
"in vec4 position;\n"
"\n"
"void main()\n"
"{\n"
" gl_Position = position * 2.0;\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::DrawXFBFeedback::s_fragment_shader = "#version 130\n"
"\n"
"out vec4 pixel;\n"
"\n"
"void main()\n"
"{\n"
" pixel = vec4(1.0);\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::DrawXFBFeedback::s_xfb_varying = "gl_Position";
const glw::GLchar* gl3cts::TransformFeedback::DrawXFBFeedback::s_attrib = "position";
const glw::GLfloat gl3cts::TransformFeedback::DrawXFBFeedback::s_initial_data[] = { 1.f, 2.f, 3.f, 4.f };
const glw::GLuint gl3cts::TransformFeedback::DrawXFBFeedback::s_draw_vertex_count =
sizeof(s_initial_data) / sizeof(s_initial_data[0]) / 4 /* components */;
const glw::GLuint gl3cts::TransformFeedback::DrawXFBFeedback::s_bo_size = sizeof(s_initial_data);
/*-----------------------------------------------------------------------------------------------*/
gl3cts::TransformFeedback::CaptureSpecialInterleaved::CaptureSpecialInterleaved(deqp::Context& context,
const char* test_name,
const char* test_description)
: deqp::TestCase(context, test_name, test_description)
, m_context(context)
, m_program_id(0)
, m_vao_id(0)
, m_xfb_id(0)
{
memset(m_bo_id, 0, sizeof(m_bo_id));
}
gl3cts::TransformFeedback::CaptureSpecialInterleaved::~CaptureSpecialInterleaved(void)
{
}
tcu::TestNode::IterateResult gl3cts::TransformFeedback::CaptureSpecialInterleaved::iterate(void)
{
/* Initializations. */
bool is_at_least_gl_40 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 0)));
bool is_arb_tf_3 = m_context.getContextInfo().isExtensionSupported("GL_ARB_transform_feedback3");
bool is_ok = true;
bool test_error = false;
/* Tests. */
try
{
if (is_at_least_gl_40 || is_arb_tf_3)
{
prepareAndBind();
draw();
is_ok = is_ok && check();
}
}
catch (...)
{
is_ok = false;
test_error = true;
}
/* Clean GL objects. */
clean();
/* Result's setup. */
if (is_ok)
{
/* Log success. */
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Capture Special Interleaved have passed."
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
}
else
{
if (test_error)
{
/* Log error. */
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "Capture Special Interleaved have approached error."
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
}
else
{
/* Log fail. */
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Capture Special Interleaved have failed."
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
}
return STOP;
}
void gl3cts::TransformFeedback::CaptureSpecialInterleaved::prepareAndBind()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Prepare programs. */
m_program_id = gl3cts::TransformFeedback::Utilities::buildProgram(
gl, m_context.getTestContext().getLog(), NULL, NULL, NULL, s_vertex_shader, s_fragment_shader, s_xfb_varyings,
s_xfb_varyings_count, GL_INTERLEAVED_ATTRIBS);
if (0 == m_program_id)
{
throw 0;
}
gl.useProgram(m_program_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed.");
/* Prepare transform feedbacks. */
gl.genTransformFeedbacks(1, &m_xfb_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTransformFeedbacks call failed.");
gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_xfb_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTransformFeedbacks call failed.");
/* Create empty Vertex Array Object */
gl.genVertexArrays(1, &m_vao_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays call failed.");
gl.bindVertexArray(m_vao_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray call failed.");
/* Prepare buffer objects. */
gl.genBuffers(s_bo_ids_count, m_bo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers call failed.");
for (glw::GLuint i = 0; i < s_bo_ids_count; ++i)
{
gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_bo_id[i]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, s_bo_size, NULL, GL_DYNAMIC_COPY); /* allocation */
GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData call failed.");
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, i, m_bo_id[i]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferRange call failed.");
}
}
void gl3cts::TransformFeedback::CaptureSpecialInterleaved::draw()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.enable(GL_RASTERIZER_DISCARD);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable call failed.");
gl.beginTransformFeedback(GL_POINTS);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback call failed.");
gl.drawArrays(GL_POINTS, 0, 1);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays call failed.");
gl.endTransformFeedback();
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback call failed.");
gl.disable(GL_RASTERIZER_DISCARD);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDisable call failed.");
}
bool gl3cts::TransformFeedback::CaptureSpecialInterleaved::check()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
bool is_ok = true;
gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_bo_id[0]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
glw::GLfloat* results =
(glw::GLfloat*)gl.mapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, s_bo_size, GL_MAP_READ_BIT);
GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange call failed.");
if ((results[0] != 1.0) || (results[1] != 2.0) || (results[2] != 3.0) || (results[3] != 4.0) ||
/* gl_SkipComponents4 here */
(results[8] != 5.0) || (results[9] != 6.0) || (results[10] != 7.0) || (results[11] != 8.0))
{
is_ok = false;
}
gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer call failed.");
gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_bo_id[1]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
results = (glw::GLfloat*)gl.mapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, s_bo_size, GL_MAP_READ_BIT);
GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange call failed.");
if ((results[0] != 9.0) || (results[1] != 10.0) || (results[2] != 11.0) || (results[3] != 12.0) ||
/* gl_SkipComponents4 here */
(results[8] != 13.0) || (results[9] != 14.0) || (results[10] != 15.0) || (results[11] != 16.0))
{
is_ok = false;
}
gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer call failed.");
return is_ok;
}
void gl3cts::TransformFeedback::CaptureSpecialInterleaved::clean()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.useProgram(0);
if (m_program_id)
{
gl.deleteProgram(m_program_id);
m_program_id = 0;
}
if (m_xfb_id)
{
gl.deleteTransformFeedbacks(1, &m_xfb_id);
m_xfb_id = 0;
}
for (glw::GLuint i = 0; i < s_bo_ids_count; ++i)
{
if (m_bo_id[i])
{
gl.deleteBuffers(1, &m_bo_id[i]);
m_bo_id[i] = 0;
}
}
if (m_vao_id)
{
gl.deleteVertexArrays(1, &m_vao_id);
m_vao_id = 0;
}
}
const glw::GLchar* gl3cts::TransformFeedback::CaptureSpecialInterleaved::s_vertex_shader =
"#version 130\n"
"\n"
"out vec4 variable_1;\n"
"out vec4 variable_2;\n"
"out vec4 variable_3;\n"
"out vec4 variable_4;\n"
"\n"
"void main()\n"
"{\n"
" variable_1 = vec4(1.0, 2.0, 3.0, 4.0);\n"
" variable_2 = vec4(5.0, 6.0, 7.0, 8.0);\n"
" variable_3 = vec4(9.0, 10.0, 11.0, 12.0);\n"
" variable_4 = vec4(13.0, 14.0, 15.0, 16.0);\n"
"\n"
" gl_Position = vec4(0.0, 0.0, 0.0, 1.0);\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::CaptureSpecialInterleaved::s_fragment_shader = "#version 130\n"
"\n"
"out vec4 pixel;\n"
"\n"
"void main()\n"
"{\n"
" pixel = vec4(1.0);\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::CaptureSpecialInterleaved::s_xfb_varyings[] =
{ "variable_1", "gl_SkipComponents4", "variable_2", "gl_NextBuffer",
"variable_3", "gl_SkipComponents4", "variable_4" };
const glw::GLuint gl3cts::TransformFeedback::CaptureSpecialInterleaved::s_xfb_varyings_count =
sizeof(s_xfb_varyings) / sizeof(s_xfb_varyings[0]);
const glw::GLuint gl3cts::TransformFeedback::CaptureSpecialInterleaved::s_bo_size =
3 /*number of variables / empty places */ * 4 /* vec4 */
* sizeof(glw::GLfloat);
/*-----------------------------------------------------------------------------------------------*/
gl3cts::TransformFeedback::DrawXFBStream::DrawXFBStream(deqp::Context& context, const char* test_name,
const char* test_description)
: deqp::TestCase(context, test_name, test_description)
, m_context(context)
, m_program_id_generate(0)
, m_program_id_draw(0)
, m_vao_id(0)
, m_xfb_id(0)
, m_fbo_id(0)
, m_rbo_id(0)
{
memset(m_bo_id, 0, sizeof(m_bo_id));
memset(m_qo_id, 0, sizeof(m_qo_id));
}
gl3cts::TransformFeedback::DrawXFBStream::~DrawXFBStream(void)
{
}
tcu::TestNode::IterateResult gl3cts::TransformFeedback::DrawXFBStream::iterate(void)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Initializations. */
bool is_at_least_gl_40 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 0)));
bool is_arb_tf_3 = m_context.getContextInfo().isExtensionSupported("GL_ARB_transform_feedback3");
bool is_arb_gpu_shader5 = m_context.getContextInfo().isExtensionSupported("GL_ARB_gpu_shader5");
glw::GLint max_vertex_streams = 0;
bool is_ok = true;
bool test_error = false;
/* Tests. */
try
{
if (is_at_least_gl_40 || (is_arb_tf_3 && is_arb_gpu_shader5))
{
gl.getIntegerv(GL_MAX_VERTEX_STREAMS, &max_vertex_streams);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv call failed.");
if (max_vertex_streams >= 2)
{
prepareObjects();
useProgram(m_program_id_generate);
drawForXFB();
is_ok = is_ok && inspectQueries();
useProgram(m_program_id_draw);
setupVertexArray(m_bo_id[0]);
drawForFramebuffer(0);
setupVertexArray(m_bo_id[1]);
drawForFramebuffer(1);
is_ok = is_ok && check();
}
}
}
catch (...)
{
is_ok = false;
test_error = true;
}
/* Clean GL objects. */
clean();
/* Result's setup. */
if (is_ok)
{
/* Log success. */
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Draw XFB Stream have passed."
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
}
else
{
if (test_error)
{
/* Log error. */
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Draw XFB Stream have approached error."
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
}
else
{
/* Log fail. */
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Draw XFB Stream have failed."
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
}
return STOP;
}
void gl3cts::TransformFeedback::DrawXFBStream::prepareObjects()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Prepare programs. */
m_program_id_generate = gl3cts::TransformFeedback::Utilities::buildProgram(
gl, m_context.getTestContext().getLog(), s_geometry_shader, NULL, NULL, s_vertex_shader_blank,
s_fragment_shader, s_xfb_varyings, s_xfb_varyings_count, GL_INTERLEAVED_ATTRIBS);
if (0 == m_program_id_generate)
{
throw 0;
}
m_program_id_draw = gl3cts::TransformFeedback::Utilities::buildProgram(
gl, m_context.getTestContext().getLog(), NULL, NULL, NULL, s_vertex_shader_pass, s_fragment_shader, NULL, 0,
GL_INTERLEAVED_ATTRIBS);
if (0 == m_program_id_draw)
{
throw 0;
}
/* Prepare transform feedbacks. */
gl.genTransformFeedbacks(1, &m_xfb_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTransformFeedbacks call failed.");
gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_xfb_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTransformFeedbacks call failed.");
/* Create empty Vertex Array Object */
gl.genVertexArrays(1, &m_vao_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays call failed.");
gl.bindVertexArray(m_vao_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray call failed.");
/* Prepare buffer objects. */
gl.genBuffers(s_bo_ids_count, m_bo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers call failed.");
for (glw::GLuint i = 0; i < s_bo_ids_count; ++i)
{
gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_bo_id[i]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, s_bo_size, NULL, GL_DYNAMIC_COPY); /* allocation */
GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData call failed.");
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, i, m_bo_id[i]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferRange call failed.");
}
/* Generate queries */
gl.genQueries(s_qo_ids_count, m_qo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenQueries call failed.");
/* Prepare framebuffer. */
gl.clearColor(0.f, 0.f, 0.f, 1.f);
GLU_EXPECT_NO_ERROR(gl.getError(), "glClearColor call failed.");
gl.genFramebuffers(1, &m_fbo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers call failed.");
gl.genRenderbuffers(1, &m_rbo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenRenderbuffers call failed.");
gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");
gl.bindRenderbuffer(GL_RENDERBUFFER, m_rbo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer call failed.");
gl.renderbufferStorage(GL_RENDERBUFFER, GL_R8, s_view_size, s_view_size);
GLU_EXPECT_NO_ERROR(gl.getError(), "glRenderbufferStorage call failed.");
gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_rbo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferRenderbuffer call failed.");
if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
throw 0;
}
gl.viewport(0, 0, s_view_size, s_view_size);
GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport call failed.");
}
void gl3cts::TransformFeedback::DrawXFBStream::setupVertexArray(glw::GLuint bo_id)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.bindBuffer(GL_ARRAY_BUFFER, bo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
glw::GLuint position_location = gl.getAttribLocation(m_program_id_draw, "position");
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation call failed.");
gl.vertexAttribPointer(position_location, 4, GL_FLOAT, GL_FALSE, 0, NULL);
GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer call failed.");
gl.enableVertexAttribArray(position_location);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray call failed.");
}
void gl3cts::TransformFeedback::DrawXFBStream::useProgram(glw::GLuint program_id)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.useProgram(program_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed.");
}
void gl3cts::TransformFeedback::DrawXFBStream::drawForXFB()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.enable(GL_RASTERIZER_DISCARD);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable call failed.");
gl.beginTransformFeedback(GL_POINTS);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback call failed.");
gl.beginQueryIndexed(GL_PRIMITIVES_GENERATED, 0, m_qo_id[0]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginQueryIndexed call failed.");
gl.beginQueryIndexed(GL_PRIMITIVES_GENERATED, 1, m_qo_id[1]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginQueryIndexed call failed.");
gl.beginQueryIndexed(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, 0, m_qo_id[2]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginQueryIndexed call failed.");
gl.beginQueryIndexed(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, 1, m_qo_id[3]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginQueryIndexed call failed.");
gl.drawArrays(GL_POINTS, 0, 1);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays call failed.");
gl.endQueryIndexed(GL_PRIMITIVES_GENERATED, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndQueryIndexed call failed.");
gl.endQueryIndexed(GL_PRIMITIVES_GENERATED, 1);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndQueryIndexed call failed.");
gl.endQueryIndexed(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndQueryIndexed call failed.");
gl.endQueryIndexed(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, 1);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndQueryIndexed call failed.");
gl.endTransformFeedback();
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback call failed.");
gl.disable(GL_RASTERIZER_DISCARD);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDisable call failed.");
}
void gl3cts::TransformFeedback::DrawXFBStream::drawForFramebuffer(glw::GLuint stream)
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.drawTransformFeedbackStream(GL_TRIANGLES, m_xfb_id, stream);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawTransformFeedbackStream call failed.");
}
bool gl3cts::TransformFeedback::DrawXFBStream::inspectQueries()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
glw::GLint generated_primitives_to_stream_0 = 0;
glw::GLint generated_primitives_to_stream_1 = 0;
gl.getQueryObjectiv(m_qo_id[0], GL_QUERY_RESULT, &generated_primitives_to_stream_0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetQueryIndexediv call failed.");
gl.getQueryObjectiv(m_qo_id[1], GL_QUERY_RESULT, &generated_primitives_to_stream_1);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetQueryIndexediv call failed.");
glw::GLint primitives_written_to_xfb_to_stream_0 = 0;
glw::GLint primitives_written_to_xfb_to_stream_1 = 0;
gl.getQueryObjectiv(m_qo_id[2], GL_QUERY_RESULT, &primitives_written_to_xfb_to_stream_0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetQueryIndexediv call failed.");
gl.getQueryObjectiv(m_qo_id[3], GL_QUERY_RESULT, &primitives_written_to_xfb_to_stream_1);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetQueryIndexediv call failed.");
if ((generated_primitives_to_stream_0 == 3) && (generated_primitives_to_stream_1 == 3) &&
(primitives_written_to_xfb_to_stream_0 == 3) && (primitives_written_to_xfb_to_stream_1 == 3))
{
return true;
}
return false;
}
bool gl3cts::TransformFeedback::DrawXFBStream::check()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Number of pixels. */
const glw::GLuint number_of_pixels = s_view_size * s_view_size;
/* Fetch framebuffer. */
std::vector<glw::GLfloat> pixels(number_of_pixels);
gl.readPixels(0, 0, s_view_size, s_view_size, GL_RED, GL_FLOAT, &pixels[0]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels call failed.");
/* Check results. */
for (glw::GLuint i = 0; i < number_of_pixels; ++i)
{
if (fabs(pixels[i] - 1.f) > 0.0625 /* precision, expected result == 1.0 */)
{
return false;
}
}
return true;
}
void gl3cts::TransformFeedback::DrawXFBStream::clean()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.useProgram(0);
if (m_program_id_generate)
{
gl.deleteProgram(m_program_id_generate);
m_program_id_generate = 0;
}
if (m_program_id_draw)
{
glw::GLuint position_location = gl.getAttribLocation(m_program_id_draw, "position");
gl.disableVertexAttribArray(position_location);
gl.deleteProgram(m_program_id_draw);
m_program_id_draw = 0;
}
if (m_xfb_id)
{
gl.deleteTransformFeedbacks(1, &m_xfb_id);
m_xfb_id = 0;
}
for (glw::GLuint i = 0; i < s_bo_ids_count; ++i)
{
if (m_bo_id[i])
{
gl.deleteBuffers(1, &m_bo_id[i]);
m_bo_id[i] = 0;
}
}
if (m_vao_id)
{
gl.deleteVertexArrays(1, &m_vao_id);
m_vao_id = 0;
}
if (m_fbo_id)
{
gl.deleteFramebuffers(1, &m_fbo_id);
m_fbo_id = 0;
}
if (m_rbo_id)
{
gl.deleteRenderbuffers(1, &m_rbo_id);
m_rbo_id = 0;
}
}
const glw::GLchar* gl3cts::TransformFeedback::DrawXFBStream::s_vertex_shader_blank = "#version 130\n"
"\n"
"void main()\n"
"{\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::DrawXFBStream::s_vertex_shader_pass = "#version 130\n"
"\n"
"in vec4 position;\n"
"\n"
"void main()\n"
"{\n"
" gl_Position = position;\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::DrawXFBStream::s_geometry_shader =
"#version 400\n"
"\n"
"layout(points) in;\n"
"layout(points, max_vertices = 6) out;\n"
"\n"
"layout(stream = 1) out vec4 position;\n"
"\n"
"void main()\n"
"{\n"
" gl_Position = vec4(-1.0, -1.0, 0.0, 1.0);\n"
" EmitStreamVertex(0);\n"
" gl_Position = vec4( 1.0, -1.0, 0.0, 1.0);\n"
" EmitStreamVertex(0);\n"
" gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n"
" EmitStreamVertex(0);\n"
"\n"
" position = vec4( 1.0, -1.0, 0.0, 1.0);\n"
" EmitStreamVertex(1);\n"
" position = vec4(-1.0, 1.0, 0.0, 1.0);\n"
" EmitStreamVertex(1);\n"
" position = vec4( 1.0, 1.0, 0.0, 1.0);\n"
" EmitStreamVertex(1);\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::DrawXFBStream::s_fragment_shader = "#version 130\n"
"\n"
"out vec4 pixel;\n"
"\n"
"void main()\n"
"{\n"
" pixel = vec4(1.0);\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::DrawXFBStream::s_xfb_varyings[] = { "gl_Position", "gl_NextBuffer",
"position" };
const glw::GLuint gl3cts::TransformFeedback::DrawXFBStream::s_xfb_varyings_count =
sizeof(s_xfb_varyings) / sizeof(s_xfb_varyings[0]);
const glw::GLuint gl3cts::TransformFeedback::DrawXFBStream::s_bo_size =
3 /* triangles */ * 4 /* vec4 */ * sizeof(glw::GLfloat);
const glw::GLuint gl3cts::TransformFeedback::DrawXFBStream::s_view_size = 2;
/*-----------------------------------------------------------------------------------------------*/
gl3cts::TransformFeedback::DrawXFBInstanced::DrawXFBInstanced(deqp::Context& context, const char* test_name,
const char* test_description)
: deqp::TestCase(context, test_name, test_description)
, m_context(context)
, m_program_id_generate(0)
, m_program_id_draw(0)
, m_vao_id(0)
, m_xfb_id(0)
, m_bo_id_xfb(0)
, m_bo_id_uniform(0)
, m_fbo_id(0)
, m_rbo_id(0)
, m_glGetUniformBlockIndex(DE_NULL)
, m_glUniformBlockBinding(DE_NULL)
{
}
gl3cts::TransformFeedback::DrawXFBInstanced::~DrawXFBInstanced(void)
{
}
tcu::TestNode::IterateResult gl3cts::TransformFeedback::DrawXFBInstanced::iterate(void)
{
/* Initializations. */
bool is_at_least_gl_42 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 2)));
bool is_at_least_gl_31 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(3, 1)));
bool is_arb_tf_instanced = m_context.getContextInfo().isExtensionSupported("GL_ARB_transform_feedback_instanced");
bool is_arb_ubo = m_context.getContextInfo().isExtensionSupported("GL_ARB_uniform_buffer_object");
bool is_ok = true;
bool test_error = false;
if (is_arb_ubo)
{
m_glGetUniformBlockIndex =
(GetUniformBlockIndex_ProcAddress)m_context.getRenderContext().getProcAddress("glGetUniformBlockIndex");
m_glUniformBlockBinding =
(UniformBlockBinding_ProcAddress)m_context.getRenderContext().getProcAddress("glUniformBlockBinding");
if (DE_NULL == m_glGetUniformBlockIndex || DE_NULL == m_glUniformBlockBinding)
{
throw 0;
}
}
try
{
if (is_at_least_gl_42 || ((is_at_least_gl_31 || is_arb_ubo) && is_arb_tf_instanced))
{
prepareObjects();
drawForXFB();
drawInstanced();
is_ok = is_ok && check();
}
}
catch (...)
{
is_ok = false;
test_error = true;
}
/* Clean GL objects */
clean();
/* Result's setup. */
if (is_ok)
{
/* Log success. */
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Draw XFB Instanced have passed."
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
}
else
{
if (test_error)
{
/* Log error. */
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Draw XFB Instanced have approached error."
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
}
else
{
/* Log fail. */
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Draw XFB Instanced have failed."
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
}
return STOP;
}
void gl3cts::TransformFeedback::DrawXFBInstanced::prepareObjects()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Prepare programs. */
m_program_id_generate = gl3cts::TransformFeedback::Utilities::buildProgram(
gl, m_context.getTestContext().getLog(), NULL, NULL, NULL, s_vertex_shader_generate, s_fragment_shader,
&s_xfb_varying, 1, GL_INTERLEAVED_ATTRIBS);
if (0 == m_program_id_generate)
{
throw 0;
}
m_program_id_draw = gl3cts::TransformFeedback::Utilities::buildProgram(
gl, m_context.getTestContext().getLog(), NULL, NULL, NULL, s_vertex_shader_draw, s_fragment_shader, NULL, 0,
GL_INTERLEAVED_ATTRIBS);
if (0 == m_program_id_draw)
{
throw 0;
}
/* Prepare transform feedbacks. */
gl.genTransformFeedbacks(1, &m_xfb_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTransformFeedbacks call failed.");
gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_xfb_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTransformFeedbacks call failed.");
/* Create empty Vertex Array Object */
gl.genVertexArrays(1, &m_vao_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays call failed.");
gl.bindVertexArray(m_vao_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray call failed.");
/* Prepare xfb buffer object. */
gl.genBuffers(1, &m_bo_id_xfb);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers call failed.");
gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_bo_id_xfb);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, s_bo_xfb_size, NULL, GL_DYNAMIC_COPY); /* allocation */
GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData call failed.");
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_bo_id_xfb);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferRange call failed.");
/* Prepare uniform buffer object. */
gl.genBuffers(1, &m_bo_id_uniform);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers call failed.");
gl.bindBuffer(GL_UNIFORM_BUFFER, m_bo_id_uniform);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
gl.bufferData(GL_UNIFORM_BUFFER, s_bo_uniform_size, s_bo_uniform_data, GL_DYNAMIC_COPY); /* allocation */
GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData call failed.");
gl.bindBufferBase(GL_UNIFORM_BUFFER, 0, m_bo_id_uniform);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferRange call failed.");
glw::GLuint uniform_index = m_glGetUniformBlockIndex(m_program_id_draw, s_uniform);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformBlockIndex call failed.");
if (GL_INVALID_INDEX == uniform_index)
{
throw 0;
}
m_glUniformBlockBinding(m_program_id_draw, uniform_index, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformBlockBinding call failed.");
/* Prepare framebuffer. */
gl.clearColor(0.f, 0.f, 0.f, 1.f);
GLU_EXPECT_NO_ERROR(gl.getError(), "glClearColor call failed.");
gl.genFramebuffers(1, &m_fbo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers call failed.");
gl.genRenderbuffers(1, &m_rbo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenRenderbuffers call failed.");
gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");
gl.bindRenderbuffer(GL_RENDERBUFFER, m_rbo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer call failed.");
gl.renderbufferStorage(GL_RENDERBUFFER, GL_R8, s_view_size, s_view_size);
GLU_EXPECT_NO_ERROR(gl.getError(), "glRenderbufferStorage call failed.");
gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_rbo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferRenderbuffer call failed.");
if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
throw 0;
}
gl.viewport(0, 0, s_view_size, s_view_size);
GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport call failed.");
}
void gl3cts::TransformFeedback::DrawXFBInstanced::drawForXFB()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.useProgram(m_program_id_generate);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed.");
gl.enable(GL_RASTERIZER_DISCARD);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable call failed.");
gl.beginTransformFeedback(GL_POINTS);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback call failed.");
gl.drawArrays(GL_POINTS, 0, 4 /* quad vertex count */);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays call failed.");
gl.endTransformFeedback();
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback call failed.");
gl.disable(GL_RASTERIZER_DISCARD);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDisable call failed.");
}
void gl3cts::TransformFeedback::DrawXFBInstanced::drawInstanced()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_id_xfb);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
glw::GLuint position_location = gl.getAttribLocation(m_program_id_draw, "position");
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation call failed.");
gl.vertexAttribPointer(position_location, 4, GL_FLOAT, GL_FALSE, 0, NULL);
GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer call failed.");
gl.enableVertexAttribArray(position_location);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray call failed.");
gl.clear(GL_COLOR_BUFFER_BIT);
GLU_EXPECT_NO_ERROR(gl.getError(), "glClear call failed.");
gl.useProgram(m_program_id_draw);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed.");
gl.drawTransformFeedbackInstanced(GL_TRIANGLE_STRIP, m_xfb_id, 4);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays call failed.");
}
bool gl3cts::TransformFeedback::DrawXFBInstanced::check()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Number of pixels. */
const glw::GLuint number_of_pixels = s_view_size * s_view_size;
/* Fetch framebuffer. */
std::vector<glw::GLfloat> pixels(number_of_pixels);
gl.readPixels(0, 0, s_view_size, s_view_size, GL_RED, GL_FLOAT, &pixels[0]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels call failed.");
/* Check results. */
for (glw::GLuint i = 0; i < number_of_pixels; ++i)
{
if (fabs(pixels[i] - 1.f) > 0.0625 /* precision, expected result == 1.0 */)
{
return false;
}
}
return true;
}
void gl3cts::TransformFeedback::DrawXFBInstanced::clean()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.useProgram(0);
if (m_program_id_generate)
{
gl.deleteProgram(m_program_id_generate);
m_program_id_generate = 0;
}
if (m_program_id_draw)
{
glw::GLuint position_location = gl.getAttribLocation(m_program_id_draw, "position");
gl.disableVertexAttribArray(position_location);
gl.deleteProgram(m_program_id_draw);
m_program_id_draw = 0;
}
if (m_xfb_id)
{
gl.deleteTransformFeedbacks(1, &m_xfb_id);
m_xfb_id = 0;
}
if (m_bo_id_xfb)
{
gl.deleteBuffers(1, &m_bo_id_xfb);
m_bo_id_xfb = 0;
}
if (m_bo_id_uniform)
{
gl.deleteBuffers(1, &m_bo_id_uniform);
m_bo_id_uniform = 0;
}
if (m_vao_id)
{
gl.deleteVertexArrays(1, &m_vao_id);
m_vao_id = 0;
}
if (m_fbo_id)
{
gl.deleteFramebuffers(1, &m_fbo_id);
m_fbo_id = 0;
}
if (m_rbo_id)
{
gl.deleteRenderbuffers(1, &m_rbo_id);
m_rbo_id = 0;
}
}
const glw::GLchar* gl3cts::TransformFeedback::DrawXFBInstanced::s_vertex_shader_generate =
"#version 140\n"
"\n"
"void main()\n"
"{\n"
" switch(gl_VertexID % 4)\n"
" {\n"
" case 0:\n"
" gl_Position = vec4(-1.0, -1.0, 0.0, 1.0);\n"
" break;\n"
" case 1:\n"
" gl_Position = vec4( 1.0, -1.0, 0.0, 1.0);\n"
" break;\n"
" case 2:\n"
" gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n"
" break;\n"
" case 3:\n"
" gl_Position = vec4( 1.0, 1.0, 0.0, 1.0);\n"
" break;\n"
" }\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::DrawXFBInstanced::s_vertex_shader_draw =
"#version 140\n"
"\n"
"uniform MatrixBlock\n"
"{\n"
" mat4 transformation_0;\n"
" mat4 transformation_1;\n"
" mat4 transformation_2;\n"
" mat4 transformation_3;\n"
"};\n"
"\n"
"in vec4 position;\n"
"\n"
"void main()\n"
"{\n"
" switch(gl_InstanceID % 4)\n"
" {\n"
" case 0:\n"
" gl_Position = position * transformation_0;\n"
" break;\n"
" case 1:\n"
" gl_Position = position * transformation_1;\n"
" break;\n"
" case 2:\n"
" gl_Position = position * transformation_2;\n"
" break;\n"
" case 3:\n"
" gl_Position = position * transformation_3;\n"
" break;\n"
" }\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::DrawXFBInstanced::s_fragment_shader = "#version 130\n"
"\n"
"out vec4 pixel;\n"
"\n"
"void main()\n"
"{\n"
" pixel = vec4(1.0);\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::DrawXFBInstanced::s_xfb_varying = "gl_Position";
const glw::GLchar* gl3cts::TransformFeedback::DrawXFBInstanced::s_uniform = "MatrixBlock";
const glw::GLuint gl3cts::TransformFeedback::DrawXFBInstanced::s_bo_xfb_size =
4 /* vertex count */ * 4 /* vec4 components */
* sizeof(glw::GLfloat) /* data type size */;
const glw::GLfloat gl3cts::TransformFeedback::DrawXFBInstanced::s_bo_uniform_data[] = {
0.5f, 0.0f, 0.0f, 0.5f, 0.0f, 0.5f, 0.0f, 0.5f, 0.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
0.5f, 0.0f, 0.0f, -0.5f, 0.0f, 0.5f, 0.0f, 0.5f, 0.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
0.5f, 0.0f, 0.0f, -0.5f, 0.0f, 0.5f, 0.0f, -0.5f, 0.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
0.5f, 0.0f, 0.0f, 0.5f, 0.0f, 0.5f, 0.0f, -0.5f, 0.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f
};
const glw::GLuint gl3cts::TransformFeedback::DrawXFBInstanced::s_bo_uniform_size = sizeof(s_bo_uniform_data);
const glw::GLuint gl3cts::TransformFeedback::DrawXFBInstanced::s_view_size = 4;
/*-----------------------------------------------------------------------------------------------*/
gl3cts::TransformFeedback::DrawXFBStreamInstanced::DrawXFBStreamInstanced(deqp::Context& context, const char* test_name,
const char* test_description)
: deqp::TestCase(context, test_name, test_description)
, m_context(context)
, m_program_id_generate(0)
, m_program_id_draw(0)
, m_vao_id(0)
, m_xfb_id(0)
, m_bo_id_xfb_position(0)
, m_bo_id_xfb_color(0)
, m_bo_id_uniform(0)
, m_fbo_id(0)
, m_rbo_id(0)
, m_glGetUniformBlockIndex(DE_NULL)
, m_glUniformBlockBinding(DE_NULL)
{
}
gl3cts::TransformFeedback::DrawXFBStreamInstanced::~DrawXFBStreamInstanced(void)
{
}
tcu::TestNode::IterateResult gl3cts::TransformFeedback::DrawXFBStreamInstanced::iterate(void)
{
/* Initializations. */
bool is_at_least_gl_31 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(3, 1)));
bool is_at_least_gl_40 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 0)));
bool is_at_least_gl_42 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 2)));
bool is_arb_tf_instanced = m_context.getContextInfo().isExtensionSupported("GL_ARB_transform_feedback_instanced");
bool is_arb_ubo = m_context.getContextInfo().isExtensionSupported("GL_ARB_uniform_buffer_object");
bool is_arb_gpu_shader5 = m_context.getContextInfo().isExtensionSupported("GL_ARB_gpu_shader5");
bool is_ok = true;
bool test_error = false;
if (is_arb_ubo)
{
m_glGetUniformBlockIndex =
(GetUniformBlockIndex_ProcAddress)m_context.getRenderContext().getProcAddress("glGetUniformBlockIndex");
m_glUniformBlockBinding =
(UniformBlockBinding_ProcAddress)m_context.getRenderContext().getProcAddress("glUniformBlockBinding");
if (DE_NULL == m_glGetUniformBlockIndex || DE_NULL == m_glUniformBlockBinding)
{
throw 0;
}
}
/* Test. */
try
{
if (is_at_least_gl_42 || ((is_at_least_gl_31 || is_arb_ubo) && is_arb_gpu_shader5 && is_arb_tf_instanced) ||
(is_at_least_gl_40 && is_arb_tf_instanced))
{
prepareObjects();
drawForXFB();
drawStreamInstanced();
is_ok = is_ok && check();
}
}
catch (...)
{
is_ok = false;
test_error = true;
}
/* Clean GL objects */
clean();
/* Result's setup. */
if (is_ok)
{
/* Log success. */
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Draw XFB Stream Instanced have passed."
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
}
else
{
if (test_error)
{
/* Log error. */
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "Draw XFB Stream Instanced have approached error."
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
}
else
{
/* Log fail. */
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Draw XFB Stream Instanced have failed."
<< tcu::TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
}
return STOP;
}
void gl3cts::TransformFeedback::DrawXFBStreamInstanced::prepareObjects()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Prepare programs. */
m_program_id_generate = gl3cts::TransformFeedback::Utilities::buildProgram(
gl, m_context.getTestContext().getLog(), s_geometry_shader_generate, NULL, NULL, s_vertex_shader_blank,
s_fragment_shader_blank, s_xfb_varyings, s_xfb_varyings_count, GL_INTERLEAVED_ATTRIBS);
if (0 == m_program_id_generate)
{
throw 0;
}
m_program_id_draw = gl3cts::TransformFeedback::Utilities::buildProgram(
gl, m_context.getTestContext().getLog(), NULL, NULL, NULL, s_vertex_shader_draw, s_fragment_shader_draw, NULL,
0, GL_INTERLEAVED_ATTRIBS);
if (0 == m_program_id_draw)
{
throw 0;
}
/* Prepare transform feedbacks. */
gl.genTransformFeedbacks(1, &m_xfb_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTransformFeedbacks call failed.");
gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_xfb_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTransformFeedbacks call failed.");
/* Create empty Vertex Array Object */
gl.genVertexArrays(1, &m_vao_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays call failed.");
gl.bindVertexArray(m_vao_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray call failed.");
/* Prepare xfb buffer objects. */
gl.genBuffers(1, &m_bo_id_xfb_position);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers call failed.");
gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_bo_id_xfb_position);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, s_bo_xfb_size, NULL, GL_DYNAMIC_COPY); /* allocation */
GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData call failed.");
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_bo_id_xfb_position);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferRange call failed.");
gl.genBuffers(1, &m_bo_id_xfb_color);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers call failed.");
gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_bo_id_xfb_color);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, s_bo_xfb_size, NULL, GL_DYNAMIC_COPY); /* allocation */
GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData call failed.");
gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 1, m_bo_id_xfb_color);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferRange call failed.");
/* Prepare uniform buffer object. */
gl.genBuffers(1, &m_bo_id_uniform);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers call failed.");
gl.bindBuffer(GL_UNIFORM_BUFFER, m_bo_id_uniform);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
gl.bufferData(GL_UNIFORM_BUFFER, s_bo_uniform_size, s_bo_uniform_data, GL_DYNAMIC_COPY); /* allocation */
GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData call failed.");
gl.bindBufferBase(GL_UNIFORM_BUFFER, 0, m_bo_id_uniform);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferRange call failed.");
glw::GLuint uniform_index = m_glGetUniformBlockIndex(m_program_id_draw, s_uniform);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformBlockIndex call failed.");
if (GL_INVALID_INDEX == uniform_index)
{
throw 0;
}
m_glUniformBlockBinding(m_program_id_draw, uniform_index, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformBlockBinding call failed.");
/* Prepare framebuffer. */
gl.clearColor(0.f, 0.f, 0.f, 1.f);
GLU_EXPECT_NO_ERROR(gl.getError(), "glClearColor call failed.");
gl.genFramebuffers(1, &m_fbo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers call failed.");
gl.genRenderbuffers(1, &m_rbo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenRenderbuffers call failed.");
gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");
gl.bindRenderbuffer(GL_RENDERBUFFER, m_rbo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer call failed.");
gl.renderbufferStorage(GL_RENDERBUFFER, GL_R8, s_view_size, s_view_size);
GLU_EXPECT_NO_ERROR(gl.getError(), "glRenderbufferStorage call failed.");
gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_rbo_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferRenderbuffer call failed.");
if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
throw 0;
}
gl.viewport(0, 0, s_view_size, s_view_size);
GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport call failed.");
}
void gl3cts::TransformFeedback::DrawXFBStreamInstanced::drawForXFB()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.useProgram(m_program_id_generate);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed.");
gl.enable(GL_RASTERIZER_DISCARD);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable call failed.");
gl.beginTransformFeedback(GL_POINTS);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback call failed.");
gl.drawArrays(GL_POINTS, 0, 4 /* quad vertex count */);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays call failed.");
gl.endTransformFeedback();
GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback call failed.");
gl.disable(GL_RASTERIZER_DISCARD);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDisable call failed.");
}
void gl3cts::TransformFeedback::DrawXFBStreamInstanced::drawStreamInstanced()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_id_xfb_position);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
glw::GLuint position_location = gl.getAttribLocation(m_program_id_draw, "position");
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation call failed.");
gl.vertexAttribPointer(position_location, 4, GL_FLOAT, GL_FALSE, 0, NULL);
GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer call failed.");
gl.enableVertexAttribArray(position_location);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray call failed.");
gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_id_xfb_color);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed.");
glw::GLuint color_location = gl.getAttribLocation(m_program_id_draw, "color");
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation call failed.");
gl.vertexAttribPointer(color_location, 4, GL_FLOAT, GL_FALSE, 0, NULL);
GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer call failed.");
gl.enableVertexAttribArray(color_location);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray call failed.");
gl.useProgram(m_program_id_draw);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed.");
gl.drawTransformFeedbackStreamInstanced(GL_TRIANGLE_STRIP, m_xfb_id, 0, 4);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays call failed.");
}
bool gl3cts::TransformFeedback::DrawXFBStreamInstanced::check()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Number of pixels. */
const glw::GLuint number_of_pixels = s_view_size * s_view_size;
/* Fetch framebuffer. */
std::vector<glw::GLfloat> pixels(number_of_pixels);
gl.readPixels(0, 0, s_view_size, s_view_size, GL_RED, GL_FLOAT, &pixels[0]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels call failed.");
/* Check results. */
for (glw::GLuint i = 0; i < number_of_pixels; ++i)
{
if (fabs(pixels[i] - 1.f) > 0.0625 /* precision, expected result == 1.0 */)
{
return false;
}
}
return true;
}
void gl3cts::TransformFeedback::DrawXFBStreamInstanced::clean()
{
/* Functions handler */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.useProgram(0);
if (m_program_id_generate)
{
gl.deleteProgram(m_program_id_generate);
m_program_id_generate = 0;
}
if (m_program_id_draw)
{
glw::GLuint position_location = gl.getAttribLocation(m_program_id_draw, "position");
gl.disableVertexAttribArray(position_location);
glw::GLuint color_location = gl.getAttribLocation(m_program_id_draw, "color");
gl.disableVertexAttribArray(color_location);
gl.deleteProgram(m_program_id_draw);
m_program_id_draw = 0;
}
if (m_xfb_id)
{
gl.deleteTransformFeedbacks(1, &m_xfb_id);
m_xfb_id = 0;
}
if (m_bo_id_xfb_position)
{
gl.deleteBuffers(1, &m_bo_id_xfb_position);
m_bo_id_xfb_position = 0;
}
if (m_bo_id_xfb_color)
{
gl.deleteBuffers(1, &m_bo_id_xfb_color);
m_bo_id_xfb_position = 0;
}
if (m_bo_id_uniform)
{
gl.deleteBuffers(1, &m_bo_id_uniform);
m_bo_id_uniform = 0;
}
if (m_vao_id)
{
gl.deleteVertexArrays(1, &m_vao_id);
m_vao_id = 0;
}
if (m_fbo_id)
{
gl.deleteFramebuffers(1, &m_fbo_id);
m_fbo_id = 0;
}
if (m_rbo_id)
{
gl.deleteRenderbuffers(1, &m_rbo_id);
m_rbo_id = 0;
}
}
const glw::GLchar* gl3cts::TransformFeedback::DrawXFBStreamInstanced::s_vertex_shader_blank = "#version 140\n"
"\n"
"void main()\n"
"{\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::DrawXFBStreamInstanced::s_geometry_shader_generate =
"#version 400\n"
"\n"
"layout(points) in;\n"
"layout(points, max_vertices = 8) out;\n"
"\n"
"layout(stream = 1) out vec4 color;\n"
"\n"
"void main()\n"
"{\n"
" gl_Position = vec4(-1.0, -1.0, 0.0, 1.0);\n"
" EmitStreamVertex(0);\n"
" gl_Position = vec4( 1.0, -1.0, 0.0, 1.0);\n"
" EmitStreamVertex(0);\n"
" gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n"
" EmitStreamVertex(0);\n"
" gl_Position = vec4( 1.0, 1.0, 0.0, 1.0);\n"
" EmitStreamVertex(0);\n"
"\n"
" color = vec4(1.0, 1.0, 1.0, 1.0);\n"
" EmitStreamVertex(1);\n"
" color = vec4(1.0, 1.0, 1.0, 1.0);\n"
" EmitStreamVertex(1);\n"
" color = vec4(1.0, 1.0, 1.0, 1.0);\n"
" EmitStreamVertex(1);\n"
" color = vec4(1.0, 1.0, 1.0, 1.0);\n"
" EmitStreamVertex(1);\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::DrawXFBStreamInstanced::s_vertex_shader_draw =
"#version 140\n"
"\n"
"uniform MatrixBlock\n"
"{\n"
" mat4 transformation_0;\n"
" mat4 transformation_1;\n"
" mat4 transformation_2;\n"
" mat4 transformation_3;\n"
"};\n"
"\n"
"in vec4 position;\n"
"in vec4 color;\n"
"out vec4 colour;\n"
"\n"
"void main()\n"
"{\n"
" switch(gl_InstanceID % 4)\n"
" {\n"
" case 0:\n"
" gl_Position = position * transformation_0;\n"
" break;\n"
" case 1:\n"
" gl_Position = position * transformation_1;\n"
" break;\n"
" case 2:\n"
" gl_Position = position * transformation_2;\n"
" break;\n"
" case 3:\n"
" gl_Position = position * transformation_3;\n"
" break;\n"
" }\n"
" colour = color;\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::DrawXFBStreamInstanced::s_fragment_shader_blank =
"#version 130\n"
"\n"
"out vec4 pixel;\n"
"\n"
"void main()\n"
"{\n"
" pixel = vec4(1.0);\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::DrawXFBStreamInstanced::s_fragment_shader_draw = "#version 130\n"
"\n"
"in vec4 colour;\n"
"out vec4 pixel;\n"
"\n"
"void main()\n"
"{\n"
" pixel = colour;\n"
"}\n";
const glw::GLchar* gl3cts::TransformFeedback::DrawXFBStreamInstanced::s_xfb_varyings[] = { "gl_Position",
"gl_NextBuffer", "color" };
const glw::GLuint gl3cts::TransformFeedback::DrawXFBStreamInstanced::s_xfb_varyings_count =
sizeof(s_xfb_varyings) / sizeof(s_xfb_varyings[0]);
const glw::GLchar* gl3cts::TransformFeedback::DrawXFBStreamInstanced::s_uniform = "MatrixBlock";
const glw::GLuint gl3cts::TransformFeedback::DrawXFBStreamInstanced::s_bo_xfb_size =
4 /* vertex count */ * 4 /* vec4 components */
* sizeof(glw::GLfloat) /* data type size */;
const glw::GLfloat gl3cts::TransformFeedback::DrawXFBStreamInstanced::s_bo_uniform_data[] = {
0.5f, 0.0f, 0.0f, 0.5f, 0.0f, 0.5f, 0.0f, 0.5f, 0.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
0.5f, 0.0f, 0.0f, -0.5f, 0.0f, 0.5f, 0.0f, 0.5f, 0.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
0.5f, 0.0f, 0.0f, -0.5f, 0.0f, 0.5f, 0.0f, -0.5f, 0.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
0.5f, 0.0f, 0.0f, 0.5f, 0.0f, 0.5f, 0.0f, -0.5f, 0.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f
};
const glw::GLuint gl3cts::TransformFeedback::DrawXFBStreamInstanced::s_bo_uniform_size = sizeof(s_bo_uniform_data);
const glw::GLuint gl3cts::TransformFeedback::DrawXFBStreamInstanced::s_view_size = 4;
/*-----------------------------------------------------------------------------------------------*/
glw::GLuint gl3cts::TransformFeedback::Utilities::buildProgram(
glw::Functions const& gl, tcu::TestLog& log, glw::GLchar const* const geometry_shader_source,
glw::GLchar const* const tessellation_control_shader_source,
glw::GLchar const* const tessellation_evaluation_shader_source, glw::GLchar const* const vertex_shader_source,
glw::GLchar const* const fragment_shader_source, glw::GLchar const* const* const transform_feedback_varyings,
glw::GLsizei const transform_feedback_varyings_count, glw::GLenum const transform_feedback_varyings_mode,
bool const do_not_detach, glw::GLint* linking_status)
{
glw::GLuint program = 0;
struct Shader
{
glw::GLchar const* const source;
glw::GLenum const type;
glw::GLuint id;
} shader[] = { { geometry_shader_source, GL_GEOMETRY_SHADER, 0 },
{ tessellation_control_shader_source, GL_TESS_CONTROL_SHADER, 0 },
{ tessellation_evaluation_shader_source, GL_TESS_EVALUATION_SHADER, 0 },
{ vertex_shader_source, GL_VERTEX_SHADER, 0 },
{ fragment_shader_source, GL_FRAGMENT_SHADER, 0 } };
glw::GLuint const shader_count = sizeof(shader) / sizeof(shader[0]);
try
{
/* Create program. */
program = gl.createProgram();
GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram call failed.");
/* Shader compilation. */
for (glw::GLuint i = 0; i < shader_count; ++i)
{
if (DE_NULL != shader[i].source)
{
shader[i].id = gl.createShader(shader[i].type);
GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader call failed.");
gl.attachShader(program, shader[i].id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader call failed.");
gl.shaderSource(shader[i].id, 1, &(shader[i].source), NULL);
GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource call failed.");
gl.compileShader(shader[i].id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader call failed.");
glw::GLint status = GL_FALSE;
gl.getShaderiv(shader[i].id, GL_COMPILE_STATUS, &status);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv call failed.");
if (GL_FALSE == status)
{
glw::GLint log_size = 0;
gl.getShaderiv(shader[i].id, GL_INFO_LOG_LENGTH, &log_size);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv call failed.");
glw::GLchar* log_text = new glw::GLchar[log_size];
gl.getShaderInfoLog(shader[i].id, log_size, NULL, &log_text[0]);
log << tcu::TestLog::Message << "Shader compilation has failed.\n"
<< "Shader type: " << glu::getShaderTypeStr(shader[i].type) << "\n"
<< "Shader compilation error log:\n"
<< log_text << "\n"
<< "Shader source code:\n"
<< shader[i].source << "\n"
<< tcu::TestLog::EndMessage;
delete[] log_text;
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderInfoLog call failed.");
throw 0;
}
}
}
/* Link. */
if (transform_feedback_varyings_count)
{
gl.transformFeedbackVaryings(program, transform_feedback_varyings_count, transform_feedback_varyings,
transform_feedback_varyings_mode);
GLU_EXPECT_NO_ERROR(gl.getError(), "glTransformFeedbackVaryings call failed.");
}
gl.linkProgram(program);
GLU_EXPECT_NO_ERROR(gl.getError(), "glTransformFeedbackVaryings call failed.");
glw::GLint status = GL_FALSE;
gl.getProgramiv(program, GL_LINK_STATUS, &status);
if (DE_NULL != linking_status)
{
*linking_status = status;
}
if (GL_TRUE == status)
{
if (!do_not_detach)
{
for (glw::GLuint i = 0; i < shader_count; ++i)
{
if (shader[i].id)
{
gl.detachShader(program, shader[i].id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDetachShader call failed.");
}
}
}
}
else
{
glw::GLint log_size = 0;
gl.getProgramiv(program, GL_INFO_LOG_LENGTH, &log_size);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv call failed.");
glw::GLchar* log_text = new glw::GLchar[log_size];
gl.getProgramInfoLog(program, log_size, NULL, &log_text[0]);
log << tcu::TestLog::Message << "Program linkage has failed due to:\n"
<< log_text << "\n"
<< tcu::TestLog::EndMessage;
delete[] log_text;
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramInfoLog call failed.");
throw 0;
}
}
catch (...)
{
if (program)
{
gl.deleteProgram(program);
program = 0;
}
}
for (glw::GLuint i = 0; i < shader_count; ++i)
{
if (0 != shader[i].id)
{
gl.deleteShader(shader[i].id);
shader[i].id = 0;
}
}
return program;
}
/** @brief Substitute key with value within source code.
*
* @param [in] source Source code to be prerocessed.
* @param [in] key Key to be substituted.
* @param [in] value Value to be inserted.
*
* @return Resulting string.
*/
std::string gl3cts::TransformFeedback::Utilities::preprocessCode(std::string source, std::string key, std::string value)
{
std::string destination = source;
while (true)
{
/* Find token in source code. */
size_t position = destination.find(key, 0);
/* No more occurences of this key. */
if (position == std::string::npos)
{
break;
}
/* Replace token with sub_code. */
destination.replace(position, key.size(), value);
}
return destination;
}
/** @brief Convert an integer to a string.
*
* @param [in] i Integer to be converted.
*
* @return String representing integer.
*/
std::string gl3cts::TransformFeedback::Utilities::itoa(glw::GLint i)
{
std::stringstream stream;
stream << i;
return stream.str();
}
/** @brief Convert an float to a string.
*
* @param [in] f Float to be converted.
*
* @return String representing integer.
*/
std::string gl3cts::TransformFeedback::Utilities::ftoa(glw::GLfloat f)
{
std::stringstream stream;
stream << f;
return stream.str();
}