#ifndef _GLSVERTEXARRAYTESTS_HPP
#define _GLSVERTEXARRAYTESTS_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 Vertex array and buffer tests
*//*--------------------------------------------------------------------*/
#include "tcuTestCase.hpp"
#include "tcuVector.hpp"
#include "tcuSurface.hpp"
#include "gluRenderContext.hpp"
#include "gluCallLogWrapper.hpp"
#include "tcuTestLog.hpp"
#include "gluShaderProgram.hpp"
#include "deFloat16.h"
#include "deMath.h"
#include "tcuFloat.hpp"
#include "tcuPixelFormat.hpp"
#include "sglrContext.hpp"
namespace sglr
{
class ReferenceContextBuffers;
class ReferenceContext;
class Context;
} // sglr
namespace deqp
{
namespace gls
{
class Array
{
public:
enum Target
{
// \note [mika] Are these actualy used somewhere?
TARGET_ELEMENT_ARRAY = 0,
TARGET_ARRAY,
TARGET_LAST
};
enum InputType
{
INPUTTYPE_FLOAT = 0,
INPUTTYPE_FIXED,
INPUTTYPE_DOUBLE,
INPUTTYPE_BYTE,
INPUTTYPE_SHORT,
INPUTTYPE_UNSIGNED_BYTE,
INPUTTYPE_UNSIGNED_SHORT,
INPUTTYPE_INT,
INPUTTYPE_UNSIGNED_INT,
INPUTTYPE_HALF,
INPUTTYPE_UNSIGNED_INT_2_10_10_10,
INPUTTYPE_INT_2_10_10_10,
INPUTTYPE_LAST
};
enum OutputType
{
OUTPUTTYPE_FLOAT = 0,
OUTPUTTYPE_VEC2,
OUTPUTTYPE_VEC3,
OUTPUTTYPE_VEC4,
OUTPUTTYPE_INT,
OUTPUTTYPE_UINT,
OUTPUTTYPE_IVEC2,
OUTPUTTYPE_IVEC3,
OUTPUTTYPE_IVEC4,
OUTPUTTYPE_UVEC2,
OUTPUTTYPE_UVEC3,
OUTPUTTYPE_UVEC4,
OUTPUTTYPE_LAST
};
enum Usage
{
USAGE_DYNAMIC_DRAW = 0,
USAGE_STATIC_DRAW,
USAGE_STREAM_DRAW,
USAGE_STREAM_READ,
USAGE_STREAM_COPY,
USAGE_STATIC_READ,
USAGE_STATIC_COPY,
USAGE_DYNAMIC_READ,
USAGE_DYNAMIC_COPY,
USAGE_LAST
};
enum Storage
{
STORAGE_USER = 0,
STORAGE_BUFFER,
STORAGE_LAST
};
enum Primitive
{
PRIMITIVE_POINTS = 0,
PRIMITIVE_TRIANGLES,
PRIMITIVE_TRIANGLE_FAN,
PRIMITIVE_TRIANGLE_STRIP,
PRIMITIVE_LAST
};
static std::string targetToString (Target target);
static std::string inputTypeToString (InputType type);
static std::string outputTypeToString (OutputType type);
static std::string usageTypeToString (Usage usage);
static std::string storageToString (Storage storage);
static std::string primitiveToString (Primitive primitive);
static int inputTypeSize (InputType type);
virtual ~Array (void) {}
virtual void data (Target target, int size, const char* data, Usage usage) = 0;
virtual void subdata (Target target, int offset, int size, const char* data) = 0;
virtual void bind (int attribNdx, int offset, int size, InputType inType, OutputType outType, bool normalized, int stride) = 0;
virtual void unBind (void) = 0;
virtual bool isBound (void) const = 0;
virtual int getComponentCount (void) const = 0;
virtual Target getTarget (void) const = 0;
virtual InputType getInputType (void) const = 0;
virtual OutputType getOutputType (void) const = 0;
virtual Storage getStorageType (void) const = 0;
virtual bool getNormalized (void) const = 0;
virtual int getStride (void) const = 0;
virtual int getAttribNdx (void) const = 0;
virtual void setAttribNdx (int attribNdx) = 0;
};
class ContextArray : public Array
{
public:
ContextArray (Storage storage, sglr::Context& context);
virtual ~ContextArray (void);
virtual void data (Target target, int size, const char* data, Usage usage);
virtual void subdata (Target target, int offset, int size, const char* data);
virtual void bind (int attribNdx, int offset, int size, InputType inType, OutputType outType, bool normalized, int stride);
virtual void bindIndexArray (Array::Target storage);
virtual void unBind (void) { m_bound = false; }
virtual bool isBound (void) const { return m_bound; }
virtual int getComponentCount (void) const { return m_componentCount; }
virtual Array::Target getTarget (void) const { return m_target; }
virtual Array::InputType getInputType (void) const { return m_inputType; }
virtual Array::OutputType getOutputType (void) const { return m_outputType; }
virtual Array::Storage getStorageType (void) const { return m_storage; }
virtual bool getNormalized (void) const { return m_normalize; }
virtual int getStride (void) const { return m_stride; }
virtual int getAttribNdx (void) const { return m_attribNdx; }
virtual void setAttribNdx (int attribNdx) { m_attribNdx = attribNdx; }
void glBind (deUint32 loc);
static deUint32 targetToGL (Array::Target target);
static deUint32 usageToGL (Array::Usage usage);
static deUint32 inputTypeToGL (Array::InputType type);
static std::string outputTypeToGLType (Array::OutputType type);
static deUint32 primitiveToGL (Array::Primitive primitive);
private:
Storage m_storage;
sglr::Context& m_ctx;
deUint32 m_glBuffer;
bool m_bound;
int m_attribNdx;
int m_size;
char* m_data;
int m_componentCount;
Array::Target m_target;
Array::InputType m_inputType;
Array::OutputType m_outputType;
bool m_normalize;
int m_stride;
int m_offset;
};
class ContextArrayPack
{
public:
ContextArrayPack (glu::RenderContext& renderCtx, sglr::Context& drawContext);
virtual ~ContextArrayPack (void);
virtual Array* getArray (int i);
virtual int getArrayCount (void);
virtual void newArray (Array::Storage storage);
virtual void render (Array::Primitive primitive, int firstVertex, int vertexCount, bool useVao, float coordScale, float colorScale);
const tcu::Surface& getSurface (void) const { return m_screen; }
private:
void updateProgram (void);
glu::RenderContext& m_renderCtx;
sglr::Context& m_ctx;
std::vector<ContextArray*> m_arrays;
sglr::ShaderProgram* m_program;
tcu::Surface m_screen;
};
class GLValue
{
public:
template<class Type>
class WrappedType
{
public:
static WrappedType<Type> create (Type value) { WrappedType<Type> v; v.m_value = value; return v; }
static WrappedType<Type> fromFloat (float value) { WrappedType<Type> v; v.m_value = (Type)value; return v; }
inline Type getValue (void) const { return m_value; }
inline WrappedType<Type> operator+ (const WrappedType<Type>& other) const { return WrappedType<Type>::create((Type)(m_value + other.getValue())); }
inline WrappedType<Type> operator* (const WrappedType<Type>& other) const { return WrappedType<Type>::create((Type)(m_value * other.getValue())); }
inline WrappedType<Type> operator/ (const WrappedType<Type>& other) const { return WrappedType<Type>::create((Type)(m_value / other.getValue())); }
inline WrappedType<Type> operator% (const WrappedType<Type>& other) const { return WrappedType<Type>::create((Type)(m_value % other.getValue())); }
inline WrappedType<Type> operator- (const WrappedType<Type>& other) const { return WrappedType<Type>::create((Type)(m_value - other.getValue())); }
inline WrappedType<Type>& operator+= (const WrappedType<Type>& other) { m_value += other.getValue(); return *this; }
inline WrappedType<Type>& operator*= (const WrappedType<Type>& other) { m_value *= other.getValue(); return *this; }
inline WrappedType<Type>& operator/= (const WrappedType<Type>& other) { m_value /= other.getValue(); return *this; }
inline WrappedType<Type>& operator-= (const WrappedType<Type>& other) { m_value -= other.getValue(); return *this; }
inline bool operator== (const WrappedType<Type>& other) const { return m_value == other.m_value; }
inline bool operator!= (const WrappedType<Type>& other) const { return m_value != other.m_value; }
inline bool operator< (const WrappedType<Type>& other) const { return m_value < other.m_value; }
inline bool operator> (const WrappedType<Type>& other) const { return m_value > other.m_value; }
inline bool operator<= (const WrappedType<Type>& other) const { return m_value <= other.m_value; }
inline bool operator>= (const WrappedType<Type>& other) const { return m_value >= other.m_value; }
inline operator Type (void) const { return m_value; }
template<class T>
inline T to (void) const { return (T)m_value; }
private:
Type m_value;
};
template<class Type>
class WrappedFloatType
{
public:
static WrappedFloatType<Type> create (Type value) { WrappedFloatType<Type> v; v.m_value = value; return v; }
static WrappedFloatType<Type> fromFloat (float value) { WrappedFloatType<Type> v; v.m_value = (Type)value; return v; }
inline Type getValue (void) const { return m_value; }
inline WrappedFloatType<Type> operator+ (const WrappedFloatType<Type>& other) const { return WrappedFloatType<Type>::create((Type)(m_value + other.getValue())); }
inline WrappedFloatType<Type> operator* (const WrappedFloatType<Type>& other) const { return WrappedFloatType<Type>::create((Type)(m_value * other.getValue())); }
inline WrappedFloatType<Type> operator/ (const WrappedFloatType<Type>& other) const { return WrappedFloatType<Type>::create((Type)(m_value / other.getValue())); }
inline WrappedFloatType<Type> operator% (const WrappedFloatType<Type>& other) const { return WrappedFloatType<Type>::create((Type)(deMod(m_value, other.getValue()))); }
inline WrappedFloatType<Type> operator- (const WrappedFloatType<Type>& other) const { return WrappedFloatType<Type>::create((Type)(m_value - other.getValue())); }
inline WrappedFloatType<Type>& operator+= (const WrappedFloatType<Type>& other) { m_value += other.getValue(); return *this; }
inline WrappedFloatType<Type>& operator*= (const WrappedFloatType<Type>& other) { m_value *= other.getValue(); return *this; }
inline WrappedFloatType<Type>& operator/= (const WrappedFloatType<Type>& other) { m_value /= other.getValue(); return *this; }
inline WrappedFloatType<Type>& operator-= (const WrappedFloatType<Type>& other) { m_value -= other.getValue(); return *this; }
inline bool operator== (const WrappedFloatType<Type>& other) const { return m_value == other.m_value; }
inline bool operator!= (const WrappedFloatType<Type>& other) const { return m_value != other.m_value; }
inline bool operator< (const WrappedFloatType<Type>& other) const { return m_value < other.m_value; }
inline bool operator> (const WrappedFloatType<Type>& other) const { return m_value > other.m_value; }
inline bool operator<= (const WrappedFloatType<Type>& other) const { return m_value <= other.m_value; }
inline bool operator>= (const WrappedFloatType<Type>& other) const { return m_value >= other.m_value; }
inline operator Type (void) const { return m_value; }
template<class T>
inline T to (void) const { return (T)m_value; }
private:
Type m_value;
};
typedef WrappedType<deInt16> Short;
typedef WrappedType<deUint16> Ushort;
typedef WrappedType<deInt8> Byte;
typedef WrappedType<deUint8> Ubyte;
typedef WrappedFloatType<float> Float;
typedef WrappedFloatType<double> Double;
typedef WrappedType<deInt32> Int;
typedef WrappedType<deUint32> Uint;
class Half
{
public:
static Half create (float value) { Half h; h.m_value = floatToHalf(value); return h; }
static Half fromFloat (float value) { Half h; h.m_value = floatToHalf(value); return h; }
inline deFloat16 getValue (void) const { return m_value; }
inline Half operator+ (const Half& other) const { return create(halfToFloat(m_value) + halfToFloat(other.getValue())); }
inline Half operator* (const Half& other) const { return create(halfToFloat(m_value) * halfToFloat(other.getValue())); }
inline Half operator/ (const Half& other) const { return create(halfToFloat(m_value) / halfToFloat(other.getValue())); }
inline Half operator% (const Half& other) const { return create(deFloatMod(halfToFloat(m_value), halfToFloat(other.getValue()))); }
inline Half operator- (const Half& other) const { return create(halfToFloat(m_value) - halfToFloat(other.getValue())); }
inline Half& operator+= (const Half& other) { m_value = floatToHalf(halfToFloat(other.getValue()) + halfToFloat(m_value)); return *this; }
inline Half& operator*= (const Half& other) { m_value = floatToHalf(halfToFloat(other.getValue()) * halfToFloat(m_value)); return *this; }
inline Half& operator/= (const Half& other) { m_value = floatToHalf(halfToFloat(other.getValue()) / halfToFloat(m_value)); return *this; }
inline Half& operator-= (const Half& other) { m_value = floatToHalf(halfToFloat(other.getValue()) - halfToFloat(m_value)); return *this; }
inline bool operator== (const Half& other) const { return m_value == other.m_value; }
inline bool operator!= (const Half& other) const { return m_value != other.m_value; }
inline bool operator< (const Half& other) const { return halfToFloat(m_value) < halfToFloat(other.m_value); }
inline bool operator> (const Half& other) const { return halfToFloat(m_value) > halfToFloat(other.m_value); }
inline bool operator<= (const Half& other) const { return halfToFloat(m_value) <= halfToFloat(other.m_value); }
inline bool operator>= (const Half& other) const { return halfToFloat(m_value) >= halfToFloat(other.m_value); }
template<class T>
inline T to (void) const { return (T)halfToFloat(m_value); }
inline static deFloat16 floatToHalf (float f);
inline static float halfToFloat (deFloat16 h);
private:
deFloat16 m_value;
};
class Fixed
{
public:
static Fixed create (deInt32 value) { Fixed v; v.m_value = value; return v; }
static Fixed fromFloat (float value) { Fixed v; v.m_value = (deInt32)(value * 32768.0f); return v; }
inline deInt32 getValue (void) const { return m_value; }
inline Fixed operator+ (const Fixed& other) const { return create(m_value + other.getValue()); }
inline Fixed operator* (const Fixed& other) const { return create(m_value * other.getValue()); }
inline Fixed operator/ (const Fixed& other) const { return create(m_value / other.getValue()); }
inline Fixed operator% (const Fixed& other) const { return create(m_value % other.getValue()); }
inline Fixed operator- (const Fixed& other) const { return create(m_value - other.getValue()); }
inline Fixed& operator+= (const Fixed& other) { m_value += other.getValue(); return *this; }
inline Fixed& operator*= (const Fixed& other) { m_value *= other.getValue(); return *this; }
inline Fixed& operator/= (const Fixed& other) { m_value /= other.getValue(); return *this; }
inline Fixed& operator-= (const Fixed& other) { m_value -= other.getValue(); return *this; }
inline bool operator== (const Fixed& other) const { return m_value == other.m_value; }
inline bool operator!= (const Fixed& other) const { return m_value != other.m_value; }
inline bool operator< (const Fixed& other) const { return m_value < other.m_value; }
inline bool operator> (const Fixed& other) const { return m_value > other.m_value; }
inline bool operator<= (const Fixed& other) const { return m_value <= other.m_value; }
inline bool operator>= (const Fixed& other) const { return m_value >= other.m_value; }
inline operator deInt32 (void) const { return m_value; }
template<class T>
inline T to (void) const { return (T)m_value; }
private:
deInt32 m_value;
};
// \todo [mika] This is pretty messy
GLValue (void) : type(Array::INPUTTYPE_LAST) {}
explicit GLValue (Float value) : type(Array::INPUTTYPE_FLOAT), fl(value) {}
explicit GLValue (Fixed value) : type(Array::INPUTTYPE_FIXED), fi(value) {}
explicit GLValue (Byte value) : type(Array::INPUTTYPE_BYTE), b(value) {}
explicit GLValue (Ubyte value) : type(Array::INPUTTYPE_UNSIGNED_BYTE), ub(value) {}
explicit GLValue (Short value) : type(Array::INPUTTYPE_SHORT), s(value) {}
explicit GLValue (Ushort value) : type(Array::INPUTTYPE_UNSIGNED_SHORT), us(value) {}
explicit GLValue (Int value) : type(Array::INPUTTYPE_INT), i(value) {}
explicit GLValue (Uint value) : type(Array::INPUTTYPE_UNSIGNED_INT), ui(value) {}
explicit GLValue (Half value) : type(Array::INPUTTYPE_HALF), h(value) {}
explicit GLValue (Double value) : type(Array::INPUTTYPE_DOUBLE), d(value) {}
float toFloat (void) const;
static GLValue getMaxValue (Array::InputType type);
static GLValue getMinValue (Array::InputType type);
Array::InputType type;
union
{
Float fl;
Fixed fi;
Double d;
Byte b;
Ubyte ub;
Short s;
Ushort us;
Int i;
Uint ui;
Half h;
};
};
class VertexArrayTest : public tcu::TestCase
{
public:
VertexArrayTest (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name ,const char* desc);
virtual ~VertexArrayTest (void);
virtual void init (void);
virtual void deinit (void);
protected:
VertexArrayTest (const VertexArrayTest& other);
VertexArrayTest& operator= (const VertexArrayTest& other);
void compare (void);
glu::RenderContext& m_renderCtx;
sglr::ReferenceContextBuffers* m_refBuffers;
sglr::ReferenceContext* m_refContext;
sglr::Context* m_glesContext;
ContextArrayPack* m_glArrayPack;
ContextArrayPack* m_rrArrayPack;
bool m_isOk;
int m_maxDiffRed;
int m_maxDiffGreen;
int m_maxDiffBlue;
};
class MultiVertexArrayTest : public VertexArrayTest
{
public:
class Spec
{
public:
class ArraySpec
{
public:
ArraySpec (Array::InputType inputType, Array::OutputType outputType, Array::Storage storage, Array::Usage usage, int componetCount, int offset, int stride, bool normalize, GLValue min, GLValue max);
Array::InputType inputType;
Array::OutputType outputType;
Array::Storage storage;
Array::Usage usage;
int componentCount;
int offset;
int stride;
bool normalize;
GLValue min;
GLValue max;
};
std::string getName (void) const;
std::string getDesc (void) const;
Array::Primitive primitive;
int drawCount; //!<Number of primitives to draw
int first;
std::vector<ArraySpec> arrays;
};
MultiVertexArrayTest (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const Spec& spec, const char* name, const char* desc);
virtual ~MultiVertexArrayTest (void);
virtual IterateResult iterate (void);
private:
bool isUnalignedBufferOffsetTest (void) const;
bool isUnalignedBufferStrideTest (void) const;
Spec m_spec;
int m_iteration;
};
inline deFloat16 GLValue::Half::floatToHalf (float f)
{
// No denorm support.
tcu::Float<deUint16, 5, 10, 15, tcu::FLOAT_HAS_SIGN> v(f);
DE_ASSERT(!v.isNaN() && !v.isInf());
return v.bits();
}
inline float GLValue::Half::halfToFloat (deFloat16 h)
{
return tcu::Float16((deUint16)h).asFloat();
}
} // gls
} // deqp
#endif // _GLSVERTEXARRAYTESTS_HPP