diff options
Diffstat (limited to 'dom/canvas/test/webgl-conf/checkout/conformance2/vertex_arrays/vertex-array-object.html')
| -rw-r--r-- | dom/canvas/test/webgl-conf/checkout/conformance2/vertex_arrays/vertex-array-object.html | 684 |
1 files changed, 684 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance2/vertex_arrays/vertex-array-object.html b/dom/canvas/test/webgl-conf/checkout/conformance2/vertex_arrays/vertex-array-object.html new file mode 100644 index 000000000..b65e0425a --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance2/vertex_arrays/vertex-array-object.html @@ -0,0 +1,684 @@ +<!-- + +/* +** Copyright (c) 2013 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +--> + +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<title>WebGL vertex_array_object 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> +<script id="vshader" type="x-shader/x-vertex"> +attribute vec4 a_position; +attribute vec4 a_color; +varying vec4 v_color; +void main(void) { + gl_Position = a_position; + v_color = a_color; +} +</script> +<script id="fshader" type="x-shader/x-fragment"> +precision mediump float; +varying vec4 v_color; +void main(void) { + gl_FragColor = v_color; +} +</script> +<script> +"use strict"; +description("This test verifies the functionality of the Vertex Array Objects."); + +debug(""); + +var wtu = WebGLTestUtils; +var canvas = document.getElementById("canvas"); +var gl = wtu.create3DContext(canvas, null, 2); +var vao = null; + +if (!gl) { + testFailed("WebGL context does not exist"); +} else { + testPassed("WebGL context exists"); + + runBindingTest(); + runObjectTest(); + runAttributeTests(); + runAttributeValueTests(); + runDrawTests(); + runUnboundDeleteTests(); + runBoundDeleteTests(); + runArrayBufferBindTests(); + wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no errors"); +} + +function runBindingTest() { + debug("Testing binding enum"); + + shouldBe("gl.VERTEX_ARRAY_BINDING", "0x85B5"); + + gl.getParameter(gl.VERTEX_ARRAY_BINDING); + wtu.glErrorShouldBe(gl, gl.NO_ERROR, "VERTEX_ARRAY_BINDING query should succeed"); + + // Default value is null + if (gl.getParameter(gl.VERTEX_ARRAY_BINDING) === null) { + testPassed("Default value of VERTEX_ARRAY_BINDING is null"); + } else { + testFailed("Default value of VERTEX_ARRAY_BINDING is not null"); + } + + debug("Testing binding a VAO"); + var vao0 = gl.createVertexArray(); + var vao1 = gl.createVertexArray(); + shouldBeNull("gl.getParameter(gl.VERTEX_ARRAY_BINDING)"); + gl.bindVertexArray(vao0); + if (gl.getParameter(gl.VERTEX_ARRAY_BINDING) == vao0) { + testPassed("gl.getParameter(gl.VERTEX_ARRAY_BINDING) is expected VAO"); + } else { + testFailed("gl.getParameter(gl.VERTEX_ARRAY_BINDING) is not expected VAO") + } + gl.bindVertexArray(vao1); + if (gl.getParameter(gl.VERTEX_ARRAY_BINDING) == vao1) { + testPassed("gl.getParameter(gl.VERTEX_ARRAY_BINDING) is expected VAO"); + } else { + testFailed("gl.getParameter(gl.VERTEX_ARRAY_BINDING) is not expected VAO") + } + gl.deleteVertexArray(vao1); + shouldBeNull("gl.getParameter(gl.VERTEX_ARRAY_BINDING)"); + gl.bindVertexArray(vao1); + wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "binding a deleted vertex array object"); + gl.bindVertexArray(null); + shouldBeNull("gl.getParameter(gl.VERTEX_ARRAY_BINDING)"); + gl.deleteVertexArray(vao1); +} + +function runObjectTest() { + debug("Testing object creation"); + + vao = gl.createVertexArray(); + wtu.glErrorShouldBe(gl, gl.NO_ERROR, "createVertexArray should not set an error"); + shouldBeNonNull("vao"); + + // Expect false if never bound + shouldBeFalse("gl.isVertexArray(vao)"); + gl.bindVertexArray(vao); + shouldBeTrue("gl.isVertexArray(vao)"); + gl.bindVertexArray(null); + shouldBeTrue("gl.isVertexArray(vao)"); + + shouldBeFalse("gl.isVertexArray(null)"); + + gl.deleteVertexArray(vao); + vao = null; +} + +function runAttributeTests() { + debug("Testing attributes work across bindings"); + + var states = []; + + var attrCount = gl.getParameter(gl.MAX_VERTEX_ATTRIBS); + for (var n = 0; n < attrCount; n++) { + gl.bindBuffer(gl.ARRAY_BUFFER, null); + gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null); + + var state = {}; + states.push(state); + + var vao = state.vao = gl.createVertexArray(); + gl.bindVertexArray(vao); + + var enableArray = (n % 2 == 0); + if (enableArray) { + gl.enableVertexAttribArray(n); + } else { + gl.disableVertexAttribArray(n); + } + + if (enableArray) { + var buffer = state.buffer = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, buffer); + gl.bufferData(gl.ARRAY_BUFFER, 1024, gl.STATIC_DRAW); + + gl.vertexAttribPointer(n, 1 + n % 4, gl.FLOAT, true, n * 4, n * 4); + } + + if (enableArray) { + var elbuffer = state.elbuffer = gl.createBuffer(); + gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, elbuffer); + gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, 1024, gl.STATIC_DRAW); + } + + gl.bindVertexArray(null); + } + + var anyMismatch = false; + for (var n = 0; n < attrCount; n++) { + var state = states[n]; + + gl.bindVertexArray(state.vao); + + var shouldBeEnabled = (n % 2 == 0); + var isEnabled = gl.getVertexAttrib(n, gl.VERTEX_ATTRIB_ARRAY_ENABLED); + if (shouldBeEnabled != isEnabled) { + testFailed("VERTEX_ATTRIB_ARRAY_ENABLED not preserved"); + anyMismatch = true; + } + + var buffer = gl.getVertexAttrib(n, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING); + if (shouldBeEnabled) { + if (buffer == state.buffer) { + // Matched + if ((gl.getVertexAttrib(n, gl.VERTEX_ATTRIB_ARRAY_SIZE) == 1 + n % 4) && + (gl.getVertexAttrib(n, gl.VERTEX_ATTRIB_ARRAY_TYPE) == gl.FLOAT) && + (gl.getVertexAttrib(n, gl.VERTEX_ATTRIB_ARRAY_NORMALIZED) == true) && + (gl.getVertexAttrib(n, gl.VERTEX_ATTRIB_ARRAY_STRIDE) == n * 4) && + (gl.getVertexAttribOffset(n, gl.VERTEX_ATTRIB_ARRAY_POINTER) == n * 4)) { + // Matched + } else { + testFailed("VERTEX_ATTRIB_ARRAY_* not preserved"); + anyMismatch = true; + } + } else { + testFailed("VERTEX_ATTRIB_ARRAY_BUFFER_BINDING not preserved"); + anyMismatch = true; + } + } else { + // GL_CURRENT_VERTEX_ATTRIB is not preserved + if (buffer) { + testFailed("VERTEX_ATTRIB_ARRAY_BUFFER_BINDING not preserved"); + anyMismatch = true; + } + } + + var elbuffer = gl.getParameter(gl.ELEMENT_ARRAY_BUFFER_BINDING); + if (shouldBeEnabled) { + if (elbuffer == state.elbuffer) { + // Matched + } else { + testFailed("ELEMENT_ARRAY_BUFFER_BINDING not preserved"); + anyMismatch = true; + } + } else { + if (elbuffer == null) { + // Matched + } else { + testFailed("ELEMENT_ARRAY_BUFFER_BINDING not preserved"); + anyMismatch = true; + } + } + } + gl.bindVertexArray(null); + if (!anyMismatch) { + testPassed("All attributes preserved across bindings"); + } + + for (var n = 0; n < attrCount; n++) { + var state = states[n]; + gl.deleteVertexArray(state.vao); + } +} + +function runAttributeValueTests() { + debug("Testing that attribute values are not attached to bindings"); + + var v; + var vao0 = gl.createVertexArray(); + var anyFailed = false; + + gl.bindVertexArray(null); + gl.vertexAttrib4f(0, 0, 1, 2, 3); + + v = gl.getVertexAttrib(0, gl.CURRENT_VERTEX_ATTRIB); + if (!(v[0] == 0 && v[1] == 1 && v[2] == 2 && v[3] == 3)) { + testFailed("Vertex attrib value not round-tripped?"); + anyFailed = true; + } + + gl.bindVertexArray(vao0); + + v = gl.getVertexAttrib(0, gl.CURRENT_VERTEX_ATTRIB); + if (!(v[0] == 0 && v[1] == 1 && v[2] == 2 && v[3] == 3)) { + testFailed("Vertex attrib value reset across bindings"); + anyFailed = true; + } + + gl.vertexAttrib4f(0, 4, 5, 6, 7); + gl.bindVertexArray(null); + + v = gl.getVertexAttrib(0, gl.CURRENT_VERTEX_ATTRIB); + if (!(v[0] == 4 && v[1] == 5 && v[2] == 6 && v[3] == 7)) { + testFailed("Vertex attrib value bound to buffer"); + anyFailed = true; + } + + if (!anyFailed) { + testPassed("Vertex attribute values are not attached to bindings") + } + + gl.bindVertexArray(null); + gl.deleteVertexArray(vao0); +} + +function runDrawTests() { + debug("Testing draws with various VAO bindings"); + + canvas.width = 50; canvas.height = 50; + gl.viewport(0, 0, canvas.width, canvas.height); + + var vao0 = gl.createVertexArray(); + var vao1 = gl.createVertexArray(); + + var opt_positionLocation = 0; + var opt_texcoordLocation = 1; + + var program = wtu.setupSimpleTextureProgram(gl, opt_positionLocation, opt_texcoordLocation); + + function setupQuad(s) { + var vertexObject = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, vertexObject); + gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([ + 1.0 * s, 1.0 * s, 0.0, + -1.0 * s, 1.0 * s, 0.0, + -1.0 * s, -1.0 * s, 0.0, + 1.0 * s, 1.0 * s, 0.0, + -1.0 * s, -1.0 * s, 0.0, + 1.0 * s, -1.0 * s, 0.0]), gl.STATIC_DRAW); + gl.enableVertexAttribArray(opt_positionLocation); + gl.vertexAttribPointer(opt_positionLocation, 3, gl.FLOAT, false, 0, 0); + + var vertexObject = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, vertexObject); + gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([ + 1.0 * s, 1.0 * s, + 0.0 * s, 1.0 * s, + 0.0 * s, 0.0 * s, + 1.0 * s, 1.0 * s, + 0.0 * s, 0.0 * s, + 1.0 * s, 0.0 * s]), gl.STATIC_DRAW); + gl.enableVertexAttribArray(opt_texcoordLocation); + gl.vertexAttribPointer(opt_texcoordLocation, 2, gl.FLOAT, false, 0, 0); + }; + + function readLocation(x, y) { + var pixels = new Uint8Array(1 * 1 * 4); + gl.readPixels(x, y, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, pixels); + return pixels; + }; + function testPixel(blackList, whiteList) { + function testList(list, expected) { + for (var n = 0; n < list.length; n++) { + var l = list[n]; + var x = -Math.floor(l * canvas.width / 2) + canvas.width / 2; + var y = -Math.floor(l * canvas.height / 2) + canvas.height / 2; + var source = readLocation(x, y); + if (Math.abs(source[0] - expected) > 2) { + return false; + } + } + return true; + } + return testList(blackList, 0) && testList(whiteList, 255); + }; + function verifyDraw(drawNumber, s) { + wtu.clearAndDrawUnitQuad(gl); + var blackList = []; + var whiteList = []; + var points = [0.0, 0.2, 0.4, 0.6, 0.8, 1.0]; + for (var n = 0; n < points.length; n++) { + if (points[n] <= s) { + blackList.push(points[n]); + } else { + whiteList.push(points[n]); + } + } + if (testPixel(blackList, whiteList)) { + testPassed("Draw " + drawNumber + " passed pixel test"); + } else { + testFailed("Draw " + drawNumber + " failed pixel test"); + } + }; + + // Setup all bindings + setupQuad(1); + gl.bindVertexArray(vao0); + setupQuad(0.5); + gl.bindVertexArray(vao1); + setupQuad(0.25); + + // Verify drawing + gl.bindVertexArray(null); + verifyDraw(0, 1); + gl.bindVertexArray(vao0); + verifyDraw(1, 0.5); + gl.bindVertexArray(vao1); + verifyDraw(2, 0.25); + + gl.bindVertexArray(null); + gl.deleteVertexArray(vao0); + gl.deleteVertexArray(vao1); + + // Disable global vertex attrib array + gl.disableVertexAttribArray(opt_positionLocation); + gl.disableVertexAttribArray(opt_texcoordLocation); + + // Draw with values. + var positionLoc = 0; + var colorLoc = 1; + var gridRes = 1; + wtu.setupIndexedQuad(gl, gridRes, positionLoc); + // Set the vertex color to red. + gl.vertexAttrib4f(colorLoc, 1, 0, 0, 1); + + var vao0 = gl.createVertexArray(); + gl.bindVertexArray(vao0); + var program = wtu.setupSimpleVertexColorProgram(gl, positionLoc, colorLoc); + wtu.setupIndexedQuad(gl, gridRes, positionLoc); + // Set the vertex color to green. + gl.vertexAttrib4f(colorLoc, 0, 1, 0, 1); + wtu.clearAndDrawIndexedQuad(gl, gridRes); + wtu.checkCanvas(gl, [0, 255, 0, 255], "should be green") + gl.deleteVertexArray(vao0); + wtu.clearAndDrawIndexedQuad(gl, gridRes); + wtu.checkCanvas(gl, [0, 255, 0, 255], "should be green") +} + +function runUnboundDeleteTests() { + debug("Testing using buffers that are deleted when attached to unbound VAOs"); + + var program = wtu.setupProgram(gl, ["vshader", "fshader"], ["a_position", "a_color"]); + gl.useProgram(program); + + var positionBuffer = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer); + gl.bufferData( + gl.ARRAY_BUFFER, + new Float32Array([ + 1.0, 1.0, + -1.0, 1.0, + -1.0, -1.0, + 1.0, -1.0]), + gl.STATIC_DRAW); + + var colors = [ + [255, 0, 0, 255], + [ 0, 255, 0, 255], + [ 0, 0, 255, 255], + [ 0, 255, 255, 255] + ]; + var colorBuffers = []; + var elementBuffers = []; + var vaos = []; + for (var ii = 0; ii < colors.length; ++ii) { + var vao = gl.createVertexArray(); + vaos.push(vao); + gl.bindVertexArray(vao); + // Set the position buffer + gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer); + gl.enableVertexAttribArray(0); + gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0); + + var elementBuffer = gl.createBuffer(); + elementBuffers.push(elementBuffer); + gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, elementBuffer); + gl.bufferData( + gl.ELEMENT_ARRAY_BUFFER, + new Uint8Array([0, 1, 2, 0, 2, 3]), + gl.STATIC_DRAW); + + // Setup the color attrib + var color = colors[ii]; + if (ii < 3) { + var colorBuffer = gl.createBuffer(); + colorBuffers.push(colorBuffer); + gl.bindBuffer(gl.ARRAY_BUFFER, colorBuffer); + gl.bufferData(gl.ARRAY_BUFFER, new Uint8Array( + [ color[0], color[1], color[2], color[3], + color[0], color[1], color[2], color[3], + color[0], color[1], color[2], color[3], + color[0], color[1], color[2], color[3] + ]), gl.STATIC_DRAW); + gl.enableVertexAttribArray(1); + gl.vertexAttribPointer(1, 4, gl.UNSIGNED_BYTE, true, 0, 0); + } else { + gl.vertexAttrib4f(1, color[0] / 255, color[1] / 255, color[2] / 255, color[3] / 255); + } + } + + // delete the color buffers AND the position buffer. + gl.bindVertexArray(null); + for (var ii = 0; ii < colorBuffers.length; ++ii) { + gl.deleteBuffer(colorBuffers[ii]); + gl.deleteBuffer(elementBuffers[ii]); + gl.bindVertexArray(vaos[ii]); + var boundBuffer = gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING); + // The buffers should still be valid at this point, since it was attached to the VAO + if(boundBuffer != colorBuffers[ii]) { + testFailed("buffer removed too early"); + } + } + gl.bindVertexArray(null); + gl.deleteBuffer(positionBuffer); + + // Render with the deleted buffers. As they are referenced by VAOs they + // must still be around. + for (var ii = 0; ii < colors.length; ++ii) { + var color = colors[ii]; + gl.bindVertexArray(vaos[ii]); + gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_BYTE, 0); + wtu.checkCanvas(gl, color, "should be " + color); + } + + // Clean up. + for (var ii = 0; ii < colorBuffers.length; ++ii) { + gl.deleteVertexArray(vaos[ii]); + } + + for (var ii = 0; ii < colorBuffers.length; ++ii) { + // The buffers should no longer be valid now that the VAOs are deleted + if(gl.isBuffer(colorBuffers[ii])) { + testFailed("buffer not properly cleaned up after VAO deletion"); + } + } +} + +function runBoundDeleteTests() { + debug("Testing using buffers that are deleted when attached to bound VAOs"); + + var program = wtu.setupProgram(gl, ["vshader", "fshader"], ["a_position", "a_color"]); + gl.useProgram(program); + + var positionBuffer = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer); + gl.bufferData( + gl.ARRAY_BUFFER, + new Float32Array([ + 1.0, 1.0, + -1.0, 1.0, + -1.0, -1.0, + 1.0, -1.0]), + gl.STATIC_DRAW); + + // Setup the color attrib + var colorBuffer = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, colorBuffer); + gl.bufferData(gl.ARRAY_BUFFER, new Uint8Array( + [ 255, 0, 0, 255, + 0, 255, 0, 255, + 0, 0, 255, 255, + 0, 255, 255, 255 + ]), gl.STATIC_DRAW); + + var vaos = []; + var elementBuffers = []; + for (var ii = 0; ii < 4; ++ii) { + var vao = gl.createVertexArray(); + vaos.push(vao); + gl.bindVertexArray(vao); + + gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer); + gl.enableVertexAttribArray(0); + gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0); + + var elementBuffer = gl.createBuffer(); + elementBuffers.push(elementBuffer); + gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, elementBuffer); + gl.bufferData( + gl.ELEMENT_ARRAY_BUFFER, + new Uint8Array([0, 1, 2, 0, 2, 3]), + gl.STATIC_DRAW); + + gl.bindBuffer(gl.ARRAY_BUFFER, colorBuffer); + gl.enableVertexAttribArray(1); + gl.vertexAttribPointer(1, 4, gl.UNSIGNED_BYTE, true, 0, 0); + } + + // delete the color buffers AND the position buffer, that are bound to the current VAO + for (var ii = 0; ii < vaos.length; ++ii) { + gl.bindVertexArray(vaos[ii]); + + gl.deleteBuffer(colorBuffer); + gl.deleteBuffer(positionBuffer); + + // The buffers should not be accessible at this point. Deleted objects that are bound + // in the current context undergo an automatic unbinding + var boundPositionBuffer = gl.getVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING); + if(boundPositionBuffer == positionBuffer) { + testFailed("Position buffer should be automatically unbound when deleted"); + } + var boundColorBuffer = gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING); + if(boundColorBuffer == colorBuffer) { + testFailed("Color buffer should be automatically unbound when deleted"); + } + + gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_BYTE, 0); + wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "Draw call should fail with unbound position and color buffers"); + + var isPositionBuffer = gl.isBuffer(positionBuffer); + var isColorBuffer = gl.isBuffer(colorBuffer); + + if(isPositionBuffer) testFailed("Position buffer should no longer exist after last ref removed"); + if(isColorBuffer) testFailed("Color buffer should no longer exist after last ref removed"); + } +} + +function runArrayBufferBindTests() { + debug("Testing that VAOs don't effect ARRAY_BUFFER binding."); + + gl.bindVertexArray(null); + + var program = wtu.setupProgram(gl, ["vshader", "fshader"], ["a_color", "a_position"]); + gl.useProgram(program); + + // create shared element buuffer + var elementBuffer = gl.createBuffer(); + // bind to default + gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, elementBuffer); + gl.bufferData( + gl.ELEMENT_ARRAY_BUFFER, + new Uint8Array([0, 1, 2, 0, 2, 3]), + gl.STATIC_DRAW); + + // first create the buffers for no vao draw. + var nonVAOColorBuffer = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, nonVAOColorBuffer); + gl.bufferData(gl.ARRAY_BUFFER, new Uint8Array( + [ 0, 255, 0, 255, + 0, 255, 0, 255, + 0, 255, 0, 255, + 0, 255, 0, 255, + ]), gl.STATIC_DRAW); + + // shared position buffer. + var positionBuffer = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer); + gl.bufferData( + gl.ARRAY_BUFFER, + new Float32Array([ + 1.0, 1.0, + -1.0, 1.0, + -1.0, -1.0, + 1.0, -1.0]), + gl.STATIC_DRAW); + + // attach position buffer to default + gl.enableVertexAttribArray(1); + gl.vertexAttribPointer(1, 2, gl.FLOAT, false, 0, 0); + + // now create vao + var vao = gl.createVertexArray(); + gl.bindVertexArray(vao); + + // attach the position buffer vao + gl.enableVertexAttribArray(1); + gl.vertexAttribPointer(1, 2, gl.FLOAT, false, 0, 0); + + var vaoColorBuffer = gl.createBuffer(); + gl.enableVertexAttribArray(0); + gl.vertexAttribPointer(0, 4, gl.UNSIGNED_BYTE, true, 0, 0); + gl.bindBuffer(gl.ARRAY_BUFFER, vaoColorBuffer); + gl.bufferData(gl.ARRAY_BUFFER, new Uint8Array( + [ 255, 0, 0, 255, + 255, 0, 0, 255, + 255, 0, 0, 255, + 255, 0, 0, 255, + ]), gl.STATIC_DRAW); + gl.enableVertexAttribArray(0); + gl.vertexAttribPointer(0, 4, gl.UNSIGNED_BYTE, true, 0, 0); + + // now set the buffer back to the nonVAOColorBuffer + gl.bindBuffer(gl.ARRAY_BUFFER, nonVAOColorBuffer); + + // bind to vao + gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, elementBuffer); + gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_BYTE, 0); + wtu.checkCanvas(gl, [255, 0, 0, 255], "should be red"); + + // unbind vao + gl.bindVertexArray(null); + + // At this point the nonVAOColorBuffer should be still be bound. + // If the WebGL impl is emulating VAOs it must make sure + // it correctly restores this binding. + gl.enableVertexAttribArray(0); + gl.vertexAttribPointer(0, 4, gl.UNSIGNED_BYTE, true, 0, 0); + gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_BYTE, 0); + wtu.checkCanvas(gl, [0, 255, 0, 255], "should be green"); +} + +debug(""); +var successfullyParsed = true; +</script> +<script src="../../js/js-test-post.js"></script> + +</body> +</html> |