| /*------------------------------------------------------------------------- |
| * 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('modules.shared.glsDrawTests'); |
| goog.require('framework.common.tcuFloat'); |
| goog.require('framework.common.tcuImageCompare'); |
| goog.require('framework.common.tcuPixelFormat'); |
| goog.require('framework.common.tcuRGBA'); |
| goog.require('framework.common.tcuSurface'); |
| goog.require('framework.common.tcuTestCase'); |
| goog.require('framework.common.tcuTextureUtil'); |
| goog.require('framework.delibs.debase.deMath'); |
| goog.require('framework.delibs.debase.deRandom'); |
| goog.require('framework.opengl.gluShaderUtil'); |
| goog.require('framework.opengl.gluStrUtil'); |
| goog.require('framework.opengl.simplereference.sglrGLContext'); |
| goog.require('framework.opengl.simplereference.sglrReferenceContext'); |
| 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.scope(function() { |
| |
| var glsDrawTests = modules.shared.glsDrawTests; |
| var tcuTestCase = framework.common.tcuTestCase; |
| var tcuRGBA = framework.common.tcuRGBA; |
| var tcuFloat = framework.common.tcuFloat; |
| var tcuPixelFormat = framework.common.tcuPixelFormat; |
| var tcuSurface = framework.common.tcuSurface; |
| var tcuImageCompare = framework.common.tcuImageCompare; |
| var tcuTextureUtil = framework.common.tcuTextureUtil; |
| var gluShaderUtil = framework.opengl.gluShaderUtil; |
| var gluStrUtil = framework.opengl.gluStrUtil; |
| var sglrGLContext = framework.opengl.simplereference.sglrGLContext; |
| var sglrReferenceContext = framework.opengl.simplereference.sglrReferenceContext; |
| var sglrShaderProgram = framework.opengl.simplereference.sglrShaderProgram; |
| var deMath = framework.delibs.debase.deMath; |
| var deRandom = framework.delibs.debase.deRandom; |
| 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; |
| |
| /** @const {number} */ glsDrawTests.MAX_RENDER_TARGET_SIZE = 512; |
| |
| // Utils |
| |
| /** |
| * @param {glsDrawTests.DrawTestSpec.Target} target |
| * @return {number} |
| */ |
| glsDrawTests.targetToGL = function(target) { |
| assertMsgOptions(target != null, 'Target is null', false, true); |
| |
| var targets = [ |
| gl.ELEMENT_ARRAY_BUFFER, // TARGET_ELEMENT_ARRAY = 0, |
| gl.ARRAY_BUFFER // TARGET_ARRAY, |
| ]; |
| |
| return targets[target]; |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.Usage} usage |
| * @return {number} |
| */ |
| glsDrawTests.usageToGL = function(usage) { |
| assertMsgOptions(usage != null, 'Usage is null', false, true); |
| |
| var usages = [ |
| gl.DYNAMIC_DRAW, // USAGE_DYNAMIC_DRAW = 0, |
| gl.STATIC_DRAW, // USAGE_STATIC_DRAW, |
| gl.STREAM_DRAW, // USAGE_STREAM_DRAW, |
| |
| gl.STREAM_READ, // USAGE_STREAM_READ, |
| gl.STREAM_COPY, // USAGE_STREAM_COPY, |
| |
| gl.STATIC_READ, // USAGE_STATIC_READ, |
| gl.STATIC_COPY, // USAGE_STATIC_COPY, |
| |
| gl.DYNAMIC_READ, // USAGE_DYNAMIC_READ, |
| gl.DYNAMIC_COPY // USAGE_DYNAMIC_COPY, |
| ]; |
| assertMsgOptions(usages.length == Object.keys(glsDrawTests.DrawTestSpec.Usage).length, |
| 'Amount of usage gl vlaues is different from amount of usages', false, true); |
| |
| return usages[usage]; |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.InputType} type |
| * @return {number} |
| */ |
| glsDrawTests.inputTypeToGL = function(type) { |
| assertMsgOptions(type != null, 'Input type is null', false, true); |
| |
| var types = [ |
| gl.FLOAT, // INPUTTYPE_FLOAT = 0, |
| gl.BYTE, // INPUTTYPE_BYTE, |
| gl.SHORT, // INPUTTYPE_SHORT, |
| gl.UNSIGNED_BYTE, // INPUTTYPE_UNSIGNED_BYTE, |
| gl.UNSIGNED_SHORT, // INPUTTYPE_UNSIGNED_SHORT, |
| |
| gl.INT, // INPUTTYPE_INT, |
| gl.UNSIGNED_INT, // INPUTTYPE_UNSIGNED_INT, |
| gl.HALF_FLOAT, // INPUTTYPE_HALF, |
| gl.UNSIGNED_INT_2_10_10_10_REV, // INPUTTYPE_UNSIGNED_INT_2_10_10_10, |
| gl.INT_2_10_10_10_REV // INPUTTYPE_INT_2_10_10_10, |
| ]; |
| assertMsgOptions(types.length == Object.keys(glsDrawTests.DrawTestSpec.InputType).length, |
| 'Amount of gl input types is different from amount of input types', false, true); |
| |
| return types[type]; |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.OutputType} type |
| * @return {string} |
| */ |
| glsDrawTests.outputTypeToGLType = function(type) { |
| assertMsgOptions(type != null, 'Output type is null', false, true); |
| |
| var types = [ |
| 'float', // OUTPUTTYPE_FLOAT = 0, |
| 'vec2', // OUTPUTTYPE_VEC2, |
| 'vec3', // OUTPUTTYPE_VEC3, |
| 'vec4', // OUTPUTTYPE_VEC4, |
| |
| 'int', // OUTPUTTYPE_INT, |
| 'uint', // OUTPUTTYPE_UINT, |
| |
| 'ivec2', // OUTPUTTYPE_IVEC2, |
| 'ivec3', // OUTPUTTYPE_IVEC3, |
| 'ivec4', // OUTPUTTYPE_IVEC4, |
| |
| 'uvec2', // OUTPUTTYPE_UVEC2, |
| 'uvec3', // OUTPUTTYPE_UVEC3, |
| 'uvec4' // OUTPUTTYPE_UVEC4, |
| ]; |
| assertMsgOptions(types.length == Object.keys(glsDrawTests.DrawTestSpec.OutputType).length, |
| 'Amount of output type names is different than amount of output types', false, true); |
| |
| return types[type]; |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.Primitive} primitive |
| * @return {number} |
| */ |
| glsDrawTests.primitiveToGL = function(primitive) { |
| var primitives = [ |
| gl.POINTS, // PRIMITIVE_POINTS = 0, |
| gl.TRIANGLES, // PRIMITIVE_TRIANGLES, |
| gl.TRIANGLE_FAN, // PRIMITIVE_TRIANGLE_FAN, |
| gl.TRIANGLE_STRIP, // PRIMITIVE_TRIANGLE_STRIP, |
| gl.LINES, // PRIMITIVE_LINES |
| gl.LINE_STRIP, // PRIMITIVE_LINE_STRIP |
| gl.LINE_LOOP |
| ]; |
| assertMsgOptions(primitives.length == Object.keys(glsDrawTests.DrawTestSpec.Primitive).length, |
| 'Amount of gl primitive values is different than amount of primitives', false, true); |
| |
| return primitives[primitive]; |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.IndexType} indexType |
| * @return {number} |
| */ |
| glsDrawTests.indexTypeToGL = function(indexType) { |
| var indexTypes = [ |
| gl.UNSIGNED_BYTE, // INDEXTYPE_BYTE = 0, |
| gl.UNSIGNED_SHORT, // INDEXTYPE_SHORT, |
| gl.UNSIGNED_INT // INDEXTYPE_INT, |
| ]; |
| assertMsgOptions(indexTypes.length == Object.keys(glsDrawTests.DrawTestSpec.IndexType).length, |
| 'Amount of gl index types is different than amount of index types', false, true); |
| |
| return indexTypes[indexType]; |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.IndexType} indexType |
| * @return {?glsDrawTests.DrawTestSpec.InputType} |
| */ |
| glsDrawTests.indexTypeToInputType = function(indexType) { |
| var inputTypes = [ |
| glsDrawTests.DrawTestSpec.InputType.UNSIGNED_BYTE, // INDEXTYPE_BYTE = 0, |
| glsDrawTests.DrawTestSpec.InputType.UNSIGNED_SHORT, // INDEXTYPE_SHORT, |
| glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT // INDEXTYPE_INT, |
| ]; |
| assertMsgOptions(inputTypes.length == Object.keys(glsDrawTests.DrawTestSpec.IndexType).length, |
| 'Amount of relevant input types is different than amount of index types', false, true); |
| |
| return inputTypes[indexType]; |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.InputType} type |
| * @return {boolean} |
| */ |
| glsDrawTests.inputTypeIsFloatType = function(type) { |
| if (type == glsDrawTests.DrawTestSpec.InputType.FLOAT) |
| return true; |
| if (type == glsDrawTests.DrawTestSpec.InputType.HALF) |
| return true; |
| return false; |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.OutputType} type |
| * @return {boolean} |
| */ |
| glsDrawTests.outputTypeIsFloatType = function(type) { |
| if (type == glsDrawTests.DrawTestSpec.OutputType.FLOAT || |
| type == glsDrawTests.DrawTestSpec.OutputType.VEC2 || |
| type == glsDrawTests.DrawTestSpec.OutputType.VEC3 || |
| type == glsDrawTests.DrawTestSpec.OutputType.VEC4) |
| return true; |
| |
| return false; |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.OutputType} type |
| * @return {boolean} |
| */ |
| glsDrawTests.outputTypeIsIntType = function(type) { |
| if (type == glsDrawTests.DrawTestSpec.OutputType.INT || |
| type == glsDrawTests.DrawTestSpec.OutputType.IVEC2 || |
| type == glsDrawTests.DrawTestSpec.OutputType.IVEC3 || |
| type == glsDrawTests.DrawTestSpec.OutputType.IVEC4) |
| return true; |
| |
| return false; |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.OutputType} type |
| * @return {boolean} |
| */ |
| glsDrawTests.outputTypeIsUintType = function(type) { |
| if (type == glsDrawTests.DrawTestSpec.OutputType.UINT || |
| type == glsDrawTests.DrawTestSpec.OutputType.UVEC2 || |
| type == glsDrawTests.DrawTestSpec.OutputType.UVEC3 || |
| type == glsDrawTests.DrawTestSpec.OutputType.UVEC4) |
| return true; |
| |
| return false; |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.Primitive} primitive |
| * @param {number} primitiveCount |
| * @return {number} |
| */ |
| glsDrawTests.getElementCount = function(primitive, primitiveCount) { |
| switch (primitive) { |
| case glsDrawTests.DrawTestSpec.Primitive.POINTS: return primitiveCount; |
| case glsDrawTests.DrawTestSpec.Primitive.TRIANGLES: return primitiveCount * 3; |
| case glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_FAN: return primitiveCount + 2; |
| case glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_STRIP: return primitiveCount + 2; |
| case glsDrawTests.DrawTestSpec.Primitive.LINES: return primitiveCount * 2; |
| case glsDrawTests.DrawTestSpec.Primitive.LINE_STRIP: return primitiveCount + 1; |
| case glsDrawTests.DrawTestSpec.Primitive.LINE_LOOP: return (primitiveCount == 1) ? (2) : (primitiveCount); |
| default: |
| throw new Error('Invalid primitive'); |
| } |
| }; |
| |
| //MethodInfo |
| |
| /** |
| * @typedef {{indexed: boolean, instanced: boolean, ranged: boolean, first: boolean}} |
| */ |
| glsDrawTests.MethodInfo = { |
| /** @type {boolean} */ indexed: false, |
| /** @type {boolean} */ instanced: false, |
| /** @type {boolean} */ ranged: false, |
| /** @type {boolean} */ first: false |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.DrawMethod} method |
| * @return {glsDrawTests.MethodInfo} |
| */ |
| glsDrawTests.getMethodInfo = function(method) { |
| /** @type {Array<glsDrawTests.MethodInfo>} */ var infos = [{ |
| indexed: false, instanced: false, ranged: false, first: true //!< DRAWMETHOD_DRAWARRAYS, |
| },{ |
| indexed: false, instanced: true, ranged: false, first: true //!< DRAWMETHOD_DRAWARRAYS_INSTANCED, |
| },{ |
| indexed: true, instanced: false, ranged: false, first: false //!< DRAWMETHOD_DRAWELEMENTS, |
| },{ |
| indexed: true, instanced: false, ranged: true, first: false //!< DRAWMETHOD_DRAWELEMENTS_RANGED, |
| },{ |
| indexed: true, instanced: true, ranged: false, first: false //!< DRAWMETHOD_DRAWELEMENTS_INSTANCED |
| } |
| ]; |
| |
| assertMsgOptions(infos.length == Object.keys(glsDrawTests.DrawTestSpec.DrawMethod).length, |
| 'Number of info names', false, true); |
| assertMsgOptions(method < infos.length, 'Invalid method', false, true); |
| return /** @type {glsDrawTests.MethodInfo} */ (infos[method]); |
| }; |
| |
| /** |
| * @param {glsDrawTests.DrawTestSpec} a |
| * @param {glsDrawTests.DrawTestSpec} b |
| * @return {boolean} |
| */ |
| glsDrawTests.checkSpecsShaderCompatible = function(a, b) { |
| // Only the attributes matter |
| if (a.attribs.length != b.attribs.length) |
| return false; |
| |
| for (var ndx = 0; ndx < a.attribs.length; ++ndx) { |
| // Only the output type (== shader input type) matters and the usage in the shader. |
| |
| if (a.attribs[ndx].additionalPositionAttribute != b.attribs[ndx].additionalPositionAttribute) |
| return false; |
| |
| // component counts need not to match |
| if (glsDrawTests.outputTypeIsFloatType(a.attribs[ndx].outputType) && glsDrawTests.outputTypeIsFloatType(b.attribs[ndx].outputType)) |
| continue; |
| if (glsDrawTests.outputTypeIsIntType(a.attribs[ndx].outputType) && glsDrawTests.outputTypeIsIntType(b.attribs[ndx].outputType)) |
| continue; |
| if (glsDrawTests.outputTypeIsUintType(a.attribs[ndx].outputType) && glsDrawTests.outputTypeIsUintType(b.attribs[ndx].outputType)) |
| continue; |
| |
| return false; |
| } |
| |
| return true; |
| }; |
| |
| // generate random vectors in a way that does not depend on argument evaluation order |
| |
| /** |
| * @param {deRandom.Random} random |
| * @return {Array<number>} |
| */ |
| glsDrawTests.generateRandomVec4 = function(random) { |
| /** @type {Array<number>} */ var retVal = []; |
| |
| for (var i = 0; i < 4; ++i) |
| retVal[i] = random.getFloat(); |
| |
| return retVal; |
| }; |
| |
| /** |
| * @param {deRandom.Random} random |
| * @return {Array<number>} |
| */ |
| glsDrawTests.generateRandomIVec4 = function(random) { |
| /** @type {Array<number>} */ var retVal = []; |
| |
| for (var i = 0; i < 4; ++i) |
| retVal[i] = random.getInt(); |
| |
| return retVal; |
| }; |
| |
| /** |
| * @param {deRandom.Random} random |
| * @return {Array<number>} |
| */ |
| glsDrawTests.generateRandomUVec4 = function(random) { |
| /** @type {Array<number>} */ var retVal = []; |
| |
| for (var i = 0; i < 4; ++i) |
| retVal[i] = Math.abs(random.getInt()); |
| |
| return retVal; |
| }; |
| |
| //GLValue |
| |
| /** |
| * glsDrawTests.GLValue class |
| * @constructor |
| */ |
| glsDrawTests.GLValue = function() { |
| /** @type {goog.NumberArray} */ this.m_value = [0]; |
| /** @type {?glsDrawTests.DrawTestSpec.InputType} */ this.m_type; |
| }; |
| |
| /** |
| * @param {goog.TypedArray} dst |
| * @param {glsDrawTests.GLValue} val |
| */ |
| glsDrawTests.copyGLValueToArray = function(dst, val) { |
| /** @type {Uint8Array} */ var dst8 = new Uint8Array(dst.buffer).subarray(dst.byteOffset, dst.byteOffset + dst.byteLength); |
| /** @type {Uint8Array} */ var val8 = new Uint8Array(val.m_value.buffer); // TODO: Fix encapsulation issue |
| dst8.set(val8); |
| }; |
| |
| /** |
| * @param {goog.TypedArray} dst |
| * @param {goog.TypedArray} src |
| */ |
| glsDrawTests.copyArray = function(dst, src) { |
| /** @type {Uint8Array} */ var dst8 = new Uint8Array(dst.buffer).subarray(dst.byteOffset, dst.byteOffset + dst.byteLength); |
| /** @type {Uint8Array} */ var src8 = new Uint8Array(src.buffer).subarray(src.byteOffset, src.byteOffset + src.byteLength); |
| dst8.set(src8); |
| }; |
| |
| /** |
| * typeToTypedArray function. Determines which type of array will store the value, and stores it. |
| * @param {number} value |
| * @param {?glsDrawTests.DrawTestSpec.InputType} type |
| */ |
| glsDrawTests.GLValue.typeToTypedArray = function(value, type) { |
| var array; |
| |
| switch (type) { |
| case glsDrawTests.DrawTestSpec.InputType.FLOAT: |
| array = new Float32Array(1); |
| break; |
| |
| case glsDrawTests.DrawTestSpec.InputType.BYTE: |
| array = new Int8Array(1); |
| break; |
| case glsDrawTests.DrawTestSpec.InputType.SHORT: |
| array = new Int16Array(1); |
| break; |
| |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_BYTE: |
| array = new Uint8Array(1); |
| break; |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_SHORT: |
| array = new Uint16Array(1); |
| break; |
| |
| case glsDrawTests.DrawTestSpec.InputType.INT: |
| array = new Int32Array(1); |
| break; |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT: |
| array = new Uint32Array(1); |
| break; |
| case glsDrawTests.DrawTestSpec.InputType.HALF: |
| array = new Uint16Array(1); |
| value = glsDrawTests.GLValue.floatToHalf(value); |
| break; |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT_2_10_10_10: |
| array = new Uint32Array(1); |
| break; |
| case glsDrawTests.DrawTestSpec.InputType.INT_2_10_10_10: |
| array = new Int32Array(1); |
| break; |
| default: |
| throw new Error('glsDrawTests.GLValue.typeToTypedArray - Invalid InputType'); |
| } |
| |
| array[0] = value; |
| return array; |
| }; |
| |
| /** |
| * glsDrawTests.GLValue.create |
| * @param {number} value |
| * @param {?glsDrawTests.DrawTestSpec.InputType} type |
| */ |
| glsDrawTests.GLValue.create = function(value, type) { |
| var v = new glsDrawTests.GLValue(); |
| v.m_value = glsDrawTests.GLValue.typeToTypedArray(value, type); |
| v.m_type = type; |
| return v; |
| }; |
| |
| /** |
| * glsDrawTests.GLValue.halfToFloat |
| * @param {number} value |
| * @return {number} |
| */ |
| glsDrawTests.GLValue.halfToFloat = function(value) { |
| return tcuFloat.halfFloatToNumberNoDenorm(value); |
| }; |
| |
| /** |
| * @param {number} f |
| * @return {number} |
| */ |
| glsDrawTests.GLValue.floatToHalf = function(f) { |
| // No denorm support. |
| return tcuFloat.numberToHalfFloatNoDenorm(f); |
| }; |
| |
| /** |
| * glsDrawTests.GLValue.getMaxValue |
| * @param {?glsDrawTests.DrawTestSpec.InputType} type |
| * @return {glsDrawTests.GLValue} |
| */ |
| glsDrawTests.GLValue.getMaxValue = function(type) { |
| var value = 0; |
| |
| assertMsgOptions(type >= 0 && type < Object.keys(glsDrawTests.DrawTestSpec.InputType).length, |
| 'Invalid type for GLValue', false, true); |
| |
| switch (type) { |
| case glsDrawTests.DrawTestSpec.InputType.FLOAT: |
| value = 127; |
| break; |
| case glsDrawTests.DrawTestSpec.InputType.BYTE: |
| value = 127; |
| break; |
| case glsDrawTests.DrawTestSpec.InputType.SHORT: |
| value = 32760; |
| break; |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_BYTE: |
| value = 255; |
| break; |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_SHORT: |
| value = 65530; |
| break; |
| case glsDrawTests.DrawTestSpec.InputType.INT: |
| value = 2147483647; |
| break; |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT: |
| value = 4294967295; |
| break; |
| case glsDrawTests.DrawTestSpec.InputType.HALF: |
| value = 256; |
| break; |
| default: //For any other valid type, return 0 |
| value = 0; |
| } |
| |
| return glsDrawTests.GLValue.create(value, type); |
| }; |
| |
| /** |
| * glsDrawTests.GLValue.getMinValue |
| * @param {?glsDrawTests.DrawTestSpec.InputType} type |
| * @return {glsDrawTests.GLValue} |
| */ |
| glsDrawTests.GLValue.getMinValue = function(type) { |
| var value = 0; |
| |
| assertMsgOptions(type >= 0 && type < Object.keys(glsDrawTests.DrawTestSpec.InputType).length, |
| 'Invalid type for GLValue', false, true); |
| |
| switch (type) { |
| case glsDrawTests.DrawTestSpec.InputType.FLOAT: |
| value = -127; |
| break; |
| case glsDrawTests.DrawTestSpec.InputType.BYTE: |
| value = -127; |
| break; |
| case glsDrawTests.DrawTestSpec.InputType.SHORT: |
| value = -32760; |
| break; |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_BYTE: |
| value = 0; |
| break; |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_SHORT: |
| value = 0; |
| break; |
| case glsDrawTests.DrawTestSpec.InputType.INT: |
| value = -2147483647; |
| break; |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT: |
| value = 0; |
| break; |
| case glsDrawTests.DrawTestSpec.InputType.HALF: |
| value = -256; |
| break; |
| default: //For any other valid type, return 0 |
| value = 0; |
| } |
| |
| return glsDrawTests.GLValue.create(value, type); |
| }; |
| |
| /** |
| * glsDrawTests.GLValue.getRandom |
| * @param {deRandom.Random} rnd |
| * @param {glsDrawTests.GLValue} min |
| * @param {glsDrawTests.GLValue} max |
| * @return {glsDrawTests.GLValue} |
| */ |
| glsDrawTests.GLValue.getRandom = function(rnd, min, max) { |
| assertMsgOptions(min.getType() == max.getType(), 'Min and max types differ', false, true); |
| |
| var minv = min.interpret(); |
| var maxv = max.interpret(); |
| var type = min.getType(); |
| var value; |
| |
| if (maxv < minv) |
| return min; |
| |
| switch (type) { |
| case glsDrawTests.DrawTestSpec.InputType.FLOAT: |
| case glsDrawTests.DrawTestSpec.InputType.HALF: { |
| return glsDrawTests.GLValue.create(minv + rnd.getFloat() * (maxv - minv), type); |
| break; |
| } |
| |
| case glsDrawTests.DrawTestSpec.InputType.SHORT: |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_SHORT: |
| case glsDrawTests.DrawTestSpec.InputType.BYTE: |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_BYTE: |
| case glsDrawTests.DrawTestSpec.InputType.INT: |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT: { |
| return glsDrawTests.GLValue.create(minv + rnd.getInt() % (maxv - minv), type); |
| break; |
| } |
| |
| default: |
| throw new Error('glsDrawTests.GLValue.getRandom - Invalid input type'); |
| break; |
| } |
| }; |
| |
| // Minimum difference required between coordinates |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.InputType} type |
| * @return {glsDrawTests.GLValue} |
| */ |
| glsDrawTests.GLValue.minValue = function(type) { |
| switch (type) { |
| case glsDrawTests.DrawTestSpec.InputType.FLOAT: |
| case glsDrawTests.DrawTestSpec.InputType.BYTE: |
| case glsDrawTests.DrawTestSpec.InputType.HALF: |
| return glsDrawTests.GLValue.create(4, type); |
| case glsDrawTests.DrawTestSpec.InputType.SHORT: |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_SHORT: |
| return glsDrawTests.GLValue.create(4 * 256, type); |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_BYTE: |
| return glsDrawTests.GLValue.create(4 * 2, type); |
| case glsDrawTests.DrawTestSpec.InputType.INT: |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT: |
| return glsDrawTests.GLValue.create(4 * 16777216, type); |
| |
| default: |
| throw new Error('glsDrawTests.GLValue.minValue - Invalid input type'); |
| } |
| }; |
| |
| /** |
| * @param {glsDrawTests.GLValue} val |
| * @return {glsDrawTests.GLValue} |
| */ |
| glsDrawTests.GLValue.abs = function(val) { |
| var type = val.getType(); |
| switch (type) { |
| case glsDrawTests.DrawTestSpec.InputType.SHORT: |
| return glsDrawTests.GLValue.create(0x7FFF & val.getValue(), type); |
| case glsDrawTests.DrawTestSpec.InputType.BYTE: |
| return glsDrawTests.GLValue.create(0x7F & val.getValue(), type); |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_BYTE: |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_SHORT: |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT: |
| return val; |
| case glsDrawTests.DrawTestSpec.InputType.FLOAT: |
| case glsDrawTests.DrawTestSpec.InputType.HALF: |
| return glsDrawTests.GLValue.create(Math.abs(val.interpret()), type); |
| case glsDrawTests.DrawTestSpec.InputType.INT: |
| return glsDrawTests.GLValue.create(0x7FFFFFFF & val.getValue(), type); |
| default: |
| throw new Error('glsDrawTests.GLValue.abs - Invalid input type'); |
| } |
| }; |
| |
| /** |
| * @return {?glsDrawTests.DrawTestSpec.InputType} |
| */ |
| glsDrawTests.GLValue.prototype.getType = function() { |
| return this.m_type; |
| }; |
| |
| /** |
| * glsDrawTests.GLValue.toFloat |
| * @return {number} |
| */ |
| glsDrawTests.GLValue.prototype.toFloat = function() { |
| return this.interpret(); |
| }; |
| |
| /** |
| * glsDrawTests.GLValue.getValue |
| * @return {number} |
| */ |
| glsDrawTests.GLValue.prototype.getValue = function() { |
| return this.m_value[0]; |
| }; |
| |
| /** |
| * interpret function. Returns the m_value as a quantity so arithmetic operations can be performed on it |
| * Only some types require this. |
| * @return {number} |
| */ |
| glsDrawTests.GLValue.prototype.interpret = function() { |
| if (this.m_type == glsDrawTests.DrawTestSpec.InputType.HALF) |
| return glsDrawTests.GLValue.halfToFloat(this.m_value[0]); |
| |
| return this.m_value[0]; |
| }; |
| |
| /** |
| * @param {glsDrawTests.GLValue} other |
| * @return {glsDrawTests.GLValue} |
| */ |
| glsDrawTests.GLValue.prototype.add = function(other) { |
| return glsDrawTests.GLValue.create(this.interpret() + other.interpret(), this.m_type); |
| }; |
| |
| /** |
| * @param {glsDrawTests.GLValue} other |
| * @return {glsDrawTests.GLValue} |
| */ |
| glsDrawTests.GLValue.prototype.mul = function(other) { |
| return glsDrawTests.GLValue.create(this.interpret() * other.interpret(), this.m_type); |
| }; |
| |
| /** |
| * @param {glsDrawTests.GLValue} other |
| * @return {glsDrawTests.GLValue} |
| */ |
| glsDrawTests.GLValue.prototype.div = function(other) { |
| return glsDrawTests.GLValue.create(this.interpret() / other.interpret(), this.m_type); |
| }; |
| |
| /** |
| * @param {glsDrawTests.GLValue} other |
| * @return {glsDrawTests.GLValue} |
| */ |
| glsDrawTests.GLValue.prototype.sub = function(other) { |
| return glsDrawTests.GLValue.create(this.interpret() - other.interpret(), this.m_type); |
| }; |
| |
| /** |
| * @param {glsDrawTests.GLValue} other |
| * @return {glsDrawTests.GLValue} |
| */ |
| glsDrawTests.GLValue.prototype.addToSelf = function(other) { |
| this.m_value[0] = this.interpret() + other.interpret(); |
| return this; |
| }; |
| |
| /** |
| * @param {glsDrawTests.GLValue} other |
| * @return {glsDrawTests.GLValue} |
| */ |
| glsDrawTests.GLValue.prototype.subToSelf = function(other) { |
| this.m_value[0] = this.interpret() - other.interpret(); |
| return this; |
| }; |
| |
| /** |
| * @param {glsDrawTests.GLValue} other |
| * @return {glsDrawTests.GLValue} |
| */ |
| glsDrawTests.GLValue.prototype.mulToSelf = function(other) { |
| this.m_value[0] = this.interpret() * other.interpret(); |
| return this; |
| }; |
| |
| /** |
| * @param {glsDrawTests.GLValue} other |
| * @return {glsDrawTests.GLValue} |
| */ |
| glsDrawTests.GLValue.prototype.divToSelf = function(other) { |
| this.m_value[0] = this.interpret() / other.interpret(); |
| return this; |
| }; |
| |
| /** |
| * @param {glsDrawTests.GLValue} other |
| * @return {boolean} |
| */ |
| glsDrawTests.GLValue.prototype.equals = function(other) { |
| return this.m_value[0] == other.getValue(); |
| }; |
| |
| /** |
| * @param {glsDrawTests.GLValue} other |
| * @return {boolean} |
| */ |
| glsDrawTests.GLValue.prototype.lessThan = function(other) { |
| return this.interpret() < other.interpret(); |
| }; |
| |
| /** |
| * @param {glsDrawTests.GLValue} other |
| * @return {boolean} |
| */ |
| glsDrawTests.GLValue.prototype.greaterThan = function(other) { |
| return this.interpret() > other.interpret(); |
| }; |
| |
| /** |
| * @param {glsDrawTests.GLValue} other |
| * @return {boolean} |
| */ |
| glsDrawTests.GLValue.prototype.lessOrEqualThan = function(other) { |
| return this.interpret() <= other.interpret(); |
| }; |
| |
| /** |
| * @param {glsDrawTests.GLValue} other |
| * @return {boolean} |
| */ |
| glsDrawTests.GLValue.prototype.greaterOrEqualThan = function(other) { |
| return this.interpret() >= other.interpret(); |
| }; |
| |
| // AttriuteArray |
| |
| /** |
| * AttributeArray |
| * @constructor |
| * @param {?glsDrawTests.DrawTestSpec.Storage} storage |
| * @param {sglrGLContext.GLContext | sglrReferenceContext.ReferenceContext} context |
| */ |
| glsDrawTests.AttributeArray = function(storage, context) { |
| /** @type {?glsDrawTests.DrawTestSpec.Storage} */ this.m_storage = storage; |
| /** @type {sglrGLContext.GLContext | sglrReferenceContext.ReferenceContext} */ this.m_ctx = context; |
| /** @type {WebGLBuffer|sglrReferenceContext.DataBuffer|null} */ this.m_glBuffer; |
| |
| /** @type {number} */ this.m_size = 0; |
| /** @type {Uint8Array} */ this.m_data; //NOTE: Used in unsupported user storage |
| /** @type {number} */ this.m_componentCount; |
| /** @type {boolean} */ this.m_bound = false; |
| /** @type {glsDrawTests.DrawTestSpec.Target} */ this.m_target = glsDrawTests.DrawTestSpec.Target.ARRAY; |
| /** @type {?glsDrawTests.DrawTestSpec.InputType} */ this.m_inputType = glsDrawTests.DrawTestSpec.InputType.FLOAT; |
| /** @type {?glsDrawTests.DrawTestSpec.OutputType} */ this.m_outputType = glsDrawTests.DrawTestSpec.OutputType.VEC4; |
| /** @type {boolean} */ this.m_normalize = false; |
| /** @type {number} */ this.m_stride = 0; |
| /** @type {number} */ this.m_offset = 0; |
| /** @type {Array<number>} */ this.m_defaultAttrib; |
| /** @type {number} */ this.m_instanceDivisor = 0; |
| /** @type {boolean} */ this.m_isPositionAttr = false; |
| |
| if (this.m_storage == glsDrawTests.DrawTestSpec.Storage.BUFFER) { |
| this.m_glBuffer = this.m_ctx.createBuffer(); |
| } |
| }; |
| |
| /** @return {number} */ glsDrawTests.AttributeArray.prototype.getComponentCount = function() {return this.m_componentCount;}; |
| |
| /** @return {?glsDrawTests.DrawTestSpec.Target} */ glsDrawTests.AttributeArray.prototype.getTarget = function() {return this.m_target;}; |
| |
| /** @return {?glsDrawTests.DrawTestSpec.InputType} */ glsDrawTests.AttributeArray.prototype.getInputType = function() {return this.m_inputType;}; |
| |
| /** @return {?glsDrawTests.DrawTestSpec.OutputType} */ glsDrawTests.AttributeArray.prototype.getOutputType = function() {return this.m_outputType;}; |
| |
| /** @return {?glsDrawTests.DrawTestSpec.Storage} */ glsDrawTests.AttributeArray.prototype.getStorageType = function() {return this.m_storage;}; |
| |
| /** @return {boolean} */ glsDrawTests.AttributeArray.prototype.getNormalized = function() {return this.m_normalize;}; |
| |
| /** @return {number} */ glsDrawTests.AttributeArray.prototype.getStride = function() {return this.m_stride;}; |
| |
| /** @return {boolean} */ glsDrawTests.AttributeArray.prototype.isBound = function() {return this.m_bound;}; |
| |
| /** @return {boolean} */ glsDrawTests.AttributeArray.prototype.isPositionAttribute = function() {return this.m_isPositionAttr;}; |
| |
| /** |
| * @param {glsDrawTests.DrawTestSpec.Target} target |
| * @param {number} size |
| * @param {goog.TypedArray} ptr |
| * @param {?glsDrawTests.DrawTestSpec.Usage} usage |
| */ |
| glsDrawTests.AttributeArray.prototype.data = function(target, size, ptr, usage) { |
| this.m_size = size; |
| this.m_target = target; |
| |
| if (this.m_storage == glsDrawTests.DrawTestSpec.Storage.BUFFER) { |
| this.m_ctx.bindBuffer(glsDrawTests.targetToGL(target), this.m_glBuffer); |
| this.m_ctx.bufferData(glsDrawTests.targetToGL(target), ptr, glsDrawTests.usageToGL(usage)); |
| } else |
| throw new Error('Wrong storage type'); |
| }; |
| |
| /** |
| * @param {glsDrawTests.DrawTestSpec.Target} target |
| * @param {number} offset |
| * @param {number} size |
| * @param {goog.TypedArray} ptr |
| */ |
| glsDrawTests.AttributeArray.prototype.subdata = function(target, offset, size, ptr) { |
| this.m_target = target; |
| |
| if (this.m_storage == glsDrawTests.DrawTestSpec.Storage.BUFFER) { |
| this.m_ctx.bindBuffer(glsDrawTests.targetToGL(target), this.m_glBuffer); |
| |
| this.m_ctx.bufferSubData(glsDrawTests.targetToGL(target), offset, size, ptr); |
| } else |
| throw new Error('Wrong storage type'); |
| }; |
| |
| /** |
| * @param {boolean} bound |
| * @param {number} offset |
| * @param {number} size |
| * @param {?glsDrawTests.DrawTestSpec.InputType} inputType |
| * @param {?glsDrawTests.DrawTestSpec.OutputType} outType |
| * @param {boolean} normalized |
| * @param {number} stride |
| * @param {number} instanceDivisor |
| * @param {Array<number>} defaultAttrib |
| * @param {boolean} isPositionAttr |
| */ |
| glsDrawTests.AttributeArray.prototype.setupArray = function(bound, offset, size, inputType, outType, |
| normalized, stride, instanceDivisor, defaultAttrib, isPositionAttr) { |
| this.m_componentCount = size; |
| this.m_bound = bound; |
| this.m_inputType = inputType; |
| this.m_outputType = outType; |
| this.m_normalize = normalized; |
| this.m_stride = stride; |
| this.m_offset = offset; |
| this.m_defaultAttrib = defaultAttrib; |
| this.m_instanceDivisor = instanceDivisor; |
| this.m_isPositionAttr = isPositionAttr; |
| }; |
| |
| /** |
| * @param {number} loc (32-bit) |
| */ |
| glsDrawTests.AttributeArray.prototype.bindAttribute = function(loc) { |
| if (!this.isBound()) { |
| /** @type {Array<number>} */ var attr = this.m_defaultAttrib; |
| switch (this.m_inputType) { |
| case glsDrawTests.DrawTestSpec.InputType.FLOAT: { |
| switch (this.m_componentCount) { |
| case 1: this.m_ctx.vertexAttrib1f(loc, attr[0]); break; |
| case 2: this.m_ctx.vertexAttrib2f(loc, attr[0], attr[1]); break; |
| case 3: this.m_ctx.vertexAttrib3f(loc, attr[0], attr[1], attr[2]); break; |
| case 4: this.m_ctx.vertexAttrib4f(loc, attr[0], attr[1], attr[2], attr[3]); break; |
| default: throw new Error('Invalid component count'); break; |
| } |
| break; |
| } |
| case glsDrawTests.DrawTestSpec.InputType.INT: { |
| this.m_ctx.vertexAttribI4i(loc, attr[0], attr[1], attr[2], attr[3]); |
| break; |
| } |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT: { |
| this.m_ctx.vertexAttribI4ui(loc, attr[0], attr[1], attr[2], attr[3]); |
| break; |
| } |
| default: |
| throw new Error('Invalid input type'); |
| break; |
| } |
| } else { |
| /** @type {Uint8Array} */ var basePtr = null; |
| |
| if (this.m_storage == glsDrawTests.DrawTestSpec.Storage.BUFFER) { |
| this.m_ctx.bindBuffer(glsDrawTests.targetToGL(this.m_target), this.m_glBuffer); |
| |
| basePtr = null; |
| } else |
| throw new Error('Invalid storage type'); |
| |
| if (!glsDrawTests.inputTypeIsFloatType(this.m_inputType)) { |
| // Input is not float type |
| |
| if (glsDrawTests.outputTypeIsFloatType(this.m_outputType)) { |
| var size = this.m_componentCount; |
| |
| // Output type is float type |
| this.m_ctx.vertexAttribPointer(loc, size, glsDrawTests.inputTypeToGL(this.m_inputType), this.m_normalize, this.m_stride, this.m_offset); |
| } else { |
| // Output type is int type |
| this.m_ctx.vertexAttribIPointer(loc, this.m_componentCount, glsDrawTests.inputTypeToGL(this.m_inputType), this.m_stride, this.m_offset); |
| } |
| } else { |
| // Input type is float type |
| |
| // Output type must be float type |
| assertMsgOptions(glsDrawTests.outputTypeIsFloatType(this.m_outputType), 'Output type is not float', false, true); |
| |
| this.m_ctx.vertexAttribPointer(loc, this.m_componentCount, glsDrawTests.inputTypeToGL(this.m_inputType), this.m_normalize, |
| this.m_stride, this.m_offset); |
| } |
| |
| if (this.m_instanceDivisor) |
| this.m_ctx.vertexAttribDivisor(loc, this.m_instanceDivisor); |
| } |
| }; |
| |
| /** |
| * @param {glsDrawTests.DrawTestSpec.Target} target |
| */ |
| glsDrawTests.AttributeArray.prototype.bindIndexArray = function(target) { |
| if (this.m_storage == glsDrawTests.DrawTestSpec.Storage.BUFFER) { |
| this.m_ctx.bindBuffer(glsDrawTests.targetToGL(target), this.m_glBuffer); |
| } |
| }; |
| |
| // DrawTestShaderProgram |
| |
| /** |
| * @constructor |
| * @extends {sglrShaderProgram.ShaderProgram} |
| * @param {Array<glsDrawTests.AttributeArray>} arrays |
| */ |
| glsDrawTests.DrawTestShaderProgram = function(arrays) { |
| sglrShaderProgram.ShaderProgram.call(this, this.createProgramDeclaration(arrays)); |
| |
| this.m_componentCount = []; |
| this.m_isCoord = []; |
| this.m_attrType = []; |
| |
| for (var arrayNdx = 0; arrayNdx < arrays.length; arrayNdx++) { |
| this.m_componentCount[arrayNdx] = this.getComponentCount(arrays[arrayNdx].getOutputType()); |
| this.m_isCoord[arrayNdx] = arrays[arrayNdx].isPositionAttribute(); |
| this.m_attrType[arrayNdx] = this.mapOutputType(arrays[arrayNdx].getOutputType()); |
| } |
| }; |
| |
| glsDrawTests.DrawTestShaderProgram.prototype = Object.create(sglrShaderProgram.ShaderProgram.prototype); |
| glsDrawTests.DrawTestShaderProgram.prototype.constructor = glsDrawTests.DrawTestShaderProgram; |
| |
| /** |
| * @param {Array<number>} color |
| * @param {goog.NumberArray} attribValue |
| * @param {number} numComponents |
| * @return {Array<number>} |
| */ |
| glsDrawTests.calcShaderColor = function(color, attribValue, numComponents) { |
| switch (numComponents) { |
| case 1: |
| color[0] = deMath.scale(color, attribValue[0])[0]; |
| break; |
| |
| case 2: |
| color[0] = color[0] * attribValue[0]; |
| color[1] = color[1] * attribValue[1]; |
| break; |
| |
| case 3: |
| color[0] = color[0] * attribValue[0]; |
| color[1] = color[1] * attribValue[1]; |
| color[2] = color[2] * attribValue[2]; |
| break; |
| |
| case 4: |
| color[0] = color[0] * attribValue[0] * attribValue[3]; |
| color[1] = color[1] * attribValue[1] * attribValue[3]; |
| color[2] = color[2] * attribValue[2] * attribValue[3]; |
| break; |
| |
| default: |
| throw new Error('Invalid component count'); |
| } |
| |
| return color; |
| }; |
| |
| /** |
| * @param {Array<number>} coord |
| * @param {goog.NumberArray} attribValue |
| * @param {number} numComponents |
| * @return {Array<number>} |
| */ |
| glsDrawTests.calcShaderCoord = function(coord, attribValue, numComponents) { |
| switch (numComponents) { |
| case 1: |
| |
| coord = deMath.add(coord, [attribValue[0], attribValue[0]]); |
| coord[0] = coord[0]; |
| coord[1] = coord[1]; |
| break; |
| case 2: |
| coord = deMath.add(coord, [attribValue[0], attribValue[1]]); |
| coord[0] = coord[0]; |
| coord[1] = coord[1]; |
| break; |
| case 3: |
| coord = deMath.add(coord, [attribValue[0] + attribValue[2], attribValue[1]]); |
| coord[0] = coord[0]; |
| coord[1] = coord[1]; |
| coord[2] = coord[2]; |
| break; |
| case 4: |
| coord = deMath.add(coord, [attribValue[0] + attribValue[2], attribValue[1] + attribValue[3]]); |
| coord[0] = coord[0]; |
| coord[1] = coord[1]; |
| coord[2] = coord[2]; |
| coord[3] = coord[3]; |
| break; |
| |
| default: |
| throw new Error('Invalid component count'); |
| } |
| |
| return coord; |
| }; |
| |
| /** |
| * @param {Array<rrVertexAttrib.VertexAttrib>} inputs |
| * @param {Array<rrVertexPacket.VertexPacket>} packets |
| * @param {number} numPackets |
| */ |
| glsDrawTests.DrawTestShaderProgram.prototype.shadeVertices = function(inputs, packets, numPackets) { |
| var u_coordScale = this.getUniformByName('u_coordScale').value; |
| var u_colorScale = this.getUniformByName('u_colorScale').value; |
| |
| for (var packetNdx = 0; packetNdx < numPackets; ++packetNdx) { |
| var varyingLocColor = 0; |
| |
| /** @type {rrVertexPacket.VertexPacket} */ var packet = packets[packetNdx]; |
| |
| // Calc output color |
| /** @type {Array<number>} */ var coord = [0.0, 0.0]; |
| /** @type {Array<number>} */ var color = [1.0, 1.0, 1.0]; |
| |
| for (var attribNdx = 0; attribNdx < this.m_attrType.length; attribNdx++) { |
| var numComponents = this.m_componentCount[attribNdx]; |
| /** @type {boolean} */ var isCoord = this.m_isCoord[attribNdx]; |
| |
| var attrib = rrVertexAttrib.readVertexAttrib(inputs[attribNdx], packet.instanceNdx, packet.vertexNdx, this.m_attrType[attribNdx]); |
| |
| if (isCoord) { |
| coord = glsDrawTests.calcShaderCoord( |
| coord, |
| attrib, |
| numComponents |
| ); |
| } else { |
| color = glsDrawTests.calcShaderColor( |
| color, |
| attrib, |
| numComponents |
| ); |
| } |
| } |
| |
| // Transform position |
| packet.position = [u_coordScale * coord[0], u_coordScale * coord[1], 1.0, 1.0]; |
| packet.pointSize = 1.0; |
| |
| // Pass color to FS |
| packet.outputs[varyingLocColor] = deMath.add(deMath.scale([u_colorScale * color[0], u_colorScale * color[1], u_colorScale * color[2], 1.0], 0.5), [0.5, 0.5, 0.5, 0.5]); |
| } |
| }; |
| |
| /** |
| * @param {Array<rrFragmentOperations.Fragment>} packets |
| * @param {rrShadingContext.FragmentShadingContext} context |
| */ |
| glsDrawTests.DrawTestShaderProgram.prototype.shadeFragments = function(packets, context) { |
| var varyingLocColor = 0; |
| |
| for (var packetNdx = 0; packetNdx < packets.length; ++packetNdx) { |
| /** @type {rrFragmentOperations.Fragment} */ var packet = packets[packetNdx]; |
| packet.value = rrShadingContext.readVarying(packet, context, varyingLocColor); |
| } |
| }; |
| |
| /** |
| * @param {Array<glsDrawTests.AttributeArray>} arrays |
| * @return {string} |
| */ |
| glsDrawTests.DrawTestShaderProgram.prototype.genVertexSource = function(arrays) { |
| /** @type {Array<string>}*/ var params; |
| var vertexShaderTmpl = ''; |
| |
| params = this.generateShaderParams(); |
| |
| vertexShaderTmpl += params['VTX_HDR']; |
| |
| for (var arrayNdx = 0; arrayNdx < arrays.length; arrayNdx++) { |
| vertexShaderTmpl += params['VTX_IN'] + ' highp ' + glsDrawTests.outputTypeToGLType(arrays[arrayNdx].getOutputType()) + ' a_' + arrayNdx + ';\n'; |
| } |
| |
| vertexShaderTmpl += |
| 'uniform highp float u_coordScale;\n' + |
| 'uniform highp float u_colorScale;\n' + |
| params['VTX_OUT'] + ' ' + params['COL_PRECISION'] + ' vec4 v_color;\n' + |
| 'void main(void)\n' + |
| '{\n' + |
| '\tgl_PointSize = 1.0;\n' + |
| '\thighp vec2 coord = vec2(0.0, 0.0);\n' + |
| '\thighp vec3 color = vec3(1.0, 1.0, 1.0);\n'; |
| |
| for (var arrayNdx = 0; arrayNdx < arrays.length; arrayNdx++) { |
| var isPositionAttr = arrays[arrayNdx].isPositionAttribute(); |
| |
| if (isPositionAttr) { |
| switch (arrays[arrayNdx].getOutputType()) { |
| case glsDrawTests.DrawTestSpec.OutputType.FLOAT: |
| case glsDrawTests.DrawTestSpec.OutputType.INT: |
| case glsDrawTests.DrawTestSpec.OutputType.UINT: |
| vertexShaderTmpl += |
| '\tcoord += vec2(float(a_' + arrayNdx + '), float(a_' + arrayNdx + '));\n'; |
| break; |
| |
| case glsDrawTests.DrawTestSpec.OutputType.VEC2: |
| case glsDrawTests.DrawTestSpec.OutputType.IVEC2: |
| case glsDrawTests.DrawTestSpec.OutputType.UVEC2: |
| vertexShaderTmpl += |
| '\tcoord += vec2(a_' + arrayNdx + '.xy);\n'; |
| break; |
| |
| case glsDrawTests.DrawTestSpec.OutputType.VEC3: |
| case glsDrawTests.DrawTestSpec.OutputType.IVEC3: |
| case glsDrawTests.DrawTestSpec.OutputType.UVEC3: |
| vertexShaderTmpl += |
| '\tcoord += vec2(a_' + arrayNdx + '.xy);\n' + |
| '\tcoord.x += float(a_' + arrayNdx + '.z);\n'; |
| break; |
| |
| case glsDrawTests.DrawTestSpec.OutputType.VEC4: |
| case glsDrawTests.DrawTestSpec.OutputType.IVEC4: |
| case glsDrawTests.DrawTestSpec.OutputType.UVEC4: |
| vertexShaderTmpl += |
| '\tcoord += vec2(a_' + arrayNdx + '.xy);\n' + |
| '\tcoord += vec2(a_' + arrayNdx + '.zw);\n'; |
| break; |
| |
| default: |
| throw new Error('Invalid output type'); |
| break; |
| } |
| } else { |
| switch (arrays[arrayNdx].getOutputType()) { |
| case glsDrawTests.DrawTestSpec.OutputType.FLOAT: |
| case glsDrawTests.DrawTestSpec.OutputType.INT: |
| case glsDrawTests.DrawTestSpec.OutputType.UINT: |
| vertexShaderTmpl += |
| '\tcolor = color * float(a_' + arrayNdx + ');\n'; |
| break; |
| |
| case glsDrawTests.DrawTestSpec.OutputType.VEC2: |
| case glsDrawTests.DrawTestSpec.OutputType.IVEC2: |
| case glsDrawTests.DrawTestSpec.OutputType.UVEC2: |
| vertexShaderTmpl += |
| '\tcolor.rg = color.rg * vec2(a_' + arrayNdx + '.xy);\n'; |
| break; |
| |
| case glsDrawTests.DrawTestSpec.OutputType.VEC3: |
| case glsDrawTests.DrawTestSpec.OutputType.IVEC3: |
| case glsDrawTests.DrawTestSpec.OutputType.UVEC3: |
| vertexShaderTmpl += |
| '\tcolor = color.rgb * vec3(a_' + arrayNdx + '.xyz);\n'; |
| break; |
| |
| case glsDrawTests.DrawTestSpec.OutputType.VEC4: |
| case glsDrawTests.DrawTestSpec.OutputType.IVEC4: |
| case glsDrawTests.DrawTestSpec.OutputType.UVEC4: |
| vertexShaderTmpl += |
| '\tcolor = color.rgb * vec3(a_' + arrayNdx + '.xyz) * float(a_' + arrayNdx + '.w);\n'; |
| break; |
| |
| default: |
| throw new Error('Invalid output type'); |
| break; |
| } |
| } |
| } |
| |
| vertexShaderTmpl += |
| '\tv_color = vec4(u_colorScale * color, 1.0) * 0.5 + vec4(0.5, 0.5, 0.5, 0.5);\n' + |
| '\tgl_Position = vec4(u_coordScale * coord, 1.0, 1.0);\n' + |
| '}\n'; |
| |
| return vertexShaderTmpl; |
| }; |
| |
| /** |
| * @return {string} |
| */ |
| glsDrawTests.DrawTestShaderProgram.prototype.genFragmentSource = function() { |
| /** @type {Array<string>} */ var params; |
| |
| params = this.generateShaderParams(); |
| |
| var fragmentShaderTmpl = params['FRAG_HDR'] + |
| params['FRAG_IN'] + ' ' + params['COL_PRECISION'] + ' vec4 v_color;\n' + |
| 'void main(void)\n' + |
| '{\n' + |
| '\t' + params['FRAG_COLOR'] + '= v_color;\n' + |
| '}\n'; |
| |
| return fragmentShaderTmpl; |
| }; |
| |
| /** |
| * @return {Array<string>} |
| */ |
| glsDrawTests.DrawTestShaderProgram.prototype.generateShaderParams = function() { |
| /** @type {Array<string>} */ var params = []; |
| if (gluShaderUtil.isGLSLVersionSupported(gl, gluShaderUtil.GLSLVersion.V300_ES)) { |
| params['VTX_IN'] = 'in'; |
| params['VTX_OUT'] = 'out'; |
| params['FRAG_IN'] = 'in'; |
| params['FRAG_COLOR'] = 'dEQP_FragColor'; |
| params['VTX_HDR'] = '#version 300 es\n'; |
| params['FRAG_HDR'] = '#version 300 es\nlayout(location = 0) out mediump vec4 dEQP_FragColor;\n'; |
| params['COL_PRECISION'] = 'mediump'; |
| } else if (gluShaderUtil.isGLSLVersionSupported(gl, gluShaderUtil.GLSLVersion.V100_ES)) { |
| params['VTX_IN'] = 'attribute'; |
| params['VTX_OUT'] = 'varying'; |
| params['FRAG_IN'] = 'varying'; |
| params['FRAG_COLOR'] = 'gl_FragColor'; |
| params['VTX_HDR'] = ''; |
| params['FRAG_HDR'] = ''; |
| params['COL_PRECISION'] = 'mediump'; |
| } else |
| throw new Error('Invalid GL version'); |
| |
| return params; |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.OutputType} type |
| * @return {rrGenericVector.GenericVecType} |
| */ |
| glsDrawTests.DrawTestShaderProgram.prototype.mapOutputType = function(type) { |
| switch (type) { |
| case glsDrawTests.DrawTestSpec.OutputType.FLOAT: |
| case glsDrawTests.DrawTestSpec.OutputType.VEC2: |
| case glsDrawTests.DrawTestSpec.OutputType.VEC3: |
| case glsDrawTests.DrawTestSpec.OutputType.VEC4: |
| return rrGenericVector.GenericVecType.FLOAT; |
| |
| case glsDrawTests.DrawTestSpec.OutputType.INT: |
| case glsDrawTests.DrawTestSpec.OutputType.IVEC2: |
| case glsDrawTests.DrawTestSpec.OutputType.IVEC3: |
| case glsDrawTests.DrawTestSpec.OutputType.IVEC4: |
| return rrGenericVector.GenericVecType.INT32; |
| |
| case glsDrawTests.DrawTestSpec.OutputType.UINT: |
| case glsDrawTests.DrawTestSpec.OutputType.UVEC2: |
| case glsDrawTests.DrawTestSpec.OutputType.UVEC3: |
| case glsDrawTests.DrawTestSpec.OutputType.UVEC4: |
| return rrGenericVector.GenericVecType.UINT32; |
| |
| default: |
| throw new Error('Invalid output type'); |
| } |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.OutputType} type |
| * @return {number} |
| */ |
| glsDrawTests.DrawTestShaderProgram.prototype.getComponentCount = function(type) { |
| switch (type) { |
| case glsDrawTests.DrawTestSpec.OutputType.FLOAT: |
| case glsDrawTests.DrawTestSpec.OutputType.INT: |
| case glsDrawTests.DrawTestSpec.OutputType.UINT: |
| return 1; |
| |
| case glsDrawTests.DrawTestSpec.OutputType.VEC2: |
| case glsDrawTests.DrawTestSpec.OutputType.IVEC2: |
| case glsDrawTests.DrawTestSpec.OutputType.UVEC2: |
| return 2; |
| |
| case glsDrawTests.DrawTestSpec.OutputType.VEC3: |
| case glsDrawTests.DrawTestSpec.OutputType.IVEC3: |
| case glsDrawTests.DrawTestSpec.OutputType.UVEC3: |
| return 3; |
| |
| case glsDrawTests.DrawTestSpec.OutputType.VEC4: |
| case glsDrawTests.DrawTestSpec.OutputType.IVEC4: |
| case glsDrawTests.DrawTestSpec.OutputType.UVEC4: |
| return 4; |
| |
| default: |
| throw new Error('Invalid output type'); |
| } |
| }; |
| |
| /** |
| * @param {Array<glsDrawTests.AttributeArray>} arrays |
| * @return {sglrShaderProgram.ShaderProgramDeclaration} |
| */ |
| glsDrawTests.DrawTestShaderProgram.prototype.createProgramDeclaration = function(arrays) { |
| /** @type {sglrShaderProgram.ShaderProgramDeclaration} */ var decl = new sglrShaderProgram.ShaderProgramDeclaration(); |
| |
| for (var arrayNdx = 0; arrayNdx < arrays.length; arrayNdx++) |
| decl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('a_' + arrayNdx, this.mapOutputType(arrays[arrayNdx].getOutputType()))); |
| |
| decl.pushVertexToFragmentVarying(new sglrShaderProgram.VertexToFragmentVarying(rrGenericVector.GenericVecType.FLOAT)); |
| decl.pushFragmentOutput(new sglrShaderProgram.FragmentOutput(rrGenericVector.GenericVecType.FLOAT)); |
| |
| decl.pushVertexSource(new sglrShaderProgram.VertexSource(this.genVertexSource(arrays))); |
| decl.pushFragmentSource(new sglrShaderProgram.FragmentSource(this.genFragmentSource())); |
| |
| decl.pushUniform(new sglrShaderProgram.Uniform('u_coordScale', gluShaderUtil.DataType.FLOAT)); |
| decl.pushUniform(new sglrShaderProgram.Uniform('u_colorScale', gluShaderUtil.DataType.FLOAT)); |
| |
| return decl; |
| }; |
| |
| /** |
| * @typedef {glsDrawTests.RandomArrayGenerator} |
| */ |
| glsDrawTests.RandomArrayGenerator = {}; |
| |
| /** |
| * @param {goog.TypedArray} data |
| * @param {?glsDrawTests.DrawTestSpec.InputType} type |
| * @param {deRandom.Random} rnd |
| * @param {glsDrawTests.GLValue} min |
| * @param {glsDrawTests.GLValue} max |
| */ |
| glsDrawTests.RandomArrayGenerator.setData = function(data, type, rnd, min, max) { |
| switch (type) { |
| case glsDrawTests.DrawTestSpec.InputType.FLOAT: |
| case glsDrawTests.DrawTestSpec.InputType.SHORT: |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_SHORT: |
| case glsDrawTests.DrawTestSpec.InputType.BYTE: |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_BYTE: |
| case glsDrawTests.DrawTestSpec.InputType.INT: |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT: |
| case glsDrawTests.DrawTestSpec.InputType.HALF: |
| glsDrawTests.copyGLValueToArray(data, glsDrawTests.GLValue.getRandom(rnd, min, max)); |
| break; |
| default: |
| throw new Error('Invalid input type'); |
| } |
| }; |
| |
| /** |
| * createBasicArray |
| * @param {number} seed |
| * @param {number} elementCount |
| * @param {number} componentCount |
| * @param {number} offset |
| * @param {number} stride |
| * @param {?glsDrawTests.DrawTestSpec.InputType} type |
| * @param {number} first |
| * @param {?glsDrawTests.DrawTestSpec.Primitive} primitive |
| * @param {?goog.TypedArray} indices |
| * @param {number} indexSize |
| * @return {goog.TypedArray} |
| */ |
| glsDrawTests.RandomArrayGenerator.createArray = function(seed, elementCount, componentCount, offset, stride, type, first, primitive, indices, indexSize) { |
| assertMsgOptions(componentCount >= 1 && componentCount <= 4, 'Unacceptable number of components', false, true); |
| |
| /** @type {glsDrawTests.GLValue} */ var min = glsDrawTests.GLValue.getMinValue(type); |
| /** @type {glsDrawTests.GLValue} */ var max = glsDrawTests.GLValue.getMaxValue(type); |
| |
| var packed = type == glsDrawTests.DrawTestSpec.InputType.INT_2_10_10_10 || |
| type == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT_2_10_10_10; |
| /** @type {number} */ var limit10 = (1 << 10); |
| /** @type {number} */ var limit2 = (1 << 2); |
| |
| |
| /** @type {number} */ var componentSize = glsDrawTests.DrawTestSpec.inputTypeSize(type); |
| /** @type {number} */ var elementSize = componentSize * componentCount; |
| /** @type {number} */ var bufferSize = offset + Math.max(elementCount * stride, elementCount * elementSize); |
| |
| var data = new ArrayBuffer(bufferSize); |
| var writePtr = new Uint8Array(data, offset); |
| |
| var previousComponentsFloat = [0, 0, 0, 0]; |
| var rnd = new deRandom.Random(seed); |
| |
| for (var vertexNdx = 0; vertexNdx < elementCount; vertexNdx++) { |
| var components = []; |
| |
| for (var componentNdx = 0; componentNdx < componentCount; componentNdx++) { |
| var getRandomComponent = function() { |
| // For packed formats we can't use GLValue |
| if (packed) { |
| if (componentNdx == 3) { |
| return rnd.getInt() % limit2; |
| } else { |
| return rnd.getInt() % limit10; |
| } |
| } else { |
| return glsDrawTests.GLValue.getRandom(rnd, min, max); |
| } |
| }; |
| |
| var component = getRandomComponent(); |
| var componentFloat = (component instanceof glsDrawTests.GLValue) ? component.toFloat() : component; |
| |
| // Try to not create vertex near previous |
| if (vertexNdx != 0 && Math.abs(componentFloat - previousComponentsFloat[componentNdx]) < min.toFloat()) { |
| // Too close, try again (but only once) |
| component = getRandomComponent(); |
| componentFloat = (component instanceof glsDrawTests.GLValue) ? component.toFloat() : component; |
| } |
| |
| components.push(component); |
| previousComponentsFloat[componentNdx] = componentFloat; |
| } |
| |
| if (packed) { |
| var packedValue = deMath.binaryOp( |
| deMath.shiftLeft(/** @type {Array<number>} */ (components)[3], 30), deMath.binaryOp( |
| deMath.shiftLeft(/** @type {Array<number>} */ (components)[2], 20), deMath.binaryOp( |
| deMath.shiftLeft(/** @type {Array<number>} */ (components)[1], 10), /** @type {Array<number>} */ (components)[0], deMath.BinaryOp.OR |
| ), deMath.BinaryOp.OR |
| ), deMath.BinaryOp.OR |
| ); |
| glsDrawTests.copyArray(writePtr, new Uint32Array([packedValue])); |
| } else { |
| for (var componentNdx = 0; componentNdx < componentCount; componentNdx++) { |
| glsDrawTests.copyGLValueToArray(writePtr.subarray(componentNdx * componentSize), components[componentNdx]); |
| } |
| } |
| |
| writePtr = writePtr.subarray(stride); |
| } |
| |
| return new Uint8Array(data); |
| }; |
| |
| /** |
| * @param {number} seed |
| * @param {number} elementCount |
| * @param {?glsDrawTests.DrawTestSpec.IndexType} type |
| * @param {number} offset |
| * @param {number} min |
| * @param {number} max |
| * @return {goog.TypedArray} |
| */ |
| glsDrawTests.RandomArrayGenerator.generateIndices = function(seed, elementCount, type, offset, min, max) { |
| return glsDrawTests.RandomArrayGenerator.createIndices(seed, elementCount, offset, min, max, type); |
| }; |
| |
| /** |
| * @param {number} seed |
| * @param {number} elementCount |
| * @param {number} offset |
| * @param {number} min |
| * @param {number} max |
| * @param {?glsDrawTests.DrawTestSpec.IndexType} type |
| * @return {goog.TypedArray} |
| */ |
| glsDrawTests.RandomArrayGenerator.createIndices = function(seed, elementCount, offset, min, max, type) { |
| /** @type {number}*/ var elementSize = glsDrawTests.DrawTestSpec.indexTypeSize(type); |
| /** @type {number}*/ var bufferSize = offset + elementCount * elementSize; |
| |
| var data = new ArrayBuffer(bufferSize); |
| var writePtr = new Uint8Array(data).subarray(offset); |
| |
| var rnd = new deRandom.Random(seed); |
| |
| /* TODO: get limits for given index type --> if (min < 0 || min > std::numeric_limits<T>::max() || |
| max < 0 || max > std::numeric_limits<T>::max() || |
| min > max) |
| DE_ASSERT(!"Invalid range");*/ |
| |
| // JS refrast requires shuffled unique keys |
| var keys = []; |
| for (var key = 0; key < elementCount; key++) |
| keys.push(glsDrawTests.GLValue.create(key, glsDrawTests.indexTypeToInputType(type))); |
| |
| for (var elementNdx = 0; elementNdx < elementCount; ++elementNdx) { |
| var randomkey = rnd.getInt(0, keys.length - 1); |
| var ndx = keys[randomkey]; |
| |
| keys.splice(randomkey, 1); |
| |
| glsDrawTests.copyArray( |
| writePtr.subarray(elementSize * elementNdx), |
| new Uint8Array(ndx.m_value.buffer) |
| ); |
| } |
| |
| return new Uint8Array(data); |
| }; |
| |
| /** |
| * @param {number} seed |
| * @param {?glsDrawTests.DrawTestSpec.InputType} type |
| * @return {Array<number>} |
| */ |
| glsDrawTests.RandomArrayGenerator.generateAttributeValue = function(seed, type) { |
| var random = new deRandom.Random(seed); |
| |
| switch (type) { |
| case glsDrawTests.DrawTestSpec.InputType.FLOAT: |
| return glsDrawTests.generateRandomVec4(random); |
| |
| case glsDrawTests.DrawTestSpec.InputType.INT: |
| return glsDrawTests.generateRandomIVec4(random); |
| |
| case glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT: |
| return glsDrawTests.generateRandomUVec4(random); |
| |
| default: |
| throw new Error('Invalid attribute type'); |
| } |
| }; |
| |
| // AttributePack |
| |
| /** |
| * @param {sglrReferenceContext.ReferenceContext | sglrGLContext.GLContext} drawContext |
| * @param {Array<number>} screenSize (2 positive elements in array) |
| * @param {boolean} useVao |
| * @param {boolean} logEnabled |
| * @constructor |
| */ |
| glsDrawTests.AttributePack = function(drawContext, screenSize, useVao, logEnabled) { |
| /** @type {sglrReferenceContext.ReferenceContext | sglrGLContext.GLContext} */ this.m_ctx = drawContext; |
| |
| /** @type {Array<glsDrawTests.AttributeArray>} */ this.m_arrays = []; |
| /** @type {sglrShaderProgram.ShaderProgram} */ this.m_program; |
| /** @type {tcuSurface.Surface} */ this.m_screen = new tcuSurface.Surface(screenSize[0], screenSize[1]); |
| /** @type {boolean} */ this.m_useVao = useVao; |
| /** @type {boolean} */ this.m_logEnabled = logEnabled; |
| /** @type {WebGLProgram | sglrShaderProgram.ShaderProgram | null} */ this.m_programID = null; |
| /** @type {WebGLVertexArrayObject|sglrReferenceContext.VertexArray|null} */ this.m_vaoID = null; |
| |
| if (this.m_useVao) |
| this.m_vaoID = this.m_ctx.createVertexArray(); |
| }; |
| |
| /** |
| * @return {tcuSurface.Surface} |
| */ |
| glsDrawTests.AttributePack.prototype.getSurface = function() { |
| return this.m_screen; |
| }; |
| |
| /** |
| * @param {number} i |
| * @return {glsDrawTests.AttributeArray} |
| */ |
| glsDrawTests.AttributePack.prototype.getArray = function(i) { |
| return this.m_arrays[i]; |
| }; |
| |
| /** |
| * @return number |
| */ |
| glsDrawTests.AttributePack.prototype.getArrayCount = function() { |
| return this.m_arrays.length; |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.Storage} storage |
| */ |
| glsDrawTests.AttributePack.prototype.newArray = function(storage) { |
| this.m_arrays.push(new glsDrawTests.AttributeArray(storage, this.m_ctx)); |
| }; |
| |
| /** |
| * clearArrays |
| */ |
| glsDrawTests.AttributePack.prototype.clearArrays = function() { |
| this.m_arrays.length = 0; |
| }; |
| |
| /** |
| * updateProgram |
| */ |
| glsDrawTests.AttributePack.prototype.updateProgram = function() { |
| if (this.m_programID) |
| this.m_ctx.deleteProgram(this.m_programID); |
| |
| this.m_program = new glsDrawTests.DrawTestShaderProgram(this.m_arrays); |
| this.m_programID = this.m_ctx.createProgram(this.m_program); |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.Primitive} primitive |
| * @param {?glsDrawTests.DrawTestSpec.DrawMethod} drawMethod |
| * @param {number} firstVertex |
| * @param {number} vertexCount |
| * @param {?glsDrawTests.DrawTestSpec.IndexType} indexType |
| * @param {number} indexOffset |
| * @param {number} rangeStart |
| * @param {number} rangeEnd |
| * @param {number} instanceCount |
| * @param {number} coordScale |
| * @param {number} colorScale |
| * @param {glsDrawTests.AttributeArray} indexArray |
| */ |
| glsDrawTests.AttributePack.prototype.render = function(primitive, drawMethod, firstVertex, vertexCount, indexType, |
| indexOffset, rangeStart, rangeEnd, instanceCount, coordScale, colorScale, indexArray) { |
| assertMsgOptions(this.m_program != null, 'Program is null', false, true); |
| assertMsgOptions(this.m_programID != null, 'No context created program', false, true); |
| |
| this.m_ctx.viewport(0, 0, this.m_screen.getWidth(), this.m_screen.getHeight()); |
| this.m_ctx.clearColor(0.0, 0.0, 0.0, 1.0); |
| this.m_ctx.clear(gl.COLOR_BUFFER_BIT); |
| |
| this.m_ctx.useProgram(this.m_programID); |
| |
| this.m_ctx.uniform1f(this.m_ctx.getUniformLocation(this.m_programID, 'u_coordScale'), coordScale); |
| this.m_ctx.uniform1f(this.m_ctx.getUniformLocation(this.m_programID, 'u_colorScale'), colorScale); |
| |
| if (this.m_useVao) |
| this.m_ctx.bindVertexArray(this.m_vaoID); |
| |
| if (indexArray) |
| indexArray.bindIndexArray(glsDrawTests.DrawTestSpec.Target.ELEMENT_ARRAY); |
| |
| for (var arrayNdx = 0; arrayNdx < this.m_arrays.length; arrayNdx++) { |
| var attribName = ''; |
| attribName += 'a_' + arrayNdx; |
| |
| var loc = this.m_ctx.getAttribLocation(this.m_programID, attribName); |
| |
| if (this.m_arrays[arrayNdx].isBound()) |
| this.m_ctx.enableVertexAttribArray(loc); |
| |
| this.m_arrays[arrayNdx].bindAttribute(loc); |
| } |
| |
| if (drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS) |
| this.m_ctx.drawArrays(glsDrawTests.primitiveToGL(primitive), firstVertex, vertexCount); |
| else if (drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS_INSTANCED) |
| this.m_ctx.drawArraysInstanced(glsDrawTests.primitiveToGL(primitive), firstVertex, vertexCount, instanceCount); |
| else if (drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS) |
| this.m_ctx.drawElements(glsDrawTests.primitiveToGL(primitive), vertexCount, glsDrawTests.indexTypeToGL(indexType), indexOffset); |
| else if (drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_RANGED) |
| this.m_ctx.drawRangeElements(glsDrawTests.primitiveToGL(primitive), rangeStart, rangeEnd, vertexCount, glsDrawTests.indexTypeToGL(indexType), indexOffset); |
| else if (drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_INSTANCED) |
| this.m_ctx.drawElementsInstanced(glsDrawTests.primitiveToGL(primitive), vertexCount, glsDrawTests.indexTypeToGL(indexType), indexOffset, instanceCount); |
| else |
| throw new Error('Invalid draw method'); |
| |
| for (var arrayNdx = 0; arrayNdx < this.m_arrays.length; arrayNdx++) { |
| if (this.m_arrays[arrayNdx].isBound()) { |
| var attribName = ''; |
| attribName += 'a_' + arrayNdx; |
| |
| var loc = this.m_ctx.getAttribLocation(this.m_programID, attribName); |
| |
| this.m_ctx.disableVertexAttribArray(loc); |
| } |
| } |
| |
| if (this.m_useVao) |
| this.m_ctx.bindVertexArray(null); |
| |
| this.m_ctx.useProgram(null); |
| this.m_screen.readViewport(this.m_ctx, [0 , 0, this.m_screen.getWidth(), this.m_screen.getHeight()]); |
| }; |
| |
| // DrawTestSpec |
| |
| /** |
| * @constructor |
| */ |
| glsDrawTests.DrawTestSpec = function() { |
| /** @type {?glsDrawTests.DrawTestSpec.Primitive} */ this.primitive = null; |
| /** @type {number} */ this.primitiveCount = 0; //!< number of primitives to draw (per instance) |
| |
| /** @type {?glsDrawTests.DrawTestSpec.DrawMethod} */ this.drawMethod = null; |
| /** @type {?glsDrawTests.DrawTestSpec.IndexType} */ this.indexType = null; //!< used only if drawMethod = DrawElements* |
| /** @type {number} */ this.indexPointerOffset = 0; //!< used only if drawMethod = DrawElements* |
| /** @type {?glsDrawTests.DrawTestSpec.Storage} */ this.indexStorage = null; //!< used only if drawMethod = DrawElements* |
| /** @type {number} */ this.first = 0; //!< used only if drawMethod = DrawArrays* |
| /** @type {number} */ this.indexMin = 0; //!< used only if drawMethod = Draw*Ranged |
| /** @type {number} */ this.indexMax = 0; //!< used only if drawMethod = Draw*Ranged |
| /** @type {number} */ this.instanceCount = 0; //!< used only if drawMethod = Draw*Instanced or Draw*Indirect |
| /** @type {number} */ this.indirectOffset = 0; //!< used only if drawMethod = Draw*Indirect |
| /** @type {number} */ this.baseVertex = 0; //!< used only if drawMethod = DrawElementsIndirect or *BaseVertex |
| |
| /** @type {Array<glsDrawTests.DrawTestSpec.AttributeSpec>} */ this.attribs = []; |
| }; |
| |
| /** |
| * @param {glsDrawTests.DrawTestSpec.Target} target |
| * @return {string} |
| */ |
| glsDrawTests.DrawTestSpec.targetToString = function(target) { |
| assertMsgOptions(target != null, 'Target is null', false, true); |
| |
| var targets = [ |
| 'element_array', // TARGET_ELEMENT_ARRAY = 0, |
| 'array' // TARGET_ARRAY, |
| ]; |
| assertMsgOptions(targets.length == Object.keys(glsDrawTests.DrawTestSpec.Target).length, |
| 'The amount of target names is different than the amount of targets', false, true); |
| |
| return targets[target]; |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.InputType} type |
| * @return {string} |
| */ |
| glsDrawTests.DrawTestSpec.inputTypeToString = function(type) { |
| assertMsgOptions(type != null, 'Type is null', false, true); |
| |
| var types = [ |
| 'float', // INPUTTYPE_FLOAT = 0, |
| |
| 'byte', // INPUTTYPE_BYTE, |
| 'short', // INPUTTYPE_SHORT, |
| |
| 'unsigned_byte', // INPUTTYPE_UNSIGNED_BYTE, |
| 'unsigned_short', // INPUTTYPE_UNSIGNED_SHORT, |
| |
| 'int', // INPUTTYPE_INT, |
| 'unsigned_int', // INPUTTYPE_UNSIGNED_INT, |
| 'half', // INPUTTYPE_HALF, |
| 'unsigned_int2_10_10_10', // INPUTTYPE_UNSIGNED_INT_2_10_10_10, |
| 'int2_10_10_10' // INPUTTYPE_INT_2_10_10_10, |
| ]; |
| assertMsgOptions(types.length == Object.keys(glsDrawTests.DrawTestSpec.InputType).length, |
| 'The amount of type names is different than the amount of types', false, true); |
| |
| return types[type]; |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.OutputType} type |
| * @return {string} |
| */ |
| glsDrawTests.DrawTestSpec.outputTypeToString = function(type) { |
| assertMsgOptions(type != null, 'Type is null', false, true); |
| |
| var types = [ |
| 'float', // OUTPUTTYPE_FLOAT = 0, |
| 'vec2', // OUTPUTTYPE_VEC2, |
| 'vec3', // OUTPUTTYPE_VEC3, |
| 'vec4', // OUTPUTTYPE_VEC4, |
| |
| 'int', // OUTPUTTYPE_INT, |
| 'uint', // OUTPUTTYPE_UINT, |
| |
| 'ivec2', // OUTPUTTYPE_IVEC2, |
| 'ivec3', // OUTPUTTYPE_IVEC3, |
| 'ivec4', // OUTPUTTYPE_IVEC4, |
| |
| 'uvec2', // OUTPUTTYPE_UVEC2, |
| 'uvec3', // OUTPUTTYPE_UVEC3, |
| 'uvec4' // OUTPUTTYPE_UVEC4, |
| ]; |
| assertMsgOptions(types.length == Object.keys(glsDrawTests.DrawTestSpec.OutputType).length, |
| 'The amount of type names is different than the amount of types', false, true); |
| |
| return types[type]; |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.Usage} usage |
| * @return {string} |
| */ |
| glsDrawTests.DrawTestSpec.usageTypeToString = function(usage) { |
| assertMsgOptions(usage != null, 'Usage is null', false, true); |
| |
| var usages = [ |
| 'dynamic_draw', // USAGE_DYNAMIC_DRAW = 0, |
| 'static_draw', // USAGE_STATIC_DRAW, |
| 'stream_draw', // USAGE_STREAM_DRAW, |
| |
| 'stream_read', // USAGE_STREAM_READ, |
| 'stream_copy', // USAGE_STREAM_COPY, |
| |
| 'static_read', // USAGE_STATIC_READ, |
| 'static_copy', // USAGE_STATIC_COPY, |
| |
| 'dynamic_read', // USAGE_DYNAMIC_READ, |
| 'dynamic_copy' // USAGE_DYNAMIC_COPY, |
| ]; |
| assertMsgOptions(usages.length == Object.keys(glsDrawTests.DrawTestSpec.Usage).length, |
| 'The amount of usage names is different than the amount of usages', false, true); |
| |
| return usages[usage]; |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.Storage} storage |
| * @return {string} |
| */ |
| glsDrawTests.DrawTestSpec.storageToString = function(storage) { |
| assertMsgOptions(storage != null, 'Storage is null', false, true); |
| |
| var storages = [ |
| 'user_ptr', // STORAGE_USER = 0, |
| 'buffer' // STORAGE_BUFFER, |
| ]; |
| assertMsgOptions(storages.length == Object.keys(glsDrawTests.DrawTestSpec.Storage).length, |
| 'The amount of storage names is different than the amount of storages', false, true); |
| |
| return storages[storage]; |
| }; |
| |
| /** |
| * @param {glsDrawTests.DrawTestSpec.Primitive} primitive |
| * @return {string} |
| */ |
| glsDrawTests.DrawTestSpec.primitiveToString = function(primitive) { |
| assertMsgOptions(primitive != null, 'Primitive is null', false, true); |
| |
| var primitives = [ |
| 'points', // PRIMITIVE_POINTS , |
| 'triangles', // PRIMITIVE_TRIANGLES, |
| 'triangle_fan', // PRIMITIVE_TRIANGLE_FAN, |
| 'triangle_strip', // PRIMITIVE_TRIANGLE_STRIP, |
| 'lines', // PRIMITIVE_LINES |
| 'line_strip', // PRIMITIVE_LINE_STRIP |
| 'line_loop' |
| ]; |
| assertMsgOptions(primitives.length == Object.keys(glsDrawTests.DrawTestSpec.Primitive).length, |
| 'The amount of primitive names is different than the amount of primitives', false, true); |
| |
| return primitives[primitive]; |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.IndexType} type |
| * @return {string} |
| */ |
| glsDrawTests.DrawTestSpec.indexTypeToString = function(type) { |
| assertMsgOptions(type != null, 'Index type is null', false, true); |
| |
| var indexTypes = [ |
| 'byte', // INDEXTYPE_BYTE = 0, |
| 'short', // INDEXTYPE_SHORT, |
| 'int' // INDEXTYPE_INT, |
| ]; |
| assertMsgOptions(indexTypes.length == Object.keys(glsDrawTests.DrawTestSpec.IndexType).length, |
| 'The amount of index type names is different than the amount of index types', false, true); |
| |
| return indexTypes[type]; |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.DrawMethod} method |
| * @return {string} |
| */ |
| glsDrawTests.DrawTestSpec.drawMethodToString = function(method) { |
| assertMsgOptions(method != null, 'Method is null', false, true); |
| |
| var methods = [ |
| 'draw_arrays', //!< DRAWMETHOD_DRAWARRAYS |
| 'draw_arrays_instanced', //!< DRAWMETHOD_DRAWARRAYS_INSTANCED |
| 'draw_elements', //!< DRAWMETHOD_DRAWELEMENTS |
| 'draw_range_elements', //!< DRAWMETHOD_DRAWELEMENTS_RANGED |
| 'draw_elements_instanced' //!< DRAWMETHOD_DRAWELEMENTS_INSTANCED |
| ]; |
| assertMsgOptions(methods.length == Object.keys(glsDrawTests.DrawTestSpec.DrawMethod).length, |
| 'The amount of method names is different than the amount of methods', false, true); |
| |
| return methods[method]; |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.InputType} type |
| * @return {number} |
| */ |
| glsDrawTests.DrawTestSpec.inputTypeSize = function(type) { |
| assertMsgOptions(type != null, 'Input type is null', false, true); |
| |
| var size = [ |
| 4, // INPUTTYPE_FLOAT = 0, |
| |
| 1, // INPUTTYPE_BYTE, |
| 2, // INPUTTYPE_SHORT, |
| |
| 1, // INPUTTYPE_UNSIGNED_BYTE, |
| 2, // INPUTTYPE_UNSIGNED_SHORT, |
| |
| 4, // INPUTTYPE_INT, |
| 4, // INPUTTYPE_UNSIGNED_INT, |
| 2, // INPUTTYPE_HALF, |
| 4 / 4, // INPUTTYPE_UNSIGNED_INT_2_10_10_10, |
| 4 / 4 // INPUTTYPE_INT_2_10_10_10, |
| ]; |
| assertMsgOptions(size.length == Object.keys(glsDrawTests.DrawTestSpec.InputType).length, |
| 'The amount of type names is different than the amount of types', false, true); |
| |
| return size[type]; |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.IndexType} type |
| * @return {number} |
| */ |
| glsDrawTests.DrawTestSpec.indexTypeSize = function(type) { |
| assertMsgOptions(type != null, 'Type is null', false, true); |
| |
| var size = [ |
| 1, // INDEXTYPE_BYTE, |
| 2, // INDEXTYPE_SHORT, |
| 4 // INDEXTYPE_INT, |
| ]; |
| assertMsgOptions(size.length == Object.keys(glsDrawTests.DrawTestSpec.IndexType).length, |
| 'The amount of type names is different than the amount of types', false, true); |
| |
| return size[type]; |
| }; |
| |
| /** |
| * @return {string} |
| */ |
| glsDrawTests.DrawTestSpec.prototype.getName = function() { |
| /** @type {glsDrawTests.MethodInfo} */ var methodInfo = glsDrawTests.getMethodInfo(this.drawMethod); |
| /** @type {boolean} */ var hasFirst = methodInfo.first; |
| /** @type {boolean} */ var instanced = methodInfo.instanced; |
| /** @type {boolean} */ var ranged = methodInfo.ranged; |
| /** @type {boolean} */ var indexed = methodInfo.indexed; |
| |
| var name = ''; |
| |
| for (var ndx = 0; ndx < this.attribs.length; ++ndx) { |
| /** @type {glsDrawTests.DrawTestSpec.AttributeSpec}*/ var attrib = this.attribs[ndx]; |
| |
| if (this.attribs.length > 1) |
| name += 'attrib' + ndx + '_'; |
| |
| if (ndx == 0 || attrib.additionalPositionAttribute) |
| name += 'pos_'; |
| else |
| name += 'col_'; |
| |
| if (attrib.useDefaultAttribute) { |
| name += 'non_array_' + |
| glsDrawTests.DrawTestSpec.inputTypeToString(/** @type {?glsDrawTests.DrawTestSpec.InputType} */ (attrib.inputType)) + '_' + |
| attrib.componentCount + '_' + |
| glsDrawTests.DrawTestSpec.outputTypeToString(attrib.outputType) + '_'; |
| } else { |
| name += glsDrawTests.DrawTestSpec.storageToString(attrib.storage) + '_' + |
| attrib.offset + '_' + |
| attrib.stride + '_' + |
| glsDrawTests.DrawTestSpec.inputTypeToString(/** @type {?glsDrawTests.DrawTestSpec.InputType} */ (attrib.inputType)); |
| if (attrib.inputType != glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT_2_10_10_10 && attrib.inputType != glsDrawTests.DrawTestSpec.InputType.INT_2_10_10_10) |
| name += attrib.componentCount; |
| name += '_' + |
| (attrib.normalize ? 'normalized_' : '') + |
| glsDrawTests.DrawTestSpec.outputTypeToString(attrib.outputType) + '_' + |
| glsDrawTests.DrawTestSpec.usageTypeToString(attrib.usage) + '_' + |
| attrib.instanceDivisor + '_'; |
| } |
| } |
| |
| if (indexed) |
| name += 'index_' + glsDrawTests.DrawTestSpec.indexTypeToString(this.indexType) + '_' + |
| glsDrawTests.DrawTestSpec.storageToString(this.indexStorage) + '_' + |
| 'offset' + this.indexPointerOffset + '_'; |
| if (hasFirst) |
| name += 'first' + this.first + '_'; |
| if (ranged) |
| name += 'ranged_' + this.indexMin + '_' + this.indexMax + '_'; |
| if (instanced) |
| name += 'instances' + this.instanceCount + '_'; |
| |
| switch (this.primitive) { |
| case glsDrawTests.DrawTestSpec.Primitive.POINTS: |
| name += 'points_'; |
| break; |
| case glsDrawTests.DrawTestSpec.Primitive.TRIANGLES: |
| name += 'triangles_'; |
| break; |
| case glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_FAN: |
| name += 'triangle_fan_'; |
| break; |
| case glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_STRIP: |
| name += 'triangle_strip_'; |
| break; |
| case glsDrawTests.DrawTestSpec.Primitive.LINES: |
| name += 'lines_'; |
| break; |
| case glsDrawTests.DrawTestSpec.Primitive.LINE_STRIP: |
| name += 'line_strip_'; |
| break; |
| case glsDrawTests.DrawTestSpec.Primitive.LINE_LOOP: |
| name += 'line_loop_'; |
| break; |
| default: |
| throw new Error('Invalid primitive'); |
| break; |
| } |
| |
| name += this.primitiveCount; |
| |
| return name; |
| }; |
| |
| /** |
| * @return {string} |
| */ |
| glsDrawTests.DrawTestSpec.prototype.getDesc = function() { |
| var desc = ''; |
| |
| for (var ndx = 0; ndx < this.attribs.length; ++ndx) { |
| /** @type {glsDrawTests.DrawTestSpec.AttributeSpec} */ var attrib = this.attribs[ndx]; |
| |
| if (attrib.useDefaultAttribute) { |
| desc += 'Attribute ' + ndx + ': default, ' + ((ndx == 0 || attrib.additionalPositionAttribute) ? ('position ,') : ('color ,')) + |
| 'input datatype ' + glsDrawTests.DrawTestSpec.inputTypeToString(/** @type {?glsDrawTests.DrawTestSpec.InputType} */ (attrib.inputType)) + ', ' + |
| 'input component count ' + attrib.componentCount + ', ' + |
| 'used as ' + glsDrawTests.DrawTestSpec.outputTypeToString(attrib.outputType) + ', '; |
| } else { |
| desc += 'Attribute ' + ndx + ': ' + ((ndx == 0 || attrib.additionalPositionAttribute) ? ('position ,') : ('color ,')) + |
| 'Storage in ' + glsDrawTests.DrawTestSpec.storageToString(attrib.storage) + ', ' + |
| 'stride ' + attrib.stride + ', ' + |
| 'input datatype ' + glsDrawTests.DrawTestSpec.inputTypeToString(/** @type {?glsDrawTests.DrawTestSpec.InputType} */ (attrib.inputType)) + ', ' + |
| 'input component count ' + attrib.componentCount + ', ' + |
| (attrib.normalize ? 'normalized, ' : '') + |
| 'used as ' + glsDrawTests.DrawTestSpec.outputTypeToString(attrib.outputType) + ', ' + |
| 'instance divisor ' + attrib.instanceDivisor + ', '; |
| } |
| } |
| |
| if (this.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS) { |
| desc += 'drawArrays(), ' + |
| 'first ' + this.first + ', '; |
| } else if (this.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS_INSTANCED) { |
| desc += 'drawArraysInstanced(), ' + |
| 'first ' + this.first + ', ' + |
| 'instance count ' + this.instanceCount + ', '; |
| } else if (this.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS) { |
| desc += 'drawElements(), ' + |
| 'index type ' + glsDrawTests.DrawTestSpec.indexTypeToString(this.indexType) + ', ' + |
| 'index storage in ' + glsDrawTests.DrawTestSpec.storageToString(this.indexStorage) + ', ' + |
| 'index offset ' + this.indexPointerOffset + ', '; |
| } else if (this.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_RANGED) { |
| desc += 'drawElementsRanged(), ' + |
| 'index type ' + glsDrawTests.DrawTestSpec.indexTypeToString(this.indexType) + ', ' + |
| 'index storage in ' + glsDrawTests.DrawTestSpec.storageToString(this.indexStorage) + ', ' + |
| 'index offset ' + this.indexPointerOffset + ', ' + |
| 'range start ' + this.indexMin + ', ' + |
| 'range end ' + this.indexMax + ', '; |
| } else if (this.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_INSTANCED) { |
| desc += 'drawElementsInstanced(), ' + |
| 'index type ' + glsDrawTests.DrawTestSpec.indexTypeToString(this.indexType) + ', ' + |
| 'index storage in ' + glsDrawTests.DrawTestSpec.storageToString(this.indexStorage) + ', ' + |
| 'index offset ' + this.indexPointerOffset + ', ' + |
| 'instance count ' + this.instanceCount + ', '; |
| } else |
| throw new Error('Invalid draw method'); |
| |
| desc += this.primitiveCount; |
| |
| switch (this.primitive) { |
| case glsDrawTests.DrawTestSpec.Primitive.POINTS: |
| desc += 'points'; |
| break; |
| case glsDrawTests.DrawTestSpec.Primitive.TRIANGLES: |
| desc += 'triangles'; |
| break; |
| case glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_FAN: |
| desc += 'triangles (fan)'; |
| break; |
| case glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_STRIP: |
| desc += 'triangles (strip)'; |
| break; |
| case glsDrawTests.DrawTestSpec.Primitive.LINES: |
| desc += 'lines'; |
| break; |
| case glsDrawTests.DrawTestSpec.Primitive.LINE_STRIP: |
| desc += 'lines (strip)'; |
| break; |
| case glsDrawTests.DrawTestSpec.Primitive.LINE_LOOP: |
| desc += 'lines (loop)'; |
| break; |
| default: |
| throw new Error('Invalid primitive'); |
| break; |
| } |
| |
| return desc; |
| }; |
| |
| /** |
| * @return {string} |
| */ |
| glsDrawTests.DrawTestSpec.prototype.getMultilineDesc = function() { |
| var desc = ''; |
| |
| for (var ndx = 0; ndx < this.attribs.length; ++ndx) { |
| /** @type {glsDrawTests.DrawTestSpec.AttributeSpec} */ var attrib = this.attribs[ndx]; |
| |
| if (attrib.useDefaultAttribute) { |
| desc += 'Attribute ' + ndx + ': default, ' + ((ndx == 0 || attrib.additionalPositionAttribute) ? ('position\n') : ('color\n')) + |
| '\tinput datatype ' + glsDrawTests.DrawTestSpec.inputTypeToString(/** @type {?glsDrawTests.DrawTestSpec.InputType} */ (attrib.inputType)) + '\n' + |
| '\tinput component count ' + attrib.componentCount + '\n' + |
| '\tused as ' + glsDrawTests.DrawTestSpec.outputTypeToString(attrib.outputType) + '\n'; |
| } else { |
| desc += 'Attribute ' + ndx + ': ' + ((ndx == 0 || attrib.additionalPositionAttribute) ? ('position\n') : ('color\n')) + |
| '\tStorage in ' + glsDrawTests.DrawTestSpec.storageToString(attrib.storage) + '\n' + |
| '\tstride ' + attrib.stride + '\n' + |
| '\tinput datatype ' + glsDrawTests.DrawTestSpec.inputTypeToString(/** @type {?glsDrawTests.DrawTestSpec.InputType} */ (attrib.inputType)) + '\n' + |
| '\tinput component count ' + attrib.componentCount + '\n' + |
| (attrib.normalize ? '\tnormalized\n' : '') + |
| '\tused as ' + glsDrawTests.DrawTestSpec.outputTypeToString(attrib.outputType) + '\n' + |
| '\tinstance divisor ' + attrib.instanceDivisor + '\n'; |
| } |
| } |
| |
| if (this.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS) { |
| desc += 'drawArrays()\n' + |
| '\tfirst ' + this.first + '\n'; |
| } else if (this.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWARRAYS_INSTANCED) { |
| desc += 'drawArraysInstanced()\n' + |
| '\tfirst ' + this.first + '\n' + |
| '\tinstance count ' + this.instanceCount + '\n'; |
| } else if (this.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS) { |
| desc += 'drawElements()\n' + |
| '\tindex type ' + glsDrawTests.DrawTestSpec.indexTypeToString(this.indexType) + '\n' + |
| '\tindex storage in ' + glsDrawTests.DrawTestSpec.storageToString(this.indexStorage) + '\n' + |
| '\tindex offset ' + this.indexPointerOffset + '\n'; |
| } else if (this.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_RANGED) { |
| desc += 'drawElementsRanged()\n' + |
| '\tindex type ' + glsDrawTests.DrawTestSpec.indexTypeToString(this.indexType) + '\n' + |
| '\tindex storage in ' + glsDrawTests.DrawTestSpec.storageToString(this.indexStorage) + '\n' + |
| '\tindex offset ' + this.indexPointerOffset + '\n' + |
| '\trange start ' + this.indexMin + '\n' + |
| '\trange end ' + this.indexMax + '\n'; |
| } else if (this.drawMethod == glsDrawTests.DrawTestSpec.DrawMethod.DRAWELEMENTS_INSTANCED) { |
| desc += 'drawElementsInstanced()\n' + |
| '\tindex type ' + glsDrawTests.DrawTestSpec.indexTypeToString(this.indexType) + '\n' + |
| '\tindex storage in ' + glsDrawTests.DrawTestSpec.storageToString(this.indexStorage) + '\n' + |
| '\tindex offset ' + this.indexPointerOffset + '\n' + |
| '\tinstance count ' + this.instanceCount + '\n'; |
| } else |
| throw new Error('Invalid draw method'); |
| |
| desc += '\t' + this.primitiveCount + ' '; |
| |
| switch (this.primitive) { |
| case glsDrawTests.DrawTestSpec.Primitive.POINTS: |
| desc += 'points'; |
| break; |
| case glsDrawTests.DrawTestSpec.Primitive.TRIANGLES: |
| desc += 'triangles'; |
| break; |
| case glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_FAN: |
| desc += 'triangles (fan)'; |
| break; |
| case glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_STRIP: |
| desc += 'triangles (strip)'; |
| break; |
| case glsDrawTests.DrawTestSpec.Primitive.LINES: |
| desc += 'lines'; |
| break; |
| case glsDrawTests.DrawTestSpec.Primitive.LINE_STRIP: |
| desc += 'lines (strip)'; |
| break; |
| case glsDrawTests.DrawTestSpec.Primitive.LINE_LOOP: |
| desc += 'lines (loop)'; |
| break; |
| default: |
| throw new Error('Invalid primitive'); |
| break; |
| } |
| |
| desc += '\n'; |
| |
| return desc; |
| }; |
| |
| /** |
| * @enum {number} |
| */ |
| glsDrawTests.DrawTestSpec.Target = { |
| ELEMENT_ARRAY: 0, |
| ARRAY: 1 |
| }; |
| |
| /** |
| * @enum {number} |
| */ |
| glsDrawTests.DrawTestSpec.InputType = { |
| FLOAT: 0, |
| |
| BYTE: 1, |
| SHORT: 2, |
| |
| UNSIGNED_BYTE: 3, |
| UNSIGNED_SHORT: 4, |
| |
| INT: 5, |
| UNSIGNED_INT: 6, |
| HALF: 7, |
| UNSIGNED_INT_2_10_10_10: 8, |
| INT_2_10_10_10: 9 |
| }; |
| |
| /** |
| * @enum {number} |
| */ |
| glsDrawTests.DrawTestSpec.OutputType = { |
| FLOAT: 0, |
| VEC2: 1, |
| VEC3: 2, |
| VEC4: 3, |
| |
| INT: 4, |
| UINT: 5, |
| |
| IVEC2: 6, |
| IVEC3: 7, |
| IVEC4: 8, |
| |
| UVEC2: 9, |
| UVEC3: 10, |
| UVEC4: 11 |
| }; |
| |
| /** |
| * @enum {number} |
| */ |
| glsDrawTests.DrawTestSpec.Usage = { |
| DYNAMIC_DRAW: 0, |
| STATIC_DRAW: 1, |
| STREAM_DRAW: 2, |
| |
| STREAM_READ: 3, |
| STREAM_COPY: 4, |
| |
| STATIC_READ: 5, |
| STATIC_COPY: 6, |
| |
| DYNAMIC_READ: 7, |
| DYNAMIC_COPY: 8 |
| }; |
| |
| /** |
| * @enum {number} |
| */ |
| glsDrawTests.DrawTestSpec.Storage = { |
| USER: 0, |
| BUFFER: 1 |
| }; |
| |
| /** |
| * @enum {number} |
| */ |
| glsDrawTests.DrawTestSpec.Primitive = { |
| POINTS: 0, |
| TRIANGLES: 1, |
| TRIANGLE_FAN: 2, |
| TRIANGLE_STRIP: 3, |
| LINES: 4, |
| LINE_STRIP: 5, |
| LINE_LOOP: 6 |
| }; |
| |
| /** |
| * @enum {number} |
| */ |
| glsDrawTests.DrawTestSpec.IndexType = { |
| BYTE: 0, |
| SHORT: 1, |
| INT: 2 |
| }; |
| |
| /** |
| * @enum {number} |
| */ |
| glsDrawTests.DrawTestSpec.DrawMethod = { |
| DRAWARRAYS: 0, |
| DRAWARRAYS_INSTANCED: 1, |
| DRAWELEMENTS: 2, |
| DRAWELEMENTS_RANGED: 3, |
| DRAWELEMENTS_INSTANCED: 4 |
| }; |
| |
| /** |
| * @enum {number} |
| */ |
| glsDrawTests.DrawTestSpec.CompatibilityTestType = { |
| NONE: 0, |
| UNALIGNED_OFFSET: 1, |
| UNALIGNED_STRIDE: 2 |
| }; |
| |
| /** |
| * @return {number} |
| */ |
| glsDrawTests.DrawTestSpec.prototype.hash = function() { |
| // Use only drawmode-relevant values in "hashing" as the unrelevant values might not be set (causing non-deterministic behavior). |
| /** @type {glsDrawTests.MethodInfo} */ var methodInfo = glsDrawTests.getMethodInfo(this.drawMethod); |
| /** @type {boolean} */ var arrayed = methodInfo.first; |
| /** @type {boolean} */ var instanced = methodInfo.instanced; |
| /** @type {boolean} */ var ranged = methodInfo.ranged; |
| /** @type {boolean} */ var indexed = methodInfo.indexed; |
| |
| /** @type {number} */ var indexHash = (!indexed) ? (0) : (this.indexType + 10 * this.indexPointerOffset + 100 * this.indexStorage); |
| /** @type {number} */ var arrayHash = (!arrayed) ? (0) : (this.first); |
| /** @type {number} */ var indexRangeHash = (!ranged) ? (0) : (this.indexMin + 10 * this.indexMax); |
| /** @type {number} */ var instanceHash = (!instanced) ? (0) : (this.instanceCount); |
| /** @type {number} */ var basicHash = this.primitive + 10 * this.primitiveCount + 100 * this.drawMethod; |
| |
| return indexHash + 3 * arrayHash + 5 * indexRangeHash + 7 * instanceHash + 13 * basicHash + 17 * this.attribs.length + 19 * this.primitiveCount; |
| }; |
| |
| /** |
| * @return {boolean} |
| */ |
| glsDrawTests.DrawTestSpec.prototype.valid = function() { |
| assertMsgOptions(this.primitive != null, 'Primitive is null', false, true); |
| assertMsgOptions(this.drawMethod != null, 'Draw method is null', false, true); |
| |
| var methodInfo = glsDrawTests.getMethodInfo(this.drawMethod); |
| |
| if (methodInfo.ranged) { |
| var maxIndexValue = 0; |
| if (this.indexType == glsDrawTests.DrawTestSpec.IndexType.BYTE) |
| maxIndexValue = glsDrawTests.GLValue.getMaxValue(glsDrawTests.DrawTestSpec.InputType.UNSIGNED_BYTE).interpret(); |
| else if (this.indexType == glsDrawTests.DrawTestSpec.IndexType.SHORT) |
| maxIndexValue = glsDrawTests.GLValue.getMaxValue(glsDrawTests.DrawTestSpec.InputType.UNSIGNED_SHORT).interpret(); |
| else if (this.indexType == glsDrawTests.DrawTestSpec.IndexType.INT) |
| maxIndexValue = glsDrawTests.GLValue.getMaxValue(glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT).interpret(); |
| else |
| throw new Error('Invalid index type'); |
| |
| if (this.indexMin > this.indexMax) |
| return false; |
| if (this.indexMin < 0 || this.indexMax < 0) |
| return false; |
| if (this.indexMin > maxIndexValue || this.indexMax > maxIndexValue) |
| return false; |
| } |
| |
| if (methodInfo.first && this.first < 0) |
| return false; |
| |
| return true; |
| }; |
| |
| /** |
| * @return {glsDrawTests.DrawTestSpec.CompatibilityTestType} |
| */ |
| glsDrawTests.DrawTestSpec.prototype.isCompatibilityTest = function() { |
| var methodInfo = glsDrawTests.getMethodInfo(this.drawMethod); |
| |
| var bufferAlignmentBad = false; |
| var strideAlignmentBad = false; |
| |
| // Attribute buffer alignment |
| for (var ndx = 0; ndx < this.attribs.length; ++ndx) |
| if (!this.attribs[ndx].isBufferAligned()) |
| bufferAlignmentBad = true; |
| |
| // Attribute stride alignment |
| for (var ndx = 0; ndx < this.attribs.length; ++ndx) |
| if (!this.attribs[ndx].isBufferStrideAligned()) |
| strideAlignmentBad = true; |
| |
| // Index buffer alignment |
| if (methodInfo.indexed) { |
| if (this.indexStorage == glsDrawTests.DrawTestSpec.Storage.BUFFER) { |
| var indexSize = 0; |
| if (this.indexType == glsDrawTests.DrawTestSpec.IndexType.BYTE) |
| indexSize = 1; |
| else if (this.indexType == glsDrawTests.DrawTestSpec.IndexType.SHORT) |
| indexSize = 2; |
| else if (this.indexType == glsDrawTests.DrawTestSpec.IndexType.INT) |
| indexSize = 4; |
| else |
| throw new Error(''); |
| |
| if (this.indexPointerOffset % indexSize != 0) |
| bufferAlignmentBad = true; |
| } |
| } |
| |
| // \note combination bad alignment & stride is treated as bad offset |
| if (bufferAlignmentBad) |
| return glsDrawTests.DrawTestSpec.CompatibilityTestType.UNALIGNED_OFFSET; |
| else if (strideAlignmentBad) |
| return glsDrawTests.DrawTestSpec.CompatibilityTestType.UNALIGNED_STRIDE; |
| else |
| return glsDrawTests.DrawTestSpec.CompatibilityTestType.NONE; |
| }; |
| |
| // DrawTestSpec.AttributeSpec |
| |
| /** |
| * @constructor |
| */ |
| glsDrawTests.DrawTestSpec.AttributeSpec = function() { |
| /** @type {?glsDrawTests.DrawTestSpec.InputType} */ this.inputType = null; |
| /** @type {?glsDrawTests.DrawTestSpec.OutputType} */ this.outputType = null; |
| /** @type {?glsDrawTests.DrawTestSpec.Storage} */ this.storage = glsDrawTests.DrawTestSpec.Storage.BUFFER; //Always BUFFER in WebGL up to 2 |
| /** @type {?glsDrawTests.DrawTestSpec.Usage} */ this.usage = null; |
| /** @type {number} */ this.componentCount = 0; |
| /** @type {number} */ this.offset = 0; |
| /** @type {number} */ this.stride = 0; |
| /** @type {boolean} */ this.normalize = false; |
| /** @type {number} */ this.instanceDivisor = 0; //!< used only if drawMethod = Draw*Instanced |
| /** @type {boolean} */ this.useDefaultAttribute = false; |
| |
| /** @type {boolean} */ this.additionalPositionAttribute = false; //!< treat this attribute as position attribute. Attribute at index 0 is alway treated as such. False by default |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.InputType} inputType |
| * @param {?glsDrawTests.DrawTestSpec.OutputType} outputType |
| * @param {?glsDrawTests.DrawTestSpec.Storage} storage |
| * @param {?glsDrawTests.DrawTestSpec.Usage} usage |
| * @param {number} componentCount |
| * @param {number} offset |
| * @param {number} stride |
| * @param {boolean} normalize |
| * @param {number} instanceDivisor |
| * @return {glsDrawTests.DrawTestSpec.AttributeSpec} |
| */ |
| glsDrawTests.DrawTestSpec.AttributeSpec.createAttributeArray = function(inputType, outputType, storage, usage, componentCount, |
| offset, stride, normalize, instanceDivisor) { |
| /** @type {glsDrawTests.DrawTestSpec.AttributeSpec} */ var spec; |
| |
| spec.inputType = inputType; |
| spec.outputType = outputType; |
| spec.storage = storage; |
| spec.usage = usage; |
| spec.componentCount = componentCount; |
| spec.offset = offset; |
| spec.stride = stride; |
| spec.normalize = normalize; |
| spec.instanceDivisor = instanceDivisor; |
| |
| spec.useDefaultAttribute = false; |
| |
| return spec; |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.InputType} inputType |
| * @param {?glsDrawTests.DrawTestSpec.OutputType} outputType |
| * @param {number} componentCount |
| * @return {glsDrawTests.DrawTestSpec.AttributeSpec} |
| */ |
| glsDrawTests.DrawTestSpec.AttributeSpec.createDefaultAttribute = function(inputType, outputType, componentCount) { |
| assertMsgOptions(inputType == glsDrawTests.DrawTestSpec.InputType.INT || inputType == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT || inputType == glsDrawTests.DrawTestSpec.InputType.FLOAT, 'Invalid input type', false, true); |
| assertMsgOptions(inputType == glsDrawTests.DrawTestSpec.InputType.FLOAT || componentCount == 4, 'If not float, input type should have 4 components', false, true); |
| |
| /** @type {glsDrawTests.DrawTestSpec.AttributeSpec} */ var spec; |
| |
| spec.inputType = inputType; |
| spec.outputType = outputType; |
| spec.storage = glsDrawTests.DrawTestSpec.Storage.BUFFER; //Always BUFFER in WebGL up to 2 |
| spec.usage = null; |
| spec.componentCount = componentCount; |
| spec.offset = 0; |
| spec.stride = 0; |
| spec.normalize = false; |
| spec.instanceDivisor = 0; |
| |
| spec.useDefaultAttribute = true; |
| |
| return spec; |
| }; |
| |
| /** |
| * @return {number} |
| */ |
| glsDrawTests.DrawTestSpec.AttributeSpec.prototype.hash = function() { |
| if (this.useDefaultAttribute) { |
| return 1 * this.inputType + 7 * this.outputType + 13 * this.componentCount; |
| } else { |
| return 1 * this.inputType + 2 * this.outputType + 3 * this.storage + 5 * this.usage + 7 * this.componentCount + 11 * this.offset + 13 * this.stride + 17 * (this.normalize ? 0 : 1) + 19 * this.instanceDivisor; |
| } |
| }; |
| |
| /** |
| * @return {boolean} |
| */ |
| glsDrawTests.DrawTestSpec.AttributeSpec.prototype.valid = function(/*ctxType*/) { |
| /** @type {boolean} */ var inputTypeFloat = this.inputType == glsDrawTests.DrawTestSpec.InputType.FLOAT || this.inputType == glsDrawTests.DrawTestSpec.InputType.HALF; |
| /** @type {boolean} */ var inputTypeUnsignedInteger = this.inputType == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_BYTE || this.inputType == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_SHORT || this.inputType == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT || this.inputType == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT_2_10_10_10; |
| /** @type {boolean} */ var inputTypeSignedInteger = this.inputType == glsDrawTests.DrawTestSpec.InputType.BYTE || this.inputType == glsDrawTests.DrawTestSpec.InputType.SHORT || this.inputType == glsDrawTests.DrawTestSpec.InputType.INT || this.inputType == glsDrawTests.DrawTestSpec.InputType.INT_2_10_10_10; |
| /** @type {boolean} */ var inputTypePacked = this.inputType == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT_2_10_10_10 || this.inputType == glsDrawTests.DrawTestSpec.InputType.INT_2_10_10_10; |
| |
| /** @type {boolean} */ var outputTypeFloat = this.outputType == glsDrawTests.DrawTestSpec.OutputType.FLOAT || this.outputType == glsDrawTests.DrawTestSpec.OutputType.VEC2 || this.outputType == glsDrawTests.DrawTestSpec.OutputType.VEC3 || this.outputType == glsDrawTests.DrawTestSpec.OutputType.VEC4; |
| /** @type {boolean} */ var outputTypeSignedInteger = this.outputType == glsDrawTests.DrawTestSpec.OutputType.INT || this.outputType == glsDrawTests.DrawTestSpec.OutputType.IVEC2 || this.outputType == glsDrawTests.DrawTestSpec.OutputType.IVEC3 || this.outputType == glsDrawTests.DrawTestSpec.OutputType.IVEC4; |
| /** @type {boolean} */ var outputTypeUnsignedInteger = this.outputType == glsDrawTests.DrawTestSpec.OutputType.UINT || this.outputType == glsDrawTests.DrawTestSpec.OutputType.UVEC2 || this.outputType == glsDrawTests.DrawTestSpec.OutputType.UVEC3 || this.outputType == glsDrawTests.DrawTestSpec.OutputType.UVEC4; |
| |
| if (this.useDefaultAttribute) { |
| if (this.inputType != glsDrawTests.DrawTestSpec.InputType.INT && this.inputType != glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT && this.inputType != glsDrawTests.DrawTestSpec.InputType.FLOAT) |
| return false; |
| |
| if (this.inputType != glsDrawTests.DrawTestSpec.InputType.FLOAT && this.componentCount != 4) |
| return false; |
| |
| // no casting allowed (undefined results) |
| if (this.inputType == glsDrawTests.DrawTestSpec.InputType.INT && !outputTypeSignedInteger) |
| return false; |
| if (this.inputType == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT && !outputTypeUnsignedInteger) |
| return false; |
| } |
| |
| if (inputTypePacked && this.componentCount != 4) |
| return false; |
| |
| // Invalid conversions: |
| |
| // float -> [u]int |
| if (inputTypeFloat && !outputTypeFloat) |
| return false; |
| |
| // uint -> int (undefined results) |
| if (inputTypeUnsignedInteger && outputTypeSignedInteger) |
| return false; |
| |
| // int -> uint (undefined results) |
| if (inputTypeSignedInteger && outputTypeUnsignedInteger) |
| return false; |
| |
| // packed -> non-float (packed formats are converted to floats) |
| if (inputTypePacked && !outputTypeFloat) |
| return false; |
| |
| // Invalid normalize. Normalize is only valid if output type is float |
| if (this.normalize && !outputTypeFloat) |
| return false; |
| |
| return true; |
| }; |
| |
| /** |
| * @return {boolean} |
| */ |
| glsDrawTests.DrawTestSpec.AttributeSpec.prototype.isBufferAligned = function() { |
| var inputTypePacked = this.inputType == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT_2_10_10_10 || this.inputType == glsDrawTests.DrawTestSpec.InputType.INT_2_10_10_10; |
| |
| // Buffer alignment, offset is a multiple of underlying data type size? |
| if (this.storage == glsDrawTests.DrawTestSpec.Storage.BUFFER) { |
| var dataTypeSize = glsDrawTests.DrawTestSpec.inputTypeSize(this.inputType); |
| if (inputTypePacked) |
| dataTypeSize = 4; |
| |
| if (this.offset % dataTypeSize != 0) |
| return false; |
| } |
| |
| return true; |
| }; |
| |
| /** |
| * @return {boolean} |
| */ |
| glsDrawTests.DrawTestSpec.AttributeSpec.prototype.isBufferStrideAligned = function() { |
| var inputTypePacked = this.inputType == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT_2_10_10_10 || this.inputType == glsDrawTests.DrawTestSpec.InputType.INT_2_10_10_10; |
| |
| // Buffer alignment, offset is a multiple of underlying data type size? |
| if (this.storage == glsDrawTests.DrawTestSpec.Storage.BUFFER) { |
| var dataTypeSize = glsDrawTests.DrawTestSpec.inputTypeSize(this.inputType); |
| if (inputTypePacked) |
| dataTypeSize = 4; |
| |
| if (this.stride % dataTypeSize != 0) |
| return false; |
| } |
| |
| return true; |
| }; |
| |
| /** |
| * @constructor |
| * @extends {tcuTestCase.DeqpTest} |
| * @param {glsDrawTests.DrawTestSpec} spec |
| * @param {string} name |
| * @param {string} desc |
| */ |
| glsDrawTests.DrawTest = function(spec, name, desc) { |
| tcuTestCase.DeqpTest.call(this, name, desc, spec); |
| |
| /** @type {WebGL2RenderingContext} */ this.m_renderCtx = gl; |
| /** @type {tcuPixelFormat.PixelFormat} */ this.m_pixelformat = new tcuPixelFormat.PixelFormat( |
| /** @type {number} */ (gl.getParameter(gl.RED_BITS)), /** @type {number} */ (gl.getParameter(gl.GREEN_BITS)), |
| /** @type {number} */ (gl.getParameter(gl.BLUE_BITS)), /** @type {number} */ (gl.getParameter(gl.ALPHA_BITS)) |
| ); |
| |
| /** @type {sglrReferenceContext.ReferenceContextBuffers} */ this.m_refBuffers = null; |
| /** @type {sglrReferenceContext.ReferenceContext} */ this.m_refContext = null; |
| /** @type {sglrGLContext.GLContext} */ this.m_glesContext = null; |
| |
| /** @type {glsDrawTests.AttributePack} */ this.m_glArrayPack = null; |
| /** @type {glsDrawTests.AttributePack} */ this.m_rrArrayPack = null; |
| |
| /** @type {number} */ this.m_maxDiffRed = -1; |
| /** @type {number} */ this.m_maxDiffGreen = -1; |
| /** @type {number} */ this.m_maxDiffBlue = -1; |
| |
| /** @type {Array<glsDrawTests.DrawTestSpec>} */ this.m_specs = []; |
| /** @type {Array<string>} */this.m_iteration_descriptions = []; |
| /** @type {number} */ this.m_iteration = 0; |
| |
| if (spec) |
| this.addIteration(spec); |
| }; |
| |
| glsDrawTests.DrawTest.prototype = Object.create(tcuTestCase.DeqpTest.prototype); |
| glsDrawTests.DrawTest.prototype.constructor = glsDrawTests.DrawTest; |
| |
| /** |
| * @param {glsDrawTests.DrawTestSpec} spec |
| * @param {string=} description |
| */ |
| glsDrawTests.DrawTest.prototype.addIteration = function(spec, description) { |
| // Validate spec |
| /** @type {boolean} */ var validSpec = spec.valid(); |
| |
| if (!validSpec) |
| return; |
| |
| this.m_specs.push(spec); |
| |
| if (description) |
| this.m_iteration_descriptions.push(description); |
| else |
| this.m_iteration_descriptions.push(''); |
| }; |
| |
| /** |
| * init |
| */ |
| glsDrawTests.DrawTest.prototype.init = function() { |
| var renderTargetWidth = Math.min(glsDrawTests.MAX_RENDER_TARGET_SIZE, gl.canvas.width); |
| var renderTargetHeight = Math.min(glsDrawTests.MAX_RENDER_TARGET_SIZE, gl.canvas.height); |
| /** @type {sglrReferenceContext.ReferenceContextLimits} */ var limits = new sglrReferenceContext.ReferenceContextLimits(gl); |
| /** @type {boolean} */ var useVao = true; |
| |
| this.m_glesContext = new sglrGLContext.GLContext(gl); |
| |
| assertMsgOptions(this.m_specs.length > 0, 'Specs is empty', false, true); |
| |
| this.m_refBuffers = new sglrReferenceContext.ReferenceContextBuffers(this.m_pixelformat, 0, 0, renderTargetWidth, renderTargetHeight); |
| this.m_refContext = new sglrReferenceContext.ReferenceContext(limits, this.m_refBuffers.getColorbuffer(), this.m_refBuffers.getDepthbuffer(), this.m_refBuffers.getStencilbuffer()); |
| |
| this.m_glArrayPack = new glsDrawTests.AttributePack(this.m_glesContext, [renderTargetWidth, renderTargetHeight], useVao, true); |
| this.m_rrArrayPack = new glsDrawTests.AttributePack(this.m_refContext, [renderTargetWidth, renderTargetHeight], useVao, false); |
| |
| this.m_maxDiffRed = Math.ceil(256.0 * (15.0 / (1 << this.m_pixelformat.redBits))); |
| this.m_maxDiffGreen = Math.ceil(256.0 * (15.0 / (1 << this.m_pixelformat.greenBits))); |
| this.m_maxDiffBlue = Math.ceil(256.0 * (15.0 / (1 << this.m_pixelformat.blueBits))); |
| }; |
| |
| /** |
| * @return {tcuTestCase.IterateResult} |
| */ |
| glsDrawTests.DrawTest.prototype.iterate = function() { |
| var specNdx = Math.floor(this.m_iteration / 2); |
| var drawStep = (this.m_iteration % 2) == 0; |
| var compareStep = (this.m_iteration % 2) == 1; |
| /** @type {tcuTestCase.IterateResult} */ var iterateResult = (this.m_iteration + 1 == this.m_specs.length * 2) ? (tcuTestCase.IterateResult.STOP) : (tcuTestCase.IterateResult.CONTINUE); |
| /** @type {glsDrawTests.DrawTestSpec} */ var spec = this.m_specs[specNdx]; |
| var updateProgram = (this.m_iteration == 0) || (drawStep && !glsDrawTests.checkSpecsShaderCompatible(this.m_specs[specNdx], this.m_specs[specNdx - 1])); // try to use the same shader in all iterations |
| |
| if (drawStep && this.m_specs.length != 1) |
| debug('Iteration ' + specNdx + ' of ' + (this.m_specs.length - 1) + ': ' + this.m_iteration_descriptions[specNdx]); |
| |
| this.m_iteration++; |
| |
| if (drawStep) { |
| /** @type {glsDrawTests.MethodInfo} */ var methodInfo = glsDrawTests.getMethodInfo(spec.drawMethod); |
| /** @type {boolean} */ var indexed = methodInfo.indexed; |
| /** @type {boolean} */ var instanced = methodInfo.instanced; |
| /** @type {boolean} */ var ranged = methodInfo.ranged; |
| /** @type {boolean} */ var hasFirst = methodInfo.first; |
| |
| /** @type {number} */ var primitiveElementCount = glsDrawTests.getElementCount(spec.primitive, spec.primitiveCount); // !< elements to be drawn |
| /** @type {number} */ var indexMin = (ranged) ? (spec.indexMin) : (0); |
| /** @type {number} */ var firstAddition = (hasFirst) ? (spec.first) : (0); |
| /** @type {number} */ var elementCount = primitiveElementCount + indexMin + firstAddition; // !< elements in buffer (buffer should have at least primitiveElementCount ACCESSIBLE (index range, first) elements) |
| /** @type {number} */ var maxElementIndex = primitiveElementCount + indexMin + firstAddition - 1; |
| /** @type {number} */ var indexMax = Math.max(0, (ranged) ? (deMath.clamp(spec.indexMax, 0, maxElementIndex)) : (maxElementIndex)); |
| /** @type {number} */ var coordScale = this.getCoordScale(spec); |
| /** @type {number} */ var colorScale = this.getColorScale(spec); |
| |
| /** @type {Array<number>} */ var nullAttribValue = []; |
| |
| // Log info |
| bufferedLogToConsole(spec.getMultilineDesc()); |
| |
| // Data |
| this.m_glArrayPack.clearArrays(); |
| this.m_rrArrayPack.clearArrays(); |
| |
| // indices |
| /** @type {number} */ var seed; |
| /** @type {number} */ var indexElementSize; |
| /** @type {number} */ var indexArraySize; |
| /** @type {goog.TypedArray} */ var indexArray; |
| /** @type {goog.TypedArray} */ var indexPointer; |
| |
| /** @type {glsDrawTests.AttributeArray}*/ var glArray; |
| /** @type {glsDrawTests.AttributeArray}*/ var rrArray; |
| |
| if (indexed) { |
| seed = spec.hash(); |
| indexElementSize = glsDrawTests.DrawTestSpec.indexTypeSize(spec.indexType); |
| indexArraySize = spec.indexPointerOffset + indexElementSize * elementCount; |
| indexArray = glsDrawTests.RandomArrayGenerator.generateIndices(seed, elementCount, spec.indexType, spec.indexPointerOffset, indexMin, indexMax); |
| indexPointer = indexArray.subarray(spec.indexPointerOffset); |
| |
| glArray = new glsDrawTests.AttributeArray(spec.indexStorage, this.m_glesContext); |
| rrArray = new glsDrawTests.AttributeArray(spec.indexStorage, this.m_refContext); |
| |
| glArray.data(glsDrawTests.DrawTestSpec.Target.ELEMENT_ARRAY, indexArraySize, indexArray, glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW); |
| rrArray.data(glsDrawTests.DrawTestSpec.Target.ELEMENT_ARRAY, indexArraySize, indexArray, glsDrawTests.DrawTestSpec.Usage.STATIC_DRAW); |
| |
| indexArray = null; |
| } |
| |
| // attributes |
| for (var attribNdx = 0; attribNdx < spec.attribs.length; attribNdx++) { |
| /** @type {glsDrawTests.DrawTestSpec.AttributeSpec} */ var attribSpec = spec.attribs[attribNdx]; |
| var isPositionAttr = (attribNdx == 0) || (attribSpec.additionalPositionAttribute); |
| |
| if (attribSpec.useDefaultAttribute) { |
| seed = 10 * attribSpec.hash() + 100 * spec.hash() + attribNdx; |
| /** @type {Array<number>} */ var attribValue = glsDrawTests.RandomArrayGenerator.generateAttributeValue(seed, attribSpec.inputType); |
| |
| // changed USER for BUFFER in JS version |
| this.m_glArrayPack.newArray(glsDrawTests.DrawTestSpec.Storage.BUFFER); |
| this.m_rrArrayPack.newArray(glsDrawTests.DrawTestSpec.Storage.BUFFER); |
| |
| this.m_glArrayPack.getArray(attribNdx).setupArray(false, 0, attribSpec.componentCount, attribSpec.inputType, attribSpec.outputType, false, 0, 0, attribValue, isPositionAttr); |
| this.m_rrArrayPack.getArray(attribNdx).setupArray(false, 0, attribSpec.componentCount, attribSpec.inputType, attribSpec.outputType, false, 0, 0, attribValue, isPositionAttr); |
| } else { |
| seed = attribSpec.hash() + 100 * spec.hash() + attribNdx; |
| /** @type {number} */ var elementSize = attribSpec.componentCount * glsDrawTests.DrawTestSpec.inputTypeSize(attribSpec.inputType); |
| /** @type {number} */ var stride = (attribSpec.stride == 0) ? (elementSize) : (attribSpec.stride); |
| /** @type {number} */ var evaluatedElementCount = (instanced && attribSpec.instanceDivisor > 0) ? (spec.instanceCount / attribSpec.instanceDivisor + 1) : (elementCount); |
| /** @type {number} */ var referencedElementCount = (ranged) ? (Math.max(evaluatedElementCount, spec.indexMax + 1)) : (evaluatedElementCount); |
| /** @type {number} */ var bufferSize = attribSpec.offset + stride * (referencedElementCount - 1) + elementSize; |
| /** @type {goog.TypedArray} */ var data = glsDrawTests.RandomArrayGenerator.createArray( |
| seed, |
| referencedElementCount, |
| attribSpec.componentCount, |
| attribSpec.offset, |
| stride, |
| attribSpec.inputType, |
| indexed ? 0 : spec.first, |
| spec.primitive, |
| indexed ? indexPointer : null, |
| indexElementSize |
| ); |
| |
| this.m_glArrayPack.newArray(attribSpec.storage); |
| this.m_rrArrayPack.newArray(attribSpec.storage); |
| |
| this.m_glArrayPack.getArray(attribNdx).data(glsDrawTests.DrawTestSpec.Target.ARRAY, bufferSize, data, attribSpec.usage); |
| this.m_rrArrayPack.getArray(attribNdx).data(glsDrawTests.DrawTestSpec.Target.ARRAY, bufferSize, data, attribSpec.usage); |
| |
| this.m_glArrayPack.getArray(attribNdx).setupArray(true, attribSpec.offset, attribSpec.componentCount, attribSpec.inputType, attribSpec.outputType, attribSpec.normalize, attribSpec.stride, attribSpec.instanceDivisor, nullAttribValue, isPositionAttr); |
| this.m_rrArrayPack.getArray(attribNdx).setupArray(true, attribSpec.offset, attribSpec.componentCount, attribSpec.inputType, attribSpec.outputType, attribSpec.normalize, attribSpec.stride, attribSpec.instanceDivisor, nullAttribValue, isPositionAttr); |
| |
| data = null; |
| } |
| } |
| |
| // Shader program |
| if (updateProgram) { |
| this.m_glArrayPack.updateProgram(); |
| this.m_rrArrayPack.updateProgram(); |
| } |
| |
| /** @type {glsDrawTests.DrawTestSpec.CompatibilityTestType} */ var ctype; |
| |
| // Draw |
| try { |
| // indices |
| if (indexed) { |
| this.m_glArrayPack.render(spec.primitive, spec.drawMethod, 0, primitiveElementCount, spec.indexType, spec.indexPointerOffset, spec.indexMin, spec.indexMax, spec.instanceCount, coordScale, colorScale, glArray); |
| this.m_rrArrayPack.render(spec.primitive, spec.drawMethod, 0, primitiveElementCount, spec.indexType, spec.indexPointerOffset, spec.indexMin, spec.indexMax, spec.instanceCount, coordScale, colorScale, rrArray); |
| } else { |
| this.m_glArrayPack.render(spec.primitive, spec.drawMethod, spec.first, primitiveElementCount, null, 0, 0, 0, spec.instanceCount, coordScale, colorScale, null); |
| this.m_rrArrayPack.render(spec.primitive, spec.drawMethod, spec.first, primitiveElementCount, null, 0, 0, 0, spec.instanceCount, coordScale, colorScale, null); |
| } |
| } catch (err) { |
| if (err instanceof wtu.GLErrorException) { |
| // GL Errors are ok if the mode is not properly aligned |
| ctype = spec.isCompatibilityTest(); |
| |
| bufferedLogToConsole('Got error: ' + err.message); |
| |
| if (ctype == glsDrawTests.DrawTestSpec.CompatibilityTestType.UNALIGNED_OFFSET) |
| checkMessage(false, 'Failed to draw with unaligned buffers.'); |
| else if (ctype == glsDrawTests.DrawTestSpec.CompatibilityTestType.UNALIGNED_STRIDE) |
| checkMessage(false, 'Failed to draw with unaligned stride.'); |
| else |
| throw err; |
| } |
| } |
| } else if (compareStep) { |
| if (!this.compare(spec.primitive)) { |
| ctype = spec.isCompatibilityTest(); |
| |
| if (ctype == glsDrawTests.DrawTestSpec.CompatibilityTestType.UNALIGNED_OFFSET) |
| checkMessage(false, 'Failed to draw with unaligned buffers.'); |
| else if (ctype == glsDrawTests.DrawTestSpec.CompatibilityTestType.UNALIGNED_STRIDE) |
| checkMessage(false, 'Failed to draw with unaligned stride.'); |
| else |
| testFailedOptions('Image comparison failed.', false); |
| return iterateResult; |
| } |
| } else { |
| testFailedOptions('Image comparison failed.', false); |
| return tcuTestCase.IterateResult.STOP; |
| } |
| |
| if (iterateResult == tcuTestCase.IterateResult.STOP) |
| testPassed(''); |
| |
| return iterateResult; |
| }; |
| |
| /** |
| * @enum {number} PrimitiveClass |
| */ |
| glsDrawTests.PrimitiveClass = { |
| POINT: 0, |
| LINE: 1, |
| TRIANGLE: 2 |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.Primitive} primitiveType |
| * @return {glsDrawTests.PrimitiveClass} |
| */ |
| glsDrawTests.getDrawPrimitiveClass = function(primitiveType) { |
| switch (primitiveType) { |
| case glsDrawTests.DrawTestSpec.Primitive.POINTS: |
| return glsDrawTests.PrimitiveClass.POINT; |
| |
| case glsDrawTests.DrawTestSpec.Primitive.LINES: |
| case glsDrawTests.DrawTestSpec.Primitive.LINE_STRIP: |
| case glsDrawTests.DrawTestSpec.Primitive.LINE_LOOP: |
| return glsDrawTests.PrimitiveClass.LINE; |
| |
| case glsDrawTests.DrawTestSpec.Primitive.TRIANGLES: |
| case glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_FAN: |
| case glsDrawTests.DrawTestSpec.Primitive.TRIANGLE_STRIP: |
| return glsDrawTests.PrimitiveClass.TRIANGLE; |
| |
| default: |
| throw new Error('Invalid primitive type'); |
| } |
| }; |
| |
| /** |
| * @param {number} c1 |
| * @param {number} c2 |
| * @param {Array<number>} threshold |
| * @return {boolean} |
| */ |
| glsDrawTests.compareUintRGB8 = function(c1, c2, threshold) { |
| return (Math.abs(((c1 >> 16) & 0xff) - ((c2 >> 16) & 0xff)) <= threshold[0] && // Red |
| Math.abs(((c1 >> 8) & 0xff) - ((c2 >> 8) & 0xff)) <= threshold[1] && // Green |
| Math.abs((c1 & 0xff) - (c2 & 0xff)) <= threshold[2]); // Blue |
| }; |
| |
| /** |
| * @param {number} c1 |
| * @param {number} c2 |
| * @param {number} c3 |
| * @param {number} renderTargetDifference |
| * @return {boolean} |
| */ |
| glsDrawTests.isEdgeTripletComponent = function(c1, c2, c3, renderTargetDifference) { |
| /** @type {number} */ var roundingDifference = 2 * renderTargetDifference; // src and dst pixels rounded to different directions |
| /** @type {number} */ var d1 = c2 - c1; |
| /** @type {number} */ var d2 = c3 - c2; |
| /** @type {number} */ var rampDiff = Math.abs(d2 - d1); |
| |
| return rampDiff > roundingDifference; |
| }; |
| |
| /** |
| * @param {tcuRGBA.RGBA} c1 |
| * @param {tcuRGBA.RGBA} c2 |
| * @param {tcuRGBA.RGBA} c3 |
| * @param {Array<number>} renderTargetThreshold |
| * @return {boolean} |
| */ |
| glsDrawTests.isEdgeTriplet = function(c1, c2, c3, renderTargetThreshold) { |
| // black (background color) and non-black is always an edge |
| /** @type {boolean} */ var b1 = c1 == 0x000000; |
| /** @type {boolean} */ var b2 = c2 == 0x000000; |
| /** @type {boolean} */ var b3 = c3 == 0x000000; |
| |
| // both pixels with coverage and pixels without coverage |
| if ((b1 && b2 && b3) == false && (b1 || b2 || b3) == true) |
| return true; |
| // all black |
| if (b1 && b2 && b3) |
| return false; |
| // all with coverage |
| assertMsgOptions(!b1 && !b2 && !b3, 'All colors with coverage', false, true); |
| |
| // Color is always linearly interpolated => component values change nearly linearly |
| // in any constant direction on triangle hull. (df/dx ~= C). |
| |
| // Edge detection (this function) is run against the reference image |
| // => no dithering to worry about |
| |
| return glsDrawTests.isEdgeTripletComponent((c1 >> 16) && 0xff, (c2 >> 16) && 0xff, (c3 >> 16) && 0xff, renderTargetThreshold[0]) || |
| glsDrawTests.isEdgeTripletComponent((c1 >> 8) && 0xff, (c2 >> 8) && 0xff, (c3 >> 8) && 0xff, renderTargetThreshold[1]) || |
| glsDrawTests.isEdgeTripletComponent(c1 && 0xff, c2 && 0xff, c3 && 0xff, renderTargetThreshold[2]); |
| }; |
| |
| /** |
| * @param {number} x |
| * @param {number} y |
| * @param {tcuSurface.Surface} ref |
| * @param {Array<number>} renderTargetThreshold |
| * @return {boolean} |
| */ |
| glsDrawTests.pixelNearEdge = function(x, y, ref, renderTargetThreshold) { |
| // should not be called for edge pixels |
| assertMsgOptions(x >= 1 && x <= ref.getWidth() - 2, 'The pixel was on the edge', false, true); |
| assertMsgOptions(y >= 1 && y <= ref.getHeight() - 2, 'The pixel was on the edge', false, true); |
| |
| // horizontal |
| |
| /** @type {number} */ var c1; |
| /** @type {number} */ var c2; |
| /** @type {number} */ var c3; |
| |
| for (var dy = -1; dy < 2; ++dy) { |
| c1 = ref.getPixelUintRGB8(x - 1, y + dy); |
| c2 = ref.getPixelUintRGB8(x, y + dy); |
| c3 = ref.getPixelUintRGB8(x + 1, y + dy); |
| if (glsDrawTests.isEdgeTriplet(c1, c2, c3, renderTargetThreshold)) |
| return true; |
| } |
| |
| // vertical |
| |
| for (var dx = -1; dx < 2; ++dx) { |
| c1 = ref.getPixelUintRGB8(x + dx, y - 1); |
| c2 = ref.getPixelUintRGB8(x + dx, y); |
| c3 = ref.getPixelUintRGB8(x + dx, y + 1); |
| if (glsDrawTests.isEdgeTriplet(c1, c2, c3, renderTargetThreshold)) |
| return true; |
| } |
| |
| return false; |
| }; |
| |
| /** |
| * @param {number} c |
| * @return {number} |
| */ |
| glsDrawTests.getVisualizationGrayscaleColorUintRGB8 = function(c) { |
| // make triangle coverage and error pixels obvious by converting coverage to grayscale |
| if (c == 0x000000) |
| return 0; |
| else |
| return 50 + Math.floor((((c >> 16) & 0xff) + ((c >> 8) & 0xff) + (c & 0xff)) / 8); |
| }; |
| |
| /** |
| * @param {number} x |
| * @param {number} y |
| * @param {tcuSurface.Surface} target |
| * @return {boolean} |
| */ |
| glsDrawTests.pixelNearLineIntersection = function(x, y, target) { |
| // should not be called for edge pixels |
| assertMsgOptions(x >= 1 && x <= target.getWidth() - 2, 'Pixel is in the edge', false, true); |
| assertMsgOptions(y >= 1 && y <= target.getHeight() - 2, 'Pixel is in the edge', false, true); |
| |
| var coveredPixels = 0; |
| |
| for (var dy = -1; dy < 2; dy++) |
| for (var dx = -1; dx < 2; dx++) { |
| var targetCoverage = target.getPixelUintRGB8(x + dx, y + dy); |
| if (targetCoverage) { |
| ++coveredPixels; |
| |
| // A single thin line cannot have more than 3 covered pixels in a 3x3 area |
| if (coveredPixels >= 4) |
| return true; |
| } |
| } |
| |
| return false; |
| }; |
| |
| // search 3x3 are for matching color |
| /** |
| * @param {tcuSurface.Surface} target |
| * @param {number} x |
| * @param {number} y |
| * @param {tcuRGBA.RGBA} color |
| * @param {Array<number>} compareThreshold |
| * @return {boolean} |
| */ |
| glsDrawTests.pixelNeighborhoodContainsColor = function(target, x, y, color, compareThreshold) { |
| // should not be called for edge pixels |
| assertMsgOptions(x >= 1 && x <= target.getWidth() - 2, 'Pixel is in the edge', false, true); |
| assertMsgOptions(y >= 1 && y <= target.getHeight() - 2, 'Pixel is in the edge', false, true); |
| |
| for (var dy = -1; dy < 2; dy++) |
| for (var dx = -1; dx < 2; dx++) { |
| if (glsDrawTests.compareUintRGB8(color, target.getPixelUintRGB8(x + dx, y + dy), compareThreshold)) |
| return true; |
| } |
| |
| return false; |
| }; |
| |
| // search 3x3 are for matching coverage (coverage == (color != background color)) |
| /** |
| * @param {tcuSurface.Surface} target |
| * @param {number} x |
| * @param {number} y |
| * @param {boolean} coverage |
| * @return {boolean} |
| */ |
| glsDrawTests.pixelNeighborhoodContainsCoverage = function(target, x, y, coverage) { |
| // should not be called for edge pixels |
| assertMsgOptions(x >= 1 && x <= target.getWidth() - 2, 'Pixel is in the edge', false, true); |
| assertMsgOptions(y >= 1 && y <= target.getHeight() - 2, 'Pixel is in the edge', false, true); |
| |
| for (var dy = -1; dy < 2; dy++) |
| for (var dx = -1; dx < 2; dx++) { |
| var targetCmpCoverage = target.getPixelUintRGB8(x + dx, y + dy) != 0x000000; // Pixel is not black |
| if (targetCmpCoverage == coverage) |
| return true; |
| } |
| |
| return false; |
| }; |
| |
| /** |
| * @param {string} imageSetName |
| * @param {string} imageSetDesc |
| * @param {tcuSurface.Surface} reference |
| * @param {tcuSurface.Surface} result |
| * @param {Array<number>} compareThreshold |
| * @param {Array<number>} renderTargetThreshold |
| * @param {number} maxAllowedInvalidPixels |
| * @return {boolean} |
| */ |
| glsDrawTests.edgeRelaxedImageCompare = function(imageSetName, imageSetDesc, reference, result, compareThreshold, renderTargetThreshold, maxAllowedInvalidPixels) { |
| assertMsgOptions(result.getWidth() == reference.getWidth() && result.getHeight() == reference.getHeight(), 'Reference and result images have different dimensions', false, true); |
| |
| /** @type {Array<number>} */ var green = [0, 255, 0, 255]; |
| /** @type {Array<number>} */ var errorColor = [255, 0, 0, 255]; |
| /** @type {number} */ var width = reference.getWidth(); |
| /** @type {number} */ var height = reference.getHeight(); |
| /** @type {tcuSurface.Surface} */ var errorMask = new tcuSurface.Surface(width, height); |
| /** @type {number} */ var numFailingPixels = 0; |
| |
| // clear errormask edges which would otherwise be transparent |
| |
| tcuTextureUtil.getSubregion(errorMask.getAccess(), 0, 0, 0, width, 1, 1).clear(green); |
| tcuTextureUtil.getSubregion(errorMask.getAccess(), 0, height - 1, 0, width, 1, 1).clear(green); |
| tcuTextureUtil.getSubregion(errorMask.getAccess(), 0, 0, 0, 1, height, 1).clear(green); |
| tcuTextureUtil.getSubregion(errorMask.getAccess(), width - 1, 0, 0, 1, height, 1).clear(green); |
| |
| // skip edge pixels since coverage on edge cannot be verified |
| |
| for (var y = 1; y < height - 1; ++y) |
| for (var x = 1; x < width - 1; ++x) { |
| /** @type {number} */ var refPixel = reference.getPixelUintRGB8(x, y); |
| /** @type {number} */ var screenPixel = result.getPixelUintRGB8(x, y); |
| /** @type {boolean} */ var isOkReferencePixel = glsDrawTests.pixelNeighborhoodContainsColor(result, x, y, refPixel, compareThreshold); // screen image has a matching pixel nearby (~= If something is drawn on reference, it must be drawn to screen too.) |
| /** @type {boolean} */ var isOkScreenPixel = glsDrawTests.pixelNeighborhoodContainsColor(reference, x, y, screenPixel, compareThreshold); // reference image has a matching pixel nearby (~= If something is drawn on screen, it must be drawn to reference too.) |
| |
| if (isOkScreenPixel && isOkReferencePixel) { |
| // pixel valid, write greenish pixels to make the result image easier to read |
| /** @type {number} */ var grayscaleValue = glsDrawTests.getVisualizationGrayscaleColorUintRGB8(screenPixel); |
| errorMask.getAccess().setPixel([grayscaleValue / 255, 1, grayscaleValue / 255, 1], x, y); |
| } else if (!glsDrawTests.pixelNearEdge(x, y, reference, renderTargetThreshold)) { |
| // non-edge pixel values must be within threshold of the reference values |
| errorMask.getAccess().setPixel(deMath.scale(errorColor, 1 / 255), x, y); |
| ++numFailingPixels; |
| } else { |
| // we are on/near an edge, verify only coverage (coverage == not background colored) |
| /** @type {boolean} */ var referenceCoverage = refPixel != 0x000000; // Not black |
| /** @type {boolean} */ var screenCoverage = screenPixel != 0x000000; // Not black |
| /** @type {boolean} */ var isOkReferenceCoverage = glsDrawTests.pixelNeighborhoodContainsCoverage(result, x, y, referenceCoverage); // Check reference pixel against screen pixel |
| /** @type {boolean} */ var isOkScreenCoverage = glsDrawTests.pixelNeighborhoodContainsCoverage(reference, x, y, screenCoverage); // Check screen pixels against reference pixel |
| |
| if (isOkScreenCoverage && isOkReferenceCoverage) { |
| // pixel valid, write greenish pixels to make the result image easier to read |
| var grayscaleValue = glsDrawTests.getVisualizationGrayscaleColorUintRGB8(screenPixel); |
| errorMask.getAccess().setPixel([grayscaleValue / 255, 1, grayscaleValue / 255, 1], x, y); |
| } else { |
| // coverage does not match |
| errorMask.getAccess().setPixel(deMath.scale(errorColor, 1 / 255), x, y); |
| ++numFailingPixels; |
| } |
| } |
| } |
| |
| bufferedLogToConsole( |
| 'Comparing images:</br>' + |
| '<span> </span>allowed deviation in pixel positions = 1</br>' + |
| '<span> </span>number of allowed invalid pixels = ' + maxAllowedInvalidPixels + '</br>' + |
| '<span> </span>number of invalid pixels = ' + numFailingPixels |
| ); |
| |
| if (numFailingPixels > maxAllowedInvalidPixels) { |
| debug('Image comparison failed. Color threshold = (' + compareThreshold[0] + ', ' + compareThreshold[1] + ', ' + compareThreshold[2] + ')'); |
| tcuImageCompare.displayImages(result.getAccess(), reference.getAccess(), errorMask.getAccess()); |
| |
| return false; |
| } else { |
| return true; |
| } |
| }; |
| |
| /** |
| * @param {string} imageSetName |
| * @param {string} imageSetDesc |
| * @param {tcuSurface.Surface} reference |
| * @param {tcuSurface.Surface} result |
| * @param {Array<number>} compareThreshold |
| * @param {number} maxAllowedInvalidPixels |
| * @return {boolean} |
| */ |
| glsDrawTests.intersectionRelaxedLineImageCompare = function(imageSetName, imageSetDesc, reference, result, compareThreshold, maxAllowedInvalidPixels) { |
| assertMsgOptions(result.getWidth() == reference.getWidth() && result.getHeight() == reference.getHeight(), 'Reference and result images have different dimensions', false, true); |
| |
| /** @type {Array<number>} */ var green = [0, 255, 0, 255]; |
| /** @type {Array<number>} */ var errorColor = [255, 0, 0, 255]; |
| var width = reference.getWidth(); |
| var height = reference.getHeight(); |
| /** @type {tcuSurface.Surface} */ var errorMask = new tcuSurface.Surface(width, height); |
| /** @type {number} */ var numFailingPixels = 0; |
| |
| // clear errormask edges which would otherwise be transparent |
| |
| tcuTextureUtil.getSubregion(errorMask.getAccess(), 0, 0, 0, width, 1, 1).clear(green); |
| tcuTextureUtil.getSubregion(errorMask.getAccess(), 0, height - 1, 0, width, 1, 1).clear(green); |
| tcuTextureUtil.getSubregion(errorMask.getAccess(), 0, 0, 0, 1, height, 1).clear(green); |
| tcuTextureUtil.getSubregion(errorMask.getAccess(), width - 1, 0, 0, 1, height, 1).clear(green); |
| |
| // skip edge pixels since coverage on edge cannot be verified |
| |
| for (var y = 1; y < height - 1; ++y) |
| for (var x = 1; x < width - 1; ++x) { |
| /** @type {number} */ var refPixel = reference.getPixelUintRGB8(x, y); |
| /** @type {number} */ var screenPixel = result.getPixelUintRGB8(x, y); |
| /** @type {boolean} */ var isOkScreenPixel = glsDrawTests.pixelNeighborhoodContainsColor(reference, x, y, screenPixel, compareThreshold); // reference image has a matching pixel nearby (~= If something is drawn on screen, it must be drawn to reference too.) |
| /** @type {boolean} */ var isOkReferencePixel = glsDrawTests.pixelNeighborhoodContainsColor(result, x, y, refPixel, compareThreshold); // screen image has a matching pixel nearby (~= If something is drawn on reference, it must be drawn to screen too.) |
| |
| /** @type {number} */ var grayscaleValue; |
| |
| if (isOkScreenPixel && isOkReferencePixel) { |
| // pixel valid, write greenish pixels to make the result image easier to read |
| grayscaleValue = glsDrawTests.getVisualizationGrayscaleColorUintRGB8(screenPixel); |
| errorMask.getAccess().setPixel([grayscaleValue / 255, 1, grayscaleValue / 255, 1], x, y); |
| } else if (!glsDrawTests.pixelNearLineIntersection(x, y, reference) && |
| !glsDrawTests.pixelNearLineIntersection(x, y, result)) { |
| // non-intersection pixel values must be within threshold of the reference values |
| errorMask.getAccess().setPixel(deMath.scale(errorColor, 1 / 255), x, y); |
| ++numFailingPixels; |
| } else { |
| // pixel is near a line intersection |
| // we are on/near an edge, verify only coverage (coverage == not background colored) |
| /** @type {boolean} */ var referenceCoverage = refPixel != 0x000000; // Not Black |
| /** @type {boolean} */ var screenCoverage = screenPixel != 0x000000; // Not Black |
| /** @type {boolean} */ var isOkScreenCoverage = glsDrawTests.pixelNeighborhoodContainsCoverage(reference, x, y, screenCoverage); // Check screen pixels against reference pixel |
| /** @type {boolean} */ var isOkReferenceCoverage = glsDrawTests.pixelNeighborhoodContainsCoverage(result, x, y, referenceCoverage); // Check reference pixel against screen pixel |
| |
| if (isOkScreenCoverage && isOkReferenceCoverage) { |
| // pixel valid, write greenish pixels to make the result image easier to read |
| grayscaleValue = glsDrawTests.getVisualizationGrayscaleColorUintRGB8(screenPixel); |
| errorMask.getAccess().setPixel([grayscaleValue / 255, 1, grayscaleValue / 255, 1], x, y); |
| } else { |
| // coverage does not match |
| errorMask.getAccess().setPixel(deMath.scale(errorColor, 1 / 255), x, y); |
| ++numFailingPixels; |
| } |
| } |
| } |
| |
| bufferedLogToConsole( |
| 'Comparing images:</br>' + |
| '<span> </span>allowed deviation in pixel positions = 1</br>' + |
| '<span> </span>number of allowed invalid pixels = ' + maxAllowedInvalidPixels + '</br>' + |
| '<span> </span>number of invalid pixels = ' + numFailingPixels |
| ); |
| |
| if (numFailingPixels > maxAllowedInvalidPixels) { |
| debug('Image comparison failed. Color threshold = (' + compareThreshold[0] + ', ' + compareThreshold[1] + ', ' + compareThreshold[2] + ')'); |
| tcuImageCompare.displayImages(result.getAccess(), reference.getAccess(), errorMask.getAccess()); |
| |
| return false; |
| } else { |
| return true; |
| } |
| }; |
| |
| /** |
| * @param {?glsDrawTests.DrawTestSpec.Primitive} primitiveType |
| * @return {boolean} |
| */ |
| glsDrawTests.DrawTest.prototype.compare = function(primitiveType) { |
| /** @type {tcuSurface.Surface} */ var ref = this.m_rrArrayPack.getSurface(); |
| /** @type {tcuSurface.Surface} */ var screen = this.m_glArrayPack.getSurface(); |
| |
| if (/** @type {number} */ (gl.getParameter(gl.SAMPLES)) > 1) { |
| // \todo [mika] Improve compare when using multisampling |
| bufferedLogToConsole('Warning: Comparision of result from multisample render targets are not as strict as without multisampling. Might produce false positives!'); |
| return tcuImageCompare.fuzzyCompare('Compare Results', 'Compare Results', ref.getAccess(), screen.getAccess(), 0.3, tcuImageCompare.CompareLogMode.RESULT); |
| } else { |
| /** @type {glsDrawTests.PrimitiveClass} */ var primitiveClass = glsDrawTests.getDrawPrimitiveClass(primitiveType); |
| |
| switch (primitiveClass) { |
| case glsDrawTests.PrimitiveClass.POINT: { |
| // Point are extremely unlikely to have overlapping regions, don't allow any no extra / missing pixels |
| /**@type {number} */ var maxAllowedInvalidPixelsWithPoints = 0; |
| return tcuImageCompare.intThresholdPositionDeviationErrorThresholdCompare( |
| 'CompareResult', |
| 'Result of rendering', |
| ref.getAccess(), |
| screen.getAccess(), |
| [this.m_maxDiffRed, this.m_maxDiffGreen, this.m_maxDiffBlue, 256], |
| [1, 1, 0], //!< 3x3 search kernel |
| true, //!< relax comparison on the image boundary |
| maxAllowedInvalidPixelsWithPoints //!< error threshold |
| ); |
| } |
| |
| case glsDrawTests.PrimitiveClass.LINE: { |
| // Lines can potentially have a large number of overlapping pixels. Pixel comparison may potentially produce |
| // false negatives in such pixels if for example the pixel in question is overdrawn by another line in the |
| // reference image but not in the resultin image. Relax comparison near line intersection points (areas) and |
| // compare only coverage, not color, in such pixels |
| /**@type {number} */ var maxAllowedInvalidPixelsWithLines = 15; // line are allowed to have a few bad pixels |
| return glsDrawTests.intersectionRelaxedLineImageCompare( |
| 'CompareResult', |
| 'Result of rendering', |
| ref, |
| screen, |
| [this.m_maxDiffRed, this.m_maxDiffGreen, this.m_maxDiffBlue], |
| maxAllowedInvalidPixelsWithLines |
| ); |
| } |
| |
| case glsDrawTests.PrimitiveClass.TRIANGLE: { |
| // Triangles are likely to partially or fully overlap. Pixel difference comparison is fragile in pixels |
| // where there could be potential overlapping since the pixels might be covered by one triangle in the |
| // reference image and by the other in the result image. Relax comparsion near primitive edges and |
| // compare only coverage, not color, in such pixels. |
| /** @type {number} */ var maxAllowedInvalidPixelsWithTriangles = 10; |
| |
| /* TODO: Implement |
| var renderTargetThreshold = //TODO: get color threshold from the pixel format --> m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold().toIVec().xyz(); |
| */ |
| |
| /** @type {Array<number>} */ var renderTargetThreshold = [3, 3, 3, 3]; |
| |
| return glsDrawTests.edgeRelaxedImageCompare( |
| 'CompareResult', |
| 'Result of rendering', |
| ref, |
| screen, |
| [this.m_maxDiffRed, this.m_maxDiffGreen, this.m_maxDiffBlue], |
| renderTargetThreshold, |
| maxAllowedInvalidPixelsWithTriangles |
| ); |
| } |
| |
| default: |
| throw new Error('Invalid primitive class'); |
| } |
| } |
| }; |
| |
| /** |
| * @param {glsDrawTests.DrawTestSpec} spec |
| * @return {number} |
| */ |
| glsDrawTests.DrawTest.prototype.getCoordScale = function(spec) { |
| var maxValue = 1.0; |
| |
| for (var arrayNdx = 0; arrayNdx < spec.attribs.length; arrayNdx++) { |
| /** @type {glsDrawTests.DrawTestSpec.AttributeSpec} */ var attribSpec = spec.attribs[arrayNdx]; |
| /** @type {boolean} */ var isPositionAttr = (arrayNdx == 0) || (attribSpec.additionalPositionAttribute); |
| /** @type {number} */ var attrMaxValue = 0; |
| |
| if (!isPositionAttr) |
| continue; |
| |
| if (attribSpec.inputType == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT_2_10_10_10) { |
| if (attribSpec.normalize) |
| attrMaxValue += 1.0; |
| else |
| attrMaxValue += 1024.0; |
| } else if (attribSpec.inputType == glsDrawTests.DrawTestSpec.InputType.INT_2_10_10_10) { |
| if (attribSpec.normalize) |
| attrMaxValue += 1.0; |
| else |
| attrMaxValue += 512.0; |
| } else { |
| var max = glsDrawTests.GLValue.getMaxValue(attribSpec.inputType).getValue(); |
| |
| attrMaxValue += (attribSpec.normalize && !glsDrawTests.inputTypeIsFloatType(attribSpec.inputType)) ? (1.0) : (max * 1.1); |
| } |
| |
| if (attribSpec.outputType == glsDrawTests.DrawTestSpec.OutputType.VEC3 || attribSpec.outputType == glsDrawTests.DrawTestSpec.OutputType.VEC4 || |
| attribSpec.outputType == glsDrawTests.DrawTestSpec.OutputType.IVEC3 || attribSpec.outputType == glsDrawTests.DrawTestSpec.OutputType.IVEC4 || |
| attribSpec.outputType == glsDrawTests.DrawTestSpec.OutputType.UVEC3 || attribSpec.outputType == glsDrawTests.DrawTestSpec.OutputType.UVEC4) |
| attrMaxValue *= 2; |
| |
| maxValue += attrMaxValue; |
| } |
| |
| return 1.0 / maxValue; |
| }; |
| |
| /** |
| * @param {glsDrawTests.DrawTestSpec} spec |
| * @return {number} |
| */ |
| glsDrawTests.DrawTest.prototype.getColorScale = function(spec) { |
| var colorScale = 1.0; |
| |
| for (var arrayNdx = 1; arrayNdx < spec.attribs.length; arrayNdx++) { |
| /** @type {glsDrawTests.DrawTestSpec.AttributeSpec} */ var attribSpec = spec.attribs[arrayNdx]; |
| /** @type {boolean} */ var isPositionAttr = (arrayNdx == 0) || (attribSpec.additionalPositionAttribute); |
| |
| if (isPositionAttr) |
| continue; |
| |
| if (attribSpec.inputType == glsDrawTests.DrawTestSpec.InputType.UNSIGNED_INT_2_10_10_10) { |
| if (!attribSpec.normalize) |
| colorScale *= 1.0 / 1024.0; |
| } else if (attribSpec.inputType == glsDrawTests.DrawTestSpec.InputType.INT_2_10_10_10) { |
| if (!attribSpec.normalize) |
| colorScale *= 1.0 / 512.0; |
| } else { |
| var max = glsDrawTests.GLValue.getMaxValue(attribSpec.inputType).toFloat(); |
| |
| colorScale *= (attribSpec.normalize && !glsDrawTests.inputTypeIsFloatType(attribSpec.inputType) ? 1.0 : (1.0 / max)); |
| if (attribSpec.outputType == glsDrawTests.DrawTestSpec.OutputType.VEC4 || |
| attribSpec.outputType == glsDrawTests.DrawTestSpec.OutputType.UVEC4 || |
| attribSpec.outputType == glsDrawTests.DrawTestSpec.OutputType.IVEC4) |
| colorScale *= (attribSpec.normalize && !glsDrawTests.inputTypeIsFloatType(attribSpec.inputType) ? 1.0 : 1.0 / max); |
| } |
| } |
| |
| return colorScale; |
| }; |
| }); |
