gl-object-get-calls.js (55732B)
1 /* 2 Copyright (c) 2019 The Khronos Group Inc. 3 Use of this source code is governed by an MIT-style license that can be 4 found in the LICENSE.txt file. 5 */ 6 7 // This test relies on the surrounding web page defining a variable 8 // "contextVersion" which indicates what version of WebGL it's running 9 // on -- 1 for WebGL 1.0, 2 for WebGL 2.0, etc. 10 11 "use strict"; 12 const wtu = WebGLTestUtils; 13 description("Test of get calls against GL objects like getBufferParameter, etc."); 14 15 let gl = wtu.create3DContext(undefined, undefined, contextVersion); 16 17 async function testInvalidArgument(funcName, argumentName, validArgumentArray, func) { 18 let validArguments = {}; 19 for (let ii = 0; ii < validArgumentArray.length; ++ii) { 20 validArguments[validArgumentArray[ii]] = true; 21 } 22 let success = true; 23 const MAX = 0x10000; 24 const STEP = Math.ceil(MAX / 10); 25 for (let ii = 0; ii < MAX; ii += 1) { 26 if (ii && ii % STEP == 0) { 27 debug(`(${ii} of ${MAX}: ${(ii/MAX*100).toFixed(1)}%)`); 28 await wtu.dispatchPromise(); // Spin the event loop. 29 } 30 if (!validArguments[ii]) { 31 let result = func(ii); 32 if (result !== null) { 33 success = false; 34 testFailed(funcName + " returned " + result + " instead of null for invalid " + argumentName + " enum: " + wtu.glEnumToString(gl, ii)); 35 break; 36 } 37 let err = gl.getError(); 38 if (err != gl.INVALID_ENUM) { 39 success = false; 40 testFailed(funcName + " did not generate INVALID_ENUM for invalid " + argumentName + " enum: " + wtu.glEnumToString(gl, ii)); 41 break; 42 } 43 } 44 } 45 if (success) { 46 testPassed(funcName + " correctly handled invalid " + argumentName + " enums"); 47 } 48 } 49 50 (async () => { 51 debug(""); 52 debug("test getBufferParameter"); 53 // Test getBufferParameter 54 let bufferTypes = [gl.ARRAY_BUFFER, gl.ELEMENT_ARRAY_BUFFER]; 55 if (contextVersion > 1) { 56 bufferTypes = bufferTypes.concat([gl.COPY_READ_BUFFER, gl.COPY_WRITE_BUFFER, gl.PIXEL_PACK_BUFFER, gl.PIXEL_UNPACK_BUFFER, gl.TRANSFORM_FEEDBACK_BUFFER, gl.UNIFORM_BUFFER]); 57 } 58 for (let bb = 0; bb < bufferTypes.length; ++bb) { 59 let bufferType = bufferTypes[bb]; 60 let buffer = gl.createBuffer(); 61 gl.bindBuffer(bufferType, buffer); 62 gl.bufferData(bufferType, 16, gl.DYNAMIC_DRAW); 63 let expression1 = "gl.getBufferParameter(" + bufferType + ", gl.BUFFER_SIZE)"; 64 let expression2 = "gl.getBufferParameter(" + bufferType + ", gl.BUFFER_USAGE)"; 65 shouldBe(expression1, '16'); 66 shouldBe(expression2, 'gl.DYNAMIC_DRAW'); 67 await testInvalidArgument("getBufferParameter", "parameter", [gl.BUFFER_SIZE, gl.BUFFER_USAGE], function(bufferType) { 68 return function(parameter) { 69 return gl.getBufferParameter(bufferType, parameter); 70 }; 71 }(bufferType)); 72 gl.bindBuffer(bufferType, null); 73 } 74 await testInvalidArgument( 75 "getBufferParameter", 76 "target", 77 bufferTypes, 78 function(target) { 79 return gl.getBufferParameter(target, gl.BUFFER_SIZE); 80 } 81 ); 82 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 83 84 let testCases = [ 85 { contextStencil: true}, 86 { contextStencil: false} 87 ]; 88 89 for (let run = 0; run < testCases.length; ++run) { 90 debug(""); 91 debug("Test getFramebufferAttachmentParameter with stencil " + testCases[run].contextStencil); 92 93 if (testCases[run].contextStencil) { 94 gl = wtu.create3DContext(null, {stencil: true}, contextVersion); 95 } else { 96 gl = wtu.create3DContext(null, {stencil: false}, contextVersion); 97 } 98 99 window.texture = gl.createTexture(); 100 window.anotherTexture = gl.createTexture(); 101 gl.bindTexture(gl.TEXTURE_2D, texture); 102 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 2, 2, 0, gl.RGBA, gl.UNSIGNED_BYTE, 103 new Uint8Array([ 104 0, 0, 0, 255, 105 255, 255, 255, 255, 106 255, 255, 255, 255, 107 0, 0, 0, 255])); 108 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR); 109 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); 110 gl.bindTexture(gl.TEXTURE_2D, null); 111 window.framebuffer = gl.createFramebuffer(); 112 gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); 113 gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0); 114 let colorAttachmentsNum = 1; 115 if (contextVersion > 1) { 116 gl.bindTexture(gl.TEXTURE_2D, anotherTexture); 117 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 2, 2, 0, gl.RGBA, gl.UNSIGNED_BYTE, 118 new Uint8Array([ 119 0, 0, 0, 255, 120 255, 255, 255, 255, 121 255, 255, 255, 255, 122 0, 0, 0, 255])); 123 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR); 124 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); 125 gl.bindTexture(gl.TEXTURE_2D, null); 126 colorAttachmentsNum = gl.getParameter(gl.MAX_COLOR_ATTACHMENTS); 127 gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + colorAttachmentsNum - 1, gl.TEXTURE_2D, anotherTexture, 0); 128 } 129 window.renderbuffer = gl.createRenderbuffer(); 130 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 131 gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer); 132 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 133 if (contextVersion == 1) 134 gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, 2, 2); 135 else 136 gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH24_STENCIL8, 2, 2); 137 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 138 gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, renderbuffer); 139 if (contextVersion > 1) 140 gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.RENDERBUFFER, renderbuffer); 141 shouldBe('gl.checkFramebufferStatus(gl.FRAMEBUFFER)', 'gl.FRAMEBUFFER_COMPLETE'); 142 // The for loop tests two color attachments for WebGL 2: the first one (gl.COLOR_ATTACHMENT0) 143 // and the last one (gl.COLOR_ATTACHMENT0 + gl.MAX_COLOR_ATTACHMENTS - 1). 144 for (let ii = 0; ii < colorAttachmentsNum; ii += (colorAttachmentsNum > 1 ? colorAttachmentsNum - 1 : 1)) { 145 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.TEXTURE'); 146 if (ii == 0) 147 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)', 'texture'); 148 else 149 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)', 'anotherTexture'); 150 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL)', '0'); 151 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE)', '0'); 152 if (contextVersion > 1) { 153 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_RED_SIZE)'); 154 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_GREEN_SIZE)'); 155 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_BLUE_SIZE)'); 156 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE)'); 157 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE)'); 158 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING)'); 159 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + ' + ii + ', gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER)', '0'); 160 } 161 } 162 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.RENDERBUFFER'); 163 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)', 'renderbuffer'); 164 if (contextVersion > 1) { 165 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.RENDERBUFFER'); 166 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)', 'renderbuffer'); 167 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.RENDERBUFFER'); 168 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)', 'renderbuffer'); 169 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE)'); 170 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE)'); 171 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE)'); 172 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING)'); 173 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE)'); 174 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING)'); 175 wtu.shouldGenerateGLError(gl, gl.INVALID_OPERATION, 'gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE)'); 176 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING)'); 177 } 178 let validParametersForFBAttachment = 179 [ gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, 180 gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, 181 gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL, 182 gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 183 ]; 184 if (contextVersion > 1) { 185 validParametersForFBAttachment = validParametersForFBAttachment.concat([ 186 gl.FRAMEBUFFER_ATTACHMENT_RED_SIZE, 187 gl.FRAMEBUFFER_ATTACHMENT_GREEN_SIZE, 188 gl.FRAMEBUFFER_ATTACHMENT_BLUE_SIZE, 189 gl.FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE, 190 gl.FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE, 191 gl.FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE, 192 gl.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE, 193 gl.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING, 194 gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 195 ]); 196 } 197 await testInvalidArgument( 198 "getFramebufferAttachmentParameter", 199 "parameter", 200 validParametersForFBAttachment, 201 function(parameter) { 202 return gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT, parameter); 203 } 204 ); 205 let validTargetsForFBAttachment = [gl.FRAMEBUFFER]; 206 if (contextVersion > 1) { 207 validTargetsForFBAttachment = validTargetsForFBAttachment.concat([gl.READ_FRAMEBUFFER, gl.DRAW_FRAMEBUFFER]); 208 } 209 await testInvalidArgument( 210 "getFramebufferAttachmentParameter", 211 "target", 212 validTargetsForFBAttachment, 213 function(target) { 214 return gl.getFramebufferAttachmentParameter(target, gl.COLOR_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE); 215 } 216 ); 217 let validAttachmentsForFBAttachment = new Array( 218 gl.COLOR_ATTACHMENT0, 219 gl.DEPTH_ATTACHMENT, 220 gl.STENCIL_ATTACHMENT, 221 gl.DEPTH_STENCIL_ATTACHMENT 222 ); 223 if (contextVersion > 1) { 224 for (let ii = 1; ii < gl.getParameter(gl.MAX_COLOR_ATTACHMENTS); ++ii) { 225 validAttachmentsForFBAttachment[validAttachmentsForFBAttachment.length] = gl.COLOR_ATTACHMENT0 + ii; 226 } 227 } 228 await testInvalidArgument( 229 "getFramebufferAttachmentParameter", 230 "attachment", 231 validAttachmentsForFBAttachment, 232 function(attachment) { 233 return gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, attachment, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE); 234 } 235 ); 236 if (contextVersion > 1) { 237 // test default framebuffer 238 gl.bindFramebuffer(gl.FRAMEBUFFER, null); 239 shouldBe('gl.checkFramebufferStatus(gl.FRAMEBUFFER)', 'gl.FRAMEBUFFER_COMPLETE'); 240 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.BACK, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.FRAMEBUFFER_DEFAULT'); 241 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.FRAMEBUFFER_DEFAULT'); 242 if (testCases[run].contextStencil) 243 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.FRAMEBUFFER_DEFAULT'); 244 else 245 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.NONE'); 246 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.BACK, gl.FRAMEBUFFER_ATTACHMENT_RED_SIZE)'); 247 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.BACK, gl.FRAMEBUFFER_ATTACHMENT_GREEN_SIZE)'); 248 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.BACK, gl.FRAMEBUFFER_ATTACHMENT_BLUE_SIZE)'); 249 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.BACK, gl.FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE)'); 250 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH, gl.FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE)'); 251 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.BACK, gl.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE)'); 252 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.BACK, gl.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING)'); 253 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH, gl.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE)'); 254 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH, gl.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING)'); 255 if (testCases[run].contextStencil) { 256 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL, gl.FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE)'); 257 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL, gl.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE)'); 258 shouldBeNonZero('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL, gl.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING)'); 259 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 260 } else { 261 wtu.shouldGenerateGLError(gl, gl.INVALID_OPERATION, 'gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL, gl.FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE)'); 262 wtu.shouldGenerateGLError(gl, gl.INVALID_OPERATION, 'gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL, gl.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE)'); 263 wtu.shouldGenerateGLError(gl, gl.INVALID_OPERATION, 'gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL, gl.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING)'); 264 } 265 await testInvalidArgument( 266 "getFramebufferAttachmentParameter", 267 "parameter", 268 validParametersForFBAttachment, 269 function(parameter) { 270 return gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.BACK, parameter); 271 } 272 ); 273 await testInvalidArgument( 274 "getFramebufferAttachmentParameter", 275 "target", 276 validTargetsForFBAttachment, 277 function(target) { 278 return gl.getFramebufferAttachmentParameter(target, gl.BACK, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE); 279 } 280 ); 281 await testInvalidArgument( 282 "getFramebufferAttachmentParameter", 283 "attachment", 284 [ gl.BACK, 285 gl.DEPTH, 286 gl.STENCIL 287 ], 288 function(attachment) { 289 return gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, attachment, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE); 290 } 291 ); 292 } 293 } 294 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 295 296 debug(""); 297 debug("test getAttachedShaders"); 298 window.standardVert = wtu.loadStandardVertexShader(gl); 299 window.standardFrag = wtu.loadStandardFragmentShader(gl); 300 window.standardProgram = gl.createProgram(); 301 gl.attachShader(standardProgram, standardVert); 302 gl.attachShader(standardProgram, standardFrag); 303 gl.linkProgram(standardProgram); 304 window.shaders = gl.getAttachedShaders(standardProgram); 305 shouldBe('shaders.length', '2'); 306 shouldBeTrue('shaders[0] == standardVert && shaders[1] == standardFrag || shaders[1] == standardVert && shaders[0] == standardFrag'); 307 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 308 shouldThrow('gl.getAttachedShaders(null)'); 309 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 310 shouldThrow('gl.getAttachedShaders(standardVert)'); 311 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 312 313 debug(""); 314 debug("Test getProgramParameter"); 315 shouldBe('gl.getProgramParameter(standardProgram, gl.DELETE_STATUS)', 'false'); 316 shouldBe('gl.getProgramParameter(standardProgram, gl.LINK_STATUS)', 'true'); 317 shouldBe('typeof gl.getProgramParameter(standardProgram, gl.VALIDATE_STATUS)', '"boolean"'); 318 shouldBe('gl.getProgramParameter(standardProgram, gl.ATTACHED_SHADERS)', '2'); 319 shouldBe('gl.getProgramParameter(standardProgram, gl.ACTIVE_ATTRIBUTES)', '2'); 320 shouldBe('gl.getProgramParameter(standardProgram, gl.ACTIVE_UNIFORMS)', '1'); 321 if (contextVersion > 1) { 322 let buffer = gl.createBuffer(); 323 gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, buffer); 324 gl.bufferData(gl.TRANSFORM_FEEDBACK_BUFFER, 1024, gl.DYNAMIC_DRAW); 325 window.uniformBlockProgram = wtu.loadUniformBlockProgram(gl); 326 let transformFeedbackVars = ["normal", "ecPosition"]; 327 gl.transformFeedbackVaryings(uniformBlockProgram, transformFeedbackVars, gl.INTERLEAVED_ATTRIBS); 328 gl.linkProgram(uniformBlockProgram); 329 shouldBe('gl.getProgramParameter(uniformBlockProgram, gl.LINK_STATUS)', 'true'); 330 shouldBe('gl.getError()', 'gl.NO_ERROR'); 331 shouldBe('gl.getProgramParameter(uniformBlockProgram, gl.ACTIVE_UNIFORM_BLOCKS)', '1'); 332 shouldBe('gl.getProgramParameter(uniformBlockProgram, gl.TRANSFORM_FEEDBACK_VARYINGS)', '2'); 333 shouldBe('gl.getProgramParameter(uniformBlockProgram, gl.TRANSFORM_FEEDBACK_BUFFER_MODE)', 'gl.INTERLEAVED_ATTRIBS'); 334 } 335 window.program = standardProgram; 336 let validArrayForProgramParameter = [ 337 gl.DELETE_STATUS, 338 gl.LINK_STATUS, 339 gl.VALIDATE_STATUS, 340 gl.ATTACHED_SHADERS, 341 gl.ACTIVE_ATTRIBUTES, 342 gl.ACTIVE_UNIFORMS 343 ]; 344 if (contextVersion > 1) { 345 validArrayForProgramParameter = validArrayForProgramParameter.concat([ 346 gl.ACTIVE_UNIFORM_BLOCKS, 347 gl.TRANSFORM_FEEDBACK_VARYINGS, 348 gl.TRANSFORM_FEEDBACK_BUFFER_MODE 349 ]); 350 program = uniformBlockProgram; 351 } 352 await testInvalidArgument( 353 "getProgramParameter", 354 "parameter", 355 validArrayForProgramParameter, 356 function(parameter) { 357 return gl.getProgramParameter(program, parameter); 358 } 359 ); 360 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 361 362 debug(""); 363 debug("Test getRenderbufferParameter"); 364 shouldBe('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_WIDTH)', '2'); 365 shouldBe('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_HEIGHT)', '2'); 366 // Note: we can't test the actual value of the internal format since 367 // the implementation is allowed to change it. 368 shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_INTERNAL_FORMAT)'); 369 shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_DEPTH_SIZE)'); 370 let colorbuffer = gl.createRenderbuffer(); 371 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 372 gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer); 373 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 374 gl.renderbufferStorage(gl.RENDERBUFFER, gl.RGBA4, 2, 2); 375 shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_RED_SIZE)'); 376 shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_GREEN_SIZE)'); 377 shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_BLUE_SIZE)'); 378 shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_ALPHA_SIZE)'); 379 if (contextVersion > 1) { 380 gl.renderbufferStorageMultisample(gl.RENDERBUFFER, 4, gl.RGBA4, 2, 2); 381 shouldBe('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_SAMPLES)', '4'); 382 } 383 let validArrayForRenderbuffer = new Array( 384 gl.RENDERBUFFER_WIDTH, 385 gl.RENDERBUFFER_HEIGHT, 386 gl.RENDERBUFFER_INTERNAL_FORMAT, 387 gl.RENDERBUFFER_RED_SIZE, 388 gl.RENDERBUFFER_GREEN_SIZE, 389 gl.RENDERBUFFER_BLUE_SIZE, 390 gl.RENDERBUFFER_ALPHA_SIZE, 391 gl.RENDERBUFFER_DEPTH_SIZE, 392 gl.RENDERBUFFER_STENCIL_SIZE 393 ); 394 if (contextVersion > 1) { 395 validArrayForRenderbuffer[validArrayForRenderbuffer.length] = gl.RENDERBUFFER_SAMPLES; 396 } 397 await testInvalidArgument( 398 "getRenderbufferParameter", 399 "parameter", 400 validArrayForRenderbuffer, 401 function(parameter) { 402 return gl.getRenderbufferParameter(gl.RENDERBUFFER, parameter); 403 }); 404 await testInvalidArgument( 405 "getRenderbufferParameter", 406 "target", 407 [ gl.RENDERBUFFER ], 408 function(target) { 409 return gl.getRenderbufferParameter(target, gl.RENDERBUFFER_WIDTH); 410 } 411 ); 412 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 413 414 debug(""); 415 debug("Test getShaderParameter"); 416 shouldBe('gl.getShaderParameter(standardVert, gl.SHADER_TYPE)', 'gl.VERTEX_SHADER'); 417 shouldBe('gl.getShaderParameter(standardVert, gl.DELETE_STATUS)', 'false'); 418 shouldBe('gl.getShaderParameter(standardVert, gl.COMPILE_STATUS)', 'true'); 419 await testInvalidArgument( 420 "getShaderParameter", 421 "parameter", 422 [ gl.DELETE_STATUS, 423 gl.COMPILE_STATUS, 424 gl.SHADER_TYPE 425 ], 426 function(parameter) { 427 return gl.getShaderParameter(standardVert, parameter); 428 } 429 ); 430 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 431 432 debug(""); 433 debug("Test getTexParameter"); 434 gl.bindTexture(gl.TEXTURE_2D, texture); 435 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST); 436 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST); 437 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); 438 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); 439 shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER)', 'gl.NEAREST'); 440 shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER)', 'gl.NEAREST'); 441 shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S)', 'gl.CLAMP_TO_EDGE'); 442 shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T)', 'gl.CLAMP_TO_EDGE'); 443 if (contextVersion > 1) { 444 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_BASE_LEVEL, 0); 445 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_COMPARE_FUNC, gl.LEQUAL); 446 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_COMPARE_MODE, gl.COMPARE_REF_TO_TEXTURE); 447 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAX_LEVEL, 10); 448 gl.texParameterf(gl.TEXTURE_2D, gl.TEXTURE_MAX_LOD, 10); 449 gl.texParameterf(gl.TEXTURE_2D, gl.TEXTURE_MIN_LOD, 0); 450 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_R, gl.CLAMP_TO_EDGE); 451 shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_BASE_LEVEL)', '0'); 452 shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_COMPARE_FUNC)', 'gl.LEQUAL'); 453 shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_COMPARE_MODE)', 'gl.COMPARE_REF_TO_TEXTURE'); 454 shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_MAX_LEVEL)', '10'); 455 shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_MAX_LOD)', '10'); 456 shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_MIN_LOD)', '0'); 457 shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_WRAP_R)', 'gl.CLAMP_TO_EDGE'); 458 shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_IMMUTABLE_FORMAT)', 'false'); 459 shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_IMMUTABLE_LEVELS)', '0'); 460 } 461 let validParametersForTexture = [ 462 gl.TEXTURE_MAG_FILTER, 463 gl.TEXTURE_MIN_FILTER, 464 gl.TEXTURE_WRAP_S, 465 gl.TEXTURE_WRAP_T, 466 ]; 467 if (contextVersion > 1) { 468 validParametersForTexture = validParametersForTexture.concat([ 469 gl.TEXTURE_BASE_LEVEL, 470 gl.TEXTURE_COMPARE_FUNC, 471 gl.TEXTURE_COMPARE_MODE, 472 gl.TEXTURE_MAX_LEVEL, 473 gl.TEXTURE_MAX_LOD, 474 gl.TEXTURE_MIN_LOD, 475 gl.TEXTURE_WRAP_R, 476 gl.TEXTURE_IMMUTABLE_FORMAT, 477 gl.TEXTURE_IMMUTABLE_LEVELS, 478 ]); 479 } 480 await testInvalidArgument( 481 "getTexParameter", 482 "parameter", 483 validParametersForTexture, 484 function(parameter) { 485 return gl.getTexParameter(gl.TEXTURE_2D, parameter); 486 } 487 ); 488 let validTargetsForTexture = [ gl.TEXTURE_2D, gl.TEXTURE_CUBE_MAP]; 489 if (contextVersion > 1) { 490 validTargetsForTexture = validTargetsForTexture.concat([ gl.TEXTURE_3D, gl.TEXTURE_2D_ARRAY]); 491 } 492 await testInvalidArgument( 493 "getTexParameter", 494 "target", 495 validTargetsForTexture, 496 function(target) { 497 return gl.getTexParameter(target, gl.TEXTURE_MAG_FILTER); 498 } 499 ); 500 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 501 502 debug(""); 503 debug("Test getUniform with all variants of data types"); 504 debug("Boolean uniform variables"); 505 window.boolProgram = wtu.loadProgramFromFile(gl, "../../resources/boolUniformShader.vert", "../../resources/noopUniformShader.frag"); 506 shouldBe('gl.getProgramParameter(boolProgram, gl.LINK_STATUS)', 'true'); 507 window.bvalLoc = gl.getUniformLocation(boolProgram, "bval"); 508 window.bval2Loc = gl.getUniformLocation(boolProgram, "bval2"); 509 window.bval3Loc = gl.getUniformLocation(boolProgram, "bval3"); 510 window.bval4Loc = gl.getUniformLocation(boolProgram, "bval4"); 511 gl.useProgram(boolProgram); 512 gl.uniform1i(bvalLoc, 1); 513 gl.uniform2i(bval2Loc, 1, 0); 514 gl.uniform3i(bval3Loc, 1, 0, 1); 515 gl.uniform4i(bval4Loc, 1, 0, 1, 0); 516 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 517 shouldBe('gl.getUniform(boolProgram, bvalLoc)', 'true'); 518 shouldBe('gl.getUniform(boolProgram, bval2Loc)', '[true, false]'); 519 shouldBe('gl.getUniform(boolProgram, bval3Loc)', '[true, false, true]'); 520 shouldBe('gl.getUniform(boolProgram, bval4Loc)', '[true, false, true, false]'); 521 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 522 523 debug("Integer uniform variables"); 524 window.intProgram = wtu.loadProgramFromFile(gl, "../../resources/intUniformShader.vert", "../../resources/noopUniformShader.frag"); 525 shouldBe('gl.getProgramParameter(intProgram, gl.LINK_STATUS)', 'true'); 526 window.ivalLoc = gl.getUniformLocation(intProgram, "ival"); 527 window.ival2Loc = gl.getUniformLocation(intProgram, "ival2"); 528 window.ival3Loc = gl.getUniformLocation(intProgram, "ival3"); 529 window.ival4Loc = gl.getUniformLocation(intProgram, "ival4"); 530 gl.useProgram(intProgram); 531 gl.uniform1i(ivalLoc, 1); 532 gl.uniform2i(ival2Loc, 2, 3); 533 gl.uniform3i(ival3Loc, 4, 5, 6); 534 gl.uniform4i(ival4Loc, 7, 8, 9, 10); 535 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 536 shouldBe('gl.getUniform(intProgram, ivalLoc)', '1'); 537 shouldBe('gl.getUniform(intProgram, ival2Loc)', '[2, 3]'); 538 shouldBe('gl.getUniform(intProgram, ival3Loc)', '[4, 5, 6]'); 539 shouldBe('gl.getUniform(intProgram, ival4Loc)', '[7, 8, 9, 10]'); 540 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 541 542 debug("Float uniform variables"); 543 window.floatProgram = wtu.loadProgramFromFile(gl, "../../resources/floatUniformShader.vert", "../../resources/noopUniformShader.frag"); 544 shouldBe('gl.getProgramParameter(floatProgram, gl.LINK_STATUS)', 'true'); 545 window.fvalLoc = gl.getUniformLocation(floatProgram, "fval"); 546 window.fval2Loc = gl.getUniformLocation(floatProgram, "fval2"); 547 window.fval3Loc = gl.getUniformLocation(floatProgram, "fval3"); 548 window.fval4Loc = gl.getUniformLocation(floatProgram, "fval4"); 549 gl.useProgram(floatProgram); 550 gl.uniform1f(fvalLoc, 11); 551 gl.uniform2f(fval2Loc, 12, 13); 552 gl.uniform3f(fval3Loc, 14, 15, 16); 553 gl.uniform4f(fval4Loc, 17, 18, 19, 20); 554 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 555 shouldBe('gl.getUniform(floatProgram, fvalLoc)', '11'); 556 shouldBe('gl.getUniform(floatProgram, fval2Loc)', '[12, 13]'); 557 shouldBe('gl.getUniform(floatProgram, fval3Loc)', '[14, 15, 16]'); 558 shouldBe('gl.getUniform(floatProgram, fval4Loc)', '[17, 18, 19, 20]'); 559 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 560 561 debug("Sampler uniform variables"); 562 window.samplerProgram = wtu.loadProgramFromFile(gl, "../../resources/noopUniformShader.vert", "../../resources/samplerUniformShader.frag"); 563 shouldBe('gl.getProgramParameter(samplerProgram, gl.LINK_STATUS)', 'true'); 564 window.s2DValLoc = gl.getUniformLocation(samplerProgram, "s2D"); 565 window.sCubeValLoc = gl.getUniformLocation(samplerProgram, "sCube"); 566 gl.useProgram(samplerProgram); 567 gl.uniform1i(s2DValLoc, 0); 568 gl.uniform1i(sCubeValLoc, 1); 569 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 570 shouldBe('gl.getUniform(samplerProgram, s2DValLoc)', '0'); 571 shouldBe('gl.getUniform(samplerProgram, sCubeValLoc)', '1'); 572 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 573 574 debug("Matrix uniform variables"); 575 window.matProgram = wtu.loadProgramFromFile(gl, "../../resources/matUniformShader.vert", "../../resources/noopUniformShader.frag"); 576 shouldBe('gl.getProgramParameter(matProgram, gl.LINK_STATUS)', 'true'); 577 window.mval2Loc = gl.getUniformLocation(matProgram, "mval2"); 578 window.mval3Loc = gl.getUniformLocation(matProgram, "mval3"); 579 window.mval4Loc = gl.getUniformLocation(matProgram, "mval4"); 580 gl.useProgram(matProgram); 581 gl.uniformMatrix2fv(mval2Loc, false, [1, 2, 3, 4]); 582 gl.uniformMatrix3fv(mval3Loc, false, [5, 6, 7, 8, 9, 10, 11, 12, 13]); 583 gl.uniformMatrix4fv(mval4Loc, false, [14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]); 584 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 585 shouldBe('gl.getUniform(matProgram, mval2Loc)', '[1, 2, 3, 4]'); 586 shouldBe('gl.getUniform(matProgram, mval3Loc)', '[5, 6, 7, 8, 9, 10, 11, 12, 13]'); 587 shouldBe('gl.getUniform(matProgram, mval4Loc)', '[14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]'); 588 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 589 590 if (contextVersion > 1) { 591 debug("Unsigned Integer uniform variables"); 592 window.uintProgram = wtu.loadProgramFromFile(gl, "../../resources/uintUniformShader.vert", "../../resources/noopUniformShaderES3.frag"); 593 shouldBe('gl.getProgramParameter(uintProgram, gl.LINK_STATUS)', 'true'); 594 window.uvalLoc = gl.getUniformLocation(uintProgram, "uval"); 595 window.uval2Loc = gl.getUniformLocation(uintProgram, "uval2"); 596 window.uval3Loc = gl.getUniformLocation(uintProgram, "uval3"); 597 window.uval4Loc = gl.getUniformLocation(uintProgram, "uval4"); 598 gl.useProgram(uintProgram); 599 gl.uniform1ui(uvalLoc, 1); 600 gl.uniform2ui(uval2Loc, 2, 3); 601 gl.uniform3ui(uval3Loc, 4, 5, 6); 602 gl.uniform4ui(uval4Loc, 7, 8, 9, 10); 603 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 604 shouldBe('gl.getUniform(uintProgram, uvalLoc)', '1'); 605 shouldBe('gl.getUniform(uintProgram, uval2Loc)', '[2, 3]'); 606 shouldBe('gl.getUniform(uintProgram, uval3Loc)', '[4, 5, 6]'); 607 shouldBe('gl.getUniform(uintProgram, uval4Loc)', '[7, 8, 9, 10]'); 608 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 609 610 debug("Matrix uniform variables for WebGL 2"); 611 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 612 613 window.matForWebGL2Program = wtu.loadProgramFromFile(gl, "../../resources/matForWebGL2UniformShader.vert", "../../resources/noopUniformShaderES3.frag"); 614 shouldBe('gl.getProgramParameter(matForWebGL2Program, gl.LINK_STATUS)', 'true'); 615 window.mval2x3Loc = gl.getUniformLocation(matForWebGL2Program, "mval2x3"); 616 window.mval2x4Loc = gl.getUniformLocation(matForWebGL2Program, "mval2x4"); 617 window.mval3x2Loc = gl.getUniformLocation(matForWebGL2Program, "mval3x2"); 618 window.mval3x4Loc = gl.getUniformLocation(matForWebGL2Program, "mval3x4"); 619 window.mval4x2Loc = gl.getUniformLocation(matForWebGL2Program, "mval4x2"); 620 window.mval4x3Loc = gl.getUniformLocation(matForWebGL2Program, "mval4x3"); 621 gl.useProgram(matForWebGL2Program); 622 gl.uniformMatrix2x3fv(mval2x3Loc, false, [1, 2, 3, 4, 5, 6]); 623 gl.uniformMatrix2x4fv(mval2x4Loc, false, [7, 8, 9, 10, 11, 12, 13, 14]); 624 gl.uniformMatrix3x2fv(mval3x2Loc, false, [15, 16, 17, 18, 19, 20]); 625 gl.uniformMatrix3x4fv(mval3x4Loc, false, [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]); 626 gl.uniformMatrix4x2fv(mval4x2Loc, false, [33, 34, 35, 36, 37, 38, 39, 40]); 627 gl.uniformMatrix4x3fv(mval4x3Loc, false, [41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52]); 628 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 629 shouldBe('gl.getUniform(matForWebGL2Program, mval2x3Loc)', '[1, 2, 3, 4, 5, 6]'); 630 shouldBe('gl.getUniform(matForWebGL2Program, mval2x4Loc)', '[7, 8, 9, 10, 11, 12, 13, 14]'); 631 shouldBe('gl.getUniform(matForWebGL2Program, mval3x2Loc)', '[15, 16, 17, 18, 19, 20]'); 632 shouldBe('gl.getUniform(matForWebGL2Program, mval3x4Loc)', '[21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]'); 633 shouldBe('gl.getUniform(matForWebGL2Program, mval4x2Loc)', '[33, 34, 35, 36, 37, 38, 39, 40]'); 634 shouldBe('gl.getUniform(matForWebGL2Program, mval4x3Loc)', '[41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52]'); 635 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 636 637 debug("Sampler uniform variables for WebGL2"); 638 window.samplerForWebGL2Program = wtu.loadProgramFromFile(gl, "../../resources/noopUniformShaderES3.vert", "../../resources/samplerForWebGL2UniformShader.frag"); 639 shouldBe('gl.getProgramParameter(samplerForWebGL2Program, gl.LINK_STATUS)', 'true'); 640 window.s3DValLoc = gl.getUniformLocation(samplerForWebGL2Program, "s3D"); 641 window.s2DArrayValLoc = gl.getUniformLocation(samplerForWebGL2Program, "s2DArray"); 642 gl.useProgram(samplerForWebGL2Program); 643 gl.uniform1i(s3DValLoc, 0); 644 gl.uniform1i(s2DArrayValLoc, 1); 645 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 646 shouldBe('gl.getUniform(samplerForWebGL2Program, s3DValLoc)', '0'); 647 shouldBe('gl.getUniform(samplerForWebGL2Program, s2DArrayValLoc)', '1'); 648 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 649 } 650 651 debug(""); 652 debug("test getVertexAttrib"); 653 let array = new Float32Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]); 654 window.buffer = gl.createBuffer(); 655 gl.bindBuffer(gl.ARRAY_BUFFER, buffer); 656 gl.bufferData(gl.ARRAY_BUFFER, array, gl.DYNAMIC_DRAW); 657 // Vertex attribute 0 is special in that it has no current state, so 658 // fetching GL_CURRENT_VERTEX_ATTRIB generates an error. Use attribute 659 // 1 for these tests instead. 660 gl.enableVertexAttribArray(1); 661 gl.vertexAttribPointer(1, 4, gl.FLOAT, false, 0, 0); 662 shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING)', 'buffer'); 663 shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_ENABLED)', 'true'); 664 shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_SIZE)', '4'); 665 // Stride MUST be the value the user put in. 666 shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_STRIDE)', '0'); 667 shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_TYPE)', 'gl.FLOAT'); 668 shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_NORMALIZED)', 'false'); 669 if (contextVersion > 1) { 670 shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_DIVISOR)', '0'); 671 shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_INTEGER)', 'false'); 672 gl.vertexAttribDivisor(1, 2); 673 shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_DIVISOR)', '2'); 674 } 675 gl.vertexAttribPointer(1, 4, gl.FLOAT, false, 36, 12); 676 shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_STRIDE)', '36'); 677 shouldBe('gl.getVertexAttribOffset(1, gl.VERTEX_ATTRIB_ARRAY_POINTER)', '12'); 678 gl.disableVertexAttribArray(1); 679 shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_ENABLED)', 'false'); 680 gl.vertexAttrib4f(1, 5, 6, 7, 8); 681 shouldBe('gl.getVertexAttrib(1, gl.CURRENT_VERTEX_ATTRIB)', '[5, 6, 7, 8]'); 682 if (contextVersion > 1) { 683 let intArray = new Int32Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]); 684 gl.bufferData(gl.ARRAY_BUFFER, intArray, gl.DYNAMIC_DRAW); 685 gl.enableVertexAttribArray(1); 686 // feed fixed-point data to buffer 687 gl.vertexAttribIPointer(1, 4, gl.INT, false, 0, 0); 688 shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_TYPE)', 'gl.INT'); 689 shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_INTEGER)', 'true'); 690 } 691 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 692 let validArrayForVertexAttrib = new Array( 693 gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, 694 gl.VERTEX_ATTRIB_ARRAY_ENABLED, 695 gl.VERTEX_ATTRIB_ARRAY_SIZE, 696 gl.VERTEX_ATTRIB_ARRAY_STRIDE, 697 gl.VERTEX_ATTRIB_ARRAY_TYPE, 698 gl.VERTEX_ATTRIB_ARRAY_NORMALIZED, 699 gl.CURRENT_VERTEX_ATTRIB 700 ); 701 if (contextVersion > 1) { 702 validArrayForVertexAttrib[validArrayForVertexAttrib.length] = gl.VERTEX_ATTRIB_ARRAY_DIVISOR; 703 validArrayForVertexAttrib[validArrayForVertexAttrib.length] = gl.VERTEX_ATTRIB_ARRAY_INTEGER; 704 } 705 await testInvalidArgument( 706 "getVertexAttrib", 707 "parameter", 708 validArrayForVertexAttrib, 709 function(parameter) { 710 return gl.getVertexAttrib(1, parameter); 711 } 712 ); 713 let numVertexAttribs = gl.getParameter(gl.MAX_VERTEX_ATTRIBS); 714 wtu.shouldGenerateGLError(gl, gl.INVALID_VALUE, 'gl.getVertexAttrib(' + numVertexAttribs + ', gl.CURRENT_VERTEX_ATTRIB)'); 715 716 debug(""); 717 debug("Test cases where name == 0"); 718 gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); 719 720 shouldNotBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.NONE'); 721 gl.deleteTexture(texture); 722 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.NONE'); 723 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 724 725 shouldNotBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.NONE'); 726 gl.deleteRenderbuffer(renderbuffer); 727 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.NONE'); 728 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 729 730 gl.deleteBuffer(buffer); 731 shouldBeNull('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING)'); 732 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 733 734 if (contextVersion > 1) { 735 debug(""); 736 debug("Test getInternalformatParameter") 737 738 shouldBeNonNull('gl.getInternalformatParameter(gl.RENDERBUFFER, gl.R32I, gl.SAMPLES)'); 739 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 740 741 await testInvalidArgument( 742 "getInternalformatParameter", 743 "target", 744 [ gl.RENDERBUFFER ], 745 function(target) { 746 return gl.getInternalformatParameter(target, gl.R32I, gl.SAMPLES); 747 }); 748 749 await testInvalidArgument( 750 "getInternalformatParameter", 751 "pname", 752 [ gl.SAMPLES ], 753 function(pname) { 754 return gl.getInternalformatParameter(gl.RENDERBUFFER, gl.RGBA4, pname); 755 }); 756 757 let validArrayForInterformat = new Array( 758 gl.R8, gl.R8_SNORM, gl.RG8, gl.RG8_SNORM, 759 gl.RGB8, gl.RGB8_SNORM, gl.RGB565, gl.RGBA4, 760 gl.RGB5_A1, gl.RGBA8, gl.RGBA8_SNORM, gl.RGB10_A2, 761 gl.RGB10_A2UI, gl.SRGB8, gl.SRGB8_ALPHA8, gl.R16F, 762 gl.RG16F, gl.RGB16F, gl.RGBA16F, gl.R32F, 763 gl.RG32F, gl.RGB32F, gl.RGBA32F, gl.R11F_G11F_B10F, 764 gl.RGB9_E5, gl.R8I, gl.R8UI, gl.R16I, 765 gl.R16UI, gl.R32I, gl.R32UI, gl.RG8I, 766 gl.RG8UI, gl.RG16I, gl.RG16UI, gl.RG32I, 767 gl.RG32UI, gl.RGB8I, gl.RGB8UI, gl.RGB16I, 768 gl.RGB16UI, gl.RGB32I, gl.RGB32UI, gl.RGBA8I, 769 gl.RGBA8UI, gl.RGBA16I, gl.RGBA16UI, gl.RGBA32I, 770 gl.RGBA32UI, gl.RGB, gl.RGBA, gl.DEPTH_STENCIL, gl.DEPTH_COMPONENT16, 771 gl.DEPTH_COMPONENT24, gl.DEPTH_COMPONENT32F, gl.DEPTH24_STENCIL8, 772 gl.DEPTH32F_STENCIL8, gl.STENCIL_INDEX8 773 ); 774 await testInvalidArgument( 775 "getInternalformatParameter", 776 "internalformat", 777 validArrayForInterformat, 778 function(internalformat) { 779 return gl.getInternalformatParameter(gl.RENDERBUFFER, internalformat, gl.SAMPLES); 780 }); 781 782 783 debug(""); 784 debug("Test getIndexedParameter"); 785 window.buffer = gl.createBuffer(); 786 gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, buffer); 787 gl.bufferData(gl.TRANSFORM_FEEDBACK_BUFFER, 64, gl.DYNAMIC_DRAW); 788 gl.bindBufferRange(gl.TRANSFORM_FEEDBACK_BUFFER, 0, buffer, 4, 8); 789 shouldBe('gl.getIndexedParameter(gl.TRANSFORM_FEEDBACK_BUFFER_BINDING, 0)', 'buffer'); 790 shouldBe('gl.getIndexedParameter(gl.TRANSFORM_FEEDBACK_BUFFER_SIZE, 0)', '8'); 791 shouldBe('gl.getIndexedParameter(gl.TRANSFORM_FEEDBACK_BUFFER_START, 0)', '4'); 792 window.buffer1 = gl.createBuffer(); 793 gl.bindBuffer(gl.UNIFORM_BUFFER, buffer1); 794 gl.bufferData(gl.UNIFORM_BUFFER, 64, gl.DYNAMIC_DRAW); 795 window.offsetUniform = gl.getParameter(gl.UNIFORM_BUFFER_OFFSET_ALIGNMENT); 796 gl.bindBufferRange(gl.UNIFORM_BUFFER, 1, buffer1, offsetUniform, 8); 797 shouldBe('gl.getIndexedParameter(gl.UNIFORM_BUFFER_BINDING, 1)', 'buffer1'); 798 shouldBe('gl.getIndexedParameter(gl.UNIFORM_BUFFER_SIZE, 1)', '8'); 799 shouldBe('gl.getIndexedParameter(gl.UNIFORM_BUFFER_START, 1)', 'offsetUniform'); 800 801 gl.bindBufferBase(gl.UNIFORM_BUFFER, 1, null); 802 shouldBe('gl.getIndexedParameter(gl.UNIFORM_BUFFER_BINDING, 1)', 'null'); 803 804 let validArrayForTarget = new Array( 805 gl.TRANSFORM_FEEDBACK_BUFFER_BINDING, 806 gl.TRANSFORM_FEEDBACK_BUFFER_SIZE, 807 gl.TRANSFORM_FEEDBACK_BUFFER_START, 808 gl.UNIFORM_BUFFER_BINDING, 809 gl.UNIFORM_BUFFER_SIZE, 810 gl.UNIFORM_BUFFER_START 811 ); 812 await testInvalidArgument( 813 "getIndexedParameter", 814 "target", 815 validArrayForTarget, 816 function(target) { 817 return gl.getIndexedParameter(target, 0); 818 }); 819 820 debug(""); 821 debug("Test getSamplerParameter"); 822 window.sampler = gl.createSampler(); 823 gl.samplerParameteri(sampler, gl.TEXTURE_COMPARE_FUNC, gl.LEQUAL); 824 gl.samplerParameteri(sampler, gl.TEXTURE_COMPARE_MODE, gl.COMPARE_REF_TO_TEXTURE); 825 gl.samplerParameteri(sampler, gl.TEXTURE_MAG_FILTER, gl.NEAREST); 826 gl.samplerParameterf(sampler, gl.TEXTURE_MAX_LOD, 10); 827 gl.samplerParameteri(sampler, gl.TEXTURE_MIN_FILTER, gl.NEAREST); 828 gl.samplerParameterf(sampler, gl.TEXTURE_MIN_LOD, 0); 829 gl.samplerParameteri(sampler, gl.TEXTURE_WRAP_R, gl.CLAMP_TO_EDGE); 830 gl.samplerParameteri(sampler, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); 831 gl.samplerParameteri(sampler, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); 832 shouldBe('gl.getSamplerParameter(sampler, gl.TEXTURE_COMPARE_FUNC)', 'gl.LEQUAL'); 833 shouldBe('gl.getSamplerParameter(sampler, gl.TEXTURE_COMPARE_MODE)', 'gl.COMPARE_REF_TO_TEXTURE'); 834 shouldBe('gl.getSamplerParameter(sampler, gl.TEXTURE_MAG_FILTER)', 'gl.NEAREST'); 835 shouldBe('gl.getSamplerParameter(sampler, gl.TEXTURE_MAX_LOD)', '10'); 836 shouldBe('gl.getSamplerParameter(sampler, gl.TEXTURE_MIN_FILTER)', 'gl.NEAREST'); 837 shouldBe('gl.getSamplerParameter(sampler, gl.TEXTURE_MIN_LOD)', '0'); 838 shouldBe('gl.getSamplerParameter(sampler, gl.TEXTURE_WRAP_R)', 'gl.CLAMP_TO_EDGE'); 839 shouldBe('gl.getSamplerParameter(sampler, gl.TEXTURE_WRAP_S)', 'gl.CLAMP_TO_EDGE'); 840 shouldBe('gl.getSamplerParameter(sampler, gl.TEXTURE_WRAP_T)', 'gl.CLAMP_TO_EDGE'); 841 let validArrayForSamplerParameter = new Array( 842 gl.TEXTURE_COMPARE_FUNC, 843 gl.TEXTURE_COMPARE_MODE, 844 gl.TEXTURE_MAG_FILTER, 845 gl.TEXTURE_MAX_LOD, 846 gl.TEXTURE_MIN_FILTER, 847 gl.TEXTURE_MIN_LOD, 848 gl.TEXTURE_WRAP_R, 849 gl.TEXTURE_WRAP_S, 850 gl.TEXTURE_WRAP_T 851 ); 852 await testInvalidArgument( 853 "getSamplerParameter", 854 "pname", 855 validArrayForSamplerParameter, 856 function(pname) { 857 return gl.getSamplerParameter(sampler, pname); 858 }); 859 860 debug(""); 861 debug("Test getSyncParameter"); 862 window.sync = gl.fenceSync(gl.SYNC_GPU_COMMANDS_COMPLETE, 0); 863 shouldBe('gl.getSyncParameter(sync, gl.OBJECT_TYPE)', 'gl.SYNC_FENCE'); 864 let sync_status = gl.getSyncParameter(sync, gl.SYNC_STATUS); 865 switch (sync_status) { 866 case gl.UNSIGNALED: 867 testPassed('gl.getSyncParameter(sync, gl.SYNC_CONDITION) is gl.UNSIGNALED'); 868 break; 869 case gl.SIGNALED: 870 testPassed('gl.getSyncParameter(sync, gl.SYNC_CONDITION) is gl.SIGNALED'); 871 break; 872 default: 873 testFailed('gl.getSyncParameter(sync, gl.SYNC_CONDITION) was ' + sync_status + 874 ', expected gl.UNSIGNALED or gl.SIGNALED'); 875 break; 876 } 877 shouldBe('gl.getSyncParameter(sync, gl.SYNC_CONDITION)', 'gl.SYNC_GPU_COMMANDS_COMPLETE'); 878 shouldBe('gl.getSyncParameter(sync, gl.SYNC_FLAGS)', '0'); 879 let validArrayForSyncParameter = new Array( 880 gl.OBJECT_TYPE, 881 gl.SYNC_STATUS, 882 gl.SYNC_CONDITION, 883 gl.SYNC_FLAGS 884 ); 885 await testInvalidArgument( 886 "getSyncParameter", 887 "pname", 888 validArrayForSyncParameter, 889 function(pname) { 890 return gl.getSyncParameter(sync, pname); 891 }); 892 893 debug(""); 894 debug("Test getQueryParameter"); 895 window.query = gl.createQuery(); 896 gl.beginQuery(gl.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, query); 897 gl.endQuery(gl.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN); 898 shouldBe('gl.getQueryParameter(query, gl.QUERY_RESULT_AVAILABLE)', 'false'); 899 // Queries' results are tested elsewhere in the conformance suite. It's complicated 900 // to wait for this query's result to become available and verify it. 901 let validArrayForPname = new Array( 902 gl.QUERY_RESULT, 903 gl.QUERY_RESULT_AVAILABLE 904 ); 905 await testInvalidArgument( 906 "getQueryParameter", 907 "pname", 908 validArrayForPname, 909 function(pname) { 910 return gl.getQueryParameter(query, pname); 911 } 912 ); 913 914 debug(""); 915 debug("Test getFragDataLocation"); 916 let baseVertShader = '' + 917 '#version 300 es\n' + 918 'uniform mat4 modelViewMatrix;\n' + 919 'uniform mat4 projectionMatrix;\n' + 920 'in vec4 vertex;\n' + 921 'out vec4 position;\n' + 922 'void main (void)\n' + 923 '{\n' + 924 ' position = modelViewMatrix * vertex;\n' + 925 ' gl_Position = projectionMatrix * position;\n' + 926 '}\n'; 927 let baseFragShader = '' + 928 '#version 300 es\n' + 929 'in lowp vec4 position;\n' + 930 'layout(location = 0) out mediump vec4 fragColor;\n' + 931 'void main (void)\n' + 932 '{\n' + 933 ' fragColor = position;\n' + 934 '}\n'; 935 window.vertShader = gl.createShader(gl.VERTEX_SHADER); 936 gl.shaderSource(vertShader, baseVertShader); 937 gl.compileShader(vertShader); 938 shouldBe('gl.getShaderParameter(vertShader, gl.COMPILE_STATUS)', 'true'); 939 window.fragShader = gl.createShader(gl.FRAGMENT_SHADER); 940 gl.shaderSource(fragShader, baseFragShader); 941 gl.compileShader(fragShader); 942 shouldBe('gl.getShaderParameter(fragShader, gl.COMPILE_STATUS)', 'true'); 943 window.program = gl.createProgram(); 944 gl.attachShader(program, vertShader); 945 gl.attachShader(program, fragShader); 946 gl.linkProgram(program); 947 shouldBe('gl.getProgramParameter(program, gl.LINK_STATUS)','true'); 948 shouldBe('gl.getFragDataLocation(program, "vertexColor")', '-1'); 949 shouldBe('gl.getFragDataLocation(program, "modelViewMatrix")', '-1'); 950 shouldBe('gl.getFragDataLocation(program, "projectionMatrix")', '-1'); 951 shouldBe('gl.getFragDataLocation(program, "position")', '-1'); 952 shouldBe('gl.getFragDataLocation(program, "fragColor")', '0'); 953 954 debug(""); 955 debug("Test getActiveUniforms"); 956 program = wtu.loadUniformBlockProgram(gl); 957 gl.linkProgram(program); 958 shouldBe('gl.getProgramParameter(program, gl.LINK_STATUS)', 'true'); 959 shouldBe('gl.getError()', 'gl.NO_ERROR'); 960 961 let numActiveUniforms = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS); 962 let blockIndex = gl.getUniformBlockIndex(program, "Transform"); 963 let uniformIndices = []; 964 for (let i = 0; i < numActiveUniforms; i++) 965 uniformIndices.push(i); 966 let types = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_TYPE); 967 let sizes = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_SIZE); 968 let blockIndices = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_BLOCK_INDEX); 969 let offsets = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_OFFSET); 970 let arrayStrides = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_ARRAY_STRIDE); 971 let matrixStrides = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_MATRIX_STRIDE); 972 let rowMajors = gl.getActiveUniforms(program, uniformIndices, gl.UNIFORM_IS_ROW_MAJOR); 973 for (let i = 0; i < numActiveUniforms; i++) { 974 if (types[i] != gl.FLOAT_MAT4 && types[i] != gl.FLOAT_MAT3) 975 testFailed("expected value: GL_FLOAT_MAT4 or GL_FLOAT_MAT3" + " actual value for UNIFORM_TYPE for uniform index[" + i + "]:" + wtu.glEnumToString(gl, types[i])); 976 if (sizes[i] != 1) 977 testFailed("expected value: 1" + " actual value for UNIFORM_SIZE for uniform index[" + i + "]:" + sizes[i]); 978 if (blockIndices[i] != blockIndex) 979 testFailed("expected value: 0" + " actual value for UNIFORM_BLOCK_INDEX for uniform index[" + i + "]:" + blockIndices[i]); 980 if (offsets[i] < 0) 981 testFailed("expected value >= 0" + " actual value for UNIFORM_OFFSET for uniform index[" + i + "]:" + offsets[i]); 982 if (arrayStrides[i] != 0) 983 testFailed("expected value: 0" + " actual value for UNIFORM_ARRAY_STRIDE for uniform index[" + i + "]:" + arrayStrides[i]); 984 if (matrixStrides[i] < 0) 985 testFailed("expected value >= 0" + " actual value for UNIFORM_MATRIX_STRIDE for uniform index[" + i + "]:" + matrixStrides[i]); 986 shouldBe(`"${typeof rowMajors[i]}"`, '"boolean"'); 987 if (rowMajors[i] != false) 988 testFailed("expected value: 0" + " actual value for UNIFORM_IS_ROW_MAJOR for uniform index[" + i + "]:" + rowMajors[i]); 989 } 990 991 validArrayForPname = new Array( 992 gl.UNIFORM_TYPE, 993 gl.UNIFORM_SIZE, 994 gl.UNIFORM_BLOCK_INDEX, 995 gl.UNIFORM_OFFSET, 996 gl.UNIFORM_ARRAY_STRIDE, 997 gl.UNIFORM_MATRIX_STRIDE, 998 gl.UNIFORM_IS_ROW_MAJOR 999 ); 1000 await testInvalidArgument( 1001 "getActiveUniforms", 1002 "pname", 1003 validArrayForPname, 1004 function(pname) { 1005 return gl.getActiveUniforms(program, uniformIndices, pname); 1006 } 1007 ); 1008 1009 debug(""); 1010 debug("Test getUniformBlockIndex"); 1011 program = wtu.loadUniformBlockProgram(gl); 1012 gl.linkProgram(program); 1013 shouldBeTrue('gl.getProgramParameter(program, gl.LINK_STATUS)'); 1014 shouldBe('gl.getUniformBlockIndex(program, "Transform")', '0'); 1015 shouldBe('gl.getUniformBlockIndex(program, "u_modelViewMatrix")', 'gl.INVALID_INDEX'); 1016 shouldBe('gl.getUniformBlockIndex(program, "normal")', 'gl.INVALID_INDEX'); 1017 shouldBe('gl.getUniformBlockIndex(program, "u_normal")', 'gl.INVALID_INDEX'); 1018 window.noUniformProgram = wtu.loadStandardProgram(gl); 1019 gl.linkProgram(noUniformProgram); 1020 shouldBeTrue('gl.getProgramParameter(noUniformProgram, gl.LINK_STATUS)'); 1021 shouldBe('gl.getUniformBlockIndex(noUniformProgram, "u_modelViewProjMatrix")', 'gl.INVALID_INDEX'); 1022 shouldBe('gl.getUniformBlockIndex(noUniformProgram, "u_normal")', 'gl.INVALID_INDEX'); 1023 1024 debug(""); 1025 debug("Test getActiveUniformBlockName"); 1026 program = wtu.loadUniformBlockProgram(gl); 1027 gl.linkProgram(program); 1028 shouldBeTrue('gl.getProgramParameter(program, gl.LINK_STATUS)'); 1029 shouldBeEqualToString('gl.getActiveUniformBlockName(program, 0)', 'Transform'); 1030 shouldBeNull('gl.getActiveUniformBlockName(program, -1)'); 1031 wtu.glErrorShouldBe(gl, gl.INVALID_VALUE); 1032 shouldBeNull('gl.getActiveUniformBlockName(program, 1)'); 1033 wtu.glErrorShouldBe(gl, gl.INVALID_VALUE); 1034 shouldBeNull('gl.getActiveUniformBlockName(program, gl.INVALID_INDEX)'); 1035 wtu.glErrorShouldBe(gl, gl.INVALID_VALUE); 1036 window.noLinkProgram = gl.createProgram(); 1037 shouldBeFalse('gl.getProgramParameter(noLinkProgram, gl.LINK_STATUS)'); 1038 wtu.shouldGenerateGLError(gl, gl.INVALID_OPERATION, 'gl.getActiveUniformBlockName(noLinkProgram, 0)'); 1039 noUniformProgram = wtu.loadStandardProgram(gl); 1040 gl.linkProgram(noUniformProgram); 1041 shouldBeTrue('gl.getProgramParameter(noUniformProgram, gl.LINK_STATUS)'); 1042 shouldBeNull('gl.getActiveUniformBlockName(noUniformProgram, -1)'); 1043 wtu.glErrorShouldBe(gl, gl.INVALID_VALUE); 1044 shouldBeNull('gl.getActiveUniformBlockName(noUniformProgram, 0)'); 1045 wtu.glErrorShouldBe(gl, gl.INVALID_VALUE); 1046 shouldBeNull('gl.getActiveUniformBlockName(noUniformProgram, gl.INVALID_INDEX)'); 1047 wtu.glErrorShouldBe(gl, gl.INVALID_VALUE); 1048 1049 debug(""); 1050 debug("Test getActiveUniformBlockParameter"); 1051 program = wtu.loadUniformBlockProgram(gl); 1052 gl.linkProgram(program); 1053 shouldBeTrue('gl.getProgramParameter(program, gl.LINK_STATUS)'); 1054 shouldBe('gl.getActiveUniformBlockParameter(program, 0, gl.UNIFORM_BLOCK_BINDING)', '0'); 1055 gl.uniformBlockBinding(program, 0, 1); 1056 shouldBe('gl.getActiveUniformBlockParameter(program, 0, gl.UNIFORM_BLOCK_BINDING)', '1'); 1057 // The actual block data size can be bigger than 164, depending on the uniform block layout. 1058 shouldBeTrue('gl.getActiveUniformBlockParameter(program, 0, gl.UNIFORM_BLOCK_DATA_SIZE) >= 164'); 1059 shouldBe('gl.getActiveUniformBlockParameter(program, 0, gl.UNIFORM_BLOCK_ACTIVE_UNIFORMS)', '3'); 1060 shouldBeTrue('gl.getActiveUniformBlockParameter(program, 0, gl.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER)'); 1061 shouldBeFalse('gl.getActiveUniformBlockParameter(program, 0, gl.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER)'); 1062 let indices = gl.getActiveUniformBlockParameter(program, 0, gl.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES); 1063 for (let i = 0; i < 3; i++) { 1064 if (indices[i] < 0) 1065 testFailed("expected value >= 0" + " actual value for UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES for uniform index[" + i + "]:" + indices[i]); 1066 } 1067 validArrayForPname = new Array( 1068 gl.UNIFORM_BLOCK_BINDING, 1069 gl.UNIFORM_BLOCK_DATA_SIZE, 1070 gl.UNIFORM_BLOCK_ACTIVE_UNIFORMS, 1071 gl.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, 1072 gl.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER, 1073 gl.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 1074 ); 1075 await testInvalidArgument( 1076 "getActiveUniformBlockParameter", 1077 "pname", 1078 validArrayForPname, 1079 function(pname) { 1080 return gl.getActiveUniformBlockParameter(program, 0, pname); 1081 } 1082 ); 1083 } 1084 1085 wtu.glErrorShouldBe(gl, gl.NO_ERROR); 1086 1087 finishTest(); 1088 })(); 1089 1090 let successfullyParsed = true;