Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(6)

Side by Side Diff: conformance/extensions/webgl-shared-resources.html

Issue 41893003: Add ToT WebGL conformance tests : part 12 (last one) (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/deps/third_party/webgl/sdk/tests/
Patch Set: Created 7 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « conformance/extensions/webgl-draw-buffers.html ('k') | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Property Changes:
Added: svn:eol-style
## -0,0 +1 ##
+LF
\ No newline at end of property
OLDNEW
(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
OLDNEW
« no previous file with comments | « conformance/extensions/webgl-draw-buffers.html ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698