diff options
Diffstat (limited to 'dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fFboTestUtil.js')
| -rw-r--r-- | dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fFboTestUtil.js | 1324 |
1 files changed, 1324 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fFboTestUtil.js b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fFboTestUtil.js new file mode 100644 index 0000000000..ed152a43e4 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fFboTestUtil.js @@ -0,0 +1,1324 @@ +/*------------------------------------------------------------------------- + * drawElements Quality Program OpenGL ES Utilities + * ------------------------------------------------ + * + * Copyright 2014 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +'use strict'; +goog.provide('functional.gles3.es3fFboTestUtil'); +goog.require('framework.common.tcuMatrix'); +goog.require('framework.common.tcuRGBA'); +goog.require('framework.common.tcuSurface'); +goog.require('framework.common.tcuTexture'); +goog.require('framework.common.tcuTextureUtil'); +goog.require('framework.delibs.debase.deMath'); +goog.require('framework.opengl.gluShaderUtil'); +goog.require('framework.opengl.gluTextureUtil'); +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 es3fFboTestUtil = functional.gles3.es3fFboTestUtil; +var tcuTexture = framework.common.tcuTexture; +var tcuTextureUtil = framework.common.tcuTextureUtil; +var tcuRGBA = framework.common.tcuRGBA; +var gluTextureUtil = framework.opengl.gluTextureUtil; +var deMath = framework.delibs.debase.deMath; +var rrShadingContext = framework.referencerenderer.rrShadingContext; +var rrVertexPacket = framework.referencerenderer.rrVertexPacket; +var rrVertexAttrib = framework.referencerenderer.rrVertexAttrib; +var gluShaderUtil = framework.opengl.gluShaderUtil; +var sglrGLContext = framework.opengl.simplereference.sglrGLContext; +var sglrReferenceContext = framework.opengl.simplereference.sglrReferenceContext; +var sglrShaderProgram = framework.opengl.simplereference.sglrShaderProgram; +var rrGenericVector = framework.referencerenderer.rrGenericVector; +var tcuMatrix = framework.common.tcuMatrix; +var rrFragmentOperations = framework.referencerenderer.rrFragmentOperations; +var tcuSurface = framework.common.tcuSurface; + +var DE_ASSERT = function(x) { + if (!x) + throw new Error('Assert failed'); +}; + +/** + * Defines the exception type for a test failure. + * @constructor + * @param {number} reason The error code. + */ +es3fFboTestUtil.FboIncompleteException = function(reason) { + this.reason = reason; + this.name = 'es3fFboTestUtil.FboIncompleteException'; +}; + +/** @typedef { (WebGL2RenderingContext|sglrReferenceContext.ReferenceContext)} */ +es3fFboTestUtil.Context; + +es3fFboTestUtil.FboIncompleteException.prototype.getReason = function() {return this.reason; }; + + /** + * @param {gluShaderUtil.DataType} type + * @return {rrGenericVector.GenericVecType} + */ + es3fFboTestUtil.mapDataTypeToGenericVecType = function(type) { + switch (type) { + case gluShaderUtil.DataType.FLOAT_VEC4: return rrGenericVector.GenericVecType.FLOAT; + case gluShaderUtil.DataType.INT_VEC4: return rrGenericVector.GenericVecType.INT32; + case gluShaderUtil.DataType.UINT_VEC4: return rrGenericVector.GenericVecType.UINT32; + default: + throw new Error('Unrecognized type: ' + type); + } + }; + + /** + * @param {Array<number>} input + * @param {{max: number, min: number}} type min, max information + * @return {Array<number>} + */ + es3fFboTestUtil.castVectorSaturate = function(input, type) { + return [ + (input[0] + 0.5 >= type.max) ? (type.max) : ((input[0] - 0.5 <= type.min) ? (type.min) : Math.round(input[0])), + (input[1] + 0.5 >= type.max) ? (type.max) : ((input[1] - 0.5 <= type.min) ? (type.min) : Math.round(input[1])), + (input[2] + 0.5 >= type.max) ? (type.max) : ((input[2] - 0.5 <= type.min) ? (type.min) : Math.round(input[2])), + (input[3] + 0.5 >= type.max) ? (type.max) : ((input[3] - 0.5 <= type.min) ? (type.min) : Math.round(input[3])) + ]; + }; + + /** + * es3fFboTestUtil.FlatColorShader inherits from sglrShaderProgram + * @constructor + * @extends {sglrShaderProgram.ShaderProgram} + * @param {gluShaderUtil.DataType} outputType + * @param {number=} pointSize + */ + es3fFboTestUtil.FlatColorShader = function(outputType, pointSize) { + pointSize = pointSize || 1; + /** @type {sglrShaderProgram.ShaderProgramDeclaration} */ + var decl = new sglrShaderProgram.ShaderProgramDeclaration(); + /** @type {gluShaderUtil.DataType} */ this.m_outputType = outputType; + + decl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('a_position', rrGenericVector.GenericVecType.FLOAT)); + decl.pushVertexToFragmentVarying(new sglrShaderProgram.VertexToFragmentVarying(rrGenericVector.GenericVecType.FLOAT)); + decl.pushFragmentOutput(new sglrShaderProgram.FragmentOutput(es3fFboTestUtil.mapDataTypeToGenericVecType(outputType))); + decl.pushUniform(new sglrShaderProgram.Uniform('u_color', gluShaderUtil.DataType.FLOAT_VEC4)); + decl.pushVertexSource(new sglrShaderProgram.VertexSource( + '#version 300 es\n' + + 'in highp vec4 a_position;\n' + + 'void main (void)\n' + + '{\n' + + ' gl_Position = a_position;\n' + + ' gl_PointSize = ' + pointSize + '.0;\n' + + '}\n')); + decl.pushFragmentSource(new sglrShaderProgram.FragmentSource( + '#version 300 es\n' + + 'uniform highp vec4 u_color;\n' + + 'layout(location = 0) out highp ' + gluShaderUtil.getDataTypeName(outputType) + ' o_color;\n' + + 'void main (void)\n' + + '{\n' + + ' o_color = ' + gluShaderUtil.getDataTypeName(outputType) + '(u_color);\n' + + '}\n')); + sglrShaderProgram.ShaderProgram.call(this, decl); + this.m_pointSize = pointSize; + }; + + es3fFboTestUtil.FlatColorShader.prototype = Object.create(sglrShaderProgram.ShaderProgram.prototype); + es3fFboTestUtil.FlatColorShader.prototype.constructor = es3fFboTestUtil.FlatColorShader; + + /** + * @param {(WebGL2RenderingContext|sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext)} context + * @param program GL program object + * @param {Array<number>} color + */ + es3fFboTestUtil.FlatColorShader.prototype.setColor = function(context, program, color) { + /** @type {number} */ var location = context.getUniformLocation(program, 'u_color'); + + context.useProgram(program); + context.uniform4fv(location, color); + }; + + /** + * @param {Array<rrVertexAttrib.VertexAttrib>} inputs + * @param {Array<rrVertexPacket.VertexPacket>} packets + * @param {number} numPackets + */ + es3fFboTestUtil.FlatColorShader.prototype.shadeVertices = function(inputs, packets, numPackets) { + for (var packetNdx = 0; packetNdx < numPackets; ++packetNdx) { + /** @type {rrVertexPacket.VertexPacket} */ var packet = packets[packetNdx]; + packet.position = rrVertexAttrib.readVertexAttrib(inputs[0], packet.instanceNdx, packet.vertexNdx, rrGenericVector.GenericVecType.FLOAT); + packet.pointSize = this.m_pointSize; + } + }; + + /** + * @param {Array<rrFragmentOperations.Fragment>} packet + * @param {rrShadingContext.FragmentShadingContext} context + */ + es3fFboTestUtil.FlatColorShader.prototype.shadeFragments = function(packet, context) { + var numPackets = packet.length; + /** @const {Array<number>} */ var color = this.m_uniforms[0].value; + /** @const {Array<number>} */ var icolor = es3fFboTestUtil.castVectorSaturate(color, tcuTexture.deTypes.deInt32); + /** @const {Array<number>} */ var uicolor = es3fFboTestUtil.castVectorSaturate(color, tcuTexture.deTypes.deUint32); + + if (this.m_outputType == gluShaderUtil.DataType.FLOAT_VEC4) { + for (var packetNdx = 0; packetNdx < numPackets; ++packetNdx) + packet[packetNdx].value = color; + } else if (this.m_outputType == gluShaderUtil.DataType.INT_VEC4) { + for (var packetNdx = 0; packetNdx < numPackets; ++packetNdx) + packet[packetNdx].value = icolor; + } else if (this.m_outputType == gluShaderUtil.DataType.UINT_VEC4) { + for (var packetNdx = 0; packetNdx < numPackets; ++packetNdx) + packet[packetNdx].value = uicolor; + } else + throw new Error('Invalid output type: ' + this.m_outputType); + }; + + /** + * es3fFboTestUtil.GradientShader inherits from sglrShaderProgram + * @constructor + * @extends {sglrShaderProgram.ShaderProgram} + * @param {gluShaderUtil.DataType} outputType + */ + es3fFboTestUtil.GradientShader = function(outputType) { + /** @type {sglrShaderProgram.ShaderProgramDeclaration} */ + var decl = new sglrShaderProgram.ShaderProgramDeclaration(); + /** @type {gluShaderUtil.DataType} */ this.m_outputType = outputType; + decl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('a_position', rrGenericVector.GenericVecType.FLOAT)); + decl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('a_coord', rrGenericVector.GenericVecType.FLOAT)); + decl.pushVertexToFragmentVarying(new sglrShaderProgram.VertexToFragmentVarying(rrGenericVector.GenericVecType.FLOAT)); + decl.pushFragmentOutput(new sglrShaderProgram.FragmentOutput(es3fFboTestUtil.mapDataTypeToGenericVecType(outputType))); + decl.pushUniform(new sglrShaderProgram.Uniform('u_gradientMin', gluShaderUtil.DataType.FLOAT_VEC4)); + decl.pushUniform(new sglrShaderProgram.Uniform('u_gradientMax', gluShaderUtil.DataType.FLOAT_VEC4)); + decl.pushVertexSource(new sglrShaderProgram.VertexSource( + '#version 300 es\n' + + 'in highp vec4 a_position;\n' + + 'in highp vec4 a_coord;\n' + + 'out highp vec4 v_coord;\n' + + 'void main (void)\n' + + '{\n' + + ' gl_Position = a_position;\n' + + ' v_coord = a_coord;\n' + + '}\n')); + decl.pushFragmentSource(new sglrShaderProgram.FragmentSource( + '#version 300 es\n' + + 'in highp vec4 v_coord;\n' + + 'uniform highp vec4 u_gradientMin;\n' + + 'uniform highp vec4 u_gradientMax;\n' + + 'layout(location = 0) out highp ' + gluShaderUtil.getDataTypeName(outputType) + ' o_color;\n' + + 'void main (void)\n' + + '{\n' + + ' highp float x = v_coord.x;\n' + + ' highp float y = v_coord.y;\n' + + ' highp float f0 = (x + y) * 0.5;\n' + + ' highp float f1 = 0.5 + (x - y) * 0.5;\n' + + ' highp vec4 fv = vec4(f0, f1, 1.0f-f0, 1.0f-f1);\n' + + ' o_color = ' + gluShaderUtil.getDataTypeName(outputType) + '(u_gradientMin + (u_gradientMax-u_gradientMin)*fv);\n' + + '}\n')); + sglrShaderProgram.ShaderProgram.call(this, decl); + }; + + es3fFboTestUtil.GradientShader.prototype = Object.create(sglrShaderProgram.ShaderProgram.prototype); + es3fFboTestUtil.GradientShader.prototype.constructor = es3fFboTestUtil.GradientShader; + + /** + * @param {es3fFboTestUtil.Context} ctx GL-like context + * @param program GL program + * @param {Array<number>} gradientMin + * @param {Array<number>} gradientMax + */ + es3fFboTestUtil.GradientShader.prototype.setGradient = function(ctx, program, gradientMin, gradientMax) { + ctx.useProgram(program); + ctx.uniform4fv(ctx.getUniformLocation(program, 'u_gradientMin'), gradientMin); + ctx.uniform4fv(ctx.getUniformLocation(program, 'u_gradientMax'), gradientMax); + }; + + /** + * @param {Array<rrVertexAttrib.VertexAttrib>} inputs + * @param {Array<rrVertexPacket.VertexPacket>} packets + * @param {number} numPackets + */ + es3fFboTestUtil.GradientShader.prototype.shadeVertices = function(inputs, packets, numPackets) { + for (var packetNdx = 0; packetNdx < numPackets; ++packetNdx) { + /** @type {rrVertexPacket.VertexPacket} */ var packet = packets[packetNdx]; + + packet.position = rrVertexAttrib.readVertexAttrib(inputs[0], packet.instanceNdx, packet.vertexNdx, rrGenericVector.GenericVecType.FLOAT); + packet.outputs[0] = rrVertexAttrib.readVertexAttrib(inputs[1], packet.instanceNdx, packet.vertexNdx, rrGenericVector.GenericVecType.FLOAT); + } + }; + + /** + * @param {Array<rrFragmentOperations.Fragment>} packet + * @param {rrShadingContext.FragmentShadingContext} context + */ + es3fFboTestUtil.GradientShader.prototype.shadeFragments = function(packet, context) { + var numPackets = packet.length; + /** @const {Array<number>} */ var gradientMin = this.m_uniforms[0].value; + /** @const {Array<number>} */ var gradientMax = this.m_uniforms[1].value; + + for (var packetNdx = 0; packetNdx < numPackets; ++packetNdx) { + /** @const {Array<number>} */ var coord = rrShadingContext.readTriangleVarying(packet[packetNdx], context, 0); + /** @const {number} */ var x = coord[0]; + /** @const {number} */ var y = coord[1]; + /** @const {number} */ var f0 = (x + y) * 0.5; + /** @const {number} */ var f1 = 0.5 + (x - y) * 0.5; + /** @const {Array<number>} */ var fv = [f0, f1, 1.0 - f0, 1.0 - f1]; + + /** @const {Array<number>} */ var color = deMath.add(gradientMin, deMath.multiply(deMath.subtract(gradientMax, gradientMin), fv)); + /** @const {Array<number>} */ var icolor = es3fFboTestUtil.castVectorSaturate(color, tcuTexture.deTypes.deInt32); + /** @const {Array<number>} */ var uicolor = es3fFboTestUtil.castVectorSaturate(color, tcuTexture.deTypes.deUint32); + + if (this.m_outputType == gluShaderUtil.DataType.FLOAT_VEC4) + packet[packetNdx].value = color; + else if (this.m_outputType == gluShaderUtil.DataType.INT_VEC4) + packet[packetNdx].value = icolor; + else if (this.m_outputType == gluShaderUtil.DataType.UINT_VEC4) + packet[packetNdx].value = uicolor; + else + throw new Error('Invalid output type: ' + this.m_outputType); + } + }; + + /** + * @param {Array<gluShaderUtil.DataType>} samplerTypes + * @param {gluShaderUtil.DataType} outputType + * @return {string} + */ + es3fFboTestUtil.genTexFragmentShader = function(samplerTypes, outputType) { + /** @type {string} */ var precision = 'highp'; + /** @type {string} */ var src = ''; + + src = '#version 300 es\n' + + 'layout(location = 0) out highp ' + gluShaderUtil.getDataTypeName(outputType) + ' o_color0;\n' + + 'in highp vec2 v_coord;\n'; + + for (var samplerNdx = 0; samplerNdx < samplerTypes.length; samplerNdx++) { + src += 'uniform ' + precision + ' ' + gluShaderUtil.getDataTypeName(samplerTypes[samplerNdx]) + ' u_sampler' + samplerNdx + ';\n' + + 'uniform ' + precision + ' vec4 u_texScale' + samplerNdx + ';\n' + + 'uniform ' + precision + ' vec4 u_texBias' + samplerNdx + ';\n'; + } + + // Output scale & bias + src += 'uniform ' + precision + ' vec4 u_outScale0;\n' + + 'uniform ' + precision + ' vec4 u_outBias0;\n'; + + src += '\n' + + 'void main (void)\n' + + '{\n' + + ' ' + precision + ' vec4 out0 = vec4(0.0);\n'; + + // Texture input fetch and combine. + for (var inNdx = 0; inNdx < samplerTypes.length; inNdx++) + src += '\tout0 += vec4(' + + 'texture(u_sampler' + inNdx + ', v_coord)) * u_texScale' + inNdx + ' + u_texBias' + inNdx + ';\n'; + + // Write output. + src += ' o_color0 = ' + gluShaderUtil.getDataTypeName(outputType) + '(out0 * u_outScale0 + u_outBias0);\n' + + '}\n'; + + return src; + }; + + /** + * @param {Array<gluShaderUtil.DataType>} samplerTypes + * @param {gluShaderUtil.DataType} outputType + * @return {sglrShaderProgram.ShaderProgramDeclaration} + */ + es3fFboTestUtil.genTexture2DShaderDecl = function(samplerTypes, outputType) { + /** @type {sglrShaderProgram.ShaderProgramDeclaration} */ + var decl = new sglrShaderProgram.ShaderProgramDeclaration(); + + decl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('a_position', rrGenericVector.GenericVecType.FLOAT)); + decl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('a_coord', rrGenericVector.GenericVecType.FLOAT)); + decl.pushVertexToFragmentVarying(new sglrShaderProgram.VertexToFragmentVarying(rrGenericVector.GenericVecType.FLOAT)); + decl.pushFragmentOutput(new sglrShaderProgram.FragmentOutput(es3fFboTestUtil.mapDataTypeToGenericVecType(outputType))); + + decl.pushVertexSource(new sglrShaderProgram.VertexSource( + '#version 300 es\n' + + 'in highp vec4 a_position;\n' + + 'in highp vec2 a_coord;\n' + + 'out highp vec2 v_coord;\n' + + 'void main(void)\n' + + '{\n' + + ' gl_Position = a_position;\n' + + ' v_coord = a_coord;\n' + + '}\n')); + + decl.pushFragmentSource(new sglrShaderProgram.FragmentSource(es3fFboTestUtil.genTexFragmentShader(samplerTypes, outputType))); + + decl.pushUniform(new sglrShaderProgram.Uniform('u_outScale0', gluShaderUtil.DataType.FLOAT_VEC4)); + decl.pushUniform(new sglrShaderProgram.Uniform('u_outBias0', gluShaderUtil.DataType.FLOAT_VEC4)); + + for (var ndx = 0; ndx < samplerTypes.length; ++ndx) { + decl.pushUniform(new sglrShaderProgram.Uniform('u_sampler' + ndx, samplerTypes[ndx])); + decl.pushUniform(new sglrShaderProgram.Uniform('u_texScale' + ndx, gluShaderUtil.DataType.FLOAT_VEC4)); + decl.pushUniform(new sglrShaderProgram.Uniform('u_texBias' + ndx, gluShaderUtil.DataType.FLOAT_VEC4)); + } + + return decl; + }; + + /** + * For use in es3fFboTestUtil.Texture2DShader + * @constructor + */ + es3fFboTestUtil.Input = function() { + /** @type {number} */ this.unitNdx; + /** @type {Array<number>} */ this.scale; + /** @type {Array<number>} */ this.bias; + }; + + /** + * es3fFboTestUtil.Texture2DShader inherits from sglrShaderProgram + * @constructor + * @extends {sglrShaderProgram.ShaderProgram} + * @param {Array<gluShaderUtil.DataType>} samplerTypes + * @param {gluShaderUtil.DataType} outputType + * @param {Array<number>=} outScale - default [1.0, 1.0, 1.0, 1.0] + * @param {Array<number>=} outBias - default [0.0, 0.0, 0.0, 0.0] + */ + es3fFboTestUtil.Texture2DShader = function(samplerTypes, outputType, outScale, outBias) { + if (outScale === undefined) outScale = [1.0, 1.0, 1.0, 1.0]; + if (outBias === undefined) outBias = [0.0, 0.0, 0.0, 0.0]; + sglrShaderProgram.ShaderProgram.call(this, es3fFboTestUtil.genTexture2DShaderDecl(samplerTypes, outputType)); + /** @type {Array<es3fFboTestUtil.Input>} */ this.m_inputs = []; + /** @type {Array<number>} */ this.m_outScale = outScale; + /** @type {Array<number>} */ this.m_outBias = outBias; + /** @const {gluShaderUtil.DataType} */ this.m_outputType = outputType; + for (var ndx = 0; ndx < samplerTypes.length; ndx++) { + var input = new es3fFboTestUtil.Input(); + input.unitNdx = ndx; + input.scale = [1.0, 1.0, 1.0, 1.0]; + input.bias = [0.0, 0.0, 0.0, 0.0]; + this.m_inputs[ndx] = input; + } + }; + + es3fFboTestUtil.Texture2DShader.prototype = Object.create(sglrShaderProgram.ShaderProgram.prototype); + es3fFboTestUtil.Texture2DShader.prototype.constructor = es3fFboTestUtil.Texture2DShader; + + /** + * @param {number} inputNdx + * @param {number} unitNdx + */ + es3fFboTestUtil.Texture2DShader.prototype.setUnit = function(inputNdx, unitNdx) { + this.m_inputs[inputNdx].unitNdx = unitNdx; + }; + + /** + * @param {number} inputNdx + * @param {Array<number>} scale + * @param {Array<number>} bias + */ + es3fFboTestUtil.Texture2DShader.prototype.setTexScaleBias = function(inputNdx, scale, bias) { + this.m_inputs[inputNdx].scale = scale; + this.m_inputs[inputNdx].bias = bias; + }; + + /** + * @param {Array<number>} scale + * @param {Array<number>} bias + */ + es3fFboTestUtil.Texture2DShader.prototype.setOutScaleBias = function(scale, bias) { + this.m_outScale = scale; + this.m_outBias = bias; + }; + + /** + * @param context GL-like context + * @param program + */ + es3fFboTestUtil.Texture2DShader.prototype.setUniforms = function(context, program) { + context.useProgram(program); + + for (var texNdx = 0; texNdx < this.m_inputs.length; texNdx++) { + /** @type {string} */ var samplerName = 'u_sampler' + texNdx; + /** @type {string} */ var scaleName = 'u_texScale' + texNdx; + /** @type {string} */ var biasName = 'u_texBias' + texNdx; + + context.uniform1i(context.getUniformLocation(program, samplerName), this.m_inputs[texNdx].unitNdx); + context.uniform4fv(context.getUniformLocation(program, scaleName), this.m_inputs[texNdx].scale); + context.uniform4fv(context.getUniformLocation(program, biasName), this.m_inputs[texNdx].bias); + } + + context.uniform4fv(context.getUniformLocation(program, 'u_outScale0'), this.m_outScale); + context.uniform4fv(context.getUniformLocation(program, 'u_outBias0'), this.m_outBias); + }; + + /** + * @param {Array<rrVertexAttrib.VertexAttrib>} inputs + * @param {Array<rrVertexPacket.VertexPacket>} packets + * @param {number} numPackets + */ + es3fFboTestUtil.Texture2DShader.prototype.shadeVertices = function(inputs, packets, numPackets) { + // TODO: implement rrVertexAttrib.readVertexAttribFloat + for (var packetNdx = 0; packetNdx < numPackets; ++packetNdx) { + /** @type {rrVertexPacket.VertexPacket} */ var packet = packets[packetNdx]; + packet.position = rrVertexAttrib.readVertexAttrib(inputs[0], packet.instanceNdx, packet.vertexNdx, rrGenericVector.GenericVecType.FLOAT); + packet.outputs[0] = rrVertexAttrib.readVertexAttrib(inputs[1], packet.instanceNdx, packet.vertexNdx, rrGenericVector.GenericVecType.FLOAT); + } + }; + + /** + * @param {Array<rrFragmentOperations.Fragment>} packet + * @param {rrShadingContext.FragmentShadingContext} context + */ + es3fFboTestUtil.Texture2DShader.prototype.shadeFragments = function(packet, context) { + var numPackets = packet.length; + /** @type {Array<number>} */ var outScale = this.m_uniforms[0].value; + /** @type {Array<number>} */ var outBias = this.m_uniforms[1].value; + var texCoords = []; + var colors = []; + + for (var packetNdx = 0; packetNdx < numPackets; ++packetNdx) { + // setup tex coords + /** @const {Array<number>} */ var coord = rrShadingContext.readTriangleVarying(packet[packetNdx], context, 0); + texCoords = [coord[0], coord[1]]; + + // clear result + colors = [0.0, 0.0, 0.0, 0.0]; + + // sample each texture + for (var ndx = 0; ndx < this.m_inputs.length; ndx++) { + var tex = this.m_uniforms[2 + ndx * 3].sampler; + var ratioX = tex.m_view.getWidth() / context.getWidth(); + var ratioY = tex.m_view.getHeight() / context.getHeight(); + var lod = Math.floor(Math.log2(Math.max(ratioX, ratioY))); + + /** @const {Array<number>} */ var scale = this.m_uniforms[2 + ndx * 3 + 1].value; + /** @const {Array<number>} */ var bias = this.m_uniforms[2 + ndx * 3 + 2].value; + + var tmpColors = tex.sample(texCoords, lod); + + colors = deMath.add(colors, deMath.add(deMath.multiply(tmpColors, scale), bias)); + } + + // write out + /** @const {Array<number>} */ var color = deMath.add(deMath.multiply(colors, outScale), outBias); + /** @const {Array<number>} */ var icolor = es3fFboTestUtil.castVectorSaturate(color, tcuTexture.deTypes.deInt32); + /** @const {Array<number>} */ var uicolor = es3fFboTestUtil.castVectorSaturate(color, tcuTexture.deTypes.deUint32); + + if (this.m_outputType == gluShaderUtil.DataType.FLOAT_VEC4) + packet[packetNdx].value = color; + else if (this.m_outputType == gluShaderUtil.DataType.INT_VEC4) + packet[packetNdx].value = icolor; + else if (this.m_outputType == gluShaderUtil.DataType.UINT_VEC4) + packet[packetNdx].value = uicolor; + } + }; + + /** + * es3fFboTestUtil.TextureCubeShader inherits from sglrShaderProgram + * @constructor + * @extends {sglrShaderProgram.ShaderProgram} + * @param {gluShaderUtil.DataType} samplerType + * @param {gluShaderUtil.DataType} outputType + */ + es3fFboTestUtil.TextureCubeShader = function(samplerType, outputType) { + /** @type {sglrShaderProgram.ShaderProgramDeclaration} */ + var decl = new sglrShaderProgram.ShaderProgramDeclaration(); + decl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('a_position', rrGenericVector.GenericVecType.FLOAT)); + decl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('a_coord', rrGenericVector.GenericVecType.FLOAT)); + decl.pushVertexToFragmentVarying(new sglrShaderProgram.VertexToFragmentVarying(rrGenericVector.GenericVecType.FLOAT)); + decl.pushFragmentOutput(new sglrShaderProgram.FragmentOutput(es3fFboTestUtil.mapDataTypeToGenericVecType(outputType))); + decl.pushUniform(new sglrShaderProgram.Uniform('u_coordMat', gluShaderUtil.DataType.FLOAT_MAT3)); + decl.pushUniform(new sglrShaderProgram.Uniform('u_sampler0', samplerType)); + decl.pushUniform(new sglrShaderProgram.Uniform('u_scale', gluShaderUtil.DataType.FLOAT_VEC4)); + decl.pushUniform(new sglrShaderProgram.Uniform('u_bias', gluShaderUtil.DataType.FLOAT_VEC4)); + decl.pushVertexSource(new sglrShaderProgram.VertexSource( + '#version 300 es\n' + + 'in highp vec4 a_position;\n' + + 'in mediump vec2 a_coord;\n' + + 'uniform mat3 u_coordMat;\n' + + 'out mediump vec3 v_coord;\n' + + 'void main (void)\n' + + '{\n' + + ' gl_Position = a_position;\n' + + ' v_coord = u_coordMat * vec3(a_coord, 1.0);\n' + + '}\n')); + decl.pushFragmentSource(new sglrShaderProgram.FragmentSource( + '#version 300 es\n' + + 'uniform highp ' + gluShaderUtil.getDataTypeName(samplerType) + ' u_sampler0;\n' + + 'uniform highp vec4 u_scale;\n' + + 'uniform highp vec4 u_bias;\n' + + 'in mediump vec3 v_coord;\n' + + 'layout(location = 0) out highp ' + gluShaderUtil.getDataTypeName(outputType) + ' o_color;\n' + + 'void main (void)\n' + + '{\n' + + ' o_color = ' + gluShaderUtil.getDataTypeName(outputType) + '(vec4(texture(u_sampler0, v_coord)) * u_scale + u_bias);\n' + + '}\n')); + sglrShaderProgram.ShaderProgram.call(this, decl); + /** @type {Array<number>} */ this.m_texScale = [1.0, 1.0, 1.0, 1.0]; + /** @type {Array<number>} */ this.m_texBias = [0.0, 0.0, 0.0, 0.0]; + /** @type {tcuMatrix.Mat3} */ this.m_coordMat; + /** @type {gluShaderUtil.DataType} */ this.m_outputType = outputType; + }; + + es3fFboTestUtil.TextureCubeShader.prototype = Object.create(sglrShaderProgram.ShaderProgram.prototype); + es3fFboTestUtil.TextureCubeShader.prototype.constructor = es3fFboTestUtil.TextureCubeShader; + + /** + * @param {tcuTexture.CubeFace} face + */ + es3fFboTestUtil.TextureCubeShader.prototype.setFace = function(face) { + /** @const {Array<Array<number>>} */ var s_cubeTransforms = [ + // Face -X: (x, y, 1) -> (-1, -(2*y-1), +(2*x-1)) + [0, 0, -1, + 0, -2, 1, + 2, 0, -1], + // Face +X: (x, y, 1) -> (+1, -(2*y-1), -(2*x-1)) + [0, 0, 1, + 0, -2, 1, + -2, 0, 1], + // Face -Y: (x, y, 1) -> (+(2*x-1), -1, -(2*y-1)) + [2, 0, -1, + 0, 0, -1, + 0, -2, 1], + // Face +Y: (x, y, 1) -> (+(2*x-1), +1, +(2*y-1)) + [2, 0, -1, + 0, 0, 1, + 0, 2, -1], + // Face -Z: (x, y, 1) -> (-(2*x-1), -(2*y-1), -1) + [-2, 0, 1, + 0, -2, 1, + 0, 0, -1], + // Face +Z: (x, y, 1) -> (+(2*x-1), -(2*y-1), +1) + [2, 0, -1, + 0, -2, 1, + 0, 0, 1]]; + this.m_coordMat = /** @type {tcuMatrix.Mat3} */ (tcuMatrix.matrixFromArray(3, 3, s_cubeTransforms[face])); + }; + + /** + * @param {Array<number>} scale + * @param {Array<number>} bias + */ + es3fFboTestUtil.TextureCubeShader.prototype.setTexScaleBias = function(scale, bias) { + this.m_texScale = scale; + this.m_texBias = bias; + }; + + /** + * @param ctx GL-like context + * @param program + */ + es3fFboTestUtil.TextureCubeShader.prototype.setUniforms = function(ctx, program) { + ctx.useProgram(program); + + ctx.uniform1i(ctx.getUniformLocation(program, 'u_sampler0'), 0); + ctx.uniformMatrix3fv(ctx.getUniformLocation(program, 'u_coordMat'), false, this.m_coordMat.getColumnMajorData()); + ctx.uniform4fv(ctx.getUniformLocation(program, 'u_scale'), this.m_texScale); + ctx.uniform4fv(ctx.getUniformLocation(program, 'u_bias'), this.m_texBias); + }; + + /** + * @param {Array<rrVertexAttrib.VertexAttrib>} inputs + * @param {Array<rrVertexPacket.VertexPacket>} packets + * @param {number} numPackets + */ + es3fFboTestUtil.TextureCubeShader.prototype.shadeVertices = function(inputs, packets, numPackets) { + /** @type {tcuMatrix.Matrix} */ var texCoordMat = tcuMatrix.matrixFromArray(3, 3, this.m_uniforms[0].value); + + for (var packetNdx = 0; packetNdx < numPackets; ++packetNdx) { + /** @type {rrVertexPacket.VertexPacket} */ var packet = packets[packetNdx]; + var x = rrVertexAttrib.readVertexAttrib(inputs[1], packet.instanceNdx, packet.vertexNdx, rrGenericVector.GenericVecType.FLOAT)[0]; + var y = rrVertexAttrib.readVertexAttrib(inputs[1], packet.instanceNdx, packet.vertexNdx, rrGenericVector.GenericVecType.FLOAT)[1]; + /** @type {Array<number>} */ var a_coord = [x, y]; + /** @type {Array<number>} */ var v_coord = tcuMatrix.multiplyMatVec(texCoordMat, [a_coord[0], a_coord[1], 1.0]); + + packet.position = rrVertexAttrib.readVertexAttrib(inputs[0], packet.instanceNdx, packet.vertexNdx, rrGenericVector.GenericVecType.FLOAT); + packet.outputs[0] = [v_coord[0], v_coord[1], v_coord[2], 0.0]; + } + }; + + /** + * @param {Array<rrFragmentOperations.Fragment>} packet + * @param {rrShadingContext.FragmentShadingContext} context + */ + es3fFboTestUtil.TextureCubeShader.prototype.shadeFragments = function(packet, context) { + var numPackets = packet.length; + /** @const {Array<number>} */ var texScale = this.m_uniforms[2].value; + /** @const {Array<number>} */ var texBias = this.m_uniforms[3].value; + + var texCoords = []; + var colors = []; + + for (var packetNdx = 0; packetNdx < numPackets; ++packetNdx) { + var tex = this.m_uniforms[1].sampler; + var ratioX = tex.m_view.getSize() / context.getWidth(); + var ratioY = tex.m_view.getSize() / context.getHeight(); + var lod = Math.floor(Math.log2(Math.max(ratioX, ratioY))); + + var coord = rrShadingContext.readTriangleVarying(packet[packetNdx], context, 0); + texCoords = [coord[0], coord[1], coord[2]]; + + colors = tex.sample(texCoords, lod); + + var color = deMath.add(deMath.multiply(colors, texScale), texBias); + var icolor = es3fFboTestUtil.castVectorSaturate(color, tcuTexture.deTypes.deInt32); + var uicolor = es3fFboTestUtil.castVectorSaturate(color, tcuTexture.deTypes.deUint32); + + if (this.m_outputType == gluShaderUtil.DataType.FLOAT_VEC4) + packet[packetNdx].value = color; + else if (this.m_outputType == gluShaderUtil.DataType.INT_VEC4) + packet[packetNdx].value = icolor; + else if (this.m_outputType == gluShaderUtil.DataType.UINT_VEC4) + packet[packetNdx].value = uicolor; + } + }; + + /** + * es3fFboTestUtil.Texture2DArrayShader inherits from sglrShaderProgram + * @constructor + * @extends {sglrShaderProgram.ShaderProgram} + * @param {gluShaderUtil.DataType} samplerType + * @param {gluShaderUtil.DataType} outputType + */ + es3fFboTestUtil.Texture2DArrayShader = function(samplerType, outputType) { + /** @type {sglrShaderProgram.ShaderProgramDeclaration} */ + var decl = new sglrShaderProgram.ShaderProgramDeclaration(); + decl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('a_position', rrGenericVector.GenericVecType.FLOAT)); + decl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('a_coord', rrGenericVector.GenericVecType.FLOAT)); + decl.pushVertexToFragmentVarying(new sglrShaderProgram.VertexToFragmentVarying(rrGenericVector.GenericVecType.FLOAT)); + decl.pushFragmentOutput(new sglrShaderProgram.FragmentOutput(es3fFboTestUtil.mapDataTypeToGenericVecType(outputType))); + decl.pushUniform(new sglrShaderProgram.Uniform('u_sampler0', samplerType)); + decl.pushUniform(new sglrShaderProgram.Uniform('u_scale', gluShaderUtil.DataType.FLOAT_VEC4)); + decl.pushUniform(new sglrShaderProgram.Uniform('u_bias', gluShaderUtil.DataType.FLOAT_VEC4)); + decl.pushUniform(new sglrShaderProgram.Uniform('u_layer', gluShaderUtil.DataType.INT)); + decl.pushVertexSource(new sglrShaderProgram.VertexSource( + '#version 300 es\n' + + 'in highp vec4 a_position;\n' + + 'in highp vec2 a_coord;\n' + + 'out highp vec2 v_coord;\n' + + 'void main (void)\n' + + '{\n' + + ' gl_Position = a_position;\n' + + ' v_coord = a_coord;\n' + + '}\n')); + decl.pushFragmentSource(new sglrShaderProgram.FragmentSource( + '#version 300 es\n' + + 'uniform highp ' + gluShaderUtil.getDataTypeName(samplerType) + ' u_sampler0;\n' + + 'uniform highp vec4 u_scale;\n' + + 'uniform highp vec4 u_bias;\n' + + 'uniform highp int u_layer;\n' + + 'in highp vec2 v_coord;\n' + + 'layout(location = 0) out highp ' + gluShaderUtil.getDataTypeName(outputType) + ' o_color;\n' + + 'void main (void)\n' + + '{\n' + + ' o_color = ' + gluShaderUtil.getDataTypeName(outputType) + '(vec4(texture(u_sampler0, vec3(v_coord, u_layer))) * u_scale + u_bias);\n' + + '}\n')); + sglrShaderProgram.ShaderProgram.call(this, decl); + /** @type {Array<number>} */ this.m_texScale = [1.0, 1.0, 1.0, 1.0]; + /** @type {Array<number>} */ this.m_texBias = [0.0, 0.0, 0.0, 0.0]; + /** @type {number} */ this.m_layer = 0; + /** @type {gluShaderUtil.DataType} */ this.m_outputType = outputType; + }; + + es3fFboTestUtil.Texture2DArrayShader.prototype = Object.create(sglrShaderProgram.ShaderProgram.prototype); + es3fFboTestUtil.Texture2DArrayShader.prototype.constructor = es3fFboTestUtil.Texture2DArrayShader; + + /** + * @param {number} layer + */ + es3fFboTestUtil.Texture2DArrayShader.prototype.setLayer = function(layer) { + this.m_layer = layer; + }; + /** + * @param {Array<number>} scale + * @param {Array<number>} bias + */ + es3fFboTestUtil.Texture2DArrayShader.prototype.setTexScaleBias = function(scale, bias) { + this.m_texScale = scale; + this.m_texBias = bias; + }; + /** + * @param {es3fFboTestUtil.Context} ctx GL-like context + * @param program + */ + es3fFboTestUtil.Texture2DArrayShader.prototype.setUniforms = function(ctx, program) { + ctx.useProgram(program); + + ctx.uniform1i(ctx.getUniformLocation(program, 'u_sampler0'), 0); + ctx.uniform1i(ctx.getUniformLocation(program, 'u_layer'), this.m_layer); + ctx.uniform4fv(ctx.getUniformLocation(program, 'u_scale'), this.m_texScale); + ctx.uniform4fv(ctx.getUniformLocation(program, 'u_bias'), this.m_texBias); + }; + + /** + * @param {Array<rrVertexAttrib.VertexAttrib>} inputs + * @param {Array<rrVertexPacket.VertexPacket>} packets + * @param {number} numPackets + */ + es3fFboTestUtil.Texture2DArrayShader.prototype.shadeVertices = function(inputs, packets, numPackets) { + for (var packetNdx = 0; packetNdx < numPackets; ++packetNdx) { + /** @type {rrVertexPacket.VertexPacket} */ var packet = packets[packetNdx]; + + packet.position = rrVertexAttrib.readVertexAttrib(inputs[0], packet.instanceNdx, packet.vertexNdx, rrGenericVector.GenericVecType.FLOAT); + packet.outputs[0] = rrVertexAttrib.readVertexAttrib(inputs[1], packet.instanceNdx, packet.vertexNdx, rrGenericVector.GenericVecType.FLOAT); + } + }; + + /** + * @param {Array<rrFragmentOperations.Fragment>} packet + * @param {rrShadingContext.FragmentShadingContext} context + */ + es3fFboTestUtil.Texture2DArrayShader.prototype.shadeFragments = function(packet, context) { + var numPackets = packet.length; + /** @const {Array<number>} */ var texScale = this.m_uniforms[1].value; + /** @const {Array<number>} */ var texBias = this.m_uniforms[2].value; + /** @const {number} */ var layer = this.m_uniforms[3].value[0]; + + var texCoords = []; + var colors = []; + + for (var packetNdx = 0; packetNdx < numPackets; ++packetNdx) { + var tex = this.m_uniforms[0].sampler; + var ratioX = tex.m_view.getWidth() / context.getWidth(); + var ratioY = tex.m_view.getHeight() / context.getHeight(); + var lod = Math.floor(Math.log2(Math.max(ratioX, ratioY))); + + /** @const {Array<number>} */ var coord = rrShadingContext.readTriangleVarying(packet[packetNdx], context, 0); + texCoords = [coord[0], coord[1], layer]; + + colors = tex.sample(texCoords, lod); + + /** @const {Array<number>} */ var color = deMath.add(deMath.multiply(colors, texScale), texBias); + /** @const {Array<number>} */ var icolor = es3fFboTestUtil.castVectorSaturate(color, tcuTexture.deTypes.deInt32); + /** @const {Array<number>} */ var uicolor = es3fFboTestUtil.castVectorSaturate(color, tcuTexture.deTypes.deUint32); + + if (this.m_outputType == gluShaderUtil.DataType.FLOAT_VEC4) + packet[packetNdx].value = color; + else if (this.m_outputType == gluShaderUtil.DataType.INT_VEC4) + packet[packetNdx].value = icolor; + else if (this.m_outputType == gluShaderUtil.DataType.UINT_VEC4) + packet[packetNdx].value = uicolor; + } + }; + + /** + * es3fFboTestUtil.Texture3DShader inherits from sglrShaderProgram + * @constructor + * @extends {sglrShaderProgram.ShaderProgram} + * @param {gluShaderUtil.DataType} samplerType + * @param {gluShaderUtil.DataType} outputType + */ + es3fFboTestUtil.Texture3DShader = function(samplerType, outputType) { + /** @type {sglrShaderProgram.ShaderProgramDeclaration} */ + var decl = new sglrShaderProgram.ShaderProgramDeclaration(); + decl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('a_position', rrGenericVector.GenericVecType.FLOAT)); + decl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('a_coord', rrGenericVector.GenericVecType.FLOAT)); + decl.pushVertexToFragmentVarying(new sglrShaderProgram.VertexToFragmentVarying(rrGenericVector.GenericVecType.FLOAT)); + decl.pushFragmentOutput(new sglrShaderProgram.FragmentOutput(es3fFboTestUtil.mapDataTypeToGenericVecType(outputType))); + decl.pushUniform(new sglrShaderProgram.Uniform('u_sampler0', samplerType)); + decl.pushUniform(new sglrShaderProgram.Uniform('u_scale', gluShaderUtil.DataType.FLOAT_VEC4)); + decl.pushUniform(new sglrShaderProgram.Uniform('u_bias', gluShaderUtil.DataType.FLOAT_VEC4)); + decl.pushUniform(new sglrShaderProgram.Uniform('u_depth', gluShaderUtil.DataType.FLOAT)); + decl.pushVertexSource(new sglrShaderProgram.VertexSource( + '#version 300 es\n' + + 'in highp vec4 a_position;\n' + + 'in highp vec2 a_coord;\n' + + 'out highp vec2 v_coord;\n' + + 'void main (void)\n' + + '{\n' + + ' gl_Position = a_position;\n' + + ' v_coord = a_coord;\n' + + '}\n')); + decl.pushFragmentSource(new sglrShaderProgram.FragmentSource( + '#version 300 es\n' + + 'uniform highp ' + gluShaderUtil.getDataTypeName(samplerType) + ' u_sampler0;\n' + + 'uniform highp vec4 u_scale;\n' + + 'uniform highp vec4 u_bias;\n' + + 'uniform highp float u_depth;\n' + + 'in highp vec2 v_coord;\n' + + 'layout(location = 0) out highp ' + gluShaderUtil.getDataTypeName(outputType) + ' o_color;\n' + + 'void main (void)\n' + + '{\n' + + ' o_color = ' + gluShaderUtil.getDataTypeName(outputType) + '(vec4(texture(u_sampler0, vec3(v_coord, u_depth))) * u_scale + u_bias);\n' + + '}\n')); + sglrShaderProgram.ShaderProgram.call(this, decl); + /** @type {Array<number>} */ this.m_texScale = [1.0, 1.0, 1.0, 1.0]; + /** @type {Array<number>} */ this.m_texBias = [0.0, 0.0, 0.0, 0.0]; + /** @type {number} */ this.m_depth = 0.0; + /** @type {gluShaderUtil.DataType} */ this.m_outputType = outputType; + }; + + es3fFboTestUtil.Texture3DShader.prototype = Object.create(sglrShaderProgram.ShaderProgram.prototype); + es3fFboTestUtil.Texture3DShader.prototype.constructor = es3fFboTestUtil.Texture3DShader; + + /** + * @param {number} depth + */ + es3fFboTestUtil.Texture3DShader.prototype.setDepth = function(depth) { + this.m_depth = depth; + }; + + /** + * @param {Array<number>} scale + * @param {Array<number>} bias + */ + es3fFboTestUtil.Texture3DShader.prototype.setTexScaleBias = function(scale, bias) { + this.m_texScale = scale; + this.m_texBias = bias; + }; + + /** + * @param context GL-like context + * @param program + */ + es3fFboTestUtil.Texture3DShader.prototype.setUniforms = function(context, program) { + context.useProgram(program); + context.uniform1i(context.getUniformLocation(program, 'u_sampler0'), 0); + context.uniform1f(context.getUniformLocation(program, 'u_depth'), this.m_depth); + context.uniform4fv(context.getUniformLocation(program, 'u_scale'), this.m_texScale); + context.uniform4fv(context.getUniformLocation(program, 'u_bias'), this.m_texBias); + }; + + /** + * @param {Array<rrVertexAttrib.VertexAttrib>} inputs + * @param {Array<rrVertexPacket.VertexPacket>} packets + * @param {number} numPackets + */ + es3fFboTestUtil.Texture3DShader.prototype.shadeVertices = function(inputs, packets, numPackets) { + for (var packetNdx = 0; packetNdx < numPackets; ++packetNdx) { + /** @type {rrVertexPacket.VertexPacket} */ var packet = packets[packetNdx]; + + packet.position = rrVertexAttrib.readVertexAttrib(inputs[0], packet.instanceNdx, packet.vertexNdx, rrGenericVector.GenericVecType.FLOAT); + packet.outputs[0] = rrVertexAttrib.readVertexAttrib(inputs[1], packet.instanceNdx, packet.vertexNdx, rrGenericVector.GenericVecType.FLOAT); + } + }; + + /** + * @param {Array<rrFragmentOperations.Fragment>} packet + * @param {rrShadingContext.FragmentShadingContext} context + */ + es3fFboTestUtil.Texture3DShader.prototype.shadeFragments = function(packet, context) { + var numPackets = packet.length; + /** @const {Array<number>} */ var texScale = this.m_uniforms[1].value; + /** @const {Array<number>} */ var texBias = this.m_uniforms[2].value; + /** @const {number} */ var depth = this.m_uniforms[3].value[0]; + + var texCoords = []; + var colors = []; + + for (var packetNdx = 0; packetNdx < numPackets; ++packetNdx) { + var tex = this.m_uniforms[0].sampler; + var ratioX = tex.m_view.getWidth() / context.getWidth(); + var ratioY = tex.m_view.getHeight() / context.getHeight(); + // TODO: what to do with Z coordinate? + var lod = Math.floor(Math.log2(Math.max(ratioX, ratioY))); + + var coord = rrShadingContext.readTriangleVarying(packet[packetNdx], context, 0); + texCoords = [coord[0], coord[1], depth]; + + colors = tex.sample(texCoords, lod); + + /** @const {Array<number>} */ var color = deMath.add(deMath.multiply(colors, texScale), texBias); + /** @const {Array<number>} */ var icolor = es3fFboTestUtil.castVectorSaturate(color, tcuTexture.deTypes.deInt32); + /** @const {Array<number>} */ var uicolor = es3fFboTestUtil.castVectorSaturate(color, tcuTexture.deTypes.deUint32); + + if (this.m_outputType == gluShaderUtil.DataType.FLOAT_VEC4) + packet[packetNdx].value = color; + else if (this.m_outputType == gluShaderUtil.DataType.INT_VEC4) + packet[packetNdx].value = icolor; + else if (this.m_outputType == gluShaderUtil.DataType.UINT_VEC4) + packet[packetNdx].value = uicolor; + } + }; + + /** + * es3fFboTestUtil.DepthGradientShader inherits from sglrShaderProgram + * @constructor + * @extends {sglrShaderProgram.ShaderProgram} + * @param {gluShaderUtil.DataType} outputType + */ + es3fFboTestUtil.DepthGradientShader = function(outputType) { + /** @type {sglrShaderProgram.ShaderProgramDeclaration} */ + var decl = new sglrShaderProgram.ShaderProgramDeclaration(); + decl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('a_position', rrGenericVector.GenericVecType.FLOAT)); + decl.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('a_coord', rrGenericVector.GenericVecType.FLOAT)); + decl.pushVertexToFragmentVarying(new sglrShaderProgram.VertexToFragmentVarying(rrGenericVector.GenericVecType.FLOAT)); + decl.pushFragmentOutput(new sglrShaderProgram.FragmentOutput(es3fFboTestUtil.mapDataTypeToGenericVecType(outputType))); + decl.pushUniform(new sglrShaderProgram.Uniform('u_maxGradient', gluShaderUtil.DataType.FLOAT)); + decl.pushUniform(new sglrShaderProgram.Uniform('u_minGradient', gluShaderUtil.DataType.FLOAT)); + decl.pushUniform(new sglrShaderProgram.Uniform('u_color', gluShaderUtil.DataType.FLOAT_VEC4)); + decl.pushVertexSource(new sglrShaderProgram.VertexSource( + '#version 300 es\n' + + 'in highp vec4 a_position;\n' + + 'in highp vec4 a_coord;\n' + + 'out highp vec4 v_coord;\n' + + 'void main (void)\n' + + '{\n' + + ' gl_Position = a_position;\n' + + ' v_coord = a_coord;\n' + + '}\n')); + decl.pushFragmentSource(new sglrShaderProgram.FragmentSource( + '#version 300 es\n' + + 'in highp vec4 v_coord;\n' + + 'uniform highp float u_minGradient;\n' + + 'uniform highp float u_maxGradient;\n' + + 'uniform highp vec4 u_color;\n' + + 'layout(location = 0) out highp ' + gluShaderUtil.getDataTypeName(outputType) + ' o_color;\n' + + 'void main (void)\n' + + '{\n' + + ' highp float x = v_coord.x;\n' + + ' highp float y = v_coord.y;\n' + + ' highp float f0 = (x + y) * 0.5;\n' + + ' gl_FragDepth = u_minGradient + (u_maxGradient-u_minGradient)*f0;\n' + + ' o_color = ' + gluShaderUtil.getDataTypeName(outputType) + '(u_color);\n' + + '}\n')); + this.m_outputType = outputType; + sglrShaderProgram.ShaderProgram.call(this, decl); + /** @const {sglrShaderProgram.Uniform} */ this.u_minGradient = this.getUniformByName('u_minGradient'); + /** @const {sglrShaderProgram.Uniform} */ this.u_maxGradient = this.getUniformByName('u_maxGradient'); + /** @const {sglrShaderProgram.Uniform} */ this.u_color = this.getUniformByName('u_color'); + }; + + es3fFboTestUtil.DepthGradientShader.prototype = Object.create(sglrShaderProgram.ShaderProgram.prototype); + es3fFboTestUtil.DepthGradientShader.prototype.constructor = es3fFboTestUtil.DepthGradientShader; + + /** + * @param ctx GL-like context + * @param program + * @param {number} gradientMin + * @param {number} gradientMax + * @param {Array<number>} color + */ + es3fFboTestUtil.DepthGradientShader.prototype.setUniforms = function(ctx, program, gradientMin, gradientMax, color) { + ctx.useProgram(program); + ctx.uniform1fv(ctx.getUniformLocation(program, 'u_minGradient'), [gradientMin]); + ctx.uniform1fv(ctx.getUniformLocation(program, 'u_maxGradient'), [gradientMax]); + ctx.uniform4fv(ctx.getUniformLocation(program, 'u_color'), color); + }; + + /** + * @param {Array<rrVertexAttrib.VertexAttrib>} inputs + * @param {Array<rrVertexPacket.VertexPacket>} packets + * @param {number} numPackets + */ + es3fFboTestUtil.DepthGradientShader.prototype.shadeVertices = function(inputs, packets, numPackets) { + for (var packetNdx = 0; packetNdx < numPackets; ++packetNdx) { + /** @type {rrVertexPacket.VertexPacket} */ var packet = packets[packetNdx]; + + packet.position = rrVertexAttrib.readVertexAttrib(inputs[0], packet.instanceNdx, packet.vertexNdx, rrGenericVector.GenericVecType.FLOAT); + packet.outputs[0] = rrVertexAttrib.readVertexAttrib(inputs[1], packet.instanceNdx, packet.vertexNdx, rrGenericVector.GenericVecType.FLOAT); + } + }; + + /** + * @param {Array<rrFragmentOperations.Fragment>} packet + * @param {rrShadingContext.FragmentShadingContext} context + */ + es3fFboTestUtil.DepthGradientShader.prototype.shadeFragments = function(packet, context) { + var numPackets = packet.length; + /** @const {number} */ var gradientMin = this.u_minGradient.value[0]; + /** @const {number} */ var gradientMax = this.u_maxGradient.value[0]; + /** @type {Array<number>} */ var color = this.u_color.value; + /** @type {Array<number>} */ var icolor = es3fFboTestUtil.castVectorSaturate(color, tcuTexture.deTypes.deInt32); + /** @type {Array<number>} */ var uicolor = es3fFboTestUtil.castVectorSaturate(color, tcuTexture.deTypes.deUint32); + + for (var packetNdx = 0; packetNdx < numPackets; ++packetNdx) { + /** @type {Array<number>} */ var coord = rrShadingContext.readTriangleVarying(packet[packetNdx], context, 0); + /** @const {number} */ var x = coord[0]; + /** @const {number} */ var y = coord[1]; + /** @const {number} */ var f0 = (x + y) * 0.5; + + packet[packetNdx].sampleDepths[0] = gradientMin + (gradientMax - gradientMin) * f0; + + if (this.m_outputType == gluShaderUtil.DataType.FLOAT_VEC4) + packet[packetNdx].value = color; + else if (this.m_outputType == gluShaderUtil.DataType.INT_VEC4) + packet[packetNdx].value = icolor; + else if (this.m_outputType == gluShaderUtil.DataType.UINT_VEC4) + packet[packetNdx].value = uicolor; + } + }; + + es3fFboTestUtil.getFormatName = function(format) { + switch (format) { + case gl.RGB565: return 'rgb565'; + case gl.RGB5_A1: return 'rgb5_a1'; + case gl.RGBA4: return 'rgba4'; + case gl.DEPTH_COMPONENT16: return 'depth_component16'; + case gl.STENCIL_INDEX8: return 'stencil_index8'; + case gl.RGBA32F: return 'rgba32f'; + case gl.RGBA32I: return 'rgba32i'; + case gl.RGBA32UI: return 'rgba32ui'; + case gl.RGBA16F: return 'rgba16f'; + case gl.RGBA16I: return 'rgba16i'; + case gl.RGBA16UI: return 'rgba16ui'; + case gl.RGBA8: return 'rgba8'; + case gl.RGBA8I: return 'rgba8i'; + case gl.RGBA8UI: return 'rgba8ui'; + case gl.SRGB8_ALPHA8: return 'srgb8_alpha8'; + case gl.RGB10_A2: return 'rgb10_a2'; + case gl.RGB10_A2UI: return 'rgb10_a2ui'; + case gl.RGBA8_SNORM: return 'rgba8_snorm'; + case gl.RGB8: return 'rgb8'; + case gl.R11F_G11F_B10F: return 'r11f_g11f_b10f'; + case gl.RGB32F: return 'rgb32f'; + case gl.RGB32I: return 'rgb32i'; + case gl.RGB32UI: return 'rgb32ui'; + case gl.RGB16F: return 'rgb16f'; + case gl.RGB16I: return 'rgb16i'; + case gl.RGB16UI: return 'rgb16ui'; + case gl.RGB8_SNORM: return 'rgb8_snorm'; + case gl.RGB8I: return 'rgb8i'; + case gl.RGB8UI: return 'rgb8ui'; + case gl.SRGB8: return 'srgb8'; + case gl.RGB9_E5: return 'rgb9_e5'; + case gl.RG32F: return 'rg32f'; + case gl.RG32I: return 'rg32i'; + case gl.RG32UI: return 'rg32ui'; + case gl.RG16F: return 'rg16f'; + case gl.RG16I: return 'rg16i'; + case gl.RG16UI: return 'rg16ui'; + case gl.RG8: return 'rg8'; + case gl.RG8I: return 'rg8i'; + case gl.RG8UI: return 'rg8ui'; + case gl.RG8_SNORM: return 'rg8_snorm'; + case gl.R32F: return 'r32f'; + case gl.R32I: return 'r32i'; + case gl.R32UI: return 'r32ui'; + case gl.R16F: return 'r16f'; + case gl.R16I: return 'r16i'; + case gl.R16UI: return 'r16ui'; + case gl.R8: return 'r8'; + case gl.R8I: return 'r8i'; + case gl.R8UI: return 'r8ui'; + case gl.R8_SNORM: return 'r8_snorm'; + case gl.DEPTH_COMPONENT32F: return 'depth_component32f'; + case gl.DEPTH_COMPONENT24: return 'depth_component24'; + case gl.DEPTH32F_STENCIL8: return 'depth32f_stencil8'; + case gl.DEPTH24_STENCIL8: return 'depth24_stencil8'; + + default: + throw new Error('Unknown format in getFromatName()'); + } + }; + + /** + * @param {tcuTexture.TextureFormat} format + * @return {gluShaderUtil.DataType} + */ + es3fFboTestUtil.getFragmentOutputType = function(format) { + switch (tcuTexture.getTextureChannelClass(format.type)) { + case tcuTexture.TextureChannelClass.FLOATING_POINT: + case tcuTexture.TextureChannelClass.SIGNED_FIXED_POINT: + case tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT: + return gluShaderUtil.DataType.FLOAT_VEC4; + + case tcuTexture.TextureChannelClass.UNSIGNED_INTEGER: + return gluShaderUtil.DataType.UINT_VEC4; + + case tcuTexture.TextureChannelClass.SIGNED_INTEGER: + return gluShaderUtil.DataType.INT_VEC4; + + default: + throw new Error('Unknown format'); + } + }; + + /** + * @param {tcuTexture.TextureFormat} format + * @return {tcuTexture.TextureFormat} + */ + es3fFboTestUtil.getFramebufferReadFormat = function(format) { + switch (tcuTexture.getTextureChannelClass(format.type)) { + case tcuTexture.TextureChannelClass.FLOATING_POINT: + return new tcuTexture.TextureFormat(tcuTexture.ChannelOrder.RGBA, tcuTexture.ChannelType.FLOAT); + + case tcuTexture.TextureChannelClass.SIGNED_FIXED_POINT: + case tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT: + return new tcuTexture.TextureFormat(tcuTexture.ChannelOrder.RGBA, tcuTexture.ChannelType.UNORM_INT8); + + case tcuTexture.TextureChannelClass.UNSIGNED_INTEGER: + return new tcuTexture.TextureFormat(tcuTexture.ChannelOrder.RGBA, tcuTexture.ChannelType.UNSIGNED_INT32); + + case tcuTexture.TextureChannelClass.SIGNED_INTEGER: + return new tcuTexture.TextureFormat(tcuTexture.ChannelOrder.RGBA, tcuTexture.ChannelType.SIGNED_INT32); + + default: + throw new Error('Unknown format in es3fFboTestUtil.getFramebufferReadFormat()'); + } + }; + + /** + * @param {es3fFboTestUtil.Context} ctx GL-like context + * @param {tcuTexture.TextureFormat} format + * @param {Array<number>} value + */ + es3fFboTestUtil.clearColorBuffer = function(ctx, format, value) { + /** @const @type {tcuTexture.TextureChannelClass} */ + var fmtClass = tcuTexture.getTextureChannelClass(format.type); + + switch (fmtClass) { + case tcuTexture.TextureChannelClass.FLOATING_POINT: + case tcuTexture.TextureChannelClass.SIGNED_FIXED_POINT: + case tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT: + ctx.clearBufferfv(gl.COLOR, 0, value); + break; + + case tcuTexture.TextureChannelClass.UNSIGNED_INTEGER: + ctx.clearBufferuiv(gl.COLOR, 0, value); + break; + + case tcuTexture.TextureChannelClass.SIGNED_INTEGER: + ctx.clearBufferiv(gl.COLOR, 0, value); + break; + + default: + throw new Error('Invalid channel class: ' + fmtClass); + } + }; + + /** + * @param {tcuTexture.TextureFormat} format + * @return {tcuRGBA.RGBA} + */ + es3fFboTestUtil.getThresholdFromTextureFormat = function(format) { + /** @const @type {Array<number>} */ var bits = tcuTextureUtil.getTextureFormatMantissaBitDepth(format); + return tcuRGBA.newRGBAComponents( + es3fFboTestUtil.calculateU8ConversionError(bits[0]), + es3fFboTestUtil.calculateU8ConversionError(bits[1]), + es3fFboTestUtil.calculateU8ConversionError(bits[2]), + es3fFboTestUtil.calculateU8ConversionError(bits[3]) + ); + }; + + /** + * @param {number} glFormat + * @return {tcuRGBA.RGBA} + */ + es3fFboTestUtil.getFormatThreshold = function(glFormat) { + /** @const @type {tcuTexture.TextureFormat} */ var format = gluTextureUtil.mapGLInternalFormat(glFormat); + return es3fFboTestUtil.getThresholdFromTextureFormat(format); + }; + + /** + * @param {number} srcBits + * @return {number} + */ + es3fFboTestUtil.getToSRGB8ConversionError = function(srcBits) { + // \note These are pre-computed based on simulation results. + /** @const @type {Array<number>} */ var errors = [ + 1, // 0 bits - rounding + 255, // 1 bits + 157, // 2 bits + 106, // 3 bits + 74, // 4 bits + 51, // 5 bits + 34, // 6 bits + 22, // 7 bits + 13, // 8 bits + 7, // 9 bits + 4, // 10 bits + 3, // 11 bits + 2 // 12 bits + // 1 from this on + ]; + + DE_ASSERT(srcBits >= 0); + if (srcBits < errors.length) + return errors[srcBits]; + else + return 1; + }; + + /** + * @param {tcuTexture.TextureFormat} src + * @param {tcuTexture.TextureFormat} dst + * @return {tcuRGBA.RGBA} + */ + es3fFboTestUtil.getToSRGBConversionThreshold = function(src, dst) { + // Only SRGB8 and SRGB8_ALPHA8 formats are supported. + DE_ASSERT(dst.type == tcuTexture.ChannelType.UNORM_INT8); + DE_ASSERT(dst.order == tcuTexture.ChannelOrder.sRGB || dst.order == tcuTexture.ChannelOrder.sRGBA); + + /** @const @type {Array<number>} */ var bits = tcuTextureUtil.getTextureFormatMantissaBitDepth(src); + /** @const @type {boolean} */ var dstHasAlpha = dst.order == tcuTexture.ChannelOrder.sRGBA; + + return tcuRGBA.newRGBAComponents( + es3fFboTestUtil.getToSRGB8ConversionError(bits[0]), + es3fFboTestUtil.getToSRGB8ConversionError(bits[1]), + es3fFboTestUtil.getToSRGB8ConversionError(bits[2]), + dstHasAlpha ? es3fFboTestUtil.calculateU8ConversionError(bits[3]) : 0); + }; + + /** + * es3fFboTestUtil.readPixels() + * @param {(WebGL2RenderingContext|sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext)} ctx + * @param {tcuSurface.Surface} dst + * @param {number} x + * @param {number} y + * @param {number} width + * @param {number} height + * @param {tcuTexture.TextureFormat} format + * @param {Array<number>} scale + * @param {Array<number>} bias + */ + es3fFboTestUtil.readPixels = function(ctx, dst, x, y, width, height, format, scale, bias) { + /** @type {tcuTexture.TextureFormat} */ var readFormat = es3fFboTestUtil.getFramebufferReadFormat(format); + /** @type {gluTextureUtil.TransferFormat} */ var transferFmt = gluTextureUtil.getTransferFormat(readFormat); + /** @type {number} */ var alignment = 4; // \note gl.PACK_ALIGNMENT = 4 is assumed. + /** @type {number} */ var rowSize = deMath.deAlign32(readFormat.getPixelSize() * width, alignment); + var typedArrayType = tcuTexture.getTypedArray(readFormat.type); + var data = new typedArrayType(rowSize * height); + ctx.readPixels(x, y, width, height, transferFmt.format, transferFmt.dataType, data); + + // Convert to surface. + var cpbaDescriptor = { + format: readFormat, + width: width, + height: height, + depth: 1, + rowPitch: rowSize, + slicePitch: 0, + data: data.buffer + }; + + /** @type {tcuTexture.ConstPixelBufferAccess} */ + var src = new tcuTexture.ConstPixelBufferAccess(cpbaDescriptor); + + dst.setSize(width, height); + /** @type {tcuTexture.PixelBufferAccess} */ var dstAccess = dst.getAccess(); + + for (var yo = 0; yo < height; yo++) + for (var xo = 0; xo < width; xo++) + dstAccess.setPixel(deMath.add(deMath.multiply(src.getPixel(xo, yo), scale), bias), xo, yo); + }; + + /** + * @param {number} srcBits + * @return {number} + */ + es3fFboTestUtil.calculateU8ConversionError = function(srcBits) { + if (srcBits > 0) { + /** @const @type {number} */ var clampedBits = deMath.clamp(srcBits, 0, 8); + /** @const @type {number} */ var srcMaxValue = Math.max((1 << clampedBits) - 1, 1); + /** @const @type {number} */ var error = Math.floor(Math.ceil(255.0 * 2.0 / srcMaxValue)); + + return deMath.clamp(error, 0, 255); + } else + return 1; + }; + +}); |