diff options
Diffstat (limited to 'dom/canvas/test/webgl-conf/checkout/conformance/extensions/oes-standard-derivatives.html')
-rw-r--r-- | dom/canvas/test/webgl-conf/checkout/conformance/extensions/oes-standard-derivatives.html | 444 |
1 files changed, 444 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/extensions/oes-standard-derivatives.html b/dom/canvas/test/webgl-conf/checkout/conformance/extensions/oes-standard-derivatives.html new file mode 100644 index 0000000000..f6f4de0243 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/extensions/oes-standard-derivatives.html @@ -0,0 +1,444 @@ +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> + +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<title>WebGL OES_standard_derivatives Conformance Tests</title> +<link rel="stylesheet" href="../../resources/js-test-style.css"/> +<script src="../../js/js-test-pre.js"></script> +<script src="../../js/webgl-test-utils.js"></script> +</head> +<body> +<div id="description"></div> +<canvas id="canvas" style="width: 50px; height: 50px;"> </canvas> +<div id="console"></div> +<!-- Shaders for testing standard derivatives --> + +<!-- Shader omitting the required #extension pragma --> +<script id="missingPragmaFragmentShader" type="x-shader/x-fragment"> +precision mediump float; +varying vec2 texCoord; +void main() { + float dx = dFdx(texCoord.x); + float dy = dFdy(texCoord.y); + float w = fwidth(texCoord.x); + gl_FragColor = vec4(dx, dy, w, 1.0); +} +</script> + +<!-- Shader to test macro definition --> +<script id="macroFragmentShader" type="x-shader/x-fragment"> +precision mediump float; +void main() { +#ifdef GL_OES_standard_derivatives + gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0); +#else + // Error expected + #error no GL_OES_standard_derivatives; +#endif +} +</script> + +<!-- Shader with required #extension pragma --> +<script id="testFragmentShader" type="x-shader/x-fragment"> +#extension GL_OES_standard_derivatives : enable +precision mediump float; +varying vec2 texCoord; +void main() { + float dx = dFdx(texCoord.x); + float dy = dFdy(texCoord.y); + float w = fwidth(texCoord.x); + gl_FragColor = vec4(dx, dy, w, 1.0); +} +</script> +<!-- Shader with #extension after other code --> +<script id="testFragmentShaderWithExtensionNotAtTop" type="x-shader/x-fragment"> +precision mediump float; +varying vec2 texCoord; +void main() { +#extension GL_OES_standard_derivatives : enable + float dx = dFdx(texCoord.x); + float dy = dFdy(texCoord.y); + float w = fwidth(texCoord.x); + gl_FragColor = vec4(dx, dy, w, 1.0); +} +</script> +<!-- Shaders to link with test fragment shaders --> +<script id="goodVertexShader" type="x-shader/x-vertex"> +attribute vec4 vPosition; +varying vec2 texCoord; +void main() { + texCoord = vPosition.xy; + gl_Position = vPosition; +} +</script> +<!-- Shaders to test output --> +<script id="outputVertexShader" type="x-shader/x-vertex"> +attribute vec4 vPosition; +varying vec4 position; +void main() { + position = vPosition; + gl_Position = vPosition; +} +</script> +<script id="outputFragmentShader" type="x-shader/x-fragment"> +#extension GL_OES_standard_derivatives : enable +precision mediump float; +varying vec4 position; +void main() { + float dzdx = dFdx(position.z); + float dzdy = dFdy(position.z); + float fw = fwidth(position.z); + gl_FragColor = vec4(abs(dzdx) * 40.0, abs(dzdy) * 40.0, fw * 40.0, 1.0); +} +</script> + +<script> +"use strict"; +description("This test verifies the functionality of the OES_standard_derivatives extension, if it is available."); + +debug(""); + +var wtu = WebGLTestUtils; +var canvas = document.getElementById("canvas"); +var gl = wtu.create3DContext(canvas); +var ext = null; + +// Run all tests once. +runAllTests(); + +// Run all tests against with a new context to test for any cache issues. +debug(""); +debug("Testing new context to catch cache errors"); +gl = wtu.create3DContext(); +ext = null; +runAllTests(); + +function runAllTests() { + if (!gl) { + testFailed("WebGL context does not exist"); + } else { + testPassed("WebGL context exists"); + + // Run tests with extension disabled + runHintTestDisabled(); + runShaderTests(false); + + // Query the extension and store globally so shouldBe can access it + ext = gl.getExtension("OES_standard_derivatives"); + if (!ext) { + testPassed("No OES_standard_derivatives support -- this is legal"); + + runSupportedTest(false); + } else { + testPassed("Successfully enabled OES_standard_derivatives extension"); + + runSupportedTest(true); + + runHintTestEnabled(); + runShaderTests(true); + runOutputTests(); + runUniqueObjectTest(); + + // Run deferred link tests. + runDeferredLinkTests(); + } + } + +} + +function runSupportedTest(extensionEnabled) { + var supported = gl.getSupportedExtensions(); + if (supported.indexOf("OES_standard_derivatives") >= 0) { + if (extensionEnabled) { + testPassed("OES_standard_derivatives listed as supported and getExtension succeeded"); + } else { + testFailed("OES_standard_derivatives listed as supported but getExtension failed"); + } + } else { + if (extensionEnabled) { + testFailed("OES_standard_derivatives not listed as supported but getExtension succeeded"); + } else { + testPassed("OES_standard_derivatives not listed as supported and getExtension failed -- this is legal"); + } + } +} + +function runHintTestDisabled() { + debug("Testing FRAGMENT_SHADER_DERIVATIVE_HINT_OES with extension disabled"); + + // Use the constant directly as we don't have the extension + var FRAGMENT_SHADER_DERIVATIVE_HINT_OES = 0x8B8B; + + gl.getParameter(FRAGMENT_SHADER_DERIVATIVE_HINT_OES); + wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "FRAGMENT_SHADER_DERIVATIVE_HINT_OES should not be queryable if extension is disabled"); + + gl.hint(FRAGMENT_SHADER_DERIVATIVE_HINT_OES, gl.DONT_CARE); + wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "hint should not accept FRAGMENT_SHADER_DERIVATIVE_HINT_OES if extension is disabled"); +} + +function runHintTestEnabled() { + debug("Testing FRAGMENT_SHADER_DERIVATIVE_HINT_OES with extension enabled"); + + shouldBe("ext.FRAGMENT_SHADER_DERIVATIVE_HINT_OES", "0x8B8B"); + + gl.getParameter(ext.FRAGMENT_SHADER_DERIVATIVE_HINT_OES); + wtu.glErrorShouldBe(gl, gl.NO_ERROR, "FRAGMENT_SHADER_DERIVATIVE_HINT_OES query should succeed if extension is enabled"); + + // Default value is DONT_CARE + if (gl.getParameter(ext.FRAGMENT_SHADER_DERIVATIVE_HINT_OES) == gl.DONT_CARE) { + testPassed("Default value of FRAGMENT_SHADER_DERIVATIVE_HINT_OES is DONT_CARE"); + } else { + testFailed("Default value of FRAGMENT_SHADER_DERIVATIVE_HINT_OES is not DONT_CARE"); + } + + // Ensure that we can set the target + gl.hint(ext.FRAGMENT_SHADER_DERIVATIVE_HINT_OES, gl.DONT_CARE); + wtu.glErrorShouldBe(gl, gl.NO_ERROR, "hint should accept FRAGMENT_SHADER_DERIVATIVE_HINT_OES"); + + // Test all the hint modes + var validModes = ["FASTEST", "NICEST", "DONT_CARE"]; + var anyFailed = false; + for (var n = 0; n < validModes.length; n++) { + var mode = validModes[n]; + gl.hint(ext.FRAGMENT_SHADER_DERIVATIVE_HINT_OES, gl[mode]); + if (gl.getParameter(ext.FRAGMENT_SHADER_DERIVATIVE_HINT_OES) != gl[mode]) { + testFailed("Round-trip of hint()/getParameter() failed on mode " + mode); + anyFailed = true; + } + } + if (!anyFailed) { + testPassed("Round-trip of hint()/getParameter() with all supported modes"); + } +} + +function runShaderTests(extensionEnabled) { + debug(""); + debug("Testing various shader compiles with extension " + (extensionEnabled ? "enabled" : "disabled")); + + // Expect the macro shader to succeed ONLY if enabled + { + const macroFragmentProgram = wtu.loadProgramFromScriptExpectError(gl, "goodVertexShader", "macroFragmentShader"); + if (extensionEnabled) { + if (macroFragmentProgram) { + // Expected result + testPassed("GL_OES_standard_derivatives defined in shaders when extension is enabled"); + } else { + testFailed("GL_OES_standard_derivatives not defined in shaders when extension is enabled"); + } + } else { + if (macroFragmentProgram) { + testFailed("GL_OES_standard_derivatives defined in shaders when extension is disabled"); + } else { + testPassed("GL_OES_standard_derivatives not defined in shaders when extension disabled"); + } + } + } + + // Always expect the shader missing the #pragma to fail (whether enabled or not) + { + const missingPragmaFragmentProgram = wtu.loadProgramFromScriptExpectError(gl, "goodVertexShader", "missingPragmaFragmentShader"); + if (missingPragmaFragmentProgram) { + testFailed("Shader built-ins allowed without #extension pragma"); + } else { + testPassed("Shader built-ins disallowed without #extension pragma"); + } + } + + // Try to compile a shader using the built-ins that should only succeed if enabled + { + const testFragmentProgram = wtu.loadProgramFromScriptExpectError(gl, "goodVertexShader", "testFragmentShader"); + if (extensionEnabled) { + if (testFragmentProgram) { + testPassed("Shader built-ins compiled successfully when extension enabled"); + } else { + testFailed("Shader built-ins failed to compile when extension enabled"); + } + } else { + if (testFragmentProgram) { + testFailed("Shader built-ins compiled successfully when extension disabled"); + } else { + testPassed("Shader built-ins failed to compile when extension disabled"); + } + } + } + + // This tests specifically that #extension directives after other code are + // valid, per spec (6.35 GLSL ES #extension directive location). + // + // This test actually has nothing to do with OES_standard_derivatives, but + // is inserted here because this extension is ubiquitous. + // + // This test is not as strict as the spec - it doesn't require that "the + // scope ... is always the whole shader", because implementations (ANGLE + // shader translator) do not actually implement this correctly. The test + // coverage is intentionally left incomplete - in practice, all WebGL + // shaders already work with the current implementation, so there's no + // practical reason to update them to match the spec. Conversely, the + // currently implemented rules are too complex to formalize in spec. + // + // Regression test for https://crbug.com/971660 . + { + const testFragmentProgramWithExtensionNotAtTop = wtu.loadProgramFromScriptExpectError(gl, "goodVertexShader", "testFragmentShaderWithExtensionNotAtTop"); + if (extensionEnabled) { + if (testFragmentProgramWithExtensionNotAtTop) { + testPassed("Shader with #extension after non-preprocessor code: compiled successfully when extension enabled"); + } else { + testFailed("Shader with #extension after non-preprocessor code: failed to compile when extension enabled"); + } + } + } +} + +function runOutputTests() { + // This tests does several draws with various values of z. + // The output of the fragment shader is: + // [dFdx(z), dFdy(z), fwidth(z), 1.0] + // The expected math: (note the conversion to uint8) + // canvas.width = canvas.height = 50 + // dFdx = totalChange.x / canvas.width = 0.5 / 50.0 = 0.01 + // dFdy = totalChange.y / canvas.height = 0.5 / 50.0 = 0.01 + // fw = abs(dFdx + dFdy) = 0.01 + 0.01 = 0.02 + // r = floor(dFdx * 40.0 * 255) = 102 + // g = floor(dFdy * 40.0 * 255) = 102 + // b = floor(fw * 40.0 * 255) = 204 + + var e = 5; // Amount of variance to allow in result pixels - may need to be tweaked higher + + debug("Testing various draws for valid built-in function behavior"); + + canvas.width = 50; canvas.height = 50; + gl.viewport(0, 0, canvas.width, canvas.height); + gl.hint(ext.FRAGMENT_SHADER_DERIVATIVE_HINT_OES, gl.NICEST); + + var positionLoc = 0; + var texcoordLoc = 1; + var program = wtu.setupProgram(gl, ["outputVertexShader", "outputFragmentShader"], ['vPosition', 'texCoord0'], [0, 1]); + var quadParameters = wtu.setupUnitQuad(gl, positionLoc, texcoordLoc); + + function expectResult(target, message) { + var locations = [ + [ 0.1, 0.1 ], + [ 0.9, 0.1 ], + [ 0.1, 0.9 ], + [ 0.9, 0.9 ], + [ 0.5, 0.5 ] + ]; + for (var n = 0; n < locations.length; n++) { + var loc = locations[n]; + var px = Math.floor(loc[0] * canvas.width); + var py = Math.floor(loc[1] * canvas.height); + wtu.checkCanvasRect(gl, px, py, 1, 1, target, message, 4); + } + }; + + function setupBuffers(tl, tr, bl, br) { + gl.bindBuffer(gl.ARRAY_BUFFER, quadParameters[0]); + gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([ + 1.0, 1.0, tr, + -1.0, 1.0, tl, + -1.0, -1.0, bl, + 1.0, 1.0, tr, + -1.0, -1.0, bl, + 1.0, -1.0, br]), gl.STATIC_DRAW); + gl.vertexAttribPointer(positionLoc, 3, gl.FLOAT, false, 0, 0); + }; + + // Draw 1: (no variation) + setupBuffers(0.0, 0.0, 0.0, 0.0); + wtu.clearAndDrawUnitQuad(gl); + expectResult([0, 0, 0, 255], + "Draw 1 (no variation) should pass"); + + // Draw 2: (variation in x) + setupBuffers(1.0, 0.0, 1.0, 0.0); + wtu.clearAndDrawUnitQuad(gl); + expectResult([204, 0, 204, 255], + "Draw 2 (variation in x) should pass"); + + // Draw 3: (variation in y) + setupBuffers(1.0, 1.0, 0.0, 0.0); + wtu.clearAndDrawUnitQuad(gl); + expectResult([0, 204, 204, 255], + "Draw 3 (variation in y) should pass"); + + // Draw 4: (variation in x & y) + setupBuffers(1.0, 0.5, 0.5, 0.0); + wtu.clearAndDrawUnitQuad(gl); + expectResult([102, 102, 204, 255], + "Draw 4 (variation in x & y) should pass"); +} + +function runUniqueObjectTest() +{ + debug("Testing that getExtension() returns the same object each time"); + ext = null; + gl.getExtension("OES_standard_derivatives").myProperty = 2; + webglHarnessCollectGarbage(); + shouldBe('gl.getExtension("OES_standard_derivatives").myProperty', '2'); +} + +function runDeferredLinkTests() { + debug(""); + debug("Testing deferred shader compilation tests."); + + // Test for compilation failures that are caused by missing extensions + // do not succeed if extensions are enabled during linking. This would + // only happen for deferred shader compilations. + + // First test if link succeeds with extension enabled. + var glEnabled = wtu.create3DContext(); + var extEnabled = glEnabled.getExtension("OES_standard_derivatives"); + if (!extEnabled) { + testFailed("Deferred link test expects the extension to be supported"); + } + + var vertexShader = wtu.loadShaderFromScript(glEnabled, "goodVertexShader"); + var fragmentShader = wtu.loadShaderFromScript(glEnabled, "macroFragmentShader"); + + if (!vertexShader || !fragmentShader) { + testFailed("Could not create good shaders."); + return; + } + + var program = wtu.setupProgram(glEnabled, [vertexShader, fragmentShader]); + + if (!program) { + testFailed("Compilation with extension enabled failed."); + return; + } + + // Create new context to test link failure without extension enabled. + var glDeferred = wtu.create3DContext(); + + var vertexShader = wtu.loadShaderFromScript(glDeferred, "goodVertexShader", glDeferred.VERTEX_SHADER, undefined, undefined, true); + var fragmentShader = wtu.loadShaderFromScript(glDeferred, "macroFragmentShader", glDeferred.FRAGMENT_SHADER, undefined, undefined, true); + + if (vertexShader == null || fragmentShader == null) { + testFailed("Could not create shaders."); + return; + } + + // Shader compilations should have failed due to extensions not enabled. + glDeferred.getExtension("OES_standard_derivatives"); + var program = wtu.setupProgram(glDeferred, [vertexShader, fragmentShader]); + if (program) { + testFailed("Compilation with extension disabled then linking with extension enabled should have failed."); + return; + } + + testPassed("Compilation with extension disabled then linking with extension enabled."); +} + +debug(""); +var successfullyParsed = true; +</script> +<script src="../../js/js-test-post.js"></script> + +</body> +</html> |