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('modules.shared.glsShaderRenderCase');
goog.require('framework.common.tcuImageCompare');
goog.require('framework.common.tcuMatrix');
goog.require('framework.common.tcuRGBA');
goog.require('framework.common.tcuSurface');
goog.require('framework.common.tcuTestCase');
goog.require('framework.common.tcuTexture');
goog.require('framework.delibs.debase.deMath');
goog.require('framework.delibs.debase.deString');
goog.require('framework.delibs.debase.deRandom');
goog.require('framework.opengl.gluDrawUtil');
goog.require('framework.opengl.gluTexture');
goog.require('framework.opengl.gluTextureUtil');
goog.require('framework.opengl.gluShaderProgram');
goog.scope(function() {
var glsShaderRenderCase = modules.shared.glsShaderRenderCase;
var deMath = framework.delibs.debase.deMath;
var deString = framework.delibs.debase.deString;
var deRandom = framework.delibs.debase.deRandom;
var gluTextureUtil = framework.opengl.gluTextureUtil;
var gluTexture = framework.opengl.gluTexture;
var gluDrawUtil = framework.opengl.gluDrawUtil;
var tcuImageCompare = framework.common.tcuImageCompare;
var tcuTexture = framework.common.tcuTexture;
var tcuMatrix = framework.common.tcuMatrix;
var tcuRGBA = framework.common.tcuRGBA;
var tcuTestCase = framework.common.tcuTestCase;
var tcuSurface = framework.common.tcuSurface;
var gluShaderProgram = framework.opengl.gluShaderProgram;
/** @typedef {function(glsShaderRenderCase.ShaderEvalContext)} */ glsShaderRenderCase.ShaderEvalFunc;
/** @const {number} */ glsShaderRenderCase.GRID_SIZE = 64;
/** @const {number} */ glsShaderRenderCase.MAX_RENDER_WIDTH = 128;
/** @const {number} */ glsShaderRenderCase.MAX_RENDER_HEIGHT = 112;
/** @const {Array<number>} */ glsShaderRenderCase.DEFAULT_CLEAR_COLOR = [0.125, 0.25, 0.5, 1.0];
/** @const {number} */ glsShaderRenderCase.MAX_USER_ATTRIBS = 4;
/** @const {number} */ glsShaderRenderCase.MAX_TEXTURES = 4;
/**
* @param {Array<number>} a
* @return {tcuRGBA.RGBA}
*/
glsShaderRenderCase.toRGBA = function(a) {
return tcuRGBA.newRGBAComponents(
deMath.clamp(Math.round(a[0] * 255.0), 0, 255),
deMath.clamp(Math.round(a[1] * 255.0), 0, 255),
deMath.clamp(Math.round(a[2] * 255.0), 0, 255),
deMath.clamp(Math.round(a[3] * 255.0), 0, 255));
};
/**
* Helper function
* @param {?(gluTexture.Texture2D|gluTexture.TextureCube|gluTexture.Texture2DArray|gluTexture.Texture3D)} tex
* @return {gluTexture.Type}
*/
glsShaderRenderCase.getTextureType = function(tex) {
if (tex === null || tex.getType() <= 0)
return gluTexture.Type.TYPE_NONE;
else
return tex.getType();
};
/**
* @constructor
* @param {number=} indent
*/
glsShaderRenderCase.LineStream = function(indent) {
indent = indent === undefined ? 0 : indent;
/** @type {number} */ this.m_indent = indent;
/** @type {string} */ this.m_stream;
/** @type {string} */ this.m_string;
};
/**
* @return {string}
*/
glsShaderRenderCase.LineStream.prototype.str = function() {
this.m_string = this.m_stream;
return this.m_string;
};
/**
* @constructor
* @param {(gluTexture.Texture2D|gluTexture.TextureCube|gluTexture.Texture2DArray|gluTexture.Texture3D)=} tex
* @param {tcuTexture.Sampler=} sampler
*/
glsShaderRenderCase.TextureBinding = function(tex, sampler) {
tex = tex === undefined ? null : tex;
sampler = sampler === undefined ? null : sampler;
/** @type {gluTexture.Type} */ this.m_type = glsShaderRenderCase.getTextureType(tex);
/** @type {tcuTexture.Sampler} */ this.m_sampler = sampler;
/** @type {(gluTexture.Texture2D|gluTexture.TextureCube|gluTexture.Texture2DArray|gluTexture.Texture3D)} */
this.m_binding = tex;
};
/**
* @param {tcuTexture.Sampler} sampler
*/
glsShaderRenderCase.TextureBinding.prototype.setSampler = function(sampler) {
this.m_sampler = sampler;
};
/**
* @param {(gluTexture.Texture2D|gluTexture.TextureCube|gluTexture.Texture2DArray|gluTexture.Texture3D)} tex
*/
glsShaderRenderCase.TextureBinding.prototype.setTexture = function(tex) {
this.m_type = glsShaderRenderCase.getTextureType(tex);
this.m_binding = tex;
};
/** @return {gluTexture.Type} */
glsShaderRenderCase.TextureBinding.prototype.getType = function() {
return this.m_type;
};
/** @return {tcuTexture.Sampler} */
glsShaderRenderCase.TextureBinding.prototype.getSampler = function() {
return this.m_sampler;
};
/** @return {(gluTexture.Texture2D|gluTexture.TextureCube|gluTexture.Texture2DArray|gluTexture.Texture3D)} */
glsShaderRenderCase.TextureBinding.prototype.getBinding = function() {
return this.m_binding;
};
/**
* @constructor
* @param {number} gridSize
* @param {number} width
* @param {number} height
* @param {Array<number>} constCoords
* @param {Array<tcuMatrix.Matrix>} userAttribTransforms
* @param {Array<glsShaderRenderCase.TextureBinding>} textures
*/
glsShaderRenderCase.QuadGrid = function(gridSize, width, height, constCoords, userAttribTransforms, textures) {
/** @type {number} */ this.m_gridSize = gridSize;
/** @type {number} */ this.m_numVertices = (gridSize + 1) * (gridSize + 1);
/** @type {number} */ this.m_numTriangles = (gridSize * gridSize *2);
/** @type {Array<number>} */ this.m_constCoords = constCoords;
/** @type {Array<tcuMatrix.Matrix>} */ this.m_userAttribTransforms = userAttribTransforms;
/** @type {Array<glsShaderRenderCase.TextureBinding>} */ this.m_textures = textures;
/** @type {Array<Array<number>>} */ this.m_screenPos = [];
/** @type {Array<Array<number>>} */ this.m_positions = [];
/** @type {Array<Array<number>>} */ this.m_coords = []; //!< Near-unit coordinates, roughly [-2.0 .. 2.0].
/** @type {Array<Array<number>>} */ this.m_unitCoords = []; //!< Positive-only coordinates [0.0 .. 1.5].
/** @type {Array<number>} */ this.m_attribOne = [];
/** @type {Array<Array<number>>} */ this.m_userAttribs = [];
for (var attribNdx = 0; attribNdx < this.getNumUserAttribs(); attribNdx++)
this.m_userAttribs[attribNdx] = [];
/** @type {Array<number>} */ this.m_indices = [];
/** @type Array<number>} */ var viewportScale = [width, height, 0, 0];
for (var y = 0; y < gridSize + 1; y++)
for (var x = 0; x < gridSize + 1; x++) {
/** @type {number} */ var sx = x / gridSize;
/** @type {number} */ var sy = y / gridSize;
/** @type {number} */ var fx = 2.0 * sx - 1.0;
/** @type {number} */ var fy = 2.0 * sy - 1.0;
/** @type {number} */ var vtxNdx = ((y * (gridSize + 1)) + x);
this.m_positions[vtxNdx] = [fx, fy, 0.0, 1.0];
this.m_attribOne[vtxNdx] = 1.0;
this.m_screenPos[vtxNdx] = deMath.multiply([sx, sy, 0.0, 1.0], viewportScale);
this.m_coords[vtxNdx] = this.getCoords(sx, sy);
this.m_unitCoords[vtxNdx] = this.getUnitCoords(sx, sy);
for (var attribNdx = 0; attribNdx < this.getNumUserAttribs(); attribNdx++)
this.m_userAttribs[attribNdx][vtxNdx] = this.getUserAttrib(attribNdx, sx, sy);
}
// Compute indices.
for (var y = 0; y < gridSize; y++)
for (var x = 0; x < gridSize; x++) {
/** @type {number} */ var stride = gridSize + 1;
/** @type {number} */ var v00 = (y * stride) + x;
/** @type {number} */ var v01 = (y * stride) + x + 1;
/** @type {number} */ var v10 = ((y + 1) * stride) + x;
/** @type {number} */ var v11 = ((y + 1) * stride) + x + 1;
/** @type {number} */ var baseNdx = ((y * gridSize) + x) * 6;
this.m_indices[baseNdx + 0] = v10;
this.m_indices[baseNdx + 1] = v00;
this.m_indices[baseNdx + 2] = v01;
this.m_indices[baseNdx + 3] = v10;
this.m_indices[baseNdx + 4] = v01;
this.m_indices[baseNdx + 5] = v11;
}
};
/** @return {number} */
glsShaderRenderCase.QuadGrid.prototype.getGridSize = function() {
return this.m_gridSize;
};
/** @return {number} */
glsShaderRenderCase.QuadGrid.prototype.getNumVertices = function() {
return this.m_numVertices;
};
/** @return {number} */
glsShaderRenderCase.QuadGrid.prototype.getNumTriangles = function() {
return this.m_numTriangles;
};
/** @return {Array<number>} */
glsShaderRenderCase.QuadGrid.prototype.getConstCoords = function() {
return this.m_constCoords;
};
/** @return {Array<tcuMatrix.Matrix>} */
glsShaderRenderCase.QuadGrid.prototype.getUserAttribTransforms = function() {
return this.m_userAttribTransforms;
};
/** @return {Array<glsShaderRenderCase.TextureBinding>} */
glsShaderRenderCase.QuadGrid.prototype.getTextures = function() {
return this.m_textures;
};
/** @return {Array<Array<number>>} */
glsShaderRenderCase.QuadGrid.prototype.getPositions = function() {
return this.m_positions;
};
/** @return {Array<number>} */
glsShaderRenderCase.QuadGrid.prototype.getAttribOne = function() {
return this.m_attribOne;
};
/** @return {Array<Array<number>>} */
glsShaderRenderCase.QuadGrid.prototype.getCoordsArray = function() {
return this.m_coords;
};
/** @return {Array<Array<number>>} */
glsShaderRenderCase.QuadGrid.prototype.getUnitCoordsArray = function() {
return this.m_unitCoords;
};
/**
* @param {number} attribNdx
* @return {Array<number>}
*/
glsShaderRenderCase.QuadGrid.prototype.getUserAttribByIndex = function(attribNdx) {
return this.m_userAttribs[attribNdx];
};
/** @return {Array<number>} */
glsShaderRenderCase.QuadGrid.prototype.getIndices = function() {
return this.m_indices;
};
/**
* @param {number} sx
* @param {number} sy
* @return {Array<number>}
*/
glsShaderRenderCase.QuadGrid.prototype.getCoords = function(sx, sy) {
/** @type {number} */ var fx = 2.0 * sx - 1.0;
/** @type {number} */ var fy = 2.0 * sy - 1.0;
return [fx, fy, -fx + 0.33 * fy, -0.275 * fx - fy];
};
/**
* @param {number} sx
* @param {number} sy
* @return {Array<number>}
*/
glsShaderRenderCase.QuadGrid.prototype.getUnitCoords = function(sx, sy) {
return [sx, sy, 0.33 * sx + 0.5 * sy, 0.5 * sx + 0.25 * sy];
};
/**
* @return {number}
*/
glsShaderRenderCase.QuadGrid.prototype.getNumUserAttribs = function() {
return this.m_userAttribTransforms.length;
};
/**
* @param {number} attribNdx
* @param {number} sx
* @param {number} sy
* @return {Array<number>}
*/
glsShaderRenderCase.QuadGrid.prototype.getUserAttrib = function(attribNdx, sx, sy) {
// homogeneous normalized screen-space coordinates
return tcuMatrix.multiplyMatVec(this.m_userAttribTransforms[attribNdx], [sx, sy, 0.0, 1.0]);
};
/**
* @constructor
* @struct
*/
glsShaderRenderCase.ShaderSampler = function() {
/** @type {tcuTexture.Sampler} */ this.sampler;
/** @type {tcuTexture.Texture2D} */ this.tex2D = null;
/** @type {tcuTexture.TextureCube} */ this.texCube = null;
/** @type {tcuTexture.Texture2DArray} */ this.tex2DArray = null;
/** @type {tcuTexture.Texture3D} */ this.tex3D = null;
};
/**
* @constructor
* @param {glsShaderRenderCase.QuadGrid} quadGrid_
*/
glsShaderRenderCase.ShaderEvalContext = function(quadGrid_) {
/** @type {Array<number>} */ this.coords = [0, 0, 0, 0]
/** @type {Array<number>} */ this.unitCoords = [0, 0, 0, 0]
/** @type {Array<number>} */ this.constCoords = quadGrid_.getConstCoords();
/** @type {Array<Array<number>>} */ this.in_ = [];
/** @type {Array<glsShaderRenderCase.ShaderSampler>} */ this.textures = [];
/** @type {Array<number>} */ this.color = [0, 0, 0, 0.0];
/** @type {boolean} */ this.isDiscarded = false;
/** @type {glsShaderRenderCase.QuadGrid} */ this.quadGrid = quadGrid_;
/** @type {Array<glsShaderRenderCase.TextureBinding>} */ var bindings = this.quadGrid.getTextures();
assertMsgOptions(bindings.length <= glsShaderRenderCase.MAX_TEXTURES, 'Too many bindings.', false, true);
// Fill in texture array.
for (var ndx = 0; ndx < bindings.length; ndx++) {
/** @type {glsShaderRenderCase.TextureBinding} */ var binding = bindings[ndx];
this.textures[ndx] = new glsShaderRenderCase.ShaderSampler();
if (binding.getType() == gluTexture.Type.TYPE_NONE)
continue;
this.textures[ndx].sampler = binding.getSampler();
switch (binding.getType()) {
case gluTexture.Type.TYPE_2D:
this.textures[ndx].tex2D = binding.getBinding().getRefTexture();
break;
case gluTexture.Type.TYPE_CUBE_MAP:
this.textures[ndx].texCube = binding.getBinding().getRefTexture();
break;
case gluTexture.Type.TYPE_2D_ARRAY:
this.textures[ndx].tex2DArray = binding.getBinding().getRefTexture();
break;
case gluTexture.Type.TYPE_3D:
this.textures[ndx].tex3D = binding.getBinding().getRefTexture();
break;
default:
throw new Error("Binding type not supported");
}
}
};
/**
* @param {number} sx
* @param {number} sy
*/
glsShaderRenderCase.ShaderEvalContext.prototype.reset = function(sx, sy) {
// Clear old values
this.color = [0.0, 0.0, 0.0, 1.0];
this.isDiscarded = false;
// Compute coords
this.coords = this.quadGrid.getCoords(sx, sy);
this.unitCoords = this.quadGrid.getUnitCoords(sx, sy);
// Compute user attributes.
/** @type {number} */ var numAttribs = this.quadGrid.getNumUserAttribs();
assertMsgOptions(numAttribs <= glsShaderRenderCase.MAX_USER_ATTRIBS, 'numAttribs out of range', false, true);
for (var attribNdx = 0; attribNdx < numAttribs; attribNdx++)
this.in_[attribNdx] = this.quadGrid.getUserAttrib(attribNdx, sx, sy);
};
glsShaderRenderCase.ShaderEvalContext.prototype.discard = function() {
this.isDiscarded = true;
};
/**
* @param {number} unitNdx
* @param {Array<number>} coords
*/
glsShaderRenderCase.ShaderEvalContext.prototype.texture2D = function(unitNdx, coords) {
if (this.textures.length > 0 && this.textures[unitNdx].tex2D)
return this.textures[unitNdx].tex2D.getView().sample(this.textures[unitNdx].sampler, coords, 0.0);
else
return [0.0, 0.0, 0.0, 1.0];
};
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
glsShaderRenderCase.evalCoordsPassthroughX = function(c) {
c.color[0] = c.coords[0];
};
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
glsShaderRenderCase.evalCoordsPassthroughXY = function(c) {
var swizzle01 = deMath.swizzle(c.coords, [0, 1]);
c.color[0] = swizzle01[0];
c.color[1] = swizzle01[1];
};
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
glsShaderRenderCase.evalCoordsPassthroughXYZ = function(c) {
var swizzle012 = deMath.swizzle(c.coords, [0, 1, 2]);
c.color[0] = swizzle012[0];
c.color[1] = swizzle012[1];
c.color[2] = swizzle012[2];
};
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
glsShaderRenderCase.evalCoordsPassthrough = function(c) {
c.color = c.coords;
};
/** @param {glsShaderRenderCase.ShaderEvalContext} c */
glsShaderRenderCase.evalCoordsSwizzleWZYX = function(c) {
c.color = deMath.swizzle(c.coords, [3, 2, 1, 0]);
};
/**
* @constructor
* @param {?glsShaderRenderCase.ShaderEvalFunc=} evalFunc
*/
glsShaderRenderCase.ShaderEvaluator = function(evalFunc) {
/** @type {?glsShaderRenderCase.ShaderEvalFunc} */ this.m_evalFunc = evalFunc || null;
};
/**
* @param {glsShaderRenderCase.ShaderEvalContext} ctx
*/
glsShaderRenderCase.ShaderEvaluator.prototype.evaluate = function(ctx) {
assertMsgOptions(this.m_evalFunc !== null, 'No evaluation function specified.', false, true);
this.m_evalFunc(ctx);
};
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
* @param {string} name
* @param {string} description
* @param {boolean} isVertexCase
* @param {glsShaderRenderCase.ShaderEvalFunc=} evalFunc
*/
glsShaderRenderCase.ShaderRenderCase = function(name, description, isVertexCase, evalFunc) {
tcuTestCase.DeqpTest.call(this, name, description);
// evalFunc = evalFunc || null;
/** @type {boolean} */ this.m_isVertexCase = isVertexCase;
/** @type {?glsShaderRenderCase.ShaderEvalFunc} */ this.m_defaultEvaluator = evalFunc || null;
/** @type {glsShaderRenderCase.ShaderEvaluator} */ this.m_evaluator = new glsShaderRenderCase.ShaderEvaluator(this.m_defaultEvaluator);
/** @type {string} */ this.m_vertShaderSource = '';
/** @type {string} */ this.m_fragShaderSource = '';
/** @type {Array<number>} */ this.m_clearColor = glsShaderRenderCase.DEFAULT_CLEAR_COLOR;
/** @type {Array<tcuMatrix.Matrix>} */ this.m_userAttribTransforms = [];
/** @type {Array<glsShaderRenderCase.TextureBinding>} */ this.m_textures = [];
/** @type {?gluShaderProgram.ShaderProgram} */ this.m_program = null;
};
/**
* @param {string} name
* @param {string} description
* @param {boolean} isVertexCase
* @param {glsShaderRenderCase.ShaderEvaluator} evaluator
* @return {glsShaderRenderCase.ShaderRenderCase}
*/
glsShaderRenderCase.ShaderRenderCase.newWithEvaluator = function(name, description, isVertexCase, evaluator) {
var renderCase = new glsShaderRenderCase.ShaderRenderCase(name, description, isVertexCase);
renderCase.m_evaluator = evaluator;
return renderCase;
};
glsShaderRenderCase.ShaderRenderCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
glsShaderRenderCase.ShaderRenderCase.prototype.constructor = glsShaderRenderCase.ShaderRenderCase;
glsShaderRenderCase.ShaderRenderCase.prototype.deinit = function() {
this.m_program = null;
};
glsShaderRenderCase.ShaderRenderCase.prototype.init = function() {
this.postinit();
};
glsShaderRenderCase.ShaderRenderCase.prototype.postinit = function() {
if (this.m_vertShaderSource.length === 0 || this.m_fragShaderSource.length === 0) {
assertMsgOptions(this.m_vertShaderSource.length === 0 && this.m_fragShaderSource.length === 0, 'No shader source.', false, true);
this.setupShaderData();
}
assertMsgOptions(!this.m_program, 'Program defined.', false, true);
this.m_program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(this.m_vertShaderSource, this.m_fragShaderSource));
try {
bufferedLogToConsole(this.m_program.program.info.infoLog); // Always log shader program.
if (!this.m_program.isOk())
throw new Error("Shader compile error.");
}
catch (exception) {
// Clean up.
this.deinit();
throw exception;
}
};
/**
* @return {tcuTestCase.IterateResult}
*/
glsShaderRenderCase.ShaderRenderCase.prototype.postiterate = function() {
assertMsgOptions(this.m_program !== null, 'Program not specified.', false, true);
/** @type {?WebGLProgram} */ var programID = this.m_program.getProgram();
gl.useProgram(programID);
// Create quad grid.
/** @type {Array<number>} */ var viewportSize = this.getViewportSize();
/** @type {number} */ var width = viewportSize[0];
/** @type {number} */ var height = viewportSize[1];
// \todo [petri] Better handling of constCoords (render in multiple chunks, vary coords).
/** @type {glsShaderRenderCase.QuadGrid} */
var quadGrid = new glsShaderRenderCase.QuadGrid(
this.m_isVertexCase ? glsShaderRenderCase.GRID_SIZE : 4, width, height,
[0.125, 0.25, 0.5, 1.0], this.m_userAttribTransforms, this.m_textures);
// Render result.
/** @type {tcuSurface.Surface} */ var resImage = new tcuSurface.Surface(width, height);
this.render(resImage, programID, quadGrid);
// Compute reference.
/** @type {tcuSurface.Surface} */ var refImage = new tcuSurface.Surface(width, height);
if (this.m_isVertexCase)
this.computeVertexReference(refImage, quadGrid);
else
this.computeFragmentReference(refImage, quadGrid);
// Compare.
/** @type {boolean} */ var testOk = this.compareImages(resImage, refImage, 0.05);
// De-initialize.
gl.useProgram(null);
if (!testOk)
testFailedOptions("Fail", false);
else
testPassedOptions("Pass", true);
return tcuTestCase.IterateResult.STOP;
};
/**
* @return {tcuTestCase.IterateResult}
*/
glsShaderRenderCase.ShaderRenderCase.prototype.iterate = function() {
return this.postiterate();
};
glsShaderRenderCase.ShaderRenderCase.prototype.setupShaderData = function() {};
/**
* @param {?WebGLProgram} programId
*/
glsShaderRenderCase.ShaderRenderCase.prototype.setup = function(programId) {};
/**
* @param {?WebGLProgram} programId
* @param {Array<number>} constCoords
*/
glsShaderRenderCase.ShaderRenderCase.prototype.setupUniforms = function(programId, constCoords) {};
/**
* @return {Array<number>}
*/
glsShaderRenderCase.ShaderRenderCase.prototype.getViewportSize = function() {
return [Math.min(gl.canvas.width, glsShaderRenderCase.MAX_RENDER_WIDTH),
Math.min(gl.canvas.height, glsShaderRenderCase.MAX_RENDER_HEIGHT)];
};
/**
* @param {?WebGLProgram} programId
*/
glsShaderRenderCase.ShaderRenderCase.prototype.setupDefaultInputs = function(programId) {
// SETUP UNIFORMS.
glsShaderRenderCase.setupDefaultUniforms(programId);
// SETUP TEXTURES.
for (var ndx = 0; ndx < this.m_textures.length; ndx++) {
/** @type {glsShaderRenderCase.TextureBinding} */ var tex = this.m_textures[ndx];
/** @type {tcuTexture.Sampler} */ var sampler = tex.getSampler();
/** @type {number} */ var texTarget = gl.NONE;
/** @type {number} */ var texObj = 0;
if (tex.getType() === gluTexture.Type.TYPE_NONE)
continue;
switch (tex.getType()) {
case gluTexture.Type.TYPE_2D:
texTarget = gl.TEXTURE_2D;
texObj = tex.getBinding().getGLTexture();
break;
case gluTexture.Type.TYPE_CUBE_MAP:
texTarget = gl.TEXTURE_CUBE_MAP;
texObj = tex.getBinding().getGLTexture();
break;
case gluTexture.Type.TYPE_2D_ARRAY:
texTarget = gl.TEXTURE_2D_ARRAY;
texObj = tex.getBinding().getGLTexture();
break;
case gluTexture.Type.TYPE_3D:
texTarget = gl.TEXTURE_3D;
texObj = tex.getBinding().getGLTexture();
break;
default:
throw new Error("Type not supported");
}
gl.activeTexture(gl.TEXTURE0+ ndx);
gl.bindTexture(texTarget, texObj);
gl.texParameteri(texTarget, gl.TEXTURE_WRAP_S, gluTextureUtil.getGLWrapMode(sampler.wrapS));
gl.texParameteri(texTarget, gl.TEXTURE_WRAP_T, gluTextureUtil.getGLWrapMode(sampler.wrapT));
gl.texParameteri(texTarget, gl.TEXTURE_MIN_FILTER, gluTextureUtil.getGLFilterMode(sampler.minFilter));
gl.texParameteri(texTarget, gl.TEXTURE_MAG_FILTER, gluTextureUtil.getGLFilterMode(sampler.magFilter));
if (texTarget === gl.TEXTURE_3D)
gl.texParameteri(texTarget, gl.TEXTURE_WRAP_R, gluTextureUtil.getGLWrapMode(sampler.wrapR));
if (sampler.compare != tcuTexture.CompareMode.COMPAREMODE_NONE)
{
gl.texParameteri(texTarget, gl.TEXTURE_COMPARE_MODE, gl.COMPARE_REF_TO_TEXTURE);
gl.texParameteri(texTarget, gl.TEXTURE_COMPARE_FUNC, gluTextureUtil.getGLCompareFunc(sampler.compare));
}
}
};
/**
* @param {tcuSurface.Surface} result
* @param {?WebGLProgram} programId
* @param {glsShaderRenderCase.QuadGrid} quadGrid
**/
glsShaderRenderCase.ShaderRenderCase.prototype.render = function(result, programId, quadGrid) {
// Buffer info.
/** @type {number} */ var width = result.getWidth();
/** @type {number} */ var height = result.getHeight();
/** @type {number} */ var xOffsetMax = gl.drawingBufferWidth - width;
/** @type {number} */ var yOffsetMax = gl.drawingBufferHeight - height;
/** @type {number} */ var hash = deString.deStringHash(this.m_vertShaderSource) + deString.deStringHash(this.m_fragShaderSource);
/** @type {deRandom.Random} */ var rnd = new deRandom.Random(hash);
/** @type {number} */ var xOffset = rnd.getInt(0, xOffsetMax);
/** @type {number} */ var yOffset = rnd.getInt(0, yOffsetMax);
gl.viewport(xOffset, yOffset, width, height);
// Setup program.
this.setupUniforms(programId, quadGrid.getConstCoords());
this.setupDefaultInputs(programId);
// Clear.
gl.clearColor(this.m_clearColor[0], this.m_clearColor[1], this.m_clearColor[2], this.m_clearColor[3]);
gl.clear(gl.COLOR_BUFFER_BIT);
// Draw.
/** @type {Array<gluDrawUtil.VertexArrayBinding>} */ var vertexArrays = [];
/** @type {number} */ var numElements = quadGrid.getNumTriangles()*3;
glsShaderRenderCase.getDefaultVertexArrays(quadGrid, programId, vertexArrays);
gluDrawUtil.draw(gl, programId, vertexArrays, gluDrawUtil.triangles(quadGrid.getIndices()));
// Read back results.
result.readViewport(gl, [xOffset, yOffset, width, height]);
};
/**
* @param {tcuSurface.Surface} result
* @param {glsShaderRenderCase.QuadGrid} quadGrid
**/
glsShaderRenderCase.ShaderRenderCase.prototype.computeVertexReference = function(result, quadGrid) {
// Buffer info.
/** @type {number} */ var width = result.getWidth();
/** @type {number} */ var height = result.getHeight();
/** @type {number} */ var gridSize = quadGrid.getGridSize();
/** @type {number} */ var stride = gridSize + 1;
/** @type {boolean} */ var hasAlpha = gl.getContextAttributes().alpha;
/** @type {glsShaderRenderCase.ShaderEvalContext} */
var evalCtx = new glsShaderRenderCase.ShaderEvalContext(quadGrid);
/** @type {Array<number>} */ var color = [];
// Evaluate color for each vertex.
/** @type {Array<Array<number>>} */ var colors = [];
for (var y = 0; y < gridSize + 1; y++)
for (var x = 0; x < gridSize + 1; x++) {
/** @type {number} */ var sx = x / gridSize;
/** @type {number} */ var sy = y / gridSize;
/** @type {number} */ var vtxNdx = ((y * (gridSize+ 1 )) + x);
evalCtx.reset(sx, sy);
this.m_evaluator.evaluate(evalCtx);
assertMsgOptions(!evalCtx.isDiscarded, 'Discard is not available in vertex shader.', false, true);
color = evalCtx.color;
if (!hasAlpha)
color[3] = 1.0;
colors[vtxNdx] = color;
}
// Render quads.
for (var y = 0; y < gridSize; y++)
for (var x = 0; x < gridSize; x++) {
/** @type {number} */ var x0 = x / gridSize;
/** @type {number} */ var x1 = (x + 1) / gridSize;
/** @type {number} */ var y0 = y / gridSize;
/** @type {number} */ var y1 = (y + 1) / gridSize;
/** @type {number} */ var sx0 = x0 * width;
/** @type {number} */ var sx1 = x1 * width;
/** @type {number} */ var sy0 = y0 * height;
/** @type {number} */ var sy1 = y1 * height;
/** @type {number} */ var oosx = 1.0 / (sx1 - sx0);
/** @type {number} */ var oosy = 1.0 / (sy1 - sy0);
/** @type {number} */ var ix0 = Math.ceil(sx0 - 0.5);
/** @type {number} */ var ix1 = Math.ceil(sx1 - 0.5);
/** @type {number} */ var iy0 = Math.ceil(sy0 - 0.5);
/** @type {number} */ var iy1 = Math.ceil(sy1 - 0.5);
/** @type {number} */ var v00 = (y * stride) + x;
/** @type {number} */ var v01 = (y * stride) + x + 1;
/** @type {number} */ var v10 = ((y + 1) * stride) + x;
/** @type {number} */ var v11 = ((y + 1) * stride) + x + 1;
/** @type {Array<number>} */ var c00 = colors[v00];
/** @type {Array<number>} */ var c01 = colors[v01];
/** @type {Array<number>} */ var c10 = colors[v10];
/** @type {Array<number>} */ var c11 = colors[v11];
for (var iy = iy0; iy < iy1; iy++)
for (var ix = ix0; ix < ix1; ix++) {
assertMsgOptions(deMath.deInBounds32(ix, 0, width), 'Out of bounds.', false, true);
assertMsgOptions(deMath.deInBounds32(iy, 0, height), 'Out of bounds.', false, true);
/** @type {number} */ var sfx = ix + 0.5;
/** @type {number} */ var sfy = iy + 0.5;
/** @type {number} */ var fx1 = deMath.clamp((sfx - sx0) * oosx, 0.0, 1.0);
/** @type {number} */ var fy1 = deMath.clamp((sfy - sy0) * oosy, 0.0, 1.0);
// Triangle quad interpolation.
/** @type {boolean} */ var tri = fx1 + fy1 <= 1.0;
/** @type {number} */ var tx = tri ? fx1 : (1.0 - fx1);
/** @type {number} */ var ty = tri ? fy1 : (1.0 - fy1);
/** @type {Array<number>} */ var t0 = tri ? c00 : c11;
/** @type {Array<number>} */ var t1 = tri ? c01 : c10;
/** @type {Array<number>} */ var t2 = tri ? c10 : c01;
color = deMath.add(t0, deMath.add(deMath.scale(deMath.subtract(t1, t0), tx), deMath.scale(deMath.subtract(t2, t0), ty)));
result.setPixel(ix, iy, glsShaderRenderCase.toRGBA(color).toIVec());
}
}
};
/**
* @param {tcuSurface.Surface} result
* @param {glsShaderRenderCase.QuadGrid} quadGrid
**/
glsShaderRenderCase.ShaderRenderCase.prototype.computeFragmentReference = function(result, quadGrid) {
// Buffer info.
/** @type {number} */ var width = result.getWidth();
/** @type {number} */ var height = result.getHeight();
/** @type {boolean} */ var hasAlpha = gl.getContextAttributes().alpha;
/** @type {glsShaderRenderCase.ShaderEvalContext} */ var evalCtx = new glsShaderRenderCase.ShaderEvalContext(quadGrid);
// Render.
for (var y = 0; y < height; y++)
for (var x = 0; x < width; x++) {
/** @type {number} */ var sx = (x + 0.5) / width;
/** @type {number} */ var sy = (y + 0.5) / height;
evalCtx.reset(sx, sy);
this.m_evaluator.evaluate(evalCtx);
// Select either clear color or computed color based on discarded bit.
/** @type {Array<number>} */ var color = evalCtx.isDiscarded ? this.m_clearColor : evalCtx.color;
if (!hasAlpha)
color[3] = 1.0;
result.setPixel(x, y, glsShaderRenderCase.toRGBA(color).toIVec());
}
};
/**
* @param {tcuSurface.Surface} resImage
* @param {tcuSurface.Surface} refImage
* @param {number} errorThreshold
* @return {boolean}
*/
glsShaderRenderCase.ShaderRenderCase.prototype.compareImages = function(resImage, refImage, errorThreshold) {
return tcuImageCompare.fuzzyCompare("ComparisonResult", "Image comparison result", refImage.getAccess(), resImage.getAccess(), errorThreshold);
};
/**
* @param {number} number
* @return {string} */
glsShaderRenderCase.getIntUniformName = function(number) {
switch (number) {
case 0: return "ui_zero";
case 1: return "ui_one";
case 2: return "ui_two";
case 3: return "ui_three";
case 4: return "ui_four";
case 5: return "ui_five";
case 6: return "ui_six";
case 7: return "ui_seven";
case 8: return "ui_eight";
case 101: return "ui_oneHundredOne";
default:
throw new Error("Uniform not supported.");
}
};
/**
* @param {number} number
* @return {string} */
glsShaderRenderCase.getFloatUniformName = function(number) {
switch (number) {
case 0: return "uf_zero";
case 1: return "uf_one";
case 2: return "uf_two";
case 3: return "uf_three";
case 4: return "uf_four";
case 5: return "uf_five";
case 6: return "uf_six";
case 7: return "uf_seven";
case 8: return "uf_eight";
default:
throw new Error("Uniform not supported.");
}
};
/**
* @param {number} number
* @return {string} */
glsShaderRenderCase.getFloatFractionUniformName = function(number) {
switch (number) {
case 1: return "uf_one";
case 2: return "uf_half";
case 3: return "uf_third";
case 4: return "uf_fourth";
case 5: return "uf_fifth";
case 6: return "uf_sixth";
case 7: return "uf_seventh";
case 8: return "uf_eighth";
default:
throw new Error("Uniform not supported.");
}
};
/**
* @param {?WebGLProgram} programID
*/
glsShaderRenderCase.setupDefaultUniforms = function(programID) {
/** @type {?WebGLUniformLocation} */ var uniLoc;
// Bool.
/**
* @constructor
* @struct
*/
var BoolUniform = function(name, value) {
/** @type {string} */ this.name = name;
/** @type {boolean} */ this.value = value;
};
/** @type {Array<BoolUniform>} */ var s_boolUniforms = [
new BoolUniform("ub_true", true),
new BoolUniform("ub_false", false)
];
for (var i = 0; i < s_boolUniforms.length; i++) {
uniLoc = gl.getUniformLocation(programID, s_boolUniforms[i].name);
if (uniLoc != null)
gl.uniform1i(uniLoc, s_boolUniforms[i].value ? 1 : 0);
}
// BVec4.
/**
* @constructor
* @struct
*/
var BVec4Uniform = function(name, value) {
/** @type {string} */ this.name = name;
/** @type {Array<boolean>} */ this.value = value;
};
/** @type {Array<BVec4Uniform>} */ var s_bvec4Uniforms = [
new BVec4Uniform("ub4_true", [true, true, true, true]),
new BVec4Uniform("ub4_false", [false, false, false, false])
];
for (var i = 0; i < s_bvec4Uniforms.length; i++) {
/** @type {BVec4Uniform} */ var uni = s_bvec4Uniforms[i];
/** @type {Array<number>} */ var arr = [];
arr[0] = uni.value[0] ? 1 : 0;
arr[1] = uni.value[1] ? 1 : 0;
arr[2] = uni.value[2] ? 1 : 0;
arr[3] = uni.value[3] ? 1 : 0;
uniLoc = gl.getUniformLocation(programID, uni.name);
if (uniLoc != null)
gl.uniform4iv(uniLoc, new Int32Array(arr));
}
// Int.
/**
* @constructor
* @struct
*/
var IntUniform = function(name, value) {
/** @type {string} */ this.name = name;
/** @type {number} */ this.value = value;
};
/** @type {Array<IntUniform>} */ var s_intUniforms = [
new IntUniform("ui_minusOne", -1),
new IntUniform("ui_zero", 0),
new IntUniform("ui_one", 1),
new IntUniform("ui_two", 2),
new IntUniform("ui_three", 3),
new IntUniform("ui_four", 4),
new IntUniform("ui_five", 5),
new IntUniform("ui_six", 6),
new IntUniform("ui_seven", 7),
new IntUniform("ui_eight", 8),
new IntUniform("ui_oneHundredOne", 101)
];
for (var i = 0; i < s_intUniforms.length; i++) {
uniLoc = gl.getUniformLocation(programID, s_intUniforms[i].name);
if (uniLoc != null)
gl.uniform1i(uniLoc, s_intUniforms[i].value);
}
// IVec2.
/**
* @constructor
* @struct
*/
var IVec2Uniform = function(name, value) {
/** @type {string} */ this.name = name;
/** @type {Array<number>} */ this.value = value;
};
/** @type {Array<IVec2Uniform>} */ var s_ivec2Uniforms = [
new IVec2Uniform("ui2_minusOne", [-1, -1]),
new IVec2Uniform("ui2_zero", [0, 0]),
new IVec2Uniform("ui2_one", [1, 1]),
new IVec2Uniform("ui2_two", [2, 2]),
new IVec2Uniform("ui2_four", [4, 4]),
new IVec2Uniform("ui2_five", [5, 5])
];
for (var i = 0; i < s_ivec2Uniforms.length; i++) {
uniLoc = gl.getUniformLocation(programID, s_ivec2Uniforms[i].name);
if (uniLoc != null)
gl.uniform2iv(uniLoc, new Int32Array(s_ivec2Uniforms[i].value));
}
// IVec3.
/**
* @constructor
* @struct
*/
var IVec3Uniform = function(name, value) {
/** @type {string} */ this.name = name;
/** @type {Array<number>} */ this.value = value;
};
/** @type {Array<IVec3Uniform>} */ var s_ivec3Uniforms = [
new IVec3Uniform("ui3_minusOne", [-1, -1, -1]),
new IVec3Uniform("ui3_zero", [0, 0, 0]),
new IVec3Uniform("ui3_one", [1, 1, 1]),
new IVec3Uniform("ui3_two", [2, 2, 2]),
new IVec3Uniform("ui3_four", [4, 4, 4]),
new IVec3Uniform("ui3_five", [5, 5, 5])
];
for (var i = 0; i < s_ivec3Uniforms.length; i++) {
uniLoc = gl.getUniformLocation(programID, s_ivec3Uniforms[i].name);
if (uniLoc != null)
gl.uniform3iv(uniLoc, new Int32Array(s_ivec3Uniforms[i].value));
}
// IVec4.
/**
* @constructor
* @struct
*/
var IVec4Uniform = function(name, value) {
/** @type {string} */ this.name = name;
/** @type {Array<number>} */ this.value = value;
};
/** @type {Array<IVec4Uniform>} */ var s_ivec4Uniforms = [
new IVec4Uniform("ui4_minusOne", [-1, -1, -1, -1]),
new IVec4Uniform("ui4_zero", [0, 0, 0, 0]),
new IVec4Uniform("ui4_one", [1, 1, 1, 1]),
new IVec4Uniform("ui4_two", [2, 2, 2, 2]),
new IVec4Uniform("ui4_four", [4, 4, 4, 4]),
new IVec4Uniform("ui4_five", [5, 5, 5, 5])
];
for (var i = 0; i < s_ivec4Uniforms.length; i++) {
uniLoc = gl.getUniformLocation(programID, s_ivec4Uniforms[i].name);
if (uniLoc != null)
gl.uniform4iv(uniLoc, new Int32Array(s_ivec4Uniforms[i].value));
}
// Float.
/**
* @constructor
* @struct
*/
var FloatUniform = function(name, value) {
/** @type {string} */ this.name = name;
/** @type {number} */ this.value = value;
};
/** @type {Array<FloatUniform>} */ var s_floatUniforms = [
new FloatUniform("uf_zero", 0.0),
new FloatUniform("uf_one", 1.0),
new FloatUniform("uf_two", 2.0),
new FloatUniform("uf_three", 3.0),
new FloatUniform("uf_four", 4.0),
new FloatUniform("uf_five", 5.0),
new FloatUniform("uf_six", 6.0),
new FloatUniform("uf_seven", 7.0),
new FloatUniform("uf_eight", 8.0),
new FloatUniform("uf_half", 1.0 / 2.0),
new FloatUniform("uf_third", 1.0 / 3.0),
new FloatUniform("uf_fourth", 1.0 / 4.0),
new FloatUniform("uf_fifth", 1.0 / 5.0),
new FloatUniform("uf_sixth", 1.0 / 6.0),
new FloatUniform("uf_seventh", 1.0 / 7.0),
new FloatUniform("uf_eighth", 1.0 / 8.0)
];
for (var i = 0; i < s_floatUniforms.length; i++) {
uniLoc = gl.getUniformLocation(programID, s_floatUniforms[i].name);
if (uniLoc != null)
gl.uniform1f(uniLoc, s_floatUniforms[i].value);
}
// Vec2.
/**
* @constructor
* @struct
*/
var Vec2Uniform = function(name, value) {
/** @type {string} */ this.name = name;
/** @type {Array<number>} */ this.value = value;
};
/** @type {Array<Vec2Uniform>} */ var s_vec2Uniforms = [
new Vec2Uniform("uv2_minusOne", [-1.0, -1.0]),
new Vec2Uniform("uv2_zero", [0.0, 0.0]),
new Vec2Uniform("uv2_half", [0.5, 0.5]),
new Vec2Uniform("uv2_one", [1.0, 1.0]),
new Vec2Uniform("uv2_two", [2.0, 2.0])
];
for (var i = 0; i < s_vec2Uniforms.length; i++) {
uniLoc = gl.getUniformLocation(programID, s_vec2Uniforms[i].name);
if (uniLoc != null)
gl.uniform2fv(uniLoc, new Float32Array(s_vec2Uniforms[i].value));
}
// Vec3.
/**
* @constructor
* @struct
*/
var Vec3Uniform = function(name, value) {
/** @type {string} */ this.name = name;
/** @type {Array<number>} */ this.value = value;
};
/** @type {Array<Vec3Uniform>} */ var s_vec3Uniforms = [
new Vec3Uniform("uv3_minusOne", [-1.0, -1.0, -1.0]),
new Vec3Uniform("uv3_zero", [0.0, 0.0, 0.0]),
new Vec3Uniform("uv3_half", [0.5, 0.5, 0.5]),
new Vec3Uniform("uv3_one", [1.0, 1.0, 1.0]),
new Vec3Uniform("uv3_two", [2.0, 2.0, 2.0])
];
for (var i = 0; i < s_vec3Uniforms.length; i++) {
uniLoc = gl.getUniformLocation(programID, s_vec3Uniforms[i].name);
if (uniLoc != null)
gl.uniform3fv(uniLoc, new Float32Array(s_vec3Uniforms[i].value));
}
// Vec4.
/**
* @constructor
* @struct
*/
var Vec4Uniform = function(name, value) {
/** @type {string} */ this.name = name;
/** @type {Array<number>} */ this.value = value;
};
/** @type {Array<Vec4Uniform>} */ var s_vec4Uniforms = [
new Vec4Uniform("uv4_minusOne", [-1.0, -1.0, -1.0, -1.0]),
new Vec4Uniform("uv4_zero", [0.0, 0.0, 0.0, 0.0]),
new Vec4Uniform("uv4_half", [0.5, 0.5, 0.5, 0.5]),
new Vec4Uniform("uv4_one", [1.0, 1.0, 1.0, 1.0]),
new Vec4Uniform("uv4_two", [2.0, 2.0, 2.0, 2.0]),
new Vec4Uniform("uv4_black", [0.0, 0.0, 0.0, 1.0]),
new Vec4Uniform("uv4_gray", [0.5, 0.5, 0.5, 1.0]),
new Vec4Uniform("uv4_white", [1.0, 1.0, 1.0, 1.0])
];
for (var i = 0; i < s_vec4Uniforms.length; i++) {
uniLoc = gl.getUniformLocation(programID, s_vec4Uniforms[i].name);
if (uniLoc != null)
gl.uniform4fv(uniLoc, new Float32Array(s_vec4Uniforms[i].value));
}
};
/**
* @param {glsShaderRenderCase.QuadGrid} quadGrid
* @param {?WebGLProgram} program
* @param {Array<gluDrawUtil.VertexArrayBinding>} vertexArrays
*/
glsShaderRenderCase.getDefaultVertexArrays = function(quadGrid, program, vertexArrays) {
/** @type {number} */ var numElements = quadGrid.getNumVertices();
var posArray = [].concat.apply([], quadGrid.getPositions());
var coordsArray = [].concat.apply([], quadGrid.getCoordsArray());
var unitCoordsArray = [].concat.apply([], quadGrid.getUnitCoordsArray());
vertexArrays.push(gluDrawUtil.newFloatVertexArrayBinding("a_position", 4, numElements, 0, posArray));
vertexArrays.push(gluDrawUtil.newFloatVertexArrayBinding("a_coords", 4, numElements, 0, coordsArray));
vertexArrays.push(gluDrawUtil.newFloatVertexArrayBinding("a_unitCoords", 4, numElements, 0, unitCoordsArray));
vertexArrays.push(gluDrawUtil.newFloatVertexArrayBinding("a_one", 1, numElements, 0, quadGrid.getAttribOne()));
// a_inN.
for (var userNdx = 0; userNdx < quadGrid.getNumUserAttribs(); userNdx++) {
/** @type {string} */ var name = "a_in" + userNdx;
var userAttribArray = [].concat.apply([], quadGrid.getUserAttribByIndex(userNdx));
vertexArrays.push(gluDrawUtil.newFloatVertexArrayBinding(name, 4, numElements, 0, userAttribArray));
}
// Matrix attributes - these are set by location
/**
* @constructor
* @struct
*/
var Matrix = function(name, cols, rows) {
this.name = name;
this.numCols = cols;
this.numRows = rows;
};
/** @type {Array<Matrix>} */ var matrices = [
new Matrix('a_mat2', 2, 2),
new Matrix('a_mat2x3', 2, 3),
new Matrix('a_mat2x4', 2, 4),
new Matrix('a_mat3x2', 3, 2),
new Matrix('a_mat3', 3, 3),
new Matrix('a_mat3x4', 3, 4),
new Matrix('a_mat4x2', 4, 2),
new Matrix('a_mat4x3', 4, 3),
new Matrix('a_mat4', 4, 4)
];
for (var matNdx = 0; matNdx < matrices.length; matNdx++) {
/** @type {number} */ var loc = gl.getAttribLocation(program, matrices[matNdx].name);
if (loc < 0)
continue; // Not used in shader.
/** @type {number} */ var numRows = matrices[matNdx].numRows;
/** @type {number} */ var numCols = matrices[matNdx].numCols;
for (var colNdx = 0; colNdx < numCols; colNdx++) {
var data = [].concat.apply([], quadGrid.getUserAttribByIndex(colNdx));
vertexArrays.push(gluDrawUtil.newFloatColumnVertexArrayBinding(matrices[matNdx].name, colNdx, numRows, numElements, 4 * 4, data));
}
}
};
});