| /*------------------------------------------------------------------------- |
| * drawElements Quality Program OpenGL ES Utilities |
| * ------------------------------------------------ |
| * |
| * Copyright 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| |
| 'use strict'; |
| goog.provide('functional.gles3.es3fShaderBuiltinVarTests'); |
| goog.require('framework.delibs.debase.deMath'); |
| goog.require('framework.delibs.debase.deRandom'); |
| goog.require('framework.delibs.debase.deString'); |
| goog.require('framework.common.tcuImageCompare'); |
| goog.require('framework.common.tcuLogImage'); |
| goog.require('framework.common.tcuPixelFormat'); |
| goog.require('framework.common.tcuRGBA'); |
| goog.require('framework.common.tcuSurface'); |
| goog.require('framework.common.tcuTestCase'); |
| goog.require('framework.common.tcuTexture'); |
| goog.require('framework.opengl.gluDrawUtil'); |
| goog.require('framework.opengl.gluShaderProgram'); |
| goog.require('framework.opengl.gluShaderUtil'); |
| goog.require('framework.opengl.gluVarType'); |
| goog.require('framework.opengl.simplereference.sglrReferenceContext'); |
| goog.require('framework.opengl.simplereference.sglrShaderProgram'); |
| goog.require('framework.referencerenderer.rrFragmentOperations'); |
| goog.require('framework.referencerenderer.rrGenericVector'); |
| goog.require('framework.referencerenderer.rrMultisamplePixelBufferAccess'); |
| goog.require('framework.referencerenderer.rrRenderer'); |
| goog.require('framework.referencerenderer.rrRenderState'); |
| goog.require('framework.referencerenderer.rrShadingContext'); |
| goog.require('framework.referencerenderer.rrVertexAttrib'); |
| goog.require('framework.referencerenderer.rrVertexPacket'); |
| goog.require('modules.shared.glsShaderRenderCase'); |
| goog.require('modules.shared.glsShaderExecUtil'); |
| |
| goog.scope(function() { |
| var es3fShaderBuiltinVarTests = functional.gles3.es3fShaderBuiltinVarTests; |
| var deMath = framework.delibs.debase.deMath; |
| var deString = framework.delibs.debase.deString; |
| var deRandom = framework.delibs.debase.deRandom; |
| var glsShaderExecUtil = modules.shared.glsShaderExecUtil; |
| var glsShaderRenderCase = modules.shared.glsShaderRenderCase; |
| var gluShaderProgram = framework.opengl.gluShaderProgram; |
| var gluShaderUtil = framework.opengl.gluShaderUtil; |
| var gluDrawUtil = framework.opengl.gluDrawUtil; |
| var gluVarType = framework.opengl.gluVarType; |
| var tcuPixelFormat = framework.common.tcuPixelFormat; |
| var tcuSurface = framework.common.tcuSurface; |
| var tcuTexture = framework.common.tcuTexture; |
| var tcuLogImage = framework.common.tcuLogImage; |
| var tcuTestCase = framework.common.tcuTestCase; |
| var tcuImageCompare = framework.common.tcuImageCompare; |
| var tcuRGBA = framework.common.tcuRGBA; |
| var rrGenericVector = framework.referencerenderer.rrGenericVector; |
| var rrFragmentOperations = framework.referencerenderer.rrFragmentOperations; |
| var rrMultisamplePixelBufferAccess = framework.referencerenderer.rrMultisamplePixelBufferAccess; |
| var rrRenderer = framework.referencerenderer.rrRenderer; |
| var rrRenderState = framework.referencerenderer.rrRenderState; |
| var rrShadingContext = framework.referencerenderer.rrShadingContext; |
| var rrVertexAttrib = framework.referencerenderer.rrVertexAttrib; |
| var rrVertexPacket = framework.referencerenderer.rrVertexPacket; |
| var sglrShaderProgram = framework.opengl.simplereference.sglrShaderProgram; |
| var sglrReferenceContext = framework.opengl.simplereference.sglrReferenceContext; |
| |
| /** @typedef {function():number} */ es3fShaderBuiltinVarTests.GetConstantValueFunc; |
| |
| /** |
| * @param {number} pname |
| * @return {number} getParameter returns values of any kind |
| */ |
| es3fShaderBuiltinVarTests.getInteger = function(pname) { |
| return /** @type {number} */ (gl.getParameter(pname)); |
| }; |
| |
| /** |
| * @param {number} pname |
| * @return {number} forcing number |
| */ |
| es3fShaderBuiltinVarTests.getVectorsFromComps = function(pname) { |
| var value = /** @type {number} */ (gl.getParameter(pname)); |
| assertMsgOptions(value%4 === 0, 'Expected value to be divisible by 4.', false, true); |
| return value / 4; |
| }; |
| |
| /** |
| * @constructor |
| * @extends {tcuTestCase.DeqpTest} |
| * @param {string} name |
| * @param {string} desc |
| * @param {string} varName |
| * @param {es3fShaderBuiltinVarTests.GetConstantValueFunc} getValue |
| * @param {gluShaderProgram.shaderType} shaderType |
| */ |
| es3fShaderBuiltinVarTests.ShaderBuiltinConstantCase = function(name, desc, varName, getValue, shaderType) { |
| tcuTestCase.DeqpTest.call(this, name, desc); |
| /** @type {string} */ this.m_varName = varName; |
| /** @type {es3fShaderBuiltinVarTests.GetConstantValueFunc} */ this.m_getValue = getValue; |
| /** @type {gluShaderProgram.shaderType} */ this.m_shaderType = shaderType; |
| }; |
| |
| es3fShaderBuiltinVarTests.ShaderBuiltinConstantCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype); |
| es3fShaderBuiltinVarTests.ShaderBuiltinConstantCase.prototype.constructor = es3fShaderBuiltinVarTests.ShaderBuiltinConstantCase; |
| |
| es3fShaderBuiltinVarTests.ShaderBuiltinConstantCase.prototype.deinit = function() { |
| // an attempt to cleanup the GL state when the test fails |
| bufferedLogToConsole('ShaderBuildInConstantCase.deinit()'); |
| gl.useProgram(null); |
| gl.bindBuffer(gl.ARRAY_BUFFER, null); |
| gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null); |
| gl.bindFramebuffer(gl.FRAMEBUFFER, null); |
| gl.bindRenderbuffer(gl.RENDERBUFFER, null); |
| }; |
| |
| /** |
| * @param {gluShaderProgram.shaderType} shaderType |
| * @param {string} varName |
| * @return {glsShaderExecUtil.ShaderExecutor} |
| */ |
| es3fShaderBuiltinVarTests.ShaderBuiltinConstantCase.prototype.createGetConstantExecutor = function(shaderType, varName) { |
| /** @type {glsShaderExecUtil.ShaderSpec} */ var shaderSpec = new glsShaderExecUtil.ShaderSpec(); |
| shaderSpec.version = gluShaderUtil.GLSLVersion.V300_ES; |
| shaderSpec.source = 'result = ' + varName + ';\n'; |
| shaderSpec.outputs.push(new glsShaderExecUtil.Symbol('result', |
| gluVarType.newTypeBasic(gluShaderUtil.DataType.INT, gluShaderUtil.precision.PRECISION_HIGHP))); |
| return glsShaderExecUtil.createExecutor(shaderType, shaderSpec); |
| |
| }; |
| |
| /** |
| * @return {tcuTestCase.IterateResult} |
| */ |
| es3fShaderBuiltinVarTests.ShaderBuiltinConstantCase.prototype.iterate = function() { |
| /** @type {glsShaderExecUtil.ShaderExecutor} */ |
| var shaderExecutor = this.createGetConstantExecutor(this.m_shaderType, this.m_varName); |
| /** @type {number} */ var reference = this.m_getValue(); |
| /** @type {goog.NumberArray} */ var shaderExecutorResult; |
| /** @type {number} */ var result; |
| |
| if (!shaderExecutor.isOk()) |
| assertMsgOptions(false, 'Compile failed', false, true); |
| |
| shaderExecutor.useProgram(); |
| |
| shaderExecutorResult = shaderExecutor.execute(1, null); |
| result = new Int32Array(shaderExecutorResult[0].buffer)[0]; |
| |
| bufferedLogToConsole(this.m_varName + ' = ' + result); |
| |
| if (result != reference) { |
| bufferedLogToConsole('ERROR: Expected ' + this.m_varName + ' = ' + reference + '\n' + |
| 'Test shader:' + shaderExecutor.m_program.getProgramInfo().infoLog); |
| testFailedOptions('Invalid builtin constant value', false); |
| } else |
| testPassedOptions('Pass', true); |
| |
| return tcuTestCase.IterateResult.STOP; |
| }; |
| |
| /** |
| * @struct |
| * @constructor |
| * @param {number=} near |
| * @param {number=} far |
| */ |
| es3fShaderBuiltinVarTests.DepthRangeParams = function(near, far) { |
| /** @type {number} */ this.zNear = near === undefined ? 0.0 : near; |
| /** @type {number} */ this.zFar = far === undefined ? 1.0 : far; |
| }; |
| |
| /** |
| * @constructor |
| * @extends {glsShaderRenderCase.ShaderEvaluator} |
| * @param {es3fShaderBuiltinVarTests.DepthRangeParams} params |
| */ |
| es3fShaderBuiltinVarTests.DepthRangeEvaluator = function(params) { |
| /** @type {es3fShaderBuiltinVarTests.DepthRangeParams} */ this.m_params = params; |
| }; |
| |
| es3fShaderBuiltinVarTests.DepthRangeEvaluator.prototype = Object.create(glsShaderRenderCase.ShaderEvaluator.prototype); |
| es3fShaderBuiltinVarTests.DepthRangeEvaluator.prototype.constructor = es3fShaderBuiltinVarTests.DepthRangeEvaluator; |
| |
| /** |
| * @param {glsShaderRenderCase.ShaderEvalContext} c |
| */ |
| es3fShaderBuiltinVarTests.DepthRangeEvaluator.prototype.evaluate = function(c) { |
| /** @type {number} */ var zNear = deMath.clamp(this.m_params.zNear, 0.0, 1.0); |
| /** @type {number} */ var zFar = deMath.clamp(this.m_params.zFar, 0.0, 1.0); |
| /** @type {number} */ var diff = zFar - zNear; |
| c.color[0] = zNear; |
| c.color[1] = zFar; |
| c.color[2] = diff * 0.5 + 0.5; |
| }; |
| |
| /** |
| * @constructor |
| * @extends {glsShaderRenderCase.ShaderRenderCase} |
| * @param {string} name |
| * @param {string} desc |
| * @param {boolean} isVertexCase |
| */ |
| es3fShaderBuiltinVarTests.ShaderDepthRangeTest = function(name, desc, isVertexCase) { |
| glsShaderRenderCase.ShaderRenderCase.call(this, name, desc, isVertexCase); |
| /** @type {es3fShaderBuiltinVarTests.DepthRangeParams} */ this.m_depthRange = new es3fShaderBuiltinVarTests.DepthRangeParams(); |
| /** @type {es3fShaderBuiltinVarTests.DepthRangeEvaluator} */ this.m_evaluator = new es3fShaderBuiltinVarTests.DepthRangeEvaluator(this.m_depthRange); |
| /** @type {number} */ this.m_iterNdx = 0; |
| }; |
| |
| es3fShaderBuiltinVarTests.ShaderDepthRangeTest.prototype = Object.create(glsShaderRenderCase.ShaderRenderCase.prototype); |
| es3fShaderBuiltinVarTests.ShaderDepthRangeTest.prototype.constructor = es3fShaderBuiltinVarTests.ShaderDepthRangeTest; |
| |
| es3fShaderBuiltinVarTests.ShaderDepthRangeTest.prototype.init = function() { |
| /** @type {string} */ var defaultVertSrc = '' + |
| '#version 300 es\n' + |
| 'in highp vec4 a_position;\n' + |
| 'void main (void)\n' + |
| '{\n' + |
| ' gl_Position = a_position;\n' + |
| '}\n'; |
| /** @type {string} */ var defaultFragSrc = '' + |
| '#version 300 es\n' + |
| 'in mediump vec4 v_color;\n' + |
| 'layout(location = 0) out mediump vec4 o_color;\n\n' + |
| 'void main (void)\n' + |
| '{\n' + |
| ' o_color = v_color;\n' + |
| '}\n'; |
| |
| // Construct shader. |
| /** @type {string} */ var src = '#version 300 es\n'; |
| if (this.m_isVertexCase) |
| src += 'in highp vec4 a_position;\n' + |
| 'out mediump vec4 v_color;\n'; |
| else |
| src += 'layout(location = 0) out mediump vec4 o_color;\n'; |
| |
| src += 'void main (void)\n{\n' + |
| '\t' + (this.m_isVertexCase ? 'v_color' : 'o_color') + ' = vec4(gl_DepthRange.near, gl_DepthRange.far, gl_DepthRange.diff*0.5 + 0.5, 1.0);\n'; |
| |
| if (this.m_isVertexCase) |
| src += '\tgl_Position = a_position;\n'; |
| |
| src += '}\n'; |
| |
| this.m_vertShaderSource = this.m_isVertexCase ? src : defaultVertSrc; |
| this.m_fragShaderSource = this.m_isVertexCase ? defaultFragSrc : src; |
| |
| this.postinit(); |
| }; |
| |
| /** |
| * @return {tcuTestCase.IterateResult} |
| */ |
| es3fShaderBuiltinVarTests.ShaderDepthRangeTest.prototype.iterate = function() { |
| /** @type {Array<es3fShaderBuiltinVarTests.DepthRangeParams>} */ var cases = [ |
| new es3fShaderBuiltinVarTests.DepthRangeParams(0.0, 1.0) |
| ]; |
| |
| this.m_depthRange = cases[this.m_iterNdx]; |
| bufferedLogToConsole('gl.depthRange(' + this.m_depthRange.zNear + ', ' + this.m_depthRange.zFar + ')'); |
| gl.depthRange(this.m_depthRange.zNear, this.m_depthRange.zFar); |
| |
| this.postiterate(); |
| this.m_iterNdx += 1; |
| |
| if (this.m_iterNdx == cases.length) |
| return tcuTestCase.IterateResult.STOP; |
| else |
| return tcuTestCase.IterateResult.CONTINUE; |
| }; |
| |
| /** |
| * @constructor |
| * @extends {tcuTestCase.DeqpTest} |
| */ |
| es3fShaderBuiltinVarTests.FragCoordXYZCase = function() { |
| tcuTestCase.DeqpTest.call(this, 'fragcoord_xyz', 'gl_FragCoord.xyz Test'); |
| }; |
| |
| es3fShaderBuiltinVarTests.FragCoordXYZCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype); |
| es3fShaderBuiltinVarTests.FragCoordXYZCase.prototype.constructor = es3fShaderBuiltinVarTests.FragCoordXYZCase; |
| |
| es3fShaderBuiltinVarTests.FragCoordXYZCase.prototype.iterate = function() { |
| /** @type {number} */ var width = gl.drawingBufferWidth; |
| /** @type {number} */ var height = gl.drawingBufferHeight; |
| /** @type {Array<number>} */ var threshold = deMath.add([1, 1, 1, 1], tcuPixelFormat.PixelFormatFromContext(gl).getColorThreshold()); |
| /** @type {Array<number>} */ var scale = [1. / width, 1. / height, 1.0]; |
| |
| /** @type {tcuSurface.Surface} */ var testImg = new tcuSurface.Surface(width, height); |
| /** @type {tcuSurface.Surface} */ var refImg = new tcuSurface.Surface(width, height); |
| |
| /** @type {string} */ var vtxSource = '' + |
| '#version 300 es\n' + |
| 'in highp vec4 a_position;\n' + |
| 'void main (void)\n' + |
| '{\n' + |
| ' gl_Position = a_position;\n' + |
| '}\n'; |
| /** @type {string} */ var fragSource = '' + |
| '#version 300 es\n' + |
| 'uniform highp vec3 u_scale;\n' + |
| 'layout(location = 0) out mediump vec4 o_color;\n' + |
| 'void main (void)\n' + |
| '{\n' + |
| ' o_color = vec4(gl_FragCoord.xyz*u_scale, 1.0);\n' + |
| '}\n'; |
| /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vtxSource, fragSource)); |
| |
| bufferedLogToConsole(program.getProgramInfo().infoLog); |
| |
| if (!program.isOk()) |
| throw new Error('Compile failed'); |
| |
| // Draw with GL. |
| /** @type {Array<number>} */ var positions = [ |
| -1.0, 1.0, -1.0, 1.0, |
| -1.0, -1.0, 0.0, 1.0, |
| 1.0, 1.0, 0.0, 1.0, |
| 1.0, -1.0, 1.0, 1.0 |
| ]; |
| /** @type {Array<number>} */ var indices = [0, 1, 2, 2, 1, 3]; |
| |
| /** @type {WebGLUniformLocation} */ var scaleLoc = gl.getUniformLocation(program.getProgram(), 'u_scale'); |
| /** @type {gluDrawUtil.VertexArrayBinding} */ var posBinding = gluDrawUtil.newFloatVertexArrayBinding('a_position', 4, 4, 0, positions); |
| |
| gl.useProgram(program.getProgram()); |
| gl.uniform3fv(scaleLoc, scale); |
| |
| gl.viewport(0, 0, width, height); |
| gluDrawUtil.draw(gl, program.getProgram(), [posBinding], gluDrawUtil.triangles(indices)); |
| |
| testImg.readViewport(gl, [0, 0, width, height]); |
| |
| // Draw reference |
| for (var y = 0; y < refImg.getHeight(); y++) { |
| for (var x = 0; x < refImg.getWidth(); x++) { |
| /** @type {number} */ var xf = (x + .5) / refImg.getWidth(); |
| /** @type {number} */ var yf = (refImg.getHeight() - y - 1 + .5) / refImg.getHeight(); |
| /** @type {number} */ var z = (xf + yf) / 2.0; |
| /** @type {Array<number>} */ var fragCoord = [x + .5, y + .5, z]; |
| /** @type {Array<number>} */ var scaledFC = deMath.multiply(fragCoord, scale); |
| /** @type {Array<number>} */ |
| var color = [ |
| deMath.clamp(Math.floor(scaledFC[0] * 255 + 0.5), 0, 255), |
| deMath.clamp(Math.floor(scaledFC[1] * 255 + 0.5), 0, 255), |
| deMath.clamp(Math.floor(scaledFC[2] * 255 + 0.5), 0, 255), |
| 255]; |
| refImg.setPixel(x, y, color); |
| } |
| } |
| |
| // Compare |
| /** @type {boolean} */ var isOk = tcuImageCompare.pixelThresholdCompare('Result', 'Image comparison result', refImg, testImg, threshold); |
| |
| if (!isOk) |
| testFailedOptions('Image comparison failed', false); |
| else |
| testPassedOptions('Pass', true); |
| |
| return tcuTestCase.IterateResult.STOP; |
| }; |
| |
| /** |
| * @param {Array<number>} s |
| * @param {Array<number>} w |
| * @param {number} nx |
| * @param {number} ny |
| * @return {number} |
| */ |
| es3fShaderBuiltinVarTests.projectedTriInterpolate = function(s, w, nx, ny) { |
| return (s[0] * (1.0 - nx - ny)/w[0] + s[1] * ny / w[1] + s[2] * nx / w[2]) / ((1.0 - nx - ny) / w[0] + ny / w[1] + nx / w[2]); |
| }; |
| |
| /** |
| * @constructor |
| * @extends {tcuTestCase.DeqpTest} |
| */ |
| es3fShaderBuiltinVarTests.FragCoordWCase = function() { |
| tcuTestCase.DeqpTest.call(this, 'fragcoord_w', 'gl_FragCoord.w Test'); |
| }; |
| |
| es3fShaderBuiltinVarTests.FragCoordWCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype); |
| es3fShaderBuiltinVarTests.FragCoordWCase.prototype.constructor = es3fShaderBuiltinVarTests.FragCoordWCase; |
| |
| /** |
| * @return {tcuTestCase.IterateResult} |
| */ |
| es3fShaderBuiltinVarTests.FragCoordWCase.prototype.iterate = function() { |
| /** @type {number} */ var width = gl.drawingBufferWidth; |
| /** @type {number} */ var height = gl.drawingBufferHeight; |
| /** @type {Array<number>} */ var threshold = deMath.add([1, 1, 1, 1], tcuPixelFormat.PixelFormatFromContext(gl).getColorThreshold()); |
| |
| /** @type {tcuSurface.Surface} */ var testImg = new tcuSurface.Surface(width, height); |
| /** @type {tcuSurface.Surface} */ var refImg = new tcuSurface.Surface(width, height); |
| |
| /** @type {Array<number>} */ var w = [1.7, 2.0, 1.2, 1.0]; |
| |
| /** @type {string} */ var vtxSource = '#version 300 es\n' + |
| 'in highp vec4 a_position;\n' + |
| 'void main (void)\n' + |
| '{\n' + |
| ' gl_Position = a_position;\n' + |
| '}\n'; |
| |
| /** @type {string} */ var fragSource = '#version 300 es\n' + |
| 'layout(location = 0) out mediump vec4 o_color;\n' + |
| 'void main (void)\n' + |
| '{\n' + |
| ' o_color = vec4(0.0, 1.0/gl_FragCoord.w - 1.0, 0.0, 1.0);\n' + |
| '}\n'; |
| |
| /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vtxSource, fragSource)); |
| bufferedLogToConsole(program.getProgramInfo().infoLog); |
| |
| if (!program.isOk()) |
| throw new Error('Compile failed'); |
| |
| // Draw with GL. |
| /** @type {Array<number>} */ var positions = [ |
| -w[0], w[0], 0.0, w[0], |
| -w[1], -w[1], 0.0, w[1], |
| w[2], w[2], 0.0, w[2], |
| w[3], -w[3], 0.0, w[3] |
| ]; |
| /** @type {Array<number>} */ var indices = [0, 1, 2, 2, 1, 3]; |
| |
| /** @type {gluDrawUtil.VertexArrayBinding} */ var posBinding = gluDrawUtil.newFloatVertexArrayBinding('a_position', 4, 4, 0, positions); |
| gl.useProgram(program.getProgram()); |
| |
| gluDrawUtil.draw(gl, program.getProgram(), [posBinding], gluDrawUtil.triangles(indices)); |
| testImg.readViewport(gl, [0, 0, width, height]); |
| |
| // Draw reference |
| for (var y = 0; y < refImg.getHeight(); y++) { |
| for (var x = 0; x < refImg.getWidth(); x++) { |
| /** @type {number} */ var xf = (x + 0.5) / refImg.getWidth(); |
| /** @type {number} */ var yf = (refImg.getHeight() - y - 1 + 0.5) / refImg.getHeight(); |
| /** @type {number} */ var oow = ((xf + yf) < 1.0) ? |
| es3fShaderBuiltinVarTests.projectedTriInterpolate([w[0], w[1], w[2]], [w[0], w[1], w[2]], xf, yf) : |
| es3fShaderBuiltinVarTests.projectedTriInterpolate([w[3], w[2], w[1]], [w[3], w[2], w[1]], 1.0 - xf, 1.0 - yf); |
| /** @type {Array<number>} */ |
| var color = [ |
| 0, |
| deMath.clamp(Math.floor((oow - 1.0) * 255 + 0.5), 0, 255), |
| 0, |
| 255]; |
| refImg.setPixel(x, y, color); |
| } |
| } |
| |
| // Compare |
| /** @type {boolean} */ var isOk = tcuImageCompare.pixelThresholdCompare('Result', 'Image comparison result', refImg, testImg, threshold); |
| |
| if (!isOk) { |
| testFailedOptions('Image comparison failed', false); |
| } else |
| testPassedOptions('Pass', true); |
| |
| return tcuTestCase.IterateResult.STOP; |
| }; |
| |
| /** |
| * @constructor |
| * @extends {tcuTestCase.DeqpTest} |
| */ |
| es3fShaderBuiltinVarTests.PointCoordCase = function() { |
| tcuTestCase.DeqpTest.call(this, 'pointcoord', 'gl_PointCoord Test'); |
| }; |
| |
| es3fShaderBuiltinVarTests.PointCoordCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype); |
| es3fShaderBuiltinVarTests.PointCoordCase.prototype.constructor = es3fShaderBuiltinVarTests.PointCoordCase; |
| |
| /** |
| * @return {tcuTestCase.IterateResult} |
| */ |
| es3fShaderBuiltinVarTests.PointCoordCase.prototype.iterate = function() { |
| /** @type {number} */ var width = Math.min(256, gl.drawingBufferWidth); |
| /** @type {number} */ var height = Math.min(256, gl.drawingBufferHeight); |
| /** @type {number} */ var threshold = 0.02; |
| |
| /** @type {number} */ var numPoints = 8; |
| |
| /** @type {Array<number>} */ var coords = []; |
| /** @type {Array<number>} */ var pointSizeRange = [0.0, 0.0]; |
| /** @type {deRandom.Random} */ var rnd = new deRandom.Random(0x145fa); |
| /** @type {tcuSurface.Surface} */ var testImg = new tcuSurface.Surface(width, height); |
| /** @type {tcuSurface.Surface} */ var refImg = new tcuSurface.Surface(width, height); |
| |
| pointSizeRange = /** @type {Array<number>} */ (gl.getParameter(gl.ALIASED_POINT_SIZE_RANGE)); |
| |
| if (pointSizeRange[0] <= 0.0 || pointSizeRange[1] <= 0.0 || pointSizeRange[1] < pointSizeRange[0]) |
| throw new Error('Invalid gl.ALIASED_POINT_SIZE_RANGE'); |
| |
| // Compute coordinates. |
| for (var i = 0; i < numPoints; i++) |
| coords.push([ |
| rnd.getFloat(-0.9, 0.9), |
| rnd.getFloat(-0.9, 0.9), |
| rnd.getFloat(pointSizeRange[0], pointSizeRange[1]) |
| ]); |
| |
| /** @type {string} */ var vtxSource = '#version 300 es\n' + |
| 'in highp vec3 a_positionSize;\n' + |
| 'void main (void)\n' + |
| '{\n' + |
| ' gl_Position = vec4(a_positionSize.xy, 0.0, 1.0);\n' + |
| ' gl_PointSize = a_positionSize.z;\n' + |
| '}\n'; |
| |
| /** @type {string} */ var fragSource = '#version 300 es\n' + |
| 'layout(location = 0) out mediump vec4 o_color;\n' + |
| 'void main (void)\n' + |
| '{\n' + |
| ' o_color = vec4(gl_PointCoord, 0.0, 1.0);\n' + |
| '}\n'; |
| |
| /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vtxSource, fragSource)); |
| bufferedLogToConsole(program.getProgramInfo().infoLog); |
| |
| if (!program.isOk()) |
| throw new Error('Compile failed'); |
| |
| // Draw with GL. |
| var newCoords = [].concat.apply([], coords); |
| |
| // /** @type {gluDrawUtil.VertexArrayBinding} */ var posBinding = gluDrawUtil.newFloatVertexArrayBinding('a_positionSize', 3, coords.length, 0, coords); |
| /** @type {gluDrawUtil.VertexArrayBinding} */ |
| var posBinding = gluDrawUtil.newFloatVertexArrayBinding('a_positionSize', 3, coords.length, 12, newCoords); |
| /** @type {number} */ var viewportX = rnd.getInt(0, gl.drawingBufferWidth - width); |
| /** @type {number} */ var viewportY = rnd.getInt(0, gl.drawingBufferHeight - height); |
| |
| gl.viewport(viewportX, viewportY, width, height); |
| gl.clearColor(0.0, 0.0, 0.0, 1.0); |
| gl.clear(gl.COLOR_BUFFER_BIT); |
| |
| gl.useProgram(program.getProgram()); |
| |
| gluDrawUtil.draw(gl, program.getProgram(), [posBinding], gluDrawUtil.pointsFromElements(coords.length)); |
| testImg.readViewport(gl, [viewportX, viewportY, width, height]); |
| |
| // Draw reference |
| refImg.getAccess().clear([0.0, 0.0, 0.0, 1.0]); |
| for (var i = 0; i < coords.length; i++) { |
| /** @type {number} */ var x0 = Math.round(width * (coords[i][0] * 0.5 + 0.5) - coords[i][2] * 0.5); |
| /** @type {number} */ var y0 = Math.round(height* (coords[i][1] * 0.5 + 0.5) - coords[i][2] * 0.5); |
| /** @type {number} */ var x1 = Math.round(width * (coords[i][0] * 0.5 + 0.5) + coords[i][2] * 0.5); |
| /** @type {number} */ var y1 = Math.round(height * (coords[i][1] * 0.5 + 0.5) + coords[i][2] * 0.5); |
| /** @type {number} */ var w = x1 - x0; |
| /** @type {number} */ var h = y1 - y0; |
| |
| for (var yo = 0; yo < h; yo++) { |
| for (var xo = 0; xo < w; xo++) { |
| /** @type {number} */ var xf = (xo + 0.5) / w; |
| /** @type {number} */ var yf = ((h - yo - 1) + 0.5) / h; |
| /** @type {number} */ var dx = x0 + xo; |
| /** @type {number} */ var dy = y0 + yo; |
| /** @type {Array<number>} */ |
| var color = [ |
| deMath.clamp(Math.floor(xf * 255 + 0.5), 0, 255), |
| deMath.clamp(Math.floor(yf * 255 + 0.5), 0, 255), |
| 0, |
| 255]; |
| if (deMath.deInBounds32(dx, 0, refImg.getWidth()) && deMath.deInBounds32(dy, 0, refImg.getHeight())) |
| refImg.setPixel(dx, dy, color); |
| } |
| } |
| } |
| |
| // Compare |
| /** @type {boolean} */ var isOk = tcuImageCompare.fuzzyCompare('Result', 'Image comparison result', refImg.getAccess(), testImg.getAccess(), threshold); |
| |
| if (!isOk) { |
| testFailedOptions('Image comparison failed', false); |
| } else |
| testPassedOptions('Pass', true); |
| |
| return tcuTestCase.IterateResult.STOP; |
| }; |
| |
| /** |
| * @constructor |
| * @extends {tcuTestCase.DeqpTest} |
| */ |
| es3fShaderBuiltinVarTests.FrontFacingCase = function() { |
| tcuTestCase.DeqpTest.call(this, 'frontfacing', 'gl_FrontFacing Test'); |
| }; |
| |
| es3fShaderBuiltinVarTests.FrontFacingCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype); |
| es3fShaderBuiltinVarTests.FrontFacingCase.prototype.constructor = es3fShaderBuiltinVarTests.FrontFacingCase; |
| |
| /** |
| * @return {tcuTestCase.IterateResult} |
| */ |
| es3fShaderBuiltinVarTests.FrontFacingCase.prototype.iterate = function() { |
| // Test case renders two adjecent quads, where left is has front-facing |
| // triagles and right back-facing. Color is selected based on gl_FrontFacing |
| // value. |
| /** @type {deRandom.Random} */ var rnd = new deRandom.Random(0x89f2c); |
| /** @type {number} */ var width = Math.min(64, gl.drawingBufferWidth); |
| /** @type {number} */ var height = Math.min(64, gl.drawingBufferHeight); |
| /** @type {number} */ var viewportX = rnd.getInt(0, gl.drawingBufferWidth - width); |
| /** @type {number} */ var viewportY = rnd.getInt(0, gl.drawingBufferHeight - height); |
| /** @type {Array<number>} */ var threshold = deMath.add([1, 1, 1, 1], tcuPixelFormat.PixelFormatFromContext(gl).getColorThreshold()); |
| |
| /** @type {tcuSurface.Surface} */ var testImg = new tcuSurface.Surface(width, height); |
| /** @type {tcuSurface.Surface} */ var refImg = new tcuSurface.Surface(width, height); |
| |
| /** @type {string} */ var vtxSource = '#version 300 es\n' + |
| 'in highp vec4 a_position;\n' + |
| 'void main (void)\n' + |
| '{\n' + |
| ' gl_Position = a_position;\n' + |
| '}\n'; |
| |
| /** @type {string} */ var fragSource = '#version 300 es\n' + |
| 'layout(location = 0) out mediump vec4 o_color;\n' + |
| 'void main (void)\n' + |
| '{\n' + |
| ' if (gl_FrontFacing)\n' + |
| ' o_color = vec4(0.0, 1.0, 0.0, 1.0);\n' + |
| ' else\n' + |
| ' o_color = vec4(0.0, 0.0, 1.0, 1.0);\n' + |
| '}\n'; |
| |
| /** @type {gluShaderProgram.ShaderProgram} */ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vtxSource, fragSource)); |
| |
| bufferedLogToConsole(program.getProgramInfo().infoLog); |
| |
| if (!program.isOk()) |
| throw new Error('Compile failed'); |
| |
| // Draw with GL. |
| /** @type {Array<number>} */ var positions = [ |
| -1.0, 1.0, 0.0, 1.0, |
| -1.0, -1.0, 0.0, 1.0, |
| 1.0, 1.0, 0.0, 1.0, |
| 1.0, -1.0, 0.0, 1.0 |
| ]; |
| |
| /** @type {Array<number>} */ var indicesCCW = [0, 1, 2, 2, 1, 3]; |
| /** @type {Array<number>} */ var indicesCW = [2, 1, 0, 3, 1, 2]; |
| |
| /** @type {gluDrawUtil.VertexArrayBinding} */ var posBinding = gluDrawUtil.newFloatVertexArrayBinding('a_position', 4, 4, 0, positions); |
| |
| gl.useProgram(program.getProgram()); |
| |
| gl.viewport(viewportX, viewportY, Math.floor(width / 2), height); |
| |
| gluDrawUtil.draw(gl, program.getProgram(), [posBinding], gluDrawUtil.triangles(indicesCCW)); |
| |
| gl.viewport(viewportX + Math.floor(width / 2), viewportY, width - Math.floor(width / 2), height); |
| gluDrawUtil.draw(gl, program.getProgram(), [posBinding], gluDrawUtil.triangles(indicesCW)); |
| testImg.readViewport(gl, [viewportX, viewportY, width, height]); |
| // Draw reference |
| for (var y = 0; y < refImg.getHeight(); y++) { |
| for (var x = 0; x < Math.floor(refImg.getWidth() / 2); x++) |
| refImg.setPixel(x, y, tcuRGBA.RGBA.green.toIVec()); |
| |
| for (var x = Math.floor(refImg.getWidth() / 2); x < refImg.getWidth(); x++) |
| refImg.setPixel(x, y, tcuRGBA.RGBA.blue.toIVec()); |
| } |
| |
| // Compare |
| /** @type {boolean} */ var isOk = tcuImageCompare.pixelThresholdCompare('Result', 'Image comparison result', refImg, testImg, threshold); |
| |
| if (!isOk) { |
| testFailedOptions('Image comparison failed', false); |
| } else |
| testPassedOptions('Pass', true); |
| |
| return tcuTestCase.IterateResult.STOP; |
| }; |
| |
| /** |
| * @constructor |
| * @extends {tcuTestCase.DeqpTest} |
| */ |
| es3fShaderBuiltinVarTests.VertexIDCase = function() { |
| tcuTestCase.DeqpTest.call(this, 'vertex_id', 'gl_VertexID Test'); |
| /** @type {?gluShaderProgram.ShaderProgram} */ this.m_program = null; |
| /** @type {WebGLBuffer} */ this.m_positionBuffer = null; |
| /** @type {WebGLBuffer} */ this.m_elementBuffer = null; |
| /** @type {number} */ this.m_viewportW = 0; |
| /** @type {number} */ this.m_viewportH = 0; |
| /** @type {number} */ this.m_iterNdx = 0; |
| /** @type {Array<Array<number>>} */ this.m_positions = []; |
| /** @type {Array<Array<number>>} */ this.m_colors = []; |
| }; |
| |
| es3fShaderBuiltinVarTests.VertexIDCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype); |
| es3fShaderBuiltinVarTests.VertexIDCase.prototype.constructor = es3fShaderBuiltinVarTests.VertexIDCase; |
| |
| es3fShaderBuiltinVarTests.VertexIDCase.MAX_VERTICES = 24; //!< 8 triangles, totals 24 vertices |
| |
| es3fShaderBuiltinVarTests.VertexIDCase.prototype.init = function() { |
| /** @type {number} */ var width = gl.drawingBufferWidth; |
| /** @type {number} */ var height = gl.drawingBufferHeight; |
| |
| /** @type {number} */ var quadWidth = 32; |
| /** @type {number} */ var quadHeight = 32; |
| |
| if (width < quadWidth) |
| throw new Error('Too small render target'); |
| |
| /** @type {number} */ var maxQuadsX = Math.floor(width / quadWidth); |
| /** @type {number} */ var numVertices = es3fShaderBuiltinVarTests.VertexIDCase.MAX_VERTICES; |
| |
| /** @type {number} */ var numQuads = Math.floor(numVertices / 6) + (numVertices % 6 != 0 ? 1 : 0); |
| /** @type {number} */ var viewportW = Math.min(numQuads, maxQuadsX)*quadWidth; |
| /** @type {number} */ var viewportH = (Math.floor(numQuads/maxQuadsX) + (numQuads % maxQuadsX != 0 ? 1 : 0)) * quadHeight; |
| |
| if (viewportH > height) |
| throw new Error('Too small render target'); |
| |
| assertMsgOptions(viewportW <= width && viewportH <= height, 'Unexpected viewport dimensions.', false, true); |
| |
| assertMsgOptions(!this.m_program, 'Program should not be defined at this point.', false, true); |
| |
| /** @type {string} */ var vtxSource = '#version 300 es\n' + |
| 'in highp vec4 a_position;\n' + |
| 'out mediump vec4 v_color;\n' + |
| 'uniform highp vec4 u_colors[24];\n' + |
| 'void main (void)\n' + |
| '{\n' + |
| ' gl_Position = a_position;\n' + |
| ' v_color = u_colors[gl_VertexID];\n' + |
| '}\n'; |
| |
| /** @type {string} */ var fragSource = '#version 300 es\n' + |
| 'in mediump vec4 v_color;\n' + |
| 'layout(location = 0) out mediump vec4 o_color;\n' + |
| 'void main (void)\n' + |
| '{\n' + |
| ' o_color = v_color;\n' + |
| '}\n'; |
| |
| this.m_program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vtxSource, fragSource)); |
| bufferedLogToConsole(this.m_program.getProgramInfo().infoLog); |
| |
| if (!this.m_program.isOk()) { |
| this.m_program = null; |
| throw new Error('Compile failed'); |
| } |
| |
| this.m_positionBuffer = gl.createBuffer(); |
| this.m_elementBuffer = gl.createBuffer(); |
| |
| // Set colors (in dynamic memory to save static data space). |
| this.m_colors[0] = [0.0, 0.0, 0.0, 1.0]; |
| this.m_colors[1] = [0.5, 1.0, 0.5, 1.0]; |
| this.m_colors[2] = [0.0, 0.5, 1.0, 1.0]; |
| this.m_colors[3] = [0.0, 1.0, 0.0, 1.0]; |
| this.m_colors[4] = [0.0, 1.0, 1.0, 1.0]; |
| this.m_colors[5] = [0.5, 0.0, 0.0, 1.0]; |
| this.m_colors[6] = [0.5, 0.0, 1.0, 1.0]; |
| this.m_colors[7] = [0.5, 0.0, 0.5, 1.0]; |
| this.m_colors[8] = [1.0, 0.0, 0.0, 1.0]; |
| this.m_colors[9] = [0.5, 1.0, 0.0, 1.0]; |
| this.m_colors[10] = [0.0, 0.5, 0.0, 1.0]; |
| this.m_colors[11] = [0.5, 1.0, 1.0, 1.0]; |
| this.m_colors[12] = [0.0, 0.0, 1.0, 1.0]; |
| this.m_colors[13] = [1.0, 0.0, 0.5, 1.0]; |
| this.m_colors[14] = [0.0, 0.5, 0.5, 1.0]; |
| this.m_colors[15] = [1.0, 1.0, 0.5, 1.0]; |
| this.m_colors[16] = [1.0, 0.0, 1.0, 1.0]; |
| this.m_colors[17] = [1.0, 0.5, 0.0, 1.0]; |
| this.m_colors[18] = [0.0, 1.0, 0.5, 1.0]; |
| this.m_colors[19] = [1.0, 0.5, 1.0, 1.0]; |
| this.m_colors[20] = [1.0, 1.0, 0.0, 1.0]; |
| this.m_colors[21] = [1.0, 0.5, 0.5, 1.0]; |
| this.m_colors[22] = [0.0, 0.0, 0.5, 1.0]; |
| this.m_colors[23] = [1.0, 1.0, 1.0, 1.0]; |
| |
| // Compute positions. |
| assertMsgOptions(numVertices % 3 == 0, 'Number of vertices should be multiple of 3.', false, true); |
| |
| for (var vtxNdx = 0; vtxNdx < numVertices; vtxNdx += 3) { |
| /** @type {number} */ var h = 2.0 * quadHeight / viewportH; |
| /** @type {number} */ var w = 2.0 * quadWidth / viewportW; |
| |
| /** @type {number} */ var triNdx = Math.floor(vtxNdx / 3); |
| /** @type {number} */ var quadNdx = Math.floor(triNdx / 2); |
| /** @type {number} */ var quadY = Math.floor(quadNdx / maxQuadsX); |
| /** @type {number} */ var quadX = quadNdx % maxQuadsX; |
| |
| /** @type {number} */ var x0 = -1.0 + quadX * w; |
| /** @type {number} */ var y0 = -1.0 + quadY * h; |
| |
| if (triNdx % 2 === 0) { |
| this.m_positions[vtxNdx + 0] = [x0, y0, 0.0, 1.0]; |
| this.m_positions[vtxNdx + 1] = [x0+w, y0+h, 0.0, 1.0]; |
| this.m_positions[vtxNdx + 2] = [x0, y0+h, 0.0, 1.0]; |
| } else { |
| this.m_positions[vtxNdx + 0] = [x0 + w, y0 + h, 0.0, 1.0]; |
| this.m_positions[vtxNdx + 1] = [x0, y0, 0.0, 1.0]; |
| this.m_positions[vtxNdx + 2] = [x0+w, y0, 0.0, 1.0]; |
| } |
| } |
| |
| this.m_viewportW = viewportW; |
| this.m_viewportH = viewportH; |
| this.m_iterNdx = 0; |
| |
| }; |
| |
| es3fShaderBuiltinVarTests.VertexIDCase.prototype.deinit = function() { |
| this.m_program = null; |
| |
| if (this.m_positionBuffer) { |
| gl.deleteBuffer(this.m_positionBuffer); |
| this.m_positionBuffer = null; |
| } |
| |
| if (this.m_elementBuffer) { |
| gl.deleteBuffer(this.m_elementBuffer); |
| this.m_elementBuffer = null; |
| } |
| |
| this.m_positions = []; |
| this.m_colors = []; |
| }; |
| |
| /** |
| * @constructor |
| * @extends {sglrShaderProgram.ShaderProgram} |
| */ |
| es3fShaderBuiltinVarTests.VertexIDReferenceShader = function() { |
| /** @type {sglrShaderProgram.ShaderProgramDeclaration} */ var declaration = new sglrShaderProgram.ShaderProgramDeclaration(); |
| declaration.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('', rrGenericVector.GenericVecType.FLOAT)); |
| declaration.pushVertexAttribute(new sglrShaderProgram.VertexAttribute('', rrGenericVector.GenericVecType.FLOAT)); |
| declaration.pushVertexToFragmentVarying(new sglrShaderProgram.VertexToFragmentVarying(rrGenericVector.GenericVecType.FLOAT, new sglrShaderProgram.VaryingFlags())); |
| declaration.pushFragmentOutput(new sglrShaderProgram.FragmentOutput(rrGenericVector.GenericVecType.FLOAT)); |
| declaration.pushVertexSource(new sglrShaderProgram.VertexSource('')); // ShaderProgram fails if we don't push a source, even though GLSL source is not used |
| declaration.pushFragmentSource(new sglrShaderProgram.FragmentSource('')); |
| sglrShaderProgram.ShaderProgram.call(this, declaration); |
| }; |
| |
| es3fShaderBuiltinVarTests.VertexIDReferenceShader.prototype = Object.create(sglrShaderProgram.ShaderProgram.prototype); |
| es3fShaderBuiltinVarTests.VertexIDReferenceShader.prototype.constructor = es3fShaderBuiltinVarTests.VertexIDReferenceShader; |
| |
| /** @const {number} */ es3fShaderBuiltinVarTests.VertexIDReferenceShader.VARYINGLOC_COLOR = 0; |
| |
| /** |
| * @param {Array<rrVertexAttrib.VertexAttrib>} inputs |
| * @param {Array<rrVertexPacket.VertexPacket>} packets |
| */ |
| es3fShaderBuiltinVarTests.VertexIDReferenceShader.prototype.shadeVertices = function(inputs, packets) { |
| for (var packetNdx = 0; packetNdx < packets.length; ++packetNdx) { |
| /** @type {number} */ var positionAttrLoc = 0; |
| /** @type {number} */ var colorAttrLoc = 1; |
| |
| /** @type {rrVertexPacket.VertexPacket} */ var packet = packets[packetNdx]; |
| |
| // Transform to position |
| packet.position = rrVertexAttrib.readVertexAttrib(inputs[positionAttrLoc], packet.instanceNdx, packet.vertexNdx, rrGenericVector.GenericVecType.FLOAT); |
| |
| // Pass color to FS |
| packet.outputs[es3fShaderBuiltinVarTests.VertexIDReferenceShader.VARYINGLOC_COLOR] = rrVertexAttrib.readVertexAttrib(inputs[colorAttrLoc], packet.instanceNdx, packet.vertexNdx, rrGenericVector.GenericVecType.FLOAT); |
| } |
| }; |
| |
| /** |
| * @param {Array<rrFragmentOperations.Fragment>} packets |
| * @param {rrShadingContext.FragmentShadingContext} context |
| */ |
| es3fShaderBuiltinVarTests.VertexIDReferenceShader.prototype.shadeFragments = function(packets, context) { |
| for (var packetNdx = 0; packetNdx < packets.length; ++packetNdx) { |
| /** @type {rrFragmentOperations.Fragment} */ var packet = packets[packetNdx]; |
| packet.value = rrShadingContext.readVarying(packet, context, es3fShaderBuiltinVarTests.VertexIDReferenceShader.VARYINGLOC_COLOR); |
| } |
| }; |
| |
| /** |
| * @param {tcuTexture.PixelBufferAccess} dst |
| * @param {Array<number>} indices |
| * @param {goog.NumberArray} positions |
| * @param {goog.NumberArray} colors |
| */ |
| es3fShaderBuiltinVarTests.VertexIDCase.prototype.renderReference = function(dst, indices, positions, colors) { |
| /** @type {rrRenderState.RenderState} */ |
| var referenceState = new rrRenderState.RenderState( |
| new rrRenderState.ViewportState(rrMultisamplePixelBufferAccess.MultisamplePixelBufferAccess.fromSinglesampleAccess(dst)) |
| ); |
| |
| /** @type {rrRenderer.RenderTarget} */ |
| var referenceTarget = new rrRenderer.RenderTarget( |
| rrMultisamplePixelBufferAccess.MultisamplePixelBufferAccess.fromSinglesampleAccess(dst) |
| ); |
| |
| /** @type {es3fShaderBuiltinVarTests.VertexIDReferenceShader} */ |
| var referenceShaderProgram = new es3fShaderBuiltinVarTests.VertexIDReferenceShader(); |
| |
| /** @type {Array<rrVertexAttrib.VertexAttrib>} */ var attribs = []; |
| attribs[0] = new rrVertexAttrib.VertexAttrib(); |
| attribs[0].type = rrVertexAttrib.VertexAttribType.FLOAT; |
| attribs[0].size = 4; |
| attribs[0].stride = 0; |
| attribs[0].instanceDivisor = 0; |
| attribs[0].pointer = positions.buffer; |
| |
| attribs[1] = new rrVertexAttrib.VertexAttrib(); |
| attribs[1].type = rrVertexAttrib.VertexAttribType.FLOAT; |
| attribs[1].size = 4; |
| attribs[1].stride = 0; |
| attribs[1].instanceDivisor = 0; |
| attribs[1].pointer = colors.buffer; |
| rrRenderer.drawTriangles(referenceState, referenceTarget, referenceShaderProgram, |
| attribs, rrRenderer.PrimitiveType.TRIANGLES, 0, indices.length, /*instanceID = */ 0); |
| }; |
| |
| /** |
| * @return {tcuTestCase.IterateResult} |
| */ |
| es3fShaderBuiltinVarTests.VertexIDCase.prototype.iterate = function() { |
| /** @type {number} */ var width = gl.drawingBufferWidth; |
| /** @type {number} */ var height = gl.drawingBufferHeight; |
| /** @type {number} */ var viewportW = this.m_viewportW; |
| /** @type {number} */ var viewportH = this.m_viewportH; |
| |
| /** @type {number} */ var threshold = 0.02; |
| |
| /** @type {deRandom.Random} */ var rnd = new deRandom.Random(0xcf23ab1 ^ deString.deStringHash(this.m_iterNdx.toString())); |
| /** @type {tcuSurface.Surface} */ var refImg = new tcuSurface.Surface(viewportW, viewportH); |
| /** @type {tcuSurface.Surface} */ var testImg = new tcuSurface.Surface(viewportW, viewportH); |
| |
| /** @type {number} */ var viewportX = rnd.getInt(0, width - viewportW); |
| /** @type {number} */ var viewportY = rnd.getInt(0, height - viewportH); |
| |
| /** @type {number} */ var posLoc = gl.getAttribLocation(this.m_program.getProgram(), 'a_position'); |
| /** @type {WebGLUniformLocation} */ var colorsLoc = gl.getUniformLocation(this.m_program.getProgram(), 'u_colors[0]'); |
| /** @type {Array<number>} */ var clearColor = [0.0, 0.0, 0.0, 1.0]; |
| /** @type {Array<number>} */ var indices = []; |
| /** @type {Array<Array<number>>} */ var mappedPos = []; |
| /** @type {goog.NumberArray} */ var flatColorArray; |
| /** @type {goog.NumberArray} */ var flatPosArray; |
| // Setup common state. |
| gl.viewport(viewportX, viewportY, viewportW, viewportH); |
| gl.useProgram(this.m_program.getProgram()); |
| gl.bindBuffer(gl.ARRAY_BUFFER, this.m_positionBuffer); |
| gl.enableVertexAttribArray(posLoc); |
| gl.vertexAttribPointer(posLoc, 4, gl.FLOAT, false, 0, 0); |
| gl.uniform4fv(colorsLoc, [].concat.apply([], this.m_colors)); |
| |
| // Clear render target to black. |
| gl.clearColor(clearColor[0], clearColor[1], clearColor[2], clearColor[3]); |
| gl.clear(gl.COLOR_BUFFER_BIT); |
| |
| refImg.getAccess().clear(clearColor); |
| |
| if (this.m_iterNdx === 0) { |
| bufferedLogToConsole('Iter0: glDrawArrays()'); |
| |
| flatPosArray = new Float32Array([].concat.apply([], this.m_positions)); |
| flatColorArray = new Float32Array([].concat.apply([], this.m_colors)); |
| gl.bufferData(gl.ARRAY_BUFFER, flatPosArray.buffer, gl.DYNAMIC_DRAW); |
| gl.drawArrays(gl.TRIANGLES, 0, Math.floor(flatPosArray.length / 4)); |
| |
| //glu::readPixels(m_context.getRenderContext(), viewportX, viewportY, testImg.getAccess()); |
| testImg.readViewport(gl, [viewportX, viewportY, viewportW, viewportH]); |
| // Reference indices |
| for (var ndx = 0; ndx < this.m_positions.length; ndx++) |
| indices.push(ndx); |
| |
| this.renderReference(refImg.getAccess(), indices, flatPosArray, flatColorArray); |
| } else if (this.m_iterNdx === 1) { |
| bufferedLogToConsole('Iter1: glDrawElements(), indices in buffer'); |
| |
| // Compute initial indices and suffle |
| for (var ndx = 0; ndx < this.m_positions.length; ndx++) |
| indices.push(ndx); |
| // deRandom.shuffle(rnd, indices); |
| // \note [2015-08-05 dag] The original test shuffles the indices array but the reference renderer cannot handle triangles with sides not parallel to the axes. |
| |
| // Use indices to re-map positions. |
| for (var ndx = 0; ndx < indices.length; ndx++) |
| mappedPos[indices[ndx]] = this.m_positions[ndx]; |
| |
| gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.m_elementBuffer); |
| gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, (new Uint16Array(indices)).buffer, gl.DYNAMIC_DRAW); |
| |
| flatPosArray = new Float32Array([].concat.apply([], mappedPos)); |
| flatColorArray = new Float32Array([].concat.apply([], this.m_colors)); |
| gl.bufferData(gl.ARRAY_BUFFER, flatPosArray.buffer, gl.DYNAMIC_DRAW); |
| gl.drawElements(gl.TRIANGLES, indices.length, gl.UNSIGNED_SHORT, 0); |
| |
| //glu::readPixels(m_context.getRenderContext(), viewportX, viewportY, testImg.getAccess()); |
| testImg.readViewport(gl, [viewportX, viewportY, viewportW, viewportH]); |
| refImg.getAccess().clear(clearColor); |
| this.renderReference(refImg.getAccess(), indices, flatPosArray, flatColorArray); |
| } else |
| throw new Error('Iteration count exceeded.'); |
| |
| if (!tcuImageCompare.fuzzyCompare('Result', 'Image comparison result', refImg.getAccess(), testImg.getAccess(), threshold)) |
| testFailedOptions('Image comparison failed', false); |
| else |
| testPassedOptions('Pass', true); |
| |
| this.m_iterNdx += 1; |
| return (this.m_iterNdx < 2) ? tcuTestCase.IterateResult.CONTINUE : tcuTestCase.IterateResult.STOP; |
| }; |
| |
| /** |
| * @constructor |
| * @extends {tcuTestCase.DeqpTest} |
| */ |
| es3fShaderBuiltinVarTests.ShaderBuiltinVarTests = function() { |
| tcuTestCase.DeqpTest.call(this, 'builtin_variable', 'Built-in Variable Tests'); |
| }; |
| |
| es3fShaderBuiltinVarTests.ShaderBuiltinVarTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype); |
| es3fShaderBuiltinVarTests.ShaderBuiltinVarTests.prototype.constructor = es3fShaderBuiltinVarTests.ShaderBuiltinVarTests; |
| |
| es3fShaderBuiltinVarTests.ShaderBuiltinVarTests.prototype.init = function() { |
| var testGroup = tcuTestCase.runner.testCases; |
| // Builtin constants. |
| /** |
| * @struct |
| * @constructor |
| * @param {string} caseName |
| * @param {string} varName |
| * @param {es3fShaderBuiltinVarTests.GetConstantValueFunc} getValue |
| */ |
| var BuiltinConstant = function(caseName, varName, getValue) { |
| /** @type {string} */ this.caseName = caseName; |
| /** @type {string} */ this.varName = varName; |
| /** @type {es3fShaderBuiltinVarTests.GetConstantValueFunc} */ this.getValue = getValue; |
| |
| }; |
| |
| /** @type {Array<BuiltinConstant>} */ var builtinConstants = [ |
| // GLES 2. |
| |
| new BuiltinConstant('max_vertex_attribs', 'gl_MaxVertexAttribs', function() { return es3fShaderBuiltinVarTests.getInteger(gl.MAX_VERTEX_ATTRIBS); }), |
| new BuiltinConstant('max_vertex_uniform_vectors', 'gl_MaxVertexUniformVectors', function() { return es3fShaderBuiltinVarTests.getInteger(gl.MAX_VERTEX_UNIFORM_VECTORS); }), |
| new BuiltinConstant('max_fragment_uniform_vectors', 'gl_MaxFragmentUniformVectors', function() { return es3fShaderBuiltinVarTests.getInteger(gl.MAX_FRAGMENT_UNIFORM_VECTORS); }), |
| new BuiltinConstant('max_texture_image_units', 'gl_MaxTextureImageUnits', function() { return es3fShaderBuiltinVarTests.getInteger(gl.MAX_TEXTURE_IMAGE_UNITS); }), |
| new BuiltinConstant('max_vertex_texture_image_units', 'gl_MaxVertexTextureImageUnits', function() { return es3fShaderBuiltinVarTests.getInteger(gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS); }), |
| new BuiltinConstant('max_combined_texture_image_units', 'gl_MaxCombinedTextureImageUnits', function() { return es3fShaderBuiltinVarTests.getInteger(gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS); }), |
| new BuiltinConstant('max_draw_buffers', 'gl_MaxDrawBuffers', function() { return es3fShaderBuiltinVarTests.getInteger(gl.MAX_DRAW_BUFFERS); }), |
| |
| // GLES 3. |
| |
| new BuiltinConstant('max_vertex_output_vectors', 'gl_MaxVertexOutputVectors', function() { return es3fShaderBuiltinVarTests.getVectorsFromComps(gl.MAX_VERTEX_OUTPUT_COMPONENTS); }), |
| new BuiltinConstant('max_fragment_input_vectors', 'gl_MaxFragmentInputVectors', function() { return es3fShaderBuiltinVarTests.getVectorsFromComps(gl.MAX_FRAGMENT_INPUT_COMPONENTS); }), |
| new BuiltinConstant('min_program_texel_offset', 'gl_MinProgramTexelOffset', function() { return es3fShaderBuiltinVarTests.getInteger(gl.MIN_PROGRAM_TEXEL_OFFSET); }), |
| new BuiltinConstant('max_program_texel_offset', 'gl_MaxProgramTexelOffset', function() { return es3fShaderBuiltinVarTests.getInteger(gl.MAX_PROGRAM_TEXEL_OFFSET); }) |
| ]; |
| |
| for (var ndx = 0; ndx < builtinConstants.length; ndx++) { |
| /** @type {string} */ var caseName = builtinConstants[ndx].caseName; |
| /** @type {string} */ var varName = builtinConstants[ndx].varName; |
| /** @type {es3fShaderBuiltinVarTests.GetConstantValueFunc} */ var getValue = builtinConstants[ndx].getValue; |
| |
| testGroup.addChild(new es3fShaderBuiltinVarTests.ShaderBuiltinConstantCase(caseName + '_vertex', varName, varName, getValue, gluShaderProgram.shaderType.VERTEX)); |
| testGroup.addChild(new es3fShaderBuiltinVarTests.ShaderBuiltinConstantCase(caseName + '_fragment', varName, varName, getValue, gluShaderProgram.shaderType.FRAGMENT)); |
| } |
| |
| testGroup.addChild(new es3fShaderBuiltinVarTests.ShaderDepthRangeTest('depth_range_vertex', 'gl_DepthRange', true)); |
| testGroup.addChild(new es3fShaderBuiltinVarTests.ShaderDepthRangeTest('depth_range_fragment', 'gl_DepthRange', false)); |
| |
| // Vertex shader builtin variables. |
| testGroup.addChild(new es3fShaderBuiltinVarTests.VertexIDCase()); |
| // \todo [2013-03-20 pyry] gl_InstanceID -- tested in instancing tests quite thoroughly. |
| |
| // Fragment shader builtin variables. |
| testGroup.addChild(new es3fShaderBuiltinVarTests.FragCoordXYZCase()); |
| testGroup.addChild(new es3fShaderBuiltinVarTests.FragCoordWCase()); |
| testGroup.addChild(new es3fShaderBuiltinVarTests.PointCoordCase()); |
| testGroup.addChild(new es3fShaderBuiltinVarTests.FrontFacingCase()); |
| }; |
| |
| /** |
| * Run test |
| * @param {WebGL2RenderingContext} context |
| */ |
| es3fShaderBuiltinVarTests.run = function(context) { |
| gl = context; |
| //Set up Test Root parameters |
| var state = tcuTestCase.runner; |
| state.setRoot(new es3fShaderBuiltinVarTests.ShaderBuiltinVarTests()); |
| |
| //Set up name and description of this test series. |
| setCurrentTestName(state.testCases.fullName()); |
| description(state.testCases.getDescription()); |
| |
| try { |
| //Run test cases |
| tcuTestCase.runTestCases(); |
| } |
| catch (err) { |
| testFailedOptions('Failed to es3fShaderBuiltinVarTests.run tests', false); |
| tcuTestCase.runner.terminate(); |
| } |
| }; |
| |
| }); |