| OLD | NEW |
|---|
| (Empty) | |
| 1 <!-- |
| 2 |
| 3 /* |
| 4 ** Copyright (c) 2012 The Khronos Group Inc. |
| 5 ** |
| 6 ** Permission is hereby granted, free of charge, to any person obtaining a |
| 7 ** copy of this software and/or associated documentation files (the |
| 8 ** "Materials"), to deal in the Materials without restriction, including |
| 9 ** without limitation the rights to use, copy, modify, merge, publish, |
| 10 ** distribute, sublicense, and/or sell copies of the Materials, and to |
| 11 ** permit persons to whom the Materials are furnished to do so, subject to |
| 12 ** the following conditions: |
| 13 ** |
| 14 ** The above copyright notice and this permission notice shall be included |
| 15 ** in all copies or substantial portions of the Materials. |
| 16 ** |
| 17 ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| 18 ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| 19 ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
| 20 ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY |
| 21 ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
| 22 ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
| 23 ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. |
| 24 */ |
| 25 |
| 26 --> |
| 27 |
| 28 <!DOCTYPE html> |
| 29 <html> |
| 30 <head> |
| 31 <meta charset="utf-8"> |
| 32 <link rel="stylesheet" href="../../resources/js-test-style.css"/> |
| 33 <script src="../../resources/js-test-pre.js"></script> |
| 34 <script src="../resources/webgl-test.js"></script> |
| 35 <script src="../resources/webgl-test-utils.js"></script> |
| 36 </head> |
| 37 <body> |
| 38 <div id="description"></div> |
| 39 <div id="console"></div> |
| 40 |
| 41 <script> |
| 42 wtu = WebGLTestUtils; |
| 43 description("Test of get calls against GL objects like getBufferParameter, etc."
); |
| 44 |
| 45 function sizeInBytes(type) { |
| 46 switch (type) { |
| 47 case gl.BYTE: |
| 48 case gl.UNSIGNED_BYTE: |
| 49 return 1; |
| 50 case gl.SHORT: |
| 51 case gl.UNSIGNED_SHORT: |
| 52 return 2; |
| 53 case gl.INT: |
| 54 case gl.UNSIGNED_INT: |
| 55 case gl.FLOAT: |
| 56 return 4; |
| 57 default: |
| 58 throw "unknown type"; |
| 59 } |
| 60 } |
| 61 |
| 62 var gl = create3DContext(); |
| 63 |
| 64 debug("test getAttachedShaders"); |
| 65 var standardVert = loadStandardVertexShader(gl); |
| 66 var standardFrag = loadStandardFragmentShader(gl); |
| 67 var standardProgram = gl.createProgram(); |
| 68 gl.attachShader(standardProgram, standardVert); |
| 69 gl.attachShader(standardProgram, standardFrag); |
| 70 gl.linkProgram(standardProgram); |
| 71 var shaders = gl.getAttachedShaders(standardProgram); |
| 72 shouldBe('shaders.length', '2'); |
| 73 shouldBeTrue('shaders[0] == standardVert && shaders[1] == standardFrag || shader
s[1] == standardVert && shaders[0] == standardFrag'); |
| 74 glErrorShouldBe(gl, gl.NO_ERROR); |
| 75 shouldBeNull('gl.getAttachedShaders(null)'); |
| 76 glErrorShouldBe(gl, gl.INVALID_VALUE); |
| 77 shouldThrow('gl.getAttachedShaders(standardVert)'); |
| 78 glErrorShouldBe(gl, gl.NO_ERROR); |
| 79 |
| 80 function testInvalidArgument(funcName, argumentName, validArgumentArray, func) { |
| 81 var validArguments = {}; |
| 82 for (var ii = 0; ii < validArgumentArray.length; ++ii) { |
| 83 validArguments[validArgumentArray[ii]] = true; |
| 84 } |
| 85 var success = true; |
| 86 for (var ii = 0; ii < 0x10000; ++ii) { |
| 87 if (!validArguments[ii]) { |
| 88 var result = func(ii); |
| 89 if (result !== null) { |
| 90 success = false; |
| 91 testFailed(funcName + " returned " + result + " instead of null for inva
lid " + argumentName + " enum: " + wtu.glEnumToString(gl, ii)); |
| 92 break; |
| 93 } |
| 94 var err = gl.getError(); |
| 95 if (err != gl.INVALID_ENUM) { |
| 96 success = false; |
| 97 testFailed(funcName + " did not generate INVALID_ENUM for invalid " + ar
gumentName + " enum: " + wtu.glEnumToString(gl, ii)); |
| 98 break; |
| 99 } |
| 100 } |
| 101 } |
| 102 if (success) { |
| 103 testPassed(funcName + " correctly handled invalid " + argumentName + " enums
"); |
| 104 } |
| 105 } |
| 106 |
| 107 debug(""); |
| 108 debug("test getBufferParameter"); |
| 109 // Test getBufferParameter |
| 110 var bufferTypes = [gl.ARRAY_BUFFER, gl.ELEMENT_ARRAY_BUFFER]; |
| 111 for (var bb = 0; bb < bufferTypes.length; ++bb) { |
| 112 var bufferType = bufferTypes[bb]; |
| 113 var buffer = gl.createBuffer(); |
| 114 gl.bindBuffer(bufferType, buffer); |
| 115 gl.bufferData(bufferType, 16, gl.DYNAMIC_DRAW); |
| 116 var expression1 = "gl.getBufferParameter(gl." + wtu.glEnumToString(gl, bufferT
ype) + ", gl.BUFFER_SIZE)"; |
| 117 var expression2 = "gl.getBufferParameter(gl." + wtu.glEnumToString(gl, bufferT
ype) + ", gl.BUFFER_USAGE)"; |
| 118 shouldBe(expression1, '16'); |
| 119 shouldBe(expression2, 'gl.DYNAMIC_DRAW'); |
| 120 testInvalidArgument("getBufferParameter", "parameter", [gl.BUFFER_SIZE, gl.BUF
FER_USAGE], function(bufferType) { |
| 121 return function(parameter) { |
| 122 return gl.getBufferParameter(bufferType, parameter); |
| 123 }; |
| 124 }(bufferType)); |
| 125 } |
| 126 testInvalidArgument( |
| 127 "getBufferParameter", |
| 128 "target", |
| 129 bufferTypes, |
| 130 function(target) { |
| 131 return gl.getBufferParameter(target, gl.BUFFER_SIZE); |
| 132 } |
| 133 ); |
| 134 |
| 135 |
| 136 debug(""); |
| 137 debug("Test getFramebufferAttachmentParameter"); |
| 138 var texture = gl.createTexture(); |
| 139 gl.bindTexture(gl.TEXTURE_2D, texture); |
| 140 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 2, 2, 0, gl.RGBA, gl.UNSIGNED_BYTE, |
| 141 new Uint8Array([ |
| 142 0, 0, 0, 255, |
| 143 255, 255, 255, 255, |
| 144 255, 255, 255, 255, |
| 145 0, 0, 0, 255])); |
| 146 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR); |
| 147 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); |
| 148 gl.bindTexture(gl.TEXTURE_2D, null); |
| 149 var framebuffer = gl.createFramebuffer(); |
| 150 gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); |
| 151 gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, tex
ture, 0); |
| 152 var renderbuffer = gl.createRenderbuffer(); |
| 153 glErrorShouldBe(gl, gl.NO_ERROR); |
| 154 gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer); |
| 155 glErrorShouldBe(gl, gl.NO_ERROR); |
| 156 gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, 2, 2); |
| 157 glErrorShouldBe(gl, gl.NO_ERROR); |
| 158 gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER,
renderbuffer); |
| 159 // FIXME: on some machines (in particular the WebKit commit bots) the |
| 160 // framebuffer status is FRAMEBUFFER_UNSUPPORTED; more investigation |
| 161 // is needed why this is the case, because the FBO allocated |
| 162 // internally by the WebKit implementation has almost identical |
| 163 // parameters to this one. See https://bugs.webkit.org/show_bug.cgi?id=31843. |
| 164 shouldBe('gl.checkFramebufferStatus(gl.FRAMEBUFFER)', 'gl.FRAMEBUFFER_COMPLETE')
; |
| 165 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHME
NT0, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.TEXTURE'); |
| 166 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHME
NT0, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)', 'texture'); |
| 167 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHME
NT0, gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL)', '0'); |
| 168 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHME
NT0, gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE)', '0'); |
| 169 |
| 170 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHME
NT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.RENDERBUFFER'); |
| 171 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHME
NT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)', 'renderbuffer'); |
| 172 testInvalidArgument( |
| 173 "getFramebufferAttachmentParameter", |
| 174 "parameter", |
| 175 [ gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, |
| 176 gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, |
| 177 gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL, |
| 178 gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE |
| 179 ], |
| 180 function(parameter) { |
| 181 return gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTAC
HMENT, parameter); |
| 182 } |
| 183 ); |
| 184 testInvalidArgument( |
| 185 "getFramebufferAttachmentParameter", |
| 186 "target", |
| 187 [ gl.FRAMEBUFFER ], |
| 188 function(target) { |
| 189 return gl.getFramebufferAttachmentParameter(target, gl.COLOR_ATTACHMENT, g
l.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE); |
| 190 } |
| 191 ); |
| 192 testInvalidArgument( |
| 193 "getFramebufferAttachmentParameter", |
| 194 "attachment", |
| 195 [ gl.COLOR_ATTACHMENT0, |
| 196 gl.DEPTH_ATTACHMENT, |
| 197 gl.STENCIL_ATTACHMENT, |
| 198 gl.DEPTH_STENCIL_ATTACHMENT |
| 199 ], |
| 200 function(attachment) { |
| 201 return gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, attachment, gl
.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE); |
| 202 } |
| 203 ); |
| 204 |
| 205 |
| 206 debug(""); |
| 207 debug("Test getProgramParameter"); |
| 208 shouldBe('gl.getProgramParameter(standardProgram, gl.DELETE_STATUS)', 'false'); |
| 209 shouldBe('gl.getProgramParameter(standardProgram, gl.LINK_STATUS)', 'true'); |
| 210 shouldBe('typeof gl.getProgramParameter(standardProgram, gl.VALIDATE_STATUS)', '
"boolean"'); |
| 211 shouldBe('gl.getProgramParameter(standardProgram, gl.ATTACHED_SHADERS)', '2'); |
| 212 shouldBe('gl.getProgramParameter(standardProgram, gl.ACTIVE_ATTRIBUTES)', '2'); |
| 213 shouldBe('gl.getProgramParameter(standardProgram, gl.ACTIVE_UNIFORMS)', '1'); |
| 214 testInvalidArgument( |
| 215 "getProgramParameter", |
| 216 "parameter", |
| 217 [ gl.DELETE_STATUS, |
| 218 gl.LINK_STATUS, |
| 219 gl.VALIDATE_STATUS, |
| 220 gl.ATTACHED_SHADERS, |
| 221 gl.ACTIVE_ATTRIBUTES, |
| 222 gl.ACTIVE_UNIFORMS |
| 223 ], |
| 224 function(parameter) { |
| 225 return gl.getProgramParameter(standardProgram, parameter); |
| 226 } |
| 227 ); |
| 228 |
| 229 debug(""); |
| 230 debug("Test getRenderbufferParameter"); |
| 231 shouldBe('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_WIDTH)',
'2'); |
| 232 shouldBe('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_HEIGHT)',
'2'); |
| 233 // Note: we can't test the actual value of the internal format since |
| 234 // the implementation is allowed to change it. |
| 235 shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_IN
TERNAL_FORMAT)'); |
| 236 shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_DE
PTH_SIZE)'); |
| 237 var colorbuffer = gl.createRenderbuffer(); |
| 238 glErrorShouldBe(gl, gl.NO_ERROR); |
| 239 gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer); |
| 240 glErrorShouldBe(gl, gl.NO_ERROR); |
| 241 gl.renderbufferStorage(gl.RENDERBUFFER, gl.RGBA4, 2, 2); |
| 242 shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_RE
D_SIZE)'); |
| 243 shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_GR
EEN_SIZE)'); |
| 244 shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_BL
UE_SIZE)'); |
| 245 shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_AL
PHA_SIZE)'); |
| 246 testInvalidArgument( |
| 247 "getRenderbufferParameter", |
| 248 "parameter", |
| 249 [ gl.RENDERBUFFER_WIDTH, |
| 250 gl.RENDERBUFFER_HEIGHT, |
| 251 gl.RENDERBUFFER_INTERNAL_FORMAT, |
| 252 gl.RENDERBUFFER_RED_SIZE, |
| 253 gl.RENDERBUFFER_GREEN_SIZE, |
| 254 gl.RENDERBUFFER_BLUE_SIZE, |
| 255 gl.RENDERBUFFER_ALPHA_SIZE, |
| 256 gl.RENDERBUFFER_DEPTH_SIZE, |
| 257 gl.RENDERBUFFER_STENCIL_SIZE, |
| 258 ], |
| 259 function(parameter) { |
| 260 return gl.getRenderbufferParameter(gl.RENDERBUFFER, parameter); |
| 261 }); |
| 262 testInvalidArgument( |
| 263 "getRenderbufferParameter", |
| 264 "target", |
| 265 [ gl.RENDERBUFFER ], |
| 266 function(target) { |
| 267 return gl.getRenderbufferParameter(target, gl.RENDERBUFFER_WIDTH); |
| 268 }); |
| 269 |
| 270 debug(""); |
| 271 debug("Test getShaderParameter"); |
| 272 shouldBe('gl.getShaderParameter(standardVert, gl.SHADER_TYPE)', 'gl.VERTEX_SHADE
R'); |
| 273 shouldBe('gl.getShaderParameter(standardVert, gl.DELETE_STATUS)', 'false'); |
| 274 shouldBe('gl.getShaderParameter(standardVert, gl.COMPILE_STATUS)', 'true'); |
| 275 testInvalidArgument( |
| 276 "getShaderParameter", |
| 277 "parameter", |
| 278 [ gl.DELETE_STATUS, |
| 279 gl.COMPILE_STATUS, |
| 280 gl.SHADER_TYPE |
| 281 ], |
| 282 function(parameter) { |
| 283 return gl.getShaderParameter(standardVert, parameter); |
| 284 } |
| 285 ); |
| 286 |
| 287 debug(""); |
| 288 debug("Test getTexParameter"); |
| 289 gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); |
| 290 gl.bindTexture(gl.TEXTURE_2D, texture); |
| 291 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST); |
| 292 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST); |
| 293 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); |
| 294 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); |
| 295 shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER)', 'gl.NEAREST
'); |
| 296 shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER)', 'gl.NEAREST
'); |
| 297 shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S)', 'gl.CLAMP_TO_ED
GE'); |
| 298 shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T)', 'gl.CLAMP_TO_ED
GE'); |
| 299 testInvalidArgument( |
| 300 "getTexParameter", |
| 301 "parameter", |
| 302 [ gl.TEXTURE_MAG_FILTER, |
| 303 gl.TEXTURE_MIN_FILTER, |
| 304 gl.TEXTURE_WRAP_S, |
| 305 gl.TEXTURE_WRAP_T |
| 306 ], |
| 307 function(parameter) { |
| 308 return gl.getTexParameter(gl.TEXTURE_2D, parameter); |
| 309 } |
| 310 ); |
| 311 testInvalidArgument( |
| 312 "getTexParameter", |
| 313 "target", |
| 314 [ gl.TEXTURE_2D, |
| 315 gl.TEXTURE_CUBE_MAP |
| 316 ], |
| 317 function(target) { |
| 318 return gl.getTexParameter(target, gl.TEXTURE_MAG_FILTER); |
| 319 } |
| 320 ); |
| 321 |
| 322 debug(""); |
| 323 debug("Test getUniform with all variants of data types"); |
| 324 // Boolean uniform variables |
| 325 var boolProgram = loadProgram(gl, "../resources/boolUniformShader.vert", "../res
ources/noopUniformShader.frag"); |
| 326 shouldBe('gl.getProgramParameter(boolProgram, gl.LINK_STATUS)', 'true'); |
| 327 var bvalLoc = gl.getUniformLocation(boolProgram, "bval"); |
| 328 var bval2Loc = gl.getUniformLocation(boolProgram, "bval2"); |
| 329 var bval3Loc = gl.getUniformLocation(boolProgram, "bval3"); |
| 330 var bval4Loc = gl.getUniformLocation(boolProgram, "bval4"); |
| 331 gl.useProgram(boolProgram); |
| 332 gl.uniform1i(bvalLoc, 1); |
| 333 gl.uniform2i(bval2Loc, 1, 0); |
| 334 gl.uniform3i(bval3Loc, 1, 0, 1); |
| 335 gl.uniform4i(bval4Loc, 1, 0, 1, 0); |
| 336 glErrorShouldBe(gl, gl.NO_ERROR); |
| 337 shouldBe('gl.getUniform(boolProgram, bvalLoc)', 'true'); |
| 338 shouldBe('gl.getUniform(boolProgram, bval2Loc)', '[true, false]'); |
| 339 shouldBe('gl.getUniform(boolProgram, bval3Loc)', '[true, false, true]'); |
| 340 shouldBe('gl.getUniform(boolProgram, bval4Loc)', '[true, false, true, false]'); |
| 341 // Integer uniform variables |
| 342 var intProgram = loadProgram(gl, "../resources/intUniformShader.vert", "../resou
rces/noopUniformShader.frag"); |
| 343 shouldBe('gl.getProgramParameter(intProgram, gl.LINK_STATUS)', 'true'); |
| 344 var ivalLoc = gl.getUniformLocation(intProgram, "ival"); |
| 345 var ival2Loc = gl.getUniformLocation(intProgram, "ival2"); |
| 346 var ival3Loc = gl.getUniformLocation(intProgram, "ival3"); |
| 347 var ival4Loc = gl.getUniformLocation(intProgram, "ival4"); |
| 348 gl.useProgram(intProgram); |
| 349 gl.uniform1i(ivalLoc, 1); |
| 350 gl.uniform2i(ival2Loc, 2, 3); |
| 351 gl.uniform3i(ival3Loc, 4, 5, 6); |
| 352 gl.uniform4i(ival4Loc, 7, 8, 9, 10); |
| 353 glErrorShouldBe(gl, gl.NO_ERROR); |
| 354 shouldBe('gl.getUniform(intProgram, ivalLoc)', '1'); |
| 355 shouldBe('gl.getUniform(intProgram, ival2Loc)', '[2, 3]'); |
| 356 shouldBe('gl.getUniform(intProgram, ival3Loc)', '[4, 5, 6]'); |
| 357 shouldBe('gl.getUniform(intProgram, ival4Loc)', '[7, 8, 9, 10]'); |
| 358 // Float uniform variables |
| 359 var floatProgram = loadProgram(gl, "../resources/floatUniformShader.vert", "../r
esources/noopUniformShader.frag"); |
| 360 shouldBe('gl.getProgramParameter(floatProgram, gl.LINK_STATUS)', 'true'); |
| 361 var fvalLoc = gl.getUniformLocation(floatProgram, "fval"); |
| 362 var fval2Loc = gl.getUniformLocation(floatProgram, "fval2"); |
| 363 var fval3Loc = gl.getUniformLocation(floatProgram, "fval3"); |
| 364 var fval4Loc = gl.getUniformLocation(floatProgram, "fval4"); |
| 365 gl.useProgram(floatProgram); |
| 366 gl.uniform1f(fvalLoc, 11); |
| 367 gl.uniform2f(fval2Loc, 12, 13); |
| 368 gl.uniform3f(fval3Loc, 14, 15, 16); |
| 369 gl.uniform4f(fval4Loc, 17, 18, 19, 20); |
| 370 glErrorShouldBe(gl, gl.NO_ERROR); |
| 371 shouldBe('gl.getUniform(floatProgram, fvalLoc)', '11'); |
| 372 shouldBe('gl.getUniform(floatProgram, fval2Loc)', '[12, 13]'); |
| 373 shouldBe('gl.getUniform(floatProgram, fval3Loc)', '[14, 15, 16]'); |
| 374 shouldBe('gl.getUniform(floatProgram, fval4Loc)', '[17, 18, 19, 20]'); |
| 375 // Sampler uniform variables |
| 376 var samplerProgram = loadProgram(gl, "../resources/noopUniformShader.vert", "../
resources/samplerUniformShader.frag"); |
| 377 shouldBe('gl.getProgramParameter(samplerProgram, gl.LINK_STATUS)', 'true'); |
| 378 var s2DValLoc = gl.getUniformLocation(samplerProgram, "s2D"); |
| 379 var sCubeValLoc = gl.getUniformLocation(samplerProgram, "sCube"); |
| 380 gl.useProgram(samplerProgram); |
| 381 gl.uniform1i(s2DValLoc, 0); |
| 382 gl.uniform1i(sCubeValLoc, 1); |
| 383 glErrorShouldBe(gl, gl.NO_ERROR); |
| 384 shouldBe('gl.getUniform(samplerProgram, s2DValLoc)', '0'); |
| 385 shouldBe('gl.getUniform(samplerProgram, sCubeValLoc)', '1'); |
| 386 // Matrix uniform variables |
| 387 var matProgram = loadProgram(gl, "../resources/matUniformShader.vert", "../resou
rces/noopUniformShader.frag"); |
| 388 shouldBe('gl.getProgramParameter(matProgram, gl.LINK_STATUS)', 'true'); |
| 389 var mval2Loc = gl.getUniformLocation(matProgram, "mval2"); |
| 390 var mval3Loc = gl.getUniformLocation(matProgram, "mval3"); |
| 391 var mval4Loc = gl.getUniformLocation(matProgram, "mval4"); |
| 392 gl.useProgram(matProgram); |
| 393 gl.uniformMatrix2fv(mval2Loc, false, [1, 2, 3, 4]); |
| 394 gl.uniformMatrix3fv(mval3Loc, false, [5, 6, 7, 8, 9, 10, 11, 12, 13]); |
| 395 gl.uniformMatrix4fv(mval4Loc, false, [14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24
, 25, 26, 27, 28, 29]); |
| 396 glErrorShouldBe(gl, gl.NO_ERROR); |
| 397 shouldBe('gl.getUniform(matProgram, mval2Loc)', '[1, 2, 3, 4]'); |
| 398 shouldBe('gl.getUniform(matProgram, mval3Loc)', '[5, 6, 7, 8, 9, 10, 11, 12, 13]
'); |
| 399 shouldBe('gl.getUniform(matProgram, mval4Loc)', '[14, 15, 16, 17, 18, 19, 20, 21
, 22, 23, 24, 25, 26, 27, 28, 29]'); |
| 400 |
| 401 debug(""); |
| 402 debug("test getVertexAttrib"); |
| 403 var array = new Float32Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16]); |
| 404 var buffer = gl.createBuffer(); |
| 405 gl.bindBuffer(gl.ARRAY_BUFFER, buffer); |
| 406 gl.bufferData(gl.ARRAY_BUFFER, array, gl.DYNAMIC_DRAW); |
| 407 // Vertex attribute 0 is special in that it has no current state, so |
| 408 // fetching GL_CURRENT_VERTEX_ATTRIB generates an error. Use attribute |
| 409 // 1 for these tests instead. |
| 410 gl.enableVertexAttribArray(1); |
| 411 gl.vertexAttribPointer(1, 4, gl.FLOAT, false, 0, 0); |
| 412 shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING)', 'buffer
'); |
| 413 shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_ENABLED)', 'true'); |
| 414 shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_SIZE)', '4'); |
| 415 // Stride MUST be the value the user put in. |
| 416 shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_STRIDE)', '0'); |
| 417 shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_TYPE)', 'gl.FLOAT'); |
| 418 shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_NORMALIZED)', 'false'); |
| 419 gl.vertexAttribPointer(1, 4, gl.FLOAT, false, 36, 12); |
| 420 shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_STRIDE)', '36'); |
| 421 shouldBe('gl.getVertexAttribOffset(1, gl.VERTEX_ATTRIB_ARRAY_POINTER)', '12'); |
| 422 gl.disableVertexAttribArray(1); |
| 423 shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_ENABLED)', 'false'); |
| 424 gl.vertexAttrib4f(1, 5, 6, 7, 8); |
| 425 shouldBe('gl.getVertexAttrib(1, gl.CURRENT_VERTEX_ATTRIB)', '[5, 6, 7, 8]'); |
| 426 glErrorShouldBe(gl, gl.NO_ERROR); |
| 427 testInvalidArgument( |
| 428 "getVertexAttrib", |
| 429 "parameter", |
| 430 [ gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, |
| 431 gl.VERTEX_ATTRIB_ARRAY_ENABLED, |
| 432 gl.VERTEX_ATTRIB_ARRAY_SIZE, |
| 433 gl.VERTEX_ATTRIB_ARRAY_STRIDE, |
| 434 gl.VERTEX_ATTRIB_ARRAY_TYPE, |
| 435 gl.VERTEX_ATTRIB_ARRAY_NORMALIZED, |
| 436 gl.VERTEX_ATTRIB_ARRAY_STRIDE, |
| 437 gl.VERTEX_ATTRIB_ARRAY_ENABLED, |
| 438 gl.CURRENT_VERTEX_ATTRIB |
| 439 ], |
| 440 function(parameter) { |
| 441 return gl.getVertexAttrib(1, parameter); |
| 442 } |
| 443 ); |
| 444 var numVertexAttribs = gl.getParameter(gl.MAX_VERTEX_ATTRIBS); |
| 445 shouldGenerateGLError(gl, gl.INVALID_VALUE, 'gl.getVertexAttrib(' + numVertexAtt
ribs + ', gl.CURRENT_VERTEX_ATTRIB)'); |
| 446 |
| 447 debug(""); |
| 448 debug("Test cases where name == 0"); |
| 449 gl.deleteTexture(texture); |
| 450 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHME
NT0, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.NONE'); |
| 451 gl.deleteRenderbuffer(renderbuffer); |
| 452 shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHME
NT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.NONE'); |
| 453 gl.deleteBuffer(buffer); |
| 454 shouldBeNull('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING)'); |
| 455 glErrorShouldBe(gl, gl.NO_ERROR); |
| 456 |
| 457 successfullyParsed = true; |
| 458 </script> |
| 459 |
| 460 <script src="../../resources/js-test-post.js"></script> |
| 461 </body> |
| 462 </html> |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 10399113:
Roll webgl conformance tests to r17874: part 2, adding r17874 (Closed)
Base URL: svn://chrome-svn/chrome/trunk/deps/