1/* 2 * Copyright (C) 2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16import hilog from '@ohos.hilog'; 17import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect, TestType, Level, Size } from '@ohos/hypium'; 18 19import {checkError, createProgram, getColorUint8Array,clear,WEBGL2_FRAGMENT_SHADER_DEMO} from './WebGL2'; 20 21 22export default function webgl2_uniform() { 23 24 describe('webgl2_uniform', function () { 25 let gl = global.gl2; 26 // Defines a test suite. Two parameters are supported: test suite name and test suite function. 27 beforeAll(function () { 28 hilog.info(0x0000, 'testTag', '%{public}s', 'webgl1_test_01 start'); 29 // Presets an action, which is performed only once before all test cases of the test suite start. 30 // This API supports only one parameter: preset action function. 31 }); 32 beforeEach(function () { 33 // Presets an action, which is performed before each unit test case starts. 34 // The number of execution times is the same as the number of test cases defined by **it**. 35 // This API supports only one parameter: preset action function. 36 checkError(gl); 37 }); 38 afterEach(function () { 39 // Presets a clear action, which is performed after each unit test case ends. 40 // The number of execution times is the same as the number of test cases defined by **it**. 41 // This API supports only one parameter: clear action function. 42 checkError(gl); 43 }); 44 afterAll(function () { 45 // Presets a clear action, which is performed after all test cases of the test suite end. 46 // This API supports only one parameter: clear action function. 47 hilog.info(0x0000, 'testTag', '%{public}s', 'webgl1_test_01 end'); 48 }); 49 function uniform(callback, finish) { 50 let p = createProgram(gl, `#version 300 es 51 uniform uint u; 52 void main(){ 53 gl_Position = vec4(0.0,0.0,0.0,1.0); 54 gl_PointSize = float(u); 55 } 56 `, WEBGL2_FRAGMENT_SHADER_DEMO); 57 gl.useProgram(p.program); 58 let u = gl.getUniformLocation(p.program, "u"); 59 callback(u); 60 let uniform = gl.getUniform(p.program, u); 61 clear(gl); 62 gl.drawArrays(gl.POINTS, 0, 1); 63 gl.deleteShader(p.vertexShader); 64 gl.deleteShader(p.fragmentShader); 65 gl.deleteProgram(p.program); 66 finish(); 67 checkError(gl); 68 } 69 /** 70 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0001 71 * @tc.name webgl2_test_uniform1ui 72 * @tc.desc Test uniform1ui. 73 */ 74 it('webgl2_test_uniform1ui', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 75 console.info("webgl2test [webgl2_test_uniform1ui] uniform1ui"); 76 let p = createProgram(gl, `#version 300 es 77 uniform uint u; 78 void main(){ 79 gl_Position = vec4(0.0,0.0,0.0,1.0); 80 gl_PointSize = float(u); 81 } 82 `, WEBGL2_FRAGMENT_SHADER_DEMO); 83 gl.useProgram(p.program); 84 let u = gl.getUniformLocation(p.program, "u"); 85 gl.uniform1ui(u, 100); 86 let uniform = gl.getUniform(p.program, u); 87 console.info("webgltest", uniform); 88 expect(uniform).assertEqual(100); 89 clear(gl); 90 gl.drawArrays(gl.POINTS, 0, 1); 91 gl.deleteShader(p.vertexShader); 92 gl.deleteShader(p.fragmentShader); 93 gl.deleteProgram(p.program); 94 checkError(gl); 95 done(); 96 }); 97 /** 98 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0002 99 * @tc.name webgl2_test_uniform1ui_1 100 * @tc.desc Test uniform1ui. 101 */ 102 it('webgl2_test_uniform1ui_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 103 console.info("webgl2test [webgl2_test_uniform1ui_1] uniform1ui"); 104 uniform((u) => { 105 gl.uniform1ui(u, null); 106 }, () => { 107 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 108 }); 109 done(); 110 }); 111 /** 112 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0003 113 * @tc.name webgl2_test_uniform1ui_2 114 * @tc.desc Test uniform1ui. 115 */ 116 it('webgl2_test_uniform1ui_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 117 console.info("webgl2test [webgl2_test_uniform1ui_2] uniform1ui"); 118 uniform((u) => { 119 gl.uniform1ui(u, undefined); 120 }, () => { 121 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 122 }); 123 done(); 124 }); 125 /** 126 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0004 127 * @tc.name webgl2_test_uniform1ui_3 128 * @tc.desc Test uniform1ui. 129 */ 130 it('webgl2_test_uniform1ui_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 131 console.info("webgl2test [webgl2_test_uniform1ui_3] uniform1ui"); 132 uniform((u) => { 133 gl.uniform1ui(u, "100"); 134 }, () => { 135 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 136 }); 137 done(); 138 }); 139 /** 140 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0005 141 * @tc.name webgl2_test_uniform1ui_4 142 * @tc.desc Test uniform1ui. 143 */ 144 it('webgl2_test_uniform1ui_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 145 console.info("webgl2test [webgl2_test_uniform1ui_4] uniform1ui"); 146 uniform((u) => { 147 gl.uniform1ui(null, 100); 148 }, () => { 149 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 150 }); 151 done(); 152 }); 153 /** 154 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0006 155 * @tc.name webgl2_test_uniform1ui_5 156 * @tc.desc Test uniform1ui. 157 */ 158 it('webgl2_test_uniform1ui_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 159 console.info("webgl2test [webgl2_test_uniform1ui_5] uniform1ui"); 160 uniform((u) => { 161 gl.uniform1ui(undefined, 100); 162 }, () => { 163 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 164 }); 165 done(); 166 }); 167 /** 168 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0007 169 * @tc.name webgl2_test_uniform1ui_6 170 * @tc.desc Test uniform1ui. 171 */ 172 it('webgl2_test_uniform1ui_6', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 173 console.info("webgl2test [webgl2_test_uniform1ui_6] uniform1ui"); 174 uniform((u) => { 175 gl.uniform1ui(undefined, undefined); 176 }, () => { 177 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 178 }); 179 done(); 180 }); 181 /** 182 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0008 183 * @tc.name webgl2_test_uniform1ui_7 184 * @tc.desc Test uniform1ui. 185 */ 186 it('webgl2_test_uniform1ui_7', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 187 console.info("webgl2test [webgl2_test_uniform1ui_7] uniform1ui"); 188 uniform((u) => { 189 gl.uniform1ui(null, null); 190 }, () => { 191 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 192 }); 193 done(); 194 }); 195 function uniform2ui(callback, finish) { 196 let p = createProgram(gl, `#version 300 es 197 uniform uvec2 u; 198 void main(){ 199 gl_Position.x = float(u.x); 200 gl_Position.y = float(u.y); 201 gl_Position.w = 1.0; 202 gl_PointSize = 100.0; 203 } 204 `, WEBGL2_FRAGMENT_SHADER_DEMO); 205 gl.useProgram(p.program); 206 let u = gl.getUniformLocation(p.program, "u"); 207 callback(u); 208 let uniform = gl.getUniform(p.program, u); 209 clear(gl); 210 gl.drawArrays(gl.POINTS, 0, 1); 211 gl.deleteShader(p.vertexShader); 212 gl.deleteShader(p.fragmentShader); 213 gl.deleteProgram(p.program); 214 finish(); 215 checkError(gl); 216 } 217 /** 218 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0009 219 * @tc.name webgl2_test_uniform2ui 220 * @tc.desc Test uniform2ui. 221 */ 222 it('webgl2_test_uniform2ui', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 223 console.info("webgl2test [webgl2_test_uniform2ui] uniform2ui"); 224 let p = createProgram(gl, `#version 300 es 225 uniform uvec2 u; 226 void main(){ 227 gl_Position.x = float(u.x); 228 gl_Position.y = float(u.y); 229 gl_Position.w = 1.0; 230 gl_PointSize = 100.0; 231 } 232 `, WEBGL2_FRAGMENT_SHADER_DEMO); 233 gl.useProgram(p.program); 234 let u = gl.getUniformLocation(p.program, "u"); 235 gl.uniform2ui(u, 1, 1); 236 let uniform = gl.getUniform(p.program, u); 237 console.info("webgltest", uniform); 238 expect(uniform[0]).assertEqual(1); 239 expect(uniform[1]).assertEqual(1); 240 clear(gl); 241 gl.drawArrays(gl.POINTS, 0, 1); 242 gl.deleteShader(p.vertexShader); 243 gl.deleteShader(p.fragmentShader); 244 gl.deleteProgram(p.program); 245 checkError(gl); 246 done(); 247 }); 248 /** 249 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0010 250 * @tc.name webgl2_test_uniform2ui_1 251 * @tc.desc Test uniform2ui. 252 */ 253 it('webgl2_test_uniform2ui_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 254 console.info("webgl2test [webgl2_test_uniform2ui_1] uniform2ui"); 255 uniform2ui((u) => { 256 gl.uniform2ui(u, 1, null); 257 }, () => { 258 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 259 }); 260 done(); 261 }); 262 /** 263 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0011 264 * @tc.name webgl2_test_uniform2ui_2 265 * @tc.desc Test uniform2ui. 266 */ 267 it('webgl2_test_uniform2ui_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 268 console.info("webgl2test [webgl2_test_uniform2ui_2] uniform2ui"); 269 uniform2ui((u) => { 270 gl.uniform2ui(u, 1, undefined); 271 }, () => { 272 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 273 }); 274 done(); 275 }); 276 /** 277 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0012 278 * @tc.name webgl2_test_uniform2ui_3 279 * @tc.desc Test uniform2ui. 280 */ 281 it('webgl2_test_uniform2ui_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 282 console.info("webgl2test [webgl2_test_uniform2ui_3] uniform2ui"); 283 uniform2ui((u) => { 284 gl.uniform2ui(u, 1, undefined); 285 }, () => { 286 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 287 }); 288 done(); 289 }); 290 /** 291 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0013 292 * @tc.name webgl2_test_uniform2ui_4 293 * @tc.desc Test uniform2ui. 294 */ 295 it('webgl2_test_uniform2ui_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 296 console.info("webgl2test [webgl2_test_uniform2ui_4] uniform2ui"); 297 uniform2ui((u) => { 298 gl.uniform2ui(u, null, null); 299 }, () => { 300 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 301 }); 302 done(); 303 }); 304 /** 305 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0014 306 * @tc.name webgl2_test_uniform2ui_5 307 * @tc.desc Test uniform2ui. 308 */ 309 it('webgl2_test_uniform2ui_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 310 console.info("webgl2test [webgl2_test_uniform2ui_5] uniform2ui"); 311 uniform2ui((u) => { 312 gl.uniform2ui(u, undefined, undefined); 313 }, () => { 314 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 315 }); 316 done(); 317 }); 318 /** 319 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0015 320 * @tc.name webgl2_test_uniform2ui_6 321 * @tc.desc Test uniform2ui. 322 */ 323 it('webgl2_test_uniform2ui_6', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 324 console.info("webgl2test [webgl2_test_uniform2ui_6] uniform2ui"); 325 uniform2ui((u) => { 326 gl.uniform2ui(null, null, null); 327 }, () => { 328 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 329 }); 330 done(); 331 }); 332 /** 333 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0016 334 * @tc.name webgl2_test_uniform2ui_7 335 * @tc.desc Test uniform2ui. 336 */ 337 it('webgl2_test_uniform2ui_7', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 338 console.info("webgl2test [webgl2_test_uniform2ui_7] uniform2ui"); 339 uniform2ui((u) => { 340 gl.uniform2ui(undefined, undefined, undefined); 341 }, () => { 342 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 343 }); 344 done(); 345 }); 346 function uniform3ui(callback, finish) { 347 let p = createProgram(gl, `#version 300 es 348 uniform uvec3 u; 349 void main(){ 350 gl_Position.x = float(u.x); 351 gl_Position.y = float(u.y); 352 gl_Position.z = float(u.z); 353 gl_Position.w = 1.0; 354 gl_PointSize = 100.0; 355 } 356 `, WEBGL2_FRAGMENT_SHADER_DEMO); 357 gl.useProgram(p.program); 358 let u = gl.getUniformLocation(p.program, "u"); 359 callback(u); 360 let uniform = gl.getUniform(p.program, u); 361 clear(gl); 362 gl.drawArrays(gl.POINTS, 0, 1); 363 gl.deleteShader(p.vertexShader); 364 gl.deleteShader(p.fragmentShader); 365 gl.deleteProgram(p.program); 366 finish(); 367 checkError(gl); 368 } 369 /** 370 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0017 371 * @tc.name webgl2_test_uniform3ui 372 * @tc.desc Test uniform3ui. 373 */ 374 it('webgl2_test_uniform3ui', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 375 console.info("webgl2test [webgl2_test_uniform3ui] uniform3ui"); 376 let p = createProgram(gl, `#version 300 es 377 uniform uvec3 u; 378 void main(){ 379 gl_Position.x = float(u.x); 380 gl_Position.y = float(u.y); 381 gl_Position.z = float(u.z); 382 gl_Position.w = 1.0; 383 gl_PointSize = 100.0; 384 } 385 `, WEBGL2_FRAGMENT_SHADER_DEMO); 386 gl.useProgram(p.program); 387 let u = gl.getUniformLocation(p.program, "u"); 388 gl.uniform3ui(u, 0, 1, 1); 389 let uniform = gl.getUniform(p.program, u); 390 console.info("webgltest", uniform); 391 expect(uniform[0]).assertEqual(0); 392 expect(uniform[1]).assertEqual(1); 393 expect(uniform[2]).assertEqual(1); 394 clear(gl); 395 gl.drawArrays(gl.POINTS, 0, 1); 396 gl.deleteShader(p.vertexShader); 397 gl.deleteShader(p.fragmentShader); 398 gl.deleteProgram(p.program); 399 checkError(gl); 400 done(); 401 }); 402 /** 403 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0018 404 * @tc.name webgl2_test_uniform3ui_1 405 * @tc.desc Test uniform3ui. 406 */ 407 it('webgl2_test_uniform3ui_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 408 console.info("webgl2test [webgl2_test_uniform3ui_1] uniform3ui"); 409 uniform3ui((u) => { 410 gl.uniform3ui(u, 0, 1, null); 411 }, () => { 412 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 413 }); 414 done(); 415 }); 416 /** 417 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0019 418 * @tc.name webgl2_test_uniform3ui_2 419 * @tc.desc Test uniform3ui. 420 */ 421 it('webgl2_test_uniform3ui_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 422 console.info("webgl2test [webgl2_test_uniform3ui_2] uniform3ui"); 423 uniform3ui((u) => { 424 gl.uniform3ui(u, 0, 1, undefined); 425 }, () => { 426 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 427 }); 428 done(); 429 }); 430 /** 431 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0020 432 * @tc.name webgl2_test_uniform3ui_3 433 * @tc.desc Test uniform3ui. 434 */ 435 it('webgl2_test_uniform3ui_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 436 console.info("webgl2test [webgl2_test_uniform3ui_3] uniform3ui"); 437 uniform3ui((u) => { 438 gl.uniform3ui(u, 0, null, undefined); 439 }, () => { 440 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 441 }); 442 done(); 443 }); 444 /** 445 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0021 446 * @tc.name webgl2_test_uniform3ui_4 447 * @tc.desc Test uniform3ui. 448 */ 449 it('webgl2_test_uniform3ui_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 450 console.info("webgl2test [webgl2_test_uniform3ui_4] uniform3ui"); 451 uniform3ui((u) => { 452 gl.uniform3ui(u, null, null, undefined); 453 }, () => { 454 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 455 }); 456 done(); 457 }); 458 /** 459 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0022 460 * @tc.name webgl2_test_uniform3ui_5 461 * @tc.desc Test uniform3ui. 462 */ 463 it('webgl2_test_uniform3ui_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 464 console.info("webgl2test [webgl2_test_uniform3ui_5] uniform3ui"); 465 uniform3ui((u) => { 466 gl.uniform3ui(null, null, null, undefined); 467 }, () => { 468 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 469 }); 470 done(); 471 }); 472 function uniform4ui(callback, finish) { 473 let p = createProgram(gl, `#version 300 es 474 uniform uvec4 u; 475 void main(){ 476 gl_Position.x = float(u.x); 477 gl_Position.y = float(u.y); 478 gl_Position.z = float(u.z); 479 gl_Position.w = float(u.w); 480 gl_PointSize = 100.0; 481 } 482 `, WEBGL2_FRAGMENT_SHADER_DEMO); 483 gl.useProgram(p.program); 484 let u = gl.getUniformLocation(p.program, "u"); 485 callback(u); 486 let uniform = gl.getUniform(p.program, u); 487 clear(gl); 488 gl.drawArrays(gl.POINTS, 0, 1); 489 gl.deleteShader(p.vertexShader); 490 gl.deleteShader(p.fragmentShader); 491 gl.deleteProgram(p.program); 492 finish(); 493 checkError(gl); 494 } 495 /** 496 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0023 497 * @tc.name webgl2_test_uniform4ui 498 * @tc.desc Test uniform4ui. 499 */ 500 it('webgl2_test_uniform4ui', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 501 console.info("webgl2test [webgl2_test_uniform4ui] uniform4ui"); 502 let p = createProgram(gl, `#version 300 es 503 uniform uvec4 u; 504 void main(){ 505 gl_Position.x = float(u.x); 506 gl_Position.y = float(u.y); 507 gl_Position.z = float(u.z); 508 gl_Position.w = float(u.w); 509 gl_PointSize = 100.0; 510 } 511 `, WEBGL2_FRAGMENT_SHADER_DEMO); 512 gl.useProgram(p.program); 513 let u = gl.getUniformLocation(p.program, "u"); 514 gl.uniform4ui(u, 1, 1, 1, 1); 515 let uniform = gl.getUniform(p.program, u); 516 console.info("webgltest", uniform); 517 expect(uniform[0]).assertEqual(1); 518 expect(uniform[1]).assertEqual(1); 519 expect(uniform[2]).assertEqual(1); 520 expect(uniform[3]).assertEqual(1); 521 clear(gl); 522 gl.drawArrays(gl.POINTS, 0, 1); 523 gl.deleteShader(p.vertexShader); 524 gl.deleteShader(p.fragmentShader); 525 gl.deleteProgram(p.program); 526 checkError(gl); 527 done(); 528 }); 529 /** 530 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0024 531 * @tc.name webgl2_test_uniform4ui_1 532 * @tc.desc Test uniform4ui. 533 */ 534 it('webgl2_test_uniform4ui_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 535 console.info("webgl2test [webgl2_test_uniform4ui_1] uniform4ui"); 536 uniform4ui((u) => { 537 gl.uniform4ui(u, 1, 1, 1, null); 538 }, () => { 539 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 540 }); 541 done(); 542 }); 543 /** 544 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0025 545 * @tc.name webgl2_test_uniform4ui_2 546 * @tc.desc Test uniform4ui. 547 */ 548 it('webgl2_test_uniform4ui_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 549 console.info("webgl2test [webgl2_test_uniform4ui_2] uniform4ui"); 550 uniform4ui((u) => { 551 gl.uniform4ui(u, 1, 1, null, null); 552 }, () => { 553 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 554 }); 555 done(); 556 }); 557 /** 558 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0026 559 * @tc.name webgl2_test_uniform4ui_3 560 * @tc.desc Test uniform4ui. 561 */ 562 it('webgl2_test_uniform4ui_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 563 console.info("webgl2test [webgl2_test_uniform4ui_3] uniform4ui"); 564 uniform4ui((u) => { 565 gl.uniform4ui(u, 1, null, null, null); 566 }, () => { 567 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 568 }); 569 done(); 570 }); 571 /** 572 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0027 573 * @tc.name webgl2_test_uniform4ui_4 574 * @tc.desc Test uniform4ui. 575 */ 576 it('webgl2_test_uniform4ui_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 577 console.info("webgl2test [webgl2_test_uniform4ui_4] uniform4ui"); 578 uniform4ui((u) => { 579 gl.uniform4ui(u, null, null, null, null); 580 }, () => { 581 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 582 }); 583 done(); 584 }); 585 /** 586 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0028 587 * @tc.name webgl2_test_uniform4ui_5 588 * @tc.desc Test uniform4ui. 589 */ 590 it('webgl2_test_uniform4ui_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 591 console.info("webgl2test [webgl2_test_uniform4ui_5] uniform4ui"); 592 uniform4ui((u) => { 593 gl.uniform4ui(null, null, null, null, null); 594 }, () => { 595 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 596 }); 597 done(); 598 }); 599 /** 600 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0029 601 * @tc.name webgl2_test_uniform4ui_6 602 * @tc.desc Test uniform4ui. 603 */ 604 it('webgl2_test_uniform4ui_6', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 605 console.info("webgl2test [webgl2_test_uniform4ui_6] uniform4ui"); 606 uniform4ui((u) => { 607 gl.uniform4ui(u, 1, 1, 1, undefined); 608 }, () => { 609 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 610 }); 611 done(); 612 }); 613 /** 614 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0030 615 * @tc.name webgl2_test_uniform4ui_7 616 * @tc.desc Test uniform4ui. 617 */ 618 it('webgl2_test_uniform4ui_7', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 619 console.info("webgl2test [webgl2_test_uniform4ui_7] uniform4ui"); 620 uniform4ui((u) => { 621 gl.uniform4ui(u, 1, 1, undefined, undefined); 622 }, () => { 623 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 624 }); 625 done(); 626 }); 627 /** 628 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0031 629 * @tc.name webgl2_test_uniform4ui_8 630 * @tc.desc Test uniform4ui. 631 */ 632 it('webgl2_test_uniform4ui_8', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 633 console.info("webgl2test [webgl2_test_uniform4ui_8] uniform4ui"); 634 uniform4ui((u) => { 635 gl.uniform4ui(u, 1, undefined, undefined, undefined); 636 }, () => { 637 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 638 }); 639 done(); 640 }); 641 /** 642 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0032 643 * @tc.name webgl2_test_uniform4ui_9 644 * @tc.desc Test uniform4ui. 645 */ 646 it('webgl2_test_uniform4ui_9', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 647 console.info("webgl2test [webgl2_test_uniform4ui_9] uniform4ui"); 648 uniform4ui((u) => { 649 gl.uniform4ui(u, undefined, undefined, undefined, undefined); 650 }, () => { 651 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 652 }); 653 done(); 654 }); 655 /** 656 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0033 657 * @tc.name webgl2_test_uniform4ui_10 658 * @tc.desc Test uniform4ui. 659 */ 660 it('webgl2_test_uniform4ui_10', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 661 console.info("webgl2test [webgl2_test_uniform4ui_10] uniform4ui"); 662 uniform4ui((u) => { 663 gl.uniform4ui(undefined, undefined, undefined, undefined, undefined); 664 }, () => { 665 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 666 }); 667 done(); 668 }); 669 function uniform1uiv(callback, finish) { 670 let p = createProgram(gl, `#version 300 es 671 uniform uint u; 672 void main(){ 673 gl_Position.x = float(u); 674 gl_Position.w = 1.0; 675 gl_PointSize = 100.0; 676 } 677 `, WEBGL2_FRAGMENT_SHADER_DEMO); 678 gl.useProgram(p.program); 679 let u = gl.getUniformLocation(p.program, "u"); 680 callback(u); 681 let uniform = gl.getUniform(p.program, u); 682 clear(gl); 683 gl.drawArrays(gl.POINTS, 0, 1); 684 gl.deleteShader(p.vertexShader); 685 gl.deleteShader(p.fragmentShader); 686 gl.deleteProgram(p.program); 687 finish(); 688 } 689 /** 690 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0034 691 * @tc.name webgl2_test_uniform1uiv 692 * @tc.desc Test uniform1uiv. 693 */ 694 it('webgl2_test_uniform1uiv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 695 console.info("webgl2test [webgl2_test_uniform1uiv] uniform1uiv"); 696 let p = createProgram(gl, `#version 300 es 697 uniform uint u; 698 void main(){ 699 gl_Position.x = float(u); 700 gl_Position.w = 1.0; 701 gl_PointSize = 100.0; 702 } 703 `, WEBGL2_FRAGMENT_SHADER_DEMO); 704 gl.useProgram(p.program); 705 let u = gl.getUniformLocation(p.program, "u"); 706 gl.uniform1uiv(u, new Uint32Array([1, 0]), 1, 1); 707 let uniform = gl.getUniform(p.program, u); 708 console.info("webgltest", uniform); 709 expect(uniform).assertEqual(0); 710 clear(gl); 711 gl.drawArrays(gl.POINTS, 0, 1); 712 gl.deleteShader(p.vertexShader); 713 gl.deleteShader(p.fragmentShader); 714 gl.deleteProgram(p.program); 715 checkError(gl); 716 done(); 717 }); 718 /** 719 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0035 720 * @tc.name webgl2_test_uniform1uiv_1 721 * @tc.desc Test uniform1uiv. 722 */ 723 it('webgl2_test_uniform1uiv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 724 console.info("webgl2test [webgl2_test_uniform1uiv_1] uniform1uiv"); 725 uniform1uiv((u) => { 726 gl.uniform1uiv(u, new Uint32Array([1, 0]), 1, null); 727 }, () => { 728 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 729 }); 730 done(); 731 }); 732 /** 733 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0036 734 * @tc.name webgl2_test_uniform1uiv_2 735 * @tc.desc Test uniform1uiv. 736 */ 737 it('webgl2_test_uniform1uiv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 738 console.info("webgl2test [webgl2_test_uniform1uiv_2] uniform1uiv"); 739 uniform1uiv((u) => { 740 gl.uniform1uiv(u, new Uint32Array([1, 0]), 1, undefined); 741 }, () => { 742 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 743 }); 744 done(); 745 }); 746 /** 747 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0037 748 * @tc.name webgl2_test_uniform1uiv_3 749 * @tc.desc Test uniform1uiv. 750 */ 751 it('webgl2_test_uniform1uiv_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 752 console.info("webgl2test [webgl2_test_uniform1uiv_3] uniform1uiv"); 753 uniform1uiv((u) => { 754 gl.uniform1uiv(u, new Uint32Array([1, 0]), undefined, undefined); 755 }, () => { 756 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 757 }); 758 done(); 759 }); 760 /** 761 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0038 762 * @tc.name webgl2_test_uniform1uiv_4 763 * @tc.desc Test uniform1uiv. 764 */ 765 it('webgl2_test_uniform1uiv_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 766 console.info("webgl2test [webgl2_test_uniform1uiv_4] uniform1uiv"); 767 uniform1uiv((u) => { 768 gl.uniform1uiv(u, new Uint32Array([1, 0]), null, undefined); 769 }, () => { 770 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 771 }); 772 done(); 773 }); 774 /** 775 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0039 776 * @tc.name webgl2_test_uniform1uiv_5 777 * @tc.desc Test uniform1uiv. 778 */ 779 it('webgl2_test_uniform1uiv_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 780 console.info("webgl2test [webgl2_test_uniform1uiv_5] uniform1uiv"); 781 uniform1uiv((u) => { 782 gl.uniform1uiv(null, new Uint32Array([1, 0]), null, undefined); 783 }, () => { 784 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 785 }); 786 done(); 787 }); 788 function uniform2uiv(callback, finish) { 789 let p = createProgram(gl, `#version 300 es 790 uniform uvec2 u; 791 void main(){ 792 gl_Position.x = float(u.x); 793 gl_Position.y = float(u.y); 794 gl_Position.w = 1.0; 795 gl_PointSize = 100.0; 796 } 797 `, WEBGL2_FRAGMENT_SHADER_DEMO); 798 gl.useProgram(p.program); 799 let u = gl.getUniformLocation(p.program, "u"); 800 callback(u); 801 let uniform = gl.getUniform(p.program, u); 802 clear(gl); 803 gl.drawArrays(gl.POINTS, 0, 1); 804 gl.deleteShader(p.vertexShader); 805 gl.deleteShader(p.fragmentShader); 806 gl.deleteProgram(p.program); 807 finish(); 808 } 809 /** 810 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0040 811 * @tc.name webgl2_test_uniform2uiv 812 * @tc.desc Test uniform2uiv. 813 */ 814 it('webgl2_test_uniform2uiv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 815 console.info("webgl2test [webgl2_test_uniform2uiv] uniform2uiv"); 816 let p = createProgram(gl, `#version 300 es 817 uniform uvec2 u; 818 void main(){ 819 gl_Position.x = float(u.x); 820 gl_Position.y = float(u.y); 821 gl_Position.w = 1.0; 822 gl_PointSize = 100.0; 823 } 824 `, WEBGL2_FRAGMENT_SHADER_DEMO); 825 gl.useProgram(p.program); 826 let u = gl.getUniformLocation(p.program, "u"); 827 gl.uniform2uiv(u, new Uint32Array([0, 1, 1]), 1, 2); 828 let uniform = gl.getUniform(p.program, u); 829 console.info("webgltest", uniform); 830 expect(uniform[0]).assertEqual(1); 831 expect(uniform[1]).assertEqual(1); 832 clear(gl); 833 gl.drawArrays(gl.POINTS, 0, 1); 834 gl.deleteShader(p.vertexShader); 835 gl.deleteShader(p.fragmentShader); 836 gl.deleteProgram(p.program); 837 checkError(gl); 838 done(); 839 }); 840 /** 841 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0041 842 * @tc.name webgl2_test_uniform2uiv_1 843 * @tc.desc Test uniform2uiv. 844 */ 845 it('webgl2_test_uniform2uiv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 846 console.info("webgl2test [webgl2_test_uniform2uiv_1] uniform2uiv"); 847 uniform2uiv((u) => { 848 gl.uniform2uiv(u, new Uint32Array([0, 1, 1]), 1, null); 849 }, () => { 850 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 851 }); 852 done(); 853 }); 854 /** 855 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0042 856 * @tc.name webgl2_test_uniform2uiv_2 857 * @tc.desc Test uniform2uiv. 858 */ 859 it('webgl2_test_uniform2uiv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 860 console.info("webgl2test [webgl2_test_uniform2uiv_2] uniform2uiv"); 861 uniform2uiv((u) => { 862 gl.uniform2uiv(u, new Uint32Array([0, 1, 1]), 1, undefined); 863 }, () => { 864 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 865 }); 866 done(); 867 }); 868 /** 869 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0043 870 * @tc.name webgl2_test_uniform2uiv_3 871 * @tc.desc Test uniform2uiv. 872 */ 873 it('webgl2_test_uniform2uiv_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 874 console.info("webgl2test [webgl2_test_uniform2uiv_3] uniform2uiv"); 875 uniform2uiv((u) => { 876 gl.uniform2uiv(u, new Uint32Array([0, 1, 1]), undefined, undefined); 877 }, () => { 878 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 879 }); 880 done(); 881 }); 882 /** 883 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0044 884 * @tc.name webgl2_test_uniform2uiv_4 885 * @tc.desc Test uniform2uiv. 886 */ 887 it('webgl2_test_uniform2uiv_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 888 console.info("webgl2test [webgl2_test_uniform2uiv_4] uniform2uiv"); 889 uniform2uiv((u) => { 890 gl.uniform2uiv(u, new Uint32Array([0, 1, 1]), null, undefined); 891 }, () => { 892 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 893 }); 894 done(); 895 }); 896 /** 897 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0045 898 * @tc.name webgl2_test_uniform2uiv_5 899 * @tc.desc Test uniform2uiv. 900 */ 901 it('webgl2_test_uniform2uiv_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 902 console.info("webgl2test [webgl2_test_uniform2uiv_5] uniform2uiv"); 903 uniform2uiv((u) => { 904 gl.uniform2uiv(null, new Uint32Array([0, 1, 1]), null, undefined); 905 }, () => { 906 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 907 }); 908 done(); 909 }); 910 function uniform3uiv(callback, finish) { 911 let p = createProgram(gl, `#version 300 es 912 uniform uvec3 u; 913 void main(){ 914 gl_Position.x = float(u.x); 915 gl_Position.y = float(u.y); 916 gl_Position.z = float(u.z); 917 gl_Position.w = 1.0; 918 gl_PointSize = 100.0; 919 } 920 `, WEBGL2_FRAGMENT_SHADER_DEMO); 921 gl.useProgram(p.program); 922 let u = gl.getUniformLocation(p.program, "u"); 923 callback(u); 924 let uniform = gl.getUniform(p.program, u); 925 clear(gl); 926 gl.drawArrays(gl.POINTS, 0, 1); 927 gl.deleteShader(p.vertexShader); 928 gl.deleteShader(p.fragmentShader); 929 gl.deleteProgram(p.program); 930 finish(); 931 } 932 /** 933 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0046 934 * @tc.name webgl2_test_uniform3uiv 935 * @tc.desc Test uniform3uiv. 936 */ 937 it('webgl2_test_uniform3uiv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 938 console.info("webgl2test [webgl2_test_uniform3uiv] uniform3uiv"); 939 let p = createProgram(gl, `#version 300 es 940 uniform uvec3 u; 941 void main(){ 942 gl_Position.x = float(u.x); 943 gl_Position.y = float(u.y); 944 gl_Position.z = float(u.z); 945 gl_Position.w = 1.0; 946 gl_PointSize = 100.0; 947 } 948 `, WEBGL2_FRAGMENT_SHADER_DEMO); 949 gl.useProgram(p.program); 950 let u = gl.getUniformLocation(p.program, "u"); 951 gl.uniform3uiv(u, new Uint32Array([0, 1, 1, 1]), 1, 3); 952 let uniform = gl.getUniform(p.program, u); 953 console.info("webgltest", uniform); 954 expect(uniform[0]).assertEqual(1); 955 expect(uniform[1]).assertEqual(1); 956 expect(uniform[2]).assertEqual(1); 957 clear(gl); 958 gl.drawArrays(gl.POINTS, 0, 1); 959 gl.deleteShader(p.vertexShader); 960 gl.deleteShader(p.fragmentShader); 961 gl.deleteProgram(p.program); 962 checkError(gl); 963 done(); 964 }); 965 /** 966 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0047 967 * @tc.name webgl2_test_uniform3uiv_1 968 * @tc.desc Test uniform3uiv. 969 */ 970 it('webgl2_test_uniform3uiv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 971 console.info("webgl2test [webgl2_test_uniform3uiv_1] uniform3uiv"); 972 uniform3uiv((u) => { 973 gl.uniform3uiv(u, new Uint32Array([0, 1, 1, 1]), 1, null); 974 }, () => { 975 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 976 }); 977 done(); 978 }); 979 /** 980 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0048 981 * @tc.name webgl2_test_uniform3uiv_2 982 * @tc.desc Test uniform3uiv. 983 */ 984 it('webgl2_test_uniform3uiv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 985 console.info("webgl2test [webgl2_test_uniform3uiv_2] uniform3uiv"); 986 uniform3uiv((u) => { 987 gl.uniform3uiv(u, new Uint32Array([0, 1, 1, 1]), 1, undefined); 988 }, () => { 989 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 990 }); 991 done(); 992 }); 993 /** 994 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0049 995 * @tc.name webgl2_test_uniform3uiv_3 996 * @tc.desc Test uniform3uiv. 997 */ 998 it('webgl2_test_uniform3uiv_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 999 console.info("webgl2test [webgl2_test_uniform3uiv_3] uniform3uiv"); 1000 uniform3uiv((u) => { 1001 gl.uniform3uiv(u, new Uint32Array([0, 1, 1, 1]), undefined, undefined); 1002 }, () => { 1003 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1004 }); 1005 done(); 1006 }); 1007 /** 1008 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0050 1009 * @tc.name webgl2_test_uniform3uiv_4 1010 * @tc.desc Test uniform3uiv. 1011 */ 1012 it('webgl2_test_uniform3uiv_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 1013 console.info("webgl2test [webgl2_test_uniform3uiv_4] uniform3uiv"); 1014 uniform3uiv((u) => { 1015 gl.uniform3uiv(u, new Uint32Array([0, 1, 1, 1]), null, undefined); 1016 }, () => { 1017 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1018 }); 1019 done(); 1020 }); 1021 /** 1022 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0051 1023 * @tc.name webgl2_test_uniform3uiv_5 1024 * @tc.desc Test uniform3uiv. 1025 */ 1026 it('webgl2_test_uniform3uiv_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 1027 console.info("webgl2test [webgl2_test_uniform3uiv_5] uniform3uiv"); 1028 uniform3uiv((u) => { 1029 gl.uniform3uiv(null, new Uint32Array([0, 1, 1, 1]), null, undefined); 1030 }, () => { 1031 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1032 }); 1033 done(); 1034 }); 1035 function uniform4uiv(callback, finish) { 1036 let p = createProgram(gl, `#version 300 es 1037 uniform uvec4 u; 1038 void main(){ 1039 gl_Position.x = float(u.x); 1040 gl_Position.y = float(u.y); 1041 gl_Position.z = float(u.z); 1042 gl_Position.w = float(u.w); 1043 gl_PointSize = 100.0; 1044 } 1045 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1046 gl.useProgram(p.program); 1047 let u = gl.getUniformLocation(p.program, "u"); 1048 callback(u); 1049 let uniform = gl.getUniform(p.program, u); 1050 clear(gl); 1051 gl.drawArrays(gl.POINTS, 0, 1); 1052 gl.deleteShader(p.vertexShader); 1053 gl.deleteShader(p.fragmentShader); 1054 gl.deleteProgram(p.program); 1055 finish(); 1056 } 1057 /** 1058 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0052 1059 * @tc.name webgl2_test_uniform4uiv 1060 * @tc.desc Test uniform4uiv. 1061 */ 1062 it('webgl2_test_uniform4uiv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 1063 console.info("webgl2test [webgl2_test_uniform4uiv] uniform4uiv"); 1064 let p = createProgram(gl, `#version 300 es 1065 uniform uvec4 u; 1066 void main(){ 1067 gl_Position.x = float(u.x); 1068 gl_Position.y = float(u.y); 1069 gl_Position.z = float(u.z); 1070 gl_Position.w = float(u.w); 1071 gl_PointSize = 100.0; 1072 } 1073 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1074 gl.useProgram(p.program); 1075 let u = gl.getUniformLocation(p.program, "u"); 1076 gl.uniform4uiv(u, new Uint32Array([0, 1, 1, 1, 1]), 1, 4); 1077 let uniform = gl.getUniform(p.program, u); 1078 console.info("webgltest", uniform); 1079 expect(uniform[0]).assertEqual(1); 1080 expect(uniform[1]).assertEqual(1); 1081 expect(uniform[2]).assertEqual(1); 1082 expect(uniform[3]).assertEqual(1); 1083 clear(gl); 1084 gl.drawArrays(gl.POINTS, 0, 1); 1085 gl.deleteShader(p.vertexShader); 1086 gl.deleteShader(p.fragmentShader); 1087 gl.deleteProgram(p.program); 1088 checkError(gl); 1089 done(); 1090 }); 1091 /** 1092 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0053 1093 * @tc.name webgl2_test_uniform4uiv_1 1094 * @tc.desc Test uniform4uiv. 1095 */ 1096 it('webgl2_test_uniform4uiv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 1097 console.info("webgl2test [webgl2_test_uniform4uiv_1] uniform4uiv"); 1098 uniform4uiv((u) => { 1099 gl.uniform4uiv(u, new Uint32Array([0, 1, 1, 1, 1]), 1, null); 1100 }, () => { 1101 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1102 }); 1103 done(); 1104 }); 1105 /** 1106 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0054 1107 * @tc.name webgl2_test_uniform4uiv_2 1108 * @tc.desc Test uniform4uiv. 1109 */ 1110 it('webgl2_test_uniform4uiv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 1111 console.info("webgl2test [webgl2_test_uniform4uiv_2] uniform4uiv"); 1112 uniform4uiv((u) => { 1113 gl.uniform4uiv(u, new Uint32Array([0, 1, 1, 1, 1]), 1, undefined); 1114 }, () => { 1115 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1116 }); 1117 done(); 1118 }); 1119 /** 1120 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0055 1121 * @tc.name webgl2_test_uniform4uiv_3 1122 * @tc.desc Test uniform4uiv. 1123 */ 1124 it('webgl2_test_uniform4uiv_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 1125 console.info("webgl2test [webgl2_test_uniform4uiv_3] uniform4uiv"); 1126 uniform4uiv((u) => { 1127 gl.uniform4uiv(u, new Uint32Array([0, 1, 1, 1, 1]), undefined, undefined); 1128 }, () => { 1129 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1130 }); 1131 done(); 1132 }); 1133 /** 1134 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0056 1135 * @tc.name webgl2_test_uniform4uiv_4 1136 * @tc.desc Test uniform4uiv. 1137 */ 1138 it('webgl2_test_uniform4uiv_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 1139 console.info("webgl2test [webgl2_test_uniform4uiv_4] uniform4uiv"); 1140 uniform4uiv((u) => { 1141 gl.uniform4uiv(u, new Uint32Array([0, 1, 1, 1, 1]), null, undefined); 1142 }, () => { 1143 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1144 }); 1145 done(); 1146 }); 1147 /** 1148 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0057 1149 * @tc.name webgl2_test_uniform4uiv_5 1150 * @tc.desc Test uniform4uiv. 1151 */ 1152 it('webgl2_test_uniform4uiv_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 1153 console.info("webgl2test [webgl2_test_uniform4uiv_5] uniform4uiv"); 1154 uniform4uiv((u) => { 1155 gl.uniform4uiv(null, new Uint32Array([0, 1, 1, 1, 1]), null, undefined); 1156 }, () => { 1157 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1158 }); 1159 done(); 1160 }); 1161 function uniformMatrix3x2fv(callback, finish) { 1162 let p = createProgram(gl, `#version 300 es 1163 in vec3 a_position; 1164 uniform mat3x2 m32; 1165 void main(){ 1166 vec2 transformedPosition = (m32 * a_position).xy; 1167 gl_Position = vec4(transformedPosition, 0.0, 1.0); 1168 } 1169 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1170 gl.useProgram(p.program); 1171 let m32 = gl.getUniformLocation(p.program, "m32"); 1172 callback(m32); 1173 let uniform = gl.getUniform(p.program, m32); 1174 clear(gl); 1175 gl.drawArrays(gl.POINTS, 0, 1); 1176 gl.deleteShader(p.vertexShader); 1177 gl.deleteShader(p.fragmentShader); 1178 gl.deleteProgram(p.program); 1179 finish(); 1180 } 1181 /** 1182 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0058 1183 * @tc.name webgl2_test_uniformMatrix3x2fv 1184 * @tc.desc Test uniformMatrix3x2fv. 1185 */ 1186 it('webgl2_test_uniformMatrix3x2fv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1187 async function (done) { 1188 console.info("webgl2test [webgl2_test_uniformMatrix3x2fv] uniformMatrix3x2fv"); 1189 let p = createProgram(gl, `#version 300 es 1190 in vec3 a_position; 1191 uniform mat3x2 m32; 1192 void main(){ 1193 vec2 transformedPosition = (m32 * a_position).xy; 1194 gl_Position = vec4(transformedPosition, 0.0, 1.0); 1195 } 1196 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1197 gl.useProgram(p.program); 1198 let m32 = gl.getUniformLocation(p.program, "m32"); 1199 gl.uniformMatrix3x2fv(m32, false, new Float32Array([ 1200 1.5, 1.5, 1201 1.0, 0.0, 1202 0.0, 1.0, 1203 0.0, 0.0 1204 ]), 2, 6); 1205 let uniform = gl.getUniform(p.program, m32); 1206 console.info("webgltest", uniform); 1207 expect(uniform[0]).assertEqual(1.0); 1208 expect(uniform[1]).assertEqual(0.0); 1209 expect(uniform[2]).assertEqual(0.0); 1210 expect(uniform[3]).assertEqual(1.0); 1211 expect(uniform[4]).assertEqual(0.0); 1212 expect(uniform[5]).assertEqual(0.0); 1213 clear(gl); 1214 gl.drawArrays(gl.POINTS, 0, 1); 1215 gl.deleteShader(p.vertexShader); 1216 gl.deleteShader(p.fragmentShader); 1217 gl.deleteProgram(p.program); 1218 checkError(gl); 1219 done(); 1220 }); 1221 /** 1222 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0059 1223 * @tc.name webgl2_test_uniformMatrix3x2fv_1 1224 * @tc.desc Test uniformMatrix3x2fv. 1225 */ 1226 it('webgl2_test_uniformMatrix3x2fv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1227 async function (done) { 1228 console.info("webgl2test [webgl2_test_uniformMatrix3x2fv_1] uniformMatrix3x2fv"); 1229 uniformMatrix3x2fv((m32) => { 1230 gl.uniformMatrix3x2fv(m32, null, new Float32Array([ 1231 1.5, 1.5, 1232 1.0, 0.0, 1233 0.0, 1.0, 1234 0.0, 0.0 1235 ]), 2, 6); 1236 }, () => { 1237 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1238 }); 1239 done(); 1240 }); 1241 /** 1242 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0060 1243 * @tc.name webgl2_test_uniformMatrix3x2fv_2 1244 * @tc.desc Test uniformMatrix3x2fv. 1245 */ 1246 it('webgl2_test_uniformMatrix3x2fv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1247 async function (done) { 1248 console.info("webgl2test [webgl2_test_uniformMatrix3x2fv_2] uniformMatrix3x2fv"); 1249 uniformMatrix3x2fv((m32) => { 1250 gl.uniformMatrix3x2fv(m32, null, new Float32Array([ 1251 1.5, 1.5, 1252 1.0, 0.0, 1253 0.0, 1.0, 1254 0.0, 0.0 1255 ]), null, 6); 1256 }, () => { 1257 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1258 }); 1259 done(); 1260 }); 1261 /** 1262 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0061 1263 * @tc.name webgl2_test_uniformMatrix3x2fv_3 1264 * @tc.desc Test uniformMatrix3x2fv. 1265 */ 1266 it('webgl2_test_uniformMatrix3x2fv_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1267 async function (done) { 1268 console.info("webgl2test [webgl2_test_uniformMatrix3x2fv_3] uniformMatrix3x2fv"); 1269 uniformMatrix3x2fv((m32) => { 1270 gl.uniformMatrix3x2fv(m32, null, new Float32Array([ 1271 1.5, 1.5, 1272 1.0, 0.0, 1273 0.0, 1.0, 1274 0.0, 0.0 1275 ]), null, null); 1276 }, () => { 1277 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1278 }); 1279 done(); 1280 }); 1281 /** 1282 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0062 1283 * @tc.name webgl2_test_uniformMatrix3x2fv_4 1284 * @tc.desc Test uniformMatrix3x2fv. 1285 */ 1286 it('webgl2_test_uniformMatrix3x2fv_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1287 async function (done) { 1288 console.info("webgl2test [webgl2_test_uniformMatrix3x2fv_4] uniformMatrix3x2fv"); 1289 uniformMatrix3x2fv((m32) => { 1290 gl.uniformMatrix3x2fv(m32, null, new Float32Array([ 1291 1.5, 1.5, 1292 1.0, 0.0, 1293 0.0, 1.0, 1294 0.0, 0.0 1295 ]), undefined, undefined); 1296 }, () => { 1297 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1298 }); 1299 done(); 1300 }); 1301 /** 1302 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0063 1303 * @tc.name webgl2_test_uniformMatrix3x2fv_5 1304 * @tc.desc Test uniformMatrix3x2fv. 1305 */ 1306 it('webgl2_test_uniformMatrix3x2fv_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1307 async function (done) { 1308 console.info("webgl2test [webgl2_test_uniformMatrix3x2fv_5] uniformMatrix3x2fv"); 1309 uniformMatrix3x2fv((m32) => { 1310 gl.uniformMatrix3x2fv(null, null, new Float32Array([ 1311 1.5, 1.5, 1312 1.0, 0.0, 1313 0.0, 1.0, 1314 0.0, 0.0 1315 ]), undefined, undefined); 1316 }, () => { 1317 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1318 }); 1319 done(); 1320 }); 1321 function uniformMatrix4x2fv(callback, finish) { 1322 let p = createProgram(gl, `#version 300 es 1323 in vec4 a_position; 1324 uniform mat4x2 m42; 1325 void main(){ 1326 vec2 transformedPosition = (m42 * a_position).xy; 1327 gl_Position = vec4(transformedPosition, 0.0, 1.0); 1328 } 1329 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1330 gl.useProgram(p.program); 1331 let m42 = gl.getUniformLocation(p.program, "m42"); 1332 callback(m42); 1333 let uniform = gl.getUniform(p.program, m42); 1334 clear(gl); 1335 gl.drawArrays(gl.POINTS, 0, 1); 1336 gl.deleteShader(p.vertexShader); 1337 gl.deleteShader(p.fragmentShader); 1338 gl.deleteProgram(p.program); 1339 finish(); 1340 } 1341 /** 1342 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0064 1343 * @tc.name webgl2_test_uniformMatrix4x2fv 1344 * @tc.desc Test uniformMatrix4x2fv. 1345 */ 1346 it('webgl2_test_uniformMatrix4x2fv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1347 async function (done) { 1348 console.info("webgl2test [webgl2_test_uniformMatrix4x2fv] uniformMatrix4x2fv"); 1349 let p = createProgram(gl, `#version 300 es 1350 in vec4 a_position; 1351 uniform mat4x2 m42; 1352 void main(){ 1353 vec2 transformedPosition = (m42 * a_position).xy; 1354 gl_Position = vec4(transformedPosition, 0.0, 1.0); 1355 } 1356 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1357 gl.useProgram(p.program); 1358 let m42 = gl.getUniformLocation(p.program, "m42"); 1359 gl.uniformMatrix4x2fv(m42, false, new Float32Array([ 1360 1.5, 1.5, 1361 1.0, 0.0, 1362 0.0, 1.0, 1363 0.0, 0.0, 1364 0.0, 0.0, 1365 ]), 2, 8); 1366 let uniform = gl.getUniform(p.program, m42); 1367 console.info("webgltest", uniform); 1368 expect(uniform[0]).assertEqual(1.0); 1369 expect(uniform[1]).assertEqual(0.0); 1370 expect(uniform[2]).assertEqual(0.0); 1371 expect(uniform[3]).assertEqual(1.0); 1372 expect(uniform[4]).assertEqual(0.0); 1373 expect(uniform[5]).assertEqual(0.0); 1374 expect(uniform[6]).assertEqual(0.0); 1375 expect(uniform[7]).assertEqual(0.0); 1376 clear(gl); 1377 gl.drawArrays(gl.POINTS, 0, 1); 1378 gl.deleteShader(p.vertexShader); 1379 gl.deleteShader(p.fragmentShader); 1380 gl.deleteProgram(p.program); 1381 checkError(gl); 1382 done(); 1383 }); 1384 /** 1385 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0065 1386 * @tc.name webgl2_test_uniformMatrix4x2fv_1 1387 * @tc.desc Test uniformMatrix4x2fv. 1388 */ 1389 it('webgl2_test_uniformMatrix4x2fv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1390 async function (done) { 1391 console.info("webgl2test [webgl2_test_uniformMatrix4x2fv_1] uniformMatrix4x2fv"); 1392 uniformMatrix4x2fv((m42) => { 1393 gl.uniformMatrix4x2fv(m42, null, new Float32Array([ 1394 1.5, 1.5, 1395 1.0, 0.0, 1396 0.0, 1.0, 1397 0.0, 0.0, 1398 0.0, 0.0, 1399 ]), 2, 6); 1400 }, () => { 1401 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1402 }); 1403 done(); 1404 }); 1405 /** 1406 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0066 1407 * @tc.name webgl2_test_uniformMatrix4x2fv_2 1408 * @tc.desc Test uniformMatrix4x2fv. 1409 */ 1410 it('webgl2_test_uniformMatrix4x2fv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1411 async function (done) { 1412 console.info("webgl2test [webgl2_test_uniformMatrix4x2fv_2] uniformMatrix4x2fv"); 1413 uniformMatrix4x2fv((m42) => { 1414 gl.uniformMatrix4x2fv(m42, null, new Float32Array([ 1415 1.5, 1.5, 1416 1.0, 0.0, 1417 0.0, 1.0, 1418 0.0, 0.0, 1419 0.0, 0.0, 1420 ]), null, 6); 1421 }, () => { 1422 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1423 }); 1424 done(); 1425 }); 1426 /** 1427 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0067 1428 * @tc.name webgl2_test_uniformMatrix4x2fv_3 1429 * @tc.desc Test uniformMatrix4x2fv. 1430 */ 1431 it('webgl2_test_uniformMatrix4x2fv_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1432 async function (done) { 1433 console.info("webgl2test [webgl2_test_uniformMatrix4x2fv_3] uniformMatrix4x2fv"); 1434 uniformMatrix4x2fv((m42) => { 1435 gl.uniformMatrix4x2fv(m42, null, new Float32Array([ 1436 1.5, 1.5, 1437 1.0, 0.0, 1438 0.0, 1.0, 1439 0.0, 0.0, 1440 0.0, 0.0, 1441 ]), null, null); 1442 }, () => { 1443 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1444 }); 1445 done(); 1446 }); 1447 /** 1448 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0068 1449 * @tc.name webgl2_test_uniformMatrix4x2fv_4 1450 * @tc.desc Test uniformMatrix4x2fv. 1451 */ 1452 it('webgl2_test_uniformMatrix4x2fv_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1453 async function (done) { 1454 console.info("webgl2test [webgl2_test_uniformMatrix4x2fv_4] uniformMatrix4x2fv"); 1455 uniformMatrix4x2fv((m42) => { 1456 gl.uniformMatrix4x2fv(m42, null, new Float32Array([ 1457 1.5, 1.5, 1458 1.0, 0.0, 1459 0.0, 1.0, 1460 0.0, 0.0, 1461 0.0, 0.0, 1462 ]), undefined, undefined); 1463 }, () => { 1464 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1465 }); 1466 done(); 1467 }); 1468 function uniformMatrix2x3fv(callback, finish) { 1469 let p = createProgram(gl, `#version 300 es 1470 in vec2 a_position; 1471 uniform mat2x3 m23; 1472 void main(){ 1473 vec3 transformedPosition = (m23 * a_position).xyz; 1474 gl_Position = vec4(transformedPosition, 1.0); 1475 } 1476 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1477 gl.useProgram(p.program); 1478 let m23 = gl.getUniformLocation(p.program, "m23"); 1479 callback(m23); 1480 let uniform = gl.getUniform(p.program, m23); 1481 clear(gl); 1482 gl.drawArrays(gl.POINTS, 0, 1); 1483 gl.deleteShader(p.vertexShader); 1484 gl.deleteShader(p.fragmentShader); 1485 gl.deleteProgram(p.program); 1486 finish(); 1487 } 1488 /** 1489 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0069 1490 * @tc.name webgl2_test_uniformMatrix2x3fv 1491 * @tc.desc Test uniformMatrix2x3fv. 1492 */ 1493 it('webgl2_test_uniformMatrix2x3fv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1494 async function (done) { 1495 console.info("webgl2test [webgl2_test_uniformMatrix2x3fv] uniformMatrix2x3fv"); 1496 let p = createProgram(gl, `#version 300 es 1497 in vec2 a_position; 1498 uniform mat2x3 m23; 1499 void main(){ 1500 vec3 transformedPosition = (m23 * a_position).xyz; 1501 gl_Position = vec4(transformedPosition, 1.0); 1502 } 1503 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1504 gl.useProgram(p.program); 1505 let m23 = gl.getUniformLocation(p.program, "m23"); 1506 gl.uniformMatrix2x3fv(m23, false, new Float32Array([ 1507 1.5, 1.5, 1.5, 1508 1.0, 0.0, 0.0, 1509 1.0, 0.0, 1.0, 1510 ]), 3, 6); 1511 let uniform = gl.getUniform(p.program, m23); 1512 console.info("webgltest", uniform); 1513 expect(uniform[0]).assertEqual(1.0); 1514 expect(uniform[1]).assertEqual(0.0); 1515 expect(uniform[2]).assertEqual(0.0); 1516 expect(uniform[3]).assertEqual(1.0); 1517 expect(uniform[4]).assertEqual(0.0); 1518 expect(uniform[5]).assertEqual(1.0); 1519 clear(gl); 1520 gl.drawArrays(gl.POINTS, 0, 1); 1521 gl.deleteShader(p.vertexShader); 1522 gl.deleteShader(p.fragmentShader); 1523 gl.deleteProgram(p.program); 1524 checkError(gl); 1525 done(); 1526 }); 1527 /** 1528 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0070 1529 * @tc.name webgl2_test_uniformMatrix2x3fv_1 1530 * @tc.desc Test uniformMatrix2x3fv. 1531 */ 1532 it('webgl2_test_uniformMatrix2x3fv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1533 async function (done) { 1534 console.info("webgl2test [webgl2_test_uniformMatrix2x3fv_1] uniformMatrix2x3fv"); 1535 uniformMatrix2x3fv((m23) => { 1536 gl.uniformMatrix2x3fv(m23, null, new Float32Array([ 1537 1.5, 1.5, 1.5, 1538 1.0, 0.0, 0.0, 1539 1.0, 0.0, 1.0, 1540 ]), 3, 6); 1541 }, () => { 1542 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1543 }); 1544 done(); 1545 }); 1546 /** 1547 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0071 1548 * @tc.name webgl2_test_uniformMatrix2x3fv_2 1549 * @tc.desc Test uniformMatrix2x3fv. 1550 */ 1551 it('webgl2_test_uniformMatrix2x3fv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1552 async function (done) { 1553 console.info("webgl2test [webgl2_test_uniformMatrix2x3fv_2] uniformMatrix2x3fv"); 1554 uniformMatrix2x3fv((m23) => { 1555 gl.uniformMatrix2x3fv(m23, null, new Float32Array([ 1556 1.5, 1.5, 1.5, 1557 1.0, 0.0, 0.0, 1558 1.0, 0.0, 1.0, 1559 ]), null, 6); 1560 }, () => { 1561 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1562 }); 1563 done(); 1564 }); 1565 /** 1566 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0072 1567 * @tc.name webgl2_test_uniformMatrix2x3fv_3 1568 * @tc.desc Test uniformMatrix2x3fv. 1569 */ 1570 it('webgl2_test_uniformMatrix2x3fv_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1571 async function (done) { 1572 console.info("webgl2test [webgl2_test_uniformMatrix2x3fv_3] uniformMatrix2x3fv"); 1573 uniformMatrix2x3fv((m23) => { 1574 gl.uniformMatrix2x3fv(m23, null, new Float32Array([ 1575 1.5, 1.5, 1.5, 1576 1.0, 0.0, 0.0, 1577 1.0, 0.0, 1.0, 1578 ]), null, null); 1579 }, () => { 1580 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1581 }); 1582 done(); 1583 }); 1584 /** 1585 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0073 1586 * @tc.name webgl2_test_uniformMatrix2x3fv_4 1587 * @tc.desc Test uniformMatrix2x3fv. 1588 */ 1589 it('webgl2_test_uniformMatrix2x3fv_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1590 async function (done) { 1591 console.info("webgl2test [webgl2_test_uniformMatrix2x3fv_4] uniformMatrix2x3fv"); 1592 uniformMatrix2x3fv((m23) => { 1593 gl.uniformMatrix2x3fv(m23, null, new Float32Array([ 1594 1.5, 1.5, 1.5, 1595 1.0, 0.0, 0.0, 1596 1.0, 0.0, 1.0, 1597 ]), undefined, undefined); 1598 }, () => { 1599 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1600 }); 1601 done(); 1602 }); 1603 function uniformMatrix4x3fv(callback, finish) { 1604 let p = createProgram(gl, `#version 300 es 1605 in vec4 a_position; 1606 uniform mat4x3 m43; 1607 void main(){ 1608 vec3 transformedPosition = (m43 * a_position).xyz; 1609 gl_Position = vec4(transformedPosition, 1.0); 1610 } 1611 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1612 gl.useProgram(p.program); 1613 let m43 = gl.getUniformLocation(p.program, "m43"); 1614 callback(m43); 1615 let uniform = gl.getUniform(p.program, m43); 1616 clear(gl); 1617 gl.drawArrays(gl.POINTS, 0, 1); 1618 gl.deleteShader(p.vertexShader); 1619 gl.deleteShader(p.fragmentShader); 1620 gl.deleteProgram(p.program); 1621 finish(); 1622 } 1623 /** 1624 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0074 1625 * @tc.name webgl2_test_uniformMatrix4x3fv 1626 * @tc.desc Test uniformMatrix4x3fv. 1627 */ 1628 it('webgl2_test_uniformMatrix4x3fv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1629 async function (done) { 1630 console.info("webgl2test [webgl2_test_uniformMatrix4x3fv] uniformMatrix4x3fv"); 1631 let p = createProgram(gl, `#version 300 es 1632 in vec4 a_position; 1633 uniform mat4x3 m43; 1634 void main(){ 1635 vec3 transformedPosition = (m43 * a_position).xyz; 1636 gl_Position = vec4(transformedPosition, 1.0); 1637 } 1638 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1639 gl.useProgram(p.program); 1640 let m43 = gl.getUniformLocation(p.program, "m43"); 1641 gl.uniformMatrix4x3fv(m43, false, new Float32Array([ 1642 1.5, 1.5, 1.5, 1643 1.0, 0.0, 0.0, 1644 1.0, 0.0, 1.0, 1645 1.0, 0.0, 1.0, 1646 1.0, 0.0, 1.0, 1647 ]), 3, 12); 1648 let uniform = gl.getUniform(p.program, m43); 1649 console.info("webgltest", uniform); 1650 expect(uniform[0]).assertEqual(1.0); 1651 expect(uniform[1]).assertEqual(0.0); 1652 expect(uniform[2]).assertEqual(0.0); 1653 expect(uniform[3]).assertEqual(1.0); 1654 expect(uniform[4]).assertEqual(0.0); 1655 expect(uniform[5]).assertEqual(1.0); 1656 expect(uniform[6]).assertEqual(1.0); 1657 expect(uniform[7]).assertEqual(0.0); 1658 expect(uniform[8]).assertEqual(1.0); 1659 expect(uniform[9]).assertEqual(1.0); 1660 expect(uniform[10]).assertEqual(0.0); 1661 expect(uniform[11]).assertEqual(1.0); 1662 clear(gl); 1663 gl.drawArrays(gl.POINTS, 0, 1); 1664 gl.deleteShader(p.vertexShader); 1665 gl.deleteShader(p.fragmentShader); 1666 gl.deleteProgram(p.program); 1667 checkError(gl); 1668 done(); 1669 }); 1670 /** 1671 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0075 1672 * @tc.name webgl2_test_uniformMatrix4x3fv_1 1673 * @tc.desc Test uniformMatrix4x3fv. 1674 */ 1675 it('webgl2_test_uniformMatrix4x3fv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1676 async function (done) { 1677 console.info("webgl2test [webgl2_test_uniformMatrix4x3fv_1] uniformMatrix4x3fv"); 1678 uniformMatrix4x3fv((m) => { 1679 gl.uniformMatrix4x3fv(m, null, new Float32Array([ 1680 1.5, 1.5, 1.5, 1681 1.0, 0.0, 0.0, 1682 1.0, 0.0, 1.0, 1683 1.0, 0.0, 1.0, 1684 1.0, 0.0, 1.0, 1685 ]), 3, 6); 1686 }, () => { 1687 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1688 }); 1689 done(); 1690 }); 1691 /** 1692 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0076 1693 * @tc.name webgl2_test_uniformMatrix4x3fv_2 1694 * @tc.desc Test uniformMatrix4x3fv. 1695 */ 1696 it('webgl2_test_uniformMatrix4x3fv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1697 async function (done) { 1698 console.info("webgl2test [webgl2_test_uniformMatrix4x3fv_2] uniformMatrix4x3fv"); 1699 uniformMatrix4x3fv((m) => { 1700 gl.uniformMatrix4x3fv(m, null, new Float32Array([ 1701 1.5, 1.5, 1.5, 1702 1.0, 0.0, 0.0, 1703 1.0, 0.0, 1.0, 1704 1.0, 0.0, 1.0, 1705 1.0, 0.0, 1.0, 1706 ]), null, 6); 1707 }, () => { 1708 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1709 }); 1710 done(); 1711 }); 1712 /** 1713 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0077 1714 * @tc.name webgl2_test_uniformMatrix4x3fv_3 1715 * @tc.desc Test uniformMatrix4x3fv. 1716 */ 1717 it('webgl2_test_uniformMatrix4x3fv_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1718 async function (done) { 1719 console.info("webgl2test [webgl2_test_uniformMatrix4x3fv_3] uniformMatrix4x3fv"); 1720 uniformMatrix4x3fv((m) => { 1721 gl.uniformMatrix4x3fv(m, null, new Float32Array([ 1722 1.5, 1.5, 1.5, 1723 1.0, 0.0, 0.0, 1724 1.0, 0.0, 1.0, 1725 1.0, 0.0, 1.0, 1726 1.0, 0.0, 1.0, 1727 ]), null, null); 1728 }, () => { 1729 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1730 }); 1731 done(); 1732 }); 1733 /** 1734 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0078 1735 * @tc.name webgl2_test_uniformMatrix4x3fv_4 1736 * @tc.desc Test uniformMatrix4x3fv. 1737 */ 1738 it('webgl2_test_uniformMatrix4x3fv_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1739 async function (done) { 1740 console.info("webgl2test [webgl2_test_uniformMatrix4x3fv_4] uniformMatrix4x3fv"); 1741 uniformMatrix4x3fv((m) => { 1742 gl.uniformMatrix4x3fv(m, null, new Float32Array([ 1743 1.5, 1.5, 1.5, 1744 1.0, 0.0, 0.0, 1745 1.0, 0.0, 1.0, 1746 1.0, 0.0, 1.0, 1747 1.0, 0.0, 1.0, 1748 ]), undefined, undefined); 1749 }, () => { 1750 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1751 }); 1752 done(); 1753 }); 1754 function uniformMatrix2x4fv(callback, finish) { 1755 let p = createProgram(gl, `#version 300 es 1756 in vec2 a_position; 1757 uniform mat2x4 m24; 1758 void main(){ 1759 vec3 transformedPosition = (m24 * a_position).xyz; 1760 gl_Position = vec4(transformedPosition, 1.0); 1761 } 1762 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1763 gl.useProgram(p.program); 1764 let m24 = gl.getUniformLocation(p.program, "m24"); 1765 callback(m24); 1766 let uniform = gl.getUniform(p.program, m24); 1767 clear(gl); 1768 gl.drawArrays(gl.POINTS, 0, 1); 1769 gl.deleteShader(p.vertexShader); 1770 gl.deleteShader(p.fragmentShader); 1771 gl.deleteProgram(p.program); 1772 finish(); 1773 } 1774 /** 1775 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0079 1776 * @tc.name webgl2_test_uniformMatrix2x4fv 1777 * @tc.desc Test uniformMatrix2x4fv. 1778 */ 1779 it('webgl2_test_uniformMatrix2x4fv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1780 async function (done) { 1781 console.info("webgl2test [webgl2_test_uniformMatrix2x4fv] uniformMatrix2x4fv"); 1782 let p = createProgram(gl, `#version 300 es 1783 in vec2 a_position; 1784 uniform mat2x4 m24; 1785 void main(){ 1786 vec3 transformedPosition = (m24 * a_position).xyz; 1787 gl_Position = vec4(transformedPosition, 1.0); 1788 } 1789 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1790 gl.useProgram(p.program); 1791 let m24 = gl.getUniformLocation(p.program, "m24"); 1792 gl.uniformMatrix2x4fv(m24, false, new Float32Array([ 1793 1.5, 1.5, 1.5, 1.5, 1794 1.0, 0.0, 0.0, 1.0, 1795 1.0, 0.0, 0.0, 1.0, 1796 ]), 4, 8); 1797 let uniform = gl.getUniform(p.program, m24); 1798 console.info("webgltest", uniform); 1799 expect(uniform[0]).assertEqual(1.0); 1800 expect(uniform[1]).assertEqual(0.0); 1801 expect(uniform[2]).assertEqual(0.0); 1802 expect(uniform[3]).assertEqual(1.0); 1803 expect(uniform[4]).assertEqual(1.0); 1804 expect(uniform[5]).assertEqual(0.0); 1805 expect(uniform[6]).assertEqual(0.0); 1806 expect(uniform[7]).assertEqual(1.0); 1807 clear(gl); 1808 gl.drawArrays(gl.POINTS, 0, 1); 1809 gl.deleteShader(p.vertexShader); 1810 gl.deleteShader(p.fragmentShader); 1811 gl.deleteProgram(p.program); 1812 checkError(gl); 1813 done(); 1814 }); 1815 /** 1816 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0080 1817 * @tc.name webgl2_test_uniformMatrix2x4fv_1 1818 * @tc.desc Test uniformMatrix2x4fv. 1819 */ 1820 it('webgl2_test_uniformMatrix2x4fv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1821 async function (done) { 1822 console.info("webgl2test [webgl2_test_uniformMatrix2x4fv_1] uniformMatrix2x4fv"); 1823 uniformMatrix2x4fv((m) => { 1824 gl.uniformMatrix2x4fv(m, null, new Float32Array([ 1825 1.5, 1.5, 1.5, 1.5, 1826 1.0, 0.0, 0.0, 1.0, 1827 1.0, 0.0, 0.0, 1.0, 1828 ]), 3, 6); 1829 }, () => { 1830 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1831 }); 1832 done(); 1833 }); 1834 /** 1835 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0081 1836 * @tc.name webgl2_test_uniformMatrix2x4fv_2 1837 * @tc.desc Test uniformMatrix2x4fv. 1838 */ 1839 it('webgl2_test_uniformMatrix2x4fv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1840 async function (done) { 1841 console.info("webgl2test [webgl2_test_uniformMatrix2x4fv_2] uniformMatrix2x4fv"); 1842 uniformMatrix2x4fv((m) => { 1843 gl.uniformMatrix2x4fv(m, null, new Float32Array([ 1844 1.5, 1.5, 1.5, 1.5, 1845 1.0, 0.0, 0.0, 1.0, 1846 1.0, 0.0, 0.0, 1.0, 1847 ]), null, 6); 1848 }, () => { 1849 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1850 }); 1851 done(); 1852 }); 1853 /** 1854 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0082 1855 * @tc.name webgl2_test_uniformMatrix2x4fv_3 1856 * @tc.desc Test uniformMatrix2x4fv. 1857 */ 1858 it('webgl2_test_uniformMatrix2x4fv_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1859 async function (done) { 1860 console.info("webgl2test [webgl2_test_uniformMatrix2x4fv_3] uniformMatrix2x4fv"); 1861 uniformMatrix2x4fv((m) => { 1862 gl.uniformMatrix2x4fv(m, null, new Float32Array([ 1863 1.5, 1.5, 1.5, 1.5, 1864 1.0, 0.0, 0.0, 1.0, 1865 1.0, 0.0, 0.0, 1.0, 1866 ]), null, null); 1867 }, () => { 1868 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1869 }); 1870 done(); 1871 }); 1872 /** 1873 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0083 1874 * @tc.name webgl2_test_uniformMatrix2x4fv_4 1875 * @tc.desc Test uniformMatrix2x4fv. 1876 */ 1877 it('webgl2_test_uniformMatrix2x4fv_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1878 async function (done) { 1879 console.info("webgl2test [webgl2_test_uniformMatrix2x4fv_4] uniformMatrix2x4fv"); 1880 uniformMatrix2x4fv((m) => { 1881 gl.uniformMatrix2x4fv(m, null, new Float32Array([ 1882 1.5, 1.5, 1.5, 1.5, 1883 1.0, 0.0, 0.0, 1.0, 1884 1.0, 0.0, 0.0, 1.0, 1885 ]), undefined, undefined); 1886 }, () => { 1887 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1888 }); 1889 done(); 1890 }); 1891 function uniformMatrix3x4fv(callback, finish) { 1892 let p = createProgram(gl, `#version 300 es 1893 in vec3 a_position; 1894 uniform mat3x4 m34; 1895 void main(){ 1896 vec3 transformedPosition = (m34 * a_position).xyz; 1897 gl_Position = vec4(transformedPosition, 1.0); 1898 } 1899 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1900 gl.useProgram(p.program); 1901 let m34 = gl.getUniformLocation(p.program, "m34"); 1902 callback(m34); 1903 let uniform = gl.getUniform(p.program, m34); 1904 clear(gl); 1905 gl.drawArrays(gl.POINTS, 0, 1); 1906 gl.deleteShader(p.vertexShader); 1907 gl.deleteShader(p.fragmentShader); 1908 gl.deleteProgram(p.program); 1909 finish(); 1910 } 1911 /** 1912 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0084 1913 * @tc.name webgl2_test_uniformMatrix3x4fv 1914 * @tc.desc Test uniformMatrix3x4fv. 1915 */ 1916 it('webgl2_test_uniformMatrix3x4fv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1917 async function (done) { 1918 console.info("webgl2test [webgl2_test_uniformMatrix3x4fv] uniformMatrix3x4fv"); 1919 let p = createProgram(gl, `#version 300 es 1920 in vec3 a_position; 1921 uniform mat3x4 m34; 1922 void main(){ 1923 vec3 transformedPosition = (m34 * a_position).xyz; 1924 gl_Position = vec4(transformedPosition, 1.0); 1925 } 1926 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1927 gl.useProgram(p.program); 1928 let m34 = gl.getUniformLocation(p.program, "m34"); 1929 gl.uniformMatrix3x4fv(m34, false, new Float32Array([ 1930 1.5, 1.5, 1.5, 1.5, 1931 1.0, 0.0, 0.0, 1.0, 1932 1.0, 0.0, 0.0, 1.0, 1933 1.0, 0.0, 0.0, 1.0, 1934 ]), 4, 12); 1935 let uniform = gl.getUniform(p.program, m34); 1936 console.info("webgltest", uniform); 1937 expect(uniform[0]).assertEqual(1.0); 1938 expect(uniform[1]).assertEqual(0.0); 1939 expect(uniform[2]).assertEqual(0.0); 1940 expect(uniform[3]).assertEqual(1.0); 1941 expect(uniform[4]).assertEqual(1.0); 1942 expect(uniform[5]).assertEqual(0.0); 1943 expect(uniform[6]).assertEqual(0.0); 1944 expect(uniform[7]).assertEqual(1.0); 1945 clear(gl); 1946 gl.drawArrays(gl.POINTS, 0, 1); 1947 gl.deleteShader(p.vertexShader); 1948 gl.deleteShader(p.fragmentShader); 1949 gl.deleteProgram(p.program); 1950 checkError(gl); 1951 done(); 1952 }); 1953 /** 1954 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0085 1955 * @tc.name webgl2_test_uniformMatrix3x4fv_1 1956 * @tc.desc Test uniformMatrix3x4fv. 1957 */ 1958 it('webgl2_test_uniformMatrix3x4fv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1959 async function (done) { 1960 console.info("webgl2test [webgl2_test_uniformMatrix3x4fv_1] uniformMatrix3x4fv"); 1961 uniformMatrix3x4fv((m) => { 1962 gl.uniformMatrix3x4fv(m, null, new Float32Array([ 1963 1.5, 1.5, 1.5, 1.5, 1964 1.0, 0.0, 0.0, 1.0, 1965 1.0, 0.0, 0.0, 1.0, 1966 1.0, 0.0, 0.0, 1.0, 1967 ]), 3, 6); 1968 }, () => { 1969 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1970 }); 1971 done(); 1972 }); 1973 /** 1974 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0086 1975 * @tc.name webgl2_test_uniformMatrix3x4fv_2 1976 * @tc.desc Test uniformMatrix3x4fv. 1977 */ 1978 it('webgl2_test_uniformMatrix3x4fv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1979 async function (done) { 1980 console.info("webgl2test [webgl2_test_uniformMatrix3x4fv_2] uniformMatrix3x4fv"); 1981 uniformMatrix3x4fv((m) => { 1982 gl.uniformMatrix3x4fv(m, null, new Float32Array([ 1983 1.5, 1.5, 1.5, 1.5, 1984 1.0, 0.0, 0.0, 1.0, 1985 1.0, 0.0, 0.0, 1.0, 1986 1.0, 0.0, 0.0, 1.0, 1987 ]), null, 6); 1988 }, () => { 1989 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1990 }); 1991 done(); 1992 }); 1993 /** 1994 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0087 1995 * @tc.name webgl2_test_uniformMatrix3x4fv_3 1996 * @tc.desc Test uniformMatrix3x4fv. 1997 */ 1998 it('webgl2_test_uniformMatrix3x4fv_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 1999 async function (done) { 2000 console.info("webgl2test [webgl2_test_uniformMatrix3x4fv_3] uniformMatrix3x4fv"); 2001 uniformMatrix3x4fv((m) => { 2002 gl.uniformMatrix3x4fv(m, null, new Float32Array([ 2003 1.5, 1.5, 1.5, 1.5, 2004 1.0, 0.0, 0.0, 1.0, 2005 1.0, 0.0, 0.0, 1.0, 2006 1.0, 0.0, 0.0, 1.0, 2007 ]), null, null); 2008 }, () => { 2009 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2010 }); 2011 done(); 2012 }); 2013 /** 2014 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0088 2015 * @tc.name webgl2_test_uniformMatrix3x4fv_4 2016 * @tc.desc Test uniformMatrix3x4fv. 2017 */ 2018 it('webgl2_test_uniformMatrix3x4fv_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 2019 async function (done) { 2020 console.info("webgl2test [webgl2_test_uniformMatrix3x4fv_4] uniformMatrix3x4fv"); 2021 uniformMatrix3x4fv((m) => { 2022 gl.uniformMatrix3x4fv(m, null, new Float32Array([ 2023 1.5, 1.5, 1.5, 1.5, 2024 1.0, 0.0, 0.0, 1.0, 2025 1.0, 0.0, 0.0, 1.0, 2026 1.0, 0.0, 0.0, 1.0, 2027 ]), undefined, undefined); 2028 }, () => { 2029 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2030 }); 2031 done(); 2032 }); 2033 function uniform1fv(callback, finish) { 2034 let p = createProgram(gl, `#version 300 es 2035 uniform float u; 2036 void main(){ 2037 gl_Position.x = float(u); 2038 gl_Position.w = 1.0; 2039 gl_PointSize = 100.0; 2040 } 2041 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2042 gl.useProgram(p.program); 2043 let u = gl.getUniformLocation(p.program, "u"); 2044 callback(u); 2045 let uniform = gl.getUniform(p.program, u); 2046 clear(gl); 2047 gl.drawArrays(gl.POINTS, 0, 1); 2048 gl.deleteShader(p.vertexShader); 2049 gl.deleteShader(p.fragmentShader); 2050 gl.deleteProgram(p.program); 2051 finish(); 2052 } 2053 /** 2054 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0089 2055 * @tc.name webgl2_test_uniform1fv 2056 * @tc.desc Test uniform1fv. 2057 */ 2058 it('webgl2_test_uniform1fv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2059 console.info("webgl2test [webgl2_test_uniform1fv] uniform1fv"); 2060 let p = createProgram(gl, `#version 300 es 2061 uniform float u; 2062 void main(){ 2063 gl_Position.x = float(u); 2064 gl_Position.w = 1.0; 2065 gl_PointSize = 100.0; 2066 } 2067 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2068 gl.useProgram(p.program); 2069 let u = gl.getUniformLocation(p.program, "u"); 2070 gl.uniform1fv(u, new Float32Array([1.0, 0.0, 1.0]), 1, 1); 2071 let uniform = gl.getUniform(p.program, u); 2072 console.info("webgltest", uniform); 2073 expect(uniform).assertEqual(0.0); 2074 clear(gl); 2075 gl.drawArrays(gl.POINTS, 0, 1); 2076 gl.deleteShader(p.vertexShader); 2077 gl.deleteShader(p.fragmentShader); 2078 gl.deleteProgram(p.program); 2079 checkError(gl); 2080 done(); 2081 }); 2082 /** 2083 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0090 2084 * @tc.name webgl2_test_uniform1fv_1 2085 * @tc.desc Test uniform1fv. 2086 */ 2087 it('webgl2_test_uniform1fv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2088 console.info("webgl2test [webgl2_test_uniform1fv_1] uniform1fv"); 2089 uniform1fv((u) => { 2090 gl.uniform1fv(u, new Float32Array([1.0, 0.0, 1.0]), 1, null); 2091 }, () => { 2092 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2093 }); 2094 done(); 2095 }); 2096 /** 2097 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0091 2098 * @tc.name webgl2_test_uniform1fv_2 2099 * @tc.desc Test uniform1fv. 2100 */ 2101 it('webgl2_test_uniform1fv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2102 console.info("webgl2test [webgl2_test_uniform1fv_2] uniform1fv"); 2103 uniform1fv((u) => { 2104 gl.uniform1fv(u, new Float32Array([1.0, 0.0, 1.0]), 1, undefined); 2105 }, () => { 2106 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2107 }); 2108 done(); 2109 }); 2110 /** 2111 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0092 2112 * @tc.name webgl2_test_uniform1fv_3 2113 * @tc.desc Test uniform1fv. 2114 */ 2115 it('webgl2_test_uniform1fv_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2116 console.info("webgl2test [webgl2_test_uniform1fv_3] uniform1fv"); 2117 uniform1fv((u) => { 2118 gl.uniform1fv(u, new Float32Array([1.0, 0.0, 1.0]), null, undefined); 2119 }, () => { 2120 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2121 }); 2122 done(); 2123 }); 2124 /** 2125 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0093 2126 * @tc.name webgl2_test_uniform1fv_4 2127 * @tc.desc Test uniform1fv. 2128 */ 2129 it('webgl2_test_uniform1fv_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2130 console.info("webgl2test [webgl2_test_uniform1fv_4] uniform1fv"); 2131 uniform1fv((u) => { 2132 gl.uniform1fv(u, new Float32Array([1.0, 0.0, 1.0]), null, undefined); 2133 }, () => { 2134 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2135 }); 2136 done(); 2137 }); 2138 /** 2139 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0094 2140 * @tc.name webgl2_test_uniform1fv_5 2141 * @tc.desc Test uniform1fv. 2142 */ 2143 it('webgl2_test_uniform1fv_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2144 console.info("webgl2test [webgl2_test_uniform1fv_5] uniform1fv"); 2145 uniform1fv((u) => { 2146 gl.uniform1fv(null, new Float32Array([1.0, 0.0, 1.0]), null, undefined); 2147 }, () => { 2148 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2149 }); 2150 done(); 2151 }); 2152 function uniform2fv(callback, finish) { 2153 let p = createProgram(gl, `#version 300 es 2154 uniform vec2 u; 2155 void main(){ 2156 gl_Position.x = u.x; 2157 gl_Position.y = u.y; 2158 gl_Position.w = 1.0; 2159 gl_PointSize = 100.0; 2160 } 2161 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2162 gl.useProgram(p.program); 2163 let u = gl.getUniformLocation(p.program, "u"); 2164 callback(u); 2165 let uniform = gl.getUniform(p.program, u); 2166 clear(gl); 2167 gl.drawArrays(gl.POINTS, 0, 1); 2168 gl.deleteShader(p.vertexShader); 2169 gl.deleteShader(p.fragmentShader); 2170 gl.deleteProgram(p.program); 2171 finish(); 2172 } 2173 /** 2174 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0095 2175 * @tc.name webgl2_test_uniform2fv 2176 * @tc.desc Test uniform2fv. 2177 */ 2178 it('webgl2_test_uniform2fv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2179 console.info("webgl2test [webgl2_test_uniform2fv] uniform2fv"); 2180 let p = createProgram(gl, `#version 300 es 2181 uniform vec2 u; 2182 void main(){ 2183 gl_Position.x = u.x; 2184 gl_Position.y = u.y; 2185 gl_Position.w = 1.0; 2186 gl_PointSize = 100.0; 2187 } 2188 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2189 gl.useProgram(p.program); 2190 let u = gl.getUniformLocation(p.program, "u"); 2191 gl.uniform2fv(u, new Float32Array([0.0, 0.0, 1.0, 1.0]), 2, 2); 2192 let uniform = gl.getUniform(p.program, u); 2193 console.info("webgltest", uniform); 2194 expect(uniform[0]).assertEqual(1.0); 2195 expect(uniform[1]).assertEqual(1.0); 2196 clear(gl); 2197 gl.drawArrays(gl.POINTS, 0, 1); 2198 gl.deleteShader(p.vertexShader); 2199 gl.deleteShader(p.fragmentShader); 2200 gl.deleteProgram(p.program); 2201 checkError(gl); 2202 done(); 2203 }); 2204 /** 2205 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0096 2206 * @tc.name webgl2_test_uniform2fv_1 2207 * @tc.desc Test uniform2fv. 2208 */ 2209 it('webgl2_test_uniform2fv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2210 console.info("webgl2test [webgl2_test_uniform2fv_1] uniform2fv"); 2211 uniform2fv((u) => { 2212 gl.uniform2fv(u, new Float32Array([1.0, 0.0, 1.0, 1.0]), 2, null); 2213 }, () => { 2214 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2215 }); 2216 done(); 2217 }); 2218 /** 2219 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0097 2220 * @tc.name webgl2_test_uniform2fv_2 2221 * @tc.desc Test uniform2fv. 2222 */ 2223 it('webgl2_test_uniform2fv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2224 console.info("webgl2test [webgl2_test_uniform2fv_2] uniform2fv"); 2225 uniform2fv((u) => { 2226 gl.uniform2fv(u, new Float32Array([1.0, 0.0, 1.0, 1.0]), 1, undefined); 2227 }, () => { 2228 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2229 }); 2230 done(); 2231 }); 2232 /** 2233 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0098 2234 * @tc.name webgl2_test_uniform2fv_3 2235 * @tc.desc Test uniform2fv. 2236 */ 2237 it('webgl2_test_uniform2fv_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2238 console.info("webgl2test [webgl2_test_uniform2fv_3] uniform2fv"); 2239 uniform2fv((u) => { 2240 gl.uniform2fv(u, new Float32Array([1.0, 0.0, 1.0, 1.0]), null, undefined); 2241 }, () => { 2242 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2243 }); 2244 done(); 2245 }); 2246 /** 2247 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0099 2248 * @tc.name webgl2_test_uniform2fv_4 2249 * @tc.desc Test uniform2fv. 2250 */ 2251 it('webgl2_test_uniform2fv_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2252 console.info("webgl2test [webgl2_test_uniform2fv_4] uniform2fv"); 2253 uniform2fv((u) => { 2254 gl.uniform2fv(u, new Float32Array([1.0, 0.0, 1.0, 1.0]), null, undefined); 2255 }, () => { 2256 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2257 }); 2258 done(); 2259 }); 2260 /** 2261 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0100 2262 * @tc.name webgl2_test_uniform2fv_5 2263 * @tc.desc Test uniform2fv. 2264 */ 2265 it('webgl2_test_uniform2fv_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2266 console.info("webgl2test [webgl2_test_uniform2fv_5] uniform2fv"); 2267 uniform2fv((u) => { 2268 gl.uniform2fv(null, new Float32Array([1.0, 0.0, 1.0, 1.0]), null, undefined); 2269 }, () => { 2270 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2271 }); 2272 done(); 2273 }); 2274 function uniform3fv(callback, finish) { 2275 let p = createProgram(gl, `#version 300 es 2276 uniform vec3 u; 2277 void main(){ 2278 gl_Position.x = u.x; 2279 gl_Position.y = u.y; 2280 gl_Position.z = u.z; 2281 gl_Position.w = 1.0; 2282 gl_PointSize = 100.0; 2283 } 2284 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2285 gl.useProgram(p.program); 2286 let u = gl.getUniformLocation(p.program, "u"); 2287 callback(u); 2288 let uniform = gl.getUniform(p.program, u); 2289 clear(gl); 2290 gl.drawArrays(gl.POINTS, 0, 1); 2291 gl.deleteShader(p.vertexShader); 2292 gl.deleteShader(p.fragmentShader); 2293 gl.deleteProgram(p.program); 2294 finish(); 2295 } 2296 /** 2297 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0101 2298 * @tc.name webgl2_test_uniform3fv 2299 * @tc.desc Test uniform3fv. 2300 */ 2301 it('webgl2_test_uniform3fv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2302 console.info("webgl2test [webgl2_test_uniform3fv] uniform3fv"); 2303 let p = createProgram(gl, `#version 300 es 2304 uniform vec3 u; 2305 void main(){ 2306 gl_Position.x = u.x; 2307 gl_Position.y = u.y; 2308 gl_Position.z = u.z; 2309 gl_Position.w = 1.0; 2310 gl_PointSize = 100.0; 2311 } 2312 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2313 gl.useProgram(p.program); 2314 let u = gl.getUniformLocation(p.program, "u"); 2315 gl.uniform3fv(u, new Float32Array([0.0, 0.0, 1.0, 1.0, 1.0, 1.0]), 2, 3); 2316 let uniform = gl.getUniform(p.program, u); 2317 console.info("webgltest", uniform); 2318 expect(uniform[0]).assertEqual(1.0); 2319 expect(uniform[1]).assertEqual(1.0); 2320 expect(uniform[2]).assertEqual(1.0); 2321 clear(gl); 2322 gl.drawArrays(gl.POINTS, 0, 1); 2323 gl.deleteShader(p.vertexShader); 2324 gl.deleteShader(p.fragmentShader); 2325 gl.deleteProgram(p.program); 2326 checkError(gl); 2327 done(); 2328 }); 2329 /** 2330 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0102 2331 * @tc.name webgl2_test_uniform3fv_1 2332 * @tc.desc Test uniform3fv. 2333 */ 2334 it('webgl2_test_uniform3fv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2335 console.info("webgl2test [webgl2_test_uniform3fv_1] uniform3fv"); 2336 uniform3fv((u) => { 2337 gl.uniform3fv(u, new Float32Array([1.0, 0.0, 1.0, 1.0, 1.0]), 2, null); 2338 }, () => { 2339 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2340 }); 2341 done(); 2342 }); 2343 /** 2344 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0103 2345 * @tc.name webgl2_test_uniform3fv_2 2346 * @tc.desc Test uniform3fv. 2347 */ 2348 it('webgl2_test_uniform3fv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2349 console.info("webgl2test [webgl2_test_uniform3fv_2] uniform3fv"); 2350 uniform3fv((u) => { 2351 gl.uniform3fv(u, new Float32Array([1.0, 0.0, 1.0, 1.0, 1.0]), 1, undefined); 2352 }, () => { 2353 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2354 }); 2355 done(); 2356 }); 2357 /** 2358 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0104 2359 * @tc.name webgl2_test_uniform3fv_3 2360 * @tc.desc Test uniform3fv. 2361 */ 2362 it('webgl2_test_uniform3fv_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2363 console.info("webgl2test [webgl2_test_uniform3fv_3] uniform3fv"); 2364 uniform3fv((u) => { 2365 gl.uniform3fv(u, new Float32Array([1.0, 0.0, 1.0, 1.0, 1.0]), null, undefined); 2366 }, () => { 2367 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2368 }); 2369 done(); 2370 }); 2371 /** 2372 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0105 2373 * @tc.name webgl2_test_uniform3fv_4 2374 * @tc.desc Test uniform3fv. 2375 */ 2376 it('webgl2_test_uniform3fv_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2377 console.info("webgl2test [webgl2_test_uniform3fv_4] uniform3fv"); 2378 uniform3fv((u) => { 2379 gl.uniform3fv(u, new Float32Array([1.0, 0.0, 1.0, 1.0, 1.0]), null, undefined); 2380 }, () => { 2381 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2382 }); 2383 done(); 2384 }); 2385 /** 2386 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0106 2387 * @tc.name webgl2_test_uniform3fv_5 2388 * @tc.desc Test uniform3fv. 2389 */ 2390 it('webgl2_test_uniform3fv_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2391 console.info("webgl2test [webgl2_test_uniform3fv_5] uniform3fv"); 2392 uniform3fv((u) => { 2393 gl.uniform3fv(null, new Float32Array([1.0, 0.0, 1.0, 1.0, 1.0]), null, undefined); 2394 }, () => { 2395 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2396 }); 2397 done(); 2398 }); 2399 function uniform4fv(callback, finish) { 2400 let p = createProgram(gl, `#version 300 es 2401 uniform vec4 u; 2402 void main(){ 2403 gl_Position.x = u.x; 2404 gl_Position.y = u.y; 2405 gl_Position.z = u.z; 2406 gl_Position.w = u.w; 2407 gl_PointSize = 100.0; 2408 } 2409 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2410 gl.useProgram(p.program); 2411 let u = gl.getUniformLocation(p.program, "u"); 2412 callback(u); 2413 let uniform = gl.getUniform(p.program, u); 2414 clear(gl); 2415 gl.drawArrays(gl.POINTS, 0, 1); 2416 gl.deleteShader(p.vertexShader); 2417 gl.deleteShader(p.fragmentShader); 2418 gl.deleteProgram(p.program); 2419 finish(); 2420 } 2421 /** 2422 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0107 2423 * @tc.name webgl2_test_uniform4fv 2424 * @tc.desc Test uniform4fv. 2425 */ 2426 it('webgl2_test_uniform4fv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2427 console.info("webgl2test [webgl2_test_uniform4fv] uniform4fv"); 2428 let p = createProgram(gl, `#version 300 es 2429 uniform vec4 u; 2430 void main(){ 2431 gl_Position.x = u.x; 2432 gl_Position.y = u.y; 2433 gl_Position.z = u.z; 2434 gl_Position.w = u.w; 2435 gl_PointSize = 100.0; 2436 } 2437 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2438 gl.useProgram(p.program); 2439 let u = gl.getUniformLocation(p.program, "u"); 2440 gl.uniform4fv(u, new Float32Array([0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]), 4, 4); 2441 let uniform = gl.getUniform(p.program, u); 2442 console.info("webgltest", uniform); 2443 expect(uniform[0]).assertEqual(1.0); 2444 expect(uniform[1]).assertEqual(1.0); 2445 expect(uniform[2]).assertEqual(1.0); 2446 clear(gl); 2447 gl.drawArrays(gl.POINTS, 0, 1); 2448 gl.deleteShader(p.vertexShader); 2449 gl.deleteShader(p.fragmentShader); 2450 gl.deleteProgram(p.program); 2451 checkError(gl); 2452 done(); 2453 }); 2454 /** 2455 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0108 2456 * @tc.name webgl2_test_uniform4fv_1 2457 * @tc.desc Test uniform4fv. 2458 */ 2459 it('webgl2_test_uniform4fv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2460 console.info("webgl2test [webgl2_test_uniform4fv_1] uniform4fv"); 2461 uniform4fv((u) => { 2462 gl.uniform4fv(u, new Float32Array([0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]), 4, null); 2463 }, () => { 2464 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2465 }); 2466 done(); 2467 }); 2468 /** 2469 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0109 2470 * @tc.name webgl2_test_uniform4fv_2 2471 * @tc.desc Test uniform4fv. 2472 */ 2473 it('webgl2_test_uniform4fv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2474 console.info("webgl2test [webgl2_test_uniform4fv_2] uniform4fv"); 2475 uniform4fv((u) => { 2476 gl.uniform4fv(u, new Float32Array([0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]), 4, undefined); 2477 }, () => { 2478 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2479 }); 2480 done(); 2481 }); 2482 /** 2483 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0110 2484 * @tc.name webgl2_test_uniform4fv_3 2485 * @tc.desc Test uniform4fv. 2486 */ 2487 it('webgl2_test_uniform4fv_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2488 console.info("webgl2test [webgl2_test_uniform4fv_3] uniform4fv"); 2489 uniform4fv((u) => { 2490 gl.uniform4fv(u, new Float32Array([0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]), null, undefined); 2491 }, () => { 2492 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2493 }); 2494 done(); 2495 }); 2496 /** 2497 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0111 2498 * @tc.name webgl2_test_uniform4fv_4 2499 * @tc.desc Test uniform4fv. 2500 */ 2501 it('webgl2_test_uniform4fv_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2502 console.info("webgl2test [webgl2_test_uniform4fv_4] uniform4fv"); 2503 uniform4fv((u) => { 2504 gl.uniform4fv(u, new Float32Array([0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]), null, undefined); 2505 }, () => { 2506 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2507 }); 2508 done(); 2509 }); 2510 /** 2511 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0112 2512 * @tc.name webgl2_test_uniform4fv_5 2513 * @tc.desc Test uniform4fv. 2514 */ 2515 it('webgl2_test_uniform4fv_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2516 console.info("webgl2test [webgl2_test_uniform4fv_5] uniform4fv"); 2517 uniform4fv((u) => { 2518 gl.uniform4fv(null, new Float32Array([0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]), null, undefined); 2519 }, () => { 2520 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2521 }); 2522 done(); 2523 }); 2524 function uniform1iv(callback, finish) { 2525 let p = createProgram(gl, `#version 300 es 2526 uniform int u; 2527 void main(){ 2528 gl_Position.x = float(u); 2529 gl_Position.w = 1.0; 2530 gl_PointSize = 100.0; 2531 } 2532 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2533 gl.useProgram(p.program); 2534 let u = gl.getUniformLocation(p.program, "u"); 2535 callback(u); 2536 let uniform = gl.getUniform(p.program, u); 2537 clear(gl); 2538 gl.drawArrays(gl.POINTS, 0, 1); 2539 gl.deleteShader(p.vertexShader); 2540 gl.deleteShader(p.fragmentShader); 2541 gl.deleteProgram(p.program); 2542 finish(); 2543 } 2544 /** 2545 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0113 2546 * @tc.name webgl2_test_uniform1iv 2547 * @tc.desc Test uniform1iv. 2548 */ 2549 it('webgl2_test_uniform1iv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2550 console.info("webgl2test [webgl2_test_uniform1iv] uniform1iv"); 2551 let p = createProgram(gl, `#version 300 es 2552 uniform int u; 2553 void main(){ 2554 gl_Position.x = float(u); 2555 gl_Position.w = 1.0; 2556 gl_PointSize = 100.0; 2557 } 2558 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2559 gl.useProgram(p.program); 2560 let u = gl.getUniformLocation(p.program, "u"); 2561 gl.uniform1iv(u, new Int32Array([0, 1, 1]), 1, 1); 2562 let uniform = gl.getUniform(p.program, u); 2563 console.info("webgltest", uniform); 2564 expect(uniform).assertEqual(1); 2565 clear(gl); 2566 gl.drawArrays(gl.POINTS, 0, 1); 2567 gl.deleteShader(p.vertexShader); 2568 gl.deleteShader(p.fragmentShader); 2569 gl.deleteProgram(p.program); 2570 checkError(gl); 2571 done(); 2572 }); 2573 /** 2574 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0114 2575 * @tc.name webgl2_test_uniform1iv_1 2576 * @tc.desc Test uniform1iv. 2577 */ 2578 it('webgl2_test_uniform1iv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2579 console.info("webgl2test [webgl2_test_uniform1iv_1] uniform1iv"); 2580 uniform1iv((u) => { 2581 gl.uniform1iv(u, new Int32Array([0, 1, 1]), 1, null); 2582 }, () => { 2583 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2584 }); 2585 done(); 2586 }); 2587 /** 2588 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0115 2589 * @tc.name webgl2_test_uniform1iv_2 2590 * @tc.desc Test uniform1iv. 2591 */ 2592 it('webgl2_test_uniform1iv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2593 console.info("webgl2test [webgl2_test_uniform1iv_2] uniform1iv"); 2594 uniform1iv((u) => { 2595 gl.uniform1iv(u, new Int32Array([0, 1, 1]), 1, undefined); 2596 }, () => { 2597 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2598 }); 2599 done(); 2600 }); 2601 /** 2602 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0116 2603 * @tc.name webgl2_test_uniform1iv_3 2604 * @tc.desc Test uniform1iv. 2605 */ 2606 it('webgl2_test_uniform1iv_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2607 console.info("webgl2test [webgl2_test_uniform1iv_3] uniform1iv"); 2608 uniform1iv((u) => { 2609 gl.uniform1iv(u, new Int32Array([0, 1, 1]), null, undefined); 2610 }, () => { 2611 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2612 }); 2613 done(); 2614 }); 2615 /** 2616 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0117 2617 * @tc.name webgl2_test_uniform1iv_4 2618 * @tc.desc Test uniform1iv. 2619 */ 2620 it('webgl2_test_uniform1iv_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2621 console.info("webgl2test [webgl2_test_uniform1iv_4] uniform1iv"); 2622 uniform1iv((u) => { 2623 gl.uniform1iv(u, new Int32Array([0, 1, 1]), null, undefined); 2624 }, () => { 2625 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2626 }); 2627 done(); 2628 }); 2629 /** 2630 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0118 2631 * @tc.name webgl2_test_uniform1iv_5 2632 * @tc.desc Test uniform1iv. 2633 */ 2634 it('webgl2_test_uniform1iv_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2635 console.info("webgl2test [webgl2_test_uniform1iv_5] uniform1iv"); 2636 uniform1iv((u) => { 2637 gl.uniform1iv(null, new Int32Array([0, 1, 1]), null, undefined); 2638 }, () => { 2639 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2640 }); 2641 done(); 2642 }); 2643 function uniform2iv(callback, finish) { 2644 let p = createProgram(gl, `#version 300 es 2645 uniform ivec2 u; 2646 void main(){ 2647 gl_Position.x = float(u.x); 2648 gl_Position.y = float(u.y); 2649 gl_Position.w = 1.0; 2650 gl_PointSize = 100.0; 2651 } 2652 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2653 gl.useProgram(p.program); 2654 let u = gl.getUniformLocation(p.program, "u"); 2655 callback(u); 2656 let uniform = gl.getUniform(p.program, u); 2657 clear(gl); 2658 gl.drawArrays(gl.POINTS, 0, 1); 2659 gl.deleteShader(p.vertexShader); 2660 gl.deleteShader(p.fragmentShader); 2661 gl.deleteProgram(p.program); 2662 finish(); 2663 } 2664 /** 2665 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0119 2666 * @tc.name webgl2_test_uniform2iv 2667 * @tc.desc Test uniform2iv. 2668 */ 2669 it('webgl2_test_uniform2iv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2670 console.info("webgl2test [webgl2_test_uniform2iv] uniform2iv"); 2671 let p = createProgram(gl, `#version 300 es 2672 uniform ivec2 u; 2673 void main(){ 2674 gl_Position.x = float(u.x); 2675 gl_Position.y = float(u.y); 2676 gl_Position.w = 1.0; 2677 gl_PointSize = 100.0; 2678 } 2679 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2680 gl.useProgram(p.program); 2681 let u = gl.getUniformLocation(p.program, "u"); 2682 gl.uniform2iv(u, new Int32Array([0, 0, 1, 1]), 2, 2); 2683 let uniform = gl.getUniform(p.program, u); 2684 console.info("webgltest", uniform); 2685 expect(uniform[0]).assertEqual(1); 2686 expect(uniform[1]).assertEqual(1); 2687 clear(gl); 2688 gl.drawArrays(gl.POINTS, 0, 1); 2689 gl.deleteShader(p.vertexShader); 2690 gl.deleteShader(p.fragmentShader); 2691 gl.deleteProgram(p.program); 2692 checkError(gl); 2693 done(); 2694 }); 2695 /** 2696 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0120 2697 * @tc.name webgl2_test_uniform2iv_1 2698 * @tc.desc Test uniform2iv. 2699 */ 2700 it('webgl2_test_uniform2iv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2701 console.info("webgl2test [webgl2_test_uniform2iv_1] uniform2iv"); 2702 uniform2iv((u) => { 2703 gl.uniform2iv(u, new Int32Array([0, 1, 1, 1]), 1, null); 2704 }, () => { 2705 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2706 }); 2707 done(); 2708 }); 2709 /** 2710 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0121 2711 * @tc.name webgl2_test_uniform2iv_2 2712 * @tc.desc Test uniform2iv. 2713 */ 2714 it('webgl2_test_uniform2iv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2715 console.info("webgl2test [webgl2_test_uniform2iv_2] uniform2iv"); 2716 uniform2iv((u) => { 2717 gl.uniform2iv(u, new Int32Array([0, 1, 1, 1]), 1, undefined); 2718 }, () => { 2719 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2720 }); 2721 done(); 2722 }); 2723 /** 2724 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0122 2725 * @tc.name webgl2_test_uniform2iv_3 2726 * @tc.desc Test uniform2iv. 2727 */ 2728 it('webgl2_test_uniform2iv_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2729 console.info("webgl2test [webgl2_test_uniform2iv_3] uniform2iv"); 2730 uniform2iv((u) => { 2731 gl.uniform2iv(u, new Int32Array([0, 1, 1, 1]), null, undefined); 2732 }, () => { 2733 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2734 }); 2735 done(); 2736 }); 2737 /** 2738 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0123 2739 * @tc.name webgl2_test_uniform2iv_4 2740 * @tc.desc Test uniform2iv. 2741 */ 2742 it('webgl2_test_uniform2iv_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2743 console.info("webgl2test [webgl2_test_uniform2iv_4] uniform2iv"); 2744 uniform2iv((u) => { 2745 gl.uniform2iv(u, new Int32Array([0, 1, 1, 1]), null, undefined); 2746 }, () => { 2747 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2748 }); 2749 done(); 2750 }); 2751 /** 2752 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0124 2753 * @tc.name webgl2_test_uniform2iv_5 2754 * @tc.desc Test uniform2iv. 2755 */ 2756 it('webgl2_test_uniform2iv_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2757 console.info("webgl2test [webgl2_test_uniform2iv_5] uniform2iv"); 2758 uniform2iv((u) => { 2759 gl.uniform2iv(null, new Int32Array([0, 1, 1, 1]), null, undefined); 2760 }, () => { 2761 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2762 }); 2763 done(); 2764 }); 2765 function uniform3iv(callback, finish) { 2766 let p = createProgram(gl, `#version 300 es 2767 uniform ivec3 u; 2768 void main(){ 2769 gl_Position.x = float(u.x); 2770 gl_Position.y = float(u.y); 2771 gl_Position.z = float(u.z); 2772 gl_Position.w = 1.0; 2773 gl_PointSize = 100.0; 2774 } 2775 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2776 gl.useProgram(p.program); 2777 let u = gl.getUniformLocation(p.program, "u"); 2778 callback(u); 2779 let uniform = gl.getUniform(p.program, u); 2780 clear(gl); 2781 gl.drawArrays(gl.POINTS, 0, 1); 2782 gl.deleteShader(p.vertexShader); 2783 gl.deleteShader(p.fragmentShader); 2784 gl.deleteProgram(p.program); 2785 finish(); 2786 } 2787 /** 2788 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0125 2789 * @tc.name webgl2_test_uniform3iv 2790 * @tc.desc Test uniform3iv. 2791 */ 2792 it('webgl2_test_uniform3iv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2793 console.info("webgl2test [webgl2_test_uniform3iv] uniform3iv"); 2794 let p = createProgram(gl, `#version 300 es 2795 uniform ivec3 u; 2796 void main(){ 2797 gl_Position.x = float(u.x); 2798 gl_Position.y = float(u.y); 2799 gl_Position.z = float(u.z); 2800 gl_Position.w = 1.0; 2801 gl_PointSize = 100.0; 2802 } 2803 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2804 gl.useProgram(p.program); 2805 let u = gl.getUniformLocation(p.program, "u"); 2806 gl.uniform3iv(u, new Int32Array([0, 0, 1, 1, 1, 1]), 3, 3); 2807 let uniform = gl.getUniform(p.program, u); 2808 console.info("webgltest", uniform); 2809 expect(uniform[0]).assertEqual(1); 2810 expect(uniform[1]).assertEqual(1); 2811 expect(uniform[2]).assertEqual(1); 2812 clear(gl); 2813 gl.drawArrays(gl.POINTS, 0, 1); 2814 gl.deleteShader(p.vertexShader); 2815 gl.deleteShader(p.fragmentShader); 2816 gl.deleteProgram(p.program); 2817 checkError(gl); 2818 done(); 2819 }); 2820 /** 2821 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0126 2822 * @tc.name webgl2_test_uniform3iv_1 2823 * @tc.desc Test uniform3iv. 2824 */ 2825 it('webgl2_test_uniform3iv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2826 console.info("webgl2test [webgl2_test_uniform3iv_1] uniform3iv"); 2827 uniform3iv((u) => { 2828 gl.uniform3iv(u, new Int32Array([0, 0, 1, 1, 1, 1]), 1, null); 2829 }, () => { 2830 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2831 }); 2832 done(); 2833 }); 2834 /** 2835 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0127 2836 * @tc.name webgl2_test_uniform3iv_2 2837 * @tc.desc Test uniform3iv. 2838 */ 2839 it('webgl2_test_uniform3iv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2840 console.info("webgl2test [webgl2_test_uniform3iv_2] uniform3iv"); 2841 uniform3iv((u) => { 2842 gl.uniform3iv(u, new Int32Array([0, 0, 1, 1, 1, 1]), 1, undefined); 2843 }, () => { 2844 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2845 }); 2846 done(); 2847 }); 2848 /** 2849 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0128 2850 * @tc.name webgl2_test_uniform3iv_3 2851 * @tc.desc Test uniform3iv. 2852 */ 2853 it('webgl2_test_uniform3iv_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2854 console.info("webgl2test [webgl2_test_uniform3iv_3] uniform3iv"); 2855 uniform3iv((u) => { 2856 gl.uniform3iv(u, new Int32Array([0, 0, 1, 1, 1, 1]), null, undefined); 2857 }, () => { 2858 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2859 }); 2860 done(); 2861 }); 2862 /** 2863 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0129 2864 * @tc.name webgl2_test_uniform3iv_4 2865 * @tc.desc Test uniform3iv. 2866 */ 2867 it('webgl2_test_uniform3iv_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2868 console.info("webgl2test [webgl2_test_uniform3iv_4] uniform3iv"); 2869 uniform3iv((u) => { 2870 gl.uniform3iv(u, new Int32Array([0, 0, 1, 1, 1, 1]), null, undefined); 2871 }, () => { 2872 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2873 }); 2874 done(); 2875 }); 2876 /** 2877 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0130 2878 * @tc.name webgl2_test_uniform3iv_5 2879 * @tc.desc Test uniform3iv. 2880 */ 2881 it('webgl2_test_uniform3iv_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2882 console.info("webgl2test [webgl2_test_uniform3iv_5] uniform3iv"); 2883 uniform3iv((u) => { 2884 gl.uniform3iv(null, new Int32Array([0, 0, 1, 1, 1, 1]), null, undefined); 2885 }, () => { 2886 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2887 }); 2888 done(); 2889 }); 2890 function uniform4iv(callback, finish) { 2891 let p = createProgram(gl, `#version 300 es 2892 uniform ivec4 u; 2893 void main(){ 2894 gl_Position.x = float(u.x); 2895 gl_Position.y = float(u.y); 2896 gl_Position.z = float(u.z); 2897 gl_Position.w = float(u.w); 2898 gl_PointSize = 100.0; 2899 } 2900 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2901 gl.useProgram(p.program); 2902 let u = gl.getUniformLocation(p.program, "u"); 2903 callback(u); 2904 let uniform = gl.getUniform(p.program, u); 2905 clear(gl); 2906 gl.drawArrays(gl.POINTS, 0, 1); 2907 gl.deleteShader(p.vertexShader); 2908 gl.deleteShader(p.fragmentShader); 2909 gl.deleteProgram(p.program); 2910 finish(); 2911 } 2912 /** 2913 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0131 2914 * @tc.name webgl2_test_uniform4iv 2915 * @tc.desc Test uniform4iv. 2916 */ 2917 it('webgl2_test_uniform4iv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2918 console.info("webgl2test [webgl2_test_uniform4iv] uniform4iv"); 2919 let p = createProgram(gl, `#version 300 es 2920 uniform ivec4 u; 2921 void main(){ 2922 gl_Position.x = float(u.x); 2923 gl_Position.y = float(u.y); 2924 gl_Position.z = float(u.z); 2925 gl_Position.w = float(u.w); 2926 gl_PointSize = 100.0; 2927 } 2928 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2929 gl.useProgram(p.program); 2930 let u = gl.getUniformLocation(p.program, "u"); 2931 gl.uniform4iv(u, new Int32Array([ 2932 0, 0, 1, 1, 2933 1, 1, 1, 1 2934 ]), 4, 4); 2935 let uniform = gl.getUniform(p.program, u); 2936 console.info("webgltest", uniform); 2937 expect(uniform[0]).assertEqual(1); 2938 expect(uniform[1]).assertEqual(1); 2939 expect(uniform[2]).assertEqual(1); 2940 expect(uniform[3]).assertEqual(1); 2941 clear(gl); 2942 gl.drawArrays(gl.POINTS, 0, 1); 2943 gl.deleteShader(p.vertexShader); 2944 gl.deleteShader(p.fragmentShader); 2945 gl.deleteProgram(p.program); 2946 checkError(gl); 2947 done(); 2948 }); 2949 /** 2950 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0132 2951 * @tc.name webgl2_test_uniform4iv_1 2952 * @tc.desc Test uniform4iv. 2953 */ 2954 it('webgl2_test_uniform4iv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2955 console.info("webgl2test [webgl2_test_uniform4iv_1] uniform4iv"); 2956 uniform4iv((u) => { 2957 gl.uniform4iv(u, new Int32Array([ 2958 0, 0, 1, 1, 2959 1, 1, 1, 1 2960 ]), 4, null); 2961 }, () => { 2962 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2963 }); 2964 done(); 2965 }); 2966 /** 2967 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0133 2968 * @tc.name webgl2_test_uniform4iv_2 2969 * @tc.desc Test uniform4iv. 2970 */ 2971 it('webgl2_test_uniform4iv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2972 console.info("webgl2test [webgl2_test_uniform4iv_2] uniform4iv"); 2973 uniform4iv((u) => { 2974 gl.uniform4iv(u, new Int32Array([ 2975 0, 0, 1, 1, 2976 1, 1, 1, 1 2977 ]), 4, undefined); 2978 }, () => { 2979 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2980 }); 2981 done(); 2982 }); 2983 /** 2984 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0134 2985 * @tc.name webgl2_test_uniform4iv_3 2986 * @tc.desc Test uniform4iv. 2987 */ 2988 it('webgl2_test_uniform4iv_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 2989 console.info("webgl2test [webgl2_test_uniform4iv_3] uniform4iv"); 2990 uniform4iv((u) => { 2991 gl.uniform4iv(u, new Int32Array([ 2992 0, 0, 1, 1, 2993 1, 1, 1, 1 2994 ]), null, undefined); 2995 }, () => { 2996 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2997 }); 2998 done(); 2999 }); 3000 /** 3001 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0135 3002 * @tc.name webgl2_test_uniform4iv_4 3003 * @tc.desc Test uniform4iv. 3004 */ 3005 it('webgl2_test_uniform4iv_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 3006 console.info("webgl2test [webgl2_test_uniform4iv_4] uniform4iv"); 3007 uniform4iv((u) => { 3008 gl.uniform4iv(u, new Int32Array([ 3009 0, 0, 1, 1, 3010 1, 1, 1, 1 3011 ]), null, undefined); 3012 }, () => { 3013 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 3014 }); 3015 done(); 3016 }); 3017 /** 3018 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0136 3019 * @tc.name webgl2_test_uniform4iv_5 3020 * @tc.desc Test uniform4iv. 3021 */ 3022 it('webgl2_test_uniform4iv_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 3023 console.info("webgl2test [webgl2_test_uniform4iv_5] uniform4iv"); 3024 uniform4iv((u) => { 3025 gl.uniform4iv(null, new Int32Array([ 3026 0, 0, 1, 1, 3027 1, 1, 1, 1 3028 ]), null, undefined); 3029 }, () => { 3030 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 3031 }); 3032 done(); 3033 }); 3034 function uniformMatrix2fv(callback, finish) { 3035 let p = createProgram(gl, `#version 300 es 3036 in vec2 a_Position; 3037 uniform mat2 u_MvpMatrix; 3038 void main(){ 3039 gl_Position = vec4( 3040 (u_MvpMatrix * vec2(a_Position.x,a_Position.y)).xy, 0, 1 3041 ); 3042 } 3043 `, WEBGL2_FRAGMENT_SHADER_DEMO); 3044 gl.useProgram(p.program); 3045 let u = gl.getUniformLocation(p.program, "u_MvpMatrix"); 3046 callback(u); 3047 let uniform = gl.getUniform(p.program, u); 3048 clear(gl); 3049 gl.drawArrays(gl.POINTS, 0, 1); 3050 gl.deleteShader(p.vertexShader); 3051 gl.deleteShader(p.fragmentShader); 3052 gl.deleteProgram(p.program); 3053 finish(); 3054 } 3055 /** 3056 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0137 3057 * @tc.name webgl2_test_uniformMatrix2fv 3058 * @tc.desc Test uniformMatrix2fv. 3059 */ 3060 it('webgl2_test_uniformMatrix2fv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 3061 console.info("webgl2test [webgl2_test_uniformMatrix2fv] uniformMatrix2fv"); 3062 let p = createProgram(gl, `#version 300 es 3063 in vec2 a_Position; 3064 uniform mat2 u_MvpMatrix; 3065 void main(){ 3066 gl_Position = vec4( 3067 (u_MvpMatrix * vec2(a_Position.x,a_Position.y)).xy, 0, 1 3068 ); 3069 } 3070 `, WEBGL2_FRAGMENT_SHADER_DEMO); 3071 gl.useProgram(p.program); 3072 let u = gl.getUniformLocation(p.program, "u_MvpMatrix"); 3073 gl.uniformMatrix2fv(u, false, new Float32Array([ 3074 3.0, -0.5, 3075 0, 3.5, 3076 1.0, -1.5, 3077 0, 1.5, 3078 ]), 4, 4); 3079 let value = gl.getUniform(p.program, u); 3080 console.info("webgltest", value); 3081 expect(value[0]).assertEqual(1.0); 3082 expect(value[1]).assertEqual(-1.5); 3083 expect(value[2]).assertEqual(0); 3084 expect(value[3]).assertEqual(1.5); 3085 clear(gl); 3086 gl.drawArrays(gl.POINTS, 0, 1); 3087 gl.deleteShader(p.vertexShader); 3088 gl.deleteShader(p.fragmentShader); 3089 gl.deleteProgram(p.program); 3090 checkError(gl); 3091 done(); 3092 }); 3093 /** 3094 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0138 3095 * @tc.name webgl2_test_uniformMatrix2fv_1 3096 * @tc.desc Test uniformMatrix2fv. 3097 */ 3098 it('webgl2_test_uniformMatrix2fv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 3099 async function (done) { 3100 console.info("webgl2test [webgl2_test_uniformMatrix2fv_1] uniformMatrix2fv"); 3101 uniformMatrix2fv((u) => { 3102 gl.uniformMatrix2fv(u, null, new Float32Array([ 3103 3.0, -0.5, 3104 0, 3.5, 3105 1.0, -1.5, 3106 0, 1.5, 3107 ]), 4, null); 3108 }, () => { 3109 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 3110 }); 3111 done(); 3112 }); 3113 /** 3114 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0139 3115 * @tc.name webgl2_test_uniformMatrix2fv_2 3116 * @tc.desc Test uniformMatrix2fv. 3117 */ 3118 it('webgl2_test_uniformMatrix2fv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 3119 async function (done) { 3120 console.info("webgl2test [webgl2_test_uniformMatrix2fv_2] uniformMatrix2fv"); 3121 uniformMatrix2fv((u) => { 3122 gl.uniformMatrix2fv(u, null, new Float32Array([ 3123 3.0, -0.5, 3124 0, 3.5, 3125 1.0, -1.5, 3126 0, 1.5, 3127 ]), 4, undefined); 3128 }, () => { 3129 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 3130 }); 3131 done(); 3132 }); 3133 /** 3134 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0140 3135 * @tc.name webgl2_test_uniformMatrix2fv_3 3136 * @tc.desc Test uniformMatrix2fv. 3137 */ 3138 it('webgl2_test_uniformMatrix2fv_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 3139 async function (done) { 3140 console.info("webgl2test [webgl2_test_uniformMatrix2fv_3] uniformMatrix2fv"); 3141 uniformMatrix2fv((u) => { 3142 gl.uniformMatrix2fv(u, null, new Float32Array([ 3143 3.0, -0.5, 3144 0, 3.5, 3145 1.0, -1.5, 3146 0, 1.5, 3147 ]), null, undefined); 3148 }, () => { 3149 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 3150 }); 3151 done(); 3152 }); 3153 /** 3154 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0141 3155 * @tc.name webgl2_test_uniformMatrix2fv_4 3156 * @tc.desc Test uniformMatrix2fv. 3157 */ 3158 it('webgl2_test_uniformMatrix2fv_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 3159 async function (done) { 3160 console.info("webgl2test [webgl2_test_uniformMatrix2fv_4] uniformMatrix2fv"); 3161 uniformMatrix2fv((u) => { 3162 gl.uniformMatrix2fv(u, null, new Float32Array([ 3163 3.0, -0.5, 3164 0, 3.5, 3165 1.0, -1.5, 3166 0, 1.5, 3167 ]), null, undefined); 3168 }, () => { 3169 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 3170 }); 3171 done(); 3172 }); 3173 /** 3174 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0142 3175 * @tc.name webgl2_test_uniformMatrix2fv_5 3176 * @tc.desc Test uniformMatrix2fv. 3177 */ 3178 it('webgl2_test_uniformMatrix2fv_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 3179 async function (done) { 3180 console.info("webgl2test [webgl2_test_uniformMatrix2fv_5] uniformMatrix2fv"); 3181 uniformMatrix2fv((u) => { 3182 gl.uniformMatrix2fv(null, null, new Float32Array([ 3183 3.0, -0.5, 3184 0, 3.5, 3185 1.0, -1.5, 3186 0, 1.5, 3187 ]), null, undefined); 3188 }, () => { 3189 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 3190 }); 3191 done(); 3192 }); 3193 function uniformMatrix3fv(callback, finish) { 3194 let p = createProgram(gl, `#version 300 es 3195 in vec2 a_Position; 3196 uniform mat3 u_MvpMatrix; 3197 void main(){ 3198 gl_Position = vec4( 3199 (u_MvpMatrix * vec3(a_Position, 1)).xy, 0, 1 3200 ); 3201 } 3202 `, WEBGL2_FRAGMENT_SHADER_DEMO); 3203 gl.useProgram(p.program); 3204 let u = gl.getUniformLocation(p.program, "u_MvpMatrix"); 3205 callback(u); 3206 let uniform = gl.getUniform(p.program, u); 3207 clear(gl); 3208 gl.drawArrays(gl.POINTS, 0, 1); 3209 gl.deleteShader(p.vertexShader); 3210 gl.deleteShader(p.fragmentShader); 3211 gl.deleteProgram(p.program); 3212 finish(); 3213 } 3214 /** 3215 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0143 3216 * @tc.name webgl2_test_uniformMatrix3fv 3217 * @tc.desc Test uniformMatrix3fv. 3218 */ 3219 it('webgl2_test_uniformMatrix3fv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 3220 console.info("webgl2test [webgl2_test_uniformMatrix3fv] uniformMatrix3fv"); 3221 let p = createProgram(gl, `#version 300 es 3222 in vec2 a_Position; 3223 uniform mat3 u_MvpMatrix; 3224 void main(){ 3225 gl_Position = vec4( 3226 (u_MvpMatrix * vec3(a_Position, 1)).xy, 0, 1 3227 ); 3228 } 3229 `, WEBGL2_FRAGMENT_SHADER_DEMO); 3230 gl.useProgram(p.program); 3231 let u = gl.getUniformLocation(p.program, "u_MvpMatrix"); 3232 gl.uniformMatrix3fv(u, false, new Float32Array([ 3233 3.0, -0.5, 1.0, 3234 0.0, 3.5, 1.0, 3235 1.0, -1.5, 1.0, 3236 0.0, 1.5, 1.0, 3237 ]), 3, 9); 3238 let value = gl.getUniform(p.program, u); 3239 console.info("webgltest", value); 3240 expect(value[0]).assertEqual(0.0); 3241 expect(value[1]).assertEqual(3.5); 3242 expect(value[2]).assertEqual(1.0); 3243 expect(value[3]).assertEqual(1.0); 3244 expect(value[4]).assertEqual(-1.5); 3245 expect(value[5]).assertEqual(1.0); 3246 expect(value[6]).assertEqual(0.0); 3247 expect(value[7]).assertEqual(1.5); 3248 expect(value[8]).assertEqual(1.0); 3249 clear(gl); 3250 gl.drawArrays(gl.POINTS, 0, 1); 3251 gl.deleteShader(p.vertexShader); 3252 gl.deleteShader(p.fragmentShader); 3253 gl.deleteProgram(p.program); 3254 checkError(gl); 3255 done(); 3256 }); 3257 /** 3258 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0144 3259 * @tc.name webgl2_test_uniformMatrix3fv_1 3260 * @tc.desc Test uniformMatrix3fv. 3261 */ 3262 it('webgl2_test_uniformMatrix3fv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 3263 async function (done) { 3264 console.info("webgl2test [webgl2_test_uniformMatrix3fv_1] uniformMatrix3fv"); 3265 uniformMatrix3fv((u) => { 3266 gl.uniformMatrix3fv(u, null, new Float32Array([ 3267 3.0, -0.5, 1.0, 3268 0.0, 3.5, 1.0, 3269 1.0, -1.5, 1.0, 3270 0.0, 1.5, 1.0, 3271 ]), 3, null); 3272 }, () => { 3273 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 3274 }); 3275 done(); 3276 }); 3277 /** 3278 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0145 3279 * @tc.name webgl2_test_uniformMatrix3fv_2 3280 * @tc.desc Test uniformMatrix3fv. 3281 */ 3282 it('webgl2_test_uniformMatrix3fv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 3283 async function (done) { 3284 console.info("webgl2test [webgl2_test_uniformMatrix3fv_2] uniformMatrix3fv"); 3285 uniformMatrix3fv((u) => { 3286 gl.uniformMatrix3fv(u, null, new Float32Array([ 3287 3.0, -0.5, 1.0, 3288 0.0, 3.5, 1.0, 3289 1.0, -1.5, 1.0, 3290 0.0, 1.5, 1.0, 3291 ]), 3, undefined); 3292 }, () => { 3293 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 3294 }); 3295 done(); 3296 }); 3297 /** 3298 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0146 3299 * @tc.name webgl2_test_uniformMatrix3fv_3 3300 * @tc.desc Test uniformMatrix3fv. 3301 */ 3302 it('webgl2_test_uniformMatrix3fv_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 3303 async function (done) { 3304 console.info("webgl2test [webgl2_test_uniformMatrix3fv_3] uniformMatrix3fv"); 3305 uniformMatrix3fv((u) => { 3306 gl.uniformMatrix3fv(u, null, new Float32Array([ 3307 3.0, -0.5, 1.0, 3308 0.0, 3.5, 1.0, 3309 1.0, -1.5, 1.0, 3310 0.0, 1.5, 1.0, 3311 ]), null, undefined); 3312 }, () => { 3313 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 3314 }); 3315 done(); 3316 }); 3317 /** 3318 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0147 3319 * @tc.name webgl2_test_uniformMatrix3fv_4 3320 * @tc.desc Test uniformMatrix3fv. 3321 */ 3322 it('webgl2_test_uniformMatrix3fv_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 3323 async function (done) { 3324 console.info("webgl2test [webgl2_test_uniformMatrix3fv_4] uniformMatrix3fv"); 3325 uniformMatrix3fv((u) => { 3326 gl.uniformMatrix3fv(u, null, new Float32Array([ 3327 3.0, -0.5, 1.0, 3328 0.0, 3.5, 1.0, 3329 1.0, -1.5, 1.0, 3330 0.0, 1.5, 1.0, 3331 ]), null, undefined); 3332 }, () => { 3333 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 3334 }); 3335 done(); 3336 }); 3337 /** 3338 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0148 3339 * @tc.name webgl2_test_uniformMatrix3fv_5 3340 * @tc.desc Test uniformMatrix3fv. 3341 */ 3342 it('webgl2_test_uniformMatrix3fv_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 3343 async function (done) { 3344 console.info("webgl2test [webgl2_test_uniformMatrix3fv_5] uniformMatrix3fv"); 3345 uniformMatrix3fv((u) => { 3346 gl.uniformMatrix3fv(null, null, new Float32Array([ 3347 3.0, -0.5, 1.0, 3348 0.0, 3.5, 1.0, 3349 1.0, -1.5, 1.0, 3350 0.0, 1.5, 1.0, 3351 ]), null, undefined); 3352 }, () => { 3353 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 3354 }); 3355 done(); 3356 }); 3357 function uniformMatrix4fv(callback, finish) { 3358 let p = createProgram(gl, `#version 300 es 3359 in vec4 a_Position; 3360 uniform mat4 u_MvpMatrix; 3361 void main(){ 3362 gl_Position = u_MvpMatrix * a_Position; 3363 } 3364 `, WEBGL2_FRAGMENT_SHADER_DEMO); 3365 gl.useProgram(p.program); 3366 let u = gl.getUniformLocation(p.program, "u_MvpMatrix"); 3367 callback(u); 3368 let uniform = gl.getUniform(p.program, u); 3369 clear(gl); 3370 gl.drawArrays(gl.POINTS, 0, 1); 3371 gl.deleteShader(p.vertexShader); 3372 gl.deleteShader(p.fragmentShader); 3373 gl.deleteProgram(p.program); 3374 finish(); 3375 } 3376 /** 3377 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0149 3378 * @tc.name webgl2_test_uniformMatrix4fv 3379 * @tc.desc Test uniformMatrix4fv. 3380 */ 3381 it('webgl2_test_uniformMatrix4fv', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function (done) { 3382 console.info("webgl2test [webgl2_test_uniformMatrix4fv] uniformMatrix4fv"); 3383 let p = createProgram(gl, `#version 300 es 3384 in vec4 a_Position; 3385 uniform mat4 u_MvpMatrix; 3386 void main(){ 3387 gl_Position = u_MvpMatrix * a_Position; 3388 } 3389 `, WEBGL2_FRAGMENT_SHADER_DEMO); 3390 gl.useProgram(p.program); 3391 let u = gl.getUniformLocation(p.program, "u_MvpMatrix"); 3392 gl.uniformMatrix4fv(u, false, new Float32Array([ 3393 1.0, 2.0, 3.0, 4.0, 3394 3.5, -0.5, -0.5, -0.5, 3395 0, 3.5, -0.5, -0.5, 3396 -1.0, -1.5, -2.0, -1.0, 3397 -3.0, -0.5, 6.0, 8.0 3398 ]), 4, 16); 3399 let value = gl.getUniform(p.program, u); 3400 console.info("webgltest", value); 3401 expect(value[0]).assertEqual(3.5); 3402 expect(value[1]).assertEqual(-0.5); 3403 expect(value[2]).assertEqual(-0.5); 3404 expect(value[3]).assertEqual(-0.5); 3405 expect(value[4]).assertEqual(0.0); 3406 expect(value[5]).assertEqual(3.5); 3407 expect(value[6]).assertEqual(-0.5); 3408 expect(value[7]).assertEqual(-0.5); 3409 expect(value[8]).assertEqual(-1.0); 3410 expect(value[9]).assertEqual(-1.5); 3411 expect(value[10]).assertEqual(-2.0); 3412 expect(value[11]).assertEqual(-1.0); 3413 expect(value[12]).assertEqual(-3.0); 3414 expect(value[13]).assertEqual(-0.5); 3415 expect(value[14]).assertEqual(6.0); 3416 expect(value[15]).assertEqual(8.0); 3417 clear(gl); 3418 gl.drawArrays(gl.POINTS, 0, 1); 3419 gl.deleteShader(p.vertexShader); 3420 gl.deleteShader(p.fragmentShader); 3421 gl.deleteProgram(p.program); 3422 checkError(gl); 3423 done(); 3424 }); 3425 /** 3426 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0150 3427 * @tc.name webgl2_test_uniformMatrix4fv_1 3428 * @tc.desc Test uniformMatrix4fv. 3429 */ 3430 it('webgl2_test_uniformMatrix4fv_1', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 3431 async function (done) { 3432 console.info("webgl2test [webgl2_test_uniformMatrix4fv_1] uniformMatrix4fv"); 3433 uniformMatrix4fv((u) => { 3434 gl.uniformMatrix4fv(u, null, new Float32Array([ 3435 1.0, 2.0, 3.0, 4.0, 3436 3.5, -0.5, -0.5, -0.5, 3437 0, 3.5, -0.5, -0.5, 3438 -1.0, -1.5, -2.0, -1.0, 3439 -3.0, -0.5, 6.0, 8.0 3440 ]), 4, null); 3441 }, () => { 3442 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 3443 }); 3444 done(); 3445 }); 3446 /** 3447 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0151 3448 * @tc.name webgl2_test_uniformMatrix4fv_2 3449 * @tc.desc Test uniformMatrix4fv. 3450 */ 3451 it('webgl2_test_uniformMatrix4fv_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 3452 async function (done) { 3453 console.info("webgl2test [webgl2_test_uniformMatrix4fv_2] uniformMatrix4fv"); 3454 uniformMatrix4fv((u) => { 3455 gl.uniformMatrix4fv(u, null, new Float32Array([ 3456 1.0, 2.0, 3.0, 4.0, 3457 3.5, -0.5, -0.5, -0.5, 3458 0, 3.5, -0.5, -0.5, 3459 -1.0, -1.5, -2.0, -1.0, 3460 -3.0, -0.5, 6.0, 8.0 3461 ]), 4, undefined); 3462 }, () => { 3463 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 3464 }); 3465 done(); 3466 }); 3467 /** 3468 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0152 3469 * @tc.name webgl2_test_uniformMatrix4fv_3 3470 * @tc.desc Test uniformMatrix4fv. 3471 */ 3472 it('webgl2_test_uniformMatrix4fv_3', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 3473 async function (done) { 3474 console.info("webgl2test [webgl2_test_uniformMatrix4fv_3] uniformMatrix4fv"); 3475 uniformMatrix4fv((u) => { 3476 gl.uniformMatrix4fv(u, null, new Float32Array([ 3477 1.0, 2.0, 3.0, 4.0, 3478 3.5, -0.5, -0.5, -0.5, 3479 0, 3.5, -0.5, -0.5, 3480 -1.0, -1.5, -2.0, -1.0, 3481 -3.0, -0.5, 6.0, 8.0 3482 ]), null, undefined); 3483 }, () => { 3484 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 3485 }); 3486 done(); 3487 }); 3488 /** 3489 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0153 3490 * @tc.name webgl2_test_uniformMatrix4fv_4 3491 * @tc.desc Test uniformMatrix4fv. 3492 */ 3493 it('webgl2_test_uniformMatrix4fv_4', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 3494 async function (done) { 3495 console.info("webgl2test [webgl2_test_uniformMatrix4fv_4] uniformMatrix4fv"); 3496 uniformMatrix4fv((u) => { 3497 gl.uniformMatrix4fv(u, null, new Float32Array([ 3498 1.0, 2.0, 3.0, 4.0, 3499 3.5, -0.5, -0.5, -0.5, 3500 0, 3.5, -0.5, -0.5, 3501 -1.0, -1.5, -2.0, -1.0, 3502 -3.0, -0.5, 6.0, 8.0 3503 ]), null, undefined); 3504 }, () => { 3505 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 3506 }); 3507 done(); 3508 }); 3509 /** 3510 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0154 3511 * @tc.name webgl2_test_uniformMatrix4fv_5 3512 * @tc.desc Test uniformMatrix4fv. 3513 */ 3514 it('webgl2_test_uniformMatrix4fv_5', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, 3515 async function (done) { 3516 console.info("webgl2test [webgl2_test_uniformMatrix4fv_5] uniformMatrix4fv"); 3517 uniformMatrix4fv((u) => { 3518 gl.uniformMatrix4fv(null, null, new Float32Array([ 3519 1.0, 2.0, 3.0, 4.0, 3520 3.5, -0.5, -0.5, -0.5, 3521 0, 3.5, -0.5, -0.5, 3522 -1.0, -1.5, -2.0, -1.0, 3523 -3.0, -0.5, 6.0, 8.0 3524 ]), null, undefined); 3525 }, () => { 3526 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 3527 }); 3528 done(); 3529 }); 3530 }) 3531} 3532