ext-shader-texture-lod.html (11682B)
1 <!-- 2 Copyright (c) 2019 The Khronos Group Inc. 3 Use of this source code is governed by an MIT-style license that can be 4 found in the LICENSE.txt file. 5 --> 6 <!DOCTYPE html> 7 <html> 8 <head> 9 <meta charset="utf-8"> 10 <title>WebGL EXT_shader_texture_lod Conformance Tests</title> 11 <link rel="stylesheet" href="../../resources/js-test-style.css"/> 12 <script src="../../js/desktop-gl-constants.js"></script> 13 <script src="../../js/js-test-pre.js"></script> 14 <script src="../../js/webgl-test-utils.js"></script> 15 </head> 16 <body> 17 <div id="description"></div> 18 <canvas id="canvas" style="width: 256px; height: 256px;"> </canvas> 19 <canvas id="canvas2" style="width: 256px; height: 256px;"> </canvas> 20 <div id="console"></div> 21 <!-- Shaders for testing texture LOD functions --> 22 23 <!-- Shader omitting the required #extension pragma --> 24 <script id="missingPragmaFragmentShader" type="x-shader/x-fragment"> 25 precision mediump float; 26 varying vec2 texCoord0v; 27 uniform float lod; 28 uniform sampler2D tex; 29 void main() { 30 vec4 color = texture2DLodEXT(tex, texCoord0v, lod); 31 gl_FragColor = color; 32 } 33 </script> 34 35 <!-- Shader to test macro definition --> 36 <script id="macroFragmentShader" type="x-shader/x-fragment"> 37 precision mediump float; 38 void main() { 39 #ifdef GL_EXT_shader_texture_lod 40 gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0); 41 #else 42 // Error expected 43 #error no GL_EXT_shader_texture_lod; 44 #endif 45 } 46 </script> 47 48 <!-- Shader with required #extension pragma --> 49 <script id="testFragmentShader" type="x-shader/x-fragment"> 50 #extension GL_EXT_shader_texture_lod : enable 51 precision mediump float; 52 varying vec2 texCoord0v; 53 uniform float lod; 54 uniform sampler2D tex; 55 void main() { 56 vec4 color = texture2DLodEXT(tex, texCoord0v, lod); 57 gl_FragColor = color; 58 } 59 </script> 60 61 <!-- Shaders to link with test fragment shaders --> 62 <script id="goodVertexShader" type="x-shader/x-vertex"> 63 attribute vec4 vPosition; 64 attribute vec2 texCoord0; 65 varying vec2 texCoord0v; 66 void main() { 67 texCoord0v = texCoord0; 68 gl_Position = vPosition; 69 } 70 </script> 71 72 <!-- Shaders to test output --> 73 <script id="outputVertexShader" type="x-shader/x-vertex"> 74 attribute vec4 vPosition; 75 attribute vec2 texCoord0; 76 varying vec2 texCoord0v; 77 void main() { 78 texCoord0v = texCoord0; 79 gl_Position = vPosition; 80 } 81 </script> 82 <script id="outputFragmentShader" type="x-shader/x-fragment"> 83 #extension GL_EXT_shader_texture_lod : require 84 precision mediump float; 85 varying vec2 texCoord0v; 86 uniform float lod; 87 uniform sampler2D tex; 88 void main() { 89 vec4 color = texture2DLodEXT(tex, texCoord0v, lod); 90 gl_FragColor = color; 91 } 92 </script> 93 94 <script> 95 description("This test verifies the functionality of the EXT_shader_texture_lod extension, if it is available."); 96 97 debug(""); 98 99 var wtu = WebGLTestUtils; 100 var canvas = document.getElementById("canvas"); 101 var gl = wtu.create3DContext(canvas); 102 var ext = null; 103 104 // Run all tests once. 105 runAllTests(); 106 107 // Run all tests against with a new context to test for any cache issues. 108 debug(""); 109 debug("Testing new context to catch cache errors"); 110 var canvas2 = document.getElementById("canvas2"); 111 gl = wtu.create3DContext(canvas2); 112 ext = null; 113 runAllTests(); 114 115 function runAllTests() { 116 if (!gl) { 117 testFailed("WebGL context does not exist"); 118 } else { 119 testPassed("WebGL context exists"); 120 121 // Run tests with extension disabled 122 runShaderTests(false); 123 124 // Query the extension and store globally so shouldBe can access it 125 ext = gl.getExtension("EXT_shader_texture_lod"); 126 if (!ext) { 127 testPassed("No EXT_shader_texture_lod support -- this is legal"); 128 129 runSupportedTest(false); 130 } else { 131 testPassed("Successfully enabled EXT_shader_texture_lod extension"); 132 133 runSupportedTest(true); 134 135 runShaderTests(true); 136 runOutputTests(); 137 runUniqueObjectTest(); 138 runReferenceCycleTest(); 139 140 // Run deferred link tests. 141 runDeferredLinkTests(); 142 } 143 } 144 145 } 146 147 function runSupportedTest(extensionEnabled) { 148 var supported = gl.getSupportedExtensions(); 149 if (supported.indexOf("EXT_shader_texture_lod") >= 0) { 150 if (extensionEnabled) { 151 testPassed("EXT_shader_texture_lod listed as supported and getExtension succeeded"); 152 } else { 153 testFailed("EXT_shader_texture_lod listed as supported but getExtension failed"); 154 } 155 } else { 156 if (extensionEnabled) { 157 testFailed("EXT_shader_texture_lod not listed as supported but getExtension succeeded"); 158 } else { 159 testPassed("EXT_shader_texture_lod not listed as supported and getExtension failed -- this is legal"); 160 } 161 } 162 } 163 164 function runShaderTests(extensionEnabled) { 165 debug(""); 166 debug("Testing various shader compiles with extension " + (extensionEnabled ? "enabled" : "disabled")); 167 168 // Expect the macro shader to succeed ONLY if enabled 169 var macroFragmentProgram = wtu.loadProgramFromScriptExpectError(gl, "goodVertexShader", "macroFragmentShader"); 170 if (extensionEnabled) { 171 if (macroFragmentProgram) { 172 // Expected result 173 testPassed("GL_EXT_shader_texture_lod defined in shaders when extension is enabled"); 174 } else { 175 testFailed("GL_EXT_shader_texture_lod not defined in shaders when extension is enabled"); 176 } 177 } else { 178 if (macroFragmentProgram) { 179 testFailed("GL_EXT_shader_texture_lod defined in shaders when extension is disabled"); 180 } else { 181 testPassed("GL_EXT_shader_texture_lod not defined in shaders when extension disabled"); 182 } 183 } 184 185 // Always expect the shader missing the #pragma to fail (whether enabled or not) 186 var missingPragmaFragmentProgram = wtu.loadProgramFromScriptExpectError(gl, "goodVertexShader", "missingPragmaFragmentShader"); 187 if (missingPragmaFragmentProgram) { 188 testFailed("Shader built-ins allowed without #extension pragma"); 189 } else { 190 testPassed("Shader built-ins disallowed without #extension pragma"); 191 } 192 193 // Try to compile a shader using the built-ins that should only succeed if enabled 194 var testFragmentProgram = wtu.loadProgramFromScriptExpectError(gl, "goodVertexShader", "testFragmentShader"); 195 if (extensionEnabled) { 196 if (testFragmentProgram) { 197 testPassed("Shader built-ins compiled successfully when extension enabled"); 198 } else { 199 testFailed("Shader built-ins failed to compile when extension enabled"); 200 } 201 } else { 202 if (testFragmentProgram) { 203 testFailed("Shader built-ins compiled successfully when extension disabled"); 204 } else { 205 testPassed("Shader built-ins failed to compile when extension disabled"); 206 } 207 } 208 } 209 210 function runOutputTests() { 211 debug(""); 212 debug("Testing various draws for valid built-in function behavior"); 213 gl.viewport(0, 0, canvas.width, canvas.height); 214 215 var program = wtu.setupProgram(gl, ["outputVertexShader", "outputFragmentShader"], ['vPosition', 'texCoord0'], [0, 1]); 216 var quadParameters = wtu.setupUnitQuad(gl, 0, 1); 217 218 var colors = [ 219 {name: 'red', color:[255, 0, 0, 255]}, 220 {name: 'green', color:[0, 255, 0, 255]}, 221 {name: 'blue', color:[0, 0, 255, 255]}, 222 {name: 'yellow', color:[255, 255, 0, 255]}, 223 {name: 'magenta', color:[255, 0, 255, 255]}, 224 {name: 'cyan', color:[0, 255, 255, 255]}, 225 {name: 'pink', color:[255, 128, 128, 255]}, 226 {name: 'gray', color:[128, 128, 128, 255]}, 227 {name: 'light green', color:[128, 255, 128, 255]}, 228 ]; 229 230 var tex = gl.createTexture(); 231 gl.bindTexture(gl.TEXTURE_2D, tex); 232 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST_MIPMAP_LINEAR); 233 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); 234 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT); 235 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT); 236 237 for (var ii = 0; ii < colors.length; ++ii) { 238 var color = colors[ii]; 239 var size = Math.pow(2, colors.length - ii - 1); 240 wtu.fillTexture(gl, tex, size, size, color.color, ii); 241 } 242 243 var loc = gl.getUniformLocation(program, "lod"); 244 245 for (var ii = 0; ii < colors.length; ++ii) { 246 gl.uniform1f(loc, ii); 247 var color = colors[ii]; 248 wtu.drawUnitQuad(gl); 249 wtu.checkCanvas( 250 gl, color.color, 251 "256x256 texture drawn to 256x256 dest with lod = " + ii + 252 " should be " + color.name); 253 } 254 255 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 256 } 257 258 function runUniqueObjectTest() 259 { 260 debug(""); 261 debug("Testing that getExtension() returns the same object each time"); 262 ext = null; 263 gl.getExtension("EXT_shader_texture_lod").myProperty = 2; 264 webglHarnessCollectGarbage(); 265 shouldBe('gl.getExtension("EXT_shader_texture_lod").myProperty', '2'); 266 } 267 268 function runReferenceCycleTest() 269 { 270 // create some reference cycles. The goal is to see if they cause leaks. The point is that 271 // some browser test runners have instrumentation to detect leaked refcounted objects. 272 debug(""); 273 debug("Testing reference cycles between context and extension objects"); 274 var ext = gl.getExtension("EXT_shader_texture_lod"); 275 276 // create cycle between extension and context, since the context has to hold a reference to the extension 277 ext.context = gl; 278 279 // create a self-cycle on the extension object 280 ext.ext = ext; 281 } 282 283 function runDeferredLinkTests() { 284 debug(""); 285 debug("Testing deferred shader compilation tests."); 286 287 // Test for compilation failures that are caused by missing extensions 288 // do not succeed if extensions are enabled during linking. This would 289 // only happen for deferred shader compilations. 290 291 // First test if link succeeds with extension enabled. 292 var glEnabled = wtu.create3DContext(); 293 var extEnabled = glEnabled.getExtension("EXT_shader_texture_lod"); 294 if (!extEnabled) { 295 testFailed("Deferred link test expects the extension to be supported"); 296 } 297 298 var vertexShader = wtu.loadShaderFromScript(glEnabled, "goodVertexShader"); 299 var fragmentShader = wtu.loadShaderFromScript(glEnabled, "macroFragmentShader"); 300 301 if (!vertexShader || !fragmentShader) { 302 testFailed("Could not create good shaders."); 303 return; 304 } 305 306 var program = wtu.setupProgram(glEnabled, [vertexShader, fragmentShader]); 307 308 if (!program) { 309 testFailed("Compilation with extension enabled failed."); 310 return; 311 } 312 313 // Create new context to test link failure without extension enabled. 314 var glDeferred = wtu.create3DContext(); 315 316 var vertexShader = wtu.loadShaderFromScript(glDeferred, "goodVertexShader", glDeferred.VERTEX_SHADER, undefined, undefined, true); 317 var fragmentShader = wtu.loadShaderFromScript(glDeferred, "macroFragmentShader", glDeferred.FRAGMENT_SHADER, undefined, undefined, true); 318 319 if (vertexShader == null || fragmentShader == null) { 320 testFailed("Could not create shaders."); 321 return; 322 } 323 324 // Shader compilations should have failed due to extensions not enabled. 325 glDeferred.getExtension("EXT_shader_texture_lod"); 326 var program = wtu.setupProgram(glDeferred, [vertexShader, fragmentShader]); 327 if (program) { 328 testFailed("Compilation with extension disabled then linking with extension enabled should have failed."); 329 return; 330 } 331 332 testPassed("Compilation with extension disabled then linking with extension enabled."); 333 } 334 335 debug(""); 336 successfullyParsed = true; 337 </script> 338 <script src="../../js/js-test-post.js"></script> 339 340 </body> 341 </html>