summaryrefslogtreecommitdiffstats
path: root/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fFragDepthTests.js
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fFragDepthTests.js593
1 files changed, 593 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fFragDepthTests.js b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fFragDepthTests.js
new file mode 100644
index 0000000000..8a892a0926
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fFragDepthTests.js
@@ -0,0 +1,593 @@
+/*-------------------------------------------------------------------------
+ * 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.es3fFragDepthTests');
+goog.require('framework.common.tcuImageCompare');
+goog.require('framework.common.tcuRGBA');
+goog.require('framework.common.tcuSurface');
+goog.require('framework.common.tcuTestCase');
+goog.require('framework.delibs.debase.deMath');
+goog.require('framework.delibs.debase.deRandom');
+goog.require('framework.delibs.debase.deString');
+goog.require('framework.opengl.gluShaderProgram');
+goog.require('framework.opengl.gluDrawUtil');
+goog.require('modules.shared.glsShaderRenderCase');
+
+goog.scope(function() {
+ var es3fFragDepthTests = functional.gles3.es3fFragDepthTests;
+ var deMath = framework.delibs.debase.deMath;
+ var deRandom = framework.delibs.debase.deRandom;
+ var deString = framework.delibs.debase.deString;
+ var glsShaderRenderCase = modules.shared.glsShaderRenderCase;
+ var gluShaderProgram = framework.opengl.gluShaderProgram;
+ var gluDrawUtil = framework.opengl.gluDrawUtil;
+ var tcuImageCompare = framework.common.tcuImageCompare;
+ var tcuRGBA = framework.common.tcuRGBA;
+ var tcuSurface = framework.common.tcuSurface;
+ var tcuTestCase = framework.common.tcuTestCase;
+ /** @typedef {function(Array<number>):number} */ es3fFragDepthTests.EvalFragDepthFunc;
+
+ /** @const {string} */ es3fFragDepthTests.s_vertexShaderSrc = '' +
+ '#version 300 es\n' +
+ 'in highp vec4 a_position;\n' +
+ 'in highp vec2 a_coord;\n' +
+ 'out highp vec2 v_coord;\n' +
+ 'void main (void)\n' +
+ '{\n' +
+ ' gl_Position = a_position;\n' +
+ ' v_coord = a_coord;\n' +
+ '}\n';
+
+ /** @const {string} */ es3fFragDepthTests.s_defaultFragmentShaderSrc = '' +
+ '#version 300 es\n' +
+ 'uniform highp vec4 u_color;\n' +
+ 'layout(location = 0) out mediump vec4 o_color;\n' +
+ 'void main (void)\n' +
+ '{\n' +
+ ' o_color = u_color;\n' +
+ '}\n';
+
+ /**
+ * @param {number} func
+ * @param {*} a
+ * @param {*} b
+ * @return {boolean}
+ */
+ es3fFragDepthTests.compare = function(func, a, b) {
+ switch (func) {
+ case gl.NEVER: return false;
+ case gl.ALWAYS: return true;
+ case gl.LESS: return a < b;
+ case gl.LEQUAL: return a <= b;
+ case gl.EQUAL: return a === b;
+ case gl.NOTEQUAL: return a !== b;
+ case gl.GEQUAL: return a >= b;
+ case gl.GREATER: return a > b;
+ }
+ bufferedLogToConsole('Compare function not supported.');
+ return false;
+ };
+
+ /**
+ * @constructor
+ * @extends {tcuTestCase.DeqpTest}
+ * @param {string} name
+ * @param {string} desc
+ * @param {string} fragSrc
+ * @param {?es3fFragDepthTests.EvalFragDepthFunc} evalFunc
+ * @param {number} compareFunc
+ */
+ es3fFragDepthTests.FragDepthCompareCase = function(name, desc, fragSrc, evalFunc, compareFunc) {
+ tcuTestCase.DeqpTest.call(this, name, desc);
+ /** @type {string} */ this.m_fragSrc = fragSrc;
+ /** @type {?es3fFragDepthTests.EvalFragDepthFunc} */ this.m_evalFunc = evalFunc;
+ /** @type {number} */ this.m_compareFunc = compareFunc;
+ };
+
+ es3fFragDepthTests.FragDepthCompareCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
+ es3fFragDepthTests.FragDepthCompareCase.prototype.constructor = es3fFragDepthTests.FragDepthCompareCase;
+
+ /**
+ * @return {tcuTestCase.IterateResult}
+ */
+ es3fFragDepthTests.FragDepthCompareCase.prototype.iterate = function() {
+ /** @type {deRandom.Random} */ var rnd = new deRandom.Random(deString.deStringHash(this.name));
+ /** @type {number} */ var viewportW = Math.min(128, gl.drawingBufferWidth);
+ /** @type {number} */ var viewportH = Math.min(128, gl.drawingBufferHeight);
+ /** @type {number} */ var viewportX = rnd.getInt(0, gl.drawingBufferWidth - viewportW);
+ /** @type {number} */ var viewportY = rnd.getInt(0, gl.drawingBufferHeight - viewportH);
+ /** @type {tcuSurface.Surface} */ var renderedFrame = new tcuSurface.Surface(viewportW, viewportH);
+ /** @type {tcuSurface.Surface} */ var referenceFrame = new tcuSurface.Surface(viewportW, viewportH);
+ /** @type {number} */ var constDepth = 0.1;
+ var depthBits = /** @type {number} */ (gl.getParameter(gl.DEPTH_BITS));
+
+ /** @type {number} */ var xf;
+ /** @type {number} */ var d;
+ /** @type {boolean} */ var dpass;
+
+ if (depthBits == 0)
+ throw new Error('Depth buffer is required');
+
+ gl.depthMask(true);
+ gl.viewport(viewportX, viewportY, viewportW, viewportH);
+ gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
+ gl.enable(gl.DEPTH_TEST);
+
+ /** @type {Array<number>} */ var quadIndices = [0, 1, 2, 2, 1, 3];
+
+ // Fill viewport with 2 quads - one with constant depth and another with d = [-1..1]
+ /** @type {gluShaderProgram.ShaderProgram} */
+ var basicQuadProgram = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(es3fFragDepthTests.s_vertexShaderSrc, es3fFragDepthTests.s_defaultFragmentShaderSrc));
+
+ if (!basicQuadProgram.isOk()) {
+ bufferedLogToConsole(basicQuadProgram.getProgramInfo().infoLog);
+ throw new Error('Compile failed');
+ }
+
+ /** @type {Array<number>} */ var constDepthCoord = [
+ -1.0, -1.0, constDepth, 1.0,
+ -1.0, 1.0, constDepth, 1.0,
+ 0.0, -1.0, constDepth, 1.0,
+ 0.0, 1.0, constDepth, 1.0
+ ];
+
+ /** @type {Array<number>} */ var varyingDepthCoord = [
+ 0.0, -1.0, 1.0, 1.0,
+ 0.0, 1.0, 0.0, 1.0,
+ 1.0, -1.0, 0.0, 1.0,
+ 1.0, 1.0, -1.0, 1.0
+ ];
+
+ gl.useProgram(basicQuadProgram.getProgram());
+ gl.uniform4f(gl.getUniformLocation(basicQuadProgram.getProgram(), 'u_color'), 0.0, 0.0, 1.0, 1.0);
+ gl.depthFunc(gl.ALWAYS);
+
+ /** @type {gluDrawUtil.VertexArrayBinding} */ var posBinding = gluDrawUtil.newFloatVertexArrayBinding('a_position', 4, 4, 0, constDepthCoord);
+ gluDrawUtil.draw(gl, basicQuadProgram.getProgram(), [posBinding], gluDrawUtil.triangles(quadIndices));
+
+ posBinding = gluDrawUtil.newFloatVertexArrayBinding('a_position', 4, 4, 0, varyingDepthCoord);
+ gluDrawUtil.draw(gl, basicQuadProgram.getProgram(), [posBinding], gluDrawUtil.triangles(quadIndices));
+
+ // Render with depth test.
+ /** @type {gluShaderProgram.ShaderProgram} */
+ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(es3fFragDepthTests.s_vertexShaderSrc, this.m_fragSrc));
+ bufferedLogToConsole(program.getProgramInfo().infoLog);
+
+ if (!program.isOk())
+ throw new Error('Compile failed');
+
+ /** @type {Array<number>} */ var coord = [
+ 0.0, 0.0,
+ 0.0, 1.0,
+ 1.0, 0.0,
+ 1.0, 1.0
+ ];
+
+ /** @type {Array<number>} */ var position = [
+ -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
+ ];
+
+ gl.useProgram(program.getProgram());
+ gl.depthFunc(this.m_compareFunc);
+ gl.uniform4f(gl.getUniformLocation(program.getProgram(), 'u_color'), 0.0, 1.0, 0.0, 1.0);
+
+ // Setup default helper uniforms.
+ glsShaderRenderCase.setupDefaultUniforms(program.getProgram());
+
+ /** @type {Array<gluDrawUtil.VertexArrayBinding>} */ var vertexArrays = [
+ gluDrawUtil.newFloatVertexArrayBinding('a_position', 4, 4, 0, position),
+ gluDrawUtil.newFloatVertexArrayBinding('a_coord', 2, 4, 0, coord)
+ ];
+
+ gluDrawUtil.draw(gl, program.getProgram(), vertexArrays, gluDrawUtil.triangles(quadIndices));
+
+ renderedFrame.readViewport(gl, [viewportX, viewportY, viewportW, viewportH]);
+
+ // Render reference.
+ for (var y = 0; y < referenceFrame.getHeight(); y++) {
+ /** @type {number} */ var yf = (y + 0.5) / referenceFrame.getHeight();
+ /** @type {number} */ var half = deMath.clamp(Math.floor(referenceFrame.getWidth() * 0.5 + 0.5), 0, referenceFrame.getWidth());
+
+ // Fill left half - comparison to constant 0.5
+ for (var x = 0; x < half; x++) {
+ xf = (x + 0.5) / referenceFrame.getWidth();
+ d = this.m_evalFunc([xf, yf]);
+ dpass = es3fFragDepthTests.compare(this.m_compareFunc, d, constDepth * 0.5 + 0.5);
+
+ referenceFrame.setPixel(x, y, dpass ? tcuRGBA.RGBA.green.toIVec() : tcuRGBA.RGBA.blue.toIVec());
+ }
+
+ // Fill right half - comparison to interpolated depth
+ for (var x = half; x < referenceFrame.getWidth(); x++) {
+ xf = (x + 0.5) / referenceFrame.getWidth();
+ /** @type {number} */ var xh = (x - half + 0.5) / (referenceFrame.getWidth() - half);
+ /** @type {number} */ var rd = 1.0 - (xh + yf) * 0.5;
+ d = this.m_evalFunc([xf, yf]);
+ dpass = es3fFragDepthTests.compare(this.m_compareFunc, d, rd);
+
+ referenceFrame.setPixel(x, y, dpass ? tcuRGBA.RGBA.green.toIVec() : tcuRGBA.RGBA.blue.toIVec());
+ }
+ }
+
+ /** @type {boolean} */ var isOk = tcuImageCompare.fuzzyCompare('Result', 'Image comparison result', referenceFrame.getAccess(), renderedFrame.getAccess(), 0.05);
+
+ if (!isOk)
+ testFailedOptions('Fail', false);
+ else
+ testPassedOptions('Pass', true);
+
+ return tcuTestCase.IterateResult.STOP;
+ };
+
+ /**
+ * @constructor
+ * @extends {tcuTestCase.DeqpTest}
+ * @param {string} name
+ * @param {string} desc
+ * @param {string} fragSrc
+ * @param {es3fFragDepthTests.EvalFragDepthFunc} evalFunc
+ */
+ es3fFragDepthTests.FragDepthWriteCase = function(name, desc, fragSrc, evalFunc) {
+ tcuTestCase.DeqpTest.call(this, name, desc);
+ /** @type {string} */ this.m_fragSrc = fragSrc;
+ /** @type {es3fFragDepthTests.EvalFragDepthFunc} */ this.m_evalFunc = evalFunc;
+ };
+
+ es3fFragDepthTests.FragDepthWriteCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
+ es3fFragDepthTests.FragDepthWriteCase.prototype.constructor = es3fFragDepthTests.FragDepthWriteCase;
+
+ /**
+ * @return {tcuTestCase.IterateResult}
+ */
+ es3fFragDepthTests.FragDepthWriteCase.prototype.iterate = function() {
+ /** @type {deRandom.Random} */ var rnd = new deRandom.Random(deString.deStringHash(this.name));
+ /** @type {number} */ var viewportW = Math.min(128, gl.drawingBufferWidth);
+ /** @type {number} */ var viewportH = Math.min(128, gl.drawingBufferHeight);
+ /** @type {number} */ var viewportX = rnd.getInt(0, gl.drawingBufferWidth - viewportW);
+ /** @type {number} */ var viewportY = rnd.getInt(0, gl.drawingBufferHeight - viewportH);
+ /** @type {tcuSurface.Surface} */ var renderedFrame = new tcuSurface.Surface(viewportW, viewportH);
+ /** @type {tcuSurface.Surface} */ var referenceFrame = new tcuSurface.Surface(viewportW, viewportH);
+ /** @type {number} */ var numDepthSteps = 16;
+ /** @type {number} */ var depthStep = 1.0 / (numDepthSteps - 1);
+ var depthBits = /** @type {number} */ (gl.getParameter(gl.DEPTH_BITS));
+
+ if (depthBits === 0)
+ throw new Error('Depth buffer is required');
+
+ gl.depthMask(true);
+ gl.viewport(viewportX, viewportY, viewportW, viewportH);
+ gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
+ gl.enable(gl.DEPTH_TEST);
+ gl.depthFunc(gl.LESS);
+
+ /** @type {Array<number>} */ var quadIndices = [0, 1, 2, 2, 1, 3];
+
+ // Render with given shader.
+ /** @type {gluShaderProgram.ShaderProgram} */
+ var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(es3fFragDepthTests.s_vertexShaderSrc, this.m_fragSrc));
+ bufferedLogToConsole(program.getProgramInfo().infoLog);
+
+ if (!program.isOk())
+ throw new Error('Compile failed');
+
+ /** @type {Array<number>} */ var coord = [
+ 0.0, 0.0,
+ 0.0, 1.0,
+ 1.0, 0.0,
+ 1.0, 1.0
+ ];
+
+ /** @type {Array<number>} */ var position = [
+ -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
+ ];
+
+ gl.useProgram(program.getProgram());
+ gl.uniform4f(gl.getUniformLocation(program.getProgram(), 'u_color'), 0.0, 1.0, 0.0, 1.0);
+
+ // Setup default helper uniforms.
+ glsShaderRenderCase.setupDefaultUniforms(program.getProgram());
+
+ /** @type {Array<gluDrawUtil.VertexArrayBinding>} */ var vertexArrays = [
+ gluDrawUtil.newFloatVertexArrayBinding('a_position', 4, 4, 0, position),
+ gluDrawUtil.newFloatVertexArrayBinding('a_coord', 2, 4, 0, coord)
+ ];
+ gluDrawUtil.draw(gl, program.getProgram(), vertexArrays, gluDrawUtil.triangles(quadIndices));
+
+ // Visualize by rendering full-screen quads with increasing depth and color.
+ program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(es3fFragDepthTests.s_vertexShaderSrc, es3fFragDepthTests.s_defaultFragmentShaderSrc));
+
+ if (!program.isOk()) {
+ bufferedLogToConsole(program.getProgramInfo().infoLog);
+ throw new Error('Compile failed');
+ }
+
+ /** @type {WebGLUniformLocation} */ var colorLoc = gl.getUniformLocation(program.getProgram(), 'u_color');
+
+ gl.useProgram(program.getProgram());
+ gl.depthMask(false);
+
+ for (var stepNdx = 0; stepNdx < numDepthSteps; stepNdx++) {
+ /** @type {number} */ var f = stepNdx * depthStep;
+ /** @type {number} */ var depth = f * 2.0 - 1.0;
+ /** @type {Array<number>} */ var color = [f, f, f, 1.0];
+
+ position = [
+ -1.0, -1.0, depth, 1.0,
+ -1.0, 1.0, depth, 1.0,
+ 1.0, -1.0, depth, 1.0,
+ 1.0, 1.0, depth, 1.0
+ ];
+
+ /** @type {gluDrawUtil.VertexArrayBinding} */
+ var posBinding = gluDrawUtil.newFloatVertexArrayBinding('a_position', 4, 4, 0, position);
+
+ gl.uniform4fv(colorLoc, color);
+ gluDrawUtil.draw(gl, program.getProgram(), [posBinding], gluDrawUtil.triangles(quadIndices));
+ }
+
+ renderedFrame.readViewport(gl, [viewportX, viewportY, viewportW, viewportH]);
+
+ // Render reference.
+ for (var y = 0; y < referenceFrame.getHeight(); y++)
+ for (var x = 0; x < referenceFrame.getWidth(); x++) {
+ /** @type {number} */ var xf = (x + 0.5) / referenceFrame.getWidth();
+ /** @type {number} */ var yf = (y + 0.5) / referenceFrame.getHeight();
+ /** @type {number} */ var d = this.m_evalFunc([xf, yf]);
+ /** @type {number} */ var step = Math.floor(d / depthStep);
+ /** @type {number} */ var col = deMath.clamp(Math.floor(step * depthStep * 255.0), 0, 255);
+
+ referenceFrame.setPixel(x, y, [col, col, col, 0xff]);
+ }
+
+ /** @type {boolean} */ var isOk = tcuImageCompare.fuzzyCompare('Result', 'Image comparison result', referenceFrame.getAccess(), renderedFrame.getAccess(), 0.05);
+
+ if (!isOk)
+ testFailedOptions('Fail', false);
+ else
+ testPassedOptions('Pass', true);
+
+ return tcuTestCase.IterateResult.STOP;
+ };
+
+
+ /**
+ * @constructor
+ * @extends {tcuTestCase.DeqpTest}
+ */
+ es3fFragDepthTests.FragDepthTests = function() {
+ tcuTestCase.DeqpTest.call(this, 'fragdepth', 'gl_FragDepth tests');
+ };
+
+ es3fFragDepthTests.FragDepthTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
+ es3fFragDepthTests.FragDepthTests.prototype.constructor = es3fFragDepthTests.FragDepthTests;
+
+ /**
+ * @param {Array<number>} coord
+ * @return {number}
+ */
+ es3fFragDepthTests.evalConstDepth = function(coord) {
+ return 0.5;
+ };
+
+ /**
+ * @param {Array<number>} coord
+ * @return {number}
+ */
+ es3fFragDepthTests.evalDynamicDepth = function(coord) {
+ return (coord[0] + coord[1]) * 0.5;
+ };
+
+ /**
+ * @param {Array<number>} coord
+ * @return {number}
+ */
+ es3fFragDepthTests.evalNoWrite = function(coord) {
+ return 1.0 - (coord[0] + coord[1]) * 0.5;
+ };
+
+ /**
+ * @param {Array<number>} coord
+ * @return {number}
+ */
+ es3fFragDepthTests.evalDynamicConditionalDepth = function(coord) {
+ /** @type {number} */ var d = (coord[0] + coord[1]) * 0.5;
+ if (coord[1] < 0.5)
+ return d;
+ else
+ return 1.0 - d;
+ };
+
+ es3fFragDepthTests.FragDepthTests.prototype.init = function() {
+ /**
+ * @struct
+ * @constructor
+ * @param {string} name
+ * @param {string} desc
+ * @param {es3fFragDepthTests.EvalFragDepthFunc} evalFunc
+ * @param {string} fragSrc
+ */
+ var Case = function(name, desc, evalFunc, fragSrc) {
+ /** @type {string} */ this.name = name;
+ /** @type {string} */ this.desc = desc;
+ /** @type {es3fFragDepthTests.EvalFragDepthFunc} */ this.evalFunc = evalFunc;
+ /** @type {string} */ this.fragSrc = fragSrc;
+ };
+
+ /** @type {Array<Case>} */ var cases = [
+ new Case('no_write', 'No gl_FragDepth write', es3fFragDepthTests.evalNoWrite,
+ '#version 300 es\n' +
+ 'uniform highp vec4 u_color;\n' +
+ 'layout(location = 0) out mediump vec4 o_color;\n' +
+ 'void main (void)\n' +
+ '{\n' +
+ ' o_color = u_color;\n' +
+ '}\n'
+ ),
+ new Case('const', 'Const depth write', es3fFragDepthTests.evalConstDepth,
+ '#version 300 es\n' +
+ 'uniform highp vec4 u_color;\n' +
+ 'layout(location = 0) out mediump vec4 o_color;\n' +
+ 'void main (void)\n' +
+ '{\n' +
+ ' o_color = u_color;\n' +
+ ' gl_FragDepth = 0.5;\n' +
+ '}\n'
+ ),
+ new Case('uniform', 'Uniform depth write', es3fFragDepthTests.evalConstDepth,
+ '#version 300 es\n' +
+ 'uniform highp vec4 u_color;\n' +
+ 'uniform highp float uf_half;\n' +
+ 'layout(location = 0) out mediump vec4 o_color;\n' +
+ 'void main (void)\n' +
+ '{\n' +
+ ' o_color = u_color;\n' +
+ ' gl_FragDepth = uf_half;\n' +
+ '}\n'
+ ),
+ new Case('dynamic', 'Dynamic depth write', es3fFragDepthTests.evalDynamicDepth,
+ '#version 300 es\n' +
+ 'uniform highp vec4 u_color;\n' +
+ 'in highp vec2 v_coord;\n' +
+ 'layout(location = 0) out mediump vec4 o_color;\n' +
+ 'void main (void)\n' +
+ '{\n' +
+ ' o_color = u_color;\n' +
+ ' gl_FragDepth = (v_coord.x+v_coord.y)*0.5;\n' +
+ '}\n'
+ ),
+ new Case('fragcoord_z', 'gl_FragDepth write from gl_FragCoord.z', es3fFragDepthTests.evalNoWrite,
+ '#version 300 es\n' +
+ 'uniform highp vec4 u_color;\n' +
+ 'layout(location = 0) out mediump vec4 o_color;\n' +
+ 'void main (void)\n' +
+ '{\n' +
+ ' o_color = u_color;\n' +
+ ' gl_FragDepth = gl_FragCoord.z;\n' +
+ '}\n'
+ ),
+ new Case('uniform_conditional_write', 'Uniform conditional write', es3fFragDepthTests.evalDynamicDepth,
+ '#version 300 es\n' +
+ 'uniform highp vec4 u_color;\n' +
+ 'uniform bool ub_true;\n' +
+ 'in highp vec2 v_coord;\n' +
+ 'layout(location = 0) out mediump vec4 o_color;\n' +
+ 'void main (void)\n' +
+ '{\n' +
+ ' o_color = u_color;\n' +
+ ' if (ub_true)\n' +
+ ' gl_FragDepth = (v_coord.x+v_coord.y)*0.5;\n' +
+ '}\n'
+ ),
+ new Case('dynamic_conditional_write', 'Uniform conditional write', es3fFragDepthTests.evalDynamicConditionalDepth,
+ '#version 300 es\n' +
+ 'uniform highp vec4 u_color;\n' +
+ 'uniform bool ub_true;\n' +
+ 'in highp vec2 v_coord;\n' +
+ 'layout(location = 0) out mediump vec4 o_color;\n' +
+ 'void main (void)\n' +
+ '{\n' +
+ ' o_color = u_color;\n' +
+ ' mediump float d = (v_coord.x+v_coord.y)*0.5f;\n' +
+ ' if (v_coord.y < 0.5)\n' +
+ ' gl_FragDepth = d;\n' +
+ ' else\n' +
+ ' gl_FragDepth = 1.0 - d;\n' +
+ '}\n'
+ ),
+ new Case('uniform_loop_write', 'Uniform loop write', es3fFragDepthTests.evalConstDepth,
+ '#version 300 es\n' +
+ 'uniform highp vec4 u_color;\n' +
+ 'uniform int ui_two;\n' +
+ 'uniform highp float uf_fourth;\n' +
+ 'in highp vec2 v_coord;\n' +
+ 'layout(location = 0) out mediump vec4 o_color;\n' +
+ 'void main (void)\n' +
+ '{\n' +
+ ' o_color = u_color;\n' +
+ ' gl_FragDepth = 0.0;\n' +
+ ' for (int i = 0; i < ui_two; i++)\n' +
+ ' gl_FragDepth += uf_fourth;\n' +
+ '}\n'
+ ),
+ new Case('write_in_function', 'Uniform loop write', es3fFragDepthTests.evalDynamicDepth,
+ '#version 300 es\n' +
+ 'uniform highp vec4 u_color;\n' +
+ 'uniform highp float uf_half;\n' +
+ 'in highp vec2 v_coord;\n' +
+ 'layout(location = 0) out mediump vec4 o_color;\n' +
+ 'void myfunc (highp vec2 coord)\n' +
+ '{\n' +
+ ' gl_FragDepth = (coord.x+coord.y)*0.5;\n' +
+ '}\n' +
+ 'void main (void)\n' +
+ '{\n' +
+ ' o_color = u_color;\n' +
+ ' myfunc(v_coord);\n' +
+ '}\n'
+ )
+ ];
+
+ var testGroup = tcuTestCase.runner.testCases;
+
+ // .write
+ /** @type {tcuTestCase.DeqpTest} */ var writeGroup = tcuTestCase.newTest('write', 'gl_FragDepth write tests');
+ testGroup.addChild(writeGroup);
+ for (var ndx = 0; ndx < cases.length; ndx++)
+ writeGroup.addChild(new es3fFragDepthTests.FragDepthWriteCase(cases[ndx].name, cases[ndx].desc, cases[ndx].fragSrc, cases[ndx].evalFunc));
+
+ // .compare
+ /** @type {tcuTestCase.DeqpTest} */ var compareGroup = tcuTestCase.newTest('compare', 'gl_FragDepth used with depth comparison');
+ testGroup.addChild(compareGroup);
+ for (var ndx = 0; ndx < cases.length; ndx++)
+ compareGroup.addChild(new es3fFragDepthTests.FragDepthCompareCase(cases[ndx].name, cases[ndx].desc, cases[ndx].fragSrc, cases[ndx].evalFunc, gl.LESS));
+ };
+
+ /**
+ * Run test
+ * @param {WebGL2RenderingContext} context
+ */
+ es3fFragDepthTests.run = function(context) {
+ gl = context;
+ //Set up Test Root parameters
+ var state = tcuTestCase.runner;
+ state.setRoot(new es3fFragDepthTests.FragDepthTests());
+
+ //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 es3fFragDepthTests.run tests', false);
+ tcuTestCase.runner.terminate();
+ }
+ };
+
+});
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-10 16:58:53 +0000