You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
530 lines
16 KiB
530 lines
16 KiB
/*-------------------------------------------------------------------------
|
|
* drawElements Quality Program OpenGL ES 3.0 Module
|
|
* -------------------------------------------------
|
|
*
|
|
* Copyright 2014 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
*//*!
|
|
* \file
|
|
* \brief Indexed State Query tests.
|
|
*//*--------------------------------------------------------------------*/
|
|
|
|
#include "es3fIndexedStateQueryTests.hpp"
|
|
#include "es3fApiCase.hpp"
|
|
#include "glsStateQueryUtil.hpp"
|
|
#include "tcuRenderTarget.hpp"
|
|
#include "glwEnums.hpp"
|
|
|
|
using namespace glw; // GLint and other GL types
|
|
using deqp::gls::StateQueryUtil::StateQueryMemoryWriteGuard;
|
|
|
|
namespace deqp
|
|
{
|
|
namespace gles3
|
|
{
|
|
namespace Functional
|
|
{
|
|
namespace
|
|
{
|
|
|
|
void checkIntEquals (tcu::TestContext& testCtx, GLint got, GLint expected)
|
|
{
|
|
using tcu::TestLog;
|
|
|
|
if (got != expected)
|
|
{
|
|
testCtx.getLog() << TestLog::Message << "// ERROR: Expected " << expected << "; got " << got << TestLog::EndMessage;
|
|
if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
|
|
testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid value");
|
|
}
|
|
}
|
|
|
|
void checkIntEquals (tcu::TestContext& testCtx, GLint64 got, GLint64 expected)
|
|
{
|
|
using tcu::TestLog;
|
|
|
|
if (got != expected)
|
|
{
|
|
testCtx.getLog() << TestLog::Message << "// ERROR: Expected " << expected << "; got " << got << TestLog::EndMessage;
|
|
if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
|
|
testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid value");
|
|
}
|
|
}
|
|
|
|
class TransformFeedbackCase : public ApiCase
|
|
{
|
|
public:
|
|
TransformFeedbackCase (Context& context, const char* name, const char* description)
|
|
: ApiCase(context, name, description)
|
|
{
|
|
}
|
|
|
|
virtual void testTransformFeedback (void) = DE_NULL;
|
|
|
|
void test (void)
|
|
{
|
|
static const char* transformFeedbackTestVertSource = "#version 300 es\n"
|
|
"out highp vec4 anotherOutput;\n"
|
|
"void main (void)\n"
|
|
"{\n"
|
|
" gl_Position = vec4(0.0);\n"
|
|
" anotherOutput = vec4(0.0);\n"
|
|
"}\n\0";
|
|
static const char* transformFeedbackTestFragSource = "#version 300 es\n"
|
|
"layout(location = 0) out mediump vec4 fragColor;"
|
|
"void main (void)\n"
|
|
"{\n"
|
|
" fragColor = vec4(0.0);\n"
|
|
"}\n\0";
|
|
|
|
GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER);
|
|
GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER);
|
|
|
|
glShaderSource(shaderVert, 1, &transformFeedbackTestVertSource, DE_NULL);
|
|
glShaderSource(shaderFrag, 1, &transformFeedbackTestFragSource, DE_NULL);
|
|
|
|
glCompileShader(shaderVert);
|
|
glCompileShader(shaderFrag);
|
|
expectError(GL_NO_ERROR);
|
|
|
|
GLuint shaderProg = glCreateProgram();
|
|
glAttachShader(shaderProg, shaderVert);
|
|
glAttachShader(shaderProg, shaderFrag);
|
|
|
|
const char* transformFeedbackOutputs[] =
|
|
{
|
|
"gl_Position",
|
|
"anotherOutput"
|
|
};
|
|
|
|
glTransformFeedbackVaryings(shaderProg, 2, transformFeedbackOutputs, GL_INTERLEAVED_ATTRIBS);
|
|
glLinkProgram(shaderProg);
|
|
expectError(GL_NO_ERROR);
|
|
|
|
glGenTransformFeedbacks(2, transformFeedbacks);
|
|
// Also store the default transform feedback in the array.
|
|
transformFeedbacks[2] = 0;
|
|
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformFeedbacks[0]);
|
|
expectError(GL_NO_ERROR);
|
|
|
|
testTransformFeedback();
|
|
|
|
// cleanup
|
|
|
|
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
|
|
|
|
glDeleteTransformFeedbacks(2, transformFeedbacks);
|
|
glDeleteShader(shaderVert);
|
|
glDeleteShader(shaderFrag);
|
|
glDeleteProgram(shaderProg);
|
|
expectError(GL_NO_ERROR);
|
|
}
|
|
protected:
|
|
GLuint transformFeedbacks[3];
|
|
};
|
|
|
|
class TransformFeedbackBufferBindingCase : public TransformFeedbackCase
|
|
{
|
|
public:
|
|
TransformFeedbackBufferBindingCase (Context& context, const char* name, const char* description)
|
|
: TransformFeedbackCase(context, name, description)
|
|
{
|
|
}
|
|
|
|
void testTransformFeedback (void)
|
|
{
|
|
const int feedbackPositionIndex = 0;
|
|
const int feedbackOutputIndex = 1;
|
|
const int feedbackIndex[2] = {feedbackPositionIndex, feedbackOutputIndex};
|
|
|
|
// bind bffers
|
|
|
|
GLuint feedbackBuffers[2];
|
|
glGenBuffers(2, feedbackBuffers);
|
|
expectError(GL_NO_ERROR);
|
|
|
|
for (int ndx = 0; ndx < 2; ++ndx)
|
|
{
|
|
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, feedbackBuffers[ndx]);
|
|
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 16, NULL, GL_DYNAMIC_READ);
|
|
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, feedbackIndex[ndx], feedbackBuffers[ndx]);
|
|
expectError(GL_NO_ERROR);
|
|
}
|
|
|
|
// test TRANSFORM_FEEDBACK_BUFFER_BINDING
|
|
|
|
for (int ndx = 0; ndx < 2; ++ndx)
|
|
{
|
|
StateQueryMemoryWriteGuard<GLint> boundBuffer;
|
|
glGetIntegeri_v(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, feedbackIndex[ndx], &boundBuffer);
|
|
boundBuffer.verifyValidity(m_testCtx);
|
|
checkIntEquals(m_testCtx, boundBuffer, feedbackBuffers[ndx]);
|
|
}
|
|
|
|
|
|
// cleanup
|
|
|
|
glDeleteBuffers(2, feedbackBuffers);
|
|
}
|
|
};
|
|
|
|
class TransformFeedbackBufferBufferCase : public TransformFeedbackCase
|
|
{
|
|
public:
|
|
TransformFeedbackBufferBufferCase (Context& context, const char* name, const char* description)
|
|
: TransformFeedbackCase(context, name, description)
|
|
{
|
|
}
|
|
|
|
void testTransformFeedback (void)
|
|
{
|
|
const int feedbackPositionIndex = 0;
|
|
const int feedbackOutputIndex = 1;
|
|
|
|
const int rangeBufferOffset = 4;
|
|
const int rangeBufferSize = 8;
|
|
|
|
// bind buffers
|
|
|
|
GLuint feedbackBuffers[2];
|
|
glGenBuffers(2, feedbackBuffers);
|
|
expectError(GL_NO_ERROR);
|
|
|
|
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, feedbackBuffers[0]);
|
|
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 16, NULL, GL_DYNAMIC_READ);
|
|
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, feedbackPositionIndex, feedbackBuffers[0]);
|
|
expectError(GL_NO_ERROR);
|
|
|
|
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, feedbackBuffers[1]);
|
|
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 16, NULL, GL_DYNAMIC_READ);
|
|
glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, feedbackOutputIndex, feedbackBuffers[1], rangeBufferOffset, rangeBufferSize);
|
|
expectError(GL_NO_ERROR);
|
|
|
|
// test TRANSFORM_FEEDBACK_BUFFER_START and TRANSFORM_FEEDBACK_BUFFER_SIZE
|
|
|
|
const struct BufferRequirements
|
|
{
|
|
GLint index;
|
|
GLenum pname;
|
|
GLint64 value;
|
|
} requirements[] =
|
|
{
|
|
{ feedbackPositionIndex, GL_TRANSFORM_FEEDBACK_BUFFER_START, 0 },
|
|
{ feedbackPositionIndex, GL_TRANSFORM_FEEDBACK_BUFFER_SIZE, 0 },
|
|
{ feedbackOutputIndex, GL_TRANSFORM_FEEDBACK_BUFFER_START, rangeBufferOffset },
|
|
{ feedbackOutputIndex, GL_TRANSFORM_FEEDBACK_BUFFER_SIZE, rangeBufferSize }
|
|
};
|
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(requirements); ++ndx)
|
|
{
|
|
StateQueryMemoryWriteGuard<GLint64> state;
|
|
glGetInteger64i_v(requirements[ndx].pname, requirements[ndx].index, &state);
|
|
|
|
if (state.verifyValidity(m_testCtx))
|
|
checkIntEquals(m_testCtx, state, requirements[ndx].value);
|
|
}
|
|
|
|
// cleanup
|
|
|
|
glDeleteBuffers(2, feedbackBuffers);
|
|
}
|
|
};
|
|
|
|
class TransformFeedbackSwitchingBufferCase : public TransformFeedbackCase
|
|
{
|
|
public:
|
|
TransformFeedbackSwitchingBufferCase (Context& context, const char* name, const char* description)
|
|
: TransformFeedbackCase(context, name, description)
|
|
{
|
|
}
|
|
|
|
void testTransformFeedback (void)
|
|
{
|
|
GLuint feedbackBuffers[3];
|
|
glGenBuffers(3, feedbackBuffers);
|
|
expectError(GL_NO_ERROR);
|
|
|
|
for (int i = 0; i < 3; ++i)
|
|
{
|
|
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformFeedbacks[i]);
|
|
expectError(GL_NO_ERROR);
|
|
GLint value;
|
|
glGetIntegeri_v(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, 0, &value);
|
|
expectError(GL_NO_ERROR);
|
|
checkIntEquals(m_testCtx, value, 0);
|
|
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, feedbackBuffers[i]);
|
|
expectError(GL_NO_ERROR);
|
|
// glBindBufferBase should also set the generic binding point.
|
|
glGetIntegerv(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, &value);
|
|
expectError(GL_NO_ERROR);
|
|
checkIntEquals(m_testCtx, value, feedbackBuffers[i]);
|
|
}
|
|
|
|
for (int i = 0; i < 3; ++i)
|
|
{
|
|
// glBindTransformFeedback should change the indexed binding points, but
|
|
// not the generic one.
|
|
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformFeedbacks[i]);
|
|
expectError(GL_NO_ERROR);
|
|
GLint value;
|
|
glGetIntegeri_v(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, 0, &value);
|
|
expectError(GL_NO_ERROR);
|
|
checkIntEquals(m_testCtx, value, feedbackBuffers[i]);
|
|
glGetIntegerv(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, &value);
|
|
expectError(GL_NO_ERROR);
|
|
// Should be unchanged.
|
|
checkIntEquals(m_testCtx, value, feedbackBuffers[2]);
|
|
}
|
|
|
|
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformFeedbacks[0]);
|
|
expectError(GL_NO_ERROR);
|
|
glDeleteBuffers(3, feedbackBuffers);
|
|
expectError(GL_NO_ERROR);
|
|
|
|
// After deleting buffers the bound state should be changed but unbound
|
|
// state should be unchanged.
|
|
|
|
GLint value;
|
|
glGetIntegeri_v(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, 0, &value);
|
|
expectError(GL_NO_ERROR);
|
|
checkIntEquals(m_testCtx, value, 0);
|
|
glGetIntegerv(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, &value);
|
|
expectError(GL_NO_ERROR);
|
|
checkIntEquals(m_testCtx, value, 0);
|
|
|
|
for (int i = 1; i < 3; ++i)
|
|
{
|
|
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformFeedbacks[i]);
|
|
expectError(GL_NO_ERROR);
|
|
glGetIntegeri_v(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, 0, &value);
|
|
expectError(GL_NO_ERROR);
|
|
checkIntEquals(m_testCtx, value, feedbackBuffers[i]);
|
|
glGetIntegerv(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, &value);
|
|
expectError(GL_NO_ERROR);
|
|
checkIntEquals(m_testCtx, value, 0);
|
|
}
|
|
}
|
|
};
|
|
|
|
class UniformBufferCase : public ApiCase
|
|
{
|
|
public:
|
|
UniformBufferCase (Context& context, const char* name, const char* description)
|
|
: ApiCase (context, name, description)
|
|
, m_program (0)
|
|
{
|
|
}
|
|
|
|
virtual void testUniformBuffers (void) = DE_NULL;
|
|
|
|
void test (void)
|
|
{
|
|
static const char* testVertSource = "#version 300 es\n"
|
|
"uniform highp vec4 input1;\n"
|
|
"uniform highp vec4 input2;\n"
|
|
"void main (void)\n"
|
|
"{\n"
|
|
" gl_Position = input1 + input2;\n"
|
|
"}\n\0";
|
|
static const char* testFragSource = "#version 300 es\n"
|
|
"layout(location = 0) out mediump vec4 fragColor;"
|
|
"void main (void)\n"
|
|
"{\n"
|
|
" fragColor = vec4(0.0);\n"
|
|
"}\n\0";
|
|
|
|
GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER);
|
|
GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER);
|
|
|
|
glShaderSource(shaderVert, 1, &testVertSource, DE_NULL);
|
|
glShaderSource(shaderFrag, 1, &testFragSource, DE_NULL);
|
|
|
|
glCompileShader(shaderVert);
|
|
glCompileShader(shaderFrag);
|
|
expectError(GL_NO_ERROR);
|
|
|
|
m_program = glCreateProgram();
|
|
glAttachShader(m_program, shaderVert);
|
|
glAttachShader(m_program, shaderFrag);
|
|
glLinkProgram(m_program);
|
|
glUseProgram(m_program);
|
|
expectError(GL_NO_ERROR);
|
|
|
|
testUniformBuffers();
|
|
|
|
glUseProgram(0);
|
|
glDeleteShader(shaderVert);
|
|
glDeleteShader(shaderFrag);
|
|
glDeleteProgram(m_program);
|
|
expectError(GL_NO_ERROR);
|
|
}
|
|
|
|
protected:
|
|
GLuint m_program;
|
|
};
|
|
|
|
class UniformBufferBindingCase : public UniformBufferCase
|
|
{
|
|
public:
|
|
UniformBufferBindingCase (Context& context, const char* name, const char* description)
|
|
: UniformBufferCase(context, name, description)
|
|
{
|
|
}
|
|
|
|
void testUniformBuffers (void)
|
|
{
|
|
const char* uniformNames[] =
|
|
{
|
|
"input1",
|
|
"input2"
|
|
};
|
|
GLuint uniformIndices[2] = {0};
|
|
glGetUniformIndices(m_program, 2, uniformNames, uniformIndices);
|
|
|
|
GLuint buffers[2];
|
|
glGenBuffers(2, buffers);
|
|
|
|
for (int ndx = 0; ndx < 2; ++ndx)
|
|
{
|
|
glBindBuffer(GL_UNIFORM_BUFFER, buffers[ndx]);
|
|
glBufferData(GL_UNIFORM_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
|
|
glBindBufferBase(GL_UNIFORM_BUFFER, uniformIndices[ndx], buffers[ndx]);
|
|
expectError(GL_NO_ERROR);
|
|
}
|
|
|
|
for (int ndx = 0; ndx < 2; ++ndx)
|
|
{
|
|
StateQueryMemoryWriteGuard<GLint> boundBuffer;
|
|
glGetIntegeri_v(GL_UNIFORM_BUFFER_BINDING, uniformIndices[ndx], &boundBuffer);
|
|
|
|
if (boundBuffer.verifyValidity(m_testCtx))
|
|
checkIntEquals(m_testCtx, boundBuffer, buffers[ndx]);
|
|
expectError(GL_NO_ERROR);
|
|
}
|
|
|
|
glDeleteBuffers(2, buffers);
|
|
}
|
|
};
|
|
|
|
class UniformBufferBufferCase : public UniformBufferCase
|
|
{
|
|
public:
|
|
UniformBufferBufferCase (Context& context, const char* name, const char* description)
|
|
: UniformBufferCase(context, name, description)
|
|
{
|
|
}
|
|
|
|
void testUniformBuffers (void)
|
|
{
|
|
const char* uniformNames[] =
|
|
{
|
|
"input1",
|
|
"input2"
|
|
};
|
|
GLuint uniformIndices[2] = {0};
|
|
glGetUniformIndices(m_program, 2, uniformNames, uniformIndices);
|
|
|
|
const GLint alignment = GetAlignment();
|
|
if (alignment == -1) // cannot continue without this
|
|
return;
|
|
|
|
m_testCtx.getLog() << tcu::TestLog::Message << "Alignment is " << alignment << tcu::TestLog::EndMessage;
|
|
|
|
int rangeBufferOffset = alignment;
|
|
int rangeBufferSize = alignment * 2;
|
|
int rangeBufferTotalSize = rangeBufferOffset + rangeBufferSize + 8; // + 8 has no special meaning, just to make it != with the size of the range
|
|
|
|
GLuint buffers[2];
|
|
glGenBuffers(2, buffers);
|
|
|
|
glBindBuffer(GL_UNIFORM_BUFFER, buffers[0]);
|
|
glBufferData(GL_UNIFORM_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
|
|
glBindBufferBase(GL_UNIFORM_BUFFER, uniformIndices[0], buffers[0]);
|
|
expectError(GL_NO_ERROR);
|
|
|
|
glBindBuffer(GL_UNIFORM_BUFFER, buffers[1]);
|
|
glBufferData(GL_UNIFORM_BUFFER, rangeBufferTotalSize, DE_NULL, GL_DYNAMIC_DRAW);
|
|
glBindBufferRange(GL_UNIFORM_BUFFER, uniformIndices[1], buffers[1], rangeBufferOffset, rangeBufferSize);
|
|
expectError(GL_NO_ERROR);
|
|
|
|
// test UNIFORM_BUFFER_START and UNIFORM_BUFFER_SIZE
|
|
|
|
const struct BufferRequirements
|
|
{
|
|
GLuint index;
|
|
GLenum pname;
|
|
GLint64 value;
|
|
} requirements[] =
|
|
{
|
|
{ uniformIndices[0], GL_UNIFORM_BUFFER_START, 0 },
|
|
{ uniformIndices[0], GL_UNIFORM_BUFFER_SIZE, 0 },
|
|
{ uniformIndices[1], GL_UNIFORM_BUFFER_START, rangeBufferOffset },
|
|
{ uniformIndices[1], GL_UNIFORM_BUFFER_SIZE, rangeBufferSize }
|
|
};
|
|
|
|
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(requirements); ++ndx)
|
|
{
|
|
StateQueryMemoryWriteGuard<GLint64> state;
|
|
glGetInteger64i_v(requirements[ndx].pname, requirements[ndx].index, &state);
|
|
|
|
if (state.verifyValidity(m_testCtx))
|
|
checkIntEquals(m_testCtx, state, requirements[ndx].value);
|
|
expectError(GL_NO_ERROR);
|
|
}
|
|
|
|
glDeleteBuffers(2, buffers);
|
|
}
|
|
|
|
int GetAlignment()
|
|
{
|
|
StateQueryMemoryWriteGuard<GLint> state;
|
|
glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &state);
|
|
|
|
if (!state.verifyValidity(m_testCtx))
|
|
return -1;
|
|
|
|
if (state <= 256)
|
|
return state;
|
|
|
|
m_testCtx.getLog() << tcu::TestLog::Message << "// ERROR: UNIFORM_BUFFER_OFFSET_ALIGNMENT has a maximum value of 256." << tcu::TestLog::EndMessage;
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "invalid UNIFORM_BUFFER_OFFSET_ALIGNMENT value");
|
|
|
|
return -1;
|
|
}
|
|
};
|
|
|
|
} // anonymous
|
|
|
|
IndexedStateQueryTests::IndexedStateQueryTests (Context& context)
|
|
: TestCaseGroup(context, "indexed", "Indexed Integer Values")
|
|
{
|
|
}
|
|
|
|
void IndexedStateQueryTests::init (void)
|
|
{
|
|
// transform feedback
|
|
addChild(new TransformFeedbackBufferBindingCase(m_context, "transform_feedback_buffer_binding", "TRANSFORM_FEEDBACK_BUFFER_BINDING"));
|
|
addChild(new TransformFeedbackBufferBufferCase(m_context, "transform_feedback_buffer_start_size", "TRANSFORM_FEEDBACK_BUFFER_START and TRANSFORM_FEEDBACK_BUFFER_SIZE"));
|
|
addChild(new TransformFeedbackSwitchingBufferCase(m_context, "transform_feedback_switching_buffer", "TRANSFORM_FEEDBACK_BUFFER_BINDING while switching transform feedback objects"));
|
|
|
|
// uniform buffers
|
|
addChild(new UniformBufferBindingCase(m_context, "uniform_buffer_binding", "UNIFORM_BUFFER_BINDING"));
|
|
addChild(new UniformBufferBufferCase(m_context, "uniform_buffer_start_size", "UNIFORM_BUFFER_START and UNIFORM_BUFFER_SIZE"));
|
|
}
|
|
|
|
} // Functional
|
|
} // gles3
|
|
} // deqp
|