summaryrefslogtreecommitdiffstats
path: root/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fVertexArrayTests.js
diff options
context:
space:
mode:
Diffstat (limited to 'dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fVertexArrayTests.js')
-rw-r--r--dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fVertexArrayTests.js1103
1 files changed, 1103 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fVertexArrayTests.js b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fVertexArrayTests.js
new file mode 100644
index 0000000000..ccfd343313
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fVertexArrayTests.js
@@ -0,0 +1,1103 @@
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program OpenGL ES Utilities
+ * ------------------------------------------------
+ *
+ * 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.
+ *
+ */
+
+'use strict';
+goog.provide('functional.gles3.es3fVertexArrayTests');
+goog.require('framework.common.tcuSurface');
+goog.require('framework.common.tcuTestCase');
+goog.require('framework.common.tcuTexture');
+goog.require('framework.delibs.debase.deMath');
+goog.require('framework.delibs.debase.deRandom');
+goog.require('framework.delibs.debase.deString');
+goog.require('framework.delibs.debase.deUtil');
+goog.require('framework.opengl.gluDrawUtil');
+goog.require('framework.opengl.gluShaderProgram');
+goog.require('framework.opengl.gluShaderUtil');
+goog.require('framework.opengl.gluTexture');
+goog.require('framework.opengl.gluVarType');
+goog.require('modules.shared.glsVertexArrayTests');
+
+goog.scope(function() {
+
+ var es3fVertexArrayTests = functional.gles3.es3fVertexArrayTests;
+ var gluDrawUtil = framework.opengl.gluDrawUtil;
+ var gluShaderUtil = framework.opengl.gluShaderUtil;
+ var gluShaderProgram = framework.opengl.gluShaderProgram;
+ var gluTexture = framework.opengl.gluTexture;
+ var gluVarType = framework.opengl.gluVarType;
+ var tcuTestCase = framework.common.tcuTestCase;
+ var tcuSurface = framework.common.tcuSurface;
+ var tcuTexture = framework.common.tcuTexture;
+ var deMath = framework.delibs.debase.deMath;
+ var deString = framework.delibs.debase.deString;
+ var deRandom = framework.delibs.debase.deRandom;
+ var deUtil = framework.delibs.debase.deUtil;
+ var glsVertexArrayTests = modules.shared.glsVertexArrayTests;
+
+ var DE_ASSERT = function(x) {
+ if (!x)
+ throw new Error('Assert failed');
+ };
+
+ /**
+ * es3fVertexArrayTests.SingleVertexArrayUsageGroup
+ * @constructor
+ * @extends {tcuTestCase.DeqpTest}
+ * @param {glsVertexArrayTests.deArray.Usage} usage
+ */
+ es3fVertexArrayTests.SingleVertexArrayUsageGroup = function(usage) {
+ tcuTestCase.DeqpTest.call(
+ this,
+ "single_attribute.usages." + glsVertexArrayTests.deArray.usageTypeToString(usage),
+ glsVertexArrayTests.deArray.usageTypeToString(usage)
+ );
+ this.makeExecutable();
+ this.m_usage = usage;
+ };
+
+ es3fVertexArrayTests.SingleVertexArrayUsageGroup.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
+ es3fVertexArrayTests.SingleVertexArrayUsageGroup.prototype.constructor = es3fVertexArrayTests.SingleVertexArrayUsageGroup;
+
+ /**
+ * init
+ */
+ es3fVertexArrayTests.SingleVertexArrayUsageGroup.prototype.init = function() {
+ /** @type {Array<number>} */ var counts = [1, 256];
+ /** @type {Array<number>} */ var strides = [0, -1, 17, 32]; // Treat negative value as sizeof input. Same as 0, but done outside of GL.
+ /** @type {Array<glsVertexArrayTests.deArray.InputType>} */ var inputTypes = [
+ glsVertexArrayTests.deArray.InputType.FLOAT,
+ /*glsVertexArrayTests.deArray.InputType.FIXED,*/
+ glsVertexArrayTests.deArray.InputType.SHORT,
+ glsVertexArrayTests.deArray.InputType.BYTE
+ ];
+
+ for (var inputTypeNdx = 0; inputTypeNdx < inputTypes.length; inputTypeNdx++) {
+ for (var countNdx = 0; countNdx < counts.length; countNdx++) {
+ for (var strideNdx = 0; strideNdx < strides.length; strideNdx++) {
+ /** @type {number} */ var stride = (strides[strideNdx] < 0 ? glsVertexArrayTests.deArray.inputTypeSize(inputTypes[inputTypeNdx]) * 2 : strides[strideNdx]);
+ /** @type {boolean} */ var aligned = (stride % glsVertexArrayTests.deArray.inputTypeSize(inputTypes[inputTypeNdx])) == 0;
+ /** @type {string} */ var name = 'stride' + stride + '_' + glsVertexArrayTests.deArray.inputTypeToString(inputTypes[inputTypeNdx]) + '_quads' + counts[countNdx];
+
+ var arraySpec = new glsVertexArrayTests.MultiVertexArrayTest.Spec.ArraySpec(
+ inputTypes[inputTypeNdx],
+ glsVertexArrayTests.deArray.OutputType.VEC2,
+ glsVertexArrayTests.deArray.Storage.BUFFER,
+ this.m_usage,
+ 2,
+ 0,
+ stride,
+ false,
+ glsVertexArrayTests.GLValue.getMinValue(inputTypes[inputTypeNdx]),
+ glsVertexArrayTests.GLValue.getMaxValue(inputTypes[inputTypeNdx])
+ );
+
+ var spec = new glsVertexArrayTests.MultiVertexArrayTest.Spec();
+ spec.primitive = glsVertexArrayTests.deArray.Primitive.TRIANGLES;
+ spec.drawCount = counts[countNdx];
+ spec.first = 0;
+ spec.arrays.push(arraySpec);
+
+ if (aligned)
+ this.addChild(
+ new glsVertexArrayTests.MultiVertexArrayTest(
+ spec, name, name
+ )
+ );
+ }
+ }
+ }
+ };
+
+ /**
+ * es3fVertexArrayTests.SingleVertexArrayStrideGroup
+ * @constructor
+ * @extends {tcuTestCase.DeqpTest}
+ * @param {glsVertexArrayTests.deArray.InputType} type
+ */
+ es3fVertexArrayTests.SingleVertexArrayStrideGroup = function(type) {
+ tcuTestCase.DeqpTest.call(this, glsVertexArrayTests.deArray.inputTypeToString(type), glsVertexArrayTests.deArray.inputTypeToString(type));
+ this.makeExecutable();
+ this.m_type = type;
+ };
+
+ es3fVertexArrayTests.SingleVertexArrayStrideGroup.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
+ es3fVertexArrayTests.SingleVertexArrayStrideGroup.prototype.constructor = es3fVertexArrayTests.SingleVertexArrayStrideGroup;
+
+ /**
+ * init
+ */
+ es3fVertexArrayTests.SingleVertexArrayStrideGroup.prototype.init = function() {
+ /** @type {Array<glsVertexArrayTests.deArray.Storage>} */ var storages = [
+ // User storage not supported in WebGL - glsVertexArrayTests.deArray.Storage.USER,
+ glsVertexArrayTests.deArray.Storage.BUFFER
+ ];
+ var counts = [1, 256];
+ var strides = [/*0,*/ -1, 17, 32]; // Treat negative value as sizeof input. Same as 0, but done outside of GL.
+
+ for (var storageNdx = 0; storageNdx < storages.length; storageNdx++) {
+ for (var componentCount = 2; componentCount < 5; componentCount++) {
+ for (var countNdx = 0; countNdx < counts.length; countNdx++) {
+ for (var strideNdx = 0; strideNdx < strides.length; strideNdx++) {
+ /** @type {boolean} */ var packed = this.m_type == glsVertexArrayTests.deArray.InputType.UNSIGNED_INT_2_10_10_10 || this.m_type == glsVertexArrayTests.deArray.InputType.INT_2_10_10_10;
+ /** @type {number} */ var stride = (strides[strideNdx] < 0) ? ((packed) ? (16) : (glsVertexArrayTests.deArray.inputTypeSize(this.m_type) * componentCount)) : (strides[strideNdx]);
+ /** @type {number} */ var alignment = (packed) ? (glsVertexArrayTests.deArray.inputTypeSize(this.m_type) * componentCount) : (glsVertexArrayTests.deArray.inputTypeSize(this.m_type));
+ /** @type {boolean} */ var bufferUnaligned = (storages[storageNdx] == glsVertexArrayTests.deArray.Storage.BUFFER) && (stride % alignment) != 0;
+
+ /** @type {string} */ var name = glsVertexArrayTests.deArray.storageToString(storages[storageNdx]) + '_stride' + stride + '_components' + componentCount + '_quads' + counts[countNdx];
+
+ if ((this.m_type == glsVertexArrayTests.deArray.InputType.UNSIGNED_INT_2_10_10_10 ||
+ this.m_type == glsVertexArrayTests.deArray.InputType.INT_2_10_10_10) && componentCount != 4)
+ continue;
+
+ /** @type {glsVertexArrayTests.MultiVertexArrayTest.Spec.ArraySpec} */ var arraySpec = new glsVertexArrayTests.MultiVertexArrayTest.Spec.ArraySpec(
+ this.m_type,
+ glsVertexArrayTests.deArray.OutputType.VEC4,
+ storages[storageNdx],
+ glsVertexArrayTests.deArray.Usage.DYNAMIC_DRAW,
+ componentCount,
+ 0,
+ stride,
+ false,
+ glsVertexArrayTests.GLValue.getMinValue(this.m_type),
+ glsVertexArrayTests.GLValue.getMaxValue(this.m_type)
+ );
+
+ var spec = new glsVertexArrayTests.MultiVertexArrayTest.Spec();
+
+ spec.primitive = glsVertexArrayTests.deArray.Primitive.TRIANGLES;
+ spec.drawCount = counts[countNdx];
+ spec.first = 0;
+ spec.arrays.push(arraySpec);
+
+ if (!bufferUnaligned)
+ this.addChild(
+ new glsVertexArrayTests.MultiVertexArrayTest(
+ spec, name, name
+ )
+ );
+ }
+ }
+ }
+ }
+ };
+
+ /**
+ * es3fVertexArrayTests.SingleVertexArrayStrideTests
+ * @constructor
+ * @extends {tcuTestCase.DeqpTest}
+ */
+ es3fVertexArrayTests.SingleVertexArrayStrideTests = function() {
+ tcuTestCase.DeqpTest.call(this, 'single_attribute.strides', 'Single stride vertex atribute');
+ this.makeExecutable();
+ };
+
+ es3fVertexArrayTests.SingleVertexArrayStrideTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
+ es3fVertexArrayTests.SingleVertexArrayStrideTests.prototype.constructor = es3fVertexArrayTests.SingleVertexArrayStrideTests;
+
+ es3fVertexArrayTests.SingleVertexArrayStrideTests.prototype.init = function() {
+ /** @type {Array<glsVertexArrayTests.deArray.InputType>} */ var inputTypes = [
+ glsVertexArrayTests.deArray.InputType.FLOAT,
+ glsVertexArrayTests.deArray.InputType.SHORT,
+ glsVertexArrayTests.deArray.InputType.BYTE,
+ /*glsVertexArrayTests.deArray.InputType.UNSIGNED_SHORT,
+ glsVertexArrayTests.deArray.InputType.UNSIGNED_BYTE,
+ glsVertexArrayTests.deArray.InputType.FIXED,*/
+ glsVertexArrayTests.deArray.InputType.INT_2_10_10_10
+ ];
+
+ for (var inputTypeNdx = 0; inputTypeNdx < inputTypes.length; inputTypeNdx++)
+ this.addChild(
+ new es3fVertexArrayTests.SingleVertexArrayStrideGroup(
+ inputTypes[inputTypeNdx]
+ )
+ );
+ };
+
+ /**
+ * @constructor
+ * @extends {tcuTestCase.DeqpTest}
+ * @param {glsVertexArrayTests.deArray.InputType} type
+ */
+ es3fVertexArrayTests.SingleVertexArrayFirstGroup = function(type) {
+ tcuTestCase.DeqpTest.call(
+ this,
+ glsVertexArrayTests.deArray.inputTypeToString(type),
+ glsVertexArrayTests.deArray.inputTypeToString(type)
+ );
+ this.makeExecutable();
+
+ this.m_type = type;
+ };
+
+ es3fVertexArrayTests.SingleVertexArrayFirstGroup.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
+ es3fVertexArrayTests.SingleVertexArrayFirstGroup.prototype.constructor = es3fVertexArrayTests.SingleVertexArrayFirstGroup;
+
+ /**
+ * init
+ */
+ es3fVertexArrayTests.SingleVertexArrayFirstGroup.prototype.init = function() {
+ var counts = [5, 256];
+ var firsts = [6, 24];
+ var offsets = [1, 16, 17];
+ var strides = [/*0,*/ -1, 17, 32]; // Tread negative value as sizeof input. Same as 0, but done outside of GL.
+
+ for (var offsetNdx = 0; offsetNdx < offsets.length; offsetNdx++) {
+ for (var countNdx = 0; countNdx < counts.length; countNdx++) {
+ for (var strideNdx = 0; strideNdx < strides.length; strideNdx++) {
+ for (var firstNdx = 0; firstNdx < firsts.length; firstNdx++) {
+ var packed = this.m_type == glsVertexArrayTests.deArray.InputType.UNSIGNED_INT_2_10_10_10 ||
+ this.m_type == glsVertexArrayTests.deArray.InputType.INT_2_10_10_10;
+ var componentCount = packed ? 4 : 2;
+ var stride = strides[strideNdx] < 0 ?
+ (packed ? 8 : (glsVertexArrayTests.deArray.inputTypeSize(this.m_type) * componentCount)) :
+ (strides[strideNdx]);
+ var alignment = packed ?
+ (glsVertexArrayTests.deArray.inputTypeSize(this.m_type) * componentCount) :
+ (glsVertexArrayTests.deArray.inputTypeSize(this.m_type));
+ var aligned = ((stride % alignment) == 0) &&
+ ((offsets[offsetNdx] % alignment) == 0);
+ var name = 'first' + firsts[firstNdx] + '_offset' + offsets[offsetNdx] + '_stride' + stride + '_quads' + counts[countNdx];
+
+ var arraySpec = new glsVertexArrayTests.MultiVertexArrayTest.Spec.ArraySpec(
+ this.m_type,
+ glsVertexArrayTests.deArray.OutputType.VEC2,
+ glsVertexArrayTests.deArray.Storage.BUFFER,
+ glsVertexArrayTests.deArray.Usage.DYNAMIC_DRAW,
+ componentCount,
+ offsets[offsetNdx],
+ stride,
+ false,
+ glsVertexArrayTests.GLValue.getMinValue(this.m_type),
+ glsVertexArrayTests.GLValue.getMaxValue(this.m_type)
+ );
+
+ var spec = new glsVertexArrayTests.MultiVertexArrayTest.Spec();
+ spec.primitive = glsVertexArrayTests.deArray.Primitive.TRIANGLES;
+ spec.drawCount = counts[countNdx];
+ spec.first = firsts[firstNdx];
+ spec.arrays.push(arraySpec);
+
+ if (aligned)
+ this.addChild(
+ new glsVertexArrayTests.MultiVertexArrayTest(
+ spec, name, name
+ )
+ );
+ }
+ }
+ }
+ }
+ };
+
+ /**
+ * @constructor
+ * @extends {tcuTestCase.DeqpTest}
+ */
+ es3fVertexArrayTests.SingleVertexArrayFirstTests = function() {
+ tcuTestCase.DeqpTest.call(this, 'single_attribute.first', 'Single vertex attribute, different first values to drawArrays');
+ this.makeExecutable();
+ };
+
+ es3fVertexArrayTests.SingleVertexArrayFirstTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
+ es3fVertexArrayTests.SingleVertexArrayFirstTests.prototype.constructor = es3fVertexArrayTests.SingleVertexArrayFirstTests;
+
+ /**
+ * init
+ */
+ es3fVertexArrayTests.SingleVertexArrayFirstTests.prototype.init = function() {
+ // Test offset with different input types, component counts and storage, Usage(?)
+ var inputTypes = [
+ glsVertexArrayTests.deArray.InputType.FLOAT,
+ glsVertexArrayTests.deArray.InputType.BYTE,
+ glsVertexArrayTests.deArray.InputType.INT_2_10_10_10
+ ];
+
+ for (var inputTypeNdx = 0; inputTypeNdx < inputTypes.length; inputTypeNdx++) {
+ this.addChild(
+ new es3fVertexArrayTests.SingleVertexArrayFirstGroup(
+ inputTypes[inputTypeNdx]
+ )
+ );
+ }
+ };
+
+ /**
+ * @constructor
+ * @extends {tcuTestCase.DeqpTest}
+ * @param {glsVertexArrayTests.deArray.InputType} type
+ */
+ es3fVertexArrayTests.SingleVertexArrayOffsetGroup = function(type) {
+ tcuTestCase.DeqpTest.call(
+ this,
+ glsVertexArrayTests.deArray.inputTypeToString(type),
+ glsVertexArrayTests.deArray.inputTypeToString(type)
+ );
+ this.makeExecutable();
+ this.m_type = type;
+ };
+
+ es3fVertexArrayTests.SingleVertexArrayOffsetGroup.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
+ es3fVertexArrayTests.SingleVertexArrayOffsetGroup.prototype.constructor = es3fVertexArrayTests.SingleVertexArrayOffsetGroup;
+
+ /**
+ * init
+ */
+ es3fVertexArrayTests.SingleVertexArrayOffsetGroup.prototype.init = function() {
+ var counts = [1, 256];
+ var offsets = [1, 4, 17, 32];
+ var strides = [/*0,*/ -1, 17, 32]; // Tread negative value as sizeof input. Same as 0, but done outside of GL.
+
+ for (var offsetNdx = 0; offsetNdx < offsets.length; offsetNdx++) {
+ for (var countNdx = 0; countNdx < counts.length; countNdx++) {
+ for (var strideNdx = 0; strideNdx < strides.length; strideNdx++) {
+ var packed = this.m_type == glsVertexArrayTests.deArray.InputType.UNSIGNED_INT_2_10_10_10 ||
+ this.m_type == glsVertexArrayTests.deArray.InputType.INT_2_10_10_10;
+ var componentCount = packed ? 4 : 2;
+ var stride = (
+ strides[strideNdx] < 0 ?
+ glsVertexArrayTests.deArray.inputTypeSize(
+ this.m_type
+ ) * componentCount :
+ strides[strideNdx]
+ );
+ var alignment = packed ?
+ glsVertexArrayTests.deArray.inputTypeSize(this.m_type) * componentCount :
+ glsVertexArrayTests.deArray.inputTypeSize(this.m_type);
+
+ var aligned = ((stride % alignment) == 0) &&
+ ((offsets[offsetNdx] % alignment) == 0);
+ var name = 'offset' + offsets[offsetNdx] +
+ '_stride' + stride + '_quads' +
+ counts[countNdx];
+
+ /** @type {glsVertexArrayTests.MultiVertexArrayTest.Spec.ArraySpec} */ var arraySpec = new glsVertexArrayTests.MultiVertexArrayTest.Spec.ArraySpec(
+ this.m_type,
+ glsVertexArrayTests.deArray.OutputType.VEC2,
+ glsVertexArrayTests.deArray.Storage.BUFFER,
+ glsVertexArrayTests.deArray.Usage.DYNAMIC_DRAW,
+ componentCount,
+ offsets[offsetNdx],
+ stride,
+ false,
+ glsVertexArrayTests.GLValue.getMinValue(this.m_type),
+ glsVertexArrayTests.GLValue.getMaxValue(this.m_type)
+ );
+
+ var spec = new glsVertexArrayTests.MultiVertexArrayTest.Spec();
+ spec.primitive = glsVertexArrayTests.deArray.Primitive.TRIANGLES;
+ spec.drawCount = counts[countNdx];
+ spec.first = 0;
+ spec.arrays.push(arraySpec);
+
+ if (aligned)
+ this.addChild(
+ new glsVertexArrayTests.MultiVertexArrayTest(
+ spec, name, name
+ )
+ );
+ }
+ }
+ }
+ };
+
+ /**
+ * @constructor
+ * @extends {tcuTestCase.DeqpTest}
+ */
+ es3fVertexArrayTests.SingleVertexArrayOffsetTests = function() {
+ tcuTestCase.DeqpTest.call(this, 'single_attribute.offset', 'Single vertex atribute offset element');
+ this.makeExecutable();
+ };
+
+ es3fVertexArrayTests.SingleVertexArrayOffsetTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
+ es3fVertexArrayTests.SingleVertexArrayOffsetTests.prototype.constructor = es3fVertexArrayTests.SingleVertexArrayOffsetTests;
+
+ /**
+ * init
+ */
+ es3fVertexArrayTests.SingleVertexArrayOffsetTests.prototype.init = function() {
+ // Test offset with different input types, component counts and storage, Usage(?)
+ var inputTypes = [
+ glsVertexArrayTests.deArray.InputType.FLOAT,
+ glsVertexArrayTests.deArray.InputType.BYTE,
+ glsVertexArrayTests.deArray.InputType.INT_2_10_10_10
+ ];
+
+ for (var inputTypeNdx = 0; inputTypeNdx < inputTypes.length; inputTypeNdx++) {
+ this.addChild(
+ new es3fVertexArrayTests.SingleVertexArrayOffsetGroup(
+ inputTypes[inputTypeNdx]
+ )
+ );
+ }
+ };
+
+ /**
+ * @constructor
+ * @extends {tcuTestCase.DeqpTest}
+ * @param {glsVertexArrayTests.deArray.InputType} type
+ */
+ es3fVertexArrayTests.SingleVertexArrayNormalizeGroup = function(type) {
+ tcuTestCase.DeqpTest.call(
+ this,
+ glsVertexArrayTests.deArray.inputTypeToString(type),
+ glsVertexArrayTests.deArray.inputTypeToString(type)
+ );
+ this.makeExecutable();
+ this.m_type = type;
+ };
+
+ es3fVertexArrayTests.SingleVertexArrayNormalizeGroup.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
+ es3fVertexArrayTests.SingleVertexArrayNormalizeGroup.prototype.constructor = es3fVertexArrayTests.SingleVertexArrayNormalizeGroup;
+
+ /**
+ * init for SingleVertexArrayNormalizeGroup
+ */
+ es3fVertexArrayTests.SingleVertexArrayNormalizeGroup.prototype.init = function() {
+ var counts = [1, 256];
+
+ for (var componentCount = 2; componentCount < 5; componentCount++) {
+ for (var countNdx = 0; countNdx < counts.length; countNdx++) {
+ if (
+ (
+ this.m_type == glsVertexArrayTests.deArray.InputType.UNSIGNED_INT_2_10_10_10 ||
+ this.m_type == glsVertexArrayTests.deArray.InputType.INT_2_10_10_10
+ ) && componentCount != 4
+ )
+ continue;
+
+ var name = 'components' + componentCount.toString() + '_quads' + counts[countNdx].toString();
+
+ var arraySpec = new glsVertexArrayTests.MultiVertexArrayTest.Spec.ArraySpec(
+ this.m_type,
+ glsVertexArrayTests.deArray.OutputType.VEC4,
+ glsVertexArrayTests.deArray.Storage.BUFFER, //No USER Storage support in WebGL2
+ glsVertexArrayTests.deArray.Usage.DYNAMIC_DRAW,
+ componentCount,
+ 0,
+ 0,
+ true,
+ glsVertexArrayTests.GLValue.getMinValue(this.m_type),
+ glsVertexArrayTests.GLValue.getMaxValue(this.m_type)
+ );
+
+ var spec = new glsVertexArrayTests.MultiVertexArrayTest.Spec();
+ spec.primitive = glsVertexArrayTests.deArray.Primitive.TRIANGLES;
+ spec.drawCount = counts[countNdx];
+ spec.first = 0;
+ spec.arrays.push(arraySpec);
+
+ this.addChild(
+ new glsVertexArrayTests.MultiVertexArrayTest(
+ spec, name, name
+ )
+ );
+ }
+ }
+ };
+
+ /**
+ * @constructor
+ * @extends {tcuTestCase.DeqpTest}
+ */
+ es3fVertexArrayTests.SingleVertexArrayNormalizeTests = function() {
+ tcuTestCase.DeqpTest.call(this, 'single_attribute.normalize', 'Single normalize vertex atribute');
+ this.makeExecutable();
+ };
+
+ es3fVertexArrayTests.SingleVertexArrayNormalizeTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
+ es3fVertexArrayTests.SingleVertexArrayNormalizeTests.prototype.constructor = es3fVertexArrayTests.SingleVertexArrayNormalizeTests;
+
+ /**
+ * init
+ */
+ es3fVertexArrayTests.SingleVertexArrayNormalizeTests.prototype.init = function() {
+ // Test normalization with different input types, component counts and storage
+ /** @type {Array<glsVertexArrayTests.deArray.InputType>} */ var inputTypes = [
+ glsVertexArrayTests.deArray.InputType.FLOAT,
+ glsVertexArrayTests.deArray.InputType.SHORT,
+ glsVertexArrayTests.deArray.InputType.BYTE,
+ glsVertexArrayTests.deArray.InputType.UNSIGNED_SHORT,
+ glsVertexArrayTests.deArray.InputType.UNSIGNED_BYTE,
+ //glsVertexArrayTests.deArray.InputType.FIXED,
+ glsVertexArrayTests.deArray.InputType.UNSIGNED_INT,
+ glsVertexArrayTests.deArray.InputType.INT,
+ glsVertexArrayTests.deArray.InputType.HALF,
+ glsVertexArrayTests.deArray.InputType.UNSIGNED_INT_2_10_10_10,
+ glsVertexArrayTests.deArray.InputType.INT_2_10_10_10
+ ];
+
+ for (var inputTypeNdx = 0; inputTypeNdx < inputTypes.length; inputTypeNdx++) {
+ this.addChild(
+ new es3fVertexArrayTests.SingleVertexArrayNormalizeGroup(
+ inputTypes[inputTypeNdx]
+ )
+ );
+ }
+ };
+
+ /**
+ * @constructor
+ * @extends {tcuTestCase.DeqpTest}
+ * @param {glsVertexArrayTests.deArray.InputType} type
+ */
+ es3fVertexArrayTests.SingleVertexArrayOutputTypeGroup = function(type) {
+ tcuTestCase.DeqpTest.call(
+ this,
+ "single_attribute.output_types." + glsVertexArrayTests.deArray.inputTypeToString(type),
+ glsVertexArrayTests.deArray.inputTypeToString(type)
+ );
+ this.makeExecutable();
+ this.m_type = type;
+ };
+
+ es3fVertexArrayTests.SingleVertexArrayOutputTypeGroup.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
+ es3fVertexArrayTests.SingleVertexArrayOutputTypeGroup.prototype.constructor = es3fVertexArrayTests.SingleVertexArrayOutputTypeGroup;
+
+ es3fVertexArrayTests.SingleVertexArrayOutputTypeGroup.prototype.init = function() {
+ var outputTypes = [
+ glsVertexArrayTests.deArray.OutputType.VEC2,
+ glsVertexArrayTests.deArray.OutputType.VEC3,
+ glsVertexArrayTests.deArray.OutputType.VEC4,
+ glsVertexArrayTests.deArray.OutputType.IVEC2,
+ glsVertexArrayTests.deArray.OutputType.IVEC3,
+ glsVertexArrayTests.deArray.OutputType.IVEC4,
+ glsVertexArrayTests.deArray.OutputType.UVEC2,
+ glsVertexArrayTests.deArray.OutputType.UVEC3,
+ glsVertexArrayTests.deArray.OutputType.UVEC4
+ ];
+ var storages = [glsVertexArrayTests.deArray.Storage.BUFFER]; //No USER storage support in WebGL2
+ var counts = [1, 256];
+
+ for (var outputTypeNdx = 0; outputTypeNdx < outputTypes.length; outputTypeNdx++) {
+ for (var storageNdx = 0; storageNdx < storages.length; storageNdx++) {
+ for (var componentCount = 2; componentCount < 5; componentCount++) {
+ for (var countNdx = 0; countNdx < counts.length; countNdx++) {
+ var name = 'components' + componentCount + '_' +
+ glsVertexArrayTests.deArray.outputTypeToString(
+ outputTypes[outputTypeNdx]
+ ) +
+ '_quads' + counts[countNdx];
+
+ var inputIsSignedInteger =
+ this.m_type == glsVertexArrayTests.deArray.InputType.INT ||
+ this.m_type == glsVertexArrayTests.deArray.InputType.SHORT ||
+ this.m_type == glsVertexArrayTests.deArray.InputType.BYTE;
+
+ var inputIsUnignedInteger =
+ this.m_type == glsVertexArrayTests.deArray.InputType.UNSIGNED_INT ||
+ this.m_type == glsVertexArrayTests.deArray.InputType.UNSIGNED_SHORT ||
+ this.m_type == glsVertexArrayTests.deArray.InputType.UNSIGNED_BYTE;
+
+ var outputIsSignedInteger =
+ outputTypes[outputTypeNdx] == glsVertexArrayTests.deArray.OutputType.IVEC2 ||
+ outputTypes[outputTypeNdx] == glsVertexArrayTests.deArray.OutputType.IVEC3 ||
+ outputTypes[outputTypeNdx] == glsVertexArrayTests.deArray.OutputType.IVEC4;
+
+ var outputIsUnsignedInteger =
+ outputTypes[outputTypeNdx] == glsVertexArrayTests.deArray.OutputType.UVEC2 ||
+ outputTypes[outputTypeNdx] == glsVertexArrayTests.deArray.OutputType.UVEC3 ||
+ outputTypes[outputTypeNdx] == glsVertexArrayTests.deArray.OutputType.UVEC4;
+
+ // If input type is float type and output type is int type skip
+ if ((this.m_type == glsVertexArrayTests.deArray.InputType.FLOAT ||
+ this.m_type == glsVertexArrayTests.deArray.InputType.HALF) &&
+ (outputTypes[outputTypeNdx] >= glsVertexArrayTests.deArray.OutputType.INT))
+ continue;
+
+ if ((this.m_type == glsVertexArrayTests.deArray.InputType.UNSIGNED_INT_2_10_10_10 ||
+ this.m_type == glsVertexArrayTests.deArray.InputType.INT_2_10_10_10) &&
+ (outputTypes[outputTypeNdx] >= glsVertexArrayTests.deArray.OutputType.INT))
+ continue;
+
+ if ((this.m_type == glsVertexArrayTests.deArray.InputType.UNSIGNED_INT_2_10_10_10 ||
+ this.m_type == glsVertexArrayTests.deArray.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;
+
+ var arraySpec = new glsVertexArrayTests.MultiVertexArrayTest.Spec.ArraySpec(
+ this.m_type,
+ outputTypes[outputTypeNdx],
+ storages[storageNdx],
+ glsVertexArrayTests.deArray.Usage.DYNAMIC_DRAW,
+ componentCount,
+ 0,
+ 0,
+ false,
+ glsVertexArrayTests.GLValue.getMinValue(this.m_type),
+ glsVertexArrayTests.GLValue.getMaxValue(this.m_type)
+ );
+
+ var spec = new glsVertexArrayTests.MultiVertexArrayTest.Spec();
+ spec.primitive = glsVertexArrayTests.deArray.Primitive.TRIANGLES;
+ spec.drawCount = counts[countNdx];
+ spec.first = 0;
+ spec.arrays.push(arraySpec);
+
+ this.addChild(
+ new glsVertexArrayTests.MultiVertexArrayTest(
+ spec, name, name
+ )
+ );
+ }
+ }
+ }
+ }
+ };
+
+ /**
+ * @constructor
+ * @extends {tcuTestCase.DeqpTest}
+ */
+ es3fVertexArrayTests.MultiVertexArrayCountTests = function() {
+ tcuTestCase.DeqpTest.call(this, 'multiple_attributes.attribute_count', 'Attribute counts');
+ this.makeExecutable();
+ };
+
+ es3fVertexArrayTests.MultiVertexArrayCountTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
+ es3fVertexArrayTests.MultiVertexArrayCountTests.prototype.constructor = es3fVertexArrayTests.MultiVertexArrayCountTests;
+
+ /**
+ * @param {glsVertexArrayTests.MultiVertexArrayTest.Spec} spec
+ * @return {string}
+ */
+ es3fVertexArrayTests.MultiVertexArrayCountTests.prototype.getTestName = function(spec) {
+ var name = '';
+ name += spec.arrays.length;
+
+ return name;
+ };
+
+ es3fVertexArrayTests.MultiVertexArrayCountTests.prototype.init = function() {
+ // Test attribute counts
+ var arrayCounts = [2, 3, 4, 5, 6, 7, 8];
+
+ for (var arrayCountNdx = 0; arrayCountNdx < arrayCounts.length; arrayCountNdx++) {
+ var spec = new glsVertexArrayTests.MultiVertexArrayTest.Spec();
+
+ spec.primitive = glsVertexArrayTests.deArray.Primitive.TRIANGLES;
+ spec.drawCount = 256;
+ spec.first = 0;
+
+ for (var arrayNdx = 0; arrayNdx < arrayCounts[arrayCountNdx]; arrayNdx++) {
+ var arraySpec = new glsVertexArrayTests.MultiVertexArrayTest.Spec.ArraySpec(
+ glsVertexArrayTests.deArray.InputType.FLOAT,
+ glsVertexArrayTests.deArray.OutputType.VEC2,
+ glsVertexArrayTests.deArray.Storage.BUFFER, // No USER storage support in WebGL2
+ glsVertexArrayTests.deArray.Usage.DYNAMIC_DRAW,
+ 2,
+ 0,
+ 0,
+ false,
+ glsVertexArrayTests.GLValue.getMinValue(glsVertexArrayTests.deArray.InputType.FLOAT),
+ glsVertexArrayTests.GLValue.getMaxValue(glsVertexArrayTests.deArray.InputType.FLOAT)
+ );
+ spec.arrays.push(arraySpec);
+ }
+
+ var name = this.getTestName(spec);
+ var desc = this.getTestName(spec);
+
+ this.addChild(
+ new glsVertexArrayTests.MultiVertexArrayTest(
+ spec, name, desc
+ )
+ );
+ }
+ };
+
+ /**
+ * @constructor
+ * @extends {tcuTestCase.DeqpTest}
+ */
+ es3fVertexArrayTests.MultiVertexArrayStorageTests = function() {
+ tcuTestCase.DeqpTest.call(this, 'multiple_attributes.storage', 'Attribute storages');
+ this.makeExecutable();
+ };
+
+ es3fVertexArrayTests.MultiVertexArrayStorageTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
+ es3fVertexArrayTests.MultiVertexArrayStorageTests.prototype.constructor = es3fVertexArrayTests.MultiVertexArrayStorageTests;
+
+ /**
+ * @param {glsVertexArrayTests.MultiVertexArrayTest.Spec} spec
+ * @return {string}
+ */
+ es3fVertexArrayTests.MultiVertexArrayStorageTests.prototype.getTestName = function(spec) {
+ var name = '';
+ name += spec.arrays.length;
+
+ for (var arrayNdx = 0; arrayNdx < spec.arrays.length; arrayNdx++)
+ name += '_' + glsVertexArrayTests.deArray.storageToString(spec.arrays[arrayNdx].storage);
+
+ return name;
+ };
+
+ /**
+ * @param {glsVertexArrayTests.MultiVertexArrayTest.Spec} spec
+ * @param {number} depth
+ */
+ es3fVertexArrayTests.MultiVertexArrayStorageTests.prototype.addStorageCases = function(spec, depth) {
+ if (depth == 0) {
+ // Skip trivial case, used elsewhere
+ var ok = false;
+ for (var arrayNdx = 0; arrayNdx < spec.arrays.length; arrayNdx++) {
+ if (spec.arrays[arrayNdx].storage != glsVertexArrayTests.deArray.Storage.USER) {
+ ok = true;
+ break;
+ }
+ }
+
+ if (!ok)
+ return;
+
+ var name = this.getTestName(spec);
+ var desc = this.getTestName(spec);
+
+ this.addChild(
+ new glsVertexArrayTests.MultiVertexArrayTest(
+ spec, name, desc
+ )
+ );
+ return;
+ }
+
+ var storages = [
+ //glsVertexArrayTests.deArray.Storage.USER, Not supported in WebGL 2.0
+ glsVertexArrayTests.deArray.Storage.BUFFER
+ ];
+
+ for (var storageNdx = 0; storageNdx < storages.length; storageNdx++) {
+ var arraySpec = new glsVertexArrayTests.MultiVertexArrayTest.Spec.ArraySpec(
+ glsVertexArrayTests.deArray.InputType.FLOAT,
+ glsVertexArrayTests.deArray.OutputType.VEC2,
+ storages[storageNdx],
+ glsVertexArrayTests.deArray.Usage.DYNAMIC_DRAW,
+ 2,
+ 0,
+ 0,
+ false,
+ glsVertexArrayTests.GLValue.getMinValue(glsVertexArrayTests.deArray.InputType.FLOAT),
+ glsVertexArrayTests.GLValue.getMaxValue(glsVertexArrayTests.deArray.InputType.FLOAT)
+ );
+
+ var _spec = spec;
+ _spec.arrays.push(arraySpec);
+ this.addStorageCases(_spec, depth - 1);
+ }
+ };
+
+ /**
+ * init
+ */
+ es3fVertexArrayTests.MultiVertexArrayStorageTests.prototype.init = function() {
+ // Test different storages
+ var arrayCounts = [3];
+
+ var spec = new glsVertexArrayTests.MultiVertexArrayTest.Spec();
+
+ spec.primitive = glsVertexArrayTests.deArray.Primitive.TRIANGLES;
+ spec.drawCount = 256;
+ spec.first = 0;
+
+ for (var arrayCountNdx = 0; arrayCountNdx < arrayCounts.length; arrayCountNdx++)
+ this.addStorageCases(spec, arrayCounts[arrayCountNdx]);
+ };
+
+ /**
+ * @constructor
+ * @extends {tcuTestCase.DeqpTest}
+ */
+ es3fVertexArrayTests.MultiVertexArrayStrideTests = function() {
+ tcuTestCase.DeqpTest.call(this, 'multiple_attributes.stride', 'Strides');
+ this.makeExecutable();
+ };
+
+ es3fVertexArrayTests.MultiVertexArrayStrideTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
+ es3fVertexArrayTests.MultiVertexArrayStrideTests.prototype.constructor = es3fVertexArrayTests.MultiVertexArrayStrideTests;
+
+ /**
+ * @param {glsVertexArrayTests.MultiVertexArrayTest.Spec} spec
+ * @return {string}
+ */
+ es3fVertexArrayTests.MultiVertexArrayStrideTests.prototype.getTestName = function(spec) {
+ var name = '';
+
+ name += spec.arrays.length;
+
+ for (var arrayNdx = 0; arrayNdx < spec.arrays.length; arrayNdx++) {
+ name += '_' +
+ glsVertexArrayTests.deArray.inputTypeToString(spec.arrays[arrayNdx].inputType) +
+ spec.arrays[arrayNdx].componentCount + '_' +
+ spec.arrays[arrayNdx].stride;
+ }
+
+ return name;
+ };
+
+ /**
+ * init
+ */
+ es3fVertexArrayTests.MultiVertexArrayStrideTests.prototype.init = function() {
+ // Test different strides, with multiple arrays, input types??
+ var arrayCounts = [3];
+
+ var spec = new glsVertexArrayTests.MultiVertexArrayTest.Spec();
+
+ spec.primitive = glsVertexArrayTests.deArray.Primitive.TRIANGLES;
+ spec.drawCount = 256;
+ spec.first = 0;
+
+ for (var arrayCountNdx = 0; arrayCountNdx < arrayCounts.length; arrayCountNdx++)
+ this.addStrideCases(spec, arrayCounts[arrayCountNdx]);
+ };
+
+ /**
+ * @param {glsVertexArrayTests.MultiVertexArrayTest.Spec} spec
+ * @param {number} depth
+ */
+ es3fVertexArrayTests.MultiVertexArrayStrideTests.prototype.addStrideCases = function(spec, depth) {
+ if (depth == 0) {
+ var name = this.getTestName(spec);
+ var desc = this.getTestName(spec);
+ this.addChild(
+ new glsVertexArrayTests.MultiVertexArrayTest(
+ spec, name, desc
+ )
+ );
+ return;
+ }
+
+ var strides = [0, -1, 17, 32];
+ var inputType = glsVertexArrayTests.deArray.InputType.FLOAT;
+
+ for (var strideNdx = 0; strideNdx < strides.length; strideNdx++) {
+ var componentCount = 2;
+ var stride = strides[strideNdx] >= 0 ? strides[strideNdx] : componentCount * glsVertexArrayTests.deArray.inputTypeSize(glsVertexArrayTests.deArray.InputType.FLOAT);
+ var arraySpec = new glsVertexArrayTests.MultiVertexArrayTest.Spec.ArraySpec(
+ inputType,
+ glsVertexArrayTests.deArray.OutputType.VEC2,
+ glsVertexArrayTests.deArray.Storage.BUFFER, //USER storage not supported in WebGL 2.0
+ glsVertexArrayTests.deArray.Usage.DYNAMIC_DRAW,
+ componentCount,
+ 0,
+ stride,
+ false,
+ glsVertexArrayTests.GLValue.getMinValue(glsVertexArrayTests.deArray.InputType.FLOAT),
+ glsVertexArrayTests.GLValue.getMaxValue(glsVertexArrayTests.deArray.InputType.FLOAT)
+ );
+
+ /** @type {boolean} */ var aligned = (stride % glsVertexArrayTests.deArray.inputTypeSize(inputType)) == 0;
+ if (aligned) {
+ var _spec = /** @type {glsVertexArrayTests.MultiVertexArrayTest.Spec} */ (deUtil.clone(spec)); //To assign spec by value;
+ _spec.arrays.push(arraySpec);
+ this.addStrideCases(_spec, depth - 1);
+ }
+ }
+ };
+
+ /**
+ * @constructor
+ * @extends {tcuTestCase.DeqpTest}
+ */
+ es3fVertexArrayTests.MultiVertexArrayOutputTests = function() {
+ tcuTestCase.DeqpTest.call(this, 'multiple_attributes.input_types', 'input types');
+ this.makeExecutable();
+ };
+
+ es3fVertexArrayTests.MultiVertexArrayOutputTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
+ es3fVertexArrayTests.MultiVertexArrayOutputTests.prototype.constructor = es3fVertexArrayTests.MultiVertexArrayOutputTests;
+
+ /**
+ * @param {glsVertexArrayTests.MultiVertexArrayTest.Spec} spec
+ * @return {string}
+ */
+ es3fVertexArrayTests.MultiVertexArrayOutputTests.prototype.getTestName = function(spec) {
+ var name = '';
+
+ name += spec.arrays.length;
+
+ for (var arrayNdx = 0; arrayNdx < spec.arrays.length; arrayNdx++) {
+ name += '_' +
+ glsVertexArrayTests.deArray.inputTypeToString(spec.arrays[arrayNdx].inputType) +
+ spec.arrays[arrayNdx].componentCount + '_' +
+ glsVertexArrayTests.deArray.outputTypeToString(spec.arrays[arrayNdx].outputType);
+ }
+
+ return name;
+ };
+
+ /**
+ * init
+ */
+ es3fVertexArrayTests.MultiVertexArrayOutputTests.prototype.init = function() {
+ // Test different input types, with multiple arrays
+ var arrayCounts = [3];
+
+ var spec = new glsVertexArrayTests.MultiVertexArrayTest.Spec();
+
+ spec.primitive = glsVertexArrayTests.deArray.Primitive.TRIANGLES;
+ spec.drawCount = 256;
+ spec.first = 0;
+
+ for (var arrayCountNdx = 0; arrayCountNdx < arrayCounts.length; arrayCountNdx++)
+ this.addInputTypeCases(spec, arrayCounts[arrayCountNdx]);
+ };
+
+ /**
+ * @param {glsVertexArrayTests.MultiVertexArrayTest.Spec} spec
+ * @param {number} depth
+ */
+ es3fVertexArrayTests.MultiVertexArrayOutputTests.prototype.addInputTypeCases = function(spec, depth) {
+ if (depth == 0) {
+ var name = this.getTestName(spec);
+ var desc = this.getTestName(spec);
+ this.addChild(
+ new glsVertexArrayTests.MultiVertexArrayTest(
+ spec, name, desc
+ )
+ );
+ return;
+ }
+
+ var inputTypes = [
+ glsVertexArrayTests.deArray.InputType.BYTE,
+ glsVertexArrayTests.deArray.InputType.SHORT,
+ glsVertexArrayTests.deArray.InputType.UNSIGNED_BYTE,
+ glsVertexArrayTests.deArray.InputType.UNSIGNED_SHORT
+ ];
+
+ for (var inputTypeNdx = 0; inputTypeNdx < inputTypes.length; inputTypeNdx++) {
+ var arraySpec = new glsVertexArrayTests.MultiVertexArrayTest.Spec.ArraySpec(
+ inputTypes[inputTypeNdx],
+ glsVertexArrayTests.deArray.OutputType.VEC2,
+ glsVertexArrayTests.deArray.Storage.BUFFER, //USER storage not supported in WebGL 2.0
+ glsVertexArrayTests.deArray.Usage.DYNAMIC_DRAW,
+ 2,
+ 0,
+ 0,
+ false,
+ glsVertexArrayTests.GLValue.getMinValue(inputTypes[inputTypeNdx]),
+ glsVertexArrayTests.GLValue.getMaxValue(inputTypes[inputTypeNdx])
+ );
+
+ var _spec = /** @type {glsVertexArrayTests.MultiVertexArrayTest.Spec} */ (deUtil.clone(spec));
+ _spec.arrays.push(arraySpec);
+ this.addInputTypeCases(_spec, depth - 1);
+ }
+ };
+
+ /**
+ * es3fVertexArrayTests.VertexArrayTestGroup
+ * @constructor
+ * @extends {tcuTestCase.DeqpTest}
+ */
+ es3fVertexArrayTests.VertexArrayTestGroup = function() {
+ tcuTestCase.DeqpTest.call(this, 'vertex_arrays', 'Vertex array and array tests');
+ this.makeExecutable();
+ };
+
+ es3fVertexArrayTests.VertexArrayTestGroup.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
+ es3fVertexArrayTests.VertexArrayTestGroup.prototype.constructor = es3fVertexArrayTests.VertexArrayTestGroup;
+
+ /**
+ * init
+ */
+ es3fVertexArrayTests.VertexArrayTestGroup.prototype.init = function() {
+ this.addChild(new es3fVertexArrayTests.SingleVertexArrayStrideTests());
+ this.addChild(new es3fVertexArrayTests.SingleVertexArrayNormalizeTests());
+
+ // Test output types with different input types, component counts and storage, Usage?, Precision?, float?
+ var inputTypes = [
+ glsVertexArrayTests.deArray.InputType.FLOAT,
+ glsVertexArrayTests.deArray.InputType.SHORT,
+ glsVertexArrayTests.deArray.InputType.BYTE,
+ glsVertexArrayTests.deArray.InputType.UNSIGNED_SHORT,
+ glsVertexArrayTests.deArray.InputType.UNSIGNED_BYTE,
+ glsVertexArrayTests.deArray.InputType.UNSIGNED_INT,
+ glsVertexArrayTests.deArray.InputType.INT,
+ glsVertexArrayTests.deArray.InputType.HALF,
+ glsVertexArrayTests.deArray.InputType.UNSIGNED_INT_2_10_10_10,
+ glsVertexArrayTests.deArray.InputType.INT_2_10_10_10
+ ];
+ for (var inputTypeNdx = 0; inputTypeNdx < inputTypes.length; inputTypeNdx++) {
+ this.addChild(new es3fVertexArrayTests.SingleVertexArrayOutputTypeGroup(inputTypes[inputTypeNdx]));
+ }
+
+ /** @type {Array<glsVertexArrayTests.deArray.Usage>} */ var usages = [
+ glsVertexArrayTests.deArray.Usage.STATIC_DRAW,
+ glsVertexArrayTests.deArray.Usage.STREAM_DRAW,
+ glsVertexArrayTests.deArray.Usage.DYNAMIC_DRAW,
+ glsVertexArrayTests.deArray.Usage.STATIC_COPY,
+ glsVertexArrayTests.deArray.Usage.STREAM_COPY,
+ glsVertexArrayTests.deArray.Usage.DYNAMIC_COPY,
+ glsVertexArrayTests.deArray.Usage.STATIC_READ,
+ glsVertexArrayTests.deArray.Usage.STREAM_READ,
+ glsVertexArrayTests.deArray.Usage.DYNAMIC_READ
+ ];
+ for (var usageNdx = 0; usageNdx < usages.length; usageNdx++) {
+ this.addChild(new es3fVertexArrayTests.SingleVertexArrayUsageGroup(usages[usageNdx]));
+ }
+
+ this.addChild(new es3fVertexArrayTests.SingleVertexArrayOffsetTests());
+ this.addChild(new es3fVertexArrayTests.SingleVertexArrayFirstTests());
+
+ this.addChild(new es3fVertexArrayTests.MultiVertexArrayCountTests());
+ this.addChild(new es3fVertexArrayTests.MultiVertexArrayStorageTests());
+ this.addChild(new es3fVertexArrayTests.MultiVertexArrayStrideTests());
+ this.addChild(new es3fVertexArrayTests.MultiVertexArrayOutputTests());
+ };
+
+ /**
+ * Create and execute the test cases
+ * @param {WebGL2RenderingContext} context
+ */
+ es3fVertexArrayTests.run = function(context, range) {
+ gl = context;
+ //Set up root Test
+ var state = tcuTestCase.runner;
+
+ var test = new es3fVertexArrayTests.VertexArrayTestGroup();
+ var testName = test.fullName();
+ var testDescription = test.getDescription();
+ state.testCases = test;
+ state.testName = testName;
+
+ //Set up name and description of this test series.
+ setCurrentTestName(testName);
+ description(testDescription);
+
+ try {
+ if (range)
+ state.setRange(range);
+ //Run test cases
+ tcuTestCase.runTestCases();
+ } catch (err) {
+ testFailedOptions('Failed to es3fVertexArrayTests.run tests', false);
+ tcuTestCase.runner.terminate();
+ }
+ };
+
+});
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-15 11:40:21 +0000