es3fFragDepthTests.js (21548B)
1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES Utilities 3 * ------------------------------------------------ 4 * 5 * Copyright 2014 The Android Open Source Project 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 */ 20 21 'use strict'; 22 goog.provide('functional.gles3.es3fFragDepthTests'); 23 goog.require('framework.common.tcuImageCompare'); 24 goog.require('framework.common.tcuRGBA'); 25 goog.require('framework.common.tcuSurface'); 26 goog.require('framework.common.tcuTestCase'); 27 goog.require('framework.delibs.debase.deMath'); 28 goog.require('framework.delibs.debase.deRandom'); 29 goog.require('framework.delibs.debase.deString'); 30 goog.require('framework.opengl.gluShaderProgram'); 31 goog.require('framework.opengl.gluDrawUtil'); 32 goog.require('modules.shared.glsShaderRenderCase'); 33 34 goog.scope(function() { 35 var es3fFragDepthTests = functional.gles3.es3fFragDepthTests; 36 var deMath = framework.delibs.debase.deMath; 37 var deRandom = framework.delibs.debase.deRandom; 38 var deString = framework.delibs.debase.deString; 39 var glsShaderRenderCase = modules.shared.glsShaderRenderCase; 40 var gluShaderProgram = framework.opengl.gluShaderProgram; 41 var gluDrawUtil = framework.opengl.gluDrawUtil; 42 var tcuImageCompare = framework.common.tcuImageCompare; 43 var tcuRGBA = framework.common.tcuRGBA; 44 var tcuSurface = framework.common.tcuSurface; 45 var tcuTestCase = framework.common.tcuTestCase; 46 /** @typedef {function(Array<number>):number} */ es3fFragDepthTests.EvalFragDepthFunc; 47 48 /** @const {string} */ es3fFragDepthTests.s_vertexShaderSrc = '' + 49 '#version 300 es\n' + 50 'in highp vec4 a_position;\n' + 51 'in highp vec2 a_coord;\n' + 52 'out highp vec2 v_coord;\n' + 53 'void main (void)\n' + 54 '{\n' + 55 ' gl_Position = a_position;\n' + 56 ' v_coord = a_coord;\n' + 57 '}\n'; 58 59 /** @const {string} */ es3fFragDepthTests.s_defaultFragmentShaderSrc = '' + 60 '#version 300 es\n' + 61 'uniform highp vec4 u_color;\n' + 62 'layout(location = 0) out mediump vec4 o_color;\n' + 63 'void main (void)\n' + 64 '{\n' + 65 ' o_color = u_color;\n' + 66 '}\n'; 67 68 /** 69 * @param {number} func 70 * @param {*} a 71 * @param {*} b 72 * @return {boolean} 73 */ 74 es3fFragDepthTests.compare = function(func, a, b) { 75 switch (func) { 76 case gl.NEVER: return false; 77 case gl.ALWAYS: return true; 78 case gl.LESS: return a < b; 79 case gl.LEQUAL: return a <= b; 80 case gl.EQUAL: return a === b; 81 case gl.NOTEQUAL: return a !== b; 82 case gl.GEQUAL: return a >= b; 83 case gl.GREATER: return a > b; 84 } 85 bufferedLogToConsole('Compare function not supported.'); 86 return false; 87 }; 88 89 /** 90 * @constructor 91 * @extends {tcuTestCase.DeqpTest} 92 * @param {string} name 93 * @param {string} desc 94 * @param {string} fragSrc 95 * @param {?es3fFragDepthTests.EvalFragDepthFunc} evalFunc 96 * @param {number} compareFunc 97 */ 98 es3fFragDepthTests.FragDepthCompareCase = function(name, desc, fragSrc, evalFunc, compareFunc) { 99 tcuTestCase.DeqpTest.call(this, name, desc); 100 /** @type {string} */ this.m_fragSrc = fragSrc; 101 /** @type {?es3fFragDepthTests.EvalFragDepthFunc} */ this.m_evalFunc = evalFunc; 102 /** @type {number} */ this.m_compareFunc = compareFunc; 103 }; 104 105 es3fFragDepthTests.FragDepthCompareCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype); 106 es3fFragDepthTests.FragDepthCompareCase.prototype.constructor = es3fFragDepthTests.FragDepthCompareCase; 107 108 /** 109 * @return {tcuTestCase.IterateResult} 110 */ 111 es3fFragDepthTests.FragDepthCompareCase.prototype.iterate = function() { 112 /** @type {deRandom.Random} */ var rnd = new deRandom.Random(deString.deStringHash(this.name)); 113 /** @type {number} */ var viewportW = Math.min(128, gl.drawingBufferWidth); 114 /** @type {number} */ var viewportH = Math.min(128, gl.drawingBufferHeight); 115 /** @type {number} */ var viewportX = rnd.getInt(0, gl.drawingBufferWidth - viewportW); 116 /** @type {number} */ var viewportY = rnd.getInt(0, gl.drawingBufferHeight - viewportH); 117 /** @type {tcuSurface.Surface} */ var renderedFrame = new tcuSurface.Surface(viewportW, viewportH); 118 /** @type {tcuSurface.Surface} */ var referenceFrame = new tcuSurface.Surface(viewportW, viewportH); 119 /** @type {number} */ var constDepth = 0.1; 120 var depthBits = /** @type {number} */ (gl.getParameter(gl.DEPTH_BITS)); 121 122 /** @type {number} */ var xf; 123 /** @type {number} */ var d; 124 /** @type {boolean} */ var dpass; 125 126 if (depthBits == 0) 127 throw new Error('Depth buffer is required'); 128 129 gl.depthMask(true); 130 gl.viewport(viewportX, viewportY, viewportW, viewportH); 131 gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT); 132 gl.enable(gl.DEPTH_TEST); 133 134 /** @type {Array<number>} */ var quadIndices = [0, 1, 2, 2, 1, 3]; 135 136 // Fill viewport with 2 quads - one with constant depth and another with d = [-1..1] 137 /** @type {gluShaderProgram.ShaderProgram} */ 138 var basicQuadProgram = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(es3fFragDepthTests.s_vertexShaderSrc, es3fFragDepthTests.s_defaultFragmentShaderSrc)); 139 140 if (!basicQuadProgram.isOk()) { 141 bufferedLogToConsole(basicQuadProgram.getProgramInfo().infoLog); 142 throw new Error('Compile failed'); 143 } 144 145 /** @type {Array<number>} */ var constDepthCoord = [ 146 -1.0, -1.0, constDepth, 1.0, 147 -1.0, 1.0, constDepth, 1.0, 148 0.0, -1.0, constDepth, 1.0, 149 0.0, 1.0, constDepth, 1.0 150 ]; 151 152 /** @type {Array<number>} */ var varyingDepthCoord = [ 153 0.0, -1.0, 1.0, 1.0, 154 0.0, 1.0, 0.0, 1.0, 155 1.0, -1.0, 0.0, 1.0, 156 1.0, 1.0, -1.0, 1.0 157 ]; 158 159 gl.useProgram(basicQuadProgram.getProgram()); 160 gl.uniform4f(gl.getUniformLocation(basicQuadProgram.getProgram(), 'u_color'), 0.0, 0.0, 1.0, 1.0); 161 gl.depthFunc(gl.ALWAYS); 162 163 /** @type {gluDrawUtil.VertexArrayBinding} */ var posBinding = gluDrawUtil.newFloatVertexArrayBinding('a_position', 4, 4, 0, constDepthCoord); 164 gluDrawUtil.draw(gl, basicQuadProgram.getProgram(), [posBinding], gluDrawUtil.triangles(quadIndices)); 165 166 posBinding = gluDrawUtil.newFloatVertexArrayBinding('a_position', 4, 4, 0, varyingDepthCoord); 167 gluDrawUtil.draw(gl, basicQuadProgram.getProgram(), [posBinding], gluDrawUtil.triangles(quadIndices)); 168 169 // Render with depth test. 170 /** @type {gluShaderProgram.ShaderProgram} */ 171 var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(es3fFragDepthTests.s_vertexShaderSrc, this.m_fragSrc)); 172 bufferedLogToConsole(program.getProgramInfo().infoLog); 173 174 if (!program.isOk()) 175 throw new Error('Compile failed'); 176 177 /** @type {Array<number>} */ var coord = [ 178 0.0, 0.0, 179 0.0, 1.0, 180 1.0, 0.0, 181 1.0, 1.0 182 ]; 183 184 /** @type {Array<number>} */ var position = [ 185 -1.0, -1.0, 1.0, 1.0, 186 -1.0, 1.0, 0.0, 1.0, 187 1.0, -1.0, 0.0, 1.0, 188 1.0, 1.0, -1.0, 1.0 189 ]; 190 191 gl.useProgram(program.getProgram()); 192 gl.depthFunc(this.m_compareFunc); 193 gl.uniform4f(gl.getUniformLocation(program.getProgram(), 'u_color'), 0.0, 1.0, 0.0, 1.0); 194 195 // Setup default helper uniforms. 196 glsShaderRenderCase.setupDefaultUniforms(program.getProgram()); 197 198 /** @type {Array<gluDrawUtil.VertexArrayBinding>} */ var vertexArrays = [ 199 gluDrawUtil.newFloatVertexArrayBinding('a_position', 4, 4, 0, position), 200 gluDrawUtil.newFloatVertexArrayBinding('a_coord', 2, 4, 0, coord) 201 ]; 202 203 gluDrawUtil.draw(gl, program.getProgram(), vertexArrays, gluDrawUtil.triangles(quadIndices)); 204 205 renderedFrame.readViewport(gl, [viewportX, viewportY, viewportW, viewportH]); 206 207 // Render reference. 208 for (var y = 0; y < referenceFrame.getHeight(); y++) { 209 /** @type {number} */ var yf = (y + 0.5) / referenceFrame.getHeight(); 210 /** @type {number} */ var half = deMath.clamp(Math.floor(referenceFrame.getWidth() * 0.5 + 0.5), 0, referenceFrame.getWidth()); 211 212 // Fill left half - comparison to constant 0.5 213 for (var x = 0; x < half; x++) { 214 xf = (x + 0.5) / referenceFrame.getWidth(); 215 d = this.m_evalFunc([xf, yf]); 216 dpass = es3fFragDepthTests.compare(this.m_compareFunc, d, constDepth * 0.5 + 0.5); 217 218 referenceFrame.setPixel(x, y, dpass ? tcuRGBA.RGBA.green.toIVec() : tcuRGBA.RGBA.blue.toIVec()); 219 } 220 221 // Fill right half - comparison to interpolated depth 222 for (var x = half; x < referenceFrame.getWidth(); x++) { 223 xf = (x + 0.5) / referenceFrame.getWidth(); 224 /** @type {number} */ var xh = (x - half + 0.5) / (referenceFrame.getWidth() - half); 225 /** @type {number} */ var rd = 1.0 - (xh + yf) * 0.5; 226 d = this.m_evalFunc([xf, yf]); 227 dpass = es3fFragDepthTests.compare(this.m_compareFunc, d, rd); 228 229 referenceFrame.setPixel(x, y, dpass ? tcuRGBA.RGBA.green.toIVec() : tcuRGBA.RGBA.blue.toIVec()); 230 } 231 } 232 233 /** @type {boolean} */ var isOk = tcuImageCompare.fuzzyCompare('Result', 'Image comparison result', referenceFrame.getAccess(), renderedFrame.getAccess(), 0.05); 234 235 if (!isOk) 236 testFailedOptions('Fail', false); 237 else 238 testPassedOptions('Pass', true); 239 240 return tcuTestCase.IterateResult.STOP; 241 }; 242 243 /** 244 * @constructor 245 * @extends {tcuTestCase.DeqpTest} 246 * @param {string} name 247 * @param {string} desc 248 * @param {string} fragSrc 249 * @param {es3fFragDepthTests.EvalFragDepthFunc} evalFunc 250 */ 251 es3fFragDepthTests.FragDepthWriteCase = function(name, desc, fragSrc, evalFunc) { 252 tcuTestCase.DeqpTest.call(this, name, desc); 253 /** @type {string} */ this.m_fragSrc = fragSrc; 254 /** @type {es3fFragDepthTests.EvalFragDepthFunc} */ this.m_evalFunc = evalFunc; 255 }; 256 257 es3fFragDepthTests.FragDepthWriteCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype); 258 es3fFragDepthTests.FragDepthWriteCase.prototype.constructor = es3fFragDepthTests.FragDepthWriteCase; 259 260 /** 261 * @return {tcuTestCase.IterateResult} 262 */ 263 es3fFragDepthTests.FragDepthWriteCase.prototype.iterate = function() { 264 /** @type {deRandom.Random} */ var rnd = new deRandom.Random(deString.deStringHash(this.name)); 265 /** @type {number} */ var viewportW = Math.min(128, gl.drawingBufferWidth); 266 /** @type {number} */ var viewportH = Math.min(128, gl.drawingBufferHeight); 267 /** @type {number} */ var viewportX = rnd.getInt(0, gl.drawingBufferWidth - viewportW); 268 /** @type {number} */ var viewportY = rnd.getInt(0, gl.drawingBufferHeight - viewportH); 269 /** @type {tcuSurface.Surface} */ var renderedFrame = new tcuSurface.Surface(viewportW, viewportH); 270 /** @type {tcuSurface.Surface} */ var referenceFrame = new tcuSurface.Surface(viewportW, viewportH); 271 /** @type {number} */ var numDepthSteps = 16; 272 /** @type {number} */ var depthStep = 1.0 / (numDepthSteps - 1); 273 var depthBits = /** @type {number} */ (gl.getParameter(gl.DEPTH_BITS)); 274 275 if (depthBits === 0) 276 throw new Error('Depth buffer is required'); 277 278 gl.depthMask(true); 279 gl.viewport(viewportX, viewportY, viewportW, viewportH); 280 gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT); 281 gl.enable(gl.DEPTH_TEST); 282 gl.depthFunc(gl.LESS); 283 284 /** @type {Array<number>} */ var quadIndices = [0, 1, 2, 2, 1, 3]; 285 286 // Render with given shader. 287 /** @type {gluShaderProgram.ShaderProgram} */ 288 var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(es3fFragDepthTests.s_vertexShaderSrc, this.m_fragSrc)); 289 bufferedLogToConsole(program.getProgramInfo().infoLog); 290 291 if (!program.isOk()) 292 throw new Error('Compile failed'); 293 294 /** @type {Array<number>} */ var coord = [ 295 0.0, 0.0, 296 0.0, 1.0, 297 1.0, 0.0, 298 1.0, 1.0 299 ]; 300 301 /** @type {Array<number>} */ var position = [ 302 -1.0, -1.0, +1.0, 1.0, 303 -1.0, 1.0, 0.0, 1.0, 304 1.0, -1.0, 0.0, 1.0, 305 1.0, 1.0, -1.0, 1.0 306 ]; 307 308 gl.useProgram(program.getProgram()); 309 gl.uniform4f(gl.getUniformLocation(program.getProgram(), 'u_color'), 0.0, 1.0, 0.0, 1.0); 310 311 // Setup default helper uniforms. 312 glsShaderRenderCase.setupDefaultUniforms(program.getProgram()); 313 314 /** @type {Array<gluDrawUtil.VertexArrayBinding>} */ var vertexArrays = [ 315 gluDrawUtil.newFloatVertexArrayBinding('a_position', 4, 4, 0, position), 316 gluDrawUtil.newFloatVertexArrayBinding('a_coord', 2, 4, 0, coord) 317 ]; 318 gluDrawUtil.draw(gl, program.getProgram(), vertexArrays, gluDrawUtil.triangles(quadIndices)); 319 320 // Visualize by rendering full-screen quads with increasing depth and color. 321 program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(es3fFragDepthTests.s_vertexShaderSrc, es3fFragDepthTests.s_defaultFragmentShaderSrc)); 322 323 if (!program.isOk()) { 324 bufferedLogToConsole(program.getProgramInfo().infoLog); 325 throw new Error('Compile failed'); 326 } 327 328 /** @type {WebGLUniformLocation} */ var colorLoc = gl.getUniformLocation(program.getProgram(), 'u_color'); 329 330 gl.useProgram(program.getProgram()); 331 gl.depthMask(false); 332 333 for (var stepNdx = 0; stepNdx < numDepthSteps; stepNdx++) { 334 /** @type {number} */ var f = stepNdx * depthStep; 335 /** @type {number} */ var depth = f * 2.0 - 1.0; 336 /** @type {Array<number>} */ var color = [f, f, f, 1.0]; 337 338 position = [ 339 -1.0, -1.0, depth, 1.0, 340 -1.0, 1.0, depth, 1.0, 341 1.0, -1.0, depth, 1.0, 342 1.0, 1.0, depth, 1.0 343 ]; 344 345 /** @type {gluDrawUtil.VertexArrayBinding} */ 346 var posBinding = gluDrawUtil.newFloatVertexArrayBinding('a_position', 4, 4, 0, position); 347 348 gl.uniform4fv(colorLoc, color); 349 gluDrawUtil.draw(gl, program.getProgram(), [posBinding], gluDrawUtil.triangles(quadIndices)); 350 } 351 352 renderedFrame.readViewport(gl, [viewportX, viewportY, viewportW, viewportH]); 353 354 // Render reference. 355 for (var y = 0; y < referenceFrame.getHeight(); y++) 356 for (var x = 0; x < referenceFrame.getWidth(); x++) { 357 /** @type {number} */ var xf = (x + 0.5) / referenceFrame.getWidth(); 358 /** @type {number} */ var yf = (y + 0.5) / referenceFrame.getHeight(); 359 /** @type {number} */ var d = this.m_evalFunc([xf, yf]); 360 /** @type {number} */ var step = Math.floor(d / depthStep); 361 /** @type {number} */ var col = deMath.clamp(Math.floor(step * depthStep * 255.0), 0, 255); 362 363 referenceFrame.setPixel(x, y, [col, col, col, 0xff]); 364 } 365 366 /** @type {boolean} */ var isOk = tcuImageCompare.fuzzyCompare('Result', 'Image comparison result', referenceFrame.getAccess(), renderedFrame.getAccess(), 0.05); 367 368 if (!isOk) 369 testFailedOptions('Fail', false); 370 else 371 testPassedOptions('Pass', true); 372 373 return tcuTestCase.IterateResult.STOP; 374 }; 375 376 377 /** 378 * @constructor 379 * @extends {tcuTestCase.DeqpTest} 380 */ 381 es3fFragDepthTests.FragDepthTests = function() { 382 tcuTestCase.DeqpTest.call(this, 'fragdepth', 'gl_FragDepth tests'); 383 }; 384 385 es3fFragDepthTests.FragDepthTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype); 386 es3fFragDepthTests.FragDepthTests.prototype.constructor = es3fFragDepthTests.FragDepthTests; 387 388 /** 389 * @param {Array<number>} coord 390 * @return {number} 391 */ 392 es3fFragDepthTests.evalConstDepth = function(coord) { 393 return 0.5; 394 }; 395 396 /** 397 * @param {Array<number>} coord 398 * @return {number} 399 */ 400 es3fFragDepthTests.evalDynamicDepth = function(coord) { 401 return (coord[0] + coord[1]) * 0.5; 402 }; 403 404 /** 405 * @param {Array<number>} coord 406 * @return {number} 407 */ 408 es3fFragDepthTests.evalNoWrite = function(coord) { 409 return 1.0 - (coord[0] + coord[1]) * 0.5; 410 }; 411 412 /** 413 * @param {Array<number>} coord 414 * @return {number} 415 */ 416 es3fFragDepthTests.evalDynamicConditionalDepth = function(coord) { 417 /** @type {number} */ var d = (coord[0] + coord[1]) * 0.5; 418 if (coord[1] < 0.5) 419 return d; 420 else 421 return 1.0 - d; 422 }; 423 424 es3fFragDepthTests.FragDepthTests.prototype.init = function() { 425 /** 426 * @struct 427 * @constructor 428 * @param {string} name 429 * @param {string} desc 430 * @param {es3fFragDepthTests.EvalFragDepthFunc} evalFunc 431 * @param {string} fragSrc 432 */ 433 var Case = function(name, desc, evalFunc, fragSrc) { 434 /** @type {string} */ this.name = name; 435 /** @type {string} */ this.desc = desc; 436 /** @type {es3fFragDepthTests.EvalFragDepthFunc} */ this.evalFunc = evalFunc; 437 /** @type {string} */ this.fragSrc = fragSrc; 438 }; 439 440 /** @type {Array<Case>} */ var cases = [ 441 new Case('no_write', 'No gl_FragDepth write', es3fFragDepthTests.evalNoWrite, 442 '#version 300 es\n' + 443 'uniform highp vec4 u_color;\n' + 444 'layout(location = 0) out mediump vec4 o_color;\n' + 445 'void main (void)\n' + 446 '{\n' + 447 ' o_color = u_color;\n' + 448 '}\n' 449 ), 450 new Case('const', 'Const depth write', es3fFragDepthTests.evalConstDepth, 451 '#version 300 es\n' + 452 'uniform highp vec4 u_color;\n' + 453 'layout(location = 0) out mediump vec4 o_color;\n' + 454 'void main (void)\n' + 455 '{\n' + 456 ' o_color = u_color;\n' + 457 ' gl_FragDepth = 0.5;\n' + 458 '}\n' 459 ), 460 new Case('uniform', 'Uniform depth write', es3fFragDepthTests.evalConstDepth, 461 '#version 300 es\n' + 462 'uniform highp vec4 u_color;\n' + 463 'uniform highp float uf_half;\n' + 464 'layout(location = 0) out mediump vec4 o_color;\n' + 465 'void main (void)\n' + 466 '{\n' + 467 ' o_color = u_color;\n' + 468 ' gl_FragDepth = uf_half;\n' + 469 '}\n' 470 ), 471 new Case('dynamic', 'Dynamic depth write', es3fFragDepthTests.evalDynamicDepth, 472 '#version 300 es\n' + 473 'uniform highp vec4 u_color;\n' + 474 'in highp vec2 v_coord;\n' + 475 'layout(location = 0) out mediump vec4 o_color;\n' + 476 'void main (void)\n' + 477 '{\n' + 478 ' o_color = u_color;\n' + 479 ' gl_FragDepth = (v_coord.x+v_coord.y)*0.5;\n' + 480 '}\n' 481 ), 482 new Case('fragcoord_z', 'gl_FragDepth write from gl_FragCoord.z', es3fFragDepthTests.evalNoWrite, 483 '#version 300 es\n' + 484 'uniform highp vec4 u_color;\n' + 485 'layout(location = 0) out mediump vec4 o_color;\n' + 486 'void main (void)\n' + 487 '{\n' + 488 ' o_color = u_color;\n' + 489 ' gl_FragDepth = gl_FragCoord.z;\n' + 490 '}\n' 491 ), 492 new Case('uniform_conditional_write', 'Uniform conditional write', es3fFragDepthTests.evalDynamicDepth, 493 '#version 300 es\n' + 494 'uniform highp vec4 u_color;\n' + 495 'uniform bool ub_true;\n' + 496 'in highp vec2 v_coord;\n' + 497 'layout(location = 0) out mediump vec4 o_color;\n' + 498 'void main (void)\n' + 499 '{\n' + 500 ' o_color = u_color;\n' + 501 ' if (ub_true)\n' + 502 ' gl_FragDepth = (v_coord.x+v_coord.y)*0.5;\n' + 503 '}\n' 504 ), 505 new Case('dynamic_conditional_write', 'Uniform conditional write', es3fFragDepthTests.evalDynamicConditionalDepth, 506 '#version 300 es\n' + 507 'uniform highp vec4 u_color;\n' + 508 'uniform bool ub_true;\n' + 509 'in highp vec2 v_coord;\n' + 510 'layout(location = 0) out mediump vec4 o_color;\n' + 511 'void main (void)\n' + 512 '{\n' + 513 ' o_color = u_color;\n' + 514 ' mediump float d = (v_coord.x+v_coord.y)*0.5f;\n' + 515 ' if (v_coord.y < 0.5)\n' + 516 ' gl_FragDepth = d;\n' + 517 ' else\n' + 518 ' gl_FragDepth = 1.0 - d;\n' + 519 '}\n' 520 ), 521 new Case('uniform_loop_write', 'Uniform loop write', es3fFragDepthTests.evalConstDepth, 522 '#version 300 es\n' + 523 'uniform highp vec4 u_color;\n' + 524 'uniform int ui_two;\n' + 525 'uniform highp float uf_fourth;\n' + 526 'in highp vec2 v_coord;\n' + 527 'layout(location = 0) out mediump vec4 o_color;\n' + 528 'void main (void)\n' + 529 '{\n' + 530 ' o_color = u_color;\n' + 531 ' gl_FragDepth = 0.0;\n' + 532 ' for (int i = 0; i < ui_two; i++)\n' + 533 ' gl_FragDepth += uf_fourth;\n' + 534 '}\n' 535 ), 536 new Case('write_in_function', 'Uniform loop write', es3fFragDepthTests.evalDynamicDepth, 537 '#version 300 es\n' + 538 'uniform highp vec4 u_color;\n' + 539 'uniform highp float uf_half;\n' + 540 'in highp vec2 v_coord;\n' + 541 'layout(location = 0) out mediump vec4 o_color;\n' + 542 'void myfunc (highp vec2 coord)\n' + 543 '{\n' + 544 ' gl_FragDepth = (coord.x+coord.y)*0.5;\n' + 545 '}\n' + 546 'void main (void)\n' + 547 '{\n' + 548 ' o_color = u_color;\n' + 549 ' myfunc(v_coord);\n' + 550 '}\n' 551 ) 552 ]; 553 554 var testGroup = tcuTestCase.runner.testCases; 555 556 // .write 557 /** @type {tcuTestCase.DeqpTest} */ var writeGroup = tcuTestCase.newTest('write', 'gl_FragDepth write tests'); 558 testGroup.addChild(writeGroup); 559 for (var ndx = 0; ndx < cases.length; ndx++) 560 writeGroup.addChild(new es3fFragDepthTests.FragDepthWriteCase(cases[ndx].name, cases[ndx].desc, cases[ndx].fragSrc, cases[ndx].evalFunc)); 561 562 // .compare 563 /** @type {tcuTestCase.DeqpTest} */ var compareGroup = tcuTestCase.newTest('compare', 'gl_FragDepth used with depth comparison'); 564 testGroup.addChild(compareGroup); 565 for (var ndx = 0; ndx < cases.length; ndx++) 566 compareGroup.addChild(new es3fFragDepthTests.FragDepthCompareCase(cases[ndx].name, cases[ndx].desc, cases[ndx].fragSrc, cases[ndx].evalFunc, gl.LESS)); 567 }; 568 569 /** 570 * Run test 571 * @param {WebGL2RenderingContext} context 572 */ 573 es3fFragDepthTests.run = function(context) { 574 gl = context; 575 //Set up Test Root parameters 576 var state = tcuTestCase.runner; 577 state.setRoot(new es3fFragDepthTests.FragDepthTests()); 578 579 //Set up name and description of this test series. 580 setCurrentTestName(state.testCases.fullName()); 581 description(state.testCases.getDescription()); 582 583 try { 584 //Run test cases 585 tcuTestCase.runTestCases(); 586 } 587 catch (err) { 588 testFailedOptions('Failed to es3fFragDepthTests.run tests', false); 589 tcuTestCase.runner.terminate(); 590 } 591 }; 592 593 });