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