| /*------------------------------------------------------------------------- |
| * 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.es3fDrawTests'); |
| goog.require('framework.common.tcuLogImage'); |
| goog.require('framework.common.tcuRGBA'); |
| 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('framework.opengl.simplereference.sglrGLContext'); |
| goog.require('framework.opengl.simplereference.sglrShaderProgram'); |
| goog.require('framework.referencerenderer.rrFragmentOperations'); |
| goog.require('framework.referencerenderer.rrGenericVector'); |
| goog.require('framework.referencerenderer.rrShadingContext'); |
| goog.require('framework.referencerenderer.rrVertexAttrib'); |
| goog.require('framework.referencerenderer.rrVertexPacket'); |
| goog.require('modules.shared.glsDrawTests'); |
| |
| goog.scope(function() { |
| |
| var es3fDrawTests = functional.gles3.es3fDrawTests; |
| 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 tcuLogImage = framework.common.tcuLogImage; |
| var tcuRGBA = framework.common.tcuRGBA; |
| 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 glsDrawTests = modules.shared.glsDrawTests; |
| var sglrShaderProgram = framework.opengl.simplereference.sglrShaderProgram; |
| var sglrGLContext = framework.opengl.simplereference.sglrGLContext; |
| var rrFragmentOperations = framework.referencerenderer.rrFragmentOperations; |
| var rrGenericVector = framework.referencerenderer.rrGenericVector; |
| var rrShadingContext = framework.referencerenderer.rrShadingContext; |
| var rrVertexAttrib = framework.referencerenderer.rrVertexAttrib; |
| var rrVertexPacket = framework.referencerenderer.rrVertexPacket; |
| |
| /** @type {WebGL2RenderingContext}*/ var gl; |
| |
| /** |
| * @enum |
| */ |
| es3fDrawTests.TestIterationType = { |
| DRAW_COUNT: 0, // !< test with 2, 6, and 26 primitives |
| INSTANCE_COUNT: 1, // !< test with 2, 4, and 12 instances |
| INDEX_RANGE: 2 |
| }; |
| |
| /** |
| * @param {glsDrawTests.DrawTest} test |
| * @param {glsDrawTests.DrawTestSpec} baseSpec |
| * @param {?es3fDrawTests.TestIterationType} type |
| */ |
| es3fDrawTests.addTestIterations = function(test, baseSpec, type) { |
| var spec = /** @type {glsDrawTests.DrawTestSpec} */ (deUtil.clone(baseSpec)); |
| |
| if (type == es3fDrawTests.TestIterationType.DRAW_COUNT) { |
| spec.primitiveCount = 1; |
| test.addIteration(spec, 'draw count = ' + spec.primitiveCount); |
| |
| spec.primitiveCount = 5; |
| test.addIteration(spec, 'draw count = ' + spec.primitiveCount); |
| |
| spec.primitiveCount = 25; |
| test.addIteration(spec, 'draw count = ' + spec.primitiveCount); |
| } else if (type == es3fDrawTests.TestIterationType.INSTANCE_COUNT) { |
| spec.instanceCount = 1; |
| test.addIteration(spec, 'instance count = ' + spec.instanceCount); |
| |
| spec.instanceCount = 4; |
| test.addIteration(spec, 'instance count = ' + spec.instanceCount); |
| |
| spec.instanceCount = 11; |
| test.addIteration(spec, 'instance count = ' + spec.instanceCount); |
| } else if (type == es3fDrawTests.TestIterationType.INDEX_RANGE) { |
| spec.indexMin = 0; |
| spec.indexMax = 23; |
| test.addIteration(spec, 'index range = [' + spec.indexMin + ', ' + spec.indexMax + ']'); |
| |
| spec.indexMin = 23; |
| spec.indexMax = 40; |
| test.addIteration(spec, 'index range = [' + spec.indexMin + ', ' + spec.indexMax + ']'); |
| |
| // Only makes sense with points |
| if (spec.primitive == glsDrawTests.DrawTestSpec.Primitive.POINTS) { |
| spec.indexMin = 5; |
| spec.indexMax = 5; |
| test.addIteration(spec, 'index range = [' + spec.indexMin + ', ' + spec.indexMax + ']'); |
| } |
| } else |
| throw new Error('Invalid test iteration type'); |
| }; |
| |
| /** |
| * @param {glsDrawTests.DrawTestSpec} spec |
| * @param {?glsDrawTests.DrawTestSpec.DrawMethod} method |
| */ |
| es3fDrawTests.genBasicSpec = function(spec, method) { |
| //spec.apiType = glu::ApiType::es(3,0); |
| spec.primitive = glsDrawTests.DrawTestSpec.Primitive.TRIANGLES; |
| spec.primitiveCount = 6; |
| spec.drawMethod = method; |
| spec.indexType = null; |
| spec.indexPointerOffset = 0; |
| spec.indexStorage = null; |
| spec.first = 0; |
| spec.indexMin = 0; |
| spec.indexMax = 0; |
| spec.instanceCount = 1; |
| |
| spec.attribs.push(new glsDrawTests.DrawTestSpec.AttributeSpec()); |
| |
| spec.attribs[0].inputType = glsDrawTests.DrawTestSpec.InputType.FLOAT; |
| spec.attribs[0].outputType = glsDrawTests.DrawTestSpec.OutputType.VEC2; |
| spec.attribs[0].storage = glsDrawTests.DrawTestSpec.Storage.BUFFER; |
| spec.attribs[0].usage = glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW; |
| spec.attribs[0].componentCount = 4; |
| spec.attribs[0].offset = 0; |
| spec.attribs[0].stride = 0; |
| spec.attribs[0].normalize = false; |
| spec.attribs[0].instanceDivisor = 0; |
| spec.attribs[0].useDefaultAttribute = false; |
| |
| spec.attribs.push(new glsDrawTests.DrawTestSpec.AttributeSpec()); |
| |
| spec.attribs[1].inputType = glsDrawTests.DrawTestSpec.InputType.FLOAT; |
| spec.attribs[1].outputType = glsDrawTests.DrawTestSpec.OutputType.VEC2; |
| spec.attribs[1].storage = glsDrawTests.DrawTestSpec.Storage.BUFFER; |
| spec.attribs[1].usage = glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW; |
| spec.attribs[1].componentCount = 2; |
| spec.attribs[1].offset = 0; |
| spec.attribs[1].stride = 0; |
| spec.attribs[1].normalize = false; |
| spec.attribs[1].instanceDivisor = 0; |
| spec.attribs[1].useDefaultAttribute = false; |
| }; |
| |
| /** |
| * @constructor |
| * @extends {tcuTestCase.DeqpTest} |
| * @param {string} name |
| * @param {string} descr |
| * @param {?glsDrawTests.DrawTestSpec.DrawMethod} drawMethod |
| * @param {?glsDrawTests.DrawTestSpec.Primitive} primitive |
| * @param {?glsDrawTests.DrawTestSpec.IndexType} indexType |
| * @param {?glsDrawTests.DrawTestSpec.Storage} indexStorage |
| */ |
| es3fDrawTests.AttributeGroup = function(name, descr, drawMethod, primitive, indexType, indexStorage) { |
| tcuTestCase.DeqpTest.call(this, name, descr); |
| this.m_method = drawMethod; |
| this.m_primitive = primitive; |
| this.m_indexType = indexType; |
| this.m_indexStorage = indexStorage; |
| this.makeExecutable(); |
| }; |
| |
| es3fDrawTests.AttributeGroup.prototype = Object.create(tcuTestCase.DeqpTest.prototype); |
| es3fDrawTests.AttributeGroup.prototype.constructor = es3fDrawTests.AttributeGroup; |
| |
| es3fDrawTests.AttributeGroup.prototype.init = function() { |
| // select test type |
| /** @type {boolean} */ var instanced = this.m_method == glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS_INSTANCED || |
| this.m_method == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_INSTANCED; |
| /** @type {boolean} */ var ranged = this.m_method == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_RANGED; |
| /** @type {es3fDrawTests.TestIterationType} */ var testType = instanced ? es3fDrawTests.TestIterationType.INSTANCE_COUNT : |
| (ranged ? es3fDrawTests.TestIterationType.INDEX_RANGE : es3fDrawTests.TestIterationType.DRAW_COUNT); |
| |
| // Single attribute |
| /** @type {glsDrawTests.DrawTest} */ var test = new glsDrawTests.DrawTest(null, 'single_attribute', 'Single attribute array.'); |
| /** @type {glsDrawTests.DrawTestSpec} */ var spec = new glsDrawTests.DrawTestSpec(); |
| |
| //spec.apiType = glu::ApiType::es(3,0); |
| spec.primitive = this.m_primitive; |
| spec.primitiveCount = 5; |
| spec.drawMethod = this.m_method; |
| spec.indexType = this.m_indexType; |
| spec.indexPointerOffset = 0; |
| spec.indexStorage = this.m_indexStorage; |
| spec.first = 0; |
| spec.indexMin = 0; |
| spec.indexMax = 0; |
| spec.instanceCount = 1; |
| |
| spec.attribs.length = 0; |
| |
| spec.attribs.push(new glsDrawTests.DrawTestSpec.AttributeSpec()); |
| spec.attribs[0].inputType = glsDrawTests.DrawTestSpec.InputType.FLOAT; |
| spec.attribs[0].outputType = glsDrawTests.DrawTestSpec.OutputType.VEC2; |
| spec.attribs[0].storage = glsDrawTests.DrawTestSpec.Storage.BUFFER; |
| spec.attribs[0].usage = glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW; |
| spec.attribs[0].componentCount = 2; |
| spec.attribs[0].offset = 0; |
| spec.attribs[0].stride = 0; |
| spec.attribs[0].normalize = false; |
| spec.attribs[0].instanceDivisor = 0; |
| spec.attribs[0].useDefaultAttribute = false; |
| |
| es3fDrawTests.addTestIterations(test, spec, testType); |
| |
| this.addChild(test); |
| |
| // Multiple attribute |
| |
| test = new glsDrawTests.DrawTest(null, 'multiple_attributes', 'Multiple attribute arrays.'); |
| spec.primitive = this.m_primitive; |
| spec.primitiveCount = 5; |
| spec.drawMethod = this.m_method; |
| spec.indexType = this.m_indexType; |
| spec.indexPointerOffset = 0; |
| spec.indexStorage = this.m_indexStorage; |
| spec.first = 0; |
| spec.indexMin = 0; |
| spec.indexMax = 0; |
| spec.instanceCount = 1; |
| |
| spec.attribs.length = 0; |
| |
| spec.attribs.push(new glsDrawTests.DrawTestSpec.AttributeSpec()); |
| spec.attribs[0].inputType = glsDrawTests.DrawTestSpec.InputType.FLOAT; |
| spec.attribs[0].outputType = glsDrawTests.DrawTestSpec.OutputType.VEC2; |
| spec.attribs[0].storage = glsDrawTests.DrawTestSpec.Storage.BUFFER; |
| spec.attribs[0].usage = glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW; |
| spec.attribs[0].componentCount = 4; |
| spec.attribs[0].offset = 0; |
| spec.attribs[0].stride = 0; |
| spec.attribs[0].normalize = false; |
| spec.attribs[0].instanceDivisor = 0; |
| spec.attribs[0].useDefaultAttribute = false; |
| |
| spec.attribs.push(new glsDrawTests.DrawTestSpec.AttributeSpec()); |
| spec.attribs[1].inputType = glsDrawTests.DrawTestSpec.InputType.FLOAT; |
| spec.attribs[1].outputType = glsDrawTests.DrawTestSpec.OutputType.VEC2; |
| spec.attribs[1].storage = glsDrawTests.DrawTestSpec.Storage.BUFFER; |
| spec.attribs[1].usage = glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW; |
| spec.attribs[1].componentCount = 2; |
| spec.attribs[1].offset = 0; |
| spec.attribs[1].stride = 0; |
| spec.attribs[1].normalize = false; |
| spec.attribs[1].instanceDivisor = 0; |
| spec.attribs[1].useDefaultAttribute = false; |
| |
| es3fDrawTests.addTestIterations(test, spec, testType); |
| |
| this.addChild(test); |
| |
| // Multiple attribute, second one divided |
| |
| test = new glsDrawTests.DrawTest(null, 'instanced_attributes', 'Instanced attribute array.'); |
| |
| //spec.apiType = glu::ApiType::es(3,0); |
| spec.primitive = this.m_primitive; |
| spec.primitiveCount = 5; |
| spec.drawMethod = this.m_method; |
| spec.indexType = this.m_indexType; |
| spec.indexPointerOffset = 0; |
| spec.indexStorage = this.m_indexStorage; |
| spec.first = 0; |
| spec.indexMin = 0; |
| spec.indexMax = 0; |
| spec.instanceCount = 1; |
| |
| spec.attribs.length = 0; |
| |
| spec.attribs.push(new glsDrawTests.DrawTestSpec.AttributeSpec()); |
| spec.attribs[0].inputType = glsDrawTests.DrawTestSpec.InputType.FLOAT; |
| spec.attribs[0].outputType = glsDrawTests.DrawTestSpec.OutputType.VEC2; |
| spec.attribs[0].storage = glsDrawTests.DrawTestSpec.Storage.BUFFER; |
| spec.attribs[0].usage = glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW; |
| spec.attribs[0].componentCount = 4; |
| spec.attribs[0].offset = 0; |
| spec.attribs[0].stride = 0; |
| spec.attribs[0].normalize = false; |
| spec.attribs[0].instanceDivisor = 0; |
| spec.attribs[0].useDefaultAttribute = false; |
| |
| // Add another position component so the instances wont be drawn on each other |
| spec.attribs.push(new glsDrawTests.DrawTestSpec.AttributeSpec()); |
| spec.attribs[1].inputType = glsDrawTests.DrawTestSpec.InputType.FLOAT; |
| spec.attribs[1].outputType = glsDrawTests.DrawTestSpec.OutputType.VEC2; |
| spec.attribs[1].storage = glsDrawTests.DrawTestSpec.Storage.BUFFER; |
| spec.attribs[1].usage = glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW; |
| spec.attribs[1].componentCount = 2; |
| spec.attribs[1].offset = 0; |
| spec.attribs[1].stride = 0; |
| spec.attribs[1].normalize = false; |
| spec.attribs[1].instanceDivisor = 1; |
| spec.attribs[1].useDefaultAttribute = false; |
| spec.attribs[1].additionalPositionAttribute = true; |
| |
| // Instanced color |
| spec.attribs.push(new glsDrawTests.DrawTestSpec.AttributeSpec()); |
| spec.attribs[2].inputType = glsDrawTests.DrawTestSpec.InputType.FLOAT; |
| spec.attribs[2].outputType = glsDrawTests.DrawTestSpec.OutputType.VEC2; |
| spec.attribs[2].storage = glsDrawTests.DrawTestSpec.Storage.BUFFER; |
| spec.attribs[2].usage = glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW; |
| spec.attribs[2].componentCount = 3; |
| spec.attribs[2].offset = 0; |
| spec.attribs[2].stride = 0; |
| spec.attribs[2].normalize = false; |
| spec.attribs[2].instanceDivisor = 1; |
| spec.attribs[2].useDefaultAttribute = false; |
| |
| es3fDrawTests.addTestIterations(test, spec, testType); |
| |
| this.addChild(test); |
| |
| // Multiple attribute, second one default |
| test = new glsDrawTests.DrawTest(null, 'default_attribute', 'Attribute specified with glVertexAttrib*.'); |
| |
| //spec.apiType = glu::ApiType::es(3,0); |
| spec.primitive = this.m_primitive; |
| spec.primitiveCount = 5; |
| spec.drawMethod = this.m_method; |
| spec.indexType = this.m_indexType; |
| spec.indexPointerOffset = 0; |
| spec.indexStorage = this.m_indexStorage; |
| spec.first = 0; |
| spec.indexMin = 0; |
| spec.indexMax = 17; // \note addTestIterations is not called for the spec, so we must ensure [indexMin, indexMax] is a good range |
| spec.instanceCount = 1; |
| |
| spec.attribs.length = 0; |
| |
| spec.attribs.push(new glsDrawTests.DrawTestSpec.AttributeSpec()); |
| spec.attribs[0].inputType = glsDrawTests.DrawTestSpec.InputType.FLOAT; |
| spec.attribs[0].outputType = glsDrawTests.DrawTestSpec.OutputType.VEC2; |
| spec.attribs[0].storage = glsDrawTests.DrawTestSpec.Storage.BUFFER; |
| spec.attribs[0].usage = glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW; |
| spec.attribs[0].componentCount = 2; |
| spec.attribs[0].offset = 0; |
| spec.attribs[0].stride = 0; |
| spec.attribs[0].normalize = false; |
| spec.attribs[0].instanceDivisor = 0; |
| spec.attribs[0].useDefaultAttribute = false; |
| |
| /** @type {Array<{input:?glsDrawTests.DrawTestSpec.InputType, output:?glsDrawTests.DrawTestSpec.OutputType, componentCount:number}>} */ var iopairs = [ |
| {input: glsDrawTests.DrawTestSpec.InputType.FLOAT, output: glsDrawTests.DrawTestSpec.OutputType.VEC2, componentCount: 4}, |
| {input: glsDrawTests.DrawTestSpec.InputType.FLOAT, output: glsDrawTests.DrawTestSpec.OutputType.VEC4, componentCount: 2}, |
| {input: glsDrawTests.DrawTestSpec.InputType.INT, output: glsDrawTests.DrawTestSpec.OutputType.IVEC3, componentCount: 4}, |
| {input: glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT, output: glsDrawTests.DrawTestSpec.OutputType.UVEC2, componentCount: 4} |
| ]; |
| |
| spec.attribs.push(new glsDrawTests.DrawTestSpec.AttributeSpec()); |
| for (var ioNdx = 0; ioNdx < iopairs.length; ++ioNdx) { |
| /** @type {string} */ var desc = glsDrawTests.DrawTestSpec.inputTypeToString(iopairs[ioNdx].input) + iopairs[ioNdx].componentCount + ' to ' + glsDrawTests.DrawTestSpec.outputTypeToString(iopairs[ioNdx].output); |
| |
| spec.attribs[1].inputType = iopairs[ioNdx].input; |
| spec.attribs[1].outputType = iopairs[ioNdx].output; |
| spec.attribs[1].storage = glsDrawTests.DrawTestSpec.Storage.BUFFER; |
| spec.attribs[1].usage = glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW; |
| spec.attribs[1].componentCount = iopairs[ioNdx].componentCount; |
| spec.attribs[1].offset = 0; |
| spec.attribs[1].stride = 0; |
| spec.attribs[1].normalize = false; |
| spec.attribs[1].instanceDivisor = 0; |
| spec.attribs[1].useDefaultAttribute = true; |
| |
| test.addIteration(spec, desc); |
| } |
| |
| this.addChild(test); |
| }; |
| |
| /** |
| * @constructor |
| * @extends {tcuTestCase.DeqpTest} |
| * @param {string} name |
| * @param {string} descr |
| * @param {?glsDrawTests.DrawTestSpec.DrawMethod} drawMethod |
| */ |
| es3fDrawTests.IndexGroup = function(name, descr, drawMethod) { |
| tcuTestCase.DeqpTest.call(this, name, descr); |
| /** @type {?glsDrawTests.DrawTestSpec.DrawMethod} */ this.m_method = drawMethod; |
| this.makeExecutable(); |
| }; |
| |
| es3fDrawTests.IndexGroup.prototype = Object.create(tcuTestCase.DeqpTest.prototype); |
| es3fDrawTests.IndexGroup.prototype.constructor = es3fDrawTests.IndexGroup; |
| |
| es3fDrawTests.IndexGroup.prototype.init = function() { |
| /** @type {Array<{storage: ?glsDrawTests.DrawTestSpec.Storage, type: ?glsDrawTests.DrawTestSpec.IndexType, aligned: boolean, offsets: Array<number>}>} */ var tests = [ |
| {storage: glsDrawTests.DrawTestSpec.Storage.BUFFER, type: glsDrawTests.DrawTestSpec.IndexType.BYTE, aligned: true, offsets: [0, 1, -1]}, |
| {storage: glsDrawTests.DrawTestSpec.Storage.BUFFER, type: glsDrawTests.DrawTestSpec.IndexType.SHORT, aligned: true, offsets: [0, 2, -1]}, |
| {storage: glsDrawTests.DrawTestSpec.Storage.BUFFER, type: glsDrawTests.DrawTestSpec.IndexType.INT, aligned: true, offsets: [0, 4, -1]}, |
| |
| {storage: glsDrawTests.DrawTestSpec.Storage.BUFFER, type: glsDrawTests.DrawTestSpec.IndexType.SHORT, aligned: false, offsets: [1, 3, -1]}, |
| {storage: glsDrawTests.DrawTestSpec.Storage.BUFFER, type: glsDrawTests.DrawTestSpec.IndexType.INT, aligned: false, offsets: [2, 3, -1]} |
| ]; |
| |
| /** @type {glsDrawTests.DrawTestSpec} */ var spec = new glsDrawTests.DrawTestSpec(); |
| es3fDrawTests.genBasicSpec(spec, this.m_method); |
| |
| /** @type {tcuTestCase.DeqpTest} */ var bufferGroup = new tcuTestCase.DeqpTest('buffer', 'buffer'); |
| /** @type {tcuTestCase.DeqpTest} */ var unalignedBufferGroup = new tcuTestCase.DeqpTest('unaligned_buffer', 'unaligned buffer'); |
| |
| this.addChild(bufferGroup); |
| this.addChild(unalignedBufferGroup); |
| |
| for (var testNdx = 0; testNdx < tests.length; ++testNdx) { |
| /** @type {{storage: ?glsDrawTests.DrawTestSpec.Storage, type: ?glsDrawTests.DrawTestSpec.IndexType, aligned: boolean, offsets: Array<number>}} */ |
| var indexTest = tests[testNdx]; |
| /** @type {tcuTestCase.DeqpTest} */ var group = indexTest.aligned ? bufferGroup : unalignedBufferGroup; |
| |
| /** @type {string} */ var name = 'index_' + glsDrawTests.DrawTestSpec.indexTypeToString(indexTest.type); |
| /** @type {string} */ var desc = 'index ' + glsDrawTests.DrawTestSpec.indexTypeToString(indexTest.type) + ' in ' + glsDrawTests.DrawTestSpec.storageToString(indexTest.storage); |
| /** @type {glsDrawTests.DrawTest} */ var test = new glsDrawTests.DrawTest(null, name, desc); |
| |
| spec.indexType = indexTest.type; |
| spec.indexStorage = indexTest.storage; |
| |
| for (var iterationNdx = 0; iterationNdx < indexTest.offsets.length && indexTest.offsets[iterationNdx] != -1; ++iterationNdx) { |
| /** @type {string} */ var iterationDesc = 'offset ' + indexTest.offsets[iterationNdx]; |
| spec.indexPointerOffset = indexTest.offsets[iterationNdx]; |
| test.addIteration(spec, iterationDesc); |
| } |
| |
| if (spec.isCompatibilityTest() != glsDrawTests.DrawTestSpec.CompatibilityTestType.UNALIGNED_OFFSET && |
| spec.isCompatibilityTest() != glsDrawTests.DrawTestSpec.CompatibilityTestType.UNALIGNED_STRIDE) |
| group.addChild(test); |
| } |
| }; |
| |
| /** |
| * @constructor |
| * @extends {tcuTestCase.DeqpTest} |
| * @param {string} name |
| * @param {string} descr |
| * @param {?glsDrawTests.DrawTestSpec.DrawMethod} drawMethod |
| */ |
| es3fDrawTests.FirstGroup = function(name, descr, drawMethod) { |
| tcuTestCase.DeqpTest.call(this, name, descr); |
| /** @type {?glsDrawTests.DrawTestSpec.DrawMethod} */ this.m_method = drawMethod; |
| this.makeExecutable(); |
| }; |
| |
| es3fDrawTests.FirstGroup.prototype = Object.create(tcuTestCase.DeqpTest.prototype); |
| es3fDrawTests.FirstGroup.prototype.constructor = es3fDrawTests.FirstGroup; |
| |
| /** |
| * init |
| */ |
| es3fDrawTests.FirstGroup.prototype.init = function() { |
| var firsts = |
| [ |
| 1, 3, 17 |
| ]; |
| |
| /** @type {glsDrawTests.DrawTestSpec} */ var spec = new glsDrawTests.DrawTestSpec(); |
| es3fDrawTests.genBasicSpec(spec, this.m_method); |
| |
| for (var firstNdx = 0; firstNdx < firsts.length; ++firstNdx) { |
| var name = 'first_' + firsts[firstNdx]; |
| var desc = 'first ' + firsts[firstNdx]; |
| /** @type {glsDrawTests.DrawTest} */ var test = new glsDrawTests.DrawTest(null, name, desc); |
| |
| spec.first = firsts[firstNdx]; |
| |
| es3fDrawTests.addTestIterations(test, spec, es3fDrawTests.TestIterationType.DRAW_COUNT); |
| |
| this.addChild(test); |
| } |
| }; |
| |
| /** |
| * @constructor |
| * @extends {tcuTestCase.DeqpTest} |
| * @param {string} name |
| * @param {string} descr |
| * @param {?glsDrawTests.DrawTestSpec.DrawMethod} drawMethod |
| */ |
| es3fDrawTests.MethodGroup = function(name, descr, drawMethod) { |
| tcuTestCase.DeqpTest.call(this, name, descr); |
| /** @type {?glsDrawTests.DrawTestSpec.DrawMethod} */ this.m_method = drawMethod; |
| this.makeExecutable(); |
| }; |
| |
| es3fDrawTests.MethodGroup.prototype = Object.create(tcuTestCase.DeqpTest.prototype); |
| es3fDrawTests.MethodGroup.prototype.constructor = es3fDrawTests.MethodGroup; |
| |
| /** |
| * init |
| */ |
| es3fDrawTests.MethodGroup.prototype.init = function() { |
| var indexed = (this.m_method == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS) || (this.m_method == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_INSTANCED) || (this.m_method == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_RANGED); |
| var hasFirst = (this.m_method == glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS) || (this.m_method == glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS_INSTANCED); |
| |
| var primitive = |
| [ |
| glsDrawTests.DrawTestSpec.Primitive.POINTS, |
| glsDrawTests.DrawTestSpec.Primitive.TRIANGLES, |
| glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_FAN, |
| glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_STRIP, |
| glsDrawTests.DrawTestSpec.Primitive.LINES, |
| glsDrawTests.DrawTestSpec.Primitive.LINE_STRIP, |
| glsDrawTests.DrawTestSpec.Primitive.LINE_LOOP |
| ]; |
| |
| if (hasFirst) { |
| // First-tests |
| this.addChild(new es3fDrawTests.FirstGroup('first', 'First tests', this.m_method)); |
| } |
| |
| if (indexed) { |
| // Index-tests |
| if (this.m_method != glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_RANGED) |
| this.addChild(new es3fDrawTests.IndexGroup('indices', 'Index tests', this.m_method)); |
| } |
| |
| for (var ndx = 0; ndx < primitive.length; ++ndx) { |
| var name = glsDrawTests.DrawTestSpec.primitiveToString(primitive[ndx]); |
| var desc = glsDrawTests.DrawTestSpec.primitiveToString(primitive[ndx]); |
| |
| this.addChild(new es3fDrawTests.AttributeGroup(name, desc, this.m_method, primitive[ndx], glsDrawTests.DrawTestSpec.IndexType.SHORT, glsDrawTests.DrawTestSpec.Storage.BUFFER)); |
| } |
| }; |
| |
| /** |
| * es3fDrawTests.GridProgram |
| * @constructor |
| * @extends {sglrShaderProgram.ShaderProgram} |
| */ |
| es3fDrawTests.GridProgram = function() { |
| /** @type {sglrShaderProgram.ShaderProgramDeclaration} */ var decl = new sglrShaderProgram.ShaderProgramDeclaration(); |
| |
| decl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('a_position', rrGenericVector.GenericVecType.FLOAT)); |
| decl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('a_offset', rrGenericVector.GenericVecType.FLOAT)); |
| decl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('a_color', rrGenericVector.GenericVecType.FLOAT)); |
| |
| decl.pushVertexToFragmentVarying(new sglrShaderProgram.VertexToFragmentVarying(rrGenericVector.GenericVecType.FLOAT)); |
| decl.pushFragmentOutput(new sglrShaderProgram.FragmentOutput(rrGenericVector.GenericVecType.FLOAT)); |
| |
| decl.pushVertexSource(new sglrShaderProgram.VertexSource( |
| '#version 300 es\n' + |
| 'in highp vec4 a_position;\n' + |
| 'in highp vec4 a_offset;\n' + |
| 'in highp vec4 a_color;\n' + |
| 'out mediump vec4 v_color;\n' + |
| 'void main(void)\n' + |
| '{\n' + |
| ' gl_Position = a_position + a_offset;\n' + |
| ' v_color = a_color;\n' + |
| '}\n' |
| )); |
| decl.pushFragmentSource(new sglrShaderProgram.FragmentSource( |
| '#version 300 es\n' + |
| 'layout(location = 0) out mediump vec4 dEQP_FragColor;\n' + |
| 'in mediump vec4 v_color;\n' + |
| 'void main(void)\n' + |
| '{\n' + |
| ' dEQP_FragColor = v_color;\n' + |
| '}\n' |
| )); |
| |
| sglrShaderProgram.ShaderProgram.call(this, decl); |
| }; |
| |
| es3fDrawTests.GridProgram.prototype = Object.create(sglrShaderProgram.ShaderProgram.prototype); |
| es3fDrawTests.GridProgram.prototype.constructor = es3fDrawTests.GridProgram; |
| |
| /** |
| * @param {Array<rrVertexAttrib.VertexAttrib>} inputs |
| * @param {Array<rrVertexPacket.VertexPacket>} packets |
| * @param {number} numPackets |
| */ |
| es3fDrawTests.GridProgram.prototype.shadeVertices = function(inputs, packets, numPackets) { |
| for (var ndx = 0; ndx < numPackets; ++ndx) { |
| packets[ndx].position = deMath.add( |
| rrVertexAttrib.readVertexAttrib(inputs[0], packets[ndx].instanceNdx, packets[ndx].vertexNdx, rrGenericVector.GenericVecType.FLOAT), |
| rrVertexAttrib.readVertexAttrib(inputs[1], packets[ndx].instanceNdx, packets[ndx].vertexNdx, rrGenericVector.GenericVecType.FLOAT) |
| ); |
| packets[ndx].outputs[0] = rrVertexAttrib.readVertexAttrib(inputs[2], packets[ndx].instanceNdx, packets[ndx].vertexNdx, rrGenericVector.GenericVecType.FLOAT); |
| } |
| }; |
| |
| /** |
| * @param {Array<rrFragmentOperations.Fragment>} packets |
| * @param {rrShadingContext.FragmentShadingContext} context |
| */ |
| es3fDrawTests.GridProgram.prototype.shadeFragments = function(packets, context) { |
| for (var packetNdx = 0; packetNdx < packets.length; ++packetNdx) |
| for (var fragNdx = 0; fragNdx < 4; ++fragNdx) |
| packets[packetNdx].value = rrShadingContext.readTriangleVarying(packets[packetNdx], context, fragNdx); |
| }; |
| |
| /** |
| * InstancedGridRenderTest |
| * @constructor |
| * @extends {tcuTestCase.DeqpTest} |
| * @param {string} name |
| * @param {string} desc |
| * @param {number} gridSide |
| * @param {boolean} useIndices |
| */ |
| es3fDrawTests.InstancedGridRenderTest = function(name, desc, gridSide, useIndices) { |
| tcuTestCase.DeqpTest.call(this, name, desc); |
| this.m_gridSide = gridSide; |
| this.m_useIndices = useIndices; |
| }; |
| |
| es3fDrawTests.InstancedGridRenderTest.prototype = Object.create(tcuTestCase.DeqpTest.prototype); |
| es3fDrawTests.InstancedGridRenderTest.prototype.constructor = es3fDrawTests.InstancedGridRenderTest; |
| |
| /** |
| * iterate |
| * @return {tcuTestCase.IterateResult} |
| */ |
| es3fDrawTests.InstancedGridRenderTest.prototype.iterate = function() { |
| var renderTargetWidth = Math.min(1024, gl.canvas.width); |
| var renderTargetHeight = Math.min(1024, gl.canvas.height); |
| |
| /** @type {sglrGLContext.GLContext} */ var ctx = new sglrGLContext.GLContext(gl); |
| /** @type {tcuSurface.Surface} */ var surface = new tcuSurface.Surface(renderTargetWidth, renderTargetHeight); |
| /** @type {es3fDrawTests.GridProgram} */ var program = new es3fDrawTests.GridProgram(); |
| |
| // render |
| |
| this.renderTo(ctx, program, surface); |
| |
| // verify image |
| |
| if (this.verifyImage(surface)) |
| testPassed(''); |
| else |
| testFailed('Incorrect rendering result'); |
| return tcuTestCase.IterateResult.STOP; |
| }; |
| |
| /** |
| * @param {sglrGLContext.GLContext} ctx |
| * @param {sglrShaderProgram.ShaderProgram} program |
| * @param {tcuSurface.Surface} dst |
| */ |
| es3fDrawTests.InstancedGridRenderTest.prototype.renderTo = function(ctx, program, dst) { |
| var green = [0, 1, 0, 1]; |
| var yellow = [1, 1, 0, 1]; |
| |
| /** @type {WebGLBuffer} */ var positionBuf = null; |
| /** @type {WebGLBuffer} */ var offsetBuf = null; |
| /** @type {WebGLBuffer} */ var colorBuf = null; |
| /** @type {WebGLBuffer} */ var indexBuf = null; |
| /** @type {WebGLProgram} */ var programID = ctx.createProgram(program); |
| /** @type {number} */ var posLocation = ctx.getAttribLocation(/** @type {WebGLProgram} */ (programID), 'a_position'); |
| /** @type {number} */ var offsetLocation = ctx.getAttribLocation(/** @type {WebGLProgram} */ (programID), 'a_offset'); |
| /** @type {number} */ var colorLocation = ctx.getAttribLocation(/** @type {WebGLProgram} */ (programID), 'a_color'); |
| |
| var cellW = 2.0 / this.m_gridSide; |
| var cellH = 2.0 / this.m_gridSide; |
| var vertexPositions = new Float32Array([ |
| 0, 0, 0, 1, |
| cellW, 0, 0, 1, |
| 0, cellH, 0, 1, |
| |
| 0, cellH, 0, 1, |
| cellW, 0, 0, 1, |
| cellW, cellH, 0, 1 |
| ]); |
| |
| var indices = new Uint16Array([ |
| 0, 4, 3, |
| 2, 1, 5 |
| ]); |
| |
| var offsets = []; |
| for (var x = 0; x < this.m_gridSide; ++x) |
| for (var y = 0; y < this.m_gridSide; ++y) { |
| offsets.push(x * cellW - 1.0); |
| offsets.push(y * cellW - 1.0); |
| offsets.push(0, 0); |
| } |
| offsets = new Float32Array(offsets); |
| |
| var colors = []; |
| for (var x = 0; x < this.m_gridSide; ++x) |
| for (var y = 0; y < this.m_gridSide; ++y) { |
| var colorToPush = ((x + y) % 2 == 0) ? (green) : (yellow); |
| colors.push(colorToPush[0]); |
| colors.push(colorToPush[1]); |
| colors.push(colorToPush[2]); |
| colors.push(colorToPush[3]); |
| } |
| colors = new Float32Array(colors); |
| |
| positionBuf = ctx.createBuffer(); |
| ctx.bindBuffer(gl.ARRAY_BUFFER, positionBuf); |
| ctx.bufferData(gl.ARRAY_BUFFER, vertexPositions, gl.STATIC_DRAW); |
| ctx.vertexAttribPointer(posLocation, 4, gl.FLOAT, false, 0, 0); |
| ctx.vertexAttribDivisor(posLocation, 0); |
| ctx.enableVertexAttribArray(posLocation); |
| |
| offsetBuf = ctx.createBuffer(); |
| ctx.bindBuffer(gl.ARRAY_BUFFER, offsetBuf); |
| ctx.bufferData(gl.ARRAY_BUFFER, offsets, gl.STATIC_DRAW); |
| ctx.vertexAttribPointer(offsetLocation, 4, gl.FLOAT, false, 0, 0); |
| ctx.vertexAttribDivisor(offsetLocation, 1); |
| ctx.enableVertexAttribArray(offsetLocation); |
| |
| colorBuf = ctx.createBuffer(); |
| ctx.bindBuffer(gl.ARRAY_BUFFER, colorBuf); |
| ctx.bufferData(gl.ARRAY_BUFFER, colors, gl.STATIC_DRAW); |
| ctx.vertexAttribPointer(colorLocation, 4, gl.FLOAT, false, 0, 0); |
| ctx.vertexAttribDivisor(colorLocation, 1); |
| ctx.enableVertexAttribArray(colorLocation); |
| |
| if (this.m_useIndices) { |
| indexBuf = ctx.createBuffer(); |
| ctx.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuf); |
| ctx.bufferData(gl.ELEMENT_ARRAY_BUFFER, indices, gl.STATIC_DRAW); |
| } |
| |
| ctx.clearColor(0, 0, 0, 1); |
| ctx.clear(gl.COLOR_BUFFER_BIT); |
| |
| ctx.viewport(0, 0, dst.getWidth(), dst.getHeight()); |
| |
| ctx.useProgram(programID); |
| if (this.m_useIndices) |
| ctx.drawElementsInstanced(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0, this.m_gridSide * this.m_gridSide); |
| else |
| ctx.drawArraysInstanced(gl.TRIANGLES, 0, 6, this.m_gridSide * this.m_gridSide); |
| ctx.useProgram(null); |
| |
| if (this.m_useIndices) |
| ctx.deleteBuffer(indexBuf); |
| ctx.deleteBuffer(colorBuf); |
| ctx.deleteBuffer(offsetBuf); |
| ctx.deleteBuffer(positionBuf); |
| ctx.deleteProgram(programID); |
| |
| ctx.finish(); |
| dst.readViewport(ctx, [0 , 0, dst.getWidth(), dst.getHeight()]); |
| }; |
| |
| /** |
| * @param {tcuSurface.Surface} image |
| * @return {boolean} |
| */ |
| es3fDrawTests.InstancedGridRenderTest.prototype.verifyImage = function(image) { |
| // \note the green/yellow pattern is only for clarity. The test will only verify that all instances were drawn by looking for anything non-green/yellow. |
| |
| var green = [0, 255, 0, 255]; |
| var yellow = [255, 255, 0, 255]; |
| var colorThreshold = 20; |
| |
| /** @type {tcuSurface.Surface} */ var error = new tcuSurface.Surface(image.getWidth(), image.getHeight()); |
| var isOk = true; |
| |
| for (var y = 1; y < image.getHeight() - 1; y++) |
| for (var x = 1; x < image.getWidth() - 1; x++) { |
| /** @type {tcuRGBA.RGBA} */ var pixel = new tcuRGBA.RGBA(image.getPixel(x, y)); |
| var pixelOk = true; |
| |
| // Any pixel with !(G ~= 255) is faulty (not a linear combinations of green and yellow) |
| if (Math.abs(pixel.getGreen() - 255) > colorThreshold) |
| pixelOk = false; |
| |
| // Any pixel with !(B ~= 0) is faulty (not a linear combinations of green and yellow) |
| if (Math.abs(pixel.getBlue() - 0) > colorThreshold) |
| pixelOk = false; |
| |
| error.setPixel(x, y, pixelOk ? [0, 255, 0, 255] : [255, 0, 0, 255]); |
| isOk = isOk && pixelOk; |
| } |
| |
| if (!isOk) { |
| bufferedLogToConsole('Image verification failed.'); |
| debug('Verfication result'); |
| tcuLogImage.logImageWithInfo(image.getAccess(), 'Result'); |
| tcuLogImage.logImageWithInfo(error.getAccess(), 'Error mask'); |
| } else { |
| debug('Verfication result'); |
| } |
| |
| return isOk; |
| }; |
| |
| /** |
| * InstancingGroup |
| * @constructor |
| * @extends {tcuTestCase.DeqpTest} |
| */ |
| es3fDrawTests.InstancingGroup = function(name, descr) { |
| tcuTestCase.DeqpTest.call(this, name, descr); |
| this.makeExecutable(); |
| }; |
| |
| es3fDrawTests.InstancingGroup.prototype = Object.create(tcuTestCase.DeqpTest.prototype); |
| es3fDrawTests.InstancingGroup.prototype.constructor = es3fDrawTests.InstancingGroup; |
| |
| /** |
| * init |
| */ |
| es3fDrawTests.InstancingGroup.prototype.init = function() { |
| var gridWidths = [ |
| 2, |
| 5, |
| 10, |
| 32, |
| 100 |
| ]; |
| |
| // drawArrays |
| for (var ndx = 0; ndx < gridWidths.length; ++ndx) { |
| var name = 'draw_arrays_instanced_grid_' + gridWidths[ndx] + 'x' + gridWidths[ndx]; |
| var desc = 'DrawArraysInstanced, Grid size ' + gridWidths[ndx] + 'x' + gridWidths[ndx]; |
| |
| this.addChild(new es3fDrawTests.InstancedGridRenderTest(name, desc, gridWidths[ndx], false)); |
| } |
| |
| // drawElements |
| for (var ndx = 0; ndx < gridWidths.length; ++ndx) { |
| var name = 'draw_elements_instanced_grid_' + gridWidths[ndx] + 'x' + gridWidths[ndx]; |
| var desc = 'DrawElementsInstanced, Grid size ' + gridWidths[ndx] + 'x' + gridWidths[ndx]; |
| |
| this.addChild(new es3fDrawTests.InstancedGridRenderTest(name, desc, gridWidths[ndx], true)); |
| } |
| }; |
| |
| /** |
| * @constructor |
| * @param {number} size |
| */ |
| es3fDrawTests.UniformWeightArray = function(size) { |
| this.weights = []; |
| |
| for (var i = 0; i < size; ++i) |
| this.weights[i] = 1.0; |
| }; |
| |
| /** |
| * RandomGroup |
| * @constructor |
| * @extends {tcuTestCase.DeqpTest} |
| * @param {string} name |
| * @param {string} descr |
| */ |
| es3fDrawTests.RandomGroup = function(name, descr) { |
| tcuTestCase.DeqpTest.call(this, name, descr); |
| this.makeExecutable(); |
| }; |
| |
| es3fDrawTests.RandomGroup.prototype = Object.create(tcuTestCase.DeqpTest.prototype); |
| es3fDrawTests.RandomGroup.prototype.constructor = es3fDrawTests.RandomGroup; |
| |
| /** |
| * init |
| */ |
| es3fDrawTests.RandomGroup.prototype.init = function() { |
| /** @type {number} */ var numAttempts = 300; |
| |
| /** @type {Array<number>} */ var attribCounts = [1, 2, 5]; |
| /** @type {Array<number>} */ var attribWeights = [30, 10, 1]; |
| /** @type {Array<number>} */ var primitiveCounts = [2, 6, 64]; |
| /** @type {Array<number>} */ var primitiveCountWeights = [20, 10, 1]; |
| /** @type {Array<number>} */ var indexOffsets = [0, 7, 13]; |
| /** @type {Array<number>} */ var indexOffsetWeights = [20, 20, 1]; |
| /** @type {Array<number>} */ var firsts = [0, 6, 12]; |
| /** @type {Array<number>} */ var firstWeights = [20, 20, 1]; |
| /** @type {Array<number>} */ var instanceCounts = [1, 2, 16, 17]; |
| /** @type {Array<number>} */ var instanceWeights = [20, 10, 5, 1]; |
| /** @type {Array<number>} */ var indexMins = [0, 1, 3, 9]; |
| /** @type {Array<number>} */ var indexMaxs = [5, 9, 129, 257]; |
| /** @type {Array<number>} */ var indexWeights = [50, 50, 50, 50]; |
| /** @type {Array<number>} */ var offsets = [0, 1, 5, 12]; |
| /** @type {Array<number>} */ var offsetWeights = [50, 10, 10, 10]; |
| /** @type {Array<number>} */ var strides = [0, 7, 16, 17]; |
| /** @type {Array<number>} */ var strideWeights = [50, 10, 10, 10]; |
| /** @type {Array<number>} */ var instanceDivisors = [0, 1, 3, 129]; |
| /** @type {Array<number>} */ var instanceDivisorWeights = [70, 30, 10, 10]; |
| |
| /** @type {Array<glsDrawTests.DrawTestSpec.Primitive>} */ var primitives = [ |
| glsDrawTests.DrawTestSpec.Primitive.POINTS, |
| glsDrawTests.DrawTestSpec.Primitive.TRIANGLES, |
| glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_FAN, |
| glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_STRIP, |
| glsDrawTests.DrawTestSpec.Primitive.LINES, |
| glsDrawTests.DrawTestSpec.Primitive.LINE_STRIP, |
| glsDrawTests.DrawTestSpec.Primitive.LINE_LOOP |
| ]; |
| /** @type {es3fDrawTests.UniformWeightArray} */ var primitiveWeights = new es3fDrawTests.UniformWeightArray(primitives.length); |
| |
| /** @type {Array<glsDrawTests.DrawTestSpec.DrawMethod>} */ var drawMethods = [ |
| glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS, |
| glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS_INSTANCED, |
| glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS, |
| glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_RANGED, |
| glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_INSTANCED |
| ]; |
| /** @type {es3fDrawTests.UniformWeightArray} */ var drawMethodWeights = new es3fDrawTests.UniformWeightArray(drawMethods.length); |
| |
| /** @type {Array<glsDrawTests.DrawTestSpec.IndexType>} */ var indexTypes = [ |
| glsDrawTests.DrawTestSpec.IndexType.BYTE, |
| glsDrawTests.DrawTestSpec.IndexType.SHORT, |
| glsDrawTests.DrawTestSpec.IndexType.INT |
| ]; |
| /** @type {es3fDrawTests.UniformWeightArray} */ var indexTypeWeights = new es3fDrawTests.UniformWeightArray(indexTypes.length); |
| |
| /** @type {Array<glsDrawTests.DrawTestSpec.Storage>} */ var storages = [ |
| //glsDrawTests.DrawTestSpec.Storage.USER, |
| glsDrawTests.DrawTestSpec.Storage.BUFFER |
| ]; |
| /** @type {es3fDrawTests.UniformWeightArray} */ var storageWeights = new es3fDrawTests.UniformWeightArray(storages.length); |
| |
| /** @type {Array<glsDrawTests.DrawTestSpec.InputType>} */ var inputTypes = [ |
| glsDrawTests.DrawTestSpec.InputType.FLOAT, |
| //glsDrawTests.DrawTestSpec.InputType.FIXED, |
| glsDrawTests.DrawTestSpec.InputType.BYTE, |
| glsDrawTests.DrawTestSpec.InputType.SHORT, |
| glsDrawTests.DrawTestSpec.InputType.UNSIGNED_BYTE, |
| glsDrawTests.DrawTestSpec.InputType.UNSIGNED_SHORT, |
| glsDrawTests.DrawTestSpec.InputType.INT, |
| glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT, |
| glsDrawTests.DrawTestSpec.InputType.HALF, |
| glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT_2_10_10_10, |
| glsDrawTests.DrawTestSpec.InputType.INT_2_10_10_10 |
| ]; |
| /** @type {es3fDrawTests.UniformWeightArray} */ var inputTypeWeights = new es3fDrawTests.UniformWeightArray(inputTypes.length); |
| |
| /** @type {Array<glsDrawTests.DrawTestSpec.OutputType>} */ var outputTypes = [ |
| glsDrawTests.DrawTestSpec.OutputType.FLOAT, |
| glsDrawTests.DrawTestSpec.OutputType.VEC2, |
| glsDrawTests.DrawTestSpec.OutputType.VEC3, |
| glsDrawTests.DrawTestSpec.OutputType.VEC4, |
| glsDrawTests.DrawTestSpec.OutputType.INT, |
| glsDrawTests.DrawTestSpec.OutputType.UINT, |
| glsDrawTests.DrawTestSpec.OutputType.IVEC2, |
| glsDrawTests.DrawTestSpec.OutputType.IVEC3, |
| glsDrawTests.DrawTestSpec.OutputType.IVEC4, |
| glsDrawTests.DrawTestSpec.OutputType.UVEC2, |
| glsDrawTests.DrawTestSpec.OutputType.UVEC3, |
| glsDrawTests.DrawTestSpec.OutputType.UVEC4 |
| ]; |
| /** @type {es3fDrawTests.UniformWeightArray} */ var outputTypeWeights = new es3fDrawTests.UniformWeightArray(outputTypes.length); |
| |
| /** @type {Array<glsDrawTests.DrawTestSpec.Usage>} */ var usages = [ |
| glsDrawTests.DrawTestSpec.Usage.DYNAMIC_DRAW, |
| glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW, |
| glsDrawTests.DrawTestSpec.Usage.STREAM_DRAW, |
| glsDrawTests.DrawTestSpec.Usage.STREAM_READ, |
| glsDrawTests.DrawTestSpec.Usage.STREAM_COPY, |
| glsDrawTests.DrawTestSpec.Usage.STATIC_READ, |
| glsDrawTests.DrawTestSpec.Usage.STATIC_COPY, |
| glsDrawTests.DrawTestSpec.Usage.DYNAMIC_READ, |
| glsDrawTests.DrawTestSpec.Usage.DYNAMIC_COPY |
| ]; |
| /** @type {es3fDrawTests.UniformWeightArray} */ var usageWeights = new es3fDrawTests.UniformWeightArray(usages.length); |
| |
| /** @type {Array<number>} */ var insertedHashes = []; //'set' structure |
| /** @type {number} */ var insertedCount = 0; |
| |
| for (var ndx = 0; ndx < numAttempts; ++ndx) { |
| /** @type {deRandom.Random} */ var random = new deRandom.Random(0xc551393 + ndx); // random does not depend on previous cases |
| |
| /** @type {number} */ var attributeCount = random.chooseWeighted(attribCounts, attribWeights); |
| /** @type {glsDrawTests.DrawTestSpec} */ var spec = new glsDrawTests.DrawTestSpec(); |
| |
| //spec.apiType = glu::ApiType::es(3,0); |
| spec.primitive = /** @type {glsDrawTests.DrawTestSpec.Primitive} */ (random.chooseWeighted(primitives, primitiveWeights.weights)); |
| spec.primitiveCount = random.chooseWeighted(primitiveCounts, primitiveCountWeights); |
| spec.drawMethod = /** @type {glsDrawTests.DrawTestSpec.DrawMethod} */ (random.chooseWeighted(drawMethods, drawMethodWeights.weights)); |
| spec.indexType = /** @type {glsDrawTests.DrawTestSpec.IndexType} */ (random.chooseWeighted(indexTypes, indexTypeWeights.weights)); |
| spec.indexPointerOffset = random.chooseWeighted(indexOffsets, indexOffsetWeights); |
| spec.indexStorage = /** @type {glsDrawTests.DrawTestSpec.Storage} */ (random.chooseWeighted(storages, storageWeights.weights)); |
| spec.first = random.chooseWeighted(firsts, firstWeights); |
| spec.indexMin = random.chooseWeighted(indexMins, indexWeights); |
| spec.indexMax = random.chooseWeighted(indexMaxs, indexWeights); |
| spec.instanceCount = random.chooseWeighted(instanceCounts, instanceWeights); |
| |
| // check spec is legal |
| if (!spec.valid()) |
| continue; |
| |
| var hasZeroDivisor = false; |
| for (var attrNdx = 0; attrNdx < attributeCount;) { |
| /** @type {boolean} */ var valid; |
| /** @type {glsDrawTests.DrawTestSpec.AttributeSpec} */ var attribSpec = new glsDrawTests.DrawTestSpec.AttributeSpec(); |
| |
| attribSpec.inputType = /** @type {glsDrawTests.DrawTestSpec.InputType} */ (random.chooseWeighted(inputTypes, inputTypeWeights.weights)); |
| attribSpec.outputType = /** @type {glsDrawTests.DrawTestSpec.OutputType} */ (random.chooseWeighted(outputTypes, outputTypeWeights.weights)); |
| attribSpec.storage = /** @type {glsDrawTests.DrawTestSpec.Storage} */ (random.chooseWeighted(storages, storageWeights.weights)); |
| attribSpec.usage = /** @type {glsDrawTests.DrawTestSpec.Usage} */ (random.chooseWeighted(usages, usageWeights.weights)); |
| attribSpec.componentCount = random.getInt(1, 4); |
| attribSpec.offset = random.chooseWeighted(offsets, offsetWeights); |
| attribSpec.stride = random.chooseWeighted(strides, strideWeights); |
| attribSpec.normalize = random.getBool(); |
| attribSpec.instanceDivisor = random.chooseWeighted(instanceDivisors, instanceDivisorWeights); |
| attribSpec.useDefaultAttribute = random.getBool(); |
| |
| // check spec is legal |
| valid = attribSpec.valid(/*spec.apiType*/); |
| |
| // we do not want interleaved elements. (Might result in some weird floating point values) |
| if (attribSpec.stride && attribSpec.componentCount * glsDrawTests.DrawTestSpec.inputTypeSize(attribSpec.inputType) > attribSpec.stride) |
| valid = false; |
| |
| // try again if not valid |
| if (valid) { |
| spec.attribs.push(attribSpec); |
| ++attrNdx; |
| if (attribSpec.instanceDivisor == 0) |
| hasZeroDivisor = true; |
| } |
| } |
| |
| // Do not collapse all vertex positions to a single positions |
| if (spec.primitive != glsDrawTests.DrawTestSpec.Primitive.POINTS) { |
| spec.attribs[0].instanceDivisor = 0; |
| hasZeroDivisor = true; |
| } |
| |
| // There should be at least one enabled vertex attribute array that has a divisor of zero in WebGL. |
| // This limitation is added to keep compatible with D3D. It differs from the feature in gles. |
| // See the section <Enabled Attribute> in WebGL spec: https://www.khronos.org/registry/webgl/specs/latest/2.0/#5.6 |
| if (hasZeroDivisor == false) |
| continue; |
| |
| // Is render result meaningful? |
| // Only one vertex |
| if (spec.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_RANGED && spec.indexMin == spec.indexMax && spec.primitive != glsDrawTests.DrawTestSpec.Primitive.POINTS) |
| continue; |
| if (spec.attribs[0].useDefaultAttribute && spec.primitive != glsDrawTests.DrawTestSpec.Primitive.POINTS) |
| continue; |
| |
| // Triangle only on one axis |
| if (spec.primitive == glsDrawTests.DrawTestSpec.Primitive.TRIANGLES || spec.primitive == glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_FAN || spec.primitive == glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_STRIP) { |
| if (spec.attribs[0].componentCount == 1) |
| continue; |
| if (spec.attribs[0].outputType == glsDrawTests.DrawTestSpec.OutputType.FLOAT || spec.attribs[0].outputType == glsDrawTests.DrawTestSpec.OutputType.INT || spec.attribs[0].outputType == glsDrawTests.DrawTestSpec.OutputType.UINT) |
| continue; |
| if (spec.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_RANGED && (spec.indexMax - spec.indexMin) < 2) |
| continue; |
| } |
| |
| // Add case |
| /** @type {number} */ var hash = spec.hash(); |
| for (var attrNdx = 0; attrNdx < attributeCount; ++attrNdx) |
| hash = deMath.binaryOp(deMath.shiftLeft(hash, 2), spec.attribs[attrNdx].hash(), deMath.BinaryOp.XOR); |
| |
| if (insertedHashes.indexOf(hash) == -1) { |
| // Only properly aligned |
| if (spec.isCompatibilityTest() != glsDrawTests.DrawTestSpec.CompatibilityTestType.UNALIGNED_OFFSET && |
| spec.isCompatibilityTest() != glsDrawTests.DrawTestSpec.CompatibilityTestType.UNALIGNED_STRIDE) { |
| this.addChild(new glsDrawTests.DrawTest(spec, insertedCount + '', spec.getDesc())); |
| } |
| deUtil.dePushUniqueToArray(insertedHashes, hash); |
| |
| ++insertedCount; |
| } |
| } |
| }; |
| |
| /** |
| * @constructor |
| * @extends {tcuTestCase.DeqpTest} |
| */ |
| es3fDrawTests.DrawTest = function() { |
| tcuTestCase.DeqpTest.call(this, 'draw', 'Drawing tests'); |
| this.makeExecutable(); |
| }; |
| |
| es3fDrawTests.DrawTest.prototype = Object.create(tcuTestCase.DeqpTest.prototype); |
| es3fDrawTests.DrawTest.prototype.constructor = es3fDrawTests.DrawTest; |
| |
| /** |
| * init |
| */ |
| es3fDrawTests.DrawTest.prototype.init = function() { |
| // Basic |
| /** @type {Array<glsDrawTests.DrawTestSpec.DrawMethod>} */ var basicMethods = [ |
| glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS, |
| glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS, |
| glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS_INSTANCED, |
| glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_INSTANCED, |
| glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_RANGED |
| ]; |
| |
| for (var ndx = 0; ndx < basicMethods.length; ++ndx) { |
| var name = glsDrawTests.DrawTestSpec.drawMethodToString(basicMethods[ndx]); |
| var desc = glsDrawTests.DrawTestSpec.drawMethodToString(basicMethods[ndx]); |
| |
| this.addChild(new es3fDrawTests.MethodGroup(name, desc, basicMethods[ndx])); |
| } |
| |
| // extreme instancing |
| |
| this.addChild(new es3fDrawTests.InstancingGroup('instancing', 'draw tests with a large instance count.')); |
| |
| // Random |
| |
| this.addChild(new es3fDrawTests.RandomGroup('random', 'random draw commands.')); |
| }; |
| |
| /** |
| * Create and execute the test cases |
| * @param {WebGL2RenderingContext} context |
| */ |
| es3fDrawTests.run = function(context, range) { |
| gl = context; |
| //Set up Test Root parameters |
| var state = tcuTestCase.runner; |
| |
| var rootTest = new es3fDrawTests.DrawTest(); |
| state.setRoot(rootTest); |
| |
| //Set up name and description of this test series. |
| setCurrentTestName(rootTest.fullName()); |
| description(rootTest.getDescription()); |
| |
| try { |
| if (range) { |
| state.setRange(range); |
| } |
| //Run test cases |
| tcuTestCase.runTestCases(); |
| } |
| catch (err) { |
| testFailedOptions('Failed to run draw tests', false); |
| tcuTestCase.runner.terminate(); |
| } |
| }; |
| |
| }); |
