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 } 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, 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', 0, async function (done) { 1187 console.info("webgl2test [webgl2_test_uniformMatrix3x2fv] uniformMatrix3x2fv"); 1188 let p = createProgram(gl, `#version 300 es 1189 in vec3 a_position; 1190 uniform mat3x2 m32; 1191 void main(){ 1192 vec2 transformedPosition = (m32 * a_position).xy; 1193 gl_Position = vec4(transformedPosition, 0.0, 1.0); 1194 } 1195 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1196 gl.useProgram(p.program); 1197 let m32 = gl.getUniformLocation(p.program, "m32"); 1198 gl.uniformMatrix3x2fv(m32, false, new Float32Array([ 1199 1.5, 1.5, 1200 1.0, 0.0, 1201 0.0, 1.0, 1202 0.0, 0.0 1203 ]), 2, 6); 1204 let uniform = gl.getUniform(p.program, m32); 1205 console.info("webgltest", uniform); 1206 expect(uniform[0]).assertEqual(1.0); 1207 expect(uniform[1]).assertEqual(0.0); 1208 expect(uniform[2]).assertEqual(0.0); 1209 expect(uniform[3]).assertEqual(1.0); 1210 expect(uniform[4]).assertEqual(0.0); 1211 expect(uniform[5]).assertEqual(0.0); 1212 clear(gl); 1213 gl.drawArrays(gl.POINTS, 0, 1); 1214 gl.deleteShader(p.vertexShader); 1215 gl.deleteShader(p.fragmentShader); 1216 gl.deleteProgram(p.program); 1217 checkError(gl); 1218 done(); 1219 }); 1220 /** 1221 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0059 1222 * @tc.name webgl2_test_uniformMatrix3x2fv_1 1223 * @tc.desc Test uniformMatrix3x2fv. 1224 */ 1225 it('webgl2_test_uniformMatrix3x2fv_1', 0, async function (done) { 1226 console.info("webgl2test [webgl2_test_uniformMatrix3x2fv_1] uniformMatrix3x2fv"); 1227 uniformMatrix3x2fv((m32) => { 1228 gl.uniformMatrix3x2fv(m32, null, new Float32Array([ 1229 1.5, 1.5, 1230 1.0, 0.0, 1231 0.0, 1.0, 1232 0.0, 0.0 1233 ]), 2, 6); 1234 }, () => { 1235 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1236 }); 1237 done(); 1238 }); 1239 /** 1240 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0060 1241 * @tc.name webgl2_test_uniformMatrix3x2fv_2 1242 * @tc.desc Test uniformMatrix3x2fv. 1243 */ 1244 it('webgl2_test_uniformMatrix3x2fv_2', 0, async function (done) { 1245 console.info("webgl2test [webgl2_test_uniformMatrix3x2fv_2] uniformMatrix3x2fv"); 1246 uniformMatrix3x2fv((m32) => { 1247 gl.uniformMatrix3x2fv(m32, null, new Float32Array([ 1248 1.5, 1.5, 1249 1.0, 0.0, 1250 0.0, 1.0, 1251 0.0, 0.0 1252 ]), null, 6); 1253 }, () => { 1254 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1255 }); 1256 done(); 1257 }); 1258 /** 1259 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0061 1260 * @tc.name webgl2_test_uniformMatrix3x2fv_3 1261 * @tc.desc Test uniformMatrix3x2fv. 1262 */ 1263 it('webgl2_test_uniformMatrix3x2fv_3', 0, async function (done) { 1264 console.info("webgl2test [webgl2_test_uniformMatrix3x2fv_3] uniformMatrix3x2fv"); 1265 uniformMatrix3x2fv((m32) => { 1266 gl.uniformMatrix3x2fv(m32, null, new Float32Array([ 1267 1.5, 1.5, 1268 1.0, 0.0, 1269 0.0, 1.0, 1270 0.0, 0.0 1271 ]), null, null); 1272 }, () => { 1273 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1274 }); 1275 done(); 1276 }); 1277 /** 1278 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0062 1279 * @tc.name webgl2_test_uniformMatrix3x2fv_4 1280 * @tc.desc Test uniformMatrix3x2fv. 1281 */ 1282 it('webgl2_test_uniformMatrix3x2fv_4', 0, async function (done) { 1283 console.info("webgl2test [webgl2_test_uniformMatrix3x2fv_4] uniformMatrix3x2fv"); 1284 uniformMatrix3x2fv((m32) => { 1285 gl.uniformMatrix3x2fv(m32, null, new Float32Array([ 1286 1.5, 1.5, 1287 1.0, 0.0, 1288 0.0, 1.0, 1289 0.0, 0.0 1290 ]), undefined, undefined); 1291 }, () => { 1292 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1293 }); 1294 done(); 1295 }); 1296 /** 1297 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0063 1298 * @tc.name webgl2_test_uniformMatrix3x2fv_5 1299 * @tc.desc Test uniformMatrix3x2fv. 1300 */ 1301 it('webgl2_test_uniformMatrix3x2fv_5', 0, async function (done) { 1302 console.info("webgl2test [webgl2_test_uniformMatrix3x2fv_5] uniformMatrix3x2fv"); 1303 uniformMatrix3x2fv((m32) => { 1304 gl.uniformMatrix3x2fv(null, null, new Float32Array([ 1305 1.5, 1.5, 1306 1.0, 0.0, 1307 0.0, 1.0, 1308 0.0, 0.0 1309 ]), undefined, undefined); 1310 }, () => { 1311 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1312 }); 1313 done(); 1314 }); 1315 function uniformMatrix4x2fv(callback, finish) { 1316 let p = createProgram(gl, `#version 300 es 1317 in vec4 a_position; 1318 uniform mat4x2 m42; 1319 void main(){ 1320 vec2 transformedPosition = (m42 * a_position).xy; 1321 gl_Position = vec4(transformedPosition, 0.0, 1.0); 1322 } 1323 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1324 gl.useProgram(p.program); 1325 let m42 = gl.getUniformLocation(p.program, "m42"); 1326 callback(m42); 1327 let uniform = gl.getUniform(p.program, m42); 1328 clear(gl); 1329 gl.drawArrays(gl.POINTS, 0, 1); 1330 gl.deleteShader(p.vertexShader); 1331 gl.deleteShader(p.fragmentShader); 1332 gl.deleteProgram(p.program); 1333 finish(); 1334 } 1335 /** 1336 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0064 1337 * @tc.name webgl2_test_uniformMatrix4x2fv 1338 * @tc.desc Test uniformMatrix4x2fv. 1339 */ 1340 it('webgl2_test_uniformMatrix4x2fv', 0, async function (done) { 1341 console.info("webgl2test [webgl2_test_uniformMatrix4x2fv] uniformMatrix4x2fv"); 1342 let p = createProgram(gl, `#version 300 es 1343 in vec4 a_position; 1344 uniform mat4x2 m42; 1345 void main(){ 1346 vec2 transformedPosition = (m42 * a_position).xy; 1347 gl_Position = vec4(transformedPosition, 0.0, 1.0); 1348 } 1349 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1350 gl.useProgram(p.program); 1351 let m42 = gl.getUniformLocation(p.program, "m42"); 1352 gl.uniformMatrix4x2fv(m42, false, new Float32Array([ 1353 1.5, 1.5, 1354 1.0, 0.0, 1355 0.0, 1.0, 1356 0.0, 0.0, 1357 0.0, 0.0, 1358 ]), 2, 8); 1359 let uniform = gl.getUniform(p.program, m42); 1360 console.info("webgltest", uniform); 1361 expect(uniform[0]).assertEqual(1.0); 1362 expect(uniform[1]).assertEqual(0.0); 1363 expect(uniform[2]).assertEqual(0.0); 1364 expect(uniform[3]).assertEqual(1.0); 1365 expect(uniform[4]).assertEqual(0.0); 1366 expect(uniform[5]).assertEqual(0.0); 1367 expect(uniform[6]).assertEqual(0.0); 1368 expect(uniform[7]).assertEqual(0.0); 1369 clear(gl); 1370 gl.drawArrays(gl.POINTS, 0, 1); 1371 gl.deleteShader(p.vertexShader); 1372 gl.deleteShader(p.fragmentShader); 1373 gl.deleteProgram(p.program); 1374 checkError(gl); 1375 done(); 1376 }); 1377 /** 1378 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0065 1379 * @tc.name webgl2_test_uniformMatrix4x2fv_1 1380 * @tc.desc Test uniformMatrix4x2fv. 1381 */ 1382 it('webgl2_test_uniformMatrix4x2fv_1', 0, async function (done) { 1383 console.info("webgl2test [webgl2_test_uniformMatrix4x2fv_1] uniformMatrix4x2fv"); 1384 uniformMatrix4x2fv((m42) => { 1385 gl.uniformMatrix4x2fv(m42, null, new Float32Array([ 1386 1.5, 1.5, 1387 1.0, 0.0, 1388 0.0, 1.0, 1389 0.0, 0.0, 1390 0.0, 0.0, 1391 ]), 2, 6); 1392 }, () => { 1393 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1394 }); 1395 done(); 1396 }); 1397 /** 1398 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0066 1399 * @tc.name webgl2_test_uniformMatrix4x2fv_2 1400 * @tc.desc Test uniformMatrix4x2fv. 1401 */ 1402 it('webgl2_test_uniformMatrix4x2fv_2', 0, async function (done) { 1403 console.info("webgl2test [webgl2_test_uniformMatrix4x2fv_2] uniformMatrix4x2fv"); 1404 uniformMatrix4x2fv((m42) => { 1405 gl.uniformMatrix4x2fv(m42, null, new Float32Array([ 1406 1.5, 1.5, 1407 1.0, 0.0, 1408 0.0, 1.0, 1409 0.0, 0.0, 1410 0.0, 0.0, 1411 ]), null, 6); 1412 }, () => { 1413 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1414 }); 1415 done(); 1416 }); 1417 /** 1418 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0067 1419 * @tc.name webgl2_test_uniformMatrix4x2fv_3 1420 * @tc.desc Test uniformMatrix4x2fv. 1421 */ 1422 it('webgl2_test_uniformMatrix4x2fv_3', 0, async function (done) { 1423 console.info("webgl2test [webgl2_test_uniformMatrix4x2fv_3] uniformMatrix4x2fv"); 1424 uniformMatrix4x2fv((m42) => { 1425 gl.uniformMatrix4x2fv(m42, null, new Float32Array([ 1426 1.5, 1.5, 1427 1.0, 0.0, 1428 0.0, 1.0, 1429 0.0, 0.0, 1430 0.0, 0.0, 1431 ]), null, null); 1432 }, () => { 1433 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1434 }); 1435 done(); 1436 }); 1437 /** 1438 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0068 1439 * @tc.name webgl2_test_uniformMatrix4x2fv_4 1440 * @tc.desc Test uniformMatrix4x2fv. 1441 */ 1442 it('webgl2_test_uniformMatrix4x2fv_4', 0, async function (done) { 1443 console.info("webgl2test [webgl2_test_uniformMatrix4x2fv_4] uniformMatrix4x2fv"); 1444 uniformMatrix4x2fv((m42) => { 1445 gl.uniformMatrix4x2fv(m42, null, new Float32Array([ 1446 1.5, 1.5, 1447 1.0, 0.0, 1448 0.0, 1.0, 1449 0.0, 0.0, 1450 0.0, 0.0, 1451 ]), undefined, undefined); 1452 }, () => { 1453 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1454 }); 1455 done(); 1456 }); 1457 function uniformMatrix2x3fv(callback, finish) { 1458 let p = createProgram(gl, `#version 300 es 1459 in vec2 a_position; 1460 uniform mat2x3 m23; 1461 void main(){ 1462 vec3 transformedPosition = (m23 * a_position).xyz; 1463 gl_Position = vec4(transformedPosition, 1.0); 1464 } 1465 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1466 gl.useProgram(p.program); 1467 let m23 = gl.getUniformLocation(p.program, "m23"); 1468 callback(m23); 1469 let uniform = gl.getUniform(p.program, m23); 1470 clear(gl); 1471 gl.drawArrays(gl.POINTS, 0, 1); 1472 gl.deleteShader(p.vertexShader); 1473 gl.deleteShader(p.fragmentShader); 1474 gl.deleteProgram(p.program); 1475 finish(); 1476 } 1477 /** 1478 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0069 1479 * @tc.name webgl2_test_uniformMatrix2x3fv 1480 * @tc.desc Test uniformMatrix2x3fv. 1481 */ 1482 it('webgl2_test_uniformMatrix2x3fv', 0, async function (done) { 1483 console.info("webgl2test [webgl2_test_uniformMatrix2x3fv] uniformMatrix2x3fv"); 1484 let p = createProgram(gl, `#version 300 es 1485 in vec2 a_position; 1486 uniform mat2x3 m23; 1487 void main(){ 1488 vec3 transformedPosition = (m23 * a_position).xyz; 1489 gl_Position = vec4(transformedPosition, 1.0); 1490 } 1491 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1492 gl.useProgram(p.program); 1493 let m23 = gl.getUniformLocation(p.program, "m23"); 1494 gl.uniformMatrix2x3fv(m23, false, new Float32Array([ 1495 1.5, 1.5, 1.5, 1496 1.0, 0.0, 0.0, 1497 1.0, 0.0, 1.0, 1498 ]), 3, 6); 1499 let uniform = gl.getUniform(p.program, m23); 1500 console.info("webgltest", uniform); 1501 expect(uniform[0]).assertEqual(1.0); 1502 expect(uniform[1]).assertEqual(0.0); 1503 expect(uniform[2]).assertEqual(0.0); 1504 expect(uniform[3]).assertEqual(1.0); 1505 expect(uniform[4]).assertEqual(0.0); 1506 expect(uniform[5]).assertEqual(1.0); 1507 clear(gl); 1508 gl.drawArrays(gl.POINTS, 0, 1); 1509 gl.deleteShader(p.vertexShader); 1510 gl.deleteShader(p.fragmentShader); 1511 gl.deleteProgram(p.program); 1512 checkError(gl); 1513 done(); 1514 }); 1515 /** 1516 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0070 1517 * @tc.name webgl2_test_uniformMatrix2x3fv_1 1518 * @tc.desc Test uniformMatrix2x3fv. 1519 */ 1520 it('webgl2_test_uniformMatrix2x3fv_1', 0, async function (done) { 1521 console.info("webgl2test [webgl2_test_uniformMatrix2x3fv_1] uniformMatrix2x3fv"); 1522 uniformMatrix2x3fv((m23) => { 1523 gl.uniformMatrix2x3fv(m23, null, new Float32Array([ 1524 1.5, 1.5, 1.5, 1525 1.0, 0.0, 0.0, 1526 1.0, 0.0, 1.0, 1527 ]), 3, 6); 1528 }, () => { 1529 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1530 }); 1531 done(); 1532 }); 1533 /** 1534 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0071 1535 * @tc.name webgl2_test_uniformMatrix2x3fv_2 1536 * @tc.desc Test uniformMatrix2x3fv. 1537 */ 1538 it('webgl2_test_uniformMatrix2x3fv_2', 0, async function (done) { 1539 console.info("webgl2test [webgl2_test_uniformMatrix2x3fv_2] uniformMatrix2x3fv"); 1540 uniformMatrix2x3fv((m23) => { 1541 gl.uniformMatrix2x3fv(m23, null, new Float32Array([ 1542 1.5, 1.5, 1.5, 1543 1.0, 0.0, 0.0, 1544 1.0, 0.0, 1.0, 1545 ]), null, 6); 1546 }, () => { 1547 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1548 }); 1549 done(); 1550 }); 1551 /** 1552 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0072 1553 * @tc.name webgl2_test_uniformMatrix2x3fv_3 1554 * @tc.desc Test uniformMatrix2x3fv. 1555 */ 1556 it('webgl2_test_uniformMatrix2x3fv_3', 0, async function (done) { 1557 console.info("webgl2test [webgl2_test_uniformMatrix2x3fv_3] uniformMatrix2x3fv"); 1558 uniformMatrix2x3fv((m23) => { 1559 gl.uniformMatrix2x3fv(m23, null, new Float32Array([ 1560 1.5, 1.5, 1.5, 1561 1.0, 0.0, 0.0, 1562 1.0, 0.0, 1.0, 1563 ]), null, null); 1564 }, () => { 1565 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1566 }); 1567 done(); 1568 }); 1569 /** 1570 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0073 1571 * @tc.name webgl2_test_uniformMatrix2x3fv_4 1572 * @tc.desc Test uniformMatrix2x3fv. 1573 */ 1574 it('webgl2_test_uniformMatrix2x3fv_4', 0, async function (done) { 1575 console.info("webgl2test [webgl2_test_uniformMatrix2x3fv_4] uniformMatrix2x3fv"); 1576 uniformMatrix2x3fv((m23) => { 1577 gl.uniformMatrix2x3fv(m23, null, new Float32Array([ 1578 1.5, 1.5, 1.5, 1579 1.0, 0.0, 0.0, 1580 1.0, 0.0, 1.0, 1581 ]), undefined, undefined); 1582 }, () => { 1583 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1584 }); 1585 done(); 1586 }); 1587 function uniformMatrix4x3fv(callback, finish) { 1588 let p = createProgram(gl, `#version 300 es 1589 in vec4 a_position; 1590 uniform mat4x3 m43; 1591 void main(){ 1592 vec3 transformedPosition = (m43 * a_position).xyz; 1593 gl_Position = vec4(transformedPosition, 1.0); 1594 } 1595 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1596 gl.useProgram(p.program); 1597 let m43 = gl.getUniformLocation(p.program, "m43"); 1598 callback(m43); 1599 let uniform = gl.getUniform(p.program, m43); 1600 clear(gl); 1601 gl.drawArrays(gl.POINTS, 0, 1); 1602 gl.deleteShader(p.vertexShader); 1603 gl.deleteShader(p.fragmentShader); 1604 gl.deleteProgram(p.program); 1605 finish(); 1606 } 1607 /** 1608 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0074 1609 * @tc.name webgl2_test_uniformMatrix4x3fv 1610 * @tc.desc Test uniformMatrix4x3fv. 1611 */ 1612 it('webgl2_test_uniformMatrix4x3fv', 0, async function (done) { 1613 console.info("webgl2test [webgl2_test_uniformMatrix4x3fv] uniformMatrix4x3fv"); 1614 let p = createProgram(gl, `#version 300 es 1615 in vec4 a_position; 1616 uniform mat4x3 m43; 1617 void main(){ 1618 vec3 transformedPosition = (m43 * a_position).xyz; 1619 gl_Position = vec4(transformedPosition, 1.0); 1620 } 1621 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1622 gl.useProgram(p.program); 1623 let m43 = gl.getUniformLocation(p.program, "m43"); 1624 gl.uniformMatrix4x3fv(m43, false, new Float32Array([ 1625 1.5, 1.5, 1.5, 1626 1.0, 0.0, 0.0, 1627 1.0, 0.0, 1.0, 1628 1.0, 0.0, 1.0, 1629 1.0, 0.0, 1.0, 1630 ]), 3, 12); 1631 let uniform = gl.getUniform(p.program, m43); 1632 console.info("webgltest", uniform); 1633 expect(uniform[0]).assertEqual(1.0); 1634 expect(uniform[1]).assertEqual(0.0); 1635 expect(uniform[2]).assertEqual(0.0); 1636 expect(uniform[3]).assertEqual(1.0); 1637 expect(uniform[4]).assertEqual(0.0); 1638 expect(uniform[5]).assertEqual(1.0); 1639 expect(uniform[6]).assertEqual(1.0); 1640 expect(uniform[7]).assertEqual(0.0); 1641 expect(uniform[8]).assertEqual(1.0); 1642 expect(uniform[9]).assertEqual(1.0); 1643 expect(uniform[10]).assertEqual(0.0); 1644 expect(uniform[11]).assertEqual(1.0); 1645 clear(gl); 1646 gl.drawArrays(gl.POINTS, 0, 1); 1647 gl.deleteShader(p.vertexShader); 1648 gl.deleteShader(p.fragmentShader); 1649 gl.deleteProgram(p.program); 1650 checkError(gl); 1651 done(); 1652 }); 1653 /** 1654 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0075 1655 * @tc.name webgl2_test_uniformMatrix4x3fv_1 1656 * @tc.desc Test uniformMatrix4x3fv. 1657 */ 1658 it('webgl2_test_uniformMatrix4x3fv_1', 0, async function (done) { 1659 console.info("webgl2test [webgl2_test_uniformMatrix4x3fv_1] uniformMatrix4x3fv"); 1660 uniformMatrix4x3fv((m) => { 1661 gl.uniformMatrix4x3fv(m, null, new Float32Array([ 1662 1.5, 1.5, 1.5, 1663 1.0, 0.0, 0.0, 1664 1.0, 0.0, 1.0, 1665 1.0, 0.0, 1.0, 1666 1.0, 0.0, 1.0, 1667 ]), 3, 6); 1668 }, () => { 1669 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1670 }); 1671 done(); 1672 }); 1673 /** 1674 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0076 1675 * @tc.name webgl2_test_uniformMatrix4x3fv_2 1676 * @tc.desc Test uniformMatrix4x3fv. 1677 */ 1678 it('webgl2_test_uniformMatrix4x3fv_2', 0, async function (done) { 1679 console.info("webgl2test [webgl2_test_uniformMatrix4x3fv_2] uniformMatrix4x3fv"); 1680 uniformMatrix4x3fv((m) => { 1681 gl.uniformMatrix4x3fv(m, null, new Float32Array([ 1682 1.5, 1.5, 1.5, 1683 1.0, 0.0, 0.0, 1684 1.0, 0.0, 1.0, 1685 1.0, 0.0, 1.0, 1686 1.0, 0.0, 1.0, 1687 ]), null, 6); 1688 }, () => { 1689 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1690 }); 1691 done(); 1692 }); 1693 /** 1694 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0077 1695 * @tc.name webgl2_test_uniformMatrix4x3fv_3 1696 * @tc.desc Test uniformMatrix4x3fv. 1697 */ 1698 it('webgl2_test_uniformMatrix4x3fv_3', 0, async function (done) { 1699 console.info("webgl2test [webgl2_test_uniformMatrix4x3fv_3] uniformMatrix4x3fv"); 1700 uniformMatrix4x3fv((m) => { 1701 gl.uniformMatrix4x3fv(m, null, new Float32Array([ 1702 1.5, 1.5, 1.5, 1703 1.0, 0.0, 0.0, 1704 1.0, 0.0, 1.0, 1705 1.0, 0.0, 1.0, 1706 1.0, 0.0, 1.0, 1707 ]), null, null); 1708 }, () => { 1709 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1710 }); 1711 done(); 1712 }); 1713 /** 1714 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0078 1715 * @tc.name webgl2_test_uniformMatrix4x3fv_4 1716 * @tc.desc Test uniformMatrix4x3fv. 1717 */ 1718 it('webgl2_test_uniformMatrix4x3fv_4', 0, async function (done) { 1719 console.info("webgl2test [webgl2_test_uniformMatrix4x3fv_4] 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 ]), undefined, undefined); 1728 }, () => { 1729 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1730 }); 1731 done(); 1732 }); 1733 function uniformMatrix2x4fv(callback, finish) { 1734 let p = createProgram(gl, `#version 300 es 1735 in vec2 a_position; 1736 uniform mat2x4 m24; 1737 void main(){ 1738 vec3 transformedPosition = (m24 * a_position).xyz; 1739 gl_Position = vec4(transformedPosition, 1.0); 1740 } 1741 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1742 gl.useProgram(p.program); 1743 let m24 = gl.getUniformLocation(p.program, "m24"); 1744 callback(m24); 1745 let uniform = gl.getUniform(p.program, m24); 1746 clear(gl); 1747 gl.drawArrays(gl.POINTS, 0, 1); 1748 gl.deleteShader(p.vertexShader); 1749 gl.deleteShader(p.fragmentShader); 1750 gl.deleteProgram(p.program); 1751 finish(); 1752 } 1753 /** 1754 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0079 1755 * @tc.name webgl2_test_uniformMatrix2x4fv 1756 * @tc.desc Test uniformMatrix2x4fv. 1757 */ 1758 it('webgl2_test_uniformMatrix2x4fv', 0, async function (done) { 1759 console.info("webgl2test [webgl2_test_uniformMatrix2x4fv] uniformMatrix2x4fv"); 1760 let p = createProgram(gl, `#version 300 es 1761 in vec2 a_position; 1762 uniform mat2x4 m24; 1763 void main(){ 1764 vec3 transformedPosition = (m24 * a_position).xyz; 1765 gl_Position = vec4(transformedPosition, 1.0); 1766 } 1767 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1768 gl.useProgram(p.program); 1769 let m24 = gl.getUniformLocation(p.program, "m24"); 1770 gl.uniformMatrix2x4fv(m24, false, new Float32Array([ 1771 1.5, 1.5, 1.5, 1.5, 1772 1.0, 0.0, 0.0, 1.0, 1773 1.0, 0.0, 0.0, 1.0, 1774 ]), 4, 8); 1775 let uniform = gl.getUniform(p.program, m24); 1776 console.info("webgltest", uniform); 1777 expect(uniform[0]).assertEqual(1.0); 1778 expect(uniform[1]).assertEqual(0.0); 1779 expect(uniform[2]).assertEqual(0.0); 1780 expect(uniform[3]).assertEqual(1.0); 1781 expect(uniform[4]).assertEqual(1.0); 1782 expect(uniform[5]).assertEqual(0.0); 1783 expect(uniform[6]).assertEqual(0.0); 1784 expect(uniform[7]).assertEqual(1.0); 1785 clear(gl); 1786 gl.drawArrays(gl.POINTS, 0, 1); 1787 gl.deleteShader(p.vertexShader); 1788 gl.deleteShader(p.fragmentShader); 1789 gl.deleteProgram(p.program); 1790 checkError(gl); 1791 done(); 1792 }); 1793 /** 1794 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0080 1795 * @tc.name webgl2_test_uniformMatrix2x4fv_1 1796 * @tc.desc Test uniformMatrix2x4fv. 1797 */ 1798 it('webgl2_test_uniformMatrix2x4fv_1', 0, async function (done) { 1799 console.info("webgl2test [webgl2_test_uniformMatrix2x4fv_1] uniformMatrix2x4fv"); 1800 uniformMatrix2x4fv((m) => { 1801 gl.uniformMatrix2x4fv(m, null, new Float32Array([ 1802 1.5, 1.5, 1.5, 1.5, 1803 1.0, 0.0, 0.0, 1.0, 1804 1.0, 0.0, 0.0, 1.0, 1805 ]), 3, 6); 1806 }, () => { 1807 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1808 }); 1809 done(); 1810 }); 1811 /** 1812 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0081 1813 * @tc.name webgl2_test_uniformMatrix2x4fv_2 1814 * @tc.desc Test uniformMatrix2x4fv. 1815 */ 1816 it('webgl2_test_uniformMatrix2x4fv_2', 0, async function (done) { 1817 console.info("webgl2test [webgl2_test_uniformMatrix2x4fv_2] uniformMatrix2x4fv"); 1818 uniformMatrix2x4fv((m) => { 1819 gl.uniformMatrix2x4fv(m, null, new Float32Array([ 1820 1.5, 1.5, 1.5, 1.5, 1821 1.0, 0.0, 0.0, 1.0, 1822 1.0, 0.0, 0.0, 1.0, 1823 ]), null, 6); 1824 }, () => { 1825 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1826 }); 1827 done(); 1828 }); 1829 /** 1830 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0082 1831 * @tc.name webgl2_test_uniformMatrix2x4fv_3 1832 * @tc.desc Test uniformMatrix2x4fv. 1833 */ 1834 it('webgl2_test_uniformMatrix2x4fv_3', 0, async function (done) { 1835 console.info("webgl2test [webgl2_test_uniformMatrix2x4fv_3] uniformMatrix2x4fv"); 1836 uniformMatrix2x4fv((m) => { 1837 gl.uniformMatrix2x4fv(m, null, new Float32Array([ 1838 1.5, 1.5, 1.5, 1.5, 1839 1.0, 0.0, 0.0, 1.0, 1840 1.0, 0.0, 0.0, 1.0, 1841 ]), null, null); 1842 }, () => { 1843 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1844 }); 1845 done(); 1846 }); 1847 /** 1848 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0083 1849 * @tc.name webgl2_test_uniformMatrix2x4fv_4 1850 * @tc.desc Test uniformMatrix2x4fv. 1851 */ 1852 it('webgl2_test_uniformMatrix2x4fv_4', 0, async function (done) { 1853 console.info("webgl2test [webgl2_test_uniformMatrix2x4fv_4] uniformMatrix2x4fv"); 1854 uniformMatrix2x4fv((m) => { 1855 gl.uniformMatrix2x4fv(m, null, new Float32Array([ 1856 1.5, 1.5, 1.5, 1.5, 1857 1.0, 0.0, 0.0, 1.0, 1858 1.0, 0.0, 0.0, 1.0, 1859 ]), undefined, undefined); 1860 }, () => { 1861 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1862 }); 1863 done(); 1864 }); 1865 function uniformMatrix3x4fv(callback, finish) { 1866 let p = createProgram(gl, `#version 300 es 1867 in vec3 a_position; 1868 uniform mat3x4 m34; 1869 void main(){ 1870 vec3 transformedPosition = (m34 * a_position).xyz; 1871 gl_Position = vec4(transformedPosition, 1.0); 1872 } 1873 `, WEBGL2_FRAGMENT_SHADER_DEMO); 1874 gl.useProgram(p.program); 1875 let m34 = gl.getUniformLocation(p.program, "m34"); 1876 callback(m34); 1877 let uniform = gl.getUniform(p.program, m34); 1878 clear(gl); 1879 gl.drawArrays(gl.POINTS, 0, 1); 1880 gl.deleteShader(p.vertexShader); 1881 gl.deleteShader(p.fragmentShader); 1882 gl.deleteProgram(p.program); 1883 finish(); 1884 } 1885 /** 1886 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0084 1887 * @tc.name webgl2_test_uniformMatrix3x4fv 1888 * @tc.desc Test uniformMatrix3x4fv. 1889 */ 1890 it('webgl2_test_uniformMatrix3x4fv', 0, async function (done) { 1891 console.info("webgl2test [webgl2_test_uniformMatrix3x4fv] uniformMatrix3x4fv"); 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 gl.uniformMatrix3x4fv(m34, false, new Float32Array([ 1903 1.5, 1.5, 1.5, 1.5, 1904 1.0, 0.0, 0.0, 1.0, 1905 1.0, 0.0, 0.0, 1.0, 1906 1.0, 0.0, 0.0, 1.0, 1907 ]), 4, 12); 1908 let uniform = gl.getUniform(p.program, m34); 1909 console.info("webgltest", uniform); 1910 expect(uniform[0]).assertEqual(1.0); 1911 expect(uniform[1]).assertEqual(0.0); 1912 expect(uniform[2]).assertEqual(0.0); 1913 expect(uniform[3]).assertEqual(1.0); 1914 expect(uniform[4]).assertEqual(1.0); 1915 expect(uniform[5]).assertEqual(0.0); 1916 expect(uniform[6]).assertEqual(0.0); 1917 expect(uniform[7]).assertEqual(1.0); 1918 clear(gl); 1919 gl.drawArrays(gl.POINTS, 0, 1); 1920 gl.deleteShader(p.vertexShader); 1921 gl.deleteShader(p.fragmentShader); 1922 gl.deleteProgram(p.program); 1923 checkError(gl); 1924 done(); 1925 }); 1926 /** 1927 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0085 1928 * @tc.name webgl2_test_uniformMatrix3x4fv_1 1929 * @tc.desc Test uniformMatrix3x4fv. 1930 */ 1931 it('webgl2_test_uniformMatrix3x4fv_1', 0, async function (done) { 1932 console.info("webgl2test [webgl2_test_uniformMatrix3x4fv_1] uniformMatrix3x4fv"); 1933 uniformMatrix3x4fv((m) => { 1934 gl.uniformMatrix3x4fv(m, null, new Float32Array([ 1935 1.5, 1.5, 1.5, 1.5, 1936 1.0, 0.0, 0.0, 1.0, 1937 1.0, 0.0, 0.0, 1.0, 1938 1.0, 0.0, 0.0, 1.0, 1939 ]), 3, 6); 1940 }, () => { 1941 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1942 }); 1943 done(); 1944 }); 1945 /** 1946 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0086 1947 * @tc.name webgl2_test_uniformMatrix3x4fv_2 1948 * @tc.desc Test uniformMatrix3x4fv. 1949 */ 1950 it('webgl2_test_uniformMatrix3x4fv_2', 0, async function (done) { 1951 console.info("webgl2test [webgl2_test_uniformMatrix3x4fv_2] uniformMatrix3x4fv"); 1952 uniformMatrix3x4fv((m) => { 1953 gl.uniformMatrix3x4fv(m, null, new Float32Array([ 1954 1.5, 1.5, 1.5, 1.5, 1955 1.0, 0.0, 0.0, 1.0, 1956 1.0, 0.0, 0.0, 1.0, 1957 1.0, 0.0, 0.0, 1.0, 1958 ]), null, 6); 1959 }, () => { 1960 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1961 }); 1962 done(); 1963 }); 1964 /** 1965 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0087 1966 * @tc.name webgl2_test_uniformMatrix3x4fv_3 1967 * @tc.desc Test uniformMatrix3x4fv. 1968 */ 1969 it('webgl2_test_uniformMatrix3x4fv_3', 0, async function (done) { 1970 console.info("webgl2test [webgl2_test_uniformMatrix3x4fv_3] uniformMatrix3x4fv"); 1971 uniformMatrix3x4fv((m) => { 1972 gl.uniformMatrix3x4fv(m, null, new Float32Array([ 1973 1.5, 1.5, 1.5, 1.5, 1974 1.0, 0.0, 0.0, 1.0, 1975 1.0, 0.0, 0.0, 1.0, 1976 1.0, 0.0, 0.0, 1.0, 1977 ]), null, null); 1978 }, () => { 1979 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1980 }); 1981 done(); 1982 }); 1983 /** 1984 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0088 1985 * @tc.name webgl2_test_uniformMatrix3x4fv_4 1986 * @tc.desc Test uniformMatrix3x4fv. 1987 */ 1988 it('webgl2_test_uniformMatrix3x4fv_4', 0, async function (done) { 1989 console.info("webgl2test [webgl2_test_uniformMatrix3x4fv_4] uniformMatrix3x4fv"); 1990 uniformMatrix3x4fv((m) => { 1991 gl.uniformMatrix3x4fv(m, null, new Float32Array([ 1992 1.5, 1.5, 1.5, 1.5, 1993 1.0, 0.0, 0.0, 1.0, 1994 1.0, 0.0, 0.0, 1.0, 1995 1.0, 0.0, 0.0, 1.0, 1996 ]), undefined, undefined); 1997 }, () => { 1998 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 1999 }); 2000 done(); 2001 }); 2002 function uniform1fv(callback, finish) { 2003 let p = createProgram(gl, `#version 300 es 2004 uniform float u; 2005 void main(){ 2006 gl_Position.x = float(u); 2007 gl_Position.w = 1.0; 2008 gl_PointSize = 100.0; 2009 } 2010 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2011 gl.useProgram(p.program); 2012 let u = gl.getUniformLocation(p.program, "u"); 2013 callback(u); 2014 let uniform = gl.getUniform(p.program, u); 2015 clear(gl); 2016 gl.drawArrays(gl.POINTS, 0, 1); 2017 gl.deleteShader(p.vertexShader); 2018 gl.deleteShader(p.fragmentShader); 2019 gl.deleteProgram(p.program); 2020 finish(); 2021 } 2022 /** 2023 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0089 2024 * @tc.name webgl2_test_uniform1fv 2025 * @tc.desc Test uniform1fv. 2026 */ 2027 it('webgl2_test_uniform1fv', 0, async function (done) { 2028 console.info("webgl2test [webgl2_test_uniform1fv] uniform1fv"); 2029 let p = createProgram(gl, `#version 300 es 2030 uniform float u; 2031 void main(){ 2032 gl_Position.x = float(u); 2033 gl_Position.w = 1.0; 2034 gl_PointSize = 100.0; 2035 } 2036 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2037 gl.useProgram(p.program); 2038 let u = gl.getUniformLocation(p.program, "u"); 2039 gl.uniform1fv(u, new Float32Array([1.0, 0.0, 1.0]), 1, 1); 2040 let uniform = gl.getUniform(p.program, u); 2041 console.info("webgltest", uniform); 2042 expect(uniform).assertEqual(0.0); 2043 clear(gl); 2044 gl.drawArrays(gl.POINTS, 0, 1); 2045 gl.deleteShader(p.vertexShader); 2046 gl.deleteShader(p.fragmentShader); 2047 gl.deleteProgram(p.program); 2048 checkError(gl); 2049 done(); 2050 }); 2051 /** 2052 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0090 2053 * @tc.name webgl2_test_uniform1fv_1 2054 * @tc.desc Test uniform1fv. 2055 */ 2056 it('webgl2_test_uniform1fv_1', 0, async function (done) { 2057 console.info("webgl2test [webgl2_test_uniform1fv_1] uniform1fv"); 2058 uniform1fv((u) => { 2059 gl.uniform1fv(u, new Float32Array([1.0, 0.0, 1.0]), 1, null); 2060 }, () => { 2061 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2062 }); 2063 done(); 2064 }); 2065 /** 2066 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0091 2067 * @tc.name webgl2_test_uniform1fv_2 2068 * @tc.desc Test uniform1fv. 2069 */ 2070 it('webgl2_test_uniform1fv_2', 0, async function (done) { 2071 console.info("webgl2test [webgl2_test_uniform1fv_2] uniform1fv"); 2072 uniform1fv((u) => { 2073 gl.uniform1fv(u, new Float32Array([1.0, 0.0, 1.0]), 1, undefined); 2074 }, () => { 2075 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2076 }); 2077 done(); 2078 }); 2079 /** 2080 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0092 2081 * @tc.name webgl2_test_uniform1fv_3 2082 * @tc.desc Test uniform1fv. 2083 */ 2084 it('webgl2_test_uniform1fv_3', 0, async function (done) { 2085 console.info("webgl2test [webgl2_test_uniform1fv_3] uniform1fv"); 2086 uniform1fv((u) => { 2087 gl.uniform1fv(u, new Float32Array([1.0, 0.0, 1.0]), null, undefined); 2088 }, () => { 2089 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2090 }); 2091 done(); 2092 }); 2093 /** 2094 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0093 2095 * @tc.name webgl2_test_uniform1fv_4 2096 * @tc.desc Test uniform1fv. 2097 */ 2098 it('webgl2_test_uniform1fv_4', 0, async function (done) { 2099 console.info("webgl2test [webgl2_test_uniform1fv_4] uniform1fv"); 2100 uniform1fv((u) => { 2101 gl.uniform1fv(u, new Float32Array([1.0, 0.0, 1.0]), null, undefined); 2102 }, () => { 2103 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2104 }); 2105 done(); 2106 }); 2107 /** 2108 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0094 2109 * @tc.name webgl2_test_uniform1fv_5 2110 * @tc.desc Test uniform1fv. 2111 */ 2112 it('webgl2_test_uniform1fv_5', 0, async function (done) { 2113 console.info("webgl2test [webgl2_test_uniform1fv_5] uniform1fv"); 2114 uniform1fv((u) => { 2115 gl.uniform1fv(null, new Float32Array([1.0, 0.0, 1.0]), null, undefined); 2116 }, () => { 2117 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2118 }); 2119 done(); 2120 }); 2121 function uniform2fv(callback, finish) { 2122 let p = createProgram(gl, `#version 300 es 2123 uniform vec2 u; 2124 void main(){ 2125 gl_Position.x = u.x; 2126 gl_Position.y = u.y; 2127 gl_Position.w = 1.0; 2128 gl_PointSize = 100.0; 2129 } 2130 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2131 gl.useProgram(p.program); 2132 let u = gl.getUniformLocation(p.program, "u"); 2133 callback(u); 2134 let uniform = gl.getUniform(p.program, u); 2135 clear(gl); 2136 gl.drawArrays(gl.POINTS, 0, 1); 2137 gl.deleteShader(p.vertexShader); 2138 gl.deleteShader(p.fragmentShader); 2139 gl.deleteProgram(p.program); 2140 finish(); 2141 } 2142 /** 2143 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0095 2144 * @tc.name webgl2_test_uniform2fv 2145 * @tc.desc Test uniform2fv. 2146 */ 2147 it('webgl2_test_uniform2fv', 0, async function (done) { 2148 console.info("webgl2test [webgl2_test_uniform2fv] uniform2fv"); 2149 let p = createProgram(gl, `#version 300 es 2150 uniform vec2 u; 2151 void main(){ 2152 gl_Position.x = u.x; 2153 gl_Position.y = u.y; 2154 gl_Position.w = 1.0; 2155 gl_PointSize = 100.0; 2156 } 2157 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2158 gl.useProgram(p.program); 2159 let u = gl.getUniformLocation(p.program, "u"); 2160 gl.uniform2fv(u, new Float32Array([0.0, 0.0, 1.0, 1.0]), 2, 2); 2161 let uniform = gl.getUniform(p.program, u); 2162 console.info("webgltest", uniform); 2163 expect(uniform[0]).assertEqual(1.0); 2164 expect(uniform[1]).assertEqual(1.0); 2165 clear(gl); 2166 gl.drawArrays(gl.POINTS, 0, 1); 2167 gl.deleteShader(p.vertexShader); 2168 gl.deleteShader(p.fragmentShader); 2169 gl.deleteProgram(p.program); 2170 checkError(gl); 2171 done(); 2172 }); 2173 /** 2174 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0096 2175 * @tc.name webgl2_test_uniform2fv_1 2176 * @tc.desc Test uniform2fv. 2177 */ 2178 it('webgl2_test_uniform2fv_1', 0, async function (done) { 2179 console.info("webgl2test [webgl2_test_uniform2fv_1] uniform2fv"); 2180 uniform2fv((u) => { 2181 gl.uniform2fv(u, new Float32Array([1.0, 0.0, 1.0, 1.0]), 2, null); 2182 }, () => { 2183 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2184 }); 2185 done(); 2186 }); 2187 /** 2188 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0097 2189 * @tc.name webgl2_test_uniform2fv_2 2190 * @tc.desc Test uniform2fv. 2191 */ 2192 it('webgl2_test_uniform2fv_2', 0, async function (done) { 2193 console.info("webgl2test [webgl2_test_uniform2fv_2] uniform2fv"); 2194 uniform2fv((u) => { 2195 gl.uniform2fv(u, new Float32Array([1.0, 0.0, 1.0, 1.0]), 1, undefined); 2196 }, () => { 2197 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2198 }); 2199 done(); 2200 }); 2201 /** 2202 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0098 2203 * @tc.name webgl2_test_uniform2fv_3 2204 * @tc.desc Test uniform2fv. 2205 */ 2206 it('webgl2_test_uniform2fv_3', 0, async function (done) { 2207 console.info("webgl2test [webgl2_test_uniform2fv_3] uniform2fv"); 2208 uniform2fv((u) => { 2209 gl.uniform2fv(u, new Float32Array([1.0, 0.0, 1.0, 1.0]), null, undefined); 2210 }, () => { 2211 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2212 }); 2213 done(); 2214 }); 2215 /** 2216 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0099 2217 * @tc.name webgl2_test_uniform2fv_4 2218 * @tc.desc Test uniform2fv. 2219 */ 2220 it('webgl2_test_uniform2fv_4', 0, async function (done) { 2221 console.info("webgl2test [webgl2_test_uniform2fv_4] uniform2fv"); 2222 uniform2fv((u) => { 2223 gl.uniform2fv(u, new Float32Array([1.0, 0.0, 1.0, 1.0]), null, undefined); 2224 }, () => { 2225 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2226 }); 2227 done(); 2228 }); 2229 /** 2230 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0100 2231 * @tc.name webgl2_test_uniform2fv_5 2232 * @tc.desc Test uniform2fv. 2233 */ 2234 it('webgl2_test_uniform2fv_5', 0, async function (done) { 2235 console.info("webgl2test [webgl2_test_uniform2fv_5] uniform2fv"); 2236 uniform2fv((u) => { 2237 gl.uniform2fv(null, new Float32Array([1.0, 0.0, 1.0, 1.0]), null, undefined); 2238 }, () => { 2239 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2240 }); 2241 done(); 2242 }); 2243 function uniform3fv(callback, finish) { 2244 let p = createProgram(gl, `#version 300 es 2245 uniform vec3 u; 2246 void main(){ 2247 gl_Position.x = u.x; 2248 gl_Position.y = u.y; 2249 gl_Position.z = u.z; 2250 gl_Position.w = 1.0; 2251 gl_PointSize = 100.0; 2252 } 2253 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2254 gl.useProgram(p.program); 2255 let u = gl.getUniformLocation(p.program, "u"); 2256 callback(u); 2257 let uniform = gl.getUniform(p.program, u); 2258 clear(gl); 2259 gl.drawArrays(gl.POINTS, 0, 1); 2260 gl.deleteShader(p.vertexShader); 2261 gl.deleteShader(p.fragmentShader); 2262 gl.deleteProgram(p.program); 2263 finish(); 2264 } 2265 /** 2266 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0101 2267 * @tc.name webgl2_test_uniform3fv 2268 * @tc.desc Test uniform3fv. 2269 */ 2270 it('webgl2_test_uniform3fv', 0, async function (done) { 2271 console.info("webgl2test [webgl2_test_uniform3fv] uniform3fv"); 2272 let p = createProgram(gl, `#version 300 es 2273 uniform vec3 u; 2274 void main(){ 2275 gl_Position.x = u.x; 2276 gl_Position.y = u.y; 2277 gl_Position.z = u.z; 2278 gl_Position.w = 1.0; 2279 gl_PointSize = 100.0; 2280 } 2281 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2282 gl.useProgram(p.program); 2283 let u = gl.getUniformLocation(p.program, "u"); 2284 gl.uniform3fv(u, new Float32Array([0.0, 0.0, 1.0, 1.0, 1.0, 1.0]), 2, 3); 2285 let uniform = gl.getUniform(p.program, u); 2286 console.info("webgltest", uniform); 2287 expect(uniform[0]).assertEqual(1.0); 2288 expect(uniform[1]).assertEqual(1.0); 2289 expect(uniform[2]).assertEqual(1.0); 2290 clear(gl); 2291 gl.drawArrays(gl.POINTS, 0, 1); 2292 gl.deleteShader(p.vertexShader); 2293 gl.deleteShader(p.fragmentShader); 2294 gl.deleteProgram(p.program); 2295 checkError(gl); 2296 done(); 2297 }); 2298 /** 2299 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0102 2300 * @tc.name webgl2_test_uniform3fv_1 2301 * @tc.desc Test uniform3fv. 2302 */ 2303 it('webgl2_test_uniform3fv_1', 0, async function (done) { 2304 console.info("webgl2test [webgl2_test_uniform3fv_1] uniform3fv"); 2305 uniform3fv((u) => { 2306 gl.uniform3fv(u, new Float32Array([1.0, 0.0, 1.0, 1.0, 1.0]), 2, null); 2307 }, () => { 2308 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2309 }); 2310 done(); 2311 }); 2312 /** 2313 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0103 2314 * @tc.name webgl2_test_uniform3fv_2 2315 * @tc.desc Test uniform3fv. 2316 */ 2317 it('webgl2_test_uniform3fv_2', 0, async function (done) { 2318 console.info("webgl2test [webgl2_test_uniform3fv_2] uniform3fv"); 2319 uniform3fv((u) => { 2320 gl.uniform3fv(u, new Float32Array([1.0, 0.0, 1.0, 1.0, 1.0]), 1, undefined); 2321 }, () => { 2322 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2323 }); 2324 done(); 2325 }); 2326 /** 2327 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0104 2328 * @tc.name webgl2_test_uniform3fv_3 2329 * @tc.desc Test uniform3fv. 2330 */ 2331 it('webgl2_test_uniform3fv_3', 0, async function (done) { 2332 console.info("webgl2test [webgl2_test_uniform3fv_3] uniform3fv"); 2333 uniform3fv((u) => { 2334 gl.uniform3fv(u, new Float32Array([1.0, 0.0, 1.0, 1.0, 1.0]), null, undefined); 2335 }, () => { 2336 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2337 }); 2338 done(); 2339 }); 2340 /** 2341 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0105 2342 * @tc.name webgl2_test_uniform3fv_4 2343 * @tc.desc Test uniform3fv. 2344 */ 2345 it('webgl2_test_uniform3fv_4', 0, async function (done) { 2346 console.info("webgl2test [webgl2_test_uniform3fv_4] uniform3fv"); 2347 uniform3fv((u) => { 2348 gl.uniform3fv(u, new Float32Array([1.0, 0.0, 1.0, 1.0, 1.0]), null, undefined); 2349 }, () => { 2350 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2351 }); 2352 done(); 2353 }); 2354 /** 2355 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0106 2356 * @tc.name webgl2_test_uniform3fv_5 2357 * @tc.desc Test uniform3fv. 2358 */ 2359 it('webgl2_test_uniform3fv_5', 0, async function (done) { 2360 console.info("webgl2test [webgl2_test_uniform3fv_5] uniform3fv"); 2361 uniform3fv((u) => { 2362 gl.uniform3fv(null, new Float32Array([1.0, 0.0, 1.0, 1.0, 1.0]), null, undefined); 2363 }, () => { 2364 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2365 }); 2366 done(); 2367 }); 2368 function uniform4fv(callback, finish) { 2369 let p = createProgram(gl, `#version 300 es 2370 uniform vec4 u; 2371 void main(){ 2372 gl_Position.x = u.x; 2373 gl_Position.y = u.y; 2374 gl_Position.z = u.z; 2375 gl_Position.w = u.w; 2376 gl_PointSize = 100.0; 2377 } 2378 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2379 gl.useProgram(p.program); 2380 let u = gl.getUniformLocation(p.program, "u"); 2381 callback(u); 2382 let uniform = gl.getUniform(p.program, u); 2383 clear(gl); 2384 gl.drawArrays(gl.POINTS, 0, 1); 2385 gl.deleteShader(p.vertexShader); 2386 gl.deleteShader(p.fragmentShader); 2387 gl.deleteProgram(p.program); 2388 finish(); 2389 } 2390 /** 2391 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0107 2392 * @tc.name webgl2_test_uniform4fv 2393 * @tc.desc Test uniform4fv. 2394 */ 2395 it('webgl2_test_uniform4fv', 0, async function (done) { 2396 console.info("webgl2test [webgl2_test_uniform4fv] uniform4fv"); 2397 let p = createProgram(gl, `#version 300 es 2398 uniform vec4 u; 2399 void main(){ 2400 gl_Position.x = u.x; 2401 gl_Position.y = u.y; 2402 gl_Position.z = u.z; 2403 gl_Position.w = u.w; 2404 gl_PointSize = 100.0; 2405 } 2406 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2407 gl.useProgram(p.program); 2408 let u = gl.getUniformLocation(p.program, "u"); 2409 gl.uniform4fv(u, new Float32Array([0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]), 4, 4); 2410 let uniform = gl.getUniform(p.program, u); 2411 console.info("webgltest", uniform); 2412 expect(uniform[0]).assertEqual(1.0); 2413 expect(uniform[1]).assertEqual(1.0); 2414 expect(uniform[2]).assertEqual(1.0); 2415 clear(gl); 2416 gl.drawArrays(gl.POINTS, 0, 1); 2417 gl.deleteShader(p.vertexShader); 2418 gl.deleteShader(p.fragmentShader); 2419 gl.deleteProgram(p.program); 2420 checkError(gl); 2421 done(); 2422 }); 2423 /** 2424 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0108 2425 * @tc.name webgl2_test_uniform4fv_1 2426 * @tc.desc Test uniform4fv. 2427 */ 2428 it('webgl2_test_uniform4fv_1', 0, async function (done) { 2429 console.info("webgl2test [webgl2_test_uniform4fv_1] uniform4fv"); 2430 uniform4fv((u) => { 2431 gl.uniform4fv(u, new Float32Array([0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]), 4, null); 2432 }, () => { 2433 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2434 }); 2435 done(); 2436 }); 2437 /** 2438 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0109 2439 * @tc.name webgl2_test_uniform4fv_2 2440 * @tc.desc Test uniform4fv. 2441 */ 2442 it('webgl2_test_uniform4fv_2', 0, async function (done) { 2443 console.info("webgl2test [webgl2_test_uniform4fv_2] uniform4fv"); 2444 uniform4fv((u) => { 2445 gl.uniform4fv(u, new Float32Array([0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]), 4, undefined); 2446 }, () => { 2447 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2448 }); 2449 done(); 2450 }); 2451 /** 2452 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0110 2453 * @tc.name webgl2_test_uniform4fv_3 2454 * @tc.desc Test uniform4fv. 2455 */ 2456 it('webgl2_test_uniform4fv_3', 0, async function (done) { 2457 console.info("webgl2test [webgl2_test_uniform4fv_3] uniform4fv"); 2458 uniform4fv((u) => { 2459 gl.uniform4fv(u, new Float32Array([0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]), null, undefined); 2460 }, () => { 2461 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2462 }); 2463 done(); 2464 }); 2465 /** 2466 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0111 2467 * @tc.name webgl2_test_uniform4fv_4 2468 * @tc.desc Test uniform4fv. 2469 */ 2470 it('webgl2_test_uniform4fv_4', 0, async function (done) { 2471 console.info("webgl2test [webgl2_test_uniform4fv_4] uniform4fv"); 2472 uniform4fv((u) => { 2473 gl.uniform4fv(u, new Float32Array([0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]), null, undefined); 2474 }, () => { 2475 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2476 }); 2477 done(); 2478 }); 2479 /** 2480 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0112 2481 * @tc.name webgl2_test_uniform4fv_5 2482 * @tc.desc Test uniform4fv. 2483 */ 2484 it('webgl2_test_uniform4fv_5', 0, async function (done) { 2485 console.info("webgl2test [webgl2_test_uniform4fv_5] uniform4fv"); 2486 uniform4fv((u) => { 2487 gl.uniform4fv(null, new Float32Array([0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]), null, undefined); 2488 }, () => { 2489 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2490 }); 2491 done(); 2492 }); 2493 function uniform1iv(callback, finish) { 2494 let p = createProgram(gl, `#version 300 es 2495 uniform int u; 2496 void main(){ 2497 gl_Position.x = float(u); 2498 gl_Position.w = 1.0; 2499 gl_PointSize = 100.0; 2500 } 2501 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2502 gl.useProgram(p.program); 2503 let u = gl.getUniformLocation(p.program, "u"); 2504 callback(u); 2505 let uniform = gl.getUniform(p.program, u); 2506 clear(gl); 2507 gl.drawArrays(gl.POINTS, 0, 1); 2508 gl.deleteShader(p.vertexShader); 2509 gl.deleteShader(p.fragmentShader); 2510 gl.deleteProgram(p.program); 2511 finish(); 2512 } 2513 /** 2514 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0113 2515 * @tc.name webgl2_test_uniform1iv 2516 * @tc.desc Test uniform1iv. 2517 */ 2518 it('webgl2_test_uniform1iv', 0, async function (done) { 2519 console.info("webgl2test [webgl2_test_uniform1iv] uniform1iv"); 2520 let p = createProgram(gl, `#version 300 es 2521 uniform int u; 2522 void main(){ 2523 gl_Position.x = float(u); 2524 gl_Position.w = 1.0; 2525 gl_PointSize = 100.0; 2526 } 2527 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2528 gl.useProgram(p.program); 2529 let u = gl.getUniformLocation(p.program, "u"); 2530 gl.uniform1iv(u, new Int32Array([0, 1, 1]), 1, 1); 2531 let uniform = gl.getUniform(p.program, u); 2532 console.info("webgltest", uniform); 2533 expect(uniform).assertEqual(1); 2534 clear(gl); 2535 gl.drawArrays(gl.POINTS, 0, 1); 2536 gl.deleteShader(p.vertexShader); 2537 gl.deleteShader(p.fragmentShader); 2538 gl.deleteProgram(p.program); 2539 checkError(gl); 2540 done(); 2541 }); 2542 /** 2543 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0114 2544 * @tc.name webgl2_test_uniform1iv_1 2545 * @tc.desc Test uniform1iv. 2546 */ 2547 it('webgl2_test_uniform1iv_1', 0, async function (done) { 2548 console.info("webgl2test [webgl2_test_uniform1iv_1] uniform1iv"); 2549 uniform1iv((u) => { 2550 gl.uniform1iv(u, new Int32Array([0, 1, 1]), 1, null); 2551 }, () => { 2552 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2553 }); 2554 done(); 2555 }); 2556 /** 2557 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0115 2558 * @tc.name webgl2_test_uniform1iv_2 2559 * @tc.desc Test uniform1iv. 2560 */ 2561 it('webgl2_test_uniform1iv_2', 0, async function (done) { 2562 console.info("webgl2test [webgl2_test_uniform1iv_2] uniform1iv"); 2563 uniform1iv((u) => { 2564 gl.uniform1iv(u, new Int32Array([0, 1, 1]), 1, undefined); 2565 }, () => { 2566 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2567 }); 2568 done(); 2569 }); 2570 /** 2571 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0116 2572 * @tc.name webgl2_test_uniform1iv_3 2573 * @tc.desc Test uniform1iv. 2574 */ 2575 it('webgl2_test_uniform1iv_3', 0, async function (done) { 2576 console.info("webgl2test [webgl2_test_uniform1iv_3] uniform1iv"); 2577 uniform1iv((u) => { 2578 gl.uniform1iv(u, new Int32Array([0, 1, 1]), null, undefined); 2579 }, () => { 2580 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2581 }); 2582 done(); 2583 }); 2584 /** 2585 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0117 2586 * @tc.name webgl2_test_uniform1iv_4 2587 * @tc.desc Test uniform1iv. 2588 */ 2589 it('webgl2_test_uniform1iv_4', 0, async function (done) { 2590 console.info("webgl2test [webgl2_test_uniform1iv_4] uniform1iv"); 2591 uniform1iv((u) => { 2592 gl.uniform1iv(u, new Int32Array([0, 1, 1]), null, undefined); 2593 }, () => { 2594 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2595 }); 2596 done(); 2597 }); 2598 /** 2599 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0118 2600 * @tc.name webgl2_test_uniform1iv_5 2601 * @tc.desc Test uniform1iv. 2602 */ 2603 it('webgl2_test_uniform1iv_5', 0, async function (done) { 2604 console.info("webgl2test [webgl2_test_uniform1iv_5] uniform1iv"); 2605 uniform1iv((u) => { 2606 gl.uniform1iv(null, new Int32Array([0, 1, 1]), null, undefined); 2607 }, () => { 2608 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2609 }); 2610 done(); 2611 }); 2612 function uniform2iv(callback, finish) { 2613 let p = createProgram(gl, `#version 300 es 2614 uniform ivec2 u; 2615 void main(){ 2616 gl_Position.x = float(u.x); 2617 gl_Position.y = float(u.y); 2618 gl_Position.w = 1.0; 2619 gl_PointSize = 100.0; 2620 } 2621 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2622 gl.useProgram(p.program); 2623 let u = gl.getUniformLocation(p.program, "u"); 2624 callback(u); 2625 let uniform = gl.getUniform(p.program, u); 2626 clear(gl); 2627 gl.drawArrays(gl.POINTS, 0, 1); 2628 gl.deleteShader(p.vertexShader); 2629 gl.deleteShader(p.fragmentShader); 2630 gl.deleteProgram(p.program); 2631 finish(); 2632 } 2633 /** 2634 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0119 2635 * @tc.name webgl2_test_uniform2iv 2636 * @tc.desc Test uniform2iv. 2637 */ 2638 it('webgl2_test_uniform2iv', 0, async function (done) { 2639 console.info("webgl2test [webgl2_test_uniform2iv] uniform2iv"); 2640 let p = createProgram(gl, `#version 300 es 2641 uniform ivec2 u; 2642 void main(){ 2643 gl_Position.x = float(u.x); 2644 gl_Position.y = float(u.y); 2645 gl_Position.w = 1.0; 2646 gl_PointSize = 100.0; 2647 } 2648 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2649 gl.useProgram(p.program); 2650 let u = gl.getUniformLocation(p.program, "u"); 2651 gl.uniform2iv(u, new Int32Array([0, 0, 1, 1]), 2, 2); 2652 let uniform = gl.getUniform(p.program, u); 2653 console.info("webgltest", uniform); 2654 expect(uniform[0]).assertEqual(1); 2655 expect(uniform[1]).assertEqual(1); 2656 clear(gl); 2657 gl.drawArrays(gl.POINTS, 0, 1); 2658 gl.deleteShader(p.vertexShader); 2659 gl.deleteShader(p.fragmentShader); 2660 gl.deleteProgram(p.program); 2661 checkError(gl); 2662 done(); 2663 }); 2664 /** 2665 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0120 2666 * @tc.name webgl2_test_uniform2iv_1 2667 * @tc.desc Test uniform2iv. 2668 */ 2669 it('webgl2_test_uniform2iv_1', 0, async function (done) { 2670 console.info("webgl2test [webgl2_test_uniform2iv_1] uniform2iv"); 2671 uniform2iv((u) => { 2672 gl.uniform2iv(u, new Int32Array([0, 1, 1, 1]), 1, null); 2673 }, () => { 2674 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2675 }); 2676 done(); 2677 }); 2678 /** 2679 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0121 2680 * @tc.name webgl2_test_uniform2iv_2 2681 * @tc.desc Test uniform2iv. 2682 */ 2683 it('webgl2_test_uniform2iv_2', 0, async function (done) { 2684 console.info("webgl2test [webgl2_test_uniform2iv_2] uniform2iv"); 2685 uniform2iv((u) => { 2686 gl.uniform2iv(u, new Int32Array([0, 1, 1, 1]), 1, undefined); 2687 }, () => { 2688 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2689 }); 2690 done(); 2691 }); 2692 /** 2693 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0122 2694 * @tc.name webgl2_test_uniform2iv_3 2695 * @tc.desc Test uniform2iv. 2696 */ 2697 it('webgl2_test_uniform2iv_3', 0, async function (done) { 2698 console.info("webgl2test [webgl2_test_uniform2iv_3] uniform2iv"); 2699 uniform2iv((u) => { 2700 gl.uniform2iv(u, new Int32Array([0, 1, 1, 1]), null, undefined); 2701 }, () => { 2702 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2703 }); 2704 done(); 2705 }); 2706 /** 2707 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0123 2708 * @tc.name webgl2_test_uniform2iv_4 2709 * @tc.desc Test uniform2iv. 2710 */ 2711 it('webgl2_test_uniform2iv_4', 0, async function (done) { 2712 console.info("webgl2test [webgl2_test_uniform2iv_4] uniform2iv"); 2713 uniform2iv((u) => { 2714 gl.uniform2iv(u, new Int32Array([0, 1, 1, 1]), null, undefined); 2715 }, () => { 2716 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2717 }); 2718 done(); 2719 }); 2720 /** 2721 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0124 2722 * @tc.name webgl2_test_uniform2iv_5 2723 * @tc.desc Test uniform2iv. 2724 */ 2725 it('webgl2_test_uniform2iv_5', 0, async function (done) { 2726 console.info("webgl2test [webgl2_test_uniform2iv_5] uniform2iv"); 2727 uniform2iv((u) => { 2728 gl.uniform2iv(null, new Int32Array([0, 1, 1, 1]), null, undefined); 2729 }, () => { 2730 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2731 }); 2732 done(); 2733 }); 2734 function uniform3iv(callback, finish) { 2735 let p = createProgram(gl, `#version 300 es 2736 uniform ivec3 u; 2737 void main(){ 2738 gl_Position.x = float(u.x); 2739 gl_Position.y = float(u.y); 2740 gl_Position.z = float(u.z); 2741 gl_Position.w = 1.0; 2742 gl_PointSize = 100.0; 2743 } 2744 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2745 gl.useProgram(p.program); 2746 let u = gl.getUniformLocation(p.program, "u"); 2747 callback(u); 2748 let uniform = gl.getUniform(p.program, u); 2749 clear(gl); 2750 gl.drawArrays(gl.POINTS, 0, 1); 2751 gl.deleteShader(p.vertexShader); 2752 gl.deleteShader(p.fragmentShader); 2753 gl.deleteProgram(p.program); 2754 finish(); 2755 } 2756 /** 2757 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0125 2758 * @tc.name webgl2_test_uniform3iv 2759 * @tc.desc Test uniform3iv. 2760 */ 2761 it('webgl2_test_uniform3iv', 0, async function (done) { 2762 console.info("webgl2test [webgl2_test_uniform3iv] uniform3iv"); 2763 let p = createProgram(gl, `#version 300 es 2764 uniform ivec3 u; 2765 void main(){ 2766 gl_Position.x = float(u.x); 2767 gl_Position.y = float(u.y); 2768 gl_Position.z = float(u.z); 2769 gl_Position.w = 1.0; 2770 gl_PointSize = 100.0; 2771 } 2772 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2773 gl.useProgram(p.program); 2774 let u = gl.getUniformLocation(p.program, "u"); 2775 gl.uniform3iv(u, new Int32Array([0, 0, 1, 1, 1, 1]), 3, 3); 2776 let uniform = gl.getUniform(p.program, u); 2777 console.info("webgltest", uniform); 2778 expect(uniform[0]).assertEqual(1); 2779 expect(uniform[1]).assertEqual(1); 2780 expect(uniform[2]).assertEqual(1); 2781 clear(gl); 2782 gl.drawArrays(gl.POINTS, 0, 1); 2783 gl.deleteShader(p.vertexShader); 2784 gl.deleteShader(p.fragmentShader); 2785 gl.deleteProgram(p.program); 2786 checkError(gl); 2787 done(); 2788 }); 2789 /** 2790 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0126 2791 * @tc.name webgl2_test_uniform3iv_1 2792 * @tc.desc Test uniform3iv. 2793 */ 2794 it('webgl2_test_uniform3iv_1', 0, async function (done) { 2795 console.info("webgl2test [webgl2_test_uniform3iv_1] uniform3iv"); 2796 uniform3iv((u) => { 2797 gl.uniform3iv(u, new Int32Array([0, 0, 1, 1, 1, 1]), 1, null); 2798 }, () => { 2799 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2800 }); 2801 done(); 2802 }); 2803 /** 2804 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0127 2805 * @tc.name webgl2_test_uniform3iv_2 2806 * @tc.desc Test uniform3iv. 2807 */ 2808 it('webgl2_test_uniform3iv_2', 0, async function (done) { 2809 console.info("webgl2test [webgl2_test_uniform3iv_2] uniform3iv"); 2810 uniform3iv((u) => { 2811 gl.uniform3iv(u, new Int32Array([0, 0, 1, 1, 1, 1]), 1, undefined); 2812 }, () => { 2813 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2814 }); 2815 done(); 2816 }); 2817 /** 2818 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0128 2819 * @tc.name webgl2_test_uniform3iv_3 2820 * @tc.desc Test uniform3iv. 2821 */ 2822 it('webgl2_test_uniform3iv_3', 0, async function (done) { 2823 console.info("webgl2test [webgl2_test_uniform3iv_3] uniform3iv"); 2824 uniform3iv((u) => { 2825 gl.uniform3iv(u, new Int32Array([0, 0, 1, 1, 1, 1]), null, undefined); 2826 }, () => { 2827 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2828 }); 2829 done(); 2830 }); 2831 /** 2832 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0129 2833 * @tc.name webgl2_test_uniform3iv_4 2834 * @tc.desc Test uniform3iv. 2835 */ 2836 it('webgl2_test_uniform3iv_4', 0, async function (done) { 2837 console.info("webgl2test [webgl2_test_uniform3iv_4] uniform3iv"); 2838 uniform3iv((u) => { 2839 gl.uniform3iv(u, new Int32Array([0, 0, 1, 1, 1, 1]), null, undefined); 2840 }, () => { 2841 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2842 }); 2843 done(); 2844 }); 2845 /** 2846 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0130 2847 * @tc.name webgl2_test_uniform3iv_5 2848 * @tc.desc Test uniform3iv. 2849 */ 2850 it('webgl2_test_uniform3iv_5', 0, async function (done) { 2851 console.info("webgl2test [webgl2_test_uniform3iv_5] uniform3iv"); 2852 uniform3iv((u) => { 2853 gl.uniform3iv(null, new Int32Array([0, 0, 1, 1, 1, 1]), null, undefined); 2854 }, () => { 2855 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2856 }); 2857 done(); 2858 }); 2859 function uniform4iv(callback, finish) { 2860 let p = createProgram(gl, `#version 300 es 2861 uniform ivec4 u; 2862 void main(){ 2863 gl_Position.x = float(u.x); 2864 gl_Position.y = float(u.y); 2865 gl_Position.z = float(u.z); 2866 gl_Position.w = float(u.w); 2867 gl_PointSize = 100.0; 2868 } 2869 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2870 gl.useProgram(p.program); 2871 let u = gl.getUniformLocation(p.program, "u"); 2872 callback(u); 2873 let uniform = gl.getUniform(p.program, u); 2874 clear(gl); 2875 gl.drawArrays(gl.POINTS, 0, 1); 2876 gl.deleteShader(p.vertexShader); 2877 gl.deleteShader(p.fragmentShader); 2878 gl.deleteProgram(p.program); 2879 finish(); 2880 } 2881 /** 2882 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0131 2883 * @tc.name webgl2_test_uniform4iv 2884 * @tc.desc Test uniform4iv. 2885 */ 2886 it('webgl2_test_uniform4iv', 0, async function (done) { 2887 console.info("webgl2test [webgl2_test_uniform4iv] uniform4iv"); 2888 let p = createProgram(gl, `#version 300 es 2889 uniform ivec4 u; 2890 void main(){ 2891 gl_Position.x = float(u.x); 2892 gl_Position.y = float(u.y); 2893 gl_Position.z = float(u.z); 2894 gl_Position.w = float(u.w); 2895 gl_PointSize = 100.0; 2896 } 2897 `, WEBGL2_FRAGMENT_SHADER_DEMO); 2898 gl.useProgram(p.program); 2899 let u = gl.getUniformLocation(p.program, "u"); 2900 gl.uniform4iv(u, new Int32Array([ 2901 0, 0, 1, 1, 2902 1, 1, 1, 1 2903 ]), 4, 4); 2904 let uniform = gl.getUniform(p.program, u); 2905 console.info("webgltest", uniform); 2906 expect(uniform[0]).assertEqual(1); 2907 expect(uniform[1]).assertEqual(1); 2908 expect(uniform[2]).assertEqual(1); 2909 expect(uniform[3]).assertEqual(1); 2910 clear(gl); 2911 gl.drawArrays(gl.POINTS, 0, 1); 2912 gl.deleteShader(p.vertexShader); 2913 gl.deleteShader(p.fragmentShader); 2914 gl.deleteProgram(p.program); 2915 checkError(gl); 2916 done(); 2917 }); 2918 /** 2919 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0132 2920 * @tc.name webgl2_test_uniform4iv_1 2921 * @tc.desc Test uniform4iv. 2922 */ 2923 it('webgl2_test_uniform4iv_1', 0, async function (done) { 2924 console.info("webgl2test [webgl2_test_uniform4iv_1] uniform4iv"); 2925 uniform4iv((u) => { 2926 gl.uniform4iv(u, new Int32Array([ 2927 0, 0, 1, 1, 2928 1, 1, 1, 1 2929 ]), 4, null); 2930 }, () => { 2931 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2932 }); 2933 done(); 2934 }); 2935 /** 2936 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0133 2937 * @tc.name webgl2_test_uniform4iv_2 2938 * @tc.desc Test uniform4iv. 2939 */ 2940 it('webgl2_test_uniform4iv_2', 0, async function (done) { 2941 console.info("webgl2test [webgl2_test_uniform4iv_2] uniform4iv"); 2942 uniform4iv((u) => { 2943 gl.uniform4iv(u, new Int32Array([ 2944 0, 0, 1, 1, 2945 1, 1, 1, 1 2946 ]), 4, undefined); 2947 }, () => { 2948 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2949 }); 2950 done(); 2951 }); 2952 /** 2953 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0134 2954 * @tc.name webgl2_test_uniform4iv_3 2955 * @tc.desc Test uniform4iv. 2956 */ 2957 it('webgl2_test_uniform4iv_3', 0, async function (done) { 2958 console.info("webgl2test [webgl2_test_uniform4iv_3] uniform4iv"); 2959 uniform4iv((u) => { 2960 gl.uniform4iv(u, new Int32Array([ 2961 0, 0, 1, 1, 2962 1, 1, 1, 1 2963 ]), null, undefined); 2964 }, () => { 2965 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2966 }); 2967 done(); 2968 }); 2969 /** 2970 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0135 2971 * @tc.name webgl2_test_uniform4iv_4 2972 * @tc.desc Test uniform4iv. 2973 */ 2974 it('webgl2_test_uniform4iv_4', 0, async function (done) { 2975 console.info("webgl2test [webgl2_test_uniform4iv_4] uniform4iv"); 2976 uniform4iv((u) => { 2977 gl.uniform4iv(u, new Int32Array([ 2978 0, 0, 1, 1, 2979 1, 1, 1, 1 2980 ]), null, undefined); 2981 }, () => { 2982 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 2983 }); 2984 done(); 2985 }); 2986 /** 2987 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0136 2988 * @tc.name webgl2_test_uniform4iv_5 2989 * @tc.desc Test uniform4iv. 2990 */ 2991 it('webgl2_test_uniform4iv_5', 0, async function (done) { 2992 console.info("webgl2test [webgl2_test_uniform4iv_5] uniform4iv"); 2993 uniform4iv((u) => { 2994 gl.uniform4iv(null, new Int32Array([ 2995 0, 0, 1, 1, 2996 1, 1, 1, 1 2997 ]), null, undefined); 2998 }, () => { 2999 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 3000 }); 3001 done(); 3002 }); 3003 function uniformMatrix2fv(callback, finish) { 3004 let p = createProgram(gl, `#version 300 es 3005 in vec2 a_Position; 3006 uniform mat2 u_MvpMatrix; 3007 void main(){ 3008 gl_Position = vec4( 3009 (u_MvpMatrix * vec2(a_Position.x,a_Position.y)).xy, 0, 1 3010 ); 3011 } 3012 `, WEBGL2_FRAGMENT_SHADER_DEMO); 3013 gl.useProgram(p.program); 3014 let u = gl.getUniformLocation(p.program, "u_MvpMatrix"); 3015 callback(u); 3016 let uniform = gl.getUniform(p.program, u); 3017 clear(gl); 3018 gl.drawArrays(gl.POINTS, 0, 1); 3019 gl.deleteShader(p.vertexShader); 3020 gl.deleteShader(p.fragmentShader); 3021 gl.deleteProgram(p.program); 3022 finish(); 3023 } 3024 /** 3025 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0137 3026 * @tc.name webgl2_test_uniformMatrix2fv 3027 * @tc.desc Test uniformMatrix2fv. 3028 */ 3029 it('webgl2_test_uniformMatrix2fv', 0, async function (done) { 3030 console.info("webgl2test [webgl2_test_uniformMatrix2fv] uniformMatrix2fv"); 3031 let p = createProgram(gl, `#version 300 es 3032 in vec2 a_Position; 3033 uniform mat2 u_MvpMatrix; 3034 void main(){ 3035 gl_Position = vec4( 3036 (u_MvpMatrix * vec2(a_Position.x,a_Position.y)).xy, 0, 1 3037 ); 3038 } 3039 `, WEBGL2_FRAGMENT_SHADER_DEMO); 3040 gl.useProgram(p.program); 3041 let u = gl.getUniformLocation(p.program, "u_MvpMatrix"); 3042 gl.uniformMatrix2fv(u, false, new Float32Array([ 3043 3.0, -0.5, 3044 0, 3.5, 3045 1.0, -1.5, 3046 0, 1.5, 3047 ]), 4, 4); 3048 let value = gl.getUniform(p.program, u); 3049 console.info("webgltest", value); 3050 expect(value[0]).assertEqual(1.0); 3051 expect(value[1]).assertEqual(-1.5); 3052 expect(value[2]).assertEqual(0); 3053 expect(value[3]).assertEqual(1.5); 3054 clear(gl); 3055 gl.drawArrays(gl.POINTS, 0, 1); 3056 gl.deleteShader(p.vertexShader); 3057 gl.deleteShader(p.fragmentShader); 3058 gl.deleteProgram(p.program); 3059 checkError(gl); 3060 done(); 3061 }); 3062 /** 3063 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0138 3064 * @tc.name webgl2_test_uniformMatrix2fv_1 3065 * @tc.desc Test uniformMatrix2fv. 3066 */ 3067 it('webgl2_test_uniformMatrix2fv_1', 0, async function (done) { 3068 console.info("webgl2test [webgl2_test_uniformMatrix2fv_1] uniformMatrix2fv"); 3069 uniformMatrix2fv((u) => { 3070 gl.uniformMatrix2fv(u, null, new Float32Array([ 3071 3.0, -0.5, 3072 0, 3.5, 3073 1.0, -1.5, 3074 0, 1.5, 3075 ]), 4, null); 3076 }, () => { 3077 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 3078 }); 3079 done(); 3080 }); 3081 /** 3082 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0139 3083 * @tc.name webgl2_test_uniformMatrix2fv_2 3084 * @tc.desc Test uniformMatrix2fv. 3085 */ 3086 it('webgl2_test_uniformMatrix2fv_2', 0, async function (done) { 3087 console.info("webgl2test [webgl2_test_uniformMatrix2fv_2] uniformMatrix2fv"); 3088 uniformMatrix2fv((u) => { 3089 gl.uniformMatrix2fv(u, null, new Float32Array([ 3090 3.0, -0.5, 3091 0, 3.5, 3092 1.0, -1.5, 3093 0, 1.5, 3094 ]), 4, undefined); 3095 }, () => { 3096 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 3097 }); 3098 done(); 3099 }); 3100 /** 3101 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0140 3102 * @tc.name webgl2_test_uniformMatrix2fv_3 3103 * @tc.desc Test uniformMatrix2fv. 3104 */ 3105 it('webgl2_test_uniformMatrix2fv_3', 0, async function (done) { 3106 console.info("webgl2test [webgl2_test_uniformMatrix2fv_3] uniformMatrix2fv"); 3107 uniformMatrix2fv((u) => { 3108 gl.uniformMatrix2fv(u, null, new Float32Array([ 3109 3.0, -0.5, 3110 0, 3.5, 3111 1.0, -1.5, 3112 0, 1.5, 3113 ]), null, undefined); 3114 }, () => { 3115 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 3116 }); 3117 done(); 3118 }); 3119 /** 3120 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0141 3121 * @tc.name webgl2_test_uniformMatrix2fv_4 3122 * @tc.desc Test uniformMatrix2fv. 3123 */ 3124 it('webgl2_test_uniformMatrix2fv_4', 0, async function (done) { 3125 console.info("webgl2test [webgl2_test_uniformMatrix2fv_4] uniformMatrix2fv"); 3126 uniformMatrix2fv((u) => { 3127 gl.uniformMatrix2fv(u, null, new Float32Array([ 3128 3.0, -0.5, 3129 0, 3.5, 3130 1.0, -1.5, 3131 0, 1.5, 3132 ]), null, undefined); 3133 }, () => { 3134 expect(checkError(gl)).assertEqual(gl.INVALID_OPERATION); 3135 }); 3136 done(); 3137 }); 3138 /** 3139 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0142 3140 * @tc.name webgl2_test_uniformMatrix2fv_5 3141 * @tc.desc Test uniformMatrix2fv. 3142 */ 3143 it('webgl2_test_uniformMatrix2fv_5', 0, async function (done) { 3144 console.info("webgl2test [webgl2_test_uniformMatrix2fv_5] uniformMatrix2fv"); 3145 uniformMatrix2fv((u) => { 3146 gl.uniformMatrix2fv(null, null, new Float32Array([ 3147 3.0, -0.5, 3148 0, 3.5, 3149 1.0, -1.5, 3150 0, 1.5, 3151 ]), null, undefined); 3152 }, () => { 3153 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 3154 }); 3155 done(); 3156 }); 3157 function uniformMatrix3fv(callback, finish) { 3158 let p = createProgram(gl, `#version 300 es 3159 in vec2 a_Position; 3160 uniform mat3 u_MvpMatrix; 3161 void main(){ 3162 gl_Position = vec4( 3163 (u_MvpMatrix * vec3(a_Position, 1)).xy, 0, 1 3164 ); 3165 } 3166 `, WEBGL2_FRAGMENT_SHADER_DEMO); 3167 gl.useProgram(p.program); 3168 let u = gl.getUniformLocation(p.program, "u_MvpMatrix"); 3169 callback(u); 3170 let uniform = gl.getUniform(p.program, u); 3171 clear(gl); 3172 gl.drawArrays(gl.POINTS, 0, 1); 3173 gl.deleteShader(p.vertexShader); 3174 gl.deleteShader(p.fragmentShader); 3175 gl.deleteProgram(p.program); 3176 finish(); 3177 } 3178 /** 3179 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0143 3180 * @tc.name webgl2_test_uniformMatrix3fv 3181 * @tc.desc Test uniformMatrix3fv. 3182 */ 3183 it('webgl2_test_uniformMatrix3fv', 0, async function (done) { 3184 console.info("webgl2test [webgl2_test_uniformMatrix3fv] uniformMatrix3fv"); 3185 let p = createProgram(gl, `#version 300 es 3186 in vec2 a_Position; 3187 uniform mat3 u_MvpMatrix; 3188 void main(){ 3189 gl_Position = vec4( 3190 (u_MvpMatrix * vec3(a_Position, 1)).xy, 0, 1 3191 ); 3192 } 3193 `, WEBGL2_FRAGMENT_SHADER_DEMO); 3194 gl.useProgram(p.program); 3195 let u = gl.getUniformLocation(p.program, "u_MvpMatrix"); 3196 gl.uniformMatrix3fv(u, false, new Float32Array([ 3197 3.0, -0.5, 1.0, 3198 0.0, 3.5, 1.0, 3199 1.0, -1.5, 1.0, 3200 0.0, 1.5, 1.0, 3201 ]), 3, 9); 3202 let value = gl.getUniform(p.program, u); 3203 console.info("webgltest", value); 3204 expect(value[0]).assertEqual(0.0); 3205 expect(value[1]).assertEqual(3.5); 3206 expect(value[2]).assertEqual(1.0); 3207 expect(value[3]).assertEqual(1.0); 3208 expect(value[4]).assertEqual(-1.5); 3209 expect(value[5]).assertEqual(1.0); 3210 expect(value[6]).assertEqual(0.0); 3211 expect(value[7]).assertEqual(1.5); 3212 expect(value[8]).assertEqual(1.0); 3213 clear(gl); 3214 gl.drawArrays(gl.POINTS, 0, 1); 3215 gl.deleteShader(p.vertexShader); 3216 gl.deleteShader(p.fragmentShader); 3217 gl.deleteProgram(p.program); 3218 checkError(gl); 3219 done(); 3220 }); 3221 /** 3222 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0144 3223 * @tc.name webgl2_test_uniformMatrix3fv_1 3224 * @tc.desc Test uniformMatrix3fv. 3225 */ 3226 it('webgl2_test_uniformMatrix3fv_1', 0, async function (done) { 3227 console.info("webgl2test [webgl2_test_uniformMatrix3fv_1] uniformMatrix3fv"); 3228 uniformMatrix3fv((u) => { 3229 gl.uniformMatrix3fv(u, null, new Float32Array([ 3230 3.0, -0.5, 1.0, 3231 0.0, 3.5, 1.0, 3232 1.0, -1.5, 1.0, 3233 0.0, 1.5, 1.0, 3234 ]), 3, null); 3235 }, () => { 3236 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 3237 }); 3238 done(); 3239 }); 3240 /** 3241 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0145 3242 * @tc.name webgl2_test_uniformMatrix3fv_2 3243 * @tc.desc Test uniformMatrix3fv. 3244 */ 3245 it('webgl2_test_uniformMatrix3fv_2', 0, async function (done) { 3246 console.info("webgl2test [webgl2_test_uniformMatrix3fv_2] uniformMatrix3fv"); 3247 uniformMatrix3fv((u) => { 3248 gl.uniformMatrix3fv(u, null, new Float32Array([ 3249 3.0, -0.5, 1.0, 3250 0.0, 3.5, 1.0, 3251 1.0, -1.5, 1.0, 3252 0.0, 1.5, 1.0, 3253 ]), 3, undefined); 3254 }, () => { 3255 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 3256 }); 3257 done(); 3258 }); 3259 /** 3260 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0146 3261 * @tc.name webgl2_test_uniformMatrix3fv_3 3262 * @tc.desc Test uniformMatrix3fv. 3263 */ 3264 it('webgl2_test_uniformMatrix3fv_3', 0, async function (done) { 3265 console.info("webgl2test [webgl2_test_uniformMatrix3fv_3] uniformMatrix3fv"); 3266 uniformMatrix3fv((u) => { 3267 gl.uniformMatrix3fv(u, null, new Float32Array([ 3268 3.0, -0.5, 1.0, 3269 0.0, 3.5, 1.0, 3270 1.0, -1.5, 1.0, 3271 0.0, 1.5, 1.0, 3272 ]), null, undefined); 3273 }, () => { 3274 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 3275 }); 3276 done(); 3277 }); 3278 /** 3279 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0147 3280 * @tc.name webgl2_test_uniformMatrix3fv_4 3281 * @tc.desc Test uniformMatrix3fv. 3282 */ 3283 it('webgl2_test_uniformMatrix3fv_4', 0, async function (done) { 3284 console.info("webgl2test [webgl2_test_uniformMatrix3fv_4] 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 ]), null, undefined); 3292 }, () => { 3293 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 3294 }); 3295 done(); 3296 }); 3297 /** 3298 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0148 3299 * @tc.name webgl2_test_uniformMatrix3fv_5 3300 * @tc.desc Test uniformMatrix3fv. 3301 */ 3302 it('webgl2_test_uniformMatrix3fv_5', 0, async function (done) { 3303 console.info("webgl2test [webgl2_test_uniformMatrix3fv_5] uniformMatrix3fv"); 3304 uniformMatrix3fv((u) => { 3305 gl.uniformMatrix3fv(null, null, new Float32Array([ 3306 3.0, -0.5, 1.0, 3307 0.0, 3.5, 1.0, 3308 1.0, -1.5, 1.0, 3309 0.0, 1.5, 1.0, 3310 ]), null, undefined); 3311 }, () => { 3312 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 3313 }); 3314 done(); 3315 }); 3316 function uniformMatrix4fv(callback, finish) { 3317 let p = createProgram(gl, `#version 300 es 3318 in vec4 a_Position; 3319 uniform mat4 u_MvpMatrix; 3320 void main(){ 3321 gl_Position = u_MvpMatrix * a_Position; 3322 } 3323 `, WEBGL2_FRAGMENT_SHADER_DEMO); 3324 gl.useProgram(p.program); 3325 let u = gl.getUniformLocation(p.program, "u_MvpMatrix"); 3326 callback(u); 3327 let uniform = gl.getUniform(p.program, u); 3328 clear(gl); 3329 gl.drawArrays(gl.POINTS, 0, 1); 3330 gl.deleteShader(p.vertexShader); 3331 gl.deleteShader(p.fragmentShader); 3332 gl.deleteProgram(p.program); 3333 finish(); 3334 } 3335 /** 3336 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0149 3337 * @tc.name webgl2_test_uniformMatrix4fv 3338 * @tc.desc Test uniformMatrix4fv. 3339 */ 3340 it('webgl2_test_uniformMatrix4fv', 0, async function (done) { 3341 console.info("webgl2test [webgl2_test_uniformMatrix4fv] uniformMatrix4fv"); 3342 let p = createProgram(gl, `#version 300 es 3343 in vec4 a_Position; 3344 uniform mat4 u_MvpMatrix; 3345 void main(){ 3346 gl_Position = u_MvpMatrix * a_Position; 3347 } 3348 `, WEBGL2_FRAGMENT_SHADER_DEMO); 3349 gl.useProgram(p.program); 3350 let u = gl.getUniformLocation(p.program, "u_MvpMatrix"); 3351 gl.uniformMatrix4fv(u, false, new Float32Array([ 3352 1.0, 2.0, 3.0, 4.0, 3353 3.5, -0.5, -0.5, -0.5, 3354 0, 3.5, -0.5, -0.5, 3355 -1.0, -1.5, -2.0, -1.0, 3356 -3.0, -0.5, 6.0, 8.0 3357 ]), 4, 16); 3358 let value = gl.getUniform(p.program, u); 3359 console.info("webgltest", value); 3360 expect(value[0]).assertEqual(3.5); 3361 expect(value[1]).assertEqual(-0.5); 3362 expect(value[2]).assertEqual(-0.5); 3363 expect(value[3]).assertEqual(-0.5); 3364 expect(value[4]).assertEqual(0.0); 3365 expect(value[5]).assertEqual(3.5); 3366 expect(value[6]).assertEqual(-0.5); 3367 expect(value[7]).assertEqual(-0.5); 3368 expect(value[8]).assertEqual(-1.0); 3369 expect(value[9]).assertEqual(-1.5); 3370 expect(value[10]).assertEqual(-2.0); 3371 expect(value[11]).assertEqual(-1.0); 3372 expect(value[12]).assertEqual(-3.0); 3373 expect(value[13]).assertEqual(-0.5); 3374 expect(value[14]).assertEqual(6.0); 3375 expect(value[15]).assertEqual(8.0); 3376 clear(gl); 3377 gl.drawArrays(gl.POINTS, 0, 1); 3378 gl.deleteShader(p.vertexShader); 3379 gl.deleteShader(p.fragmentShader); 3380 gl.deleteProgram(p.program); 3381 checkError(gl); 3382 done(); 3383 }); 3384 /** 3385 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0150 3386 * @tc.name webgl2_test_uniformMatrix4fv_1 3387 * @tc.desc Test uniformMatrix4fv. 3388 */ 3389 it('webgl2_test_uniformMatrix4fv_1', 0, async function (done) { 3390 console.info("webgl2test [webgl2_test_uniformMatrix4fv_1] uniformMatrix4fv"); 3391 uniformMatrix4fv((u) => { 3392 gl.uniformMatrix4fv(u, null, 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, null); 3399 }, () => { 3400 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 3401 }); 3402 done(); 3403 }); 3404 /** 3405 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0151 3406 * @tc.name webgl2_test_uniformMatrix4fv_2 3407 * @tc.desc Test uniformMatrix4fv. 3408 */ 3409 it('webgl2_test_uniformMatrix4fv_2', 0, async function (done) { 3410 console.info("webgl2test [webgl2_test_uniformMatrix4fv_2] uniformMatrix4fv"); 3411 uniformMatrix4fv((u) => { 3412 gl.uniformMatrix4fv(u, null, new Float32Array([ 3413 1.0, 2.0, 3.0, 4.0, 3414 3.5, -0.5, -0.5, -0.5, 3415 0, 3.5, -0.5, -0.5, 3416 -1.0, -1.5, -2.0, -1.0, 3417 -3.0, -0.5, 6.0, 8.0 3418 ]), 4, undefined); 3419 }, () => { 3420 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 3421 }); 3422 done(); 3423 }); 3424 /** 3425 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0152 3426 * @tc.name webgl2_test_uniformMatrix4fv_3 3427 * @tc.desc Test uniformMatrix4fv. 3428 */ 3429 it('webgl2_test_uniformMatrix4fv_3', 0, async function (done) { 3430 console.info("webgl2test [webgl2_test_uniformMatrix4fv_3] uniformMatrix4fv"); 3431 uniformMatrix4fv((u) => { 3432 gl.uniformMatrix4fv(u, null, new Float32Array([ 3433 1.0, 2.0, 3.0, 4.0, 3434 3.5, -0.5, -0.5, -0.5, 3435 0, 3.5, -0.5, -0.5, 3436 -1.0, -1.5, -2.0, -1.0, 3437 -3.0, -0.5, 6.0, 8.0 3438 ]), null, undefined); 3439 }, () => { 3440 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 3441 }); 3442 done(); 3443 }); 3444 /** 3445 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0153 3446 * @tc.name webgl2_test_uniformMatrix4fv_4 3447 * @tc.desc Test uniformMatrix4fv. 3448 */ 3449 it('webgl2_test_uniformMatrix4fv_4', 0, async function (done) { 3450 console.info("webgl2test [webgl2_test_uniformMatrix4fv_4] uniformMatrix4fv"); 3451 uniformMatrix4fv((u) => { 3452 gl.uniformMatrix4fv(u, null, new Float32Array([ 3453 1.0, 2.0, 3.0, 4.0, 3454 3.5, -0.5, -0.5, -0.5, 3455 0, 3.5, -0.5, -0.5, 3456 -1.0, -1.5, -2.0, -1.0, 3457 -3.0, -0.5, 6.0, 8.0 3458 ]), null, undefined); 3459 }, () => { 3460 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 3461 }); 3462 done(); 3463 }); 3464 /** 3465 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0154 3466 * @tc.name webgl2_test_uniformMatrix4fv_5 3467 * @tc.desc Test uniformMatrix4fv. 3468 */ 3469 it('webgl2_test_uniformMatrix4fv_5', 0, async function (done) { 3470 console.info("webgl2test [webgl2_test_uniformMatrix4fv_5] uniformMatrix4fv"); 3471 uniformMatrix4fv((u) => { 3472 gl.uniformMatrix4fv(null, null, new Float32Array([ 3473 1.0, 2.0, 3.0, 4.0, 3474 3.5, -0.5, -0.5, -0.5, 3475 0, 3.5, -0.5, -0.5, 3476 -1.0, -1.5, -2.0, -1.0, 3477 -3.0, -0.5, 6.0, 8.0 3478 ]), null, undefined); 3479 }, () => { 3480 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 3481 }); 3482 done(); 3483 }); 3484 }) 3485} 3486