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.
661 lines
22 KiB
661 lines
22 KiB
4 months ago
|
/*-------------------------------------------------------------------------
|
||
|
|
* drawElements Quality Program OpenGL ES 3.1 Module
|
||
|
|
* -------------------------------------------------
|
||
|
|
*
|
||
|
|
* Copyright 2014 The Android Open Source Project
|
||
|
|
*
|
||
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
|
|
* you may not use this file except in compliance with the License.
|
||
|
|
* You may obtain a copy of the License at
|
||
|
|
*
|
||
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||
|
|
*
|
||
|
|
* Unless required by applicable law or agreed to in writing, software
|
||
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
|
|
* See the License for the specific language governing permissions and
|
||
|
|
* limitations under the License.
|
||
|
|
*
|
||
|
|
*//*!
|
||
|
|
* \file
|
||
|
|
* \brief Vertex attribute binding stress tests.
|
||
|
|
*//*--------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
#include "es31sVertexAttributeBindingTests.hpp"
|
||
|
|
#include "tcuVector.hpp"
|
||
|
|
#include "tcuTestLog.hpp"
|
||
|
|
#include "tcuRenderTarget.hpp"
|
||
|
|
#include "tcuSurface.hpp"
|
||
|
|
#include "gluCallLogWrapper.hpp"
|
||
|
|
#include "gluObjectWrapper.hpp"
|
||
|
|
#include "gluPixelTransfer.hpp"
|
||
|
|
#include "gluRenderContext.hpp"
|
||
|
|
#include "gluShaderProgram.hpp"
|
||
|
|
#include "gluStrUtil.hpp"
|
||
|
|
#include "glwFunctions.hpp"
|
||
|
|
#include "glwEnums.hpp"
|
||
|
|
#include "deStringUtil.hpp"
|
||
|
|
|
||
|
|
namespace deqp
|
||
|
|
{
|
||
|
|
namespace gles31
|
||
|
|
{
|
||
|
|
namespace Stress
|
||
|
|
{
|
||
|
|
namespace
|
||
|
|
{
|
||
|
|
|
||
|
|
static const char* const s_vertexSource = "#version 310 es\n"
|
||
|
|
"in highp vec4 a_position;\n"
|
||
|
|
"void main (void)\n"
|
||
|
|
"{\n"
|
||
|
|
" gl_Position = a_position;\n"
|
||
|
|
"}\n";
|
||
|
|
|
||
|
|
static const char* const s_fragmentSource = "#version 310 es\n"
|
||
|
|
"layout(location = 0) out mediump vec4 fragColor;\n"
|
||
|
|
"void main (void)\n"
|
||
|
|
"{\n"
|
||
|
|
" fragColor = vec4(1.0, 1.0, 1.0, 1.0);\n"
|
||
|
|
"}\n";
|
||
|
|
|
||
|
|
static const char* const s_colorFragmentShader = "#version 310 es\n"
|
||
|
|
"in mediump vec4 v_color;\n"
|
||
|
|
"layout(location = 0) out mediump vec4 fragColor;\n"
|
||
|
|
"void main (void)\n"
|
||
|
|
"{\n"
|
||
|
|
" fragColor = v_color;\n"
|
||
|
|
"}\n";
|
||
|
|
|
||
|
|
// Verifies image contains only yellow or greeen, or a linear combination
|
||
|
|
// of these colors.
|
||
|
|
static bool verifyImageYellowGreen (const tcu::Surface& image, tcu::TestLog& log, bool logImageOnSuccess)
|
||
|
|
{
|
||
|
|
using tcu::TestLog;
|
||
|
|
|
||
|
|
const int colorThreshold = 20;
|
||
|
|
|
||
|
|
tcu::Surface error (image.getWidth(), image.getHeight());
|
||
|
|
bool isOk = true;
|
||
|
|
|
||
|
|
log << TestLog::Message << "Verifying image contents." << TestLog::EndMessage;
|
||
|
|
|
||
|
|
for (int y = 0; y < image.getHeight(); y++)
|
||
|
|
for (int x = 0; x < image.getWidth(); x++)
|
||
|
|
{
|
||
|
|
const tcu::RGBA pixel = image.getPixel(x, y);
|
||
|
|
bool pixelOk = true;
|
||
|
|
|
||
|
|
// Any pixel with !(G ~= 255) is faulty (not a linear combinations of green and yellow)
|
||
|
|
if (de::abs(pixel.getGreen() - 255) > colorThreshold)
|
||
|
|
pixelOk = false;
|
||
|
|
|
||
|
|
// Any pixel with !(B ~= 0) is faulty (not a linear combinations of green and yellow)
|
||
|
|
if (de::abs(pixel.getBlue() - 0) > colorThreshold)
|
||
|
|
pixelOk = false;
|
||
|
|
|
||
|
|
error.setPixel(x, y, (pixelOk) ? (tcu::RGBA(0, 255, 0, 255)) : (tcu::RGBA(255, 0, 0, 255)));
|
||
|
|
isOk = isOk && pixelOk;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!isOk)
|
||
|
|
{
|
||
|
|
log << TestLog::Message << "Image verification failed." << TestLog::EndMessage;
|
||
|
|
log << TestLog::ImageSet("Verfication result", "Result of rendering")
|
||
|
|
<< TestLog::Image("Result", "Result", image)
|
||
|
|
<< TestLog::Image("ErrorMask", "Error mask", error)
|
||
|
|
<< TestLog::EndImageSet;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
log << TestLog::Message << "Image verification passed." << TestLog::EndMessage;
|
||
|
|
|
||
|
|
if (logImageOnSuccess)
|
||
|
|
log << TestLog::ImageSet("Verfication result", "Result of rendering")
|
||
|
|
<< TestLog::Image("Result", "Result", image)
|
||
|
|
<< TestLog::EndImageSet;
|
||
|
|
}
|
||
|
|
|
||
|
|
return isOk;
|
||
|
|
}
|
||
|
|
|
||
|
|
class BindingRenderCase : public TestCase
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
enum
|
||
|
|
{
|
||
|
|
TEST_RENDER_SIZE = 64
|
||
|
|
};
|
||
|
|
|
||
|
|
BindingRenderCase (Context& ctx, const char* name, const char* desc, bool unalignedData);
|
||
|
|
virtual ~BindingRenderCase (void);
|
||
|
|
|
||
|
|
virtual void init (void);
|
||
|
|
virtual void deinit (void);
|
||
|
|
IterateResult iterate (void);
|
||
|
|
|
||
|
|
private:
|
||
|
|
virtual void renderTo (tcu::Surface& dst) = 0;
|
||
|
|
virtual void createBuffers (void) = 0;
|
||
|
|
virtual void createShader (void) = 0;
|
||
|
|
|
||
|
|
protected:
|
||
|
|
const bool m_unalignedData;
|
||
|
|
glw::GLuint m_vao;
|
||
|
|
glu::ShaderProgram* m_program;
|
||
|
|
};
|
||
|
|
|
||
|
|
BindingRenderCase::BindingRenderCase (Context& ctx, const char* name, const char* desc, bool unalignedData)
|
||
|
|
: TestCase (ctx, name, desc)
|
||
|
|
, m_unalignedData (unalignedData)
|
||
|
|
, m_vao (0)
|
||
|
|
, m_program (DE_NULL)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
BindingRenderCase::~BindingRenderCase (void)
|
||
|
|
{
|
||
|
|
deinit();
|
||
|
|
}
|
||
|
|
|
||
|
|
void BindingRenderCase::init (void)
|
||
|
|
{
|
||
|
|
// check requirements
|
||
|
|
if (m_context.getRenderTarget().getWidth() < TEST_RENDER_SIZE || m_context.getRenderTarget().getHeight() < TEST_RENDER_SIZE)
|
||
|
|
throw tcu::NotSupportedError("Test requires at least " + de::toString<int>(TEST_RENDER_SIZE) + "x" + de::toString<int>(TEST_RENDER_SIZE) + " render target");
|
||
|
|
|
||
|
|
// resources
|
||
|
|
m_context.getRenderContext().getFunctions().genVertexArrays(1, &m_vao);
|
||
|
|
if (m_context.getRenderContext().getFunctions().getError() != GL_NO_ERROR)
|
||
|
|
throw tcu::TestError("could not gen vao");
|
||
|
|
|
||
|
|
createBuffers();
|
||
|
|
createShader();
|
||
|
|
}
|
||
|
|
|
||
|
|
void BindingRenderCase::deinit (void)
|
||
|
|
{
|
||
|
|
if (m_vao)
|
||
|
|
{
|
||
|
|
m_context.getRenderContext().getFunctions().deleteVertexArrays(1, &m_vao);
|
||
|
|
m_vao = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
delete m_program;
|
||
|
|
m_program = DE_NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
BindingRenderCase::IterateResult BindingRenderCase::iterate (void)
|
||
|
|
{
|
||
|
|
tcu::Surface surface(TEST_RENDER_SIZE, TEST_RENDER_SIZE);
|
||
|
|
|
||
|
|
// draw pattern
|
||
|
|
|
||
|
|
renderTo(surface);
|
||
|
|
|
||
|
|
// verify results
|
||
|
|
|
||
|
|
if (verifyImageYellowGreen(surface, m_testCtx.getLog(), false))
|
||
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
|
||
|
|
else if (m_unalignedData)
|
||
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_COMPATIBILITY_WARNING, "Failed to draw with unaligned data");
|
||
|
|
else
|
||
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed");
|
||
|
|
|
||
|
|
return STOP;
|
||
|
|
}
|
||
|
|
|
||
|
|
class SingleBindingCase : public BindingRenderCase
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
|
||
|
|
enum CaseFlag
|
||
|
|
{
|
||
|
|
FLAG_ATTRIB_UNALIGNED = (1<<0), // !< unalign attributes with relativeOffset
|
||
|
|
FLAG_ATTRIB_ALIGNED = (1<<1), // !< align attributes with relativeOffset to the buffer begin (and not buffer offset)
|
||
|
|
FLAG_ATTRIBS_MULTIPLE_ELEMS = (1<<2), // !< use multiple attribute elements
|
||
|
|
FLAG_ATTRIBS_SHARED_ELEMS = (1<<3), // !< use multiple shared attribute elements. xyzw & rgba stored as (x, y, zr, wg, b, a)
|
||
|
|
|
||
|
|
FLAG_BUF_ALIGNED_OFFSET = (1<<4), // !< use aligned offset to the buffer object
|
||
|
|
FLAG_BUF_UNALIGNED_OFFSET = (1<<5), // !< use unaligned offset to the buffer object
|
||
|
|
FLAG_BUF_UNALIGNED_STRIDE = (1<<6), // !< unalign buffer elements
|
||
|
|
};
|
||
|
|
SingleBindingCase (Context& ctx, const char* name, int flags);
|
||
|
|
~SingleBindingCase (void);
|
||
|
|
|
||
|
|
void init (void);
|
||
|
|
void deinit (void);
|
||
|
|
|
||
|
|
private:
|
||
|
|
struct TestSpec
|
||
|
|
{
|
||
|
|
int bufferOffset;
|
||
|
|
int bufferStride;
|
||
|
|
int positionAttrOffset;
|
||
|
|
int colorAttrOffset;
|
||
|
|
bool hasColorAttr;
|
||
|
|
};
|
||
|
|
|
||
|
|
enum
|
||
|
|
{
|
||
|
|
GRID_SIZE = 20
|
||
|
|
};
|
||
|
|
|
||
|
|
void renderTo (tcu::Surface& dst);
|
||
|
|
|
||
|
|
static TestSpec genTestSpec (int flags);
|
||
|
|
static std::string genTestDescription (int flags);
|
||
|
|
static bool isDataUnaligned (int flags);
|
||
|
|
|
||
|
|
void createBuffers (void);
|
||
|
|
void createShader (void);
|
||
|
|
std::string genVertexSource (void);
|
||
|
|
|
||
|
|
const TestSpec m_spec;
|
||
|
|
glw::GLuint m_buf;
|
||
|
|
};
|
||
|
|
|
||
|
|
SingleBindingCase::SingleBindingCase (Context& ctx, const char* name, int flags)
|
||
|
|
: BindingRenderCase (ctx, name, genTestDescription(flags).c_str(), isDataUnaligned(flags))
|
||
|
|
, m_spec (genTestSpec(flags))
|
||
|
|
, m_buf (0)
|
||
|
|
{
|
||
|
|
DE_ASSERT(!((flags & FLAG_ATTRIB_UNALIGNED) && (flags & FLAG_ATTRIB_ALIGNED)));
|
||
|
|
DE_ASSERT(!((flags & FLAG_ATTRIB_ALIGNED) && (flags & FLAG_BUF_UNALIGNED_STRIDE)));
|
||
|
|
|
||
|
|
DE_ASSERT(isDataUnaligned(flags));
|
||
|
|
}
|
||
|
|
|
||
|
|
SingleBindingCase::~SingleBindingCase (void)
|
||
|
|
{
|
||
|
|
deinit();
|
||
|
|
}
|
||
|
|
|
||
|
|
void SingleBindingCase::init (void)
|
||
|
|
{
|
||
|
|
// log what we are trying to do
|
||
|
|
|
||
|
|
m_testCtx.getLog() << tcu::TestLog::Message
|
||
|
|
<< "Rendering " << (int)GRID_SIZE << "x" << (int)GRID_SIZE << " grid.\n"
|
||
|
|
<< "Buffer format:\n"
|
||
|
|
<< " bufferOffset: " << m_spec.bufferOffset << "\n"
|
||
|
|
<< " bufferStride: " << m_spec.bufferStride << "\n"
|
||
|
|
<< "Vertex position format:\n"
|
||
|
|
<< " type: float4\n"
|
||
|
|
<< " offset: " << m_spec.positionAttrOffset << "\n"
|
||
|
|
<< " total offset: " << m_spec.bufferOffset + m_spec.positionAttrOffset << "\n"
|
||
|
|
<< tcu::TestLog::EndMessage;
|
||
|
|
|
||
|
|
if (m_spec.hasColorAttr)
|
||
|
|
m_testCtx.getLog() << tcu::TestLog::Message
|
||
|
|
<< "Color:\n"
|
||
|
|
<< " type: float4\n"
|
||
|
|
<< " offset: " << m_spec.colorAttrOffset << "\n"
|
||
|
|
<< " total offset: " << m_spec.bufferOffset + m_spec.colorAttrOffset << "\n"
|
||
|
|
<< tcu::TestLog::EndMessage;
|
||
|
|
// init
|
||
|
|
|
||
|
|
BindingRenderCase::init();
|
||
|
|
}
|
||
|
|
|
||
|
|
void SingleBindingCase::deinit (void)
|
||
|
|
{
|
||
|
|
if (m_buf)
|
||
|
|
{
|
||
|
|
m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_buf);
|
||
|
|
m_buf = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
BindingRenderCase::deinit();
|
||
|
|
}
|
||
|
|
|
||
|
|
void SingleBindingCase::renderTo (tcu::Surface& dst)
|
||
|
|
{
|
||
|
|
glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
|
||
|
|
const int positionLoc = gl.glGetAttribLocation(m_program->getProgram(), "a_position");
|
||
|
|
const int colorLoc = gl.glGetAttribLocation(m_program->getProgram(), "a_color");
|
||
|
|
const int colorUniformLoc = gl.glGetUniformLocation(m_program->getProgram(), "u_color");
|
||
|
|
|
||
|
|
gl.enableLogging(true);
|
||
|
|
|
||
|
|
gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
|
||
|
|
gl.glClear(GL_COLOR_BUFFER_BIT);
|
||
|
|
gl.glViewport(0, 0, dst.getWidth(), dst.getHeight());
|
||
|
|
gl.glBindVertexArray(m_vao);
|
||
|
|
GLU_EXPECT_NO_ERROR(gl.glGetError(), "set vao");
|
||
|
|
|
||
|
|
gl.glUseProgram(m_program->getProgram());
|
||
|
|
GLU_EXPECT_NO_ERROR(gl.glGetError(), "use program");
|
||
|
|
|
||
|
|
if (m_spec.hasColorAttr)
|
||
|
|
{
|
||
|
|
gl.glBindVertexBuffer(3, m_buf, m_spec.bufferOffset, m_spec.bufferStride);
|
||
|
|
|
||
|
|
gl.glVertexAttribBinding(positionLoc, 3);
|
||
|
|
gl.glVertexAttribFormat(positionLoc, 4, GL_FLOAT, GL_FALSE, m_spec.positionAttrOffset);
|
||
|
|
gl.glEnableVertexAttribArray(positionLoc);
|
||
|
|
|
||
|
|
gl.glVertexAttribBinding(colorLoc, 3);
|
||
|
|
gl.glVertexAttribFormat(colorLoc, 4, GL_FLOAT, GL_FALSE, m_spec.colorAttrOffset);
|
||
|
|
gl.glEnableVertexAttribArray(colorLoc);
|
||
|
|
|
||
|
|
GLU_EXPECT_NO_ERROR(gl.glGetError(), "set va");
|
||
|
|
|
||
|
|
gl.glDrawArrays(GL_TRIANGLES, 0, GRID_SIZE*GRID_SIZE*6);
|
||
|
|
GLU_EXPECT_NO_ERROR(gl.glGetError(), "draw");
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
gl.glBindVertexBuffer(3, m_buf, m_spec.bufferOffset, m_spec.bufferStride);
|
||
|
|
gl.glVertexAttribBinding(positionLoc, 3);
|
||
|
|
gl.glVertexAttribFormat(positionLoc, 4, GL_FLOAT, GL_FALSE, m_spec.positionAttrOffset);
|
||
|
|
gl.glEnableVertexAttribArray(positionLoc);
|
||
|
|
|
||
|
|
GLU_EXPECT_NO_ERROR(gl.glGetError(), "set va");
|
||
|
|
gl.glUniform4f(colorUniformLoc, 0.0f, 1.0f, 0.0f, 1.0f);
|
||
|
|
|
||
|
|
gl.glDrawArrays(GL_TRIANGLES, 0, GRID_SIZE*GRID_SIZE*6);
|
||
|
|
GLU_EXPECT_NO_ERROR(gl.glGetError(), "draw");
|
||
|
|
}
|
||
|
|
|
||
|
|
gl.glFinish();
|
||
|
|
gl.glBindVertexArray(0);
|
||
|
|
gl.glUseProgram(0);
|
||
|
|
GLU_EXPECT_NO_ERROR(gl.glGetError(), "clean");
|
||
|
|
|
||
|
|
glu::readPixels(m_context.getRenderContext(), 0, 0, dst.getAccess());
|
||
|
|
}
|
||
|
|
|
||
|
|
SingleBindingCase::TestSpec SingleBindingCase::genTestSpec (int flags)
|
||
|
|
{
|
||
|
|
const int datumSize = 4;
|
||
|
|
const int bufferOffset = (flags & FLAG_BUF_ALIGNED_OFFSET) ? (32) : (flags & FLAG_BUF_UNALIGNED_OFFSET) ? (19) : (0);
|
||
|
|
const int attrBufAlignment = ((bufferOffset % datumSize) == 0) ? (0) : (datumSize - (bufferOffset % datumSize));
|
||
|
|
const int positionAttrOffset = (flags & FLAG_ATTRIB_UNALIGNED) ? (3) : (flags & FLAG_ATTRIB_ALIGNED) ? (attrBufAlignment) : (0);
|
||
|
|
const bool hasColorAttr = (flags & FLAG_ATTRIBS_SHARED_ELEMS) || (flags & FLAG_ATTRIBS_MULTIPLE_ELEMS);
|
||
|
|
const int colorAttrOffset = (flags & FLAG_ATTRIBS_SHARED_ELEMS) ? (2 * datumSize) : (flags & FLAG_ATTRIBS_MULTIPLE_ELEMS) ? (4 * datumSize) : (-1);
|
||
|
|
|
||
|
|
const int bufferStrideBase = de::max(positionAttrOffset + 4 * datumSize, colorAttrOffset + 4 * datumSize);
|
||
|
|
const int bufferStrideAlignment = ((bufferStrideBase % datumSize) == 0) ? (0) : (datumSize - (bufferStrideBase % datumSize));
|
||
|
|
const int bufferStridePadding = ((flags & FLAG_BUF_UNALIGNED_STRIDE) && deIsAligned32(bufferStrideBase, datumSize)) ? (13) : (!(flags & FLAG_BUF_UNALIGNED_STRIDE) && !deIsAligned32(bufferStrideBase, datumSize)) ? (bufferStrideAlignment) : (0);
|
||
|
|
|
||
|
|
TestSpec spec;
|
||
|
|
|
||
|
|
spec.bufferOffset = bufferOffset;
|
||
|
|
spec.bufferStride = bufferStrideBase + bufferStridePadding;
|
||
|
|
spec.positionAttrOffset = positionAttrOffset;
|
||
|
|
spec.colorAttrOffset = colorAttrOffset;
|
||
|
|
spec.hasColorAttr = hasColorAttr;
|
||
|
|
|
||
|
|
if (flags & FLAG_ATTRIB_UNALIGNED)
|
||
|
|
DE_ASSERT(!deIsAligned32(spec.bufferOffset + spec.positionAttrOffset, datumSize));
|
||
|
|
else if (flags & FLAG_ATTRIB_ALIGNED)
|
||
|
|
DE_ASSERT(deIsAligned32(spec.bufferOffset + spec.positionAttrOffset, datumSize));
|
||
|
|
|
||
|
|
if (flags & FLAG_BUF_UNALIGNED_STRIDE)
|
||
|
|
DE_ASSERT(!deIsAligned32(spec.bufferStride, datumSize));
|
||
|
|
else
|
||
|
|
DE_ASSERT(deIsAligned32(spec.bufferStride, datumSize));
|
||
|
|
|
||
|
|
return spec;
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string SingleBindingCase::genTestDescription (int flags)
|
||
|
|
{
|
||
|
|
std::ostringstream buf;
|
||
|
|
buf << "draw test pattern";
|
||
|
|
|
||
|
|
if (flags & FLAG_ATTRIB_UNALIGNED)
|
||
|
|
buf << ", attribute offset (unaligned)";
|
||
|
|
if (flags & FLAG_ATTRIB_ALIGNED)
|
||
|
|
buf << ", attribute offset (aligned)";
|
||
|
|
|
||
|
|
if (flags & FLAG_ATTRIBS_MULTIPLE_ELEMS)
|
||
|
|
buf << ", 2 attributes";
|
||
|
|
if (flags & FLAG_ATTRIBS_SHARED_ELEMS)
|
||
|
|
buf << ", 2 attributes (some components shared)";
|
||
|
|
|
||
|
|
if (flags & FLAG_BUF_ALIGNED_OFFSET)
|
||
|
|
buf << ", buffer offset aligned";
|
||
|
|
if (flags & FLAG_BUF_UNALIGNED_OFFSET)
|
||
|
|
buf << ", buffer offset unaligned";
|
||
|
|
if (flags & FLAG_BUF_UNALIGNED_STRIDE)
|
||
|
|
buf << ", buffer stride unaligned";
|
||
|
|
|
||
|
|
return buf.str();
|
||
|
|
}
|
||
|
|
|
||
|
|
bool SingleBindingCase::isDataUnaligned (int flags)
|
||
|
|
{
|
||
|
|
if (flags & FLAG_ATTRIB_UNALIGNED)
|
||
|
|
return true;
|
||
|
|
if (flags & FLAG_ATTRIB_ALIGNED)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
return (flags & FLAG_BUF_UNALIGNED_OFFSET) || (flags & FLAG_BUF_UNALIGNED_STRIDE);
|
||
|
|
}
|
||
|
|
|
||
|
|
void SingleBindingCase::createBuffers (void)
|
||
|
|
{
|
||
|
|
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
|
||
|
|
std::vector<deUint8> dataBuf (m_spec.bufferOffset + m_spec.bufferStride * GRID_SIZE * GRID_SIZE * 6);
|
||
|
|
|
||
|
|
// In interleaved mode color rg and position zw are the same. Select "good" values for r and g
|
||
|
|
const tcu::Vec4 colorA (0.0f, 1.0f, 0.0f, 1.0f);
|
||
|
|
const tcu::Vec4 colorB (0.5f, 1.0f, 0.0f, 1.0f);
|
||
|
|
|
||
|
|
for (int y = 0; y < GRID_SIZE; ++y)
|
||
|
|
for (int x = 0; x < GRID_SIZE; ++x)
|
||
|
|
{
|
||
|
|
const tcu::Vec4& color = ((x + y) % 2 == 0) ? (colorA) : (colorB);
|
||
|
|
const tcu::Vec4 positions[6] =
|
||
|
|
{
|
||
|
|
tcu::Vec4(float(x+0) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+0) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f),
|
||
|
|
tcu::Vec4(float(x+0) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+1) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f),
|
||
|
|
tcu::Vec4(float(x+1) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+1) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f),
|
||
|
|
tcu::Vec4(float(x+0) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+0) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f),
|
||
|
|
tcu::Vec4(float(x+1) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+1) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f),
|
||
|
|
tcu::Vec4(float(x+1) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+0) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f),
|
||
|
|
};
|
||
|
|
|
||
|
|
// copy cell vertices to the buffer.
|
||
|
|
for (int v = 0; v < 6; ++v)
|
||
|
|
memcpy(&dataBuf[m_spec.bufferOffset + m_spec.positionAttrOffset + m_spec.bufferStride * ((y * GRID_SIZE + x) * 6 + v)], positions[v].getPtr(), sizeof(positions[v]));
|
||
|
|
|
||
|
|
// copy color to buffer
|
||
|
|
if (m_spec.hasColorAttr)
|
||
|
|
for (int v = 0; v < 6; ++v)
|
||
|
|
memcpy(&dataBuf[m_spec.bufferOffset + m_spec.colorAttrOffset + m_spec.bufferStride * ((y * GRID_SIZE + x) * 6 + v)], color.getPtr(), sizeof(color));
|
||
|
|
}
|
||
|
|
|
||
|
|
gl.genBuffers(1, &m_buf);
|
||
|
|
gl.bindBuffer(GL_ARRAY_BUFFER, m_buf);
|
||
|
|
gl.bufferData(GL_ARRAY_BUFFER, (glw::GLsizeiptr)dataBuf.size(), &dataBuf[0], GL_STATIC_DRAW);
|
||
|
|
gl.bindBuffer(GL_ARRAY_BUFFER, 0);
|
||
|
|
|
||
|
|
if (gl.getError() != GL_NO_ERROR)
|
||
|
|
throw tcu::TestError("could not init buffer");
|
||
|
|
}
|
||
|
|
|
||
|
|
void SingleBindingCase::createShader (void)
|
||
|
|
{
|
||
|
|
m_program = new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::VertexSource(genVertexSource()) << glu::FragmentSource(s_colorFragmentShader));
|
||
|
|
m_testCtx.getLog() << *m_program;
|
||
|
|
|
||
|
|
if (!m_program->isOk())
|
||
|
|
throw tcu::TestError("could not build shader");
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string SingleBindingCase::genVertexSource (void)
|
||
|
|
{
|
||
|
|
const bool useUniformColor = !m_spec.hasColorAttr;
|
||
|
|
std::ostringstream buf;
|
||
|
|
|
||
|
|
buf << "#version 310 es\n"
|
||
|
|
"in highp vec4 a_position;\n";
|
||
|
|
|
||
|
|
if (!useUniformColor)
|
||
|
|
buf << "in highp vec4 a_color;\n";
|
||
|
|
else
|
||
|
|
buf << "uniform highp vec4 u_color;\n";
|
||
|
|
|
||
|
|
buf << "out highp vec4 v_color;\n"
|
||
|
|
"void main (void)\n"
|
||
|
|
"{\n"
|
||
|
|
" gl_Position = a_position;\n"
|
||
|
|
" v_color = " << ((useUniformColor) ? ("u_color") : ("a_color")) << ";\n"
|
||
|
|
"}\n";
|
||
|
|
|
||
|
|
return buf.str();
|
||
|
|
}
|
||
|
|
|
||
|
|
class BindVertexBufferCase : public TestCase
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
BindVertexBufferCase (Context& ctx, const char* name, const char* desc, int offset, int drawCount);
|
||
|
|
~BindVertexBufferCase (void);
|
||
|
|
|
||
|
|
void init (void);
|
||
|
|
void deinit (void);
|
||
|
|
IterateResult iterate (void);
|
||
|
|
|
||
|
|
private:
|
||
|
|
const int m_offset;
|
||
|
|
const int m_drawCount;
|
||
|
|
deUint32 m_buffer;
|
||
|
|
glu::ShaderProgram* m_program;
|
||
|
|
};
|
||
|
|
|
||
|
|
BindVertexBufferCase::BindVertexBufferCase (Context& ctx, const char* name, const char* desc, int offset, int drawCount)
|
||
|
|
: TestCase (ctx, name, desc)
|
||
|
|
, m_offset (offset)
|
||
|
|
, m_drawCount (drawCount)
|
||
|
|
, m_buffer (0)
|
||
|
|
, m_program (DE_NULL)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
BindVertexBufferCase::~BindVertexBufferCase (void)
|
||
|
|
{
|
||
|
|
deinit();
|
||
|
|
}
|
||
|
|
|
||
|
|
void BindVertexBufferCase::init (void)
|
||
|
|
{
|
||
|
|
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
|
||
|
|
std::vector<tcu::Vec4> data (m_drawCount); // !< some junk data to make sure buffer is really allocated
|
||
|
|
|
||
|
|
gl.genBuffers(1, &m_buffer);
|
||
|
|
gl.bindBuffer(GL_ARRAY_BUFFER, m_buffer);
|
||
|
|
gl.bufferData(GL_ARRAY_BUFFER, int(m_drawCount * sizeof(tcu::Vec4)), &data[0], GL_STATIC_DRAW);
|
||
|
|
GLU_EXPECT_NO_ERROR(gl.getError(), "buffer gen");
|
||
|
|
|
||
|
|
m_program = new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::VertexSource(s_vertexSource) << glu::FragmentSource(s_fragmentSource));
|
||
|
|
if (!m_program->isOk())
|
||
|
|
{
|
||
|
|
m_testCtx.getLog() << *m_program;
|
||
|
|
throw tcu::TestError("could not build program");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void BindVertexBufferCase::deinit (void)
|
||
|
|
{
|
||
|
|
if (m_buffer)
|
||
|
|
{
|
||
|
|
m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_buffer);
|
||
|
|
m_buffer = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
delete m_program;
|
||
|
|
m_program = DE_NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
BindVertexBufferCase::IterateResult BindVertexBufferCase::iterate (void)
|
||
|
|
{
|
||
|
|
glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
|
||
|
|
const deInt32 positionLoc = gl.glGetAttribLocation(m_program->getProgram(), "a_position");
|
||
|
|
tcu::Surface dst (m_context.getRenderTarget().getWidth(), m_context.getRenderTarget().getHeight());
|
||
|
|
glu::VertexArray vao (m_context.getRenderContext());
|
||
|
|
|
||
|
|
gl.enableLogging(true);
|
||
|
|
|
||
|
|
gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
|
||
|
|
gl.glClear(GL_COLOR_BUFFER_BIT);
|
||
|
|
GLU_EXPECT_NO_ERROR(gl.glGetError(), "setup");
|
||
|
|
|
||
|
|
gl.glUseProgram(m_program->getProgram());
|
||
|
|
GLU_EXPECT_NO_ERROR(gl.glGetError(), "use program");
|
||
|
|
|
||
|
|
gl.glBindVertexArray(*vao);
|
||
|
|
gl.glEnableVertexAttribArray(positionLoc);
|
||
|
|
gl.glVertexAttribFormat(positionLoc, 4, GL_FLOAT, GL_FALSE, 0);
|
||
|
|
gl.glVertexAttribBinding(positionLoc, 0);
|
||
|
|
gl.glBindVertexBuffer(0, m_buffer, m_offset, int(sizeof(tcu::Vec4)));
|
||
|
|
GLU_EXPECT_NO_ERROR(gl.glGetError(), "set buffer");
|
||
|
|
|
||
|
|
gl.glDrawArrays(GL_POINTS, 0, m_drawCount);
|
||
|
|
|
||
|
|
// allow errors after attempted out-of-bounds memory access
|
||
|
|
{
|
||
|
|
const deUint32 error = gl.glGetError();
|
||
|
|
|
||
|
|
if (error != GL_NO_ERROR)
|
||
|
|
m_testCtx.getLog() << tcu::TestLog::Message << "Got error: " << glu::getErrorStr(error) << ", ignoring..." << tcu::TestLog::EndMessage;
|
||
|
|
}
|
||
|
|
|
||
|
|
// read pixels to wait for rendering
|
||
|
|
gl.glFinish();
|
||
|
|
glu::readPixels(m_context.getRenderContext(), 0, 0, dst.getAccess());
|
||
|
|
|
||
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
|
||
|
|
return STOP;
|
||
|
|
}
|
||
|
|
|
||
|
|
} // anonymous
|
||
|
|
|
||
|
|
VertexAttributeBindingTests::VertexAttributeBindingTests (Context& context)
|
||
|
|
: TestCaseGroup(context, "vertex_attribute_binding", "Test vertex attribute binding stress tests")
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
VertexAttributeBindingTests::~VertexAttributeBindingTests (void)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
void VertexAttributeBindingTests::init (void)
|
||
|
|
{
|
||
|
|
tcu::TestCaseGroup* const unalignedGroup = new tcu::TestCaseGroup(m_testCtx, "unaligned", "Unaligned access");
|
||
|
|
tcu::TestCaseGroup* const bufferRangeGroup = new tcu::TestCaseGroup(m_testCtx, "buffer_bounds", "Source data over buffer bounds");
|
||
|
|
|
||
|
|
addChild(unalignedGroup);
|
||
|
|
addChild(bufferRangeGroup);
|
||
|
|
|
||
|
|
// .unaligned
|
||
|
|
{
|
||
|
|
unalignedGroup->addChild(new SingleBindingCase(m_context, "elements_1_unaligned", SingleBindingCase::FLAG_ATTRIB_UNALIGNED));
|
||
|
|
unalignedGroup->addChild(new SingleBindingCase(m_context, "offset_elements_1_unaligned", SingleBindingCase::FLAG_BUF_ALIGNED_OFFSET | SingleBindingCase::FLAG_ATTRIB_UNALIGNED));
|
||
|
|
|
||
|
|
unalignedGroup->addChild(new SingleBindingCase(m_context, "unaligned_offset_elements_1", SingleBindingCase::FLAG_BUF_UNALIGNED_OFFSET | 0));
|
||
|
|
unalignedGroup->addChild(new SingleBindingCase(m_context, "unaligned_offset_elements_1_unaligned", SingleBindingCase::FLAG_BUF_UNALIGNED_OFFSET | SingleBindingCase::FLAG_ATTRIB_UNALIGNED));
|
||
|
|
unalignedGroup->addChild(new SingleBindingCase(m_context, "unaligned_offset_elements_2", SingleBindingCase::FLAG_BUF_UNALIGNED_OFFSET | SingleBindingCase::FLAG_ATTRIBS_MULTIPLE_ELEMS));
|
||
|
|
unalignedGroup->addChild(new SingleBindingCase(m_context, "unaligned_offset_elements_2_share_elements", SingleBindingCase::FLAG_BUF_UNALIGNED_OFFSET | SingleBindingCase::FLAG_ATTRIBS_SHARED_ELEMS));
|
||
|
|
|
||
|
|
unalignedGroup->addChild(new SingleBindingCase(m_context, "unaligned_stride_elements_1", SingleBindingCase::FLAG_BUF_UNALIGNED_STRIDE | 0));
|
||
|
|
unalignedGroup->addChild(new SingleBindingCase(m_context, "unaligned_stride_elements_2", SingleBindingCase::FLAG_BUF_UNALIGNED_STRIDE | SingleBindingCase::FLAG_ATTRIBS_MULTIPLE_ELEMS));
|
||
|
|
unalignedGroup->addChild(new SingleBindingCase(m_context, "unaligned_stride_elements_2_share_elements", SingleBindingCase::FLAG_BUF_UNALIGNED_STRIDE | SingleBindingCase::FLAG_ATTRIBS_SHARED_ELEMS));
|
||
|
|
}
|
||
|
|
|
||
|
|
// .buffer_bounds
|
||
|
|
{
|
||
|
|
// bind buffer offset cases
|
||
|
|
bufferRangeGroup->addChild(new BindVertexBufferCase(m_context, "bind_vertex_buffer_offset_over_bounds_10", "Offset over buffer bounds", 0x00210000, 10));
|
||
|
|
bufferRangeGroup->addChild(new BindVertexBufferCase(m_context, "bind_vertex_buffer_offset_over_bounds_1000", "Offset over buffer bounds", 0x00210000, 1000));
|
||
|
|
bufferRangeGroup->addChild(new BindVertexBufferCase(m_context, "bind_vertex_buffer_offset_near_wrap_10", "Offset over buffer bounds, near wrapping", 0x7FFFFFF0, 10));
|
||
|
|
bufferRangeGroup->addChild(new BindVertexBufferCase(m_context, "bind_vertex_buffer_offset_near_wrap_1000", "Offset over buffer bounds, near wrapping", 0x7FFFFFF0, 1000));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
} // Stress
|
||
|
|
} // gles31
|
||
|
|
} // deqp
|