883 lines
28 KiB
C++
883 lines
28 KiB
C++
/*-------------------------------------------------------------------------
|
|
* drawElements Quality Program OpenGL ES 2.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 Vertex array and buffer tests
|
|
*//*--------------------------------------------------------------------*/
|
|
|
|
#include "es2fVertexArrayTest.hpp"
|
|
#include "glsVertexArrayTests.hpp"
|
|
|
|
#include "glwEnums.hpp"
|
|
|
|
using namespace deqp::gls;
|
|
|
|
namespace deqp
|
|
{
|
|
namespace gles2
|
|
{
|
|
namespace Functional
|
|
{
|
|
|
|
template<class T>
|
|
static std::string typeToString (T t)
|
|
{
|
|
std::stringstream strm;
|
|
strm << t;
|
|
return strm.str();
|
|
}
|
|
|
|
|
|
class SingleVertexArrayUsageTests : public TestCaseGroup
|
|
{
|
|
public:
|
|
SingleVertexArrayUsageTests (Context& context);
|
|
virtual ~SingleVertexArrayUsageTests (void);
|
|
|
|
virtual void init (void);
|
|
|
|
private:
|
|
SingleVertexArrayUsageTests (const SingleVertexArrayUsageTests& other);
|
|
SingleVertexArrayUsageTests& operator= (const SingleVertexArrayUsageTests& other);
|
|
};
|
|
|
|
SingleVertexArrayUsageTests::SingleVertexArrayUsageTests (Context& context)
|
|
: TestCaseGroup(context, "usages", "Single vertex atribute, usage")
|
|
{
|
|
}
|
|
|
|
SingleVertexArrayUsageTests::~SingleVertexArrayUsageTests (void)
|
|
{
|
|
}
|
|
|
|
void SingleVertexArrayUsageTests::init (void)
|
|
{
|
|
// Test usage
|
|
Array::Usage usages[] = {Array::USAGE_STATIC_DRAW, Array::USAGE_STREAM_DRAW, Array::USAGE_DYNAMIC_DRAW};
|
|
int counts[] = {1, 256};
|
|
int strides[] = {0, -1, 17, 32}; // Tread negative value as sizeof input. Same as 0, but done outside of GL.
|
|
Array::InputType inputTypes[] = {Array::INPUTTYPE_FLOAT, Array::INPUTTYPE_FIXED, Array::INPUTTYPE_SHORT, Array::INPUTTYPE_BYTE};
|
|
|
|
for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); inputTypeNdx++)
|
|
{
|
|
for (int countNdx = 0; countNdx < DE_LENGTH_OF_ARRAY(counts); countNdx++)
|
|
{
|
|
for (int strideNdx = 0; strideNdx < DE_LENGTH_OF_ARRAY(strides); strideNdx++)
|
|
{
|
|
for (int usageNdx = 0; usageNdx < DE_LENGTH_OF_ARRAY(usages); usageNdx++)
|
|
{
|
|
const int componentCount = 2;
|
|
const int stride = (strides[strideNdx] < 0 ? Array::inputTypeSize(inputTypes[inputTypeNdx]) * componentCount : strides[strideNdx]);
|
|
const bool aligned = (stride % Array::inputTypeSize(inputTypes[inputTypeNdx])) == 0;
|
|
MultiVertexArrayTest::Spec::ArraySpec arraySpec(inputTypes[inputTypeNdx],
|
|
Array::OUTPUTTYPE_VEC2,
|
|
Array::STORAGE_BUFFER,
|
|
usages[usageNdx],
|
|
componentCount,
|
|
0,
|
|
stride,
|
|
false,
|
|
GLValue::getMinValue(inputTypes[inputTypeNdx]),
|
|
GLValue::getMaxValue(inputTypes[inputTypeNdx]));
|
|
|
|
MultiVertexArrayTest::Spec spec;
|
|
spec.primitive = Array::PRIMITIVE_TRIANGLES;
|
|
spec.drawCount = counts[countNdx];
|
|
spec.first = 0;
|
|
spec.arrays.push_back(arraySpec);
|
|
|
|
std::string name = spec.getName();
|
|
|
|
if (aligned)
|
|
addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), name.c_str()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class SingleVertexArrayStrideTests : public TestCaseGroup
|
|
{
|
|
public:
|
|
SingleVertexArrayStrideTests (Context& context);
|
|
virtual ~SingleVertexArrayStrideTests (void);
|
|
|
|
virtual void init (void);
|
|
|
|
private:
|
|
SingleVertexArrayStrideTests (const SingleVertexArrayStrideTests& other);
|
|
SingleVertexArrayStrideTests& operator= (const SingleVertexArrayStrideTests& other);
|
|
};
|
|
|
|
SingleVertexArrayStrideTests::SingleVertexArrayStrideTests (Context& context)
|
|
: TestCaseGroup(context, "strides", "Single stride vertex atribute")
|
|
{
|
|
}
|
|
|
|
SingleVertexArrayStrideTests::~SingleVertexArrayStrideTests (void)
|
|
{
|
|
}
|
|
|
|
void SingleVertexArrayStrideTests::init (void)
|
|
{
|
|
// Test strides with different input types, component counts and storage, Usage(?)
|
|
Array::InputType inputTypes[] = {Array::INPUTTYPE_FLOAT, Array::INPUTTYPE_SHORT, Array::INPUTTYPE_BYTE, /*Array::INPUTTYPE_UNSIGNED_SHORT, Array::INPUTTYPE_UNSIGNED_BYTE,*/ Array::INPUTTYPE_FIXED};
|
|
Array::Storage storages[] = {Array::STORAGE_USER, Array::STORAGE_BUFFER};
|
|
int counts[] = {1, 256};
|
|
int strides[] = {/*0,*/ -1, 17, 32}; // Tread negative value as sizeof input. Same as 0, but done outside of GL.
|
|
|
|
for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); inputTypeNdx++)
|
|
{
|
|
for (int storageNdx = 0; storageNdx < DE_LENGTH_OF_ARRAY(storages); storageNdx++)
|
|
{
|
|
for (int componentCount = 2; componentCount < 5; componentCount++)
|
|
{
|
|
for (int countNdx = 0; countNdx < DE_LENGTH_OF_ARRAY(counts); countNdx++)
|
|
{
|
|
for (int strideNdx = 0; strideNdx < DE_LENGTH_OF_ARRAY(strides); strideNdx++)
|
|
{
|
|
const int stride = (strides[strideNdx] < 0 ? Array::inputTypeSize(inputTypes[inputTypeNdx]) * componentCount : strides[strideNdx]);
|
|
const bool bufferAligned = (storages[storageNdx] == Array::STORAGE_BUFFER) && (stride % Array::inputTypeSize(inputTypes[inputTypeNdx])) == 0;
|
|
|
|
MultiVertexArrayTest::Spec::ArraySpec arraySpec(inputTypes[inputTypeNdx],
|
|
Array::OUTPUTTYPE_VEC4,
|
|
storages[storageNdx],
|
|
Array::USAGE_DYNAMIC_DRAW,
|
|
componentCount,
|
|
0,
|
|
stride,
|
|
false,
|
|
GLValue::getMinValue(inputTypes[inputTypeNdx]),
|
|
GLValue::getMaxValue(inputTypes[inputTypeNdx]));
|
|
|
|
MultiVertexArrayTest::Spec spec;
|
|
spec.primitive = Array::PRIMITIVE_TRIANGLES;
|
|
spec.drawCount = counts[countNdx];
|
|
spec.first = 0;
|
|
spec.arrays.push_back(arraySpec);
|
|
|
|
std::string name = spec.getName();
|
|
if (bufferAligned)
|
|
addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), name.c_str()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class SingleVertexArrayFirstTests : public TestCaseGroup
|
|
{
|
|
public:
|
|
SingleVertexArrayFirstTests (Context& context);
|
|
virtual ~SingleVertexArrayFirstTests (void);
|
|
|
|
virtual void init (void);
|
|
|
|
private:
|
|
SingleVertexArrayFirstTests (const SingleVertexArrayFirstTests& other);
|
|
SingleVertexArrayFirstTests& operator= (const SingleVertexArrayFirstTests& other);
|
|
};
|
|
|
|
SingleVertexArrayFirstTests::SingleVertexArrayFirstTests (Context& context)
|
|
: TestCaseGroup(context, "first", "Single vertex atribute different first values")
|
|
{
|
|
}
|
|
|
|
SingleVertexArrayFirstTests::~SingleVertexArrayFirstTests (void)
|
|
{
|
|
}
|
|
|
|
void SingleVertexArrayFirstTests::init (void)
|
|
{
|
|
// Test strides with different input types, component counts and storage, Usage(?)
|
|
Array::InputType inputTypes[] = {Array::INPUTTYPE_FLOAT, Array::INPUTTYPE_BYTE, Array::INPUTTYPE_FIXED};
|
|
int counts[] = {5, 256};
|
|
int firsts[] = {6, 24};
|
|
int offsets[] = {1, 16, 17};
|
|
int strides[] = {/*0,*/ -1, 17, 32}; // Tread negative value as sizeof input. Same as 0, but done outside of GL.
|
|
|
|
for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); inputTypeNdx++)
|
|
{
|
|
for (int offsetNdx = 0; offsetNdx < DE_LENGTH_OF_ARRAY(offsets); offsetNdx++)
|
|
{
|
|
for (int countNdx = 0; countNdx < DE_LENGTH_OF_ARRAY(counts); countNdx++)
|
|
{
|
|
for (int strideNdx = 0; strideNdx < DE_LENGTH_OF_ARRAY(strides); strideNdx++)
|
|
{
|
|
for (int firstNdx = 0; firstNdx < DE_LENGTH_OF_ARRAY(firsts); firstNdx++)
|
|
{
|
|
const int stride = (strides[strideNdx] < 0 ? Array::inputTypeSize(inputTypes[inputTypeNdx]) * 2 : strides[strideNdx]);
|
|
const bool aligned = ((stride % Array::inputTypeSize(inputTypes[inputTypeNdx])) == 0) && (offsets[offsetNdx] % Array::inputTypeSize(inputTypes[inputTypeNdx]) == 0);
|
|
|
|
MultiVertexArrayTest::Spec::ArraySpec arraySpec(inputTypes[inputTypeNdx],
|
|
Array::OUTPUTTYPE_VEC2,
|
|
Array::STORAGE_BUFFER,
|
|
Array::USAGE_DYNAMIC_DRAW,
|
|
2,
|
|
offsets[offsetNdx],
|
|
stride,
|
|
false,
|
|
GLValue::getMinValue(inputTypes[inputTypeNdx]),
|
|
GLValue::getMaxValue(inputTypes[inputTypeNdx]));
|
|
|
|
MultiVertexArrayTest::Spec spec;
|
|
spec.primitive = Array::PRIMITIVE_TRIANGLES;
|
|
spec.drawCount = counts[countNdx];
|
|
spec.first = firsts[firstNdx];
|
|
spec.arrays.push_back(arraySpec);
|
|
|
|
std::string name = Array::inputTypeToString(inputTypes[inputTypeNdx]) + "_first" + typeToString(firsts[firstNdx]) + "_offset" + typeToString(offsets[offsetNdx]) + "_stride" + typeToString(stride) + "_quads" + typeToString(counts[countNdx]);
|
|
if (aligned)
|
|
addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), name.c_str()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class SingleVertexArrayOffsetTests : public TestCaseGroup
|
|
{
|
|
public:
|
|
SingleVertexArrayOffsetTests (Context& context);
|
|
virtual ~SingleVertexArrayOffsetTests (void);
|
|
|
|
virtual void init (void);
|
|
|
|
private:
|
|
SingleVertexArrayOffsetTests (const SingleVertexArrayOffsetTests& other);
|
|
SingleVertexArrayOffsetTests& operator= (const SingleVertexArrayOffsetTests& other);
|
|
};
|
|
|
|
SingleVertexArrayOffsetTests::SingleVertexArrayOffsetTests (Context& context)
|
|
: TestCaseGroup(context, "offset", "Single vertex atribute offset element")
|
|
{
|
|
}
|
|
|
|
SingleVertexArrayOffsetTests::~SingleVertexArrayOffsetTests (void)
|
|
{
|
|
}
|
|
|
|
void SingleVertexArrayOffsetTests::init (void)
|
|
{
|
|
// Test strides with different input types, component counts and storage, Usage(?)
|
|
Array::InputType inputTypes[] = {Array::INPUTTYPE_FLOAT, Array::INPUTTYPE_BYTE, Array::INPUTTYPE_FIXED};
|
|
int counts[] = {1, 256};
|
|
int offsets[] = {1, 4, 17, 32};
|
|
int strides[] = {/*0,*/ -1, 17, 32}; // Tread negative value as sizeof input. Same as 0, but done outside of GL.
|
|
|
|
for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); inputTypeNdx++)
|
|
{
|
|
for (int offsetNdx = 0; offsetNdx < DE_LENGTH_OF_ARRAY(offsets); offsetNdx++)
|
|
{
|
|
for (int countNdx = 0; countNdx < DE_LENGTH_OF_ARRAY(counts); countNdx++)
|
|
{
|
|
for (int strideNdx = 0; strideNdx < DE_LENGTH_OF_ARRAY(strides); strideNdx++)
|
|
{
|
|
const int stride = (strides[strideNdx] < 0 ? Array::inputTypeSize(inputTypes[inputTypeNdx]) * 2 : strides[strideNdx]);
|
|
const bool aligned = ((stride % Array::inputTypeSize(inputTypes[inputTypeNdx])) == 0) && ((offsets[offsetNdx] % Array::inputTypeSize(inputTypes[inputTypeNdx])) == 0);
|
|
|
|
MultiVertexArrayTest::Spec::ArraySpec arraySpec(inputTypes[inputTypeNdx],
|
|
Array::OUTPUTTYPE_VEC2,
|
|
Array::STORAGE_BUFFER,
|
|
Array::USAGE_DYNAMIC_DRAW,
|
|
2,
|
|
offsets[offsetNdx],
|
|
stride,
|
|
false,
|
|
GLValue::getMinValue(inputTypes[inputTypeNdx]),
|
|
GLValue::getMaxValue(inputTypes[inputTypeNdx]));
|
|
|
|
MultiVertexArrayTest::Spec spec;
|
|
spec.primitive = Array::PRIMITIVE_TRIANGLES;
|
|
spec.drawCount = counts[countNdx];
|
|
spec.first = 0;
|
|
spec.arrays.push_back(arraySpec);
|
|
|
|
std::string name = spec.getName();
|
|
if (aligned)
|
|
addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), name.c_str()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class SingleVertexArrayNormalizeTests : public TestCaseGroup
|
|
{
|
|
public:
|
|
SingleVertexArrayNormalizeTests (Context& context);
|
|
virtual ~SingleVertexArrayNormalizeTests (void);
|
|
|
|
virtual void init (void);
|
|
|
|
private:
|
|
SingleVertexArrayNormalizeTests (const SingleVertexArrayNormalizeTests& other);
|
|
SingleVertexArrayNormalizeTests& operator= (const SingleVertexArrayNormalizeTests& other);
|
|
};
|
|
|
|
SingleVertexArrayNormalizeTests::SingleVertexArrayNormalizeTests (Context& context)
|
|
: TestCaseGroup(context, "normalize", "Single normalize vertex atribute")
|
|
{
|
|
}
|
|
|
|
SingleVertexArrayNormalizeTests::~SingleVertexArrayNormalizeTests (void)
|
|
{
|
|
}
|
|
|
|
void SingleVertexArrayNormalizeTests::init (void)
|
|
{
|
|
// Test normalization with different input types, component counts and storage
|
|
Array::InputType inputTypes[] = {Array::INPUTTYPE_FLOAT, Array::INPUTTYPE_SHORT, Array::INPUTTYPE_BYTE, Array::INPUTTYPE_UNSIGNED_SHORT, Array::INPUTTYPE_UNSIGNED_BYTE, Array::INPUTTYPE_FIXED};
|
|
Array::Storage storages[] = {Array::STORAGE_USER};
|
|
int counts[] = {1, 256};
|
|
|
|
for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); inputTypeNdx++)
|
|
{
|
|
for (int storageNdx = 0; storageNdx < DE_LENGTH_OF_ARRAY(storages); storageNdx++)
|
|
{
|
|
for (int componentCount = 2; componentCount < 5; componentCount++)
|
|
{
|
|
for (int countNdx = 0; countNdx < DE_LENGTH_OF_ARRAY(counts); countNdx++)
|
|
{
|
|
MultiVertexArrayTest::Spec::ArraySpec arraySpec(inputTypes[inputTypeNdx],
|
|
Array::OUTPUTTYPE_VEC4,
|
|
storages[storageNdx],
|
|
Array::USAGE_DYNAMIC_DRAW,
|
|
componentCount,
|
|
0,
|
|
0,
|
|
true,
|
|
GLValue::getMinValue(inputTypes[inputTypeNdx]),
|
|
GLValue::getMaxValue(inputTypes[inputTypeNdx]));
|
|
|
|
MultiVertexArrayTest::Spec spec;
|
|
spec.primitive = Array::PRIMITIVE_TRIANGLES;
|
|
spec.drawCount = counts[countNdx];
|
|
spec.first = 0;
|
|
spec.arrays.push_back(arraySpec);
|
|
|
|
std::string name = spec.getName();
|
|
addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), name.c_str()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class SingleVertexArrayOutputTypeTests : public TestCaseGroup
|
|
{
|
|
public:
|
|
SingleVertexArrayOutputTypeTests (Context& context);
|
|
virtual ~SingleVertexArrayOutputTypeTests (void);
|
|
|
|
virtual void init (void);
|
|
|
|
private:
|
|
SingleVertexArrayOutputTypeTests (const SingleVertexArrayOutputTypeTests& other);
|
|
SingleVertexArrayOutputTypeTests& operator= (const SingleVertexArrayOutputTypeTests& other);
|
|
};
|
|
|
|
SingleVertexArrayOutputTypeTests::SingleVertexArrayOutputTypeTests (Context& context)
|
|
: TestCaseGroup(context, "output_types", "Single output type vertex atribute")
|
|
{
|
|
}
|
|
|
|
SingleVertexArrayOutputTypeTests::~SingleVertexArrayOutputTypeTests (void)
|
|
{
|
|
}
|
|
|
|
void SingleVertexArrayOutputTypeTests::init (void)
|
|
{
|
|
// Test output types with different input types, component counts and storage, Usage?, Precision?, float?
|
|
Array::InputType inputTypes[] = {Array::INPUTTYPE_FLOAT, Array::INPUTTYPE_SHORT, Array::INPUTTYPE_BYTE, Array::INPUTTYPE_UNSIGNED_SHORT, Array::INPUTTYPE_UNSIGNED_BYTE, Array::INPUTTYPE_FIXED};
|
|
Array::OutputType outputTypes[] = {Array::OUTPUTTYPE_VEC2, Array::OUTPUTTYPE_VEC3, Array::OUTPUTTYPE_VEC4};
|
|
Array::Storage storages[] = {Array::STORAGE_USER};
|
|
int counts[] = {1, 256};
|
|
|
|
for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); inputTypeNdx++)
|
|
{
|
|
for (int outputTypeNdx = 0; outputTypeNdx < DE_LENGTH_OF_ARRAY(outputTypes); outputTypeNdx++)
|
|
{
|
|
for (int storageNdx = 0; storageNdx < DE_LENGTH_OF_ARRAY(storages); storageNdx++)
|
|
{
|
|
for (int componentCount = 2; componentCount < 5; componentCount++)
|
|
{
|
|
for (int countNdx = 0; countNdx < DE_LENGTH_OF_ARRAY(counts); countNdx++)
|
|
{
|
|
MultiVertexArrayTest::Spec::ArraySpec arraySpec(inputTypes[inputTypeNdx],
|
|
outputTypes[outputTypeNdx],
|
|
storages[storageNdx],
|
|
Array::USAGE_DYNAMIC_DRAW,
|
|
componentCount,
|
|
0,
|
|
0,
|
|
false,
|
|
GLValue::getMinValue(inputTypes[inputTypeNdx]),
|
|
GLValue::getMaxValue(inputTypes[inputTypeNdx]));
|
|
|
|
MultiVertexArrayTest::Spec spec;
|
|
spec.primitive = Array::PRIMITIVE_TRIANGLES;
|
|
spec.drawCount = counts[countNdx];
|
|
spec.first = 0;
|
|
spec.arrays.push_back(arraySpec);
|
|
|
|
std::string name = spec.getName();
|
|
addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), name.c_str()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class SingleVertexArrayTestGroup : public TestCaseGroup
|
|
{
|
|
public:
|
|
SingleVertexArrayTestGroup (Context& context);
|
|
virtual ~SingleVertexArrayTestGroup (void);
|
|
|
|
virtual void init (void);
|
|
|
|
private:
|
|
SingleVertexArrayTestGroup (const SingleVertexArrayTestGroup& other);
|
|
SingleVertexArrayTestGroup& operator= (const SingleVertexArrayTestGroup& other);
|
|
};
|
|
|
|
SingleVertexArrayTestGroup::SingleVertexArrayTestGroup (Context& context)
|
|
: TestCaseGroup(context, "single_attribute", "Single vertex atribute")
|
|
{
|
|
}
|
|
|
|
SingleVertexArrayTestGroup::~SingleVertexArrayTestGroup (void)
|
|
{
|
|
}
|
|
|
|
void SingleVertexArrayTestGroup::init (void)
|
|
{
|
|
addChild(new SingleVertexArrayStrideTests(m_context));
|
|
addChild(new SingleVertexArrayNormalizeTests(m_context));
|
|
addChild(new SingleVertexArrayOutputTypeTests(m_context));
|
|
addChild(new SingleVertexArrayUsageTests(m_context));
|
|
addChild(new SingleVertexArrayOffsetTests(m_context));
|
|
addChild(new SingleVertexArrayFirstTests(m_context));
|
|
}
|
|
|
|
class MultiVertexArrayCountTests : public TestCaseGroup
|
|
{
|
|
public:
|
|
MultiVertexArrayCountTests (Context& context);
|
|
virtual ~MultiVertexArrayCountTests (void);
|
|
|
|
virtual void init (void);
|
|
|
|
private:
|
|
MultiVertexArrayCountTests (const MultiVertexArrayCountTests& other);
|
|
MultiVertexArrayCountTests& operator= (const MultiVertexArrayCountTests& other);
|
|
|
|
std::string getTestName (const MultiVertexArrayTest::Spec& spec);
|
|
};
|
|
|
|
MultiVertexArrayCountTests::MultiVertexArrayCountTests (Context& context)
|
|
: TestCaseGroup(context, "attribute_count", "Attribute counts")
|
|
{
|
|
}
|
|
|
|
MultiVertexArrayCountTests::~MultiVertexArrayCountTests (void)
|
|
{
|
|
}
|
|
|
|
std::string MultiVertexArrayCountTests::getTestName (const MultiVertexArrayTest::Spec& spec)
|
|
{
|
|
std::stringstream name;
|
|
name
|
|
<< spec.arrays.size();
|
|
|
|
return name.str();
|
|
}
|
|
|
|
void MultiVertexArrayCountTests::init (void)
|
|
{
|
|
// Test attribute counts
|
|
int arrayCounts[] = {2, 3, 4, 5, 6, 7, 8};
|
|
|
|
for (int arrayCountNdx = 0; arrayCountNdx < DE_LENGTH_OF_ARRAY(arrayCounts); arrayCountNdx++)
|
|
{
|
|
MultiVertexArrayTest::Spec spec;
|
|
|
|
spec.primitive = Array::PRIMITIVE_TRIANGLES;
|
|
spec.drawCount = 256;
|
|
spec.first = 0;
|
|
|
|
for (int arrayNdx = 0; arrayNdx < arrayCounts[arrayCountNdx]; arrayNdx++)
|
|
{
|
|
MultiVertexArrayTest::Spec::ArraySpec arraySpec(Array::INPUTTYPE_FLOAT,
|
|
Array::OUTPUTTYPE_VEC2,
|
|
Array::STORAGE_USER,
|
|
Array::USAGE_DYNAMIC_DRAW,
|
|
2,
|
|
0,
|
|
0,
|
|
false,
|
|
GLValue::getMinValue(Array::INPUTTYPE_FLOAT),
|
|
GLValue::getMaxValue(Array::INPUTTYPE_FLOAT));
|
|
|
|
spec.arrays.push_back(arraySpec);
|
|
}
|
|
|
|
std::string name = getTestName(spec);
|
|
std::string desc = getTestName(spec);
|
|
|
|
addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), desc.c_str()));
|
|
}
|
|
}
|
|
|
|
class MultiVertexArrayStorageTests : public TestCaseGroup
|
|
{
|
|
public:
|
|
MultiVertexArrayStorageTests (Context& context);
|
|
virtual ~MultiVertexArrayStorageTests (void);
|
|
|
|
virtual void init (void);
|
|
|
|
private:
|
|
MultiVertexArrayStorageTests (const MultiVertexArrayStorageTests& other);
|
|
MultiVertexArrayStorageTests& operator= (const MultiVertexArrayStorageTests& other);
|
|
|
|
void addStorageCases (MultiVertexArrayTest::Spec spec, int depth);
|
|
std::string getTestName (const MultiVertexArrayTest::Spec& spec);
|
|
};
|
|
|
|
MultiVertexArrayStorageTests::MultiVertexArrayStorageTests (Context& context)
|
|
: TestCaseGroup(context, "storage", "Attribute storages")
|
|
{
|
|
}
|
|
|
|
MultiVertexArrayStorageTests::~MultiVertexArrayStorageTests (void)
|
|
{
|
|
}
|
|
|
|
std::string MultiVertexArrayStorageTests::getTestName (const MultiVertexArrayTest::Spec& spec)
|
|
{
|
|
std::stringstream name;
|
|
name
|
|
<< spec.arrays.size();
|
|
|
|
for (int arrayNdx = 0; arrayNdx < (int)spec.arrays.size(); arrayNdx++)
|
|
{
|
|
name
|
|
<< "_"
|
|
<< Array::storageToString(spec.arrays[arrayNdx].storage);
|
|
}
|
|
|
|
return name.str();
|
|
}
|
|
|
|
void MultiVertexArrayStorageTests::addStorageCases (MultiVertexArrayTest::Spec spec, int depth)
|
|
{
|
|
if (depth == 0)
|
|
{
|
|
// Skip trivial case, used elsewhere
|
|
bool ok = false;
|
|
for (int arrayNdx = 0; arrayNdx < (int)spec.arrays.size(); arrayNdx++)
|
|
{
|
|
if (spec.arrays[arrayNdx].storage != Array::STORAGE_USER)
|
|
{
|
|
ok = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!ok)
|
|
return;
|
|
|
|
std::string name = getTestName(spec);
|
|
std::string desc = getTestName(spec);
|
|
|
|
addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), desc.c_str()));
|
|
return;
|
|
}
|
|
|
|
Array::Storage storages[] = {Array::STORAGE_USER, Array::STORAGE_BUFFER};
|
|
for (int storageNdx = 0; storageNdx < DE_LENGTH_OF_ARRAY(storages); storageNdx++)
|
|
{
|
|
MultiVertexArrayTest::Spec::ArraySpec arraySpec(Array::INPUTTYPE_FLOAT,
|
|
Array::OUTPUTTYPE_VEC2,
|
|
storages[storageNdx],
|
|
Array::USAGE_DYNAMIC_DRAW,
|
|
2,
|
|
0,
|
|
0,
|
|
false,
|
|
GLValue::getMinValue(Array::INPUTTYPE_FLOAT),
|
|
GLValue::getMaxValue(Array::INPUTTYPE_FLOAT));
|
|
|
|
MultiVertexArrayTest::Spec _spec = spec;
|
|
_spec.arrays.push_back(arraySpec);
|
|
addStorageCases(_spec, depth-1);
|
|
}
|
|
}
|
|
|
|
|
|
void MultiVertexArrayStorageTests::init (void)
|
|
{
|
|
// Test different storages
|
|
int arrayCounts[] = {3};
|
|
|
|
MultiVertexArrayTest::Spec spec;
|
|
|
|
spec.primitive = Array::PRIMITIVE_TRIANGLES;
|
|
spec.drawCount = 256;
|
|
spec.first = 0;
|
|
|
|
for (int arrayCountNdx = 0; arrayCountNdx < DE_LENGTH_OF_ARRAY(arrayCounts); arrayCountNdx++)
|
|
addStorageCases(spec, arrayCounts[arrayCountNdx]);
|
|
}
|
|
|
|
class MultiVertexArrayStrideTests : public TestCaseGroup
|
|
{
|
|
public:
|
|
MultiVertexArrayStrideTests (Context& context);
|
|
virtual ~MultiVertexArrayStrideTests (void);
|
|
|
|
virtual void init (void);
|
|
|
|
private:
|
|
MultiVertexArrayStrideTests (const MultiVertexArrayStrideTests& other);
|
|
MultiVertexArrayStrideTests& operator= (const MultiVertexArrayStrideTests& other);
|
|
|
|
void addStrideCases (MultiVertexArrayTest::Spec spec, int depth);
|
|
std::string getTestName (const MultiVertexArrayTest::Spec& spec);
|
|
};
|
|
|
|
MultiVertexArrayStrideTests::MultiVertexArrayStrideTests (Context& context)
|
|
: TestCaseGroup(context, "stride", "Strides")
|
|
{
|
|
}
|
|
|
|
MultiVertexArrayStrideTests::~MultiVertexArrayStrideTests (void)
|
|
{
|
|
}
|
|
|
|
std::string MultiVertexArrayStrideTests::getTestName (const MultiVertexArrayTest::Spec& spec)
|
|
{
|
|
std::stringstream name;
|
|
|
|
name
|
|
<< spec.arrays.size();
|
|
|
|
for (int arrayNdx = 0; arrayNdx < (int)spec.arrays.size(); arrayNdx++)
|
|
{
|
|
name
|
|
<< "_"
|
|
<< Array::inputTypeToString(spec.arrays[arrayNdx].inputType)
|
|
<< spec.arrays[arrayNdx].componentCount << "_"
|
|
<< spec.arrays[arrayNdx].stride;
|
|
}
|
|
|
|
return name.str();
|
|
}
|
|
|
|
void MultiVertexArrayStrideTests::init (void)
|
|
{
|
|
// Test different strides, with multiple arrays, input types??
|
|
int arrayCounts[] = {3};
|
|
|
|
MultiVertexArrayTest::Spec spec;
|
|
|
|
spec.primitive = Array::PRIMITIVE_TRIANGLES;
|
|
spec.drawCount = 256;
|
|
spec.first = 0;
|
|
|
|
for (int arrayCountNdx = 0; arrayCountNdx < DE_LENGTH_OF_ARRAY(arrayCounts); arrayCountNdx++)
|
|
addStrideCases(spec, arrayCounts[arrayCountNdx]);
|
|
}
|
|
|
|
void MultiVertexArrayStrideTests::addStrideCases (MultiVertexArrayTest::Spec spec, int depth)
|
|
{
|
|
if (depth == 0)
|
|
{
|
|
std::string name = getTestName(spec);
|
|
std::string desc = getTestName(spec);
|
|
addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), desc.c_str()));
|
|
return;
|
|
}
|
|
|
|
int strides[] = {0, -1, 17, 32};
|
|
|
|
for (int strideNdx = 0; strideNdx < DE_LENGTH_OF_ARRAY(strides); strideNdx++)
|
|
{
|
|
const int componentCount = 2;
|
|
MultiVertexArrayTest::Spec::ArraySpec arraySpec(Array::INPUTTYPE_FLOAT,
|
|
Array::OUTPUTTYPE_VEC2,
|
|
Array::STORAGE_USER,
|
|
Array::USAGE_DYNAMIC_DRAW,
|
|
componentCount,
|
|
0,
|
|
(strides[strideNdx] >= 0 ? strides[strideNdx] : componentCount * Array::inputTypeSize(Array::INPUTTYPE_FLOAT)),
|
|
false,
|
|
GLValue::getMinValue(Array::INPUTTYPE_FLOAT),
|
|
GLValue::getMaxValue(Array::INPUTTYPE_FLOAT));
|
|
|
|
MultiVertexArrayTest::Spec _spec = spec;
|
|
_spec.arrays.push_back(arraySpec);
|
|
addStrideCases(_spec, depth-1);
|
|
}
|
|
}
|
|
|
|
class MultiVertexArrayOutputTests : public TestCaseGroup
|
|
{
|
|
public:
|
|
MultiVertexArrayOutputTests (Context& context);
|
|
virtual ~MultiVertexArrayOutputTests (void);
|
|
|
|
virtual void init (void);
|
|
|
|
private:
|
|
MultiVertexArrayOutputTests (const MultiVertexArrayOutputTests& other);
|
|
MultiVertexArrayOutputTests& operator= (const MultiVertexArrayOutputTests& other);
|
|
|
|
void addInputTypeCases (MultiVertexArrayTest::Spec spec, int depth);
|
|
std::string getTestName (const MultiVertexArrayTest::Spec& spec);
|
|
};
|
|
|
|
MultiVertexArrayOutputTests::MultiVertexArrayOutputTests (Context& context)
|
|
: TestCaseGroup(context, "input_types", "input types")
|
|
{
|
|
}
|
|
|
|
MultiVertexArrayOutputTests::~MultiVertexArrayOutputTests (void)
|
|
{
|
|
}
|
|
|
|
std::string MultiVertexArrayOutputTests::getTestName (const MultiVertexArrayTest::Spec& spec)
|
|
{
|
|
std::stringstream name;
|
|
|
|
name
|
|
<< spec.arrays.size();
|
|
|
|
for (int arrayNdx = 0; arrayNdx < (int)spec.arrays.size(); arrayNdx++)
|
|
{
|
|
name
|
|
<< "_"
|
|
<< Array::inputTypeToString(spec.arrays[arrayNdx].inputType)
|
|
<< spec.arrays[arrayNdx].componentCount << "_"
|
|
<< Array::outputTypeToString(spec.arrays[arrayNdx].outputType);
|
|
}
|
|
|
|
return name.str();
|
|
}
|
|
|
|
void MultiVertexArrayOutputTests::init (void)
|
|
{
|
|
// Test different input types, with multiple arrays
|
|
int arrayCounts[] = {3};
|
|
|
|
MultiVertexArrayTest::Spec spec;
|
|
|
|
spec.primitive = Array::PRIMITIVE_TRIANGLES;
|
|
spec.drawCount = 256;
|
|
spec.first = 0;
|
|
|
|
for (int arrayCountNdx = 0; arrayCountNdx < DE_LENGTH_OF_ARRAY(arrayCounts); arrayCountNdx++)
|
|
addInputTypeCases(spec, arrayCounts[arrayCountNdx]);
|
|
}
|
|
|
|
void MultiVertexArrayOutputTests::addInputTypeCases (MultiVertexArrayTest::Spec spec, int depth)
|
|
{
|
|
if (depth == 0)
|
|
{
|
|
std::string name = getTestName(spec);
|
|
std::string desc = getTestName(spec);
|
|
addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), desc.c_str()));
|
|
return;
|
|
}
|
|
|
|
Array::InputType inputTypes[] = {Array::INPUTTYPE_FIXED, Array::INPUTTYPE_BYTE, Array::INPUTTYPE_SHORT, Array::INPUTTYPE_UNSIGNED_BYTE, Array::INPUTTYPE_UNSIGNED_SHORT};
|
|
for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); inputTypeNdx++)
|
|
{
|
|
MultiVertexArrayTest::Spec::ArraySpec arraySpec(inputTypes[inputTypeNdx],
|
|
Array::OUTPUTTYPE_VEC2,
|
|
Array::STORAGE_USER,
|
|
Array::USAGE_DYNAMIC_DRAW,
|
|
2,
|
|
0,
|
|
0,
|
|
false,
|
|
GLValue::getMinValue(inputTypes[inputTypeNdx]),
|
|
GLValue::getMaxValue(inputTypes[inputTypeNdx]));
|
|
|
|
MultiVertexArrayTest::Spec _spec = spec;
|
|
_spec.arrays.push_back(arraySpec);
|
|
addInputTypeCases(_spec, depth-1);
|
|
}
|
|
}
|
|
|
|
class MultiVertexArrayTestGroup : public TestCaseGroup
|
|
{
|
|
public:
|
|
MultiVertexArrayTestGroup (Context& context);
|
|
virtual ~MultiVertexArrayTestGroup (void);
|
|
|
|
virtual void init (void);
|
|
|
|
private:
|
|
MultiVertexArrayTestGroup (const MultiVertexArrayTestGroup& other);
|
|
MultiVertexArrayTestGroup& operator= (const MultiVertexArrayTestGroup& other);
|
|
};
|
|
|
|
MultiVertexArrayTestGroup::MultiVertexArrayTestGroup (Context& context)
|
|
: TestCaseGroup(context, "multiple_attributes", "Multiple vertex atributes")
|
|
{
|
|
}
|
|
|
|
MultiVertexArrayTestGroup::~MultiVertexArrayTestGroup (void)
|
|
{
|
|
}
|
|
|
|
void MultiVertexArrayTestGroup::init (void)
|
|
{
|
|
addChild(new MultiVertexArrayCountTests(m_context));
|
|
addChild(new MultiVertexArrayStorageTests(m_context));
|
|
addChild(new MultiVertexArrayStrideTests(m_context));
|
|
addChild(new MultiVertexArrayOutputTests(m_context));
|
|
}
|
|
|
|
VertexArrayTestGroup::VertexArrayTestGroup (Context& context)
|
|
: TestCaseGroup(context, "vertex_arrays", "Vertex array and array tests")
|
|
{
|
|
}
|
|
|
|
VertexArrayTestGroup::~VertexArrayTestGroup (void)
|
|
{
|
|
}
|
|
|
|
void VertexArrayTestGroup::init (void)
|
|
{
|
|
addChild(new SingleVertexArrayTestGroup(m_context));
|
|
addChild(new MultiVertexArrayTestGroup(m_context));
|
|
}
|
|
|
|
} // Functional
|
|
} // gles2
|
|
} // deqp
|
|
|