OLD | NEW |
(Empty) | |
| 1 <!-- |
| 2 |
| 3 /* |
| 4 ** Copyright (c) 2013 The Khronos Group Inc. |
| 5 ** |
| 6 ** Permission is hereby granted, free of charge, to any person obtaining a |
| 7 ** copy of this software and/or associated documentation files (the |
| 8 ** "Materials"), to deal in the Materials without restriction, including |
| 9 ** without limitation the rights to use, copy, modify, merge, publish, |
| 10 ** distribute, sublicense, and/or sell copies of the Materials, and to |
| 11 ** permit persons to whom the Materials are furnished to do so, subject to |
| 12 ** the following conditions: |
| 13 ** |
| 14 ** The above copyright notice and this permission notice shall be included |
| 15 ** in all copies or substantial portions of the Materials. |
| 16 ** |
| 17 ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| 18 ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| 19 ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
| 20 ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY |
| 21 ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
| 22 ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
| 23 ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. |
| 24 */ |
| 25 |
| 26 --> |
| 27 |
| 28 <!DOCTYPE html> |
| 29 <html> |
| 30 <head> |
| 31 <meta charset="utf-8"> |
| 32 <title>WebGL WEBGL_Shared_Resources Conformance Test</title> |
| 33 <link rel="stylesheet" href="../../resources/js-test-style.css"/> |
| 34 <script src="../../resources/desktop-gl-constants.js" type="text/javascript"></s
cript> |
| 35 <script src="../../resources/js-test-pre.js"></script> |
| 36 <script src="../resources/webgl-test.js"></script> |
| 37 <script src="../resources/webgl-test-utils.js"></script> |
| 38 </head> |
| 39 <body> |
| 40 <script id="vshader" type="x-shader/x-vertex"> |
| 41 attribute vec4 a_position; |
| 42 void main() { |
| 43 gl_Position = a_position; |
| 44 } |
| 45 </script> |
| 46 <script id="fshader" type="x-shader/x-fragment"> |
| 47 precision mediump float; |
| 48 uniform vec4 u_color; |
| 49 void main() { |
| 50 gl_FragColor = u_color; |
| 51 } |
| 52 </script> |
| 53 <style> |
| 54 canvas { |
| 55 border: 1px solid black; |
| 56 } |
| 57 </style> |
| 58 <canvas id="canvas1" width="64" height="64"> </canvas> |
| 59 <canvas id="canvas2" width="64" height="64"> </canvas> |
| 60 <div id="description"></div> |
| 61 <div id="console"></div> |
| 62 <script> |
| 63 "use strict"; |
| 64 description(); |
| 65 |
| 66 var wtu = WebGLTestUtils; |
| 67 var canvas1 = document.getElementById("canvas1"); |
| 68 var gl = wtu.create3DContext(canvas1); |
| 69 var gl2; |
| 70 var ext = null; |
| 71 var ext2; |
| 72 var ext3; |
| 73 var buf; |
| 74 var elementBuf; |
| 75 var tex; |
| 76 var tex3; |
| 77 var rb; |
| 78 var fb; |
| 79 var id; |
| 80 var resource; |
| 81 var shader; |
| 82 var program; |
| 83 var uniformLocation; |
| 84 var acquiredFlag; |
| 85 var shaderProgram; // acquired progam (never released) used for shader testing |
| 86 var programShader; // acquired shader (never released) used for program testing |
| 87 |
| 88 if (!gl) { |
| 89 testFailed("context does not exist"); |
| 90 } else { |
| 91 testPassed("context exists"); |
| 92 |
| 93 // Run tests with extension disabled |
| 94 runTestDisabled(); |
| 95 |
| 96 // Query the extension and store globally so shouldBe can access it |
| 97 ext = wtu.getExtensionWithKnownPrefixes(gl, "WEBGL_shared_resources"); |
| 98 if (!ext) { |
| 99 testPassed("No WEBGL_shared_resources support -- this is legal"); |
| 100 runSupportedTest(false); |
| 101 finishTest(); |
| 102 } else { |
| 103 testPassed("Successfully enabled WEBGL_shared_resources extension"); |
| 104 |
| 105 runSupportedTest(true); |
| 106 runTestExtension(); |
| 107 } |
| 108 } |
| 109 |
| 110 function runSupportedTest(extensionEnabled) { |
| 111 var name = wtu.getSupportedExtensionWithKnownPrefixes(gl, "WEBGL_shared_reso
urces"); |
| 112 if (name !== undefined) { |
| 113 if (extensionEnabled) { |
| 114 testPassed("WEBGL_shared_resources listed as supported and getExtens
ion succeeded"); |
| 115 } else { |
| 116 testFailed("WEBGL_shared_resources listed as supported but getExtens
ion failed"); |
| 117 } |
| 118 } else { |
| 119 if (extensionEnabled) { |
| 120 testFailed("WEBGL_shared_resources not listed as supported but getEx
tension succeeded"); |
| 121 } else { |
| 122 testPassed("WEBGL_shared_resources not listed as supported and getEx
tension failed -- this is legal"); |
| 123 } |
| 124 } |
| 125 } |
| 126 |
| 127 function runTestDisabled() { |
| 128 // There is no functionality accessable with this extension disabled. |
| 129 } |
| 130 |
| 131 function makeFailCallback(msg) { |
| 132 return function() { |
| 133 testFailed(msg); |
| 134 } |
| 135 }; |
| 136 |
| 137 |
| 138 function runTestExtension() { |
| 139 var canvas2 = document.getElementById("canvas2"); |
| 140 gl2 = wtu.create3DContext(canvas2, { group: ext.group }); |
| 141 ext2 = wtu.getExtensionWithKnownPrefixes(gl2, "WEBGL_shared_resources"); |
| 142 |
| 143 // Runs an array of functions. Expects each function takes a callback |
| 144 // it will call when finished. |
| 145 var runSequence = function(steps) { |
| 146 var stepNdx = 0; |
| 147 var runNextStep = function() { |
| 148 if (stepNdx < steps.length) { |
| 149 steps[stepNdx++](runNextStep); |
| 150 } |
| 151 }; |
| 152 runNextStep(); |
| 153 }; |
| 154 |
| 155 var bufferTests = { |
| 156 resourceType: "buffer", |
| 157 |
| 158 setupFunction: function() { |
| 159 buf = gl.createBuffer(); |
| 160 gl.bindBuffer(gl.ARRAY_BUFFER, buf); |
| 161 gl.bufferData(gl.ARRAY_BUFFER, 16, gl.STATIC_DRAW); |
| 162 return buf; |
| 163 }, |
| 164 |
| 165 bindFunction: function(buf) { |
| 166 gl.bindBuffer(gl.ARRAY_BUFFER, buf); |
| 167 }, |
| 168 |
| 169 implicitBindFunctions: function(expectedError) { |
| 170 shouldGenerateGLError(gl, expectedError, "gl.vertexAttribPointer(0, 4, gl.
FLOAT, false, 0, 0)"); |
| 171 }, |
| 172 |
| 173 modificationFunctions: function(expectedError) { |
| 174 shouldGenerateGLError(gl, expectedError, "gl.bufferData(gl.ARRAY_BUFFER, 1
6, gl.STATIC_DRAW)"); |
| 175 shouldGenerateGLError(gl, expectedError, "gl.bufferSubData(gl.ARRAY_BUFFER
, 0, new Uint8Array(4))"); |
| 176 }, |
| 177 |
| 178 queryFunctions: function(expectedError) { |
| 179 shouldGenerateGLError(gl, expectedError, "gl.getBufferParameter(gl.ARRAY_B
UFFER, gl.BUFFER_SIZE)"); |
| 180 }, |
| 181 }; |
| 182 |
| 183 var programTests = { |
| 184 resourceType: "program", |
| 185 |
| 186 setupFunction: function() { |
| 187 // We need a valid a program with valid shaders to share because the only
way to 'bind' |
| 188 // a program is to call gl.useProgram and you can't call gl.useProgram on
an invalid program. |
| 189 program = wtu.setupProgram(gl, ["vshader", "fshader"]); |
| 190 programShader = gl.getAttachedShaders(program)[0]; |
| 191 uniformLocation = gl.getUniformLocation(program, "u_color"); |
| 192 return program; |
| 193 }, |
| 194 |
| 195 bindFunction: function(program) { |
| 196 gl.useProgram(program); |
| 197 }, |
| 198 |
| 199 implicitBindFunctions: function(expectedError) { |
| 200 }, |
| 201 |
| 202 modificationFunctions: function(expectedError) { |
| 203 if (expectedError == gl.NO_ERROR) { |
| 204 // Need to get a new location because we may have re-linked. |
| 205 uniformLocation = gl.getUniformLocation(program, 'u_color'); |
| 206 } |
| 207 shouldGenerateGLError(gl, expectedError, "gl.uniform4f(uniformLocation, 0,
1, 2, 3)"); |
| 208 shouldGenerateGLError(gl, expectedError, "gl.detachShader(program, program
Shader)"); |
| 209 shouldGenerateGLError(gl, expectedError, "gl.attachShader(program, program
Shader)"); |
| 210 shouldGenerateGLError(gl, expectedError, "gl.bindAttribLocation(program, 0
, 'foo')"); |
| 211 shouldGenerateGLError(gl, expectedError, "gl.linkProgram(program)"); |
| 212 }, |
| 213 |
| 214 queryFunctions: function(expectedError) { |
| 215 shouldGenerateGLError(gl, expectedError, "gl.getProgramParameter(program,
gl.LINK_STATUS)"); |
| 216 shouldGenerateGLError(gl, expectedError, "gl.getProgramInfoLog(program)"); |
| 217 shouldGenerateGLError(gl, expectedError, "gl.getAttachedShaders(program)")
; |
| 218 shouldGenerateGLError(gl, expectedError, "gl.getAttribLocation(program, 'f
oo')"); |
| 219 shouldGenerateGLError(gl, expectedError, "gl.getUniformLocation(program, '
foo')"); |
| 220 shouldGenerateGLError(gl, expectedError, "gl.getActiveAttrib(program, 0)")
; |
| 221 shouldGenerateGLError(gl, expectedError, "gl.getActiveUniform(program, 0)"
); |
| 222 shouldGenerateGLError(gl, expectedError, "gl.getUniform(program, uniformLo
cation)"); |
| 223 }, |
| 224 }; |
| 225 |
| 226 var renderbufferTests = { |
| 227 resourceType: "renderbuffer", |
| 228 |
| 229 setupFunction: function() { |
| 230 rb = gl.createRenderbuffer(); |
| 231 gl.bindRenderbuffer(gl.RENDERBUFFER, rb); |
| 232 gl.renderbufferStorage(gl.RENDERBUFFER, gl.RGBA4, 16, 16); |
| 233 fb = gl.createFramebuffer(); |
| 234 return rb; |
| 235 }, |
| 236 |
| 237 bindFunction: function(rb) { |
| 238 gl.bindRenderbuffer(gl.RENDERBUFFER, rb); |
| 239 }, |
| 240 |
| 241 implicitBindFunctions: function(expectedError) { |
| 242 gl.bindFramebuffer(gl.FRAMEBUFFER, fb); |
| 243 shouldGenerateGLError(gl, expectedError, "gl.framebufferRenderbuffer(gl.F
RAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, rb)"); |
| 244 gl.bindFramebuffer(gl.FRAMEBUFFER, null); |
| 245 }, |
| 246 |
| 247 modificationFunctions: function(expectedError) { |
| 248 shouldGenerateGLError(gl, expectedError, "gl.renderbufferStorage(gl.RENDER
BUFFER, gl.RGBA4, 16, 16)"); |
| 249 }, |
| 250 |
| 251 queryFunctions: function(expectedError) { |
| 252 shouldGenerateGLError(gl, expectedError, "gl.getRenderbufferParameter(gl.R
ENDERBUFFER, gl.RENDERBUFFER_WIDTH)"); |
| 253 }, |
| 254 }; |
| 255 |
| 256 |
| 257 var shaderTests = { |
| 258 resourceType: "shader", |
| 259 |
| 260 setupFunction: function() { |
| 261 var shaderSource = "Hello World"; |
| 262 shader = gl.createShader(gl.VERTEX_SHADER); |
| 263 gl.shaderSource(shader, shaderSource); |
| 264 shaderProgram = gl.createProgram(); |
| 265 gl.attachShader(shaderProgram, shader); |
| 266 return shader; |
| 267 }, |
| 268 |
| 269 bindFunction: function(shader) { |
| 270 gl.detachShader(shaderProgram, shader); // you can't attach if a shader i
s already attached. |
| 271 gl.attachShader(shaderProgram, shader); |
| 272 }, |
| 273 |
| 274 implicitBindFunctions: function(expectedError) { |
| 275 }, |
| 276 |
| 277 modificationFunctions: function(expectedError) { |
| 278 shouldGenerateGLError(gl, expectedError, "gl.shaderSource(shader, 'foo')")
; |
| 279 shouldGenerateGLError(gl, expectedError, "gl.compileShader(shader)"); |
| 280 }, |
| 281 |
| 282 queryFunctions: function(expectedError) { |
| 283 shouldGenerateGLError(gl, expectedError, "gl.getShaderParameter(shader, gl
.COMPILE_STATUS)"); |
| 284 shouldGenerateGLError(gl, expectedError, "gl.getShaderInfoLog(shader)"); |
| 285 }, |
| 286 }; |
| 287 |
| 288 var textureTests = { |
| 289 resourceType: "texture", |
| 290 |
| 291 setupFunction: function() { |
| 292 tex = gl.createTexture(); |
| 293 gl.bindTexture(gl.TEXTURE_2D, tex); |
| 294 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 16, 16, 0, gl.RGBA, gl.UNSIGNED_B
YTE, null); |
| 295 return tex; |
| 296 }, |
| 297 |
| 298 bindFunction: function(tex) { |
| 299 gl.bindTexture(gl.TEXTURE_2D, tex); |
| 300 }, |
| 301 |
| 302 implicitBindFunctions: function(expectedError) { |
| 303 }, |
| 304 |
| 305 modificationFunctions: function(expectedError) { |
| 306 shouldGenerateGLError(gl, expectedError, "gl.texParameteri(gl.TEXTURE_2D,
gl.TEXTURE_WRAP_S, gl.REPEAT)"); |
| 307 shouldGenerateGLError(gl, expectedError, "gl.generateMipmap(gl.TEXTURE_2D)
"); |
| 308 shouldGenerateGLError(gl, expectedError, "gl.texImage2D(gl.TEXTURE_2D, 0,
gl.RGBA, 16, 16, 0, gl.RGBA, gl.UNSIGNED_BYTE, null)"); |
| 309 shouldGenerateGLError(gl, expectedError, "gl.texSubImage2D(gl.TEXTURE_2D,
0, 0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array(4))"); |
| 310 shouldGenerateGLError(gl, expectedError, "gl.copyTexImage2D(gl.TEXTURE_2D,
0, gl.RGBA, 0, 0, 16, 16, 0)"); |
| 311 shouldGenerateGLError(gl, expectedError, "gl.copyTexSubImage2D(gl.TEXTURE_
2D, 0, 0, 0, 0, 0, 16, 16)"); |
| 312 // TODO: Add compressed texture test if extension exists? |
| 313 }, |
| 314 |
| 315 queryFunctions: function(expectedError) { |
| 316 shouldGenerateGLError(gl, expectedError, "gl.getTexParameter(gl.TEXTURE_2D
, gl.TEXTURE_WRAP_S)"); |
| 317 }, |
| 318 }; |
| 319 |
| 320 var testResourceWithSingleContext = function(info, callback) { |
| 321 var resourceType = info.resourceType; |
| 322 |
| 323 debug("") |
| 324 debug("test " + resourceType); |
| 325 var resource = info.setupFunction(); |
| 326 ext.releaseSharedResource(resource); |
| 327 |
| 328 debug(""); |
| 329 debug("test " + resourceType + " functions can not be called on released " +
resourceType); |
| 330 info.modificationFunctions(gl.INVALID_OPERATION); |
| 331 info.implicitBindFunctions(gl.INVALID_OPERATION); |
| 332 info.queryFunctions(gl.INVALID_OPERATION); |
| 333 |
| 334 debug(""); |
| 335 debug("test acquring " + resourceType); |
| 336 ext.acquireSharedResource(resource, ext.READ_ONLY, function() { |
| 337 debug(""); |
| 338 debug("test " + resourceType + " functions can not be called on READ_ONLY
acquired " + resourceType + " that has not been bound"); |
| 339 info.queryFunctions(gl.INVALID_OPERATION); |
| 340 info.modificationFunctions(gl.INVALID_OPERATION); |
| 341 |
| 342 debug(""); |
| 343 debug("test query " + resourceType + " functions can be called on READ_ONL
Y acquired " + resourceType + " that has been bound but not " + resourceType + "
modification functions"); |
| 344 info.bindFunction(resource); |
| 345 info.queryFunctions(gl.NO_ERROR); |
| 346 info.modificationFunctions(gl.INVALID_OPERATION); |
| 347 |
| 348 ext.releaseSharedResource(resource); |
| 349 ext.acquireSharedResource(resource, ext.EXCLUSIVE, function() { |
| 350 debug(""); |
| 351 debug("test " + resourceType + " functions can not be called on EXCLUSIV
E acquired " + resourceType + " that has not been bound"); |
| 352 info.queryFunctions(gl.INVALID_OPERATION); |
| 353 info.modificationFunctions(gl.INVALID_OPERATION); |
| 354 |
| 355 debug(""); |
| 356 debug("test all " + resourceType + " functions can be called on EXCLUSIV
E acquired " + resourceType + " that has been bound."); |
| 357 info.bindFunction(resource) |
| 358 info.queryFunctions(gl.NO_ERROR); |
| 359 info.modificationFunctions(gl.NO_ERROR); |
| 360 callback(); |
| 361 }); |
| 362 }); |
| 363 }; |
| 364 |
| 365 var makeSingleContextResourceTest = function(info) { |
| 366 return function(callback) { |
| 367 testResourceWithSingleContext(info, callback); |
| 368 }; |
| 369 }; |
| 370 |
| 371 var testCommonResourceFeatures = function(info, callback) { |
| 372 var type = info.resourceType.charAt(0).toUpperCase() + info.resourceType.sli
ce(1); |
| 373 acquiredFlag = false; |
| 374 debug(""); |
| 375 debug("test common features of " + type); |
| 376 |
| 377 resource = info.setupFunction(); |
| 378 info.bindFunction(resource); |
| 379 |
| 380 debug("Test a deleted resource can still be acquired."); |
| 381 var checkAcquireAfterDelete = function() { |
| 382 debug("check Acquire After Delete"); |
| 383 shouldGenerateGLError(gl, gl.INVALID_OPERATION, "gl.delete" + type + "(res
ource)"); |
| 384 // TODO: fix spec then comment this in shouldGenerateGLError(gl, gl.INVALID
_OPERATION, "gl.bind" + type + "(gl." + target + ", resource)"); // You can't b
ind a deleted resource |
| 385 shouldGenerateGLError(gl, gl.NO_ERROR, "ext.releaseSharedResource(resource
)"); |
| 386 callback(); |
| 387 }; |
| 388 |
| 389 var checkDeleteExclusive = function() { |
| 390 debug("check delete EXLUSIVE"); |
| 391 shouldGenerateGLError(gl, gl.INVALID_OPERATION, "gl.delete" + type + "(res
ource)"); |
| 392 info.bindFunction(resource); |
| 393 glErrorShouldBe(gl, gl.NO_ERROR, "no error deleting exclusively acquired r
esource"); |
| 394 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.delete" + type + "(resource)"); |
| 395 ext.releaseSharedResource(resource); |
| 396 ext.acquireSharedResource(resource, ext.EXCLUSIVE, checkAcquireAfterDelete
); |
| 397 }; |
| 398 |
| 399 var checkDeleteReadOnly = function() { |
| 400 acquiredFlag = true; |
| 401 debug("check delete READ_ONLY"); |
| 402 shouldGenerateGLError(gl, gl.INVALID_OPERATION, "gl.delete" + type + "(res
ource)"); |
| 403 info.bindFunction(resource); |
| 404 glErrorShouldBe(gl, gl.NO_ERROR, "no error bind read only acquired resourc
e"); |
| 405 shouldGenerateGLError(gl, gl.INVALID_OPERATION, "gl.delete" + type + "(res
ource)"); // We're READ_ONLY so this should fail |
| 406 ext.releaseSharedResource(resource); |
| 407 ext.acquireSharedResource(resource, ext.EXCLUSIVE, checkDeleteExclusive); |
| 408 }; |
| 409 |
| 410 debug("Test you can't have 2 outstanding requests for the same resource."); |
| 411 ext.releaseSharedResource(resource); |
| 412 ext.acquireSharedResource(resource, ext.READ_ONLY, checkDeleteReadOnly); |
| 413 glErrorShouldBe(gl, gl.NO_ERROR, "should be no error from 1st acquire reques
t"); |
| 414 ext.acquireSharedResource(resource, ext.READ_ONLY, checkDeleteReadOnly); |
| 415 glErrorShouldBe(gl, gl.INVALID_OPERATION, "should be INVALID_OPERATION from
2nd acquire request"); |
| 416 |
| 417 debug("Test acquire does not happen immediately on release (must exit curren
t event)"); |
| 418 shouldBeTrue("acquiredFlag === false"); |
| 419 }; |
| 420 |
| 421 var makeCommonResourceFeatureTest = function(info) { |
| 422 return function(callback) { |
| 423 testCommonResourceFeatures(info, callback); |
| 424 }; |
| 425 }; |
| 426 |
| 427 // acquire multiple resources in multiple contexts. |
| 428 var acquireMultipleResources = function(extensions, resources, mode, callback)
{ |
| 429 var numNeeded = resources.length * extensions.length; |
| 430 |
| 431 var checkAcquire = function() { |
| 432 --numNeeded; |
| 433 if (numNeeded == 0) { |
| 434 callback(); |
| 435 } |
| 436 }; |
| 437 |
| 438 resources.forEach(function(resource) { |
| 439 extensions.forEach(function(ext) { |
| 440 ext.acquireSharedResource(resource, mode, checkAcquire); |
| 441 }); |
| 442 }); |
| 443 }; |
| 444 |
| 445 // release multiple resources in multiple contexts. |
| 446 var releaseMultipleResources = function(extensions, resources) { |
| 447 resources.forEach(function(resource) { |
| 448 extensions.forEach(function(ext) { |
| 449 ext.releaseSharedResource(resource); |
| 450 }); |
| 451 }); |
| 452 }; |
| 453 |
| 454 var testRendering = function(callback) { |
| 455 debug(""); |
| 456 debug("test rendering"); |
| 457 var positionLocation = 0; |
| 458 var texcoordLocation = 1; |
| 459 var program = wtu.setupSimpleTextureProgram(gl, positionLocation, texcoordLo
cation); |
| 460 var buffers = wtu.setupUnitQuad(gl, positionLocation, texcoordLocation); |
| 461 var rb = gl.createRenderbuffer(); |
| 462 var fb = gl.createFramebuffer(); |
| 463 |
| 464 var elementBuf = gl.createBuffer(); |
| 465 gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, elementBuf); |
| 466 gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array([0, 1, 2, 3, 4, 5]),
gl.STATIC_DRAW); |
| 467 |
| 468 var width = 16; |
| 469 var height = 16; |
| 470 |
| 471 gl.bindRenderbuffer(gl.RENDERBUFFER, rb); |
| 472 gl.renderbufferStorage(gl.RENDERBUFFER, gl.RGBA4, width, height); |
| 473 |
| 474 var destTex = gl.createTexture(); |
| 475 gl.bindTexture(gl.TEXTURE_2D, destTex); |
| 476 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIG
NED_BYTE, null); |
| 477 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST); |
| 478 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST); |
| 479 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); |
| 480 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); |
| 481 |
| 482 gl.bindFramebuffer(gl.FRAMEBUFFER, fb); |
| 483 gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBU
FFER, rb); |
| 484 // It's not clear if gl.RGBA4 must be framebuffer complete. |
| 485 var canCheckRenderbuffer = (gl.checkFramebufferStatus(gl.FRAMEBUFFER) == gl.
FRAMEBUFFER_COMPLETE); |
| 486 |
| 487 gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D,
destTex, 0); |
| 488 glErrorShouldBe(gl, gl.NO_ERROR, "setup"); |
| 489 shouldBeTrue("gl.checkFramebufferStatus(gl.FRAMEBUFFER) == gl.FRAMEBUFFER_CO
MPLETE"); |
| 490 |
| 491 var tex = gl.createTexture(); |
| 492 wtu.fillTexture(gl, tex, 1, 1, [0, 255, 0, 255]); |
| 493 |
| 494 if (!program) { |
| 495 testFailed("could not link program"); |
| 496 callback(); |
| 497 return; |
| 498 } |
| 499 |
| 500 var releaseAndAcquireResources = function(callback) { |
| 501 var resources = [buffers[0], buffers[1], tex, program, elementBuf]; |
| 502 releaseMultipleResources([ext], resources); |
| 503 acquireMultipleResources([ext, ext2], resources, ext.READ_ONLY, callback); |
| 504 }; |
| 505 |
| 506 var doRenderTest = function(callback) { |
| 507 debug("Test 2 contexts can render with read only resources."); |
| 508 |
| 509 shouldGenerateGLError(gl, gl.INVALID_OPERATION, "gl.drawArrays(gl.TRIANGLE
S, 0, 6)"); |
| 510 gl.bindBuffer(gl.ARRAY_BUFFER, buffers[0]); |
| 511 shouldGenerateGLError(gl, gl.INVALID_OPERATION, "gl.drawArrays(gl.TRIANGLE
S, 0, 6)"); |
| 512 gl.bindBuffer(gl.ARRAY_BUFFER, buffers[1]); |
| 513 shouldGenerateGLError(gl, gl.INVALID_OPERATION, "gl.drawArrays(gl.TRIANGLE
S, 0, 6)"); |
| 514 gl.bindTexture(gl.TEXTURE_2D, tex); |
| 515 shouldGenerateGLError(gl, gl.INVALID_OPERATION, "gl.drawArrays(gl.TRIANGLE
S, 0, 6)"); |
| 516 gl.useProgram(program); |
| 517 |
| 518 // Render to canvas1; |
| 519 debug("render with context 1"); |
| 520 wtu.checkCanvasRect(gl, 0, 0, width, height, [0, 0, 0, 0]); |
| 521 wtu.drawUnitQuad(gl); |
| 522 wtu.checkCanvasRect(gl, 0, 0, width, height, [0, 255, 0, 255]); |
| 523 |
| 524 shouldGenerateGLError(gl, gl.INVALID_OPERATION, "gl.drawElements(gl.TRIANG
LES, 6, gl.UNSIGNED_SHORT, 0)"); |
| 525 gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, elementBuf); |
| 526 gl.clear(gl.COLOR_BUFFER_BIT); |
| 527 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.drawElements(gl.TRIANGLES, 6, g
l.UNSIGNED_SHORT, 0)"); |
| 528 wtu.checkCanvasRect(gl, 0, 0, width, height, [0, 255, 0, 255]); |
| 529 |
| 530 // Render to canvas2; |
| 531 debug("render with context 2"); |
| 532 gl2.useProgram(program); |
| 533 |
| 534 gl2.bindBuffer(gl.ARRAY_BUFFER, buffers[0]); |
| 535 gl2.enableVertexAttribArray(positionLocation); |
| 536 gl2.vertexAttribPointer(positionLocation, 2, gl.FLOAT, false, 0, 0); |
| 537 gl2.bindBuffer(gl.ARRAY_BUFFER, buffers[1]); |
| 538 gl2.enableVertexAttribArray(texcoordLocation); |
| 539 gl2.vertexAttribPointer(texcoordLocation, 2, gl.FLOAT, false, 0, 0); |
| 540 |
| 541 gl2.bindTexture(gl.TEXTURE_2D, tex); |
| 542 |
| 543 wtu.checkCanvas(gl2, [0, 0, 0, 0]); |
| 544 wtu.drawUnitQuad(gl2); |
| 545 wtu.checkCanvas(gl2, [0, 255, 0, 255]); |
| 546 |
| 547 shouldGenerateGLError(gl2, gl2.INVALID_OPERATION, "gl2.drawElements(gl2.TR
IANGLES, 6, gl2.UNSIGNED_SHORT, 0)"); |
| 548 gl2.bindBuffer(gl2.ELEMENT_ARRAY_BUFFER, elementBuf); |
| 549 gl2.clear(gl2.COLOR_BUFFER_BIT); |
| 550 shouldGenerateGLError(gl2, gl2.NO_ERROR, "gl2.drawElements(gl.TRIANGLES, 6
, gl.UNSIGNED_SHORT, 0)"); |
| 551 wtu.checkCanvas(gl2, [0, 255, 0, 255]); |
| 552 |
| 553 debug("Test you can't render to a framebuffer with a released texture"); |
| 554 ext.releaseSharedResource(destTex); |
| 555 shouldGenerateGLError(gl, gl.INVALID_FRAMEBUFFER_OPERATION, "gl.drawArrays
(gl.TRIANGLES, 0, 6)"); |
| 556 shouldGenerateGLError(gl, gl.INVALID_FRAMEBUFFER_OPERATION, "gl.clear(gl.C
OLOR_BUFFER_BIT)"); |
| 557 |
| 558 debug("Test you can't read from a framebuffer with a released texture"); |
| 559 shouldGenerateGLError(gl, gl.INVALID_FRAMEBUFFER_OPERATION, "gl.readPixels
(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array(4))"); |
| 560 |
| 561 ext.acquireSharedResource(destTex, ext.READ_ONLY, callback); |
| 562 }; |
| 563 |
| 564 var checkReadOnlyTextureOnFramebuffer = function(callback) { |
| 565 debug(""); |
| 566 debug("test READ_ONLY texture attachment"); |
| 567 debug("Test we fail of we haven't bound again"); |
| 568 shouldGenerateGLError(gl, gl.INVALID_FRAMEBUFFER_OPERATION, "gl.readPixels
(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array(4))"); |
| 569 shouldBeTrue("gl.checkFramebufferStatus(gl.FRAMEBUFFER) != gl.FRAMEBUFFER_
COMPLETE"); |
| 570 shouldBeTrue("gl.checkFramebufferStatus(gl.READ_FRAMEBUFFER) != gl.FRAMEBU
FFER_COMPLETE"); |
| 571 shouldBeTrue("gl.checkFramebufferStatus(gl.DRAW_FRAMEBUFFER) != gl.FRAMEBU
FFER_COMPLETE"); |
| 572 |
| 573 gl.activeTexture(gl.TEXTURE1); |
| 574 gl.bindTexture(gl.TEXTURE_2D, destTex); |
| 575 gl.activeTexture(gl.TEXTURE0); |
| 576 debug("Test we fail to draw because we're read only."); |
| 577 shouldBeTrue("gl.checkFramebufferStatus(gl.FRAMEBUFFER) != gl.FRAMEBUFFER_
COMPLETE"); |
| 578 shouldBeTrue("gl.checkFramebufferStatus(gl.DRAW_FRAMEBUFFER) != gl.FRAMEBU
FFER_COMPLETE"); |
| 579 shouldGenerateGLError(gl, gl.INVALID_FRAMEBUFFER_OPERATION, "gl.drawArrays
(gl.TRIANGLES, 0, 6)"); |
| 580 shouldGenerateGLError(gl, gl.INVALID_FRAMEBUFFER_OPERATION, "gl.clear(gl.C
OLOR_BUFFER_BIT)"); |
| 581 |
| 582 debug("Test we can read a READ_ONLY texture."); |
| 583 shouldBeTrue("gl.checkFramebufferStatus(gl.READ_FRAMEBUFFER) == gl.FRAMEBU
FFER_COMPLETE"); |
| 584 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.readPixels(0, 0, 1, 1, gl.RGBA,
gl.UNSIGNED_BYTE, new Uint8Array(4))"); |
| 585 |
| 586 checkRenderbuffer(callback); |
| 587 }; |
| 588 |
| 589 var checkRenderbuffer = function(callback) { |
| 590 if (canCheckRenderbuffer) { |
| 591 gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.REND
ERBUFFER, rb); |
| 592 wtu.drawUnitQuad(gl); |
| 593 wtu.checkCanvasRect(gl, 0, 0, width, height, [0, 255, 0, 255]); |
| 594 |
| 595 debug("Test you can't render to a framebuffer with a released renderbuff
er"); |
| 596 ext.releaseSharedResource(rb); |
| 597 shouldGenerateGLError(gl, gl.INVALID_FRAMEBUFFER_OPERATION, "gl.drawArra
ys(gl.TRIANGLES, 0, 6)"); |
| 598 shouldGenerateGLError(gl, gl.INVALID_FRAMEBUFFER_OPERATION, "gl.clear(gl
.COLOR_BUFFER_BIT)"); |
| 599 |
| 600 debug("Test you can't read from a framebuffer with a released renderbuff
er"); |
| 601 shouldGenerateGLError(gl, gl.INVALID_FRAMEBUFFER_OPERATION, "gl.readPixe
ls(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array(4))"); |
| 602 } |
| 603 |
| 604 ext.acquireSharedResource(rb, ext.READ_ONLY, callback); |
| 605 }; |
| 606 |
| 607 var checkReadOnlyRenderbufferOnFramebuffer = function(callback) { |
| 608 if (canCheckRenderbuffer) { |
| 609 debug(""); |
| 610 debug("test READ_ONLY renderbuffer attachment"); |
| 611 debug("Test we fail of we haven't bound again"); |
| 612 shouldGenerateGLError(gl, gl.INVALID_FRAMEBUFFER_OPERATION, "gl.readPixe
ls(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array(4))"); |
| 613 shouldBeTrue("gl.checkFramebufferStatus(gl.FRAMEBUFFER) != gl.FRAMEBUFFE
R_COMPLETE"); |
| 614 shouldBeTrue("gl.checkFramebufferStatus(gl.READ_FRAMEBUFFER) != gl.FRAME
BUFFER_COMPLETE"); |
| 615 shouldBeTrue("gl.checkFramebufferStatus(gl.DRAW_FRAMEBUFFER) != gl.FRAME
BUFFER_COMPLETE"); |
| 616 |
| 617 gl.bindRenderbuffer(gl.RENDERBUFFER, rb); |
| 618 debug("Test we fail to draw because we're read only."); |
| 619 shouldGenerateGLError(gl, gl.INVALID_FRAMEBUFFER_OPERATION, "gl.drawArra
ys(gl.TRIANGLES, 0, 6)"); |
| 620 shouldGenerateGLError(gl, gl.INVALID_FRAMEBUFFER_OPERATION, "gl.clear(gl
.COLOR_BUFFER_BIT)"); |
| 621 shouldBeTrue("gl.checkFramebufferStatus(gl.FRAMEBUFFER) != gl.FRAMEBUFFE
R_COMPLETE"); |
| 622 shouldBeTrue("gl.checkFramebufferStatus(gl.DRAW_FRAMEBUFFER) != gl.FRAME
BUFFER_COMPLETE"); |
| 623 |
| 624 debug("Test we can read a READ_ONLY renderbuffer."); |
| 625 shouldBeTrue("gl.checkFramebufferStatus(gl.READ_FRAMEBUFFER) == gl.FRAME
BUFFER_COMPLETE"); |
| 626 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.readPixels(0, 0, 1, 1, gl.RGB
A, gl.UNSIGNED_BYTE, new Uint8Array(4))"); |
| 627 } |
| 628 |
| 629 ext.releaseSharedResource(rb); |
| 630 ext.acquireSharedResource(rb, ext.READ_ONLY, callback); |
| 631 }; |
| 632 |
| 633 var checkRenderbufferBindsOnAttach = function(callback) { |
| 634 if (canCheckRenderbuffer) { |
| 635 debug(""); |
| 636 debug("Test we fail of we haven't bound again"); |
| 637 shouldGenerateGLError(gl, gl.INVALID_FRAMEBUFFER_OPERATION, "gl.readPixe
ls(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array(4))"); |
| 638 |
| 639 debug("Test attaching a renderbuffer marks it as bound"); |
| 640 gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.REND
ERBUFFER, rb); |
| 641 |
| 642 debug("Test we can read a READ_ONLY renderbuffer."); |
| 643 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.readPixels(0, 0, 1, 1, gl.RGB
A, gl.UNSIGNED_BYTE, new Uint8Array(4))"); |
| 644 } |
| 645 |
| 646 gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2
D, destTex, 0); |
| 647 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.readPixels(0, 0, 1, 1, gl.RGBA,
gl.UNSIGNED_BYTE, new Uint8Array(4))"); |
| 648 ext.releaseSharedResource(destTex); |
| 649 ext.acquireSharedResource(destTex, ext.READ_ONLY, callback); |
| 650 }; |
| 651 |
| 652 var checkTextureBindsOnAttach = function(callback) { |
| 653 debug(""); |
| 654 debug("Test we fail of we haven't bound again"); |
| 655 shouldGenerateGLError(gl, gl.INVALID_FRAMEBUFFER_OPERATION, "gl.readPixels
(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array(4))"); |
| 656 |
| 657 debug("Test attaching a texture marks it as bound"); |
| 658 gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2
D, destTex, 0); |
| 659 |
| 660 debug("Test we can read a READ_ONLY texture."); |
| 661 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.readPixels(0, 0, 1, 1, gl.RGBA,
gl.UNSIGNED_BYTE, new Uint8Array(4))"); |
| 662 |
| 663 callback(); |
| 664 }; |
| 665 |
| 666 var checkCanNotRenderWithReleasedProgram = function(callback) { |
| 667 debug(""); |
| 668 gl.bindFramebuffer(gl.FRAMEBUFFER, null); |
| 669 |
| 670 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.drawArrays(gl.TRIANGLES, 0, 6)"
); |
| 671 |
| 672 ext.releaseSharedResource(program); |
| 673 |
| 674 debug("Test we can't draw with a released program."); |
| 675 shouldGenerateGLError(gl, gl.INVALID_OPERATION, "gl.drawArrays(gl.TRIANGLE
S, 0, 6)"); |
| 676 |
| 677 ext.acquireSharedResource(program, ext.EXCLUSIVE, callback); |
| 678 ext2.releaseSharedResource(program); |
| 679 }; |
| 680 |
| 681 var checkCanNotRenderWithReleasedBuffer = function(callback) { |
| 682 debug(""); |
| 683 gl.useProgram(program); |
| 684 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.drawArrays(gl.TRIANGLES, 0, 6)"
); |
| 685 |
| 686 ext.releaseSharedResource(buffers[0]); |
| 687 |
| 688 debug("Test we can't draw with a released buffer."); |
| 689 shouldGenerateGLError(gl, gl.INVALID_OPERATION, "gl.drawArrays(gl.TRIANGLE
S, 0, 6)"); |
| 690 |
| 691 ext.acquireSharedResource(buffers[0], ext.READ_ONLY, callback); |
| 692 }; |
| 693 |
| 694 var checkCanNotRenderWithReleasedTexture = function(callback) { |
| 695 debug(""); |
| 696 gl.bindBuffer(gl.ARRAY_BUFFER, buffers[0]); |
| 697 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.drawArrays(gl.TRIANGLES, 0, 6)"
); |
| 698 |
| 699 ext.releaseSharedResource(tex); |
| 700 |
| 701 debug("Test we can't draw with a released texture."); |
| 702 shouldGenerateGLError(gl, gl.INVALID_OPERATION, "gl.drawArrays(gl.TRIANGLE
S, 0, 6)"); |
| 703 |
| 704 ext.acquireSharedResource(tex, ext.READ_ONLY, callback); |
| 705 }; |
| 706 |
| 707 var checkCanRenderWithReleasedShader = function(callback) { |
| 708 gl.bindTexture(gl.TEXTURE_2D, tex); |
| 709 var shaders = gl.getAttachedShaders(program); |
| 710 ext.releaseSharedResource(shaders[0]); |
| 711 |
| 712 debug(""); |
| 713 debug("Test we can draw with a released shader."); |
| 714 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.drawArrays(gl.TRIANGLES, 0, 6)"
); |
| 715 callback(); |
| 716 }; |
| 717 |
| 718 runSequence( |
| 719 [ |
| 720 releaseAndAcquireResources, |
| 721 doRenderTest, |
| 722 checkReadOnlyTextureOnFramebuffer, |
| 723 checkReadOnlyRenderbufferOnFramebuffer, |
| 724 checkRenderbufferBindsOnAttach, |
| 725 checkTextureBindsOnAttach, |
| 726 checkCanNotRenderWithReleasedProgram, |
| 727 checkCanNotRenderWithReleasedBuffer, |
| 728 checkCanNotRenderWithReleasedTexture, |
| 729 checkCanRenderWithReleasedShader, |
| 730 callback, |
| 731 ]); |
| 732 }; |
| 733 |
| 734 var testMisc = function(callback) { |
| 735 debug(""); |
| 736 debug("Test you can't release a framebuffer"); |
| 737 // TODO: It's not clear what should happen here to me. |
| 738 //shouldThrow("ext.releaseSharedResource(fb)", "TypeError"); |
| 739 |
| 740 debug("") |
| 741 debug("Test you can compare sharegroups"); |
| 742 var gl3 = wtu.create3DContext(); |
| 743 ext3 = wtu.getExtensionWithKnownPrefixes(gl3, "WEBGL_shared_resources"); |
| 744 // TODO: comment in once this comparison works. |
| 745 //shouldBeTrue("ext.group == ext2.group"); |
| 746 shouldBeTrue("ext.group != ext3.group"); |
| 747 |
| 748 debug("Test you can't use resources from another different group."); |
| 749 tex3 = gl3.createTexture(); |
| 750 shouldGenerateGLError(gl, gl.INVALID_OPERATION, "ext.releaseSharedResource(t
ex3)"); |
| 751 shouldGenerateGLError(gl, gl.INVALID_OPERATION, "ext.acquireSharedResource(t
ex3, ext.READ_ONLY, makeFailCallback('should not be able to acquire resource fro
m other context'))"); |
| 752 |
| 753 var failTest = function() { |
| 754 testFailed("cancelled callback was called"); |
| 755 }; |
| 756 |
| 757 var tex = gl.createTexture(); |
| 758 debug("test releasing from the wrong context. Should be a no-op"); |
| 759 shouldGenerateGLError(gl, gl.NO_ERROR, "ext2.releaseSharedResource(tex)"); |
| 760 |
| 761 id = ext2.acquireSharedResource(tex, ext.READ_ONLY, failTest); |
| 762 debug("test cancelling a request for which an event has not been posted"); |
| 763 ext2.cancelAcquireSharedResource(id); |
| 764 |
| 765 debug("test cancelling a request for which an event has already been posted"
); |
| 766 ext.releaseSharedResource(tex); |
| 767 id = ext.acquireSharedResource(tex, ext.READ_ONLY, failTest); |
| 768 ext.cancelAcquireSharedResource(id); |
| 769 |
| 770 debug("test cancelling on the wrong context's extension is ignored"); |
| 771 id = ext2.acquireSharedResource(tex, ext.READ_ONLY, callback); |
| 772 shouldGenerateGLError(gl, gl.NO_ERROR, 'ext.cancelAcquireSharedResource(id)'
); |
| 773 }; |
| 774 |
| 775 var testLostContext = function(callback) { |
| 776 var WEBGL_lose_context = wtu.getExtensionWithKnownPrefixes(gl, "WEBGL_lose_c
ontext"); |
| 777 if (!WEBGL_lose_context) { |
| 778 callback(); |
| 779 return; |
| 780 } |
| 781 |
| 782 var tex = gl.createTexture(); |
| 783 var tex2 = gl.createTexture(); |
| 784 |
| 785 var setupAcquire = function(callback) { |
| 786 var callbacksNeeded = 3; |
| 787 var waitForContextLostAndAcquire = function(e) { |
| 788 if (e && e.preventDefault) { |
| 789 e.preventDefault(); // allow context restore. |
| 790 } |
| 791 --callbacksNeeded; |
| 792 if (callbacksNeeded == 0) { |
| 793 callback(); |
| 794 } |
| 795 return false; |
| 796 }; |
| 797 |
| 798 debug(""); |
| 799 debug("Test extension still functions during context lost."); |
| 800 acquireMultipleResources([ext2], [tex, tex2], ext2.READ_ONLY, waitForConte
xtLostAndAcquire); |
| 801 canvas1.addEventListener("webglcontextlost", waitForContextLostAndAcquire,
false); |
| 802 canvas2.addEventListener("webglcontextlost", waitForContextLostAndAcquire,
false); |
| 803 // Release one before context lost |
| 804 ext.releaseSharedResource(tex); |
| 805 WEBGL_lose_context.loseContext(); |
| 806 // Release one after context lost |
| 807 ext.releaseSharedResource(tex2); |
| 808 |
| 809 shouldBeTrue('gl.isContextLost()'); |
| 810 shouldBeTrue('gl2.isContextLost()'); |
| 811 }; |
| 812 |
| 813 var checkAcquireExt2 = function(callback) { |
| 814 testPassed("was able to acquire resources during context lost"); |
| 815 acquireMultipleResources([ext], [tex, tex2], ext.READ_ONLY, callback); |
| 816 }; |
| 817 |
| 818 var checkAcquireExt = function(callback) { |
| 819 testPassed("was able to request acquire resources during context lost"); |
| 820 canvas1.addEventListener("webglcontextrestored", callback, false); |
| 821 WEBGL_lose_context.restoreContext(); |
| 822 }; |
| 823 |
| 824 var passTest = function(callback) { |
| 825 testPassed("extension works during lost context"); |
| 826 callback(); |
| 827 }; |
| 828 |
| 829 runSequence( |
| 830 [ |
| 831 setupAcquire, |
| 832 checkAcquireExt2, |
| 833 checkAcquireExt, |
| 834 passTest, |
| 835 callback, |
| 836 ]); |
| 837 }; |
| 838 |
| 839 runSequence( |
| 840 [ |
| 841 makeCommonResourceFeatureTest(bufferTests), |
| 842 makeCommonResourceFeatureTest(programTests), |
| 843 makeCommonResourceFeatureTest(shaderTests), |
| 844 makeCommonResourceFeatureTest(renderbufferTests), |
| 845 makeCommonResourceFeatureTest(textureTests), |
| 846 makeSingleContextResourceTest(bufferTests), |
| 847 makeSingleContextResourceTest(programTests), |
| 848 makeSingleContextResourceTest(renderbufferTests), |
| 849 makeSingleContextResourceTest(shaderTests), |
| 850 makeSingleContextResourceTest(textureTests), |
| 851 testRendering, |
| 852 testMisc, |
| 853 testLostContext, |
| 854 finishTest, |
| 855 ]); |
| 856 |
| 857 } |
| 858 var successfullyParsed = true; |
| 859 </script> |
| 860 </body> |
| 861 </html> |
| 862 |
OLD | NEW |