Source code
Revision control
Copy as Markdown
Other Tools
/*-------------------------------------------------------------------------
* 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
*
*
* 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;
};
});