#ifndef _GLSBUFFERTESTUTIL_HPP
|
#define _GLSBUFFERTESTUTIL_HPP
|
/*-------------------------------------------------------------------------
|
* drawElements Quality Program OpenGL (ES) 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 Buffer test utilities.
|
*//*--------------------------------------------------------------------*/
|
|
#include "tcuDefs.hpp"
|
#include "tcuTestCase.hpp"
|
#include "gluCallLogWrapper.hpp"
|
#include "gluObjectWrapper.hpp"
|
|
#include <vector>
|
#include <set>
|
|
namespace tcu
|
{
|
class TestLog;
|
}
|
|
namespace glu
|
{
|
class RenderContext;
|
class ShaderProgram;
|
}
|
|
namespace deqp
|
{
|
namespace gls
|
{
|
namespace BufferTestUtil
|
{
|
|
// Helper functions.
|
|
void fillWithRandomBytes (deUint8* ptr, int numBytes, deUint32 seed);
|
bool compareByteArrays (tcu::TestLog& log, const deUint8* resPtr, const deUint8* refPtr, int numBytes);
|
const char* getBufferTargetName (deUint32 target);
|
const char* getUsageHintName (deUint32 hint);
|
|
// Base class for buffer cases.
|
|
class BufferCase : public tcu::TestCase, public glu::CallLogWrapper
|
{
|
public:
|
BufferCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description);
|
virtual ~BufferCase (void);
|
|
void init (void);
|
void deinit (void);
|
|
deUint32 genBuffer (void);
|
void deleteBuffer (deUint32 buffer);
|
void checkError (void);
|
|
protected:
|
glu::RenderContext& m_renderCtx;
|
|
private:
|
// Resource handles for cleanup in case of unexpected iterate() termination.
|
std::set<deUint32> m_allocatedBuffers;
|
};
|
|
// Reference buffer.
|
|
class ReferenceBuffer
|
{
|
public:
|
ReferenceBuffer (void) {}
|
~ReferenceBuffer (void) {}
|
|
void setSize (int numBytes);
|
void setData (int numBytes, const deUint8* bytes);
|
void setSubData (int offset, int numBytes, const deUint8* bytes);
|
|
deUint8* getPtr (int offset = 0) { return &m_data[offset]; }
|
const deUint8* getPtr (int offset = 0) const { return &m_data[offset]; }
|
|
private:
|
std::vector<deUint8> m_data;
|
};
|
|
// Buffer writer system.
|
|
enum WriteType
|
{
|
WRITE_BUFFER_SUB_DATA = 0,
|
WRITE_BUFFER_WRITE_MAP,
|
WRITE_TRANSFORM_FEEDBACK,
|
WRITE_PIXEL_PACK,
|
|
WRITE_LAST
|
};
|
|
const char* getWriteTypeDescription (WriteType type);
|
|
class BufferWriterBase : protected glu::CallLogWrapper
|
{
|
public:
|
BufferWriterBase (glu::RenderContext& renderCtx, tcu::TestLog& log);
|
virtual ~BufferWriterBase (void) {}
|
|
virtual int getMinSize (void) const = DE_NULL;
|
virtual int getAlignment (void) const = DE_NULL;
|
virtual void write (deUint32 buffer, int offset, int numBytes, const deUint8* bytes) = DE_NULL;
|
virtual void write (deUint32 buffer, int offset, int numBytes, const deUint8* bytes, deUint32 targetHint);
|
|
protected:
|
glu::RenderContext& m_renderCtx;
|
|
private:
|
BufferWriterBase (const BufferWriterBase& other);
|
BufferWriterBase& operator= (const BufferWriterBase& other);
|
};
|
|
class BufferWriter
|
{
|
public:
|
BufferWriter (glu::RenderContext& renderCtx, tcu::TestLog& log, WriteType writeType);
|
~BufferWriter (void);
|
|
int getMinSize (void) const { return m_writer->getMinSize(); }
|
int getAlignment (void) const { return m_writer->getAlignment(); }
|
void write (deUint32 buffer, int offset, int numBytes, const deUint8* bytes);
|
void write (deUint32 buffer, int offset, int numBytes, const deUint8* bytes, deUint32 targetHint);
|
|
private:
|
BufferWriter (const BufferWriter& other);
|
BufferWriter& operator= (const BufferWriter& other);
|
|
BufferWriterBase* m_writer;
|
};
|
|
class BufferSubDataWriter : public BufferWriterBase
|
{
|
public:
|
BufferSubDataWriter (glu::RenderContext& renderCtx, tcu::TestLog& log) : BufferWriterBase(renderCtx, log) {}
|
~BufferSubDataWriter (void) {}
|
|
int getMinSize (void) const { return 1; }
|
int getAlignment (void) const { return 1; }
|
virtual void write (deUint32 buffer, int offset, int numBytes, const deUint8* bytes);
|
virtual void write (deUint32 buffer, int offset, int numBytes, const deUint8* bytes, deUint32 target);
|
};
|
|
class BufferWriteMapWriter : public BufferWriterBase
|
{
|
public:
|
BufferWriteMapWriter (glu::RenderContext& renderCtx, tcu::TestLog& log) : BufferWriterBase(renderCtx, log) {}
|
~BufferWriteMapWriter (void) {}
|
|
int getMinSize (void) const { return 1; }
|
int getAlignment (void) const { return 1; }
|
virtual void write (deUint32 buffer, int offset, int numBytes, const deUint8* bytes);
|
virtual void write (deUint32 buffer, int offset, int numBytes, const deUint8* bytes, deUint32 target);
|
};
|
|
// Buffer verifier system.
|
|
enum VerifyType
|
{
|
VERIFY_AS_VERTEX_ARRAY = 0,
|
VERIFY_AS_INDEX_ARRAY,
|
VERIFY_AS_UNIFORM_BUFFER,
|
VERIFY_AS_PIXEL_UNPACK_BUFFER,
|
VERIFY_BUFFER_READ_MAP,
|
|
VERIFY_LAST
|
};
|
|
const char* getVerifyTypeDescription (VerifyType type);
|
|
class BufferVerifierBase : public glu::CallLogWrapper
|
{
|
public:
|
BufferVerifierBase (glu::RenderContext& renderCtx, tcu::TestLog& log);
|
virtual ~BufferVerifierBase (void) {}
|
|
virtual int getMinSize (void) const = DE_NULL;
|
virtual int getAlignment (void) const = DE_NULL;
|
virtual bool verify (deUint32 buffer, const deUint8* reference, int offset, int numBytes) = DE_NULL;
|
virtual bool verify (deUint32 buffer, const deUint8* reference, int offset, int numBytes, deUint32 targetHint);
|
|
protected:
|
glu::RenderContext& m_renderCtx;
|
tcu::TestLog& m_log;
|
|
private:
|
BufferVerifierBase (const BufferVerifierBase& other);
|
BufferVerifierBase& operator= (const BufferVerifierBase& other);
|
};
|
|
class BufferVerifier
|
{
|
public:
|
BufferVerifier (glu::RenderContext& renderCtx, tcu::TestLog& log, VerifyType verifyType);
|
~BufferVerifier (void);
|
|
int getMinSize (void) const { return m_verifier->getMinSize(); }
|
int getAlignment (void) const { return m_verifier->getAlignment(); }
|
|
// \note Offset is applied to reference pointer as well.
|
bool verify (deUint32 buffer, const deUint8* reference, int offset, int numBytes);
|
bool verify (deUint32 buffer, const deUint8* reference, int offset, int numBytes, deUint32 targetHint);
|
|
private:
|
BufferVerifier (const BufferVerifier& other);
|
BufferVerifier& operator= (const BufferVerifier& other);
|
|
BufferVerifierBase* m_verifier;
|
};
|
|
class BufferMapVerifier : public BufferVerifierBase
|
{
|
public:
|
BufferMapVerifier (glu::RenderContext& renderCtx, tcu::TestLog& log) : BufferVerifierBase(renderCtx, log) {}
|
~BufferMapVerifier (void) {}
|
|
int getMinSize (void) const { return 1; }
|
int getAlignment (void) const { return 1; }
|
bool verify (deUint32 buffer, const deUint8* reference, int offset, int numBytes);
|
bool verify (deUint32 buffer, const deUint8* reference, int offset, int numBytes, deUint32 target);
|
};
|
|
class VertexArrayVerifier : public BufferVerifierBase
|
{
|
public:
|
VertexArrayVerifier (glu::RenderContext& renderCtx, tcu::TestLog& log);
|
~VertexArrayVerifier (void);
|
|
int getMinSize (void) const { return 3*4; }
|
int getAlignment (void) const { return 1; }
|
bool verify (deUint32 buffer, const deUint8* reference, int offset, int numBytes);
|
|
private:
|
glu::ShaderProgram* m_program;
|
deUint32 m_posLoc;
|
deUint32 m_byteVecLoc;
|
|
deUint32 m_vao;
|
deUint32 m_positionBuf;
|
deUint32 m_indexBuf;
|
};
|
|
class IndexArrayVerifier : public BufferVerifierBase
|
{
|
public:
|
IndexArrayVerifier (glu::RenderContext& renderCtx, tcu::TestLog& log);
|
~IndexArrayVerifier (void);
|
|
int getMinSize (void) const { return 2; }
|
int getAlignment (void) const { return 1; }
|
bool verify (deUint32 buffer, const deUint8* reference, int offset, int numBytes);
|
|
private:
|
glu::ShaderProgram* m_program;
|
deUint32 m_posLoc;
|
deUint32 m_colorLoc;
|
|
deUint32 m_vao;
|
deUint32 m_positionBuf;
|
deUint32 m_colorBuf;
|
};
|
|
} // BufferTestUtil
|
} // gls
|
} // deqp
|
|
#endif // _GLSBUFFERTESTUTIL_HPP
|
