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} from './WebGL1'; 20 21 22export default function webgl1_uniform() { 23 24 describe('webgl1_uniform', function () { 25 let gl = global.gl; 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 50 function getActiveUniform(callback, finish) { 51 let vSource = ` 52 void main(){ 53 gl_Position = vec4(0.5, 0.5, 1, 1.0); 54 } 55 `; 56 let fSource = ` 57 precision mediump float; 58 uniform vec4 u_FragColor; 59 void main(){ 60 gl_FragColor = u_FragColor; 61 } 62 ` 63 let p = createProgram(gl, vSource, fSource); 64 callback(p.program); 65 gl.deleteShader(p.vertexShader); 66 gl.deleteShader(p.fragmentShader); 67 gl.deleteProgram(p.program); 68 } 69 70 71 /** 72 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0001 73 * @tc.name webgl_test_getActiveUniform 74 * @tc.desc Test getActiveUniform. 75 */ 76 it('webgl_test_getActiveUniform', 0, async function (done) { 77 console.info("webgltest [webgl_test_getActiveUniform] getActiveUniform"); 78 let vSource = ` 79 void main(){ 80 gl_Position = vec4(0.5, 0.5, 1, 1.0); 81 } 82 `; 83 let fSource = ` 84 precision mediump float; 85 uniform vec4 u_FragColor; 86 void main(){ 87 gl_FragColor = u_FragColor; 88 } 89 ` 90 let p = createProgram(gl, vSource, fSource); 91 let u_FragColor = gl.getUniformLocation(p.program, "u_FragColor"); 92 console.info("webgltest fragmentShader source :", fSource); 93 console.info("webgltest uniform u_FragColor:", u_FragColor); 94 expect(u_FragColor != null).assertTrue(); 95 let activeUniforms = gl.getProgramParameter(p.program, gl.ACTIVE_UNIFORMS); 96 console.info("webgltest ACTIVE_UNIFORMS: ", activeUniforms); 97 let activeUniform = gl.getActiveUniform(p.program, 0); 98 console.info("webgltest gl.getActiveUniform(p.program,0); ", activeUniform); 99 expect(activeUniform.name).assertEqual("u_FragColor"); 100 expect(activeUniform.type).assertEqual(gl.FLOAT_VEC4); 101 gl.deleteShader(p.vertexShader); 102 gl.deleteShader(p.fragmentShader); 103 gl.deleteProgram(p.program); 104 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 105 done(); 106 }) 107 108 109 /** 110 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0002 111 * @tc.name webgl_test_getActiveUniforms_1 112 * @tc.desc Test getActiveUniforms. 113 */ 114 it('webgl_test_getActiveUniforms_1', 0, async function (done) { 115 console.info("webgltest [webgl_test_getActiveUniforms_1] getActiveUniforms_1"); 116 getActiveUniform((program) => { 117 let activeUniform = gl.getActiveUniform(program, 0); 118 expect(activeUniform.name).assertEqual("u_FragColor"); 119 expect(activeUniform.type).assertEqual(gl.FLOAT_VEC4); 120 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 121 }) 122 done(); 123 }) 124 125 126 /** 127 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0003 128 * @tc.name webgl_test_getActiveUniforms_2 129 * @tc.desc Test getActiveUniforms. 130 */ 131 it('webgl_test_getActiveUniforms_2', 0, async function (done) { 132 console.info("webgltest [webgl_test_getActiveUniforms_2] getActiveUniforms_1"); 133 getActiveUniform((program) => { 134 let activeUniform = gl.getActiveUniform(program, -1); 135 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 136 }) 137 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 138 done(); 139 }) 140 141 142 /** 143 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0004 144 * @tc.name webgl_test_getActiveUniforms_3 145 * @tc.desc Test getActiveUniforms. 146 */ 147 it('webgl_test_getActiveUniforms_3', 0, async function (done) { 148 console.info("webgltest [webgl_test_getActiveUniforms_3] getActiveUniforms_1"); 149 getActiveUniform((program) => { 150 let activeUniform = gl.getActiveUniform(program, null); 151 expect(activeUniform["name"]).assertEqual("u_FragColor"); 152 expect(activeUniform["type"]).assertEqual(gl.FLOAT_VEC4); 153 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 154 }) 155 done(); 156 }) 157 158 159 /** 160 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0005 161 * @tc.name webgl_test_getUniformLocation 162 * @tc.desc Test getUniformLocation. 163 */ 164 it('webgl_test_getUniformLocation', 0, async function (done) { 165 console.info("webgltest [webgl_test_getUniformLocation] getUniformLocation"); 166 let vSource = ` 167 void main(){ 168 gl_Position = vec4(0.5, 0.5, 1, 1.0); 169 } 170 `; 171 let fSource = ` 172 precision mediump float; 173 uniform vec4 u_FragColor; 174 void main(){ 175 gl_FragColor = u_FragColor; 176 } 177 ` 178 let p = createProgram(gl, vSource, fSource); 179 let u_FragColor = gl.getUniformLocation(p.program, "u_FragColor"); 180 console.info("webgltest fragmentShader source :", fSource); 181 console.info("webgltest uniform u_FragColor:", u_FragColor); 182 expect(u_FragColor != null).assertTrue(); 183 let u_FragColorErr = gl.getUniformLocation(p.program, "u_FragColor_Err"); 184 console.info("webgltest uniform u_FragColorErr:", u_FragColorErr); 185 expect(u_FragColorErr).assertEqual(null); 186 gl.deleteShader(p.vertexShader); 187 gl.deleteShader(p.fragmentShader); 188 gl.deleteProgram(p.program); 189 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 190 done(); 191 }) 192 193 function getUniformLocation(callback) { 194 let vSource = ` 195 void main(){ 196 gl_Position = vec4(0.5, 0.5, 1, 1.0); 197 } 198 `; 199 let fSource = ` 200 precision mediump float; 201 uniform vec4 u_FragColor; 202 void main(){ 203 gl_FragColor = u_FragColor; 204 } 205 ` 206 let p = createProgram(gl, vSource, fSource); 207 callback(p.program); 208 gl.deleteShader(p.vertexShader); 209 gl.deleteShader(p.fragmentShader); 210 gl.deleteProgram(p.program); 211 } 212 213 214 /** 215 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0006 216 * @tc.name webgl_test_getUniformLocation_1 217 * @tc.desc Test getUniformLocation. 218 */ 219 it('webgl_test_getUniformLocation_1', 0, async function (done) { 220 console.info("webgltest [webgl_test_getUniformLocation_1] getUniformLocation"); 221 getUniformLocation((program) => { 222 let u_FragColor = gl.getUniformLocation(program, "u_FragColor"); 223 expect(u_FragColor != null).assertTrue(); 224 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 225 }) 226 done(); 227 }) 228 229 230 /** 231 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0007 232 * @tc.name webgl_test_getUniformLocation_2 233 * @tc.desc Test getUniformLocation. 234 */ 235 it('webgl_test_getUniformLocation_2', 0, async function (done) { 236 console.info("webgltest [webgl_test_getUniformLocation_2] getUniformLocation"); 237 getUniformLocation((program) => { 238 let u_FragColor = gl.getUniformLocation(program, "u_FragColor_1"); 239 expect(u_FragColor).assertEqual(null); 240 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 241 }) 242 done(); 243 }) 244 245 246 /** 247 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0008 248 * @tc.name webgl_test_getUniformLocation_3 249 * @tc.desc Test getUniformLocation. 250 */ 251 it('webgl_test_getUniformLocation_3', 0, async function (done) { 252 console.info("webgltest [webgl_test_getUniformLocation_3] getUniformLocation"); 253 getUniformLocation((program) => { 254 let u_FragColor = gl.getUniformLocation(program, null); 255 expect(u_FragColor).assertEqual(null); 256 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 257 }) 258 done(); 259 }) 260 261 function uniform1f(callback, finish) { 262 let vSource = ` 263 attribute vec4 a_Position; 264 uniform float u_num; 265 void main(){ 266 gl_Position = u_num * vec4(0.5, 0.5, 1, 1.0); 267 } 268 `; 269 let fSource = ` 270 precision mediump float; 271 void main(){ 272 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 273 } 274 ` 275 let p = createProgram(gl, vSource, fSource); 276 let u_num = gl.getUniformLocation(p.program, "u_num"); 277 callback(p.program, u_num); 278 let uniform = gl.getUniform(p.program, u_num); 279 finish(uniform); 280 gl.deleteShader(p.vertexShader); 281 gl.deleteShader(p.fragmentShader); 282 gl.deleteProgram(p.program); 283 } 284 285 286 /** 287 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0009 288 * @tc.name webgl_test_uniform1f 289 * @tc.desc Test uniform1f. 290 */ 291 it('webgl_test_uniform1f', 0, async function (done) { 292 console.info("webgltest [webgl_test_uniform1f] uniform1f"); 293 let vSource = ` 294 attribute vec4 a_Position; 295 uniform float u_num; 296 void main(){ 297 gl_Position = u_num * vec4(0.5, 0.5, 1, 1.0); 298 } 299 `; 300 let fSource = ` 301 precision mediump float; 302 void main(){ 303 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 304 } 305 ` 306 let p = createProgram(gl, vSource, fSource); 307 let u_num = gl.getUniformLocation(p.program, "u_num"); 308 console.info("webgltest fragmentShader source :", fSource); 309 console.info("webgltest uniform u_num:", u_num); 310 gl.uniform1f(u_num, 0.5); 311 let uniform = gl.getUniform(p.program, u_num); 312 console.info("webgltest uniform u_num value:", uniform); 313 expect(uniform).assertEqual(0.5); 314 gl.deleteShader(p.vertexShader); 315 gl.deleteShader(p.fragmentShader); 316 gl.deleteProgram(p.program); 317 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 318 done(); 319 }) 320 321 322 /** 323 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0010 324 * @tc.name webgl_test_uniform1f_1 325 * @tc.desc Test uniform1f. 326 */ 327 it('webgl_test_uniform1f_1', 0, async function (done) { 328 console.info("webgltest [webgl_test_uniform1f_1] uniform1f"); 329 uniform1f((program, val) => { 330 gl.uniform1f(val, 0); 331 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 332 }, val => { 333 expect(val).assertEqual(0); 334 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 335 }) 336 done(); 337 }) 338 339 340 /** 341 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0011 342 * @tc.name webgl_test_uniform1f_2 343 * @tc.desc Test uniform1f. 344 */ 345 it('webgl_test_uniform1f_2', 0, async function (done) { 346 console.info("webgltest [webgl_test_uniform1f_2] uniform1f"); 347 uniform1f((program, val) => { 348 gl.uniform1f(val, null); 349 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 350 }, val => { 351 expect(val).assertEqual(0); 352 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 353 }) 354 done(); 355 }) 356 357 358 /** 359 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0012 360 * @tc.name webgl_test_uniform1f_3 361 * @tc.desc Test uniform1f. 362 */ 363 it('webgl_test_uniform1f_3', 0, async function (done) { 364 console.info("webgltest [webgl_test_uniform1f_3] uniform1f"); 365 uniform1f((program, val) => { 366 gl.uniform1f(val, undefined); 367 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 368 }, val => { 369 expect(val.toString()).assertEqual("NaN"); 370 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 371 }) 372 done(); 373 }) 374 375 376 /** 377 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0013 378 * @tc.name webgl_test_uniform1f_4 379 * @tc.desc Test uniform1f. 380 */ 381 it('webgl_test_uniform1f_4', 0, async function (done) { 382 console.info("webgltest [webgl_test_uniform1f_4] uniform1f"); 383 uniform1f((program, val) => { 384 gl.uniform1f(val, "0"); 385 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 386 }, val => { 387 expect(val).assertEqual(0); 388 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 389 }) 390 done(); 391 }) 392 393 function uniform2f(callback, finish) { 394 let vSource = ` 395 attribute vec4 a_Position; 396 uniform vec2 u_num; 397 void main(){ 398 gl_Position.x = u_num.x; 399 gl_Position.y = u_num.y; 400 } 401 `; 402 let fSource = ` 403 precision mediump float; 404 void main(){ 405 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 406 } 407 ` 408 let p = createProgram(gl, vSource, fSource); 409 let u_num = gl.getUniformLocation(p.program, "u_num"); 410 callback(u_num); 411 let uniform = gl.getUniform(p.program, u_num); 412 finish(uniform); 413 gl.deleteShader(p.vertexShader); 414 gl.deleteShader(p.fragmentShader); 415 gl.deleteProgram(p.program); 416 } 417 418 419 /** 420 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0014 421 * @tc.name webgl_test_uniform2f 422 * @tc.desc Test uniform2f. 423 */ 424 it('webgl_test_uniform2f', 0, async function (done) { 425 console.info("webgltest [webgl_test_uniform2f] uniform2f"); 426 let vSource = ` 427 attribute vec4 a_Position; 428 uniform vec2 u_num; 429 void main(){ 430 gl_Position.x = u_num.x; 431 gl_Position.y = u_num.y; 432 } 433 `; 434 let fSource = ` 435 precision mediump float; 436 void main(){ 437 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 438 } 439 ` 440 let p = createProgram(gl, vSource, fSource); 441 let u_num = gl.getUniformLocation(p.program, "u_num"); 442 console.info("webgltest fragmentShader source :", fSource); 443 console.info("webgltest uniform u_num:", u_num); 444 gl.uniform2f(u_num, 0.5, 0.5); 445 console.info("webgltest gl.uniform2f(u_num,0.5,0.5);"); 446 let uniform = gl.getUniform(p.program, u_num); 447 console.info("webgltest uniform u_num value:", uniform); 448 expect(uniform[0]).assertEqual(0.5); 449 expect(uniform[1]).assertEqual(0.5); 450 gl.deleteShader(p.vertexShader); 451 gl.deleteShader(p.fragmentShader); 452 gl.deleteProgram(p.program); 453 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 454 done(); 455 }) 456 457 458 /** 459 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0015 460 * @tc.name webgl_test_uniform2f_1 461 * @tc.desc Test uniform2f. 462 */ 463 it('webgl_test_uniform2f_1', 0, async function (done) { 464 console.info("webgltest [webgl_test_uniform2f_1] uniform2f"); 465 uniform2f((val) => { 466 gl.uniform2f(val, 0, 0); 467 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 468 }, val => { 469 expect(val[0]).assertEqual(0); 470 expect(val[1]).assertEqual(0); 471 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 472 }) 473 done(); 474 }) 475 476 477 /** 478 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0016 479 * @tc.name webgl_test_uniform2f_2 480 * @tc.desc Test uniform2f. 481 */ 482 it('webgl_test_uniform2f_2', 0, async function (done) { 483 console.info("webgltest [webgl_test_uniform2f_2] uniform2f"); 484 uniform2f((val) => { 485 gl.uniform2f(val, null, null); 486 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 487 }, val => { 488 expect(val[0]).assertEqual(0); 489 expect(val[1]).assertEqual(0); 490 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 491 }) 492 done(); 493 }) 494 495 496 /** 497 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0017 498 * @tc.name webgl_test_uniform2f_3 499 * @tc.desc Test uniform2f. 500 */ 501 it('webgl_test_uniform2f_3', 0, async function (done) { 502 console.info("webgltest [webgl_test_uniform2f_3] uniform2f"); 503 uniform2f((val) => { 504 gl.uniform2f(val, undefined, undefined); 505 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 506 }, val => { 507 expect(val[0].toString()).assertEqual("NaN"); 508 expect(val[1].toString()).assertEqual("NaN"); 509 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 510 }) 511 done(); 512 }) 513 514 function uniform3f(callback, finish) { 515 let vSource = ` 516 attribute vec4 a_Position; 517 uniform vec3 u_num; 518 void main(){ 519 gl_Position.x = u_num.x; 520 gl_Position.y = u_num.y; 521 gl_Position.z = u_num.z; 522 } 523 `; 524 let fSource = ` 525 precision mediump float; 526 void main(){ 527 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 528 } 529 ` 530 let p = createProgram(gl, vSource, fSource); 531 let u_num = gl.getUniformLocation(p.program, "u_num"); 532 callback(u_num); 533 let uniform = gl.getUniform(p.program, u_num); 534 finish(uniform); 535 gl.deleteShader(p.vertexShader); 536 gl.deleteShader(p.fragmentShader); 537 gl.deleteProgram(p.program); 538 } 539 540 541 /** 542 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0018 543 * @tc.name webgl_test_uniform3f 544 * @tc.desc Test uniform3f. 545 */ 546 it('webgl_test_uniform3f', 0, async function (done) { 547 console.info("webgltest [webgl_test_uniform3f] uniform3f"); 548 let vSource = ` 549 attribute vec4 a_Position; 550 uniform vec3 u_num; 551 void main(){ 552 gl_Position.x = u_num.x; 553 gl_Position.y = u_num.y; 554 gl_Position.z = u_num.z; 555 } 556 `; 557 let fSource = ` 558 precision mediump float; 559 void main(){ 560 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 561 } 562 ` 563 let p = createProgram(gl, vSource, fSource); 564 let u_num = gl.getUniformLocation(p.program, "u_num"); 565 console.info("webgltest fragmentShader source :", fSource); 566 console.info("webgltest uniform u_num:", u_num); 567 gl.uniform3f(u_num, 1.0, 0.5, 0.5); 568 console.info("webgltest gl.uniform3f(u_num,1.0,0.5,0.5);"); 569 let uniform = gl.getUniform(p.program, u_num); 570 console.info("webgltest uniform u_num value:", uniform); 571 expect(uniform[0]).assertEqual(1.0); 572 expect(uniform[1]).assertEqual(0.5); 573 expect(uniform[2]).assertEqual(0.5); 574 gl.deleteShader(p.vertexShader); 575 gl.deleteShader(p.fragmentShader); 576 gl.deleteProgram(p.program); 577 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 578 done(); 579 }) 580 581 582 /** 583 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0019 584 * @tc.name webgl_test_uniform3f_1 585 * @tc.desc Test uniform3f. 586 */ 587 it('webgl_test_uniform3f_1', 0, async function (done) { 588 console.info("webgltest [webgl_test_uniform3f_1] uniform3f"); 589 uniform3f((val) => { 590 gl.uniform3f(val, 0, 0, 0); 591 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 592 }, val => { 593 expect(val[0]).assertEqual(0); 594 expect(val[1]).assertEqual(0); 595 expect(val[2]).assertEqual(0); 596 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 597 }) 598 done(); 599 }) 600 601 602 /** 603 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0020 604 * @tc.name webgl_test_uniform3f_2 605 * @tc.desc Test uniform3f. 606 */ 607 it('webgl_test_uniform3f_2', 0, async function (done) { 608 console.info("webgltest [webgl_test_uniform3f_2] uniform3f"); 609 uniform3f((val) => { 610 gl.uniform3f(val, null, null, null); 611 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 612 }, val => { 613 expect(val[0]).assertEqual(0); 614 expect(val[1]).assertEqual(0); 615 expect(val[2]).assertEqual(0); 616 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 617 }) 618 done(); 619 }) 620 621 622 /** 623 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0021 624 * @tc.name webgl_test_uniform3f_3 625 * @tc.desc Test uniform3f. 626 */ 627 it('webgl_test_uniform3f_3', 0, async function (done) { 628 console.info("webgltest [webgl_test_uniform3f_3] uniform3f"); 629 uniform3f((val) => { 630 gl.uniform3f(val, undefined, undefined, undefined); 631 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 632 }, val => { 633 expect(val[0].toString()).assertEqual("NaN"); 634 expect(val[1].toString()).assertEqual("NaN"); 635 expect(val[2].toString()).assertEqual("NaN"); 636 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 637 }) 638 done(); 639 }) 640 641 function uniform4f(callback, finish) { 642 let vSource = ` 643 attribute vec4 a_Position; 644 uniform vec4 u_num; 645 void main(){ 646 gl_Position.x = u_num.x; 647 gl_Position.y = u_num.y; 648 gl_Position.z = u_num.z; 649 gl_Position.w = u_num.w; 650 } 651 `; 652 let fSource = ` 653 precision mediump float; 654 void main(){ 655 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 656 } 657 ` 658 let p = createProgram(gl, vSource, fSource); 659 let u_num = gl.getUniformLocation(p.program, "u_num"); 660 callback(u_num); 661 let uniform = gl.getUniform(p.program, u_num); 662 finish(uniform); 663 gl.deleteShader(p.vertexShader); 664 gl.deleteShader(p.fragmentShader); 665 gl.deleteProgram(p.program); 666 } 667 668 669 /** 670 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0022 671 * @tc.name webgl_test_uniform4f 672 * @tc.desc Test uniform4f. 673 */ 674 it('webgl_test_uniform4f', 0, async function (done) { 675 console.info("webgltest [webgl_test_uniform4f] uniform4f"); 676 let vSource = ` 677 attribute vec4 a_Position; 678 uniform vec4 u_num; 679 void main(){ 680 gl_Position.x = u_num.x; 681 gl_Position.y = u_num.y; 682 gl_Position.z = u_num.z; 683 gl_Position.w = u_num.w; 684 } 685 `; 686 let fSource = ` 687 precision mediump float; 688 void main(){ 689 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 690 } 691 ` 692 let p = createProgram(gl, vSource, fSource); 693 let u_num = gl.getUniformLocation(p.program, "u_num"); 694 console.info("webgltest fragmentShader source :", fSource); 695 console.info("webgltest uniform u_num:", u_num); 696 gl.uniform4f(u_num, 1.0, 0.5, 0.5, 1.0); 697 console.info("webgltest gl.uniform3f(u_num,1.0,0.5,0.5,1.0);"); 698 let uniform = gl.getUniform(p.program, u_num); 699 console.info("webgltest uniform u_num value:", uniform); 700 expect(uniform[0]).assertEqual(1.0); 701 expect(uniform[1]).assertEqual(0.5); 702 expect(uniform[2]).assertEqual(0.5); 703 expect(uniform[3]).assertEqual(1.0); 704 gl.deleteShader(p.vertexShader); 705 gl.deleteShader(p.fragmentShader); 706 gl.deleteProgram(p.program); 707 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 708 done(); 709 }) 710 711 712 /** 713 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0023 714 * @tc.name webgl_test_uniform4f_1 715 * @tc.desc Test uniform4f. 716 */ 717 it('webgl_test_uniform4f_1', 0, async function (done) { 718 console.info("webgltest [webgl_test_uniform4f_1] uniform4f"); 719 uniform4f((val) => { 720 gl.uniform4f(val, 0, 0, 0, 0); 721 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 722 }, val => { 723 expect(val[0]).assertEqual(0); 724 expect(val[1]).assertEqual(0); 725 expect(val[2]).assertEqual(0); 726 expect(val[3]).assertEqual(0); 727 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 728 }) 729 done(); 730 }) 731 732 733 /** 734 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0024 735 * @tc.name webgl_test_uniform4f_2 736 * @tc.desc Test uniform4f. 737 */ 738 it('webgl_test_uniform4f_2', 0, async function (done) { 739 console.info("webgltest [webgl_test_uniform4f_2] uniform4f"); 740 uniform4f((val) => { 741 gl.uniform4f(val, null, null, null, null); 742 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 743 }, val => { 744 expect(val[0]).assertEqual(0); 745 expect(val[1]).assertEqual(0); 746 expect(val[2]).assertEqual(0); 747 expect(val[3]).assertEqual(0); 748 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 749 }) 750 done(); 751 }) 752 753 754 /** 755 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0025 756 * @tc.name webgl_test_uniform4f_3 757 * @tc.desc Test uniform4f. 758 */ 759 it('webgl_test_uniform4f_3', 0, async function (done) { 760 console.info("webgltest [webgl_test_uniform4f_3] uniform4f"); 761 uniform4f((val) => { 762 gl.uniform4f(val, undefined, undefined, undefined, undefined); 763 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 764 }, val => { 765 expect(val[0].toString()).assertEqual("NaN"); 766 expect(val[1].toString()).assertEqual("NaN"); 767 expect(val[2].toString()).assertEqual("NaN"); 768 expect(val[3].toString()).assertEqual("NaN"); 769 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 770 }) 771 done(); 772 }) 773 774 function uniform1fv(callback, finish) { 775 let vSource = ` 776 attribute vec4 a_Position; 777 uniform float u_num; 778 void main(){ 779 gl_Position.x = u_num; 780 } 781 `; 782 let fSource = ` 783 precision mediump float; 784 void main(){ 785 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 786 } 787 ` 788 let p = createProgram(gl, vSource, fSource); 789 let u_num = gl.getUniformLocation(p.program, "u_num"); 790 callback(u_num); 791 let uniform = gl.getUniform(p.program, u_num); 792 finish(uniform); 793 gl.deleteShader(p.vertexShader); 794 gl.deleteShader(p.fragmentShader); 795 gl.deleteProgram(p.program); 796 } 797 798 799 /** 800 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0026 801 * @tc.name webgl_test_uniform1fv 802 * @tc.desc Test uniform1fv. 803 */ 804 it('webgl_test_uniform1fv', 0, async function (done) { 805 console.info("webgltest [webgl_test_uniform1fv] uniform1fv"); 806 let vSource = ` 807 attribute vec4 a_Position; 808 uniform float u_num; 809 void main(){ 810 gl_Position.x = u_num; 811 } 812 `; 813 let fSource = ` 814 precision mediump float; 815 void main(){ 816 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 817 } 818 ` 819 let p = createProgram(gl, vSource, fSource); 820 let u_num = gl.getUniformLocation(p.program, "u_num"); 821 console.info("webgltest fragmentShader source :", fSource); 822 console.info("webgltest uniform u_num:", u_num); 823 gl.uniform1fv(u_num, new Float32Array([1.0])); 824 console.info("webgltest gl.uniform1fv(u_num,new Float32Array([1.0]));"); 825 let uniform = gl.getUniform(p.program, u_num); 826 console.info("webgltest uniform u_num value:", uniform); 827 expect(uniform).assertEqual(1.0); 828 gl.deleteShader(p.vertexShader); 829 gl.deleteShader(p.fragmentShader); 830 gl.deleteProgram(p.program); 831 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 832 done(); 833 }) 834 835 836 /** 837 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0027 838 * @tc.name webgl_test_uniform1fv_1 839 * @tc.desc Test uniform1fv. 840 */ 841 it('webgl_test_uniform1fv_1', 0, async function (done) { 842 console.info("webgltest [webgl_test_uniform1fv_1] uniform1fv"); 843 uniform1fv((val) => { 844 gl.uniform1fv(val, [0]); 845 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 846 }, val => { 847 expect(val).assertEqual(0); 848 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 849 }) 850 done(); 851 }) 852 853 854 /** 855 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0028 856 * @tc.name webgl_test_uniform1fv_2 857 * @tc.desc Test uniform1fv. 858 */ 859 it('webgl_test_uniform1fv_2', 0, async function (done) { 860 console.info("webgltest [webgl_test_uniform1fv_2] uniform1fv"); 861 uniform1fv((val) => { 862 gl.uniform1fv(val, [null]); 863 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 864 }, val => { 865 expect(val).assertEqual(0); 866 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 867 }) 868 done(); 869 }) 870 871 872 /** 873 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0029 874 * @tc.name webgl_test_uniform1fv_3 875 * @tc.desc Test uniform1fv. 876 */ 877 it('webgl_test_uniform1fv_3', 0, async function (done) { 878 console.info("webgltest [webgl_test_uniform1fv_3] uniform1fv"); 879 uniform1fv((val) => { 880 gl.uniform1fv(val, [undefined]); 881 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 882 }, val => { 883 expect(val.toString()).assertEqual("NaN"); 884 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 885 }) 886 done(); 887 }) 888 889 function uniform2fv(callback, finish) { 890 let vSource = ` 891 attribute vec4 a_Position; 892 uniform vec2 u_num; 893 void main(){ 894 gl_Position.x = u_num.x; 895 gl_Position.y = u_num.y; 896 } 897 `; 898 let fSource = ` 899 precision mediump float; 900 void main(){ 901 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 902 } 903 `; 904 let p = createProgram(gl, vSource, fSource); 905 let u_num = gl.getUniformLocation(p.program, "u_num"); 906 callback(u_num); 907 let uniform = gl.getUniform(p.program, u_num); 908 finish(uniform); 909 gl.deleteShader(p.vertexShader); 910 gl.deleteShader(p.fragmentShader); 911 gl.deleteProgram(p.program); 912 } 913 914 915 /** 916 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0030 917 * @tc.name webgl_test_uniform2fv 918 * @tc.desc Test uniform2fv. 919 */ 920 it('webgl_test_uniform2fv', 0, async function (done) { 921 console.info("webgltest [webgl_test_uniform2fv] uniform2fv"); 922 let vSource = ` 923 attribute vec4 a_Position; 924 uniform vec2 u_num; 925 void main(){ 926 gl_Position.x = u_num.x; 927 gl_Position.y = u_num.y; 928 } 929 `; 930 let fSource = ` 931 precision mediump float; 932 void main(){ 933 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 934 } 935 ` 936 let p = createProgram(gl, vSource, fSource); 937 let u_num = gl.getUniformLocation(p.program, "u_num"); 938 console.info("webgltest fragmentShader source :", fSource); 939 console.info("webgltest uniform u_num:", u_num); 940 gl.uniform2fv(u_num, new Float32Array([1.0, 1.0])); 941 console.info("webgltest gl.uniform2fv(u_num,new Float32Array([1.0,1.0]));"); 942 let uniform = gl.getUniform(p.program, u_num); 943 console.info("webgltest uniform u_num value:", uniform); 944 expect(uniform[0]).assertEqual(1.0); 945 expect(uniform[1]).assertEqual(1.0); 946 gl.deleteShader(p.vertexShader); 947 gl.deleteShader(p.fragmentShader); 948 gl.deleteProgram(p.program); 949 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 950 done(); 951 }) 952 953 954 /** 955 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0031 956 * @tc.name webgl_test_uniform2fv_1 957 * @tc.desc Test uniform2fv. 958 */ 959 it('webgl_test_uniform2fv_1', 0, async function (done) { 960 console.info("webgltest [webgl_test_uniform2fv_1] uniform2fv"); 961 uniform2fv((val) => { 962 gl.uniform2fv(val, [0, 0]); 963 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 964 }, val => { 965 expect(val[0]).assertEqual(0); 966 expect(val[1]).assertEqual(0); 967 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 968 }) 969 done(); 970 }) 971 972 973 /** 974 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0032 975 * @tc.name webgl_test_uniform2fv_2 976 * @tc.desc Test uniform2fv. 977 */ 978 it('webgl_test_uniform2fv_2', 0, async function (done) { 979 console.info("webgltest [webgl_test_uniform2fv_2] uniform2fv"); 980 uniform2fv((val) => { 981 gl.uniform2fv(val, [null, null]); 982 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 983 }, val => { 984 expect(val[0]).assertEqual(0); 985 expect(val[1]).assertEqual(0); 986 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 987 }) 988 done(); 989 }) 990 991 992 /** 993 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0033 994 * @tc.name webgl_test_uniform2fv_3 995 * @tc.desc Test uniform2fv. 996 */ 997 it('webgl_test_uniform2fv_3', 0, async function (done) { 998 console.info("webgltest [webgl_test_uniform2fv_3] uniform2fv"); 999 uniform2fv((val) => { 1000 gl.uniform2fv(val, [undefined, undefined]); 1001 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1002 }, val => { 1003 expect(val[0].toString()).assertEqual("NaN"); 1004 expect(val[1].toString()).assertEqual("NaN"); 1005 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1006 }) 1007 done(); 1008 }) 1009 1010 function uniform3fv(callback, finish) { 1011 let vSource = ` 1012 attribute vec4 a_Position; 1013 uniform vec3 u_num; 1014 void main(){ 1015 gl_Position.x = u_num.x; 1016 gl_Position.y = u_num.y; 1017 gl_Position.z = u_num.z; 1018 } 1019 `; 1020 let fSource = ` 1021 precision mediump float; 1022 void main(){ 1023 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 1024 } 1025 ` 1026 let p = createProgram(gl, vSource, fSource); 1027 let u_num = gl.getUniformLocation(p.program, "u_num"); 1028 callback(u_num); 1029 let uniform = gl.getUniform(p.program, u_num); 1030 finish(uniform); 1031 gl.deleteShader(p.vertexShader); 1032 gl.deleteShader(p.fragmentShader); 1033 gl.deleteProgram(p.program); 1034 } 1035 1036 1037 /** 1038 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0034 1039 * @tc.name webgl_test_uniform3fv 1040 * @tc.desc Test uniform3fv. 1041 */ 1042 it('webgl_test_uniform3fv', 0, async function (done) { 1043 console.info("webgltest [webgl_test_uniform3fv] uniform3fv"); 1044 let vSource = ` 1045 attribute vec4 a_Position; 1046 uniform vec3 u_num; 1047 void main(){ 1048 gl_Position.x = u_num.x; 1049 gl_Position.y = u_num.y; 1050 gl_Position.z = u_num.z; 1051 } 1052 `; 1053 let fSource = ` 1054 precision mediump float; 1055 void main(){ 1056 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 1057 } 1058 ` 1059 let p = createProgram(gl, vSource, fSource); 1060 let u_num = gl.getUniformLocation(p.program, "u_num"); 1061 console.info("webgltest fragmentShader source :", fSource); 1062 console.info("webgltest uniform u_num:", u_num); 1063 gl.uniform3fv(u_num, new Float32Array([1.0, 1.0, 1.0])); 1064 console.info("webgltest gl.uniform3fv(u_num,new Float32Array([1.0,1.0,1.0]));"); 1065 let uniform = gl.getUniform(p.program, u_num); 1066 console.info("webgltest uniform u_num value:", uniform); 1067 expect(uniform[0]).assertEqual(1.0); 1068 expect(uniform[1]).assertEqual(1.0); 1069 expect(uniform[2]).assertEqual(1.0); 1070 gl.deleteShader(p.vertexShader); 1071 gl.deleteShader(p.fragmentShader); 1072 gl.deleteProgram(p.program); 1073 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1074 done(); 1075 }) 1076 1077 1078 /** 1079 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0035 1080 * @tc.name webgl_test_uniform3fv_1 1081 * @tc.desc Test uniform3fv. 1082 */ 1083 it('webgl_test_uniform3fv_1', 0, async function (done) { 1084 console.info("webgltest [webgl_test_uniform3fv_1] uniform3fv"); 1085 uniform3fv((val) => { 1086 gl.uniform3fv(val, [0, 0, 0]); 1087 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1088 }, val => { 1089 expect(val[0]).assertEqual(0); 1090 expect(val[1]).assertEqual(0); 1091 expect(val[2]).assertEqual(0); 1092 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1093 }) 1094 done(); 1095 }) 1096 1097 1098 /** 1099 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0036 1100 * @tc.name webgl_test_uniform3fv_2 1101 * @tc.desc Test uniform3fv. 1102 */ 1103 it('webgl_test_uniform3fv_2', 0, async function (done) { 1104 console.info("webgltest [webgl_test_uniform3fv_2] uniform3fv"); 1105 uniform3fv((val) => { 1106 gl.uniform3fv(val, [null, null, null]); 1107 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1108 }, val => { 1109 expect(val[0]).assertEqual(0); 1110 expect(val[1]).assertEqual(0); 1111 expect(val[2]).assertEqual(0); 1112 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1113 }) 1114 done(); 1115 }) 1116 1117 1118 /** 1119 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0037 1120 * @tc.name webgl_test_uniform3fv_3 1121 * @tc.desc Test uniform3fv. 1122 */ 1123 it('webgl_test_uniform3fv_3', 0, async function (done) { 1124 console.info("webgltest [webgl_test_uniform3fv_3] uniform3fv"); 1125 uniform3fv((val) => { 1126 gl.uniform3fv(val, [undefined, undefined, undefined]); 1127 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1128 }, val => { 1129 expect(val[0].toString()).assertEqual("NaN"); 1130 expect(val[1].toString()).assertEqual("NaN"); 1131 expect(val[2].toString()).assertEqual("NaN"); 1132 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1133 }) 1134 done(); 1135 }) 1136 1137 function uniform4fv(callback, finish) { 1138 let vSource = ` 1139 attribute vec4 a_Position; 1140 uniform vec4 u_num; 1141 void main(){ 1142 gl_Position.x = u_num.x; 1143 gl_Position.y = u_num.y; 1144 gl_Position.z = u_num.z; 1145 gl_Position.w = u_num.w; 1146 } 1147 `; 1148 let fSource = ` 1149 precision mediump float; 1150 void main(){ 1151 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 1152 } 1153 ` 1154 let p = createProgram(gl, vSource, fSource); 1155 let u_num = gl.getUniformLocation(p.program, "u_num"); 1156 callback(u_num); 1157 let uniform = gl.getUniform(p.program, u_num); 1158 finish(uniform); 1159 gl.deleteShader(p.vertexShader); 1160 gl.deleteShader(p.fragmentShader); 1161 gl.deleteProgram(p.program); 1162 } 1163 1164 1165 /** 1166 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0038 1167 * @tc.name webgl_test_uniform4fv 1168 * @tc.desc Test uniform4fv. 1169 */ 1170 it('webgl_test_uniform4fv', 0, async function (done) { 1171 console.info("webgltest [webgl_test_uniform4fv] uniform4fv"); 1172 let vSource = ` 1173 attribute vec4 a_Position; 1174 uniform vec4 u_num; 1175 void main(){ 1176 gl_Position.x = u_num.x; 1177 gl_Position.y = u_num.y; 1178 gl_Position.z = u_num.z; 1179 gl_Position.w = u_num.w; 1180 } 1181 `; 1182 let fSource = ` 1183 precision mediump float; 1184 void main(){ 1185 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 1186 } 1187 ` 1188 let p = createProgram(gl, vSource, fSource); 1189 let u_num = gl.getUniformLocation(p.program, "u_num"); 1190 console.info("webgltest fragmentShader source :", fSource); 1191 console.info("webgltest uniform u_num:", u_num); 1192 gl.uniform4fv(u_num, new Float32Array([1.0, 1.0, 1.0, 1.0])); 1193 console.info("webgltest gl.uniform4fv(u_num,new Float32Array([1.0,1.0,1.0,1.0]));"); 1194 let uniform = gl.getUniform(p.program, u_num); 1195 console.info("webgltest uniform u_num value:", uniform); 1196 expect(uniform[0]).assertEqual(1.0); 1197 expect(uniform[1]).assertEqual(1.0); 1198 expect(uniform[2]).assertEqual(1.0); 1199 expect(uniform[3]).assertEqual(1.0); 1200 gl.deleteShader(p.vertexShader); 1201 gl.deleteShader(p.fragmentShader); 1202 gl.deleteProgram(p.program); 1203 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1204 done(); 1205 }) 1206 1207 1208 /** 1209 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0039 1210 * @tc.name webgl_test_uniform4fv_1 1211 * @tc.desc Test uniform4fv. 1212 */ 1213 it('webgl_test_uniform4fv_1', 0, async function (done) { 1214 console.info("webgltest [webgl_test_uniform4fv_1] uniform4fv"); 1215 uniform4fv((val) => { 1216 gl.uniform4fv(val, [0, 0, 0, 0]); 1217 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1218 }, val => { 1219 expect(val[0]).assertEqual(0); 1220 expect(val[1]).assertEqual(0); 1221 expect(val[2]).assertEqual(0); 1222 expect(val[3]).assertEqual(0); 1223 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1224 }) 1225 done(); 1226 }) 1227 1228 1229 /** 1230 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0040 1231 * @tc.name webgl_test_uniform4fv_2 1232 * @tc.desc Test uniform4fv. 1233 */ 1234 it('webgl_test_uniform4fv_2', 0, async function (done) { 1235 console.info("webgltest [webgl_test_uniform4fv_2] uniform4fv"); 1236 uniform4fv((val) => { 1237 gl.uniform4fv(val, [null, null, null, null]); 1238 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1239 }, val => { 1240 expect(val[0]).assertEqual(0); 1241 expect(val[1]).assertEqual(0); 1242 expect(val[2]).assertEqual(0); 1243 expect(val[3]).assertEqual(0); 1244 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1245 }) 1246 done(); 1247 }) 1248 1249 1250 /** 1251 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0041 1252 * @tc.name webgl_test_uniform4fv_3 1253 * @tc.desc Test uniform4fv. 1254 */ 1255 it('webgl_test_uniform4fv_3', 0, async function (done) { 1256 console.info("webgltest [webgl_test_uniform4fv_3] uniform4fv"); 1257 uniform4fv((val) => { 1258 gl.uniform4fv(val, [undefined, undefined, undefined, undefined]); 1259 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1260 }, val => { 1261 expect(val[0].toString()).assertEqual("NaN"); 1262 expect(val[1].toString()).assertEqual("NaN"); 1263 expect(val[2].toString()).assertEqual("NaN"); 1264 expect(val[3].toString()).assertEqual("NaN"); 1265 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1266 }) 1267 done(); 1268 }) 1269 1270 function uniform1i(callback, finish) { 1271 let vSource = ` 1272 attribute vec4 a_Position; 1273 uniform int u_num; 1274 void main(){ 1275 gl_Position.x = float(u_num); 1276 } 1277 `; 1278 let fSource = ` 1279 precision mediump float; 1280 void main(){ 1281 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 1282 } 1283 ` 1284 let p = createProgram(gl, vSource, fSource); 1285 let u_num = gl.getUniformLocation(p.program, "u_num"); 1286 callback(u_num); 1287 let uniform = gl.getUniform(p.program, u_num); 1288 finish(uniform); 1289 gl.deleteShader(p.vertexShader); 1290 gl.deleteShader(p.fragmentShader); 1291 gl.deleteProgram(p.program); 1292 } 1293 1294 1295 /** 1296 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0042 1297 * @tc.name webgl_test_uniform1i 1298 * @tc.desc Test uniform1i. 1299 */ 1300 it('webgl_test_uniform1i', 0, async function (done) { 1301 console.info("webgltest [webgl_test_uniform1i] uniform1i"); 1302 let vSource = ` 1303 attribute vec4 a_Position; 1304 attribute vec2 a_TexCoord; 1305 varying vec2 v_TexCoord; 1306 void main(){ 1307 gl_Position.x = 0.5; 1308 v_TexCoord = a_TexCoord; 1309 } 1310 `; 1311 let fSource = ` 1312 precision mediump float; 1313 precision highp sampler2D; 1314 uniform sampler2D u_Sampler; 1315 varying vec2 v_TexCoord; 1316 void main(){ 1317 gl_FragColor = texture2D(u_Sampler, v_TexCoord); 1318 } 1319 ` 1320 let p = createProgram(gl, vSource, fSource); 1321 let u_Sampler = gl.getUniformLocation(p.program, "u_Sampler"); 1322 console.info("webgltest fragmentShader source :", fSource); 1323 console.info("webgltest uniform u_Sampler:", u_Sampler); 1324 gl.uniform1i(u_Sampler, 1); 1325 console.info("webgltest gl.uniform1i(u_Sampler,1);"); 1326 let uniform = gl.getUniform(p.program, u_Sampler); 1327 console.info("webgltest uniform u_Sampler value:", uniform); 1328 expect(uniform).assertEqual(1); 1329 gl.deleteShader(p.vertexShader); 1330 gl.deleteShader(p.fragmentShader); 1331 gl.deleteProgram(p.program); 1332 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1333 done(); 1334 }) 1335 1336 1337 /** 1338 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0043 1339 * @tc.name webgl_test_uniform1i_1 1340 * @tc.desc Test uniform1i. 1341 */ 1342 it('webgl_test_uniform1i_1', 0, async function (done) { 1343 console.info("webgltest [webgl_test_uniform1i_1] uniform1i"); 1344 uniform1i((val) => { 1345 gl.uniform1i(val, 1); 1346 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1347 }, val => { 1348 expect(val).assertEqual(1); 1349 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1350 }) 1351 done(); 1352 }) 1353 1354 1355 /** 1356 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0044 1357 * @tc.name webgl_test_uniform1i_2 1358 * @tc.desc Test uniform1i. 1359 */ 1360 it('webgl_test_uniform1i_2', 0, async function (done) { 1361 console.info("webgltest [webgl_test_uniform1i_2] uniform1i"); 1362 uniform1i((val) => { 1363 gl.uniform1i(val, null); 1364 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1365 }, val => { 1366 expect(val).assertEqual(0); 1367 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1368 }) 1369 done(); 1370 }) 1371 1372 1373 /** 1374 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0045 1375 * @tc.name webgl_test_uniform1i_3 1376 * @tc.desc Test uniform1i. 1377 */ 1378 it('webgl_test_uniform1i_3', 0, async function (done) { 1379 console.info("webgltest [webgl_test_uniform1i_3] uniform1i"); 1380 uniform1i((val) => { 1381 gl.uniform1i(val, undefined); 1382 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1383 }, val => { 1384 expect(val).assertEqual(0); 1385 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1386 }) 1387 done(); 1388 }) 1389 1390 function uniform1iv(callback, finish) { 1391 let vSource = ` 1392 attribute vec4 a_Position; 1393 attribute vec2 a_TexCoord; 1394 varying vec2 v_TexCoord; 1395 void main(){ 1396 gl_Position.x = 0.5; 1397 v_TexCoord = a_TexCoord; 1398 } 1399 `; 1400 let fSource = ` 1401 precision mediump float; 1402 precision highp sampler2D; 1403 uniform sampler2D u_Sampler; 1404 varying vec2 v_TexCoord; 1405 void main(){ 1406 gl_FragColor = texture2D(u_Sampler, v_TexCoord); 1407 } 1408 ` 1409 let p = createProgram(gl, vSource, fSource); 1410 let u_Sampler = gl.getUniformLocation(p.program, "u_Sampler"); 1411 callback(u_Sampler); 1412 let uniform = gl.getUniform(p.program, u_Sampler); 1413 finish(uniform); 1414 gl.deleteShader(p.vertexShader); 1415 gl.deleteShader(p.fragmentShader); 1416 gl.deleteProgram(p.program); 1417 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1418 } 1419 1420 1421 /** 1422 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0046 1423 * @tc.name webgl_test_uniform1iv 1424 * @tc.desc Test uniform1iv. 1425 */ 1426 it('webgl_test_uniform1iv', 0, async function (done) { 1427 console.info("webgltest [webgl_test_uniform1iv] uniform1iv"); 1428 let vSource = ` 1429 attribute vec4 a_Position; 1430 attribute vec2 a_TexCoord; 1431 varying vec2 v_TexCoord; 1432 void main(){ 1433 gl_Position.x = 0.5; 1434 v_TexCoord = a_TexCoord; 1435 } 1436 `; 1437 let fSource = ` 1438 precision mediump float; 1439 precision highp sampler2D; 1440 uniform sampler2D u_Sampler; 1441 varying vec2 v_TexCoord; 1442 void main(){ 1443 gl_FragColor = texture2D(u_Sampler, v_TexCoord); 1444 } 1445 ` 1446 let p = createProgram(gl, vSource, fSource); 1447 let u_Sampler = gl.getUniformLocation(p.program, "u_Sampler"); 1448 console.info("webgltest fragmentShader source :", fSource); 1449 console.info("webgltest uniform u_Sampler:", u_Sampler); 1450 gl.uniform1iv(u_Sampler, new Int32Array([1])); 1451 console.info("webgltest gl.uniform1iv(u_Sampler,new Int32Array([1]));"); 1452 let uniform = gl.getUniform(p.program, u_Sampler); 1453 console.info("webgltest uniform u_Sampler value:", uniform); 1454 expect(uniform).assertEqual(1); 1455 gl.deleteShader(p.vertexShader); 1456 gl.deleteShader(p.fragmentShader); 1457 gl.deleteProgram(p.program); 1458 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1459 done(); 1460 }) 1461 1462 1463 /** 1464 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0047 1465 * @tc.name webgl_test_uniform1iv_1 1466 * @tc.desc Test uniform1iv. 1467 */ 1468 it('webgl_test_uniform1iv_1', 0, async function (done) { 1469 console.info("webgltest [webgl_test_uniform1iv_1] uniform1iv"); 1470 uniform1iv((val) => { 1471 gl.uniform1iv(val, [1]); 1472 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1473 }, val => { 1474 expect(val).assertEqual(1); 1475 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1476 }) 1477 done(); 1478 }) 1479 1480 1481 /** 1482 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0048 1483 * @tc.name webgl_test_uniform1iv_2 1484 * @tc.desc Test uniform1iv. 1485 */ 1486 it('webgl_test_uniform1iv_2', 0, async function (done) { 1487 console.info("webgltest [webgl_test_uniform1iv_2] uniform1iv"); 1488 uniform1iv((val) => { 1489 gl.uniform1iv(val, [null]); 1490 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1491 }, val => { 1492 expect(val).assertEqual(0); 1493 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1494 }) 1495 done(); 1496 }) 1497 1498 1499 /** 1500 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0049 1501 * @tc.name webgl_test_uniform1iv_3 1502 * @tc.desc Test uniform1iv. 1503 */ 1504 it('webgl_test_uniform1iv_3', 0, async function (done) { 1505 console.info("webgltest [webgl_test_uniform1iv_3] uniform1iv"); 1506 uniform1iv((val) => { 1507 gl.uniform1iv(val, [undefined]); 1508 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1509 }, val => { 1510 expect(val).assertEqual(0); 1511 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1512 }) 1513 done(); 1514 }) 1515 1516 function uniform2iv(callback, finish) { 1517 let vSource = ` 1518 uniform ivec2 a_Position; 1519 void main(){ 1520 gl_Position.x = float(a_Position.x); 1521 gl_Position.y = float(a_Position.y); 1522 } 1523 `; 1524 let fSource = ` 1525 precision mediump float; 1526 precision highp sampler2D; 1527 void main(){ 1528 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 1529 } 1530 ` 1531 let p = createProgram(gl, vSource, fSource); 1532 let a_Position = gl.getUniformLocation(p.program, "a_Position"); 1533 callback(a_Position); 1534 let uniform = gl.getUniform(p.program, a_Position); 1535 finish(uniform); 1536 gl.deleteShader(p.vertexShader); 1537 gl.deleteShader(p.fragmentShader); 1538 gl.deleteProgram(p.program); 1539 } 1540 1541 1542 /** 1543 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0050 1544 * @tc.name webgl_test_uniform2iv 1545 * @tc.desc Test uniform2iv. 1546 */ 1547 it('webgl_test_uniform2iv', 0, async function (done) { 1548 console.info("webgltest [webgl_test_uniform2iv] uniform2iv"); 1549 let vSource = ` 1550 uniform ivec2 a_Position; 1551 void main(){ 1552 gl_Position.x = float(a_Position.x); 1553 gl_Position.y = float(a_Position.y); 1554 } 1555 `; 1556 let fSource = ` 1557 precision mediump float; 1558 precision highp sampler2D; 1559 void main(){ 1560 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 1561 } 1562 ` 1563 let p = createProgram(gl, vSource, fSource); 1564 let a_Position = gl.getUniformLocation(p.program, "a_Position"); 1565 console.info("webgltest fragmentShader source :", vSource); 1566 console.info("webgltest uniform u_Sampler:", a_Position); 1567 gl.uniform2iv(a_Position, new Int32Array([1, 1])); 1568 console.info("webgltest gl.uniform2iv(a_Position,new Int32Array([1,1]));"); 1569 let uniform = gl.getUniform(p.program, a_Position); 1570 console.info("webgltest uniform u_Sampler value:", uniform); 1571 expect(uniform[0]).assertEqual(1); 1572 expect(uniform[1]).assertEqual(1); 1573 gl.deleteShader(p.vertexShader); 1574 gl.deleteShader(p.fragmentShader); 1575 gl.deleteProgram(p.program); 1576 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1577 done(); 1578 }) 1579 1580 1581 /** 1582 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0051 1583 * @tc.name webgl_test_uniform2iv_1 1584 * @tc.desc Test uniform2iv. 1585 */ 1586 it('webgl_test_uniform2iv_1', 0, async function (done) { 1587 console.info("webgltest [webgl_test_uniform2iv_1] uniform2iv"); 1588 uniform2iv((val) => { 1589 gl.uniform2iv(val, [1, 1]); 1590 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1591 }, val => { 1592 expect(val[0]).assertEqual(1); 1593 expect(val[1]).assertEqual(1); 1594 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1595 }) 1596 done(); 1597 }) 1598 1599 1600 /** 1601 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0052 1602 * @tc.name webgl_test_uniform2iv_2 1603 * @tc.desc Test uniform2iv. 1604 */ 1605 it('webgl_test_uniform2iv_2', 0, async function (done) { 1606 console.info("webgltest [webgl_test_uniform2iv_2] uniform2iv"); 1607 uniform2iv((val) => { 1608 gl.uniform2iv(val, [null, null]); 1609 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1610 }, val => { 1611 expect(val[0]).assertEqual(0); 1612 expect(val[1]).assertEqual(0); 1613 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1614 }) 1615 done(); 1616 }) 1617 1618 1619 /** 1620 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0053 1621 * @tc.name webgl_test_uniform2iv_3 1622 * @tc.desc Test uniform2iv. 1623 */ 1624 it('webgl_test_uniform2iv_3', 0, async function (done) { 1625 console.info("webgltest [webgl_test_uniform2iv_3] uniform2iv"); 1626 uniform2iv((val) => { 1627 gl.uniform2iv(val, [undefined, undefined]); 1628 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1629 }, val => { 1630 expect(val[0]).assertEqual(0); 1631 expect(val[1]).assertEqual(0); 1632 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1633 }) 1634 done(); 1635 }) 1636 1637 function uniform3iv(callback, finish) { 1638 let vSource = ` 1639 uniform ivec3 a_Position; 1640 void main(){ 1641 gl_Position.x = float(a_Position.x); 1642 gl_Position.y = float(a_Position.y); 1643 gl_Position.z = float(a_Position.z); 1644 } 1645 `; 1646 let fSource = ` 1647 precision mediump float; 1648 precision highp sampler2D; 1649 void main(){ 1650 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 1651 } 1652 ` 1653 let p = createProgram(gl, vSource, fSource); 1654 let a_Position = gl.getUniformLocation(p.program, "a_Position"); 1655 callback(a_Position); 1656 let uniform = gl.getUniform(p.program, a_Position); 1657 finish(uniform); 1658 gl.deleteShader(p.vertexShader); 1659 gl.deleteShader(p.fragmentShader); 1660 gl.deleteProgram(p.program); 1661 } 1662 1663 1664 /** 1665 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0054 1666 * @tc.name webgl_test_uniform3iv 1667 * @tc.desc Test uniform3iv. 1668 */ 1669 it('webgl_test_uniform3iv', 0, async function (done) { 1670 console.info("webgltest [webgl_test_uniform3iv] uniform3iv"); 1671 let vSource = ` 1672 uniform ivec3 a_Position1; 1673 uniform ivec3 a_Position2; 1674 void main(){ 1675 gl_Position.x = float(a_Position1.x + a_Position2.x); 1676 gl_Position.y = float(a_Position1.y + a_Position2.y); 1677 gl_Position.z = float(a_Position1.z + a_Position2.z); 1678 } 1679 `; 1680 let fSource = ` 1681 precision mediump float; 1682 precision highp sampler2D; 1683 void main(){ 1684 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 1685 } 1686 ` 1687 let p = createProgram(gl, vSource, fSource); 1688 let a_Position1 = gl.getUniformLocation(p.program, "a_Position1"); 1689 let a_Position2 = gl.getUniformLocation(p.program, "a_Position2"); 1690 console.info("webgltest fragmentShader source :", vSource); 1691 console.info("webgltest uniform u_Sampler:", a_Position1,a_Position2); 1692 gl.uniform3iv(a_Position1, new Int32Array([1, 1, 1])); 1693 gl.uniform3iv(a_Position2, new Int32Array([2, 2, 2])); 1694 console.info("webgltest gl.uniform3iv(a_Position1,new Int32Array([1,1,1]));"); 1695 console.info("webgltest gl.uniform3iv(a_Position2,new Int32Array([2,2,2]));"); 1696 let uniform1 = gl.getUniform(p.program, a_Position1); 1697 let uniform2 = gl.getUniform(p.program, a_Position2); 1698 console.info("webgltest uniform1 value:", uniform1); 1699 console.info("webgltest uniform2 value:", uniform2); 1700 expect(uniform1[0]).assertEqual(1); 1701 expect(uniform1[1]).assertEqual(1); 1702 expect(uniform1[2]).assertEqual(1); 1703 expect(uniform2[0]).assertEqual(2); 1704 expect(uniform2[1]).assertEqual(2); 1705 expect(uniform2[2]).assertEqual(2); 1706 gl.deleteShader(p.vertexShader); 1707 gl.deleteShader(p.fragmentShader); 1708 gl.deleteProgram(p.program); 1709 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1710 done(); 1711 }) 1712 1713 1714 /** 1715 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0055 1716 * @tc.name webgl_test_uniform3iv_1 1717 * @tc.desc Test uniform3iv. 1718 */ 1719 it('webgl_test_uniform3iv_1', 0, async function (done) { 1720 console.info("webgltest [webgl_test_uniform3iv_1] uniform3iv"); 1721 uniform3iv((val) => { 1722 gl.uniform3iv(val, [1, 1, 1]); 1723 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1724 }, val => { 1725 expect(val[0]).assertEqual(1); 1726 expect(val[1]).assertEqual(1); 1727 expect(val[2]).assertEqual(1); 1728 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1729 }) 1730 done(); 1731 }) 1732 1733 1734 /** 1735 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0056 1736 * @tc.name webgl_test_uniform3iv_2 1737 * @tc.desc Test uniform3iv. 1738 */ 1739 it('webgl_test_uniform3iv_2', 0, async function (done) { 1740 console.info("webgltest [webgl_test_uniform3iv_2] uniform3iv"); 1741 uniform3iv((val) => { 1742 gl.uniform3iv(val, [null, null, null]); 1743 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1744 }, val => { 1745 expect(val[0]).assertEqual(0); 1746 expect(val[1]).assertEqual(0); 1747 expect(val[2]).assertEqual(0); 1748 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1749 }) 1750 done(); 1751 }) 1752 1753 1754 /** 1755 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0057 1756 * @tc.name webgl_test_uniform3iv_3 1757 * @tc.desc Test uniform3iv. 1758 */ 1759 it('webgl_test_uniform3iv_3', 0, async function (done) { 1760 console.info("webgltest [webgl_test_uniform3iv_3] uniform3iv"); 1761 uniform3iv((val) => { 1762 gl.uniform3iv(val, [undefined, undefined, undefined]); 1763 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1764 }, val => { 1765 expect(val[0]).assertEqual(0); 1766 expect(val[1]).assertEqual(0); 1767 expect(val[2]).assertEqual(0); 1768 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1769 }) 1770 done(); 1771 }) 1772 1773 function uniform4iv(callback, finish) { 1774 let vSource = ` 1775 uniform ivec4 a_Position; 1776 void main(){ 1777 gl_Position.x = float(a_Position.x); 1778 gl_Position.y = float(a_Position.y); 1779 gl_Position.z = float(a_Position.z); 1780 gl_Position.w = float(a_Position.w); 1781 } 1782 `; 1783 let fSource = ` 1784 precision mediump float; 1785 precision highp sampler2D; 1786 void main(){ 1787 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 1788 } 1789 ` 1790 let p = createProgram(gl, vSource, fSource); 1791 let a_Position = gl.getUniformLocation(p.program, "a_Position"); 1792 callback(a_Position); 1793 let uniform = gl.getUniform(p.program, a_Position); 1794 finish(uniform); 1795 gl.deleteShader(p.vertexShader); 1796 gl.deleteShader(p.fragmentShader); 1797 gl.deleteProgram(p.program); 1798 } 1799 1800 1801 /** 1802 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0058 1803 * @tc.name webgl_test_uniform4iv 1804 * @tc.desc Test uniform4iv. 1805 */ 1806 it('webgl_test_uniform4iv', 0, async function (done) { 1807 console.info("webgltest [webgl_test_uniform4iv] uniform4iv"); 1808 let vSource = ` 1809 uniform ivec4 a_Position; 1810 void main(){ 1811 gl_Position.x = float(a_Position.x); 1812 gl_Position.y = float(a_Position.y); 1813 gl_Position.z = float(a_Position.z); 1814 gl_Position.w = float(a_Position.w); 1815 } 1816 `; 1817 let fSource = ` 1818 precision mediump float; 1819 precision highp sampler2D; 1820 void main(){ 1821 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 1822 } 1823 ` 1824 let p = createProgram(gl, vSource, fSource); 1825 let a_Position = gl.getUniformLocation(p.program, "a_Position"); 1826 console.info("webgltest fragmentShader source :", vSource); 1827 console.info("webgltest uniform u_Sampler:", a_Position); 1828 gl.uniform4iv(a_Position, new Int32Array([1, 1, 1, 1])); 1829 console.info("webgltest gl.uniform4iv(a_Position,new Int32Array([1,1,1,1]));"); 1830 let uniform = gl.getUniform(p.program, a_Position); 1831 console.info("webgltest uniform u_Sampler value:", uniform); 1832 expect(uniform[0]).assertEqual(1); 1833 expect(uniform[1]).assertEqual(1); 1834 expect(uniform[2]).assertEqual(1); 1835 expect(uniform[3]).assertEqual(1); 1836 gl.deleteShader(p.vertexShader); 1837 gl.deleteShader(p.fragmentShader); 1838 gl.deleteProgram(p.program); 1839 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1840 done(); 1841 }) 1842 1843 1844 /** 1845 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0059 1846 * @tc.name webgl_test_uniform4iv_1 1847 * @tc.desc Test uniform4iv. 1848 */ 1849 it('webgl_test_uniform4iv_1', 0, async function (done) { 1850 console.info("webgltest [webgl_test_uniform4iv_1] uniform4iv"); 1851 uniform4iv((val) => { 1852 gl.uniform4iv(val, [1, 1, 1, 1]); 1853 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1854 }, val => { 1855 expect(val[0]).assertEqual(1); 1856 expect(val[1]).assertEqual(1); 1857 expect(val[2]).assertEqual(1); 1858 expect(val[3]).assertEqual(1); 1859 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1860 }) 1861 done(); 1862 }) 1863 1864 1865 /** 1866 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0060 1867 * @tc.name webgl_test_uniform4iv_2 1868 * @tc.desc Test uniform4iv. 1869 */ 1870 it('webgl_test_uniform4iv_2', 0, async function (done) { 1871 console.info("webgltest [webgl_test_uniform4iv_2] uniform4iv"); 1872 uniform4iv((val) => { 1873 gl.uniform4iv(val, [null, null, null, null]); 1874 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1875 }, val => { 1876 expect(val[0]).assertEqual(0); 1877 expect(val[1]).assertEqual(0); 1878 expect(val[2]).assertEqual(0); 1879 expect(val[3]).assertEqual(0); 1880 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1881 }) 1882 done(); 1883 }) 1884 1885 1886 /** 1887 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0061 1888 * @tc.name webgl_test_uniform4iv_3 1889 * @tc.desc Test uniform4iv. 1890 */ 1891 it('webgl_test_uniform4iv_3', 0, async function (done) { 1892 console.info("webgltest [webgl_test_uniform4iv_3] uniform4iv"); 1893 uniform4iv((val) => { 1894 gl.uniform4iv(val, [undefined, undefined, undefined, undefined]); 1895 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1896 }, val => { 1897 expect(val[0]).assertEqual(0); 1898 expect(val[1]).assertEqual(0); 1899 expect(val[2]).assertEqual(0); 1900 expect(val[3]).assertEqual(0); 1901 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1902 }) 1903 done(); 1904 }) 1905 1906 function uniform2i(callback, finish) { 1907 let vSource = ` 1908 uniform ivec2 a_Position; 1909 void main(){ 1910 gl_Position.x = float(a_Position.x); 1911 gl_Position.y = float(a_Position.y); 1912 } 1913 `; 1914 let fSource = ` 1915 precision mediump float; 1916 precision highp sampler2D; 1917 void main(){ 1918 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 1919 } 1920 ` 1921 let p = createProgram(gl, vSource, fSource); 1922 let a_Position = gl.getUniformLocation(p.program, "a_Position"); 1923 callback(a_Position); 1924 let uniform = gl.getUniform(p.program, a_Position); 1925 finish(uniform); 1926 gl.deleteShader(p.vertexShader); 1927 gl.deleteShader(p.fragmentShader); 1928 gl.deleteProgram(p.program); 1929 } 1930 1931 1932 /** 1933 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0062 1934 * @tc.name webgl_test_uniform2i 1935 * @tc.desc Test uniform2i. 1936 */ 1937 it('webgl_test_uniform2i', 0, async function (done) { 1938 console.info("webgltest [webgl_test_uniform2i] uniform2i"); 1939 let vSource = ` 1940 uniform ivec2 a_Position; 1941 void main(){ 1942 gl_Position.x = float(a_Position.x); 1943 gl_Position.y = float(a_Position.y); 1944 } 1945 `; 1946 let fSource = ` 1947 precision mediump float; 1948 precision highp sampler2D; 1949 void main(){ 1950 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 1951 } 1952 ` 1953 let p = createProgram(gl, vSource, fSource); 1954 let a_Position = gl.getUniformLocation(p.program, "a_Position"); 1955 console.info("webgltest fragmentShader source :", vSource); 1956 console.info("webgltest uniform u_Sampler:", a_Position); 1957 gl.uniform2i(a_Position, 1, 1); 1958 console.info("webgltest gl.uniform2i(u_Sampler,1,1);"); 1959 let uniform = gl.getUniform(p.program, a_Position); 1960 console.info("webgltest uniform u_Sampler value:", uniform); 1961 expect(uniform[0]).assertEqual(1); 1962 expect(uniform[1]).assertEqual(1); 1963 gl.deleteShader(p.vertexShader); 1964 gl.deleteShader(p.fragmentShader); 1965 gl.deleteProgram(p.program); 1966 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1967 done(); 1968 }) 1969 1970 1971 /** 1972 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0063 1973 * @tc.name webgl_test_uniform2i_1 1974 * @tc.desc Test uniform2i. 1975 */ 1976 it('webgl_test_uniform2i_1', 0, async function (done) { 1977 console.info("webgltest [webgl_test_uniform2i_1] uniform2i"); 1978 uniform2i((val) => { 1979 gl.uniform2i(val, 1, 1); 1980 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1981 }, val => { 1982 expect(val[0]).assertEqual(1); 1983 expect(val[1]).assertEqual(1); 1984 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 1985 }) 1986 done(); 1987 }) 1988 1989 1990 /** 1991 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0064 1992 * @tc.name webgl_test_uniform2i_2 1993 * @tc.desc Test uniform2i. 1994 */ 1995 it('webgl_test_uniform2i_2', 0, async function (done) { 1996 console.info("webgltest [webgl_test_uniform2i_2] uniform2i"); 1997 uniform2i((val) => { 1998 gl.uniform2i(val, null, null); 1999 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2000 }, val => { 2001 expect(val[0]).assertEqual(0); 2002 expect(val[1]).assertEqual(0); 2003 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2004 }) 2005 done(); 2006 }) 2007 2008 2009 /** 2010 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0065 2011 * @tc.name webgl_test_uniform2i_3 2012 * @tc.desc Test uniform2i. 2013 */ 2014 it('webgl_test_uniform2i_3', 0, async function (done) { 2015 console.info("webgltest [webgl_test_uniform2i_3] uniform2i"); 2016 uniform2i((val) => { 2017 gl.uniform2i(val, undefined, undefined); 2018 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2019 }, val => { 2020 expect(val[0]).assertEqual(0); 2021 expect(val[1]).assertEqual(0); 2022 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2023 }) 2024 done(); 2025 }) 2026 2027 function uniform3i(callback, finish) { 2028 let vSource = ` 2029 uniform ivec3 a_Position; 2030 void main(){ 2031 gl_Position.x = float(a_Position.x); 2032 gl_Position.y = float(a_Position.y); 2033 gl_Position.z = float(a_Position.z); 2034 } 2035 `; 2036 let fSource = ` 2037 precision mediump float; 2038 precision highp sampler2D; 2039 void main(){ 2040 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 2041 } 2042 ` 2043 let p = createProgram(gl, vSource, fSource); 2044 let a_Position = gl.getUniformLocation(p.program, "a_Position"); 2045 callback(a_Position); 2046 let uniform = gl.getUniform(p.program, a_Position); 2047 finish(uniform); 2048 gl.deleteShader(p.vertexShader); 2049 gl.deleteShader(p.fragmentShader); 2050 gl.deleteProgram(p.program); 2051 } 2052 2053 2054 /** 2055 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0066 2056 * @tc.name webgl_test_uniform3i 2057 * @tc.desc Test uniform3i. 2058 */ 2059 it('webgl_test_uniform3i', 0, async function (done) { 2060 console.info("webgltest [webgl_test_uniform3i] uniform3i"); 2061 let vSource = ` 2062 uniform ivec3 a_Position; 2063 void main(){ 2064 gl_Position.x = float(a_Position.x); 2065 gl_Position.y = float(a_Position.y); 2066 gl_Position.z = float(a_Position.z); 2067 } 2068 `; 2069 let fSource = ` 2070 precision mediump float; 2071 precision highp sampler2D; 2072 void main(){ 2073 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 2074 } 2075 ` 2076 let p = createProgram(gl, vSource, fSource); 2077 let a_Position = gl.getUniformLocation(p.program, "a_Position"); 2078 console.info("webgltest fragmentShader source :", vSource); 2079 console.info("webgltest uniform u_Sampler:", a_Position); 2080 gl.uniform3i(a_Position, 1, 1, 1); 2081 console.info("webgltest gl.uniform3i(a_Position,1,1,1);"); 2082 let uniform = gl.getUniform(p.program, a_Position); 2083 console.info("webgltest uniform u_Sampler value:", uniform); 2084 expect(uniform[0]).assertEqual(1); 2085 expect(uniform[1]).assertEqual(1); 2086 expect(uniform[2]).assertEqual(1); 2087 gl.deleteShader(p.vertexShader); 2088 gl.deleteShader(p.fragmentShader); 2089 gl.deleteProgram(p.program); 2090 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2091 done(); 2092 }) 2093 2094 2095 /** 2096 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0067 2097 * @tc.name webgl_test_uniform3i_1 2098 * @tc.desc Test uniform3i. 2099 */ 2100 it('webgl_test_uniform3i_1', 0, async function (done) { 2101 console.info("webgltest [webgl_test_uniform3i_1] uniform3i"); 2102 uniform3i((val) => { 2103 gl.uniform3i(val, 1, 1, 1); 2104 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2105 }, val => { 2106 expect(val[0]).assertEqual(1); 2107 expect(val[1]).assertEqual(1); 2108 expect(val[2]).assertEqual(1); 2109 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2110 }) 2111 done(); 2112 }) 2113 2114 2115 /** 2116 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0068 2117 * @tc.name webgl_test_uniform3i_2 2118 * @tc.desc Test uniform3i. 2119 */ 2120 it('webgl_test_uniform3i_2', 0, async function (done) { 2121 console.info("webgltest [webgl_test_uniform3i_2] uniform3i"); 2122 uniform3i((val) => { 2123 gl.uniform3i(val, null, null, null); 2124 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2125 }, val => { 2126 expect(val[0]).assertEqual(0); 2127 expect(val[1]).assertEqual(0); 2128 expect(val[2]).assertEqual(0); 2129 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2130 }) 2131 done(); 2132 }) 2133 2134 2135 /** 2136 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0069 2137 * @tc.name webgl_test_uniform3i_3 2138 * @tc.desc Test uniform3i. 2139 */ 2140 it('webgl_test_uniform3i_3', 0, async function (done) { 2141 console.info("webgltest [webgl_test_uniform3i_3] uniform3i"); 2142 uniform3i((val) => { 2143 gl.uniform3i(val, undefined, undefined, undefined); 2144 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2145 }, val => { 2146 expect(val[0]).assertEqual(0); 2147 expect(val[1]).assertEqual(0); 2148 expect(val[2]).assertEqual(0); 2149 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2150 }) 2151 done(); 2152 }) 2153 2154 function uniform4i(callback, finish) { 2155 let vSource = ` 2156 uniform ivec4 a_Position; 2157 void main(){ 2158 gl_Position.x = float(a_Position.x); 2159 gl_Position.y = float(a_Position.y); 2160 gl_Position.z = float(a_Position.z); 2161 gl_Position.w = float(a_Position.w); 2162 } 2163 `; 2164 let fSource = ` 2165 precision mediump float; 2166 precision highp sampler2D; 2167 void main(){ 2168 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 2169 } 2170 ` 2171 let p = createProgram(gl, vSource, fSource); 2172 let a_Position = gl.getUniformLocation(p.program, "a_Position"); 2173 callback(a_Position); 2174 let uniform = gl.getUniform(p.program, a_Position); 2175 finish(uniform); 2176 gl.deleteShader(p.vertexShader); 2177 gl.deleteShader(p.fragmentShader); 2178 gl.deleteProgram(p.program); 2179 } 2180 2181 2182 /** 2183 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0070 2184 * @tc.name webgl_test_uniform4i 2185 * @tc.desc Test uniform4i. 2186 */ 2187 it('webgl_test_uniform4i', 0, async function (done) { 2188 console.info("webgltest [webgl_test_uniform4i] uniform4i"); 2189 let vSource = ` 2190 uniform ivec4 a_Position; 2191 void main(){ 2192 gl_Position.x = float(a_Position.x); 2193 gl_Position.y = float(a_Position.y); 2194 gl_Position.z = float(a_Position.z); 2195 gl_Position.w = float(a_Position.w); 2196 } 2197 `; 2198 let fSource = ` 2199 precision mediump float; 2200 precision highp sampler2D; 2201 void main(){ 2202 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 2203 } 2204 ` 2205 let p = createProgram(gl, vSource, fSource); 2206 let a_Position = gl.getUniformLocation(p.program, "a_Position"); 2207 console.info("webgltest fragmentShader source :", vSource); 2208 console.info("webgltest uniform u_Sampler:", a_Position); 2209 gl.uniform4i(a_Position, 1, 1, 1, 1); 2210 console.info("webgltest gl.uniform4i(a_Position,1,1,1,1);"); 2211 let uniform = gl.getUniform(p.program, a_Position); 2212 console.info("webgltest uniform u_Sampler value:", uniform); 2213 expect(uniform[0]).assertEqual(1); 2214 expect(uniform[1]).assertEqual(1); 2215 expect(uniform[2]).assertEqual(1); 2216 expect(uniform[3]).assertEqual(1); 2217 gl.deleteShader(p.vertexShader); 2218 gl.deleteShader(p.fragmentShader); 2219 gl.deleteProgram(p.program); 2220 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2221 done(); 2222 }) 2223 2224 2225 /** 2226 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0071 2227 * @tc.name webgl_test_uniform4i_1 2228 * @tc.desc Test uniform4i. 2229 */ 2230 it('webgl_test_uniform4i_1', 0, async function (done) { 2231 console.info("webgltest [webgl_test_uniform4i_1] uniform4i"); 2232 uniform4i((val) => { 2233 gl.uniform4i(val, 1, 1, 1, 1); 2234 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2235 }, val => { 2236 expect(val[0]).assertEqual(1); 2237 expect(val[1]).assertEqual(1); 2238 expect(val[2]).assertEqual(1); 2239 expect(val[3]).assertEqual(1); 2240 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2241 }) 2242 done(); 2243 }) 2244 2245 2246 /** 2247 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0072 2248 * @tc.name webgl_test_uniform4i_2 2249 * @tc.desc Test uniform4i. 2250 */ 2251 it('webgl_test_uniform4i_2', 0, async function (done) { 2252 console.info("webgltest [webgl_test_uniform4i_2] uniform4i"); 2253 uniform4i((val) => { 2254 gl.uniform4i(val, null, null, null, null); 2255 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2256 }, val => { 2257 expect(val[0]).assertEqual(0); 2258 expect(val[1]).assertEqual(0); 2259 expect(val[2]).assertEqual(0); 2260 expect(val[3]).assertEqual(0); 2261 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2262 }) 2263 done(); 2264 }) 2265 2266 2267 /** 2268 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0073 2269 * @tc.name webgl_test_uniform4i_3 2270 * @tc.desc Test uniform4i. 2271 */ 2272 it('webgl_test_uniform4i_3', 0, async function (done) { 2273 console.info("webgltest [webgl_test_uniform4i_3] uniform4i"); 2274 uniform4i((val) => { 2275 gl.uniform4i(val, undefined, undefined, undefined, undefined); 2276 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2277 }, val => { 2278 expect(val[0]).assertEqual(0); 2279 expect(val[1]).assertEqual(0); 2280 expect(val[2]).assertEqual(0); 2281 expect(val[3]).assertEqual(0); 2282 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2283 }) 2284 done(); 2285 }) 2286 2287 2288 /** 2289 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0074 2290 * @tc.name webgl_test_getUniform 2291 * @tc.desc Test getUniform. 2292 */ 2293 it('webgl_test_getUniform', 0, async function (done) { 2294 console.info("webgltest [webgl_test_getUniform] getUniform"); 2295 let vSource = ` 2296 attribute vec4 a_Position; 2297 void main() { 2298 gl_Position = a_Position; 2299 } 2300 `; 2301 let fSource = ` 2302 precision mediump float; 2303 uniform vec4 u_FragColor; 2304 void main() { 2305 gl_FragColor = u_FragColor; 2306 } 2307 `; 2308 let p = createProgram(gl, vSource, fSource); 2309 let a_Position = gl.getAttribLocation(p.program, "a_Position"); 2310 let u_FragColor = gl.getUniformLocation(p.program, "u_FragColor"); 2311 console.info("webgltest gl.uniform4f(u_FragColor, 1.0, 0.5, 0.5, 1.0);"); 2312 gl.uniform4f(u_FragColor, 1.0, 0.5, 0.5, 1.0); 2313 let value = gl.getUniform(p.program, u_FragColor); 2314 console.info("webgltest u_FragColor:", u_FragColor, value); 2315 expect(value[0]).assertEqual(1.0); 2316 expect(value[1]).assertEqual(0.5); 2317 expect(value[2]).assertEqual(0.5); 2318 expect(value[3]).assertEqual(1.0); 2319 gl.deleteShader(p.vertexShader); 2320 gl.deleteShader(p.fragmentShader); 2321 gl.deleteProgram(p.program); 2322 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2323 done(); 2324 }) 2325 2326 function uniformMatrix4fv(callback, finish) { 2327 let vSource = ` 2328 attribute vec4 a_Position; 2329 uniform mat4 u_MvpMatrix; 2330 void main() { 2331 gl_Position = u_MvpMatrix *a_Position; 2332 } 2333 `; 2334 let fSource = ` 2335 precision mediump float; 2336 uniform vec4 u_FragColor; 2337 void main() { 2338 gl_FragColor = u_FragColor; 2339 } 2340 `; 2341 let p = createProgram(gl, vSource, fSource); 2342 let u_MvpMatrix = gl.getUniformLocation(p.program, "u_MvpMatrix"); 2343 callback(u_MvpMatrix); 2344 let value = gl.getUniform(p.program, u_MvpMatrix); 2345 finish(value); 2346 gl.deleteShader(p.vertexShader); 2347 gl.deleteShader(p.fragmentShader); 2348 gl.deleteProgram(p.program); 2349 } 2350 2351 2352 /** 2353 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0075 2354 * @tc.name webgl_test_uniformMatrix4fv 2355 * @tc.desc Test uniformMatrix4fv. 2356 */ 2357 it('webgl_test_uniformMatrix4fv', 0, async function (done) { 2358 console.info("webgltest [webgl_test_uniformMatrix4fv] uniformMatrix4fv"); 2359 let vSource = ` 2360 attribute vec4 a_Position; 2361 uniform mat4 u_MvpMatrix; 2362 void main() { 2363 gl_Position = u_MvpMatrix *a_Position; 2364 } 2365 `; 2366 let fSource = ` 2367 precision mediump float; 2368 uniform vec4 u_FragColor; 2369 void main() { 2370 gl_FragColor = u_FragColor; 2371 } 2372 `; 2373 let p = createProgram(gl, vSource, fSource); 2374 let u_MvpMatrix = gl.getUniformLocation(p.program, "u_MvpMatrix"); 2375 gl.uniformMatrix4fv(u_MvpMatrix, false, new Float32Array([ 2376 3.4, -0.5, -0.3, -0.3, 2377 0, 3.4, -0.3, -0.3, 2378 -1.4, -1.2, -0.8, -0.8, 2379 -0.4, -0.5, 6.3, 8.1 2380 ])); 2381 checkError(gl); 2382 let value = gl.getUniform(p.program, u_MvpMatrix); 2383 console.info("webgltest u_MvpMatrix:", u_MvpMatrix, JSON.stringify(value)); 2384 expect(parseFloat(value[0].toFixed(2))).assertEqual(3.4); 2385 expect(parseFloat(value[1].toFixed(2))).assertEqual(-0.5); 2386 expect(parseFloat(value[2].toFixed(2))).assertEqual(-0.3); 2387 expect(parseFloat(value[3].toFixed(2))).assertEqual(-0.3); 2388 expect(parseFloat(value[4].toFixed(2))).assertEqual(0); 2389 expect(parseFloat(value[5].toFixed(2))).assertEqual(3.4); 2390 expect(parseFloat(value[6].toFixed(2))).assertEqual(-0.3); 2391 expect(parseFloat(value[7].toFixed(2))).assertEqual(-0.3); 2392 expect(parseFloat(value[8].toFixed(2))).assertEqual(-1.4); 2393 expect(parseFloat(value[9].toFixed(2))).assertEqual(-1.2); 2394 expect(parseFloat(value[10].toFixed(2))).assertEqual(-0.8); 2395 expect(parseFloat(value[11].toFixed(2))).assertEqual(-0.8); 2396 expect(parseFloat(value[12].toFixed(2))).assertEqual(-0.4); 2397 expect(parseFloat(value[13].toFixed(2))).assertEqual(-0.5); 2398 expect(parseFloat(value[14].toFixed(2))).assertEqual(6.3); 2399 expect(parseFloat(value[15].toFixed(2))).assertEqual(8.1); 2400 gl.deleteShader(p.vertexShader); 2401 gl.deleteShader(p.fragmentShader); 2402 gl.deleteProgram(p.program); 2403 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2404 done(); 2405 }) 2406 2407 2408 /** 2409 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0076 2410 * @tc.name webgl_test_uniformMatrix4fv_1 2411 * @tc.desc Test uniformMatrix4fv. 2412 */ 2413 it('webgl_test_uniformMatrix4fv_1', 0, async function (done) { 2414 console.info("webgltest [webgl_test_uniformMatrix4fv_1] uniformMatrix4fv"); 2415 uniformMatrix4fv((val) => { 2416 gl.uniformMatrix4fv(val, false, [ 2417 0.0, 0.0, 0.0, 0.0, 2418 0.0, 0.0, 0.0, 0.0, 2419 0.0, 0.0, 0.0, 0.0, 2420 0.0, 0.0, 0.0, 0.0 2421 ]); 2422 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2423 }, val => { 2424 for (let i = 0; i < 15; i++) { 2425 expect(val[i]).assertEqual(0); 2426 } 2427 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2428 }) 2429 done(); 2430 }) 2431 2432 2433 /** 2434 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0077 2435 * @tc.name webgl_test_uniformMatrix4fv_2 2436 * @tc.desc Test uniformMatrix4fv. 2437 */ 2438 it('webgl_test_uniformMatrix4fv_2', 0, async function (done) { 2439 console.info("webgltest [webgl_test_uniformMatrix4fv_2] uniformMatrix4fv"); 2440 uniformMatrix4fv((val) => { 2441 gl.uniformMatrix4fv(val, false, [ 2442 0.0, 0.0, 0.0, 0.0, 2443 0.0, 0.0, 0.0, 0.0, 2444 0.0, 0.0, 0.0, 0.0 2445 ]); 2446 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2447 }, val => { 2448 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2449 }) 2450 done(); 2451 }) 2452 2453 2454 /** 2455 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0078 2456 * @tc.name webgl_test_uniformMatrix4fv_3 2457 * @tc.desc Test uniformMatrix4fv. 2458 */ 2459 it('webgl_test_uniformMatrix4fv_3', 0, async function (done) { 2460 console.info("webgltest [webgl_test_uniformMatrix4fv_3] uniformMatrix4fv"); 2461 uniformMatrix4fv((val) => { 2462 gl.uniformMatrix4fv(val, false, [ 2463 null, null, null, null, 2464 null, null, null, null, 2465 null, null, null, null, 2466 null, null, null, null 2467 ]); 2468 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2469 }, val => { 2470 for (let i = 0; i < 15; i++) { 2471 expect(val[i]).assertEqual(0); 2472 } 2473 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2474 }) 2475 done(); 2476 }) 2477 2478 function uniformMatrix3fv(callback, finish) { 2479 let vSource = ` 2480 attribute vec2 a_Position; 2481 uniform mat3 u_MvpMatrix; 2482 void main() { 2483 gl_Position = vec4( 2484 (u_MvpMatrix * vec3(a_Position, 1)).xy, 0, 1 2485 ); 2486 } 2487 `; 2488 let fSource = ` 2489 precision mediump float; 2490 void main() { 2491 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 2492 } 2493 `; 2494 let p = createProgram(gl, vSource, fSource); 2495 let u_MvpMatrix = gl.getUniformLocation(p.program, "u_MvpMatrix"); 2496 callback(u_MvpMatrix); 2497 let value = gl.getUniform(p.program, u_MvpMatrix); 2498 finish(value); 2499 gl.deleteShader(p.vertexShader); 2500 gl.deleteShader(p.fragmentShader); 2501 gl.deleteProgram(p.program); 2502 } 2503 2504 2505 /** 2506 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0079 2507 * @tc.name webgl_test_uniformMatrix3fv 2508 * @tc.desc Test uniformMatrix3fv. 2509 */ 2510 it('webgl_test_uniformMatrix3fv', 0, async function (done) { 2511 console.info("webgltest [webgl_test_uniformMatrix3fv] uniformMatrix3fv"); 2512 let vSource = ` 2513 attribute vec2 a_Position; 2514 uniform mat3 u_MvpMatrix; 2515 void main() { 2516 gl_Position = vec4( 2517 (u_MvpMatrix * vec3(a_Position, 1)).xy, 0, 1 2518 ); 2519 } 2520 `; 2521 let fSource = ` 2522 precision mediump float; 2523 void main() { 2524 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 2525 } 2526 `; 2527 let p = createProgram(gl, vSource, fSource); 2528 let u_MvpMatrix = gl.getUniformLocation(p.program, "u_MvpMatrix"); 2529 gl.uniformMatrix3fv(u_MvpMatrix, false, new Float32Array([ 2530 3.4, -0.5, -0.3, 2531 0, 3.4, -0.3, 2532 -1.4, -1.2, -0.8, 2533 ])); 2534 let value = gl.getUniform(p.program, u_MvpMatrix); 2535 console.info("webgltest u_MvpMatrix:", u_MvpMatrix, JSON.stringify(value)); 2536 expect(parseFloat(value[0].toFixed(2))).assertEqual(3.4); 2537 expect(parseFloat(value[1].toFixed(2))).assertEqual(-0.5); 2538 expect(parseFloat(value[2].toFixed(2))).assertEqual(-0.3); 2539 expect(parseFloat(value[3].toFixed(2))).assertEqual(0); 2540 expect(parseFloat(value[4].toFixed(2))).assertEqual(3.4); 2541 expect(parseFloat(value[5].toFixed(2))).assertEqual(-0.3); 2542 expect(parseFloat(value[6].toFixed(2))).assertEqual(-1.4); 2543 expect(parseFloat(value[7].toFixed(2))).assertEqual(-1.2); 2544 expect(parseFloat(value[8].toFixed(2))).assertEqual(-0.8); 2545 gl.deleteShader(p.vertexShader); 2546 gl.deleteShader(p.fragmentShader); 2547 gl.deleteProgram(p.program); 2548 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2549 done(); 2550 }) 2551 2552 2553 /** 2554 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0080 2555 * @tc.name webgl_test_uniformMatrix3fv_1 2556 * @tc.desc Test uniformMatrix3fv. 2557 */ 2558 it('webgl_test_uniformMatrix3fv_1', 0, async function (done) { 2559 console.info("webgltest [webgl_test_uniformMatrix3fv_1] uniformMatrix3fv"); 2560 uniformMatrix3fv((val) => { 2561 gl.uniformMatrix3fv(val, false, [ 2562 0.0, 0.0, 0.0, 2563 0.0, 0.0, 0.0, 2564 0.0, 0.0, 0.0 2565 ]); 2566 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2567 }, val => { 2568 for (let i = 0; i < 8; i++) { 2569 expect(val[i]).assertEqual(0); 2570 } 2571 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2572 }) 2573 done(); 2574 }) 2575 2576 2577 /** 2578 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0081 2579 * @tc.name webgl_test_uniformMatrix3fv_2 2580 * @tc.desc Test uniformMatrix3fv. 2581 */ 2582 it('webgl_test_uniformMatrix3fv_2', 0, async function (done) { 2583 console.info("webgltest [webgl_test_uniformMatrix3fv_2] uniformMatrix3fv"); 2584 uniformMatrix3fv((val) => { 2585 gl.uniformMatrix3fv(val, false, [ 2586 0.0, 0.0, 0.0, 2587 0.0, 0.0, 0.0 2588 ]); 2589 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2590 }, val => { 2591 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2592 }) 2593 done(); 2594 }) 2595 2596 2597 /** 2598 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0082 2599 * @tc.name webgl_test_uniformMatrix3fv_3 2600 * @tc.desc Test uniformMatrix3fv. 2601 */ 2602 it('webgl_test_uniformMatrix3fv_3', 0, async function (done) { 2603 console.info("webgltest [webgl_test_uniformMatrix3fv_3] uniformMatrix3fv"); 2604 uniformMatrix3fv((val) => { 2605 gl.uniformMatrix3fv(val, false, [ 2606 null, null, null, 2607 null, null, null, 2608 null, null, null 2609 ]); 2610 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2611 }, val => { 2612 for (let i = 0; i < 8; i++) { 2613 expect(val[i]).assertEqual(0); 2614 } 2615 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2616 }) 2617 done(); 2618 }) 2619 2620 function uniformMatrix2fv(callback, finish) { 2621 let vSource = ` 2622 attribute vec2 a_Position; 2623 uniform mat2 u_MvpMatrix; 2624 void main() { 2625 gl_Position = vec4( 2626 (u_MvpMatrix * vec2(a_Position.x,a_Position.y)).xy, 0, 1 2627 ); 2628 } 2629 `; 2630 let fSource = ` 2631 precision mediump float; 2632 void main() { 2633 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 2634 } 2635 `; 2636 let p = createProgram(gl, vSource, fSource); 2637 let u_MvpMatrix = gl.getUniformLocation(p.program, "u_MvpMatrix"); 2638 callback(u_MvpMatrix); 2639 let value = gl.getUniform(p.program, u_MvpMatrix); 2640 finish(value); 2641 gl.deleteShader(p.vertexShader); 2642 gl.deleteShader(p.fragmentShader); 2643 gl.deleteProgram(p.program); 2644 } 2645 2646 2647 /** 2648 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0083 2649 * @tc.name webgl_test_uniformMatrix2fv 2650 * @tc.desc Test uniformMatrix2fv. 2651 */ 2652 it('webgl_test_uniformMatrix2fv', 0, async function (done) { 2653 console.info("webgltest [webgl_test_uniformMatrix2fv] uniformMatrix2fv"); 2654 let vSource = ` 2655 attribute vec2 a_Position; 2656 uniform mat2 u_MvpMatrix; 2657 void main() { 2658 gl_Position = vec4( 2659 (u_MvpMatrix * vec2(a_Position.x,a_Position.y)).xy, 0, 1 2660 ); 2661 } 2662 `; 2663 let fSource = ` 2664 precision mediump float; 2665 void main() { 2666 gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 2667 } 2668 `; 2669 let p = createProgram(gl, vSource, fSource); 2670 let u_MvpMatrix = gl.getUniformLocation(p.program, "u_MvpMatrix"); 2671 gl.uniformMatrix2fv(u_MvpMatrix, false, new Float32Array([ 2672 3.4, -0.5, 2673 0, 3.4, 2674 ])); 2675 let value = gl.getUniform(p.program, u_MvpMatrix); 2676 console.info("webgltest u_MvpMatrix:", u_MvpMatrix, JSON.stringify(value)); 2677 expect(parseFloat(value[0].toFixed(2))).assertEqual(3.4); 2678 expect(parseFloat(value[1].toFixed(2))).assertEqual(-0.5); 2679 expect(parseFloat(value[2].toFixed(2))).assertEqual(0); 2680 expect(parseFloat(value[3].toFixed(2))).assertEqual(3.4); 2681 gl.deleteShader(p.vertexShader); 2682 gl.deleteShader(p.fragmentShader); 2683 gl.deleteProgram(p.program); 2684 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2685 done(); 2686 }) 2687 2688 2689 /** 2690 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0084 2691 * @tc.name webgl_test_uniformMatrix2fv_1 2692 * @tc.desc Test uniformMatrix2fv. 2693 */ 2694 it('webgl_test_uniformMatrix2fv_1', 0, async function (done) { 2695 console.info("webgltest [webgl_test_uniformMatrix2fv_1] uniformMatrix2fv"); 2696 uniformMatrix2fv((val) => { 2697 gl.uniformMatrix2fv(val, false, [ 2698 0.0, 0.0, 2699 0.0, 0.0 2700 ]); 2701 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2702 }, val => { 2703 for (let i = 0; i < 3; i++) { 2704 expect(val[i]).assertEqual(0); 2705 } 2706 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2707 }) 2708 done(); 2709 }) 2710 2711 2712 /** 2713 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0085 2714 * @tc.name webgl_test_uniformMatrix2fv_2 2715 * @tc.desc Test uniformMatrix2fv. 2716 */ 2717 it('webgl_test_uniformMatrix2fv_2', 0, async function (done) { 2718 console.info("webgltest [webgl_test_uniformMatrix2fv_2] uniformMatrix2fv"); 2719 uniformMatrix2fv((val) => { 2720 gl.uniformMatrix2fv(val, false, [ 2721 0.0, 0.0, 2722 0.0 2723 ]); 2724 expect(checkError(gl)).assertEqual(gl.INVALID_VALUE); 2725 }, val => { 2726 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2727 }) 2728 done(); 2729 }) 2730 2731 2732 /** 2733 * @tc.number GRAPHIC_FUNCTION_JS_WEBGL_UNIFORM_0086 2734 * @tc.name webgl_test_uniformMatrix2fv_3 2735 * @tc.desc Test uniformMatrix2fv. 2736 */ 2737 it('webgl_test_uniformMatrix2fv_3', 0, async function (done) { 2738 console.info("webgltest [webgl_test_uniformMatrix2fv_3] uniformMatrix2fv"); 2739 uniformMatrix2fv((val) => { 2740 gl.uniformMatrix2fv(val, false, [ 2741 null, null, 2742 null, null 2743 ]); 2744 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2745 }, val => { 2746 for (let i = 0; i < 3; i++) { 2747 expect(val[i]).assertEqual(0); 2748 } 2749 expect(checkError(gl)).assertEqual(gl.NO_ERROR); 2750 }) 2751 done(); 2752 }) 2753 }) 2754} 2755