| /*------------------------------------------------------------------------- |
| * 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; |
| }; |
| |
| }); |
