| <!-- |
| Copyright (c) 2019 The Khronos Group Inc. |
| Use of this source code is governed by an MIT-style license that can be |
| found in the LICENSE.txt file. |
| --> |
| <!DOCTYPE html> |
| <html> |
| <head> |
| <meta charset="utf-8"> |
| <title>WebGL Program Compiling/Linking Conformance Test</title> |
| <link rel="stylesheet" href="../../resources/js-test-style.css"/> |
| <script src="../../js/js-test-pre.js"></script> |
| <script src="../../js/desktop-gl-constants.js"></script> |
| <script src="../../js/webgl-test-utils.js"></script> |
| </head> |
| <body> |
| <script id="vshader" type="x-shader/x-vertex"> |
| attribute vec4 a_position; |
| void main() |
| { |
| gl_Position = a_position; |
| } |
| </script> |
| <script id="fshader-red" type="x-shader/x-fragment"> |
| void main() |
| { |
| gl_FragColor = vec4(1, 0, 0, 1); |
| } |
| </script> |
| <script id="fshader-green" type="x-shader/x-fragment"> |
| void main() |
| { |
| gl_FragColor = vec4(0, 1, 0, 1); |
| } |
| </script> |
| <script id="fshader-settable" type="x-shader/x-fragment"> |
| precision mediump float; |
| uniform vec4 u_color; |
| void main() |
| { |
| gl_FragColor = u_color; |
| } |
| </script> |
| <div id="description"></div> |
| <div id="console"></div> |
| <canvas id="canvas" width="2" height="2"> </canvas> |
| <script type="application/javascript"> |
| var wtu = WebGLTestUtils; |
| let gl; |
| function go() { |
| description("Tests that program compiling/linking/using works correctly."); |
| |
| debug(""); |
| debug("Canvas.getContext"); |
| |
| gl = wtu.create3DContext("canvas"); |
| if (!gl) { |
| testFailed("context does not exist"); |
| return; |
| } |
| |
| testPassed("context exists"); |
| |
| gl.clearColor(0.0, 0.0, 0.0, 0.0); |
| gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT); |
| |
| function doArraysHaveSameContents(a, b) { |
| var flags = []; |
| function hasUnusedValue(a, value) { |
| for (var ii = 0; ii < a.length; ++ii) { |
| if (a[ii] === value && !flags[ii]) { |
| flags[ii] = true; |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| try { |
| if (a.length !== b.length) { |
| return false; |
| } |
| for (var ii = 0; ii < a.length; ii++) { |
| if (!hasUnusedValue(b, a[ii])) { |
| return false; |
| } |
| } |
| } catch (ex) { |
| return false; |
| } |
| return true; |
| } |
| |
| /////// Check compileShader() ///////////////////////////// |
| |
| var vs = gl.createShader(gl.VERTEX_SHADER); |
| gl.shaderSource(vs, "attribute vec4 aVertex; attribute vec4 aColor; varying vec4 vColor; void main() { vColor = aColor; gl_Position = aVertex; }"); |
| gl.compileShader(vs); |
| |
| assertMsg(gl.getShaderParameter(vs, gl.COMPILE_STATUS) == true, |
| "good vertex shader should compile"); |
| |
| // Verify that constants removed from the WebGL spec generate INVALID_ENUM errors |
| wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no errors at this point"); |
| assertMsg(gl.getShaderParameter(vs, desktopGL['INFO_LOG_LENGTH']) === null, "invalid call to getShaderParameter should return null"); |
| wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "INFO_LOG_LENGTH is not a valid argument to getShaderParameter in WebGL"); |
| assertMsg(gl.getShaderParameter(vs, desktopGL['SHADER_SOURCE_LENGTH']) === null, "invalid call to getShaderParameter should return null"); |
| wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "SHADER_SOURCE_LENGTH is not a valid argument to getShaderParameter in WebGL"); |
| |
| var vs2 = gl.createShader(gl.VERTEX_SHADER); |
| gl.shaderSource(vs2, "attribute vec4 aVertex; attribute vec4 aColor; varying vec4 vColor; void main() { vColor = aColor; gl_Position = aVertex * 0.5; }"); |
| gl.compileShader(vs2); |
| |
| assertMsg(gl.getShaderParameter(vs2, gl.COMPILE_STATUS) == true, |
| "good vertex shader #2 should compile"); |
| |
| var vsBad = gl.createShader(gl.VERTEX_SHADER); |
| gl.shaderSource(vsBad, "WILL NOT COMPILE;"); |
| gl.compileShader(vsBad); |
| |
| // GLSL 1.0.17 section 10.27. compile shader does not have to return failure. |
| //assertMsg(gl.getShaderParameter(vsBad, gl.COMPILE_STATUS) == false, |
| // "bad vertex shader should fail to compile"); |
| |
| var fs = gl.createShader(gl.FRAGMENT_SHADER); |
| gl.shaderSource(fs, "precision mediump float; varying vec4 vColor; void main() { gl_FragColor = vColor; }"); |
| gl.compileShader(fs); |
| |
| assertMsg(gl.getShaderParameter(fs, gl.COMPILE_STATUS) == true, |
| "good fragment shader should compile"); |
| |
| var fs2 = gl.createShader(gl.FRAGMENT_SHADER); |
| gl.shaderSource(fs2, "precision mediump float; varying vec4 vColor; void main() { gl_FragColor = vColor * 0.5; }"); |
| gl.compileShader(fs2); |
| |
| assertMsg(gl.getShaderParameter(fs2, gl.COMPILE_STATUS) == true, |
| "good fragment shader #2 should compile"); |
| |
| var fsBad = gl.createShader(gl.FRAGMENT_SHADER); |
| gl.shaderSource(fsBad, "WILL NOT COMPILE;"); |
| gl.compileShader(fsBad); |
| |
| // GLSL 1.0.17 section 10.27. compile shader does not have to return failure. |
| //assertMsg(gl.getShaderParameter(fsBad, gl.COMPILE_STATUS) == false, |
| // "bad fragment shader should fail to compile"); |
| |
| wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no errors at this point"); |
| |
| /////// Check attachShader() ///////////////////////////// |
| |
| function checkAttachShader(already_attached_shaders, shader, expected_error_code, errmsg) { |
| var prog = gl.createProgram(); |
| for (var i = 0; i < already_attached_shaders.length; ++i) |
| gl.attachShader(prog, already_attached_shaders[i]); |
| if(gl.getError() != gl.NO_ERROR) |
| assertMsg(false, "unexpected error in attachShader()"); |
| gl.attachShader(prog, shader); |
| wtu.glErrorShouldBe(gl, expected_error_code, errmsg); |
| } |
| |
| checkAttachShader([], vs, gl.NO_ERROR, "attaching a vertex shader should succeed"); |
| checkAttachShader([vs], vs, gl.INVALID_OPERATION, |
| "attaching an already attached vertex shader should generate INVALID_OPERATION"); |
| checkAttachShader([], fs, gl.NO_ERROR, "attaching a fragment shader should succeed"); |
| checkAttachShader([fs], fs, gl.INVALID_OPERATION, |
| "attaching an already attached fragment shader should generate INVALID_OPERATION"); |
| checkAttachShader([vs], vs2, gl.INVALID_OPERATION, |
| "attaching shaders of the same type to a program should generate INVALID_OPERATION"); |
| checkAttachShader([fs], fs2, gl.INVALID_OPERATION, |
| "attaching shaders of the same type to a program should generate INVALID_OPERATION"); |
| |
| /////// Check detachShader() ///////////////////////////// |
| |
| function checkDetachShader(already_attached_shaders, shader, expected_error_code, errmsg) { |
| var prog = gl.createProgram(); |
| for (var i = 0; i < already_attached_shaders.length; ++i) |
| gl.attachShader(prog, already_attached_shaders[i]); |
| if(gl.getError() != gl.NO_ERROR) |
| assertMsg(false, "unexpected error in attachShader()"); |
| gl.detachShader(prog, shader); |
| wtu.glErrorShouldBe(gl, expected_error_code, errmsg); |
| } |
| |
| checkDetachShader([vs], vs, gl.NO_ERROR, "detaching a vertex shader should succeed"); |
| checkDetachShader([fs], vs, gl.INVALID_OPERATION, |
| "detaching a not already attached vertex shader should generate INVALID_OPERATION"); |
| checkDetachShader([fs], fs, gl.NO_ERROR, "detaching a fragment shader should succeed"); |
| checkDetachShader([vs], fs, gl.INVALID_OPERATION, |
| "detaching a not already attached fragment shader should generate INVALID_OPERATION"); |
| |
| /////// Check getAttachedShaders() ///////////////////////////// |
| |
| function checkGetAttachedShaders(shaders_to_attach, shaders_to_detach, expected_shaders, errmsg) { |
| prog = gl.createProgram(); |
| for (var i = 0; i < shaders_to_attach.length; ++i) |
| gl.attachShader(prog, shaders_to_attach[i]); |
| if(gl.getError() != gl.NO_ERROR) |
| assertMsg(false, "unexpected error in attachShader()"); |
| for (var i = 0; i < shaders_to_detach.length; ++i) |
| gl.detachShader(prog, shaders_to_detach[i]); |
| if(gl.getError() != gl.NO_ERROR) |
| assertMsg(false, "unexpected error in detachShader()"); |
| assertMsg(doArraysHaveSameContents(gl.getAttachedShaders(prog), expected_shaders), errmsg); |
| shouldBe('gl.getProgramParameter(prog, gl.ATTACHED_SHADERS)', `${expected_shaders.length}`); |
| } |
| checkGetAttachedShaders([], [], [], "getAttachedShaders should return an empty list by default"); |
| checkGetAttachedShaders([fs], [], [fs], "attaching a single shader should give the expected list"); |
| checkGetAttachedShaders([fs, vs], [], [fs, vs], |
| "attaching some shaders should give the expected list"); |
| checkGetAttachedShaders([fs], [fs], [], "attaching a shader and detaching it should leave an empty list"); |
| checkGetAttachedShaders([fs, vs], [fs, vs], [], |
| "attaching some shaders and detaching them in same order should leave an empty list"); |
| checkGetAttachedShaders([fs, vs], [vs, fs], [], |
| "attaching some shaders and detaching them in random order should leave an empty list"); |
| checkGetAttachedShaders([fs, vs], [vs], [fs], |
| "attaching and detaching some shaders should leave the difference list"); |
| checkGetAttachedShaders([fs, vs], [fs], [vs], |
| "attaching and detaching some shaders should leave the difference list"); |
| checkGetAttachedShaders([fsBad], [], [fsBad], |
| "attaching a shader that failed to compile should still show it in the list"); |
| checkGetAttachedShaders([fs, vsBad], [], [fs, vsBad], |
| "attaching shaders, including one that failed to compile, should still show the it in the list"); |
| |
| /////// Check linkProgram() and useProgram ///////////////////////////// |
| |
| function checkLinkAndUse(shaders, deleteShaderAfterAttach, expected_status, testInvalidEnums, errmsg) { |
| var prog = gl.createProgram(); |
| for (var i = 0; i < shaders.length; ++i) { |
| gl.attachShader(prog, shaders[i]); |
| if (deleteShaderAfterAttach) |
| gl.deleteShader(shaders[i]); |
| } |
| gl.bindAttribLocation(prog, 0, "aVertex"); |
| gl.bindAttribLocation(prog, 1, "aColor"); |
| gl.linkProgram(prog); |
| if (gl.getError() != gl.NO_ERROR) |
| assertMsg(false, "unexpected error in linkProgram()"); |
| assertMsg(gl.getProgramParameter(prog, gl.LINK_STATUS) == expected_status, errmsg); |
| var infolog = gl.getProgramInfoLog(prog); |
| if (gl.getError() != gl.NO_ERROR) |
| assertMsg(false, "unexpected error in getProgramInfoLog()"); |
| if (typeof(infolog) != "string") |
| assertMsg(false, "getProgramInfoLog() did not return a string"); |
| if (expected_status == true && gl.getProgramParameter(prog, gl.LINK_STATUS) == false) |
| debug(infolog); |
| if (gl.getError() != gl.NO_ERROR) |
| assertMsg(false, "unexpected error in getProgramParameter()"); |
| |
| if (testInvalidEnums) { |
| // Verify that constants removed from the WebGL spec generate INVALID_ENUM errors |
| assertMsg(gl.getProgramParameter(prog, desktopGL['INFO_LOG_LENGTH']) === null, "invalid call to getProgramParameter should return null"); |
| wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "INFO_LOG_LENGTH is not a valid argument to getProgramParameter in WebGL"); |
| assertMsg(gl.getProgramParameter(prog, desktopGL['ACTIVE_ATTRIBUTE_MAX_LENGTH']) === null, "invalid call to getProgramParameter should return null"); |
| wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "ACTIVE_ATTRIBUTE_MAX_LENGTH is not a valid argument to getProgramParameter in WebGL"); |
| assertMsg(gl.getProgramParameter(prog, desktopGL['ACTIVE_UNIFORM_MAX_LENGTH']) === null, "invalid call to getProgramParameter should return null"); |
| wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "ACTIVE_UNIFORM_MAX_LENGTH is not a valid argument to getProgramParameter in WebGL"); |
| } |
| |
| gl.useProgram(prog); |
| if (expected_status == true) |
| wtu.glErrorShouldBe(gl, gl.NO_ERROR, "using a valid program should succeed"); |
| if (expected_status == false) |
| wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "using an invalid program should generate INVALID_OPERATION"); |
| return prog; |
| } |
| |
| var progGood1 = checkLinkAndUse([vs, fs], false, true, true, "valid program should link"); |
| var progGood2 = checkLinkAndUse([vs, fs2], false, true, false, "valid program #2 should link"); |
| var progBad1 = checkLinkAndUse([vs], false, false, false, "program with no fragment shader should fail to link"); |
| var progBad2 = checkLinkAndUse([fs], false, false, false, "program with no vertex shader should fail to link"); |
| var progBad3 = checkLinkAndUse([vsBad, fs], false, false, false, "program with bad vertex shader should fail to link"); |
| var progBad4 = checkLinkAndUse([vs, fsBad], false, false, false, "program with bad fragment shader should fail to link"); |
| var progBad5 = checkLinkAndUse([vsBad, fsBad], false, false, false, "program with bad shaders should fail to link"); |
| |
| gl.useProgram(progGood1); |
| wtu.glErrorShouldBe(gl, gl.NO_ERROR, "using a valid program shouldn't generate a GL error"); |
| |
| var vbuf = gl.createBuffer(); |
| gl.bindBuffer(gl.ARRAY_BUFFER, vbuf); |
| gl.bufferData(gl.ARRAY_BUFFER, |
| new Float32Array([ |
| 0.0, 0.0, 0.0, 1.0, |
| 1.0, 0.0, 0.0, 1.0, |
| 1.0, 1.0, 0.0, 1.0, |
| 0.0, 1.0, 0.0, 1.0]), |
| gl.STATIC_DRAW); |
| gl.vertexAttribPointer(0, 4, gl.FLOAT, false, 0, 0); |
| gl.enableVertexAttribArray(0); |
| gl.vertexAttrib3f(1, 1.0, 0.0, 0.0); |
| |
| wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no errors at this point #2"); |
| |
| gl.useProgram(null); |
| gl.drawArrays(gl.TRIANGLES, 0, 3); |
| wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "drawing with a null program should generate INVALID_OPERATION"); |
| |
| gl.useProgram(progGood1); |
| gl.drawArrays(gl.TRIANGLES, 0, 3); |
| wtu.glErrorShouldBe(gl, gl.NO_ERROR, "drawing with a valid program shouldn't generate a GL error"); |
| |
| gl.useProgram(progBad1); |
| wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "using an invalid program should generate INVALID_OPERATION"); |
| gl.drawArrays(gl.TRIANGLES, 0, 3); |
| wtu.glErrorShouldBe(gl, gl.NO_ERROR, "Try to use an invalid program should not change the current rendering state"); |
| |
| gl.useProgram(progGood2); |
| gl.drawArrays(gl.TRIANGLES, 0, 3); |
| wtu.glErrorShouldBe(gl, gl.NO_ERROR, "drawing with a valid program shouldn't generate a GL error"); |
| gl.detachShader(progGood2, fs2); |
| gl.attachShader(progGood2, fsBad); |
| gl.linkProgram(progGood2); |
| assertMsg(gl.getProgramParameter(progGood2, gl.LINK_STATUS) == false, |
| "linking should fail with in-use formerly good program, with new bad shader attached"); |
| |
| // In WebGL, an unsuccessful link immediately invalidates the previous valid program. |
| gl.drawArrays(gl.TRIANGLES, 0, 3); |
| wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "drawing with a newly-invalidated program should generate INVALID_OPERATION"); |
| |
| gl.useProgram(progGood1); |
| gl.drawArrays(gl.TRIANGLES, 0, 4); |
| wtu.glErrorShouldBe(gl, gl.NO_ERROR, "drawing with a valid when last used program shouldn't generate a GL error"); |
| |
| var progGood1 = checkLinkAndUse([vs, fs], true, true, false, "delete shaders after attaching them and before linking program should not affect linkProgram"); |
| gl.useProgram(progGood1); |
| gl.drawArrays(gl.TRIANGLES, 0, 4); |
| wtu.glErrorShouldBe(gl, gl.NO_ERROR, "drawing with a valid when last used program shouldn't generate a GL error"); |
| |
| /////// Check deleteProgram() and deleteShader() ///////////////////////////// |
| |
| gl.useProgram(progGood1); |
| gl.deleteProgram(progGood1); |
| gl.drawArrays(gl.TRIANGLES, 0, 4); |
| wtu.glErrorShouldBe(gl, gl.NO_ERROR, "delete the current program shouldn't change the current rendering state"); |
| |
| gl.linkProgram(progGood1); |
| wtu.glErrorShouldBe(gl, gl.NO_ERROR, "The current program shouldn't be deleted"); |
| |
| var fs3 = gl.createShader(gl.FRAGMENT_SHADER); |
| gl.shaderSource(fs3, "precision mediump float; varying vec4 vColor; void main() { gl_FragColor = vColor; }"); |
| gl.compileShader(fs3); |
| |
| assertMsg(gl.getShaderParameter(fs3, gl.COMPILE_STATUS) == true, |
| "good fragment shader should compile"); |
| |
| gl.deleteShader(fs3); |
| gl.compileShader(fs3); |
| wtu.glErrorShouldBe(gl, gl.INVALID_VALUE, "an unattached shader should be deleted immediately"); |
| |
| fs3 = gl.createShader(gl.FRAGMENT_SHADER); |
| gl.shaderSource(fs3, "precision mediump float; varying vec4 vColor; void main() { gl_FragColor = vColor; }"); |
| gl.compileShader(fs3); |
| |
| assertMsg(gl.getShaderParameter(fs3, gl.COMPILE_STATUS) == true, |
| "good fragment shader should compile"); |
| |
| gl.detachShader(progGood1, fs); |
| gl.attachShader(progGood1, fs3); |
| |
| gl.deleteShader(fs3); |
| gl.compileShader(fs3); |
| assertMsg(gl.getShaderParameter(fs3, gl.COMPILE_STATUS) == true, |
| "an attached shader shouldn't be deleted"); |
| |
| gl.useProgram(null); |
| gl.linkProgram(progGood1); |
| wtu.glErrorShouldBe(gl, gl.INVALID_VALUE, "a delete-marked program should be deleted once it's no longer the current program"); |
| |
| gl.compileShader(fs3); |
| wtu.glErrorShouldBe(gl, gl.INVALID_VALUE, "a delete-marked shader should be deleted once all its attachments are removed"); |
| |
| //////// Check linkProgram() with relinked program ////////// |
| var vs = wtu.loadShaderFromScript(gl, "vshader"); |
| var fs = wtu.loadShaderFromScript(gl, "fshader-red"); |
| var prg = wtu.createProgram(gl, vs, fs); |
| gl.useProgram(prg); |
| var posLoc = gl.getAttribLocation(prg, "a_position"); |
| wtu.setupUnitQuad(gl, posLoc); |
| wtu.clearAndDrawUnitQuad(gl); |
| wtu.checkCanvas(gl, [255, 0, 0, 255], "should be red"); |
| gl.shaderSource(fs, wtu.getScript("fshader-green")); |
| gl.compileShader(fs); |
| gl.linkProgram(prg); |
| // Program should be new program at this point without calling useProgram |
| wtu.clearAndDrawUnitQuad(gl); |
| wtu.checkCanvas(gl, [0, 255, 0, 255], "should be green"); |
| var prg = wtu.setupProgram(gl, ["vshader", "fshader-settable"], ["a_position"]); |
| var colorLoc = gl.getUniformLocation(prg, "u_color"); |
| gl.uniform4f(colorLoc, 1, 0, 0, 1); |
| wtu.clearAndDrawUnitQuad(gl); |
| wtu.checkCanvas(gl, [255, 0, 0, 255], "should be red"); |
| gl.linkProgram(prg); |
| // Program's uniforms should be cleared at this point without calling useProgram |
| wtu.clearAndDrawUnitQuad(gl, [0, 255, 0, 255]); |
| wtu.checkCanvas(gl, [0, 0, 0, 0], "should be tranparent black"); |
| wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no errors"); |
| } |
| |
| debug(""); |
| go(); |
| |
| var successfullyParsed = true; |
| </script> |
| <script src="../../js/js-test-post.js"></script> |
| |
| </body> |
| </html> |
