| /*------------------------------------------------------------------------- |
| * 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 Vertex array and buffer tests |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "es3fVertexArrayTest.hpp" |
| #include "glsVertexArrayTests.hpp" |
| |
| #include <sstream> |
| |
| using namespace deqp::gls; |
| |
| namespace deqp |
| { |
| namespace gles3 |
| { |
| namespace Functional |
| { |
| |
| class SingleVertexArrayUsageGroup : public TestCaseGroup |
| { |
| public: |
| SingleVertexArrayUsageGroup(Context &context, Array::Usage usage); |
| virtual ~SingleVertexArrayUsageGroup(void); |
| |
| virtual void init(void); |
| |
| private: |
| SingleVertexArrayUsageGroup(const SingleVertexArrayUsageGroup &other); |
| SingleVertexArrayUsageGroup &operator=(const SingleVertexArrayUsageGroup &other); |
| |
| Array::Usage m_usage; |
| }; |
| |
| SingleVertexArrayUsageGroup::SingleVertexArrayUsageGroup(Context &context, Array::Usage usage) |
| : TestCaseGroup(context, Array::usageTypeToString(usage).c_str(), Array::usageTypeToString(usage).c_str()) |
| , m_usage(usage) |
| { |
| } |
| |
| SingleVertexArrayUsageGroup::~SingleVertexArrayUsageGroup(void) |
| { |
| } |
| |
| template <class T> |
| static std::string typeToString(T t) |
| { |
| std::stringstream strm; |
| strm << t; |
| return strm.str(); |
| } |
| |
| void SingleVertexArrayUsageGroup::init(void) |
| { |
| 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++) |
| { |
| const int stride = |
| (strides[strideNdx] < 0 ? Array::inputTypeSize(inputTypes[inputTypeNdx]) * 2 : strides[strideNdx]); |
| const bool aligned = (stride % Array::inputTypeSize(inputTypes[inputTypeNdx])) == 0; |
| const std::string name = "stride" + typeToString(stride) + "_" + |
| Array::inputTypeToString(inputTypes[inputTypeNdx]) + "_quads" + |
| typeToString(counts[countNdx]); |
| |
| MultiVertexArrayTest::Spec::ArraySpec arraySpec(inputTypes[inputTypeNdx], Array::OUTPUTTYPE_VEC2, |
| Array::STORAGE_BUFFER, m_usage, 2, 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); |
| |
| if (aligned) |
| addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), |
| name.c_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, |
| Array::USAGE_STATIC_COPY, Array::USAGE_STREAM_COPY, Array::USAGE_DYNAMIC_COPY, |
| Array::USAGE_STATIC_READ, Array::USAGE_STREAM_READ, Array::USAGE_DYNAMIC_READ}; |
| for (int usageNdx = 0; usageNdx < DE_LENGTH_OF_ARRAY(usages); usageNdx++) |
| { |
| addChild(new SingleVertexArrayUsageGroup(m_context, usages[usageNdx])); |
| } |
| } |
| |
| class SingleVertexArrayStrideGroup : public TestCaseGroup |
| { |
| public: |
| SingleVertexArrayStrideGroup(Context &context, Array::InputType type); |
| virtual ~SingleVertexArrayStrideGroup(void); |
| |
| virtual void init(void); |
| |
| private: |
| SingleVertexArrayStrideGroup(const SingleVertexArrayStrideGroup &other); |
| SingleVertexArrayStrideGroup &operator=(const SingleVertexArrayStrideGroup &other); |
| |
| Array::InputType m_type; |
| }; |
| |
| SingleVertexArrayStrideGroup::SingleVertexArrayStrideGroup(Context &context, Array::InputType type) |
| : TestCaseGroup(context, Array::inputTypeToString(type).c_str(), Array::inputTypeToString(type).c_str()) |
| , m_type(type) |
| { |
| } |
| |
| SingleVertexArrayStrideGroup::~SingleVertexArrayStrideGroup(void) |
| { |
| } |
| |
| void SingleVertexArrayStrideGroup::init(void) |
| { |
| 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 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 bool packed = |
| m_type == Array::INPUTTYPE_UNSIGNED_INT_2_10_10_10 || m_type == Array::INPUTTYPE_INT_2_10_10_10; |
| const int stride = (strides[strideNdx] < 0) ? |
| ((packed) ? (16) : (Array::inputTypeSize(m_type) * componentCount)) : |
| (strides[strideNdx]); |
| const int alignment = |
| (packed) ? (Array::inputTypeSize(m_type) * componentCount) : (Array::inputTypeSize(m_type)); |
| const bool bufferUnaligned = |
| (storages[storageNdx] == Array::STORAGE_BUFFER) && (stride % alignment) != 0; |
| |
| std::string name = Array::storageToString(storages[storageNdx]) + "_stride" + typeToString(stride) + |
| "_components" + typeToString(componentCount) + "_quads" + |
| typeToString(counts[countNdx]); |
| |
| if ((m_type == Array::INPUTTYPE_UNSIGNED_INT_2_10_10_10 || |
| m_type == Array::INPUTTYPE_INT_2_10_10_10) && |
| componentCount != 4) |
| continue; |
| |
| MultiVertexArrayTest::Spec::ArraySpec arraySpec( |
| m_type, Array::OUTPUTTYPE_VEC4, storages[storageNdx], Array::USAGE_DYNAMIC_DRAW, componentCount, |
| 0, stride, false, GLValue::getMinValue(m_type), GLValue::getMaxValue(m_type)); |
| |
| MultiVertexArrayTest::Spec spec; |
| spec.primitive = Array::PRIMITIVE_TRIANGLES; |
| spec.drawCount = counts[countNdx]; |
| spec.first = 0; |
| spec.arrays.push_back(arraySpec); |
| |
| if (!bufferUnaligned) |
| 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) |
| { |
| Array::InputType inputTypes[] = { |
| Array::INPUTTYPE_FLOAT, Array::INPUTTYPE_SHORT, Array::INPUTTYPE_BYTE, |
| /*Array::INPUTTYPE_UNSIGNED_SHORT, Array::INPUTTYPE_UNSIGNED_BYTE,*/ Array::INPUTTYPE_FIXED, |
| Array::INPUTTYPE_INT_2_10_10_10}; |
| |
| for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); inputTypeNdx++) |
| { |
| addChild(new SingleVertexArrayStrideGroup(m_context, inputTypes[inputTypeNdx])); |
| } |
| } |
| |
| class SingleVertexArrayFirstGroup : public TestCaseGroup |
| { |
| public: |
| SingleVertexArrayFirstGroup(Context &context, Array::InputType type); |
| virtual ~SingleVertexArrayFirstGroup(void); |
| |
| virtual void init(void); |
| |
| private: |
| SingleVertexArrayFirstGroup(const SingleVertexArrayFirstGroup &other); |
| SingleVertexArrayFirstGroup &operator=(const SingleVertexArrayFirstGroup &other); |
| Array::InputType m_type; |
| }; |
| |
| SingleVertexArrayFirstGroup::SingleVertexArrayFirstGroup(Context &context, Array::InputType type) |
| : TestCaseGroup(context, Array::inputTypeToString(type).c_str(), Array::inputTypeToString(type).c_str()) |
| , m_type(type) |
| { |
| } |
| |
| SingleVertexArrayFirstGroup::~SingleVertexArrayFirstGroup(void) |
| { |
| } |
| |
| void SingleVertexArrayFirstGroup::init(void) |
| { |
| 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 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 bool packed = |
| m_type == Array::INPUTTYPE_UNSIGNED_INT_2_10_10_10 || m_type == Array::INPUTTYPE_INT_2_10_10_10; |
| const int componentCount = (packed) ? (4) : (2); |
| const int stride = (strides[strideNdx] < 0) ? |
| ((packed) ? (8) : (Array::inputTypeSize(m_type) * componentCount)) : |
| (strides[strideNdx]); |
| const int alignment = |
| (packed) ? (Array::inputTypeSize(m_type) * componentCount) : (Array::inputTypeSize(m_type)); |
| const bool aligned = ((stride % alignment) == 0) && ((offsets[offsetNdx] % alignment) == 0); |
| std::string name = "first" + typeToString(firsts[firstNdx]) + "_offset" + |
| typeToString(offsets[offsetNdx]) + "_stride" + typeToString(stride) + "_quads" + |
| typeToString(counts[countNdx]); |
| |
| MultiVertexArrayTest::Spec::ArraySpec arraySpec( |
| m_type, Array::OUTPUTTYPE_VEC2, Array::STORAGE_BUFFER, Array::USAGE_DYNAMIC_DRAW, |
| componentCount, offsets[offsetNdx], stride, false, GLValue::getMinValue(m_type), |
| GLValue::getMaxValue(m_type)); |
| |
| MultiVertexArrayTest::Spec spec; |
| spec.primitive = Array::PRIMITIVE_TRIANGLES; |
| spec.drawCount = counts[countNdx]; |
| spec.first = firsts[firstNdx]; |
| spec.arrays.push_back(arraySpec); |
| |
| if (aligned) |
| 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 attribute, different first values to drawArrays") |
| { |
| } |
| |
| SingleVertexArrayFirstTests::~SingleVertexArrayFirstTests(void) |
| { |
| } |
| |
| void SingleVertexArrayFirstTests::init(void) |
| { |
| // Test offset with different input types, component counts and storage, Usage(?) |
| Array::InputType inputTypes[] = {Array::INPUTTYPE_FLOAT, Array::INPUTTYPE_BYTE, Array::INPUTTYPE_INT_2_10_10_10}; |
| |
| for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); inputTypeNdx++) |
| { |
| addChild(new SingleVertexArrayFirstGroup(m_context, inputTypes[inputTypeNdx])); |
| } |
| } |
| |
| class SingleVertexArrayOffsetGroup : public TestCaseGroup |
| { |
| public: |
| SingleVertexArrayOffsetGroup(Context &context, Array::InputType type); |
| virtual ~SingleVertexArrayOffsetGroup(void); |
| |
| virtual void init(void); |
| |
| private: |
| SingleVertexArrayOffsetGroup(const SingleVertexArrayOffsetGroup &other); |
| SingleVertexArrayOffsetGroup &operator=(const SingleVertexArrayOffsetGroup &other); |
| Array::InputType m_type; |
| }; |
| |
| SingleVertexArrayOffsetGroup::SingleVertexArrayOffsetGroup(Context &context, Array::InputType type) |
| : TestCaseGroup(context, Array::inputTypeToString(type).c_str(), Array::inputTypeToString(type).c_str()) |
| , m_type(type) |
| { |
| } |
| |
| SingleVertexArrayOffsetGroup::~SingleVertexArrayOffsetGroup(void) |
| { |
| } |
| |
| void SingleVertexArrayOffsetGroup::init(void) |
| { |
| 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 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 bool packed = |
| m_type == Array::INPUTTYPE_UNSIGNED_INT_2_10_10_10 || m_type == Array::INPUTTYPE_INT_2_10_10_10; |
| const int componentCount = (packed) ? (4) : (2); |
| const int stride = |
| (strides[strideNdx] < 0 ? Array::inputTypeSize(m_type) * componentCount : strides[strideNdx]); |
| const int alignment = |
| (packed) ? (Array::inputTypeSize(m_type) * componentCount) : (Array::inputTypeSize(m_type)); |
| const bool aligned = ((stride % alignment) == 0) && ((offsets[offsetNdx] % alignment) == 0); |
| const std::string name = "offset" + typeToString(offsets[offsetNdx]) + "_stride" + |
| typeToString(stride) + "_quads" + typeToString(counts[countNdx]); |
| |
| MultiVertexArrayTest::Spec::ArraySpec arraySpec( |
| m_type, Array::OUTPUTTYPE_VEC2, Array::STORAGE_BUFFER, Array::USAGE_DYNAMIC_DRAW, componentCount, |
| offsets[offsetNdx], stride, false, GLValue::getMinValue(m_type), GLValue::getMaxValue(m_type)); |
| |
| MultiVertexArrayTest::Spec spec; |
| spec.primitive = Array::PRIMITIVE_TRIANGLES; |
| spec.drawCount = counts[countNdx]; |
| spec.first = 0; |
| spec.arrays.push_back(arraySpec); |
| |
| 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 offset with different input types, component counts and storage, Usage(?) |
| Array::InputType inputTypes[] = {Array::INPUTTYPE_FLOAT, Array::INPUTTYPE_BYTE, Array::INPUTTYPE_INT_2_10_10_10}; |
| |
| for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); inputTypeNdx++) |
| { |
| addChild(new SingleVertexArrayOffsetGroup(m_context, inputTypes[inputTypeNdx])); |
| } |
| } |
| |
| class SingleVertexArrayNormalizeGroup : public TestCaseGroup |
| { |
| public: |
| SingleVertexArrayNormalizeGroup(Context &context, Array::InputType type); |
| virtual ~SingleVertexArrayNormalizeGroup(void); |
| |
| virtual void init(void); |
| |
| private: |
| SingleVertexArrayNormalizeGroup(const SingleVertexArrayNormalizeGroup &other); |
| SingleVertexArrayNormalizeGroup &operator=(const SingleVertexArrayNormalizeGroup &other); |
| Array::InputType m_type; |
| }; |
| |
| SingleVertexArrayNormalizeGroup::SingleVertexArrayNormalizeGroup(Context &context, Array::InputType type) |
| : TestCaseGroup(context, Array::inputTypeToString(type).c_str(), Array::inputTypeToString(type).c_str()) |
| , m_type(type) |
| { |
| } |
| |
| SingleVertexArrayNormalizeGroup::~SingleVertexArrayNormalizeGroup(void) |
| { |
| } |
| |
| void SingleVertexArrayNormalizeGroup::init(void) |
| { |
| int counts[] = {1, 256}; |
| |
| for (int componentCount = 2; componentCount < 5; componentCount++) |
| { |
| for (int countNdx = 0; countNdx < DE_LENGTH_OF_ARRAY(counts); countNdx++) |
| { |
| if ((m_type == Array::INPUTTYPE_UNSIGNED_INT_2_10_10_10 || m_type == Array::INPUTTYPE_INT_2_10_10_10) && |
| componentCount != 4) |
| continue; |
| |
| std::string name = "components" + typeToString(componentCount) + "_quads" + typeToString(counts[countNdx]); |
| |
| MultiVertexArrayTest::Spec::ArraySpec arraySpec(m_type, Array::OUTPUTTYPE_VEC4, Array::STORAGE_USER, |
| Array::USAGE_DYNAMIC_DRAW, componentCount, 0, 0, true, |
| GLValue::getMinValue(m_type), GLValue::getMaxValue(m_type)); |
| |
| MultiVertexArrayTest::Spec spec; |
| spec.primitive = Array::PRIMITIVE_TRIANGLES; |
| spec.drawCount = counts[countNdx]; |
| spec.first = 0; |
| spec.arrays.push_back(arraySpec); |
| |
| 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::INPUTTYPE_UNSIGNED_INT, Array::INPUTTYPE_INT, |
| Array::INPUTTYPE_HALF, Array::INPUTTYPE_UNSIGNED_INT_2_10_10_10, |
| Array::INPUTTYPE_INT_2_10_10_10}; |
| |
| for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); inputTypeNdx++) |
| { |
| addChild(new SingleVertexArrayNormalizeGroup(m_context, inputTypes[inputTypeNdx])); |
| } |
| } |
| |
| class SingleVertexArrayOutputTypeGroup : public TestCaseGroup |
| { |
| public: |
| SingleVertexArrayOutputTypeGroup(Context &context, Array::InputType type); |
| virtual ~SingleVertexArrayOutputTypeGroup(void); |
| |
| virtual void init(void); |
| |
| private: |
| SingleVertexArrayOutputTypeGroup(const SingleVertexArrayOutputTypeGroup &other); |
| SingleVertexArrayOutputTypeGroup &operator=(const SingleVertexArrayOutputTypeGroup &other); |
| Array::InputType m_type; |
| }; |
| |
| SingleVertexArrayOutputTypeGroup::SingleVertexArrayOutputTypeGroup(Context &context, Array::InputType type) |
| : TestCaseGroup(context, Array::inputTypeToString(type).c_str(), Array::inputTypeToString(type).c_str()) |
| , m_type(type) |
| { |
| } |
| |
| SingleVertexArrayOutputTypeGroup::~SingleVertexArrayOutputTypeGroup(void) |
| { |
| } |
| |
| void SingleVertexArrayOutputTypeGroup::init(void) |
| { |
| Array::OutputType outputTypes[] = {Array::OUTPUTTYPE_VEC2, Array::OUTPUTTYPE_VEC3, Array::OUTPUTTYPE_VEC4, |
| Array::OUTPUTTYPE_IVEC2, Array::OUTPUTTYPE_IVEC3, Array::OUTPUTTYPE_IVEC4, |
| Array::OUTPUTTYPE_UVEC2, Array::OUTPUTTYPE_UVEC3, Array::OUTPUTTYPE_UVEC4}; |
| Array::Storage storages[] = {Array::STORAGE_USER}; |
| int counts[] = {1, 256}; |
| |
| 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++) |
| { |
| std::string name = "components" + typeToString(componentCount) + "_" + |
| Array::outputTypeToString(outputTypes[outputTypeNdx]) + "_quads" + |
| typeToString(counts[countNdx]); |
| |
| const bool inputIsSignedInteger = m_type == Array::INPUTTYPE_INT || |
| m_type == Array::INPUTTYPE_SHORT || |
| m_type == Array::INPUTTYPE_BYTE; |
| const bool inputIsUnignedInteger = m_type == Array::INPUTTYPE_UNSIGNED_INT || |
| m_type == Array::INPUTTYPE_UNSIGNED_SHORT || |
| m_type == Array::INPUTTYPE_UNSIGNED_BYTE; |
| const bool outputIsSignedInteger = outputTypes[outputTypeNdx] == Array::OUTPUTTYPE_IVEC2 || |
| outputTypes[outputTypeNdx] == Array::OUTPUTTYPE_IVEC3 || |
| outputTypes[outputTypeNdx] == Array::OUTPUTTYPE_IVEC4; |
| const bool outputIsUnsignedInteger = outputTypes[outputTypeNdx] == Array::OUTPUTTYPE_UVEC2 || |
| outputTypes[outputTypeNdx] == Array::OUTPUTTYPE_UVEC3 || |
| outputTypes[outputTypeNdx] == Array::OUTPUTTYPE_UVEC4; |
| |
| // If input type is float type and output type is int type skip |
| if ((m_type == Array::INPUTTYPE_FLOAT || m_type == Array::INPUTTYPE_HALF || |
| m_type == Array::INPUTTYPE_FIXED) && |
| (outputTypes[outputTypeNdx] >= Array::OUTPUTTYPE_INT)) |
| continue; |
| |
| if ((m_type == Array::INPUTTYPE_UNSIGNED_INT_2_10_10_10 || |
| m_type == Array::INPUTTYPE_INT_2_10_10_10) && |
| (outputTypes[outputTypeNdx] >= Array::OUTPUTTYPE_INT)) |
| continue; |
| |
| if ((m_type == Array::INPUTTYPE_UNSIGNED_INT_2_10_10_10 || |
| m_type == Array::INPUTTYPE_INT_2_10_10_10) && |
| componentCount != 4) |
| continue; |
| |
| // Loading signed data as unsigned causes undefined values and vice versa |
| if (inputIsSignedInteger && outputIsUnsignedInteger) |
| continue; |
| if (inputIsUnignedInteger && outputIsSignedInteger) |
| continue; |
| |
| MultiVertexArrayTest::Spec::ArraySpec arraySpec( |
| m_type, outputTypes[outputTypeNdx], storages[storageNdx], Array::USAGE_DYNAMIC_DRAW, |
| componentCount, 0, 0, false, GLValue::getMinValue(m_type), GLValue::getMaxValue(m_type)); |
| |
| MultiVertexArrayTest::Spec spec; |
| spec.primitive = Array::PRIMITIVE_TRIANGLES; |
| spec.drawCount = counts[countNdx]; |
| spec.first = 0; |
| spec.arrays.push_back(arraySpec); |
| |
| 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::INPUTTYPE_UNSIGNED_INT, Array::INPUTTYPE_INT, |
| Array::INPUTTYPE_HALF, Array::INPUTTYPE_UNSIGNED_INT_2_10_10_10, |
| Array::INPUTTYPE_INT_2_10_10_10}; |
| |
| for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); inputTypeNdx++) |
| { |
| addChild(new SingleVertexArrayOutputTypeGroup(m_context, inputTypes[inputTypeNdx])); |
| } |
| } |
| |
| 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)); |
| } |
| |
| } // namespace Functional |
| } // namespace gles3 |
| } // namespace deqp |
