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.es3fFragmentOutputTests');
goog.require('framework.common.tcuImageCompare');
goog.require('framework.common.tcuTestCase');
goog.require('framework.common.tcuTexture');
goog.require('framework.common.tcuTextureUtil');
goog.require('framework.delibs.debase.deMath');
goog.require('framework.delibs.debase.deRandom');
goog.require('framework.opengl.gluShaderProgram');
goog.require('framework.opengl.gluShaderUtil');
goog.require('framework.opengl.gluTextureUtil');
goog.require('functional.gles3.es3fFboTestUtil');
goog.scope(function() {
var es3fFragmentOutputTests = functional.gles3.es3fFragmentOutputTests;
var gluShaderProgram = framework.opengl.gluShaderProgram;
var es3fFboTestUtil = functional.gles3.es3fFboTestUtil;
var gluShaderUtil = framework.opengl.gluShaderUtil;
var deRandom = framework.delibs.debase.deRandom;
var tcuTestCase = framework.common.tcuTestCase;
var gluTextureUtil = framework.opengl.gluTextureUtil;
var tcuTexture = framework.common.tcuTexture;
var tcuTextureUtil = framework.common.tcuTextureUtil;
var deMath = framework.delibs.debase.deMath;
var tcuImageCompare = framework.common.tcuImageCompare;
/** @type {WebGL2RenderingContext} */ var gl;
var DE_ASSERT = function(x) {
if (!x)
throw new Error('Assert failed');
};
/**
* es3fFragmentOutputTests.BufferSpec. Constructs the es3fFragmentOutputTests.BufferSpec object
* @constructor
* @param {WebGLRenderingContextBase.GLenum} format_
* @param {number} width_
* @param {number} height_
* @param {number} samples_
*/
es3fFragmentOutputTests.BufferSpec = function(format_, width_, height_, samples_) {
this.format = format_;
this.width = width_;
this.height = height_;
this.samples = samples_;
};
/**
* es3fFragmentOutputTests.FragmentOutput. Constructs the es3fFragmentOutputTests.FragmentOutput object
* @constructor
* @param {gluShaderUtil.DataType} type_
* @param {gluShaderUtil.precision} precision_
* @param {number} location_
* @param {number=} arrayLength_
*/
es3fFragmentOutputTests.FragmentOutput = function(type_, precision_, location_, arrayLength_) {
this.type = type_;
this.precision = precision_;
this.location = location_;
this.arrayLength = arrayLength_ || 0;
};
/**
* es3fFragmentOutputTests.FragmentOutputCase. Constructs the es3fFragmentOutputTests.FragmentOutputCase object
* @constructor
* @extends {tcuTestCase.DeqpTest}
* @param {string} name
* @param {string} description
* @param {Array<es3fFragmentOutputTests.BufferSpec>} fboSpec
* @param {Array<es3fFragmentOutputTests.FragmentOutput>} outputs
* @return {Object} The currently modified object
*/
es3fFragmentOutputTests.FragmentOutputCase = function(name, description, fboSpec, outputs) {
tcuTestCase.DeqpTest.call(this, name, description);
/** @type {Array<es3fFragmentOutputTests.BufferSpec>} */ this.m_fboSpec = fboSpec;
/** @type {Array<es3fFragmentOutputTests.FragmentOutput>} */ this.m_outputs = outputs;
/** @type {gluShaderProgram.ShaderProgram} */ this.m_program = null;
/** @type {WebGLFramebuffer} */ this.m_framebuffer = null;
/** @type {WebGLRenderbuffer} */ this.m_renderbuffer = null;
};
es3fFragmentOutputTests.FragmentOutputCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
es3fFragmentOutputTests.FragmentOutputCase.prototype.constructor = es3fFragmentOutputTests.FragmentOutputCase;
/**
* es3fFragmentOutputTests.createProgram. Returns a ShaderProgram object
* @param {Array<es3fFragmentOutputTests.FragmentOutput>} outputs
* @return {gluShaderProgram.ShaderProgram} program
*/
es3fFragmentOutputTests.createProgram = function(outputs) {
var vtx = '';
var frag = '';
vtx = '#version 300 es\n' + 'in highp vec4 a_position;\n';
frag = '#version 300 es\n';
/** @type {es3fFragmentOutputTests.FragmentOutput} */ var output = null;
/** @type {boolean} */ var isArray = false;
// Input-output declarations.
for (var outNdx = 0; outNdx < outputs.length; outNdx++) {
output = outputs[outNdx];
isArray = output.arrayLength > 0;
/** @type {string} */ var typeName = gluShaderUtil.getDataTypeName(output.type);
/** @type {string} */ var precName = gluShaderUtil.getPrecisionName(output.precision);
/** @type {boolean} */ var isFloat = gluShaderUtil.isDataTypeFloatOrVec(output.type);
/** @type {string} */ var interp = isFloat ? 'smooth' : 'flat';
if (isArray) {
for (var elemNdx = 0; elemNdx < output.arrayLength; elemNdx++) {
vtx += 'in ' + precName + ' ' + typeName + ' in' + outNdx + '_' + elemNdx + ';\n' +
interp + ' out ' + precName + ' ' + typeName + ' var' + outNdx + '_' + elemNdx + ';\n';
frag += interp + ' in ' + precName + ' ' + typeName + ' var' + outNdx + '_' + elemNdx + ';\n';
}
frag += 'layout(location = ' + output.location + ') out ' + precName + ' ' + typeName + ' out' + outNdx + '[' + output.arrayLength + '];\n';
} else {
vtx += 'in ' + precName + ' ' + typeName + ' in' + outNdx + ';\n' +
interp + ' out ' + precName + ' ' + typeName + ' var' + outNdx + ';\n';
frag += interp + ' in ' + precName + ' ' + typeName + ' var' + outNdx + ';\n' +
'layout(location = ' + output.location + ') out ' + precName + ' ' + typeName + ' out' + outNdx + ';\n';
}
}
vtx += '\nvoid main()\n{\n';
frag += '\nvoid main()\n{\n';
vtx += ' gl_Position = a_position;\n';
// Copy body
for (var outNdx = 0; outNdx < outputs.length; outNdx++) {
output = outputs[outNdx];
isArray = output.arrayLength > 0;
if (isArray) {
for (var elemNdx = 0; elemNdx < output.arrayLength; elemNdx++) {
vtx += '\tvar' + outNdx + '_' + elemNdx + ' = in' + outNdx + '_' + elemNdx + ';\n';
frag += '\tout' + outNdx + '[' + elemNdx + '] = var' + outNdx + '_' + elemNdx + ';\n';
}
} else {
vtx += '\tvar' + outNdx + ' = in' + outNdx + ';\n';
frag += '\tout' + outNdx + ' = var' + outNdx + ';\n';
}
}
vtx += '}\n';
frag += '}\n';
/** @type {gluShaderProgram.ShaderProgram} */
var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vtx, frag));
return program;
};
es3fFragmentOutputTests.FragmentOutputCase.prototype.init = function() {
// Check that all attachments are supported
for (var iter = 0; iter < this.m_fboSpec.length; ++iter) {
if (!gluTextureUtil.isSizedFormatColorRenderable(this.m_fboSpec[iter].format))
throw new Error('Unsupported attachment format');
}
DE_ASSERT(!this.m_program);
this.m_program = es3fFragmentOutputTests.createProgram(this.m_outputs);
// log << *m_program;
if (!this.m_program.isOk())
throw new Error('Compile failed. Program no created');
/*
// Print render target info to log.
log << TestLog::Section("Framebuffer", "Framebuffer configuration");
for (int ndx = 0; ndx < (int)m_fboSpec.size(); ndx++)
log << TestLog::Message << "COLOR_ATTACHMENT" << ndx << ": "
<< glu::getPixelFormatStr(m_fboSpec[ndx].format) << ", "
<< m_fboSpec[ndx].width << "x" << m_fboSpec[ndx].height << ", "
<< m_fboSpec[ndx].samples << " samples"
<< TestLog::EndMessage;
log << TestLog::EndSection;*/
// Create framebuffer.
this.m_framebuffer = gl.createFramebuffer();
gl.bindFramebuffer(gl.FRAMEBUFFER, this.m_framebuffer);
for (var bufNdx = 0; bufNdx < /* m_renderbuffers.size() */ this.m_fboSpec.length; bufNdx++) {
this.m_renderbuffer = gl.createRenderbuffer();
/** @type {es3fFragmentOutputTests.BufferSpec} */ var bufSpec = this.m_fboSpec[bufNdx];
/** @type {number} */ var attachment = gl.COLOR_ATTACHMENT0 + bufNdx;
gl.bindRenderbuffer(gl.RENDERBUFFER, this.m_renderbuffer);
gl.renderbufferStorageMultisample(gl.RENDERBUFFER, bufSpec.samples, bufSpec.format, bufSpec.width, bufSpec.height);
gl.framebufferRenderbuffer(gl.FRAMEBUFFER, attachment, gl.RENDERBUFFER, this.m_renderbuffer);
}
/** @type {number} */ var fboStatus = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
if (fboStatus == gl.FRAMEBUFFER_UNSUPPORTED)
throw new Error('Framebuffer not supported');
else if (fboStatus != gl.FRAMEBUFFER_COMPLETE)
throw new Error('Incomplete framebuffer');
// throw tcu::TestError((string("Incomplete framebuffer: ") + glu::getFramebufferStatusStr(fboStatus), "", __FILE__, __LINE__);
// gl.bindRenderbuffer(gl.RENDERBUFFER, null); // TODO: maybe needed?
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
};
es3fFragmentOutputTests.FragmentOutputCase.prototype.deinit = function() {
// TODO: implement?
};
/**
* es3fFragmentOutputTests.getMinSize.
* @param {Array<es3fFragmentOutputTests.BufferSpec>} fboSpec
* @return {Array<number>} minSize
*/
es3fFragmentOutputTests.getMinSize = function(fboSpec) {
/** @type {Array<number>} */ var minSize = [0x7fffffff, 0x7fffffff];
for (var i = 0; i < fboSpec.length; i++) {
minSize[0] = Math.min(minSize[0], fboSpec[i].width);
minSize[1] = Math.min(minSize[1], fboSpec[i].height);
}
return minSize;
};
/**
* es3fFragmentOutputTests.getNumInputVectors. Returns the length of the array of all the outputs (es3fFragmentOutputTests.FragmentOutput object)
* @param {Array<es3fFragmentOutputTests.FragmentOutput>} outputs
* @return {number} numVecs
*/
es3fFragmentOutputTests.getNumInputVectors = function(outputs) {
/** @type {number} */ var numVecs = 0;
for (var i = 0; i < outputs.length; i++)
numVecs += (outputs[i].arrayLength > 0 ? outputs[i].arrayLength : 1);
return numVecs;
};
/**
* es3fFragmentOutputTests.getFloatRange
* @param {gluShaderUtil.precision} precision
* @return {Array<number>} Vec2
*/
es3fFragmentOutputTests.getFloatRange = function(precision) {
/** @type {Array<Array<number>>} */
var ranges = // Vec2
[
[-2.0, 2.0],
[-16000.0, 16000.0],
[-1e35, 1e35]
];
// DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(ranges) == glu::PRECISION_LAST);
// DE_ASSERT(de::inBounds<int>(precision, 0, DE_LENGTH_OF_ARRAY(ranges)));
return ranges[precision];
};
/**
* es3fFragmentOutputTests.getIntRange
* @param {gluShaderUtil.precision} precision
* @return {Array<number>} IVec2
*/
es3fFragmentOutputTests.getIntRange = function(precision) {
/** @type {Array<Array<number>>} */
var ranges = // IVec2
[
[-(1 << 7), (1 << 7) - 1],
[-(1 << 15), (1 << 15) - 1],
[-0x80000000, 0x7fffffff]
];
// DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(ranges) == glu::PRECISION_LAST);
// DE_ASSERT(de::inBounds<int>(precision, 0, DE_LENGTH_OF_ARRAY(ranges)));
return ranges[precision];
};
/**
* es3fFragmentOutputTests.getUintRange
* @param {gluShaderUtil.precision} precision
* @return {Array<number>} UVec2
*/
es3fFragmentOutputTests.getUintRange = function(precision) {
/** @type {Array<Array<number>>} */
var ranges = // UVec2
[
[0, (1 << 8) - 1],
[0, (1 << 16) - 1],
[0, 0xffffffff]
];
// DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(ranges) == glu::PRECISION_LAST);
// DE_ASSERT(de::inBounds<int>(precision, 0, DE_LENGTH_OF_ARRAY(ranges)));
return ranges[precision];
};
/**
* es3fFragmentOutputTests.readVec4
* @param {Array<number>} ptr
* @param {number} index
* @param {number} numComponents
* @return {Array<number>} Vec4
*/
es3fFragmentOutputTests.readVec4 = function(ptr, index, numComponents) {
DE_ASSERT(numComponents >= 1);
return [
ptr[index + 0],
numComponents >= 2 ? ptr[index + 1] : 0.0,
numComponents >= 3 ? ptr[index + 2] : 0.0,
numComponents >= 4 ? ptr[index + 3] : 0.0
];
};
/**
* es3fFragmentOutputTests.readIVec4
* @param {Array<number>} ptr
* @param {number} numComponents
* @return {Array<number>} IVec4
*/
es3fFragmentOutputTests.readIVec4 = function(ptr, index, numComponents) {
DE_ASSERT(numComponents >= 1);
return [
ptr[index + 0],
numComponents >= 2 ? ptr[index + 1] : 0,
numComponents >= 3 ? ptr[index + 2] : 0,
numComponents >= 4 ? ptr[index + 3] : 0
];
};
/**
* es3fFragmentOutputTests.renderFloatReference
* @param {tcuTexture.PixelBufferAccess} dst
* @param {number} gridWidth
* @param {number} gridHeight
* @param {number} numComponents
* @param {Array<number>} vertices
*/
es3fFragmentOutputTests.renderFloatReference = function(dst, gridWidth, gridHeight, numComponents, vertices) {
/** @type {boolean} */ var isSRGB = dst.getFormat().order == tcuTexture.ChannelOrder.sRGB || dst.getFormat().order == tcuTexture.ChannelOrder.sRGBA;
/** @type {number} */ var cellW = dst.getWidth() / (gridWidth - 1);
/** @type {number} */ var cellH = dst.getHeight() / (gridHeight - 1);
for (var y = 0; y < dst.getHeight(); y++) {
for (var x = 0; x < dst.getWidth(); x++) {
/** @type {number} */ var cellX = deMath.clamp(Math.floor(x / cellW), 0, gridWidth - 2);
/** @type {number} */ var cellY = deMath.clamp(Math.floor(y / cellH), 0, gridHeight - 2);
/** @type {number} */ var xf = (x - cellX * cellW + 0.5) / cellW;
/** @type {number} */ var yf = (y - cellY * cellH + 0.5) / cellH;
/** @type {Array<number>} */ var v00 = es3fFragmentOutputTests.readVec4(vertices, ((cellY + 0) * gridWidth + cellX + 0) * numComponents, numComponents); // Vec4
/** @type {Array<number>} */ var v01 = es3fFragmentOutputTests.readVec4(vertices, ((cellY + 1) * gridWidth + cellX + 0) * numComponents, numComponents); // Vec4
/** @type {Array<number>} */ var v10 = es3fFragmentOutputTests.readVec4(vertices, ((cellY + 0) * gridWidth + cellX + 1) * numComponents, numComponents); // Vec4
/** @type {Array<number>} */ var v11 = es3fFragmentOutputTests.readVec4(vertices, ((cellY + 1) * gridWidth + cellX + 1) * numComponents, numComponents); // Vec4
/** @type {boolean} */ var tri = xf + yf >= 1.0;
/** @type {Array<number>} */ var v0 = tri ? v11 : v00; // Vec4&
/** @type {Array<number>} */ var v1 = tri ? v01 : v10; // Vec4&
/** @type {Array<number>} */ var v2 = tri ? v10 : v01; // Vec4&
/** @type {number} */ var s = tri ? 1.0 - xf : xf;
/** @type {number} */ var t = tri ? 1.0 - yf : yf;
/** @type {Array<number>} */ var color = deMath.add(v0, deMath.add(deMath.multiply((deMath.subtract(v1, v0)), [s, s, s, s]), deMath.multiply((deMath.subtract(v2, v0)), [t, t, t, t]))); // Vec4
dst.setPixel(isSRGB ? tcuTextureUtil.linearToSRGB(color) : color, x, y);
}
}
};
/**
* es3fFragmentOutputTests.renderIntReference
* @param {tcuTexture.PixelBufferAccess} dst
* @param {number} gridWidth
* @param {number} gridHeight
* @param {number} numComponents
* @param {Array<number>} vertices
*/
es3fFragmentOutputTests.renderIntReference = function(dst, gridWidth, gridHeight, numComponents, vertices) {
/** @type {number} */ var cellW = dst.getWidth() / (gridWidth - 1);
/** @type {number} */ var cellH = dst.getHeight() / (gridHeight - 1);
for (var y = 0; y < dst.getHeight(); y++) {
for (var x = 0; x < dst.getWidth(); x++) {
/** @type {number} */ var cellX = deMath.clamp(Math.floor(x / cellW), 0, gridWidth - 2);
/** @type {number} */ var cellY = deMath.clamp(Math.floor(y / cellH), 0, gridHeight - 2);
/** @type {Array<number>} */ var c = es3fFragmentOutputTests.readIVec4(vertices, (cellY * gridWidth + cellX + 1) * numComponents, numComponents); // IVec4
dst.setPixelInt(c, x, y);
}
}
};
/**
* es3fFragmentOutputTests.s_swizzles
* @return {Array<Array<number>>}
*/
es3fFragmentOutputTests.s_swizzles = function() {
var mat_swizzles = [
[0, 1, 2, 3],
[1, 2, 3, 0],
[2, 3, 0, 1],
[3, 0, 1, 2],
[3, 2, 1, 0],
[2, 1, 0, 3],
[1, 0, 3, 2],
[0, 3, 2, 1]
];
return mat_swizzles;
};
/**
* es3fFragmentOutputTests.swizzleVec. Returns an Array from a position contained in the Array es3fFragmentOutputTests.s_swizzles []
* @param {Array<number>} vec
* @param {number} swzNdx
* @return {Array<number>} Swizzled array
*/
es3fFragmentOutputTests.swizzleVec = function(vec, swzNdx) {
/** @type {Array<number>} */ var swz = es3fFragmentOutputTests.s_swizzles()[swzNdx % es3fFragmentOutputTests.s_swizzles().length];
return deMath.swizzle(vec, swz);
};
/**
* es3fFragmentOutputTests.AttachmentData struct class
* @constructor
* @return {Object}
*/
es3fFragmentOutputTests.AttachmentData = function() {
return {
/** @type {tcuTexture.TextureFormat} */ format: null, //!< Actual format of attachment.
/** @type {tcuTexture.TextureFormat} */ referenceFormat: null, //!< Used for reference rendering.
/** @type {tcuTexture.TextureFormat} */ readFormat: null,
/** @type {number} */ numWrittenChannels: 0,
/** @type {gluShaderUtil.precision} */ outPrecision: gluShaderUtil.precision.PRECISION_LOWP,
/** @type {ArrayBuffer} */ renderedData: null,
/** @type {ArrayBuffer} */ referenceData: null
};
};
es3fFragmentOutputTests.FragmentOutputCase.prototype.iterate = function() {
// Compute grid size & index list.
/** @type {number} */ var minCellSize = 8;
/** @type {Array<number>} */ var minBufSize = es3fFragmentOutputTests.getMinSize(this.m_fboSpec); // IVec2
/** @type {number} */ var gridWidth = deMath.clamp(Math.floor(minBufSize[0] / minCellSize), 1, 255) + 1;
/** @type {number} */ var gridHeight = deMath.clamp(Math.floor(minBufSize[1] / minCellSize), 1, 255) + 1;
/** @type {number} */ var numVertices = gridWidth * gridHeight;
/** @type {number} */ var numQuads = (gridWidth - 1) * (gridHeight - 1);
/** @type {number} */ var numIndices = numQuads * 6;
/** @type {number} */ var numInputVecs = es3fFragmentOutputTests.getNumInputVectors(this.m_outputs);
/** @type {Array<Array<number>>} */ var inputs = []; // originally vector<vector<deUint32>
for (var inputNdx = 0; inputNdx < numInputVecs; inputNdx++)
inputs[inputNdx] = []; // inputs.length = numInputVecs;
/** @type {Array<number>} */ var positions = []; // originally vector<float>
/** @type {Array<number>} */ var indices = []; // originally vector<deUint16>
/** @type {number} */ var readAlignment = 4;
/** @type {number} */ var viewportW = minBufSize[0];
/** @type {number} */ var viewportH = minBufSize[1];
/** @type {number} */ var numAttachments = this.m_fboSpec.length;
/** @type {Array<number>} */ var drawBuffers = []; // originally vector<deUint32>
/** @type {Array<es3fFragmentOutputTests.AttachmentData>} */ var attachments = [];
/** @type {number} */ var attachmentW;
/** @type {number} */ var attachmentH;
// Initialize attachment data.
for (var ndx = 0; ndx < numAttachments; ndx++) {
/** @type {tcuTexture.TextureFormat} */ var texFmt = gluTextureUtil.mapGLInternalFormat(this.m_fboSpec[ndx].format);
/** @type {tcuTexture.TextureChannelClass} */ var chnClass = tcuTexture.getTextureChannelClass(texFmt.type);
/** @type {boolean} */ var isFixedPoint = (chnClass == tcuTexture.TextureChannelClass.SIGNED_FIXED_POINT ||
chnClass == tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT);
// \note Fixed-point formats use float reference to enable more accurate result verification.
/** @type {tcuTexture.TextureFormat} */ var refFmt = isFixedPoint ? new tcuTexture.TextureFormat(texFmt.order, tcuTexture.ChannelType.FLOAT) : texFmt;
/** @type {tcuTexture.TextureFormat} */ var readFmt = es3fFboTestUtil.getFramebufferReadFormat(texFmt);
attachmentW = this.m_fboSpec[ndx].width;
attachmentH = this.m_fboSpec[ndx].height;
drawBuffers[ndx] = gl.COLOR_ATTACHMENT0 + ndx;
attachments[ndx] = new es3fFragmentOutputTests.AttachmentData();
attachments[ndx].format = texFmt;
attachments[ndx].readFormat = readFmt;
attachments[ndx].referenceFormat = refFmt;
attachments[ndx].renderedData = new ArrayBuffer(readFmt.getPixelSize() * attachmentW * attachmentH);
attachments[ndx].referenceData = new ArrayBuffer(refFmt.getPixelSize() * attachmentW * attachmentH);
}
// Initialize indices.
for (var quadNdx = 0; quadNdx < numQuads; quadNdx++) {
/** @type {number} */ var quadY = Math.floor(quadNdx / (gridWidth - 1));
/** @type {number} */ var quadX = quadNdx - quadY * (gridWidth - 1);
indices[quadNdx * 6 + 0] = quadX + quadY * gridWidth;
indices[quadNdx * 6 + 1] = quadX + (quadY + 1) * gridWidth;
indices[quadNdx * 6 + 2] = quadX + quadY * gridWidth + 1;
indices[quadNdx * 6 + 3] = indices[quadNdx * 6 + 1];
indices[quadNdx * 6 + 4] = quadX + (quadY + 1) * gridWidth + 1;
indices[quadNdx * 6 + 5] = indices[quadNdx * 6 + 2];
}
/** @type {number} */ var xf = 0;
/** @type {number} */ var yf = 0;
for (var y = 0; y < gridHeight; y++) {
for (var x = 0; x < gridWidth; x++) {
xf = x / (gridWidth - 1);
yf = y / (gridHeight - 1);
positions[(y * gridWidth + x) * 4 + 0] = 2.0 * xf - 1.0;
positions[(y * gridWidth + x) * 4 + 1] = 2.0 * yf - 1.0;
positions[(y * gridWidth + x) * 4 + 2] = 0.0;
positions[(y * gridWidth + x) * 4 + 3] = 1.0;
}
}
/** @type {es3fFragmentOutputTests.FragmentOutput} */ var output;
/** @type {boolean} */ var isArray;
/** @type {boolean} */ var isFloat;
/** @type {boolean} */ var isInt;
/** @type {boolean} */ var isUint;
/** @type {number} */ var numVecs;
/** @type {number} */ var numScalars;
var curInVec = 0;
for (var outputNdx = 0; outputNdx < this.m_outputs.length; outputNdx++) {
output = this.m_outputs[outputNdx];
isFloat = gluShaderUtil.isDataTypeFloatOrVec(output.type);
isInt = gluShaderUtil.isDataTypeIntOrIVec(output.type);
isUint = gluShaderUtil.isDataTypeUintOrUVec(output.type);
numVecs = output.arrayLength > 0 ? output.arrayLength : 1;
numScalars = gluShaderUtil.getDataTypeScalarSize(output.type);
for (var vecNdx = 0; vecNdx < numVecs; vecNdx++) {
inputs[curInVec].length = numVertices * numScalars;
// Record how many outputs are written in attachment.
DE_ASSERT(output.location + vecNdx < attachments.length);
attachments[output.location + vecNdx].numWrittenChannels = numScalars;
attachments[output.location + vecNdx].outPrecision = output.precision;
/** @type {Array<number>} */ var range = null;
/** @type {Array<number>} */ var minVal = null;
/** @type {Array<number>} */ var maxVal = null;
/** @type {Array<number>} */ var fmtBits = null;
/** @type {Array<number>} */ var fmtMaxVal = [];
/** @type {Array<number>} */ var rangeDiv = null;
/** @type {Array<number>} */ var step = [];
/** @type {number} */ var ix = 0;
/** @type {number} */ var iy = 0;
/** @type {Array<number>} */ var c = null;
/** @type {number} */ var pos = 0;
if (isFloat) {
range = es3fFragmentOutputTests.getFloatRange(output.precision); // Vec2
minVal = [range[0], range[0], range[0], range[0]]; // Vec4
maxVal = [range[1], range[1], range[1], range[1]]; // Vec4
if (deMath.deInBounds32(output.location + vecNdx, 0, attachments.length)) {
// \note Floating-point precision conversion is not well-defined. For that reason we must
// limit value range to intersection of both data type and render target value ranges.
/** @type {tcuTextureUtil.TextureFormatInfo} */ var fmtInfo = tcuTextureUtil.getTextureFormatInfo(attachments[output.location + vecNdx].format);
minVal = deMath.max(minVal, fmtInfo.valueMin);
maxVal = deMath.min(maxVal, fmtInfo.valueMax);
}
bufferedLogToConsole('out ' + curInVec + ' value range: ' + minVal + ' -> ' + maxVal);
for (var y = 0; y < gridHeight; y++) {
for (var x = 0; x < gridWidth; x++) {
xf = x / (gridWidth - 1);
yf = y / (gridHeight - 1);
/** @type {number} */ var f0 = (xf + yf) * 0.5;
/** @type {number} */ var f1 = 0.5 + (xf - yf) * 0.5;
/** @type {Array<number>} */ var f = es3fFragmentOutputTests.swizzleVec([f0, f1, 1.0 - f0, 1.0 - f1], curInVec); // Vec4
c = deMath.add(minVal, deMath.multiply(deMath.subtract(maxVal, minVal), f)); // Vec4
pos = (y * gridWidth + x) * numScalars;
for (var ndx = 0; ndx < numScalars; ndx++)
inputs[curInVec][pos + ndx] = c[ndx];
}
}
} else if (isInt) {
range = es3fFragmentOutputTests.getIntRange(output.precision); // IVec2
minVal = [range[0], range[0], range[0], range[0]]; // IVec4
maxVal = [range[1], range[1], range[1], range[1]]; // IVec4
if (deMath.deInBounds32(output.location + vecNdx, 0, attachments.length)) {
// Limit to range of output format as conversion mode is not specified.
fmtBits = tcuTextureUtil.getTextureFormatBitDepth(attachments[output.location + vecNdx].format); // IVec4
/** @type {Array<boolean>} */ var isZero = deMath.lessThanEqual(fmtBits, [0, 0, 0, 0]); // BVec4, array of booleans, size = 4
/** @type {Array<number>} */ var fmtMinVal = []; // IVec4
for (var i = 0; i < 4; i++) {
// const IVec4 fmtMinVal = (-(tcu::Vector<deInt64, 4>(1) << (fmtBits - 1 ).cast<deInt64>())).asInt();
fmtMinVal[i] = -1 * Math.pow(2, fmtBits[i] - 1); // TODO: check implementation, original above
// const IVec4 fmtMaxVal = ((tcu::Vector<deInt64, 4>(1) << (fmtBits - 1 ).cast<deInt64>()) - deInt64(1)).asInt();
fmtMaxVal[i] = Math.pow(2, fmtBits[i] - 1) - 1; // TODO: check implementation, original above
}
minVal = tcuTextureUtil.select(minVal, deMath.max(minVal, fmtMinVal), isZero);
maxVal = tcuTextureUtil.select(maxVal, deMath.min(maxVal, fmtMaxVal), isZero);
}
bufferedLogToConsole('out ' + curInVec + ' value range: ' + minVal + ' -> ' + maxVal);
rangeDiv = es3fFragmentOutputTests.swizzleVec([gridWidth - 1, gridHeight - 1, gridWidth - 1, gridHeight - 1], curInVec); // IVec4
for (var i = 0; i < 4; i++) {
// const IVec4 step = ((maxVal.cast<deInt64>() - minVal.cast<deInt64>()) / (rangeDiv.cast<deInt64>())).asInt();
step[i] = Math.floor((maxVal[i] - minVal[i]) / rangeDiv[i]); // TODO: check with the above line of code
}
for (var y = 0; y < gridHeight; y++) {
for (var x = 0; x < gridWidth; x++) {
ix = gridWidth - x - 1;
iy = gridHeight - y - 1;
c = deMath.add(minVal, deMath.multiply(step, es3fFragmentOutputTests.swizzleVec([x, y, ix, iy], curInVec))); // IVec4
pos = (y * gridWidth + x) * numScalars;
for (var ndx = 0; ndx < numScalars; ndx++)
inputs[curInVec][pos + ndx] = c[ndx];
}
}
} else if (isUint) {
range = es3fFragmentOutputTests.getUintRange(output.precision); // UVec2
maxVal = [range[1], range[1], range[1], range[1]]; // UVec4
if (deMath.deInBounds32(output.location + vecNdx, 0, attachments.length)) {
// Limit to range of output format as conversion mode is not specified.
fmtBits = tcuTextureUtil.getTextureFormatBitDepth(attachments[output.location + vecNdx].format); // IVec4
for (var i = 0; i < 4; i++) {
fmtMaxVal[i] = Math.pow(2, fmtBits[i]) - 1;
}
maxVal = deMath.min(maxVal, fmtMaxVal);
}
bufferedLogToConsole('out ' + curInVec + ' value range: ' + minVal + ' -> ' + maxVal);
rangeDiv = es3fFragmentOutputTests.swizzleVec([gridWidth - 1, gridHeight - 1, gridWidth - 1, gridHeight - 1], curInVec); // IVec4
for (var stepPos = 0; stepPos < maxVal.length; stepPos++) {
step[stepPos] = Math.floor(maxVal[stepPos] / rangeDiv[stepPos]);
}
DE_ASSERT(range[0] == 0);
for (var y = 0; y < gridHeight; y++) {
for (var x = 0; x < gridWidth; x++) {
ix = gridWidth - x - 1;
iy = gridHeight - y - 1;
c = deMath.multiply(step, es3fFragmentOutputTests.swizzleVec([x, y, ix, iy], curInVec)); // UVec4
pos = (y * gridWidth + x) * numScalars;
DE_ASSERT(deMath.boolAll(deMath.lessThanEqual(c, maxVal))); // TODO: sometimes crashes here, condition not asserted
for (var ndx = 0; ndx < numScalars; ndx++)
inputs[curInVec][pos + ndx] = c[ndx];
}
}
} else
DE_ASSERT(false);
curInVec += 1;
}
}
// Render using gl.
gl.useProgram(this.m_program.getProgram());
gl.bindFramebuffer(gl.FRAMEBUFFER, this.m_framebuffer);
gl.viewport(0, 0, viewportW, viewportH);
gl.drawBuffers(drawBuffers);
gl.disable(gl.DITHER); // Dithering causes issues with unorm formats. Those issues could be worked around in threshold, but it makes validation less accurate.
/** @type {WebGLBuffer} */ var buffer = null;
/** @type {string} */ var name;
curInVec = 0;
for (var outputNdx = 0; outputNdx < this.m_outputs.length; outputNdx++) {
output = this.m_outputs[outputNdx];
isArray = output.arrayLength > 0;
isFloat = gluShaderUtil.isDataTypeFloatOrVec(output.type);
isInt = gluShaderUtil.isDataTypeIntOrIVec(output.type);
isUint = gluShaderUtil.isDataTypeUintOrUVec(output.type);
/** @type {number} */ var scalarSize = gluShaderUtil.getDataTypeScalarSize(output.type);
/** @type {number} */ var glScalarType = isFloat ? /* gluShaderUtil.DataType.FLOAT */ gl.FLOAT :
isInt ? /* gluShaderUtil.DataType.INT */ gl.INT :
isUint ? /* gluShaderUtil.DataType.UINT */ gl.UNSIGNED_INT : /* gluShaderUtil.DataType.INVALID */ gl.NONE;
numVecs = isArray ? output.arrayLength : 1;
for (var vecNdx = 0; vecNdx < numVecs; vecNdx++) {
name = 'in' + outputNdx + (isArray ? '_' + vecNdx : '');
/** @type {number} */ var loc = gl.getAttribLocation(this.m_program.getProgram(), name);
if (loc >= 0) {
buffer = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
gl.enableVertexAttribArray(loc);
if (isFloat) {
gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(inputs[curInVec]), gl.STATIC_DRAW);
// KHRONOS WebGL 1.0 specification:
// void vertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLintptr offset);
gl.vertexAttribPointer(loc, scalarSize, glScalarType, false, 0, 0); // offset = 0
} else {
gl.bufferData(gl.ARRAY_BUFFER, new Int32Array(inputs[curInVec]), gl.STATIC_DRAW);
// KHRONOS WebGL 2.0 specification:
// void vertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset)
gl.vertexAttribIPointer(loc, scalarSize, glScalarType, 0, 0); // offset = 0
}
} else
bufferedLogToConsole('Warning: No location for attribute "' + name + '" found.');
curInVec += 1;
}
}
/** @type {number} */ var posLoc = gl.getAttribLocation(this.m_program.getProgram(), 'a_position');
// TCU_CHECK(posLoc >= 0);
buffer = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(positions), gl.STATIC_DRAW);
gl.enableVertexAttribArray(posLoc);
gl.vertexAttribPointer(posLoc, 4, gl.FLOAT, false, 0, 0); // offset = 0
/** @type {WebGLBuffer} */ var indexObject = gl.createBuffer();
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexObject);
gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(indices), gl.STATIC_DRAW);
gl.drawElements(gl.TRIANGLES, numIndices, gl.UNSIGNED_SHORT, 0); // offset = 0
// Render reference images.
var curInNdx = 0;
for (var outputNdx = 0; outputNdx < this.m_outputs.length; outputNdx++) {
output = this.m_outputs[outputNdx];
isArray = output.arrayLength > 0;
isFloat = gluShaderUtil.isDataTypeFloatOrVec(output.type);
isInt = gluShaderUtil.isDataTypeIntOrIVec(output.type);
isUint = gluShaderUtil.isDataTypeUintOrUVec(output.type);
scalarSize = gluShaderUtil.getDataTypeScalarSize(output.type);
numVecs = isArray ? output.arrayLength : 1;
for (var vecNdx = 0; vecNdx < numVecs; vecNdx++) {
/** @type {number} */ var location = output.location + vecNdx;
/** @type {Array<number>} */ var inputData = inputs[curInNdx];
DE_ASSERT(deMath.deInBounds32(location, 0, this.m_fboSpec.length));
/** @type {number} */ var bufW = this.m_fboSpec[location].width;
/** @type {number} */ var bufH = this.m_fboSpec[location].height;
/** @type {Object} */ var descriptor = {
format: attachments[location].referenceFormat,
width: bufW,
height: bufH,
depth: 1,
data: attachments[location].referenceData // ArrayBuffer
};
/** @type {tcuTexture.PixelBufferAccess} */ var buf = new tcuTexture.PixelBufferAccess(descriptor);
/** @type {tcuTexture.PixelBufferAccess} */ var viewportBuf = tcuTextureUtil.getSubregion(buf, 0, 0, 0, viewportW, viewportH, 1);
if (isInt || isUint)
es3fFragmentOutputTests.renderIntReference(viewportBuf, gridWidth, gridHeight, scalarSize, inputData);
else if (isFloat)
es3fFragmentOutputTests.renderFloatReference(viewportBuf, gridWidth, gridHeight, scalarSize, inputData);
else
DE_ASSERT(false);
curInNdx += 1;
}
}
// Compare all images.
/** @type {boolean} */ var allLevelsOk = true;
for (var attachNdx = 0; attachNdx < numAttachments; attachNdx++) {
attachmentW = this.m_fboSpec[attachNdx].width;
attachmentH = this.m_fboSpec[attachNdx].height;
/** @type {number} */ var numValidChannels = attachments[attachNdx].numWrittenChannels;
/** @type {Array<boolean>} */ var cmpMask = [numValidChannels >= 1, numValidChannels >= 2, numValidChannels >= 3, numValidChannels >= 4];
/** @type {gluShaderUtil.precision} */ var outPrecision = attachments[attachNdx].outPrecision;
/** @type {tcuTexture.TextureFormat} */ var format = attachments[attachNdx].format;
/** @type {Object} */
var renderedDescriptor = {
format: attachments[attachNdx].readFormat,
width: attachmentW,
height: attachmentH,
depth: 1,
rowPitch: deMath.deAlign32(attachments[attachNdx].readFormat.getPixelSize() * attachmentW, readAlignment),
slicePitch: 0,
data: attachments[attachNdx].renderedData // ArrayBuffer
};
/** @type {tcuTexture.PixelBufferAccess} */ var rendered = new tcuTexture.PixelBufferAccess(renderedDescriptor);
/** @type {gluTextureUtil.TransferFormat} */ var transferFmt = gluTextureUtil.getTransferFormat(attachments[attachNdx].readFormat);
gl.readBuffer(gl.COLOR_ATTACHMENT0 + attachNdx);
gl.readPixels(0, 0, attachmentW, attachmentH, transferFmt.format, transferFmt.dataType, rendered.getDataPtr());
/** @type {Object} */
var referenceDescriptor = {
format: attachments[attachNdx].referenceFormat,
width: attachmentW,
height: attachmentH,
depth: 1,
data: attachments[attachNdx].referenceData // ArrayBuffer
};
/** @type {tcuTexture.ConstPixelBufferAccess} */ var reference = new tcuTexture.ConstPixelBufferAccess(referenceDescriptor);
/** @type {tcuTexture.TextureChannelClass} */ var texClass = tcuTexture.getTextureChannelClass(format.type);
/** @type {boolean} */ var isOk = true;
name = 'Attachment ' + attachNdx;
/** @type {string} */ var desc = 'Color attachment ' + attachNdx;
/** @type {Array<number>} */ var threshold;
bufferedLogToConsole('Attachment ' + attachNdx + ': ' + numValidChannels + ' channels have defined values and used for comparison');
switch (texClass) {
case tcuTexture.TextureChannelClass.FLOATING_POINT: {
/** @type {Array<number>} */ var formatThreshold = []; // UVec4 //!< Threshold computed based on format.
formatThreshold.length = 4;
/** @type {number} */ var precThreshold = 0; // deUint32 //!< Threshold computed based on output type precision
/** @type {Array<number>} */ var finalThreshold = []; // UVec4
finalThreshold.length = 4;
switch (format.type) {
case tcuTexture.ChannelType.FLOAT:
formatThreshold = [4, 4, 4, 4]; // UVec4
break;
case tcuTexture.ChannelType.HALF_FLOAT:
formatThreshold = [(1 << 13) + 4, (1 << 13) + 4, (1 << 13) + 4, (1 << 13) + 4]; // UVec4
break;
case tcuTexture.ChannelType.UNSIGNED_INT_11F_11F_10F_REV:
formatThreshold = [(1 << 17) + 4, (1 << 17) + 4, (1 << 18) + 4, 4]; // UVec4
break;
default:
DE_ASSERT(false);
break;
}
switch (outPrecision) {
case gluShaderUtil.precision.PRECISION_LOWP:
precThreshold = (1 << 21);
break;
case gluShaderUtil.precision.PRECISION_MEDIUMP:
precThreshold = (1 << 13);
break;
case gluShaderUtil.precision.PRECISION_HIGHP:
precThreshold = 0;
break;
default:
DE_ASSERT(false);
}
finalThreshold = tcuTextureUtil.select(
deMath.max(formatThreshold, [precThreshold, precThreshold, precThreshold, precThreshold]),
[0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff], // C++ version: UVec4(~0u) bitwise not, all bits in the integer will be flipped
cmpMask);
isOk = tcuImageCompare.floatUlpThresholdCompare(name, desc, reference, rendered, finalThreshold /*, tcu::COMPARE_LOG_RESULT*/);
break;
}
case tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT: {
// \note glReadPixels() allows only 8 bits to be read. This means that RGB10_A2 will loose some
// bits in the process and it must be taken into account when computing threshold.
/** @type {Array<number>} */ var bits = deMath.min([8, 8, 8, 8], tcuTextureUtil.getTextureFormatBitDepth(format)); // IVec4
/** @type {Array<number>} */ var baseThreshold = []; // Vec4
baseThreshold.length = 4;
for (var inc = 0; inc < baseThreshold.length; inc++) {
// TODO: check the operation below: baseThreshold = 1.0f / ((IVec4(1) << bits)-1).asFloat();
baseThreshold[inc] = 1.0 / ((1 << bits[inc]) - 1);
}
threshold = tcuTextureUtil.select(baseThreshold, [2.0, 2.0, 2.0, 2.0], cmpMask); // Vec4
isOk = tcuImageCompare.floatThresholdCompare(name, desc, reference, rendered, threshold/*, tcu::COMPARE_LOG_RESULT*/);
break;
}
case tcuTexture.TextureChannelClass.SIGNED_INTEGER:
case tcuTexture.TextureChannelClass.UNSIGNED_INTEGER: {
// The C++ dEQP code uses ~0u but ~0 is -1 in Javascript
var UINT_MAX = Math.pow(2.0, 32.0) - 1;
threshold = tcuTextureUtil.select(
[0, 0, 0, 0],
[UINT_MAX, UINT_MAX, UINT_MAX, UINT_MAX],
cmpMask
); // UVec4
isOk = tcuImageCompare.intThresholdCompare(name, desc, reference, rendered, threshold/*, tcu::COMPARE_LOG_RESULT*/);
break;
}
default:
testFailedOptions('Unsupported comparison', true);
break;
}
if (!isOk)
allLevelsOk = false;
}
if (numAttachments > 1) {
if (allLevelsOk)
testPassed('Image comparison passed for ' + numAttachments + ' attachments');
else
testFailed('Image comparison failed for some of ' + numAttachments + ' attachments');
} else {
if (allLevelsOk)
testPassed('Image comparison passed');
else
testFailed('Image comparison failed');
}
return tcuTestCase.IterateResult.STOP;
};
/**
* es3fFragmentOutputTests.createRandomCase. Constructs the es3fFragmentOutputTests.createRandomCase, child class of es3fFragmentOutputTests.FragmentOutputCase
* @constructor
* @param {number} minRenderTargets
* @param {number} maxRenderTargets
* @param {number} seed
* @return {es3fFragmentOutputTests.FragmentOutputCase} The currently modified object
*/
es3fFragmentOutputTests.createRandomCase = function(minRenderTargets, maxRenderTargets, seed, colorBufferFloatSupported) {
/** @type {Array<gluShaderUtil.DataType>} */
var outputTypes = [
gluShaderUtil.DataType.FLOAT,
gluShaderUtil.DataType.FLOAT_VEC2,
gluShaderUtil.DataType.FLOAT_VEC3,
gluShaderUtil.DataType.FLOAT_VEC4,
gluShaderUtil.DataType.INT,
gluShaderUtil.DataType.INT_VEC2,
gluShaderUtil.DataType.INT_VEC3,
gluShaderUtil.DataType.INT_VEC4,
gluShaderUtil.DataType.UINT,
gluShaderUtil.DataType.UINT_VEC2,
gluShaderUtil.DataType.UINT_VEC3,
gluShaderUtil.DataType.UINT_VEC4
];
/** @type {Array<gluShaderUtil.precision>} */
var precisions = [
gluShaderUtil.precision.PRECISION_LOWP,
gluShaderUtil.precision.PRECISION_MEDIUMP,
gluShaderUtil.precision.PRECISION_HIGHP
];
/** @type {Array<WebGLRenderingContextBase.GLenum>} */
var floatFormats = [
gl.RGBA32F,
gl.RGBA16F,
gl.R11F_G11F_B10F,
gl.RG32F,
gl.RG16F,
gl.R32F,
gl.R16F,
gl.RGBA8,
gl.SRGB8_ALPHA8,
gl.RGB10_A2,
gl.RGBA4,
gl.RGB5_A1,
gl.RGB8,
gl.RGB565,
gl.RG8,
gl.R8
];
/** @type {Array<WebGLRenderingContextBase.GLenum>} */
var colorBufferFloatFormats = [
gl.RGBA32F,
gl.RGBA16F,
gl.R11F_G11F_B10F,
gl.RG32F,
gl.RG16F,
gl.R32F,
gl.R16F
];
/** @type {Array<WebGLRenderingContextBase.GLenum>} */
var intFormats = [
gl.RGBA32I,
gl.RGBA16I,
gl.RGBA8I,
gl.RG32I,
gl.RG16I,
gl.RG8I,
gl.R32I,
gl.R16I,
gl.R8I
];
/** @type {Array<WebGLRenderingContextBase.GLenum>} */
var uintFormats = [
gl.RGBA32UI,
gl.RGBA16UI,
gl.RGBA8UI,
gl.RGB10_A2UI,
gl.RG32UI,
gl.RG16UI,
gl.RG8UI,
gl.R32UI,
gl.R16UI,
gl.R8UI
];
/** @type {deRandom.Random} */ var rnd = new deRandom.Random(seed);
/** @type {Array<es3fFragmentOutputTests.FragmentOutput>} */ var outputs = [];
/** @type {Array<es3fFragmentOutputTests.BufferSpec>} */ var targets = [];
/** @type {Array<gluShaderUtil.DataType>} */ var outTypes = [];
/** @type {number} */ var numTargets = rnd.getInt(minRenderTargets, maxRenderTargets);
/** @type {number} */ var width = 128; // \todo [2012-04-10 pyry] Separate randomized sizes per target?
/** @type {number} */ var height = 64;
/** @type {number} */ var samples = 0;
// Compute outputs.
/** @type {number} */ var curLoc = 0;
while (curLoc < numTargets) {
/** @type {boolean} */ var useArray = rnd.getFloat() < 0.3;
/** @type {number} */ var maxArrayLen = numTargets - curLoc;
/** @type {number} */ var arrayLen = useArray ? rnd.getInt(1, maxArrayLen) : 0;
/** @type {Array<gluShaderUtil.DataType>} */ var basicTypeArray = rnd.choose(outputTypes, undefined, 1);
/** @type {gluShaderUtil.DataType} */ var basicType = basicTypeArray[0];
/** @type {Array<gluShaderUtil.precision>} */ var precisionArray = rnd.choose(precisions, undefined, 1);
/** @type {gluShaderUtil.precision} */ var precision = precisionArray[0];
/** @type {number} */ var numLocations = useArray ? arrayLen : 1;
outputs.push(new es3fFragmentOutputTests.FragmentOutput(basicType, precision, curLoc, arrayLen));
for (var ndx = 0; ndx < numLocations; ndx++)
outTypes.push(basicType);
curLoc += numLocations;
}
DE_ASSERT(curLoc == numTargets);
DE_ASSERT(outTypes.length == numTargets);
// Compute buffers.
while (targets.length < numTargets) {
/** @type {gluShaderUtil.DataType} */ var outType = outTypes[targets.length];
/** @type {boolean} */ var isFloat = gluShaderUtil.isDataTypeFloatOrVec(outType);
/** @type {boolean} */ var isInt = gluShaderUtil.isDataTypeIntOrIVec(outType);
/** @type {boolean} */ var isUint = gluShaderUtil.isDataTypeUintOrUVec(outType);
/** @type {Array} */ var formatArray = [];
/** @type {number} */ var format = 0;
if (isFloat) {
formatArray = rnd.choose(floatFormats, undefined, 1);
format = formatArray[0];
if (colorBufferFloatFormats.indexOf(format) >= 0 && !colorBufferFloatSupported)
return null;
} else if (isInt) {
formatArray = rnd.choose(intFormats, undefined, 1);
format = formatArray[0];
} else if (isUint) {
formatArray = rnd.choose(uintFormats, undefined, 1);
format = formatArray[0];
} else
DE_ASSERT(false);
targets.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));
}
return new es3fFragmentOutputTests.FragmentOutputCase(seed.toString(), '', targets, outputs);
};
es3fFragmentOutputTests.init = function(gl) {
var state = tcuTestCase.runner;
state.testCases = tcuTestCase.newTest('fragment_outputs', 'Top level');
/** @const @type {tcuTestCase.DeqpTest} */ var testGroup = state.testCases;
/** @type {Array<WebGLRenderingContextBase.GLenum>} */
var requiredFloatFormats = [
gl.RGBA32F,
gl.RGBA16F,
gl.R11F_G11F_B10F,
gl.RG32F,
gl.RG16F,
gl.R32F,
gl.R16F
];
/** @type {Array<WebGLRenderingContextBase.GLenum>} */
var requiredFixedFormats = [
gl.RGBA8,
gl.SRGB8_ALPHA8,
gl.RGB10_A2,
gl.RGBA4,
gl.RGB5_A1,
gl.RGB8,
gl.RGB565,
gl.RG8,
gl.R8
];
/** @type {Array<WebGLRenderingContextBase.GLenum>} */
var requiredIntFormats = [
gl.RGBA32I,
gl.RGBA16I,
gl.RGBA8I,
gl.RG32I,
gl.RG16I,
gl.RG8I,
gl.R32I,
gl.R16I,
gl.R8I
];
/** @type {Array<WebGLRenderingContextBase.GLenum>} */
var requiredUintFormats = [
gl.RGBA32UI,
gl.RGBA16UI,
gl.RGBA8UI,
gl.RGB10_A2UI,
gl.RG32UI,
gl.RG16UI,
gl.RG8UI,
gl.R32UI,
gl.R16UI,
gl.R8UI
];
/** @type {Array<gluShaderUtil.precision>} */
var precisions = [
gluShaderUtil.precision.PRECISION_LOWP,
gluShaderUtil.precision.PRECISION_MEDIUMP,
gluShaderUtil.precision.PRECISION_HIGHP
];
// .basic.
/** @const @type {number} */ var width = 64;
/** @const @type {number} */ var height = 64;
/** @const @type {number} */ var samples = 0;
/** @type {Array<es3fFragmentOutputTests.BufferSpec>} */ var fboSpec = null;
/** @type {gluShaderUtil.precision} */ var prec;
/** @type {string} */ var precName;
// .float
if (gl.getExtension('EXT_color_buffer_float')) {
/** @type {tcuTestCase.DeqpTest} */ var floatGroup = tcuTestCase.newTest('basic.float', 'Floating-point output tests');
testGroup.addChild(floatGroup);
for (var fmtNdx = 0; fmtNdx < requiredFloatFormats.length; fmtNdx++) {
var format = requiredFloatFormats[fmtNdx];
var fmtName = es3fFboTestUtil.getFormatName(format);
fboSpec = [];
fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));
for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
prec = precisions[precNdx];
precName = gluShaderUtil.getPrecisionName(prec);
// NOTE: Eliminated original OutputVec and toVec(), as it only returned an element of the outputs array in OutputVec
floatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_float', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT, prec, 0)]));
floatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC2, prec, 0)]));
floatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC3, prec, 0)]));
floatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC4, prec, 0)]));
}
}
}
// .fixed
/** @type {tcuTestCase.DeqpTest} */ var fixedGroup = tcuTestCase.newTest('basic.fixed', 'Fixed-point output tests');
testGroup.addChild(fixedGroup);
for (var fmtNdx = 0; fmtNdx < requiredFixedFormats.length; fmtNdx++) {
var format = requiredFixedFormats[fmtNdx];
var fmtName = es3fFboTestUtil.getFormatName(format);
fboSpec = [];
fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));
for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
prec = precisions[precNdx];
precName = gluShaderUtil.getPrecisionName(prec);
fixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_float', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT, prec, 0)]));
fixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC2, prec, 0)]));
fixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC3, prec, 0)]));
fixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC4, prec, 0)]));
}
}
// .int
/** @type {tcuTestCase.DeqpTest} */ var intGroup = tcuTestCase.newTest('basic.int', 'Integer output tests');
testGroup.addChild(intGroup);
for (var fmtNdx = 0; fmtNdx < requiredIntFormats.length; fmtNdx++) {
var format = requiredIntFormats[fmtNdx];
var fmtName = es3fFboTestUtil.getFormatName(format);
fboSpec = [];
fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));
for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
prec = precisions[precNdx];
precName = gluShaderUtil.getPrecisionName(prec);
intGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_int', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT, prec, 0)]));
intGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC2, prec, 0)]));
intGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC3, prec, 0)]));
intGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC4, prec, 0)]));
}
}
// .uint
/** @type {tcuTestCase.DeqpTest} */ var uintGroup = tcuTestCase.newTest('basic.uint', 'Usigned integer output tests');
testGroup.addChild(uintGroup);
for (var fmtNdx = 0; fmtNdx < requiredUintFormats.length; fmtNdx++) {
var format = requiredUintFormats[fmtNdx];
var fmtName = es3fFboTestUtil.getFormatName(format);
fboSpec = [];
fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));
for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
prec = precisions[precNdx];
precName = gluShaderUtil.getPrecisionName(prec);
uintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uint', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT, prec, 0)]));
uintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC2, prec, 0)]));
uintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC3, prec, 0)]));
uintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC4, prec, 0)]));
}
}
// .array
/** @type {number} */ var numTargets = 3;
// .float
if (gl.getExtension('EXT_color_buffer_float')) {
/** @type {tcuTestCase.DeqpTest} */ var arrayFloatGroup = tcuTestCase.newTest('array.float', 'Floating-point output tests');
testGroup.addChild(arrayFloatGroup);
for (var fmtNdx = 0; fmtNdx < requiredFloatFormats.length; fmtNdx++) {
var format = requiredFloatFormats[fmtNdx];
var fmtName = es3fFboTestUtil.getFormatName(format);
fboSpec = [];
for (var ndx = 0; ndx < numTargets; ndx++)
fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));
for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
prec = precisions[precNdx];
precName = gluShaderUtil.getPrecisionName(prec);
arrayFloatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_float', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT, prec, 0, numTargets)]));
arrayFloatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC2, prec, 0, numTargets)]));
arrayFloatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC3, prec, 0, numTargets)]));
arrayFloatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC4, prec, 0, numTargets)]));
}
}
}
// .fixed
/** @type {tcuTestCase.DeqpTest} */ var arrayFixedGroup = tcuTestCase.newTest('array.fixed', 'Fixed-point output tests');
testGroup.addChild(arrayFixedGroup);
for (var fmtNdx = 0; fmtNdx < requiredFixedFormats.length; fmtNdx++) {
var format = requiredFixedFormats[fmtNdx];
var fmtName = es3fFboTestUtil.getFormatName(format);
fboSpec = [];
for (var ndx = 0; ndx < numTargets; ndx++)
fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));
for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
prec = precisions[precNdx];
precName = gluShaderUtil.getPrecisionName(prec);
arrayFixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_float', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT, prec, 0, numTargets)]));
arrayFixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC2, prec, 0, numTargets)]));
arrayFixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC3, prec, 0, numTargets)]));
arrayFixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC4, prec, 0, numTargets)]));
}
}
// .int
/** @type {tcuTestCase.DeqpTest} */ var arrayIntGroup = tcuTestCase.newTest('array.int', 'Integer output tests');
testGroup.addChild(arrayIntGroup);
for (var fmtNdx = 0; fmtNdx < requiredIntFormats.length; fmtNdx++) {
var format = requiredIntFormats[fmtNdx];
var fmtName = es3fFboTestUtil.getFormatName(format);
fboSpec = [];
for (var ndx = 0; ndx < numTargets; ndx++)
fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));
for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
prec = precisions[precNdx];
precName = gluShaderUtil.getPrecisionName(prec);
arrayIntGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_int', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT, prec, 0, numTargets)]));
arrayIntGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC2, prec, 0, numTargets)]));
arrayIntGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC3, prec, 0, numTargets)]));
arrayIntGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC4, prec, 0, numTargets)]));
}
}
// .uint
/** @type {tcuTestCase.DeqpTest} */ var arrayUintGroup = tcuTestCase.newTest('array.uint', 'Usigned integer output tests');
testGroup.addChild(arrayUintGroup);
for (var fmtNdx = 0; fmtNdx < requiredUintFormats.length; fmtNdx++) {
var format = requiredUintFormats[fmtNdx];
var fmtName = es3fFboTestUtil.getFormatName(format);
fboSpec = [];
for (var ndx = 0; ndx < numTargets; ndx++)
fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));
for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
prec = precisions[precNdx];
precName = gluShaderUtil.getPrecisionName(prec);
arrayUintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uint', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT, prec, 0, numTargets)]));
arrayUintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC2, prec, 0, numTargets)]));
arrayUintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC3, prec, 0, numTargets)]));
arrayUintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC4, prec, 0, numTargets)]));
}
}
// .random
/** @type {Array<tcuTestCase.DeqpTest>} */ var randomGroup = [];
var numRandomGroups = 3;
for (var ii = 0; ii < numRandomGroups; ++ii) {
randomGroup[ii] = tcuTestCase.newTest('random', 'Random fragment output cases');
testGroup.addChild(randomGroup[ii]);
}
/** @type {boolean} */ var colorBufferFloatSupported = (gl.getExtension('EXT_color_buffer_float') != null);
for (var seed = 0; seed < 100; seed++) {
var test = es3fFragmentOutputTests.createRandomCase(2, 4, seed, colorBufferFloatSupported);
if (test !== null) {
randomGroup[seed % numRandomGroups].addChild(test);
}
}
};
/**
* Create and execute the test cases
*/
es3fFragmentOutputTests.run = function(context, range) {
gl = context;
//Set up Test Root parameters
var testName = 'fragment_output';
var testDescription = 'Fragment Output Tests';
var state = tcuTestCase.runner;
state.testName = testName;
state.testCases = tcuTestCase.newTest(testName, testDescription, null);
//Set up name and description of this test series.
setCurrentTestName(testName);
description(testDescription);
try {
es3fFragmentOutputTests.init(gl);
if (range)
state.setRange(range);
tcuTestCase.runTestCases();
} catch (err) {
testFailedOptions('Failed to es3fFragmentOutputTests.run tests', false);
bufferedLogToConsole(err);
tcuTestCase.runner.terminate();
}
};
});